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