meson.build

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