1 project('qemu', ['c'], meson_version: '>=0.59.3',
2 default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto',
3 'b_staticpic=false', 'stdsplit=false'],
4 version: files('VERSION'))
6 add_test_setup('quick', exclude_suites: ['block', 'slow', 'thorough'], is_default: true)
7 add_test_setup('slow', exclude_suites: ['block', 'thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
8 add_test_setup('thorough', exclude_suites: ['block'], env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
10 not_found = dependency('', required: false)
11 keyval = import('keyval')
12 ss = import('sourceset')
15 sh = find_program('sh')
16 cc = meson.get_compiler('c')
17 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
18 enable_modules = 'CONFIG_MODULES' in config_host
19 enable_static = 'CONFIG_STATIC' in config_host
21 # Allow both shared and static libraries unless --enable-static
22 static_kwargs = enable_static ? {'static': true} : {}
24 # Temporary directory used for files created while
25 # configure runs. Since it is in the build directory
26 # we can safely blow away any previous version of it
27 # (and we need not jump through hoops to try to delete
28 # it when configure exits.)
29 tmpdir = meson.current_build_dir() / 'meson-private/temp'
31 if get_option('qemu_suffix').startswith('/')
32 error('qemu_suffix cannot start with a /')
35 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
36 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
37 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
38 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
40 qemu_desktopdir = get_option('datadir') / 'applications'
41 qemu_icondir = get_option('datadir') / 'icons'
43 config_host_data = configuration_data()
45 qapi_trace_events = []
47 bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin']
48 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
49 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv', 'x86', 'x86_64',
50 'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc', 'sparc64']
52 cpu = host_machine.cpu_family()
54 # Unify riscv* to a single family.
55 if cpu in ['riscv32', 'riscv64']
59 targetos = host_machine.system()
61 target_dirs = config_host['TARGET_DIRS'].split()
62 have_linux_user = false
65 foreach target : target_dirs
66 have_linux_user = have_linux_user or target.endswith('linux-user')
67 have_bsd_user = have_bsd_user or target.endswith('bsd-user')
68 have_system = have_system or target.endswith('-softmmu')
70 have_user = have_linux_user or have_bsd_user
71 have_tools = get_option('tools') \
72 .disable_auto_if(not have_system) \
74 have_ga = get_option('guest_agent') \
75 .disable_auto_if(not have_system and not have_tools) \
76 .require(targetos in ['sunos', 'linux', 'windows'],
77 error_message: 'unsupported OS for QEMU guest agent') \
79 have_block = have_system or have_tools
81 python = import('python').find_installation()
83 if cpu not in supported_cpus
93 if cpu in ['x86', 'x86_64']
94 kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
96 kvm_targets = ['aarch64-softmmu']
98 kvm_targets = ['s390x-softmmu']
99 elif cpu in ['ppc', 'ppc64']
100 kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
101 elif cpu in ['mips', 'mips64']
102 kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
103 elif cpu in ['riscv']
104 kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu']
110 if get_option('kvm').allowed() and targetos == 'linux'
111 kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"'
113 config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c)
115 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
117 if cpu in ['aarch64']
118 accelerator_targets += {
119 'CONFIG_HVF': ['aarch64-softmmu']
123 if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
124 # i386 emulator provides xenpv machine type for multiple architectures
125 accelerator_targets += {
126 'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
129 if cpu in ['x86', 'x86_64']
130 accelerator_targets += {
131 'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
132 'CONFIG_HVF': ['x86_64-softmmu'],
133 'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
134 'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
139 # Darwin does not support references to thread-local variables in modules
140 if targetos != 'darwin'
141 modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
144 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
145 unpack_edk2_blobs = false
146 foreach target : edk2_targets
147 if target in target_dirs
148 bzip2 = find_program('bzip2', required: get_option('install_blobs'))
149 unpack_edk2_blobs = bzip2.found()
156 if 'dtrace' in get_option('trace_backends')
157 dtrace = find_program('dtrace', required: true)
158 stap = find_program('stap', required: false)
160 # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
161 # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
162 # instead. QEMU --enable-modules depends on this because the SystemTap
163 # semaphores are linked into the main binary and not the module's shared
165 add_global_arguments('-DSTAP_SDT_V2',
166 native: false, language: ['c', 'cpp', 'objc'])
174 qemu_cflags = config_host['QEMU_CFLAGS'].split()
175 qemu_cxxflags = config_host['QEMU_CXXFLAGS'].split()
176 qemu_objcflags = config_host['QEMU_OBJCFLAGS'].split()
177 qemu_ldflags = config_host['QEMU_LDFLAGS'].split()
179 if get_option('gprof')
180 qemu_cflags += ['-p']
181 qemu_cxxflags += ['-p']
182 qemu_objcflags += ['-p']
183 qemu_ldflags += ['-p']
186 # Specify linker-script with add_project_link_arguments so that it is not placed
187 # within a linker --start-group/--end-group pair
188 if get_option('fuzzing')
189 add_project_link_arguments(['-Wl,-T,',
190 (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
191 native: false, language: ['c', 'cpp', 'objc'])
193 # Specify a filter to only instrument code that is directly related to
195 configure_file(output: 'instrumentation-filter',
196 input: 'scripts/oss-fuzz/instrumentation-filter-template',
198 add_global_arguments(
199 cc.get_supported_arguments('-fsanitize-coverage-allowlist=instrumentation-filter'),
200 native: false, language: ['c', 'cpp', 'objc'])
202 if get_option('fuzzing_engine') == ''
203 # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
204 # compiled code. To build non-fuzzer binaries with --enable-fuzzing, link
205 # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
206 # unable to bind the fuzzer-related callbacks added by instrumentation.
207 add_global_arguments('-fsanitize=fuzzer-no-link',
208 native: false, language: ['c', 'cpp', 'objc'])
209 add_global_link_arguments('-fsanitize=fuzzer-no-link',
210 native: false, language: ['c', 'cpp', 'objc'])
211 # For the actual fuzzer binaries, we need to link against the libfuzzer
212 # library. They need to be configurable, to support OSS-Fuzz
213 fuzz_exe_ldflags = ['-fsanitize=fuzzer']
215 # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
216 # the needed CFLAGS have already been provided
217 fuzz_exe_ldflags = get_option('fuzzing_engine').split()
221 add_global_arguments(qemu_cflags, native: false, language: ['c'])
222 add_global_arguments(qemu_cxxflags, native: false, language: ['cpp'])
223 add_global_arguments(qemu_objcflags, native: false, language: ['objc'])
224 add_global_link_arguments(qemu_ldflags, native: false, language: ['c', 'cpp', 'objc'])
226 if targetos == 'linux'
227 add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
228 '-isystem', 'linux-headers',
229 language: ['c', 'cpp'])
232 add_project_arguments('-iquote', '.',
233 '-iquote', meson.current_source_dir(),
234 '-iquote', meson.current_source_dir() / 'include',
235 '-iquote', meson.current_source_dir() / 'disas/libvixl',
236 language: ['c', 'cpp', 'objc'])
238 link_language = meson.get_external_property('link_language', 'cpp')
239 if link_language == 'cpp'
240 add_languages('cpp', required: true, native: false)
241 cxx = meson.get_compiler('cpp')
246 if host_machine.system() == 'darwin'
247 add_languages('objc', required: false, native: false)
250 sparse = find_program('cgcc', required: get_option('sparse'))
253 command: [find_program('scripts/check_sparse.py'),
254 'compile_commands.json', sparse.full_path(), '-Wbitwise',
255 '-Wno-transparent-union', '-Wno-old-initializer',
256 '-Wno-non-pointer-null'])
259 ###########################################
260 # Target-specific checks and dependencies #
261 ###########################################
264 if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
267 #include <sys/types.h>
268 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
269 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
271 args: ['-Werror', '-fsanitize=fuzzer'])
272 error('Your compiler does not support -fsanitize=fuzzer')
276 if 'ftrace' in get_option('trace_backends') and targetos != 'linux'
277 error('ftrace is supported only on Linux')
279 if 'syslog' in get_option('trace_backends') and not cc.compiles('''
282 openlog("qemu", LOG_PID, LOG_DAEMON);
283 syslog(LOG_INFO, "configure");
286 error('syslog is not supported on this system')
289 # Miscellaneous Linux-only features
290 get_option('mpath') \
291 .require(targetos == 'linux', error_message: 'Multipath is supported only on Linux')
293 multiprocess_allowed = get_option('multiprocess') \
294 .require(targetos == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
297 have_tpm = get_option('tpm') \
298 .require(targetos != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
301 # Target-specific libraries and flags
302 libm = cc.find_library('m', required: false)
303 threads = dependency('threads')
304 util = cc.find_library('util', required: false)
310 emulator_link_args = []
316 if targetos == 'windows'
317 midl = find_program('midl', required: false)
318 widl = find_program('widl', required: false)
319 socket = cc.find_library('ws2_32')
320 winmm = cc.find_library('winmm')
322 win = import('windows')
323 version_res = win.compile_resources('version.rc',
324 depend_files: files('pc-bios/qemu-nsis.ico'),
325 include_directories: include_directories('.'))
327 elif targetos == 'darwin'
328 coref = dependency('appleframeworks', modules: 'CoreFoundation')
329 iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
330 host_dsosuf = '.dylib'
331 elif targetos == 'sunos'
332 socket = [cc.find_library('socket'),
333 cc.find_library('nsl'),
334 cc.find_library('resolv')]
335 elif targetos == 'haiku'
336 socket = [cc.find_library('posix_error_mapper'),
337 cc.find_library('network'),
338 cc.find_library('bsd')]
339 elif targetos == 'openbsd'
340 if get_option('tcg').allowed() and target_dirs.length() > 0
341 # Disable OpenBSD W^X if available
342 emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
346 # Target-specific configuration of accelerators
348 if get_option('kvm').allowed() and targetos == 'linux'
349 accelerators += 'CONFIG_KVM'
351 if get_option('xen').allowed() and 'CONFIG_XEN_BACKEND' in config_host
352 accelerators += 'CONFIG_XEN'
353 have_xen_pci_passthrough = get_option('xen_pci_passthrough').allowed() and targetos == 'linux'
355 have_xen_pci_passthrough = false
357 if get_option('whpx').allowed() and targetos == 'windows'
358 if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
359 error('WHPX requires 64-bit host')
360 elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
361 cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
362 accelerators += 'CONFIG_WHPX'
365 if get_option('hvf').allowed()
366 hvf = dependency('appleframeworks', modules: 'Hypervisor',
367 required: get_option('hvf'))
369 accelerators += 'CONFIG_HVF'
372 if get_option('hax').allowed()
373 if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
374 accelerators += 'CONFIG_HAX'
377 if targetos == 'netbsd'
378 nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
380 accelerators += 'CONFIG_NVMM'
385 if get_option('tcg').allowed()
386 if host_arch == 'unknown'
387 if get_option('tcg_interpreter')
388 warning('Unsupported CPU @0@, will use TCG with TCI (slow)'.format(cpu))
390 error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
392 elif get_option('tcg_interpreter')
393 warning('Use of the TCG interpreter is not recommended on this host')
394 warning('architecture. There is a native TCG execution backend available')
395 warning('which provides substantially better performance and reliability.')
396 warning('It is strongly recommended to remove the --enable-tcg-interpreter')
397 warning('configuration option on this architecture to use the native')
400 if get_option('tcg_interpreter')
402 elif host_arch == 'sparc64'
404 elif host_arch == 'x86_64'
406 elif host_arch == 'ppc64'
409 add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
410 language: ['c', 'cpp', 'objc'])
412 accelerators += 'CONFIG_TCG'
413 config_host += { 'CONFIG_TCG': 'y' }
416 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
417 error('KVM not available on this platform')
419 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
420 error('HVF not available on this platform')
422 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
423 error('NVMM not available on this platform')
425 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
426 error('WHPX not available on this platform')
428 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
429 if 'CONFIG_XEN' in accelerators
430 error('Xen PCI passthrough not available on this platform')
432 error('Xen PCI passthrough requested but Xen not enabled')
440 # The path to glib.h is added to all compilation commands. This was
441 # grandfathered in from the QEMU Makefiles.
442 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
443 native: false, language: ['c', 'cpp', 'objc'])
444 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
445 link_args: config_host['GLIB_LIBS'].split(),
446 version: config_host['GLIB_VERSION'])
447 # override glib dep with the configure results (for subprojects)
448 meson.override_dependency('glib-2.0', glib)
451 if 'CONFIG_GIO' in config_host
452 gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
453 link_args: config_host['GIO_LIBS'].split(),
454 version: config_host['GLIB_VERSION'])
457 if 'ust' in get_option('trace_backends')
458 lttng = dependency('lttng-ust', required: true, method: 'pkg-config',
459 kwargs: static_kwargs)
462 if have_system or have_tools
463 pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
464 method: 'pkg-config', kwargs: static_kwargs)
466 zlib = dependency('zlib', required: true, kwargs: static_kwargs)
469 if not get_option('linux_aio').auto() or have_block
470 libaio = cc.find_library('aio', has_headers: ['libaio.h'],
471 required: get_option('linux_aio'),
472 kwargs: static_kwargs)
474 linux_io_uring = not_found
475 if not get_option('linux_io_uring').auto() or have_block
476 linux_io_uring = dependency('liburing', version: '>=0.3',
477 required: get_option('linux_io_uring'),
478 method: 'pkg-config', kwargs: static_kwargs)
481 if not get_option('libnfs').auto() or have_block
482 libnfs = dependency('libnfs', version: '>=1.9.3',
483 required: get_option('libnfs'),
484 method: 'pkg-config', kwargs: static_kwargs)
489 #include <sys/types.h>
490 #ifdef CONFIG_LIBATTR
491 #include <attr/xattr.h>
493 #include <sys/xattr.h>
495 int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
498 have_old_libattr = false
499 if get_option('attr').allowed()
500 if cc.links(libattr_test)
501 libattr = declare_dependency()
503 libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
504 required: get_option('attr'),
505 kwargs: static_kwargs)
506 if libattr.found() and not \
507 cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
509 if get_option('attr').enabled()
510 error('could not link libattr')
512 warning('could not link libattr, disabling')
515 have_old_libattr = libattr.found()
520 cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
521 if cocoa.found() and get_option('sdl').enabled()
522 error('Cocoa and SDL cannot be enabled at the same time')
524 if cocoa.found() and get_option('gtk').enabled()
525 error('Cocoa and GTK+ cannot be enabled at the same time')
529 if not get_option('seccomp').auto() or have_system or have_tools
530 seccomp = dependency('libseccomp', version: '>=2.3.0',
531 required: get_option('seccomp'),
532 method: 'pkg-config', kwargs: static_kwargs)
535 libcap_ng = not_found
536 if not get_option('cap_ng').auto() or have_system or have_tools
537 libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
538 required: get_option('cap_ng'),
539 kwargs: static_kwargs)
541 if libcap_ng.found() and not cc.links('''
545 capng_capability_to_name(CAPNG_EFFECTIVE);
547 }''', dependencies: libcap_ng)
548 libcap_ng = not_found
549 if get_option('cap_ng').enabled()
550 error('could not link libcap-ng')
552 warning('could not link libcap-ng, disabling')
556 if get_option('xkbcommon').auto() and not have_system and not have_tools
557 xkbcommon = not_found
559 xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
560 method: 'pkg-config', kwargs: static_kwargs)
564 if not get_option('vde').auto() or have_system or have_tools
565 vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
566 required: get_option('vde'),
567 kwargs: static_kwargs)
569 if vde.found() and not cc.links('''
570 #include <libvdeplug.h>
573 struct vde_open_args a = {0, 0, 0};
577 }''', dependencies: vde)
579 if get_option('cap_ng').enabled()
580 error('could not link libvdeplug')
582 warning('could not link libvdeplug, disabling')
587 if not get_option('pa').auto() or (targetos == 'linux' and have_system)
588 pulse = dependency('libpulse', required: get_option('pa'),
589 method: 'pkg-config', kwargs: static_kwargs)
592 if not get_option('alsa').auto() or (targetos == 'linux' and have_system)
593 alsa = dependency('alsa', required: get_option('alsa'),
594 method: 'pkg-config', kwargs: static_kwargs)
597 if not get_option('jack').auto() or have_system
598 jack = dependency('jack', required: get_option('jack'),
599 method: 'pkg-config', kwargs: static_kwargs)
602 spice_protocol = not_found
603 if not get_option('spice_protocol').auto() or have_system
604 spice_protocol = dependency('spice-protocol', version: '>=0.12.3',
605 required: get_option('spice_protocol'),
606 method: 'pkg-config', kwargs: static_kwargs)
609 if not get_option('spice').auto() or have_system
610 spice = dependency('spice-server', version: '>=0.12.5',
611 required: get_option('spice'),
612 method: 'pkg-config', kwargs: static_kwargs)
614 spice_headers = spice.partial_dependency(compile_args: true, includes: true)
616 rt = cc.find_library('rt', required: false)
619 if not get_option('libiscsi').auto() or have_block
620 libiscsi = dependency('libiscsi', version: '>=1.9.0',
621 required: get_option('libiscsi'),
622 method: 'pkg-config', kwargs: static_kwargs)
625 if not get_option('zstd').auto() or have_block
626 zstd = dependency('libzstd', version: '>=1.4.0',
627 required: get_option('zstd'),
628 method: 'pkg-config', kwargs: static_kwargs)
632 have_vhost_user_gpu = have_tools and targetos == 'linux' and pixman.found()
633 if not get_option('virglrenderer').auto() or have_system or have_vhost_user_gpu
634 virgl = dependency('virglrenderer',
635 method: 'pkg-config',
636 required: get_option('virglrenderer'),
637 kwargs: static_kwargs)
640 if not get_option('curl').auto() or have_block
641 curl = dependency('libcurl', version: '>=7.29.0',
642 method: 'pkg-config',
643 required: get_option('curl'),
644 kwargs: static_kwargs)
647 if targetos == 'linux' and (have_system or have_tools)
648 libudev = dependency('libudev',
649 method: 'pkg-config',
650 required: get_option('libudev'),
651 kwargs: static_kwargs)
654 mpathlibs = [libudev]
655 mpathpersist = not_found
656 mpathpersist_new_api = false
657 if targetos == 'linux' and have_tools and get_option('mpath').allowed()
658 mpath_test_source_new = '''
660 #include <mpath_persist.h>
661 unsigned mpath_mx_alloc_len = 1024;
663 static struct config *multipath_conf;
664 extern struct udev *udev;
665 extern struct config *get_multipath_config(void);
666 extern void put_multipath_config(struct config *conf);
668 struct config *get_multipath_config(void) { return multipath_conf; }
669 void put_multipath_config(struct config *conf) { }
672 multipath_conf = mpath_lib_init();
675 mpath_test_source_old = '''
677 #include <mpath_persist.h>
678 unsigned mpath_mx_alloc_len = 1024;
681 struct udev *udev = udev_new();
682 mpath_lib_init(udev);
685 libmpathpersist = cc.find_library('mpathpersist',
686 required: get_option('mpath'),
687 kwargs: static_kwargs)
688 if libmpathpersist.found()
689 mpathlibs += libmpathpersist
691 mpathlibs += cc.find_library('devmapper',
692 required: get_option('mpath'),
693 kwargs: static_kwargs)
695 mpathlibs += cc.find_library('multipath',
696 required: get_option('mpath'),
697 kwargs: static_kwargs)
698 foreach lib: mpathlibs
704 if mpathlibs.length() == 0
705 msg = 'Dependencies missing for libmpathpersist'
706 elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
707 mpathpersist = declare_dependency(dependencies: mpathlibs)
708 mpathpersist_new_api = true
709 elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
710 mpathpersist = declare_dependency(dependencies: mpathlibs)
712 msg = 'Cannot detect libmpathpersist API'
714 if not mpathpersist.found()
715 if get_option('mpath').enabled()
718 warning(msg + ', disabling')
726 if have_system and get_option('curses').allowed()
728 #if defined(__APPLE__) || defined(__OpenBSD__)
729 #define _XOPEN_SOURCE_EXTENDED 1
736 setlocale(LC_ALL, "");
738 addwstr(L"wide chars\n");
740 add_wch(WACS_DEGREE);
744 curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
745 foreach curses_dep : curses_dep_list
746 if not curses.found()
747 curses = dependency(curses_dep,
749 method: 'pkg-config',
750 kwargs: static_kwargs)
753 msg = get_option('curses').enabled() ? 'curses library not found' : ''
754 curses_compile_args = ['-DNCURSES_WIDECHAR=1']
756 if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
757 curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
759 msg = 'curses package not usable'
763 if not curses.found()
764 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
765 if targetos != 'windows' and not has_curses_h
766 message('Trying with /usr/include/ncursesw')
767 curses_compile_args += ['-I/usr/include/ncursesw']
768 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
771 curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
772 foreach curses_libname : curses_libname_list
773 libcurses = cc.find_library(curses_libname,
775 kwargs: static_kwargs)
777 if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
778 curses = declare_dependency(compile_args: curses_compile_args,
779 dependencies: [libcurses])
782 msg = 'curses library not usable'
788 if get_option('iconv').allowed()
789 foreach link_args : [ ['-liconv'], [] ]
790 # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
791 # We need to use libiconv if available because mixing libiconv's headers with
792 # the system libc does not work.
793 # However, without adding glib to the dependencies -L/usr/local/lib will not be
794 # included in the command line and libiconv will not be found.
798 iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
799 return conv != (iconv_t) -1;
800 }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
801 iconv = declare_dependency(link_args: link_args, dependencies: glib)
806 if curses.found() and not iconv.found()
807 if get_option('iconv').enabled()
808 error('iconv not available')
810 msg = 'iconv required for curses UI but not available'
813 if not curses.found() and msg != ''
814 if get_option('curses').enabled()
817 warning(msg + ', disabling')
823 if not get_option('brlapi').auto() or have_system
824 brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
825 required: get_option('brlapi'),
826 kwargs: static_kwargs)
827 if brlapi.found() and not cc.links('''
830 int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
832 if get_option('brlapi').enabled()
833 error('could not link brlapi')
835 warning('could not link brlapi, disabling')
841 if not get_option('sdl').auto() or (have_system and not cocoa.found())
842 sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
843 sdl_image = not_found
846 # work around 2.0.8 bug
847 sdl = declare_dependency(compile_args: '-Wno-undef',
849 sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
850 method: 'pkg-config', kwargs: static_kwargs)
852 if get_option('sdl_image').enabled()
853 error('sdl-image required, but SDL was @0@'.format(
854 get_option('sdl').disabled() ? 'disabled' : 'not found'))
856 sdl_image = not_found
860 if not get_option('rbd').auto() or have_block
861 librados = cc.find_library('rados', required: get_option('rbd'),
862 kwargs: static_kwargs)
863 librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
864 required: get_option('rbd'),
865 kwargs: static_kwargs)
866 if librados.found() and librbd.found()
869 #include <rbd/librbd.h>
872 rados_create(&cluster, NULL);
873 #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
877 }''', dependencies: [librbd, librados])
878 rbd = declare_dependency(dependencies: [librbd, librados])
879 elif get_option('rbd').enabled()
880 error('librbd >= 1.12.0 required')
882 warning('librbd >= 1.12.0 not found, disabling')
887 glusterfs = not_found
888 glusterfs_ftruncate_has_stat = false
889 glusterfs_iocb_has_stat = false
890 if not get_option('glusterfs').auto() or have_block
891 glusterfs = dependency('glusterfs-api', version: '>=3',
892 required: get_option('glusterfs'),
893 method: 'pkg-config', kwargs: static_kwargs)
895 glusterfs_ftruncate_has_stat = cc.links('''
896 #include <glusterfs/api/glfs.h>
901 /* new glfs_ftruncate() passes two additional args */
902 return glfs_ftruncate(NULL, 0, NULL, NULL);
904 ''', dependencies: glusterfs)
905 glusterfs_iocb_has_stat = cc.links('''
906 #include <glusterfs/api/glfs.h>
908 /* new glfs_io_cbk() passes two additional glfs_stat structs */
910 glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
916 glfs_io_cbk iocb = &glusterfs_iocb;
917 iocb(NULL, 0 , NULL, NULL, NULL);
920 ''', dependencies: glusterfs)
925 if not get_option('libssh').auto() or have_block
926 libssh = dependency('libssh', version: '>=0.8.7',
927 method: 'pkg-config',
928 required: get_option('libssh'),
929 kwargs: static_kwargs)
933 if not get_option('bzip2').auto() or have_block
934 libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
935 required: get_option('bzip2'),
936 kwargs: static_kwargs)
937 if libbzip2.found() and not cc.links('''
939 int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
941 if get_option('bzip2').enabled()
942 error('could not link libbzip2')
944 warning('could not link libbzip2, disabling')
950 if not get_option('lzfse').auto() or have_block
951 liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
952 required: get_option('lzfse'),
953 kwargs: static_kwargs)
955 if liblzfse.found() and not cc.links('''
957 int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
959 if get_option('lzfse').enabled()
960 error('could not link liblzfse')
962 warning('could not link liblzfse, disabling')
967 if get_option('oss').allowed() and have_system
968 if not cc.has_header('sys/soundcard.h')
970 elif targetos == 'netbsd'
971 oss = cc.find_library('ossaudio', required: get_option('oss'),
972 kwargs: static_kwargs)
974 oss = declare_dependency()
978 if get_option('oss').enabled()
979 error('OSS not found')
984 if not get_option('dsound').auto() or (targetos == 'windows' and have_system)
985 if cc.has_header('dsound.h')
986 dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
989 if not dsound.found()
990 if get_option('dsound').enabled()
991 error('DirectSound not found')
996 coreaudio = not_found
997 if not get_option('coreaudio').auto() or (targetos == 'darwin' and have_system)
998 coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
999 required: get_option('coreaudio'))
1003 if 'CONFIG_OPENGL' in config_host
1004 opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
1005 link_args: config_host['OPENGL_LIBS'].split())
1008 if (have_system or have_tools) and (virgl.found() or opengl.found())
1009 gbm = dependency('gbm', method: 'pkg-config', required: false,
1010 kwargs: static_kwargs)
1012 have_vhost_user_gpu = have_vhost_user_gpu and virgl.found() and gbm.found()
1015 gnutls_crypto = not_found
1016 if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
1017 # For general TLS support our min gnutls matches
1018 # that implied by our platform support matrix
1020 # For the crypto backends, we look for a newer
1023 # Version 3.6.8 is needed to get XTS
1024 # Version 3.6.13 is needed to get PBKDF
1025 # Version 3.6.14 is needed to get HW accelerated XTS
1027 # If newer enough gnutls isn't available, we can
1028 # still use a different crypto backend to satisfy
1029 # the platform support requirements
1030 gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
1031 method: 'pkg-config',
1033 kwargs: static_kwargs)
1034 if gnutls_crypto.found()
1035 gnutls = gnutls_crypto
1037 # Our min version if all we need is TLS
1038 gnutls = dependency('gnutls', version: '>=3.5.18',
1039 method: 'pkg-config',
1040 required: get_option('gnutls'),
1041 kwargs: static_kwargs)
1045 # We prefer use of gnutls for crypto, unless the options
1046 # explicitly asked for nettle or gcrypt.
1048 # If gnutls isn't available for crypto, then we'll prefer
1049 # gcrypt over nettle for performance reasons.
1054 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
1055 error('Only one of gcrypt & nettle can be enabled')
1058 # Explicit nettle/gcrypt request, so ignore gnutls for crypto
1059 if get_option('nettle').enabled() or get_option('gcrypt').enabled()
1060 gnutls_crypto = not_found
1063 if not gnutls_crypto.found()
1064 if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
1065 gcrypt = dependency('libgcrypt', version: '>=1.8',
1066 method: 'config-tool',
1067 required: get_option('gcrypt'),
1068 kwargs: static_kwargs)
1069 # Debian has removed -lgpg-error from libgcrypt-config
1070 # as it "spreads unnecessary dependencies" which in
1071 # turn breaks static builds...
1072 if gcrypt.found() and enable_static
1073 gcrypt = declare_dependency(dependencies: [
1075 cc.find_library('gpg-error', required: true, kwargs: static_kwargs)])
1078 if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
1079 nettle = dependency('nettle', version: '>=3.4',
1080 method: 'pkg-config',
1081 required: get_option('nettle'),
1082 kwargs: static_kwargs)
1083 if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
1092 if not get_option('gtk').auto() or (have_system and not cocoa.found())
1093 gtk = dependency('gtk+-3.0', version: '>=3.22.0',
1094 method: 'pkg-config',
1095 required: get_option('gtk'),
1096 kwargs: static_kwargs)
1098 gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
1099 method: 'pkg-config',
1101 kwargs: static_kwargs)
1102 gtk = declare_dependency(dependencies: [gtk, gtkx11])
1104 if not get_option('vte').auto() or have_system
1105 vte = dependency('vte-2.91',
1106 method: 'pkg-config',
1107 required: get_option('vte'),
1108 kwargs: static_kwargs)
1115 x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
1116 kwargs: static_kwargs)
1122 if get_option('vnc').allowed() and have_system
1123 vnc = declare_dependency() # dummy dependency
1124 png = dependency('libpng', required: get_option('vnc_png'),
1125 method: 'pkg-config', kwargs: static_kwargs)
1126 jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
1127 method: 'pkg-config', kwargs: static_kwargs)
1128 sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
1129 required: get_option('vnc_sasl'),
1130 kwargs: static_kwargs)
1132 sasl = declare_dependency(dependencies: sasl,
1133 compile_args: '-DSTRUCT_IOVEC_DEFINED')
1138 if not get_option('auth_pam').auto() or have_system
1139 pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
1140 required: get_option('auth_pam'),
1141 kwargs: static_kwargs)
1143 if pam.found() and not cc.links('''
1145 #include <security/pam_appl.h>
1147 const char *service_name = "qemu";
1148 const char *user = "frank";
1149 const struct pam_conv pam_conv = { 0 };
1150 pam_handle_t *pamh = NULL;
1151 pam_start(service_name, user, &pam_conv, &pamh);
1153 }''', dependencies: pam)
1155 if get_option('auth_pam').enabled()
1156 error('could not link libpam')
1158 warning('could not link libpam, disabling')
1163 if not get_option('snappy').auto() or have_system
1164 snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
1165 required: get_option('snappy'),
1166 kwargs: static_kwargs)
1168 if snappy.found() and not linker.links('''
1169 #include <snappy-c.h>
1170 int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
1172 if get_option('snappy').enabled()
1173 error('could not link libsnappy')
1175 warning('could not link libsnappy, disabling')
1180 if not get_option('lzo').auto() or have_system
1181 lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1182 required: get_option('lzo'),
1183 kwargs: static_kwargs)
1185 if lzo.found() and not cc.links('''
1186 #include <lzo/lzo1x.h>
1187 int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1189 if get_option('lzo').enabled()
1190 error('could not link liblzo2')
1192 warning('could not link liblzo2, disabling')
1197 if not get_option('numa').auto() or have_system or have_tools
1198 numa = cc.find_library('numa', has_headers: ['numa.h'],
1199 required: get_option('numa'),
1200 kwargs: static_kwargs)
1202 if numa.found() and not cc.links('''
1204 int main(void) { return numa_available(); }
1205 ''', dependencies: numa)
1207 if get_option('numa').enabled()
1208 error('could not link numa')
1210 warning('could not link numa, disabling')
1215 if 'CONFIG_RDMA' in config_host
1216 rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
1219 if 'CONFIG_XEN_BACKEND' in config_host
1220 xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
1221 link_args: config_host['XEN_LIBS'].split())
1224 if not get_option('smartcard').auto() or have_system
1225 cacard = dependency('libcacard', required: get_option('smartcard'),
1226 version: '>=2.5.1', method: 'pkg-config',
1227 kwargs: static_kwargs)
1231 u2f = dependency('u2f-emu', required: get_option('u2f'),
1232 method: 'pkg-config',
1233 kwargs: static_kwargs)
1235 usbredir = not_found
1236 if not get_option('usb_redir').auto() or have_system
1237 usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1238 version: '>=0.6', method: 'pkg-config',
1239 kwargs: static_kwargs)
1242 if not get_option('libusb').auto() or have_system
1243 libusb = dependency('libusb-1.0', required: get_option('libusb'),
1244 version: '>=1.0.13', method: 'pkg-config',
1245 kwargs: static_kwargs)
1249 if not get_option('libpmem').auto() or have_system
1250 libpmem = dependency('libpmem', required: get_option('libpmem'),
1251 method: 'pkg-config', kwargs: static_kwargs)
1253 libdaxctl = not_found
1254 if not get_option('libdaxctl').auto() or have_system
1255 libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1256 version: '>=57', method: 'pkg-config',
1257 kwargs: static_kwargs)
1261 tasn1 = dependency('libtasn1',
1262 method: 'pkg-config',
1263 kwargs: static_kwargs)
1265 keyutils = dependency('libkeyutils', required: false,
1266 method: 'pkg-config', kwargs: static_kwargs)
1268 has_gettid = cc.has_function('gettid')
1271 selinux = dependency('libselinux',
1272 required: get_option('selinux'),
1273 method: 'pkg-config', kwargs: static_kwargs)
1278 if get_option('malloc') == 'system'
1280 get_option('malloc_trim').allowed() and \
1281 cc.links('''#include <malloc.h>
1282 int main(void) { malloc_trim(0); return 0; }''')
1284 has_malloc_trim = false
1285 malloc = cc.find_library(get_option('malloc'), required: true)
1287 if not has_malloc_trim and get_option('malloc_trim').enabled()
1288 if get_option('malloc') == 'system'
1289 error('malloc_trim not available on this platform.')
1291 error('malloc_trim not available with non-libc memory allocator')
1295 # Check whether the glibc provides statx()
1297 gnu_source_prefix = '''
1302 statx_test = gnu_source_prefix + '''
1303 #include <sys/stat.h>
1305 struct statx statxbuf;
1306 statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
1310 has_statx = cc.links(statx_test)
1312 # Check whether statx() provides mount ID information
1314 statx_mnt_id_test = gnu_source_prefix + '''
1315 #include <sys/stat.h>
1317 struct statx statxbuf;
1318 statx(0, "", 0, STATX_BASIC_STATS | STATX_MNT_ID, &statxbuf);
1319 return statxbuf.stx_mnt_id;
1322 has_statx_mnt_id = cc.links(statx_mnt_id_test)
1324 have_vhost_user_blk_server = get_option('vhost_user_blk_server') \
1325 .require(targetos == 'linux',
1326 error_message: 'vhost_user_blk_server requires linux') \
1327 .require('CONFIG_VHOST_USER' in config_host,
1328 error_message: 'vhost_user_blk_server requires vhost-user support') \
1329 .disable_auto_if(not have_system) \
1332 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1333 error('Cannot enable fuse-lseek while fuse is disabled')
1336 fuse = dependency('fuse3', required: get_option('fuse'),
1337 version: '>=3.1', method: 'pkg-config',
1338 kwargs: static_kwargs)
1340 fuse_lseek = not_found
1341 if get_option('fuse_lseek').allowed()
1342 if fuse.version().version_compare('>=3.8')
1344 fuse_lseek = declare_dependency()
1345 elif get_option('fuse_lseek').enabled()
1347 error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1349 error('fuse-lseek requires libfuse, which was not found')
1355 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1356 if libbpf.found() and not cc.links('''
1357 #include <bpf/libbpf.h>
1360 bpf_object__destroy_skeleton(NULL);
1362 }''', dependencies: libbpf)
1364 if get_option('bpf').enabled()
1365 error('libbpf skeleton test failed')
1367 warning('libbpf skeleton test failed, disabling')
1375 audio_drivers_selected = []
1377 audio_drivers_available = {
1378 'alsa': alsa.found(),
1379 'coreaudio': coreaudio.found(),
1380 'dsound': dsound.found(),
1381 'jack': jack.found(),
1383 'pa': pulse.found(),
1386 foreach k, v: audio_drivers_available
1387 config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
1390 # Default to native drivers first, OSS second, SDL third
1391 audio_drivers_priority = \
1392 [ 'pa', 'coreaudio', 'dsound', 'oss' ] + \
1393 (targetos == 'linux' ? [] : [ 'sdl' ])
1394 audio_drivers_default = []
1395 foreach k: audio_drivers_priority
1396 if audio_drivers_available[k]
1397 audio_drivers_default += k
1401 foreach k: get_option('audio_drv_list')
1403 audio_drivers_selected += audio_drivers_default
1404 elif not audio_drivers_available[k]
1405 error('Audio driver "@0@" not available.'.format(k))
1407 audio_drivers_selected += k
1411 config_host_data.set('CONFIG_AUDIO_DRIVERS',
1412 '"' + '", "'.join(audio_drivers_selected) + '", ')
1414 if get_option('cfi')
1416 # Check for dependency on LTO
1417 if not get_option('b_lto')
1418 error('Selected Control-Flow Integrity but LTO is disabled')
1420 if config_host.has_key('CONFIG_MODULES')
1421 error('Selected Control-Flow Integrity is not compatible with modules')
1423 # Check for cfi flags. CFI requires LTO so we can't use
1424 # get_supported_arguments, but need a more complex "compiles" which allows
1426 if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1427 args: ['-flto', '-fsanitize=cfi-icall'] )
1428 cfi_flags += '-fsanitize=cfi-icall'
1430 error('-fsanitize=cfi-icall is not supported by the compiler')
1432 if cc.compiles('int main () { return 0; }',
1433 name: '-fsanitize-cfi-icall-generalize-pointers',
1434 args: ['-flto', '-fsanitize=cfi-icall',
1435 '-fsanitize-cfi-icall-generalize-pointers'] )
1436 cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1438 error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1440 if get_option('cfi_debug')
1441 if cc.compiles('int main () { return 0; }',
1442 name: '-fno-sanitize-trap=cfi-icall',
1443 args: ['-flto', '-fsanitize=cfi-icall',
1444 '-fno-sanitize-trap=cfi-icall'] )
1445 cfi_flags += '-fno-sanitize-trap=cfi-icall'
1447 error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1450 add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1451 add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1454 have_host_block_device = (targetos != 'darwin' or
1455 cc.has_header('IOKit/storage/IOMedia.h'))
1457 # FIXME enable_modules shouldn't be necessary, but: https://github.com/mesonbuild/meson/issues/8333
1458 dbus_display = get_option('dbus_display') \
1459 .require(gio.version().version_compare('>=2.64'),
1460 error_message: '-display dbus requires glib>=2.64') \
1461 .require(enable_modules,
1462 error_message: '-display dbus requires --enable-modules') \
1463 .require(config_host.has_key('GDBUS_CODEGEN'),
1464 error_message: '-display dbus requires gdbus-codegen') \
1467 have_virtfs = get_option('virtfs') \
1468 .require(targetos == 'linux' or targetos == 'darwin',
1469 error_message: 'virtio-9p (virtfs) requires Linux or macOS') \
1470 .require(targetos == 'linux' or cc.has_function('pthread_fchdir_np'),
1471 error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \
1472 .require(targetos == 'darwin' or (libattr.found() and libcap_ng.found()),
1473 error_message: 'virtio-9p (virtfs) on Linux requires libcap-ng-devel and libattr-devel') \
1474 .disable_auto_if(not have_tools and not have_system) \
1477 have_virtfs_proxy_helper = targetos != 'darwin' and have_virtfs and have_tools
1479 foreach k : get_option('trace_backends')
1480 config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
1482 config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
1483 if get_option('iasl') != ''
1484 config_host_data.set_quoted('CONFIG_IASL', get_option('iasl'))
1486 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1487 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1488 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1489 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1490 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1491 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
1492 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1493 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1494 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1495 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1496 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1497 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1499 have_slirp_smbd = get_option('slirp_smbd') \
1500 .require(targetos != 'windows', error_message: 'Host smbd not supported on this platform.') \
1503 smbd_path = get_option('smbd')
1505 smbd_path = (targetos == 'solaris' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd')
1507 config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path)
1510 config_host_data.set('HOST_' + host_arch.to_upper(), 1)
1512 config_host_data.set('CONFIG_ATTR', libattr.found())
1513 config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools'))
1514 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1515 config_host_data.set('CONFIG_COCOA', cocoa.found())
1516 config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
1517 config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
1518 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1519 config_host_data.set('CONFIG_LZO', lzo.found())
1520 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1521 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1522 config_host_data.set('CONFIG_CURL', curl.found())
1523 config_host_data.set('CONFIG_CURSES', curses.found())
1524 config_host_data.set('CONFIG_GBM', gbm.found())
1525 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1526 if glusterfs.found()
1527 config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1528 config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1529 config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1530 config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1531 config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1532 config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1534 config_host_data.set('CONFIG_GTK', gtk.found())
1535 config_host_data.set('CONFIG_VTE', vte.found())
1536 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1537 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1538 config_host_data.set('CONFIG_EBPF', libbpf.found())
1539 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
1540 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1541 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1542 config_host_data.set('CONFIG_LIBSSH', libssh.found())
1543 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
1544 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
1545 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
1546 config_host_data.set('CONFIG_NUMA', numa.found())
1547 config_host_data.set('CONFIG_PROFILER', get_option('profiler'))
1548 config_host_data.set('CONFIG_RBD', rbd.found())
1549 config_host_data.set('CONFIG_SDL', sdl.found())
1550 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1551 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1552 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1553 config_host_data.set('CONFIG_TPM', have_tpm)
1554 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
1555 config_host_data.set('CONFIG_VDE', vde.found())
1556 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1557 config_host_data.set('CONFIG_VNC', vnc.found())
1558 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1559 config_host_data.set('CONFIG_VNC_PNG', png.found())
1560 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1561 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1562 config_host_data.set('CONFIG_VTE', vte.found())
1563 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1564 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1565 config_host_data.set('CONFIG_GETTID', has_gettid)
1566 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
1567 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
1568 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
1569 config_host_data.set('CONFIG_NETTLE', nettle.found())
1570 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
1571 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1572 config_host_data.set('CONFIG_STATX', has_statx)
1573 config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id)
1574 config_host_data.set('CONFIG_ZSTD', zstd.found())
1575 config_host_data.set('CONFIG_FUSE', fuse.found())
1576 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1577 config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
1578 if spice_protocol.found()
1579 config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
1580 config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
1581 config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
1583 config_host_data.set('CONFIG_SPICE', spice.found())
1584 config_host_data.set('CONFIG_X11', x11.found())
1585 config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
1586 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1587 config_host_data.set('CONFIG_SELINUX', selinux.found())
1588 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1589 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1590 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1591 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1593 config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
1594 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
1595 config_host_data.set('HOST_WORDS_BIGENDIAN', host_machine.endian() == 'big')
1597 have_coroutine_pool = get_option('coroutine_pool')
1598 if get_option('debug_stack_usage') and have_coroutine_pool
1599 message('Disabling coroutine pool to measure stack usage')
1600 have_coroutine_pool = false
1602 config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool)
1603 config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
1604 config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
1605 config_host_data.set('CONFIG_GPROF', get_option('gprof'))
1606 config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
1607 config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
1608 config_host_data.set('CONFIG_REPLICATION', get_option('live_block_migration').allowed())
1611 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1612 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1613 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1614 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1615 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1616 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1617 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1618 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1619 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1622 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1623 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1624 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1625 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1626 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1627 # Note that we need to specify prefix: here to avoid incorrectly
1628 # thinking that Windows has posix_memalign()
1629 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
1630 config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
1631 config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
1632 config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
1633 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
1634 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1635 config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
1636 config_host_data.set('CONFIG_SEM_TIMEDWAIT', cc.has_function('sem_timedwait', dependencies: threads))
1637 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
1638 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
1639 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
1640 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
1641 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
1642 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
1643 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
1644 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
1645 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1647 config_host_data.set('HAVE_IBV_ADVISE_MR',
1648 cc.has_function('ibv_advise_mr',
1649 args: config_host['RDMA_LIBS'].split(),
1650 prefix: '#include <infiniband/verbs.h>'))
1654 config_host_data.set('CONFIG_BYTESWAP_H',
1655 cc.has_header_symbol('byteswap.h', 'bswap_32'))
1656 config_host_data.set('CONFIG_EPOLL_CREATE1',
1657 cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
1658 config_host_data.set('CONFIG_HAS_ENVIRON',
1659 cc.has_header_symbol('unistd.h', 'environ', prefix: gnu_source_prefix))
1660 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
1661 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
1662 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
1663 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
1664 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
1665 config_host_data.set('CONFIG_FIEMAP',
1666 cc.has_header('linux/fiemap.h') and
1667 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
1668 config_host_data.set('CONFIG_GETRANDOM',
1669 cc.has_function('getrandom') and
1670 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
1671 config_host_data.set('CONFIG_INOTIFY',
1672 cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
1673 config_host_data.set('CONFIG_INOTIFY1',
1674 cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
1675 config_host_data.set('CONFIG_MACHINE_BSWAP_H',
1676 cc.has_header_symbol('machine/bswap.h', 'bswap32',
1677 prefix: '''#include <sys/endian.h>
1678 #include <sys/types.h>'''))
1679 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
1680 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
1681 config_host_data.set('CONFIG_RTNETLINK',
1682 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
1683 config_host_data.set('CONFIG_SYSMACROS',
1684 cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1685 config_host_data.set('HAVE_OPTRESET',
1686 cc.has_header_symbol('getopt.h', 'optreset'))
1687 config_host_data.set('HAVE_IPPROTO_MPTCP',
1688 cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
1691 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
1692 cc.has_member('struct sigevent', 'sigev_notify_thread_id',
1693 prefix: '#include <signal.h>'))
1694 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
1695 cc.has_member('struct stat', 'st_atim',
1696 prefix: '#include <sys/stat.h>'))
1699 config_host_data.set('CONFIG_IOVEC',
1700 cc.has_type('struct iovec',
1701 prefix: '#include <sys/uio.h>'))
1702 config_host_data.set('HAVE_UTMPX',
1703 cc.has_type('struct utmpx',
1704 prefix: '#include <utmpx.h>'))
1706 config_host_data.set('CONFIG_EVENTFD', cc.links('''
1707 #include <sys/eventfd.h>
1708 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
1709 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
1712 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
1713 return fdatasync(0);
1715 #error Not supported
1718 config_host_data.set('CONFIG_MADVISE', cc.links(gnu_source_prefix + '''
1719 #include <sys/types.h>
1720 #include <sys/mman.h>
1722 int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }'''))
1723 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
1724 #include <sys/mman.h>
1725 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
1726 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
1728 #if !defined(AT_EMPTY_PATH)
1729 # error missing definition
1731 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
1733 config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
1740 return pipe2(pipefd, O_CLOEXEC);
1742 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
1743 #include <sys/mman.h>
1745 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
1747 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
1748 #include <pthread.h>
1750 static void *f(void *p) { return NULL; }
1754 pthread_create(&thread, 0, f, 0);
1755 pthread_setname_np(thread, "QEMU");
1757 }''', dependencies: threads))
1758 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
1759 #include <pthread.h>
1761 static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
1765 pthread_create(&thread, 0, f, 0);
1767 }''', dependencies: threads))
1769 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
1770 #include <sys/signalfd.h>
1772 int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
1773 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
1781 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
1782 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
1786 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
1787 #include <sys/mman.h>
1788 int main(int argc, char *argv[]) {
1789 return mlockall(MCL_FUTURE);
1793 if get_option('l2tpv3').allowed() and have_system
1794 have_l2tpv3 = cc.has_type('struct mmsghdr',
1795 prefix: gnu_source_prefix + '''
1796 #include <sys/socket.h>
1797 #include <linux/ip.h>''')
1799 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
1802 if get_option('netmap').allowed() and have_system
1803 have_netmap = cc.compiles('''
1804 #include <inttypes.h>
1806 #include <net/netmap.h>
1807 #include <net/netmap_user.h>
1808 #if (NETMAP_API < 11) || (NETMAP_API > 15)
1811 int main(void) { return 0; }''')
1812 if not have_netmap and get_option('netmap').enabled()
1813 error('Netmap headers not available')
1816 config_host_data.set('CONFIG_NETMAP', have_netmap)
1818 # Work around a system header bug with some kernel/XFS header
1819 # versions where they both try to define 'struct fsxattr':
1820 # xfs headers will not try to redefine structs from linux headers
1821 # if this macro is set.
1822 config_host_data.set('HAVE_FSXATTR', cc.links('''
1823 #include <linux/fs.h>
1829 # Some versions of Mac OS X incorrectly define SIZE_MAX
1830 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
1833 int main(int argc, char *argv[]) {
1834 return printf("%zu", SIZE_MAX);
1835 }''', args: ['-Werror']))
1837 # See if 64-bit atomic operations are supported.
1838 # Note that without __atomic builtins, we can only
1839 # assume atomic loads/stores max at pointer size.
1840 config_host_data.set('CONFIG_ATOMIC64', cc.links('''
1844 uint64_t x = 0, y = 0;
1845 y = __atomic_load_n(&x, __ATOMIC_RELAXED);
1846 __atomic_store_n(&x, y, __ATOMIC_RELAXED);
1847 __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
1848 __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
1849 __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
1853 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
1854 #include <sys/auxv.h>
1856 return getauxval(AT_HWCAP) == 0;
1859 have_cpuid_h = cc.links('''
1862 unsigned a, b, c, d;
1863 unsigned max = __get_cpuid_max(0, 0);
1866 __cpuid(1, a, b, c, d);
1870 __cpuid_count(7, 0, a, b, c, d);
1875 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
1877 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
1878 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
1879 .require(cc.links('''
1880 #pragma GCC push_options
1881 #pragma GCC target("avx2")
1883 #include <immintrin.h>
1884 static int bar(void *a) {
1885 __m256i x = *(__m256i *)a;
1886 return _mm256_testz_si256(x, x);
1888 int main(int argc, char *argv[]) { return bar(argv[0]); }
1889 '''), error_message: 'AVX2 not available').allowed())
1891 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
1892 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
1893 .require(cc.links('''
1894 #pragma GCC push_options
1895 #pragma GCC target("avx512f")
1897 #include <immintrin.h>
1898 static int bar(void *a) {
1899 __m512i x = *(__m512i *)a;
1900 return _mm512_test_epi64_mask(x, x);
1902 int main(int argc, char *argv[]) { return bar(argv[0]); }
1903 '''), error_message: 'AVX512F not available').allowed())
1905 if get_option('membarrier').disabled()
1906 have_membarrier = false
1907 elif targetos == 'windows'
1908 have_membarrier = true
1909 elif targetos == 'linux'
1910 have_membarrier = cc.compiles('''
1911 #include <linux/membarrier.h>
1912 #include <sys/syscall.h>
1916 syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
1917 syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
1921 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
1922 .require(have_membarrier, error_message: 'membarrier system call not available') \
1925 have_afalg = get_option('crypto_afalg') \
1926 .require(cc.compiles(gnu_source_prefix + '''
1928 #include <sys/types.h>
1929 #include <sys/socket.h>
1930 #include <linux/if_alg.h>
1933 sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
1936 '''), error_message: 'AF_ALG requested but could not be detected').allowed()
1937 config_host_data.set('CONFIG_AF_ALG', have_afalg)
1939 config_host_data.set('CONFIG_AF_VSOCK', cc.compiles(gnu_source_prefix + '''
1941 #include <sys/types.h>
1942 #include <sys/socket.h>
1943 #if !defined(AF_VSOCK)
1944 # error missing AF_VSOCK flag
1946 #include <linux/vm_sockets.h>
1949 struct sockaddr_vm svm;
1950 socklen_t len = sizeof(svm);
1951 sock = socket(AF_VSOCK, SOCK_STREAM, 0);
1952 ret = getpeername(sock, (struct sockaddr *)&svm, &len);
1953 if ((ret == -1) && (errno == ENOTCONN)) {
1960 have_vss_sdk = false # old xp/2003 SDK
1961 if targetos == 'windows' and link_language == 'cpp'
1962 have_vss = cxx.compiles('''
1963 #define __MIDL_user_allocate_free_DEFINED__
1965 int main(void) { return VSS_CTX_BACKUP; }''')
1966 have_vss_sdk = cxx.has_header('vscoordint.h')
1968 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
1970 have_ntddscsi = false
1971 if targetos == 'windows'
1972 have_ntddscsi = cc.compiles('''
1973 #include <windows.h>
1974 #include <ntddscsi.h>
1976 #if !defined(IOCTL_SCSI_GET_ADDRESS)
1977 #error Missing required ioctl definitions
1979 SCSI_ADDRESS addr = { .Lun = 0, .TargetId = 0, .PathId = 0 };
1984 config_host_data.set('HAVE_NTDDSCSI', have_ntddscsi)
1986 ignored = ['CONFIG_QEMU_INTERP_PREFIX', # actually per-target
1988 arrays = ['CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1989 foreach k, v: config_host
1990 if ignored.contains(k)
1992 elif arrays.contains(k)
1994 v = '"' + '", "'.join(v.split()) + '", '
1996 config_host_data.set(k, v)
1997 elif k.startswith('CONFIG_')
1998 config_host_data.set(k, v == 'y' ? 1 : v)
2002 ########################
2003 # Target configuration #
2004 ########################
2006 minikconf = find_program('scripts/minikconf.py')
2008 config_all_devices = {}
2009 config_all_disas = {}
2010 config_devices_mak_list = []
2011 config_devices_h = {}
2012 config_target_h = {}
2013 config_target_mak = {}
2016 'alpha' : ['CONFIG_ALPHA_DIS'],
2017 'arm' : ['CONFIG_ARM_DIS'],
2018 'avr' : ['CONFIG_AVR_DIS'],
2019 'cris' : ['CONFIG_CRIS_DIS'],
2020 'hexagon' : ['CONFIG_HEXAGON_DIS'],
2021 'hppa' : ['CONFIG_HPPA_DIS'],
2022 'i386' : ['CONFIG_I386_DIS'],
2023 'x86_64' : ['CONFIG_I386_DIS'],
2024 'm68k' : ['CONFIG_M68K_DIS'],
2025 'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2026 'mips' : ['CONFIG_MIPS_DIS'],
2027 'nios2' : ['CONFIG_NIOS2_DIS'],
2028 'or1k' : ['CONFIG_OPENRISC_DIS'],
2029 'ppc' : ['CONFIG_PPC_DIS'],
2030 'riscv' : ['CONFIG_RISCV_DIS'],
2031 'rx' : ['CONFIG_RX_DIS'],
2032 's390' : ['CONFIG_S390_DIS'],
2033 'sh4' : ['CONFIG_SH4_DIS'],
2034 'sparc' : ['CONFIG_SPARC_DIS'],
2035 'xtensa' : ['CONFIG_XTENSA_DIS'],
2037 if link_language == 'cpp'
2039 'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
2040 'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
2041 'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
2045 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2047 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2048 (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2049 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2050 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2051 ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
2052 (x11.found() ? ['CONFIG_X11=y'] : []) + \
2053 ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
2054 ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2055 ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2056 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2057 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2058 ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
2059 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
2061 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2063 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2064 actual_target_dirs = []
2066 foreach target : target_dirs
2067 config_target = { 'TARGET_NAME': target.split('-')[0] }
2068 if target.endswith('linux-user')
2069 if targetos != 'linux'
2073 error('Target @0@ is only available on a Linux host'.format(target))
2075 config_target += { 'CONFIG_LINUX_USER': 'y' }
2076 elif target.endswith('bsd-user')
2077 if 'CONFIG_BSD' not in config_host
2081 error('Target @0@ is only available on a BSD host'.format(target))
2083 config_target += { 'CONFIG_BSD_USER': 'y' }
2084 elif target.endswith('softmmu')
2085 config_target += { 'CONFIG_SOFTMMU': 'y' }
2087 if target.endswith('-user')
2089 'CONFIG_USER_ONLY': 'y',
2090 'CONFIG_QEMU_INTERP_PREFIX':
2091 config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
2096 foreach sym: accelerators
2097 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2098 config_target += { sym: 'y' }
2099 config_all += { sym: 'y' }
2100 if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
2101 config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
2102 elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
2103 config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
2105 if target in modular_tcg
2106 config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2108 config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2110 accel_kconfig += [ sym + '=y' ]
2113 if accel_kconfig.length() == 0
2117 error('No accelerator available for target @0@'.format(target))
2120 actual_target_dirs += target
2121 config_target += keyval.load('configs/targets' / target + '.mak')
2122 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2124 if 'TARGET_NEED_FDT' in config_target
2125 fdt_required += target
2129 if 'TARGET_BASE_ARCH' not in config_target
2130 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2132 if 'TARGET_ABI_DIR' not in config_target
2133 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2136 foreach k, v: disassemblers
2137 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2139 config_target += { sym: 'y' }
2140 config_all_disas += { sym: 'y' }
2145 config_target_data = configuration_data()
2146 foreach k, v: config_target
2147 if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2149 elif ignored.contains(k)
2151 elif k == 'TARGET_BASE_ARCH'
2152 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2153 # not used to select files from sourcesets.
2154 config_target_data.set('TARGET_' + v.to_upper(), 1)
2155 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2156 config_target_data.set_quoted(k, v)
2158 config_target_data.set(k, 1)
2160 config_target_data.set(k, v)
2163 config_target_data.set('QEMU_ARCH',
2164 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2165 config_target_h += {target: configure_file(output: target + '-config-target.h',
2166 configuration: config_target_data)}
2168 if target.endswith('-softmmu')
2169 config_input = meson.get_external_property(target, 'default')
2170 config_devices_mak = target + '-config-devices.mak'
2171 config_devices_mak = configure_file(
2172 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2173 output: config_devices_mak,
2174 depfile: config_devices_mak + '.d',
2176 command: [minikconf,
2177 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2178 config_devices_mak, '@DEPFILE@', '@INPUT@',
2179 host_kconfig, accel_kconfig,
2180 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2182 config_devices_data = configuration_data()
2183 config_devices = keyval.load(config_devices_mak)
2184 foreach k, v: config_devices
2185 config_devices_data.set(k, 1)
2187 config_devices_mak_list += config_devices_mak
2188 config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2189 configuration: config_devices_data)}
2190 config_target += config_devices
2191 config_all_devices += config_devices
2193 config_target_mak += {target: config_target}
2195 target_dirs = actual_target_dirs
2197 # This configuration is used to build files that are shared by
2198 # multiple binaries, and then extracted out of the "common"
2199 # static_library target.
2201 # We do not use all_sources()/all_dependencies(), because it would
2202 # build literally all source files, including devices only used by
2203 # targets that are not built for this compilation. The CONFIG_ALL
2204 # pseudo symbol replaces it.
2206 config_all += config_all_devices
2207 config_all += config_host
2208 config_all += config_all_disas
2210 'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
2211 'CONFIG_SOFTMMU': have_system,
2212 'CONFIG_USER_ONLY': have_user,
2216 target_configs_h = []
2217 foreach target: target_dirs
2218 target_configs_h += config_target_h[target]
2219 target_configs_h += config_devices_h.get(target, [])
2221 genh += custom_target('config-poison.h',
2222 input: [target_configs_h],
2223 output: 'config-poison.h',
2225 command: [find_program('scripts/make-config-poison.sh'),
2232 capstone = not_found
2233 capstone_opt = get_option('capstone')
2234 if capstone_opt in ['enabled', 'auto', 'system']
2235 have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
2236 capstone = dependency('capstone', version: '>=4.0',
2237 kwargs: static_kwargs, method: 'pkg-config',
2238 required: capstone_opt == 'system' or
2239 capstone_opt == 'enabled' and not have_internal)
2241 # Some versions of capstone have broken pkg-config file
2242 # that reports a wrong -I path, causing the #include to
2243 # fail later. If the system has such a broken version
2245 if capstone.found() and not cc.compiles('#include <capstone.h>',
2246 dependencies: [capstone])
2247 capstone = not_found
2248 if capstone_opt == 'system'
2249 error('system capstone requested, it does not appear to work')
2254 capstone_opt = 'system'
2256 capstone_opt = 'internal'
2258 capstone_opt = 'disabled'
2261 if capstone_opt == 'internal'
2262 capstone_data = configuration_data()
2263 capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
2265 capstone_files = files(
2267 'capstone/MCInst.c',
2268 'capstone/MCInstrDesc.c',
2269 'capstone/MCRegisterInfo.c',
2270 'capstone/SStream.c',
2274 if 'CONFIG_ARM_DIS' in config_all_disas
2275 capstone_data.set('CAPSTONE_HAS_ARM', '1')
2276 capstone_files += files(
2277 'capstone/arch/ARM/ARMDisassembler.c',
2278 'capstone/arch/ARM/ARMInstPrinter.c',
2279 'capstone/arch/ARM/ARMMapping.c',
2280 'capstone/arch/ARM/ARMModule.c'
2284 # FIXME: This config entry currently depends on a c++ compiler.
2285 # Which is needed for building libvixl, but not for capstone.
2286 if 'CONFIG_ARM_A64_DIS' in config_all_disas
2287 capstone_data.set('CAPSTONE_HAS_ARM64', '1')
2288 capstone_files += files(
2289 'capstone/arch/AArch64/AArch64BaseInfo.c',
2290 'capstone/arch/AArch64/AArch64Disassembler.c',
2291 'capstone/arch/AArch64/AArch64InstPrinter.c',
2292 'capstone/arch/AArch64/AArch64Mapping.c',
2293 'capstone/arch/AArch64/AArch64Module.c'
2297 if 'CONFIG_PPC_DIS' in config_all_disas
2298 capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
2299 capstone_files += files(
2300 'capstone/arch/PowerPC/PPCDisassembler.c',
2301 'capstone/arch/PowerPC/PPCInstPrinter.c',
2302 'capstone/arch/PowerPC/PPCMapping.c',
2303 'capstone/arch/PowerPC/PPCModule.c'
2307 if 'CONFIG_S390_DIS' in config_all_disas
2308 capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
2309 capstone_files += files(
2310 'capstone/arch/SystemZ/SystemZDisassembler.c',
2311 'capstone/arch/SystemZ/SystemZInstPrinter.c',
2312 'capstone/arch/SystemZ/SystemZMapping.c',
2313 'capstone/arch/SystemZ/SystemZModule.c',
2314 'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
2318 if 'CONFIG_I386_DIS' in config_all_disas
2319 capstone_data.set('CAPSTONE_HAS_X86', 1)
2320 capstone_files += files(
2321 'capstone/arch/X86/X86Disassembler.c',
2322 'capstone/arch/X86/X86DisassemblerDecoder.c',
2323 'capstone/arch/X86/X86ATTInstPrinter.c',
2324 'capstone/arch/X86/X86IntelInstPrinter.c',
2325 'capstone/arch/X86/X86InstPrinterCommon.c',
2326 'capstone/arch/X86/X86Mapping.c',
2327 'capstone/arch/X86/X86Module.c'
2331 configure_file(output: 'capstone-defs.h', configuration: capstone_data)
2334 # FIXME: There does not seem to be a way to completely replace the c_args
2335 # that come from add_project_arguments() -- we can only add to them.
2336 # So: disable all warnings with a big hammer.
2339 # Include all configuration defines via a header file, which will wind up
2340 # as a dependency on the object file, and thus changes here will result
2342 '-include', 'capstone-defs.h'
2345 libcapstone = static_library('capstone',
2346 build_by_default: false,
2347 sources: capstone_files,
2348 c_args: capstone_cargs,
2349 include_directories: 'capstone/include')
2350 capstone = declare_dependency(link_with: libcapstone,
2351 include_directories: 'capstone/include/capstone')
2355 slirp_opt = 'disabled'
2357 slirp_opt = get_option('slirp')
2358 if slirp_opt in ['enabled', 'auto', 'system']
2359 have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2360 slirp = dependency('slirp', kwargs: static_kwargs,
2361 method: 'pkg-config',
2362 required: slirp_opt == 'system' or
2363 slirp_opt == 'enabled' and not have_internal)
2365 slirp_opt = 'system'
2367 slirp_opt = 'internal'
2369 slirp_opt = 'disabled'
2372 if slirp_opt == 'internal'
2374 if targetos == 'windows'
2375 slirp_deps = cc.find_library('iphlpapi')
2376 elif targetos == 'darwin'
2377 slirp_deps = cc.find_library('resolv')
2379 slirp_conf = configuration_data()
2380 slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2381 slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2382 slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2383 slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2384 slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2386 'slirp/src/arp_table.c',
2387 'slirp/src/bootp.c',
2388 'slirp/src/cksum.c',
2389 'slirp/src/dhcpv6.c',
2390 'slirp/src/dnssearch.c',
2392 'slirp/src/ip6_icmp.c',
2393 'slirp/src/ip6_input.c',
2394 'slirp/src/ip6_output.c',
2395 'slirp/src/ip_icmp.c',
2396 'slirp/src/ip_input.c',
2397 'slirp/src/ip_output.c',
2401 'slirp/src/ndp_table.c',
2403 'slirp/src/slirp.c',
2404 'slirp/src/socket.c',
2405 'slirp/src/state.c',
2406 'slirp/src/stream.c',
2407 'slirp/src/tcp_input.c',
2408 'slirp/src/tcp_output.c',
2409 'slirp/src/tcp_subr.c',
2410 'slirp/src/tcp_timer.c',
2415 'slirp/src/version.c',
2416 'slirp/src/vmstate.c',
2420 input : 'slirp/src/libslirp-version.h.in',
2421 output : 'libslirp-version.h',
2422 configuration: slirp_conf)
2424 slirp_inc = include_directories('slirp', 'slirp/src')
2425 libslirp = static_library('slirp',
2426 build_by_default: false,
2427 sources: slirp_files,
2428 c_args: slirp_cargs,
2429 include_directories: slirp_inc)
2430 slirp = declare_dependency(link_with: libslirp,
2431 dependencies: slirp_deps,
2432 include_directories: slirp_inc)
2436 # For CFI, we need to compile slirp as a static library together with qemu.
2437 # This is because we register slirp functions as callbacks for QEMU Timers.
2438 # When using a system-wide shared libslirp, the type information for the
2439 # callback is missing and the timer call produces a false positive with CFI.
2441 # Now that slirp_opt has been defined, check if the selected slirp is compatible
2442 # with control-flow integrity.
2443 if get_option('cfi') and slirp_opt == 'system'
2444 error('Control-Flow Integrity is not compatible with system-wide slirp.' \
2445 + ' Please configure with --enable-slirp=git')
2450 fdt_opt = get_option('fdt')
2451 if fdt_opt in ['enabled', 'auto', 'system']
2452 have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2453 fdt = cc.find_library('fdt', kwargs: static_kwargs,
2454 required: fdt_opt == 'system' or
2455 fdt_opt == 'enabled' and not have_internal)
2456 if fdt.found() and cc.links('''
2458 #include <libfdt_env.h>
2459 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2462 elif fdt_opt == 'system'
2463 error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2465 fdt_opt = 'internal'
2467 fdt_opt = 'disabled'
2471 if fdt_opt == 'internal'
2474 'dtc/libfdt/fdt_ro.c',
2475 'dtc/libfdt/fdt_wip.c',
2476 'dtc/libfdt/fdt_sw.c',
2477 'dtc/libfdt/fdt_rw.c',
2478 'dtc/libfdt/fdt_strerror.c',
2479 'dtc/libfdt/fdt_empty_tree.c',
2480 'dtc/libfdt/fdt_addresses.c',
2481 'dtc/libfdt/fdt_overlay.c',
2482 'dtc/libfdt/fdt_check.c',
2485 fdt_inc = include_directories('dtc/libfdt')
2486 libfdt = static_library('fdt',
2487 build_by_default: false,
2489 include_directories: fdt_inc)
2490 fdt = declare_dependency(link_with: libfdt,
2491 include_directories: fdt_inc)
2494 fdt_opt = 'disabled'
2496 if not fdt.found() and fdt_required.length() > 0
2497 error('fdt not available but required by targets ' + ', '.join(fdt_required))
2500 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2501 config_host_data.set('CONFIG_FDT', fdt.found())
2502 config_host_data.set('CONFIG_SLIRP', slirp.found())
2504 #####################
2505 # Generated sources #
2506 #####################
2508 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2510 hxtool = find_program('scripts/hxtool')
2511 shaderinclude = find_program('scripts/shaderinclude.pl')
2512 qapi_gen = find_program('scripts/qapi-gen.py')
2513 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2514 meson.current_source_dir() / 'scripts/qapi/commands.py',
2515 meson.current_source_dir() / 'scripts/qapi/common.py',
2516 meson.current_source_dir() / 'scripts/qapi/error.py',
2517 meson.current_source_dir() / 'scripts/qapi/events.py',
2518 meson.current_source_dir() / 'scripts/qapi/expr.py',
2519 meson.current_source_dir() / 'scripts/qapi/gen.py',
2520 meson.current_source_dir() / 'scripts/qapi/introspect.py',
2521 meson.current_source_dir() / 'scripts/qapi/parser.py',
2522 meson.current_source_dir() / 'scripts/qapi/schema.py',
2523 meson.current_source_dir() / 'scripts/qapi/source.py',
2524 meson.current_source_dir() / 'scripts/qapi/types.py',
2525 meson.current_source_dir() / 'scripts/qapi/visit.py',
2526 meson.current_source_dir() / 'scripts/qapi/common.py',
2527 meson.current_source_dir() / 'scripts/qapi-gen.py'
2531 python, files('scripts/tracetool.py'),
2532 '--backend=' + ','.join(get_option('trace_backends'))
2534 tracetool_depends = files(
2535 'scripts/tracetool/backend/log.py',
2536 'scripts/tracetool/backend/__init__.py',
2537 'scripts/tracetool/backend/dtrace.py',
2538 'scripts/tracetool/backend/ftrace.py',
2539 'scripts/tracetool/backend/simple.py',
2540 'scripts/tracetool/backend/syslog.py',
2541 'scripts/tracetool/backend/ust.py',
2542 'scripts/tracetool/format/ust_events_c.py',
2543 'scripts/tracetool/format/ust_events_h.py',
2544 'scripts/tracetool/format/__init__.py',
2545 'scripts/tracetool/format/d.py',
2546 'scripts/tracetool/format/simpletrace_stap.py',
2547 'scripts/tracetool/format/c.py',
2548 'scripts/tracetool/format/h.py',
2549 'scripts/tracetool/format/log_stap.py',
2550 'scripts/tracetool/format/stap.py',
2551 'scripts/tracetool/__init__.py',
2552 'scripts/tracetool/transform.py',
2553 'scripts/tracetool/vcpu.py'
2556 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2557 meson.current_source_dir(),
2558 config_host['PKGVERSION'], meson.project_version()]
2559 qemu_version = custom_target('qemu-version.h',
2560 output: 'qemu-version.h',
2561 command: qemu_version_cmd,
2563 build_by_default: true,
2564 build_always_stale: true)
2565 genh += qemu_version
2569 ['qemu-options.hx', 'qemu-options.def'],
2570 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2574 ['hmp-commands.hx', 'hmp-commands.h'],
2575 ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2578 foreach d : hx_headers
2579 hxdep += custom_target(d[1],
2583 build_by_default: true, # to be removed when added to a target
2584 command: [hxtool, '-h', '@INPUT0@'])
2592 authz_ss = ss.source_set()
2593 blockdev_ss = ss.source_set()
2594 block_ss = ss.source_set()
2595 chardev_ss = ss.source_set()
2596 common_ss = ss.source_set()
2597 crypto_ss = ss.source_set()
2598 hwcore_ss = ss.source_set()
2599 io_ss = ss.source_set()
2600 qmp_ss = ss.source_set()
2601 qom_ss = ss.source_set()
2602 softmmu_ss = ss.source_set()
2603 specific_fuzz_ss = ss.source_set()
2604 specific_ss = ss.source_set()
2605 stub_ss = ss.source_set()
2606 trace_ss = ss.source_set()
2607 user_ss = ss.source_set()
2608 util_ss = ss.source_set()
2611 qtest_module_ss = ss.source_set()
2612 tcg_module_ss = ss.source_set()
2618 target_softmmu_arch = {}
2619 target_user_arch = {}
2625 # TODO: add each directory to the subdirs from its own meson.build, once
2627 trace_events_subdirs = [
2635 trace_events_subdirs += [ 'linux-user' ]
2638 trace_events_subdirs += [ 'bsd-user' ]
2641 trace_events_subdirs += [
2650 trace_events_subdirs += [
2664 'hw/block/dataplane',
2714 if have_system or have_user
2715 trace_events_subdirs += [
2733 vhost_user = not_found
2734 if targetos == 'linux' and 'CONFIG_VHOST_USER' in config_host
2735 libvhost_user = subproject('libvhost-user')
2736 vhost_user = libvhost_user.get_variable('vhost_user_dep')
2739 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
2740 # that is filled in by qapi/.
2753 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2754 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2757 stub_ss = stub_ss.apply(config_all, strict: false)
2759 util_ss.add_all(trace_ss)
2760 util_ss = util_ss.apply(config_all, strict: false)
2761 libqemuutil = static_library('qemuutil',
2762 sources: util_ss.sources() + stub_ss.sources() + genh,
2763 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2764 qemuutil = declare_dependency(link_with: libqemuutil,
2765 sources: genh + version_res)
2767 if have_system or have_user
2768 decodetree = generator(find_program('scripts/decodetree.py'),
2769 output: 'decode-@BASENAME@.c.inc',
2770 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2771 subdir('libdecnumber')
2788 if config_host_data.get('CONFIG_REPLICATION')
2789 block_ss.add(files('replication.c'))
2796 blockdev_ss.add(files(
2803 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2804 # os-win32.c does not
2805 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2806 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2809 common_ss.add(files('cpus-common.c'))
2813 common_ss.add(capstone)
2814 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2816 # Work around a gcc bug/misfeature wherein constant propagation looks
2818 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2819 # to guess that a const variable is always zero. Without lto, this is
2820 # impossible, as the alias is restricted to page-vary-common.c. Indeed,
2821 # without lto, not even the alias is required -- we simply use different
2822 # declarations in different compilation units.
2823 pagevary = files('page-vary-common.c')
2824 if get_option('b_lto')
2825 pagevary_flags = ['-fno-lto']
2826 if get_option('cfi')
2827 pagevary_flags += '-fno-sanitize=cfi-icall'
2829 pagevary = static_library('page-vary-common', sources: pagevary,
2830 c_args: pagevary_flags)
2831 pagevary = declare_dependency(link_with: pagevary)
2833 common_ss.add(pagevary)
2834 specific_ss.add(files('page-vary.c'))
2842 subdir('semihosting')
2850 common_user_inc = []
2852 subdir('common-user')
2854 subdir('linux-user')
2856 # needed for fuzzing binaries
2857 subdir('tests/qtest/libqos')
2858 subdir('tests/qtest/fuzz')
2861 tcg_real_module_ss = ss.source_set()
2862 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2863 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2864 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2865 'tcg': tcg_real_module_ss }}
2867 ########################
2868 # Library dependencies #
2869 ########################
2871 modinfo_collect = find_program('scripts/modinfo-collect.py')
2872 modinfo_generate = find_program('scripts/modinfo-generate.py')
2877 foreach d, list : modules
2878 foreach m, module_ss : list
2879 if enable_modules and targetos != 'windows'
2880 module_ss = module_ss.apply(config_all, strict: false)
2881 sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2882 dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2888 if module_ss.sources() != []
2889 # FIXME: Should use sl.extract_all_objects(recursive: true) as
2890 # input. Sources can be used multiple times but objects are
2891 # unique when it comes to lookup in compile_commands.json.
2892 # Depnds on a mesion version with
2893 # https://github.com/mesonbuild/meson/pull/8900
2894 modinfo_files += custom_target(d + '-' + m + '.modinfo',
2895 output: d + '-' + m + '.modinfo',
2896 input: module_ss.sources() + genh,
2898 command: [modinfo_collect, module_ss.sources()])
2902 block_ss.add_all(module_ss)
2904 softmmu_ss.add_all(module_ss)
2910 foreach d, list : target_modules
2911 foreach m, module_ss : list
2912 if enable_modules and targetos != 'windows'
2913 foreach target : target_dirs
2914 if target.endswith('-softmmu')
2915 config_target = config_target_mak[target]
2916 config_target += config_host
2917 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2918 c_args = ['-DNEED_CPU_H',
2919 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2920 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2921 target_module_ss = module_ss.apply(config_target, strict: false)
2922 if target_module_ss.sources() != []
2923 module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2924 sl = static_library(module_name,
2925 [genh, target_module_ss.sources()],
2926 dependencies: [modulecommon, target_module_ss.dependencies()],
2927 include_directories: target_inc,
2931 # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2932 modinfo_files += custom_target(module_name + '.modinfo',
2933 output: module_name + '.modinfo',
2934 input: target_module_ss.sources() + genh,
2936 command: [modinfo_collect, '--target', target, target_module_ss.sources()])
2941 specific_ss.add_all(module_ss)
2947 modinfo_src = custom_target('modinfo.c',
2948 output: 'modinfo.c',
2949 input: modinfo_files,
2950 command: [modinfo_generate, '@INPUT@'],
2952 modinfo_lib = static_library('modinfo', modinfo_src)
2953 modinfo_dep = declare_dependency(link_whole: modinfo_lib)
2954 softmmu_ss.add(modinfo_dep)
2957 nm = find_program('nm')
2958 undefsym = find_program('scripts/undefsym.py')
2959 block_syms = custom_target('block.syms', output: 'block.syms',
2960 input: [libqemuutil, block_mods],
2962 command: [undefsym, nm, '@INPUT@'])
2963 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
2964 input: [libqemuutil, softmmu_mods],
2966 command: [undefsym, nm, '@INPUT@'])
2968 qom_ss = qom_ss.apply(config_host, strict: false)
2969 libqom = static_library('qom', qom_ss.sources() + genh,
2970 dependencies: [qom_ss.dependencies()],
2973 qom = declare_dependency(link_whole: libqom)
2975 authz_ss = authz_ss.apply(config_host, strict: false)
2976 libauthz = static_library('authz', authz_ss.sources() + genh,
2977 dependencies: [authz_ss.dependencies()],
2979 build_by_default: false)
2981 authz = declare_dependency(link_whole: libauthz,
2984 crypto_ss = crypto_ss.apply(config_host, strict: false)
2985 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2986 dependencies: [crypto_ss.dependencies()],
2988 build_by_default: false)
2990 crypto = declare_dependency(link_whole: libcrypto,
2991 dependencies: [authz, qom])
2993 io_ss = io_ss.apply(config_host, strict: false)
2994 libio = static_library('io', io_ss.sources() + genh,
2995 dependencies: [io_ss.dependencies()],
2996 link_with: libqemuutil,
2998 build_by_default: false)
3000 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3002 libmigration = static_library('migration', sources: migration_files + genh,
3004 build_by_default: false)
3005 migration = declare_dependency(link_with: libmigration,
3006 dependencies: [zlib, qom, io])
3007 softmmu_ss.add(migration)
3009 block_ss = block_ss.apply(config_host, strict: false)
3010 libblock = static_library('block', block_ss.sources() + genh,
3011 dependencies: block_ss.dependencies(),
3012 link_depends: block_syms,
3014 build_by_default: false)
3016 block = declare_dependency(link_whole: [libblock],
3017 link_args: '@block.syms',
3018 dependencies: [crypto, io])
3020 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3021 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3022 dependencies: blockdev_ss.dependencies(),
3024 build_by_default: false)
3026 blockdev = declare_dependency(link_whole: [libblockdev],
3027 dependencies: [block])
3029 qmp_ss = qmp_ss.apply(config_host, strict: false)
3030 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3031 dependencies: qmp_ss.dependencies(),
3033 build_by_default: false)
3035 qmp = declare_dependency(link_whole: [libqmp])
3037 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3039 dependencies: [gnutls],
3040 build_by_default: false)
3042 chardev = declare_dependency(link_whole: libchardev)
3044 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3045 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3047 build_by_default: false)
3048 hwcore = declare_dependency(link_whole: libhwcore)
3049 common_ss.add(hwcore)
3055 emulator_modules = []
3056 foreach m : block_mods + softmmu_mods
3057 emulator_modules += shared_module(m.name(),
3058 build_by_default: true,
3062 install_dir: qemu_moddir)
3065 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3066 common_ss.add(qom, qemuutil)
3068 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3069 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3071 common_all = common_ss.apply(config_all, strict: false)
3072 common_all = static_library('common',
3073 build_by_default: false,
3074 sources: common_all.sources() + genh,
3075 include_directories: common_user_inc,
3076 implicit_include_directories: false,
3077 dependencies: common_all.dependencies(),
3080 feature_to_c = find_program('scripts/feature_to_c.sh')
3082 if targetos == 'darwin'
3083 entitlement = find_program('scripts/entitlement.sh')
3087 foreach target : target_dirs
3088 config_target = config_target_mak[target]
3089 target_name = config_target['TARGET_NAME']
3090 target_base_arch = config_target['TARGET_BASE_ARCH']
3091 arch_srcs = [config_target_h[target]]
3093 c_args = ['-DNEED_CPU_H',
3094 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3095 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3096 link_args = emulator_link_args
3098 config_target += config_host
3099 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3100 if targetos == 'linux'
3101 target_inc += include_directories('linux-headers', is_system: true)
3103 if target.endswith('-softmmu')
3104 qemu_target_name = 'qemu-system-' + target_name
3105 target_type='system'
3106 t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3107 arch_srcs += t.sources()
3108 arch_deps += t.dependencies()
3110 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3111 hw = hw_arch[hw_dir].apply(config_target, strict: false)
3112 arch_srcs += hw.sources()
3113 arch_deps += hw.dependencies()
3115 arch_srcs += config_devices_h[target]
3116 link_args += ['@block.syms', '@qemu.syms']
3118 abi = config_target['TARGET_ABI_DIR']
3120 target_inc += common_user_inc
3121 qemu_target_name = 'qemu-' + target_name
3122 if target_base_arch in target_user_arch
3123 t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3124 arch_srcs += t.sources()
3125 arch_deps += t.dependencies()
3127 if 'CONFIG_LINUX_USER' in config_target
3128 base_dir = 'linux-user'
3130 if 'CONFIG_BSD_USER' in config_target
3131 base_dir = 'bsd-user'
3132 target_inc += include_directories('bsd-user/' / targetos)
3133 target_inc += include_directories('bsd-user/host/' / host_arch)
3134 dir = base_dir / abi
3135 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3137 target_inc += include_directories(
3141 if 'CONFIG_LINUX_USER' in config_target
3142 dir = base_dir / abi
3143 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3144 if config_target.has_key('TARGET_SYSTBL_ABI')
3146 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3147 extra_args : config_target['TARGET_SYSTBL_ABI'])
3152 if 'TARGET_XML_FILES' in config_target
3153 gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3154 output: target + '-gdbstub-xml.c',
3155 input: files(config_target['TARGET_XML_FILES'].split()),
3156 command: [feature_to_c, '@INPUT@'],
3158 arch_srcs += gdbstub_xml
3161 t = target_arch[target_base_arch].apply(config_target, strict: false)
3162 arch_srcs += t.sources()
3163 arch_deps += t.dependencies()
3165 target_common = common_ss.apply(config_target, strict: false)
3166 objects = common_all.extract_objects(target_common.sources())
3167 deps = target_common.dependencies()
3169 target_specific = specific_ss.apply(config_target, strict: false)
3170 arch_srcs += target_specific.sources()
3171 arch_deps += target_specific.dependencies()
3173 lib = static_library('qemu-' + target,
3174 sources: arch_srcs + genh,
3175 dependencies: arch_deps,
3177 include_directories: target_inc,
3179 build_by_default: false,
3182 if target.endswith('-softmmu')
3184 'name': 'qemu-system-' + target_name,
3185 'win_subsystem': 'console',
3186 'sources': files('softmmu/main.c'),
3189 if targetos == 'windows' and (sdl.found() or gtk.found())
3191 'name': 'qemu-system-' + target_name + 'w',
3192 'win_subsystem': 'windows',
3193 'sources': files('softmmu/main.c'),
3197 if get_option('fuzzing')
3198 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3200 'name': 'qemu-fuzz-' + target_name,
3201 'win_subsystem': 'console',
3202 'sources': specific_fuzz.sources(),
3203 'dependencies': specific_fuzz.dependencies(),
3208 'name': 'qemu-' + target_name,
3209 'win_subsystem': 'console',
3215 exe_name = exe['name']
3216 if targetos == 'darwin'
3217 exe_name += '-unsigned'
3220 emulator = executable(exe_name, exe['sources'],
3223 dependencies: arch_deps + deps + exe['dependencies'],
3224 objects: lib.extract_all_objects(recursive: true),
3225 link_language: link_language,
3226 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3227 link_args: link_args,
3228 win_subsystem: exe['win_subsystem'])
3230 if targetos == 'darwin'
3231 icon = 'pc-bios/qemu.rsrc'
3232 build_input = [emulator, files(icon)]
3234 get_option('bindir') / exe_name,
3235 meson.current_source_dir() / icon
3237 if 'CONFIG_HVF' in config_target
3238 entitlements = 'accel/hvf/entitlements.plist'
3239 build_input += files(entitlements)
3240 install_input += meson.current_source_dir() / entitlements
3243 emulators += {exe['name'] : custom_target(exe['name'],
3245 output: exe['name'],
3246 command: [entitlement, '@OUTPUT@', '@INPUT@'])
3249 meson.add_install_script(entitlement, '--install',
3250 get_option('bindir') / exe['name'],
3253 emulators += {exe['name']: emulator}
3258 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3259 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3260 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3261 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3263 custom_target(exe['name'] + stp['ext'],
3264 input: trace_events_all,
3265 output: exe['name'] + stp['ext'],
3266 install: stp['install'],
3267 install_dir: get_option('datadir') / 'systemtap/tapset',
3269 tracetool, '--group=all', '--format=' + stp['fmt'],
3270 '--binary=' + stp['bin'],
3271 '--target-name=' + target_name,
3272 '--target-type=' + target_type,
3273 '--probe-prefix=qemu.' + target_type + '.' + target_name,
3274 '@INPUT@', '@OUTPUT@'
3276 depend_files: tracetool_depends)
3282 # Other build targets
3284 if 'CONFIG_PLUGIN' in config_host
3285 install_headers('include/qemu/qemu-plugin.h')
3290 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3291 # when we don't build tools or system
3292 if xkbcommon.found()
3293 # used for the update-keymaps target, so include rules even if !have_tools
3294 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3295 dependencies: [qemuutil, xkbcommon], install: have_tools)
3299 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3300 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3301 qemu_io = executable('qemu-io', files('qemu-io.c'),
3302 dependencies: [block, qemuutil], install: true)
3303 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3304 dependencies: [blockdev, qemuutil, gnutls, selinux],
3307 subdir('storage-daemon')
3308 subdir('contrib/rdmacm-mux')
3309 subdir('contrib/elf2dmp')
3311 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3312 dependencies: qemuutil,
3315 if 'CONFIG_VHOST_USER' in config_host
3316 subdir('contrib/vhost-user-blk')
3317 subdir('contrib/vhost-user-gpu')
3318 subdir('contrib/vhost-user-input')
3319 subdir('contrib/vhost-user-scsi')
3322 if targetos == 'linux'
3323 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3324 dependencies: [qemuutil, libcap_ng],
3326 install_dir: get_option('libexecdir'))
3328 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3329 dependencies: [authz, crypto, io, qom, qemuutil,
3330 libcap_ng, mpathpersist],
3335 subdir('contrib/ivshmem-client')
3336 subdir('contrib/ivshmem-server')
3349 if host_machine.system() == 'windows'
3351 find_program('scripts/nsis.py'),
3353 get_option('prefix'),
3354 meson.current_source_dir(),
3357 '-DDISPLAYVERSION=' + meson.project_version(),
3360 nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3363 nsis_cmd += '-DCONFIG_GTK=y'
3366 nsis = custom_target('nsis',
3367 output: 'qemu-setup-' + meson.project_version() + '.exe',
3368 input: files('qemu.nsi'),
3369 build_always_stale: true,
3370 command: nsis_cmd + ['@INPUT@'])
3371 alias_target('installer', nsis)
3374 #########################
3375 # Configuration summary #
3376 #########################
3380 summary_info += {'Install prefix': get_option('prefix')}
3381 summary_info += {'BIOS directory': qemu_datadir}
3382 summary_info += {'firmware path': get_option('qemu_firmwarepath')}
3383 summary_info += {'binary directory': get_option('bindir')}
3384 summary_info += {'library directory': get_option('libdir')}
3385 summary_info += {'module directory': qemu_moddir}
3386 summary_info += {'libexec directory': get_option('libexecdir')}
3387 summary_info += {'include directory': get_option('includedir')}
3388 summary_info += {'config directory': get_option('sysconfdir')}
3389 if targetos != 'windows'
3390 summary_info += {'local state directory': get_option('localstatedir')}
3391 summary_info += {'Manual directory': get_option('mandir')}
3393 summary_info += {'local state directory': 'queried at runtime'}
3395 summary_info += {'Doc directory': get_option('docdir')}
3396 summary_info += {'Build directory': meson.current_build_dir()}
3397 summary_info += {'Source path': meson.current_source_dir()}
3398 summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']}
3399 summary(summary_info, bool_yn: true, section: 'Directories')
3403 summary_info += {'git': config_host['GIT']}
3404 summary_info += {'make': config_host['MAKE']}
3405 summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3406 summary_info += {'sphinx-build': sphinx_build}
3407 if config_host.has_key('HAVE_GDB_BIN')
3408 summary_info += {'gdb': config_host['HAVE_GDB_BIN']}
3410 if get_option('iasl') != ''
3411 summary_info += {'iasl': get_option('iasl')}
3413 summary_info += {'iasl': false}
3415 summary_info += {'genisoimage': config_host['GENISOIMAGE']}
3416 if targetos == 'windows' and have_ga
3417 summary_info += {'wixl': wixl}
3419 if slirp_opt != 'disabled' and have_system
3420 summary_info += {'smbd': have_slirp_smbd ? smbd_path : false}
3422 summary(summary_info, bool_yn: true, section: 'Host binaries')
3424 # Configurable features
3426 summary_info += {'Documentation': build_docs}
3427 summary_info += {'system-mode emulation': have_system}
3428 summary_info += {'user-mode emulation': have_user}
3429 summary_info += {'block layer': have_block}
3430 summary_info += {'Install blobs': get_option('install_blobs')}
3431 summary_info += {'module support': config_host.has_key('CONFIG_MODULES')}
3432 if config_host.has_key('CONFIG_MODULES')
3433 summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
3435 summary_info += {'fuzzing support': get_option('fuzzing')}
3437 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)}
3439 summary_info += {'Trace backends': ','.join(get_option('trace_backends'))}
3440 if 'simple' in get_option('trace_backends')
3441 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3443 summary_info += {'D-Bus display': dbus_display}
3444 summary_info += {'QOM debugging': get_option('qom_cast_debug')}
3445 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
3446 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
3447 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
3448 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
3449 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
3450 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
3451 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3452 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
3453 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
3454 summary_info += {'build guest agent': have_ga}
3455 summary(summary_info, bool_yn: true, section: 'Configurable features')
3457 # Compilation information
3459 summary_info += {'host CPU': cpu}
3460 summary_info += {'host endianness': build_machine.endian()}
3461 summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())}
3462 summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3463 if link_language == 'cpp'
3464 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())}
3466 summary_info += {'C++ compiler': false}
3468 if targetos == 'darwin'
3469 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3471 summary_info += {'CFLAGS': ' '.join(get_option('c_args')
3472 + ['-O' + get_option('optimization')]
3473 + (get_option('debug') ? ['-g'] : []))}
3474 if link_language == 'cpp'
3475 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args')
3476 + ['-O' + get_option('optimization')]
3477 + (get_option('debug') ? ['-g'] : []))}
3479 if targetos == 'darwin'
3480 summary_info += {'OBJCFLAGS': ' '.join(get_option('objc_args')
3481 + ['-O' + get_option('optimization')]
3482 + (get_option('debug') ? ['-g'] : []))}
3484 link_args = get_option(link_language + '_link_args')
3485 if link_args.length() > 0
3486 summary_info += {'LDFLAGS': ' '.join(link_args)}
3488 summary_info += {'QEMU_CFLAGS': config_host['QEMU_CFLAGS']}
3489 summary_info += {'QEMU_CXXFLAGS': config_host['QEMU_CXXFLAGS']}
3490 summary_info += {'QEMU_OBJCFLAGS': config_host['QEMU_OBJCFLAGS']}
3491 summary_info += {'QEMU_LDFLAGS': config_host['QEMU_LDFLAGS']}
3492 summary_info += {'profiler': get_option('profiler')}
3493 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3494 summary_info += {'PIE': get_option('b_pie')}
3495 summary_info += {'static build': config_host.has_key('CONFIG_STATIC')}
3496 summary_info += {'malloc trim support': has_malloc_trim}
3497 summary_info += {'membarrier': have_membarrier}
3498 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
3499 summary_info += {'mutex debugging': get_option('debug_mutex')}
3500 summary_info += {'memory allocator': get_option('malloc')}
3501 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
3502 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
3503 summary_info += {'gprof enabled': get_option('gprof')}
3504 summary_info += {'gcov': get_option('b_coverage')}
3505 summary_info += {'thread sanitizer': config_host.has_key('CONFIG_TSAN')}
3506 summary_info += {'CFI support': get_option('cfi')}
3507 if get_option('cfi')
3508 summary_info += {'CFI debug support': get_option('cfi_debug')}
3510 summary_info += {'strip binaries': get_option('strip')}
3511 summary_info += {'sparse': sparse}
3512 summary_info += {'mingw32 support': targetos == 'windows'}
3514 # snarf the cross-compilation information for tests
3515 foreach target: target_dirs
3516 tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3517 if fs.exists(tcg_mak)
3518 config_cross_tcg = keyval.load(tcg_mak)
3519 target = config_cross_tcg['TARGET_NAME']
3521 if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
3522 summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
3523 ' via ' + config_cross_tcg['DOCKER_IMAGE']}
3524 elif 'CROSS_CC_GUEST' in config_cross_tcg
3525 summary_info += {target + ' tests'
3526 : config_cross_tcg['CROSS_CC_GUEST'] }
3531 summary(summary_info, bool_yn: true, section: 'Compilation')
3533 # Targets and accelerators
3536 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')}
3537 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')}
3538 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')}
3539 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')}
3540 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')}
3541 summary_info += {'Xen support': config_host.has_key('CONFIG_XEN_BACKEND')}
3542 if config_host.has_key('CONFIG_XEN_BACKEND')
3543 summary_info += {'xen ctrl version': config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
3546 summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')}
3547 if config_all.has_key('CONFIG_TCG')
3548 if get_option('tcg_interpreter')
3549 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'}
3551 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)}
3553 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3554 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3556 summary_info += {'target list': ' '.join(target_dirs)}
3558 summary_info += {'default devices': get_option('default_devices')}
3559 summary_info += {'out of process emulation': multiprocess_allowed}
3561 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3565 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3566 summary_info += {'coroutine pool': have_coroutine_pool}
3568 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3569 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3570 summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
3571 summary_info += {'VirtFS support': have_virtfs}
3572 summary_info += {'build virtiofs daemon': have_virtiofsd}
3573 summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
3574 summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
3575 summary_info += {'bochs support': get_option('bochs').allowed()}
3576 summary_info += {'cloop support': get_option('cloop').allowed()}
3577 summary_info += {'dmg support': get_option('dmg').allowed()}
3578 summary_info += {'qcow v1 support': get_option('qcow1').allowed()}
3579 summary_info += {'vdi support': get_option('vdi').allowed()}
3580 summary_info += {'vvfat support': get_option('vvfat').allowed()}
3581 summary_info += {'qed support': get_option('qed').allowed()}
3582 summary_info += {'parallels support': get_option('parallels').allowed()}
3583 summary_info += {'FUSE exports': fuse}
3585 summary(summary_info, bool_yn: true, section: 'Block layer support')
3589 summary_info += {'TLS priority': config_host['CONFIG_TLS_PRIORITY']}
3590 summary_info += {'GNUTLS support': gnutls}
3592 summary_info += {' GNUTLS crypto': gnutls_crypto.found()}
3594 summary_info += {'libgcrypt': gcrypt}
3595 summary_info += {'nettle': nettle}
3597 summary_info += {' XTS': xts != 'private'}
3599 summary_info += {'AF_ALG support': have_afalg}
3600 summary_info += {'rng-none': get_option('rng_none')}
3601 summary_info += {'Linux keyring': config_host.has_key('CONFIG_SECRET_KEYRING')}
3602 summary(summary_info, bool_yn: true, section: 'Crypto')
3606 if targetos == 'darwin'
3607 summary_info += {'Cocoa support': cocoa}
3609 summary_info += {'SDL support': sdl}
3610 summary_info += {'SDL image support': sdl_image}
3611 summary_info += {'GTK support': gtk}
3612 summary_info += {'pixman': pixman}
3613 summary_info += {'VTE support': vte}
3614 summary_info += {'slirp support': slirp_opt == 'internal' ? slirp_opt : slirp}
3615 summary_info += {'libtasn1': tasn1}
3616 summary_info += {'PAM': pam}
3617 summary_info += {'iconv support': iconv}
3618 summary_info += {'curses support': curses}
3619 summary_info += {'virgl support': virgl}
3620 summary_info += {'curl support': curl}
3621 summary_info += {'Multipath support': mpathpersist}
3622 summary_info += {'VNC support': vnc}
3624 summary_info += {'VNC SASL support': sasl}
3625 summary_info += {'VNC JPEG support': jpeg}
3626 summary_info += {'VNC PNG support': png}
3628 if targetos not in ['darwin', 'haiku', 'windows']
3629 summary_info += {'OSS support': oss}
3630 elif targetos == 'darwin'
3631 summary_info += {'CoreAudio support': coreaudio}
3632 elif targetos == 'windows'
3633 summary_info += {'DirectSound support': dsound}
3635 if targetos == 'linux'
3636 summary_info += {'ALSA support': alsa}
3637 summary_info += {'PulseAudio support': pulse}
3639 summary_info += {'JACK support': jack}
3640 summary_info += {'brlapi support': brlapi}
3641 summary_info += {'vde support': vde}
3642 summary_info += {'netmap support': have_netmap}
3643 summary_info += {'l2tpv3 support': have_l2tpv3}
3644 summary_info += {'Linux AIO support': libaio}
3645 summary_info += {'Linux io_uring support': linux_io_uring}
3646 summary_info += {'ATTR/XATTR support': libattr}
3647 summary_info += {'RDMA support': config_host.has_key('CONFIG_RDMA')}
3648 summary_info += {'PVRDMA support': config_host.has_key('CONFIG_PVRDMA')}
3649 summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt}
3650 summary_info += {'libcap-ng support': libcap_ng}
3651 summary_info += {'bpf support': libbpf}
3652 summary_info += {'spice protocol support': spice_protocol}
3653 if spice_protocol.found()
3654 summary_info += {' spice server support': spice}
3656 summary_info += {'rbd support': rbd}
3657 summary_info += {'smartcard support': cacard}
3658 summary_info += {'U2F support': u2f}
3659 summary_info += {'libusb': libusb}
3660 summary_info += {'usb net redir': usbredir}
3661 summary_info += {'OpenGL support': config_host.has_key('CONFIG_OPENGL')}
3662 summary_info += {'GBM': gbm}
3663 summary_info += {'libiscsi support': libiscsi}
3664 summary_info += {'libnfs support': libnfs}
3665 if targetos == 'windows'
3667 summary_info += {'QGA VSS support': have_qga_vss}
3668 summary_info += {'QGA w32 disk info': have_ntddscsi}
3671 summary_info += {'seccomp support': seccomp}
3672 summary_info += {'GlusterFS support': glusterfs}
3673 summary_info += {'TPM support': have_tpm}
3674 summary_info += {'libssh support': libssh}
3675 summary_info += {'lzo support': lzo}
3676 summary_info += {'snappy support': snappy}
3677 summary_info += {'bzip2 support': libbzip2}
3678 summary_info += {'lzfse support': liblzfse}
3679 summary_info += {'zstd support': zstd}
3680 summary_info += {'NUMA host support': numa}
3681 summary_info += {'capstone': capstone_opt == 'internal' ? capstone_opt : capstone}
3682 summary_info += {'libpmem support': libpmem}
3683 summary_info += {'libdaxctl support': libdaxctl}
3684 summary_info += {'libudev': libudev}
3685 # Dummy dependency, keep .found()
3686 summary_info += {'FUSE lseek': fuse_lseek.found()}
3687 summary_info += {'selinux': selinux}
3688 summary(summary_info, bool_yn: true, section: 'Dependencies')
3690 if not supported_cpus.contains(cpu)
3692 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3694 message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3695 message('The QEMU project intends to remove support for this host CPU in')
3696 message('a future release if nobody volunteers to maintain it and to')
3697 message('provide a build host for our continuous integration setup.')
3698 message('configure has succeeded and you can continue to build, but')
3699 message('if you care about QEMU on this platform you should contact')
3700 message('us upstream at qemu-devel@nongnu.org.')
3703 if not supported_oses.contains(targetos)
3705 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3707 message('Host OS ' + targetos + 'support is not currently maintained.')
3708 message('The QEMU project intends to remove support for this host OS in')
3709 message('a future release if nobody volunteers to maintain it and to')
3710 message('provide a build host for our continuous integration setup.')
3711 message('configure has succeeded and you can continue to build, but')
3712 message('if you care about QEMU on this platform you should contact')
3713 message('us upstream at qemu-devel@nongnu.org.')