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