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/loongarch',
3333     'target/mips/tcg',
3334     'target/nios2',
3335     'target/ppc',
3336     'target/riscv',
3337     'target/s390x',
3338     'target/s390x/kvm',
3339     'target/sparc',
3340   ]
3341 endif
3342
3343 ###################
3344 # Collect sources #
3345 ###################
3346
3347 authz_ss = ss.source_set()
3348 blockdev_ss = ss.source_set()
3349 block_ss = ss.source_set()
3350 chardev_ss = ss.source_set()
3351 common_ss = ss.source_set()
3352 crypto_ss = ss.source_set()
3353 hwcore_ss = ss.source_set()
3354 io_ss = ss.source_set()
3355 qmp_ss = ss.source_set()
3356 qom_ss = ss.source_set()
3357 system_ss = ss.source_set()
3358 specific_fuzz_ss = ss.source_set()
3359 specific_ss = ss.source_set()
3360 stub_ss = ss.source_set()
3361 trace_ss = ss.source_set()
3362 user_ss = ss.source_set()
3363 util_ss = ss.source_set()
3364
3365 # accel modules
3366 qtest_module_ss = ss.source_set()
3367 tcg_module_ss = ss.source_set()
3368
3369 modules = {}
3370 target_modules = {}
3371 hw_arch = {}
3372 target_arch = {}
3373 target_system_arch = {}
3374 target_user_arch = {}
3375
3376 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
3377 # that is filled in by qapi/.
3378 subdir('qapi')
3379 subdir('qobject')
3380 subdir('stubs')
3381 subdir('trace')
3382 subdir('util')
3383 subdir('qom')
3384 subdir('authz')
3385 subdir('crypto')
3386 subdir('ui')
3387 subdir('hw')
3388 subdir('gdbstub')
3389
3390 if enable_modules
3391   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
3392   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
3393 endif
3394
3395 qom_ss = qom_ss.apply({})
3396 libqom = static_library('qom', qom_ss.sources() + genh,
3397                         dependencies: [qom_ss.dependencies()],
3398                         name_suffix: 'fa',
3399                         build_by_default: false)
3400 qom = declare_dependency(link_whole: libqom)
3401
3402 event_loop_base = files('event-loop-base.c')
3403 event_loop_base = static_library('event-loop-base',
3404                                  sources: event_loop_base + genh,
3405                                  name_suffix: 'fa',
3406                                  build_by_default: false)
3407 event_loop_base = declare_dependency(link_whole: event_loop_base,
3408                                      dependencies: [qom])
3409
3410 stub_ss = stub_ss.apply({})
3411
3412 util_ss.add_all(trace_ss)
3413 util_ss = util_ss.apply({})
3414 libqemuutil = static_library('qemuutil',
3415                              build_by_default: false,
3416                              sources: util_ss.sources() + stub_ss.sources() + genh,
3417                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
3418 qemuutil = declare_dependency(link_with: libqemuutil,
3419                               sources: genh + version_res,
3420                               dependencies: [event_loop_base])
3421
3422 if have_system or have_user
3423   decodetree = generator(find_program('scripts/decodetree.py'),
3424                          output: 'decode-@BASENAME@.c.inc',
3425                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
3426   subdir('libdecnumber')
3427   subdir('target')
3428 endif
3429
3430 subdir('audio')
3431 subdir('io')
3432 subdir('chardev')
3433 subdir('fsdev')
3434 subdir('dump')
3435
3436 if have_block
3437   block_ss.add(files(
3438     'block.c',
3439     'blockjob.c',
3440     'job.c',
3441     'qemu-io-cmds.c',
3442   ))
3443   if config_host_data.get('CONFIG_REPLICATION')
3444     block_ss.add(files('replication.c'))
3445   endif
3446
3447   subdir('nbd')
3448   subdir('scsi')
3449   subdir('block')
3450
3451   blockdev_ss.add(files(
3452     'blockdev.c',
3453     'blockdev-nbd.c',
3454     'iothread.c',
3455     'job-qmp.c',
3456   ), gnutls)
3457
3458   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
3459   # os-win32.c does not
3460   if host_os == 'windows'
3461     system_ss.add(files('os-win32.c'))
3462   else
3463     blockdev_ss.add(files('os-posix.c'))
3464   endif
3465 endif
3466
3467 common_ss.add(files('cpu-common.c'))
3468 specific_ss.add(files('cpu-target.c'))
3469
3470 subdir('system')
3471
3472 # Work around a gcc bug/misfeature wherein constant propagation looks
3473 # through an alias:
3474 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
3475 # to guess that a const variable is always zero.  Without lto, this is
3476 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
3477 # without lto, not even the alias is required -- we simply use different
3478 # declarations in different compilation units.
3479 pagevary = files('page-vary-common.c')
3480 if get_option('b_lto')
3481   pagevary_flags = ['-fno-lto']
3482   if get_option('cfi')
3483     pagevary_flags += '-fno-sanitize=cfi-icall'
3484   endif
3485   pagevary = static_library('page-vary-common', sources: pagevary + genh,
3486                             c_args: pagevary_flags)
3487   pagevary = declare_dependency(link_with: pagevary)
3488 endif
3489 common_ss.add(pagevary)
3490 specific_ss.add(files('page-vary-target.c'))
3491
3492 subdir('backends')
3493 subdir('disas')
3494 subdir('migration')
3495 subdir('monitor')
3496 subdir('net')
3497 subdir('replay')
3498 subdir('semihosting')
3499 subdir('stats')
3500 subdir('tcg')
3501 subdir('fpu')
3502 subdir('accel')
3503 subdir('plugins')
3504 subdir('ebpf')
3505
3506 common_user_inc = []
3507
3508 subdir('common-user')
3509 subdir('bsd-user')
3510 subdir('linux-user')
3511
3512 # needed for fuzzing binaries
3513 subdir('tests/qtest/libqos')
3514 subdir('tests/qtest/fuzz')
3515
3516 # accel modules
3517 tcg_real_module_ss = ss.source_set()
3518 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
3519 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
3520 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
3521                                 'tcg': tcg_real_module_ss }}
3522
3523 ##############################################
3524 # Internal static_libraries and dependencies #
3525 ##############################################
3526
3527 modinfo_collect = find_program('scripts/modinfo-collect.py')
3528 modinfo_generate = find_program('scripts/modinfo-generate.py')
3529 modinfo_files = []
3530
3531 block_mods = []
3532 system_mods = []
3533 foreach d, list : modules
3534   if not (d == 'block' ? have_block : have_system)
3535     continue
3536   endif
3537
3538   foreach m, module_ss : list
3539     if enable_modules
3540       module_ss = module_ss.apply(config_all_devices, strict: false)
3541       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
3542                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
3543       if d == 'block'
3544         block_mods += sl
3545       else
3546         system_mods += sl
3547       endif
3548       if module_ss.sources() != []
3549         # FIXME: Should use sl.extract_all_objects(recursive: true) as
3550         # input. Sources can be used multiple times but objects are
3551         # unique when it comes to lookup in compile_commands.json.
3552         # Depnds on a mesion version with
3553         # https://github.com/mesonbuild/meson/pull/8900
3554         modinfo_files += custom_target(d + '-' + m + '.modinfo',
3555                                        output: d + '-' + m + '.modinfo',
3556                                        input: module_ss.sources() + genh,
3557                                        capture: true,
3558                                        command: [modinfo_collect, module_ss.sources()])
3559       endif
3560     else
3561       if d == 'block'
3562         block_ss.add_all(module_ss)
3563       else
3564         system_ss.add_all(module_ss)
3565       endif
3566     endif
3567   endforeach
3568 endforeach
3569
3570 foreach d, list : target_modules
3571   foreach m, module_ss : list
3572     if enable_modules
3573       foreach target : target_dirs
3574         if target.endswith('-softmmu')
3575           config_target = config_target_mak[target]
3576           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3577           c_args = ['-DNEED_CPU_H',
3578                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3579                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3580           target_module_ss = module_ss.apply(config_target, strict: false)
3581           if target_module_ss.sources() != []
3582             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
3583             sl = static_library(module_name,
3584                                 [genh, target_module_ss.sources()],
3585                                 dependencies: [modulecommon, target_module_ss.dependencies()],
3586                                 include_directories: target_inc,
3587                                 c_args: c_args,
3588                                 pic: true)
3589             system_mods += sl
3590             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
3591             modinfo_files += custom_target(module_name + '.modinfo',
3592                                            output: module_name + '.modinfo',
3593                                            input: target_module_ss.sources() + genh,
3594                                            capture: true,
3595                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3596           endif
3597         endif
3598       endforeach
3599     else
3600       specific_ss.add_all(module_ss)
3601     endif
3602   endforeach
3603 endforeach
3604
3605 if enable_modules
3606   foreach target : target_dirs
3607     if target.endswith('-softmmu')
3608       config_target = config_target_mak[target]
3609       config_devices_mak = target + '-config-devices.mak'
3610       modinfo_src = custom_target('modinfo-' + target + '.c',
3611                                   output: 'modinfo-' + target + '.c',
3612                                   input: modinfo_files,
3613                                   command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
3614                                   capture: true)
3615
3616       modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
3617       modinfo_dep = declare_dependency(link_with: modinfo_lib)
3618
3619       arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
3620       hw_arch[arch].add(modinfo_dep)
3621     endif
3622   endforeach
3623 endif
3624
3625 nm = find_program('nm')
3626 undefsym = find_program('scripts/undefsym.py')
3627 block_syms = custom_target('block.syms', output: 'block.syms',
3628                              input: [libqemuutil, block_mods],
3629                              capture: true,
3630                              command: [undefsym, nm, '@INPUT@'])
3631 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3632                              input: [libqemuutil, system_mods],
3633                              capture: true,
3634                              command: [undefsym, nm, '@INPUT@'])
3635
3636 authz_ss = authz_ss.apply({})
3637 libauthz = static_library('authz', authz_ss.sources() + genh,
3638                           dependencies: [authz_ss.dependencies()],
3639                           name_suffix: 'fa',
3640                           build_by_default: false)
3641
3642 authz = declare_dependency(link_whole: libauthz,
3643                            dependencies: qom)
3644
3645 crypto_ss = crypto_ss.apply({})
3646 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3647                            dependencies: [crypto_ss.dependencies()],
3648                            name_suffix: 'fa',
3649                            build_by_default: false)
3650
3651 crypto = declare_dependency(link_whole: libcrypto,
3652                             dependencies: [authz, qom])
3653
3654 io_ss = io_ss.apply({})
3655 libio = static_library('io', io_ss.sources() + genh,
3656                        dependencies: [io_ss.dependencies()],
3657                        link_with: libqemuutil,
3658                        name_suffix: 'fa',
3659                        build_by_default: false)
3660
3661 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3662
3663 libmigration = static_library('migration', sources: migration_files + genh,
3664                               name_suffix: 'fa',
3665                               build_by_default: false)
3666 migration = declare_dependency(link_with: libmigration,
3667                                dependencies: [zlib, qom, io])
3668 system_ss.add(migration)
3669
3670 block_ss = block_ss.apply({})
3671 libblock = static_library('block', block_ss.sources() + genh,
3672                           dependencies: block_ss.dependencies(),
3673                           link_depends: block_syms,
3674                           name_suffix: 'fa',
3675                           build_by_default: false)
3676
3677 block = declare_dependency(link_whole: [libblock],
3678                            link_args: '@block.syms',
3679                            dependencies: [crypto, io])
3680
3681 blockdev_ss = blockdev_ss.apply({})
3682 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3683                              dependencies: blockdev_ss.dependencies(),
3684                              name_suffix: 'fa',
3685                              build_by_default: false)
3686
3687 blockdev = declare_dependency(link_whole: [libblockdev],
3688                               dependencies: [block, event_loop_base])
3689
3690 qmp_ss = qmp_ss.apply({})
3691 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3692                         dependencies: qmp_ss.dependencies(),
3693                         name_suffix: 'fa',
3694                         build_by_default: false)
3695
3696 qmp = declare_dependency(link_whole: [libqmp])
3697
3698 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3699                             name_suffix: 'fa',
3700                             dependencies: chardev_ss.dependencies(),
3701                             build_by_default: false)
3702
3703 chardev = declare_dependency(link_whole: libchardev)
3704
3705 hwcore_ss = hwcore_ss.apply({})
3706 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3707                            name_suffix: 'fa',
3708                            build_by_default: false)
3709 hwcore = declare_dependency(link_whole: libhwcore)
3710 common_ss.add(hwcore)
3711
3712 ###########
3713 # Targets #
3714 ###########
3715
3716 emulator_modules = []
3717 foreach m : block_mods + system_mods
3718   emulator_modules += shared_module(m.name(),
3719                 build_by_default: true,
3720                 name_prefix: '',
3721                 link_whole: m,
3722                 install: true,
3723                 install_dir: qemu_moddir)
3724 endforeach
3725 if emulator_modules.length() > 0
3726   alias_target('modules', emulator_modules)
3727 endif
3728
3729 system_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3730 common_ss.add(qom, qemuutil)
3731
3732 common_ss.add_all(when: 'CONFIG_SYSTEM_ONLY', if_true: [system_ss])
3733 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3734
3735 # Note that this library is never used directly (only through extract_objects)
3736 # and is not built by default; therefore, source files not used by the build
3737 # configuration will be in build.ninja, but are never built by default.
3738 common_all = static_library('common',
3739                             build_by_default: false,
3740                             sources: common_ss.all_sources() + genh,
3741                             include_directories: common_user_inc,
3742                             implicit_include_directories: false,
3743                             dependencies: common_ss.all_dependencies(),
3744                             name_suffix: 'fa')
3745
3746 feature_to_c = find_program('scripts/feature_to_c.py')
3747
3748 if host_os == 'darwin'
3749   entitlement = find_program('scripts/entitlement.sh')
3750 endif
3751
3752 emulators = {}
3753 foreach target : target_dirs
3754   config_target = config_target_mak[target]
3755   target_name = config_target['TARGET_NAME']
3756   target_base_arch = config_target['TARGET_BASE_ARCH']
3757   arch_srcs = [config_target_h[target]]
3758   arch_deps = []
3759   c_args = ['-DNEED_CPU_H',
3760             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3761             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3762   link_args = emulator_link_args
3763
3764   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3765   if host_os == 'linux'
3766     target_inc += include_directories('linux-headers', is_system: true)
3767   endif
3768   if target.endswith('-softmmu')
3769     target_type='system'
3770     t = target_system_arch[target_base_arch].apply(config_target, strict: false)
3771     arch_srcs += t.sources()
3772     arch_deps += t.dependencies()
3773
3774     hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3775     if hw_arch.has_key(hw_dir)
3776       hw = hw_arch[hw_dir].apply(config_target, strict: false)
3777       arch_srcs += hw.sources()
3778       arch_deps += hw.dependencies()
3779     endif
3780
3781     arch_srcs += config_devices_h[target]
3782     link_args += ['@block.syms', '@qemu.syms']
3783   else
3784     abi = config_target['TARGET_ABI_DIR']
3785     target_type='user'
3786     target_inc += common_user_inc
3787     if target_base_arch in target_user_arch
3788       t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3789       arch_srcs += t.sources()
3790       arch_deps += t.dependencies()
3791     endif
3792     if 'CONFIG_LINUX_USER' in config_target
3793       base_dir = 'linux-user'
3794     endif
3795     if 'CONFIG_BSD_USER' in config_target
3796       base_dir = 'bsd-user'
3797       target_inc += include_directories('bsd-user/' / host_os)
3798       target_inc += include_directories('bsd-user/host/' / host_arch)
3799       dir = base_dir / abi
3800       arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3801     endif
3802     target_inc += include_directories(
3803       base_dir,
3804       base_dir / abi,
3805     )
3806     if 'CONFIG_LINUX_USER' in config_target
3807       dir = base_dir / abi
3808       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3809       if config_target.has_key('TARGET_SYSTBL_ABI')
3810         arch_srcs += \
3811           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3812                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
3813       endif
3814     endif
3815   endif
3816
3817   if 'TARGET_XML_FILES' in config_target
3818     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3819                                 output: target + '-gdbstub-xml.c',
3820                                 input: files(config_target['TARGET_XML_FILES'].split()),
3821                                 command: [feature_to_c, '@INPUT@'],
3822                                 capture: true)
3823     arch_srcs += gdbstub_xml
3824   endif
3825
3826   t = target_arch[target_base_arch].apply(config_target, strict: false)
3827   arch_srcs += t.sources()
3828   arch_deps += t.dependencies()
3829
3830   target_common = common_ss.apply(config_target, strict: false)
3831   objects = common_all.extract_objects(target_common.sources())
3832   deps = target_common.dependencies()
3833
3834   target_specific = specific_ss.apply(config_target, strict: false)
3835   arch_srcs += target_specific.sources()
3836   arch_deps += target_specific.dependencies()
3837
3838   lib = static_library('qemu-' + target,
3839                  sources: arch_srcs + genh,
3840                  dependencies: arch_deps,
3841                  objects: objects,
3842                  include_directories: target_inc,
3843                  c_args: c_args,
3844                  build_by_default: false,
3845                  name_suffix: 'fa')
3846
3847   if target.endswith('-softmmu')
3848     execs = [{
3849       'name': 'qemu-system-' + target_name,
3850       'win_subsystem': 'console',
3851       'sources': files('system/main.c'),
3852       'dependencies': []
3853     }]
3854     if host_os == 'windows' and (sdl.found() or gtk.found())
3855       execs += [{
3856         'name': 'qemu-system-' + target_name + 'w',
3857         'win_subsystem': 'windows',
3858         'sources': files('system/main.c'),
3859         'dependencies': []
3860       }]
3861     endif
3862     if get_option('fuzzing')
3863       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3864       execs += [{
3865         'name': 'qemu-fuzz-' + target_name,
3866         'win_subsystem': 'console',
3867         'sources': specific_fuzz.sources(),
3868         'dependencies': specific_fuzz.dependencies(),
3869       }]
3870     endif
3871   else
3872     execs = [{
3873       'name': 'qemu-' + target_name,
3874       'win_subsystem': 'console',
3875       'sources': [],
3876       'dependencies': []
3877     }]
3878   endif
3879   foreach exe: execs
3880     exe_name = exe['name']
3881     if host_os == 'darwin'
3882       exe_name += '-unsigned'
3883     endif
3884
3885     emulator = executable(exe_name, exe['sources'],
3886                install: true,
3887                c_args: c_args,
3888                dependencies: arch_deps + deps + exe['dependencies'],
3889                objects: lib.extract_all_objects(recursive: true),
3890                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3891                link_args: link_args,
3892                win_subsystem: exe['win_subsystem'])
3893
3894     if host_os == 'darwin'
3895       icon = 'pc-bios/qemu.rsrc'
3896       build_input = [emulator, files(icon)]
3897       install_input = [
3898         get_option('bindir') / exe_name,
3899         meson.current_source_dir() / icon
3900       ]
3901       if 'CONFIG_HVF' in config_target
3902         entitlements = 'accel/hvf/entitlements.plist'
3903         build_input += files(entitlements)
3904         install_input += meson.current_source_dir() / entitlements
3905       endif
3906
3907       emulators += {exe['name'] : custom_target(exe['name'],
3908                    input: build_input,
3909                    output: exe['name'],
3910                    command: [entitlement, '@OUTPUT@', '@INPUT@'])
3911       }
3912
3913       meson.add_install_script(entitlement, '--install',
3914                                get_option('bindir') / exe['name'],
3915                                install_input)
3916     else
3917       emulators += {exe['name']: emulator}
3918     endif
3919
3920     if stap.found()
3921       foreach stp: [
3922         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3923         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3924         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3925         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3926       ]
3927         custom_target(exe['name'] + stp['ext'],
3928                       input: trace_events_all,
3929                       output: exe['name'] + stp['ext'],
3930                       install: stp['install'],
3931                       install_dir: get_option('datadir') / 'systemtap/tapset',
3932                       command: [
3933                         tracetool, '--group=all', '--format=' + stp['fmt'],
3934                         '--binary=' + stp['bin'],
3935                         '--target-name=' + target_name,
3936                         '--target-type=' + target_type,
3937                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
3938                         '@INPUT@', '@OUTPUT@'
3939                       ],
3940                       depend_files: tracetool_depends)
3941       endforeach
3942     endif
3943   endforeach
3944 endforeach
3945
3946 # Other build targets
3947
3948 if get_option('plugins')
3949   install_headers('include/qemu/qemu-plugin.h')
3950   if host_os == 'windows'
3951     # On windows, we want to deliver the qemu_plugin_api.lib file in the qemu installer,
3952     # so that plugin authors can compile against it.
3953     install_data(win32_qemu_plugin_api_lib, install_dir: 'lib')
3954   endif
3955 endif
3956
3957 subdir('qga')
3958
3959 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3960 # when we don't build tools or system
3961 if xkbcommon.found()
3962   # used for the update-keymaps target, so include rules even if !have_tools
3963   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3964                            dependencies: [qemuutil, xkbcommon], install: have_tools)
3965 endif
3966
3967 if have_tools
3968   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3969              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3970   qemu_io = executable('qemu-io', files('qemu-io.c'),
3971              dependencies: [block, qemuutil], install: true)
3972   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3973                dependencies: [blockdev, qemuutil, gnutls, selinux],
3974                install: true)
3975
3976   subdir('storage-daemon')
3977   subdir('contrib/rdmacm-mux')
3978   subdir('contrib/elf2dmp')
3979
3980   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3981              dependencies: qemuutil,
3982              install: true)
3983
3984   if have_vhost_user
3985     subdir('contrib/vhost-user-blk')
3986     subdir('contrib/vhost-user-gpu')
3987     subdir('contrib/vhost-user-input')
3988     subdir('contrib/vhost-user-scsi')
3989   endif
3990
3991   if host_os == 'linux'
3992     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3993                dependencies: [qemuutil, libcap_ng],
3994                install: true,
3995                install_dir: get_option('libexecdir'))
3996
3997     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3998                dependencies: [authz, crypto, io, qom, qemuutil,
3999                               libcap_ng, mpathpersist],
4000                install: true)
4001   endif
4002
4003   if have_ivshmem
4004     subdir('contrib/ivshmem-client')
4005     subdir('contrib/ivshmem-server')
4006   endif
4007 endif
4008
4009 subdir('scripts')
4010 subdir('tools')
4011 subdir('pc-bios')
4012 subdir('docs')
4013 subdir('tests')
4014 if gtk.found()
4015   subdir('po')
4016 endif
4017
4018 if host_machine.system() == 'windows'
4019   nsis_cmd = [
4020     find_program('scripts/nsis.py'),
4021     '@OUTPUT@',
4022     get_option('prefix'),
4023     meson.current_source_dir(),
4024     glib_pc.get_variable('bindir'),
4025     host_machine.cpu(),
4026     '--',
4027     '-DDISPLAYVERSION=' + meson.project_version(),
4028   ]
4029   if build_docs
4030     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
4031   endif
4032   if gtk.found()
4033     nsis_cmd += '-DCONFIG_GTK=y'
4034   endif
4035
4036   nsis = custom_target('nsis',
4037                        output: 'qemu-setup-' + meson.project_version() + '.exe',
4038                        input: files('qemu.nsi'),
4039                        build_always_stale: true,
4040                        command: nsis_cmd + ['@INPUT@'])
4041   alias_target('installer', nsis)
4042 endif
4043
4044 #########################
4045 # Configuration summary #
4046 #########################
4047
4048 # Build environment
4049 summary_info = {}
4050 summary_info += {'Build directory':   meson.current_build_dir()}
4051 summary_info += {'Source path':       meson.current_source_dir()}
4052 summary_info += {'Download dependencies': get_option('wrap_mode') != 'nodownload'}
4053 summary(summary_info, bool_yn: true, section: 'Build environment')
4054
4055 # Directories
4056 summary_info += {'Install prefix':    get_option('prefix')}
4057 summary_info += {'BIOS directory':    qemu_datadir}
4058 pathsep = host_os == 'windows' ? ';' : ':'
4059 summary_info += {'firmware path':     pathsep.join(get_option('qemu_firmwarepath'))}
4060 summary_info += {'binary directory':  get_option('prefix') / get_option('bindir')}
4061 summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
4062 summary_info += {'module directory':  qemu_moddir}
4063 summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
4064 summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
4065 summary_info += {'config directory':  get_option('prefix') / get_option('sysconfdir')}
4066 if host_os != 'windows'
4067   summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
4068   summary_info += {'Manual directory':      get_option('prefix') / get_option('mandir')}
4069 else
4070   summary_info += {'local state directory': 'queried at runtime'}
4071 endif
4072 summary_info += {'Doc directory':     get_option('prefix') / get_option('docdir')}
4073 summary(summary_info, bool_yn: true, section: 'Directories')
4074
4075 # Host binaries
4076 summary_info = {}
4077 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
4078 summary_info += {'sphinx-build':      sphinx_build}
4079
4080 # FIXME: the [binaries] section of machine files, which can be probed
4081 # with find_program(), would be great for passing gdb and genisoimage
4082 # paths from configure to Meson.  However, there seems to be no way to
4083 # hide a program (for example if gdb is too old).
4084 if config_host.has_key('GDB')
4085   summary_info += {'gdb':             config_host['GDB']}
4086 endif
4087 summary_info += {'iasl':              iasl}
4088 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
4089 if host_os == 'windows' and have_ga
4090   summary_info += {'wixl':            wixl}
4091 endif
4092 if slirp.found() and have_system
4093   summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
4094 endif
4095 summary(summary_info, bool_yn: true, section: 'Host binaries')
4096
4097 # Configurable features
4098 summary_info = {}
4099 summary_info += {'Documentation':     build_docs}
4100 summary_info += {'system-mode emulation': have_system}
4101 summary_info += {'user-mode emulation': have_user}
4102 summary_info += {'block layer':       have_block}
4103 summary_info += {'Install blobs':     get_option('install_blobs')}
4104 summary_info += {'module support':    enable_modules}
4105 if enable_modules
4106   summary_info += {'alternative module path': get_option('module_upgrades')}
4107 endif
4108 summary_info += {'fuzzing support':   get_option('fuzzing')}
4109 if have_system
4110   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
4111 endif
4112 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
4113 if 'simple' in get_option('trace_backends')
4114   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
4115 endif
4116 summary_info += {'D-Bus display':     dbus_display}
4117 summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
4118 summary_info += {'Relocatable install': get_option('relocatable')}
4119 summary_info += {'vhost-kernel support': have_vhost_kernel}
4120 summary_info += {'vhost-net support': have_vhost_net}
4121 summary_info += {'vhost-user support': have_vhost_user}
4122 summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
4123 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
4124 summary_info += {'vhost-vdpa support': have_vhost_vdpa}
4125 summary_info += {'build guest agent': have_ga}
4126 summary(summary_info, bool_yn: true, section: 'Configurable features')
4127
4128 # Compilation information
4129 summary_info = {}
4130 summary_info += {'host CPU':          cpu}
4131 summary_info += {'host endianness':   build_machine.endian()}
4132 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
4133 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
4134 if 'cpp' in all_languages
4135   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
4136 else
4137   summary_info += {'C++ compiler':      false}
4138 endif
4139 if 'objc' in all_languages
4140   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
4141 else
4142   summary_info += {'Objective-C compiler': false}
4143 endif
4144 option_cflags = (get_option('debug') ? ['-g'] : [])
4145 if get_option('optimization') != 'plain'
4146   option_cflags += ['-O' + get_option('optimization')]
4147 endif
4148 summary_info += {'CFLAGS':            ' '.join(get_option('c_args') + option_cflags)}
4149 if 'cpp' in all_languages
4150   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args') + option_cflags)}
4151 endif
4152 if 'objc' in all_languages
4153   summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args') + option_cflags)}
4154 endif
4155 link_args = get_option('c_link_args')
4156 if link_args.length() > 0
4157   summary_info += {'LDFLAGS':         ' '.join(link_args)}
4158 endif
4159 summary_info += {'QEMU_CFLAGS':       ' '.join(qemu_common_flags + qemu_cflags)}
4160 if 'cpp' in all_languages
4161   summary_info += {'QEMU_CXXFLAGS':     ' '.join(qemu_common_flags + qemu_cxxflags)}
4162 endif
4163 if 'objc' in all_languages
4164   summary_info += {'QEMU_OBJCFLAGS':    ' '.join(qemu_common_flags)}
4165 endif
4166 summary_info += {'QEMU_LDFLAGS':      ' '.join(qemu_ldflags)}
4167 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
4168 summary_info += {'PIE':               get_option('b_pie')}
4169 summary_info += {'static build':      get_option('prefer_static')}
4170 summary_info += {'malloc trim support': has_malloc_trim}
4171 summary_info += {'membarrier':        have_membarrier}
4172 summary_info += {'debug graph lock':  get_option('debug_graph_lock')}
4173 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
4174 summary_info += {'mutex debugging':   get_option('debug_mutex')}
4175 summary_info += {'memory allocator':  get_option('malloc')}
4176 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
4177 summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')}
4178 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
4179 summary_info += {'gcov':              get_option('b_coverage')}
4180 summary_info += {'thread sanitizer':  get_option('tsan')}
4181 summary_info += {'CFI support':       get_option('cfi')}
4182 if get_option('cfi')
4183   summary_info += {'CFI debug support': get_option('cfi_debug')}
4184 endif
4185 summary_info += {'strip binaries':    get_option('strip')}
4186 summary_info += {'sparse':            sparse}
4187 summary_info += {'mingw32 support':   host_os == 'windows'}
4188 summary(summary_info, bool_yn: true, section: 'Compilation')
4189
4190 # snarf the cross-compilation information for tests
4191 summary_info = {}
4192 have_cross = false
4193 foreach target: target_dirs
4194   tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak'
4195   if fs.exists(tcg_mak)
4196     config_cross_tcg = keyval.load(tcg_mak)
4197     if 'CC' in config_cross_tcg
4198       summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
4199       have_cross = true
4200     endif
4201   endif
4202 endforeach
4203 if have_cross
4204   summary(summary_info, bool_yn: true, section: 'Cross compilers')
4205 endif
4206
4207 # Targets and accelerators
4208 summary_info = {}
4209 if have_system
4210   summary_info += {'KVM support':       config_all_accel.has_key('CONFIG_KVM')}
4211   summary_info += {'HVF support':       config_all_accel.has_key('CONFIG_HVF')}
4212   summary_info += {'WHPX support':      config_all_accel.has_key('CONFIG_WHPX')}
4213   summary_info += {'NVMM support':      config_all_accel.has_key('CONFIG_NVMM')}
4214   summary_info += {'Xen support':       xen.found()}
4215   if xen.found()
4216     summary_info += {'xen ctrl version':  xen.version()}
4217   endif
4218   summary_info += {'Xen emulation':     config_all_devices.has_key('CONFIG_XEN_EMU')}
4219 endif
4220 summary_info += {'TCG support':       config_all_accel.has_key('CONFIG_TCG')}
4221 if config_all_accel.has_key('CONFIG_TCG')
4222   if get_option('tcg_interpreter')
4223     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
4224   else
4225     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
4226   endif
4227   summary_info += {'TCG plugins':       get_option('plugins')}
4228   summary_info += {'TCG debug enabled': get_option('debug_tcg')}
4229 endif
4230 summary_info += {'target list':       ' '.join(target_dirs)}
4231 if have_system
4232   summary_info += {'default devices':   get_option('default_devices')}
4233   summary_info += {'out of process emulation': multiprocess_allowed}
4234   summary_info += {'vfio-user server': vfio_user_server_allowed}
4235 endif
4236 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
4237
4238 # Block layer
4239 summary_info = {}
4240 summary_info += {'coroutine backend': coroutine_backend}
4241 summary_info += {'coroutine pool':    have_coroutine_pool}
4242 if have_block
4243   summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
4244   summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
4245   summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
4246   summary_info += {'VirtFS (9P) support':    have_virtfs}
4247   summary_info += {'VirtFS (9P) Proxy Helper support (deprecated)': have_virtfs_proxy_helper}
4248   summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
4249   summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
4250   summary_info += {'bochs support':     get_option('bochs').allowed()}
4251   summary_info += {'cloop support':     get_option('cloop').allowed()}
4252   summary_info += {'dmg support':       get_option('dmg').allowed()}
4253   summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
4254   summary_info += {'vdi support':       get_option('vdi').allowed()}
4255   summary_info += {'vhdx support':      get_option('vhdx').allowed()}
4256   summary_info += {'vmdk support':      get_option('vmdk').allowed()}
4257   summary_info += {'vpc support':       get_option('vpc').allowed()}
4258   summary_info += {'vvfat support':     get_option('vvfat').allowed()}
4259   summary_info += {'qed support':       get_option('qed').allowed()}
4260   summary_info += {'parallels support': get_option('parallels').allowed()}
4261   summary_info += {'FUSE exports':      fuse}
4262   summary_info += {'VDUSE block exports': have_vduse_blk_export}
4263 endif
4264 summary(summary_info, bool_yn: true, section: 'Block layer support')
4265
4266 # Crypto
4267 summary_info = {}
4268 summary_info += {'TLS priority':      get_option('tls_priority')}
4269 summary_info += {'GNUTLS support':    gnutls}
4270 if gnutls.found()
4271   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
4272 endif
4273 summary_info += {'libgcrypt':         gcrypt}
4274 summary_info += {'nettle':            nettle}
4275 if nettle.found()
4276    summary_info += {'  XTS':             xts != 'private'}
4277 endif
4278 summary_info += {'AF_ALG support':    have_afalg}
4279 summary_info += {'rng-none':          get_option('rng_none')}
4280 summary_info += {'Linux keyring':     have_keyring}
4281 summary_info += {'Linux keyutils':    keyutils}
4282 summary(summary_info, bool_yn: true, section: 'Crypto')
4283
4284 # UI
4285 summary_info = {}
4286 if host_os == 'darwin'
4287   summary_info += {'Cocoa support':           cocoa}
4288 endif
4289 summary_info += {'SDL support':       sdl}
4290 summary_info += {'SDL image support': sdl_image}
4291 summary_info += {'GTK support':       gtk}
4292 summary_info += {'pixman':            pixman}
4293 summary_info += {'VTE support':       vte}
4294 summary_info += {'PNG support':       png}
4295 summary_info += {'VNC support':       vnc}
4296 if vnc.found()
4297   summary_info += {'VNC SASL support':  sasl}
4298   summary_info += {'VNC JPEG support':  jpeg}
4299 endif
4300 summary_info += {'spice protocol support': spice_protocol}
4301 if spice_protocol.found()
4302   summary_info += {'  spice server support': spice}
4303 endif
4304 summary_info += {'curses support':    curses}
4305 summary_info += {'brlapi support':    brlapi}
4306 summary(summary_info, bool_yn: true, section: 'User interface')
4307
4308 # Graphics backends
4309 summary_info = {}
4310 summary_info += {'VirGL support':     virgl}
4311 summary_info += {'Rutabaga support':  rutabaga}
4312 summary(summary_info, bool_yn: true, section: 'Graphics backends')
4313
4314 # Audio backends
4315 summary_info = {}
4316 if host_os not in ['darwin', 'haiku', 'windows']
4317   summary_info += {'OSS support':     oss}
4318   summary_info += {'sndio support':   sndio}
4319 elif host_os == 'darwin'
4320   summary_info += {'CoreAudio support': coreaudio}
4321 elif host_os == 'windows'
4322   summary_info += {'DirectSound support': dsound}
4323 endif
4324 if host_os == 'linux'
4325   summary_info += {'ALSA support':    alsa}
4326   summary_info += {'PulseAudio support': pulse}
4327 endif
4328 summary_info += {'PipeWire support':  pipewire}
4329 summary_info += {'JACK support':      jack}
4330 summary(summary_info, bool_yn: true, section: 'Audio backends')
4331
4332 # Network backends
4333 summary_info = {}
4334 if host_os == 'darwin'
4335   summary_info += {'vmnet.framework support': vmnet}
4336 endif
4337 summary_info += {'AF_XDP support':    libxdp}
4338 summary_info += {'slirp support':     slirp}
4339 summary_info += {'vde support':       vde}
4340 summary_info += {'netmap support':    have_netmap}
4341 summary_info += {'l2tpv3 support':    have_l2tpv3}
4342 summary(summary_info, bool_yn: true, section: 'Network backends')
4343
4344 # Libraries
4345 summary_info = {}
4346 summary_info += {'libtasn1':          tasn1}
4347 summary_info += {'PAM':               pam}
4348 summary_info += {'iconv support':     iconv}
4349 summary_info += {'blkio support':     blkio}
4350 summary_info += {'curl support':      curl}
4351 summary_info += {'Multipath support': mpathpersist}
4352 summary_info += {'Linux AIO support': libaio}
4353 summary_info += {'Linux io_uring support': linux_io_uring}
4354 summary_info += {'ATTR/XATTR support': libattr}
4355 summary_info += {'RDMA support':      rdma}
4356 summary_info += {'PVRDMA support':    have_pvrdma}
4357 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
4358 summary_info += {'libcap-ng support': libcap_ng}
4359 summary_info += {'bpf support':       libbpf}
4360 summary_info += {'rbd support':       rbd}
4361 summary_info += {'smartcard support': cacard}
4362 summary_info += {'U2F support':       u2f}
4363 summary_info += {'libusb':            libusb}
4364 summary_info += {'usb net redir':     usbredir}
4365 summary_info += {'OpenGL support (epoxy)': opengl}
4366 summary_info += {'GBM':               gbm}
4367 summary_info += {'libiscsi support':  libiscsi}
4368 summary_info += {'libnfs support':    libnfs}
4369 if host_os == 'windows'
4370   if have_ga
4371     summary_info += {'QGA VSS support':   have_qga_vss}
4372   endif
4373 endif
4374 summary_info += {'seccomp support':   seccomp}
4375 summary_info += {'GlusterFS support': glusterfs}
4376 summary_info += {'hv-balloon support': hv_balloon}
4377 summary_info += {'TPM support':       have_tpm}
4378 summary_info += {'libssh support':    libssh}
4379 summary_info += {'lzo support':       lzo}
4380 summary_info += {'snappy support':    snappy}
4381 summary_info += {'bzip2 support':     libbzip2}
4382 summary_info += {'lzfse support':     liblzfse}
4383 summary_info += {'zstd support':      zstd}
4384 summary_info += {'NUMA host support': numa}
4385 summary_info += {'capstone':          capstone}
4386 summary_info += {'libpmem support':   libpmem}
4387 summary_info += {'libdaxctl support': libdaxctl}
4388 summary_info += {'libudev':           libudev}
4389 # Dummy dependency, keep .found()
4390 summary_info += {'FUSE lseek':        fuse_lseek.found()}
4391 summary_info += {'selinux':           selinux}
4392 summary_info += {'libdw':             libdw}
4393 summary(summary_info, bool_yn: true, section: 'Dependencies')
4394
4395 if host_arch == 'unknown'
4396   message()
4397   warning('UNSUPPORTED HOST CPU')
4398   message()
4399   message('Support for CPU host architecture ' + cpu + ' is not currently')
4400   message('maintained. The QEMU project does not guarantee that QEMU will')
4401   message('compile or work on this host CPU. You can help by volunteering')
4402   message('to maintain it and providing a build host for our continuous')
4403   message('integration setup.')
4404   if get_option('tcg').allowed() and target_dirs.length() > 0
4405     message()
4406     message('configure has succeeded and you can continue to build, but')
4407     message('QEMU will use a slow interpreter to emulate the target CPU.')
4408   endif
4409 endif
4410
4411 if not supported_oses.contains(host_os)
4412   message()
4413   warning('UNSUPPORTED HOST OS')
4414   message()
4415   message('Support for host OS ' + host_os + 'is not currently maintained.')
4416   message('configure has succeeded and you can continue to build, but')
4417   message('the QEMU project does not guarantee that QEMU will compile or')
4418   message('work on this operating system. You can help by volunteering')
4419   message('to maintain it and providing a build host for our continuous')
4420   message('integration setup. This will ensure that future versions of QEMU')
4421   message('will keep working on ' + host_os + '.')
4422 endif
4423
4424 if host_arch == 'unknown' or not supported_oses.contains(host_os)
4425   message()
4426   message('If you want to help supporting QEMU on this platform, please')
4427   message('contact the developers at qemu-devel@nongnu.org.')
4428 endif
4429
4430 actually_reloc = get_option('relocatable')
4431 # check if get_relocated_path() is actually able to relocate paths
4432 if get_option('relocatable') and \
4433   not (get_option('prefix') / get_option('bindir')).startswith(get_option('prefix') / '')
4434   message()
4435   warning('bindir not included within prefix, the installation will not be relocatable.')
4436   actually_reloc = false
4437 endif
4438 if not actually_reloc and (host_os == 'windows' or get_option('relocatable'))
4439   if host_os == 'windows'
4440     message()
4441     warning('Windows installs should usually be relocatable.')
4442   endif
4443   message()
4444   message('QEMU will have to be installed under ' + get_option('prefix') + '.')
4445   message('Use --disable-relocatable to remove this warning.')
4446 endif