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 = cc.links(''' 2547 __int128_t a; 2548 __uint128_t b; 2549 int main (void) { 2550 a = a + b; 2551 b = a * b; 2552 a = a * a; 2553 return 0; 2554 }''') 2555 2556config_host_data.set('CONFIG_INT128', has_int128) 2557 2558if has_int128 2559 # "do we have 128-bit atomics which are handled inline and specifically not 2560 # via libatomic". The reason we can't use libatomic is documented in the 2561 # comment starting "GCC is a house divided" in include/qemu/atomic128.h. 2562 # We only care about these operations on 16-byte aligned pointers, so 2563 # force 16-byte alignment of the pointer, which may be greater than 2564 # __alignof(unsigned __int128) for the host. 2565 atomic_test_128 = ''' 2566 int main(int ac, char **av) { 2567 unsigned __int128 *p = __builtin_assume_aligned(av[ac - 1], 16); 2568 p[1] = __atomic_load_n(&p[0], __ATOMIC_RELAXED); 2569 __atomic_store_n(&p[2], p[3], __ATOMIC_RELAXED); 2570 __atomic_compare_exchange_n(&p[4], &p[5], p[6], 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED); 2571 return 0; 2572 }''' 2573 has_atomic128 = cc.links(atomic_test_128) 2574 2575 config_host_data.set('CONFIG_ATOMIC128', has_atomic128) 2576 2577 if not has_atomic128 2578 # Even with __builtin_assume_aligned, the above test may have failed 2579 # without optimization enabled. Try again with optimizations locally 2580 # enabled for the function. See 2581 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107389 2582 has_atomic128_opt = cc.links('__attribute__((optimize("O1")))' + atomic_test_128) 2583 config_host_data.set('CONFIG_ATOMIC128_OPT', has_atomic128_opt) 2584 2585 if not has_atomic128_opt 2586 config_host_data.set('CONFIG_CMPXCHG128', cc.links(''' 2587 int main(void) 2588 { 2589 unsigned __int128 x = 0, y = 0; 2590 __sync_val_compare_and_swap_16(&x, y, x); 2591 return 0; 2592 } 2593 ''')) 2594 endif 2595 endif 2596endif 2597 2598config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + ''' 2599 #include <sys/auxv.h> 2600 int main(void) { 2601 return getauxval(AT_HWCAP) == 0; 2602 }''')) 2603 2604config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles(''' 2605 #include <linux/usbdevice_fs.h> 2606 2607 #ifndef USBDEVFS_GET_CAPABILITIES 2608 #error "USBDEVFS_GET_CAPABILITIES undefined" 2609 #endif 2610 2611 #ifndef USBDEVFS_DISCONNECT_CLAIM 2612 #error "USBDEVFS_DISCONNECT_CLAIM undefined" 2613 #endif 2614 2615 int main(void) { return 0; }''')) 2616 2617have_keyring = get_option('keyring') \ 2618 .require(targetos == 'linux', error_message: 'keyring is only available on Linux') \ 2619 .require(cc.compiles(''' 2620 #include <errno.h> 2621 #include <asm/unistd.h> 2622 #include <linux/keyctl.h> 2623 #include <sys/syscall.h> 2624 #include <unistd.h> 2625 int main(void) { 2626 return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0); 2627 }'''), error_message: 'keyctl syscall not available on this system').allowed() 2628config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring) 2629 2630have_cpuid_h = cc.links(''' 2631 #include <cpuid.h> 2632 int main(void) { 2633 unsigned a, b, c, d; 2634 unsigned max = __get_cpuid_max(0, 0); 2635 2636 if (max >= 1) { 2637 __cpuid(1, a, b, c, d); 2638 } 2639 2640 if (max >= 7) { 2641 __cpuid_count(7, 0, a, b, c, d); 2642 } 2643 2644 return 0; 2645 }''') 2646config_host_data.set('CONFIG_CPUID_H', have_cpuid_h) 2647 2648config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \ 2649 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \ 2650 .require(cc.links(''' 2651 #include <cpuid.h> 2652 #include <immintrin.h> 2653 static int __attribute__((target("avx2"))) bar(void *a) { 2654 __m256i x = *(__m256i *)a; 2655 return _mm256_testz_si256(x, x); 2656 } 2657 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); } 2658 '''), error_message: 'AVX2 not available').allowed()) 2659 2660config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \ 2661 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \ 2662 .require(cc.links(''' 2663 #include <cpuid.h> 2664 #include <immintrin.h> 2665 static int __attribute__((target("avx512f"))) bar(void *a) { 2666 __m512i x = *(__m512i *)a; 2667 return _mm512_test_epi64_mask(x, x); 2668 } 2669 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); } 2670 '''), error_message: 'AVX512F not available').allowed()) 2671 2672config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \ 2673 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \ 2674 .require(cc.links(''' 2675 #include <cpuid.h> 2676 #include <immintrin.h> 2677 static int __attribute__((target("avx512bw"))) bar(void *a) { 2678 __m512i *x = a; 2679 __m512i res= _mm512_abs_epi8(*x); 2680 return res[1]; 2681 } 2682 int main(int argc, char *argv[]) { return bar(argv[0]); } 2683 '''), error_message: 'AVX512BW not available').allowed()) 2684 2685have_pvrdma = get_option('pvrdma') \ 2686 .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \ 2687 .require(cc.compiles(gnu_source_prefix + ''' 2688 #include <sys/mman.h> 2689 int main(void) 2690 { 2691 char buf = 0; 2692 void *addr = &buf; 2693 addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED); 2694 2695 return 0; 2696 }'''), error_message: 'PVRDMA requires mremap').allowed() 2697 2698if have_pvrdma 2699 config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links(''' 2700 #include <infiniband/verbs.h> 2701 int main(void) 2702 { 2703 struct ibv_mr *mr; 2704 struct ibv_pd *pd = NULL; 2705 size_t length = 10; 2706 uint64_t iova = 0; 2707 int access = 0; 2708 void *addr = NULL; 2709 2710 mr = ibv_reg_mr_iova(pd, addr, length, iova, access); 2711 ibv_dereg_mr(mr); 2712 return 0; 2713 }''')) 2714endif 2715 2716if get_option('membarrier').disabled() 2717 have_membarrier = false 2718elif targetos == 'windows' 2719 have_membarrier = true 2720elif targetos == 'linux' 2721 have_membarrier = cc.compiles(''' 2722 #include <linux/membarrier.h> 2723 #include <sys/syscall.h> 2724 #include <unistd.h> 2725 #include <stdlib.h> 2726 int main(void) { 2727 syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0); 2728 syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0); 2729 exit(0); 2730 }''') 2731endif 2732config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \ 2733 .require(have_membarrier, error_message: 'membarrier system call not available') \ 2734 .allowed()) 2735 2736have_afalg = get_option('crypto_afalg') \ 2737 .require(cc.compiles(gnu_source_prefix + ''' 2738 #include <errno.h> 2739 #include <sys/types.h> 2740 #include <sys/socket.h> 2741 #include <linux/if_alg.h> 2742 int main(void) { 2743 int sock; 2744 sock = socket(AF_ALG, SOCK_SEQPACKET, 0); 2745 return sock; 2746 } 2747 '''), error_message: 'AF_ALG requested but could not be detected').allowed() 2748config_host_data.set('CONFIG_AF_ALG', have_afalg) 2749 2750config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol( 2751 'linux/vm_sockets.h', 'AF_VSOCK', 2752 prefix: '#include <sys/socket.h>', 2753)) 2754 2755have_vss = false 2756have_vss_sdk = false # old xp/2003 SDK 2757if targetos == 'windows' and link_language == 'cpp' 2758 have_vss = cxx.compiles(''' 2759 #define __MIDL_user_allocate_free_DEFINED__ 2760 #include <vss.h> 2761 int main(void) { return VSS_CTX_BACKUP; }''') 2762 have_vss_sdk = cxx.has_header('vscoordint.h') 2763endif 2764config_host_data.set('HAVE_VSS_SDK', have_vss_sdk) 2765 2766foreach k, v: config_host 2767 if k.startswith('CONFIG_') 2768 config_host_data.set(k, v == 'y' ? 1 : v) 2769 endif 2770endforeach 2771 2772# Older versions of MinGW do not import _lock_file and _unlock_file properly. 2773# This was fixed for v6.0.0 with commit b48e3ac8969d. 2774if targetos == 'windows' 2775 config_host_data.set('HAVE__LOCK_FILE', cc.links(''' 2776 #include <stdio.h> 2777 int main(void) { 2778 _lock_file(NULL); 2779 _unlock_file(NULL); 2780 return 0; 2781 }''', name: '_lock_file and _unlock_file')) 2782endif 2783 2784if targetos == 'windows' 2785 mingw_has_setjmp_longjmp = cc.links(''' 2786 #include <setjmp.h> 2787 int main(void) { 2788 /* 2789 * These functions are not available in setjmp header, but may be 2790 * available at link time, from libmingwex.a. 2791 */ 2792 extern int __mingw_setjmp(jmp_buf); 2793 extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int); 2794 jmp_buf env; 2795 __mingw_setjmp(env); 2796 __mingw_longjmp(env, 0); 2797 } 2798 ''', name: 'mingw setjmp and longjmp') 2799 2800 if cpu == 'aarch64' and not mingw_has_setjmp_longjmp 2801 error('mingw must provide setjmp/longjmp for windows-arm64') 2802 endif 2803endif 2804 2805######################## 2806# Target configuration # 2807######################## 2808 2809minikconf = find_program('scripts/minikconf.py') 2810config_all = {} 2811config_all_devices = {} 2812config_all_disas = {} 2813config_devices_mak_list = [] 2814config_devices_h = {} 2815config_target_h = {} 2816config_target_mak = {} 2817 2818disassemblers = { 2819 'alpha' : ['CONFIG_ALPHA_DIS'], 2820 'avr' : ['CONFIG_AVR_DIS'], 2821 'cris' : ['CONFIG_CRIS_DIS'], 2822 'hexagon' : ['CONFIG_HEXAGON_DIS'], 2823 'hppa' : ['CONFIG_HPPA_DIS'], 2824 'i386' : ['CONFIG_I386_DIS'], 2825 'x86_64' : ['CONFIG_I386_DIS'], 2826 'm68k' : ['CONFIG_M68K_DIS'], 2827 'microblaze' : ['CONFIG_MICROBLAZE_DIS'], 2828 'mips' : ['CONFIG_MIPS_DIS'], 2829 'nios2' : ['CONFIG_NIOS2_DIS'], 2830 'or1k' : ['CONFIG_OPENRISC_DIS'], 2831 'ppc' : ['CONFIG_PPC_DIS'], 2832 'riscv' : ['CONFIG_RISCV_DIS'], 2833 'rx' : ['CONFIG_RX_DIS'], 2834 's390' : ['CONFIG_S390_DIS'], 2835 'sh4' : ['CONFIG_SH4_DIS'], 2836 'sparc' : ['CONFIG_SPARC_DIS'], 2837 'xtensa' : ['CONFIG_XTENSA_DIS'], 2838 'loongarch' : ['CONFIG_LOONGARCH_DIS'], 2839} 2840 2841have_ivshmem = config_host_data.get('CONFIG_EVENTFD') 2842host_kconfig = \ 2843 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \ 2844 (have_tpm ? ['CONFIG_TPM=y'] : []) + \ 2845 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \ 2846 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \ 2847 (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \ 2848 (x11.found() ? ['CONFIG_X11=y'] : []) + \ 2849 (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \ 2850 (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \ 2851 (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \ 2852 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \ 2853 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \ 2854 (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \ 2855 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \ 2856 (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : []) 2857 2858ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ] 2859 2860default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host 2861actual_target_dirs = [] 2862fdt_required = [] 2863foreach target : target_dirs 2864 config_target = { 'TARGET_NAME': target.split('-')[0] } 2865 if target.endswith('linux-user') 2866 if targetos != 'linux' 2867 if default_targets 2868 continue 2869 endif 2870 error('Target @0@ is only available on a Linux host'.format(target)) 2871 endif 2872 config_target += { 'CONFIG_LINUX_USER': 'y' } 2873 elif target.endswith('bsd-user') 2874 if 'CONFIG_BSD' not in config_host 2875 if default_targets 2876 continue 2877 endif 2878 error('Target @0@ is only available on a BSD host'.format(target)) 2879 endif 2880 config_target += { 'CONFIG_BSD_USER': 'y' } 2881 elif target.endswith('softmmu') 2882 config_target += { 'CONFIG_SOFTMMU': 'y' } 2883 endif 2884 if target.endswith('-user') 2885 config_target += { 2886 'CONFIG_USER_ONLY': 'y', 2887 'CONFIG_QEMU_INTERP_PREFIX': 2888 get_option('interp_prefix').replace('%M', config_target['TARGET_NAME']) 2889 } 2890 endif 2891 2892 accel_kconfig = [] 2893 foreach sym: accelerators 2894 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, []) 2895 config_target += { sym: 'y' } 2896 config_all += { sym: 'y' } 2897 if target in modular_tcg 2898 config_target += { 'CONFIG_TCG_MODULAR': 'y' } 2899 else 2900 config_target += { 'CONFIG_TCG_BUILTIN': 'y' } 2901 endif 2902 accel_kconfig += [ sym + '=y' ] 2903 endif 2904 endforeach 2905 if accel_kconfig.length() == 0 2906 if default_targets 2907 continue 2908 endif 2909 error('No accelerator available for target @0@'.format(target)) 2910 endif 2911 2912 actual_target_dirs += target 2913 config_target += keyval.load('configs/targets' / target + '.mak') 2914 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' } 2915 2916 if 'TARGET_NEED_FDT' in config_target 2917 fdt_required += target 2918 endif 2919 2920 # Add default keys 2921 if 'TARGET_BASE_ARCH' not in config_target 2922 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']} 2923 endif 2924 if 'TARGET_ABI_DIR' not in config_target 2925 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']} 2926 endif 2927 if 'TARGET_BIG_ENDIAN' not in config_target 2928 config_target += {'TARGET_BIG_ENDIAN': 'n'} 2929 endif 2930 2931 foreach k, v: disassemblers 2932 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k) 2933 foreach sym: v 2934 config_target += { sym: 'y' } 2935 config_all_disas += { sym: 'y' } 2936 endforeach 2937 endif 2938 endforeach 2939 2940 config_target_data = configuration_data() 2941 foreach k, v: config_target 2942 if not k.startswith('TARGET_') and not k.startswith('CONFIG_') 2943 # do nothing 2944 elif ignored.contains(k) 2945 # do nothing 2946 elif k == 'TARGET_BASE_ARCH' 2947 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is 2948 # not used to select files from sourcesets. 2949 config_target_data.set('TARGET_' + v.to_upper(), 1) 2950 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX' 2951 config_target_data.set_quoted(k, v) 2952 elif v == 'y' 2953 config_target_data.set(k, 1) 2954 elif v == 'n' 2955 config_target_data.set(k, 0) 2956 else 2957 config_target_data.set(k, v) 2958 endif 2959 endforeach 2960 config_target_data.set('QEMU_ARCH', 2961 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper()) 2962 config_target_h += {target: configure_file(output: target + '-config-target.h', 2963 configuration: config_target_data)} 2964 2965 if target.endswith('-softmmu') 2966 config_input = meson.get_external_property(target, 'default') 2967 config_devices_mak = target + '-config-devices.mak' 2968 config_devices_mak = configure_file( 2969 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'], 2970 output: config_devices_mak, 2971 depfile: config_devices_mak + '.d', 2972 capture: true, 2973 command: [minikconf, 2974 get_option('default_devices') ? '--defconfig' : '--allnoconfig', 2975 config_devices_mak, '@DEPFILE@', '@INPUT@', 2976 host_kconfig, accel_kconfig, 2977 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y']) 2978 2979 config_devices_data = configuration_data() 2980 config_devices = keyval.load(config_devices_mak) 2981 foreach k, v: config_devices 2982 config_devices_data.set(k, 1) 2983 endforeach 2984 config_devices_mak_list += config_devices_mak 2985 config_devices_h += {target: configure_file(output: target + '-config-devices.h', 2986 configuration: config_devices_data)} 2987 config_target += config_devices 2988 config_all_devices += config_devices 2989 endif 2990 config_target_mak += {target: config_target} 2991endforeach 2992target_dirs = actual_target_dirs 2993 2994# This configuration is used to build files that are shared by 2995# multiple binaries, and then extracted out of the "common" 2996# static_library target. 2997# 2998# We do not use all_sources()/all_dependencies(), because it would 2999# build literally all source files, including devices only used by 3000# targets that are not built for this compilation. The CONFIG_ALL 3001# pseudo symbol replaces it. 3002 3003config_all += config_all_devices 3004config_all += config_host 3005config_all += config_all_disas 3006config_all += { 3007 'CONFIG_XEN': xen.found(), 3008 'CONFIG_SOFTMMU': have_system, 3009 'CONFIG_USER_ONLY': have_user, 3010 'CONFIG_ALL': true, 3011} 3012 3013target_configs_h = [] 3014foreach target: target_dirs 3015 target_configs_h += config_target_h[target] 3016 target_configs_h += config_devices_h.get(target, []) 3017endforeach 3018genh += custom_target('config-poison.h', 3019 input: [target_configs_h], 3020 output: 'config-poison.h', 3021 capture: true, 3022 command: [find_program('scripts/make-config-poison.sh'), 3023 target_configs_h]) 3024 3025############## 3026# Submodules # 3027############## 3028 3029capstone = not_found 3030if not get_option('capstone').auto() or have_system or have_user 3031 capstone = dependency('capstone', version: '>=3.0.5', 3032 method: 'pkg-config', 3033 required: get_option('capstone')) 3034 3035 # Some versions of capstone have broken pkg-config file 3036 # that reports a wrong -I path, causing the #include to 3037 # fail later. If the system has such a broken version 3038 # do not use it. 3039 if capstone.found() and not cc.compiles('#include <capstone.h>', 3040 dependencies: [capstone]) 3041 capstone = not_found 3042 if get_option('capstone').enabled() 3043 error('capstone requested, but it does not appear to work') 3044 endif 3045 endif 3046endif 3047 3048libvfio_user_dep = not_found 3049if have_system and vfio_user_server_allowed 3050 have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build') 3051 3052 if not have_internal 3053 error('libvfio-user source not found - please pull git submodule') 3054 endif 3055 3056 libvfio_user_proj = subproject('libvfio-user') 3057 3058 libvfio_user_dep = libvfio_user_proj.get_variable('libvfio_user_dep') 3059endif 3060 3061fdt = not_found 3062fdt_opt = get_option('fdt') 3063if fdt_required.length() > 0 or fdt_opt == 'enabled' 3064 if fdt_opt == 'disabled' 3065 error('fdt disabled but required by targets ' + ', '.join(fdt_required)) 3066 endif 3067 3068 if fdt_opt in ['enabled', 'auto', 'system'] 3069 fdt = cc.find_library('fdt', required: fdt_opt == 'system') 3070 if fdt.found() and cc.links(''' 3071 #include <libfdt.h> 3072 #include <libfdt_env.h> 3073 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''', 3074 dependencies: fdt) 3075 fdt_opt = 'system' 3076 elif fdt_opt == 'system' 3077 error('system libfdt requested, but it is too old (1.5.1 or newer required)') 3078 else 3079 fdt_opt = 'internal' 3080 fdt = not_found 3081 endif 3082 endif 3083 if not fdt.found() 3084 assert(fdt_opt == 'internal') 3085 have_internal = fs.exists(meson.current_source_dir() / 'subprojects/dtc/meson.build') 3086 3087 if not have_internal 3088 error('libfdt source not found - please pull git submodule') 3089 endif 3090 3091 libfdt_proj = subproject('dtc', required: true, 3092 default_options: ['tools=false', 'yaml=disabled', 3093 'python=disabled', 'default_library=static']) 3094 fdt = libfdt_proj.get_variable('libfdt_dep') 3095 endif 3096else 3097 fdt_opt = 'disabled' 3098endif 3099 3100config_host_data.set('CONFIG_CAPSTONE', capstone.found()) 3101config_host_data.set('CONFIG_FDT', fdt.found()) 3102config_host_data.set('CONFIG_SLIRP', slirp.found()) 3103 3104##################### 3105# Generated sources # 3106##################### 3107 3108genh += configure_file(output: 'config-host.h', configuration: config_host_data) 3109 3110hxtool = find_program('scripts/hxtool') 3111shaderinclude = find_program('scripts/shaderinclude.py') 3112qapi_gen = find_program('scripts/qapi-gen.py') 3113qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py', 3114 meson.current_source_dir() / 'scripts/qapi/commands.py', 3115 meson.current_source_dir() / 'scripts/qapi/common.py', 3116 meson.current_source_dir() / 'scripts/qapi/error.py', 3117 meson.current_source_dir() / 'scripts/qapi/events.py', 3118 meson.current_source_dir() / 'scripts/qapi/expr.py', 3119 meson.current_source_dir() / 'scripts/qapi/gen.py', 3120 meson.current_source_dir() / 'scripts/qapi/introspect.py', 3121 meson.current_source_dir() / 'scripts/qapi/main.py', 3122 meson.current_source_dir() / 'scripts/qapi/parser.py', 3123 meson.current_source_dir() / 'scripts/qapi/schema.py', 3124 meson.current_source_dir() / 'scripts/qapi/source.py', 3125 meson.current_source_dir() / 'scripts/qapi/types.py', 3126 meson.current_source_dir() / 'scripts/qapi/visit.py', 3127 meson.current_source_dir() / 'scripts/qapi-gen.py' 3128] 3129 3130tracetool = [ 3131 python, files('scripts/tracetool.py'), 3132 '--backend=' + ','.join(get_option('trace_backends')) 3133] 3134tracetool_depends = files( 3135 'scripts/tracetool/backend/log.py', 3136 'scripts/tracetool/backend/__init__.py', 3137 'scripts/tracetool/backend/dtrace.py', 3138 'scripts/tracetool/backend/ftrace.py', 3139 'scripts/tracetool/backend/simple.py', 3140 'scripts/tracetool/backend/syslog.py', 3141 'scripts/tracetool/backend/ust.py', 3142 'scripts/tracetool/format/ust_events_c.py', 3143 'scripts/tracetool/format/ust_events_h.py', 3144 'scripts/tracetool/format/__init__.py', 3145 'scripts/tracetool/format/d.py', 3146 'scripts/tracetool/format/simpletrace_stap.py', 3147 'scripts/tracetool/format/c.py', 3148 'scripts/tracetool/format/h.py', 3149 'scripts/tracetool/format/log_stap.py', 3150 'scripts/tracetool/format/stap.py', 3151 'scripts/tracetool/__init__.py', 3152 'scripts/tracetool/vcpu.py' 3153) 3154 3155qemu_version_cmd = [find_program('scripts/qemu-version.sh'), 3156 meson.current_source_dir(), 3157 get_option('pkgversion'), meson.project_version()] 3158qemu_version = custom_target('qemu-version.h', 3159 output: 'qemu-version.h', 3160 command: qemu_version_cmd, 3161 capture: true, 3162 build_by_default: true, 3163 build_always_stale: true) 3164genh += qemu_version 3165 3166hxdep = [] 3167hx_headers = [ 3168 ['qemu-options.hx', 'qemu-options.def'], 3169 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'], 3170] 3171if have_system 3172 hx_headers += [ 3173 ['hmp-commands.hx', 'hmp-commands.h'], 3174 ['hmp-commands-info.hx', 'hmp-commands-info.h'], 3175 ] 3176endif 3177foreach d : hx_headers 3178 hxdep += custom_target(d[1], 3179 input: files(d[0]), 3180 output: d[1], 3181 capture: true, 3182 build_by_default: true, # to be removed when added to a target 3183 command: [hxtool, '-h', '@INPUT0@']) 3184endforeach 3185genh += hxdep 3186 3187################### 3188# Collect sources # 3189################### 3190 3191authz_ss = ss.source_set() 3192blockdev_ss = ss.source_set() 3193block_ss = ss.source_set() 3194chardev_ss = ss.source_set() 3195common_ss = ss.source_set() 3196crypto_ss = ss.source_set() 3197hwcore_ss = ss.source_set() 3198io_ss = ss.source_set() 3199qmp_ss = ss.source_set() 3200qom_ss = ss.source_set() 3201softmmu_ss = ss.source_set() 3202specific_fuzz_ss = ss.source_set() 3203specific_ss = ss.source_set() 3204stub_ss = ss.source_set() 3205trace_ss = ss.source_set() 3206user_ss = ss.source_set() 3207util_ss = ss.source_set() 3208 3209# accel modules 3210qtest_module_ss = ss.source_set() 3211tcg_module_ss = ss.source_set() 3212 3213modules = {} 3214target_modules = {} 3215hw_arch = {} 3216target_arch = {} 3217target_softmmu_arch = {} 3218target_user_arch = {} 3219 3220############### 3221# Trace files # 3222############### 3223 3224# TODO: add each directory to the subdirs from its own meson.build, once 3225# we have those 3226trace_events_subdirs = [ 3227 'crypto', 3228 'qapi', 3229 'qom', 3230 'monitor', 3231 'util', 3232 'gdbstub', 3233] 3234if have_linux_user 3235 trace_events_subdirs += [ 'linux-user' ] 3236endif 3237if have_bsd_user 3238 trace_events_subdirs += [ 'bsd-user' ] 3239endif 3240if have_block 3241 trace_events_subdirs += [ 3242 'authz', 3243 'block', 3244 'io', 3245 'nbd', 3246 'scsi', 3247 ] 3248endif 3249if have_system 3250 trace_events_subdirs += [ 3251 'accel/kvm', 3252 'audio', 3253 'backends', 3254 'backends/tpm', 3255 'chardev', 3256 'ebpf', 3257 'hw/9pfs', 3258 'hw/acpi', 3259 'hw/adc', 3260 'hw/alpha', 3261 'hw/arm', 3262 'hw/audio', 3263 'hw/block', 3264 'hw/block/dataplane', 3265 'hw/char', 3266 'hw/display', 3267 'hw/dma', 3268 'hw/hyperv', 3269 'hw/i2c', 3270 'hw/i386', 3271 'hw/i386/xen', 3272 'hw/i386/kvm', 3273 'hw/ide', 3274 'hw/input', 3275 'hw/intc', 3276 'hw/isa', 3277 'hw/mem', 3278 'hw/mips', 3279 'hw/misc', 3280 'hw/misc/macio', 3281 'hw/net', 3282 'hw/net/can', 3283 'hw/nubus', 3284 'hw/nvme', 3285 'hw/nvram', 3286 'hw/pci', 3287 'hw/pci-host', 3288 'hw/ppc', 3289 'hw/rdma', 3290 'hw/rdma/vmw', 3291 'hw/rtc', 3292 'hw/s390x', 3293 'hw/scsi', 3294 'hw/sd', 3295 'hw/sh4', 3296 'hw/sparc', 3297 'hw/sparc64', 3298 'hw/ssi', 3299 'hw/timer', 3300 'hw/tpm', 3301 'hw/usb', 3302 'hw/vfio', 3303 'hw/virtio', 3304 'hw/watchdog', 3305 'hw/xen', 3306 'hw/gpio', 3307 'migration', 3308 'net', 3309 'softmmu', 3310 'ui', 3311 'hw/remote', 3312 ] 3313endif 3314if have_system or have_user 3315 trace_events_subdirs += [ 3316 'accel/tcg', 3317 'hw/core', 3318 'target/arm', 3319 'target/arm/hvf', 3320 'target/hppa', 3321 'target/i386', 3322 'target/i386/kvm', 3323 'target/mips/tcg', 3324 'target/nios2', 3325 'target/ppc', 3326 'target/riscv', 3327 'target/s390x', 3328 'target/s390x/kvm', 3329 'target/sparc', 3330 ] 3331endif 3332 3333vhost_user = not_found 3334if targetos == 'linux' and have_vhost_user 3335 libvhost_user = subproject('libvhost-user') 3336 vhost_user = libvhost_user.get_variable('vhost_user_dep') 3337endif 3338 3339libvduse = not_found 3340if have_libvduse 3341 libvduse_proj = subproject('libvduse') 3342 libvduse = libvduse_proj.get_variable('libvduse_dep') 3343endif 3344 3345# NOTE: the trace/ subdirectory needs the qapi_trace_events variable 3346# that is filled in by qapi/. 3347subdir('qapi') 3348subdir('qobject') 3349subdir('stubs') 3350subdir('trace') 3351subdir('util') 3352subdir('qom') 3353subdir('authz') 3354subdir('crypto') 3355subdir('ui') 3356subdir('hw') 3357subdir('gdbstub') 3358 3359if enable_modules 3360 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO') 3361 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO') 3362endif 3363 3364qom_ss = qom_ss.apply(config_host, strict: false) 3365libqom = static_library('qom', qom_ss.sources() + genh, 3366 dependencies: [qom_ss.dependencies()], 3367 name_suffix: 'fa') 3368qom = declare_dependency(link_whole: libqom) 3369 3370event_loop_base = files('event-loop-base.c') 3371event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh, 3372 build_by_default: true) 3373event_loop_base = declare_dependency(link_whole: event_loop_base, 3374 dependencies: [qom]) 3375 3376stub_ss = stub_ss.apply(config_all, strict: false) 3377 3378util_ss.add_all(trace_ss) 3379util_ss = util_ss.apply(config_all, strict: false) 3380libqemuutil = static_library('qemuutil', 3381 sources: util_ss.sources() + stub_ss.sources() + genh, 3382 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman]) 3383qemuutil = declare_dependency(link_with: libqemuutil, 3384 sources: genh + version_res, 3385 dependencies: [event_loop_base]) 3386 3387if have_system or have_user 3388 decodetree = generator(find_program('scripts/decodetree.py'), 3389 output: 'decode-@BASENAME@.c.inc', 3390 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@']) 3391 subdir('libdecnumber') 3392 subdir('target') 3393endif 3394 3395subdir('audio') 3396subdir('io') 3397subdir('chardev') 3398subdir('fsdev') 3399subdir('dump') 3400 3401if have_block 3402 block_ss.add(files( 3403 'block.c', 3404 'blockjob.c', 3405 'job.c', 3406 'qemu-io-cmds.c', 3407 )) 3408 if config_host_data.get('CONFIG_REPLICATION') 3409 block_ss.add(files('replication.c')) 3410 endif 3411 3412 subdir('nbd') 3413 subdir('scsi') 3414 subdir('block') 3415 3416 blockdev_ss.add(files( 3417 'blockdev.c', 3418 'blockdev-nbd.c', 3419 'iothread.c', 3420 'job-qmp.c', 3421 ), gnutls) 3422 3423 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon, 3424 # os-win32.c does not 3425 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c')) 3426 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')]) 3427endif 3428 3429common_ss.add(files('cpus-common.c')) 3430specific_ss.add(files('cpu.c')) 3431 3432subdir('softmmu') 3433 3434# Work around a gcc bug/misfeature wherein constant propagation looks 3435# through an alias: 3436# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696 3437# to guess that a const variable is always zero. Without lto, this is 3438# impossible, as the alias is restricted to page-vary-common.c. Indeed, 3439# without lto, not even the alias is required -- we simply use different 3440# declarations in different compilation units. 3441pagevary = files('page-vary-common.c') 3442if get_option('b_lto') 3443 pagevary_flags = ['-fno-lto'] 3444 if get_option('cfi') 3445 pagevary_flags += '-fno-sanitize=cfi-icall' 3446 endif 3447 pagevary = static_library('page-vary-common', sources: pagevary + genh, 3448 c_args: pagevary_flags) 3449 pagevary = declare_dependency(link_with: pagevary) 3450endif 3451common_ss.add(pagevary) 3452specific_ss.add(files('page-vary.c')) 3453 3454subdir('backends') 3455subdir('disas') 3456subdir('migration') 3457subdir('monitor') 3458subdir('net') 3459subdir('replay') 3460subdir('semihosting') 3461subdir('stats') 3462subdir('tcg') 3463subdir('fpu') 3464subdir('accel') 3465subdir('plugins') 3466subdir('ebpf') 3467 3468common_user_inc = [] 3469 3470subdir('common-user') 3471subdir('bsd-user') 3472subdir('linux-user') 3473 3474# needed for fuzzing binaries 3475subdir('tests/qtest/libqos') 3476subdir('tests/qtest/fuzz') 3477 3478# accel modules 3479tcg_real_module_ss = ss.source_set() 3480tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss) 3481specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss) 3482target_modules += { 'accel' : { 'qtest': qtest_module_ss, 3483 'tcg': tcg_real_module_ss }} 3484 3485######################## 3486# Library dependencies # 3487######################## 3488 3489modinfo_collect = find_program('scripts/modinfo-collect.py') 3490modinfo_generate = find_program('scripts/modinfo-generate.py') 3491modinfo_files = [] 3492 3493block_mods = [] 3494softmmu_mods = [] 3495foreach d, list : modules 3496 if not (d == 'block' ? have_block : have_system) 3497 continue 3498 endif 3499 3500 foreach m, module_ss : list 3501 if enable_modules 3502 module_ss = module_ss.apply(config_all, strict: false) 3503 sl = static_library(d + '-' + m, [genh, module_ss.sources()], 3504 dependencies: [modulecommon, module_ss.dependencies()], pic: true) 3505 if d == 'block' 3506 block_mods += sl 3507 else 3508 softmmu_mods += sl 3509 endif 3510 if module_ss.sources() != [] 3511 # FIXME: Should use sl.extract_all_objects(recursive: true) as 3512 # input. Sources can be used multiple times but objects are 3513 # unique when it comes to lookup in compile_commands.json. 3514 # Depnds on a mesion version with 3515 # https://github.com/mesonbuild/meson/pull/8900 3516 modinfo_files += custom_target(d + '-' + m + '.modinfo', 3517 output: d + '-' + m + '.modinfo', 3518 input: module_ss.sources() + genh, 3519 capture: true, 3520 command: [modinfo_collect, module_ss.sources()]) 3521 endif 3522 else 3523 if d == 'block' 3524 block_ss.add_all(module_ss) 3525 else 3526 softmmu_ss.add_all(module_ss) 3527 endif 3528 endif 3529 endforeach 3530endforeach 3531 3532foreach d, list : target_modules 3533 foreach m, module_ss : list 3534 if enable_modules 3535 foreach target : target_dirs 3536 if target.endswith('-softmmu') 3537 config_target = config_target_mak[target] 3538 config_target += config_host 3539 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])] 3540 c_args = ['-DNEED_CPU_H', 3541 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target), 3542 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)] 3543 target_module_ss = module_ss.apply(config_target, strict: false) 3544 if target_module_ss.sources() != [] 3545 module_name = d + '-' + m + '-' + config_target['TARGET_NAME'] 3546 sl = static_library(module_name, 3547 [genh, target_module_ss.sources()], 3548 dependencies: [modulecommon, target_module_ss.dependencies()], 3549 include_directories: target_inc, 3550 c_args: c_args, 3551 pic: true) 3552 softmmu_mods += sl 3553 # FIXME: Should use sl.extract_all_objects(recursive: true) too. 3554 modinfo_files += custom_target(module_name + '.modinfo', 3555 output: module_name + '.modinfo', 3556 input: target_module_ss.sources() + genh, 3557 capture: true, 3558 command: [modinfo_collect, '--target', target, target_module_ss.sources()]) 3559 endif 3560 endif 3561 endforeach 3562 else 3563 specific_ss.add_all(module_ss) 3564 endif 3565 endforeach 3566endforeach 3567 3568if enable_modules 3569 foreach target : target_dirs 3570 if target.endswith('-softmmu') 3571 config_target = config_target_mak[target] 3572 config_devices_mak = target + '-config-devices.mak' 3573 modinfo_src = custom_target('modinfo-' + target + '.c', 3574 output: 'modinfo-' + target + '.c', 3575 input: modinfo_files, 3576 command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'], 3577 capture: true) 3578 3579 modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src) 3580 modinfo_dep = declare_dependency(link_with: modinfo_lib) 3581 3582 arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH'] 3583 hw_arch[arch].add(modinfo_dep) 3584 endif 3585 endforeach 3586endif 3587 3588nm = find_program('nm') 3589undefsym = find_program('scripts/undefsym.py') 3590block_syms = custom_target('block.syms', output: 'block.syms', 3591 input: [libqemuutil, block_mods], 3592 capture: true, 3593 command: [undefsym, nm, '@INPUT@']) 3594qemu_syms = custom_target('qemu.syms', output: 'qemu.syms', 3595 input: [libqemuutil, softmmu_mods], 3596 capture: true, 3597 command: [undefsym, nm, '@INPUT@']) 3598 3599authz_ss = authz_ss.apply(config_host, strict: false) 3600libauthz = static_library('authz', authz_ss.sources() + genh, 3601 dependencies: [authz_ss.dependencies()], 3602 name_suffix: 'fa', 3603 build_by_default: false) 3604 3605authz = declare_dependency(link_whole: libauthz, 3606 dependencies: qom) 3607 3608crypto_ss = crypto_ss.apply(config_host, strict: false) 3609libcrypto = static_library('crypto', crypto_ss.sources() + genh, 3610 dependencies: [crypto_ss.dependencies()], 3611 name_suffix: 'fa', 3612 build_by_default: false) 3613 3614crypto = declare_dependency(link_whole: libcrypto, 3615 dependencies: [authz, qom]) 3616 3617io_ss = io_ss.apply(config_host, strict: false) 3618libio = static_library('io', io_ss.sources() + genh, 3619 dependencies: [io_ss.dependencies()], 3620 link_with: libqemuutil, 3621 name_suffix: 'fa', 3622 build_by_default: false) 3623 3624io = declare_dependency(link_whole: libio, dependencies: [crypto, qom]) 3625 3626libmigration = static_library('migration', sources: migration_files + genh, 3627 name_suffix: 'fa', 3628 build_by_default: false) 3629migration = declare_dependency(link_with: libmigration, 3630 dependencies: [zlib, qom, io]) 3631softmmu_ss.add(migration) 3632 3633block_ss = block_ss.apply(config_host, strict: false) 3634libblock = static_library('block', block_ss.sources() + genh, 3635 dependencies: block_ss.dependencies(), 3636 link_depends: block_syms, 3637 name_suffix: 'fa', 3638 build_by_default: false) 3639 3640block = declare_dependency(link_whole: [libblock], 3641 link_args: '@block.syms', 3642 dependencies: [crypto, io]) 3643 3644blockdev_ss = blockdev_ss.apply(config_host, strict: false) 3645libblockdev = static_library('blockdev', blockdev_ss.sources() + genh, 3646 dependencies: blockdev_ss.dependencies(), 3647 name_suffix: 'fa', 3648 build_by_default: false) 3649 3650blockdev = declare_dependency(link_whole: [libblockdev], 3651 dependencies: [block, event_loop_base]) 3652 3653qmp_ss = qmp_ss.apply(config_host, strict: false) 3654libqmp = static_library('qmp', qmp_ss.sources() + genh, 3655 dependencies: qmp_ss.dependencies(), 3656 name_suffix: 'fa', 3657 build_by_default: false) 3658 3659qmp = declare_dependency(link_whole: [libqmp]) 3660 3661libchardev = static_library('chardev', chardev_ss.sources() + genh, 3662 name_suffix: 'fa', 3663 dependencies: chardev_ss.dependencies(), 3664 build_by_default: false) 3665 3666chardev = declare_dependency(link_whole: libchardev) 3667 3668hwcore_ss = hwcore_ss.apply(config_host, strict: false) 3669libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh, 3670 name_suffix: 'fa', 3671 build_by_default: false) 3672hwcore = declare_dependency(link_whole: libhwcore) 3673common_ss.add(hwcore) 3674 3675########### 3676# Targets # 3677########### 3678 3679emulator_modules = [] 3680foreach m : block_mods + softmmu_mods 3681 emulator_modules += shared_module(m.name(), 3682 build_by_default: true, 3683 name_prefix: '', 3684 link_whole: m, 3685 install: true, 3686 install_dir: qemu_moddir) 3687endforeach 3688if emulator_modules.length() > 0 3689 alias_target('modules', emulator_modules) 3690endif 3691 3692softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp) 3693common_ss.add(qom, qemuutil) 3694 3695common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss]) 3696common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss) 3697 3698common_all = common_ss.apply(config_all, strict: false) 3699common_all = static_library('common', 3700 build_by_default: false, 3701 sources: common_all.sources() + genh, 3702 include_directories: common_user_inc, 3703 implicit_include_directories: false, 3704 dependencies: common_all.dependencies(), 3705 name_suffix: 'fa') 3706 3707feature_to_c = find_program('scripts/feature_to_c.sh') 3708 3709if targetos == 'darwin' 3710 entitlement = find_program('scripts/entitlement.sh') 3711endif 3712 3713emulators = {} 3714foreach target : target_dirs 3715 config_target = config_target_mak[target] 3716 target_name = config_target['TARGET_NAME'] 3717 target_base_arch = config_target['TARGET_BASE_ARCH'] 3718 arch_srcs = [config_target_h[target]] 3719 arch_deps = [] 3720 c_args = ['-DNEED_CPU_H', 3721 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target), 3722 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)] 3723 link_args = emulator_link_args 3724 3725 config_target += config_host 3726 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])] 3727 if targetos == 'linux' 3728 target_inc += include_directories('linux-headers', is_system: true) 3729 endif 3730 if target.endswith('-softmmu') 3731 target_type='system' 3732 t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false) 3733 arch_srcs += t.sources() 3734 arch_deps += t.dependencies() 3735 3736 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch 3737 hw = hw_arch[hw_dir].apply(config_target, strict: false) 3738 arch_srcs += hw.sources() 3739 arch_deps += hw.dependencies() 3740 3741 arch_srcs += config_devices_h[target] 3742 link_args += ['@block.syms', '@qemu.syms'] 3743 else 3744 abi = config_target['TARGET_ABI_DIR'] 3745 target_type='user' 3746 target_inc += common_user_inc 3747 if target_base_arch in target_user_arch 3748 t = target_user_arch[target_base_arch].apply(config_target, strict: false) 3749 arch_srcs += t.sources() 3750 arch_deps += t.dependencies() 3751 endif 3752 if 'CONFIG_LINUX_USER' in config_target 3753 base_dir = 'linux-user' 3754 endif 3755 if 'CONFIG_BSD_USER' in config_target 3756 base_dir = 'bsd-user' 3757 target_inc += include_directories('bsd-user/' / targetos) 3758 target_inc += include_directories('bsd-user/host/' / host_arch) 3759 dir = base_dir / abi 3760 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c') 3761 endif 3762 target_inc += include_directories( 3763 base_dir, 3764 base_dir / abi, 3765 ) 3766 if 'CONFIG_LINUX_USER' in config_target 3767 dir = base_dir / abi 3768 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c') 3769 if config_target.has_key('TARGET_SYSTBL_ABI') 3770 arch_srcs += \ 3771 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'], 3772 extra_args : config_target['TARGET_SYSTBL_ABI']) 3773 endif 3774 endif 3775 endif 3776 3777 if 'TARGET_XML_FILES' in config_target 3778 gdbstub_xml = custom_target(target + '-gdbstub-xml.c', 3779 output: target + '-gdbstub-xml.c', 3780 input: files(config_target['TARGET_XML_FILES'].split()), 3781 command: [feature_to_c, '@INPUT@'], 3782 capture: true) 3783 arch_srcs += gdbstub_xml 3784 endif 3785 3786 t = target_arch[target_base_arch].apply(config_target, strict: false) 3787 arch_srcs += t.sources() 3788 arch_deps += t.dependencies() 3789 3790 target_common = common_ss.apply(config_target, strict: false) 3791 objects = common_all.extract_objects(target_common.sources()) 3792 deps = target_common.dependencies() 3793 3794 target_specific = specific_ss.apply(config_target, strict: false) 3795 arch_srcs += target_specific.sources() 3796 arch_deps += target_specific.dependencies() 3797 3798 lib = static_library('qemu-' + target, 3799 sources: arch_srcs + genh, 3800 dependencies: arch_deps, 3801 objects: objects, 3802 include_directories: target_inc, 3803 c_args: c_args, 3804 build_by_default: false, 3805 name_suffix: 'fa') 3806 3807 if target.endswith('-softmmu') 3808 execs = [{ 3809 'name': 'qemu-system-' + target_name, 3810 'win_subsystem': 'console', 3811 'sources': files('softmmu/main.c'), 3812 'dependencies': [] 3813 }] 3814 if targetos == 'windows' and (sdl.found() or gtk.found()) 3815 execs += [{ 3816 'name': 'qemu-system-' + target_name + 'w', 3817 'win_subsystem': 'windows', 3818 'sources': files('softmmu/main.c'), 3819 'dependencies': [] 3820 }] 3821 endif 3822 if get_option('fuzzing') 3823 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false) 3824 execs += [{ 3825 'name': 'qemu-fuzz-' + target_name, 3826 'win_subsystem': 'console', 3827 'sources': specific_fuzz.sources(), 3828 'dependencies': specific_fuzz.dependencies(), 3829 }] 3830 endif 3831 else 3832 execs = [{ 3833 'name': 'qemu-' + target_name, 3834 'win_subsystem': 'console', 3835 'sources': [], 3836 'dependencies': [] 3837 }] 3838 endif 3839 foreach exe: execs 3840 exe_name = exe['name'] 3841 if targetos == 'darwin' 3842 exe_name += '-unsigned' 3843 endif 3844 3845 emulator = executable(exe_name, exe['sources'], 3846 install: true, 3847 c_args: c_args, 3848 dependencies: arch_deps + deps + exe['dependencies'], 3849 objects: lib.extract_all_objects(recursive: true), 3850 link_language: link_language, 3851 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []), 3852 link_args: link_args, 3853 win_subsystem: exe['win_subsystem']) 3854 3855 if targetos == 'darwin' 3856 icon = 'pc-bios/qemu.rsrc' 3857 build_input = [emulator, files(icon)] 3858 install_input = [ 3859 get_option('bindir') / exe_name, 3860 meson.current_source_dir() / icon 3861 ] 3862 if 'CONFIG_HVF' in config_target 3863 entitlements = 'accel/hvf/entitlements.plist' 3864 build_input += files(entitlements) 3865 install_input += meson.current_source_dir() / entitlements 3866 endif 3867 3868 emulators += {exe['name'] : custom_target(exe['name'], 3869 input: build_input, 3870 output: exe['name'], 3871 command: [entitlement, '@OUTPUT@', '@INPUT@']) 3872 } 3873 3874 meson.add_install_script(entitlement, '--install', 3875 get_option('bindir') / exe['name'], 3876 install_input) 3877 else 3878 emulators += {exe['name']: emulator} 3879 endif 3880 3881 if stap.found() 3882 foreach stp: [ 3883 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false}, 3884 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true}, 3885 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true}, 3886 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true}, 3887 ] 3888 custom_target(exe['name'] + stp['ext'], 3889 input: trace_events_all, 3890 output: exe['name'] + stp['ext'], 3891 install: stp['install'], 3892 install_dir: get_option('datadir') / 'systemtap/tapset', 3893 command: [ 3894 tracetool, '--group=all', '--format=' + stp['fmt'], 3895 '--binary=' + stp['bin'], 3896 '--target-name=' + target_name, 3897 '--target-type=' + target_type, 3898 '--probe-prefix=qemu.' + target_type + '.' + target_name, 3899 '@INPUT@', '@OUTPUT@' 3900 ], 3901 depend_files: tracetool_depends) 3902 endforeach 3903 endif 3904 endforeach 3905endforeach 3906 3907# Other build targets 3908 3909if 'CONFIG_PLUGIN' in config_host 3910 install_headers('include/qemu/qemu-plugin.h') 3911endif 3912 3913subdir('qga') 3914 3915# Don't build qemu-keymap if xkbcommon is not explicitly enabled 3916# when we don't build tools or system 3917if xkbcommon.found() 3918 # used for the update-keymaps target, so include rules even if !have_tools 3919 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh, 3920 dependencies: [qemuutil, xkbcommon], install: have_tools) 3921endif 3922 3923if have_tools 3924 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep], 3925 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true) 3926 qemu_io = executable('qemu-io', files('qemu-io.c'), 3927 dependencies: [block, qemuutil], install: true) 3928 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'), 3929 dependencies: [blockdev, qemuutil, gnutls, selinux], 3930 install: true) 3931 3932 subdir('storage-daemon') 3933 subdir('contrib/rdmacm-mux') 3934 subdir('contrib/elf2dmp') 3935 3936 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'), 3937 dependencies: qemuutil, 3938 install: true) 3939 3940 if have_vhost_user 3941 subdir('contrib/vhost-user-blk') 3942 subdir('contrib/vhost-user-gpu') 3943 subdir('contrib/vhost-user-input') 3944 subdir('contrib/vhost-user-scsi') 3945 endif 3946 3947 if targetos == 'linux' 3948 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'), 3949 dependencies: [qemuutil, libcap_ng], 3950 install: true, 3951 install_dir: get_option('libexecdir')) 3952 3953 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'), 3954 dependencies: [authz, crypto, io, qom, qemuutil, 3955 libcap_ng, mpathpersist], 3956 install: true) 3957 endif 3958 3959 if have_ivshmem 3960 subdir('contrib/ivshmem-client') 3961 subdir('contrib/ivshmem-server') 3962 endif 3963endif 3964 3965subdir('scripts') 3966subdir('tools') 3967subdir('pc-bios') 3968subdir('docs') 3969subdir('tests') 3970if gtk.found() 3971 subdir('po') 3972endif 3973 3974if host_machine.system() == 'windows' 3975 nsis_cmd = [ 3976 find_program('scripts/nsis.py'), 3977 '@OUTPUT@', 3978 get_option('prefix'), 3979 meson.current_source_dir(), 3980 glib_pc.get_variable('bindir'), 3981 host_machine.cpu(), 3982 '--', 3983 '-DDISPLAYVERSION=' + meson.project_version(), 3984 ] 3985 if build_docs 3986 nsis_cmd += '-DCONFIG_DOCUMENTATION=y' 3987 endif 3988 if gtk.found() 3989 nsis_cmd += '-DCONFIG_GTK=y' 3990 endif 3991 3992 nsis = custom_target('nsis', 3993 output: 'qemu-setup-' + meson.project_version() + '.exe', 3994 input: files('qemu.nsi'), 3995 build_always_stale: true, 3996 command: nsis_cmd + ['@INPUT@']) 3997 alias_target('installer', nsis) 3998endif 3999 4000######################### 4001# Configuration summary # 4002######################### 4003 4004# Directories 4005summary_info = {} 4006summary_info += {'Install prefix': get_option('prefix')} 4007summary_info += {'BIOS directory': qemu_datadir} 4008pathsep = targetos == 'windows' ? ';' : ':' 4009summary_info += {'firmware path': pathsep.join(get_option('qemu_firmwarepath'))} 4010summary_info += {'binary directory': get_option('prefix') / get_option('bindir')} 4011summary_info += {'library directory': get_option('prefix') / get_option('libdir')} 4012summary_info += {'module directory': qemu_moddir} 4013summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')} 4014summary_info += {'include directory': get_option('prefix') / get_option('includedir')} 4015summary_info += {'config directory': get_option('prefix') / get_option('sysconfdir')} 4016if targetos != 'windows' 4017 summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')} 4018 summary_info += {'Manual directory': get_option('prefix') / get_option('mandir')} 4019else 4020 summary_info += {'local state directory': 'queried at runtime'} 4021endif 4022summary_info += {'Doc directory': get_option('prefix') / get_option('docdir')} 4023summary_info += {'Build directory': meson.current_build_dir()} 4024summary_info += {'Source path': meson.current_source_dir()} 4025summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']} 4026summary(summary_info, bool_yn: true, section: 'Directories') 4027 4028# Host binaries 4029summary_info = {} 4030summary_info += {'git': config_host['GIT']} 4031summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())} 4032summary_info += {'sphinx-build': sphinx_build} 4033if config_host.has_key('HAVE_GDB_BIN') 4034 summary_info += {'gdb': config_host['HAVE_GDB_BIN']} 4035endif 4036summary_info += {'iasl': iasl} 4037summary_info += {'genisoimage': config_host['GENISOIMAGE']} 4038if targetos == 'windows' and have_ga 4039 summary_info += {'wixl': wixl} 4040endif 4041if slirp.found() and have_system 4042 summary_info += {'smbd': have_slirp_smbd ? smbd_path : false} 4043endif 4044summary(summary_info, bool_yn: true, section: 'Host binaries') 4045 4046# Configurable features 4047summary_info = {} 4048summary_info += {'Documentation': build_docs} 4049summary_info += {'system-mode emulation': have_system} 4050summary_info += {'user-mode emulation': have_user} 4051summary_info += {'block layer': have_block} 4052summary_info += {'Install blobs': get_option('install_blobs')} 4053summary_info += {'module support': enable_modules} 4054if enable_modules 4055 summary_info += {'alternative module path': get_option('module_upgrades')} 4056endif 4057summary_info += {'fuzzing support': get_option('fuzzing')} 4058if have_system 4059 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)} 4060endif 4061summary_info += {'Trace backends': ','.join(get_option('trace_backends'))} 4062if 'simple' in get_option('trace_backends') 4063 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'} 4064endif 4065summary_info += {'D-Bus display': dbus_display} 4066summary_info += {'QOM debugging': get_option('qom_cast_debug')} 4067summary_info += {'vhost-kernel support': have_vhost_kernel} 4068summary_info += {'vhost-net support': have_vhost_net} 4069summary_info += {'vhost-user support': have_vhost_user} 4070summary_info += {'vhost-user-crypto support': have_vhost_user_crypto} 4071summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server} 4072summary_info += {'vhost-vdpa support': have_vhost_vdpa} 4073summary_info += {'build guest agent': have_ga} 4074summary(summary_info, bool_yn: true, section: 'Configurable features') 4075 4076# Compilation information 4077summary_info = {} 4078summary_info += {'host CPU': cpu} 4079summary_info += {'host endianness': build_machine.endian()} 4080summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())} 4081summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())} 4082if link_language == 'cpp' 4083 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())} 4084else 4085 summary_info += {'C++ compiler': false} 4086endif 4087if targetos == 'darwin' 4088 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())} 4089endif 4090option_cflags = (get_option('debug') ? ['-g'] : []) 4091if get_option('optimization') != 'plain' 4092 option_cflags += ['-O' + get_option('optimization')] 4093endif 4094summary_info += {'CFLAGS': ' '.join(get_option('c_args') + option_cflags)} 4095if link_language == 'cpp' 4096 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args') + option_cflags)} 4097endif 4098if targetos == 'darwin' 4099 summary_info += {'OBJCFLAGS': ' '.join(get_option('objc_args') + option_cflags)} 4100endif 4101link_args = get_option(link_language + '_link_args') 4102if link_args.length() > 0 4103 summary_info += {'LDFLAGS': ' '.join(link_args)} 4104endif 4105summary_info += {'QEMU_CFLAGS': ' '.join(qemu_common_flags + qemu_cflags)} 4106if 'cpp' in all_languages 4107 summary_info += {'QEMU_CXXFLAGS': ' '.join(qemu_common_flags + qemu_cxxflags)} 4108endif 4109if 'objc' in all_languages 4110 summary_info += {'QEMU_OBJCFLAGS': ' '.join(qemu_common_flags)} 4111endif 4112summary_info += {'QEMU_LDFLAGS': ' '.join(qemu_ldflags)} 4113summary_info += {'profiler': get_option('profiler')} 4114summary_info += {'link-time optimization (LTO)': get_option('b_lto')} 4115summary_info += {'PIE': get_option('b_pie')} 4116summary_info += {'static build': config_host.has_key('CONFIG_STATIC')} 4117summary_info += {'malloc trim support': has_malloc_trim} 4118summary_info += {'membarrier': have_membarrier} 4119summary_info += {'debug graph lock': get_option('debug_graph_lock')} 4120summary_info += {'debug stack usage': get_option('debug_stack_usage')} 4121summary_info += {'mutex debugging': get_option('debug_mutex')} 4122summary_info += {'memory allocator': get_option('malloc')} 4123summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')} 4124summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')} 4125summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')} 4126if get_option('gprof') 4127 gprof_info = 'YES (deprecated)' 4128else 4129 gprof_info = get_option('gprof') 4130endif 4131summary_info += {'gprof': gprof_info} 4132summary_info += {'gcov': get_option('b_coverage')} 4133summary_info += {'thread sanitizer': get_option('tsan')} 4134summary_info += {'CFI support': get_option('cfi')} 4135if get_option('cfi') 4136 summary_info += {'CFI debug support': get_option('cfi_debug')} 4137endif 4138summary_info += {'strip binaries': get_option('strip')} 4139summary_info += {'sparse': sparse} 4140summary_info += {'mingw32 support': targetos == 'windows'} 4141summary(summary_info, bool_yn: true, section: 'Compilation') 4142 4143# snarf the cross-compilation information for tests 4144summary_info = {} 4145have_cross = false 4146foreach target: target_dirs 4147 tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak' 4148 if fs.exists(tcg_mak) 4149 config_cross_tcg = keyval.load(tcg_mak) 4150 if 'CC' in config_cross_tcg 4151 summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']} 4152 have_cross = true 4153 endif 4154 endif 4155endforeach 4156if have_cross 4157 summary(summary_info, bool_yn: true, section: 'Cross compilers') 4158endif 4159 4160# Targets and accelerators 4161summary_info = {} 4162if have_system 4163 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')} 4164 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')} 4165 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')} 4166 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')} 4167 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')} 4168 summary_info += {'Xen support': xen.found()} 4169 if xen.found() 4170 summary_info += {'xen ctrl version': xen.version()} 4171 endif 4172 summary_info += {'Xen emulation': config_all.has_key('CONFIG_XEN_EMU')} 4173endif 4174summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')} 4175if config_all.has_key('CONFIG_TCG') 4176 if get_option('tcg_interpreter') 4177 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'} 4178 else 4179 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)} 4180 endif 4181 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')} 4182 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')} 4183endif 4184summary_info += {'target list': ' '.join(target_dirs)} 4185if have_system 4186 summary_info += {'default devices': get_option('default_devices')} 4187 summary_info += {'out of process emulation': multiprocess_allowed} 4188 summary_info += {'vfio-user server': vfio_user_server_allowed} 4189endif 4190summary(summary_info, bool_yn: true, section: 'Targets and accelerators') 4191 4192# Block layer 4193summary_info = {} 4194summary_info += {'coroutine backend': coroutine_backend} 4195summary_info += {'coroutine pool': have_coroutine_pool} 4196if have_block 4197 summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')} 4198 summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')} 4199 summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')} 4200 summary_info += {'VirtFS (9P) support': have_virtfs} 4201 summary_info += {'VirtFS (9P) Proxy Helper support': have_virtfs_proxy_helper} 4202 summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')} 4203 summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')} 4204 summary_info += {'bochs support': get_option('bochs').allowed()} 4205 summary_info += {'cloop support': get_option('cloop').allowed()} 4206 summary_info += {'dmg support': get_option('dmg').allowed()} 4207 summary_info += {'qcow v1 support': get_option('qcow1').allowed()} 4208 summary_info += {'vdi support': get_option('vdi').allowed()} 4209 summary_info += {'vhdx support': get_option('vhdx').allowed()} 4210 summary_info += {'vmdk support': get_option('vmdk').allowed()} 4211 summary_info += {'vpc support': get_option('vpc').allowed()} 4212 summary_info += {'vvfat support': get_option('vvfat').allowed()} 4213 summary_info += {'qed support': get_option('qed').allowed()} 4214 summary_info += {'parallels support': get_option('parallels').allowed()} 4215 summary_info += {'FUSE exports': fuse} 4216 summary_info += {'VDUSE block exports': have_vduse_blk_export} 4217endif 4218summary(summary_info, bool_yn: true, section: 'Block layer support') 4219 4220# Crypto 4221summary_info = {} 4222summary_info += {'TLS priority': get_option('tls_priority')} 4223summary_info += {'GNUTLS support': gnutls} 4224if gnutls.found() 4225 summary_info += {' GNUTLS crypto': gnutls_crypto.found()} 4226endif 4227summary_info += {'libgcrypt': gcrypt} 4228summary_info += {'nettle': nettle} 4229if nettle.found() 4230 summary_info += {' XTS': xts != 'private'} 4231endif 4232summary_info += {'AF_ALG support': have_afalg} 4233summary_info += {'rng-none': get_option('rng_none')} 4234summary_info += {'Linux keyring': have_keyring} 4235summary(summary_info, bool_yn: true, section: 'Crypto') 4236 4237# Libraries 4238summary_info = {} 4239if targetos == 'darwin' 4240 summary_info += {'Cocoa support': cocoa} 4241 summary_info += {'vmnet.framework support': vmnet} 4242endif 4243summary_info += {'SDL support': sdl} 4244summary_info += {'SDL image support': sdl_image} 4245summary_info += {'GTK support': gtk} 4246summary_info += {'pixman': pixman} 4247summary_info += {'VTE support': vte} 4248summary_info += {'slirp support': slirp} 4249summary_info += {'libtasn1': tasn1} 4250summary_info += {'PAM': pam} 4251summary_info += {'iconv support': iconv} 4252summary_info += {'curses support': curses} 4253summary_info += {'virgl support': virgl} 4254summary_info += {'blkio support': blkio} 4255summary_info += {'curl support': curl} 4256summary_info += {'Multipath support': mpathpersist} 4257summary_info += {'PNG support': png} 4258summary_info += {'VNC support': vnc} 4259if vnc.found() 4260 summary_info += {'VNC SASL support': sasl} 4261 summary_info += {'VNC JPEG support': jpeg} 4262endif 4263if targetos not in ['darwin', 'haiku', 'windows'] 4264 summary_info += {'OSS support': oss} 4265 summary_info += {'sndio support': sndio} 4266elif targetos == 'darwin' 4267 summary_info += {'CoreAudio support': coreaudio} 4268elif targetos == 'windows' 4269 summary_info += {'DirectSound support': dsound} 4270endif 4271if targetos == 'linux' 4272 summary_info += {'ALSA support': alsa} 4273 summary_info += {'PulseAudio support': pulse} 4274endif 4275summary_info += {'Pipewire support': pipewire} 4276summary_info += {'JACK support': jack} 4277summary_info += {'brlapi support': brlapi} 4278summary_info += {'vde support': vde} 4279summary_info += {'netmap support': have_netmap} 4280summary_info += {'l2tpv3 support': have_l2tpv3} 4281summary_info += {'Linux AIO support': libaio} 4282summary_info += {'Linux io_uring support': linux_io_uring} 4283summary_info += {'ATTR/XATTR support': libattr} 4284summary_info += {'RDMA support': rdma} 4285summary_info += {'PVRDMA support': have_pvrdma} 4286summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt} 4287summary_info += {'libcap-ng support': libcap_ng} 4288summary_info += {'bpf support': libbpf} 4289summary_info += {'spice protocol support': spice_protocol} 4290if spice_protocol.found() 4291 summary_info += {' spice server support': spice} 4292endif 4293summary_info += {'rbd support': rbd} 4294summary_info += {'smartcard support': cacard} 4295summary_info += {'U2F support': u2f} 4296summary_info += {'libusb': libusb} 4297summary_info += {'usb net redir': usbredir} 4298summary_info += {'OpenGL support (epoxy)': opengl} 4299summary_info += {'GBM': gbm} 4300summary_info += {'libiscsi support': libiscsi} 4301summary_info += {'libnfs support': libnfs} 4302if targetos == 'windows' 4303 if have_ga 4304 summary_info += {'QGA VSS support': have_qga_vss} 4305 endif 4306endif 4307summary_info += {'seccomp support': seccomp} 4308summary_info += {'GlusterFS support': glusterfs} 4309summary_info += {'TPM support': have_tpm} 4310summary_info += {'libssh support': libssh} 4311summary_info += {'lzo support': lzo} 4312summary_info += {'snappy support': snappy} 4313summary_info += {'bzip2 support': libbzip2} 4314summary_info += {'lzfse support': liblzfse} 4315summary_info += {'zstd support': zstd} 4316summary_info += {'NUMA host support': numa} 4317summary_info += {'capstone': capstone} 4318summary_info += {'libpmem support': libpmem} 4319summary_info += {'libdaxctl support': libdaxctl} 4320summary_info += {'libudev': libudev} 4321# Dummy dependency, keep .found() 4322summary_info += {'FUSE lseek': fuse_lseek.found()} 4323summary_info += {'selinux': selinux} 4324summary_info += {'libdw': libdw} 4325summary(summary_info, bool_yn: true, section: 'Dependencies') 4326 4327if not supported_cpus.contains(cpu) 4328 message() 4329 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!') 4330 message() 4331 message('CPU host architecture ' + cpu + ' support is not currently maintained.') 4332 message('The QEMU project intends to remove support for this host CPU in') 4333 message('a future release if nobody volunteers to maintain it and to') 4334 message('provide a build host for our continuous integration setup.') 4335 message('configure has succeeded and you can continue to build, but') 4336 message('if you care about QEMU on this platform you should contact') 4337 message('us upstream at qemu-devel@nongnu.org.') 4338endif 4339 4340if not supported_oses.contains(targetos) 4341 message() 4342 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!') 4343 message() 4344 message('Host OS ' + targetos + 'support is not currently maintained.') 4345 message('The QEMU project intends to remove support for this host OS in') 4346 message('a future release if nobody volunteers to maintain it and to') 4347 message('provide a build host for our continuous integration setup.') 4348 message('configure has succeeded and you can continue to build, but') 4349 message('if you care about QEMU on this platform you should contact') 4350 message('us upstream at qemu-devel@nongnu.org.') 4351endif 4352