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() and libcap_ng.found()),
1770              error_message: 'virtio-9p (virtfs) on Linux requires libcap-ng-devel and libattr-devel') \
1771     .disable_auto_if(not have_tools and not have_system) \
1772     .allowed()
1773
1774 have_virtfs_proxy_helper = targetos != 'darwin' and have_virtfs and have_tools
1775
1776 if get_option('block_drv_ro_whitelist') == ''
1777   config_host_data.set('CONFIG_BDRV_RO_WHITELIST', '')
1778 else
1779   config_host_data.set('CONFIG_BDRV_RO_WHITELIST',
1780         '"' + get_option('block_drv_ro_whitelist').replace(',', '", "') + '", ')
1781 endif
1782 if get_option('block_drv_rw_whitelist') == ''
1783   config_host_data.set('CONFIG_BDRV_RW_WHITELIST', '')
1784 else
1785   config_host_data.set('CONFIG_BDRV_RW_WHITELIST',
1786         '"' + get_option('block_drv_rw_whitelist').replace(',', '", "') + '", ')
1787 endif
1788
1789 foreach k : get_option('trace_backends')
1790   config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
1791 endforeach
1792 config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
1793 config_host_data.set_quoted('CONFIG_TLS_PRIORITY', get_option('tls_priority'))
1794 if iasl.found()
1795   config_host_data.set_quoted('CONFIG_IASL', iasl.full_path())
1796 endif
1797 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1798 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1799 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1800 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1801 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1802
1803 qemu_firmwarepath = ''
1804 foreach k : get_option('qemu_firmwarepath')
1805   qemu_firmwarepath += '"' + get_option('prefix') / k + '", '
1806 endforeach
1807 config_host_data.set('CONFIG_QEMU_FIRMWAREPATH', qemu_firmwarepath)
1808
1809 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1810 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1811 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1812 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1813 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1814 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1815
1816 if config_host.has_key('CONFIG_MODULES')
1817   config_host_data.set('CONFIG_STAMP', run_command(
1818       meson.current_source_dir() / 'scripts/qemu-stamp.py',
1819       meson.project_version(), get_option('pkgversion'), '--',
1820       meson.current_source_dir() / 'configure',
1821       capture: true, check: true).stdout().strip())
1822 endif
1823
1824 have_slirp_smbd = get_option('slirp_smbd') \
1825   .require(targetos != 'windows', error_message: 'Host smbd not supported on this platform.') \
1826   .allowed()
1827 if have_slirp_smbd
1828   smbd_path = get_option('smbd')
1829   if smbd_path == ''
1830     smbd_path = (targetos == 'solaris' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd')
1831   endif
1832   config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path)
1833 endif
1834
1835 config_host_data.set('HOST_' + host_arch.to_upper(), 1)
1836
1837 if get_option('module_upgrades') and not enable_modules
1838   error('Cannot enable module-upgrades as modules are not enabled')
1839 endif
1840 config_host_data.set('CONFIG_MODULE_UPGRADES', get_option('module_upgrades'))
1841
1842 config_host_data.set('CONFIG_ATTR', libattr.found())
1843 config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools'))
1844 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1845 config_host_data.set('CONFIG_COCOA', cocoa.found())
1846 config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
1847 config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
1848 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1849 config_host_data.set('CONFIG_LZO', lzo.found())
1850 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1851 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1852 config_host_data.set('CONFIG_BLKIO', blkio.found())
1853 config_host_data.set('CONFIG_CURL', curl.found())
1854 config_host_data.set('CONFIG_CURSES', curses.found())
1855 config_host_data.set('CONFIG_GBM', gbm.found())
1856 config_host_data.set('CONFIG_GIO', gio.found())
1857 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1858 if glusterfs.found()
1859   config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1860   config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1861   config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1862   config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1863   config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1864   config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1865 endif
1866 config_host_data.set('CONFIG_GTK', gtk.found())
1867 config_host_data.set('CONFIG_VTE', vte.found())
1868 config_host_data.set('CONFIG_GTK_CLIPBOARD', have_gtk_clipboard)
1869 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1870 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1871 config_host_data.set('CONFIG_EBPF', libbpf.found())
1872 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
1873 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1874 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1875 config_host_data.set('CONFIG_LIBSSH', libssh.found())
1876 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
1877 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
1878 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
1879 config_host_data.set('CONFIG_NUMA', numa.found())
1880 if numa.found()
1881   config_host_data.set('HAVE_NUMA_HAS_PREFERRED_MANY',
1882                        cc.has_function('numa_has_preferred_many',
1883                                        dependencies: numa))
1884 endif
1885 config_host_data.set('CONFIG_OPENGL', opengl.found())
1886 config_host_data.set('CONFIG_PROFILER', get_option('profiler'))
1887 config_host_data.set('CONFIG_RBD', rbd.found())
1888 config_host_data.set('CONFIG_RDMA', rdma.found())
1889 config_host_data.set('CONFIG_SDL', sdl.found())
1890 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1891 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1892 if seccomp.found()
1893   config_host_data.set('CONFIG_SECCOMP_SYSRAWRC', seccomp_has_sysrawrc)
1894 endif
1895 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1896 config_host_data.set('CONFIG_TPM', have_tpm)
1897 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
1898 config_host_data.set('CONFIG_VDE', vde.found())
1899 config_host_data.set('CONFIG_VHOST_NET', have_vhost_net)
1900 config_host_data.set('CONFIG_VHOST_NET_USER', have_vhost_net_user)
1901 config_host_data.set('CONFIG_VHOST_NET_VDPA', have_vhost_net_vdpa)
1902 config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel)
1903 config_host_data.set('CONFIG_VHOST_USER', have_vhost_user)
1904 config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto)
1905 config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa)
1906 config_host_data.set('CONFIG_VMNET', vmnet.found())
1907 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1908 config_host_data.set('CONFIG_VDUSE_BLK_EXPORT', have_vduse_blk_export)
1909 config_host_data.set('CONFIG_PNG', png.found())
1910 config_host_data.set('CONFIG_VNC', vnc.found())
1911 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1912 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1913 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1914 config_host_data.set('CONFIG_VTE', vte.found())
1915 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1916 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1917 config_host_data.set('CONFIG_GETTID', has_gettid)
1918 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
1919 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
1920 config_host_data.set('CONFIG_TASN1', tasn1.found())
1921 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
1922 config_host_data.set('CONFIG_NETTLE', nettle.found())
1923 config_host_data.set('CONFIG_HOGWEED', hogweed.found())
1924 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
1925 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1926 config_host_data.set('CONFIG_STATX', has_statx)
1927 config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id)
1928 config_host_data.set('CONFIG_ZSTD', zstd.found())
1929 config_host_data.set('CONFIG_FUSE', fuse.found())
1930 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1931 config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
1932 if spice_protocol.found()
1933 config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
1934 config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
1935 config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
1936 endif
1937 config_host_data.set('CONFIG_SPICE', spice.found())
1938 config_host_data.set('CONFIG_X11', x11.found())
1939 config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
1940 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1941 config_host_data.set('CONFIG_SELINUX', selinux.found())
1942 config_host_data.set('CONFIG_XEN_BACKEND', xen.found())
1943 config_host_data.set('CONFIG_LIBDW', libdw.found())
1944 if xen.found()
1945   # protect from xen.version() having less than three components
1946   xen_version = xen.version().split('.') + ['0', '0']
1947   xen_ctrl_version = xen_version[0] + \
1948     ('0' + xen_version[1]).substring(-2) + \
1949     ('0' + xen_version[2]).substring(-2)
1950   config_host_data.set('CONFIG_XEN_CTRL_INTERFACE_VERSION', xen_ctrl_version)
1951 endif
1952 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1953 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1954 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1955 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1956
1957 config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
1958 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
1959
1960 have_coroutine_pool = get_option('coroutine_pool')
1961 if get_option('debug_stack_usage') and have_coroutine_pool
1962   message('Disabling coroutine pool to measure stack usage')
1963   have_coroutine_pool = false
1964 endif
1965 config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool)
1966 config_host_data.set('CONFIG_DEBUG_GRAPH_LOCK', get_option('debug_graph_lock'))
1967 config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
1968 config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
1969 config_host_data.set('CONFIG_GPROF', get_option('gprof'))
1970 config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
1971 config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
1972 config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed())
1973
1974 # has_header
1975 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1976 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1977 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1978 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1979 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1980 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1981 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1982 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1983 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1984 if targetos == 'windows'
1985   config_host_data.set('HAVE_AFUNIX_H', cc.has_header('afunix.h'))
1986 endif
1987
1988 # has_function
1989 config_host_data.set('CONFIG_CLOSE_RANGE', cc.has_function('close_range'))
1990 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1991 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1992 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1993 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1994 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1995 # Note that we need to specify prefix: here to avoid incorrectly
1996 # thinking that Windows has posix_memalign()
1997 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
1998 config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
1999 config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
2000 config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
2001 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
2002 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
2003 config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
2004 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
2005 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
2006 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
2007 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
2008 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
2009 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
2010 config_host_data.set('HAVE_GETIFADDRS', cc.has_function('getifaddrs'))
2011 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
2012 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
2013 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
2014 if rbd.found()
2015   config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS',
2016                        cc.has_function('rbd_namespace_exists',
2017                                        dependencies: rbd,
2018                                        prefix: '#include <rbd/librbd.h>'))
2019 endif
2020 if rdma.found()
2021   config_host_data.set('HAVE_IBV_ADVISE_MR',
2022                        cc.has_function('ibv_advise_mr',
2023                                        dependencies: rdma,
2024                                        prefix: '#include <infiniband/verbs.h>'))
2025 endif
2026
2027 # has_header_symbol
2028 config_host_data.set('CONFIG_EPOLL_CREATE1',
2029                      cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
2030 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
2031                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
2032                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
2033 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
2034                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
2035 config_host_data.set('CONFIG_FIEMAP',
2036                      cc.has_header('linux/fiemap.h') and
2037                      cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
2038 config_host_data.set('CONFIG_GETRANDOM',
2039                      cc.has_function('getrandom') and
2040                      cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
2041 config_host_data.set('CONFIG_INOTIFY',
2042                      cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
2043 config_host_data.set('CONFIG_INOTIFY1',
2044                      cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
2045 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
2046                      cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
2047 config_host_data.set('CONFIG_RTNETLINK',
2048                      cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
2049 config_host_data.set('CONFIG_SYSMACROS',
2050                      cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
2051 config_host_data.set('HAVE_OPTRESET',
2052                      cc.has_header_symbol('getopt.h', 'optreset'))
2053 config_host_data.set('HAVE_IPPROTO_MPTCP',
2054                      cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
2055
2056 # has_member
2057 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
2058                      cc.has_member('struct sigevent', 'sigev_notify_thread_id',
2059                                    prefix: '#include <signal.h>'))
2060 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
2061                      cc.has_member('struct stat', 'st_atim',
2062                                    prefix: '#include <sys/stat.h>'))
2063
2064 # has_type
2065 config_host_data.set('CONFIG_IOVEC',
2066                      cc.has_type('struct iovec',
2067                                  prefix: '#include <sys/uio.h>'))
2068 config_host_data.set('HAVE_UTMPX',
2069                      cc.has_type('struct utmpx',
2070                                  prefix: '#include <utmpx.h>'))
2071
2072 config_host_data.set('CONFIG_EVENTFD', cc.links('''
2073   #include <sys/eventfd.h>
2074   int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
2075 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
2076   #include <unistd.h>
2077   int main(void) {
2078   #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
2079   return fdatasync(0);
2080   #else
2081   #error Not supported
2082   #endif
2083   }'''))
2084
2085 has_madvise = cc.links(gnu_source_prefix + '''
2086   #include <sys/types.h>
2087   #include <sys/mman.h>
2088   #include <stddef.h>
2089   int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''')
2090 missing_madvise_proto = false
2091 if has_madvise
2092   # Some platforms (illumos and Solaris before Solaris 11) provide madvise()
2093   # but forget to prototype it. In this case, has_madvise will be true (the
2094   # test program links despite a compile warning). To detect the
2095   # missing-prototype case, we try again with a definitely-bogus prototype.
2096   # This will only compile if the system headers don't provide the prototype;
2097   # otherwise the conflicting prototypes will cause a compiler error.
2098   missing_madvise_proto = cc.links(gnu_source_prefix + '''
2099     #include <sys/types.h>
2100     #include <sys/mman.h>
2101     #include <stddef.h>
2102     extern int madvise(int);
2103     int main(void) { return madvise(0); }''')
2104 endif
2105 config_host_data.set('CONFIG_MADVISE', has_madvise)
2106 config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
2107
2108 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
2109   #include <sys/mman.h>
2110   int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
2111 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
2112   #include <fcntl.h>
2113   #if !defined(AT_EMPTY_PATH)
2114   # error missing definition
2115   #else
2116   int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
2117   #endif'''))
2118 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
2119   #include <sys/mman.h>
2120   #include <stddef.h>
2121   int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
2122
2123 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
2124   #include <pthread.h>
2125
2126   static void *f(void *p) { return NULL; }
2127   int main(void)
2128   {
2129     pthread_t thread;
2130     pthread_create(&thread, 0, f, 0);
2131     pthread_setname_np(thread, "QEMU");
2132     return 0;
2133   }''', dependencies: threads))
2134 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
2135   #include <pthread.h>
2136
2137   static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
2138   int main(void)
2139   {
2140     pthread_t thread;
2141     pthread_create(&thread, 0, f, 0);
2142     return 0;
2143   }''', dependencies: threads))
2144 config_host_data.set('CONFIG_PTHREAD_SET_NAME_NP', cc.links(gnu_source_prefix + '''
2145   #include <pthread.h>
2146   #include <pthread_np.h>
2147
2148   static void *f(void *p) { return NULL; }
2149   int main(void)
2150   {
2151     pthread_t thread;
2152     pthread_create(&thread, 0, f, 0);
2153     pthread_set_name_np(thread, "QEMU");
2154     return 0;
2155   }''', dependencies: threads))
2156 config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
2157   #include <pthread.h>
2158   #include <time.h>
2159
2160   int main(void)
2161   {
2162     pthread_condattr_t attr
2163     pthread_condattr_init(&attr);
2164     pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
2165     return 0;
2166   }''', dependencies: threads))
2167 config_host_data.set('CONFIG_PTHREAD_AFFINITY_NP', cc.links(gnu_source_prefix + '''
2168   #include <pthread.h>
2169
2170   static void *f(void *p) { return NULL; }
2171   int main(void)
2172   {
2173     int setsize = CPU_ALLOC_SIZE(64);
2174     pthread_t thread;
2175     cpu_set_t *cpuset;
2176     pthread_create(&thread, 0, f, 0);
2177     cpuset = CPU_ALLOC(64);
2178     CPU_ZERO_S(setsize, cpuset);
2179     pthread_setaffinity_np(thread, setsize, cpuset);
2180     pthread_getaffinity_np(thread, setsize, cpuset);
2181     CPU_FREE(cpuset);
2182     return 0;
2183   }''', dependencies: threads))
2184 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
2185   #include <sys/signalfd.h>
2186   #include <stddef.h>
2187   int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
2188 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
2189   #include <unistd.h>
2190   #include <fcntl.h>
2191   #include <limits.h>
2192
2193   int main(void)
2194   {
2195     int len, fd = 0;
2196     len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
2197     splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
2198     return 0;
2199   }'''))
2200
2201 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
2202   #include <sys/mman.h>
2203   int main(void) {
2204     return mlockall(MCL_FUTURE);
2205   }'''))
2206
2207 have_l2tpv3 = false
2208 if get_option('l2tpv3').allowed() and have_system
2209   have_l2tpv3 = cc.has_type('struct mmsghdr',
2210     prefix: gnu_source_prefix + '''
2211       #include <sys/socket.h>
2212       #include <linux/ip.h>''')
2213 endif
2214 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
2215
2216 have_netmap = false
2217 if get_option('netmap').allowed() and have_system
2218   have_netmap = cc.compiles('''
2219     #include <inttypes.h>
2220     #include <net/if.h>
2221     #include <net/netmap.h>
2222     #include <net/netmap_user.h>
2223     #if (NETMAP_API < 11) || (NETMAP_API > 15)
2224     #error
2225     #endif
2226     int main(void) { return 0; }''')
2227   if not have_netmap and get_option('netmap').enabled()
2228     error('Netmap headers not available')
2229   endif
2230 endif
2231 config_host_data.set('CONFIG_NETMAP', have_netmap)
2232
2233 # Work around a system header bug with some kernel/XFS header
2234 # versions where they both try to define 'struct fsxattr':
2235 # xfs headers will not try to redefine structs from linux headers
2236 # if this macro is set.
2237 config_host_data.set('HAVE_FSXATTR', cc.links('''
2238   #include <linux/fs.h>
2239   struct fsxattr foo;
2240   int main(void) {
2241     return 0;
2242   }'''))
2243
2244 # Some versions of Mac OS X incorrectly define SIZE_MAX
2245 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
2246     #include <stdint.h>
2247     #include <stdio.h>
2248     int main(void) {
2249         return printf("%zu", SIZE_MAX);
2250     }''', args: ['-Werror']))
2251
2252 atomic_test = '''
2253   #include <stdint.h>
2254   int main(void)
2255   {
2256     @0@ x = 0, y = 0;
2257     y = __atomic_load_n(&x, __ATOMIC_RELAXED);
2258     __atomic_store_n(&x, y, __ATOMIC_RELAXED);
2259     __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2260     __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
2261     __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
2262     return 0;
2263   }'''
2264
2265 # See if 64-bit atomic operations are supported.
2266 # Note that without __atomic builtins, we can only
2267 # assume atomic loads/stores max at pointer size.
2268 config_host_data.set('CONFIG_ATOMIC64', cc.links(atomic_test.format('uint64_t')))
2269
2270 has_int128 = cc.links('''
2271   __int128_t a;
2272   __uint128_t b;
2273   int main (void) {
2274     a = a + b;
2275     b = a * b;
2276     a = a * a;
2277     return 0;
2278   }''')
2279
2280 config_host_data.set('CONFIG_INT128', has_int128)
2281
2282 if has_int128
2283   # "do we have 128-bit atomics which are handled inline and specifically not
2284   # via libatomic". The reason we can't use libatomic is documented in the
2285   # comment starting "GCC is a house divided" in include/qemu/atomic128.h.
2286   has_atomic128 = cc.links(atomic_test.format('unsigned __int128'))
2287
2288   config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
2289
2290   if not has_atomic128
2291     has_cmpxchg128 = cc.links('''
2292       int main(void)
2293       {
2294         unsigned __int128 x = 0, y = 0;
2295         __sync_val_compare_and_swap_16(&x, y, x);
2296         return 0;
2297       }
2298     ''')
2299
2300     config_host_data.set('CONFIG_CMPXCHG128', has_cmpxchg128)
2301   endif
2302 endif
2303
2304 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
2305   #include <sys/auxv.h>
2306   int main(void) {
2307     return getauxval(AT_HWCAP) == 0;
2308   }'''))
2309
2310 config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles('''
2311   #include <linux/usbdevice_fs.h>
2312
2313   #ifndef USBDEVFS_GET_CAPABILITIES
2314   #error "USBDEVFS_GET_CAPABILITIES undefined"
2315   #endif
2316
2317   #ifndef USBDEVFS_DISCONNECT_CLAIM
2318   #error "USBDEVFS_DISCONNECT_CLAIM undefined"
2319   #endif
2320
2321   int main(void) { return 0; }'''))
2322
2323 have_keyring = get_option('keyring') \
2324   .require(targetos == 'linux', error_message: 'keyring is only available on Linux') \
2325   .require(cc.compiles('''
2326     #include <errno.h>
2327     #include <asm/unistd.h>
2328     #include <linux/keyctl.h>
2329     #include <sys/syscall.h>
2330     #include <unistd.h>
2331     int main(void) {
2332         return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0);
2333     }'''), error_message: 'keyctl syscall not available on this system').allowed()
2334 config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring)
2335
2336 have_cpuid_h = cc.links('''
2337   #include <cpuid.h>
2338   int main(void) {
2339     unsigned a, b, c, d;
2340     unsigned max = __get_cpuid_max(0, 0);
2341
2342     if (max >= 1) {
2343         __cpuid(1, a, b, c, d);
2344     }
2345
2346     if (max >= 7) {
2347         __cpuid_count(7, 0, a, b, c, d);
2348     }
2349
2350     return 0;
2351   }''')
2352 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
2353
2354 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
2355   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
2356   .require(cc.links('''
2357     #include <cpuid.h>
2358     #include <immintrin.h>
2359     static int __attribute__((target("avx2"))) bar(void *a) {
2360       __m256i x = *(__m256i *)a;
2361       return _mm256_testz_si256(x, x);
2362     }
2363     int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2364   '''), error_message: 'AVX2 not available').allowed())
2365
2366 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
2367   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
2368   .require(cc.links('''
2369     #include <cpuid.h>
2370     #include <immintrin.h>
2371     static int __attribute__((target("avx512f"))) bar(void *a) {
2372       __m512i x = *(__m512i *)a;
2373       return _mm512_test_epi64_mask(x, x);
2374     }
2375     int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2376   '''), error_message: 'AVX512F not available').allowed())
2377
2378 config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \
2379   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \
2380   .require(cc.links('''
2381     #include <cpuid.h>
2382     #include <immintrin.h>
2383     static int __attribute__((target("avx512bw"))) bar(void *a) {
2384       __m512i *x = a;
2385       __m512i res= _mm512_abs_epi8(*x);
2386       return res[1];
2387     }
2388     int main(int argc, char *argv[]) { return bar(argv[0]); }
2389   '''), error_message: 'AVX512BW not available').allowed())
2390
2391 have_pvrdma = get_option('pvrdma') \
2392   .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \
2393   .require(cc.compiles(gnu_source_prefix + '''
2394     #include <sys/mman.h>
2395     int main(void)
2396     {
2397       char buf = 0;
2398       void *addr = &buf;
2399       addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED);
2400
2401       return 0;
2402     }'''), error_message: 'PVRDMA requires mremap').allowed()
2403
2404 if have_pvrdma
2405   config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links('''
2406     #include <infiniband/verbs.h>
2407     int main(void)
2408     {
2409       struct ibv_mr *mr;
2410       struct ibv_pd *pd = NULL;
2411       size_t length = 10;
2412       uint64_t iova = 0;
2413       int access = 0;
2414       void *addr = NULL;
2415
2416       mr = ibv_reg_mr_iova(pd, addr, length, iova, access);
2417       ibv_dereg_mr(mr);
2418       return 0;
2419     }'''))
2420 endif
2421
2422 if get_option('membarrier').disabled()
2423   have_membarrier = false
2424 elif targetos == 'windows'
2425   have_membarrier = true
2426 elif targetos == 'linux'
2427   have_membarrier = cc.compiles('''
2428     #include <linux/membarrier.h>
2429     #include <sys/syscall.h>
2430     #include <unistd.h>
2431     #include <stdlib.h>
2432     int main(void) {
2433         syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
2434         syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
2435         exit(0);
2436     }''')
2437 endif
2438 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
2439   .require(have_membarrier, error_message: 'membarrier system call not available') \
2440   .allowed())
2441
2442 have_afalg = get_option('crypto_afalg') \
2443   .require(cc.compiles(gnu_source_prefix + '''
2444     #include <errno.h>
2445     #include <sys/types.h>
2446     #include <sys/socket.h>
2447     #include <linux/if_alg.h>
2448     int main(void) {
2449       int sock;
2450       sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
2451       return sock;
2452     }
2453   '''), error_message: 'AF_ALG requested but could not be detected').allowed()
2454 config_host_data.set('CONFIG_AF_ALG', have_afalg)
2455
2456 config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol(
2457   'linux/vm_sockets.h', 'AF_VSOCK',
2458   prefix: '#include <sys/socket.h>',
2459 ))
2460
2461 have_vss = false
2462 have_vss_sdk = false # old xp/2003 SDK
2463 if targetos == 'windows' and link_language == 'cpp'
2464   have_vss = cxx.compiles('''
2465     #define __MIDL_user_allocate_free_DEFINED__
2466     #include <vss.h>
2467     int main(void) { return VSS_CTX_BACKUP; }''')
2468   have_vss_sdk = cxx.has_header('vscoordint.h')
2469 endif
2470 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
2471
2472 foreach k, v: config_host
2473   if k.startswith('CONFIG_')
2474     config_host_data.set(k, v == 'y' ? 1 : v)
2475   endif
2476 endforeach
2477
2478 # Older versions of MinGW do not import _lock_file and _unlock_file properly.
2479 # This was fixed for v6.0.0 with commit b48e3ac8969d.
2480 if targetos == 'windows'
2481   config_host_data.set('HAVE__LOCK_FILE', cc.links('''
2482     #include <stdio.h>
2483     int main(void) {
2484       _lock_file(NULL);
2485       _unlock_file(NULL);
2486       return 0;
2487     }''', name: '_lock_file and _unlock_file'))
2488 endif
2489
2490 if targetos == 'windows'
2491   mingw_has_setjmp_longjmp = cc.links('''
2492     #include <setjmp.h>
2493     int main(void) {
2494       /*
2495        * These functions are not available in setjmp header, but may be
2496        * available at link time, from libmingwex.a.
2497        */
2498       extern int __mingw_setjmp(jmp_buf);
2499       extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int);
2500       jmp_buf env;
2501       __mingw_setjmp(env);
2502       __mingw_longjmp(env, 0);
2503     }
2504   ''', name: 'mingw setjmp and longjmp')
2505
2506   if cpu == 'aarch64' and not mingw_has_setjmp_longjmp
2507     error('mingw must provide setjmp/longjmp for windows-arm64')
2508   endif
2509 endif
2510
2511 ########################
2512 # Target configuration #
2513 ########################
2514
2515 minikconf = find_program('scripts/minikconf.py')
2516 config_all = {}
2517 config_all_devices = {}
2518 config_all_disas = {}
2519 config_devices_mak_list = []
2520 config_devices_h = {}
2521 config_target_h = {}
2522 config_target_mak = {}
2523
2524 disassemblers = {
2525   'alpha' : ['CONFIG_ALPHA_DIS'],
2526   'avr' : ['CONFIG_AVR_DIS'],
2527   'cris' : ['CONFIG_CRIS_DIS'],
2528   'hexagon' : ['CONFIG_HEXAGON_DIS'],
2529   'hppa' : ['CONFIG_HPPA_DIS'],
2530   'i386' : ['CONFIG_I386_DIS'],
2531   'x86_64' : ['CONFIG_I386_DIS'],
2532   'm68k' : ['CONFIG_M68K_DIS'],
2533   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2534   'mips' : ['CONFIG_MIPS_DIS'],
2535   'nios2' : ['CONFIG_NIOS2_DIS'],
2536   'or1k' : ['CONFIG_OPENRISC_DIS'],
2537   'ppc' : ['CONFIG_PPC_DIS'],
2538   'riscv' : ['CONFIG_RISCV_DIS'],
2539   'rx' : ['CONFIG_RX_DIS'],
2540   's390' : ['CONFIG_S390_DIS'],
2541   'sh4' : ['CONFIG_SH4_DIS'],
2542   'sparc' : ['CONFIG_SPARC_DIS'],
2543   'xtensa' : ['CONFIG_XTENSA_DIS'],
2544   'loongarch' : ['CONFIG_LOONGARCH_DIS'],
2545 }
2546
2547 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2548 host_kconfig = \
2549   (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2550   (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2551   (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2552   (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2553   (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \
2554   (x11.found() ? ['CONFIG_X11=y'] : []) + \
2555   (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \
2556   (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2557   (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2558   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2559   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2560   (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
2561   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
2562   (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : [])
2563
2564 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2565
2566 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2567 actual_target_dirs = []
2568 fdt_required = []
2569 foreach target : target_dirs
2570   config_target = { 'TARGET_NAME': target.split('-')[0] }
2571   if target.endswith('linux-user')
2572     if targetos != 'linux'
2573       if default_targets
2574         continue
2575       endif
2576       error('Target @0@ is only available on a Linux host'.format(target))
2577     endif
2578     config_target += { 'CONFIG_LINUX_USER': 'y' }
2579   elif target.endswith('bsd-user')
2580     if 'CONFIG_BSD' not in config_host
2581       if default_targets
2582         continue
2583       endif
2584       error('Target @0@ is only available on a BSD host'.format(target))
2585     endif
2586     config_target += { 'CONFIG_BSD_USER': 'y' }
2587   elif target.endswith('softmmu')
2588     config_target += { 'CONFIG_SOFTMMU': 'y' }
2589   endif
2590   if target.endswith('-user')
2591     config_target += {
2592       'CONFIG_USER_ONLY': 'y',
2593       'CONFIG_QEMU_INTERP_PREFIX':
2594         get_option('interp_prefix').replace('%M', config_target['TARGET_NAME'])
2595     }
2596   endif
2597
2598   accel_kconfig = []
2599   foreach sym: accelerators
2600     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2601       config_target += { sym: 'y' }
2602       config_all += { sym: 'y' }
2603       if target in modular_tcg
2604         config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2605       else
2606         config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2607       endif
2608       accel_kconfig += [ sym + '=y' ]
2609     endif
2610   endforeach
2611   if accel_kconfig.length() == 0
2612     if default_targets
2613       continue
2614     endif
2615     error('No accelerator available for target @0@'.format(target))
2616   endif
2617
2618   actual_target_dirs += target
2619   config_target += keyval.load('configs/targets' / target + '.mak')
2620   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2621
2622   if 'TARGET_NEED_FDT' in config_target
2623     fdt_required += target
2624   endif
2625
2626   # Add default keys
2627   if 'TARGET_BASE_ARCH' not in config_target
2628     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2629   endif
2630   if 'TARGET_ABI_DIR' not in config_target
2631     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2632   endif
2633   if 'TARGET_BIG_ENDIAN' not in config_target
2634     config_target += {'TARGET_BIG_ENDIAN': 'n'}
2635   endif
2636
2637   foreach k, v: disassemblers
2638     if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2639       foreach sym: v
2640         config_target += { sym: 'y' }
2641         config_all_disas += { sym: 'y' }
2642       endforeach
2643     endif
2644   endforeach
2645
2646   config_target_data = configuration_data()
2647   foreach k, v: config_target
2648     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2649       # do nothing
2650     elif ignored.contains(k)
2651       # do nothing
2652     elif k == 'TARGET_BASE_ARCH'
2653       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2654       # not used to select files from sourcesets.
2655       config_target_data.set('TARGET_' + v.to_upper(), 1)
2656     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2657       config_target_data.set_quoted(k, v)
2658     elif v == 'y'
2659       config_target_data.set(k, 1)
2660     elif v == 'n'
2661       config_target_data.set(k, 0)
2662     else
2663       config_target_data.set(k, v)
2664     endif
2665   endforeach
2666   config_target_data.set('QEMU_ARCH',
2667                          'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2668   config_target_h += {target: configure_file(output: target + '-config-target.h',
2669                                                configuration: config_target_data)}
2670
2671   if target.endswith('-softmmu')
2672     config_input = meson.get_external_property(target, 'default')
2673     config_devices_mak = target + '-config-devices.mak'
2674     config_devices_mak = configure_file(
2675       input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2676       output: config_devices_mak,
2677       depfile: config_devices_mak + '.d',
2678       capture: true,
2679       command: [minikconf,
2680                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2681                 config_devices_mak, '@DEPFILE@', '@INPUT@',
2682                 host_kconfig, accel_kconfig,
2683                 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2684
2685     config_devices_data = configuration_data()
2686     config_devices = keyval.load(config_devices_mak)
2687     foreach k, v: config_devices
2688       config_devices_data.set(k, 1)
2689     endforeach
2690     config_devices_mak_list += config_devices_mak
2691     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2692                                                 configuration: config_devices_data)}
2693     config_target += config_devices
2694     config_all_devices += config_devices
2695   endif
2696   config_target_mak += {target: config_target}
2697 endforeach
2698 target_dirs = actual_target_dirs
2699
2700 # This configuration is used to build files that are shared by
2701 # multiple binaries, and then extracted out of the "common"
2702 # static_library target.
2703 #
2704 # We do not use all_sources()/all_dependencies(), because it would
2705 # build literally all source files, including devices only used by
2706 # targets that are not built for this compilation.  The CONFIG_ALL
2707 # pseudo symbol replaces it.
2708
2709 config_all += config_all_devices
2710 config_all += config_host
2711 config_all += config_all_disas
2712 config_all += {
2713   'CONFIG_XEN': xen.found(),
2714   'CONFIG_SOFTMMU': have_system,
2715   'CONFIG_USER_ONLY': have_user,
2716   'CONFIG_ALL': true,
2717 }
2718
2719 target_configs_h = []
2720 foreach target: target_dirs
2721   target_configs_h += config_target_h[target]
2722   target_configs_h += config_devices_h.get(target, [])
2723 endforeach
2724 genh += custom_target('config-poison.h',
2725                       input: [target_configs_h],
2726                       output: 'config-poison.h',
2727                       capture: true,
2728                       command: [find_program('scripts/make-config-poison.sh'),
2729                                 target_configs_h])
2730
2731 ##############
2732 # Submodules #
2733 ##############
2734
2735 capstone = not_found
2736 if not get_option('capstone').auto() or have_system or have_user
2737   capstone = dependency('capstone', version: '>=3.0.5',
2738                         kwargs: static_kwargs, method: 'pkg-config',
2739                         required: get_option('capstone'))
2740
2741   # Some versions of capstone have broken pkg-config file
2742   # that reports a wrong -I path, causing the #include to
2743   # fail later. If the system has such a broken version
2744   # do not use it.
2745   if capstone.found() and not cc.compiles('#include <capstone.h>',
2746                                           dependencies: [capstone])
2747     capstone = not_found
2748     if get_option('capstone').enabled()
2749       error('capstone requested, but it does not appear to work')
2750     endif
2751   endif
2752 endif
2753
2754 libvfio_user_dep = not_found
2755 if have_system and vfio_user_server_allowed
2756   have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build')
2757
2758   if not have_internal
2759     error('libvfio-user source not found - please pull git submodule')
2760   endif
2761
2762   libvfio_user_proj = subproject('libvfio-user')
2763
2764   libvfio_user_lib = libvfio_user_proj.get_variable('libvfio_user_dep')
2765
2766   libvfio_user_dep = declare_dependency(dependencies: [libvfio_user_lib])
2767 endif
2768
2769 fdt = not_found
2770 if have_system
2771   fdt_opt = get_option('fdt')
2772   if fdt_opt in ['enabled', 'auto', 'system']
2773     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2774     fdt = cc.find_library('fdt', kwargs: static_kwargs,
2775                           required: fdt_opt == 'system' or
2776                                     fdt_opt == 'enabled' and not have_internal)
2777     if fdt.found() and cc.links('''
2778        #include <libfdt.h>
2779        #include <libfdt_env.h>
2780        int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2781          dependencies: fdt)
2782       fdt_opt = 'system'
2783     elif fdt_opt == 'system'
2784        error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2785     elif have_internal
2786       fdt_opt = 'internal'
2787     else
2788       fdt_opt = 'disabled'
2789       fdt = not_found
2790     endif
2791   endif
2792   if fdt_opt == 'internal'
2793     fdt_files = files(
2794       'dtc/libfdt/fdt.c',
2795       'dtc/libfdt/fdt_ro.c',
2796       'dtc/libfdt/fdt_wip.c',
2797       'dtc/libfdt/fdt_sw.c',
2798       'dtc/libfdt/fdt_rw.c',
2799       'dtc/libfdt/fdt_strerror.c',
2800       'dtc/libfdt/fdt_empty_tree.c',
2801       'dtc/libfdt/fdt_addresses.c',
2802       'dtc/libfdt/fdt_overlay.c',
2803       'dtc/libfdt/fdt_check.c',
2804     )
2805
2806     fdt_inc = include_directories('dtc/libfdt')
2807     libfdt = static_library('fdt',
2808                             build_by_default: false,
2809                             sources: fdt_files,
2810                             include_directories: fdt_inc)
2811     fdt = declare_dependency(link_with: libfdt,
2812                              include_directories: fdt_inc)
2813   endif
2814 else
2815   fdt_opt = 'disabled'
2816 endif
2817 if not fdt.found() and fdt_required.length() > 0
2818   error('fdt not available but required by targets ' + ', '.join(fdt_required))
2819 endif
2820
2821 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2822 config_host_data.set('CONFIG_FDT', fdt.found())
2823 config_host_data.set('CONFIG_SLIRP', slirp.found())
2824
2825 #####################
2826 # Generated sources #
2827 #####################
2828
2829 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2830
2831 hxtool = find_program('scripts/hxtool')
2832 shaderinclude = find_program('scripts/shaderinclude.py')
2833 qapi_gen = find_program('scripts/qapi-gen.py')
2834 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2835                      meson.current_source_dir() / 'scripts/qapi/commands.py',
2836                      meson.current_source_dir() / 'scripts/qapi/common.py',
2837                      meson.current_source_dir() / 'scripts/qapi/error.py',
2838                      meson.current_source_dir() / 'scripts/qapi/events.py',
2839                      meson.current_source_dir() / 'scripts/qapi/expr.py',
2840                      meson.current_source_dir() / 'scripts/qapi/gen.py',
2841                      meson.current_source_dir() / 'scripts/qapi/introspect.py',
2842                      meson.current_source_dir() / 'scripts/qapi/main.py',
2843                      meson.current_source_dir() / 'scripts/qapi/parser.py',
2844                      meson.current_source_dir() / 'scripts/qapi/schema.py',
2845                      meson.current_source_dir() / 'scripts/qapi/source.py',
2846                      meson.current_source_dir() / 'scripts/qapi/types.py',
2847                      meson.current_source_dir() / 'scripts/qapi/visit.py',
2848                      meson.current_source_dir() / 'scripts/qapi-gen.py'
2849 ]
2850
2851 tracetool = [
2852   python, files('scripts/tracetool.py'),
2853    '--backend=' + ','.join(get_option('trace_backends'))
2854 ]
2855 tracetool_depends = files(
2856   'scripts/tracetool/backend/log.py',
2857   'scripts/tracetool/backend/__init__.py',
2858   'scripts/tracetool/backend/dtrace.py',
2859   'scripts/tracetool/backend/ftrace.py',
2860   'scripts/tracetool/backend/simple.py',
2861   'scripts/tracetool/backend/syslog.py',
2862   'scripts/tracetool/backend/ust.py',
2863   'scripts/tracetool/format/ust_events_c.py',
2864   'scripts/tracetool/format/ust_events_h.py',
2865   'scripts/tracetool/format/__init__.py',
2866   'scripts/tracetool/format/d.py',
2867   'scripts/tracetool/format/simpletrace_stap.py',
2868   'scripts/tracetool/format/c.py',
2869   'scripts/tracetool/format/h.py',
2870   'scripts/tracetool/format/log_stap.py',
2871   'scripts/tracetool/format/stap.py',
2872   'scripts/tracetool/__init__.py',
2873   'scripts/tracetool/vcpu.py'
2874 )
2875
2876 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2877                     meson.current_source_dir(),
2878                     get_option('pkgversion'), meson.project_version()]
2879 qemu_version = custom_target('qemu-version.h',
2880                              output: 'qemu-version.h',
2881                              command: qemu_version_cmd,
2882                              capture: true,
2883                              build_by_default: true,
2884                              build_always_stale: true)
2885 genh += qemu_version
2886
2887 hxdep = []
2888 hx_headers = [
2889   ['qemu-options.hx', 'qemu-options.def'],
2890   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2891 ]
2892 if have_system
2893   hx_headers += [
2894     ['hmp-commands.hx', 'hmp-commands.h'],
2895     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2896   ]
2897 endif
2898 foreach d : hx_headers
2899   hxdep += custom_target(d[1],
2900                 input: files(d[0]),
2901                 output: d[1],
2902                 capture: true,
2903                 build_by_default: true, # to be removed when added to a target
2904                 command: [hxtool, '-h', '@INPUT0@'])
2905 endforeach
2906 genh += hxdep
2907
2908 ###################
2909 # Collect sources #
2910 ###################
2911
2912 authz_ss = ss.source_set()
2913 blockdev_ss = ss.source_set()
2914 block_ss = ss.source_set()
2915 chardev_ss = ss.source_set()
2916 common_ss = ss.source_set()
2917 crypto_ss = ss.source_set()
2918 hwcore_ss = ss.source_set()
2919 io_ss = ss.source_set()
2920 qmp_ss = ss.source_set()
2921 qom_ss = ss.source_set()
2922 softmmu_ss = ss.source_set()
2923 specific_fuzz_ss = ss.source_set()
2924 specific_ss = ss.source_set()
2925 stub_ss = ss.source_set()
2926 trace_ss = ss.source_set()
2927 user_ss = ss.source_set()
2928 util_ss = ss.source_set()
2929
2930 # accel modules
2931 qtest_module_ss = ss.source_set()
2932 tcg_module_ss = ss.source_set()
2933
2934 modules = {}
2935 target_modules = {}
2936 hw_arch = {}
2937 target_arch = {}
2938 target_softmmu_arch = {}
2939 target_user_arch = {}
2940
2941 ###############
2942 # Trace files #
2943 ###############
2944
2945 # TODO: add each directory to the subdirs from its own meson.build, once
2946 # we have those
2947 trace_events_subdirs = [
2948   'crypto',
2949   'qapi',
2950   'qom',
2951   'monitor',
2952   'util',
2953   'gdbstub',
2954 ]
2955 if have_linux_user
2956   trace_events_subdirs += [ 'linux-user' ]
2957 endif
2958 if have_bsd_user
2959   trace_events_subdirs += [ 'bsd-user' ]
2960 endif
2961 if have_block
2962   trace_events_subdirs += [
2963     'authz',
2964     'block',
2965     'io',
2966     'nbd',
2967     'scsi',
2968   ]
2969 endif
2970 if have_system
2971   trace_events_subdirs += [
2972     'accel/kvm',
2973     'audio',
2974     'backends',
2975     'backends/tpm',
2976     'chardev',
2977     'ebpf',
2978     'hw/9pfs',
2979     'hw/acpi',
2980     'hw/adc',
2981     'hw/alpha',
2982     'hw/arm',
2983     'hw/audio',
2984     'hw/block',
2985     'hw/block/dataplane',
2986     'hw/char',
2987     'hw/display',
2988     'hw/dma',
2989     'hw/hyperv',
2990     'hw/i2c',
2991     'hw/i386',
2992     'hw/i386/xen',
2993     'hw/i386/kvm',
2994     'hw/ide',
2995     'hw/input',
2996     'hw/intc',
2997     'hw/isa',
2998     'hw/mem',
2999     'hw/mips',
3000     'hw/misc',
3001     'hw/misc/macio',
3002     'hw/net',
3003     'hw/net/can',
3004     'hw/nubus',
3005     'hw/nvme',
3006     'hw/nvram',
3007     'hw/pci',
3008     'hw/pci-host',
3009     'hw/ppc',
3010     'hw/rdma',
3011     'hw/rdma/vmw',
3012     'hw/rtc',
3013     'hw/s390x',
3014     'hw/scsi',
3015     'hw/sd',
3016     'hw/sh4',
3017     'hw/sparc',
3018     'hw/sparc64',
3019     'hw/ssi',
3020     'hw/timer',
3021     'hw/tpm',
3022     'hw/usb',
3023     'hw/vfio',
3024     'hw/virtio',
3025     'hw/watchdog',
3026     'hw/xen',
3027     'hw/gpio',
3028     'migration',
3029     'net',
3030     'softmmu',
3031     'ui',
3032     'hw/remote',
3033   ]
3034 endif
3035 if have_system or have_user
3036   trace_events_subdirs += [
3037     'accel/tcg',
3038     'hw/core',
3039     'target/arm',
3040     'target/arm/hvf',
3041     'target/hppa',
3042     'target/i386',
3043     'target/i386/kvm',
3044     'target/mips/tcg',
3045     'target/nios2',
3046     'target/ppc',
3047     'target/riscv',
3048     'target/s390x',
3049     'target/s390x/kvm',
3050     'target/sparc',
3051   ]
3052 endif
3053
3054 vhost_user = not_found
3055 if targetos == 'linux' and have_vhost_user
3056   libvhost_user = subproject('libvhost-user')
3057   vhost_user = libvhost_user.get_variable('vhost_user_dep')
3058 endif
3059
3060 libvduse = not_found
3061 if have_libvduse
3062   libvduse_proj = subproject('libvduse')
3063   libvduse = libvduse_proj.get_variable('libvduse_dep')
3064 endif
3065
3066 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
3067 # that is filled in by qapi/.
3068 subdir('qapi')
3069 subdir('qobject')
3070 subdir('stubs')
3071 subdir('trace')
3072 subdir('util')
3073 subdir('qom')
3074 subdir('authz')
3075 subdir('crypto')
3076 subdir('ui')
3077 subdir('hw')
3078 subdir('gdbstub')
3079
3080
3081 if enable_modules
3082   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
3083   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
3084 endif
3085
3086 qom_ss = qom_ss.apply(config_host, strict: false)
3087 libqom = static_library('qom', qom_ss.sources() + genh,
3088                         dependencies: [qom_ss.dependencies()],
3089                         name_suffix: 'fa')
3090 qom = declare_dependency(link_whole: libqom)
3091
3092 event_loop_base = files('event-loop-base.c')
3093 event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
3094                                  build_by_default: true)
3095 event_loop_base = declare_dependency(link_whole: event_loop_base,
3096                                      dependencies: [qom])
3097
3098 stub_ss = stub_ss.apply(config_all, strict: false)
3099
3100 util_ss.add_all(trace_ss)
3101 util_ss = util_ss.apply(config_all, strict: false)
3102 libqemuutil = static_library('qemuutil',
3103                              sources: util_ss.sources() + stub_ss.sources() + genh,
3104                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
3105 qemuutil = declare_dependency(link_with: libqemuutil,
3106                               sources: genh + version_res,
3107                               dependencies: [event_loop_base])
3108
3109 if have_system or have_user
3110   decodetree = generator(find_program('scripts/decodetree.py'),
3111                          output: 'decode-@BASENAME@.c.inc',
3112                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
3113   subdir('libdecnumber')
3114   subdir('target')
3115 endif
3116
3117 subdir('audio')
3118 subdir('io')
3119 subdir('chardev')
3120 subdir('fsdev')
3121 subdir('dump')
3122
3123 if have_block
3124   block_ss.add(files(
3125     'block.c',
3126     'blockjob.c',
3127     'job.c',
3128     'qemu-io-cmds.c',
3129   ))
3130   if config_host_data.get('CONFIG_REPLICATION')
3131     block_ss.add(files('replication.c'))
3132   endif
3133
3134   subdir('nbd')
3135   subdir('scsi')
3136   subdir('block')
3137
3138   blockdev_ss.add(files(
3139     'blockdev.c',
3140     'blockdev-nbd.c',
3141     'iothread.c',
3142     'job-qmp.c',
3143   ), gnutls)
3144
3145   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
3146   # os-win32.c does not
3147   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
3148   softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
3149 endif
3150
3151 common_ss.add(files('cpus-common.c'))
3152 specific_ss.add(files('cpu.c'))
3153
3154 subdir('softmmu')
3155
3156 # Work around a gcc bug/misfeature wherein constant propagation looks
3157 # through an alias:
3158 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
3159 # to guess that a const variable is always zero.  Without lto, this is
3160 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
3161 # without lto, not even the alias is required -- we simply use different
3162 # declarations in different compilation units.
3163 pagevary = files('page-vary-common.c')
3164 if get_option('b_lto')
3165   pagevary_flags = ['-fno-lto']
3166   if get_option('cfi')
3167     pagevary_flags += '-fno-sanitize=cfi-icall'
3168   endif
3169   pagevary = static_library('page-vary-common', sources: pagevary + genh,
3170                             c_args: pagevary_flags)
3171   pagevary = declare_dependency(link_with: pagevary)
3172 endif
3173 common_ss.add(pagevary)
3174 specific_ss.add(files('page-vary.c'))
3175
3176 subdir('backends')
3177 subdir('disas')
3178 subdir('migration')
3179 subdir('monitor')
3180 subdir('net')
3181 subdir('replay')
3182 subdir('semihosting')
3183 subdir('stats')
3184 subdir('tcg')
3185 subdir('fpu')
3186 subdir('accel')
3187 subdir('plugins')
3188 subdir('ebpf')
3189
3190 common_user_inc = []
3191
3192 subdir('common-user')
3193 subdir('bsd-user')
3194 subdir('linux-user')
3195
3196 # needed for fuzzing binaries
3197 subdir('tests/qtest/libqos')
3198 subdir('tests/qtest/fuzz')
3199
3200 # accel modules
3201 tcg_real_module_ss = ss.source_set()
3202 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
3203 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
3204 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
3205                                 'tcg': tcg_real_module_ss }}
3206
3207 ########################
3208 # Library dependencies #
3209 ########################
3210
3211 modinfo_collect = find_program('scripts/modinfo-collect.py')
3212 modinfo_generate = find_program('scripts/modinfo-generate.py')
3213 modinfo_files = []
3214
3215 block_mods = []
3216 softmmu_mods = []
3217 foreach d, list : modules
3218   if not (d == 'block' ? have_block : have_system)
3219     continue
3220   endif
3221
3222   foreach m, module_ss : list
3223     if enable_modules and targetos != 'windows'
3224       module_ss = module_ss.apply(config_all, strict: false)
3225       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
3226                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
3227       if d == 'block'
3228         block_mods += sl
3229       else
3230         softmmu_mods += sl
3231       endif
3232       if module_ss.sources() != []
3233         # FIXME: Should use sl.extract_all_objects(recursive: true) as
3234         # input. Sources can be used multiple times but objects are
3235         # unique when it comes to lookup in compile_commands.json.
3236         # Depnds on a mesion version with
3237         # https://github.com/mesonbuild/meson/pull/8900
3238         modinfo_files += custom_target(d + '-' + m + '.modinfo',
3239                                        output: d + '-' + m + '.modinfo',
3240                                        input: module_ss.sources() + genh,
3241                                        capture: true,
3242                                        command: [modinfo_collect, module_ss.sources()])
3243       endif
3244     else
3245       if d == 'block'
3246         block_ss.add_all(module_ss)
3247       else
3248         softmmu_ss.add_all(module_ss)
3249       endif
3250     endif
3251   endforeach
3252 endforeach
3253
3254 foreach d, list : target_modules
3255   foreach m, module_ss : list
3256     if enable_modules and targetos != 'windows'
3257       foreach target : target_dirs
3258         if target.endswith('-softmmu')
3259           config_target = config_target_mak[target]
3260           config_target += config_host
3261           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3262           c_args = ['-DNEED_CPU_H',
3263                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3264                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3265           target_module_ss = module_ss.apply(config_target, strict: false)
3266           if target_module_ss.sources() != []
3267             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
3268             sl = static_library(module_name,
3269                                 [genh, target_module_ss.sources()],
3270                                 dependencies: [modulecommon, target_module_ss.dependencies()],
3271                                 include_directories: target_inc,
3272                                 c_args: c_args,
3273                                 pic: true)
3274             softmmu_mods += sl
3275             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
3276             modinfo_files += custom_target(module_name + '.modinfo',
3277                                            output: module_name + '.modinfo',
3278                                            input: target_module_ss.sources() + genh,
3279                                            capture: true,
3280                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3281           endif
3282         endif
3283       endforeach
3284     else
3285       specific_ss.add_all(module_ss)
3286     endif
3287   endforeach
3288 endforeach
3289
3290 if enable_modules
3291   foreach target : target_dirs
3292     if target.endswith('-softmmu')
3293       config_target = config_target_mak[target]
3294       config_devices_mak = target + '-config-devices.mak'
3295       modinfo_src = custom_target('modinfo-' + target + '.c',
3296                                   output: 'modinfo-' + target + '.c',
3297                                   input: modinfo_files,
3298                                   command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
3299                                   capture: true)
3300
3301       modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
3302       modinfo_dep = declare_dependency(link_with: modinfo_lib)
3303
3304       arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
3305       hw_arch[arch].add(modinfo_dep)
3306     endif
3307   endforeach
3308 endif
3309
3310 nm = find_program('nm')
3311 undefsym = find_program('scripts/undefsym.py')
3312 block_syms = custom_target('block.syms', output: 'block.syms',
3313                              input: [libqemuutil, block_mods],
3314                              capture: true,
3315                              command: [undefsym, nm, '@INPUT@'])
3316 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3317                              input: [libqemuutil, softmmu_mods],
3318                              capture: true,
3319                              command: [undefsym, nm, '@INPUT@'])
3320
3321 authz_ss = authz_ss.apply(config_host, strict: false)
3322 libauthz = static_library('authz', authz_ss.sources() + genh,
3323                           dependencies: [authz_ss.dependencies()],
3324                           name_suffix: 'fa',
3325                           build_by_default: false)
3326
3327 authz = declare_dependency(link_whole: libauthz,
3328                            dependencies: qom)
3329
3330 crypto_ss = crypto_ss.apply(config_host, strict: false)
3331 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3332                            dependencies: [crypto_ss.dependencies()],
3333                            name_suffix: 'fa',
3334                            build_by_default: false)
3335
3336 crypto = declare_dependency(link_whole: libcrypto,
3337                             dependencies: [authz, qom])
3338
3339 io_ss = io_ss.apply(config_host, strict: false)
3340 libio = static_library('io', io_ss.sources() + genh,
3341                        dependencies: [io_ss.dependencies()],
3342                        link_with: libqemuutil,
3343                        name_suffix: 'fa',
3344                        build_by_default: false)
3345
3346 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3347
3348 libmigration = static_library('migration', sources: migration_files + genh,
3349                               name_suffix: 'fa',
3350                               build_by_default: false)
3351 migration = declare_dependency(link_with: libmigration,
3352                                dependencies: [zlib, qom, io])
3353 softmmu_ss.add(migration)
3354
3355 block_ss = block_ss.apply(config_host, strict: false)
3356 libblock = static_library('block', block_ss.sources() + genh,
3357                           dependencies: block_ss.dependencies(),
3358                           link_depends: block_syms,
3359                           name_suffix: 'fa',
3360                           build_by_default: false)
3361
3362 block = declare_dependency(link_whole: [libblock],
3363                            link_args: '@block.syms',
3364                            dependencies: [crypto, io])
3365
3366 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3367 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3368                              dependencies: blockdev_ss.dependencies(),
3369                              name_suffix: 'fa',
3370                              build_by_default: false)
3371
3372 blockdev = declare_dependency(link_whole: [libblockdev],
3373                               dependencies: [block, event_loop_base])
3374
3375 qmp_ss = qmp_ss.apply(config_host, strict: false)
3376 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3377                         dependencies: qmp_ss.dependencies(),
3378                         name_suffix: 'fa',
3379                         build_by_default: false)
3380
3381 qmp = declare_dependency(link_whole: [libqmp])
3382
3383 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3384                             name_suffix: 'fa',
3385                             dependencies: chardev_ss.dependencies(),
3386                             build_by_default: false)
3387
3388 chardev = declare_dependency(link_whole: libchardev)
3389
3390 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3391 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3392                            name_suffix: 'fa',
3393                            build_by_default: false)
3394 hwcore = declare_dependency(link_whole: libhwcore)
3395 common_ss.add(hwcore)
3396
3397 ###########
3398 # Targets #
3399 ###########
3400
3401 emulator_modules = []
3402 foreach m : block_mods + softmmu_mods
3403   emulator_modules += shared_module(m.name(),
3404                 build_by_default: true,
3405                 name_prefix: '',
3406                 link_whole: m,
3407                 install: true,
3408                 install_dir: qemu_moddir)
3409 endforeach
3410 if emulator_modules.length() > 0
3411   alias_target('modules', emulator_modules)
3412 endif
3413
3414 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3415 common_ss.add(qom, qemuutil)
3416
3417 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3418 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3419
3420 common_all = common_ss.apply(config_all, strict: false)
3421 common_all = static_library('common',
3422                             build_by_default: false,
3423                             sources: common_all.sources() + genh,
3424                             include_directories: common_user_inc,
3425                             implicit_include_directories: false,
3426                             dependencies: common_all.dependencies(),
3427                             name_suffix: 'fa')
3428
3429 feature_to_c = find_program('scripts/feature_to_c.sh')
3430
3431 if targetos == 'darwin'
3432   entitlement = find_program('scripts/entitlement.sh')
3433 endif
3434
3435 emulators = {}
3436 foreach target : target_dirs
3437   config_target = config_target_mak[target]
3438   target_name = config_target['TARGET_NAME']
3439   target_base_arch = config_target['TARGET_BASE_ARCH']
3440   arch_srcs = [config_target_h[target]]
3441   arch_deps = []
3442   c_args = ['-DNEED_CPU_H',
3443             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3444             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3445   link_args = emulator_link_args
3446
3447   config_target += config_host
3448   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3449   if targetos == 'linux'
3450     target_inc += include_directories('linux-headers', is_system: true)
3451   endif
3452   if target.endswith('-softmmu')
3453     target_type='system'
3454     t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3455     arch_srcs += t.sources()
3456     arch_deps += t.dependencies()
3457
3458     hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3459     hw = hw_arch[hw_dir].apply(config_target, strict: false)
3460     arch_srcs += hw.sources()
3461     arch_deps += hw.dependencies()
3462
3463     arch_srcs += config_devices_h[target]
3464     link_args += ['@block.syms', '@qemu.syms']
3465   else
3466     abi = config_target['TARGET_ABI_DIR']
3467     target_type='user'
3468     target_inc += common_user_inc
3469     if target_base_arch in target_user_arch
3470       t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3471       arch_srcs += t.sources()
3472       arch_deps += t.dependencies()
3473     endif
3474     if 'CONFIG_LINUX_USER' in config_target
3475       base_dir = 'linux-user'
3476     endif
3477     if 'CONFIG_BSD_USER' in config_target
3478       base_dir = 'bsd-user'
3479       target_inc += include_directories('bsd-user/' / targetos)
3480       target_inc += include_directories('bsd-user/host/' / host_arch)
3481       dir = base_dir / abi
3482       arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3483     endif
3484     target_inc += include_directories(
3485       base_dir,
3486       base_dir / abi,
3487     )
3488     if 'CONFIG_LINUX_USER' in config_target
3489       dir = base_dir / abi
3490       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3491       if config_target.has_key('TARGET_SYSTBL_ABI')
3492         arch_srcs += \
3493           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3494                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
3495       endif
3496     endif
3497   endif
3498
3499   if 'TARGET_XML_FILES' in config_target
3500     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3501                                 output: target + '-gdbstub-xml.c',
3502                                 input: files(config_target['TARGET_XML_FILES'].split()),
3503                                 command: [feature_to_c, '@INPUT@'],
3504                                 capture: true)
3505     arch_srcs += gdbstub_xml
3506   endif
3507
3508   t = target_arch[target_base_arch].apply(config_target, strict: false)
3509   arch_srcs += t.sources()
3510   arch_deps += t.dependencies()
3511
3512   target_common = common_ss.apply(config_target, strict: false)
3513   objects = common_all.extract_objects(target_common.sources())
3514   deps = target_common.dependencies()
3515
3516   target_specific = specific_ss.apply(config_target, strict: false)
3517   arch_srcs += target_specific.sources()
3518   arch_deps += target_specific.dependencies()
3519
3520   lib = static_library('qemu-' + target,
3521                  sources: arch_srcs + genh,
3522                  dependencies: arch_deps,
3523                  objects: objects,
3524                  include_directories: target_inc,
3525                  c_args: c_args,
3526                  build_by_default: false,
3527                  name_suffix: 'fa')
3528
3529   if target.endswith('-softmmu')
3530     execs = [{
3531       'name': 'qemu-system-' + target_name,
3532       'win_subsystem': 'console',
3533       'sources': files('softmmu/main.c'),
3534       'dependencies': []
3535     }]
3536     if targetos == 'windows' and (sdl.found() or gtk.found())
3537       execs += [{
3538         'name': 'qemu-system-' + target_name + 'w',
3539         'win_subsystem': 'windows',
3540         'sources': files('softmmu/main.c'),
3541         'dependencies': []
3542       }]
3543     endif
3544     if get_option('fuzzing')
3545       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3546       execs += [{
3547         'name': 'qemu-fuzz-' + target_name,
3548         'win_subsystem': 'console',
3549         'sources': specific_fuzz.sources(),
3550         'dependencies': specific_fuzz.dependencies(),
3551       }]
3552     endif
3553   else
3554     execs = [{
3555       'name': 'qemu-' + target_name,
3556       'win_subsystem': 'console',
3557       'sources': [],
3558       'dependencies': []
3559     }]
3560   endif
3561   foreach exe: execs
3562     exe_name = exe['name']
3563     if targetos == 'darwin'
3564       exe_name += '-unsigned'
3565     endif
3566
3567     emulator = executable(exe_name, exe['sources'],
3568                install: true,
3569                c_args: c_args,
3570                dependencies: arch_deps + deps + exe['dependencies'],
3571                objects: lib.extract_all_objects(recursive: true),
3572                link_language: link_language,
3573                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3574                link_args: link_args,
3575                win_subsystem: exe['win_subsystem'])
3576
3577     if targetos == 'darwin'
3578       icon = 'pc-bios/qemu.rsrc'
3579       build_input = [emulator, files(icon)]
3580       install_input = [
3581         get_option('bindir') / exe_name,
3582         meson.current_source_dir() / icon
3583       ]
3584       if 'CONFIG_HVF' in config_target
3585         entitlements = 'accel/hvf/entitlements.plist'
3586         build_input += files(entitlements)
3587         install_input += meson.current_source_dir() / entitlements
3588       endif
3589
3590       emulators += {exe['name'] : custom_target(exe['name'],
3591                    input: build_input,
3592                    output: exe['name'],
3593                    command: [entitlement, '@OUTPUT@', '@INPUT@'])
3594       }
3595
3596       meson.add_install_script(entitlement, '--install',
3597                                get_option('bindir') / exe['name'],
3598                                install_input)
3599     else
3600       emulators += {exe['name']: emulator}
3601     endif
3602
3603     if stap.found()
3604       foreach stp: [
3605         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3606         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3607         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3608         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3609       ]
3610         custom_target(exe['name'] + stp['ext'],
3611                       input: trace_events_all,
3612                       output: exe['name'] + stp['ext'],
3613                       install: stp['install'],
3614                       install_dir: get_option('datadir') / 'systemtap/tapset',
3615                       command: [
3616                         tracetool, '--group=all', '--format=' + stp['fmt'],
3617                         '--binary=' + stp['bin'],
3618                         '--target-name=' + target_name,
3619                         '--target-type=' + target_type,
3620                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
3621                         '@INPUT@', '@OUTPUT@'
3622                       ],
3623                       depend_files: tracetool_depends)
3624       endforeach
3625     endif
3626   endforeach
3627 endforeach
3628
3629 # Other build targets
3630
3631 if 'CONFIG_PLUGIN' in config_host
3632   install_headers('include/qemu/qemu-plugin.h')
3633 endif
3634
3635 subdir('qga')
3636
3637 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3638 # when we don't build tools or system
3639 if xkbcommon.found()
3640   # used for the update-keymaps target, so include rules even if !have_tools
3641   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3642                            dependencies: [qemuutil, xkbcommon], install: have_tools)
3643 endif
3644
3645 if have_tools
3646   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3647              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3648   qemu_io = executable('qemu-io', files('qemu-io.c'),
3649              dependencies: [block, qemuutil], install: true)
3650   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3651                dependencies: [blockdev, qemuutil, gnutls, selinux],
3652                install: true)
3653
3654   subdir('storage-daemon')
3655   subdir('contrib/rdmacm-mux')
3656   subdir('contrib/elf2dmp')
3657
3658   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3659              dependencies: qemuutil,
3660              install: true)
3661
3662   if have_vhost_user
3663     subdir('contrib/vhost-user-blk')
3664     subdir('contrib/vhost-user-gpu')
3665     subdir('contrib/vhost-user-input')
3666     subdir('contrib/vhost-user-scsi')
3667   endif
3668
3669   if targetos == 'linux'
3670     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3671                dependencies: [qemuutil, libcap_ng],
3672                install: true,
3673                install_dir: get_option('libexecdir'))
3674
3675     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3676                dependencies: [authz, crypto, io, qom, qemuutil,
3677                               libcap_ng, mpathpersist],
3678                install: true)
3679   endif
3680
3681   if have_ivshmem
3682     subdir('contrib/ivshmem-client')
3683     subdir('contrib/ivshmem-server')
3684   endif
3685 endif
3686
3687 subdir('scripts')
3688 subdir('tools')
3689 subdir('pc-bios')
3690 subdir('docs')
3691 subdir('tests')
3692 if gtk.found()
3693   subdir('po')
3694 endif
3695
3696 if host_machine.system() == 'windows'
3697   nsis_cmd = [
3698     find_program('scripts/nsis.py'),
3699     '@OUTPUT@',
3700     get_option('prefix'),
3701     meson.current_source_dir(),
3702     config_host['GLIB_BINDIR'],
3703     host_machine.cpu(),
3704     '--',
3705     '-DDISPLAYVERSION=' + meson.project_version(),
3706   ]
3707   if build_docs
3708     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3709   endif
3710   if gtk.found()
3711     nsis_cmd += '-DCONFIG_GTK=y'
3712   endif
3713
3714   nsis = custom_target('nsis',
3715                        output: 'qemu-setup-' + meson.project_version() + '.exe',
3716                        input: files('qemu.nsi'),
3717                        build_always_stale: true,
3718                        command: nsis_cmd + ['@INPUT@'])
3719   alias_target('installer', nsis)
3720 endif
3721
3722 #########################
3723 # Configuration summary #
3724 #########################
3725
3726 # Directories
3727 summary_info = {}
3728 summary_info += {'Install prefix':    get_option('prefix')}
3729 summary_info += {'BIOS directory':    qemu_datadir}
3730 pathsep = targetos == 'windows' ? ';' : ':'
3731 summary_info += {'firmware path':     pathsep.join(get_option('qemu_firmwarepath'))}
3732 summary_info += {'binary directory':  get_option('prefix') / get_option('bindir')}
3733 summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
3734 summary_info += {'module directory':  qemu_moddir}
3735 summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
3736 summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
3737 summary_info += {'config directory':  get_option('prefix') / get_option('sysconfdir')}
3738 if targetos != 'windows'
3739   summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
3740   summary_info += {'Manual directory':      get_option('prefix') / get_option('mandir')}
3741 else
3742   summary_info += {'local state directory': 'queried at runtime'}
3743 endif
3744 summary_info += {'Doc directory':     get_option('prefix') / get_option('docdir')}
3745 summary_info += {'Build directory':   meson.current_build_dir()}
3746 summary_info += {'Source path':       meson.current_source_dir()}
3747 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
3748 summary(summary_info, bool_yn: true, section: 'Directories')
3749
3750 # Host binaries
3751 summary_info = {}
3752 summary_info += {'git':               config_host['GIT']}
3753 summary_info += {'make':              config_host['MAKE']}
3754 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3755 summary_info += {'sphinx-build':      sphinx_build}
3756 if config_host.has_key('HAVE_GDB_BIN')
3757   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
3758 endif
3759 summary_info += {'iasl':              iasl}
3760 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
3761 if targetos == 'windows' and have_ga
3762   summary_info += {'wixl':            wixl}
3763 endif
3764 if slirp.found() and have_system
3765   summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
3766 endif
3767 summary(summary_info, bool_yn: true, section: 'Host binaries')
3768
3769 # Configurable features
3770 summary_info = {}
3771 summary_info += {'Documentation':     build_docs}
3772 summary_info += {'system-mode emulation': have_system}
3773 summary_info += {'user-mode emulation': have_user}
3774 summary_info += {'block layer':       have_block}
3775 summary_info += {'Install blobs':     get_option('install_blobs')}
3776 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
3777 if config_host.has_key('CONFIG_MODULES')
3778   summary_info += {'alternative module path': get_option('module_upgrades')}
3779 endif
3780 summary_info += {'fuzzing support':   get_option('fuzzing')}
3781 if have_system
3782   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
3783 endif
3784 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
3785 if 'simple' in get_option('trace_backends')
3786   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3787 endif
3788 summary_info += {'D-Bus display':     dbus_display}
3789 summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
3790 summary_info += {'vhost-kernel support': have_vhost_kernel}
3791 summary_info += {'vhost-net support': have_vhost_net}
3792 summary_info += {'vhost-user support': have_vhost_user}
3793 summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
3794 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3795 summary_info += {'vhost-vdpa support': have_vhost_vdpa}
3796 summary_info += {'build guest agent': have_ga}
3797 summary(summary_info, bool_yn: true, section: 'Configurable features')
3798
3799 # Compilation information
3800 summary_info = {}
3801 summary_info += {'host CPU':          cpu}
3802 summary_info += {'host endianness':   build_machine.endian()}
3803 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
3804 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3805 if link_language == 'cpp'
3806   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
3807 else
3808   summary_info += {'C++ compiler':      false}
3809 endif
3810 if targetos == 'darwin'
3811   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3812 endif
3813 option_cflags = (get_option('debug') ? ['-g'] : [])
3814 if get_option('optimization') != 'plain'
3815   option_cflags += ['-O' + get_option('optimization')]
3816 endif
3817 summary_info += {'CFLAGS':            ' '.join(get_option('c_args') + option_cflags)}
3818 if link_language == 'cpp'
3819   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args') + option_cflags)}
3820 endif
3821 if targetos == 'darwin'
3822   summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args') + option_cflags)}
3823 endif
3824 link_args = get_option(link_language + '_link_args')
3825 if link_args.length() > 0
3826   summary_info += {'LDFLAGS':         ' '.join(link_args)}
3827 endif
3828 summary_info += {'QEMU_CFLAGS':       ' '.join(qemu_cflags)}
3829 if 'cpp' in all_languages
3830   summary_info += {'QEMU_CXXFLAGS':     ' '.join(qemu_cxxflags)}
3831 endif
3832 if 'objc' in all_languages
3833   summary_info += {'QEMU_OBJCFLAGS':    ' '.join(qemu_objcflags)}
3834 endif
3835 summary_info += {'QEMU_LDFLAGS':      ' '.join(qemu_ldflags)}
3836 summary_info += {'profiler':          get_option('profiler')}
3837 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3838 summary_info += {'PIE':               get_option('b_pie')}
3839 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
3840 summary_info += {'malloc trim support': has_malloc_trim}
3841 summary_info += {'membarrier':        have_membarrier}
3842 summary_info += {'debug graph lock':  get_option('debug_graph_lock')}
3843 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
3844 summary_info += {'mutex debugging':   get_option('debug_mutex')}
3845 summary_info += {'memory allocator':  get_option('malloc')}
3846 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
3847 summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')}
3848 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
3849 if get_option('gprof')
3850   gprof_info = 'YES (deprecated)'
3851 else
3852   gprof_info = get_option('gprof')
3853 endif
3854 summary_info += {'gprof':             gprof_info}
3855 summary_info += {'gcov':              get_option('b_coverage')}
3856 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
3857 summary_info += {'CFI support':       get_option('cfi')}
3858 if get_option('cfi')
3859   summary_info += {'CFI debug support': get_option('cfi_debug')}
3860 endif
3861 summary_info += {'strip binaries':    get_option('strip')}
3862 summary_info += {'sparse':            sparse}
3863 summary_info += {'mingw32 support':   targetos == 'windows'}
3864 summary(summary_info, bool_yn: true, section: 'Compilation')
3865
3866 # snarf the cross-compilation information for tests
3867 summary_info = {}
3868 have_cross = false
3869 foreach target: target_dirs
3870   tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak'
3871   if fs.exists(tcg_mak)
3872     config_cross_tcg = keyval.load(tcg_mak)
3873     if 'CC' in config_cross_tcg
3874       summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
3875       have_cross = true
3876     endif
3877   endif
3878 endforeach
3879 if have_cross
3880   summary(summary_info, bool_yn: true, section: 'Cross compilers')
3881 endif
3882
3883 # Targets and accelerators
3884 summary_info = {}
3885 if have_system
3886   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
3887   summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
3888   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
3889   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
3890   summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
3891   summary_info += {'Xen support':       xen.found()}
3892   if xen.found()
3893     summary_info += {'xen ctrl version':  xen.version()}
3894   endif
3895   summary_info += {'Xen emulation':     config_all.has_key('CONFIG_XEN_EMU')}
3896 endif
3897 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
3898 if config_all.has_key('CONFIG_TCG')
3899   if get_option('tcg_interpreter')
3900     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
3901   else
3902     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
3903   endif
3904   summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3905   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3906 endif
3907 summary_info += {'target list':       ' '.join(target_dirs)}
3908 if have_system
3909   summary_info += {'default devices':   get_option('default_devices')}
3910   summary_info += {'out of process emulation': multiprocess_allowed}
3911   summary_info += {'vfio-user server': vfio_user_server_allowed}
3912 endif
3913 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3914
3915 # Block layer
3916 summary_info = {}
3917 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3918 summary_info += {'coroutine pool':    have_coroutine_pool}
3919 if have_block
3920   summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
3921   summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
3922   summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
3923   summary_info += {'VirtFS support':    have_virtfs}
3924   summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
3925   summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
3926   summary_info += {'bochs support':     get_option('bochs').allowed()}
3927   summary_info += {'cloop support':     get_option('cloop').allowed()}
3928   summary_info += {'dmg support':       get_option('dmg').allowed()}
3929   summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
3930   summary_info += {'vdi support':       get_option('vdi').allowed()}
3931   summary_info += {'vhdx support':      get_option('vhdx').allowed()}
3932   summary_info += {'vmdk support':      get_option('vmdk').allowed()}
3933   summary_info += {'vpc support':       get_option('vpc').allowed()}
3934   summary_info += {'vvfat support':     get_option('vvfat').allowed()}
3935   summary_info += {'qed support':       get_option('qed').allowed()}
3936   summary_info += {'parallels support': get_option('parallels').allowed()}
3937   summary_info += {'FUSE exports':      fuse}
3938   summary_info += {'VDUSE block exports': have_vduse_blk_export}
3939 endif
3940 summary(summary_info, bool_yn: true, section: 'Block layer support')
3941
3942 # Crypto
3943 summary_info = {}
3944 summary_info += {'TLS priority':      get_option('tls_priority')}
3945 summary_info += {'GNUTLS support':    gnutls}
3946 if gnutls.found()
3947   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
3948 endif
3949 summary_info += {'libgcrypt':         gcrypt}
3950 summary_info += {'nettle':            nettle}
3951 if nettle.found()
3952    summary_info += {'  XTS':             xts != 'private'}
3953 endif
3954 summary_info += {'AF_ALG support':    have_afalg}
3955 summary_info += {'rng-none':          get_option('rng_none')}
3956 summary_info += {'Linux keyring':     have_keyring}
3957 summary(summary_info, bool_yn: true, section: 'Crypto')
3958
3959 # Libraries
3960 summary_info = {}
3961 if targetos == 'darwin'
3962   summary_info += {'Cocoa support':           cocoa}
3963   summary_info += {'vmnet.framework support': vmnet}
3964 endif
3965 summary_info += {'SDL support':       sdl}
3966 summary_info += {'SDL image support': sdl_image}
3967 summary_info += {'GTK support':       gtk}
3968 summary_info += {'pixman':            pixman}
3969 summary_info += {'VTE support':       vte}
3970 summary_info += {'slirp support':     slirp}
3971 summary_info += {'libtasn1':          tasn1}
3972 summary_info += {'PAM':               pam}
3973 summary_info += {'iconv support':     iconv}
3974 summary_info += {'curses support':    curses}
3975 summary_info += {'virgl support':     virgl}
3976 summary_info += {'blkio support':     blkio}
3977 summary_info += {'curl support':      curl}
3978 summary_info += {'Multipath support': mpathpersist}
3979 summary_info += {'PNG support':       png}
3980 summary_info += {'VNC support':       vnc}
3981 if vnc.found()
3982   summary_info += {'VNC SASL support':  sasl}
3983   summary_info += {'VNC JPEG support':  jpeg}
3984 endif
3985 if targetos not in ['darwin', 'haiku', 'windows']
3986   summary_info += {'OSS support':     oss}
3987   summary_info += {'sndio support':   sndio}
3988 elif targetos == 'darwin'
3989   summary_info += {'CoreAudio support': coreaudio}
3990 elif targetos == 'windows'
3991   summary_info += {'DirectSound support': dsound}
3992 endif
3993 if targetos == 'linux'
3994   summary_info += {'ALSA support':    alsa}
3995   summary_info += {'PulseAudio support': pulse}
3996 endif
3997 summary_info += {'Pipewire support':   pipewire}
3998 summary_info += {'JACK support':      jack}
3999 summary_info += {'brlapi support':    brlapi}
4000 summary_info += {'vde support':       vde}
4001 summary_info += {'netmap support':    have_netmap}
4002 summary_info += {'l2tpv3 support':    have_l2tpv3}
4003 summary_info += {'Linux AIO support': libaio}
4004 summary_info += {'Linux io_uring support': linux_io_uring}
4005 summary_info += {'ATTR/XATTR support': libattr}
4006 summary_info += {'RDMA support':      rdma}
4007 summary_info += {'PVRDMA support':    have_pvrdma}
4008 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
4009 summary_info += {'libcap-ng support': libcap_ng}
4010 summary_info += {'bpf support':       libbpf}
4011 summary_info += {'spice protocol support': spice_protocol}
4012 if spice_protocol.found()
4013   summary_info += {'  spice server support': spice}
4014 endif
4015 summary_info += {'rbd support':       rbd}
4016 summary_info += {'smartcard support': cacard}
4017 summary_info += {'U2F support':       u2f}
4018 summary_info += {'libusb':            libusb}
4019 summary_info += {'usb net redir':     usbredir}
4020 summary_info += {'OpenGL support (epoxy)': opengl}
4021 summary_info += {'GBM':               gbm}
4022 summary_info += {'libiscsi support':  libiscsi}
4023 summary_info += {'libnfs support':    libnfs}
4024 if targetos == 'windows'
4025   if have_ga
4026     summary_info += {'QGA VSS support':   have_qga_vss}
4027   endif
4028 endif
4029 summary_info += {'seccomp support':   seccomp}
4030 summary_info += {'GlusterFS support': glusterfs}
4031 summary_info += {'TPM support':       have_tpm}
4032 summary_info += {'libssh support':    libssh}
4033 summary_info += {'lzo support':       lzo}
4034 summary_info += {'snappy support':    snappy}
4035 summary_info += {'bzip2 support':     libbzip2}
4036 summary_info += {'lzfse support':     liblzfse}
4037 summary_info += {'zstd support':      zstd}
4038 summary_info += {'NUMA host support': numa}
4039 summary_info += {'capstone':          capstone}
4040 summary_info += {'libpmem support':   libpmem}
4041 summary_info += {'libdaxctl support': libdaxctl}
4042 summary_info += {'libudev':           libudev}
4043 # Dummy dependency, keep .found()
4044 summary_info += {'FUSE lseek':        fuse_lseek.found()}
4045 summary_info += {'selinux':           selinux}
4046 summary_info += {'libdw':             libdw}
4047 summary(summary_info, bool_yn: true, section: 'Dependencies')
4048
4049 if not supported_cpus.contains(cpu)
4050   message()
4051   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
4052   message()
4053   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
4054   message('The QEMU project intends to remove support for this host CPU in')
4055   message('a future release if nobody volunteers to maintain it and to')
4056   message('provide a build host for our continuous integration setup.')
4057   message('configure has succeeded and you can continue to build, but')
4058   message('if you care about QEMU on this platform you should contact')
4059   message('us upstream at qemu-devel@nongnu.org.')
4060 endif
4061
4062 if not supported_oses.contains(targetos)
4063   message()
4064   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
4065   message()
4066   message('Host OS ' + targetos + 'support is not currently maintained.')
4067   message('The QEMU project intends to remove support for this host OS in')
4068   message('a future release if nobody volunteers to maintain it and to')
4069   message('provide a build host for our continuous integration setup.')
4070   message('configure has succeeded and you can continue to build, but')
4071   message('if you care about QEMU on this platform you should contact')
4072   message('us upstream at qemu-devel@nongnu.org.')
4073 endif