meson.build

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