meson.build

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