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