meson.build

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