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