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: ['slow', 'thorough'], is_default: true)
7 add_test_setup('slow', exclude_suites: ['thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
8 add_test_setup('thorough', env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
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, version: '>= 2.1',
459 method: 'pkg-config', 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)
1596 have_coroutine_pool = get_option('coroutine_pool')
1597 if get_option('debug_stack_usage') and have_coroutine_pool
1598 message('Disabling coroutine pool to measure stack usage')
1599 have_coroutine_pool = false
1601 config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool)
1602 config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
1603 config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
1604 config_host_data.set('CONFIG_GPROF', get_option('gprof'))
1605 config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
1606 config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
1607 config_host_data.set('CONFIG_REPLICATION', get_option('live_block_migration').allowed())
1610 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1611 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1612 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1613 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1614 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1615 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1616 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1617 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1618 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1621 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1622 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1623 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1624 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1625 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1626 # Note that we need to specify prefix: here to avoid incorrectly
1627 # thinking that Windows has posix_memalign()
1628 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
1629 config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
1630 config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
1631 config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
1632 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
1633 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1634 config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
1635 config_host_data.set('CONFIG_SEM_TIMEDWAIT', cc.has_function('sem_timedwait', dependencies: threads))
1636 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
1637 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
1638 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
1639 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
1640 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
1641 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
1642 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
1643 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
1644 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1646 config_host_data.set('HAVE_IBV_ADVISE_MR',
1647 cc.has_function('ibv_advise_mr',
1648 args: config_host['RDMA_LIBS'].split(),
1649 prefix: '#include <infiniband/verbs.h>'))
1653 config_host_data.set('CONFIG_BYTESWAP_H',
1654 cc.has_header_symbol('byteswap.h', 'bswap_32'))
1655 config_host_data.set('CONFIG_EPOLL_CREATE1',
1656 cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
1657 config_host_data.set('CONFIG_HAS_ENVIRON',
1658 cc.has_header_symbol('unistd.h', 'environ', prefix: gnu_source_prefix))
1659 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
1660 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
1661 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
1662 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
1663 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
1664 config_host_data.set('CONFIG_FIEMAP',
1665 cc.has_header('linux/fiemap.h') and
1666 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
1667 config_host_data.set('CONFIG_GETRANDOM',
1668 cc.has_function('getrandom') and
1669 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
1670 config_host_data.set('CONFIG_INOTIFY',
1671 cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
1672 config_host_data.set('CONFIG_INOTIFY1',
1673 cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
1674 config_host_data.set('CONFIG_MACHINE_BSWAP_H',
1675 cc.has_header_symbol('machine/bswap.h', 'bswap32',
1676 prefix: '''#include <sys/endian.h>
1677 #include <sys/types.h>'''))
1678 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
1679 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
1680 config_host_data.set('CONFIG_RTNETLINK',
1681 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
1682 config_host_data.set('CONFIG_SYSMACROS',
1683 cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1684 config_host_data.set('HAVE_OPTRESET',
1685 cc.has_header_symbol('getopt.h', 'optreset'))
1686 config_host_data.set('HAVE_IPPROTO_MPTCP',
1687 cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
1690 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
1691 cc.has_member('struct sigevent', 'sigev_notify_thread_id',
1692 prefix: '#include <signal.h>'))
1693 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
1694 cc.has_member('struct stat', 'st_atim',
1695 prefix: '#include <sys/stat.h>'))
1698 config_host_data.set('CONFIG_IOVEC',
1699 cc.has_type('struct iovec',
1700 prefix: '#include <sys/uio.h>'))
1701 config_host_data.set('HAVE_UTMPX',
1702 cc.has_type('struct utmpx',
1703 prefix: '#include <utmpx.h>'))
1705 config_host_data.set('CONFIG_EVENTFD', cc.links('''
1706 #include <sys/eventfd.h>
1707 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
1708 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
1711 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
1712 return fdatasync(0);
1714 #error Not supported
1718 has_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 missing_madvise_proto = false
1725 # Some platforms (illumos and Solaris before Solaris 11) provide madvise()
1726 # but forget to prototype it. In this case, has_madvise will be true (the
1727 # test program links despite a compile warning). To detect the
1728 # missing-prototype case, we try again with a definitely-bogus prototype.
1729 # This will only compile if the system headers don't provide the prototype;
1730 # otherwise the conflicting prototypes will cause a compiler error.
1731 missing_madvise_proto = cc.links(gnu_source_prefix + '''
1732 #include <sys/types.h>
1733 #include <sys/mman.h>
1735 extern int madvise(int);
1736 int main(void) { return madvise(0); }''')
1738 config_host_data.set('CONFIG_MADVISE', has_madvise)
1739 config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
1741 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
1742 #include <sys/mman.h>
1743 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
1744 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
1746 #if !defined(AT_EMPTY_PATH)
1747 # error missing definition
1749 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
1751 config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
1758 return pipe2(pipefd, O_CLOEXEC);
1760 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
1761 #include <sys/mman.h>
1763 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
1765 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
1766 #include <pthread.h>
1768 static void *f(void *p) { return NULL; }
1772 pthread_create(&thread, 0, f, 0);
1773 pthread_setname_np(thread, "QEMU");
1775 }''', dependencies: threads))
1776 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
1777 #include <pthread.h>
1779 static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
1783 pthread_create(&thread, 0, f, 0);
1785 }''', dependencies: threads))
1787 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
1788 #include <sys/signalfd.h>
1790 int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
1791 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
1799 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
1800 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
1804 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
1805 #include <sys/mman.h>
1806 int main(int argc, char *argv[]) {
1807 return mlockall(MCL_FUTURE);
1811 if get_option('l2tpv3').allowed() and have_system
1812 have_l2tpv3 = cc.has_type('struct mmsghdr',
1813 prefix: gnu_source_prefix + '''
1814 #include <sys/socket.h>
1815 #include <linux/ip.h>''')
1817 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
1820 if get_option('netmap').allowed() and have_system
1821 have_netmap = cc.compiles('''
1822 #include <inttypes.h>
1824 #include <net/netmap.h>
1825 #include <net/netmap_user.h>
1826 #if (NETMAP_API < 11) || (NETMAP_API > 15)
1829 int main(void) { return 0; }''')
1830 if not have_netmap and get_option('netmap').enabled()
1831 error('Netmap headers not available')
1834 config_host_data.set('CONFIG_NETMAP', have_netmap)
1836 # Work around a system header bug with some kernel/XFS header
1837 # versions where they both try to define 'struct fsxattr':
1838 # xfs headers will not try to redefine structs from linux headers
1839 # if this macro is set.
1840 config_host_data.set('HAVE_FSXATTR', cc.links('''
1841 #include <linux/fs.h>
1847 # Some versions of Mac OS X incorrectly define SIZE_MAX
1848 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
1851 int main(int argc, char *argv[]) {
1852 return printf("%zu", SIZE_MAX);
1853 }''', args: ['-Werror']))
1860 y = __atomic_load_n(&x, __ATOMIC_RELAXED);
1861 __atomic_store_n(&x, y, __ATOMIC_RELAXED);
1862 __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
1863 __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
1864 __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
1868 # See if 64-bit atomic operations are supported.
1869 # Note that without __atomic builtins, we can only
1870 # assume atomic loads/stores max at pointer size.
1871 config_host_data.set('CONFIG_ATOMIC64', cc.links(atomic_test.format('uint64_t')))
1873 has_int128 = cc.links('''
1883 config_host_data.set('CONFIG_INT128', has_int128)
1886 # "do we have 128-bit atomics which are handled inline and specifically not
1887 # via libatomic". The reason we can't use libatomic is documented in the
1888 # comment starting "GCC is a house divided" in include/qemu/atomic128.h.
1889 has_atomic128 = cc.links(atomic_test.format('unsigned __int128'))
1891 config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
1893 if not has_atomic128
1894 has_cmpxchg128 = cc.links('''
1897 unsigned __int128 x = 0, y = 0;
1898 __sync_val_compare_and_swap_16(&x, y, x);
1903 config_host_data.set('CONFIG_CMPXCHG128', has_cmpxchg128)
1907 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
1908 #include <sys/auxv.h>
1910 return getauxval(AT_HWCAP) == 0;
1913 have_cpuid_h = cc.links('''
1916 unsigned a, b, c, d;
1917 unsigned max = __get_cpuid_max(0, 0);
1920 __cpuid(1, a, b, c, d);
1924 __cpuid_count(7, 0, a, b, c, d);
1929 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
1931 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
1932 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
1933 .require(cc.links('''
1934 #pragma GCC push_options
1935 #pragma GCC target("avx2")
1937 #include <immintrin.h>
1938 static int bar(void *a) {
1939 __m256i x = *(__m256i *)a;
1940 return _mm256_testz_si256(x, x);
1942 int main(int argc, char *argv[]) { return bar(argv[0]); }
1943 '''), error_message: 'AVX2 not available').allowed())
1945 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
1946 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
1947 .require(cc.links('''
1948 #pragma GCC push_options
1949 #pragma GCC target("avx512f")
1951 #include <immintrin.h>
1952 static int bar(void *a) {
1953 __m512i x = *(__m512i *)a;
1954 return _mm512_test_epi64_mask(x, x);
1956 int main(int argc, char *argv[]) { return bar(argv[0]); }
1957 '''), error_message: 'AVX512F not available').allowed())
1959 if get_option('membarrier').disabled()
1960 have_membarrier = false
1961 elif targetos == 'windows'
1962 have_membarrier = true
1963 elif targetos == 'linux'
1964 have_membarrier = cc.compiles('''
1965 #include <linux/membarrier.h>
1966 #include <sys/syscall.h>
1970 syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
1971 syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
1975 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
1976 .require(have_membarrier, error_message: 'membarrier system call not available') \
1979 have_afalg = get_option('crypto_afalg') \
1980 .require(cc.compiles(gnu_source_prefix + '''
1982 #include <sys/types.h>
1983 #include <sys/socket.h>
1984 #include <linux/if_alg.h>
1987 sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
1990 '''), error_message: 'AF_ALG requested but could not be detected').allowed()
1991 config_host_data.set('CONFIG_AF_ALG', have_afalg)
1993 config_host_data.set('CONFIG_AF_VSOCK', cc.compiles(gnu_source_prefix + '''
1995 #include <sys/types.h>
1996 #include <sys/socket.h>
1997 #if !defined(AF_VSOCK)
1998 # error missing AF_VSOCK flag
2000 #include <linux/vm_sockets.h>
2003 struct sockaddr_vm svm;
2004 socklen_t len = sizeof(svm);
2005 sock = socket(AF_VSOCK, SOCK_STREAM, 0);
2006 ret = getpeername(sock, (struct sockaddr *)&svm, &len);
2007 if ((ret == -1) && (errno == ENOTCONN)) {
2014 have_vss_sdk = false # old xp/2003 SDK
2015 if targetos == 'windows' and link_language == 'cpp'
2016 have_vss = cxx.compiles('''
2017 #define __MIDL_user_allocate_free_DEFINED__
2019 int main(void) { return VSS_CTX_BACKUP; }''')
2020 have_vss_sdk = cxx.has_header('vscoordint.h')
2022 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
2024 have_ntddscsi = false
2025 if targetos == 'windows'
2026 have_ntddscsi = cc.compiles('''
2027 #include <windows.h>
2028 #include <ntddscsi.h>
2030 #if !defined(IOCTL_SCSI_GET_ADDRESS)
2031 #error Missing required ioctl definitions
2033 SCSI_ADDRESS addr = { .Lun = 0, .TargetId = 0, .PathId = 0 };
2038 config_host_data.set('HAVE_NTDDSCSI', have_ntddscsi)
2040 ignored = ['CONFIG_QEMU_INTERP_PREFIX', # actually per-target
2042 arrays = ['CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
2043 foreach k, v: config_host
2044 if ignored.contains(k)
2046 elif arrays.contains(k)
2048 v = '"' + '", "'.join(v.split()) + '", '
2050 config_host_data.set(k, v)
2051 elif k.startswith('CONFIG_')
2052 config_host_data.set(k, v == 'y' ? 1 : v)
2056 ########################
2057 # Target configuration #
2058 ########################
2060 minikconf = find_program('scripts/minikconf.py')
2062 config_all_devices = {}
2063 config_all_disas = {}
2064 config_devices_mak_list = []
2065 config_devices_h = {}
2066 config_target_h = {}
2067 config_target_mak = {}
2070 'alpha' : ['CONFIG_ALPHA_DIS'],
2071 'arm' : ['CONFIG_ARM_DIS'],
2072 'avr' : ['CONFIG_AVR_DIS'],
2073 'cris' : ['CONFIG_CRIS_DIS'],
2074 'hexagon' : ['CONFIG_HEXAGON_DIS'],
2075 'hppa' : ['CONFIG_HPPA_DIS'],
2076 'i386' : ['CONFIG_I386_DIS'],
2077 'x86_64' : ['CONFIG_I386_DIS'],
2078 'm68k' : ['CONFIG_M68K_DIS'],
2079 'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2080 'mips' : ['CONFIG_MIPS_DIS'],
2081 'nios2' : ['CONFIG_NIOS2_DIS'],
2082 'or1k' : ['CONFIG_OPENRISC_DIS'],
2083 'ppc' : ['CONFIG_PPC_DIS'],
2084 'riscv' : ['CONFIG_RISCV_DIS'],
2085 'rx' : ['CONFIG_RX_DIS'],
2086 's390' : ['CONFIG_S390_DIS'],
2087 'sh4' : ['CONFIG_SH4_DIS'],
2088 'sparc' : ['CONFIG_SPARC_DIS'],
2089 'xtensa' : ['CONFIG_XTENSA_DIS'],
2091 if link_language == 'cpp'
2093 'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
2094 'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
2095 'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
2099 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2101 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2102 (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2103 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2104 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2105 ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
2106 (x11.found() ? ['CONFIG_X11=y'] : []) + \
2107 ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
2108 ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2109 ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2110 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2111 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2112 ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
2113 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
2115 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2117 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2118 actual_target_dirs = []
2120 foreach target : target_dirs
2121 config_target = { 'TARGET_NAME': target.split('-')[0] }
2122 if target.endswith('linux-user')
2123 if targetos != 'linux'
2127 error('Target @0@ is only available on a Linux host'.format(target))
2129 config_target += { 'CONFIG_LINUX_USER': 'y' }
2130 elif target.endswith('bsd-user')
2131 if 'CONFIG_BSD' not in config_host
2135 error('Target @0@ is only available on a BSD host'.format(target))
2137 config_target += { 'CONFIG_BSD_USER': 'y' }
2138 elif target.endswith('softmmu')
2139 config_target += { 'CONFIG_SOFTMMU': 'y' }
2141 if target.endswith('-user')
2143 'CONFIG_USER_ONLY': 'y',
2144 'CONFIG_QEMU_INTERP_PREFIX':
2145 config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
2150 foreach sym: accelerators
2151 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2152 config_target += { sym: 'y' }
2153 config_all += { sym: 'y' }
2154 if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
2155 config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
2156 elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
2157 config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
2159 if target in modular_tcg
2160 config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2162 config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2164 accel_kconfig += [ sym + '=y' ]
2167 if accel_kconfig.length() == 0
2171 error('No accelerator available for target @0@'.format(target))
2174 actual_target_dirs += target
2175 config_target += keyval.load('configs/targets' / target + '.mak')
2176 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2178 if 'TARGET_NEED_FDT' in config_target
2179 fdt_required += target
2183 if 'TARGET_BASE_ARCH' not in config_target
2184 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2186 if 'TARGET_ABI_DIR' not in config_target
2187 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2189 if 'TARGET_BIG_ENDIAN' not in config_target
2190 config_target += {'TARGET_BIG_ENDIAN': 'n'}
2193 foreach k, v: disassemblers
2194 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2196 config_target += { sym: 'y' }
2197 config_all_disas += { sym: 'y' }
2202 config_target_data = configuration_data()
2203 foreach k, v: config_target
2204 if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2206 elif ignored.contains(k)
2208 elif k == 'TARGET_BASE_ARCH'
2209 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2210 # not used to select files from sourcesets.
2211 config_target_data.set('TARGET_' + v.to_upper(), 1)
2212 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2213 config_target_data.set_quoted(k, v)
2215 config_target_data.set(k, 1)
2217 config_target_data.set(k, 0)
2219 config_target_data.set(k, v)
2222 config_target_data.set('QEMU_ARCH',
2223 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2224 config_target_h += {target: configure_file(output: target + '-config-target.h',
2225 configuration: config_target_data)}
2227 if target.endswith('-softmmu')
2228 config_input = meson.get_external_property(target, 'default')
2229 config_devices_mak = target + '-config-devices.mak'
2230 config_devices_mak = configure_file(
2231 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2232 output: config_devices_mak,
2233 depfile: config_devices_mak + '.d',
2235 command: [minikconf,
2236 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2237 config_devices_mak, '@DEPFILE@', '@INPUT@',
2238 host_kconfig, accel_kconfig,
2239 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2241 config_devices_data = configuration_data()
2242 config_devices = keyval.load(config_devices_mak)
2243 foreach k, v: config_devices
2244 config_devices_data.set(k, 1)
2246 config_devices_mak_list += config_devices_mak
2247 config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2248 configuration: config_devices_data)}
2249 config_target += config_devices
2250 config_all_devices += config_devices
2252 config_target_mak += {target: config_target}
2254 target_dirs = actual_target_dirs
2256 # This configuration is used to build files that are shared by
2257 # multiple binaries, and then extracted out of the "common"
2258 # static_library target.
2260 # We do not use all_sources()/all_dependencies(), because it would
2261 # build literally all source files, including devices only used by
2262 # targets that are not built for this compilation. The CONFIG_ALL
2263 # pseudo symbol replaces it.
2265 config_all += config_all_devices
2266 config_all += config_host
2267 config_all += config_all_disas
2269 'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
2270 'CONFIG_SOFTMMU': have_system,
2271 'CONFIG_USER_ONLY': have_user,
2275 target_configs_h = []
2276 foreach target: target_dirs
2277 target_configs_h += config_target_h[target]
2278 target_configs_h += config_devices_h.get(target, [])
2280 genh += custom_target('config-poison.h',
2281 input: [target_configs_h],
2282 output: 'config-poison.h',
2284 command: [find_program('scripts/make-config-poison.sh'),
2291 capstone = not_found
2292 capstone_opt = get_option('capstone')
2293 if capstone_opt in ['enabled', 'auto', 'system']
2294 have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
2295 capstone = dependency('capstone', version: '>=4.0',
2296 kwargs: static_kwargs, method: 'pkg-config',
2297 required: capstone_opt == 'system' or
2298 capstone_opt == 'enabled' and not have_internal)
2300 # Some versions of capstone have broken pkg-config file
2301 # that reports a wrong -I path, causing the #include to
2302 # fail later. If the system has such a broken version
2304 if capstone.found() and not cc.compiles('#include <capstone.h>',
2305 dependencies: [capstone])
2306 capstone = not_found
2307 if capstone_opt == 'system'
2308 error('system capstone requested, it does not appear to work')
2313 capstone_opt = 'system'
2315 capstone_opt = 'internal'
2317 capstone_opt = 'disabled'
2320 if capstone_opt == 'internal'
2321 capstone_data = configuration_data()
2322 capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
2324 capstone_files = files(
2326 'capstone/MCInst.c',
2327 'capstone/MCInstrDesc.c',
2328 'capstone/MCRegisterInfo.c',
2329 'capstone/SStream.c',
2333 if 'CONFIG_ARM_DIS' in config_all_disas
2334 capstone_data.set('CAPSTONE_HAS_ARM', '1')
2335 capstone_files += files(
2336 'capstone/arch/ARM/ARMDisassembler.c',
2337 'capstone/arch/ARM/ARMInstPrinter.c',
2338 'capstone/arch/ARM/ARMMapping.c',
2339 'capstone/arch/ARM/ARMModule.c'
2343 # FIXME: This config entry currently depends on a c++ compiler.
2344 # Which is needed for building libvixl, but not for capstone.
2345 if 'CONFIG_ARM_A64_DIS' in config_all_disas
2346 capstone_data.set('CAPSTONE_HAS_ARM64', '1')
2347 capstone_files += files(
2348 'capstone/arch/AArch64/AArch64BaseInfo.c',
2349 'capstone/arch/AArch64/AArch64Disassembler.c',
2350 'capstone/arch/AArch64/AArch64InstPrinter.c',
2351 'capstone/arch/AArch64/AArch64Mapping.c',
2352 'capstone/arch/AArch64/AArch64Module.c'
2356 if 'CONFIG_PPC_DIS' in config_all_disas
2357 capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
2358 capstone_files += files(
2359 'capstone/arch/PowerPC/PPCDisassembler.c',
2360 'capstone/arch/PowerPC/PPCInstPrinter.c',
2361 'capstone/arch/PowerPC/PPCMapping.c',
2362 'capstone/arch/PowerPC/PPCModule.c'
2366 if 'CONFIG_S390_DIS' in config_all_disas
2367 capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
2368 capstone_files += files(
2369 'capstone/arch/SystemZ/SystemZDisassembler.c',
2370 'capstone/arch/SystemZ/SystemZInstPrinter.c',
2371 'capstone/arch/SystemZ/SystemZMapping.c',
2372 'capstone/arch/SystemZ/SystemZModule.c',
2373 'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
2377 if 'CONFIG_I386_DIS' in config_all_disas
2378 capstone_data.set('CAPSTONE_HAS_X86', 1)
2379 capstone_files += files(
2380 'capstone/arch/X86/X86Disassembler.c',
2381 'capstone/arch/X86/X86DisassemblerDecoder.c',
2382 'capstone/arch/X86/X86ATTInstPrinter.c',
2383 'capstone/arch/X86/X86IntelInstPrinter.c',
2384 'capstone/arch/X86/X86InstPrinterCommon.c',
2385 'capstone/arch/X86/X86Mapping.c',
2386 'capstone/arch/X86/X86Module.c'
2390 configure_file(output: 'capstone-defs.h', configuration: capstone_data)
2393 # FIXME: There does not seem to be a way to completely replace the c_args
2394 # that come from add_project_arguments() -- we can only add to them.
2395 # So: disable all warnings with a big hammer.
2398 # Include all configuration defines via a header file, which will wind up
2399 # as a dependency on the object file, and thus changes here will result
2401 '-include', 'capstone-defs.h'
2404 libcapstone = static_library('capstone',
2405 build_by_default: false,
2406 sources: capstone_files,
2407 c_args: capstone_cargs,
2408 include_directories: 'capstone/include')
2409 capstone = declare_dependency(link_with: libcapstone,
2410 include_directories: 'capstone/include/capstone')
2414 slirp_opt = 'disabled'
2416 slirp_opt = get_option('slirp')
2417 if slirp_opt in ['enabled', 'auto', 'system']
2418 have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2419 slirp = dependency('slirp', kwargs: static_kwargs,
2420 method: 'pkg-config',
2421 required: slirp_opt == 'system' or
2422 slirp_opt == 'enabled' and not have_internal)
2424 slirp_opt = 'system'
2426 slirp_opt = 'internal'
2428 slirp_opt = 'disabled'
2431 if slirp_opt == 'internal'
2433 if targetos == 'windows'
2434 slirp_deps = cc.find_library('iphlpapi')
2435 elif targetos == 'darwin'
2436 slirp_deps = cc.find_library('resolv')
2438 slirp_conf = configuration_data()
2439 slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2440 slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2441 slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2442 slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2443 slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2445 'slirp/src/arp_table.c',
2446 'slirp/src/bootp.c',
2447 'slirp/src/cksum.c',
2448 'slirp/src/dhcpv6.c',
2449 'slirp/src/dnssearch.c',
2451 'slirp/src/ip6_icmp.c',
2452 'slirp/src/ip6_input.c',
2453 'slirp/src/ip6_output.c',
2454 'slirp/src/ip_icmp.c',
2455 'slirp/src/ip_input.c',
2456 'slirp/src/ip_output.c',
2460 'slirp/src/ndp_table.c',
2462 'slirp/src/slirp.c',
2463 'slirp/src/socket.c',
2464 'slirp/src/state.c',
2465 'slirp/src/stream.c',
2466 'slirp/src/tcp_input.c',
2467 'slirp/src/tcp_output.c',
2468 'slirp/src/tcp_subr.c',
2469 'slirp/src/tcp_timer.c',
2474 'slirp/src/version.c',
2475 'slirp/src/vmstate.c',
2479 input : 'slirp/src/libslirp-version.h.in',
2480 output : 'libslirp-version.h',
2481 configuration: slirp_conf)
2483 slirp_inc = include_directories('slirp', 'slirp/src')
2484 libslirp = static_library('slirp',
2485 build_by_default: false,
2486 sources: slirp_files,
2487 c_args: slirp_cargs,
2488 include_directories: slirp_inc)
2489 slirp = declare_dependency(link_with: libslirp,
2490 dependencies: slirp_deps,
2491 include_directories: slirp_inc)
2495 # For CFI, we need to compile slirp as a static library together with qemu.
2496 # This is because we register slirp functions as callbacks for QEMU Timers.
2497 # When using a system-wide shared libslirp, the type information for the
2498 # callback is missing and the timer call produces a false positive with CFI.
2500 # Now that slirp_opt has been defined, check if the selected slirp is compatible
2501 # with control-flow integrity.
2502 if get_option('cfi') and slirp_opt == 'system'
2503 error('Control-Flow Integrity is not compatible with system-wide slirp.' \
2504 + ' Please configure with --enable-slirp=git')
2509 fdt_opt = get_option('fdt')
2510 if fdt_opt in ['enabled', 'auto', 'system']
2511 have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2512 fdt = cc.find_library('fdt', kwargs: static_kwargs,
2513 required: fdt_opt == 'system' or
2514 fdt_opt == 'enabled' and not have_internal)
2515 if fdt.found() and cc.links('''
2517 #include <libfdt_env.h>
2518 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2521 elif fdt_opt == 'system'
2522 error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2524 fdt_opt = 'internal'
2526 fdt_opt = 'disabled'
2530 if fdt_opt == 'internal'
2533 'dtc/libfdt/fdt_ro.c',
2534 'dtc/libfdt/fdt_wip.c',
2535 'dtc/libfdt/fdt_sw.c',
2536 'dtc/libfdt/fdt_rw.c',
2537 'dtc/libfdt/fdt_strerror.c',
2538 'dtc/libfdt/fdt_empty_tree.c',
2539 'dtc/libfdt/fdt_addresses.c',
2540 'dtc/libfdt/fdt_overlay.c',
2541 'dtc/libfdt/fdt_check.c',
2544 fdt_inc = include_directories('dtc/libfdt')
2545 libfdt = static_library('fdt',
2546 build_by_default: false,
2548 include_directories: fdt_inc)
2549 fdt = declare_dependency(link_with: libfdt,
2550 include_directories: fdt_inc)
2553 fdt_opt = 'disabled'
2555 if not fdt.found() and fdt_required.length() > 0
2556 error('fdt not available but required by targets ' + ', '.join(fdt_required))
2559 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2560 config_host_data.set('CONFIG_FDT', fdt.found())
2561 config_host_data.set('CONFIG_SLIRP', slirp.found())
2563 #####################
2564 # Generated sources #
2565 #####################
2567 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2569 hxtool = find_program('scripts/hxtool')
2570 shaderinclude = find_program('scripts/shaderinclude.pl')
2571 qapi_gen = find_program('scripts/qapi-gen.py')
2572 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2573 meson.current_source_dir() / 'scripts/qapi/commands.py',
2574 meson.current_source_dir() / 'scripts/qapi/common.py',
2575 meson.current_source_dir() / 'scripts/qapi/error.py',
2576 meson.current_source_dir() / 'scripts/qapi/events.py',
2577 meson.current_source_dir() / 'scripts/qapi/expr.py',
2578 meson.current_source_dir() / 'scripts/qapi/gen.py',
2579 meson.current_source_dir() / 'scripts/qapi/introspect.py',
2580 meson.current_source_dir() / 'scripts/qapi/parser.py',
2581 meson.current_source_dir() / 'scripts/qapi/schema.py',
2582 meson.current_source_dir() / 'scripts/qapi/source.py',
2583 meson.current_source_dir() / 'scripts/qapi/types.py',
2584 meson.current_source_dir() / 'scripts/qapi/visit.py',
2585 meson.current_source_dir() / 'scripts/qapi/common.py',
2586 meson.current_source_dir() / 'scripts/qapi-gen.py'
2590 python, files('scripts/tracetool.py'),
2591 '--backend=' + ','.join(get_option('trace_backends'))
2593 tracetool_depends = files(
2594 'scripts/tracetool/backend/log.py',
2595 'scripts/tracetool/backend/__init__.py',
2596 'scripts/tracetool/backend/dtrace.py',
2597 'scripts/tracetool/backend/ftrace.py',
2598 'scripts/tracetool/backend/simple.py',
2599 'scripts/tracetool/backend/syslog.py',
2600 'scripts/tracetool/backend/ust.py',
2601 'scripts/tracetool/format/ust_events_c.py',
2602 'scripts/tracetool/format/ust_events_h.py',
2603 'scripts/tracetool/format/__init__.py',
2604 'scripts/tracetool/format/d.py',
2605 'scripts/tracetool/format/simpletrace_stap.py',
2606 'scripts/tracetool/format/c.py',
2607 'scripts/tracetool/format/h.py',
2608 'scripts/tracetool/format/log_stap.py',
2609 'scripts/tracetool/format/stap.py',
2610 'scripts/tracetool/__init__.py',
2611 'scripts/tracetool/transform.py',
2612 'scripts/tracetool/vcpu.py'
2615 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2616 meson.current_source_dir(),
2617 config_host['PKGVERSION'], meson.project_version()]
2618 qemu_version = custom_target('qemu-version.h',
2619 output: 'qemu-version.h',
2620 command: qemu_version_cmd,
2622 build_by_default: true,
2623 build_always_stale: true)
2624 genh += qemu_version
2628 ['qemu-options.hx', 'qemu-options.def'],
2629 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2633 ['hmp-commands.hx', 'hmp-commands.h'],
2634 ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2637 foreach d : hx_headers
2638 hxdep += custom_target(d[1],
2642 build_by_default: true, # to be removed when added to a target
2643 command: [hxtool, '-h', '@INPUT0@'])
2651 authz_ss = ss.source_set()
2652 blockdev_ss = ss.source_set()
2653 block_ss = ss.source_set()
2654 chardev_ss = ss.source_set()
2655 common_ss = ss.source_set()
2656 crypto_ss = ss.source_set()
2657 hwcore_ss = ss.source_set()
2658 io_ss = ss.source_set()
2659 qmp_ss = ss.source_set()
2660 qom_ss = ss.source_set()
2661 softmmu_ss = ss.source_set()
2662 specific_fuzz_ss = ss.source_set()
2663 specific_ss = ss.source_set()
2664 stub_ss = ss.source_set()
2665 trace_ss = ss.source_set()
2666 user_ss = ss.source_set()
2667 util_ss = ss.source_set()
2670 qtest_module_ss = ss.source_set()
2671 tcg_module_ss = ss.source_set()
2677 target_softmmu_arch = {}
2678 target_user_arch = {}
2684 # TODO: add each directory to the subdirs from its own meson.build, once
2686 trace_events_subdirs = [
2694 trace_events_subdirs += [ 'linux-user' ]
2697 trace_events_subdirs += [ 'bsd-user' ]
2700 trace_events_subdirs += [
2709 trace_events_subdirs += [
2723 'hw/block/dataplane',
2773 if have_system or have_user
2774 trace_events_subdirs += [
2792 vhost_user = not_found
2793 if targetos == 'linux' and 'CONFIG_VHOST_USER' in config_host
2794 libvhost_user = subproject('libvhost-user')
2795 vhost_user = libvhost_user.get_variable('vhost_user_dep')
2798 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
2799 # that is filled in by qapi/.
2812 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2813 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2816 stub_ss = stub_ss.apply(config_all, strict: false)
2818 util_ss.add_all(trace_ss)
2819 util_ss = util_ss.apply(config_all, strict: false)
2820 libqemuutil = static_library('qemuutil',
2821 sources: util_ss.sources() + stub_ss.sources() + genh,
2822 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2823 qemuutil = declare_dependency(link_with: libqemuutil,
2824 sources: genh + version_res)
2826 if have_system or have_user
2827 decodetree = generator(find_program('scripts/decodetree.py'),
2828 output: 'decode-@BASENAME@.c.inc',
2829 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2830 subdir('libdecnumber')
2847 if config_host_data.get('CONFIG_REPLICATION')
2848 block_ss.add(files('replication.c'))
2855 blockdev_ss.add(files(
2862 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2863 # os-win32.c does not
2864 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2865 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2868 common_ss.add(files('cpus-common.c'))
2872 common_ss.add(capstone)
2873 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2875 # Work around a gcc bug/misfeature wherein constant propagation looks
2877 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2878 # to guess that a const variable is always zero. Without lto, this is
2879 # impossible, as the alias is restricted to page-vary-common.c. Indeed,
2880 # without lto, not even the alias is required -- we simply use different
2881 # declarations in different compilation units.
2882 pagevary = files('page-vary-common.c')
2883 if get_option('b_lto')
2884 pagevary_flags = ['-fno-lto']
2885 if get_option('cfi')
2886 pagevary_flags += '-fno-sanitize=cfi-icall'
2888 pagevary = static_library('page-vary-common', sources: pagevary + genh,
2889 c_args: pagevary_flags)
2890 pagevary = declare_dependency(link_with: pagevary)
2892 common_ss.add(pagevary)
2893 specific_ss.add(files('page-vary.c'))
2901 subdir('semihosting')
2909 common_user_inc = []
2911 subdir('common-user')
2913 subdir('linux-user')
2915 # needed for fuzzing binaries
2916 subdir('tests/qtest/libqos')
2917 subdir('tests/qtest/fuzz')
2920 tcg_real_module_ss = ss.source_set()
2921 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2922 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2923 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2924 'tcg': tcg_real_module_ss }}
2926 ########################
2927 # Library dependencies #
2928 ########################
2930 modinfo_collect = find_program('scripts/modinfo-collect.py')
2931 modinfo_generate = find_program('scripts/modinfo-generate.py')
2936 foreach d, list : modules
2937 foreach m, module_ss : list
2938 if enable_modules and targetos != 'windows'
2939 module_ss = module_ss.apply(config_all, strict: false)
2940 sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2941 dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2947 if module_ss.sources() != []
2948 # FIXME: Should use sl.extract_all_objects(recursive: true) as
2949 # input. Sources can be used multiple times but objects are
2950 # unique when it comes to lookup in compile_commands.json.
2951 # Depnds on a mesion version with
2952 # https://github.com/mesonbuild/meson/pull/8900
2953 modinfo_files += custom_target(d + '-' + m + '.modinfo',
2954 output: d + '-' + m + '.modinfo',
2955 input: module_ss.sources() + genh,
2957 command: [modinfo_collect, module_ss.sources()])
2961 block_ss.add_all(module_ss)
2963 softmmu_ss.add_all(module_ss)
2969 foreach d, list : target_modules
2970 foreach m, module_ss : list
2971 if enable_modules and targetos != 'windows'
2972 foreach target : target_dirs
2973 if target.endswith('-softmmu')
2974 config_target = config_target_mak[target]
2975 config_target += config_host
2976 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2977 c_args = ['-DNEED_CPU_H',
2978 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2979 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2980 target_module_ss = module_ss.apply(config_target, strict: false)
2981 if target_module_ss.sources() != []
2982 module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2983 sl = static_library(module_name,
2984 [genh, target_module_ss.sources()],
2985 dependencies: [modulecommon, target_module_ss.dependencies()],
2986 include_directories: target_inc,
2990 # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2991 modinfo_files += custom_target(module_name + '.modinfo',
2992 output: module_name + '.modinfo',
2993 input: target_module_ss.sources() + genh,
2995 command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3000 specific_ss.add_all(module_ss)
3006 modinfo_src = custom_target('modinfo.c',
3007 output: 'modinfo.c',
3008 input: modinfo_files,
3009 command: [modinfo_generate, '@INPUT@'],
3011 modinfo_lib = static_library('modinfo', modinfo_src)
3012 modinfo_dep = declare_dependency(link_whole: modinfo_lib)
3013 softmmu_ss.add(modinfo_dep)
3016 nm = find_program('nm')
3017 undefsym = find_program('scripts/undefsym.py')
3018 block_syms = custom_target('block.syms', output: 'block.syms',
3019 input: [libqemuutil, block_mods],
3021 command: [undefsym, nm, '@INPUT@'])
3022 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3023 input: [libqemuutil, softmmu_mods],
3025 command: [undefsym, nm, '@INPUT@'])
3027 qom_ss = qom_ss.apply(config_host, strict: false)
3028 libqom = static_library('qom', qom_ss.sources() + genh,
3029 dependencies: [qom_ss.dependencies()],
3032 qom = declare_dependency(link_whole: libqom)
3034 authz_ss = authz_ss.apply(config_host, strict: false)
3035 libauthz = static_library('authz', authz_ss.sources() + genh,
3036 dependencies: [authz_ss.dependencies()],
3038 build_by_default: false)
3040 authz = declare_dependency(link_whole: libauthz,
3043 crypto_ss = crypto_ss.apply(config_host, strict: false)
3044 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3045 dependencies: [crypto_ss.dependencies()],
3047 build_by_default: false)
3049 crypto = declare_dependency(link_whole: libcrypto,
3050 dependencies: [authz, qom])
3052 io_ss = io_ss.apply(config_host, strict: false)
3053 libio = static_library('io', io_ss.sources() + genh,
3054 dependencies: [io_ss.dependencies()],
3055 link_with: libqemuutil,
3057 build_by_default: false)
3059 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3061 libmigration = static_library('migration', sources: migration_files + genh,
3063 build_by_default: false)
3064 migration = declare_dependency(link_with: libmigration,
3065 dependencies: [zlib, qom, io])
3066 softmmu_ss.add(migration)
3068 block_ss = block_ss.apply(config_host, strict: false)
3069 libblock = static_library('block', block_ss.sources() + genh,
3070 dependencies: block_ss.dependencies(),
3071 link_depends: block_syms,
3073 build_by_default: false)
3075 block = declare_dependency(link_whole: [libblock],
3076 link_args: '@block.syms',
3077 dependencies: [crypto, io])
3079 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3080 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3081 dependencies: blockdev_ss.dependencies(),
3083 build_by_default: false)
3085 blockdev = declare_dependency(link_whole: [libblockdev],
3086 dependencies: [block])
3088 qmp_ss = qmp_ss.apply(config_host, strict: false)
3089 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3090 dependencies: qmp_ss.dependencies(),
3092 build_by_default: false)
3094 qmp = declare_dependency(link_whole: [libqmp])
3096 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3098 dependencies: chardev_ss.dependencies(),
3099 build_by_default: false)
3101 chardev = declare_dependency(link_whole: libchardev)
3103 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3104 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3106 build_by_default: false)
3107 hwcore = declare_dependency(link_whole: libhwcore)
3108 common_ss.add(hwcore)
3114 emulator_modules = []
3115 foreach m : block_mods + softmmu_mods
3116 emulator_modules += shared_module(m.name(),
3117 build_by_default: true,
3121 install_dir: qemu_moddir)
3124 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3125 common_ss.add(qom, qemuutil)
3127 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3128 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3130 common_all = common_ss.apply(config_all, strict: false)
3131 common_all = static_library('common',
3132 build_by_default: false,
3133 sources: common_all.sources() + genh,
3134 include_directories: common_user_inc,
3135 implicit_include_directories: false,
3136 dependencies: common_all.dependencies(),
3139 feature_to_c = find_program('scripts/feature_to_c.sh')
3141 if targetos == 'darwin'
3142 entitlement = find_program('scripts/entitlement.sh')
3146 foreach target : target_dirs
3147 config_target = config_target_mak[target]
3148 target_name = config_target['TARGET_NAME']
3149 target_base_arch = config_target['TARGET_BASE_ARCH']
3150 arch_srcs = [config_target_h[target]]
3152 c_args = ['-DNEED_CPU_H',
3153 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3154 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3155 link_args = emulator_link_args
3157 config_target += config_host
3158 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3159 if targetos == 'linux'
3160 target_inc += include_directories('linux-headers', is_system: true)
3162 if target.endswith('-softmmu')
3163 qemu_target_name = 'qemu-system-' + target_name
3164 target_type='system'
3165 t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3166 arch_srcs += t.sources()
3167 arch_deps += t.dependencies()
3169 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3170 hw = hw_arch[hw_dir].apply(config_target, strict: false)
3171 arch_srcs += hw.sources()
3172 arch_deps += hw.dependencies()
3174 arch_srcs += config_devices_h[target]
3175 link_args += ['@block.syms', '@qemu.syms']
3177 abi = config_target['TARGET_ABI_DIR']
3179 target_inc += common_user_inc
3180 qemu_target_name = 'qemu-' + target_name
3181 if target_base_arch in target_user_arch
3182 t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3183 arch_srcs += t.sources()
3184 arch_deps += t.dependencies()
3186 if 'CONFIG_LINUX_USER' in config_target
3187 base_dir = 'linux-user'
3189 if 'CONFIG_BSD_USER' in config_target
3190 base_dir = 'bsd-user'
3191 target_inc += include_directories('bsd-user/' / targetos)
3192 target_inc += include_directories('bsd-user/host/' / host_arch)
3193 dir = base_dir / abi
3194 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3196 target_inc += include_directories(
3200 if 'CONFIG_LINUX_USER' in config_target
3201 dir = base_dir / abi
3202 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3203 if config_target.has_key('TARGET_SYSTBL_ABI')
3205 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3206 extra_args : config_target['TARGET_SYSTBL_ABI'])
3211 if 'TARGET_XML_FILES' in config_target
3212 gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3213 output: target + '-gdbstub-xml.c',
3214 input: files(config_target['TARGET_XML_FILES'].split()),
3215 command: [feature_to_c, '@INPUT@'],
3217 arch_srcs += gdbstub_xml
3220 t = target_arch[target_base_arch].apply(config_target, strict: false)
3221 arch_srcs += t.sources()
3222 arch_deps += t.dependencies()
3224 target_common = common_ss.apply(config_target, strict: false)
3225 objects = common_all.extract_objects(target_common.sources())
3226 deps = target_common.dependencies()
3228 target_specific = specific_ss.apply(config_target, strict: false)
3229 arch_srcs += target_specific.sources()
3230 arch_deps += target_specific.dependencies()
3232 lib = static_library('qemu-' + target,
3233 sources: arch_srcs + genh,
3234 dependencies: arch_deps,
3236 include_directories: target_inc,
3238 build_by_default: false,
3241 if target.endswith('-softmmu')
3243 'name': 'qemu-system-' + target_name,
3244 'win_subsystem': 'console',
3245 'sources': files('softmmu/main.c'),
3248 if targetos == 'windows' and (sdl.found() or gtk.found())
3250 'name': 'qemu-system-' + target_name + 'w',
3251 'win_subsystem': 'windows',
3252 'sources': files('softmmu/main.c'),
3256 if get_option('fuzzing')
3257 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3259 'name': 'qemu-fuzz-' + target_name,
3260 'win_subsystem': 'console',
3261 'sources': specific_fuzz.sources(),
3262 'dependencies': specific_fuzz.dependencies(),
3267 'name': 'qemu-' + target_name,
3268 'win_subsystem': 'console',
3274 exe_name = exe['name']
3275 if targetos == 'darwin'
3276 exe_name += '-unsigned'
3279 emulator = executable(exe_name, exe['sources'],
3282 dependencies: arch_deps + deps + exe['dependencies'],
3283 objects: lib.extract_all_objects(recursive: true),
3284 link_language: link_language,
3285 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3286 link_args: link_args,
3287 win_subsystem: exe['win_subsystem'])
3289 if targetos == 'darwin'
3290 icon = 'pc-bios/qemu.rsrc'
3291 build_input = [emulator, files(icon)]
3293 get_option('bindir') / exe_name,
3294 meson.current_source_dir() / icon
3296 if 'CONFIG_HVF' in config_target
3297 entitlements = 'accel/hvf/entitlements.plist'
3298 build_input += files(entitlements)
3299 install_input += meson.current_source_dir() / entitlements
3302 emulators += {exe['name'] : custom_target(exe['name'],
3304 output: exe['name'],
3305 command: [entitlement, '@OUTPUT@', '@INPUT@'])
3308 meson.add_install_script(entitlement, '--install',
3309 get_option('bindir') / exe['name'],
3312 emulators += {exe['name']: emulator}
3317 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3318 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3319 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3320 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3322 custom_target(exe['name'] + stp['ext'],
3323 input: trace_events_all,
3324 output: exe['name'] + stp['ext'],
3325 install: stp['install'],
3326 install_dir: get_option('datadir') / 'systemtap/tapset',
3328 tracetool, '--group=all', '--format=' + stp['fmt'],
3329 '--binary=' + stp['bin'],
3330 '--target-name=' + target_name,
3331 '--target-type=' + target_type,
3332 '--probe-prefix=qemu.' + target_type + '.' + target_name,
3333 '@INPUT@', '@OUTPUT@'
3335 depend_files: tracetool_depends)
3341 # Other build targets
3343 if 'CONFIG_PLUGIN' in config_host
3344 install_headers('include/qemu/qemu-plugin.h')
3349 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3350 # when we don't build tools or system
3351 if xkbcommon.found()
3352 # used for the update-keymaps target, so include rules even if !have_tools
3353 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3354 dependencies: [qemuutil, xkbcommon], install: have_tools)
3358 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3359 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3360 qemu_io = executable('qemu-io', files('qemu-io.c'),
3361 dependencies: [block, qemuutil], install: true)
3362 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3363 dependencies: [blockdev, qemuutil, gnutls, selinux],
3366 subdir('storage-daemon')
3367 subdir('contrib/rdmacm-mux')
3368 subdir('contrib/elf2dmp')
3370 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3371 dependencies: qemuutil,
3374 if 'CONFIG_VHOST_USER' in config_host
3375 subdir('contrib/vhost-user-blk')
3376 subdir('contrib/vhost-user-gpu')
3377 subdir('contrib/vhost-user-input')
3378 subdir('contrib/vhost-user-scsi')
3381 if targetos == 'linux'
3382 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3383 dependencies: [qemuutil, libcap_ng],
3385 install_dir: get_option('libexecdir'))
3387 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3388 dependencies: [authz, crypto, io, qom, qemuutil,
3389 libcap_ng, mpathpersist],
3394 subdir('contrib/ivshmem-client')
3395 subdir('contrib/ivshmem-server')
3408 if host_machine.system() == 'windows'
3410 find_program('scripts/nsis.py'),
3412 get_option('prefix'),
3413 meson.current_source_dir(),
3416 '-DDISPLAYVERSION=' + meson.project_version(),
3419 nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3422 nsis_cmd += '-DCONFIG_GTK=y'
3425 nsis = custom_target('nsis',
3426 output: 'qemu-setup-' + meson.project_version() + '.exe',
3427 input: files('qemu.nsi'),
3428 build_always_stale: true,
3429 command: nsis_cmd + ['@INPUT@'])
3430 alias_target('installer', nsis)
3433 #########################
3434 # Configuration summary #
3435 #########################
3439 summary_info += {'Install prefix': get_option('prefix')}
3440 summary_info += {'BIOS directory': qemu_datadir}
3441 summary_info += {'firmware path': get_option('qemu_firmwarepath')}
3442 summary_info += {'binary directory': get_option('bindir')}
3443 summary_info += {'library directory': get_option('libdir')}
3444 summary_info += {'module directory': qemu_moddir}
3445 summary_info += {'libexec directory': get_option('libexecdir')}
3446 summary_info += {'include directory': get_option('includedir')}
3447 summary_info += {'config directory': get_option('sysconfdir')}
3448 if targetos != 'windows'
3449 summary_info += {'local state directory': get_option('localstatedir')}
3450 summary_info += {'Manual directory': get_option('mandir')}
3452 summary_info += {'local state directory': 'queried at runtime'}
3454 summary_info += {'Doc directory': get_option('docdir')}
3455 summary_info += {'Build directory': meson.current_build_dir()}
3456 summary_info += {'Source path': meson.current_source_dir()}
3457 summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']}
3458 summary(summary_info, bool_yn: true, section: 'Directories')
3462 summary_info += {'git': config_host['GIT']}
3463 summary_info += {'make': config_host['MAKE']}
3464 summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3465 summary_info += {'sphinx-build': sphinx_build}
3466 if config_host.has_key('HAVE_GDB_BIN')
3467 summary_info += {'gdb': config_host['HAVE_GDB_BIN']}
3469 if get_option('iasl') != ''
3470 summary_info += {'iasl': get_option('iasl')}
3472 summary_info += {'iasl': false}
3474 summary_info += {'genisoimage': config_host['GENISOIMAGE']}
3475 if targetos == 'windows' and have_ga
3476 summary_info += {'wixl': wixl}
3478 if slirp_opt != 'disabled' and have_system
3479 summary_info += {'smbd': have_slirp_smbd ? smbd_path : false}
3481 summary(summary_info, bool_yn: true, section: 'Host binaries')
3483 # Configurable features
3485 summary_info += {'Documentation': build_docs}
3486 summary_info += {'system-mode emulation': have_system}
3487 summary_info += {'user-mode emulation': have_user}
3488 summary_info += {'block layer': have_block}
3489 summary_info += {'Install blobs': get_option('install_blobs')}
3490 summary_info += {'module support': config_host.has_key('CONFIG_MODULES')}
3491 if config_host.has_key('CONFIG_MODULES')
3492 summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
3494 summary_info += {'fuzzing support': get_option('fuzzing')}
3496 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)}
3498 summary_info += {'Trace backends': ','.join(get_option('trace_backends'))}
3499 if 'simple' in get_option('trace_backends')
3500 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3502 summary_info += {'D-Bus display': dbus_display}
3503 summary_info += {'QOM debugging': get_option('qom_cast_debug')}
3504 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
3505 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
3506 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
3507 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
3508 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
3509 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
3510 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3511 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
3512 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
3513 summary_info += {'build guest agent': have_ga}
3514 summary(summary_info, bool_yn: true, section: 'Configurable features')
3516 # Compilation information
3518 summary_info += {'host CPU': cpu}
3519 summary_info += {'host endianness': build_machine.endian()}
3520 summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())}
3521 summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3522 if link_language == 'cpp'
3523 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())}
3525 summary_info += {'C++ compiler': false}
3527 if targetos == 'darwin'
3528 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3530 summary_info += {'CFLAGS': ' '.join(get_option('c_args')
3531 + ['-O' + get_option('optimization')]
3532 + (get_option('debug') ? ['-g'] : []))}
3533 if link_language == 'cpp'
3534 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args')
3535 + ['-O' + get_option('optimization')]
3536 + (get_option('debug') ? ['-g'] : []))}
3538 if targetos == 'darwin'
3539 summary_info += {'OBJCFLAGS': ' '.join(get_option('objc_args')
3540 + ['-O' + get_option('optimization')]
3541 + (get_option('debug') ? ['-g'] : []))}
3543 link_args = get_option(link_language + '_link_args')
3544 if link_args.length() > 0
3545 summary_info += {'LDFLAGS': ' '.join(link_args)}
3547 summary_info += {'QEMU_CFLAGS': config_host['QEMU_CFLAGS']}
3548 summary_info += {'QEMU_CXXFLAGS': config_host['QEMU_CXXFLAGS']}
3549 summary_info += {'QEMU_OBJCFLAGS': config_host['QEMU_OBJCFLAGS']}
3550 summary_info += {'QEMU_LDFLAGS': config_host['QEMU_LDFLAGS']}
3551 summary_info += {'profiler': get_option('profiler')}
3552 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3553 summary_info += {'PIE': get_option('b_pie')}
3554 summary_info += {'static build': config_host.has_key('CONFIG_STATIC')}
3555 summary_info += {'malloc trim support': has_malloc_trim}
3556 summary_info += {'membarrier': have_membarrier}
3557 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
3558 summary_info += {'mutex debugging': get_option('debug_mutex')}
3559 summary_info += {'memory allocator': get_option('malloc')}
3560 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
3561 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
3562 summary_info += {'gprof enabled': get_option('gprof')}
3563 summary_info += {'gcov': get_option('b_coverage')}
3564 summary_info += {'thread sanitizer': config_host.has_key('CONFIG_TSAN')}
3565 summary_info += {'CFI support': get_option('cfi')}
3566 if get_option('cfi')
3567 summary_info += {'CFI debug support': get_option('cfi_debug')}
3569 summary_info += {'strip binaries': get_option('strip')}
3570 summary_info += {'sparse': sparse}
3571 summary_info += {'mingw32 support': targetos == 'windows'}
3573 # snarf the cross-compilation information for tests
3574 foreach target: target_dirs
3575 tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3576 if fs.exists(tcg_mak)
3577 config_cross_tcg = keyval.load(tcg_mak)
3578 target = config_cross_tcg['TARGET_NAME']
3580 if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
3581 summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
3582 ' via ' + config_cross_tcg['DOCKER_IMAGE']}
3583 elif 'CROSS_CC_GUEST' in config_cross_tcg
3584 summary_info += {target + ' tests'
3585 : config_cross_tcg['CROSS_CC_GUEST'] }
3590 summary(summary_info, bool_yn: true, section: 'Compilation')
3592 # Targets and accelerators
3595 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')}
3596 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')}
3597 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')}
3598 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')}
3599 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')}
3600 summary_info += {'Xen support': config_host.has_key('CONFIG_XEN_BACKEND')}
3601 if config_host.has_key('CONFIG_XEN_BACKEND')
3602 summary_info += {'xen ctrl version': config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
3605 summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')}
3606 if config_all.has_key('CONFIG_TCG')
3607 if get_option('tcg_interpreter')
3608 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'}
3610 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)}
3612 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3613 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3615 summary_info += {'target list': ' '.join(target_dirs)}
3617 summary_info += {'default devices': get_option('default_devices')}
3618 summary_info += {'out of process emulation': multiprocess_allowed}
3620 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3624 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3625 summary_info += {'coroutine pool': have_coroutine_pool}
3627 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3628 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3629 summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
3630 summary_info += {'VirtFS support': have_virtfs}
3631 summary_info += {'build virtiofs daemon': have_virtiofsd}
3632 summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
3633 summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
3634 summary_info += {'bochs support': get_option('bochs').allowed()}
3635 summary_info += {'cloop support': get_option('cloop').allowed()}
3636 summary_info += {'dmg support': get_option('dmg').allowed()}
3637 summary_info += {'qcow v1 support': get_option('qcow1').allowed()}
3638 summary_info += {'vdi support': get_option('vdi').allowed()}
3639 summary_info += {'vvfat support': get_option('vvfat').allowed()}
3640 summary_info += {'qed support': get_option('qed').allowed()}
3641 summary_info += {'parallels support': get_option('parallels').allowed()}
3642 summary_info += {'FUSE exports': fuse}
3644 summary(summary_info, bool_yn: true, section: 'Block layer support')
3648 summary_info += {'TLS priority': config_host['CONFIG_TLS_PRIORITY']}
3649 summary_info += {'GNUTLS support': gnutls}
3651 summary_info += {' GNUTLS crypto': gnutls_crypto.found()}
3653 summary_info += {'libgcrypt': gcrypt}
3654 summary_info += {'nettle': nettle}
3656 summary_info += {' XTS': xts != 'private'}
3658 summary_info += {'AF_ALG support': have_afalg}
3659 summary_info += {'rng-none': get_option('rng_none')}
3660 summary_info += {'Linux keyring': config_host.has_key('CONFIG_SECRET_KEYRING')}
3661 summary(summary_info, bool_yn: true, section: 'Crypto')
3665 if targetos == 'darwin'
3666 summary_info += {'Cocoa support': cocoa}
3668 summary_info += {'SDL support': sdl}
3669 summary_info += {'SDL image support': sdl_image}
3670 summary_info += {'GTK support': gtk}
3671 summary_info += {'pixman': pixman}
3672 summary_info += {'VTE support': vte}
3673 summary_info += {'slirp support': slirp_opt == 'internal' ? slirp_opt : slirp}
3674 summary_info += {'libtasn1': tasn1}
3675 summary_info += {'PAM': pam}
3676 summary_info += {'iconv support': iconv}
3677 summary_info += {'curses support': curses}
3678 summary_info += {'virgl support': virgl}
3679 summary_info += {'curl support': curl}
3680 summary_info += {'Multipath support': mpathpersist}
3681 summary_info += {'VNC support': vnc}
3683 summary_info += {'VNC SASL support': sasl}
3684 summary_info += {'VNC JPEG support': jpeg}
3685 summary_info += {'VNC PNG support': png}
3687 if targetos not in ['darwin', 'haiku', 'windows']
3688 summary_info += {'OSS support': oss}
3689 elif targetos == 'darwin'
3690 summary_info += {'CoreAudio support': coreaudio}
3691 elif targetos == 'windows'
3692 summary_info += {'DirectSound support': dsound}
3694 if targetos == 'linux'
3695 summary_info += {'ALSA support': alsa}
3696 summary_info += {'PulseAudio support': pulse}
3698 summary_info += {'JACK support': jack}
3699 summary_info += {'brlapi support': brlapi}
3700 summary_info += {'vde support': vde}
3701 summary_info += {'netmap support': have_netmap}
3702 summary_info += {'l2tpv3 support': have_l2tpv3}
3703 summary_info += {'Linux AIO support': libaio}
3704 summary_info += {'Linux io_uring support': linux_io_uring}
3705 summary_info += {'ATTR/XATTR support': libattr}
3706 summary_info += {'RDMA support': config_host.has_key('CONFIG_RDMA')}
3707 summary_info += {'PVRDMA support': config_host.has_key('CONFIG_PVRDMA')}
3708 summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt}
3709 summary_info += {'libcap-ng support': libcap_ng}
3710 summary_info += {'bpf support': libbpf}
3711 summary_info += {'spice protocol support': spice_protocol}
3712 if spice_protocol.found()
3713 summary_info += {' spice server support': spice}
3715 summary_info += {'rbd support': rbd}
3716 summary_info += {'smartcard support': cacard}
3717 summary_info += {'U2F support': u2f}
3718 summary_info += {'libusb': libusb}
3719 summary_info += {'usb net redir': usbredir}
3720 summary_info += {'OpenGL support': config_host.has_key('CONFIG_OPENGL')}
3721 summary_info += {'GBM': gbm}
3722 summary_info += {'libiscsi support': libiscsi}
3723 summary_info += {'libnfs support': libnfs}
3724 if targetos == 'windows'
3726 summary_info += {'QGA VSS support': have_qga_vss}
3727 summary_info += {'QGA w32 disk info': have_ntddscsi}
3730 summary_info += {'seccomp support': seccomp}
3731 summary_info += {'GlusterFS support': glusterfs}
3732 summary_info += {'TPM support': have_tpm}
3733 summary_info += {'libssh support': libssh}
3734 summary_info += {'lzo support': lzo}
3735 summary_info += {'snappy support': snappy}
3736 summary_info += {'bzip2 support': libbzip2}
3737 summary_info += {'lzfse support': liblzfse}
3738 summary_info += {'zstd support': zstd}
3739 summary_info += {'NUMA host support': numa}
3740 summary_info += {'capstone': capstone_opt == 'internal' ? capstone_opt : capstone}
3741 summary_info += {'libpmem support': libpmem}
3742 summary_info += {'libdaxctl support': libdaxctl}
3743 summary_info += {'libudev': libudev}
3744 # Dummy dependency, keep .found()
3745 summary_info += {'FUSE lseek': fuse_lseek.found()}
3746 summary_info += {'selinux': selinux}
3747 summary(summary_info, bool_yn: true, section: 'Dependencies')
3749 if not supported_cpus.contains(cpu)
3751 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3753 message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3754 message('The QEMU project intends to remove support for this host CPU in')
3755 message('a future release if nobody volunteers to maintain it and to')
3756 message('provide a build host for our continuous integration setup.')
3757 message('configure has succeeded and you can continue to build, but')
3758 message('if you care about QEMU on this platform you should contact')
3759 message('us upstream at qemu-devel@nongnu.org.')
3762 if not supported_oses.contains(targetos)
3764 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3766 message('Host OS ' + targetos + 'support is not currently maintained.')
3767 message('The QEMU project intends to remove support for this host OS in')
3768 message('a future release if nobody volunteers to maintain it and to')
3769 message('provide a build host for our continuous integration setup.')
3770 message('configure has succeeded and you can continue to build, but')
3771 message('if you care about QEMU on this platform you should contact')
3772 message('us upstream at qemu-devel@nongnu.org.')