meson.build

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