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