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