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