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