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     add_global_arguments('-fsanitize-coverage-allowlist=instrumentation-filter',
 217                          native: false, language: ['c', 'cpp', 'objc'])
 218   endif
 219
 220   if get_option('fuzzing_engine') == ''
 221     # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
 222     # compiled code.  To build non-fuzzer binaries with --enable-fuzzing, link
 223     # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
 224     # unable to bind the fuzzer-related callbacks added by instrumentation.
 225     add_global_arguments('-fsanitize=fuzzer-no-link',
 226                          native: false, language: ['c', 'cpp', 'objc'])
 227     add_global_link_arguments('-fsanitize=fuzzer-no-link',
 228                               native: false, language: ['c', 'cpp', 'objc'])
 229     # For the actual fuzzer binaries, we need to link against the libfuzzer
 230     # library. They need to be configurable, to support OSS-Fuzz
 231     fuzz_exe_ldflags = ['-fsanitize=fuzzer']
 232   else
 233     # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
 234     # the needed CFLAGS have already been provided
 235     fuzz_exe_ldflags = get_option('fuzzing_engine').split()
 236   endif
 237 endif
 238
 239 add_global_arguments(qemu_cflags, native: false, language: ['c'])
 240 add_global_arguments(qemu_cxxflags, native: false, language: ['cpp'])
 241 add_global_arguments(qemu_objcflags, native: false, language: ['objc'])
 242 add_global_link_arguments(qemu_ldflags, native: false, language: ['c', 'cpp', 'objc'])
 243
 244 if targetos == 'linux'
 245   add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
 246                         '-isystem', 'linux-headers',
 247                         language: ['c', 'cpp'])
 248 endif
 249
 250 add_project_arguments('-iquote', '.',
 251                       '-iquote', meson.current_source_dir(),
 252                       '-iquote', meson.current_source_dir() / 'include',
 253                       '-iquote', meson.current_source_dir() / 'disas/libvixl',
 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', 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   'arm' : ['CONFIG_ARM_DIS'],
2376   'avr' : ['CONFIG_AVR_DIS'],
2377   'cris' : ['CONFIG_CRIS_DIS'],
2378   'hexagon' : ['CONFIG_HEXAGON_DIS'],
2379   'hppa' : ['CONFIG_HPPA_DIS'],
2380   'i386' : ['CONFIG_I386_DIS'],
2381   'x86_64' : ['CONFIG_I386_DIS'],
2382   'm68k' : ['CONFIG_M68K_DIS'],
2383   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2384   'mips' : ['CONFIG_MIPS_DIS'],
2385   'nios2' : ['CONFIG_NIOS2_DIS'],
2386   'or1k' : ['CONFIG_OPENRISC_DIS'],
2387   'ppc' : ['CONFIG_PPC_DIS'],
2388   'riscv' : ['CONFIG_RISCV_DIS'],
2389   'rx' : ['CONFIG_RX_DIS'],
2390   's390' : ['CONFIG_S390_DIS'],
2391   'sh4' : ['CONFIG_SH4_DIS'],
2392   'sparc' : ['CONFIG_SPARC_DIS'],
2393   'xtensa' : ['CONFIG_XTENSA_DIS'],
2394   'loongarch' : ['CONFIG_LOONGARCH_DIS'],
2395 }
2396 if link_language == 'cpp'
2397   disassemblers += {
2398     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
2399     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
2400     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
2401   }
2402 endif
2403
2404 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2405 host_kconfig = \
2406   (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2407   (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2408   (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2409   (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2410   (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \
2411   (x11.found() ? ['CONFIG_X11=y'] : []) + \
2412   (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \
2413   (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2414   (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2415   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2416   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2417   (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
2418   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
2419   (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : [])
2420
2421 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2422
2423 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2424 actual_target_dirs = []
2425 fdt_required = []
2426 foreach target : target_dirs
2427   config_target = { 'TARGET_NAME': target.split('-')[0] }
2428   if target.endswith('linux-user')
2429     if targetos != 'linux'
2430       if default_targets
2431         continue
2432       endif
2433       error('Target @0@ is only available on a Linux host'.format(target))
2434     endif
2435     config_target += { 'CONFIG_LINUX_USER': 'y' }
2436   elif target.endswith('bsd-user')
2437     if 'CONFIG_BSD' not in config_host
2438       if default_targets
2439         continue
2440       endif
2441       error('Target @0@ is only available on a BSD host'.format(target))
2442     endif
2443     config_target += { 'CONFIG_BSD_USER': 'y' }
2444   elif target.endswith('softmmu')
2445     config_target += { 'CONFIG_SOFTMMU': 'y' }
2446   endif
2447   if target.endswith('-user')
2448     config_target += {
2449       'CONFIG_USER_ONLY': 'y',
2450       'CONFIG_QEMU_INTERP_PREFIX':
2451         get_option('interp_prefix').replace('%M', config_target['TARGET_NAME'])
2452     }
2453   endif
2454
2455   accel_kconfig = []
2456   foreach sym: accelerators
2457     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2458       config_target += { sym: 'y' }
2459       config_all += { sym: 'y' }
2460       if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
2461         config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
2462       endif
2463       if target in modular_tcg
2464         config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2465       else
2466         config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2467       endif
2468       accel_kconfig += [ sym + '=y' ]
2469     endif
2470   endforeach
2471   if accel_kconfig.length() == 0
2472     if default_targets
2473       continue
2474     endif
2475     error('No accelerator available for target @0@'.format(target))
2476   endif
2477
2478   actual_target_dirs += target
2479   config_target += keyval.load('configs/targets' / target + '.mak')
2480   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2481
2482   if 'TARGET_NEED_FDT' in config_target
2483     fdt_required += target
2484   endif
2485
2486   # Add default keys
2487   if 'TARGET_BASE_ARCH' not in config_target
2488     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2489   endif
2490   if 'TARGET_ABI_DIR' not in config_target
2491     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2492   endif
2493   if 'TARGET_BIG_ENDIAN' not in config_target
2494     config_target += {'TARGET_BIG_ENDIAN': 'n'}
2495   endif
2496
2497   foreach k, v: disassemblers
2498     if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2499       foreach sym: v
2500         config_target += { sym: 'y' }
2501         config_all_disas += { sym: 'y' }
2502       endforeach
2503     endif
2504   endforeach
2505
2506   config_target_data = configuration_data()
2507   foreach k, v: config_target
2508     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2509       # do nothing
2510     elif ignored.contains(k)
2511       # do nothing
2512     elif k == 'TARGET_BASE_ARCH'
2513       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2514       # not used to select files from sourcesets.
2515       config_target_data.set('TARGET_' + v.to_upper(), 1)
2516     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2517       config_target_data.set_quoted(k, v)
2518     elif v == 'y'
2519       config_target_data.set(k, 1)
2520     elif v == 'n'
2521       config_target_data.set(k, 0)
2522     else
2523       config_target_data.set(k, v)
2524     endif
2525   endforeach
2526   config_target_data.set('QEMU_ARCH',
2527                          'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2528   config_target_h += {target: configure_file(output: target + '-config-target.h',
2529                                                configuration: config_target_data)}
2530
2531   if target.endswith('-softmmu')
2532     config_input = meson.get_external_property(target, 'default')
2533     config_devices_mak = target + '-config-devices.mak'
2534     config_devices_mak = configure_file(
2535       input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2536       output: config_devices_mak,
2537       depfile: config_devices_mak + '.d',
2538       capture: true,
2539       command: [minikconf,
2540                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2541                 config_devices_mak, '@DEPFILE@', '@INPUT@',
2542                 host_kconfig, accel_kconfig,
2543                 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2544
2545     config_devices_data = configuration_data()
2546     config_devices = keyval.load(config_devices_mak)
2547     foreach k, v: config_devices
2548       config_devices_data.set(k, 1)
2549     endforeach
2550     config_devices_mak_list += config_devices_mak
2551     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2552                                                 configuration: config_devices_data)}
2553     config_target += config_devices
2554     config_all_devices += config_devices
2555   endif
2556   config_target_mak += {target: config_target}
2557 endforeach
2558 target_dirs = actual_target_dirs
2559
2560 # This configuration is used to build files that are shared by
2561 # multiple binaries, and then extracted out of the "common"
2562 # static_library target.
2563 #
2564 # We do not use all_sources()/all_dependencies(), because it would
2565 # build literally all source files, including devices only used by
2566 # targets that are not built for this compilation.  The CONFIG_ALL
2567 # pseudo symbol replaces it.
2568
2569 config_all += config_all_devices
2570 config_all += config_host
2571 config_all += config_all_disas
2572 config_all += {
2573   'CONFIG_XEN': xen.found(),
2574   'CONFIG_SOFTMMU': have_system,
2575   'CONFIG_USER_ONLY': have_user,
2576   'CONFIG_ALL': true,
2577 }
2578
2579 target_configs_h = []
2580 foreach target: target_dirs
2581   target_configs_h += config_target_h[target]
2582   target_configs_h += config_devices_h.get(target, [])
2583 endforeach
2584 genh += custom_target('config-poison.h',
2585                       input: [target_configs_h],
2586                       output: 'config-poison.h',
2587                       capture: true,
2588                       command: [find_program('scripts/make-config-poison.sh'),
2589                                 target_configs_h])
2590
2591 ##############
2592 # Submodules #
2593 ##############
2594
2595 capstone = not_found
2596 if not get_option('capstone').auto() or have_system or have_user
2597   capstone = dependency('capstone', version: '>=3.0.5',
2598                         kwargs: static_kwargs, method: 'pkg-config',
2599                         required: get_option('capstone'))
2600
2601   # Some versions of capstone have broken pkg-config file
2602   # that reports a wrong -I path, causing the #include to
2603   # fail later. If the system has such a broken version
2604   # do not use it.
2605   if capstone.found() and not cc.compiles('#include <capstone.h>',
2606                                           dependencies: [capstone])
2607     capstone = not_found
2608     if get_option('capstone').enabled()
2609       error('capstone requested, but it does not appear to work')
2610     endif
2611   endif
2612 endif
2613
2614 slirp = not_found
2615 slirp_opt = 'disabled'
2616 if have_system
2617   slirp_opt = get_option('slirp')
2618   if slirp_opt in ['enabled', 'auto', 'system']
2619     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2620     slirp_dep_required = (slirp_opt == 'system' or
2621                           slirp_opt == 'enabled' and not have_internal)
2622     slirp = dependency('slirp', kwargs: static_kwargs,
2623                        method: 'pkg-config', version: '>=4.1.0',
2624                        required: slirp_dep_required)
2625     # slirp <4.7 is incompatible with CFI support in QEMU.  This is because
2626     # it passes function pointers within libslirp as callbacks for timers.
2627     # When using a system-wide shared libslirp, the type information for the
2628     # callback is missing and the timer call produces a false positive with CFI.
2629     # Do not use the "version" keyword argument to produce a better error.
2630     # with control-flow integrity.
2631     if get_option('cfi') and slirp.found() and slirp.version().version_compare('<4.7')
2632       if slirp_dep_required
2633         error('Control-Flow Integrity requires libslirp 4.7.')
2634       else
2635         warning('Control-Flow Integrity requires libslirp 4.7, not using system-wide libslirp.')
2636         slirp = not_found
2637       endif
2638     endif
2639     if slirp.found()
2640       slirp_opt = 'system'
2641     elif have_internal
2642       slirp_opt = 'internal'
2643     else
2644       slirp_opt = 'disabled'
2645     endif
2646   endif
2647   if slirp_opt == 'internal'
2648     slirp_deps = []
2649     if targetos == 'windows'
2650       slirp_deps = cc.find_library('iphlpapi')
2651     elif targetos == 'darwin'
2652       slirp_deps = cc.find_library('resolv')
2653     endif
2654     slirp_conf = configuration_data()
2655     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2656     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2657     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2658     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2659     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2660     slirp_files = [
2661       'slirp/src/arp_table.c',
2662       'slirp/src/bootp.c',
2663       'slirp/src/cksum.c',
2664       'slirp/src/dhcpv6.c',
2665       'slirp/src/dnssearch.c',
2666       'slirp/src/if.c',
2667       'slirp/src/ip6_icmp.c',
2668       'slirp/src/ip6_input.c',
2669       'slirp/src/ip6_output.c',
2670       'slirp/src/ip_icmp.c',
2671       'slirp/src/ip_input.c',
2672       'slirp/src/ip_output.c',
2673       'slirp/src/mbuf.c',
2674       'slirp/src/misc.c',
2675       'slirp/src/ncsi.c',
2676       'slirp/src/ndp_table.c',
2677       'slirp/src/sbuf.c',
2678       'slirp/src/slirp.c',
2679       'slirp/src/socket.c',
2680       'slirp/src/state.c',
2681       'slirp/src/stream.c',
2682       'slirp/src/tcp_input.c',
2683       'slirp/src/tcp_output.c',
2684       'slirp/src/tcp_subr.c',
2685       'slirp/src/tcp_timer.c',
2686       'slirp/src/tftp.c',
2687       'slirp/src/udp.c',
2688       'slirp/src/udp6.c',
2689       'slirp/src/util.c',
2690       'slirp/src/version.c',
2691       'slirp/src/vmstate.c',
2692     ]
2693
2694     configure_file(
2695       input : 'slirp/src/libslirp-version.h.in',
2696       output : 'libslirp-version.h',
2697       configuration: slirp_conf)
2698
2699     slirp_inc = include_directories('slirp', 'slirp/src')
2700     libslirp = static_library('slirp',
2701                               build_by_default: false,
2702                               sources: slirp_files,
2703                               c_args: slirp_cargs,
2704                               include_directories: slirp_inc)
2705     slirp = declare_dependency(link_with: libslirp,
2706                                dependencies: slirp_deps,
2707                                include_directories: slirp_inc)
2708   endif
2709 endif
2710
2711 libvfio_user_dep = not_found
2712 if have_system and vfio_user_server_allowed
2713   have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build')
2714
2715   if not have_internal
2716     error('libvfio-user source not found - please pull git submodule')
2717   endif
2718
2719   libvfio_user_proj = subproject('libvfio-user')
2720
2721   libvfio_user_lib = libvfio_user_proj.get_variable('libvfio_user_dep')
2722
2723   libvfio_user_dep = declare_dependency(dependencies: [libvfio_user_lib])
2724 endif
2725
2726 fdt = not_found
2727 if have_system
2728   fdt_opt = get_option('fdt')
2729   if fdt_opt in ['enabled', 'auto', 'system']
2730     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2731     fdt = cc.find_library('fdt', kwargs: static_kwargs,
2732                           required: fdt_opt == 'system' or
2733                                     fdt_opt == 'enabled' and not have_internal)
2734     if fdt.found() and cc.links('''
2735        #include <libfdt.h>
2736        #include <libfdt_env.h>
2737        int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2738          dependencies: fdt)
2739       fdt_opt = 'system'
2740     elif fdt_opt == 'system'
2741        error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2742     elif have_internal
2743       fdt_opt = 'internal'
2744     else
2745       fdt_opt = 'disabled'
2746       fdt = not_found
2747     endif
2748   endif
2749   if fdt_opt == 'internal'
2750     fdt_files = files(
2751       'dtc/libfdt/fdt.c',
2752       'dtc/libfdt/fdt_ro.c',
2753       'dtc/libfdt/fdt_wip.c',
2754       'dtc/libfdt/fdt_sw.c',
2755       'dtc/libfdt/fdt_rw.c',
2756       'dtc/libfdt/fdt_strerror.c',
2757       'dtc/libfdt/fdt_empty_tree.c',
2758       'dtc/libfdt/fdt_addresses.c',
2759       'dtc/libfdt/fdt_overlay.c',
2760       'dtc/libfdt/fdt_check.c',
2761     )
2762
2763     fdt_inc = include_directories('dtc/libfdt')
2764     libfdt = static_library('fdt',
2765                             build_by_default: false,
2766                             sources: fdt_files,
2767                             include_directories: fdt_inc)
2768     fdt = declare_dependency(link_with: libfdt,
2769                              include_directories: fdt_inc)
2770   endif
2771 else
2772   fdt_opt = 'disabled'
2773 endif
2774 if not fdt.found() and fdt_required.length() > 0
2775   error('fdt not available but required by targets ' + ', '.join(fdt_required))
2776 endif
2777
2778 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2779 config_host_data.set('CONFIG_FDT', fdt.found())
2780 config_host_data.set('CONFIG_SLIRP', slirp.found())
2781
2782 #####################
2783 # Generated sources #
2784 #####################
2785
2786 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2787
2788 hxtool = find_program('scripts/hxtool')
2789 shaderinclude = find_program('scripts/shaderinclude.pl')
2790 qapi_gen = find_program('scripts/qapi-gen.py')
2791 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2792                      meson.current_source_dir() / 'scripts/qapi/commands.py',
2793                      meson.current_source_dir() / 'scripts/qapi/common.py',
2794                      meson.current_source_dir() / 'scripts/qapi/error.py',
2795                      meson.current_source_dir() / 'scripts/qapi/events.py',
2796                      meson.current_source_dir() / 'scripts/qapi/expr.py',
2797                      meson.current_source_dir() / 'scripts/qapi/gen.py',
2798                      meson.current_source_dir() / 'scripts/qapi/introspect.py',
2799                      meson.current_source_dir() / 'scripts/qapi/parser.py',
2800                      meson.current_source_dir() / 'scripts/qapi/schema.py',
2801                      meson.current_source_dir() / 'scripts/qapi/source.py',
2802                      meson.current_source_dir() / 'scripts/qapi/types.py',
2803                      meson.current_source_dir() / 'scripts/qapi/visit.py',
2804                      meson.current_source_dir() / 'scripts/qapi/common.py',
2805                      meson.current_source_dir() / 'scripts/qapi-gen.py'
2806 ]
2807
2808 tracetool = [
2809   python, files('scripts/tracetool.py'),
2810    '--backend=' + ','.join(get_option('trace_backends'))
2811 ]
2812 tracetool_depends = files(
2813   'scripts/tracetool/backend/log.py',
2814   'scripts/tracetool/backend/__init__.py',
2815   'scripts/tracetool/backend/dtrace.py',
2816   'scripts/tracetool/backend/ftrace.py',
2817   'scripts/tracetool/backend/simple.py',
2818   'scripts/tracetool/backend/syslog.py',
2819   'scripts/tracetool/backend/ust.py',
2820   'scripts/tracetool/format/ust_events_c.py',
2821   'scripts/tracetool/format/ust_events_h.py',
2822   'scripts/tracetool/format/__init__.py',
2823   'scripts/tracetool/format/d.py',
2824   'scripts/tracetool/format/simpletrace_stap.py',
2825   'scripts/tracetool/format/c.py',
2826   'scripts/tracetool/format/h.py',
2827   'scripts/tracetool/format/log_stap.py',
2828   'scripts/tracetool/format/stap.py',
2829   'scripts/tracetool/__init__.py',
2830   'scripts/tracetool/transform.py',
2831   'scripts/tracetool/vcpu.py'
2832 )
2833
2834 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2835                     meson.current_source_dir(),
2836                     get_option('pkgversion'), meson.project_version()]
2837 qemu_version = custom_target('qemu-version.h',
2838                              output: 'qemu-version.h',
2839                              command: qemu_version_cmd,
2840                              capture: true,
2841                              build_by_default: true,
2842                              build_always_stale: true)
2843 genh += qemu_version
2844
2845 hxdep = []
2846 hx_headers = [
2847   ['qemu-options.hx', 'qemu-options.def'],
2848   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2849 ]
2850 if have_system
2851   hx_headers += [
2852     ['hmp-commands.hx', 'hmp-commands.h'],
2853     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2854   ]
2855 endif
2856 foreach d : hx_headers
2857   hxdep += custom_target(d[1],
2858                 input: files(d[0]),
2859                 output: d[1],
2860                 capture: true,
2861                 build_by_default: true, # to be removed when added to a target
2862                 command: [hxtool, '-h', '@INPUT0@'])
2863 endforeach
2864 genh += hxdep
2865
2866 ###################
2867 # Collect sources #
2868 ###################
2869
2870 authz_ss = ss.source_set()
2871 blockdev_ss = ss.source_set()
2872 block_ss = ss.source_set()
2873 chardev_ss = ss.source_set()
2874 common_ss = ss.source_set()
2875 crypto_ss = ss.source_set()
2876 hwcore_ss = ss.source_set()
2877 io_ss = ss.source_set()
2878 qmp_ss = ss.source_set()
2879 qom_ss = ss.source_set()
2880 softmmu_ss = ss.source_set()
2881 specific_fuzz_ss = ss.source_set()
2882 specific_ss = ss.source_set()
2883 stub_ss = ss.source_set()
2884 trace_ss = ss.source_set()
2885 user_ss = ss.source_set()
2886 util_ss = ss.source_set()
2887
2888 # accel modules
2889 qtest_module_ss = ss.source_set()
2890 tcg_module_ss = ss.source_set()
2891
2892 modules = {}
2893 target_modules = {}
2894 hw_arch = {}
2895 target_arch = {}
2896 target_softmmu_arch = {}
2897 target_user_arch = {}
2898
2899 ###############
2900 # Trace files #
2901 ###############
2902
2903 # TODO: add each directory to the subdirs from its own meson.build, once
2904 # we have those
2905 trace_events_subdirs = [
2906   'crypto',
2907   'qapi',
2908   'qom',
2909   'monitor',
2910   'util',
2911 ]
2912 if have_linux_user
2913   trace_events_subdirs += [ 'linux-user' ]
2914 endif
2915 if have_bsd_user
2916   trace_events_subdirs += [ 'bsd-user' ]
2917 endif
2918 if have_block
2919   trace_events_subdirs += [
2920     'authz',
2921     'block',
2922     'io',
2923     'nbd',
2924     'scsi',
2925   ]
2926 endif
2927 if have_system
2928   trace_events_subdirs += [
2929     'accel/kvm',
2930     'audio',
2931     'backends',
2932     'backends/tpm',
2933     'chardev',
2934     'ebpf',
2935     'hw/9pfs',
2936     'hw/acpi',
2937     'hw/adc',
2938     'hw/alpha',
2939     'hw/arm',
2940     'hw/audio',
2941     'hw/block',
2942     'hw/block/dataplane',
2943     'hw/char',
2944     'hw/display',
2945     'hw/dma',
2946     'hw/hyperv',
2947     'hw/i2c',
2948     'hw/i386',
2949     'hw/i386/xen',
2950     'hw/ide',
2951     'hw/input',
2952     'hw/intc',
2953     'hw/isa',
2954     'hw/mem',
2955     'hw/mips',
2956     'hw/misc',
2957     'hw/misc/macio',
2958     'hw/net',
2959     'hw/net/can',
2960     'hw/nubus',
2961     'hw/nvme',
2962     'hw/nvram',
2963     'hw/pci',
2964     'hw/pci-host',
2965     'hw/ppc',
2966     'hw/rdma',
2967     'hw/rdma/vmw',
2968     'hw/rtc',
2969     'hw/s390x',
2970     'hw/scsi',
2971     'hw/sd',
2972     'hw/sh4',
2973     'hw/sparc',
2974     'hw/sparc64',
2975     'hw/ssi',
2976     'hw/timer',
2977     'hw/tpm',
2978     'hw/usb',
2979     'hw/vfio',
2980     'hw/virtio',
2981     'hw/watchdog',
2982     'hw/xen',
2983     'hw/gpio',
2984     'migration',
2985     'net',
2986     'softmmu',
2987     'ui',
2988     'hw/remote',
2989   ]
2990 endif
2991 if have_system or have_user
2992   trace_events_subdirs += [
2993     'accel/tcg',
2994     'hw/core',
2995     'target/arm',
2996     'target/arm/hvf',
2997     'target/hppa',
2998     'target/i386',
2999     'target/i386/kvm',
3000     'target/mips/tcg',
3001     'target/nios2',
3002     'target/ppc',
3003     'target/riscv',
3004     'target/s390x',
3005     'target/s390x/kvm',
3006     'target/sparc',
3007   ]
3008 endif
3009
3010 vhost_user = not_found
3011 if targetos == 'linux' and have_vhost_user
3012   libvhost_user = subproject('libvhost-user')
3013   vhost_user = libvhost_user.get_variable('vhost_user_dep')
3014 endif
3015
3016 libvduse = not_found
3017 if have_libvduse
3018   libvduse_proj = subproject('libvduse')
3019   libvduse = libvduse_proj.get_variable('libvduse_dep')
3020 endif
3021
3022 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
3023 # that is filled in by qapi/.
3024 subdir('qapi')
3025 subdir('qobject')
3026 subdir('stubs')
3027 subdir('trace')
3028 subdir('util')
3029 subdir('qom')
3030 subdir('authz')
3031 subdir('crypto')
3032 subdir('ui')
3033 subdir('hw')
3034
3035
3036 if enable_modules
3037   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
3038   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
3039 endif
3040
3041 qom_ss = qom_ss.apply(config_host, strict: false)
3042 libqom = static_library('qom', qom_ss.sources() + genh,
3043                         dependencies: [qom_ss.dependencies()],
3044                         name_suffix: 'fa')
3045 qom = declare_dependency(link_whole: libqom)
3046
3047 event_loop_base = files('event-loop-base.c')
3048 event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
3049                                  build_by_default: true)
3050 event_loop_base = declare_dependency(link_whole: event_loop_base,
3051                                      dependencies: [qom])
3052
3053 stub_ss = stub_ss.apply(config_all, strict: false)
3054
3055 util_ss.add_all(trace_ss)
3056 util_ss = util_ss.apply(config_all, strict: false)
3057 libqemuutil = static_library('qemuutil',
3058                              sources: util_ss.sources() + stub_ss.sources() + genh,
3059                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
3060 qemuutil = declare_dependency(link_with: libqemuutil,
3061                               sources: genh + version_res,
3062                               dependencies: [event_loop_base])
3063
3064 if have_system or have_user
3065   decodetree = generator(find_program('scripts/decodetree.py'),
3066                          output: 'decode-@BASENAME@.c.inc',
3067                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
3068   subdir('libdecnumber')
3069   subdir('target')
3070 endif
3071
3072 subdir('audio')
3073 subdir('io')
3074 subdir('chardev')
3075 subdir('fsdev')
3076 subdir('dump')
3077
3078 if have_block
3079   block_ss.add(files(
3080     'block.c',
3081     'blockjob.c',
3082     'job.c',
3083     'qemu-io-cmds.c',
3084   ))
3085   if config_host_data.get('CONFIG_REPLICATION')
3086     block_ss.add(files('replication.c'))
3087   endif
3088
3089   subdir('nbd')
3090   subdir('scsi')
3091   subdir('block')
3092
3093   blockdev_ss.add(files(
3094     'blockdev.c',
3095     'blockdev-nbd.c',
3096     'iothread.c',
3097     'job-qmp.c',
3098   ), gnutls)
3099
3100   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
3101   # os-win32.c does not
3102   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
3103   softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
3104 endif
3105
3106 common_ss.add(files('cpus-common.c'))
3107
3108 subdir('softmmu')
3109
3110 common_ss.add(capstone)
3111 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
3112
3113 # Work around a gcc bug/misfeature wherein constant propagation looks
3114 # through an alias:
3115 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
3116 # to guess that a const variable is always zero.  Without lto, this is
3117 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
3118 # without lto, not even the alias is required -- we simply use different
3119 # declarations in different compilation units.
3120 pagevary = files('page-vary-common.c')
3121 if get_option('b_lto')
3122   pagevary_flags = ['-fno-lto']
3123   if get_option('cfi')
3124     pagevary_flags += '-fno-sanitize=cfi-icall'
3125   endif
3126   pagevary = static_library('page-vary-common', sources: pagevary + genh,
3127                             c_args: pagevary_flags)
3128   pagevary = declare_dependency(link_with: pagevary)
3129 endif
3130 common_ss.add(pagevary)
3131 specific_ss.add(files('page-vary.c'))
3132
3133 subdir('backends')
3134 subdir('disas')
3135 subdir('migration')
3136 subdir('monitor')
3137 subdir('net')
3138 subdir('replay')
3139 subdir('semihosting')
3140 subdir('tcg')
3141 subdir('fpu')
3142 subdir('accel')
3143 subdir('plugins')
3144 subdir('ebpf')
3145
3146 common_user_inc = []
3147
3148 subdir('common-user')
3149 subdir('bsd-user')
3150 subdir('linux-user')
3151
3152 # needed for fuzzing binaries
3153 subdir('tests/qtest/libqos')
3154 subdir('tests/qtest/fuzz')
3155
3156 # accel modules
3157 tcg_real_module_ss = ss.source_set()
3158 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
3159 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
3160 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
3161                                 'tcg': tcg_real_module_ss }}
3162
3163 ########################
3164 # Library dependencies #
3165 ########################
3166
3167 modinfo_collect = find_program('scripts/modinfo-collect.py')
3168 modinfo_generate = find_program('scripts/modinfo-generate.py')
3169 modinfo_files = []
3170
3171 block_mods = []
3172 softmmu_mods = []
3173 foreach d, list : modules
3174   foreach m, module_ss : list
3175     if enable_modules and targetos != 'windows'
3176       module_ss = module_ss.apply(config_all, strict: false)
3177       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
3178                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
3179       if d == 'block'
3180         block_mods += sl
3181       else
3182         softmmu_mods += sl
3183       endif
3184       if module_ss.sources() != []
3185         # FIXME: Should use sl.extract_all_objects(recursive: true) as
3186         # input. Sources can be used multiple times but objects are
3187         # unique when it comes to lookup in compile_commands.json.
3188         # Depnds on a mesion version with
3189         # https://github.com/mesonbuild/meson/pull/8900
3190         modinfo_files += custom_target(d + '-' + m + '.modinfo',
3191                                        output: d + '-' + m + '.modinfo',
3192                                        input: module_ss.sources() + genh,
3193                                        capture: true,
3194                                        command: [modinfo_collect, module_ss.sources()])
3195       endif
3196     else
3197       if d == 'block'
3198         block_ss.add_all(module_ss)
3199       else
3200         softmmu_ss.add_all(module_ss)
3201       endif
3202     endif
3203   endforeach
3204 endforeach
3205
3206 foreach d, list : target_modules
3207   foreach m, module_ss : list
3208     if enable_modules and targetos != 'windows'
3209       foreach target : target_dirs
3210         if target.endswith('-softmmu')
3211           config_target = config_target_mak[target]
3212           config_target += config_host
3213           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3214           c_args = ['-DNEED_CPU_H',
3215                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3216                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3217           target_module_ss = module_ss.apply(config_target, strict: false)
3218           if target_module_ss.sources() != []
3219             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
3220             sl = static_library(module_name,
3221                                 [genh, target_module_ss.sources()],
3222                                 dependencies: [modulecommon, target_module_ss.dependencies()],
3223                                 include_directories: target_inc,
3224                                 c_args: c_args,
3225                                 pic: true)
3226             softmmu_mods += sl
3227             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
3228             modinfo_files += custom_target(module_name + '.modinfo',
3229                                            output: module_name + '.modinfo',
3230                                            input: target_module_ss.sources() + genh,
3231                                            capture: true,
3232                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3233           endif
3234         endif
3235       endforeach
3236     else
3237       specific_ss.add_all(module_ss)
3238     endif
3239   endforeach
3240 endforeach
3241
3242 if enable_modules
3243   foreach target : target_dirs
3244     if target.endswith('-softmmu')
3245       config_target = config_target_mak[target]
3246       config_devices_mak = target + '-config-devices.mak'
3247       modinfo_src = custom_target('modinfo-' + target + '.c',
3248                                   output: 'modinfo-' + target + '.c',
3249                                   input: modinfo_files,
3250                                   command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
3251                                   capture: true)
3252
3253       modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
3254       modinfo_dep = declare_dependency(link_with: modinfo_lib)
3255
3256       arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
3257       hw_arch[arch].add(modinfo_dep)
3258     endif
3259   endforeach
3260 endif
3261
3262 nm = find_program('nm')
3263 undefsym = find_program('scripts/undefsym.py')
3264 block_syms = custom_target('block.syms', output: 'block.syms',
3265                              input: [libqemuutil, block_mods],
3266                              capture: true,
3267                              command: [undefsym, nm, '@INPUT@'])
3268 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3269                              input: [libqemuutil, softmmu_mods],
3270                              capture: true,
3271                              command: [undefsym, nm, '@INPUT@'])
3272
3273 authz_ss = authz_ss.apply(config_host, strict: false)
3274 libauthz = static_library('authz', authz_ss.sources() + genh,
3275                           dependencies: [authz_ss.dependencies()],
3276                           name_suffix: 'fa',
3277                           build_by_default: false)
3278
3279 authz = declare_dependency(link_whole: libauthz,
3280                            dependencies: qom)
3281
3282 crypto_ss = crypto_ss.apply(config_host, strict: false)
3283 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3284                            dependencies: [crypto_ss.dependencies()],
3285                            name_suffix: 'fa',
3286                            build_by_default: false)
3287
3288 crypto = declare_dependency(link_whole: libcrypto,
3289                             dependencies: [authz, qom])
3290
3291 io_ss = io_ss.apply(config_host, strict: false)
3292 libio = static_library('io', io_ss.sources() + genh,
3293                        dependencies: [io_ss.dependencies()],
3294                        link_with: libqemuutil,
3295                        name_suffix: 'fa',
3296                        build_by_default: false)
3297
3298 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3299
3300 libmigration = static_library('migration', sources: migration_files + genh,
3301                               name_suffix: 'fa',
3302                               build_by_default: false)
3303 migration = declare_dependency(link_with: libmigration,
3304                                dependencies: [zlib, qom, io])
3305 softmmu_ss.add(migration)
3306
3307 block_ss = block_ss.apply(config_host, strict: false)
3308 libblock = static_library('block', block_ss.sources() + genh,
3309                           dependencies: block_ss.dependencies(),
3310                           link_depends: block_syms,
3311                           name_suffix: 'fa',
3312                           build_by_default: false)
3313
3314 block = declare_dependency(link_whole: [libblock],
3315                            link_args: '@block.syms',
3316                            dependencies: [crypto, io])
3317
3318 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3319 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3320                              dependencies: blockdev_ss.dependencies(),
3321                              name_suffix: 'fa',
3322                              build_by_default: false)
3323
3324 blockdev = declare_dependency(link_whole: [libblockdev],
3325                               dependencies: [block, event_loop_base])
3326
3327 qmp_ss = qmp_ss.apply(config_host, strict: false)
3328 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3329                         dependencies: qmp_ss.dependencies(),
3330                         name_suffix: 'fa',
3331                         build_by_default: false)
3332
3333 qmp = declare_dependency(link_whole: [libqmp])
3334
3335 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3336                             name_suffix: 'fa',
3337                             dependencies: chardev_ss.dependencies(),
3338                             build_by_default: false)
3339
3340 chardev = declare_dependency(link_whole: libchardev)
3341
3342 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3343 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3344                            name_suffix: 'fa',
3345                            build_by_default: false)
3346 hwcore = declare_dependency(link_whole: libhwcore)
3347 common_ss.add(hwcore)
3348
3349 ###########
3350 # Targets #
3351 ###########
3352
3353 emulator_modules = []
3354 foreach m : block_mods + softmmu_mods
3355   emulator_modules += shared_module(m.name(),
3356                 build_by_default: true,
3357                 name_prefix: '',
3358                 link_whole: m,
3359                 install: true,
3360                 install_dir: qemu_moddir)
3361 endforeach
3362 if emulator_modules.length() > 0
3363   alias_target('modules', emulator_modules)
3364 endif
3365
3366 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3367 common_ss.add(qom, qemuutil)
3368
3369 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3370 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3371
3372 common_all = common_ss.apply(config_all, strict: false)
3373 common_all = static_library('common',
3374                             build_by_default: false,
3375                             sources: common_all.sources() + genh,
3376                             include_directories: common_user_inc,
3377                             implicit_include_directories: false,
3378                             dependencies: common_all.dependencies(),
3379                             name_suffix: 'fa')
3380
3381 feature_to_c = find_program('scripts/feature_to_c.sh')
3382
3383 if targetos == 'darwin'
3384   entitlement = find_program('scripts/entitlement.sh')
3385 endif
3386
3387 emulators = {}
3388 foreach target : target_dirs
3389   config_target = config_target_mak[target]
3390   target_name = config_target['TARGET_NAME']
3391   target_base_arch = config_target['TARGET_BASE_ARCH']
3392   arch_srcs = [config_target_h[target]]
3393   arch_deps = []
3394   c_args = ['-DNEED_CPU_H',
3395             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3396             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3397   link_args = emulator_link_args
3398
3399   config_target += config_host
3400   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3401   if targetos == 'linux'
3402     target_inc += include_directories('linux-headers', is_system: true)
3403   endif
3404   if target.endswith('-softmmu')
3405     qemu_target_name = 'qemu-system-' + target_name
3406     target_type='system'
3407     t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3408     arch_srcs += t.sources()
3409     arch_deps += t.dependencies()
3410
3411     hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3412     hw = hw_arch[hw_dir].apply(config_target, strict: false)
3413     arch_srcs += hw.sources()
3414     arch_deps += hw.dependencies()
3415
3416     arch_srcs += config_devices_h[target]
3417     link_args += ['@block.syms', '@qemu.syms']
3418   else
3419     abi = config_target['TARGET_ABI_DIR']
3420     target_type='user'
3421     target_inc += common_user_inc
3422     qemu_target_name = 'qemu-' + target_name
3423     if target_base_arch in target_user_arch
3424       t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3425       arch_srcs += t.sources()
3426       arch_deps += t.dependencies()
3427     endif
3428     if 'CONFIG_LINUX_USER' in config_target
3429       base_dir = 'linux-user'
3430     endif
3431     if 'CONFIG_BSD_USER' in config_target
3432       base_dir = 'bsd-user'
3433       target_inc += include_directories('bsd-user/' / targetos)
3434       target_inc += include_directories('bsd-user/host/' / host_arch)
3435       dir = base_dir / abi
3436       arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3437     endif
3438     target_inc += include_directories(
3439       base_dir,
3440       base_dir / abi,
3441     )
3442     if 'CONFIG_LINUX_USER' in config_target
3443       dir = base_dir / abi
3444       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3445       if config_target.has_key('TARGET_SYSTBL_ABI')
3446         arch_srcs += \
3447           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3448                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
3449       endif
3450     endif
3451   endif
3452
3453   if 'TARGET_XML_FILES' in config_target
3454     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3455                                 output: target + '-gdbstub-xml.c',
3456                                 input: files(config_target['TARGET_XML_FILES'].split()),
3457                                 command: [feature_to_c, '@INPUT@'],
3458                                 capture: true)
3459     arch_srcs += gdbstub_xml
3460   endif
3461
3462   t = target_arch[target_base_arch].apply(config_target, strict: false)
3463   arch_srcs += t.sources()
3464   arch_deps += t.dependencies()
3465
3466   target_common = common_ss.apply(config_target, strict: false)
3467   objects = common_all.extract_objects(target_common.sources())
3468   deps = target_common.dependencies()
3469
3470   target_specific = specific_ss.apply(config_target, strict: false)
3471   arch_srcs += target_specific.sources()
3472   arch_deps += target_specific.dependencies()
3473
3474   lib = static_library('qemu-' + target,
3475                  sources: arch_srcs + genh,
3476                  dependencies: arch_deps,
3477                  objects: objects,
3478                  include_directories: target_inc,
3479                  c_args: c_args,
3480                  build_by_default: false,
3481                  name_suffix: 'fa')
3482
3483   if target.endswith('-softmmu')
3484     execs = [{
3485       'name': 'qemu-system-' + target_name,
3486       'win_subsystem': 'console',
3487       'sources': files('softmmu/main.c'),
3488       'dependencies': []
3489     }]
3490     if targetos == 'windows' and (sdl.found() or gtk.found())
3491       execs += [{
3492         'name': 'qemu-system-' + target_name + 'w',
3493         'win_subsystem': 'windows',
3494         'sources': files('softmmu/main.c'),
3495         'dependencies': []
3496       }]
3497     endif
3498     if get_option('fuzzing')
3499       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3500       execs += [{
3501         'name': 'qemu-fuzz-' + target_name,
3502         'win_subsystem': 'console',
3503         'sources': specific_fuzz.sources(),
3504         'dependencies': specific_fuzz.dependencies(),
3505       }]
3506     endif
3507   else
3508     execs = [{
3509       'name': 'qemu-' + target_name,
3510       'win_subsystem': 'console',
3511       'sources': [],
3512       'dependencies': []
3513     }]
3514   endif
3515   foreach exe: execs
3516     exe_name = exe['name']
3517     if targetos == 'darwin'
3518       exe_name += '-unsigned'
3519     endif
3520
3521     emulator = executable(exe_name, exe['sources'],
3522                install: true,
3523                c_args: c_args,
3524                dependencies: arch_deps + deps + exe['dependencies'],
3525                objects: lib.extract_all_objects(recursive: true),
3526                link_language: link_language,
3527                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3528                link_args: link_args,
3529                win_subsystem: exe['win_subsystem'])
3530
3531     if targetos == 'darwin'
3532       icon = 'pc-bios/qemu.rsrc'
3533       build_input = [emulator, files(icon)]
3534       install_input = [
3535         get_option('bindir') / exe_name,
3536         meson.current_source_dir() / icon
3537       ]
3538       if 'CONFIG_HVF' in config_target
3539         entitlements = 'accel/hvf/entitlements.plist'
3540         build_input += files(entitlements)
3541         install_input += meson.current_source_dir() / entitlements
3542       endif
3543
3544       emulators += {exe['name'] : custom_target(exe['name'],
3545                    input: build_input,
3546                    output: exe['name'],
3547                    command: [entitlement, '@OUTPUT@', '@INPUT@'])
3548       }
3549
3550       meson.add_install_script(entitlement, '--install',
3551                                get_option('bindir') / exe['name'],
3552                                install_input)
3553     else
3554       emulators += {exe['name']: emulator}
3555     endif
3556
3557     if stap.found()
3558       foreach stp: [
3559         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3560         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3561         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3562         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3563       ]
3564         custom_target(exe['name'] + stp['ext'],
3565                       input: trace_events_all,
3566                       output: exe['name'] + stp['ext'],
3567                       install: stp['install'],
3568                       install_dir: get_option('datadir') / 'systemtap/tapset',
3569                       command: [
3570                         tracetool, '--group=all', '--format=' + stp['fmt'],
3571                         '--binary=' + stp['bin'],
3572                         '--target-name=' + target_name,
3573                         '--target-type=' + target_type,
3574                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
3575                         '@INPUT@', '@OUTPUT@'
3576                       ],
3577                       depend_files: tracetool_depends)
3578       endforeach
3579     endif
3580   endforeach
3581 endforeach
3582
3583 # Other build targets
3584
3585 if 'CONFIG_PLUGIN' in config_host
3586   install_headers('include/qemu/qemu-plugin.h')
3587 endif
3588
3589 subdir('qga')
3590
3591 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3592 # when we don't build tools or system
3593 if xkbcommon.found()
3594   # used for the update-keymaps target, so include rules even if !have_tools
3595   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3596                            dependencies: [qemuutil, xkbcommon], install: have_tools)
3597 endif
3598
3599 if have_tools
3600   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3601              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3602   qemu_io = executable('qemu-io', files('qemu-io.c'),
3603              dependencies: [block, qemuutil], install: true)
3604   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3605                dependencies: [blockdev, qemuutil, gnutls, selinux],
3606                install: true)
3607
3608   subdir('storage-daemon')
3609   subdir('contrib/rdmacm-mux')
3610   subdir('contrib/elf2dmp')
3611
3612   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3613              dependencies: qemuutil,
3614              install: true)
3615
3616   if have_vhost_user
3617     subdir('contrib/vhost-user-blk')
3618     subdir('contrib/vhost-user-gpu')
3619     subdir('contrib/vhost-user-input')
3620     subdir('contrib/vhost-user-scsi')
3621   endif
3622
3623   if targetos == 'linux'
3624     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3625                dependencies: [qemuutil, libcap_ng],
3626                install: true,
3627                install_dir: get_option('libexecdir'))
3628
3629     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3630                dependencies: [authz, crypto, io, qom, qemuutil,
3631                               libcap_ng, mpathpersist],
3632                install: true)
3633   endif
3634
3635   if have_ivshmem
3636     subdir('contrib/ivshmem-client')
3637     subdir('contrib/ivshmem-server')
3638   endif
3639 endif
3640
3641 subdir('scripts')
3642 subdir('tools')
3643 subdir('pc-bios')
3644 subdir('docs')
3645 subdir('tests')
3646 if gtk.found()
3647   subdir('po')
3648 endif
3649
3650 if host_machine.system() == 'windows'
3651   nsis_cmd = [
3652     find_program('scripts/nsis.py'),
3653     '@OUTPUT@',
3654     get_option('prefix'),
3655     meson.current_source_dir(),
3656     host_machine.cpu(),
3657     '--',
3658     '-DDISPLAYVERSION=' + meson.project_version(),
3659   ]
3660   if build_docs
3661     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3662   endif
3663   if gtk.found()
3664     nsis_cmd += '-DCONFIG_GTK=y'
3665   endif
3666
3667   nsis = custom_target('nsis',
3668                        output: 'qemu-setup-' + meson.project_version() + '.exe',
3669                        input: files('qemu.nsi'),
3670                        build_always_stale: true,
3671                        command: nsis_cmd + ['@INPUT@'])
3672   alias_target('installer', nsis)
3673 endif
3674
3675 #########################
3676 # Configuration summary #
3677 #########################
3678
3679 # Directories
3680 summary_info = {}
3681 summary_info += {'Install prefix':    get_option('prefix')}
3682 summary_info += {'BIOS directory':    qemu_datadir}
3683 summary_info += {'firmware path':     get_option('prefix') / get_option('qemu_firmwarepath')}
3684 summary_info += {'binary directory':  get_option('prefix') / get_option('bindir')}
3685 summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
3686 summary_info += {'module directory':  qemu_moddir}
3687 summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
3688 summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
3689 summary_info += {'config directory':  get_option('prefix') / get_option('sysconfdir')}
3690 if targetos != 'windows'
3691   summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
3692   summary_info += {'Manual directory':      get_option('prefix') / get_option('mandir')}
3693 else
3694   summary_info += {'local state directory': 'queried at runtime'}
3695 endif
3696 summary_info += {'Doc directory':     get_option('prefix') / get_option('docdir')}
3697 summary_info += {'Build directory':   meson.current_build_dir()}
3698 summary_info += {'Source path':       meson.current_source_dir()}
3699 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
3700 summary(summary_info, bool_yn: true, section: 'Directories')
3701
3702 # Host binaries
3703 summary_info = {}
3704 summary_info += {'git':               config_host['GIT']}
3705 summary_info += {'make':              config_host['MAKE']}
3706 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3707 summary_info += {'sphinx-build':      sphinx_build}
3708 if config_host.has_key('HAVE_GDB_BIN')
3709   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
3710 endif
3711 summary_info += {'iasl':              iasl}
3712 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
3713 if targetos == 'windows' and have_ga
3714   summary_info += {'wixl':            wixl}
3715 endif
3716 if slirp_opt != 'disabled' and have_system
3717   summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
3718 endif
3719 summary(summary_info, bool_yn: true, section: 'Host binaries')
3720
3721 # Configurable features
3722 summary_info = {}
3723 summary_info += {'Documentation':     build_docs}
3724 summary_info += {'system-mode emulation': have_system}
3725 summary_info += {'user-mode emulation': have_user}
3726 summary_info += {'block layer':       have_block}
3727 summary_info += {'Install blobs':     get_option('install_blobs')}
3728 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
3729 if config_host.has_key('CONFIG_MODULES')
3730   summary_info += {'alternative module path': get_option('module_upgrades')}
3731 endif
3732 summary_info += {'fuzzing support':   get_option('fuzzing')}
3733 if have_system
3734   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
3735 endif
3736 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
3737 if 'simple' in get_option('trace_backends')
3738   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3739 endif
3740 summary_info += {'D-Bus display':     dbus_display}
3741 summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
3742 summary_info += {'vhost-kernel support': have_vhost_kernel}
3743 summary_info += {'vhost-net support': have_vhost_net}
3744 summary_info += {'vhost-user support': have_vhost_user}
3745 summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
3746 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3747 summary_info += {'vhost-vdpa support': have_vhost_vdpa}
3748 summary_info += {'build guest agent': have_ga}
3749 summary(summary_info, bool_yn: true, section: 'Configurable features')
3750
3751 # Compilation information
3752 summary_info = {}
3753 summary_info += {'host CPU':          cpu}
3754 summary_info += {'host endianness':   build_machine.endian()}
3755 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
3756 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3757 if link_language == 'cpp'
3758   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
3759 else
3760   summary_info += {'C++ compiler':      false}
3761 endif
3762 if targetos == 'darwin'
3763   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3764 endif
3765 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
3766                                                + ['-O' + get_option('optimization')]
3767                                                + (get_option('debug') ? ['-g'] : []))}
3768 if link_language == 'cpp'
3769   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
3770                                                + ['-O' + get_option('optimization')]
3771                                                + (get_option('debug') ? ['-g'] : []))}
3772 endif
3773 if targetos == 'darwin'
3774   summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args')
3775                                                + ['-O' + get_option('optimization')]
3776                                                + (get_option('debug') ? ['-g'] : []))}
3777 endif
3778 link_args = get_option(link_language + '_link_args')
3779 if link_args.length() > 0
3780   summary_info += {'LDFLAGS':         ' '.join(link_args)}
3781 endif
3782 summary_info += {'QEMU_CFLAGS':       ' '.join(qemu_cflags)}
3783 summary_info += {'QEMU_CXXFLAGS':     ' '.join(qemu_cxxflags)}
3784 summary_info += {'QEMU_OBJCFLAGS':    ' '.join(qemu_objcflags)}
3785 summary_info += {'QEMU_LDFLAGS':      ' '.join(qemu_ldflags)}
3786 summary_info += {'profiler':          get_option('profiler')}
3787 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3788 summary_info += {'PIE':               get_option('b_pie')}
3789 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
3790 summary_info += {'malloc trim support': has_malloc_trim}
3791 summary_info += {'membarrier':        have_membarrier}
3792 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
3793 summary_info += {'mutex debugging':   get_option('debug_mutex')}
3794 summary_info += {'memory allocator':  get_option('malloc')}
3795 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
3796 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
3797 summary_info += {'gprof enabled':     get_option('gprof')}
3798 summary_info += {'gcov':              get_option('b_coverage')}
3799 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
3800 summary_info += {'CFI support':       get_option('cfi')}
3801 if get_option('cfi')
3802   summary_info += {'CFI debug support': get_option('cfi_debug')}
3803 endif
3804 summary_info += {'strip binaries':    get_option('strip')}
3805 summary_info += {'sparse':            sparse}
3806 summary_info += {'mingw32 support':   targetos == 'windows'}
3807 summary(summary_info, bool_yn: true, section: 'Compilation')
3808
3809 # snarf the cross-compilation information for tests
3810 summary_info = {}
3811 have_cross = false
3812 foreach target: target_dirs
3813   tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3814   if fs.exists(tcg_mak)
3815     config_cross_tcg = keyval.load(tcg_mak)
3816     if 'CC' in config_cross_tcg
3817       summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
3818       have_cross = true
3819     endif
3820   endif
3821 endforeach
3822 if have_cross
3823   summary(summary_info, bool_yn: true, section: 'Cross compilers')
3824 endif
3825
3826 # Targets and accelerators
3827 summary_info = {}
3828 if have_system
3829   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
3830   summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
3831   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
3832   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
3833   summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
3834   summary_info += {'Xen support':       xen.found()}
3835   if xen.found()
3836     summary_info += {'xen ctrl version':  xen.version()}
3837   endif
3838 endif
3839 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
3840 if config_all.has_key('CONFIG_TCG')
3841   if get_option('tcg_interpreter')
3842     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
3843   else
3844     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
3845   endif
3846   summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3847   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3848 endif
3849 summary_info += {'target list':       ' '.join(target_dirs)}
3850 if have_system
3851   summary_info += {'default devices':   get_option('default_devices')}
3852   summary_info += {'out of process emulation': multiprocess_allowed}
3853   summary_info += {'vfio-user server': vfio_user_server_allowed}
3854 endif
3855 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3856
3857 # Block layer
3858 summary_info = {}
3859 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3860 summary_info += {'coroutine pool':    have_coroutine_pool}
3861 if have_block
3862   summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
3863   summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
3864   summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
3865   summary_info += {'VirtFS support':    have_virtfs}
3866   summary_info += {'build virtiofs daemon': have_virtiofsd}
3867   summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
3868   summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
3869   summary_info += {'bochs support':     get_option('bochs').allowed()}
3870   summary_info += {'cloop support':     get_option('cloop').allowed()}
3871   summary_info += {'dmg support':       get_option('dmg').allowed()}
3872   summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
3873   summary_info += {'vdi support':       get_option('vdi').allowed()}
3874   summary_info += {'vvfat support':     get_option('vvfat').allowed()}
3875   summary_info += {'qed support':       get_option('qed').allowed()}
3876   summary_info += {'parallels support': get_option('parallels').allowed()}
3877   summary_info += {'FUSE exports':      fuse}
3878   summary_info += {'VDUSE block exports': have_vduse_blk_export}
3879 endif
3880 summary(summary_info, bool_yn: true, section: 'Block layer support')
3881
3882 # Crypto
3883 summary_info = {}
3884 summary_info += {'TLS priority':      get_option('tls_priority')}
3885 summary_info += {'GNUTLS support':    gnutls}
3886 if gnutls.found()
3887   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
3888 endif
3889 summary_info += {'libgcrypt':         gcrypt}
3890 summary_info += {'nettle':            nettle}
3891 if nettle.found()
3892    summary_info += {'  XTS':             xts != 'private'}
3893 endif
3894 summary_info += {'AF_ALG support':    have_afalg}
3895 summary_info += {'rng-none':          get_option('rng_none')}
3896 summary_info += {'Linux keyring':     have_keyring}
3897 summary(summary_info, bool_yn: true, section: 'Crypto')
3898
3899 # Libraries
3900 summary_info = {}
3901 if targetos == 'darwin'
3902   summary_info += {'Cocoa support':           cocoa}
3903   summary_info += {'vmnet.framework support': vmnet}
3904 endif
3905 summary_info += {'SDL support':       sdl}
3906 summary_info += {'SDL image support': sdl_image}
3907 summary_info += {'GTK support':       gtk}
3908 summary_info += {'pixman':            pixman}
3909 summary_info += {'VTE support':       vte}
3910 summary_info += {'slirp support':     slirp_opt == 'internal' ? slirp_opt : slirp}
3911 summary_info += {'libtasn1':          tasn1}
3912 summary_info += {'PAM':               pam}
3913 summary_info += {'iconv support':     iconv}
3914 summary_info += {'curses support':    curses}
3915 summary_info += {'virgl support':     virgl}
3916 summary_info += {'curl support':      curl}
3917 summary_info += {'Multipath support': mpathpersist}
3918 summary_info += {'PNG support':       png}
3919 summary_info += {'VNC support':       vnc}
3920 if vnc.found()
3921   summary_info += {'VNC SASL support':  sasl}
3922   summary_info += {'VNC JPEG support':  jpeg}
3923 endif
3924 if targetos not in ['darwin', 'haiku', 'windows']
3925   summary_info += {'OSS support':     oss}
3926 elif targetos == 'darwin'
3927   summary_info += {'CoreAudio support': coreaudio}
3928 elif targetos == 'windows'
3929   summary_info += {'DirectSound support': dsound}
3930 endif
3931 if targetos == 'linux'
3932   summary_info += {'ALSA support':    alsa}
3933   summary_info += {'PulseAudio support': pulse}
3934 endif
3935 summary_info += {'JACK support':      jack}
3936 summary_info += {'brlapi support':    brlapi}
3937 summary_info += {'vde support':       vde}
3938 summary_info += {'netmap support':    have_netmap}
3939 summary_info += {'l2tpv3 support':    have_l2tpv3}
3940 summary_info += {'Linux AIO support': libaio}
3941 summary_info += {'Linux io_uring support': linux_io_uring}
3942 summary_info += {'ATTR/XATTR support': libattr}
3943 summary_info += {'RDMA support':      rdma}
3944 summary_info += {'PVRDMA support':    have_pvrdma}
3945 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
3946 summary_info += {'libcap-ng support': libcap_ng}
3947 summary_info += {'bpf support':       libbpf}
3948 summary_info += {'spice protocol support': spice_protocol}
3949 if spice_protocol.found()
3950   summary_info += {'  spice server support': spice}
3951 endif
3952 summary_info += {'rbd support':       rbd}
3953 summary_info += {'smartcard support': cacard}
3954 summary_info += {'U2F support':       u2f}
3955 summary_info += {'libusb':            libusb}
3956 summary_info += {'usb net redir':     usbredir}
3957 summary_info += {'OpenGL support (epoxy)': opengl}
3958 summary_info += {'GBM':               gbm}
3959 summary_info += {'libiscsi support':  libiscsi}
3960 summary_info += {'libnfs support':    libnfs}
3961 if targetos == 'windows'
3962   if have_ga
3963     summary_info += {'QGA VSS support':   have_qga_vss}
3964   endif
3965 endif
3966 summary_info += {'seccomp support':   seccomp}
3967 summary_info += {'GlusterFS support': glusterfs}
3968 summary_info += {'TPM support':       have_tpm}
3969 summary_info += {'libssh support':    libssh}
3970 summary_info += {'lzo support':       lzo}
3971 summary_info += {'snappy support':    snappy}
3972 summary_info += {'bzip2 support':     libbzip2}
3973 summary_info += {'lzfse support':     liblzfse}
3974 summary_info += {'zstd support':      zstd}
3975 summary_info += {'NUMA host support': numa}
3976 summary_info += {'capstone':          capstone}
3977 summary_info += {'libpmem support':   libpmem}
3978 summary_info += {'libdaxctl support': libdaxctl}
3979 summary_info += {'libudev':           libudev}
3980 # Dummy dependency, keep .found()
3981 summary_info += {'FUSE lseek':        fuse_lseek.found()}
3982 summary_info += {'selinux':           selinux}
3983 summary(summary_info, bool_yn: true, section: 'Dependencies')
3984
3985 if not supported_cpus.contains(cpu)
3986   message()
3987   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3988   message()
3989   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3990   message('The QEMU project intends to remove support for this host CPU in')
3991   message('a future release if nobody volunteers to maintain it and to')
3992   message('provide a build host for our continuous integration setup.')
3993   message('configure has succeeded and you can continue to build, but')
3994   message('if you care about QEMU on this platform you should contact')
3995   message('us upstream at qemu-devel@nongnu.org.')
3996 endif
3997
3998 if not supported_oses.contains(targetos)
3999   message()
4000   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
4001   message()
4002   message('Host OS ' + targetos + 'support is not currently maintained.')
4003   message('The QEMU project intends to remove support for this host OS in')
4004   message('a future release if nobody volunteers to maintain it and to')
4005   message('provide a build host for our continuous integration setup.')
4006   message('configure has succeeded and you can continue to build, but')
4007   message('if you care about QEMU on this platform you should contact')
4008   message('us upstream at qemu-devel@nongnu.org.')
4009 endif