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