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