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