meson.build

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