1project('qemu', ['c'], meson_version: '>=0.63.0', 2 default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto', 3 'b_staticpic=false', 'stdsplit=false', 'optimization=2', 'b_pie=true'], 4 version: files('VERSION')) 5 6add_test_setup('quick', exclude_suites: ['slow', 'thorough'], is_default: true) 7add_test_setup('slow', exclude_suites: ['thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow']) 8add_test_setup('thorough', env: ['G_TEST_SLOW=1', 'SPEED=thorough']) 9 10meson.add_postconf_script(find_program('scripts/symlink-install-tree.py')) 11 12not_found = dependency('', required: false) 13keyval = import('keyval') 14ss = import('sourceset') 15fs = import('fs') 16 17targetos = host_machine.system() 18sh = find_program('sh') 19config_host = keyval.load(meson.current_build_dir() / 'config-host.mak') 20 21cc = meson.get_compiler('c') 22all_languages = ['c'] 23if add_languages('cpp', required: false, native: false) 24 all_languages += ['cpp'] 25 cxx = meson.get_compiler('cpp') 26endif 27if targetos == 'darwin' and \ 28 add_languages('objc', required: get_option('cocoa'), native: false) 29 all_languages += ['objc'] 30 objc = meson.get_compiler('objc') 31endif 32 33# Temporary directory used for files created while 34# configure runs. Since it is in the build directory 35# we can safely blow away any previous version of it 36# (and we need not jump through hoops to try to delete 37# it when configure exits.) 38tmpdir = meson.current_build_dir() / 'meson-private/temp' 39 40if get_option('qemu_suffix').startswith('/') 41 error('qemu_suffix cannot start with a /') 42endif 43 44qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix') 45qemu_datadir = get_option('datadir') / get_option('qemu_suffix') 46qemu_docdir = get_option('docdir') / get_option('qemu_suffix') 47qemu_moddir = get_option('libdir') / get_option('qemu_suffix') 48 49qemu_desktopdir = get_option('datadir') / 'applications' 50qemu_icondir = get_option('datadir') / 'icons' 51 52config_host_data = configuration_data() 53genh = [] 54qapi_trace_events = [] 55 56bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin'] 57supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux'] 58supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv', 'x86', 'x86_64', 59 'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc64'] 60 61cpu = host_machine.cpu_family() 62 63# Unify riscv* to a single family. 64if cpu in ['riscv32', 'riscv64'] 65 cpu = 'riscv' 66endif 67 68target_dirs = config_host['TARGET_DIRS'].split() 69have_linux_user = false 70have_bsd_user = false 71have_system = false 72foreach target : target_dirs 73 have_linux_user = have_linux_user or target.endswith('linux-user') 74 have_bsd_user = have_bsd_user or target.endswith('bsd-user') 75 have_system = have_system or target.endswith('-softmmu') 76endforeach 77have_user = have_linux_user or have_bsd_user 78have_tools = get_option('tools') \ 79 .disable_auto_if(not have_system) \ 80 .allowed() 81have_ga = get_option('guest_agent') \ 82 .disable_auto_if(not have_system and not have_tools) \ 83 .require(targetos in ['sunos', 'linux', 'windows', 'freebsd', 'netbsd', 'openbsd'], 84 error_message: 'unsupported OS for QEMU guest agent') \ 85 .allowed() 86enable_modules = get_option('modules') \ 87 .require(targetos != 'windows', 88 error_message: 'Modules are not available for Windows') \ 89 .require(not get_option('prefer_static'), 90 error_message: 'Modules are incompatible with static linking') \ 91 .allowed() 92have_block = have_system or have_tools 93 94python = import('python').find_installation() 95 96if cpu not in supported_cpus 97 host_arch = 'unknown' 98elif cpu == 'x86' 99 host_arch = 'i386' 100elif cpu == 'mips64' 101 host_arch = 'mips' 102else 103 host_arch = cpu 104endif 105 106if cpu in ['x86', 'x86_64'] 107 kvm_targets = ['i386-softmmu', 'x86_64-softmmu'] 108elif cpu == 'aarch64' 109 kvm_targets = ['aarch64-softmmu'] 110elif cpu == 's390x' 111 kvm_targets = ['s390x-softmmu'] 112elif cpu in ['ppc', 'ppc64'] 113 kvm_targets = ['ppc-softmmu', 'ppc64-softmmu'] 114elif cpu in ['mips', 'mips64'] 115 kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu'] 116elif cpu in ['riscv'] 117 kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu'] 118else 119 kvm_targets = [] 120endif 121 122kvm_targets_c = '""' 123if get_option('kvm').allowed() and targetos == 'linux' 124 kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"' 125endif 126config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c) 127 128accelerator_targets = { 'CONFIG_KVM': kvm_targets } 129 130if cpu in ['aarch64'] 131 accelerator_targets += { 132 'CONFIG_HVF': ['aarch64-softmmu'] 133 } 134endif 135 136if cpu in ['x86', 'x86_64', 'arm', 'aarch64'] 137 # i386 emulator provides xenpv machine type for multiple architectures 138 accelerator_targets += { 139 'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'], 140 } 141endif 142if cpu in ['x86', 'x86_64'] 143 accelerator_targets += { 144 'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'], 145 'CONFIG_HVF': ['x86_64-softmmu'], 146 'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'], 147 'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'], 148 } 149endif 150 151modular_tcg = [] 152# Darwin does not support references to thread-local variables in modules 153if targetos != 'darwin' 154 modular_tcg = ['i386-softmmu', 'x86_64-softmmu'] 155endif 156 157edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ] 158unpack_edk2_blobs = false 159foreach target : edk2_targets 160 if target in target_dirs 161 bzip2 = find_program('bzip2', required: get_option('install_blobs')) 162 unpack_edk2_blobs = bzip2.found() 163 break 164 endif 165endforeach 166 167dtrace = not_found 168stap = not_found 169if 'dtrace' in get_option('trace_backends') 170 dtrace = find_program('dtrace', required: true) 171 stap = find_program('stap', required: false) 172 if stap.found() 173 # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol 174 # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility 175 # instead. QEMU --enable-modules depends on this because the SystemTap 176 # semaphores are linked into the main binary and not the module's shared 177 # object. 178 add_global_arguments('-DSTAP_SDT_V2', 179 native: false, language: all_languages) 180 endif 181endif 182 183if get_option('iasl') == '' 184 iasl = find_program('iasl', required: false) 185else 186 iasl = find_program(get_option('iasl'), required: true) 187endif 188 189################## 190# Compiler flags # 191################## 192 193foreach lang : all_languages 194 compiler = meson.get_compiler(lang) 195 if compiler.get_id() == 'gcc' and compiler.version().version_compare('>=7.4') 196 # ok 197 elif compiler.get_id() == 'clang' and compiler.compiles(''' 198 #ifdef __apple_build_version__ 199 # if __clang_major__ < 12 || (__clang_major__ == 12 && __clang_minor__ < 0) 200 # error You need at least XCode Clang v12.0 to compile QEMU 201 # endif 202 #else 203 # if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0) 204 # error You need at least Clang v10.0 to compile QEMU 205 # endif 206 #endif''') 207 # ok 208 else 209 error('You either need GCC v7.4 or Clang v10.0 (or XCode Clang v12.0) to compile QEMU') 210 endif 211endforeach 212 213# default flags for all hosts 214# We use -fwrapv to tell the compiler that we require a C dialect where 215# left shift of signed integers is well defined and has the expected 216# 2s-complement style results. (Both clang and gcc agree that it 217# provides these semantics.) 218 219qemu_common_flags = [ 220 '-D_GNU_SOURCE', '-D_FILE_OFFSET_BITS=64', '-D_LARGEFILE_SOURCE', 221 '-fno-strict-aliasing', '-fno-common', '-fwrapv' ] 222qemu_cflags = [] 223qemu_ldflags = [] 224 225if targetos == 'darwin' 226 # Disable attempts to use ObjectiveC features in os/object.h since they 227 # won't work when we're compiling with gcc as a C compiler. 228 qemu_common_flags += '-DOS_OBJECT_USE_OBJC=0' 229elif targetos == 'solaris' 230 # needed for CMSG_ macros in sys/socket.h 231 qemu_common_flags += '-D_XOPEN_SOURCE=600' 232 # needed for TIOCWIN* defines in termios.h 233 qemu_common_flags += '-D__EXTENSIONS__' 234elif targetos == 'haiku' 235 qemu_common_flags += ['-DB_USE_POSITIVE_POSIX_ERRORS', '-D_BSD_SOURCE', '-fPIC'] 236endif 237 238# __sync_fetch_and_and requires at least -march=i486. Many toolchains 239# use i686 as default anyway, but for those that don't, an explicit 240# specification is necessary 241if host_arch == 'i386' and not cc.links(''' 242 static int sfaa(int *ptr) 243 { 244 return __sync_fetch_and_and(ptr, 0); 245 } 246 247 int main(void) 248 { 249 int val = 42; 250 val = __sync_val_compare_and_swap(&val, 0, 1); 251 sfaa(&val); 252 return val; 253 }''') 254 qemu_common_flags = ['-march=i486'] + qemu_common_flags 255endif 256 257if get_option('gprof') 258 qemu_common_flags += ['-p'] 259 qemu_ldflags += ['-p'] 260endif 261 262if get_option('prefer_static') 263 qemu_ldflags += get_option('b_pie') ? '-static-pie' : '-static' 264endif 265 266# Meson currently only handles pie as a boolean for now, so if the user 267# has explicitly disabled PIE we need to extend our cflags. 268# 269# -no-pie is supposedly a linker flag that has no effect on the compiler 270# command line, but some distros, that didn't quite know what they were 271# doing, made local changes to gcc's specs file that turned it into 272# a compiler command-line flag. 273# 274# What about linker flags? For a static build, no PIE is implied by -static 275# which we added above (and if it's not because of the same specs patching, 276# there's nothing we can do: compilation will fail, report a bug to your 277# distro and do not use --disable-pie in the meanwhile). For dynamic linking, 278# instead, we can't add -no-pie because it overrides -shared: the linker then 279# tries to build an executable instead of a shared library and fails. So 280# don't add -no-pie anywhere and cross fingers. :( 281if not get_option('b_pie') 282 qemu_common_flags += cc.get_supported_arguments('-fno-pie', '-no-pie') 283endif 284 285if not get_option('stack_protector').disabled() 286 stack_protector_probe = ''' 287 int main(int argc, char *argv[]) 288 { 289 char arr[64], *p = arr, *c = argv[argc - 1]; 290 while (*c) { 291 *p++ = *c++; 292 } 293 return 0; 294 }''' 295 have_stack_protector = false 296 foreach arg : ['-fstack-protector-strong', '-fstack-protector-all'] 297 # We need to check both a compile and a link, since some compiler 298 # setups fail only on a .c->.o compile and some only at link time 299 if cc.compiles(stack_protector_probe, args: ['-Werror', arg]) and \ 300 cc.links(stack_protector_probe, args: ['-Werror', arg]) 301 have_stack_protector = true 302 qemu_cflags += arg 303 qemu_ldflags += arg 304 break 305 endif 306 endforeach 307 get_option('stack_protector') \ 308 .require(have_stack_protector, error_message: 'Stack protector not supported') 309endif 310 311coroutine_backend = get_option('coroutine_backend') 312ucontext_probe = ''' 313 #include <ucontext.h> 314 #ifdef __stub_makecontext 315 #error Ignoring glibc stub makecontext which will always fail 316 #endif 317 int main(void) { makecontext(0, 0, 0); return 0; }''' 318 319# On Windows the only valid backend is the Windows specific one. 320# For POSIX prefer ucontext, but it's not always possible. The fallback 321# is sigcontext. 322supported_backends = [] 323if targetos == 'windows' 324 supported_backends += ['windows'] 325else 326 if targetos != 'darwin' and cc.links(ucontext_probe) 327 supported_backends += ['ucontext'] 328 endif 329 supported_backends += ['sigaltstack'] 330endif 331 332if coroutine_backend == 'auto' 333 coroutine_backend = supported_backends[0] 334elif coroutine_backend not in supported_backends 335 error('"@0@" backend requested but not available. Available backends: @1@' \ 336 .format(coroutine_backend, ', '.join(supported_backends))) 337endif 338 339# Compiles if SafeStack *not* enabled 340safe_stack_probe = ''' 341 int main(void) 342 { 343 #if defined(__has_feature) 344 #if __has_feature(safe_stack) 345 #error SafeStack Enabled 346 #endif 347 #endif 348 return 0; 349 }''' 350if get_option('safe_stack') != not cc.compiles(safe_stack_probe) 351 safe_stack_arg = get_option('safe_stack') ? '-fsanitize=safe-stack' : '-fno-sanitize=safe-stack' 352 if get_option('safe_stack') != not cc.compiles(safe_stack_probe, args: safe_stack_arg) 353 error(get_option('safe_stack') \ 354 ? 'SafeStack not supported by your compiler' \ 355 : 'Cannot disable SafeStack') 356 endif 357 qemu_cflags += safe_stack_arg 358 qemu_ldflags += safe_stack_arg 359endif 360if get_option('safe_stack') and coroutine_backend != 'ucontext' 361 error('SafeStack is only supported with the ucontext coroutine backend') 362endif 363 364if get_option('sanitizers') 365 if cc.has_argument('-fsanitize=address') 366 qemu_cflags = ['-fsanitize=address'] + qemu_cflags 367 qemu_ldflags = ['-fsanitize=address'] + qemu_ldflags 368 endif 369 370 # Detect static linking issue with ubsan - https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84285 371 if cc.links('int main(int argc, char **argv) { return argc + 1; }', 372 args: [qemu_ldflags, '-fsanitize=undefined']) 373 qemu_cflags = ['-fsanitize=undefined'] + qemu_cflags 374 qemu_ldflags = ['-fsanitize=undefined'] + qemu_ldflags 375 endif 376endif 377 378# Thread sanitizer is, for now, much noisier than the other sanitizers; 379# keep it separate until that is not the case. 380if get_option('tsan') 381 if get_option('sanitizers') 382 error('TSAN is not supported with other sanitizers') 383 endif 384 if not cc.has_function('__tsan_create_fiber', 385 args: '-fsanitize=thread', 386 prefix: '#include <sanitizer/tsan_interface.h>') 387 error('Cannot enable TSAN due to missing fiber annotation interface') 388 endif 389 qemu_cflags = ['-fsanitize=thread'] + qemu_cflags 390 qemu_ldflags = ['-fsanitize=thread'] + qemu_ldflags 391endif 392 393# Detect support for PT_GNU_RELRO + DT_BIND_NOW. 394# The combination is known as "full relro", because .got.plt is read-only too. 395qemu_ldflags += cc.get_supported_link_arguments('-Wl,-z,relro', '-Wl,-z,now') 396 397if targetos == 'windows' 398 qemu_ldflags += cc.get_supported_link_arguments('-Wl,--no-seh', '-Wl,--nxcompat') 399 qemu_ldflags += cc.get_supported_link_arguments('-Wl,--dynamicbase', '-Wl,--high-entropy-va') 400endif 401 402# Exclude --warn-common with TSan to suppress warnings from the TSan libraries. 403if targetos != 'sunos' and not get_option('tsan') 404 qemu_ldflags += cc.get_supported_link_arguments('-Wl,--warn-common') 405endif 406 407if get_option('fuzzing') 408 # Specify a filter to only instrument code that is directly related to 409 # virtual-devices. 410 configure_file(output: 'instrumentation-filter', 411 input: 'scripts/oss-fuzz/instrumentation-filter-template', 412 copy: true) 413 414 if cc.compiles('int main () { return 0; }', 415 name: '-fsanitize-coverage-allowlist=/dev/null', 416 args: ['-fsanitize-coverage-allowlist=/dev/null', 417 '-fsanitize-coverage=trace-pc'] ) 418 qemu_common_flags += ['-fsanitize-coverage-allowlist=instrumentation-filter'] 419 endif 420 421 if get_option('fuzzing_engine') == '' 422 # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the 423 # compiled code. To build non-fuzzer binaries with --enable-fuzzing, link 424 # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be 425 # unable to bind the fuzzer-related callbacks added by instrumentation. 426 qemu_common_flags += ['-fsanitize=fuzzer-no-link'] 427 qemu_ldflags += ['-fsanitize=fuzzer-no-link'] 428 # For the actual fuzzer binaries, we need to link against the libfuzzer 429 # library. They need to be configurable, to support OSS-Fuzz 430 fuzz_exe_ldflags = ['-fsanitize=fuzzer'] 431 else 432 # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and 433 # the needed CFLAGS have already been provided 434 fuzz_exe_ldflags = get_option('fuzzing_engine').split() 435 endif 436endif 437 438add_global_arguments(qemu_common_flags, native: false, language: all_languages) 439add_global_link_arguments(qemu_ldflags, native: false, language: all_languages) 440 441# Collect warnings that we want to enable 442 443warn_flags = [ 444 '-Wundef', 445 '-Wwrite-strings', 446 '-Wmissing-prototypes', 447 '-Wstrict-prototypes', 448 '-Wredundant-decls', 449 '-Wold-style-declaration', 450 '-Wold-style-definition', 451 '-Wtype-limits', 452 '-Wformat-security', 453 '-Wformat-y2k', 454 '-Winit-self', 455 '-Wignored-qualifiers', 456 '-Wempty-body', 457 '-Wnested-externs', 458 '-Wendif-labels', 459 '-Wexpansion-to-defined', 460 '-Wimplicit-fallthrough=2', 461 '-Wmissing-format-attribute', 462 '-Wno-initializer-overrides', 463 '-Wno-missing-include-dirs', 464 '-Wno-shift-negative-value', 465 '-Wno-string-plus-int', 466 '-Wno-typedef-redefinition', 467 '-Wno-tautological-type-limit-compare', 468 '-Wno-psabi', 469 '-Wno-gnu-variable-sized-type-not-at-end', 470] 471 472if targetos != 'darwin' 473 warn_flags += ['-Wthread-safety'] 474endif 475 476# Check that the C++ compiler exists and works with the C compiler. 477link_language = 'c' 478linker = cc 479qemu_cxxflags = [] 480if 'cpp' in all_languages 481 qemu_cxxflags = ['-D__STDC_LIMIT_MACROS', '-D__STDC_CONSTANT_MACROS', '-D__STDC_FORMAT_MACROS'] + qemu_cflags 482 if cxx.links(files('scripts/main.c'), args: qemu_cflags) 483 link_language = 'cpp' 484 linker = cxx 485 else 486 message('C++ compiler does not work with C compiler') 487 message('Disabling C++-specific optional code') 488 endif 489endif 490 491# clang does not support glibc + FORTIFY_SOURCE (is it still true?) 492if get_option('optimization') != '0' and targetos == 'linux' 493 if cc.get_id() == 'gcc' 494 qemu_cflags += ['-U_FORTIFY_SOURCE', '-D_FORTIFY_SOURCE=2'] 495 endif 496 if 'cpp' in all_languages and cxx.get_id() == 'gcc' 497 qemu_cxxflags += ['-U_FORTIFY_SOURCE', '-D_FORTIFY_SOURCE=2'] 498 endif 499endif 500 501add_project_arguments(qemu_cflags, native: false, language: 'c') 502add_project_arguments(cc.get_supported_arguments(warn_flags), native: false, language: 'c') 503if 'cpp' in all_languages 504 add_project_arguments(qemu_cxxflags, native: false, language: 'cpp') 505 add_project_arguments(cxx.get_supported_arguments(warn_flags), native: false, language: 'cpp') 506endif 507if 'objc' in all_languages 508 # Note sanitizer flags are not applied to Objective-C sources! 509 add_project_arguments(objc.get_supported_arguments(warn_flags), native: false, language: 'objc') 510endif 511if targetos == 'linux' 512 add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers', 513 '-isystem', 'linux-headers', 514 language: all_languages) 515endif 516 517add_project_arguments('-iquote', '.', 518 '-iquote', meson.current_source_dir(), 519 '-iquote', meson.current_source_dir() / 'include', 520 language: all_languages) 521 522# If a host-specific include directory exists, list that first... 523host_include = meson.current_source_dir() / 'host/include/' 524if fs.is_dir(host_include / host_arch) 525 add_project_arguments('-iquote', host_include / host_arch, 526 language: all_languages) 527endif 528# ... followed by the generic fallback. 529add_project_arguments('-iquote', host_include / 'generic', 530 language: all_languages) 531 532sparse = find_program('cgcc', required: get_option('sparse')) 533if sparse.found() 534 run_target('sparse', 535 command: [find_program('scripts/check_sparse.py'), 536 'compile_commands.json', sparse.full_path(), '-Wbitwise', 537 '-Wno-transparent-union', '-Wno-old-initializer', 538 '-Wno-non-pointer-null']) 539endif 540 541########################################### 542# Target-specific checks and dependencies # 543########################################### 544 545# Fuzzing 546if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \ 547 not cc.links(''' 548 #include <stdint.h> 549 #include <sys/types.h> 550 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size); 551 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; } 552 ''', 553 args: ['-Werror', '-fsanitize=fuzzer']) 554 error('Your compiler does not support -fsanitize=fuzzer') 555endif 556 557# Tracing backends 558if 'ftrace' in get_option('trace_backends') and targetos != 'linux' 559 error('ftrace is supported only on Linux') 560endif 561if 'syslog' in get_option('trace_backends') and not cc.compiles(''' 562 #include <syslog.h> 563 int main(void) { 564 openlog("qemu", LOG_PID, LOG_DAEMON); 565 syslog(LOG_INFO, "configure"); 566 return 0; 567 }''') 568 error('syslog is not supported on this system') 569endif 570 571# Miscellaneous Linux-only features 572get_option('mpath') \ 573 .require(targetos == 'linux', error_message: 'Multipath is supported only on Linux') 574 575multiprocess_allowed = get_option('multiprocess') \ 576 .require(targetos == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \ 577 .allowed() 578 579vfio_user_server_allowed = get_option('vfio_user_server') \ 580 .require(targetos == 'linux', error_message: 'vfio-user server is supported only on Linux') \ 581 .allowed() 582 583have_tpm = get_option('tpm') \ 584 .require(targetos != 'windows', error_message: 'TPM emulation only available on POSIX systems') \ 585 .allowed() 586 587# vhost 588have_vhost_user = get_option('vhost_user') \ 589 .disable_auto_if(targetos != 'linux') \ 590 .require(targetos != 'windows', 591 error_message: 'vhost-user is not available on Windows').allowed() 592have_vhost_vdpa = get_option('vhost_vdpa') \ 593 .require(targetos == 'linux', 594 error_message: 'vhost-vdpa is only available on Linux').allowed() 595have_vhost_kernel = get_option('vhost_kernel') \ 596 .require(targetos == 'linux', 597 error_message: 'vhost-kernel is only available on Linux').allowed() 598have_vhost_user_crypto = get_option('vhost_crypto') \ 599 .require(have_vhost_user, 600 error_message: 'vhost-crypto requires vhost-user to be enabled').allowed() 601 602have_vhost = have_vhost_user or have_vhost_vdpa or have_vhost_kernel 603 604have_vhost_net_user = have_vhost_user and get_option('vhost_net').allowed() 605have_vhost_net_vdpa = have_vhost_vdpa and get_option('vhost_net').allowed() 606have_vhost_net_kernel = have_vhost_kernel and get_option('vhost_net').allowed() 607have_vhost_net = have_vhost_net_kernel or have_vhost_net_user or have_vhost_net_vdpa 608 609# Target-specific libraries and flags 610libm = cc.find_library('m', required: false) 611threads = dependency('threads') 612util = cc.find_library('util', required: false) 613winmm = [] 614socket = [] 615version_res = [] 616coref = [] 617iokit = [] 618emulator_link_args = [] 619nvmm =not_found 620hvf = not_found 621midl = not_found 622widl = not_found 623pathcch = not_found 624host_dsosuf = '.so' 625if targetos == 'windows' 626 midl = find_program('midl', required: false) 627 widl = find_program('widl', required: false) 628 pathcch = cc.find_library('pathcch') 629 socket = cc.find_library('ws2_32') 630 winmm = cc.find_library('winmm') 631 632 win = import('windows') 633 version_res = win.compile_resources('version.rc', 634 depend_files: files('pc-bios/qemu-nsis.ico'), 635 include_directories: include_directories('.')) 636 host_dsosuf = '.dll' 637elif targetos == 'darwin' 638 coref = dependency('appleframeworks', modules: 'CoreFoundation') 639 iokit = dependency('appleframeworks', modules: 'IOKit', required: false) 640 host_dsosuf = '.dylib' 641elif targetos == 'sunos' 642 socket = [cc.find_library('socket'), 643 cc.find_library('nsl'), 644 cc.find_library('resolv')] 645elif targetos == 'haiku' 646 socket = [cc.find_library('posix_error_mapper'), 647 cc.find_library('network'), 648 cc.find_library('bsd')] 649elif targetos == 'openbsd' 650 if get_option('tcg').allowed() and target_dirs.length() > 0 651 # Disable OpenBSD W^X if available 652 emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded') 653 endif 654endif 655 656# Target-specific configuration of accelerators 657accelerators = [] 658if get_option('kvm').allowed() and targetos == 'linux' 659 accelerators += 'CONFIG_KVM' 660endif 661if get_option('whpx').allowed() and targetos == 'windows' 662 if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64' 663 error('WHPX requires 64-bit host') 664 elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \ 665 cc.has_header('WinHvEmulation.h', required: get_option('whpx')) 666 accelerators += 'CONFIG_WHPX' 667 endif 668endif 669if get_option('hvf').allowed() 670 hvf = dependency('appleframeworks', modules: 'Hypervisor', 671 required: get_option('hvf')) 672 if hvf.found() 673 accelerators += 'CONFIG_HVF' 674 endif 675endif 676if get_option('hax').allowed() 677 if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd'] 678 accelerators += 'CONFIG_HAX' 679 endif 680endif 681if targetos == 'netbsd' 682 nvmm = cc.find_library('nvmm', required: get_option('nvmm')) 683 if nvmm.found() 684 accelerators += 'CONFIG_NVMM' 685 endif 686endif 687 688tcg_arch = host_arch 689if get_option('tcg').allowed() 690 if host_arch == 'unknown' 691 if get_option('tcg_interpreter') 692 warning('Unsupported CPU @0@, will use TCG with TCI (slow)'.format(cpu)) 693 else 694 error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu)) 695 endif 696 elif get_option('tcg_interpreter') 697 warning('Use of the TCG interpreter is not recommended on this host') 698 warning('architecture. There is a native TCG execution backend available') 699 warning('which provides substantially better performance and reliability.') 700 warning('It is strongly recommended to remove the --enable-tcg-interpreter') 701 warning('configuration option on this architecture to use the native') 702 warning('backend.') 703 endif 704 if get_option('tcg_interpreter') 705 tcg_arch = 'tci' 706 config_host += { 'CONFIG_TCG_INTERPRETER': 'y' } 707 elif host_arch == 'x86_64' 708 tcg_arch = 'i386' 709 elif host_arch == 'ppc64' 710 tcg_arch = 'ppc' 711 endif 712 add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch, 713 language: all_languages) 714 715 accelerators += 'CONFIG_TCG' 716 config_host += { 'CONFIG_TCG': 'y' } 717endif 718 719if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled() 720 error('KVM not available on this platform') 721endif 722if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled() 723 error('HVF not available on this platform') 724endif 725if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled() 726 error('NVMM not available on this platform') 727endif 728if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled() 729 error('WHPX not available on this platform') 730endif 731 732################ 733# Dependencies # 734################ 735 736# When bumping glib minimum version, please check also whether to increase 737# the _WIN32_WINNT setting in osdep.h according to the value from glib 738glib_req_ver = '>=2.56.0' 739glib_pc = dependency('glib-2.0', version: glib_req_ver, required: true, 740 method: 'pkg-config') 741glib_cflags = [] 742if enable_modules 743 gmodule = dependency('gmodule-export-2.0', version: glib_req_ver, required: true, 744 method: 'pkg-config') 745elif config_host.has_key('CONFIG_PLUGIN') 746 gmodule = dependency('gmodule-no-export-2.0', version: glib_req_ver, required: true, 747 method: 'pkg-config') 748else 749 gmodule = not_found 750endif 751 752# This workaround is required due to a bug in pkg-config file for glib as it 753# doesn't define GLIB_STATIC_COMPILATION for pkg-config --static 754if targetos == 'windows' and get_option('prefer_static') 755 glib_cflags += ['-DGLIB_STATIC_COMPILATION'] 756endif 757 758# Sanity check that the current size_t matches the 759# size that glib thinks it should be. This catches 760# problems on multi-arch where people try to build 761# 32-bit QEMU while pointing at 64-bit glib headers 762 763if not cc.compiles(''' 764 #include <glib.h> 765 #include <unistd.h> 766 767 #define QEMU_BUILD_BUG_ON(x) \ 768 typedef char qemu_build_bug_on[(x)?-1:1] __attribute__((unused)); 769 770 int main(void) { 771 QEMU_BUILD_BUG_ON(sizeof(size_t) != GLIB_SIZEOF_SIZE_T); 772 return 0; 773 }''', dependencies: glib_pc, args: glib_cflags) 774 error('''sizeof(size_t) doesn't match GLIB_SIZEOF_SIZE_T. 775 You probably need to set PKG_CONFIG_LIBDIR" to point 776 to the right pkg-config files for your build target.''') 777endif 778 779# Silence clang warnings triggered by glib < 2.57.2 780if not cc.compiles(''' 781 #include <glib.h> 782 typedef struct Foo { 783 int i; 784 } Foo; 785 static void foo_free(Foo *f) 786 { 787 g_free(f); 788 } 789 G_DEFINE_AUTOPTR_CLEANUP_FUNC(Foo, foo_free) 790 int main(void) { return 0; }''', dependencies: glib_pc, args: ['-Wunused-function', '-Werror']) 791 glib_cflags += cc.get_supported_arguments('-Wno-unused-function') 792endif 793glib = declare_dependency(dependencies: [glib_pc, gmodule], 794 compile_args: glib_cflags, 795 version: glib_pc.version()) 796 797# Check whether glib has gslice, which we have to avoid for correctness. 798# TODO: remove this check and the corresponding workaround (qtree) when 799# the minimum supported glib is >= 2.75.3 800glib_has_gslice = glib.version().version_compare('<2.75.3') 801 802# override glib dep to include the above refinements 803meson.override_dependency('glib-2.0', glib) 804 805# The path to glib.h is added to all compilation commands. 806add_project_dependencies(glib.partial_dependency(compile_args: true, includes: true), 807 native: false, language: all_languages) 808 809gio = not_found 810gdbus_codegen = not_found 811gdbus_codegen_error = '@0@ requires gdbus-codegen, please install libgio' 812if not get_option('gio').auto() or have_system 813 gio = dependency('gio-2.0', required: get_option('gio'), 814 method: 'pkg-config') 815 if gio.found() and not cc.links(''' 816 #include <gio/gio.h> 817 int main(void) 818 { 819 g_dbus_proxy_new_sync(0, 0, 0, 0, 0, 0, 0, 0); 820 return 0; 821 }''', dependencies: [glib, gio]) 822 if get_option('gio').enabled() 823 error('The installed libgio is broken for static linking') 824 endif 825 gio = not_found 826 endif 827 if gio.found() 828 gdbus_codegen = find_program(gio.get_variable('gdbus_codegen'), 829 required: get_option('gio')) 830 gio_unix = dependency('gio-unix-2.0', required: get_option('gio'), 831 method: 'pkg-config') 832 gio = declare_dependency(dependencies: [gio, gio_unix], 833 version: gio.version()) 834 endif 835endif 836if gdbus_codegen.found() and get_option('cfi') 837 gdbus_codegen = not_found 838 gdbus_codegen_error = '@0@ uses gdbus-codegen, which does not support control flow integrity' 839endif 840 841lttng = not_found 842if 'ust' in get_option('trace_backends') 843 lttng = dependency('lttng-ust', required: true, version: '>= 2.1', 844 method: 'pkg-config') 845endif 846pixman = not_found 847if have_system or have_tools 848 pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8', 849 method: 'pkg-config') 850endif 851zlib = dependency('zlib', required: true) 852 853libaio = not_found 854if not get_option('linux_aio').auto() or have_block 855 libaio = cc.find_library('aio', has_headers: ['libaio.h'], 856 required: get_option('linux_aio')) 857endif 858 859linux_io_uring_test = ''' 860 #include <liburing.h> 861 #include <linux/errqueue.h> 862 863 int main(void) { return 0; }''' 864 865linux_io_uring = not_found 866if not get_option('linux_io_uring').auto() or have_block 867 linux_io_uring = dependency('liburing', version: '>=0.3', 868 required: get_option('linux_io_uring'), 869 method: 'pkg-config') 870 if not cc.links(linux_io_uring_test) 871 linux_io_uring = not_found 872 endif 873endif 874 875libnfs = not_found 876if not get_option('libnfs').auto() or have_block 877 libnfs = dependency('libnfs', version: '>=1.9.3', 878 required: get_option('libnfs'), 879 method: 'pkg-config') 880endif 881 882libattr_test = ''' 883 #include <stddef.h> 884 #include <sys/types.h> 885 #ifdef CONFIG_LIBATTR 886 #include <attr/xattr.h> 887 #else 888 #include <sys/xattr.h> 889 #endif 890 int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }''' 891 892libattr = not_found 893have_old_libattr = false 894if get_option('attr').allowed() 895 if cc.links(libattr_test) 896 libattr = declare_dependency() 897 else 898 libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'], 899 required: get_option('attr')) 900 if libattr.found() and not \ 901 cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR') 902 libattr = not_found 903 if get_option('attr').enabled() 904 error('could not link libattr') 905 else 906 warning('could not link libattr, disabling') 907 endif 908 else 909 have_old_libattr = libattr.found() 910 endif 911 endif 912endif 913 914cocoa = dependency('appleframeworks', modules: ['Cocoa', 'CoreVideo'], 915 required: get_option('cocoa')) 916 917vmnet = dependency('appleframeworks', modules: 'vmnet', required: get_option('vmnet')) 918if vmnet.found() and not cc.has_header_symbol('vmnet/vmnet.h', 919 'VMNET_BRIDGED_MODE', 920 dependencies: vmnet) 921 vmnet = not_found 922 if get_option('vmnet').enabled() 923 error('vmnet.framework API is outdated') 924 else 925 warning('vmnet.framework API is outdated, disabling') 926 endif 927endif 928 929seccomp = not_found 930seccomp_has_sysrawrc = false 931if not get_option('seccomp').auto() or have_system or have_tools 932 seccomp = dependency('libseccomp', version: '>=2.3.0', 933 required: get_option('seccomp'), 934 method: 'pkg-config') 935 if seccomp.found() 936 seccomp_has_sysrawrc = cc.has_header_symbol('seccomp.h', 937 'SCMP_FLTATR_API_SYSRAWRC', 938 dependencies: seccomp) 939 endif 940endif 941 942libcap_ng = not_found 943if not get_option('cap_ng').auto() or have_system or have_tools 944 libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'], 945 required: get_option('cap_ng')) 946endif 947if libcap_ng.found() and not cc.links(''' 948 #include <cap-ng.h> 949 int main(void) 950 { 951 capng_capability_to_name(CAPNG_EFFECTIVE); 952 return 0; 953 }''', dependencies: libcap_ng) 954 libcap_ng = not_found 955 if get_option('cap_ng').enabled() 956 error('could not link libcap-ng') 957 else 958 warning('could not link libcap-ng, disabling') 959 endif 960endif 961 962if get_option('xkbcommon').auto() and not have_system and not have_tools 963 xkbcommon = not_found 964else 965 xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'), 966 method: 'pkg-config') 967endif 968 969slirp = not_found 970if not get_option('slirp').auto() or have_system 971 slirp = dependency('slirp', required: get_option('slirp'), 972 method: 'pkg-config') 973 # slirp < 4.7 is incompatible with CFI support in QEMU. This is because 974 # it passes function pointers within libslirp as callbacks for timers. 975 # When using a system-wide shared libslirp, the type information for the 976 # callback is missing and the timer call produces a false positive with CFI. 977 # Do not use the "version" keyword argument to produce a better error. 978 # with control-flow integrity. 979 if get_option('cfi') and slirp.found() and slirp.version().version_compare('<4.7') 980 if get_option('slirp').enabled() 981 error('Control-Flow Integrity requires libslirp 4.7.') 982 else 983 warning('Cannot use libslirp since Control-Flow Integrity requires libslirp >= 4.7.') 984 slirp = not_found 985 endif 986 endif 987endif 988 989vde = not_found 990if not get_option('vde').auto() or have_system or have_tools 991 vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'], 992 required: get_option('vde')) 993endif 994if vde.found() and not cc.links(''' 995 #include <libvdeplug.h> 996 int main(void) 997 { 998 struct vde_open_args a = {0, 0, 0}; 999 char s[] = ""; 1000 vde_open(s, s, &a); 1001 return 0; 1002 }''', dependencies: vde) 1003 vde = not_found 1004 if get_option('cap_ng').enabled() 1005 error('could not link libvdeplug') 1006 else 1007 warning('could not link libvdeplug, disabling') 1008 endif 1009endif 1010 1011pulse = not_found 1012if not get_option('pa').auto() or (targetos == 'linux' and have_system) 1013 pulse = dependency('libpulse', required: get_option('pa'), 1014 method: 'pkg-config') 1015endif 1016alsa = not_found 1017if not get_option('alsa').auto() or (targetos == 'linux' and have_system) 1018 alsa = dependency('alsa', required: get_option('alsa'), 1019 method: 'pkg-config') 1020endif 1021jack = not_found 1022if not get_option('jack').auto() or have_system 1023 jack = dependency('jack', required: get_option('jack'), 1024 method: 'pkg-config') 1025endif 1026pipewire = not_found 1027if not get_option('pipewire').auto() or (targetos == 'linux' and have_system) 1028 pipewire = dependency('libpipewire-0.3', version: '>=0.3.60', 1029 required: get_option('pipewire'), 1030 method: 'pkg-config') 1031endif 1032sndio = not_found 1033if not get_option('sndio').auto() or have_system 1034 sndio = dependency('sndio', required: get_option('sndio'), 1035 method: 'pkg-config') 1036endif 1037 1038spice_protocol = not_found 1039if not get_option('spice_protocol').auto() or have_system 1040 spice_protocol = dependency('spice-protocol', version: '>=0.14.0', 1041 required: get_option('spice_protocol'), 1042 method: 'pkg-config') 1043endif 1044spice = not_found 1045if not get_option('spice').auto() or have_system 1046 spice = dependency('spice-server', version: '>=0.14.0', 1047 required: get_option('spice'), 1048 method: 'pkg-config') 1049endif 1050spice_headers = spice.partial_dependency(compile_args: true, includes: true) 1051 1052rt = cc.find_library('rt', required: false) 1053 1054libiscsi = not_found 1055if not get_option('libiscsi').auto() or have_block 1056 libiscsi = dependency('libiscsi', version: '>=1.9.0', 1057 required: get_option('libiscsi'), 1058 method: 'pkg-config') 1059endif 1060zstd = not_found 1061if not get_option('zstd').auto() or have_block 1062 zstd = dependency('libzstd', version: '>=1.4.0', 1063 required: get_option('zstd'), 1064 method: 'pkg-config') 1065endif 1066virgl = not_found 1067 1068have_vhost_user_gpu = have_tools and targetos == 'linux' and pixman.found() 1069if not get_option('virglrenderer').auto() or have_system or have_vhost_user_gpu 1070 virgl = dependency('virglrenderer', 1071 method: 'pkg-config', 1072 required: get_option('virglrenderer')) 1073endif 1074blkio = not_found 1075if not get_option('blkio').auto() or have_block 1076 blkio = dependency('blkio', 1077 method: 'pkg-config', 1078 required: get_option('blkio')) 1079endif 1080curl = not_found 1081if not get_option('curl').auto() or have_block 1082 curl = dependency('libcurl', version: '>=7.29.0', 1083 method: 'pkg-config', 1084 required: get_option('curl')) 1085endif 1086libudev = not_found 1087if targetos == 'linux' and (have_system or have_tools) 1088 libudev = dependency('libudev', 1089 method: 'pkg-config', 1090 required: get_option('libudev')) 1091endif 1092 1093mpathlibs = [libudev] 1094mpathpersist = not_found 1095mpathpersist_new_api = false 1096if targetos == 'linux' and have_tools and get_option('mpath').allowed() 1097 mpath_test_source_new = ''' 1098 #include <libudev.h> 1099 #include <mpath_persist.h> 1100 unsigned mpath_mx_alloc_len = 1024; 1101 int logsink; 1102 static struct config *multipath_conf; 1103 extern struct udev *udev; 1104 extern struct config *get_multipath_config(void); 1105 extern void put_multipath_config(struct config *conf); 1106 struct udev *udev; 1107 struct config *get_multipath_config(void) { return multipath_conf; } 1108 void put_multipath_config(struct config *conf) { } 1109 int main(void) { 1110 udev = udev_new(); 1111 multipath_conf = mpath_lib_init(); 1112 return 0; 1113 }''' 1114 mpath_test_source_old = ''' 1115 #include <libudev.h> 1116 #include <mpath_persist.h> 1117 unsigned mpath_mx_alloc_len = 1024; 1118 int logsink; 1119 int main(void) { 1120 struct udev *udev = udev_new(); 1121 mpath_lib_init(udev); 1122 return 0; 1123 }''' 1124 libmpathpersist = cc.find_library('mpathpersist', 1125 required: get_option('mpath')) 1126 if libmpathpersist.found() 1127 mpathlibs += libmpathpersist 1128 if get_option('prefer_static') 1129 mpathlibs += cc.find_library('devmapper', 1130 required: get_option('mpath')) 1131 endif 1132 mpathlibs += cc.find_library('multipath', 1133 required: get_option('mpath')) 1134 foreach lib: mpathlibs 1135 if not lib.found() 1136 mpathlibs = [] 1137 break 1138 endif 1139 endforeach 1140 if mpathlibs.length() == 0 1141 msg = 'Dependencies missing for libmpathpersist' 1142 elif cc.links(mpath_test_source_new, dependencies: mpathlibs) 1143 mpathpersist = declare_dependency(dependencies: mpathlibs) 1144 mpathpersist_new_api = true 1145 elif cc.links(mpath_test_source_old, dependencies: mpathlibs) 1146 mpathpersist = declare_dependency(dependencies: mpathlibs) 1147 else 1148 msg = 'Cannot detect libmpathpersist API' 1149 endif 1150 if not mpathpersist.found() 1151 if get_option('mpath').enabled() 1152 error(msg) 1153 else 1154 warning(msg + ', disabling') 1155 endif 1156 endif 1157 endif 1158endif 1159 1160iconv = not_found 1161curses = not_found 1162if have_system and get_option('curses').allowed() 1163 curses_test = ''' 1164 #if defined(__APPLE__) || defined(__OpenBSD__) 1165 #define _XOPEN_SOURCE_EXTENDED 1 1166 #endif 1167 #include <locale.h> 1168 #include <curses.h> 1169 #include <wchar.h> 1170 int main(void) { 1171 wchar_t wch = L'w'; 1172 setlocale(LC_ALL, ""); 1173 resize_term(0, 0); 1174 addwstr(L"wide chars\n"); 1175 addnwstr(&wch, 1); 1176 add_wch(WACS_DEGREE); 1177 return 0; 1178 }''' 1179 1180 curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw'] 1181 curses = dependency(curses_dep_list, 1182 required: false, 1183 method: 'pkg-config') 1184 msg = get_option('curses').enabled() ? 'curses library not found' : '' 1185 curses_compile_args = ['-DNCURSES_WIDECHAR=1'] 1186 if curses.found() 1187 if cc.links(curses_test, args: curses_compile_args, dependencies: [curses]) 1188 curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses], 1189 version: curses.version()) 1190 else 1191 msg = 'curses package not usable' 1192 curses = not_found 1193 endif 1194 endif 1195 if not curses.found() 1196 has_curses_h = cc.has_header('curses.h', args: curses_compile_args) 1197 if targetos != 'windows' and not has_curses_h 1198 message('Trying with /usr/include/ncursesw') 1199 curses_compile_args += ['-I/usr/include/ncursesw'] 1200 has_curses_h = cc.has_header('curses.h', args: curses_compile_args) 1201 endif 1202 if has_curses_h 1203 curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw']) 1204 foreach curses_libname : curses_libname_list 1205 libcurses = cc.find_library(curses_libname, 1206 required: false) 1207 if libcurses.found() 1208 if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses) 1209 curses = declare_dependency(compile_args: curses_compile_args, 1210 dependencies: [libcurses]) 1211 break 1212 else 1213 msg = 'curses library not usable' 1214 endif 1215 endif 1216 endforeach 1217 endif 1218 endif 1219 if get_option('iconv').allowed() 1220 foreach link_args : [ ['-liconv'], [] ] 1221 # Programs will be linked with glib and this will bring in libiconv on FreeBSD. 1222 # We need to use libiconv if available because mixing libiconv's headers with 1223 # the system libc does not work. 1224 # However, without adding glib to the dependencies -L/usr/local/lib will not be 1225 # included in the command line and libiconv will not be found. 1226 if cc.links(''' 1227 #include <iconv.h> 1228 int main(void) { 1229 iconv_t conv = iconv_open("WCHAR_T", "UCS-2"); 1230 return conv != (iconv_t) -1; 1231 }''', args: link_args, dependencies: glib) 1232 iconv = declare_dependency(link_args: link_args, dependencies: glib) 1233 break 1234 endif 1235 endforeach 1236 endif 1237 if curses.found() and not iconv.found() 1238 if get_option('iconv').enabled() 1239 error('iconv not available') 1240 endif 1241 msg = 'iconv required for curses UI but not available' 1242 curses = not_found 1243 endif 1244 if not curses.found() and msg != '' 1245 if get_option('curses').enabled() 1246 error(msg) 1247 else 1248 warning(msg + ', disabling') 1249 endif 1250 endif 1251endif 1252 1253brlapi = not_found 1254if not get_option('brlapi').auto() or have_system 1255 brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'], 1256 required: get_option('brlapi')) 1257 if brlapi.found() and not cc.links(''' 1258 #include <brlapi.h> 1259 #include <stddef.h> 1260 int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi) 1261 brlapi = not_found 1262 if get_option('brlapi').enabled() 1263 error('could not link brlapi') 1264 else 1265 warning('could not link brlapi, disabling') 1266 endif 1267 endif 1268endif 1269 1270sdl = not_found 1271if not get_option('sdl').auto() or have_system 1272 sdl = dependency('sdl2', required: get_option('sdl')) 1273 sdl_image = not_found 1274endif 1275if sdl.found() 1276 # work around 2.0.8 bug 1277 sdl = declare_dependency(compile_args: '-Wno-undef', 1278 dependencies: sdl, 1279 version: sdl.version()) 1280 sdl_image = dependency('SDL2_image', required: get_option('sdl_image'), 1281 method: 'pkg-config') 1282else 1283 if get_option('sdl_image').enabled() 1284 error('sdl-image required, but SDL was @0@'.format( 1285 get_option('sdl').disabled() ? 'disabled' : 'not found')) 1286 endif 1287 sdl_image = not_found 1288endif 1289 1290rbd = not_found 1291if not get_option('rbd').auto() or have_block 1292 librados = cc.find_library('rados', required: get_option('rbd')) 1293 librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'], 1294 required: get_option('rbd')) 1295 if librados.found() and librbd.found() 1296 if cc.links(''' 1297 #include <stdio.h> 1298 #include <rbd/librbd.h> 1299 int main(void) { 1300 rados_t cluster; 1301 rados_create(&cluster, NULL); 1302 #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0) 1303 #error 1304 #endif 1305 return 0; 1306 }''', dependencies: [librbd, librados]) 1307 rbd = declare_dependency(dependencies: [librbd, librados]) 1308 elif get_option('rbd').enabled() 1309 error('librbd >= 1.12.0 required') 1310 else 1311 warning('librbd >= 1.12.0 not found, disabling') 1312 endif 1313 endif 1314endif 1315 1316glusterfs = not_found 1317glusterfs_ftruncate_has_stat = false 1318glusterfs_iocb_has_stat = false 1319if not get_option('glusterfs').auto() or have_block 1320 glusterfs = dependency('glusterfs-api', version: '>=3', 1321 required: get_option('glusterfs'), 1322 method: 'pkg-config') 1323 if glusterfs.found() 1324 glusterfs_ftruncate_has_stat = cc.links(''' 1325 #include <glusterfs/api/glfs.h> 1326 1327 int 1328 main(void) 1329 { 1330 /* new glfs_ftruncate() passes two additional args */ 1331 return glfs_ftruncate(NULL, 0, NULL, NULL); 1332 } 1333 ''', dependencies: glusterfs) 1334 glusterfs_iocb_has_stat = cc.links(''' 1335 #include <glusterfs/api/glfs.h> 1336 1337 /* new glfs_io_cbk() passes two additional glfs_stat structs */ 1338 static void 1339 glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data) 1340 {} 1341 1342 int 1343 main(void) 1344 { 1345 glfs_io_cbk iocb = &glusterfs_iocb; 1346 iocb(NULL, 0 , NULL, NULL, NULL); 1347 return 0; 1348 } 1349 ''', dependencies: glusterfs) 1350 endif 1351endif 1352 1353libssh = not_found 1354if not get_option('libssh').auto() or have_block 1355 libssh = dependency('libssh', version: '>=0.8.7', 1356 method: 'pkg-config', 1357 required: get_option('libssh')) 1358endif 1359 1360libbzip2 = not_found 1361if not get_option('bzip2').auto() or have_block 1362 libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'], 1363 required: get_option('bzip2')) 1364 if libbzip2.found() and not cc.links(''' 1365 #include <bzlib.h> 1366 int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2) 1367 libbzip2 = not_found 1368 if get_option('bzip2').enabled() 1369 error('could not link libbzip2') 1370 else 1371 warning('could not link libbzip2, disabling') 1372 endif 1373 endif 1374endif 1375 1376liblzfse = not_found 1377if not get_option('lzfse').auto() or have_block 1378 liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'], 1379 required: get_option('lzfse')) 1380endif 1381if liblzfse.found() and not cc.links(''' 1382 #include <lzfse.h> 1383 int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse) 1384 liblzfse = not_found 1385 if get_option('lzfse').enabled() 1386 error('could not link liblzfse') 1387 else 1388 warning('could not link liblzfse, disabling') 1389 endif 1390endif 1391 1392oss = not_found 1393if get_option('oss').allowed() and have_system 1394 if not cc.has_header('sys/soundcard.h') 1395 # not found 1396 elif targetos == 'netbsd' 1397 oss = cc.find_library('ossaudio', required: get_option('oss')) 1398 else 1399 oss = declare_dependency() 1400 endif 1401 1402 if not oss.found() 1403 if get_option('oss').enabled() 1404 error('OSS not found') 1405 endif 1406 endif 1407endif 1408dsound = not_found 1409if not get_option('dsound').auto() or (targetos == 'windows' and have_system) 1410 if cc.has_header('dsound.h') 1411 dsound = declare_dependency(link_args: ['-lole32', '-ldxguid']) 1412 endif 1413 1414 if not dsound.found() 1415 if get_option('dsound').enabled() 1416 error('DirectSound not found') 1417 endif 1418 endif 1419endif 1420 1421coreaudio = not_found 1422if not get_option('coreaudio').auto() or (targetos == 'darwin' and have_system) 1423 coreaudio = dependency('appleframeworks', modules: 'CoreAudio', 1424 required: get_option('coreaudio')) 1425endif 1426 1427opengl = not_found 1428if not get_option('opengl').auto() or have_system or have_vhost_user_gpu 1429 epoxy = dependency('epoxy', method: 'pkg-config', 1430 required: get_option('opengl')) 1431 if cc.has_header('epoxy/egl.h', dependencies: epoxy) 1432 opengl = epoxy 1433 elif get_option('opengl').enabled() 1434 error('epoxy/egl.h not found') 1435 endif 1436endif 1437gbm = not_found 1438if (have_system or have_tools) and (virgl.found() or opengl.found()) 1439 gbm = dependency('gbm', method: 'pkg-config', required: false) 1440endif 1441have_vhost_user_gpu = have_vhost_user_gpu and virgl.found() and opengl.found() and gbm.found() 1442 1443gnutls = not_found 1444gnutls_crypto = not_found 1445if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system) 1446 # For general TLS support our min gnutls matches 1447 # that implied by our platform support matrix 1448 # 1449 # For the crypto backends, we look for a newer 1450 # gnutls: 1451 # 1452 # Version 3.6.8 is needed to get XTS 1453 # Version 3.6.13 is needed to get PBKDF 1454 # Version 3.6.14 is needed to get HW accelerated XTS 1455 # 1456 # If newer enough gnutls isn't available, we can 1457 # still use a different crypto backend to satisfy 1458 # the platform support requirements 1459 gnutls_crypto = dependency('gnutls', version: '>=3.6.14', 1460 method: 'pkg-config', 1461 required: false) 1462 if gnutls_crypto.found() 1463 gnutls = gnutls_crypto 1464 else 1465 # Our min version if all we need is TLS 1466 gnutls = dependency('gnutls', version: '>=3.5.18', 1467 method: 'pkg-config', 1468 required: get_option('gnutls')) 1469 endif 1470endif 1471 1472# We prefer use of gnutls for crypto, unless the options 1473# explicitly asked for nettle or gcrypt. 1474# 1475# If gnutls isn't available for crypto, then we'll prefer 1476# gcrypt over nettle for performance reasons. 1477gcrypt = not_found 1478nettle = not_found 1479hogweed = not_found 1480xts = 'none' 1481 1482if get_option('nettle').enabled() and get_option('gcrypt').enabled() 1483 error('Only one of gcrypt & nettle can be enabled') 1484endif 1485 1486# Explicit nettle/gcrypt request, so ignore gnutls for crypto 1487if get_option('nettle').enabled() or get_option('gcrypt').enabled() 1488 gnutls_crypto = not_found 1489endif 1490 1491if not gnutls_crypto.found() 1492 if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled() 1493 gcrypt = dependency('libgcrypt', version: '>=1.8', 1494 method: 'config-tool', 1495 required: get_option('gcrypt')) 1496 # Debian has removed -lgpg-error from libgcrypt-config 1497 # as it "spreads unnecessary dependencies" which in 1498 # turn breaks static builds... 1499 if gcrypt.found() and get_option('prefer_static') 1500 gcrypt = declare_dependency(dependencies: 1501 [gcrypt, 1502 cc.find_library('gpg-error', required: true)], 1503 version: gcrypt.version()) 1504 endif 1505 endif 1506 if (not get_option('nettle').auto() or have_system) and not gcrypt.found() 1507 nettle = dependency('nettle', version: '>=3.4', 1508 method: 'pkg-config', 1509 required: get_option('nettle')) 1510 if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle) 1511 xts = 'private' 1512 endif 1513 endif 1514endif 1515 1516gmp = dependency('gmp', required: false, method: 'pkg-config') 1517if nettle.found() and gmp.found() 1518 hogweed = dependency('hogweed', version: '>=3.4', 1519 method: 'pkg-config', 1520 required: get_option('nettle')) 1521endif 1522 1523 1524gtk = not_found 1525gtkx11 = not_found 1526vte = not_found 1527have_gtk_clipboard = get_option('gtk_clipboard').enabled() 1528 1529if not get_option('gtk').auto() or have_system 1530 gtk = dependency('gtk+-3.0', version: '>=3.22.0', 1531 method: 'pkg-config', 1532 required: get_option('gtk')) 1533 if gtk.found() 1534 gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0', 1535 method: 'pkg-config', 1536 required: false) 1537 gtk = declare_dependency(dependencies: [gtk, gtkx11], 1538 version: gtk.version()) 1539 1540 if not get_option('vte').auto() or have_system 1541 vte = dependency('vte-2.91', 1542 method: 'pkg-config', 1543 required: get_option('vte')) 1544 endif 1545 elif have_gtk_clipboard 1546 error('GTK clipboard requested, but GTK not found') 1547 endif 1548endif 1549 1550x11 = not_found 1551if gtkx11.found() 1552 x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found()) 1553endif 1554png = not_found 1555if get_option('png').allowed() and have_system 1556 png = dependency('libpng', version: '>=1.6.34', required: get_option('png'), 1557 method: 'pkg-config') 1558endif 1559vnc = not_found 1560jpeg = not_found 1561sasl = not_found 1562if get_option('vnc').allowed() and have_system 1563 vnc = declare_dependency() # dummy dependency 1564 jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'), 1565 method: 'pkg-config') 1566 sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'], 1567 required: get_option('vnc_sasl')) 1568 if sasl.found() 1569 sasl = declare_dependency(dependencies: sasl, 1570 compile_args: '-DSTRUCT_IOVEC_DEFINED') 1571 endif 1572endif 1573 1574pam = not_found 1575if not get_option('auth_pam').auto() or have_system 1576 pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'], 1577 required: get_option('auth_pam')) 1578endif 1579if pam.found() and not cc.links(''' 1580 #include <stddef.h> 1581 #include <security/pam_appl.h> 1582 int main(void) { 1583 const char *service_name = "qemu"; 1584 const char *user = "frank"; 1585 const struct pam_conv pam_conv = { 0 }; 1586 pam_handle_t *pamh = NULL; 1587 pam_start(service_name, user, &pam_conv, &pamh); 1588 return 0; 1589 }''', dependencies: pam) 1590 pam = not_found 1591 if get_option('auth_pam').enabled() 1592 error('could not link libpam') 1593 else 1594 warning('could not link libpam, disabling') 1595 endif 1596endif 1597 1598snappy = not_found 1599if not get_option('snappy').auto() or have_system 1600 snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'], 1601 required: get_option('snappy')) 1602endif 1603if snappy.found() and not linker.links(''' 1604 #include <snappy-c.h> 1605 int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy) 1606 snappy = not_found 1607 if get_option('snappy').enabled() 1608 error('could not link libsnappy') 1609 else 1610 warning('could not link libsnappy, disabling') 1611 endif 1612endif 1613 1614lzo = not_found 1615if not get_option('lzo').auto() or have_system 1616 lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'], 1617 required: get_option('lzo')) 1618endif 1619if lzo.found() and not cc.links(''' 1620 #include <lzo/lzo1x.h> 1621 int main(void) { lzo_version(); return 0; }''', dependencies: lzo) 1622 lzo = not_found 1623 if get_option('lzo').enabled() 1624 error('could not link liblzo2') 1625 else 1626 warning('could not link liblzo2, disabling') 1627 endif 1628endif 1629 1630numa = not_found 1631if not get_option('numa').auto() or have_system or have_tools 1632 numa = cc.find_library('numa', has_headers: ['numa.h'], 1633 required: get_option('numa')) 1634endif 1635if numa.found() and not cc.links(''' 1636 #include <numa.h> 1637 int main(void) { return numa_available(); } 1638 ''', dependencies: numa) 1639 numa = not_found 1640 if get_option('numa').enabled() 1641 error('could not link numa') 1642 else 1643 warning('could not link numa, disabling') 1644 endif 1645endif 1646 1647rdma = not_found 1648if not get_option('rdma').auto() or have_system 1649 libumad = cc.find_library('ibumad', required: get_option('rdma')) 1650 rdma_libs = [cc.find_library('rdmacm', has_headers: ['rdma/rdma_cma.h'], 1651 required: get_option('rdma')), 1652 cc.find_library('ibverbs', required: get_option('rdma')), 1653 libumad] 1654 rdma = declare_dependency(dependencies: rdma_libs) 1655 foreach lib: rdma_libs 1656 if not lib.found() 1657 rdma = not_found 1658 endif 1659 endforeach 1660endif 1661 1662xen = not_found 1663if get_option('xen').enabled() or (get_option('xen').auto() and have_system) 1664 xencontrol = dependency('xencontrol', required: false, 1665 method: 'pkg-config') 1666 if xencontrol.found() 1667 xen_pc = declare_dependency(version: xencontrol.version(), 1668 dependencies: [ 1669 xencontrol, 1670 # disabler: true makes xen_pc.found() return false if any is not found 1671 dependency('xenstore', required: false, 1672 method: 'pkg-config', 1673 disabler: true), 1674 dependency('xenforeignmemory', required: false, 1675 method: 'pkg-config', 1676 disabler: true), 1677 dependency('xengnttab', required: false, 1678 method: 'pkg-config', 1679 disabler: true), 1680 dependency('xenevtchn', required: false, 1681 method: 'pkg-config', 1682 disabler: true), 1683 dependency('xendevicemodel', required: false, 1684 method: 'pkg-config', 1685 disabler: true), 1686 # optional, no "disabler: true" 1687 dependency('xentoolcore', required: false, 1688 method: 'pkg-config')]) 1689 if xen_pc.found() 1690 xen = xen_pc 1691 endif 1692 endif 1693 if not xen.found() 1694 xen_tests = [ '4.11.0', '4.10.0', '4.9.0', '4.8.0', '4.7.1', '4.6.0', '4.5.0', '4.2.0' ] 1695 xen_libs = { 1696 '4.11.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ], 1697 '4.10.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ], 1698 '4.9.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ], 1699 '4.8.0': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ], 1700 '4.7.1': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ], 1701 '4.6.0': [ 'xenstore', 'xenctrl' ], 1702 '4.5.0': [ 'xenstore', 'xenctrl' ], 1703 '4.2.0': [ 'xenstore', 'xenctrl' ], 1704 } 1705 xen_deps = {} 1706 foreach ver: xen_tests 1707 # cache the various library tests to avoid polluting the logs 1708 xen_test_deps = [] 1709 foreach l: xen_libs[ver] 1710 if l not in xen_deps 1711 xen_deps += { l: cc.find_library(l, required: false) } 1712 endif 1713 xen_test_deps += xen_deps[l] 1714 endforeach 1715 1716 # Use -D to pick just one of the test programs in scripts/xen-detect.c 1717 xen_version = ver.split('.') 1718 xen_ctrl_version = xen_version[0] + \ 1719 ('0' + xen_version[1]).substring(-2) + \ 1720 ('0' + xen_version[2]).substring(-2) 1721 if cc.links(files('scripts/xen-detect.c'), 1722 args: '-DCONFIG_XEN_CTRL_INTERFACE_VERSION=' + xen_ctrl_version, 1723 dependencies: xen_test_deps) 1724 xen = declare_dependency(version: ver, dependencies: xen_test_deps) 1725 break 1726 endif 1727 endforeach 1728 endif 1729 if xen.found() 1730 accelerators += 'CONFIG_XEN' 1731 elif get_option('xen').enabled() 1732 error('could not compile and link Xen test program') 1733 endif 1734endif 1735have_xen_pci_passthrough = get_option('xen_pci_passthrough') \ 1736 .require(xen.found(), 1737 error_message: 'Xen PCI passthrough requested but Xen not enabled') \ 1738 .require(targetos == 'linux', 1739 error_message: 'Xen PCI passthrough not available on this platform') \ 1740 .allowed() 1741 1742 1743cacard = not_found 1744if not get_option('smartcard').auto() or have_system 1745 cacard = dependency('libcacard', required: get_option('smartcard'), 1746 version: '>=2.5.1', method: 'pkg-config') 1747endif 1748u2f = not_found 1749if have_system 1750 u2f = dependency('u2f-emu', required: get_option('u2f'), 1751 method: 'pkg-config') 1752endif 1753canokey = not_found 1754if have_system 1755 canokey = dependency('canokey-qemu', required: get_option('canokey'), 1756 method: 'pkg-config') 1757endif 1758usbredir = not_found 1759if not get_option('usb_redir').auto() or have_system 1760 usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'), 1761 version: '>=0.6', method: 'pkg-config') 1762endif 1763libusb = not_found 1764if not get_option('libusb').auto() or have_system 1765 libusb = dependency('libusb-1.0', required: get_option('libusb'), 1766 version: '>=1.0.13', method: 'pkg-config') 1767endif 1768 1769libpmem = not_found 1770if not get_option('libpmem').auto() or have_system 1771 libpmem = dependency('libpmem', required: get_option('libpmem'), 1772 method: 'pkg-config') 1773endif 1774libdaxctl = not_found 1775if not get_option('libdaxctl').auto() or have_system 1776 libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'), 1777 version: '>=57', method: 'pkg-config') 1778endif 1779tasn1 = not_found 1780if gnutls.found() 1781 tasn1 = dependency('libtasn1', 1782 method: 'pkg-config') 1783endif 1784keyutils = dependency('libkeyutils', required: false, 1785 method: 'pkg-config') 1786 1787has_gettid = cc.has_function('gettid') 1788 1789# libselinux 1790selinux = dependency('libselinux', 1791 required: get_option('selinux'), 1792 method: 'pkg-config') 1793 1794# Malloc tests 1795 1796malloc = [] 1797if get_option('malloc') == 'system' 1798 has_malloc_trim = \ 1799 get_option('malloc_trim').allowed() and \ 1800 cc.links('''#include <malloc.h> 1801 int main(void) { malloc_trim(0); return 0; }''') 1802else 1803 has_malloc_trim = false 1804 malloc = cc.find_library(get_option('malloc'), required: true) 1805endif 1806if not has_malloc_trim and get_option('malloc_trim').enabled() 1807 if get_option('malloc') == 'system' 1808 error('malloc_trim not available on this platform.') 1809 else 1810 error('malloc_trim not available with non-libc memory allocator') 1811 endif 1812endif 1813 1814# Check whether the glibc provides statx() 1815 1816gnu_source_prefix = ''' 1817 #ifndef _GNU_SOURCE 1818 #define _GNU_SOURCE 1819 #endif 1820''' 1821statx_test = gnu_source_prefix + ''' 1822 #include <sys/stat.h> 1823 int main(void) { 1824 struct statx statxbuf; 1825 statx(0, "", 0, STATX_BASIC_STATS, &statxbuf); 1826 return 0; 1827 }''' 1828 1829has_statx = cc.links(statx_test) 1830 1831# Check whether statx() provides mount ID information 1832 1833statx_mnt_id_test = gnu_source_prefix + ''' 1834 #include <sys/stat.h> 1835 int main(void) { 1836 struct statx statxbuf; 1837 statx(0, "", 0, STATX_BASIC_STATS | STATX_MNT_ID, &statxbuf); 1838 return statxbuf.stx_mnt_id; 1839 }''' 1840 1841has_statx_mnt_id = cc.links(statx_mnt_id_test) 1842 1843have_vhost_user_blk_server = get_option('vhost_user_blk_server') \ 1844 .require(targetos == 'linux', 1845 error_message: 'vhost_user_blk_server requires linux') \ 1846 .require(have_vhost_user, 1847 error_message: 'vhost_user_blk_server requires vhost-user support') \ 1848 .disable_auto_if(not have_tools and not have_system) \ 1849 .allowed() 1850 1851if get_option('fuse').disabled() and get_option('fuse_lseek').enabled() 1852 error('Cannot enable fuse-lseek while fuse is disabled') 1853endif 1854 1855fuse = dependency('fuse3', required: get_option('fuse'), 1856 version: '>=3.1', method: 'pkg-config') 1857 1858fuse_lseek = not_found 1859if get_option('fuse_lseek').allowed() 1860 if fuse.version().version_compare('>=3.8') 1861 # Dummy dependency 1862 fuse_lseek = declare_dependency() 1863 elif get_option('fuse_lseek').enabled() 1864 if fuse.found() 1865 error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version()) 1866 else 1867 error('fuse-lseek requires libfuse, which was not found') 1868 endif 1869 endif 1870endif 1871 1872have_libvduse = (targetos == 'linux') 1873if get_option('libvduse').enabled() 1874 if targetos != 'linux' 1875 error('libvduse requires linux') 1876 endif 1877elif get_option('libvduse').disabled() 1878 have_libvduse = false 1879endif 1880 1881have_vduse_blk_export = (have_libvduse and targetos == 'linux') 1882if get_option('vduse_blk_export').enabled() 1883 if targetos != 'linux' 1884 error('vduse_blk_export requires linux') 1885 elif not have_libvduse 1886 error('vduse_blk_export requires libvduse support') 1887 endif 1888elif get_option('vduse_blk_export').disabled() 1889 have_vduse_blk_export = false 1890endif 1891 1892# libbpf 1893libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config') 1894if libbpf.found() and not cc.links(''' 1895 #include <bpf/libbpf.h> 1896 int main(void) 1897 { 1898 bpf_object__destroy_skeleton(NULL); 1899 return 0; 1900 }''', dependencies: libbpf) 1901 libbpf = not_found 1902 if get_option('bpf').enabled() 1903 error('libbpf skeleton test failed') 1904 else 1905 warning('libbpf skeleton test failed, disabling') 1906 endif 1907endif 1908 1909# libdw 1910libdw = not_found 1911if not get_option('libdw').auto() or \ 1912 (not get_option('prefer_static') and (have_system or have_user)) 1913 libdw = dependency('libdw', 1914 method: 'pkg-config', 1915 required: get_option('libdw')) 1916endif 1917 1918################# 1919# config-host.h # 1920################# 1921 1922audio_drivers_selected = [] 1923if have_system 1924 audio_drivers_available = { 1925 'alsa': alsa.found(), 1926 'coreaudio': coreaudio.found(), 1927 'dsound': dsound.found(), 1928 'jack': jack.found(), 1929 'oss': oss.found(), 1930 'pa': pulse.found(), 1931 'pipewire': pipewire.found(), 1932 'sdl': sdl.found(), 1933 'sndio': sndio.found(), 1934 } 1935 foreach k, v: audio_drivers_available 1936 config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v) 1937 endforeach 1938 1939 # Default to native drivers first, OSS second, SDL third 1940 audio_drivers_priority = \ 1941 [ 'pa', 'coreaudio', 'dsound', 'sndio', 'oss' ] + \ 1942 (targetos == 'linux' ? [] : [ 'sdl' ]) 1943 audio_drivers_default = [] 1944 foreach k: audio_drivers_priority 1945 if audio_drivers_available[k] 1946 audio_drivers_default += k 1947 endif 1948 endforeach 1949 1950 foreach k: get_option('audio_drv_list') 1951 if k == 'default' 1952 audio_drivers_selected += audio_drivers_default 1953 elif not audio_drivers_available[k] 1954 error('Audio driver "@0@" not available.'.format(k)) 1955 else 1956 audio_drivers_selected += k 1957 endif 1958 endforeach 1959endif 1960config_host_data.set('CONFIG_AUDIO_DRIVERS', 1961 '"' + '", "'.join(audio_drivers_selected) + '", ') 1962 1963if get_option('cfi') 1964 cfi_flags=[] 1965 # Check for dependency on LTO 1966 if not get_option('b_lto') 1967 error('Selected Control-Flow Integrity but LTO is disabled') 1968 endif 1969 if enable_modules 1970 error('Selected Control-Flow Integrity is not compatible with modules') 1971 endif 1972 # Check for cfi flags. CFI requires LTO so we can't use 1973 # get_supported_arguments, but need a more complex "compiles" which allows 1974 # custom arguments 1975 if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall', 1976 args: ['-flto', '-fsanitize=cfi-icall'] ) 1977 cfi_flags += '-fsanitize=cfi-icall' 1978 else 1979 error('-fsanitize=cfi-icall is not supported by the compiler') 1980 endif 1981 if cc.compiles('int main () { return 0; }', 1982 name: '-fsanitize-cfi-icall-generalize-pointers', 1983 args: ['-flto', '-fsanitize=cfi-icall', 1984 '-fsanitize-cfi-icall-generalize-pointers'] ) 1985 cfi_flags += '-fsanitize-cfi-icall-generalize-pointers' 1986 else 1987 error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler') 1988 endif 1989 if get_option('cfi_debug') 1990 if cc.compiles('int main () { return 0; }', 1991 name: '-fno-sanitize-trap=cfi-icall', 1992 args: ['-flto', '-fsanitize=cfi-icall', 1993 '-fno-sanitize-trap=cfi-icall'] ) 1994 cfi_flags += '-fno-sanitize-trap=cfi-icall' 1995 else 1996 error('-fno-sanitize-trap=cfi-icall is not supported by the compiler') 1997 endif 1998 endif 1999 add_global_arguments(cfi_flags, native: false, language: all_languages) 2000 add_global_link_arguments(cfi_flags, native: false, language: all_languages) 2001endif 2002 2003have_host_block_device = (targetos != 'darwin' or 2004 cc.has_header('IOKit/storage/IOMedia.h')) 2005 2006dbus_display = get_option('dbus_display') \ 2007 .require(gio.version().version_compare('>=2.64'), 2008 error_message: '-display dbus requires glib>=2.64') \ 2009 .require(gdbus_codegen.found(), 2010 error_message: gdbus_codegen_error.format('-display dbus')) \ 2011 .require(targetos != 'windows', 2012 error_message: '-display dbus is not available on Windows') \ 2013 .allowed() 2014 2015have_virtfs = get_option('virtfs') \ 2016 .require(targetos == 'linux' or targetos == 'darwin', 2017 error_message: 'virtio-9p (virtfs) requires Linux or macOS') \ 2018 .require(targetos == 'linux' or cc.has_function('pthread_fchdir_np'), 2019 error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \ 2020 .require(targetos == 'darwin' or libattr.found(), 2021 error_message: 'virtio-9p (virtfs) on Linux requires libattr-devel') \ 2022 .disable_auto_if(not have_tools and not have_system) \ 2023 .allowed() 2024 2025have_virtfs_proxy_helper = get_option('virtfs_proxy_helper') \ 2026 .require(targetos != 'darwin', error_message: 'the virtfs proxy helper is incompatible with macOS') \ 2027 .require(have_virtfs, error_message: 'the virtfs proxy helper requires that virtfs is enabled') \ 2028 .disable_auto_if(not have_tools) \ 2029 .require(libcap_ng.found(), error_message: 'the virtfs proxy helper requires libcap-ng') \ 2030 .allowed() 2031 2032if get_option('block_drv_ro_whitelist') == '' 2033 config_host_data.set('CONFIG_BDRV_RO_WHITELIST', '') 2034else 2035 config_host_data.set('CONFIG_BDRV_RO_WHITELIST', 2036 '"' + get_option('block_drv_ro_whitelist').replace(',', '", "') + '", ') 2037endif 2038if get_option('block_drv_rw_whitelist') == '' 2039 config_host_data.set('CONFIG_BDRV_RW_WHITELIST', '') 2040else 2041 config_host_data.set('CONFIG_BDRV_RW_WHITELIST', 2042 '"' + get_option('block_drv_rw_whitelist').replace(',', '", "') + '", ') 2043endif 2044 2045foreach k : get_option('trace_backends') 2046 config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true) 2047endforeach 2048config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file')) 2049config_host_data.set_quoted('CONFIG_TLS_PRIORITY', get_option('tls_priority')) 2050if iasl.found() 2051 config_host_data.set_quoted('CONFIG_IASL', iasl.full_path()) 2052endif 2053config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir')) 2054config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix')) 2055config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir) 2056config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir) 2057config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir) 2058 2059qemu_firmwarepath = '' 2060foreach k : get_option('qemu_firmwarepath') 2061 qemu_firmwarepath += '"' + get_option('prefix') / k + '", ' 2062endforeach 2063config_host_data.set('CONFIG_QEMU_FIRMWAREPATH', qemu_firmwarepath) 2064 2065config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir')) 2066config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir) 2067config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir')) 2068config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir')) 2069config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir) 2070config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir')) 2071 2072if enable_modules 2073 config_host_data.set('CONFIG_STAMP', run_command( 2074 meson.current_source_dir() / 'scripts/qemu-stamp.py', 2075 meson.project_version(), get_option('pkgversion'), '--', 2076 meson.current_source_dir() / 'configure', 2077 capture: true, check: true).stdout().strip()) 2078endif 2079 2080have_slirp_smbd = get_option('slirp_smbd') \ 2081 .require(targetos != 'windows', error_message: 'Host smbd not supported on this platform.') \ 2082 .allowed() 2083if have_slirp_smbd 2084 smbd_path = get_option('smbd') 2085 if smbd_path == '' 2086 smbd_path = (targetos == 'solaris' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd') 2087 endif 2088 config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path) 2089endif 2090 2091config_host_data.set('HOST_' + host_arch.to_upper(), 1) 2092 2093if get_option('module_upgrades') and not enable_modules 2094 error('Cannot enable module-upgrades as modules are not enabled') 2095endif 2096config_host_data.set('CONFIG_MODULE_UPGRADES', get_option('module_upgrades')) 2097 2098config_host_data.set('CONFIG_ATTR', libattr.found()) 2099config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools')) 2100config_host_data.set('CONFIG_BRLAPI', brlapi.found()) 2101config_host_data.set('CONFIG_COCOA', cocoa.found()) 2102config_host_data.set('CONFIG_FUZZ', get_option('fuzzing')) 2103config_host_data.set('CONFIG_GCOV', get_option('b_coverage')) 2104config_host_data.set('CONFIG_LIBUDEV', libudev.found()) 2105config_host_data.set('CONFIG_LZO', lzo.found()) 2106config_host_data.set('CONFIG_MPATH', mpathpersist.found()) 2107config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api) 2108config_host_data.set('CONFIG_BLKIO', blkio.found()) 2109if blkio.found() 2110 config_host_data.set('CONFIG_BLKIO_VHOST_VDPA_FD', 2111 blkio.version().version_compare('>=1.3.0')) 2112endif 2113config_host_data.set('CONFIG_CURL', curl.found()) 2114config_host_data.set('CONFIG_CURSES', curses.found()) 2115config_host_data.set('CONFIG_GBM', gbm.found()) 2116config_host_data.set('CONFIG_GIO', gio.found()) 2117config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found()) 2118if glusterfs.found() 2119 config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4')) 2120 config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5')) 2121 config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6')) 2122 config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6')) 2123 config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat) 2124 config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat) 2125endif 2126config_host_data.set('CONFIG_GTK', gtk.found()) 2127config_host_data.set('CONFIG_VTE', vte.found()) 2128config_host_data.set('CONFIG_GTK_CLIPBOARD', have_gtk_clipboard) 2129config_host_data.set('CONFIG_HEXAGON_IDEF_PARSER', get_option('hexagon_idef_parser')) 2130config_host_data.set('CONFIG_LIBATTR', have_old_libattr) 2131config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found()) 2132config_host_data.set('CONFIG_EBPF', libbpf.found()) 2133config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found()) 2134config_host_data.set('CONFIG_LIBISCSI', libiscsi.found()) 2135config_host_data.set('CONFIG_LIBNFS', libnfs.found()) 2136config_host_data.set('CONFIG_LIBSSH', libssh.found()) 2137config_host_data.set('CONFIG_LINUX_AIO', libaio.found()) 2138config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found()) 2139config_host_data.set('CONFIG_LIBPMEM', libpmem.found()) 2140config_host_data.set('CONFIG_MODULES', enable_modules) 2141config_host_data.set('CONFIG_NUMA', numa.found()) 2142if numa.found() 2143 config_host_data.set('HAVE_NUMA_HAS_PREFERRED_MANY', 2144 cc.has_function('numa_has_preferred_many', 2145 dependencies: numa)) 2146endif 2147config_host_data.set('CONFIG_OPENGL', opengl.found()) 2148config_host_data.set('CONFIG_PROFILER', get_option('profiler')) 2149config_host_data.set('CONFIG_RBD', rbd.found()) 2150config_host_data.set('CONFIG_RDMA', rdma.found()) 2151config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack')) 2152config_host_data.set('CONFIG_SDL', sdl.found()) 2153config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found()) 2154config_host_data.set('CONFIG_SECCOMP', seccomp.found()) 2155if seccomp.found() 2156 config_host_data.set('CONFIG_SECCOMP_SYSRAWRC', seccomp_has_sysrawrc) 2157endif 2158config_host_data.set('CONFIG_SNAPPY', snappy.found()) 2159config_host_data.set('CONFIG_TPM', have_tpm) 2160config_host_data.set('CONFIG_TSAN', get_option('tsan')) 2161config_host_data.set('CONFIG_USB_LIBUSB', libusb.found()) 2162config_host_data.set('CONFIG_VDE', vde.found()) 2163config_host_data.set('CONFIG_VHOST_NET', have_vhost_net) 2164config_host_data.set('CONFIG_VHOST_NET_USER', have_vhost_net_user) 2165config_host_data.set('CONFIG_VHOST_NET_VDPA', have_vhost_net_vdpa) 2166config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel) 2167config_host_data.set('CONFIG_VHOST_USER', have_vhost_user) 2168config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto) 2169config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa) 2170config_host_data.set('CONFIG_VMNET', vmnet.found()) 2171config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server) 2172config_host_data.set('CONFIG_VDUSE_BLK_EXPORT', have_vduse_blk_export) 2173config_host_data.set('CONFIG_PNG', png.found()) 2174config_host_data.set('CONFIG_VNC', vnc.found()) 2175config_host_data.set('CONFIG_VNC_JPEG', jpeg.found()) 2176config_host_data.set('CONFIG_VNC_SASL', sasl.found()) 2177config_host_data.set('CONFIG_VIRTFS', have_virtfs) 2178config_host_data.set('CONFIG_VTE', vte.found()) 2179config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found()) 2180config_host_data.set('CONFIG_KEYUTILS', keyutils.found()) 2181config_host_data.set('CONFIG_GETTID', has_gettid) 2182config_host_data.set('CONFIG_GNUTLS', gnutls.found()) 2183config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found()) 2184config_host_data.set('CONFIG_TASN1', tasn1.found()) 2185config_host_data.set('CONFIG_GCRYPT', gcrypt.found()) 2186config_host_data.set('CONFIG_NETTLE', nettle.found()) 2187config_host_data.set('CONFIG_HOGWEED', hogweed.found()) 2188config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private') 2189config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim) 2190config_host_data.set('CONFIG_STATX', has_statx) 2191config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id) 2192config_host_data.set('CONFIG_ZSTD', zstd.found()) 2193config_host_data.set('CONFIG_FUSE', fuse.found()) 2194config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found()) 2195config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found()) 2196if spice_protocol.found() 2197config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0]) 2198config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1]) 2199config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2]) 2200endif 2201config_host_data.set('CONFIG_SPICE', spice.found()) 2202config_host_data.set('CONFIG_X11', x11.found()) 2203config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display) 2204config_host_data.set('CONFIG_CFI', get_option('cfi')) 2205config_host_data.set('CONFIG_SELINUX', selinux.found()) 2206config_host_data.set('CONFIG_XEN_BACKEND', xen.found()) 2207config_host_data.set('CONFIG_LIBDW', libdw.found()) 2208if xen.found() 2209 # protect from xen.version() having less than three components 2210 xen_version = xen.version().split('.') + ['0', '0'] 2211 xen_ctrl_version = xen_version[0] + \ 2212 ('0' + xen_version[1]).substring(-2) + \ 2213 ('0' + xen_version[2]).substring(-2) 2214 config_host_data.set('CONFIG_XEN_CTRL_INTERFACE_VERSION', xen_ctrl_version) 2215endif 2216config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version())) 2217config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0]) 2218config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1]) 2219config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2]) 2220 2221config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf) 2222config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device) 2223 2224have_coroutine_pool = get_option('coroutine_pool') 2225if get_option('debug_stack_usage') and have_coroutine_pool 2226 message('Disabling coroutine pool to measure stack usage') 2227 have_coroutine_pool = false 2228endif 2229config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool) 2230config_host_data.set('CONFIG_DEBUG_GRAPH_LOCK', get_option('debug_graph_lock')) 2231config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex')) 2232config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage')) 2233config_host_data.set('CONFIG_GPROF', get_option('gprof')) 2234config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed()) 2235config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug')) 2236config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed()) 2237 2238# has_header 2239config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h')) 2240config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h')) 2241config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h')) 2242config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h')) 2243config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h')) 2244config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h')) 2245config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h')) 2246config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h')) 2247config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h')) 2248if targetos == 'windows' 2249 config_host_data.set('HAVE_AFUNIX_H', cc.has_header('afunix.h')) 2250endif 2251 2252# has_function 2253config_host_data.set('CONFIG_CLOSE_RANGE', cc.has_function('close_range')) 2254config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4')) 2255config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime')) 2256config_host_data.set('CONFIG_DUP3', cc.has_function('dup3')) 2257config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate')) 2258config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate')) 2259# Note that we need to specify prefix: here to avoid incorrectly 2260# thinking that Windows has posix_memalign() 2261config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>')) 2262config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc')) 2263config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc')) 2264config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign')) 2265config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll')) 2266config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>')) 2267config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np')) 2268config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile')) 2269config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare')) 2270config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs')) 2271config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range')) 2272config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create')) 2273config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range')) 2274config_host_data.set('HAVE_GETIFADDRS', cc.has_function('getifaddrs')) 2275config_host_data.set('HAVE_GLIB_WITH_SLICE_ALLOCATOR', glib_has_gslice) 2276config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util)) 2277config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul')) 2278config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>')) 2279if rbd.found() 2280 config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS', 2281 cc.has_function('rbd_namespace_exists', 2282 dependencies: rbd, 2283 prefix: '#include <rbd/librbd.h>')) 2284endif 2285if rdma.found() 2286 config_host_data.set('HAVE_IBV_ADVISE_MR', 2287 cc.has_function('ibv_advise_mr', 2288 dependencies: rdma, 2289 prefix: '#include <infiniband/verbs.h>')) 2290endif 2291 2292have_asan_fiber = false 2293if get_option('sanitizers') and \ 2294 not cc.has_function('__sanitizer_start_switch_fiber', 2295 args: '-fsanitize=address', 2296 prefix: '#include <sanitizer/asan_interface.h>') 2297 warning('Missing ASAN due to missing fiber annotation interface') 2298 warning('Without code annotation, the report may be inferior.') 2299else 2300 have_asan_fiber = true 2301endif 2302config_host_data.set('CONFIG_ASAN_IFACE_FIBER', have_asan_fiber) 2303 2304# has_header_symbol 2305config_host_data.set('CONFIG_BLKZONED', 2306 cc.has_header_symbol('linux/blkzoned.h', 'BLKOPENZONE')) 2307config_host_data.set('CONFIG_EPOLL_CREATE1', 2308 cc.has_header_symbol('sys/epoll.h', 'epoll_create1')) 2309config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE', 2310 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and 2311 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE')) 2312config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE', 2313 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE')) 2314config_host_data.set('CONFIG_FIEMAP', 2315 cc.has_header('linux/fiemap.h') and 2316 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP')) 2317config_host_data.set('CONFIG_GETRANDOM', 2318 cc.has_function('getrandom') and 2319 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK')) 2320config_host_data.set('CONFIG_INOTIFY', 2321 cc.has_header_symbol('sys/inotify.h', 'inotify_init')) 2322config_host_data.set('CONFIG_INOTIFY1', 2323 cc.has_header_symbol('sys/inotify.h', 'inotify_init1')) 2324config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK', 2325 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK')) 2326config_host_data.set('CONFIG_RTNETLINK', 2327 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN')) 2328config_host_data.set('CONFIG_SYSMACROS', 2329 cc.has_header_symbol('sys/sysmacros.h', 'makedev')) 2330config_host_data.set('HAVE_OPTRESET', 2331 cc.has_header_symbol('getopt.h', 'optreset')) 2332config_host_data.set('HAVE_IPPROTO_MPTCP', 2333 cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP')) 2334 2335# has_member 2336config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID', 2337 cc.has_member('struct sigevent', 'sigev_notify_thread_id', 2338 prefix: '#include <signal.h>')) 2339config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM', 2340 cc.has_member('struct stat', 'st_atim', 2341 prefix: '#include <sys/stat.h>')) 2342config_host_data.set('HAVE_BLK_ZONE_REP_CAPACITY', 2343 cc.has_member('struct blk_zone', 'capacity', 2344 prefix: '#include <linux/blkzoned.h>')) 2345 2346# has_type 2347config_host_data.set('CONFIG_IOVEC', 2348 cc.has_type('struct iovec', 2349 prefix: '#include <sys/uio.h>')) 2350config_host_data.set('HAVE_UTMPX', 2351 cc.has_type('struct utmpx', 2352 prefix: '#include <utmpx.h>')) 2353 2354config_host_data.set('CONFIG_EVENTFD', cc.links(''' 2355 #include <sys/eventfd.h> 2356 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }''')) 2357config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + ''' 2358 #include <unistd.h> 2359 int main(void) { 2360 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0 2361 return fdatasync(0); 2362 #else 2363 #error Not supported 2364 #endif 2365 }''')) 2366 2367has_madvise = cc.links(gnu_source_prefix + ''' 2368 #include <sys/types.h> 2369 #include <sys/mman.h> 2370 #include <stddef.h> 2371 int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''') 2372missing_madvise_proto = false 2373if has_madvise 2374 # Some platforms (illumos and Solaris before Solaris 11) provide madvise() 2375 # but forget to prototype it. In this case, has_madvise will be true (the 2376 # test program links despite a compile warning). To detect the 2377 # missing-prototype case, we try again with a definitely-bogus prototype. 2378 # This will only compile if the system headers don't provide the prototype; 2379 # otherwise the conflicting prototypes will cause a compiler error. 2380 missing_madvise_proto = cc.links(gnu_source_prefix + ''' 2381 #include <sys/types.h> 2382 #include <sys/mman.h> 2383 #include <stddef.h> 2384 extern int madvise(int); 2385 int main(void) { return madvise(0); }''') 2386endif 2387config_host_data.set('CONFIG_MADVISE', has_madvise) 2388config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto) 2389 2390config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + ''' 2391 #include <sys/mman.h> 2392 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }''')) 2393config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + ''' 2394 #include <fcntl.h> 2395 #if !defined(AT_EMPTY_PATH) 2396 # error missing definition 2397 #else 2398 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); } 2399 #endif''')) 2400config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + ''' 2401 #include <sys/mman.h> 2402 #include <stddef.h> 2403 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }''')) 2404 2405config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + ''' 2406 #include <pthread.h> 2407 2408 static void *f(void *p) { return NULL; } 2409 int main(void) 2410 { 2411 pthread_t thread; 2412 pthread_create(&thread, 0, f, 0); 2413 pthread_setname_np(thread, "QEMU"); 2414 return 0; 2415 }''', dependencies: threads)) 2416config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + ''' 2417 #include <pthread.h> 2418 2419 static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; } 2420 int main(void) 2421 { 2422 pthread_t thread; 2423 pthread_create(&thread, 0, f, 0); 2424 return 0; 2425 }''', dependencies: threads)) 2426config_host_data.set('CONFIG_PTHREAD_SET_NAME_NP', cc.links(gnu_source_prefix + ''' 2427 #include <pthread.h> 2428 #include <pthread_np.h> 2429 2430 static void *f(void *p) { return NULL; } 2431 int main(void) 2432 { 2433 pthread_t thread; 2434 pthread_create(&thread, 0, f, 0); 2435 pthread_set_name_np(thread, "QEMU"); 2436 return 0; 2437 }''', dependencies: threads)) 2438config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + ''' 2439 #include <pthread.h> 2440 #include <time.h> 2441 2442 int main(void) 2443 { 2444 pthread_condattr_t attr 2445 pthread_condattr_init(&attr); 2446 pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); 2447 return 0; 2448 }''', dependencies: threads)) 2449config_host_data.set('CONFIG_PTHREAD_AFFINITY_NP', cc.links(gnu_source_prefix + ''' 2450 #include <pthread.h> 2451 2452 static void *f(void *p) { return NULL; } 2453 int main(void) 2454 { 2455 int setsize = CPU_ALLOC_SIZE(64); 2456 pthread_t thread; 2457 cpu_set_t *cpuset; 2458 pthread_create(&thread, 0, f, 0); 2459 cpuset = CPU_ALLOC(64); 2460 CPU_ZERO_S(setsize, cpuset); 2461 pthread_setaffinity_np(thread, setsize, cpuset); 2462 pthread_getaffinity_np(thread, setsize, cpuset); 2463 CPU_FREE(cpuset); 2464 return 0; 2465 }''', dependencies: threads)) 2466config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + ''' 2467 #include <sys/signalfd.h> 2468 #include <stddef.h> 2469 int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }''')) 2470config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + ''' 2471 #include <unistd.h> 2472 #include <fcntl.h> 2473 #include <limits.h> 2474 2475 int main(void) 2476 { 2477 int len, fd = 0; 2478 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK); 2479 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE); 2480 return 0; 2481 }''')) 2482 2483config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + ''' 2484 #include <sys/mman.h> 2485 int main(void) { 2486 return mlockall(MCL_FUTURE); 2487 }''')) 2488 2489have_l2tpv3 = false 2490if get_option('l2tpv3').allowed() and have_system 2491 have_l2tpv3 = cc.has_type('struct mmsghdr', 2492 prefix: gnu_source_prefix + ''' 2493 #include <sys/socket.h> 2494 #include <linux/ip.h>''') 2495endif 2496config_host_data.set('CONFIG_L2TPV3', have_l2tpv3) 2497 2498have_netmap = false 2499if get_option('netmap').allowed() and have_system 2500 have_netmap = cc.compiles(''' 2501 #include <inttypes.h> 2502 #include <net/if.h> 2503 #include <net/netmap.h> 2504 #include <net/netmap_user.h> 2505 #if (NETMAP_API < 11) || (NETMAP_API > 15) 2506 #error 2507 #endif 2508 int main(void) { return 0; }''') 2509 if not have_netmap and get_option('netmap').enabled() 2510 error('Netmap headers not available') 2511 endif 2512endif 2513config_host_data.set('CONFIG_NETMAP', have_netmap) 2514 2515# Work around a system header bug with some kernel/XFS header 2516# versions where they both try to define 'struct fsxattr': 2517# xfs headers will not try to redefine structs from linux headers 2518# if this macro is set. 2519config_host_data.set('HAVE_FSXATTR', cc.links(''' 2520 #include <linux/fs.h> 2521 struct fsxattr foo; 2522 int main(void) { 2523 return 0; 2524 }''')) 2525 2526# Some versions of Mac OS X incorrectly define SIZE_MAX 2527config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles(''' 2528 #include <stdint.h> 2529 #include <stdio.h> 2530 int main(void) { 2531 return printf("%zu", SIZE_MAX); 2532 }''', args: ['-Werror'])) 2533 2534# See if 64-bit atomic operations are supported. 2535# Note that without __atomic builtins, we can only 2536# assume atomic loads/stores max at pointer size. 2537config_host_data.set('CONFIG_ATOMIC64', cc.links(''' 2538 #include <stdint.h> 2539 int main(void) 2540 { 2541 uint64_t x = 0, y = 0; 2542 y = __atomic_load_n(&x, __ATOMIC_RELAXED); 2543 __atomic_store_n(&x, y, __ATOMIC_RELAXED); 2544 __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED); 2545 __atomic_exchange_n(&x, y, __ATOMIC_RELAXED); 2546 __atomic_fetch_add(&x, y, __ATOMIC_RELAXED); 2547 return 0; 2548 }''')) 2549 2550has_int128_type = cc.compiles(''' 2551 __int128_t a; 2552 __uint128_t b; 2553 int main(void) { b = a; }''') 2554config_host_data.set('CONFIG_INT128_TYPE', has_int128_type) 2555 2556has_int128 = has_int128_type and cc.links(''' 2557 __int128_t a; 2558 __uint128_t b; 2559 int main (void) { 2560 a = a + b; 2561 b = a * b; 2562 a = a * a; 2563 return 0; 2564 }''') 2565config_host_data.set('CONFIG_INT128', has_int128) 2566 2567if has_int128_type 2568 # "do we have 128-bit atomics which are handled inline and specifically not 2569 # via libatomic". The reason we can't use libatomic is documented in the 2570 # comment starting "GCC is a house divided" in include/qemu/atomic128.h. 2571 # We only care about these operations on 16-byte aligned pointers, so 2572 # force 16-byte alignment of the pointer, which may be greater than 2573 # __alignof(unsigned __int128) for the host. 2574 atomic_test_128 = ''' 2575 int main(int ac, char **av) { 2576 __uint128_t *p = __builtin_assume_aligned(av[ac - 1], 16); 2577 p[1] = __atomic_load_n(&p[0], __ATOMIC_RELAXED); 2578 __atomic_store_n(&p[2], p[3], __ATOMIC_RELAXED); 2579 __atomic_compare_exchange_n(&p[4], &p[5], p[6], 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED); 2580 return 0; 2581 }''' 2582 has_atomic128 = cc.links(atomic_test_128) 2583 2584 config_host_data.set('CONFIG_ATOMIC128', has_atomic128) 2585 2586 if not has_atomic128 2587 # Even with __builtin_assume_aligned, the above test may have failed 2588 # without optimization enabled. Try again with optimizations locally 2589 # enabled for the function. See 2590 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107389 2591 has_atomic128_opt = cc.links('__attribute__((optimize("O1")))' + atomic_test_128) 2592 config_host_data.set('CONFIG_ATOMIC128_OPT', has_atomic128_opt) 2593 2594 if not has_atomic128_opt 2595 config_host_data.set('CONFIG_CMPXCHG128', cc.links(''' 2596 int main(void) 2597 { 2598 __uint128_t x = 0, y = 0; 2599 __sync_val_compare_and_swap_16(&x, y, x); 2600 return 0; 2601 } 2602 ''')) 2603 endif 2604 endif 2605endif 2606 2607config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + ''' 2608 #include <sys/auxv.h> 2609 int main(void) { 2610 return getauxval(AT_HWCAP) == 0; 2611 }''')) 2612 2613config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles(''' 2614 #include <linux/usbdevice_fs.h> 2615 2616 #ifndef USBDEVFS_GET_CAPABILITIES 2617 #error "USBDEVFS_GET_CAPABILITIES undefined" 2618 #endif 2619 2620 #ifndef USBDEVFS_DISCONNECT_CLAIM 2621 #error "USBDEVFS_DISCONNECT_CLAIM undefined" 2622 #endif 2623 2624 int main(void) { return 0; }''')) 2625 2626have_keyring = get_option('keyring') \ 2627 .require(targetos == 'linux', error_message: 'keyring is only available on Linux') \ 2628 .require(cc.compiles(''' 2629 #include <errno.h> 2630 #include <asm/unistd.h> 2631 #include <linux/keyctl.h> 2632 #include <sys/syscall.h> 2633 #include <unistd.h> 2634 int main(void) { 2635 return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0); 2636 }'''), error_message: 'keyctl syscall not available on this system').allowed() 2637config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring) 2638 2639have_cpuid_h = cc.links(''' 2640 #include <cpuid.h> 2641 int main(void) { 2642 unsigned a, b, c, d; 2643 unsigned max = __get_cpuid_max(0, 0); 2644 2645 if (max >= 1) { 2646 __cpuid(1, a, b, c, d); 2647 } 2648 2649 if (max >= 7) { 2650 __cpuid_count(7, 0, a, b, c, d); 2651 } 2652 2653 return 0; 2654 }''') 2655config_host_data.set('CONFIG_CPUID_H', have_cpuid_h) 2656 2657config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \ 2658 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \ 2659 .require(cc.links(''' 2660 #include <cpuid.h> 2661 #include <immintrin.h> 2662 static int __attribute__((target("avx2"))) bar(void *a) { 2663 __m256i x = *(__m256i *)a; 2664 return _mm256_testz_si256(x, x); 2665 } 2666 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); } 2667 '''), error_message: 'AVX2 not available').allowed()) 2668 2669config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \ 2670 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \ 2671 .require(cc.links(''' 2672 #include <cpuid.h> 2673 #include <immintrin.h> 2674 static int __attribute__((target("avx512f"))) bar(void *a) { 2675 __m512i x = *(__m512i *)a; 2676 return _mm512_test_epi64_mask(x, x); 2677 } 2678 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); } 2679 '''), error_message: 'AVX512F not available').allowed()) 2680 2681config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \ 2682 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \ 2683 .require(cc.links(''' 2684 #include <cpuid.h> 2685 #include <immintrin.h> 2686 static int __attribute__((target("avx512bw"))) bar(void *a) { 2687 __m512i *x = a; 2688 __m512i res= _mm512_abs_epi8(*x); 2689 return res[1]; 2690 } 2691 int main(int argc, char *argv[]) { return bar(argv[0]); } 2692 '''), error_message: 'AVX512BW not available').allowed()) 2693 2694have_pvrdma = get_option('pvrdma') \ 2695 .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \ 2696 .require(cc.compiles(gnu_source_prefix + ''' 2697 #include <sys/mman.h> 2698 int main(void) 2699 { 2700 char buf = 0; 2701 void *addr = &buf; 2702 addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED); 2703 2704 return 0; 2705 }'''), error_message: 'PVRDMA requires mremap').allowed() 2706 2707if have_pvrdma 2708 config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links(''' 2709 #include <infiniband/verbs.h> 2710 int main(void) 2711 { 2712 struct ibv_mr *mr; 2713 struct ibv_pd *pd = NULL; 2714 size_t length = 10; 2715 uint64_t iova = 0; 2716 int access = 0; 2717 void *addr = NULL; 2718 2719 mr = ibv_reg_mr_iova(pd, addr, length, iova, access); 2720 ibv_dereg_mr(mr); 2721 return 0; 2722 }''')) 2723endif 2724 2725if get_option('membarrier').disabled() 2726 have_membarrier = false 2727elif targetos == 'windows' 2728 have_membarrier = true 2729elif targetos == 'linux' 2730 have_membarrier = cc.compiles(''' 2731 #include <linux/membarrier.h> 2732 #include <sys/syscall.h> 2733 #include <unistd.h> 2734 #include <stdlib.h> 2735 int main(void) { 2736 syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0); 2737 syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0); 2738 exit(0); 2739 }''') 2740endif 2741config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \ 2742 .require(have_membarrier, error_message: 'membarrier system call not available') \ 2743 .allowed()) 2744 2745have_afalg = get_option('crypto_afalg') \ 2746 .require(cc.compiles(gnu_source_prefix + ''' 2747 #include <errno.h> 2748 #include <sys/types.h> 2749 #include <sys/socket.h> 2750 #include <linux/if_alg.h> 2751 int main(void) { 2752 int sock; 2753 sock = socket(AF_ALG, SOCK_SEQPACKET, 0); 2754 return sock; 2755 } 2756 '''), error_message: 'AF_ALG requested but could not be detected').allowed() 2757config_host_data.set('CONFIG_AF_ALG', have_afalg) 2758 2759config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol( 2760 'linux/vm_sockets.h', 'AF_VSOCK', 2761 prefix: '#include <sys/socket.h>', 2762)) 2763 2764have_vss = false 2765have_vss_sdk = false # old xp/2003 SDK 2766if targetos == 'windows' and link_language == 'cpp' 2767 have_vss = cxx.compiles(''' 2768 #define __MIDL_user_allocate_free_DEFINED__ 2769 #include <vss.h> 2770 int main(void) { return VSS_CTX_BACKUP; }''') 2771 have_vss_sdk = cxx.has_header('vscoordint.h') 2772endif 2773config_host_data.set('HAVE_VSS_SDK', have_vss_sdk) 2774 2775foreach k, v: config_host 2776 if k.startswith('CONFIG_') 2777 config_host_data.set(k, v == 'y' ? 1 : v) 2778 endif 2779endforeach 2780 2781# Older versions of MinGW do not import _lock_file and _unlock_file properly. 2782# This was fixed for v6.0.0 with commit b48e3ac8969d. 2783if targetos == 'windows' 2784 config_host_data.set('HAVE__LOCK_FILE', cc.links(''' 2785 #include <stdio.h> 2786 int main(void) { 2787 _lock_file(NULL); 2788 _unlock_file(NULL); 2789 return 0; 2790 }''', name: '_lock_file and _unlock_file')) 2791endif 2792 2793if targetos == 'windows' 2794 mingw_has_setjmp_longjmp = cc.links(''' 2795 #include <setjmp.h> 2796 int main(void) { 2797 /* 2798 * These functions are not available in setjmp header, but may be 2799 * available at link time, from libmingwex.a. 2800 */ 2801 extern int __mingw_setjmp(jmp_buf); 2802 extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int); 2803 jmp_buf env; 2804 __mingw_setjmp(env); 2805 __mingw_longjmp(env, 0); 2806 } 2807 ''', name: 'mingw setjmp and longjmp') 2808 2809 if cpu == 'aarch64' and not mingw_has_setjmp_longjmp 2810 error('mingw must provide setjmp/longjmp for windows-arm64') 2811 endif 2812endif 2813 2814######################## 2815# Target configuration # 2816######################## 2817 2818minikconf = find_program('scripts/minikconf.py') 2819config_all = {} 2820config_all_devices = {} 2821config_all_disas = {} 2822config_devices_mak_list = [] 2823config_devices_h = {} 2824config_target_h = {} 2825config_target_mak = {} 2826 2827disassemblers = { 2828 'alpha' : ['CONFIG_ALPHA_DIS'], 2829 'avr' : ['CONFIG_AVR_DIS'], 2830 'cris' : ['CONFIG_CRIS_DIS'], 2831 'hexagon' : ['CONFIG_HEXAGON_DIS'], 2832 'hppa' : ['CONFIG_HPPA_DIS'], 2833 'i386' : ['CONFIG_I386_DIS'], 2834 'x86_64' : ['CONFIG_I386_DIS'], 2835 'm68k' : ['CONFIG_M68K_DIS'], 2836 'microblaze' : ['CONFIG_MICROBLAZE_DIS'], 2837 'mips' : ['CONFIG_MIPS_DIS'], 2838 'nios2' : ['CONFIG_NIOS2_DIS'], 2839 'or1k' : ['CONFIG_OPENRISC_DIS'], 2840 'ppc' : ['CONFIG_PPC_DIS'], 2841 'riscv' : ['CONFIG_RISCV_DIS'], 2842 'rx' : ['CONFIG_RX_DIS'], 2843 's390' : ['CONFIG_S390_DIS'], 2844 'sh4' : ['CONFIG_SH4_DIS'], 2845 'sparc' : ['CONFIG_SPARC_DIS'], 2846 'xtensa' : ['CONFIG_XTENSA_DIS'], 2847 'loongarch' : ['CONFIG_LOONGARCH_DIS'], 2848} 2849 2850have_ivshmem = config_host_data.get('CONFIG_EVENTFD') 2851host_kconfig = \ 2852 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \ 2853 (have_tpm ? ['CONFIG_TPM=y'] : []) + \ 2854 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \ 2855 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \ 2856 (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \ 2857 (x11.found() ? ['CONFIG_X11=y'] : []) + \ 2858 (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \ 2859 (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \ 2860 (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \ 2861 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \ 2862 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \ 2863 (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \ 2864 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \ 2865 (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : []) 2866 2867ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ] 2868 2869default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host 2870actual_target_dirs = [] 2871fdt_required = [] 2872foreach target : target_dirs 2873 config_target = { 'TARGET_NAME': target.split('-')[0] } 2874 if target.endswith('linux-user') 2875 if targetos != 'linux' 2876 if default_targets 2877 continue 2878 endif 2879 error('Target @0@ is only available on a Linux host'.format(target)) 2880 endif 2881 config_target += { 'CONFIG_LINUX_USER': 'y' } 2882 elif target.endswith('bsd-user') 2883 if 'CONFIG_BSD' not in config_host 2884 if default_targets 2885 continue 2886 endif 2887 error('Target @0@ is only available on a BSD host'.format(target)) 2888 endif 2889 config_target += { 'CONFIG_BSD_USER': 'y' } 2890 elif target.endswith('softmmu') 2891 config_target += { 'CONFIG_SOFTMMU': 'y' } 2892 endif 2893 if target.endswith('-user') 2894 config_target += { 2895 'CONFIG_USER_ONLY': 'y', 2896 'CONFIG_QEMU_INTERP_PREFIX': 2897 get_option('interp_prefix').replace('%M', config_target['TARGET_NAME']) 2898 } 2899 endif 2900 2901 accel_kconfig = [] 2902 foreach sym: accelerators 2903 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, []) 2904 config_target += { sym: 'y' } 2905 config_all += { sym: 'y' } 2906 if target in modular_tcg 2907 config_target += { 'CONFIG_TCG_MODULAR': 'y' } 2908 else 2909 config_target += { 'CONFIG_TCG_BUILTIN': 'y' } 2910 endif 2911 accel_kconfig += [ sym + '=y' ] 2912 endif 2913 endforeach 2914 if accel_kconfig.length() == 0 2915 if default_targets 2916 continue 2917 endif 2918 error('No accelerator available for target @0@'.format(target)) 2919 endif 2920 2921 actual_target_dirs += target 2922 config_target += keyval.load('configs/targets' / target + '.mak') 2923 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' } 2924 2925 if 'TARGET_NEED_FDT' in config_target 2926 fdt_required += target 2927 endif 2928 2929 # Add default keys 2930 if 'TARGET_BASE_ARCH' not in config_target 2931 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']} 2932 endif 2933 if 'TARGET_ABI_DIR' not in config_target 2934 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']} 2935 endif 2936 if 'TARGET_BIG_ENDIAN' not in config_target 2937 config_target += {'TARGET_BIG_ENDIAN': 'n'} 2938 endif 2939 2940 foreach k, v: disassemblers 2941 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k) 2942 foreach sym: v 2943 config_target += { sym: 'y' } 2944 config_all_disas += { sym: 'y' } 2945 endforeach 2946 endif 2947 endforeach 2948 2949 config_target_data = configuration_data() 2950 foreach k, v: config_target 2951 if not k.startswith('TARGET_') and not k.startswith('CONFIG_') 2952 # do nothing 2953 elif ignored.contains(k) 2954 # do nothing 2955 elif k == 'TARGET_BASE_ARCH' 2956 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is 2957 # not used to select files from sourcesets. 2958 config_target_data.set('TARGET_' + v.to_upper(), 1) 2959 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX' 2960 config_target_data.set_quoted(k, v) 2961 elif v == 'y' 2962 config_target_data.set(k, 1) 2963 elif v == 'n' 2964 config_target_data.set(k, 0) 2965 else 2966 config_target_data.set(k, v) 2967 endif 2968 endforeach 2969 config_target_data.set('QEMU_ARCH', 2970 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper()) 2971 config_target_h += {target: configure_file(output: target + '-config-target.h', 2972 configuration: config_target_data)} 2973 2974 if target.endswith('-softmmu') 2975 config_input = meson.get_external_property(target, 'default') 2976 config_devices_mak = target + '-config-devices.mak' 2977 config_devices_mak = configure_file( 2978 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'], 2979 output: config_devices_mak, 2980 depfile: config_devices_mak + '.d', 2981 capture: true, 2982 command: [minikconf, 2983 get_option('default_devices') ? '--defconfig' : '--allnoconfig', 2984 config_devices_mak, '@DEPFILE@', '@INPUT@', 2985 host_kconfig, accel_kconfig, 2986 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y']) 2987 2988 config_devices_data = configuration_data() 2989 config_devices = keyval.load(config_devices_mak) 2990 foreach k, v: config_devices 2991 config_devices_data.set(k, 1) 2992 endforeach 2993 config_devices_mak_list += config_devices_mak 2994 config_devices_h += {target: configure_file(output: target + '-config-devices.h', 2995 configuration: config_devices_data)} 2996 config_target += config_devices 2997 config_all_devices += config_devices 2998 endif 2999 config_target_mak += {target: config_target} 3000endforeach 3001target_dirs = actual_target_dirs 3002 3003# This configuration is used to build files that are shared by 3004# multiple binaries, and then extracted out of the "common" 3005# static_library target. 3006# 3007# We do not use all_sources()/all_dependencies(), because it would 3008# build literally all source files, including devices only used by 3009# targets that are not built for this compilation. The CONFIG_ALL 3010# pseudo symbol replaces it. 3011 3012config_all += config_all_devices 3013config_all += config_host 3014config_all += config_all_disas 3015config_all += { 3016 'CONFIG_XEN': xen.found(), 3017 'CONFIG_SOFTMMU': have_system, 3018 'CONFIG_USER_ONLY': have_user, 3019 'CONFIG_ALL': true, 3020} 3021 3022target_configs_h = [] 3023foreach target: target_dirs 3024 target_configs_h += config_target_h[target] 3025 target_configs_h += config_devices_h.get(target, []) 3026endforeach 3027genh += custom_target('config-poison.h', 3028 input: [target_configs_h], 3029 output: 'config-poison.h', 3030 capture: true, 3031 command: [find_program('scripts/make-config-poison.sh'), 3032 target_configs_h]) 3033 3034############## 3035# Submodules # 3036############## 3037 3038capstone = not_found 3039if not get_option('capstone').auto() or have_system or have_user 3040 capstone = dependency('capstone', version: '>=3.0.5', 3041 method: 'pkg-config', 3042 required: get_option('capstone')) 3043 3044 # Some versions of capstone have broken pkg-config file 3045 # that reports a wrong -I path, causing the #include to 3046 # fail later. If the system has such a broken version 3047 # do not use it. 3048 if capstone.found() and not cc.compiles('#include <capstone.h>', 3049 dependencies: [capstone]) 3050 capstone = not_found 3051 if get_option('capstone').enabled() 3052 error('capstone requested, but it does not appear to work') 3053 endif 3054 endif 3055endif 3056 3057libvfio_user_dep = not_found 3058if have_system and vfio_user_server_allowed 3059 have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build') 3060 3061 if not have_internal 3062 error('libvfio-user source not found - please pull git submodule') 3063 endif 3064 3065 libvfio_user_proj = subproject('libvfio-user') 3066 3067 libvfio_user_dep = libvfio_user_proj.get_variable('libvfio_user_dep') 3068endif 3069 3070fdt = not_found 3071fdt_opt = get_option('fdt') 3072if fdt_required.length() > 0 or fdt_opt == 'enabled' 3073 if fdt_opt == 'disabled' 3074 error('fdt disabled but required by targets ' + ', '.join(fdt_required)) 3075 endif 3076 3077 if fdt_opt in ['enabled', 'auto', 'system'] 3078 fdt = cc.find_library('fdt', required: fdt_opt == 'system') 3079 if fdt.found() and cc.links(''' 3080 #include <libfdt.h> 3081 #include <libfdt_env.h> 3082 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''', 3083 dependencies: fdt) 3084 fdt_opt = 'system' 3085 elif fdt_opt == 'system' 3086 error('system libfdt requested, but it is too old (1.5.1 or newer required)') 3087 else 3088 fdt_opt = 'internal' 3089 fdt = not_found 3090 endif 3091 endif 3092 if not fdt.found() 3093 assert(fdt_opt == 'internal') 3094 have_internal = fs.exists(meson.current_source_dir() / 'subprojects/dtc/meson.build') 3095 3096 if not have_internal 3097 error('libfdt source not found - please pull git submodule') 3098 endif 3099 3100 libfdt_proj = subproject('dtc', required: true, 3101 default_options: ['tools=false', 'yaml=disabled', 3102 'python=disabled', 'default_library=static']) 3103 fdt = libfdt_proj.get_variable('libfdt_dep') 3104 endif 3105else 3106 fdt_opt = 'disabled' 3107endif 3108 3109config_host_data.set('CONFIG_CAPSTONE', capstone.found()) 3110config_host_data.set('CONFIG_FDT', fdt.found()) 3111config_host_data.set('CONFIG_SLIRP', slirp.found()) 3112 3113##################### 3114# Generated sources # 3115##################### 3116 3117genh += configure_file(output: 'config-host.h', configuration: config_host_data) 3118 3119hxtool = find_program('scripts/hxtool') 3120shaderinclude = find_program('scripts/shaderinclude.py') 3121qapi_gen = find_program('scripts/qapi-gen.py') 3122qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py', 3123 meson.current_source_dir() / 'scripts/qapi/commands.py', 3124 meson.current_source_dir() / 'scripts/qapi/common.py', 3125 meson.current_source_dir() / 'scripts/qapi/error.py', 3126 meson.current_source_dir() / 'scripts/qapi/events.py', 3127 meson.current_source_dir() / 'scripts/qapi/expr.py', 3128 meson.current_source_dir() / 'scripts/qapi/gen.py', 3129 meson.current_source_dir() / 'scripts/qapi/introspect.py', 3130 meson.current_source_dir() / 'scripts/qapi/main.py', 3131 meson.current_source_dir() / 'scripts/qapi/parser.py', 3132 meson.current_source_dir() / 'scripts/qapi/schema.py', 3133 meson.current_source_dir() / 'scripts/qapi/source.py', 3134 meson.current_source_dir() / 'scripts/qapi/types.py', 3135 meson.current_source_dir() / 'scripts/qapi/visit.py', 3136 meson.current_source_dir() / 'scripts/qapi-gen.py' 3137] 3138 3139tracetool = [ 3140 python, files('scripts/tracetool.py'), 3141 '--backend=' + ','.join(get_option('trace_backends')) 3142] 3143tracetool_depends = files( 3144 'scripts/tracetool/backend/log.py', 3145 'scripts/tracetool/backend/__init__.py', 3146 'scripts/tracetool/backend/dtrace.py', 3147 'scripts/tracetool/backend/ftrace.py', 3148 'scripts/tracetool/backend/simple.py', 3149 'scripts/tracetool/backend/syslog.py', 3150 'scripts/tracetool/backend/ust.py', 3151 'scripts/tracetool/format/ust_events_c.py', 3152 'scripts/tracetool/format/ust_events_h.py', 3153 'scripts/tracetool/format/__init__.py', 3154 'scripts/tracetool/format/d.py', 3155 'scripts/tracetool/format/simpletrace_stap.py', 3156 'scripts/tracetool/format/c.py', 3157 'scripts/tracetool/format/h.py', 3158 'scripts/tracetool/format/log_stap.py', 3159 'scripts/tracetool/format/stap.py', 3160 'scripts/tracetool/__init__.py', 3161 'scripts/tracetool/vcpu.py' 3162) 3163 3164qemu_version_cmd = [find_program('scripts/qemu-version.sh'), 3165 meson.current_source_dir(), 3166 get_option('pkgversion'), meson.project_version()] 3167qemu_version = custom_target('qemu-version.h', 3168 output: 'qemu-version.h', 3169 command: qemu_version_cmd, 3170 capture: true, 3171 build_by_default: true, 3172 build_always_stale: true) 3173genh += qemu_version 3174 3175hxdep = [] 3176hx_headers = [ 3177 ['qemu-options.hx', 'qemu-options.def'], 3178 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'], 3179] 3180if have_system 3181 hx_headers += [ 3182 ['hmp-commands.hx', 'hmp-commands.h'], 3183 ['hmp-commands-info.hx', 'hmp-commands-info.h'], 3184 ] 3185endif 3186foreach d : hx_headers 3187 hxdep += custom_target(d[1], 3188 input: files(d[0]), 3189 output: d[1], 3190 capture: true, 3191 build_by_default: true, # to be removed when added to a target 3192 command: [hxtool, '-h', '@INPUT0@']) 3193endforeach 3194genh += hxdep 3195 3196################### 3197# Collect sources # 3198################### 3199 3200authz_ss = ss.source_set() 3201blockdev_ss = ss.source_set() 3202block_ss = ss.source_set() 3203chardev_ss = ss.source_set() 3204common_ss = ss.source_set() 3205crypto_ss = ss.source_set() 3206hwcore_ss = ss.source_set() 3207io_ss = ss.source_set() 3208qmp_ss = ss.source_set() 3209qom_ss = ss.source_set() 3210softmmu_ss = ss.source_set() 3211specific_fuzz_ss = ss.source_set() 3212specific_ss = ss.source_set() 3213stub_ss = ss.source_set() 3214trace_ss = ss.source_set() 3215user_ss = ss.source_set() 3216util_ss = ss.source_set() 3217 3218# accel modules 3219qtest_module_ss = ss.source_set() 3220tcg_module_ss = ss.source_set() 3221 3222modules = {} 3223target_modules = {} 3224hw_arch = {} 3225target_arch = {} 3226target_softmmu_arch = {} 3227target_user_arch = {} 3228 3229############### 3230# Trace files # 3231############### 3232 3233# TODO: add each directory to the subdirs from its own meson.build, once 3234# we have those 3235trace_events_subdirs = [ 3236 'crypto', 3237 'qapi', 3238 'qom', 3239 'monitor', 3240 'util', 3241 'gdbstub', 3242] 3243if have_linux_user 3244 trace_events_subdirs += [ 'linux-user' ] 3245endif 3246if have_bsd_user 3247 trace_events_subdirs += [ 'bsd-user' ] 3248endif 3249if have_block 3250 trace_events_subdirs += [ 3251 'authz', 3252 'block', 3253 'io', 3254 'nbd', 3255 'scsi', 3256 ] 3257endif 3258if have_system 3259 trace_events_subdirs += [ 3260 'accel/kvm', 3261 'audio', 3262 'backends', 3263 'backends/tpm', 3264 'chardev', 3265 'ebpf', 3266 'hw/9pfs', 3267 'hw/acpi', 3268 'hw/adc', 3269 'hw/alpha', 3270 'hw/arm', 3271 'hw/audio', 3272 'hw/block', 3273 'hw/block/dataplane', 3274 'hw/char', 3275 'hw/display', 3276 'hw/dma', 3277 'hw/hyperv', 3278 'hw/i2c', 3279 'hw/i386', 3280 'hw/i386/xen', 3281 'hw/i386/kvm', 3282 'hw/ide', 3283 'hw/input', 3284 'hw/intc', 3285 'hw/isa', 3286 'hw/mem', 3287 'hw/mips', 3288 'hw/misc', 3289 'hw/misc/macio', 3290 'hw/net', 3291 'hw/net/can', 3292 'hw/nubus', 3293 'hw/nvme', 3294 'hw/nvram', 3295 'hw/pci', 3296 'hw/pci-host', 3297 'hw/ppc', 3298 'hw/rdma', 3299 'hw/rdma/vmw', 3300 'hw/rtc', 3301 'hw/s390x', 3302 'hw/scsi', 3303 'hw/sd', 3304 'hw/sh4', 3305 'hw/sparc', 3306 'hw/sparc64', 3307 'hw/ssi', 3308 'hw/timer', 3309 'hw/tpm', 3310 'hw/usb', 3311 'hw/vfio', 3312 'hw/virtio', 3313 'hw/watchdog', 3314 'hw/xen', 3315 'hw/gpio', 3316 'migration', 3317 'net', 3318 'softmmu', 3319 'ui', 3320 'hw/remote', 3321 ] 3322endif 3323if have_system or have_user 3324 trace_events_subdirs += [ 3325 'accel/tcg', 3326 'hw/core', 3327 'target/arm', 3328 'target/arm/hvf', 3329 'target/hppa', 3330 'target/i386', 3331 'target/i386/kvm', 3332 'target/mips/tcg', 3333 'target/nios2', 3334 'target/ppc', 3335 'target/riscv', 3336 'target/s390x', 3337 'target/s390x/kvm', 3338 'target/sparc', 3339 ] 3340endif 3341 3342vhost_user = not_found 3343if targetos == 'linux' and have_vhost_user 3344 libvhost_user = subproject('libvhost-user') 3345 vhost_user = libvhost_user.get_variable('vhost_user_dep') 3346endif 3347 3348libvduse = not_found 3349if have_libvduse 3350 libvduse_proj = subproject('libvduse') 3351 libvduse = libvduse_proj.get_variable('libvduse_dep') 3352endif 3353 3354# NOTE: the trace/ subdirectory needs the qapi_trace_events variable 3355# that is filled in by qapi/. 3356subdir('qapi') 3357subdir('qobject') 3358subdir('stubs') 3359subdir('trace') 3360subdir('util') 3361subdir('qom') 3362subdir('authz') 3363subdir('crypto') 3364subdir('ui') 3365subdir('hw') 3366subdir('gdbstub') 3367 3368if enable_modules 3369 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO') 3370 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO') 3371endif 3372 3373qom_ss = qom_ss.apply(config_host, strict: false) 3374libqom = static_library('qom', qom_ss.sources() + genh, 3375 dependencies: [qom_ss.dependencies()], 3376 name_suffix: 'fa') 3377qom = declare_dependency(link_whole: libqom) 3378 3379event_loop_base = files('event-loop-base.c') 3380event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh, 3381 build_by_default: true) 3382event_loop_base = declare_dependency(link_whole: event_loop_base, 3383 dependencies: [qom]) 3384 3385stub_ss = stub_ss.apply(config_all, strict: false) 3386 3387util_ss.add_all(trace_ss) 3388util_ss = util_ss.apply(config_all, strict: false) 3389libqemuutil = static_library('qemuutil', 3390 sources: util_ss.sources() + stub_ss.sources() + genh, 3391 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman]) 3392qemuutil = declare_dependency(link_with: libqemuutil, 3393 sources: genh + version_res, 3394 dependencies: [event_loop_base]) 3395 3396if have_system or have_user 3397 decodetree = generator(find_program('scripts/decodetree.py'), 3398 output: 'decode-@BASENAME@.c.inc', 3399 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@']) 3400 subdir('libdecnumber') 3401 subdir('target') 3402endif 3403 3404subdir('audio') 3405subdir('io') 3406subdir('chardev') 3407subdir('fsdev') 3408subdir('dump') 3409 3410if have_block 3411 block_ss.add(files( 3412 'block.c', 3413 'blockjob.c', 3414 'job.c', 3415 'qemu-io-cmds.c', 3416 )) 3417 if config_host_data.get('CONFIG_REPLICATION') 3418 block_ss.add(files('replication.c')) 3419 endif 3420 3421 subdir('nbd') 3422 subdir('scsi') 3423 subdir('block') 3424 3425 blockdev_ss.add(files( 3426 'blockdev.c', 3427 'blockdev-nbd.c', 3428 'iothread.c', 3429 'job-qmp.c', 3430 ), gnutls) 3431 3432 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon, 3433 # os-win32.c does not 3434 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c')) 3435 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')]) 3436endif 3437 3438common_ss.add(files('cpus-common.c')) 3439specific_ss.add(files('cpu.c')) 3440 3441subdir('softmmu') 3442 3443# Work around a gcc bug/misfeature wherein constant propagation looks 3444# through an alias: 3445# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696 3446# to guess that a const variable is always zero. Without lto, this is 3447# impossible, as the alias is restricted to page-vary-common.c. Indeed, 3448# without lto, not even the alias is required -- we simply use different 3449# declarations in different compilation units. 3450pagevary = files('page-vary-common.c') 3451if get_option('b_lto') 3452 pagevary_flags = ['-fno-lto'] 3453 if get_option('cfi') 3454 pagevary_flags += '-fno-sanitize=cfi-icall' 3455 endif 3456 pagevary = static_library('page-vary-common', sources: pagevary + genh, 3457 c_args: pagevary_flags) 3458 pagevary = declare_dependency(link_with: pagevary) 3459endif 3460common_ss.add(pagevary) 3461specific_ss.add(files('page-vary.c')) 3462 3463subdir('backends') 3464subdir('disas') 3465subdir('migration') 3466subdir('monitor') 3467subdir('net') 3468subdir('replay') 3469subdir('semihosting') 3470subdir('stats') 3471subdir('tcg') 3472subdir('fpu') 3473subdir('accel') 3474subdir('plugins') 3475subdir('ebpf') 3476 3477common_user_inc = [] 3478 3479subdir('common-user') 3480subdir('bsd-user') 3481subdir('linux-user') 3482 3483# needed for fuzzing binaries 3484subdir('tests/qtest/libqos') 3485subdir('tests/qtest/fuzz') 3486 3487# accel modules 3488tcg_real_module_ss = ss.source_set() 3489tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss) 3490specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss) 3491target_modules += { 'accel' : { 'qtest': qtest_module_ss, 3492 'tcg': tcg_real_module_ss }} 3493 3494######################## 3495# Library dependencies # 3496######################## 3497 3498modinfo_collect = find_program('scripts/modinfo-collect.py') 3499modinfo_generate = find_program('scripts/modinfo-generate.py') 3500modinfo_files = [] 3501 3502block_mods = [] 3503softmmu_mods = [] 3504foreach d, list : modules 3505 if not (d == 'block' ? have_block : have_system) 3506 continue 3507 endif 3508 3509 foreach m, module_ss : list 3510 if enable_modules 3511 module_ss = module_ss.apply(config_all, strict: false) 3512 sl = static_library(d + '-' + m, [genh, module_ss.sources()], 3513 dependencies: [modulecommon, module_ss.dependencies()], pic: true) 3514 if d == 'block' 3515 block_mods += sl 3516 else 3517 softmmu_mods += sl 3518 endif 3519 if module_ss.sources() != [] 3520 # FIXME: Should use sl.extract_all_objects(recursive: true) as 3521 # input. Sources can be used multiple times but objects are 3522 # unique when it comes to lookup in compile_commands.json. 3523 # Depnds on a mesion version with 3524 # https://github.com/mesonbuild/meson/pull/8900 3525 modinfo_files += custom_target(d + '-' + m + '.modinfo', 3526 output: d + '-' + m + '.modinfo', 3527 input: module_ss.sources() + genh, 3528 capture: true, 3529 command: [modinfo_collect, module_ss.sources()]) 3530 endif 3531 else 3532 if d == 'block' 3533 block_ss.add_all(module_ss) 3534 else 3535 softmmu_ss.add_all(module_ss) 3536 endif 3537 endif 3538 endforeach 3539endforeach 3540 3541foreach d, list : target_modules 3542 foreach m, module_ss : list 3543 if enable_modules 3544 foreach target : target_dirs 3545 if target.endswith('-softmmu') 3546 config_target = config_target_mak[target] 3547 config_target += config_host 3548 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])] 3549 c_args = ['-DNEED_CPU_H', 3550 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target), 3551 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)] 3552 target_module_ss = module_ss.apply(config_target, strict: false) 3553 if target_module_ss.sources() != [] 3554 module_name = d + '-' + m + '-' + config_target['TARGET_NAME'] 3555 sl = static_library(module_name, 3556 [genh, target_module_ss.sources()], 3557 dependencies: [modulecommon, target_module_ss.dependencies()], 3558 include_directories: target_inc, 3559 c_args: c_args, 3560 pic: true) 3561 softmmu_mods += sl 3562 # FIXME: Should use sl.extract_all_objects(recursive: true) too. 3563 modinfo_files += custom_target(module_name + '.modinfo', 3564 output: module_name + '.modinfo', 3565 input: target_module_ss.sources() + genh, 3566 capture: true, 3567 command: [modinfo_collect, '--target', target, target_module_ss.sources()]) 3568 endif 3569 endif 3570 endforeach 3571 else 3572 specific_ss.add_all(module_ss) 3573 endif 3574 endforeach 3575endforeach 3576 3577if enable_modules 3578 foreach target : target_dirs 3579 if target.endswith('-softmmu') 3580 config_target = config_target_mak[target] 3581 config_devices_mak = target + '-config-devices.mak' 3582 modinfo_src = custom_target('modinfo-' + target + '.c', 3583 output: 'modinfo-' + target + '.c', 3584 input: modinfo_files, 3585 command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'], 3586 capture: true) 3587 3588 modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src) 3589 modinfo_dep = declare_dependency(link_with: modinfo_lib) 3590 3591 arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH'] 3592 hw_arch[arch].add(modinfo_dep) 3593 endif 3594 endforeach 3595endif 3596 3597nm = find_program('nm') 3598undefsym = find_program('scripts/undefsym.py') 3599block_syms = custom_target('block.syms', output: 'block.syms', 3600 input: [libqemuutil, block_mods], 3601 capture: true, 3602 command: [undefsym, nm, '@INPUT@']) 3603qemu_syms = custom_target('qemu.syms', output: 'qemu.syms', 3604 input: [libqemuutil, softmmu_mods], 3605 capture: true, 3606 command: [undefsym, nm, '@INPUT@']) 3607 3608authz_ss = authz_ss.apply(config_host, strict: false) 3609libauthz = static_library('authz', authz_ss.sources() + genh, 3610 dependencies: [authz_ss.dependencies()], 3611 name_suffix: 'fa', 3612 build_by_default: false) 3613 3614authz = declare_dependency(link_whole: libauthz, 3615 dependencies: qom) 3616 3617crypto_ss = crypto_ss.apply(config_host, strict: false) 3618libcrypto = static_library('crypto', crypto_ss.sources() + genh, 3619 dependencies: [crypto_ss.dependencies()], 3620 name_suffix: 'fa', 3621 build_by_default: false) 3622 3623crypto = declare_dependency(link_whole: libcrypto, 3624 dependencies: [authz, qom]) 3625 3626io_ss = io_ss.apply(config_host, strict: false) 3627libio = static_library('io', io_ss.sources() + genh, 3628 dependencies: [io_ss.dependencies()], 3629 link_with: libqemuutil, 3630 name_suffix: 'fa', 3631 build_by_default: false) 3632 3633io = declare_dependency(link_whole: libio, dependencies: [crypto, qom]) 3634 3635libmigration = static_library('migration', sources: migration_files + genh, 3636 name_suffix: 'fa', 3637 build_by_default: false) 3638migration = declare_dependency(link_with: libmigration, 3639 dependencies: [zlib, qom, io]) 3640softmmu_ss.add(migration) 3641 3642block_ss = block_ss.apply(config_host, strict: false) 3643libblock = static_library('block', block_ss.sources() + genh, 3644 dependencies: block_ss.dependencies(), 3645 link_depends: block_syms, 3646 name_suffix: 'fa', 3647 build_by_default: false) 3648 3649block = declare_dependency(link_whole: [libblock], 3650 link_args: '@block.syms', 3651 dependencies: [crypto, io]) 3652 3653blockdev_ss = blockdev_ss.apply(config_host, strict: false) 3654libblockdev = static_library('blockdev', blockdev_ss.sources() + genh, 3655 dependencies: blockdev_ss.dependencies(), 3656 name_suffix: 'fa', 3657 build_by_default: false) 3658 3659blockdev = declare_dependency(link_whole: [libblockdev], 3660 dependencies: [block, event_loop_base]) 3661 3662qmp_ss = qmp_ss.apply(config_host, strict: false) 3663libqmp = static_library('qmp', qmp_ss.sources() + genh, 3664 dependencies: qmp_ss.dependencies(), 3665 name_suffix: 'fa', 3666 build_by_default: false) 3667 3668qmp = declare_dependency(link_whole: [libqmp]) 3669 3670libchardev = static_library('chardev', chardev_ss.sources() + genh, 3671 name_suffix: 'fa', 3672 dependencies: chardev_ss.dependencies(), 3673 build_by_default: false) 3674 3675chardev = declare_dependency(link_whole: libchardev) 3676 3677hwcore_ss = hwcore_ss.apply(config_host, strict: false) 3678libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh, 3679 name_suffix: 'fa', 3680 build_by_default: false) 3681hwcore = declare_dependency(link_whole: libhwcore) 3682common_ss.add(hwcore) 3683 3684########### 3685# Targets # 3686########### 3687 3688emulator_modules = [] 3689foreach m : block_mods + softmmu_mods 3690 emulator_modules += shared_module(m.name(), 3691 build_by_default: true, 3692 name_prefix: '', 3693 link_whole: m, 3694 install: true, 3695 install_dir: qemu_moddir) 3696endforeach 3697if emulator_modules.length() > 0 3698 alias_target('modules', emulator_modules) 3699endif 3700 3701softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp) 3702common_ss.add(qom, qemuutil) 3703 3704common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss]) 3705common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss) 3706 3707common_all = common_ss.apply(config_all, strict: false) 3708common_all = static_library('common', 3709 build_by_default: false, 3710 sources: common_all.sources() + genh, 3711 include_directories: common_user_inc, 3712 implicit_include_directories: false, 3713 dependencies: common_all.dependencies(), 3714 name_suffix: 'fa') 3715 3716feature_to_c = find_program('scripts/feature_to_c.sh') 3717 3718if targetos == 'darwin' 3719 entitlement = find_program('scripts/entitlement.sh') 3720endif 3721 3722emulators = {} 3723foreach target : target_dirs 3724 config_target = config_target_mak[target] 3725 target_name = config_target['TARGET_NAME'] 3726 target_base_arch = config_target['TARGET_BASE_ARCH'] 3727 arch_srcs = [config_target_h[target]] 3728 arch_deps = [] 3729 c_args = ['-DNEED_CPU_H', 3730 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target), 3731 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)] 3732 link_args = emulator_link_args 3733 3734 config_target += config_host 3735 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])] 3736 if targetos == 'linux' 3737 target_inc += include_directories('linux-headers', is_system: true) 3738 endif 3739 if target.endswith('-softmmu') 3740 target_type='system' 3741 t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false) 3742 arch_srcs += t.sources() 3743 arch_deps += t.dependencies() 3744 3745 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch 3746 hw = hw_arch[hw_dir].apply(config_target, strict: false) 3747 arch_srcs += hw.sources() 3748 arch_deps += hw.dependencies() 3749 3750 arch_srcs += config_devices_h[target] 3751 link_args += ['@block.syms', '@qemu.syms'] 3752 else 3753 abi = config_target['TARGET_ABI_DIR'] 3754 target_type='user' 3755 target_inc += common_user_inc 3756 if target_base_arch in target_user_arch 3757 t = target_user_arch[target_base_arch].apply(config_target, strict: false) 3758 arch_srcs += t.sources() 3759 arch_deps += t.dependencies() 3760 endif 3761 if 'CONFIG_LINUX_USER' in config_target 3762 base_dir = 'linux-user' 3763 endif 3764 if 'CONFIG_BSD_USER' in config_target 3765 base_dir = 'bsd-user' 3766 target_inc += include_directories('bsd-user/' / targetos) 3767 target_inc += include_directories('bsd-user/host/' / host_arch) 3768 dir = base_dir / abi 3769 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c') 3770 endif 3771 target_inc += include_directories( 3772 base_dir, 3773 base_dir / abi, 3774 ) 3775 if 'CONFIG_LINUX_USER' in config_target 3776 dir = base_dir / abi 3777 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c') 3778 if config_target.has_key('TARGET_SYSTBL_ABI') 3779 arch_srcs += \ 3780 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'], 3781 extra_args : config_target['TARGET_SYSTBL_ABI']) 3782 endif 3783 endif 3784 endif 3785 3786 if 'TARGET_XML_FILES' in config_target 3787 gdbstub_xml = custom_target(target + '-gdbstub-xml.c', 3788 output: target + '-gdbstub-xml.c', 3789 input: files(config_target['TARGET_XML_FILES'].split()), 3790 command: [feature_to_c, '@INPUT@'], 3791 capture: true) 3792 arch_srcs += gdbstub_xml 3793 endif 3794 3795 t = target_arch[target_base_arch].apply(config_target, strict: false) 3796 arch_srcs += t.sources() 3797 arch_deps += t.dependencies() 3798 3799 target_common = common_ss.apply(config_target, strict: false) 3800 objects = common_all.extract_objects(target_common.sources()) 3801 deps = target_common.dependencies() 3802 3803 target_specific = specific_ss.apply(config_target, strict: false) 3804 arch_srcs += target_specific.sources() 3805 arch_deps += target_specific.dependencies() 3806 3807 lib = static_library('qemu-' + target, 3808 sources: arch_srcs + genh, 3809 dependencies: arch_deps, 3810 objects: objects, 3811 include_directories: target_inc, 3812 c_args: c_args, 3813 build_by_default: false, 3814 name_suffix: 'fa') 3815 3816 if target.endswith('-softmmu') 3817 execs = [{ 3818 'name': 'qemu-system-' + target_name, 3819 'win_subsystem': 'console', 3820 'sources': files('softmmu/main.c'), 3821 'dependencies': [] 3822 }] 3823 if targetos == 'windows' and (sdl.found() or gtk.found()) 3824 execs += [{ 3825 'name': 'qemu-system-' + target_name + 'w', 3826 'win_subsystem': 'windows', 3827 'sources': files('softmmu/main.c'), 3828 'dependencies': [] 3829 }] 3830 endif 3831 if get_option('fuzzing') 3832 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false) 3833 execs += [{ 3834 'name': 'qemu-fuzz-' + target_name, 3835 'win_subsystem': 'console', 3836 'sources': specific_fuzz.sources(), 3837 'dependencies': specific_fuzz.dependencies(), 3838 }] 3839 endif 3840 else 3841 execs = [{ 3842 'name': 'qemu-' + target_name, 3843 'win_subsystem': 'console', 3844 'sources': [], 3845 'dependencies': [] 3846 }] 3847 endif 3848 foreach exe: execs 3849 exe_name = exe['name'] 3850 if targetos == 'darwin' 3851 exe_name += '-unsigned' 3852 endif 3853 3854 emulator = executable(exe_name, exe['sources'], 3855 install: true, 3856 c_args: c_args, 3857 dependencies: arch_deps + deps + exe['dependencies'], 3858 objects: lib.extract_all_objects(recursive: true), 3859 link_language: link_language, 3860 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []), 3861 link_args: link_args, 3862 win_subsystem: exe['win_subsystem']) 3863 3864 if targetos == 'darwin' 3865 icon = 'pc-bios/qemu.rsrc' 3866 build_input = [emulator, files(icon)] 3867 install_input = [ 3868 get_option('bindir') / exe_name, 3869 meson.current_source_dir() / icon 3870 ] 3871 if 'CONFIG_HVF' in config_target 3872 entitlements = 'accel/hvf/entitlements.plist' 3873 build_input += files(entitlements) 3874 install_input += meson.current_source_dir() / entitlements 3875 endif 3876 3877 emulators += {exe['name'] : custom_target(exe['name'], 3878 input: build_input, 3879 output: exe['name'], 3880 command: [entitlement, '@OUTPUT@', '@INPUT@']) 3881 } 3882 3883 meson.add_install_script(entitlement, '--install', 3884 get_option('bindir') / exe['name'], 3885 install_input) 3886 else 3887 emulators += {exe['name']: emulator} 3888 endif 3889 3890 if stap.found() 3891 foreach stp: [ 3892 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false}, 3893 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true}, 3894 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true}, 3895 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true}, 3896 ] 3897 custom_target(exe['name'] + stp['ext'], 3898 input: trace_events_all, 3899 output: exe['name'] + stp['ext'], 3900 install: stp['install'], 3901 install_dir: get_option('datadir') / 'systemtap/tapset', 3902 command: [ 3903 tracetool, '--group=all', '--format=' + stp['fmt'], 3904 '--binary=' + stp['bin'], 3905 '--target-name=' + target_name, 3906 '--target-type=' + target_type, 3907 '--probe-prefix=qemu.' + target_type + '.' + target_name, 3908 '@INPUT@', '@OUTPUT@' 3909 ], 3910 depend_files: tracetool_depends) 3911 endforeach 3912 endif 3913 endforeach 3914endforeach 3915 3916# Other build targets 3917 3918if 'CONFIG_PLUGIN' in config_host 3919 install_headers('include/qemu/qemu-plugin.h') 3920endif 3921 3922subdir('qga') 3923 3924# Don't build qemu-keymap if xkbcommon is not explicitly enabled 3925# when we don't build tools or system 3926if xkbcommon.found() 3927 # used for the update-keymaps target, so include rules even if !have_tools 3928 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh, 3929 dependencies: [qemuutil, xkbcommon], install: have_tools) 3930endif 3931 3932if have_tools 3933 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep], 3934 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true) 3935 qemu_io = executable('qemu-io', files('qemu-io.c'), 3936 dependencies: [block, qemuutil], install: true) 3937 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'), 3938 dependencies: [blockdev, qemuutil, gnutls, selinux], 3939 install: true) 3940 3941 subdir('storage-daemon') 3942 subdir('contrib/rdmacm-mux') 3943 subdir('contrib/elf2dmp') 3944 3945 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'), 3946 dependencies: qemuutil, 3947 install: true) 3948 3949 if have_vhost_user 3950 subdir('contrib/vhost-user-blk') 3951 subdir('contrib/vhost-user-gpu') 3952 subdir('contrib/vhost-user-input') 3953 subdir('contrib/vhost-user-scsi') 3954 endif 3955 3956 if targetos == 'linux' 3957 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'), 3958 dependencies: [qemuutil, libcap_ng], 3959 install: true, 3960 install_dir: get_option('libexecdir')) 3961 3962 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'), 3963 dependencies: [authz, crypto, io, qom, qemuutil, 3964 libcap_ng, mpathpersist], 3965 install: true) 3966 endif 3967 3968 if have_ivshmem 3969 subdir('contrib/ivshmem-client') 3970 subdir('contrib/ivshmem-server') 3971 endif 3972endif 3973 3974subdir('scripts') 3975subdir('tools') 3976subdir('pc-bios') 3977subdir('docs') 3978subdir('tests') 3979if gtk.found() 3980 subdir('po') 3981endif 3982 3983if host_machine.system() == 'windows' 3984 nsis_cmd = [ 3985 find_program('scripts/nsis.py'), 3986 '@OUTPUT@', 3987 get_option('prefix'), 3988 meson.current_source_dir(), 3989 glib_pc.get_variable('bindir'), 3990 host_machine.cpu(), 3991 '--', 3992 '-DDISPLAYVERSION=' + meson.project_version(), 3993 ] 3994 if build_docs 3995 nsis_cmd += '-DCONFIG_DOCUMENTATION=y' 3996 endif 3997 if gtk.found() 3998 nsis_cmd += '-DCONFIG_GTK=y' 3999 endif 4000 4001 nsis = custom_target('nsis', 4002 output: 'qemu-setup-' + meson.project_version() + '.exe', 4003 input: files('qemu.nsi'), 4004 build_always_stale: true, 4005 command: nsis_cmd + ['@INPUT@']) 4006 alias_target('installer', nsis) 4007endif 4008 4009######################### 4010# Configuration summary # 4011######################### 4012 4013# Directories 4014summary_info = {} 4015summary_info += {'Install prefix': get_option('prefix')} 4016summary_info += {'BIOS directory': qemu_datadir} 4017pathsep = targetos == 'windows' ? ';' : ':' 4018summary_info += {'firmware path': pathsep.join(get_option('qemu_firmwarepath'))} 4019summary_info += {'binary directory': get_option('prefix') / get_option('bindir')} 4020summary_info += {'library directory': get_option('prefix') / get_option('libdir')} 4021summary_info += {'module directory': qemu_moddir} 4022summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')} 4023summary_info += {'include directory': get_option('prefix') / get_option('includedir')} 4024summary_info += {'config directory': get_option('prefix') / get_option('sysconfdir')} 4025if targetos != 'windows' 4026 summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')} 4027 summary_info += {'Manual directory': get_option('prefix') / get_option('mandir')} 4028else 4029 summary_info += {'local state directory': 'queried at runtime'} 4030endif 4031summary_info += {'Doc directory': get_option('prefix') / get_option('docdir')} 4032summary_info += {'Build directory': meson.current_build_dir()} 4033summary_info += {'Source path': meson.current_source_dir()} 4034summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']} 4035summary(summary_info, bool_yn: true, section: 'Directories') 4036 4037# Host binaries 4038summary_info = {} 4039summary_info += {'git': config_host['GIT']} 4040summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())} 4041summary_info += {'sphinx-build': sphinx_build} 4042if config_host.has_key('HAVE_GDB_BIN') 4043 summary_info += {'gdb': config_host['HAVE_GDB_BIN']} 4044endif 4045summary_info += {'iasl': iasl} 4046summary_info += {'genisoimage': config_host['GENISOIMAGE']} 4047if targetos == 'windows' and have_ga 4048 summary_info += {'wixl': wixl} 4049endif 4050if slirp.found() and have_system 4051 summary_info += {'smbd': have_slirp_smbd ? smbd_path : false} 4052endif 4053summary(summary_info, bool_yn: true, section: 'Host binaries') 4054 4055# Configurable features 4056summary_info = {} 4057summary_info += {'Documentation': build_docs} 4058summary_info += {'system-mode emulation': have_system} 4059summary_info += {'user-mode emulation': have_user} 4060summary_info += {'block layer': have_block} 4061summary_info += {'Install blobs': get_option('install_blobs')} 4062summary_info += {'module support': enable_modules} 4063if enable_modules 4064 summary_info += {'alternative module path': get_option('module_upgrades')} 4065endif 4066summary_info += {'fuzzing support': get_option('fuzzing')} 4067if have_system 4068 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)} 4069endif 4070summary_info += {'Trace backends': ','.join(get_option('trace_backends'))} 4071if 'simple' in get_option('trace_backends') 4072 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'} 4073endif 4074summary_info += {'D-Bus display': dbus_display} 4075summary_info += {'QOM debugging': get_option('qom_cast_debug')} 4076summary_info += {'vhost-kernel support': have_vhost_kernel} 4077summary_info += {'vhost-net support': have_vhost_net} 4078summary_info += {'vhost-user support': have_vhost_user} 4079summary_info += {'vhost-user-crypto support': have_vhost_user_crypto} 4080summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server} 4081summary_info += {'vhost-vdpa support': have_vhost_vdpa} 4082summary_info += {'build guest agent': have_ga} 4083summary(summary_info, bool_yn: true, section: 'Configurable features') 4084 4085# Compilation information 4086summary_info = {} 4087summary_info += {'host CPU': cpu} 4088summary_info += {'host endianness': build_machine.endian()} 4089summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())} 4090summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())} 4091if link_language == 'cpp' 4092 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())} 4093else 4094 summary_info += {'C++ compiler': false} 4095endif 4096if targetos == 'darwin' 4097 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())} 4098endif 4099option_cflags = (get_option('debug') ? ['-g'] : []) 4100if get_option('optimization') != 'plain' 4101 option_cflags += ['-O' + get_option('optimization')] 4102endif 4103summary_info += {'CFLAGS': ' '.join(get_option('c_args') + option_cflags)} 4104if link_language == 'cpp' 4105 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args') + option_cflags)} 4106endif 4107if targetos == 'darwin' 4108 summary_info += {'OBJCFLAGS': ' '.join(get_option('objc_args') + option_cflags)} 4109endif 4110link_args = get_option(link_language + '_link_args') 4111if link_args.length() > 0 4112 summary_info += {'LDFLAGS': ' '.join(link_args)} 4113endif 4114summary_info += {'QEMU_CFLAGS': ' '.join(qemu_common_flags + qemu_cflags)} 4115if 'cpp' in all_languages 4116 summary_info += {'QEMU_CXXFLAGS': ' '.join(qemu_common_flags + qemu_cxxflags)} 4117endif 4118if 'objc' in all_languages 4119 summary_info += {'QEMU_OBJCFLAGS': ' '.join(qemu_common_flags)} 4120endif 4121summary_info += {'QEMU_LDFLAGS': ' '.join(qemu_ldflags)} 4122summary_info += {'profiler': get_option('profiler')} 4123summary_info += {'link-time optimization (LTO)': get_option('b_lto')} 4124summary_info += {'PIE': get_option('b_pie')} 4125summary_info += {'static build': config_host.has_key('CONFIG_STATIC')} 4126summary_info += {'malloc trim support': has_malloc_trim} 4127summary_info += {'membarrier': have_membarrier} 4128summary_info += {'debug graph lock': get_option('debug_graph_lock')} 4129summary_info += {'debug stack usage': get_option('debug_stack_usage')} 4130summary_info += {'mutex debugging': get_option('debug_mutex')} 4131summary_info += {'memory allocator': get_option('malloc')} 4132summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')} 4133summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')} 4134summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')} 4135if get_option('gprof') 4136 gprof_info = 'YES (deprecated)' 4137else 4138 gprof_info = get_option('gprof') 4139endif 4140summary_info += {'gprof': gprof_info} 4141summary_info += {'gcov': get_option('b_coverage')} 4142summary_info += {'thread sanitizer': get_option('tsan')} 4143summary_info += {'CFI support': get_option('cfi')} 4144if get_option('cfi') 4145 summary_info += {'CFI debug support': get_option('cfi_debug')} 4146endif 4147summary_info += {'strip binaries': get_option('strip')} 4148summary_info += {'sparse': sparse} 4149summary_info += {'mingw32 support': targetos == 'windows'} 4150summary(summary_info, bool_yn: true, section: 'Compilation') 4151 4152# snarf the cross-compilation information for tests 4153summary_info = {} 4154have_cross = false 4155foreach target: target_dirs 4156 tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak' 4157 if fs.exists(tcg_mak) 4158 config_cross_tcg = keyval.load(tcg_mak) 4159 if 'CC' in config_cross_tcg 4160 summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']} 4161 have_cross = true 4162 endif 4163 endif 4164endforeach 4165if have_cross 4166 summary(summary_info, bool_yn: true, section: 'Cross compilers') 4167endif 4168 4169# Targets and accelerators 4170summary_info = {} 4171if have_system 4172 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')} 4173 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')} 4174 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')} 4175 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')} 4176 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')} 4177 summary_info += {'Xen support': xen.found()} 4178 if xen.found() 4179 summary_info += {'xen ctrl version': xen.version()} 4180 endif 4181 summary_info += {'Xen emulation': config_all.has_key('CONFIG_XEN_EMU')} 4182endif 4183summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')} 4184if config_all.has_key('CONFIG_TCG') 4185 if get_option('tcg_interpreter') 4186 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'} 4187 else 4188 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)} 4189 endif 4190 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')} 4191 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')} 4192endif 4193summary_info += {'target list': ' '.join(target_dirs)} 4194if have_system 4195 summary_info += {'default devices': get_option('default_devices')} 4196 summary_info += {'out of process emulation': multiprocess_allowed} 4197 summary_info += {'vfio-user server': vfio_user_server_allowed} 4198endif 4199summary(summary_info, bool_yn: true, section: 'Targets and accelerators') 4200 4201# Block layer 4202summary_info = {} 4203summary_info += {'coroutine backend': coroutine_backend} 4204summary_info += {'coroutine pool': have_coroutine_pool} 4205if have_block 4206 summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')} 4207 summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')} 4208 summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')} 4209 summary_info += {'VirtFS (9P) support': have_virtfs} 4210 summary_info += {'VirtFS (9P) Proxy Helper support': have_virtfs_proxy_helper} 4211 summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')} 4212 summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')} 4213 summary_info += {'bochs support': get_option('bochs').allowed()} 4214 summary_info += {'cloop support': get_option('cloop').allowed()} 4215 summary_info += {'dmg support': get_option('dmg').allowed()} 4216 summary_info += {'qcow v1 support': get_option('qcow1').allowed()} 4217 summary_info += {'vdi support': get_option('vdi').allowed()} 4218 summary_info += {'vhdx support': get_option('vhdx').allowed()} 4219 summary_info += {'vmdk support': get_option('vmdk').allowed()} 4220 summary_info += {'vpc support': get_option('vpc').allowed()} 4221 summary_info += {'vvfat support': get_option('vvfat').allowed()} 4222 summary_info += {'qed support': get_option('qed').allowed()} 4223 summary_info += {'parallels support': get_option('parallels').allowed()} 4224 summary_info += {'FUSE exports': fuse} 4225 summary_info += {'VDUSE block exports': have_vduse_blk_export} 4226endif 4227summary(summary_info, bool_yn: true, section: 'Block layer support') 4228 4229# Crypto 4230summary_info = {} 4231summary_info += {'TLS priority': get_option('tls_priority')} 4232summary_info += {'GNUTLS support': gnutls} 4233if gnutls.found() 4234 summary_info += {' GNUTLS crypto': gnutls_crypto.found()} 4235endif 4236summary_info += {'libgcrypt': gcrypt} 4237summary_info += {'nettle': nettle} 4238if nettle.found() 4239 summary_info += {' XTS': xts != 'private'} 4240endif 4241summary_info += {'AF_ALG support': have_afalg} 4242summary_info += {'rng-none': get_option('rng_none')} 4243summary_info += {'Linux keyring': have_keyring} 4244summary(summary_info, bool_yn: true, section: 'Crypto') 4245 4246# Libraries 4247summary_info = {} 4248if targetos == 'darwin' 4249 summary_info += {'Cocoa support': cocoa} 4250 summary_info += {'vmnet.framework support': vmnet} 4251endif 4252summary_info += {'SDL support': sdl} 4253summary_info += {'SDL image support': sdl_image} 4254summary_info += {'GTK support': gtk} 4255summary_info += {'pixman': pixman} 4256summary_info += {'VTE support': vte} 4257summary_info += {'slirp support': slirp} 4258summary_info += {'libtasn1': tasn1} 4259summary_info += {'PAM': pam} 4260summary_info += {'iconv support': iconv} 4261summary_info += {'curses support': curses} 4262summary_info += {'virgl support': virgl} 4263summary_info += {'blkio support': blkio} 4264summary_info += {'curl support': curl} 4265summary_info += {'Multipath support': mpathpersist} 4266summary_info += {'PNG support': png} 4267summary_info += {'VNC support': vnc} 4268if vnc.found() 4269 summary_info += {'VNC SASL support': sasl} 4270 summary_info += {'VNC JPEG support': jpeg} 4271endif 4272if targetos not in ['darwin', 'haiku', 'windows'] 4273 summary_info += {'OSS support': oss} 4274 summary_info += {'sndio support': sndio} 4275elif targetos == 'darwin' 4276 summary_info += {'CoreAudio support': coreaudio} 4277elif targetos == 'windows' 4278 summary_info += {'DirectSound support': dsound} 4279endif 4280if targetos == 'linux' 4281 summary_info += {'ALSA support': alsa} 4282 summary_info += {'PulseAudio support': pulse} 4283endif 4284summary_info += {'Pipewire support': pipewire} 4285summary_info += {'JACK support': jack} 4286summary_info += {'brlapi support': brlapi} 4287summary_info += {'vde support': vde} 4288summary_info += {'netmap support': have_netmap} 4289summary_info += {'l2tpv3 support': have_l2tpv3} 4290summary_info += {'Linux AIO support': libaio} 4291summary_info += {'Linux io_uring support': linux_io_uring} 4292summary_info += {'ATTR/XATTR support': libattr} 4293summary_info += {'RDMA support': rdma} 4294summary_info += {'PVRDMA support': have_pvrdma} 4295summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt} 4296summary_info += {'libcap-ng support': libcap_ng} 4297summary_info += {'bpf support': libbpf} 4298summary_info += {'spice protocol support': spice_protocol} 4299if spice_protocol.found() 4300 summary_info += {' spice server support': spice} 4301endif 4302summary_info += {'rbd support': rbd} 4303summary_info += {'smartcard support': cacard} 4304summary_info += {'U2F support': u2f} 4305summary_info += {'libusb': libusb} 4306summary_info += {'usb net redir': usbredir} 4307summary_info += {'OpenGL support (epoxy)': opengl} 4308summary_info += {'GBM': gbm} 4309summary_info += {'libiscsi support': libiscsi} 4310summary_info += {'libnfs support': libnfs} 4311if targetos == 'windows' 4312 if have_ga 4313 summary_info += {'QGA VSS support': have_qga_vss} 4314 endif 4315endif 4316summary_info += {'seccomp support': seccomp} 4317summary_info += {'GlusterFS support': glusterfs} 4318summary_info += {'TPM support': have_tpm} 4319summary_info += {'libssh support': libssh} 4320summary_info += {'lzo support': lzo} 4321summary_info += {'snappy support': snappy} 4322summary_info += {'bzip2 support': libbzip2} 4323summary_info += {'lzfse support': liblzfse} 4324summary_info += {'zstd support': zstd} 4325summary_info += {'NUMA host support': numa} 4326summary_info += {'capstone': capstone} 4327summary_info += {'libpmem support': libpmem} 4328summary_info += {'libdaxctl support': libdaxctl} 4329summary_info += {'libudev': libudev} 4330# Dummy dependency, keep .found() 4331summary_info += {'FUSE lseek': fuse_lseek.found()} 4332summary_info += {'selinux': selinux} 4333summary_info += {'libdw': libdw} 4334summary(summary_info, bool_yn: true, section: 'Dependencies') 4335 4336if not supported_cpus.contains(cpu) 4337 message() 4338 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!') 4339 message() 4340 message('CPU host architecture ' + cpu + ' support is not currently maintained.') 4341 message('The QEMU project intends to remove support for this host CPU in') 4342 message('a future release if nobody volunteers to maintain it and to') 4343 message('provide a build host for our continuous integration setup.') 4344 message('configure has succeeded and you can continue to build, but') 4345 message('if you care about QEMU on this platform you should contact') 4346 message('us upstream at qemu-devel@nongnu.org.') 4347endif 4348 4349if not supported_oses.contains(targetos) 4350 message() 4351 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!') 4352 message() 4353 message('Host OS ' + targetos + 'support is not currently maintained.') 4354 message('The QEMU project intends to remove support for this host OS in') 4355 message('a future release if nobody volunteers to maintain it and to') 4356 message('provide a build host for our continuous integration setup.') 4357 message('configure has succeeded and you can continue to build, but') 4358 message('if you care about QEMU on this platform you should contact') 4359 message('us upstream at qemu-devel@nongnu.org.') 4360endif 4361