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