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