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.has_function('malloc_trim', prefix: '#include <malloc.h>') 1801else 1802 has_malloc_trim = false 1803 malloc = cc.find_library(get_option('malloc'), required: true) 1804endif 1805if not has_malloc_trim and get_option('malloc_trim').enabled() 1806 if get_option('malloc') == 'system' 1807 error('malloc_trim not available on this platform.') 1808 else 1809 error('malloc_trim not available with non-libc memory allocator') 1810 endif 1811endif 1812 1813gnu_source_prefix = ''' 1814 #ifndef _GNU_SOURCE 1815 #define _GNU_SOURCE 1816 #endif 1817''' 1818 1819# Check whether the glibc provides STATX_BASIC_STATS 1820 1821has_statx = cc.has_header_symbol('sys/stat.h', 'STATX_BASIC_STATS', prefix: gnu_source_prefix) 1822 1823# Check whether statx() provides mount ID information 1824 1825has_statx_mnt_id = cc.has_header_symbol('sys/stat.h', 'STATX_MNT_ID', prefix: gnu_source_prefix) 1826 1827have_vhost_user_blk_server = get_option('vhost_user_blk_server') \ 1828 .require(targetos == 'linux', 1829 error_message: 'vhost_user_blk_server requires linux') \ 1830 .require(have_vhost_user, 1831 error_message: 'vhost_user_blk_server requires vhost-user support') \ 1832 .disable_auto_if(not have_tools and not have_system) \ 1833 .allowed() 1834 1835if get_option('fuse').disabled() and get_option('fuse_lseek').enabled() 1836 error('Cannot enable fuse-lseek while fuse is disabled') 1837endif 1838 1839fuse = dependency('fuse3', required: get_option('fuse'), 1840 version: '>=3.1', method: 'pkg-config') 1841 1842fuse_lseek = not_found 1843if get_option('fuse_lseek').allowed() 1844 if fuse.version().version_compare('>=3.8') 1845 # Dummy dependency 1846 fuse_lseek = declare_dependency() 1847 elif get_option('fuse_lseek').enabled() 1848 if fuse.found() 1849 error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version()) 1850 else 1851 error('fuse-lseek requires libfuse, which was not found') 1852 endif 1853 endif 1854endif 1855 1856have_libvduse = (targetos == 'linux') 1857if get_option('libvduse').enabled() 1858 if targetos != 'linux' 1859 error('libvduse requires linux') 1860 endif 1861elif get_option('libvduse').disabled() 1862 have_libvduse = false 1863endif 1864 1865have_vduse_blk_export = (have_libvduse and targetos == 'linux') 1866if get_option('vduse_blk_export').enabled() 1867 if targetos != 'linux' 1868 error('vduse_blk_export requires linux') 1869 elif not have_libvduse 1870 error('vduse_blk_export requires libvduse support') 1871 endif 1872elif get_option('vduse_blk_export').disabled() 1873 have_vduse_blk_export = false 1874endif 1875 1876# libbpf 1877libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config') 1878if libbpf.found() and not cc.links(''' 1879 #include <bpf/libbpf.h> 1880 int main(void) 1881 { 1882 bpf_object__destroy_skeleton(NULL); 1883 return 0; 1884 }''', dependencies: libbpf) 1885 libbpf = not_found 1886 if get_option('bpf').enabled() 1887 error('libbpf skeleton test failed') 1888 else 1889 warning('libbpf skeleton test failed, disabling') 1890 endif 1891endif 1892 1893# libdw 1894libdw = not_found 1895if not get_option('libdw').auto() or \ 1896 (not get_option('prefer_static') and (have_system or have_user)) 1897 libdw = dependency('libdw', 1898 method: 'pkg-config', 1899 required: get_option('libdw')) 1900endif 1901 1902################# 1903# config-host.h # 1904################# 1905 1906audio_drivers_selected = [] 1907if have_system 1908 audio_drivers_available = { 1909 'alsa': alsa.found(), 1910 'coreaudio': coreaudio.found(), 1911 'dsound': dsound.found(), 1912 'jack': jack.found(), 1913 'oss': oss.found(), 1914 'pa': pulse.found(), 1915 'pipewire': pipewire.found(), 1916 'sdl': sdl.found(), 1917 'sndio': sndio.found(), 1918 } 1919 foreach k, v: audio_drivers_available 1920 config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v) 1921 endforeach 1922 1923 # Default to native drivers first, OSS second, SDL third 1924 audio_drivers_priority = \ 1925 [ 'pa', 'coreaudio', 'dsound', 'sndio', 'oss' ] + \ 1926 (targetos == 'linux' ? [] : [ 'sdl' ]) 1927 audio_drivers_default = [] 1928 foreach k: audio_drivers_priority 1929 if audio_drivers_available[k] 1930 audio_drivers_default += k 1931 endif 1932 endforeach 1933 1934 foreach k: get_option('audio_drv_list') 1935 if k == 'default' 1936 audio_drivers_selected += audio_drivers_default 1937 elif not audio_drivers_available[k] 1938 error('Audio driver "@0@" not available.'.format(k)) 1939 else 1940 audio_drivers_selected += k 1941 endif 1942 endforeach 1943endif 1944config_host_data.set('CONFIG_AUDIO_DRIVERS', 1945 '"' + '", "'.join(audio_drivers_selected) + '", ') 1946 1947if get_option('cfi') 1948 cfi_flags=[] 1949 # Check for dependency on LTO 1950 if not get_option('b_lto') 1951 error('Selected Control-Flow Integrity but LTO is disabled') 1952 endif 1953 if enable_modules 1954 error('Selected Control-Flow Integrity is not compatible with modules') 1955 endif 1956 # Check for cfi flags. CFI requires LTO so we can't use 1957 # get_supported_arguments, but need a more complex "compiles" which allows 1958 # custom arguments 1959 if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall', 1960 args: ['-flto', '-fsanitize=cfi-icall'] ) 1961 cfi_flags += '-fsanitize=cfi-icall' 1962 else 1963 error('-fsanitize=cfi-icall is not supported by the compiler') 1964 endif 1965 if cc.compiles('int main () { return 0; }', 1966 name: '-fsanitize-cfi-icall-generalize-pointers', 1967 args: ['-flto', '-fsanitize=cfi-icall', 1968 '-fsanitize-cfi-icall-generalize-pointers'] ) 1969 cfi_flags += '-fsanitize-cfi-icall-generalize-pointers' 1970 else 1971 error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler') 1972 endif 1973 if get_option('cfi_debug') 1974 if cc.compiles('int main () { return 0; }', 1975 name: '-fno-sanitize-trap=cfi-icall', 1976 args: ['-flto', '-fsanitize=cfi-icall', 1977 '-fno-sanitize-trap=cfi-icall'] ) 1978 cfi_flags += '-fno-sanitize-trap=cfi-icall' 1979 else 1980 error('-fno-sanitize-trap=cfi-icall is not supported by the compiler') 1981 endif 1982 endif 1983 add_global_arguments(cfi_flags, native: false, language: all_languages) 1984 add_global_link_arguments(cfi_flags, native: false, language: all_languages) 1985endif 1986 1987have_host_block_device = (targetos != 'darwin' or 1988 cc.has_header('IOKit/storage/IOMedia.h')) 1989 1990dbus_display = get_option('dbus_display') \ 1991 .require(gio.version().version_compare('>=2.64'), 1992 error_message: '-display dbus requires glib>=2.64') \ 1993 .require(gdbus_codegen.found(), 1994 error_message: gdbus_codegen_error.format('-display dbus')) \ 1995 .require(targetos != 'windows', 1996 error_message: '-display dbus is not available on Windows') \ 1997 .allowed() 1998 1999have_virtfs = get_option('virtfs') \ 2000 .require(targetos == 'linux' or targetos == 'darwin', 2001 error_message: 'virtio-9p (virtfs) requires Linux or macOS') \ 2002 .require(targetos == 'linux' or cc.has_function('pthread_fchdir_np'), 2003 error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \ 2004 .require(targetos == 'darwin' or libattr.found(), 2005 error_message: 'virtio-9p (virtfs) on Linux requires libattr-devel') \ 2006 .disable_auto_if(not have_tools and not have_system) \ 2007 .allowed() 2008 2009have_virtfs_proxy_helper = get_option('virtfs_proxy_helper') \ 2010 .require(targetos != 'darwin', error_message: 'the virtfs proxy helper is incompatible with macOS') \ 2011 .require(have_virtfs, error_message: 'the virtfs proxy helper requires that virtfs is enabled') \ 2012 .disable_auto_if(not have_tools) \ 2013 .require(libcap_ng.found(), error_message: 'the virtfs proxy helper requires libcap-ng') \ 2014 .allowed() 2015 2016if get_option('block_drv_ro_whitelist') == '' 2017 config_host_data.set('CONFIG_BDRV_RO_WHITELIST', '') 2018else 2019 config_host_data.set('CONFIG_BDRV_RO_WHITELIST', 2020 '"' + get_option('block_drv_ro_whitelist').replace(',', '", "') + '", ') 2021endif 2022if get_option('block_drv_rw_whitelist') == '' 2023 config_host_data.set('CONFIG_BDRV_RW_WHITELIST', '') 2024else 2025 config_host_data.set('CONFIG_BDRV_RW_WHITELIST', 2026 '"' + get_option('block_drv_rw_whitelist').replace(',', '", "') + '", ') 2027endif 2028 2029foreach k : get_option('trace_backends') 2030 config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true) 2031endforeach 2032config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file')) 2033config_host_data.set_quoted('CONFIG_TLS_PRIORITY', get_option('tls_priority')) 2034if iasl.found() 2035 config_host_data.set_quoted('CONFIG_IASL', iasl.full_path()) 2036endif 2037config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir')) 2038config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix')) 2039config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir) 2040config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir) 2041config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir) 2042 2043qemu_firmwarepath = '' 2044foreach k : get_option('qemu_firmwarepath') 2045 qemu_firmwarepath += '"' + get_option('prefix') / k + '", ' 2046endforeach 2047config_host_data.set('CONFIG_QEMU_FIRMWAREPATH', qemu_firmwarepath) 2048 2049config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir')) 2050config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir) 2051config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir')) 2052config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir')) 2053config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir) 2054config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir')) 2055 2056if enable_modules 2057 config_host_data.set('CONFIG_STAMP', run_command( 2058 meson.current_source_dir() / 'scripts/qemu-stamp.py', 2059 meson.project_version(), get_option('pkgversion'), '--', 2060 meson.current_source_dir() / 'configure', 2061 capture: true, check: true).stdout().strip()) 2062endif 2063 2064have_slirp_smbd = get_option('slirp_smbd') \ 2065 .require(targetos != 'windows', error_message: 'Host smbd not supported on this platform.') \ 2066 .allowed() 2067if have_slirp_smbd 2068 smbd_path = get_option('smbd') 2069 if smbd_path == '' 2070 smbd_path = (targetos == 'solaris' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd') 2071 endif 2072 config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path) 2073endif 2074 2075config_host_data.set('HOST_' + host_arch.to_upper(), 1) 2076 2077if get_option('module_upgrades') and not enable_modules 2078 error('Cannot enable module-upgrades as modules are not enabled') 2079endif 2080config_host_data.set('CONFIG_MODULE_UPGRADES', get_option('module_upgrades')) 2081 2082config_host_data.set('CONFIG_ATTR', libattr.found()) 2083config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools')) 2084config_host_data.set('CONFIG_BRLAPI', brlapi.found()) 2085config_host_data.set('CONFIG_COCOA', cocoa.found()) 2086config_host_data.set('CONFIG_FUZZ', get_option('fuzzing')) 2087config_host_data.set('CONFIG_GCOV', get_option('b_coverage')) 2088config_host_data.set('CONFIG_LIBUDEV', libudev.found()) 2089config_host_data.set('CONFIG_LZO', lzo.found()) 2090config_host_data.set('CONFIG_MPATH', mpathpersist.found()) 2091config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api) 2092config_host_data.set('CONFIG_BLKIO', blkio.found()) 2093if blkio.found() 2094 config_host_data.set('CONFIG_BLKIO_VHOST_VDPA_FD', 2095 blkio.version().version_compare('>=1.3.0')) 2096endif 2097config_host_data.set('CONFIG_CURL', curl.found()) 2098config_host_data.set('CONFIG_CURSES', curses.found()) 2099config_host_data.set('CONFIG_GBM', gbm.found()) 2100config_host_data.set('CONFIG_GIO', gio.found()) 2101config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found()) 2102if glusterfs.found() 2103 config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4')) 2104 config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5')) 2105 config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6')) 2106 config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6')) 2107 config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat) 2108 config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat) 2109endif 2110config_host_data.set('CONFIG_GTK', gtk.found()) 2111config_host_data.set('CONFIG_VTE', vte.found()) 2112config_host_data.set('CONFIG_GTK_CLIPBOARD', have_gtk_clipboard) 2113config_host_data.set('CONFIG_HEXAGON_IDEF_PARSER', get_option('hexagon_idef_parser')) 2114config_host_data.set('CONFIG_LIBATTR', have_old_libattr) 2115config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found()) 2116config_host_data.set('CONFIG_EBPF', libbpf.found()) 2117config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found()) 2118config_host_data.set('CONFIG_LIBISCSI', libiscsi.found()) 2119config_host_data.set('CONFIG_LIBNFS', libnfs.found()) 2120config_host_data.set('CONFIG_LIBSSH', libssh.found()) 2121config_host_data.set('CONFIG_LINUX_AIO', libaio.found()) 2122config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found()) 2123config_host_data.set('CONFIG_LIBPMEM', libpmem.found()) 2124config_host_data.set('CONFIG_MODULES', enable_modules) 2125config_host_data.set('CONFIG_NUMA', numa.found()) 2126if numa.found() 2127 config_host_data.set('HAVE_NUMA_HAS_PREFERRED_MANY', 2128 cc.has_function('numa_has_preferred_many', 2129 dependencies: numa)) 2130endif 2131config_host_data.set('CONFIG_OPENGL', opengl.found()) 2132config_host_data.set('CONFIG_PROFILER', get_option('profiler')) 2133config_host_data.set('CONFIG_RBD', rbd.found()) 2134config_host_data.set('CONFIG_RDMA', rdma.found()) 2135config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack')) 2136config_host_data.set('CONFIG_SDL', sdl.found()) 2137config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found()) 2138config_host_data.set('CONFIG_SECCOMP', seccomp.found()) 2139if seccomp.found() 2140 config_host_data.set('CONFIG_SECCOMP_SYSRAWRC', seccomp_has_sysrawrc) 2141endif 2142config_host_data.set('CONFIG_SNAPPY', snappy.found()) 2143config_host_data.set('CONFIG_TPM', have_tpm) 2144config_host_data.set('CONFIG_TSAN', get_option('tsan')) 2145config_host_data.set('CONFIG_USB_LIBUSB', libusb.found()) 2146config_host_data.set('CONFIG_VDE', vde.found()) 2147config_host_data.set('CONFIG_VHOST_NET', have_vhost_net) 2148config_host_data.set('CONFIG_VHOST_NET_USER', have_vhost_net_user) 2149config_host_data.set('CONFIG_VHOST_NET_VDPA', have_vhost_net_vdpa) 2150config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel) 2151config_host_data.set('CONFIG_VHOST_USER', have_vhost_user) 2152config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto) 2153config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa) 2154config_host_data.set('CONFIG_VMNET', vmnet.found()) 2155config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server) 2156config_host_data.set('CONFIG_VDUSE_BLK_EXPORT', have_vduse_blk_export) 2157config_host_data.set('CONFIG_PNG', png.found()) 2158config_host_data.set('CONFIG_VNC', vnc.found()) 2159config_host_data.set('CONFIG_VNC_JPEG', jpeg.found()) 2160config_host_data.set('CONFIG_VNC_SASL', sasl.found()) 2161config_host_data.set('CONFIG_VIRTFS', have_virtfs) 2162config_host_data.set('CONFIG_VTE', vte.found()) 2163config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found()) 2164config_host_data.set('CONFIG_KEYUTILS', keyutils.found()) 2165config_host_data.set('CONFIG_GETTID', has_gettid) 2166config_host_data.set('CONFIG_GNUTLS', gnutls.found()) 2167config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found()) 2168config_host_data.set('CONFIG_TASN1', tasn1.found()) 2169config_host_data.set('CONFIG_GCRYPT', gcrypt.found()) 2170config_host_data.set('CONFIG_NETTLE', nettle.found()) 2171config_host_data.set('CONFIG_HOGWEED', hogweed.found()) 2172config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private') 2173config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim) 2174config_host_data.set('CONFIG_STATX', has_statx) 2175config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id) 2176config_host_data.set('CONFIG_ZSTD', zstd.found()) 2177config_host_data.set('CONFIG_FUSE', fuse.found()) 2178config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found()) 2179config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found()) 2180if spice_protocol.found() 2181config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0]) 2182config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1]) 2183config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2]) 2184endif 2185config_host_data.set('CONFIG_SPICE', spice.found()) 2186config_host_data.set('CONFIG_X11', x11.found()) 2187config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display) 2188config_host_data.set('CONFIG_CFI', get_option('cfi')) 2189config_host_data.set('CONFIG_SELINUX', selinux.found()) 2190config_host_data.set('CONFIG_XEN_BACKEND', xen.found()) 2191config_host_data.set('CONFIG_LIBDW', libdw.found()) 2192if xen.found() 2193 # protect from xen.version() having less than three components 2194 xen_version = xen.version().split('.') + ['0', '0'] 2195 xen_ctrl_version = xen_version[0] + \ 2196 ('0' + xen_version[1]).substring(-2) + \ 2197 ('0' + xen_version[2]).substring(-2) 2198 config_host_data.set('CONFIG_XEN_CTRL_INTERFACE_VERSION', xen_ctrl_version) 2199endif 2200config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version())) 2201config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0]) 2202config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1]) 2203config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2]) 2204 2205config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf) 2206config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device) 2207 2208have_coroutine_pool = get_option('coroutine_pool') 2209if get_option('debug_stack_usage') and have_coroutine_pool 2210 message('Disabling coroutine pool to measure stack usage') 2211 have_coroutine_pool = false 2212endif 2213config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool) 2214config_host_data.set('CONFIG_DEBUG_GRAPH_LOCK', get_option('debug_graph_lock')) 2215config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex')) 2216config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage')) 2217config_host_data.set('CONFIG_GPROF', get_option('gprof')) 2218config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed()) 2219config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug')) 2220config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed()) 2221 2222# has_header 2223config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h')) 2224config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h')) 2225config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h')) 2226config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h')) 2227config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h')) 2228config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h')) 2229config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h')) 2230config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h')) 2231config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h')) 2232if targetos == 'windows' 2233 config_host_data.set('HAVE_AFUNIX_H', cc.has_header('afunix.h')) 2234endif 2235 2236# has_function 2237config_host_data.set('CONFIG_CLOSE_RANGE', cc.has_function('close_range')) 2238config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4')) 2239config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime')) 2240config_host_data.set('CONFIG_DUP3', cc.has_function('dup3')) 2241config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate')) 2242config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate')) 2243# Note that we need to specify prefix: here to avoid incorrectly 2244# thinking that Windows has posix_memalign() 2245config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>')) 2246config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc')) 2247config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc')) 2248config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign')) 2249config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll')) 2250config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>')) 2251config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np')) 2252config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile')) 2253config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare')) 2254config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs')) 2255config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range')) 2256config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create')) 2257config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range')) 2258config_host_data.set('HAVE_GETIFADDRS', cc.has_function('getifaddrs')) 2259config_host_data.set('HAVE_GLIB_WITH_SLICE_ALLOCATOR', glib_has_gslice) 2260config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util)) 2261config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul')) 2262config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>')) 2263if rbd.found() 2264 config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS', 2265 cc.has_function('rbd_namespace_exists', 2266 dependencies: rbd, 2267 prefix: '#include <rbd/librbd.h>')) 2268endif 2269if rdma.found() 2270 config_host_data.set('HAVE_IBV_ADVISE_MR', 2271 cc.has_function('ibv_advise_mr', 2272 dependencies: rdma, 2273 prefix: '#include <infiniband/verbs.h>')) 2274endif 2275 2276have_asan_fiber = false 2277if get_option('sanitizers') and \ 2278 not cc.has_function('__sanitizer_start_switch_fiber', 2279 args: '-fsanitize=address', 2280 prefix: '#include <sanitizer/asan_interface.h>') 2281 warning('Missing ASAN due to missing fiber annotation interface') 2282 warning('Without code annotation, the report may be inferior.') 2283else 2284 have_asan_fiber = true 2285endif 2286config_host_data.set('CONFIG_ASAN_IFACE_FIBER', have_asan_fiber) 2287 2288# has_header_symbol 2289config_host_data.set('CONFIG_BLKZONED', 2290 cc.has_header_symbol('linux/blkzoned.h', 'BLKOPENZONE')) 2291config_host_data.set('CONFIG_EPOLL_CREATE1', 2292 cc.has_header_symbol('sys/epoll.h', 'epoll_create1')) 2293config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE', 2294 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and 2295 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE')) 2296config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE', 2297 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE')) 2298config_host_data.set('CONFIG_FIEMAP', 2299 cc.has_header('linux/fiemap.h') and 2300 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP')) 2301config_host_data.set('CONFIG_GETRANDOM', 2302 cc.has_function('getrandom') and 2303 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK')) 2304config_host_data.set('CONFIG_INOTIFY', 2305 cc.has_header_symbol('sys/inotify.h', 'inotify_init')) 2306config_host_data.set('CONFIG_INOTIFY1', 2307 cc.has_header_symbol('sys/inotify.h', 'inotify_init1')) 2308config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK', 2309 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK')) 2310config_host_data.set('CONFIG_RTNETLINK', 2311 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN')) 2312config_host_data.set('CONFIG_SYSMACROS', 2313 cc.has_header_symbol('sys/sysmacros.h', 'makedev')) 2314config_host_data.set('HAVE_OPTRESET', 2315 cc.has_header_symbol('getopt.h', 'optreset')) 2316config_host_data.set('HAVE_IPPROTO_MPTCP', 2317 cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP')) 2318 2319# has_member 2320config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID', 2321 cc.has_member('struct sigevent', 'sigev_notify_thread_id', 2322 prefix: '#include <signal.h>')) 2323config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM', 2324 cc.has_member('struct stat', 'st_atim', 2325 prefix: '#include <sys/stat.h>')) 2326config_host_data.set('HAVE_BLK_ZONE_REP_CAPACITY', 2327 cc.has_member('struct blk_zone', 'capacity', 2328 prefix: '#include <linux/blkzoned.h>')) 2329 2330# has_type 2331config_host_data.set('CONFIG_IOVEC', 2332 cc.has_type('struct iovec', 2333 prefix: '#include <sys/uio.h>')) 2334config_host_data.set('HAVE_UTMPX', 2335 cc.has_type('struct utmpx', 2336 prefix: '#include <utmpx.h>')) 2337 2338config_host_data.set('CONFIG_EVENTFD', cc.links(''' 2339 #include <sys/eventfd.h> 2340 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }''')) 2341config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + ''' 2342 #include <unistd.h> 2343 int main(void) { 2344 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0 2345 return fdatasync(0); 2346 #else 2347 #error Not supported 2348 #endif 2349 }''')) 2350 2351has_madvise = cc.links(gnu_source_prefix + ''' 2352 #include <sys/types.h> 2353 #include <sys/mman.h> 2354 #include <stddef.h> 2355 int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''') 2356missing_madvise_proto = false 2357if has_madvise 2358 # Some platforms (illumos and Solaris before Solaris 11) provide madvise() 2359 # but forget to prototype it. In this case, has_madvise will be true (the 2360 # test program links despite a compile warning). To detect the 2361 # missing-prototype case, we try again with a definitely-bogus prototype. 2362 # This will only compile if the system headers don't provide the prototype; 2363 # otherwise the conflicting prototypes will cause a compiler error. 2364 missing_madvise_proto = cc.links(gnu_source_prefix + ''' 2365 #include <sys/types.h> 2366 #include <sys/mman.h> 2367 #include <stddef.h> 2368 extern int madvise(int); 2369 int main(void) { return madvise(0); }''') 2370endif 2371config_host_data.set('CONFIG_MADVISE', has_madvise) 2372config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto) 2373 2374config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + ''' 2375 #include <sys/mman.h> 2376 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }''')) 2377config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + ''' 2378 #include <fcntl.h> 2379 #if !defined(AT_EMPTY_PATH) 2380 # error missing definition 2381 #else 2382 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); } 2383 #endif''')) 2384config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + ''' 2385 #include <sys/mman.h> 2386 #include <stddef.h> 2387 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }''')) 2388 2389config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + ''' 2390 #include <pthread.h> 2391 2392 static void *f(void *p) { return NULL; } 2393 int main(void) 2394 { 2395 pthread_t thread; 2396 pthread_create(&thread, 0, f, 0); 2397 pthread_setname_np(thread, "QEMU"); 2398 return 0; 2399 }''', dependencies: threads)) 2400config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + ''' 2401 #include <pthread.h> 2402 2403 static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; } 2404 int main(void) 2405 { 2406 pthread_t thread; 2407 pthread_create(&thread, 0, f, 0); 2408 return 0; 2409 }''', dependencies: threads)) 2410config_host_data.set('CONFIG_PTHREAD_SET_NAME_NP', cc.links(gnu_source_prefix + ''' 2411 #include <pthread.h> 2412 #include <pthread_np.h> 2413 2414 static void *f(void *p) { return NULL; } 2415 int main(void) 2416 { 2417 pthread_t thread; 2418 pthread_create(&thread, 0, f, 0); 2419 pthread_set_name_np(thread, "QEMU"); 2420 return 0; 2421 }''', dependencies: threads)) 2422config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + ''' 2423 #include <pthread.h> 2424 #include <time.h> 2425 2426 int main(void) 2427 { 2428 pthread_condattr_t attr 2429 pthread_condattr_init(&attr); 2430 pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); 2431 return 0; 2432 }''', dependencies: threads)) 2433config_host_data.set('CONFIG_PTHREAD_AFFINITY_NP', cc.links(gnu_source_prefix + ''' 2434 #include <pthread.h> 2435 2436 static void *f(void *p) { return NULL; } 2437 int main(void) 2438 { 2439 int setsize = CPU_ALLOC_SIZE(64); 2440 pthread_t thread; 2441 cpu_set_t *cpuset; 2442 pthread_create(&thread, 0, f, 0); 2443 cpuset = CPU_ALLOC(64); 2444 CPU_ZERO_S(setsize, cpuset); 2445 pthread_setaffinity_np(thread, setsize, cpuset); 2446 pthread_getaffinity_np(thread, setsize, cpuset); 2447 CPU_FREE(cpuset); 2448 return 0; 2449 }''', dependencies: threads)) 2450config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + ''' 2451 #include <sys/signalfd.h> 2452 #include <stddef.h> 2453 int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }''')) 2454config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + ''' 2455 #include <unistd.h> 2456 #include <fcntl.h> 2457 #include <limits.h> 2458 2459 int main(void) 2460 { 2461 int len, fd = 0; 2462 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK); 2463 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE); 2464 return 0; 2465 }''')) 2466 2467config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + ''' 2468 #include <sys/mman.h> 2469 int main(void) { 2470 return mlockall(MCL_FUTURE); 2471 }''')) 2472 2473have_l2tpv3 = false 2474if get_option('l2tpv3').allowed() and have_system 2475 have_l2tpv3 = cc.has_type('struct mmsghdr', 2476 prefix: gnu_source_prefix + ''' 2477 #include <sys/socket.h> 2478 #include <linux/ip.h>''') 2479endif 2480config_host_data.set('CONFIG_L2TPV3', have_l2tpv3) 2481 2482have_netmap = false 2483if get_option('netmap').allowed() and have_system 2484 have_netmap = cc.compiles(''' 2485 #include <inttypes.h> 2486 #include <net/if.h> 2487 #include <net/netmap.h> 2488 #include <net/netmap_user.h> 2489 #if (NETMAP_API < 11) || (NETMAP_API > 15) 2490 #error 2491 #endif 2492 int main(void) { return 0; }''') 2493 if not have_netmap and get_option('netmap').enabled() 2494 error('Netmap headers not available') 2495 endif 2496endif 2497config_host_data.set('CONFIG_NETMAP', have_netmap) 2498 2499# Work around a system header bug with some kernel/XFS header 2500# versions where they both try to define 'struct fsxattr': 2501# xfs headers will not try to redefine structs from linux headers 2502# if this macro is set. 2503config_host_data.set('HAVE_FSXATTR', cc.links(''' 2504 #include <linux/fs.h> 2505 struct fsxattr foo; 2506 int main(void) { 2507 return 0; 2508 }''')) 2509 2510# Some versions of Mac OS X incorrectly define SIZE_MAX 2511config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles(''' 2512 #include <stdint.h> 2513 #include <stdio.h> 2514 int main(void) { 2515 return printf("%zu", SIZE_MAX); 2516 }''', args: ['-Werror'])) 2517 2518# See if 64-bit atomic operations are supported. 2519# Note that without __atomic builtins, we can only 2520# assume atomic loads/stores max at pointer size. 2521config_host_data.set('CONFIG_ATOMIC64', cc.links(''' 2522 #include <stdint.h> 2523 int main(void) 2524 { 2525 uint64_t x = 0, y = 0; 2526 y = __atomic_load_n(&x, __ATOMIC_RELAXED); 2527 __atomic_store_n(&x, y, __ATOMIC_RELAXED); 2528 __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED); 2529 __atomic_exchange_n(&x, y, __ATOMIC_RELAXED); 2530 __atomic_fetch_add(&x, y, __ATOMIC_RELAXED); 2531 return 0; 2532 }''')) 2533 2534has_int128_type = cc.compiles(''' 2535 __int128_t a; 2536 __uint128_t b; 2537 int main(void) { b = a; }''') 2538config_host_data.set('CONFIG_INT128_TYPE', has_int128_type) 2539 2540has_int128 = has_int128_type and cc.links(''' 2541 __int128_t a; 2542 __uint128_t b; 2543 int main (void) { 2544 a = a + b; 2545 b = a * b; 2546 a = a * a; 2547 return 0; 2548 }''') 2549config_host_data.set('CONFIG_INT128', has_int128) 2550 2551if has_int128_type 2552 # "do we have 128-bit atomics which are handled inline and specifically not 2553 # via libatomic". The reason we can't use libatomic is documented in the 2554 # comment starting "GCC is a house divided" in include/qemu/atomic128.h. 2555 # We only care about these operations on 16-byte aligned pointers, so 2556 # force 16-byte alignment of the pointer, which may be greater than 2557 # __alignof(unsigned __int128) for the host. 2558 atomic_test_128 = ''' 2559 int main(int ac, char **av) { 2560 __uint128_t *p = __builtin_assume_aligned(av[ac - 1], 16); 2561 p[1] = __atomic_load_n(&p[0], __ATOMIC_RELAXED); 2562 __atomic_store_n(&p[2], p[3], __ATOMIC_RELAXED); 2563 __atomic_compare_exchange_n(&p[4], &p[5], p[6], 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED); 2564 return 0; 2565 }''' 2566 has_atomic128 = cc.links(atomic_test_128) 2567 2568 config_host_data.set('CONFIG_ATOMIC128', has_atomic128) 2569 2570 if not has_atomic128 2571 # Even with __builtin_assume_aligned, the above test may have failed 2572 # without optimization enabled. Try again with optimizations locally 2573 # enabled for the function. See 2574 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107389 2575 has_atomic128_opt = cc.links('__attribute__((optimize("O1")))' + atomic_test_128) 2576 config_host_data.set('CONFIG_ATOMIC128_OPT', has_atomic128_opt) 2577 2578 if not has_atomic128_opt 2579 config_host_data.set('CONFIG_CMPXCHG128', cc.links(''' 2580 int main(void) 2581 { 2582 __uint128_t x = 0, y = 0; 2583 __sync_val_compare_and_swap_16(&x, y, x); 2584 return 0; 2585 } 2586 ''')) 2587 endif 2588 endif 2589endif 2590 2591config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + ''' 2592 #include <sys/auxv.h> 2593 int main(void) { 2594 return getauxval(AT_HWCAP) == 0; 2595 }''')) 2596 2597config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles(''' 2598 #include <linux/usbdevice_fs.h> 2599 2600 #ifndef USBDEVFS_GET_CAPABILITIES 2601 #error "USBDEVFS_GET_CAPABILITIES undefined" 2602 #endif 2603 2604 #ifndef USBDEVFS_DISCONNECT_CLAIM 2605 #error "USBDEVFS_DISCONNECT_CLAIM undefined" 2606 #endif 2607 2608 int main(void) { return 0; }''')) 2609 2610have_keyring = get_option('keyring') \ 2611 .require(targetos == 'linux', error_message: 'keyring is only available on Linux') \ 2612 .require(cc.compiles(''' 2613 #include <errno.h> 2614 #include <asm/unistd.h> 2615 #include <linux/keyctl.h> 2616 #include <sys/syscall.h> 2617 #include <unistd.h> 2618 int main(void) { 2619 return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0); 2620 }'''), error_message: 'keyctl syscall not available on this system').allowed() 2621config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring) 2622 2623have_cpuid_h = cc.links(''' 2624 #include <cpuid.h> 2625 int main(void) { 2626 unsigned a, b, c, d; 2627 unsigned max = __get_cpuid_max(0, 0); 2628 2629 if (max >= 1) { 2630 __cpuid(1, a, b, c, d); 2631 } 2632 2633 if (max >= 7) { 2634 __cpuid_count(7, 0, a, b, c, d); 2635 } 2636 2637 return 0; 2638 }''') 2639config_host_data.set('CONFIG_CPUID_H', have_cpuid_h) 2640 2641config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \ 2642 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \ 2643 .require(cc.links(''' 2644 #include <cpuid.h> 2645 #include <immintrin.h> 2646 static int __attribute__((target("avx2"))) bar(void *a) { 2647 __m256i x = *(__m256i *)a; 2648 return _mm256_testz_si256(x, x); 2649 } 2650 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); } 2651 '''), error_message: 'AVX2 not available').allowed()) 2652 2653config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \ 2654 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \ 2655 .require(cc.links(''' 2656 #include <cpuid.h> 2657 #include <immintrin.h> 2658 static int __attribute__((target("avx512f"))) bar(void *a) { 2659 __m512i x = *(__m512i *)a; 2660 return _mm512_test_epi64_mask(x, x); 2661 } 2662 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); } 2663 '''), error_message: 'AVX512F not available').allowed()) 2664 2665config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \ 2666 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \ 2667 .require(cc.links(''' 2668 #include <cpuid.h> 2669 #include <immintrin.h> 2670 static int __attribute__((target("avx512bw"))) bar(void *a) { 2671 __m512i *x = a; 2672 __m512i res= _mm512_abs_epi8(*x); 2673 return res[1]; 2674 } 2675 int main(int argc, char *argv[]) { return bar(argv[0]); } 2676 '''), error_message: 'AVX512BW not available').allowed()) 2677 2678have_pvrdma = get_option('pvrdma') \ 2679 .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \ 2680 .require(cc.compiles(gnu_source_prefix + ''' 2681 #include <sys/mman.h> 2682 int main(void) 2683 { 2684 char buf = 0; 2685 void *addr = &buf; 2686 addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED); 2687 2688 return 0; 2689 }'''), error_message: 'PVRDMA requires mremap').allowed() 2690 2691if have_pvrdma 2692 config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links(''' 2693 #include <infiniband/verbs.h> 2694 int main(void) 2695 { 2696 struct ibv_mr *mr; 2697 struct ibv_pd *pd = NULL; 2698 size_t length = 10; 2699 uint64_t iova = 0; 2700 int access = 0; 2701 void *addr = NULL; 2702 2703 mr = ibv_reg_mr_iova(pd, addr, length, iova, access); 2704 ibv_dereg_mr(mr); 2705 return 0; 2706 }''')) 2707endif 2708 2709if get_option('membarrier').disabled() 2710 have_membarrier = false 2711elif targetos == 'windows' 2712 have_membarrier = true 2713elif targetos == 'linux' 2714 have_membarrier = cc.compiles(''' 2715 #include <linux/membarrier.h> 2716 #include <sys/syscall.h> 2717 #include <unistd.h> 2718 #include <stdlib.h> 2719 int main(void) { 2720 syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0); 2721 syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0); 2722 exit(0); 2723 }''') 2724endif 2725config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \ 2726 .require(have_membarrier, error_message: 'membarrier system call not available') \ 2727 .allowed()) 2728 2729have_afalg = get_option('crypto_afalg') \ 2730 .require(cc.compiles(gnu_source_prefix + ''' 2731 #include <errno.h> 2732 #include <sys/types.h> 2733 #include <sys/socket.h> 2734 #include <linux/if_alg.h> 2735 int main(void) { 2736 int sock; 2737 sock = socket(AF_ALG, SOCK_SEQPACKET, 0); 2738 return sock; 2739 } 2740 '''), error_message: 'AF_ALG requested but could not be detected').allowed() 2741config_host_data.set('CONFIG_AF_ALG', have_afalg) 2742 2743config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol( 2744 'linux/vm_sockets.h', 'AF_VSOCK', 2745 prefix: '#include <sys/socket.h>', 2746)) 2747 2748have_vss = false 2749have_vss_sdk = false # old xp/2003 SDK 2750if targetos == 'windows' and link_language == 'cpp' 2751 have_vss = cxx.compiles(''' 2752 #define __MIDL_user_allocate_free_DEFINED__ 2753 #include <vss.h> 2754 int main(void) { return VSS_CTX_BACKUP; }''') 2755 have_vss_sdk = cxx.has_header('vscoordint.h') 2756endif 2757config_host_data.set('HAVE_VSS_SDK', have_vss_sdk) 2758 2759foreach k, v: config_host 2760 if k.startswith('CONFIG_') 2761 config_host_data.set(k, v == 'y' ? 1 : v) 2762 endif 2763endforeach 2764 2765# Older versions of MinGW do not import _lock_file and _unlock_file properly. 2766# This was fixed for v6.0.0 with commit b48e3ac8969d. 2767if targetos == 'windows' 2768 config_host_data.set('HAVE__LOCK_FILE', cc.links(''' 2769 #include <stdio.h> 2770 int main(void) { 2771 _lock_file(NULL); 2772 _unlock_file(NULL); 2773 return 0; 2774 }''', name: '_lock_file and _unlock_file')) 2775endif 2776 2777if targetos == 'windows' 2778 mingw_has_setjmp_longjmp = cc.links(''' 2779 #include <setjmp.h> 2780 int main(void) { 2781 /* 2782 * These functions are not available in setjmp header, but may be 2783 * available at link time, from libmingwex.a. 2784 */ 2785 extern int __mingw_setjmp(jmp_buf); 2786 extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int); 2787 jmp_buf env; 2788 __mingw_setjmp(env); 2789 __mingw_longjmp(env, 0); 2790 } 2791 ''', name: 'mingw setjmp and longjmp') 2792 2793 if cpu == 'aarch64' and not mingw_has_setjmp_longjmp 2794 error('mingw must provide setjmp/longjmp for windows-arm64') 2795 endif 2796endif 2797 2798######################## 2799# Target configuration # 2800######################## 2801 2802minikconf = find_program('scripts/minikconf.py') 2803config_all = {} 2804config_all_devices = {} 2805config_all_disas = {} 2806config_devices_mak_list = [] 2807config_devices_h = {} 2808config_target_h = {} 2809config_target_mak = {} 2810 2811disassemblers = { 2812 'alpha' : ['CONFIG_ALPHA_DIS'], 2813 'avr' : ['CONFIG_AVR_DIS'], 2814 'cris' : ['CONFIG_CRIS_DIS'], 2815 'hexagon' : ['CONFIG_HEXAGON_DIS'], 2816 'hppa' : ['CONFIG_HPPA_DIS'], 2817 'i386' : ['CONFIG_I386_DIS'], 2818 'x86_64' : ['CONFIG_I386_DIS'], 2819 'm68k' : ['CONFIG_M68K_DIS'], 2820 'microblaze' : ['CONFIG_MICROBLAZE_DIS'], 2821 'mips' : ['CONFIG_MIPS_DIS'], 2822 'nios2' : ['CONFIG_NIOS2_DIS'], 2823 'or1k' : ['CONFIG_OPENRISC_DIS'], 2824 'ppc' : ['CONFIG_PPC_DIS'], 2825 'riscv' : ['CONFIG_RISCV_DIS'], 2826 'rx' : ['CONFIG_RX_DIS'], 2827 's390' : ['CONFIG_S390_DIS'], 2828 'sh4' : ['CONFIG_SH4_DIS'], 2829 'sparc' : ['CONFIG_SPARC_DIS'], 2830 'xtensa' : ['CONFIG_XTENSA_DIS'], 2831 'loongarch' : ['CONFIG_LOONGARCH_DIS'], 2832} 2833 2834have_ivshmem = config_host_data.get('CONFIG_EVENTFD') 2835host_kconfig = \ 2836 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \ 2837 (have_tpm ? ['CONFIG_TPM=y'] : []) + \ 2838 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \ 2839 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \ 2840 (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \ 2841 (x11.found() ? ['CONFIG_X11=y'] : []) + \ 2842 (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \ 2843 (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \ 2844 (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \ 2845 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \ 2846 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \ 2847 (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \ 2848 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \ 2849 (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : []) 2850 2851ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ] 2852 2853default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host 2854actual_target_dirs = [] 2855fdt_required = [] 2856foreach target : target_dirs 2857 config_target = { 'TARGET_NAME': target.split('-')[0] } 2858 if target.endswith('linux-user') 2859 if targetos != 'linux' 2860 if default_targets 2861 continue 2862 endif 2863 error('Target @0@ is only available on a Linux host'.format(target)) 2864 endif 2865 config_target += { 'CONFIG_LINUX_USER': 'y' } 2866 elif target.endswith('bsd-user') 2867 if 'CONFIG_BSD' not in config_host 2868 if default_targets 2869 continue 2870 endif 2871 error('Target @0@ is only available on a BSD host'.format(target)) 2872 endif 2873 config_target += { 'CONFIG_BSD_USER': 'y' } 2874 elif target.endswith('softmmu') 2875 config_target += { 'CONFIG_SOFTMMU': 'y' } 2876 endif 2877 if target.endswith('-user') 2878 config_target += { 2879 'CONFIG_USER_ONLY': 'y', 2880 'CONFIG_QEMU_INTERP_PREFIX': 2881 get_option('interp_prefix').replace('%M', config_target['TARGET_NAME']) 2882 } 2883 endif 2884 2885 accel_kconfig = [] 2886 foreach sym: accelerators 2887 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, []) 2888 config_target += { sym: 'y' } 2889 config_all += { sym: 'y' } 2890 if target in modular_tcg 2891 config_target += { 'CONFIG_TCG_MODULAR': 'y' } 2892 else 2893 config_target += { 'CONFIG_TCG_BUILTIN': 'y' } 2894 endif 2895 accel_kconfig += [ sym + '=y' ] 2896 endif 2897 endforeach 2898 if accel_kconfig.length() == 0 2899 if default_targets 2900 continue 2901 endif 2902 error('No accelerator available for target @0@'.format(target)) 2903 endif 2904 2905 actual_target_dirs += target 2906 config_target += keyval.load('configs/targets' / target + '.mak') 2907 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' } 2908 2909 if 'TARGET_NEED_FDT' in config_target 2910 fdt_required += target 2911 endif 2912 2913 # Add default keys 2914 if 'TARGET_BASE_ARCH' not in config_target 2915 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']} 2916 endif 2917 if 'TARGET_ABI_DIR' not in config_target 2918 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']} 2919 endif 2920 if 'TARGET_BIG_ENDIAN' not in config_target 2921 config_target += {'TARGET_BIG_ENDIAN': 'n'} 2922 endif 2923 2924 foreach k, v: disassemblers 2925 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k) 2926 foreach sym: v 2927 config_target += { sym: 'y' } 2928 config_all_disas += { sym: 'y' } 2929 endforeach 2930 endif 2931 endforeach 2932 2933 config_target_data = configuration_data() 2934 foreach k, v: config_target 2935 if not k.startswith('TARGET_') and not k.startswith('CONFIG_') 2936 # do nothing 2937 elif ignored.contains(k) 2938 # do nothing 2939 elif k == 'TARGET_BASE_ARCH' 2940 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is 2941 # not used to select files from sourcesets. 2942 config_target_data.set('TARGET_' + v.to_upper(), 1) 2943 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX' 2944 config_target_data.set_quoted(k, v) 2945 elif v == 'y' 2946 config_target_data.set(k, 1) 2947 elif v == 'n' 2948 config_target_data.set(k, 0) 2949 else 2950 config_target_data.set(k, v) 2951 endif 2952 endforeach 2953 config_target_data.set('QEMU_ARCH', 2954 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper()) 2955 config_target_h += {target: configure_file(output: target + '-config-target.h', 2956 configuration: config_target_data)} 2957 2958 if target.endswith('-softmmu') 2959 config_input = meson.get_external_property(target, 'default') 2960 config_devices_mak = target + '-config-devices.mak' 2961 config_devices_mak = configure_file( 2962 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'], 2963 output: config_devices_mak, 2964 depfile: config_devices_mak + '.d', 2965 capture: true, 2966 command: [minikconf, 2967 get_option('default_devices') ? '--defconfig' : '--allnoconfig', 2968 config_devices_mak, '@DEPFILE@', '@INPUT@', 2969 host_kconfig, accel_kconfig, 2970 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y']) 2971 2972 config_devices_data = configuration_data() 2973 config_devices = keyval.load(config_devices_mak) 2974 foreach k, v: config_devices 2975 config_devices_data.set(k, 1) 2976 endforeach 2977 config_devices_mak_list += config_devices_mak 2978 config_devices_h += {target: configure_file(output: target + '-config-devices.h', 2979 configuration: config_devices_data)} 2980 config_target += config_devices 2981 config_all_devices += config_devices 2982 endif 2983 config_target_mak += {target: config_target} 2984endforeach 2985target_dirs = actual_target_dirs 2986 2987# This configuration is used to build files that are shared by 2988# multiple binaries, and then extracted out of the "common" 2989# static_library target. 2990# 2991# We do not use all_sources()/all_dependencies(), because it would 2992# build literally all source files, including devices only used by 2993# targets that are not built for this compilation. The CONFIG_ALL 2994# pseudo symbol replaces it. 2995 2996config_all += config_all_devices 2997config_all += config_host 2998config_all += config_all_disas 2999config_all += { 3000 'CONFIG_XEN': xen.found(), 3001 'CONFIG_SOFTMMU': have_system, 3002 'CONFIG_USER_ONLY': have_user, 3003 'CONFIG_ALL': true, 3004} 3005 3006target_configs_h = [] 3007foreach target: target_dirs 3008 target_configs_h += config_target_h[target] 3009 target_configs_h += config_devices_h.get(target, []) 3010endforeach 3011genh += custom_target('config-poison.h', 3012 input: [target_configs_h], 3013 output: 'config-poison.h', 3014 capture: true, 3015 command: [find_program('scripts/make-config-poison.sh'), 3016 target_configs_h]) 3017 3018############## 3019# Submodules # 3020############## 3021 3022capstone = not_found 3023if not get_option('capstone').auto() or have_system or have_user 3024 capstone = dependency('capstone', version: '>=3.0.5', 3025 method: 'pkg-config', 3026 required: get_option('capstone')) 3027 3028 # Some versions of capstone have broken pkg-config file 3029 # that reports a wrong -I path, causing the #include to 3030 # fail later. If the system has such a broken version 3031 # do not use it. 3032 if capstone.found() and not cc.compiles('#include <capstone.h>', 3033 dependencies: [capstone]) 3034 capstone = not_found 3035 if get_option('capstone').enabled() 3036 error('capstone requested, but it does not appear to work') 3037 endif 3038 endif 3039endif 3040 3041libvfio_user_dep = not_found 3042if have_system and vfio_user_server_allowed 3043 have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build') 3044 3045 if not have_internal 3046 error('libvfio-user source not found - please pull git submodule') 3047 endif 3048 3049 libvfio_user_proj = subproject('libvfio-user') 3050 3051 libvfio_user_dep = libvfio_user_proj.get_variable('libvfio_user_dep') 3052endif 3053 3054fdt = not_found 3055fdt_opt = get_option('fdt') 3056if fdt_required.length() > 0 or fdt_opt == 'enabled' 3057 if fdt_opt == 'disabled' 3058 error('fdt disabled but required by targets ' + ', '.join(fdt_required)) 3059 endif 3060 3061 if fdt_opt in ['enabled', 'auto', 'system'] 3062 fdt = cc.find_library('fdt', required: fdt_opt == 'system') 3063 if fdt.found() and cc.links(''' 3064 #include <libfdt.h> 3065 #include <libfdt_env.h> 3066 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''', 3067 dependencies: fdt) 3068 fdt_opt = 'system' 3069 elif fdt_opt == 'system' 3070 error('system libfdt requested, but it is too old (1.5.1 or newer required)') 3071 else 3072 fdt_opt = 'internal' 3073 fdt = not_found 3074 endif 3075 endif 3076 if not fdt.found() 3077 assert(fdt_opt == 'internal') 3078 have_internal = fs.exists(meson.current_source_dir() / 'subprojects/dtc/meson.build') 3079 3080 if not have_internal 3081 error('libfdt source not found - please pull git submodule') 3082 endif 3083 3084 libfdt_proj = subproject('dtc', required: true, 3085 default_options: ['tools=false', 'yaml=disabled', 3086 'python=disabled', 'default_library=static']) 3087 fdt = libfdt_proj.get_variable('libfdt_dep') 3088 endif 3089else 3090 fdt_opt = 'disabled' 3091endif 3092 3093config_host_data.set('CONFIG_CAPSTONE', capstone.found()) 3094config_host_data.set('CONFIG_FDT', fdt.found()) 3095config_host_data.set('CONFIG_SLIRP', slirp.found()) 3096 3097##################### 3098# Generated sources # 3099##################### 3100 3101genh += configure_file(output: 'config-host.h', configuration: config_host_data) 3102 3103hxtool = find_program('scripts/hxtool') 3104shaderinclude = find_program('scripts/shaderinclude.py') 3105qapi_gen = find_program('scripts/qapi-gen.py') 3106qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py', 3107 meson.current_source_dir() / 'scripts/qapi/commands.py', 3108 meson.current_source_dir() / 'scripts/qapi/common.py', 3109 meson.current_source_dir() / 'scripts/qapi/error.py', 3110 meson.current_source_dir() / 'scripts/qapi/events.py', 3111 meson.current_source_dir() / 'scripts/qapi/expr.py', 3112 meson.current_source_dir() / 'scripts/qapi/gen.py', 3113 meson.current_source_dir() / 'scripts/qapi/introspect.py', 3114 meson.current_source_dir() / 'scripts/qapi/main.py', 3115 meson.current_source_dir() / 'scripts/qapi/parser.py', 3116 meson.current_source_dir() / 'scripts/qapi/schema.py', 3117 meson.current_source_dir() / 'scripts/qapi/source.py', 3118 meson.current_source_dir() / 'scripts/qapi/types.py', 3119 meson.current_source_dir() / 'scripts/qapi/visit.py', 3120 meson.current_source_dir() / 'scripts/qapi-gen.py' 3121] 3122 3123tracetool = [ 3124 python, files('scripts/tracetool.py'), 3125 '--backend=' + ','.join(get_option('trace_backends')) 3126] 3127tracetool_depends = files( 3128 'scripts/tracetool/backend/log.py', 3129 'scripts/tracetool/backend/__init__.py', 3130 'scripts/tracetool/backend/dtrace.py', 3131 'scripts/tracetool/backend/ftrace.py', 3132 'scripts/tracetool/backend/simple.py', 3133 'scripts/tracetool/backend/syslog.py', 3134 'scripts/tracetool/backend/ust.py', 3135 'scripts/tracetool/format/ust_events_c.py', 3136 'scripts/tracetool/format/ust_events_h.py', 3137 'scripts/tracetool/format/__init__.py', 3138 'scripts/tracetool/format/d.py', 3139 'scripts/tracetool/format/simpletrace_stap.py', 3140 'scripts/tracetool/format/c.py', 3141 'scripts/tracetool/format/h.py', 3142 'scripts/tracetool/format/log_stap.py', 3143 'scripts/tracetool/format/stap.py', 3144 'scripts/tracetool/__init__.py', 3145 'scripts/tracetool/vcpu.py' 3146) 3147 3148qemu_version_cmd = [find_program('scripts/qemu-version.sh'), 3149 meson.current_source_dir(), 3150 get_option('pkgversion'), meson.project_version()] 3151qemu_version = custom_target('qemu-version.h', 3152 output: 'qemu-version.h', 3153 command: qemu_version_cmd, 3154 capture: true, 3155 build_by_default: true, 3156 build_always_stale: true) 3157genh += qemu_version 3158 3159hxdep = [] 3160hx_headers = [ 3161 ['qemu-options.hx', 'qemu-options.def'], 3162 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'], 3163] 3164if have_system 3165 hx_headers += [ 3166 ['hmp-commands.hx', 'hmp-commands.h'], 3167 ['hmp-commands-info.hx', 'hmp-commands-info.h'], 3168 ] 3169endif 3170foreach d : hx_headers 3171 hxdep += custom_target(d[1], 3172 input: files(d[0]), 3173 output: d[1], 3174 capture: true, 3175 build_by_default: true, # to be removed when added to a target 3176 command: [hxtool, '-h', '@INPUT0@']) 3177endforeach 3178genh += hxdep 3179 3180################### 3181# Collect sources # 3182################### 3183 3184authz_ss = ss.source_set() 3185blockdev_ss = ss.source_set() 3186block_ss = ss.source_set() 3187chardev_ss = ss.source_set() 3188common_ss = ss.source_set() 3189crypto_ss = ss.source_set() 3190hwcore_ss = ss.source_set() 3191io_ss = ss.source_set() 3192qmp_ss = ss.source_set() 3193qom_ss = ss.source_set() 3194softmmu_ss = ss.source_set() 3195specific_fuzz_ss = ss.source_set() 3196specific_ss = ss.source_set() 3197stub_ss = ss.source_set() 3198trace_ss = ss.source_set() 3199user_ss = ss.source_set() 3200util_ss = ss.source_set() 3201 3202# accel modules 3203qtest_module_ss = ss.source_set() 3204tcg_module_ss = ss.source_set() 3205 3206modules = {} 3207target_modules = {} 3208hw_arch = {} 3209target_arch = {} 3210target_softmmu_arch = {} 3211target_user_arch = {} 3212 3213############### 3214# Trace files # 3215############### 3216 3217# TODO: add each directory to the subdirs from its own meson.build, once 3218# we have those 3219trace_events_subdirs = [ 3220 'crypto', 3221 'qapi', 3222 'qom', 3223 'monitor', 3224 'util', 3225 'gdbstub', 3226] 3227if have_linux_user 3228 trace_events_subdirs += [ 'linux-user' ] 3229endif 3230if have_bsd_user 3231 trace_events_subdirs += [ 'bsd-user' ] 3232endif 3233if have_block 3234 trace_events_subdirs += [ 3235 'authz', 3236 'block', 3237 'io', 3238 'nbd', 3239 'scsi', 3240 ] 3241endif 3242if have_system 3243 trace_events_subdirs += [ 3244 'accel/kvm', 3245 'audio', 3246 'backends', 3247 'backends/tpm', 3248 'chardev', 3249 'ebpf', 3250 'hw/9pfs', 3251 'hw/acpi', 3252 'hw/adc', 3253 'hw/alpha', 3254 'hw/arm', 3255 'hw/audio', 3256 'hw/block', 3257 'hw/block/dataplane', 3258 'hw/char', 3259 'hw/display', 3260 'hw/dma', 3261 'hw/hyperv', 3262 'hw/i2c', 3263 'hw/i386', 3264 'hw/i386/xen', 3265 'hw/i386/kvm', 3266 'hw/ide', 3267 'hw/input', 3268 'hw/intc', 3269 'hw/isa', 3270 'hw/mem', 3271 'hw/mips', 3272 'hw/misc', 3273 'hw/misc/macio', 3274 'hw/net', 3275 'hw/net/can', 3276 'hw/nubus', 3277 'hw/nvme', 3278 'hw/nvram', 3279 'hw/pci', 3280 'hw/pci-host', 3281 'hw/ppc', 3282 'hw/rdma', 3283 'hw/rdma/vmw', 3284 'hw/rtc', 3285 'hw/s390x', 3286 'hw/scsi', 3287 'hw/sd', 3288 'hw/sh4', 3289 'hw/sparc', 3290 'hw/sparc64', 3291 'hw/ssi', 3292 'hw/timer', 3293 'hw/tpm', 3294 'hw/usb', 3295 'hw/vfio', 3296 'hw/virtio', 3297 'hw/watchdog', 3298 'hw/xen', 3299 'hw/gpio', 3300 'migration', 3301 'net', 3302 'softmmu', 3303 'ui', 3304 'hw/remote', 3305 ] 3306endif 3307if have_system or have_user 3308 trace_events_subdirs += [ 3309 'accel/tcg', 3310 'hw/core', 3311 'target/arm', 3312 'target/arm/hvf', 3313 'target/hppa', 3314 'target/i386', 3315 'target/i386/kvm', 3316 'target/mips/tcg', 3317 'target/nios2', 3318 'target/ppc', 3319 'target/riscv', 3320 'target/s390x', 3321 'target/s390x/kvm', 3322 'target/sparc', 3323 ] 3324endif 3325 3326vhost_user = not_found 3327if targetos == 'linux' and have_vhost_user 3328 libvhost_user = subproject('libvhost-user') 3329 vhost_user = libvhost_user.get_variable('vhost_user_dep') 3330endif 3331 3332libvduse = not_found 3333if have_libvduse 3334 libvduse_proj = subproject('libvduse') 3335 libvduse = libvduse_proj.get_variable('libvduse_dep') 3336endif 3337 3338# NOTE: the trace/ subdirectory needs the qapi_trace_events variable 3339# that is filled in by qapi/. 3340subdir('qapi') 3341subdir('qobject') 3342subdir('stubs') 3343subdir('trace') 3344subdir('util') 3345subdir('qom') 3346subdir('authz') 3347subdir('crypto') 3348subdir('ui') 3349subdir('hw') 3350subdir('gdbstub') 3351 3352if enable_modules 3353 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO') 3354 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO') 3355endif 3356 3357qom_ss = qom_ss.apply(config_host, strict: false) 3358libqom = static_library('qom', qom_ss.sources() + genh, 3359 dependencies: [qom_ss.dependencies()], 3360 name_suffix: 'fa') 3361qom = declare_dependency(link_whole: libqom) 3362 3363event_loop_base = files('event-loop-base.c') 3364event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh, 3365 build_by_default: true) 3366event_loop_base = declare_dependency(link_whole: event_loop_base, 3367 dependencies: [qom]) 3368 3369stub_ss = stub_ss.apply(config_all, strict: false) 3370 3371util_ss.add_all(trace_ss) 3372util_ss = util_ss.apply(config_all, strict: false) 3373libqemuutil = static_library('qemuutil', 3374 sources: util_ss.sources() + stub_ss.sources() + genh, 3375 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman]) 3376qemuutil = declare_dependency(link_with: libqemuutil, 3377 sources: genh + version_res, 3378 dependencies: [event_loop_base]) 3379 3380if have_system or have_user 3381 decodetree = generator(find_program('scripts/decodetree.py'), 3382 output: 'decode-@BASENAME@.c.inc', 3383 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@']) 3384 subdir('libdecnumber') 3385 subdir('target') 3386endif 3387 3388subdir('audio') 3389subdir('io') 3390subdir('chardev') 3391subdir('fsdev') 3392subdir('dump') 3393 3394if have_block 3395 block_ss.add(files( 3396 'block.c', 3397 'blockjob.c', 3398 'job.c', 3399 'qemu-io-cmds.c', 3400 )) 3401 if config_host_data.get('CONFIG_REPLICATION') 3402 block_ss.add(files('replication.c')) 3403 endif 3404 3405 subdir('nbd') 3406 subdir('scsi') 3407 subdir('block') 3408 3409 blockdev_ss.add(files( 3410 'blockdev.c', 3411 'blockdev-nbd.c', 3412 'iothread.c', 3413 'job-qmp.c', 3414 ), gnutls) 3415 3416 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon, 3417 # os-win32.c does not 3418 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c')) 3419 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')]) 3420endif 3421 3422common_ss.add(files('cpus-common.c')) 3423specific_ss.add(files('cpu.c')) 3424 3425subdir('softmmu') 3426 3427# Work around a gcc bug/misfeature wherein constant propagation looks 3428# through an alias: 3429# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696 3430# to guess that a const variable is always zero. Without lto, this is 3431# impossible, as the alias is restricted to page-vary-common.c. Indeed, 3432# without lto, not even the alias is required -- we simply use different 3433# declarations in different compilation units. 3434pagevary = files('page-vary-common.c') 3435if get_option('b_lto') 3436 pagevary_flags = ['-fno-lto'] 3437 if get_option('cfi') 3438 pagevary_flags += '-fno-sanitize=cfi-icall' 3439 endif 3440 pagevary = static_library('page-vary-common', sources: pagevary + genh, 3441 c_args: pagevary_flags) 3442 pagevary = declare_dependency(link_with: pagevary) 3443endif 3444common_ss.add(pagevary) 3445specific_ss.add(files('page-vary.c')) 3446 3447subdir('backends') 3448subdir('disas') 3449subdir('migration') 3450subdir('monitor') 3451subdir('net') 3452subdir('replay') 3453subdir('semihosting') 3454subdir('stats') 3455subdir('tcg') 3456subdir('fpu') 3457subdir('accel') 3458subdir('plugins') 3459subdir('ebpf') 3460 3461common_user_inc = [] 3462 3463subdir('common-user') 3464subdir('bsd-user') 3465subdir('linux-user') 3466 3467# needed for fuzzing binaries 3468subdir('tests/qtest/libqos') 3469subdir('tests/qtest/fuzz') 3470 3471# accel modules 3472tcg_real_module_ss = ss.source_set() 3473tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss) 3474specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss) 3475target_modules += { 'accel' : { 'qtest': qtest_module_ss, 3476 'tcg': tcg_real_module_ss }} 3477 3478######################## 3479# Library dependencies # 3480######################## 3481 3482modinfo_collect = find_program('scripts/modinfo-collect.py') 3483modinfo_generate = find_program('scripts/modinfo-generate.py') 3484modinfo_files = [] 3485 3486block_mods = [] 3487softmmu_mods = [] 3488foreach d, list : modules 3489 if not (d == 'block' ? have_block : have_system) 3490 continue 3491 endif 3492 3493 foreach m, module_ss : list 3494 if enable_modules 3495 module_ss = module_ss.apply(config_all, strict: false) 3496 sl = static_library(d + '-' + m, [genh, module_ss.sources()], 3497 dependencies: [modulecommon, module_ss.dependencies()], pic: true) 3498 if d == 'block' 3499 block_mods += sl 3500 else 3501 softmmu_mods += sl 3502 endif 3503 if module_ss.sources() != [] 3504 # FIXME: Should use sl.extract_all_objects(recursive: true) as 3505 # input. Sources can be used multiple times but objects are 3506 # unique when it comes to lookup in compile_commands.json. 3507 # Depnds on a mesion version with 3508 # https://github.com/mesonbuild/meson/pull/8900 3509 modinfo_files += custom_target(d + '-' + m + '.modinfo', 3510 output: d + '-' + m + '.modinfo', 3511 input: module_ss.sources() + genh, 3512 capture: true, 3513 command: [modinfo_collect, module_ss.sources()]) 3514 endif 3515 else 3516 if d == 'block' 3517 block_ss.add_all(module_ss) 3518 else 3519 softmmu_ss.add_all(module_ss) 3520 endif 3521 endif 3522 endforeach 3523endforeach 3524 3525foreach d, list : target_modules 3526 foreach m, module_ss : list 3527 if enable_modules 3528 foreach target : target_dirs 3529 if target.endswith('-softmmu') 3530 config_target = config_target_mak[target] 3531 config_target += config_host 3532 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])] 3533 c_args = ['-DNEED_CPU_H', 3534 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target), 3535 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)] 3536 target_module_ss = module_ss.apply(config_target, strict: false) 3537 if target_module_ss.sources() != [] 3538 module_name = d + '-' + m + '-' + config_target['TARGET_NAME'] 3539 sl = static_library(module_name, 3540 [genh, target_module_ss.sources()], 3541 dependencies: [modulecommon, target_module_ss.dependencies()], 3542 include_directories: target_inc, 3543 c_args: c_args, 3544 pic: true) 3545 softmmu_mods += sl 3546 # FIXME: Should use sl.extract_all_objects(recursive: true) too. 3547 modinfo_files += custom_target(module_name + '.modinfo', 3548 output: module_name + '.modinfo', 3549 input: target_module_ss.sources() + genh, 3550 capture: true, 3551 command: [modinfo_collect, '--target', target, target_module_ss.sources()]) 3552 endif 3553 endif 3554 endforeach 3555 else 3556 specific_ss.add_all(module_ss) 3557 endif 3558 endforeach 3559endforeach 3560 3561if enable_modules 3562 foreach target : target_dirs 3563 if target.endswith('-softmmu') 3564 config_target = config_target_mak[target] 3565 config_devices_mak = target + '-config-devices.mak' 3566 modinfo_src = custom_target('modinfo-' + target + '.c', 3567 output: 'modinfo-' + target + '.c', 3568 input: modinfo_files, 3569 command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'], 3570 capture: true) 3571 3572 modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src) 3573 modinfo_dep = declare_dependency(link_with: modinfo_lib) 3574 3575 arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH'] 3576 hw_arch[arch].add(modinfo_dep) 3577 endif 3578 endforeach 3579endif 3580 3581nm = find_program('nm') 3582undefsym = find_program('scripts/undefsym.py') 3583block_syms = custom_target('block.syms', output: 'block.syms', 3584 input: [libqemuutil, block_mods], 3585 capture: true, 3586 command: [undefsym, nm, '@INPUT@']) 3587qemu_syms = custom_target('qemu.syms', output: 'qemu.syms', 3588 input: [libqemuutil, softmmu_mods], 3589 capture: true, 3590 command: [undefsym, nm, '@INPUT@']) 3591 3592authz_ss = authz_ss.apply(config_host, strict: false) 3593libauthz = static_library('authz', authz_ss.sources() + genh, 3594 dependencies: [authz_ss.dependencies()], 3595 name_suffix: 'fa', 3596 build_by_default: false) 3597 3598authz = declare_dependency(link_whole: libauthz, 3599 dependencies: qom) 3600 3601crypto_ss = crypto_ss.apply(config_host, strict: false) 3602libcrypto = static_library('crypto', crypto_ss.sources() + genh, 3603 dependencies: [crypto_ss.dependencies()], 3604 name_suffix: 'fa', 3605 build_by_default: false) 3606 3607crypto = declare_dependency(link_whole: libcrypto, 3608 dependencies: [authz, qom]) 3609 3610io_ss = io_ss.apply(config_host, strict: false) 3611libio = static_library('io', io_ss.sources() + genh, 3612 dependencies: [io_ss.dependencies()], 3613 link_with: libqemuutil, 3614 name_suffix: 'fa', 3615 build_by_default: false) 3616 3617io = declare_dependency(link_whole: libio, dependencies: [crypto, qom]) 3618 3619libmigration = static_library('migration', sources: migration_files + genh, 3620 name_suffix: 'fa', 3621 build_by_default: false) 3622migration = declare_dependency(link_with: libmigration, 3623 dependencies: [zlib, qom, io]) 3624softmmu_ss.add(migration) 3625 3626block_ss = block_ss.apply(config_host, strict: false) 3627libblock = static_library('block', block_ss.sources() + genh, 3628 dependencies: block_ss.dependencies(), 3629 link_depends: block_syms, 3630 name_suffix: 'fa', 3631 build_by_default: false) 3632 3633block = declare_dependency(link_whole: [libblock], 3634 link_args: '@block.syms', 3635 dependencies: [crypto, io]) 3636 3637blockdev_ss = blockdev_ss.apply(config_host, strict: false) 3638libblockdev = static_library('blockdev', blockdev_ss.sources() + genh, 3639 dependencies: blockdev_ss.dependencies(), 3640 name_suffix: 'fa', 3641 build_by_default: false) 3642 3643blockdev = declare_dependency(link_whole: [libblockdev], 3644 dependencies: [block, event_loop_base]) 3645 3646qmp_ss = qmp_ss.apply(config_host, strict: false) 3647libqmp = static_library('qmp', qmp_ss.sources() + genh, 3648 dependencies: qmp_ss.dependencies(), 3649 name_suffix: 'fa', 3650 build_by_default: false) 3651 3652qmp = declare_dependency(link_whole: [libqmp]) 3653 3654libchardev = static_library('chardev', chardev_ss.sources() + genh, 3655 name_suffix: 'fa', 3656 dependencies: chardev_ss.dependencies(), 3657 build_by_default: false) 3658 3659chardev = declare_dependency(link_whole: libchardev) 3660 3661hwcore_ss = hwcore_ss.apply(config_host, strict: false) 3662libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh, 3663 name_suffix: 'fa', 3664 build_by_default: false) 3665hwcore = declare_dependency(link_whole: libhwcore) 3666common_ss.add(hwcore) 3667 3668########### 3669# Targets # 3670########### 3671 3672emulator_modules = [] 3673foreach m : block_mods + softmmu_mods 3674 emulator_modules += shared_module(m.name(), 3675 build_by_default: true, 3676 name_prefix: '', 3677 link_whole: m, 3678 install: true, 3679 install_dir: qemu_moddir) 3680endforeach 3681if emulator_modules.length() > 0 3682 alias_target('modules', emulator_modules) 3683endif 3684 3685softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp) 3686common_ss.add(qom, qemuutil) 3687 3688common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss]) 3689common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss) 3690 3691common_all = common_ss.apply(config_all, strict: false) 3692common_all = static_library('common', 3693 build_by_default: false, 3694 sources: common_all.sources() + genh, 3695 include_directories: common_user_inc, 3696 implicit_include_directories: false, 3697 dependencies: common_all.dependencies(), 3698 name_suffix: 'fa') 3699 3700feature_to_c = find_program('scripts/feature_to_c.sh') 3701 3702if targetos == 'darwin' 3703 entitlement = find_program('scripts/entitlement.sh') 3704endif 3705 3706emulators = {} 3707foreach target : target_dirs 3708 config_target = config_target_mak[target] 3709 target_name = config_target['TARGET_NAME'] 3710 target_base_arch = config_target['TARGET_BASE_ARCH'] 3711 arch_srcs = [config_target_h[target]] 3712 arch_deps = [] 3713 c_args = ['-DNEED_CPU_H', 3714 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target), 3715 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)] 3716 link_args = emulator_link_args 3717 3718 config_target += config_host 3719 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])] 3720 if targetos == 'linux' 3721 target_inc += include_directories('linux-headers', is_system: true) 3722 endif 3723 if target.endswith('-softmmu') 3724 target_type='system' 3725 t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false) 3726 arch_srcs += t.sources() 3727 arch_deps += t.dependencies() 3728 3729 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch 3730 hw = hw_arch[hw_dir].apply(config_target, strict: false) 3731 arch_srcs += hw.sources() 3732 arch_deps += hw.dependencies() 3733 3734 arch_srcs += config_devices_h[target] 3735 link_args += ['@block.syms', '@qemu.syms'] 3736 else 3737 abi = config_target['TARGET_ABI_DIR'] 3738 target_type='user' 3739 target_inc += common_user_inc 3740 if target_base_arch in target_user_arch 3741 t = target_user_arch[target_base_arch].apply(config_target, strict: false) 3742 arch_srcs += t.sources() 3743 arch_deps += t.dependencies() 3744 endif 3745 if 'CONFIG_LINUX_USER' in config_target 3746 base_dir = 'linux-user' 3747 endif 3748 if 'CONFIG_BSD_USER' in config_target 3749 base_dir = 'bsd-user' 3750 target_inc += include_directories('bsd-user/' / targetos) 3751 target_inc += include_directories('bsd-user/host/' / host_arch) 3752 dir = base_dir / abi 3753 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c') 3754 endif 3755 target_inc += include_directories( 3756 base_dir, 3757 base_dir / abi, 3758 ) 3759 if 'CONFIG_LINUX_USER' in config_target 3760 dir = base_dir / abi 3761 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c') 3762 if config_target.has_key('TARGET_SYSTBL_ABI') 3763 arch_srcs += \ 3764 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'], 3765 extra_args : config_target['TARGET_SYSTBL_ABI']) 3766 endif 3767 endif 3768 endif 3769 3770 if 'TARGET_XML_FILES' in config_target 3771 gdbstub_xml = custom_target(target + '-gdbstub-xml.c', 3772 output: target + '-gdbstub-xml.c', 3773 input: files(config_target['TARGET_XML_FILES'].split()), 3774 command: [feature_to_c, '@INPUT@'], 3775 capture: true) 3776 arch_srcs += gdbstub_xml 3777 endif 3778 3779 t = target_arch[target_base_arch].apply(config_target, strict: false) 3780 arch_srcs += t.sources() 3781 arch_deps += t.dependencies() 3782 3783 target_common = common_ss.apply(config_target, strict: false) 3784 objects = common_all.extract_objects(target_common.sources()) 3785 deps = target_common.dependencies() 3786 3787 target_specific = specific_ss.apply(config_target, strict: false) 3788 arch_srcs += target_specific.sources() 3789 arch_deps += target_specific.dependencies() 3790 3791 lib = static_library('qemu-' + target, 3792 sources: arch_srcs + genh, 3793 dependencies: arch_deps, 3794 objects: objects, 3795 include_directories: target_inc, 3796 c_args: c_args, 3797 build_by_default: false, 3798 name_suffix: 'fa') 3799 3800 if target.endswith('-softmmu') 3801 execs = [{ 3802 'name': 'qemu-system-' + target_name, 3803 'win_subsystem': 'console', 3804 'sources': files('softmmu/main.c'), 3805 'dependencies': [] 3806 }] 3807 if targetos == 'windows' and (sdl.found() or gtk.found()) 3808 execs += [{ 3809 'name': 'qemu-system-' + target_name + 'w', 3810 'win_subsystem': 'windows', 3811 'sources': files('softmmu/main.c'), 3812 'dependencies': [] 3813 }] 3814 endif 3815 if get_option('fuzzing') 3816 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false) 3817 execs += [{ 3818 'name': 'qemu-fuzz-' + target_name, 3819 'win_subsystem': 'console', 3820 'sources': specific_fuzz.sources(), 3821 'dependencies': specific_fuzz.dependencies(), 3822 }] 3823 endif 3824 else 3825 execs = [{ 3826 'name': 'qemu-' + target_name, 3827 'win_subsystem': 'console', 3828 'sources': [], 3829 'dependencies': [] 3830 }] 3831 endif 3832 foreach exe: execs 3833 exe_name = exe['name'] 3834 if targetos == 'darwin' 3835 exe_name += '-unsigned' 3836 endif 3837 3838 emulator = executable(exe_name, exe['sources'], 3839 install: true, 3840 c_args: c_args, 3841 dependencies: arch_deps + deps + exe['dependencies'], 3842 objects: lib.extract_all_objects(recursive: true), 3843 link_language: link_language, 3844 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []), 3845 link_args: link_args, 3846 win_subsystem: exe['win_subsystem']) 3847 3848 if targetos == 'darwin' 3849 icon = 'pc-bios/qemu.rsrc' 3850 build_input = [emulator, files(icon)] 3851 install_input = [ 3852 get_option('bindir') / exe_name, 3853 meson.current_source_dir() / icon 3854 ] 3855 if 'CONFIG_HVF' in config_target 3856 entitlements = 'accel/hvf/entitlements.plist' 3857 build_input += files(entitlements) 3858 install_input += meson.current_source_dir() / entitlements 3859 endif 3860 3861 emulators += {exe['name'] : custom_target(exe['name'], 3862 input: build_input, 3863 output: exe['name'], 3864 command: [entitlement, '@OUTPUT@', '@INPUT@']) 3865 } 3866 3867 meson.add_install_script(entitlement, '--install', 3868 get_option('bindir') / exe['name'], 3869 install_input) 3870 else 3871 emulators += {exe['name']: emulator} 3872 endif 3873 3874 if stap.found() 3875 foreach stp: [ 3876 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false}, 3877 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true}, 3878 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true}, 3879 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true}, 3880 ] 3881 custom_target(exe['name'] + stp['ext'], 3882 input: trace_events_all, 3883 output: exe['name'] + stp['ext'], 3884 install: stp['install'], 3885 install_dir: get_option('datadir') / 'systemtap/tapset', 3886 command: [ 3887 tracetool, '--group=all', '--format=' + stp['fmt'], 3888 '--binary=' + stp['bin'], 3889 '--target-name=' + target_name, 3890 '--target-type=' + target_type, 3891 '--probe-prefix=qemu.' + target_type + '.' + target_name, 3892 '@INPUT@', '@OUTPUT@' 3893 ], 3894 depend_files: tracetool_depends) 3895 endforeach 3896 endif 3897 endforeach 3898endforeach 3899 3900# Other build targets 3901 3902if 'CONFIG_PLUGIN' in config_host 3903 install_headers('include/qemu/qemu-plugin.h') 3904endif 3905 3906subdir('qga') 3907 3908# Don't build qemu-keymap if xkbcommon is not explicitly enabled 3909# when we don't build tools or system 3910if xkbcommon.found() 3911 # used for the update-keymaps target, so include rules even if !have_tools 3912 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh, 3913 dependencies: [qemuutil, xkbcommon], install: have_tools) 3914endif 3915 3916if have_tools 3917 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep], 3918 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true) 3919 qemu_io = executable('qemu-io', files('qemu-io.c'), 3920 dependencies: [block, qemuutil], install: true) 3921 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'), 3922 dependencies: [blockdev, qemuutil, gnutls, selinux], 3923 install: true) 3924 3925 subdir('storage-daemon') 3926 subdir('contrib/rdmacm-mux') 3927 subdir('contrib/elf2dmp') 3928 3929 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'), 3930 dependencies: qemuutil, 3931 install: true) 3932 3933 if have_vhost_user 3934 subdir('contrib/vhost-user-blk') 3935 subdir('contrib/vhost-user-gpu') 3936 subdir('contrib/vhost-user-input') 3937 subdir('contrib/vhost-user-scsi') 3938 endif 3939 3940 if targetos == 'linux' 3941 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'), 3942 dependencies: [qemuutil, libcap_ng], 3943 install: true, 3944 install_dir: get_option('libexecdir')) 3945 3946 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'), 3947 dependencies: [authz, crypto, io, qom, qemuutil, 3948 libcap_ng, mpathpersist], 3949 install: true) 3950 endif 3951 3952 if have_ivshmem 3953 subdir('contrib/ivshmem-client') 3954 subdir('contrib/ivshmem-server') 3955 endif 3956endif 3957 3958subdir('scripts') 3959subdir('tools') 3960subdir('pc-bios') 3961subdir('docs') 3962subdir('tests') 3963if gtk.found() 3964 subdir('po') 3965endif 3966 3967if host_machine.system() == 'windows' 3968 nsis_cmd = [ 3969 find_program('scripts/nsis.py'), 3970 '@OUTPUT@', 3971 get_option('prefix'), 3972 meson.current_source_dir(), 3973 glib_pc.get_variable('bindir'), 3974 host_machine.cpu(), 3975 '--', 3976 '-DDISPLAYVERSION=' + meson.project_version(), 3977 ] 3978 if build_docs 3979 nsis_cmd += '-DCONFIG_DOCUMENTATION=y' 3980 endif 3981 if gtk.found() 3982 nsis_cmd += '-DCONFIG_GTK=y' 3983 endif 3984 3985 nsis = custom_target('nsis', 3986 output: 'qemu-setup-' + meson.project_version() + '.exe', 3987 input: files('qemu.nsi'), 3988 build_always_stale: true, 3989 command: nsis_cmd + ['@INPUT@']) 3990 alias_target('installer', nsis) 3991endif 3992 3993######################### 3994# Configuration summary # 3995######################### 3996 3997# Directories 3998summary_info = {} 3999summary_info += {'Install prefix': get_option('prefix')} 4000summary_info += {'BIOS directory': qemu_datadir} 4001pathsep = targetos == 'windows' ? ';' : ':' 4002summary_info += {'firmware path': pathsep.join(get_option('qemu_firmwarepath'))} 4003summary_info += {'binary directory': get_option('prefix') / get_option('bindir')} 4004summary_info += {'library directory': get_option('prefix') / get_option('libdir')} 4005summary_info += {'module directory': qemu_moddir} 4006summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')} 4007summary_info += {'include directory': get_option('prefix') / get_option('includedir')} 4008summary_info += {'config directory': get_option('prefix') / get_option('sysconfdir')} 4009if targetos != 'windows' 4010 summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')} 4011 summary_info += {'Manual directory': get_option('prefix') / get_option('mandir')} 4012else 4013 summary_info += {'local state directory': 'queried at runtime'} 4014endif 4015summary_info += {'Doc directory': get_option('prefix') / get_option('docdir')} 4016summary_info += {'Build directory': meson.current_build_dir()} 4017summary_info += {'Source path': meson.current_source_dir()} 4018summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']} 4019summary(summary_info, bool_yn: true, section: 'Directories') 4020 4021# Host binaries 4022summary_info = {} 4023summary_info += {'git': config_host['GIT']} 4024summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())} 4025summary_info += {'sphinx-build': sphinx_build} 4026if config_host.has_key('HAVE_GDB_BIN') 4027 summary_info += {'gdb': config_host['HAVE_GDB_BIN']} 4028endif 4029summary_info += {'iasl': iasl} 4030summary_info += {'genisoimage': config_host['GENISOIMAGE']} 4031if targetos == 'windows' and have_ga 4032 summary_info += {'wixl': wixl} 4033endif 4034if slirp.found() and have_system 4035 summary_info += {'smbd': have_slirp_smbd ? smbd_path : false} 4036endif 4037summary(summary_info, bool_yn: true, section: 'Host binaries') 4038 4039# Configurable features 4040summary_info = {} 4041summary_info += {'Documentation': build_docs} 4042summary_info += {'system-mode emulation': have_system} 4043summary_info += {'user-mode emulation': have_user} 4044summary_info += {'block layer': have_block} 4045summary_info += {'Install blobs': get_option('install_blobs')} 4046summary_info += {'module support': enable_modules} 4047if enable_modules 4048 summary_info += {'alternative module path': get_option('module_upgrades')} 4049endif 4050summary_info += {'fuzzing support': get_option('fuzzing')} 4051if have_system 4052 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)} 4053endif 4054summary_info += {'Trace backends': ','.join(get_option('trace_backends'))} 4055if 'simple' in get_option('trace_backends') 4056 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'} 4057endif 4058summary_info += {'D-Bus display': dbus_display} 4059summary_info += {'QOM debugging': get_option('qom_cast_debug')} 4060summary_info += {'vhost-kernel support': have_vhost_kernel} 4061summary_info += {'vhost-net support': have_vhost_net} 4062summary_info += {'vhost-user support': have_vhost_user} 4063summary_info += {'vhost-user-crypto support': have_vhost_user_crypto} 4064summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server} 4065summary_info += {'vhost-vdpa support': have_vhost_vdpa} 4066summary_info += {'build guest agent': have_ga} 4067summary(summary_info, bool_yn: true, section: 'Configurable features') 4068 4069# Compilation information 4070summary_info = {} 4071summary_info += {'host CPU': cpu} 4072summary_info += {'host endianness': build_machine.endian()} 4073summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())} 4074summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())} 4075if link_language == 'cpp' 4076 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())} 4077else 4078 summary_info += {'C++ compiler': false} 4079endif 4080if targetos == 'darwin' 4081 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())} 4082endif 4083option_cflags = (get_option('debug') ? ['-g'] : []) 4084if get_option('optimization') != 'plain' 4085 option_cflags += ['-O' + get_option('optimization')] 4086endif 4087summary_info += {'CFLAGS': ' '.join(get_option('c_args') + option_cflags)} 4088if link_language == 'cpp' 4089 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args') + option_cflags)} 4090endif 4091if targetos == 'darwin' 4092 summary_info += {'OBJCFLAGS': ' '.join(get_option('objc_args') + option_cflags)} 4093endif 4094link_args = get_option(link_language + '_link_args') 4095if link_args.length() > 0 4096 summary_info += {'LDFLAGS': ' '.join(link_args)} 4097endif 4098summary_info += {'QEMU_CFLAGS': ' '.join(qemu_common_flags + qemu_cflags)} 4099if 'cpp' in all_languages 4100 summary_info += {'QEMU_CXXFLAGS': ' '.join(qemu_common_flags + qemu_cxxflags)} 4101endif 4102if 'objc' in all_languages 4103 summary_info += {'QEMU_OBJCFLAGS': ' '.join(qemu_common_flags)} 4104endif 4105summary_info += {'QEMU_LDFLAGS': ' '.join(qemu_ldflags)} 4106summary_info += {'profiler': get_option('profiler')} 4107summary_info += {'link-time optimization (LTO)': get_option('b_lto')} 4108summary_info += {'PIE': get_option('b_pie')} 4109summary_info += {'static build': config_host.has_key('CONFIG_STATIC')} 4110summary_info += {'malloc trim support': has_malloc_trim} 4111summary_info += {'membarrier': have_membarrier} 4112summary_info += {'debug graph lock': get_option('debug_graph_lock')} 4113summary_info += {'debug stack usage': get_option('debug_stack_usage')} 4114summary_info += {'mutex debugging': get_option('debug_mutex')} 4115summary_info += {'memory allocator': get_option('malloc')} 4116summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')} 4117summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')} 4118summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')} 4119if get_option('gprof') 4120 gprof_info = 'YES (deprecated)' 4121else 4122 gprof_info = get_option('gprof') 4123endif 4124summary_info += {'gprof': gprof_info} 4125summary_info += {'gcov': get_option('b_coverage')} 4126summary_info += {'thread sanitizer': get_option('tsan')} 4127summary_info += {'CFI support': get_option('cfi')} 4128if get_option('cfi') 4129 summary_info += {'CFI debug support': get_option('cfi_debug')} 4130endif 4131summary_info += {'strip binaries': get_option('strip')} 4132summary_info += {'sparse': sparse} 4133summary_info += {'mingw32 support': targetos == 'windows'} 4134summary(summary_info, bool_yn: true, section: 'Compilation') 4135 4136# snarf the cross-compilation information for tests 4137summary_info = {} 4138have_cross = false 4139foreach target: target_dirs 4140 tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak' 4141 if fs.exists(tcg_mak) 4142 config_cross_tcg = keyval.load(tcg_mak) 4143 if 'CC' in config_cross_tcg 4144 summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']} 4145 have_cross = true 4146 endif 4147 endif 4148endforeach 4149if have_cross 4150 summary(summary_info, bool_yn: true, section: 'Cross compilers') 4151endif 4152 4153# Targets and accelerators 4154summary_info = {} 4155if have_system 4156 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')} 4157 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')} 4158 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')} 4159 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')} 4160 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')} 4161 summary_info += {'Xen support': xen.found()} 4162 if xen.found() 4163 summary_info += {'xen ctrl version': xen.version()} 4164 endif 4165 summary_info += {'Xen emulation': config_all.has_key('CONFIG_XEN_EMU')} 4166endif 4167summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')} 4168if config_all.has_key('CONFIG_TCG') 4169 if get_option('tcg_interpreter') 4170 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'} 4171 else 4172 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)} 4173 endif 4174 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')} 4175 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')} 4176endif 4177summary_info += {'target list': ' '.join(target_dirs)} 4178if have_system 4179 summary_info += {'default devices': get_option('default_devices')} 4180 summary_info += {'out of process emulation': multiprocess_allowed} 4181 summary_info += {'vfio-user server': vfio_user_server_allowed} 4182endif 4183summary(summary_info, bool_yn: true, section: 'Targets and accelerators') 4184 4185# Block layer 4186summary_info = {} 4187summary_info += {'coroutine backend': coroutine_backend} 4188summary_info += {'coroutine pool': have_coroutine_pool} 4189if have_block 4190 summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')} 4191 summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')} 4192 summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')} 4193 summary_info += {'VirtFS (9P) support': have_virtfs} 4194 summary_info += {'VirtFS (9P) Proxy Helper support': have_virtfs_proxy_helper} 4195 summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')} 4196 summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')} 4197 summary_info += {'bochs support': get_option('bochs').allowed()} 4198 summary_info += {'cloop support': get_option('cloop').allowed()} 4199 summary_info += {'dmg support': get_option('dmg').allowed()} 4200 summary_info += {'qcow v1 support': get_option('qcow1').allowed()} 4201 summary_info += {'vdi support': get_option('vdi').allowed()} 4202 summary_info += {'vhdx support': get_option('vhdx').allowed()} 4203 summary_info += {'vmdk support': get_option('vmdk').allowed()} 4204 summary_info += {'vpc support': get_option('vpc').allowed()} 4205 summary_info += {'vvfat support': get_option('vvfat').allowed()} 4206 summary_info += {'qed support': get_option('qed').allowed()} 4207 summary_info += {'parallels support': get_option('parallels').allowed()} 4208 summary_info += {'FUSE exports': fuse} 4209 summary_info += {'VDUSE block exports': have_vduse_blk_export} 4210endif 4211summary(summary_info, bool_yn: true, section: 'Block layer support') 4212 4213# Crypto 4214summary_info = {} 4215summary_info += {'TLS priority': get_option('tls_priority')} 4216summary_info += {'GNUTLS support': gnutls} 4217if gnutls.found() 4218 summary_info += {' GNUTLS crypto': gnutls_crypto.found()} 4219endif 4220summary_info += {'libgcrypt': gcrypt} 4221summary_info += {'nettle': nettle} 4222if nettle.found() 4223 summary_info += {' XTS': xts != 'private'} 4224endif 4225summary_info += {'AF_ALG support': have_afalg} 4226summary_info += {'rng-none': get_option('rng_none')} 4227summary_info += {'Linux keyring': have_keyring} 4228summary(summary_info, bool_yn: true, section: 'Crypto') 4229 4230# Libraries 4231summary_info = {} 4232if targetos == 'darwin' 4233 summary_info += {'Cocoa support': cocoa} 4234 summary_info += {'vmnet.framework support': vmnet} 4235endif 4236summary_info += {'SDL support': sdl} 4237summary_info += {'SDL image support': sdl_image} 4238summary_info += {'GTK support': gtk} 4239summary_info += {'pixman': pixman} 4240summary_info += {'VTE support': vte} 4241summary_info += {'slirp support': slirp} 4242summary_info += {'libtasn1': tasn1} 4243summary_info += {'PAM': pam} 4244summary_info += {'iconv support': iconv} 4245summary_info += {'curses support': curses} 4246summary_info += {'virgl support': virgl} 4247summary_info += {'blkio support': blkio} 4248summary_info += {'curl support': curl} 4249summary_info += {'Multipath support': mpathpersist} 4250summary_info += {'PNG support': png} 4251summary_info += {'VNC support': vnc} 4252if vnc.found() 4253 summary_info += {'VNC SASL support': sasl} 4254 summary_info += {'VNC JPEG support': jpeg} 4255endif 4256if targetos not in ['darwin', 'haiku', 'windows'] 4257 summary_info += {'OSS support': oss} 4258 summary_info += {'sndio support': sndio} 4259elif targetos == 'darwin' 4260 summary_info += {'CoreAudio support': coreaudio} 4261elif targetos == 'windows' 4262 summary_info += {'DirectSound support': dsound} 4263endif 4264if targetos == 'linux' 4265 summary_info += {'ALSA support': alsa} 4266 summary_info += {'PulseAudio support': pulse} 4267endif 4268summary_info += {'Pipewire support': pipewire} 4269summary_info += {'JACK support': jack} 4270summary_info += {'brlapi support': brlapi} 4271summary_info += {'vde support': vde} 4272summary_info += {'netmap support': have_netmap} 4273summary_info += {'l2tpv3 support': have_l2tpv3} 4274summary_info += {'Linux AIO support': libaio} 4275summary_info += {'Linux io_uring support': linux_io_uring} 4276summary_info += {'ATTR/XATTR support': libattr} 4277summary_info += {'RDMA support': rdma} 4278summary_info += {'PVRDMA support': have_pvrdma} 4279summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt} 4280summary_info += {'libcap-ng support': libcap_ng} 4281summary_info += {'bpf support': libbpf} 4282summary_info += {'spice protocol support': spice_protocol} 4283if spice_protocol.found() 4284 summary_info += {' spice server support': spice} 4285endif 4286summary_info += {'rbd support': rbd} 4287summary_info += {'smartcard support': cacard} 4288summary_info += {'U2F support': u2f} 4289summary_info += {'libusb': libusb} 4290summary_info += {'usb net redir': usbredir} 4291summary_info += {'OpenGL support (epoxy)': opengl} 4292summary_info += {'GBM': gbm} 4293summary_info += {'libiscsi support': libiscsi} 4294summary_info += {'libnfs support': libnfs} 4295if targetos == 'windows' 4296 if have_ga 4297 summary_info += {'QGA VSS support': have_qga_vss} 4298 endif 4299endif 4300summary_info += {'seccomp support': seccomp} 4301summary_info += {'GlusterFS support': glusterfs} 4302summary_info += {'TPM support': have_tpm} 4303summary_info += {'libssh support': libssh} 4304summary_info += {'lzo support': lzo} 4305summary_info += {'snappy support': snappy} 4306summary_info += {'bzip2 support': libbzip2} 4307summary_info += {'lzfse support': liblzfse} 4308summary_info += {'zstd support': zstd} 4309summary_info += {'NUMA host support': numa} 4310summary_info += {'capstone': capstone} 4311summary_info += {'libpmem support': libpmem} 4312summary_info += {'libdaxctl support': libdaxctl} 4313summary_info += {'libudev': libudev} 4314# Dummy dependency, keep .found() 4315summary_info += {'FUSE lseek': fuse_lseek.found()} 4316summary_info += {'selinux': selinux} 4317summary_info += {'libdw': libdw} 4318summary(summary_info, bool_yn: true, section: 'Dependencies') 4319 4320if not supported_cpus.contains(cpu) 4321 message() 4322 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!') 4323 message() 4324 message('CPU host architecture ' + cpu + ' support is not currently maintained.') 4325 message('The QEMU project intends to remove support for this host CPU in') 4326 message('a future release if nobody volunteers to maintain it and to') 4327 message('provide a build host for our continuous integration setup.') 4328 message('configure has succeeded and you can continue to build, but') 4329 message('if you care about QEMU on this platform you should contact') 4330 message('us upstream at qemu-devel@nongnu.org.') 4331endif 4332 4333if not supported_oses.contains(targetos) 4334 message() 4335 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!') 4336 message() 4337 message('Host OS ' + targetos + 'support is not currently maintained.') 4338 message('The QEMU project intends to remove support for this host OS in') 4339 message('a future release if nobody volunteers to maintain it and to') 4340 message('provide a build host for our continuous integration setup.') 4341 message('configure has succeeded and you can continue to build, but') 4342 message('if you care about QEMU on this platform you should contact') 4343 message('us upstream at qemu-devel@nongnu.org.') 4344endif 4345