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