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