1 project('qemu', ['c'], meson_version: '>=0.58.2',
2 default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto',
3 'b_staticpic=false', 'stdsplit=false'],
4 version: files('VERSION'))
6 add_test_setup('quick', exclude_suites: ['block', 'slow', 'thorough'], is_default: true)
7 add_test_setup('slow', exclude_suites: ['block', 'thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
8 add_test_setup('thorough', exclude_suites: ['block'], env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
10 not_found = dependency('', required: false)
11 keyval = import('keyval')
12 ss = import('sourceset')
15 sh = find_program('sh')
16 cc = meson.get_compiler('c')
17 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
18 enable_modules = 'CONFIG_MODULES' in config_host
19 enable_static = 'CONFIG_STATIC' in config_host
21 # Allow both shared and static libraries unless --enable-static
22 static_kwargs = enable_static ? {'static': true} : {}
24 # Temporary directory used for files created while
25 # configure runs. Since it is in the build directory
26 # we can safely blow away any previous version of it
27 # (and we need not jump through hoops to try to delete
28 # it when configure exits.)
29 tmpdir = meson.current_build_dir() / 'meson-private/temp'
31 if get_option('qemu_suffix').startswith('/')
32 error('qemu_suffix cannot start with a /')
35 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
36 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
37 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
38 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
40 qemu_desktopdir = get_option('datadir') / 'applications'
41 qemu_icondir = get_option('datadir') / 'icons'
43 config_host_data = configuration_data()
45 qapi_trace_events = []
47 target_dirs = config_host['TARGET_DIRS'].split()
48 have_linux_user = false
51 foreach target : target_dirs
52 have_linux_user = have_linux_user or target.endswith('linux-user')
53 have_bsd_user = have_bsd_user or target.endswith('bsd-user')
54 have_system = have_system or target.endswith('-softmmu')
56 have_user = have_linux_user or have_bsd_user
57 have_tools = 'CONFIG_TOOLS' in config_host
58 have_block = have_system or have_tools
60 python = import('python').find_installation()
62 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
63 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv', 'x86', 'x86_64',
64 'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc', 'sparc64']
66 cpu = host_machine.cpu_family()
68 # Unify riscv* to a single family.
69 if cpu in ['riscv32', 'riscv64']
73 targetos = host_machine.system()
75 if cpu not in supported_cpus
85 if cpu in ['x86', 'x86_64']
86 kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
88 kvm_targets = ['aarch64-softmmu']
90 kvm_targets = ['s390x-softmmu']
91 elif cpu in ['ppc', 'ppc64']
92 kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
93 elif cpu in ['mips', 'mips64']
94 kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
96 kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu']
102 if not get_option('kvm').disabled() and targetos == 'linux'
103 kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"'
105 config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c)
107 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
109 if cpu in ['aarch64']
110 accelerator_targets += {
111 'CONFIG_HVF': ['aarch64-softmmu']
115 if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
116 # i386 emulator provides xenpv machine type for multiple architectures
117 accelerator_targets += {
118 'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
121 if cpu in ['x86', 'x86_64']
122 accelerator_targets += {
123 'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
124 'CONFIG_HVF': ['x86_64-softmmu'],
125 'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
126 'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
131 # Darwin does not support references to thread-local variables in modules
132 if targetos != 'darwin'
133 modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
136 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
137 unpack_edk2_blobs = false
138 foreach target : edk2_targets
139 if target in target_dirs
140 bzip2 = find_program('bzip2', required: get_option('install_blobs'))
141 unpack_edk2_blobs = bzip2.found()
148 if 'dtrace' in get_option('trace_backends')
149 dtrace = find_program('dtrace', required: true)
150 stap = find_program('stap', required: false)
152 # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
153 # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
154 # instead. QEMU --enable-modules depends on this because the SystemTap
155 # semaphores are linked into the main binary and not the module's shared
157 add_global_arguments('-DSTAP_SDT_V2',
158 native: false, language: ['c', 'cpp', 'objc'])
166 # Specify linker-script with add_project_link_arguments so that it is not placed
167 # within a linker --start-group/--end-group pair
168 if get_option('fuzzing')
169 add_project_link_arguments(['-Wl,-T,',
170 (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
171 native: false, language: ['c', 'cpp', 'objc'])
173 # Specify a filter to only instrument code that is directly related to
175 configure_file(output: 'instrumentation-filter',
176 input: 'scripts/oss-fuzz/instrumentation-filter-template',
178 add_global_arguments(
179 cc.get_supported_arguments('-fsanitize-coverage-allowlist=instrumentation-filter'),
180 native: false, language: ['c', 'cpp', 'objc'])
182 if get_option('fuzzing_engine') == ''
183 # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
184 # compiled code. To build non-fuzzer binaries with --enable-fuzzing, link
185 # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
186 # unable to bind the fuzzer-related callbacks added by instrumentation.
187 add_global_arguments('-fsanitize=fuzzer-no-link',
188 native: false, language: ['c', 'cpp', 'objc'])
189 add_global_link_arguments('-fsanitize=fuzzer-no-link',
190 native: false, language: ['c', 'cpp', 'objc'])
191 # For the actual fuzzer binaries, we need to link against the libfuzzer
192 # library. They need to be configurable, to support OSS-Fuzz
193 fuzz_exe_ldflags = ['-fsanitize=fuzzer']
195 # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
196 # the needed CFLAGS have already been provided
197 fuzz_exe_ldflags = get_option('fuzzing_engine').split()
201 add_global_arguments(config_host['QEMU_CFLAGS'].split(),
202 native: false, language: ['c', 'objc'])
203 add_global_arguments(config_host['QEMU_CXXFLAGS'].split(),
204 native: false, language: 'cpp')
205 add_global_link_arguments(config_host['QEMU_LDFLAGS'].split(),
206 native: false, language: ['c', 'cpp', 'objc'])
208 if targetos == 'linux'
209 add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
210 '-isystem', 'linux-headers',
211 language: ['c', 'cpp'])
214 add_project_arguments('-iquote', '.',
215 '-iquote', meson.current_source_dir(),
216 '-iquote', meson.current_source_dir() / 'include',
217 '-iquote', meson.current_source_dir() / 'disas/libvixl',
218 language: ['c', 'cpp', 'objc'])
220 link_language = meson.get_external_property('link_language', 'cpp')
221 if link_language == 'cpp'
222 add_languages('cpp', required: true, native: false)
223 cxx = meson.get_compiler('cpp')
228 if host_machine.system() == 'darwin'
229 add_languages('objc', required: false, native: false)
232 sparse = find_program('cgcc', required: get_option('sparse'))
235 command: [find_program('scripts/check_sparse.py'),
236 'compile_commands.json', sparse.full_path(), '-Wbitwise',
237 '-Wno-transparent-union', '-Wno-old-initializer',
238 '-Wno-non-pointer-null'])
241 ###########################################
242 # Target-specific checks and dependencies #
243 ###########################################
246 if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
249 #include <sys/types.h>
250 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
251 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
253 args: ['-Werror', '-fsanitize=fuzzer'])
254 error('Your compiler does not support -fsanitize=fuzzer')
258 if 'ftrace' in get_option('trace_backends') and targetos != 'linux'
259 error('ftrace is supported only on Linux')
261 if 'syslog' in get_option('trace_backends') and not cc.compiles('''
264 openlog("qemu", LOG_PID, LOG_DAEMON);
265 syslog(LOG_INFO, "configure");
268 error('syslog is not supported on this system')
271 # Miscellaneous Linux-only features
272 if targetos != 'linux' and get_option('mpath').enabled()
273 error('Multipath is supported only on Linux')
276 if targetos != 'linux' and get_option('multiprocess').enabled()
277 error('Multiprocess QEMU is supported only on Linux')
279 multiprocess_allowed = targetos == 'linux' and not get_option('multiprocess').disabled()
281 # Target-specific libraries and flags
282 libm = cc.find_library('m', required: false)
283 threads = dependency('threads')
284 util = cc.find_library('util', required: false)
290 emulator_link_args = []
294 if targetos == 'windows'
295 socket = cc.find_library('ws2_32')
296 winmm = cc.find_library('winmm')
298 win = import('windows')
299 version_res = win.compile_resources('version.rc',
300 depend_files: files('pc-bios/qemu-nsis.ico'),
301 include_directories: include_directories('.'))
303 elif targetos == 'darwin'
304 coref = dependency('appleframeworks', modules: 'CoreFoundation')
305 iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
306 host_dsosuf = '.dylib'
307 elif targetos == 'sunos'
308 socket = [cc.find_library('socket'),
309 cc.find_library('nsl'),
310 cc.find_library('resolv')]
311 elif targetos == 'haiku'
312 socket = [cc.find_library('posix_error_mapper'),
313 cc.find_library('network'),
314 cc.find_library('bsd')]
315 elif targetos == 'openbsd'
316 if not get_option('tcg').disabled() and target_dirs.length() > 0
317 # Disable OpenBSD W^X if available
318 emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
322 # Target-specific configuration of accelerators
324 if not get_option('kvm').disabled() and targetos == 'linux'
325 accelerators += 'CONFIG_KVM'
327 if not get_option('xen').disabled() and 'CONFIG_XEN_BACKEND' in config_host
328 accelerators += 'CONFIG_XEN'
329 have_xen_pci_passthrough = not get_option('xen_pci_passthrough').disabled() and targetos == 'linux'
331 have_xen_pci_passthrough = false
333 if not get_option('whpx').disabled() and targetos == 'windows'
334 if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
335 error('WHPX requires 64-bit host')
336 elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
337 cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
338 accelerators += 'CONFIG_WHPX'
341 if not get_option('hvf').disabled()
342 hvf = dependency('appleframeworks', modules: 'Hypervisor',
343 required: get_option('hvf'))
345 accelerators += 'CONFIG_HVF'
348 if not get_option('hax').disabled()
349 if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
350 accelerators += 'CONFIG_HAX'
353 if targetos == 'netbsd'
354 nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
356 accelerators += 'CONFIG_NVMM'
361 if not get_option('tcg').disabled()
362 if host_arch == 'unknown'
363 if get_option('tcg_interpreter')
364 warning('Unsupported CPU @0@, will use TCG with TCI (slow)'.format(cpu))
366 error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
368 elif get_option('tcg_interpreter')
369 warning('Use of the TCG interpreter is not recommended on this host')
370 warning('architecture. There is a native TCG execution backend available')
371 warning('which provides substantially better performance and reliability.')
372 warning('It is strongly recommended to remove the --enable-tcg-interpreter')
373 warning('configuration option on this architecture to use the native')
376 if get_option('tcg_interpreter')
378 elif host_arch == 'sparc64'
380 elif host_arch == 'x86_64'
382 elif host_arch == 'ppc64'
385 add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
386 language: ['c', 'cpp', 'objc'])
388 accelerators += 'CONFIG_TCG'
389 config_host += { 'CONFIG_TCG': 'y' }
392 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
393 error('KVM not available on this platform')
395 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
396 error('HVF not available on this platform')
398 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
399 error('NVMM not available on this platform')
401 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
402 error('WHPX not available on this platform')
404 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
405 if 'CONFIG_XEN' in accelerators
406 error('Xen PCI passthrough not available on this platform')
408 error('Xen PCI passthrough requested but Xen not enabled')
416 # The path to glib.h is added to all compilation commands. This was
417 # grandfathered in from the QEMU Makefiles.
418 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
419 native: false, language: ['c', 'cpp', 'objc'])
420 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
421 link_args: config_host['GLIB_LIBS'].split(),
422 version: config_host['GLIB_VERSION'])
423 # override glib dep with the configure results (for subprojects)
424 meson.override_dependency('glib-2.0', glib)
427 if 'CONFIG_GIO' in config_host
428 gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
429 link_args: config_host['GIO_LIBS'].split(),
430 version: config_host['GLIB_VERSION'])
433 if 'ust' in get_option('trace_backends')
434 lttng = dependency('lttng-ust', required: true, method: 'pkg-config',
435 kwargs: static_kwargs)
438 if have_system or have_tools
439 pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
440 method: 'pkg-config', kwargs: static_kwargs)
442 zlib = dependency('zlib', required: true, kwargs: static_kwargs)
445 if not get_option('linux_aio').auto() or have_block
446 libaio = cc.find_library('aio', has_headers: ['libaio.h'],
447 required: get_option('linux_aio'),
448 kwargs: static_kwargs)
450 linux_io_uring = not_found
451 if not get_option('linux_io_uring').auto() or have_block
452 linux_io_uring = dependency('liburing', version: '>=0.3',
453 required: get_option('linux_io_uring'),
454 method: 'pkg-config', kwargs: static_kwargs)
457 if not get_option('libnfs').auto() or have_block
458 libnfs = dependency('libnfs', version: '>=1.9.3',
459 required: get_option('libnfs'),
460 method: 'pkg-config', kwargs: static_kwargs)
465 #include <sys/types.h>
466 #ifdef CONFIG_LIBATTR
467 #include <attr/xattr.h>
469 #include <sys/xattr.h>
471 int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
474 have_old_libattr = false
475 if not get_option('attr').disabled()
476 if cc.links(libattr_test)
477 libattr = declare_dependency()
479 libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
480 required: get_option('attr'),
481 kwargs: static_kwargs)
482 if libattr.found() and not \
483 cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
485 if get_option('attr').enabled()
486 error('could not link libattr')
488 warning('could not link libattr, disabling')
491 have_old_libattr = libattr.found()
496 cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
497 if cocoa.found() and get_option('sdl').enabled()
498 error('Cocoa and SDL cannot be enabled at the same time')
500 if cocoa.found() and get_option('gtk').enabled()
501 error('Cocoa and GTK+ cannot be enabled at the same time')
505 if not get_option('seccomp').auto() or have_system or have_tools
506 seccomp = dependency('libseccomp', version: '>=2.3.0',
507 required: get_option('seccomp'),
508 method: 'pkg-config', kwargs: static_kwargs)
511 libcap_ng = not_found
512 if not get_option('cap_ng').auto() or have_system or have_tools
513 libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
514 required: get_option('cap_ng'),
515 kwargs: static_kwargs)
517 if libcap_ng.found() and not cc.links('''
521 capng_capability_to_name(CAPNG_EFFECTIVE);
523 }''', dependencies: libcap_ng)
524 libcap_ng = not_found
525 if get_option('cap_ng').enabled()
526 error('could not link libcap-ng')
528 warning('could not link libcap-ng, disabling')
532 if get_option('xkbcommon').auto() and not have_system and not have_tools
533 xkbcommon = not_found
535 xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
536 method: 'pkg-config', kwargs: static_kwargs)
540 if not get_option('vde').auto() or have_system or have_tools
541 vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
542 required: get_option('vde'),
543 kwargs: static_kwargs)
545 if vde.found() and not cc.links('''
546 #include <libvdeplug.h>
549 struct vde_open_args a = {0, 0, 0};
553 }''', dependencies: vde)
555 if get_option('cap_ng').enabled()
556 error('could not link libvdeplug')
558 warning('could not link libvdeplug, disabling')
563 if not get_option('pa').auto() or (targetos == 'linux' and have_system)
564 pulse = dependency('libpulse', required: get_option('pa'),
565 method: 'pkg-config', kwargs: static_kwargs)
568 if not get_option('alsa').auto() or (targetos == 'linux' and have_system)
569 alsa = dependency('alsa', required: get_option('alsa'),
570 method: 'pkg-config', kwargs: static_kwargs)
573 if not get_option('jack').auto() or have_system
574 jack = dependency('jack', required: get_option('jack'),
575 method: 'pkg-config', kwargs: static_kwargs)
578 spice_protocol = not_found
579 if not get_option('spice_protocol').auto() or have_system
580 spice_protocol = dependency('spice-protocol', version: '>=0.12.3',
581 required: get_option('spice_protocol'),
582 method: 'pkg-config', kwargs: static_kwargs)
585 if not get_option('spice').auto() or have_system
586 spice = dependency('spice-server', version: '>=0.12.5',
587 required: get_option('spice'),
588 method: 'pkg-config', kwargs: static_kwargs)
590 spice_headers = spice.partial_dependency(compile_args: true, includes: true)
592 rt = cc.find_library('rt', required: false)
595 if not get_option('libiscsi').auto() or have_block
596 libiscsi = dependency('libiscsi', version: '>=1.9.0',
597 required: get_option('libiscsi'),
598 method: 'pkg-config', kwargs: static_kwargs)
601 if not get_option('zstd').auto() or have_block
602 zstd = dependency('libzstd', version: '>=1.4.0',
603 required: get_option('zstd'),
604 method: 'pkg-config', kwargs: static_kwargs)
607 if not get_option('virglrenderer').auto() or have_system
608 virgl = dependency('virglrenderer',
609 method: 'pkg-config',
610 required: get_option('virglrenderer'),
611 kwargs: static_kwargs)
614 if not get_option('curl').auto() or have_block
615 curl = dependency('libcurl', version: '>=7.29.0',
616 method: 'pkg-config',
617 required: get_option('curl'),
618 kwargs: static_kwargs)
621 if targetos == 'linux' and (have_system or have_tools)
622 libudev = dependency('libudev',
623 method: 'pkg-config',
624 required: get_option('libudev'),
625 kwargs: static_kwargs)
628 mpathlibs = [libudev]
629 mpathpersist = not_found
630 mpathpersist_new_api = false
631 if targetos == 'linux' and have_tools and not get_option('mpath').disabled()
632 mpath_test_source_new = '''
634 #include <mpath_persist.h>
635 unsigned mpath_mx_alloc_len = 1024;
637 static struct config *multipath_conf;
638 extern struct udev *udev;
639 extern struct config *get_multipath_config(void);
640 extern void put_multipath_config(struct config *conf);
642 struct config *get_multipath_config(void) { return multipath_conf; }
643 void put_multipath_config(struct config *conf) { }
646 multipath_conf = mpath_lib_init();
649 mpath_test_source_old = '''
651 #include <mpath_persist.h>
652 unsigned mpath_mx_alloc_len = 1024;
655 struct udev *udev = udev_new();
656 mpath_lib_init(udev);
659 libmpathpersist = cc.find_library('mpathpersist',
660 required: get_option('mpath'),
661 kwargs: static_kwargs)
662 if libmpathpersist.found()
663 mpathlibs += libmpathpersist
665 mpathlibs += cc.find_library('devmapper',
666 required: get_option('mpath'),
667 kwargs: static_kwargs)
669 mpathlibs += cc.find_library('multipath',
670 required: get_option('mpath'),
671 kwargs: static_kwargs)
672 foreach lib: mpathlibs
678 if mpathlibs.length() == 0
679 msg = 'Dependencies missing for libmpathpersist'
680 elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
681 mpathpersist = declare_dependency(dependencies: mpathlibs)
682 mpathpersist_new_api = true
683 elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
684 mpathpersist = declare_dependency(dependencies: mpathlibs)
686 msg = 'Cannot detect libmpathpersist API'
688 if not mpathpersist.found()
689 if get_option('mpath').enabled()
692 warning(msg + ', disabling')
700 if have_system and not get_option('curses').disabled()
702 #if defined(__APPLE__) || defined(__OpenBSD__)
703 #define _XOPEN_SOURCE_EXTENDED 1
710 setlocale(LC_ALL, "");
712 addwstr(L"wide chars\n");
714 add_wch(WACS_DEGREE);
718 curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
719 foreach curses_dep : curses_dep_list
720 if not curses.found()
721 curses = dependency(curses_dep,
723 method: 'pkg-config',
724 kwargs: static_kwargs)
727 msg = get_option('curses').enabled() ? 'curses library not found' : ''
728 curses_compile_args = ['-DNCURSES_WIDECHAR=1']
730 if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
731 curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
733 msg = 'curses package not usable'
737 if not curses.found()
738 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
739 if targetos != 'windows' and not has_curses_h
740 message('Trying with /usr/include/ncursesw')
741 curses_compile_args += ['-I/usr/include/ncursesw']
742 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
745 curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
746 foreach curses_libname : curses_libname_list
747 libcurses = cc.find_library(curses_libname,
749 kwargs: static_kwargs)
751 if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
752 curses = declare_dependency(compile_args: curses_compile_args,
753 dependencies: [libcurses])
756 msg = 'curses library not usable'
762 if not get_option('iconv').disabled()
763 foreach link_args : [ ['-liconv'], [] ]
764 # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
765 # We need to use libiconv if available because mixing libiconv's headers with
766 # the system libc does not work.
767 # However, without adding glib to the dependencies -L/usr/local/lib will not be
768 # included in the command line and libiconv will not be found.
772 iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
773 return conv != (iconv_t) -1;
774 }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
775 iconv = declare_dependency(link_args: link_args, dependencies: glib)
780 if curses.found() and not iconv.found()
781 if get_option('iconv').enabled()
782 error('iconv not available')
784 msg = 'iconv required for curses UI but not available'
787 if not curses.found() and msg != ''
788 if get_option('curses').enabled()
791 warning(msg + ', disabling')
797 if not get_option('brlapi').auto() or have_system
798 brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
799 required: get_option('brlapi'),
800 kwargs: static_kwargs)
801 if brlapi.found() and not cc.links('''
804 int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
806 if get_option('brlapi').enabled()
807 error('could not link brlapi')
809 warning('could not link brlapi, disabling')
815 if not get_option('sdl').auto() or (have_system and not cocoa.found())
816 sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
817 sdl_image = not_found
820 # work around 2.0.8 bug
821 sdl = declare_dependency(compile_args: '-Wno-undef',
823 sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
824 method: 'pkg-config', kwargs: static_kwargs)
826 if get_option('sdl_image').enabled()
827 error('sdl-image required, but SDL was @0@'.format(
828 get_option('sdl').disabled() ? 'disabled' : 'not found'))
830 sdl_image = not_found
834 if not get_option('rbd').auto() or have_block
835 librados = cc.find_library('rados', required: get_option('rbd'),
836 kwargs: static_kwargs)
837 librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
838 required: get_option('rbd'),
839 kwargs: static_kwargs)
840 if librados.found() and librbd.found()
843 #include <rbd/librbd.h>
846 rados_create(&cluster, NULL);
847 #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
851 }''', dependencies: [librbd, librados])
852 rbd = declare_dependency(dependencies: [librbd, librados])
853 elif get_option('rbd').enabled()
854 error('librbd >= 1.12.0 required')
856 warning('librbd >= 1.12.0 not found, disabling')
861 glusterfs = not_found
862 glusterfs_ftruncate_has_stat = false
863 glusterfs_iocb_has_stat = false
864 if not get_option('glusterfs').auto() or have_block
865 glusterfs = dependency('glusterfs-api', version: '>=3',
866 required: get_option('glusterfs'),
867 method: 'pkg-config', kwargs: static_kwargs)
869 glusterfs_ftruncate_has_stat = cc.links('''
870 #include <glusterfs/api/glfs.h>
875 /* new glfs_ftruncate() passes two additional args */
876 return glfs_ftruncate(NULL, 0, NULL, NULL);
878 ''', dependencies: glusterfs)
879 glusterfs_iocb_has_stat = cc.links('''
880 #include <glusterfs/api/glfs.h>
882 /* new glfs_io_cbk() passes two additional glfs_stat structs */
884 glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
890 glfs_io_cbk iocb = &glusterfs_iocb;
891 iocb(NULL, 0 , NULL, NULL, NULL);
894 ''', dependencies: glusterfs)
899 if not get_option('libssh').auto() or have_block
900 libssh = dependency('libssh', version: '>=0.8.7',
901 method: 'pkg-config',
902 required: get_option('libssh'),
903 kwargs: static_kwargs)
907 if not get_option('bzip2').auto() or have_block
908 libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
909 required: get_option('bzip2'),
910 kwargs: static_kwargs)
911 if libbzip2.found() and not cc.links('''
913 int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
915 if get_option('bzip2').enabled()
916 error('could not link libbzip2')
918 warning('could not link libbzip2, disabling')
924 if not get_option('lzfse').auto() or have_block
925 liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
926 required: get_option('lzfse'),
927 kwargs: static_kwargs)
929 if liblzfse.found() and not cc.links('''
931 int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
933 if get_option('lzfse').enabled()
934 error('could not link liblzfse')
936 warning('could not link liblzfse, disabling')
941 if have_system and not get_option('oss').disabled()
942 if not cc.has_header('sys/soundcard.h')
944 elif targetos == 'netbsd'
945 oss = cc.find_library('ossaudio', required: get_option('oss'),
946 kwargs: static_kwargs)
948 oss = declare_dependency()
952 if get_option('oss').enabled()
953 error('OSS not found')
958 if not get_option('dsound').auto() or (targetos == 'windows' and have_system)
959 if cc.has_header('dsound.h')
960 dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
963 if not dsound.found()
964 if get_option('dsound').enabled()
965 error('DirectSound not found')
970 coreaudio = not_found
971 if not get_option('coreaudio').auto() or (targetos == 'darwin' and have_system)
972 coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
973 required: get_option('coreaudio'))
977 if 'CONFIG_OPENGL' in config_host
978 opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
979 link_args: config_host['OPENGL_LIBS'].split())
982 if (have_system or have_tools) and (virgl.found() or opengl.found())
983 gbm = dependency('gbm', method: 'pkg-config', required: false,
984 kwargs: static_kwargs)
988 gnutls_crypto = not_found
989 if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
990 # For general TLS support our min gnutls matches
991 # that implied by our platform support matrix
993 # For the crypto backends, we look for a newer
996 # Version 3.6.8 is needed to get XTS
997 # Version 3.6.13 is needed to get PBKDF
998 # Version 3.6.14 is needed to get HW accelerated XTS
1000 # If newer enough gnutls isn't available, we can
1001 # still use a different crypto backend to satisfy
1002 # the platform support requirements
1003 gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
1004 method: 'pkg-config',
1006 kwargs: static_kwargs)
1007 if gnutls_crypto.found()
1008 gnutls = gnutls_crypto
1010 # Our min version if all we need is TLS
1011 gnutls = dependency('gnutls', version: '>=3.5.18',
1012 method: 'pkg-config',
1013 required: get_option('gnutls'),
1014 kwargs: static_kwargs)
1018 # We prefer use of gnutls for crypto, unless the options
1019 # explicitly asked for nettle or gcrypt.
1021 # If gnutls isn't available for crypto, then we'll prefer
1022 # gcrypt over nettle for performance reasons.
1027 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
1028 error('Only one of gcrypt & nettle can be enabled')
1031 # Explicit nettle/gcrypt request, so ignore gnutls for crypto
1032 if get_option('nettle').enabled() or get_option('gcrypt').enabled()
1033 gnutls_crypto = not_found
1036 if not gnutls_crypto.found()
1037 if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
1038 gcrypt = dependency('libgcrypt', version: '>=1.8',
1039 method: 'config-tool',
1040 required: get_option('gcrypt'),
1041 kwargs: static_kwargs)
1042 # Debian has removed -lgpg-error from libgcrypt-config
1043 # as it "spreads unnecessary dependencies" which in
1044 # turn breaks static builds...
1045 if gcrypt.found() and enable_static
1046 gcrypt = declare_dependency(dependencies: [
1048 cc.find_library('gpg-error', required: true, kwargs: static_kwargs)])
1051 if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
1052 nettle = dependency('nettle', version: '>=3.4',
1053 method: 'pkg-config',
1054 required: get_option('nettle'),
1055 kwargs: static_kwargs)
1056 if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
1065 if not get_option('gtk').auto() or (have_system and not cocoa.found())
1066 gtk = dependency('gtk+-3.0', version: '>=3.22.0',
1067 method: 'pkg-config',
1068 required: get_option('gtk'),
1069 kwargs: static_kwargs)
1071 gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
1072 method: 'pkg-config',
1074 kwargs: static_kwargs)
1075 gtk = declare_dependency(dependencies: [gtk, gtkx11])
1077 if not get_option('vte').auto() or have_system
1078 vte = dependency('vte-2.91',
1079 method: 'pkg-config',
1080 required: get_option('vte'),
1081 kwargs: static_kwargs)
1088 x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
1089 kwargs: static_kwargs)
1095 if have_system and not get_option('vnc').disabled()
1096 vnc = declare_dependency() # dummy dependency
1097 png = dependency('libpng', required: get_option('vnc_png'),
1098 method: 'pkg-config', kwargs: static_kwargs)
1099 jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
1100 method: 'pkg-config', kwargs: static_kwargs)
1101 sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
1102 required: get_option('vnc_sasl'),
1103 kwargs: static_kwargs)
1105 sasl = declare_dependency(dependencies: sasl,
1106 compile_args: '-DSTRUCT_IOVEC_DEFINED')
1111 if not get_option('auth_pam').auto() or have_system
1112 pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
1113 required: get_option('auth_pam'),
1114 kwargs: static_kwargs)
1116 if pam.found() and not cc.links('''
1118 #include <security/pam_appl.h>
1120 const char *service_name = "qemu";
1121 const char *user = "frank";
1122 const struct pam_conv pam_conv = { 0 };
1123 pam_handle_t *pamh = NULL;
1124 pam_start(service_name, user, &pam_conv, &pamh);
1126 }''', dependencies: pam)
1128 if get_option('auth_pam').enabled()
1129 error('could not link libpam')
1131 warning('could not link libpam, disabling')
1136 if not get_option('snappy').auto() or have_system
1137 snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
1138 required: get_option('snappy'),
1139 kwargs: static_kwargs)
1141 if snappy.found() and not linker.links('''
1142 #include <snappy-c.h>
1143 int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
1145 if get_option('snappy').enabled()
1146 error('could not link libsnappy')
1148 warning('could not link libsnappy, disabling')
1153 if not get_option('lzo').auto() or have_system
1154 lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1155 required: get_option('lzo'),
1156 kwargs: static_kwargs)
1158 if lzo.found() and not cc.links('''
1159 #include <lzo/lzo1x.h>
1160 int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1162 if get_option('lzo').enabled()
1163 error('could not link liblzo2')
1165 warning('could not link liblzo2, disabling')
1170 if 'CONFIG_RDMA' in config_host
1171 rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
1174 if 'CONFIG_NUMA' in config_host
1175 numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
1178 if 'CONFIG_XEN_BACKEND' in config_host
1179 xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
1180 link_args: config_host['XEN_LIBS'].split())
1183 if not get_option('smartcard').auto() or have_system
1184 cacard = dependency('libcacard', required: get_option('smartcard'),
1185 version: '>=2.5.1', method: 'pkg-config',
1186 kwargs: static_kwargs)
1190 u2f = dependency('u2f-emu', required: get_option('u2f'),
1191 method: 'pkg-config',
1192 kwargs: static_kwargs)
1194 usbredir = not_found
1195 if not get_option('usb_redir').auto() or have_system
1196 usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1197 version: '>=0.6', method: 'pkg-config',
1198 kwargs: static_kwargs)
1201 if not get_option('libusb').auto() or have_system
1202 libusb = dependency('libusb-1.0', required: get_option('libusb'),
1203 version: '>=1.0.13', method: 'pkg-config',
1204 kwargs: static_kwargs)
1208 if not get_option('libpmem').auto() or have_system
1209 libpmem = dependency('libpmem', required: get_option('libpmem'),
1210 method: 'pkg-config', kwargs: static_kwargs)
1212 libdaxctl = not_found
1213 if not get_option('libdaxctl').auto() or have_system
1214 libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1215 version: '>=57', method: 'pkg-config',
1216 kwargs: static_kwargs)
1220 tasn1 = dependency('libtasn1',
1221 method: 'pkg-config',
1222 kwargs: static_kwargs)
1224 keyutils = dependency('libkeyutils', required: false,
1225 method: 'pkg-config', kwargs: static_kwargs)
1227 has_gettid = cc.has_function('gettid')
1230 selinux = dependency('libselinux',
1231 required: get_option('selinux'),
1232 method: 'pkg-config', kwargs: static_kwargs)
1237 if get_option('malloc') == 'system'
1239 not get_option('malloc_trim').disabled() and \
1240 cc.links('''#include <malloc.h>
1241 int main(void) { malloc_trim(0); return 0; }''')
1243 has_malloc_trim = false
1244 malloc = cc.find_library(get_option('malloc'), required: true)
1246 if not has_malloc_trim and get_option('malloc_trim').enabled()
1247 if get_option('malloc') == 'system'
1248 error('malloc_trim not available on this platform.')
1250 error('malloc_trim not available with non-libc memory allocator')
1254 # Check whether the glibc provides statx()
1256 gnu_source_prefix = '''
1261 statx_test = gnu_source_prefix + '''
1262 #include <sys/stat.h>
1264 struct statx statxbuf;
1265 statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
1269 has_statx = cc.links(statx_test)
1271 have_vhost_user_blk_server = (targetos == 'linux' and
1272 'CONFIG_VHOST_USER' in config_host)
1274 if get_option('vhost_user_blk_server').enabled()
1275 if targetos != 'linux'
1276 error('vhost_user_blk_server requires linux')
1277 elif 'CONFIG_VHOST_USER' not in config_host
1278 error('vhost_user_blk_server requires vhost-user support')
1280 elif get_option('vhost_user_blk_server').disabled() or not have_system
1281 have_vhost_user_blk_server = false
1285 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1286 error('Cannot enable fuse-lseek while fuse is disabled')
1289 fuse = dependency('fuse3', required: get_option('fuse'),
1290 version: '>=3.1', method: 'pkg-config',
1291 kwargs: static_kwargs)
1293 fuse_lseek = not_found
1294 if not get_option('fuse_lseek').disabled()
1295 if fuse.version().version_compare('>=3.8')
1297 fuse_lseek = declare_dependency()
1298 elif get_option('fuse_lseek').enabled()
1300 error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1302 error('fuse-lseek requires libfuse, which was not found')
1308 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1309 if libbpf.found() and not cc.links('''
1310 #include <bpf/libbpf.h>
1313 bpf_object__destroy_skeleton(NULL);
1315 }''', dependencies: libbpf)
1317 if get_option('bpf').enabled()
1318 error('libbpf skeleton test failed')
1320 warning('libbpf skeleton test failed, disabling')
1328 audio_drivers_selected = []
1330 audio_drivers_available = {
1331 'alsa': alsa.found(),
1332 'coreaudio': coreaudio.found(),
1333 'dsound': dsound.found(),
1334 'jack': jack.found(),
1336 'pa': pulse.found(),
1339 foreach k, v: audio_drivers_available
1340 config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
1343 # Default to native drivers first, OSS second, SDL third
1344 audio_drivers_priority = \
1345 [ 'pa', 'coreaudio', 'dsound', 'oss' ] + \
1346 (targetos == 'linux' ? [] : [ 'sdl' ])
1347 audio_drivers_default = []
1348 foreach k: audio_drivers_priority
1349 if audio_drivers_available[k]
1350 audio_drivers_default += k
1354 foreach k: get_option('audio_drv_list')
1356 audio_drivers_selected += audio_drivers_default
1357 elif not audio_drivers_available[k]
1358 error('Audio driver "@0@" not available.'.format(k))
1360 audio_drivers_selected += k
1364 config_host_data.set('CONFIG_AUDIO_DRIVERS',
1365 '"' + '", "'.join(audio_drivers_selected) + '", ')
1367 if get_option('cfi')
1369 # Check for dependency on LTO
1370 if not get_option('b_lto')
1371 error('Selected Control-Flow Integrity but LTO is disabled')
1373 if config_host.has_key('CONFIG_MODULES')
1374 error('Selected Control-Flow Integrity is not compatible with modules')
1376 # Check for cfi flags. CFI requires LTO so we can't use
1377 # get_supported_arguments, but need a more complex "compiles" which allows
1379 if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1380 args: ['-flto', '-fsanitize=cfi-icall'] )
1381 cfi_flags += '-fsanitize=cfi-icall'
1383 error('-fsanitize=cfi-icall is not supported by the compiler')
1385 if cc.compiles('int main () { return 0; }',
1386 name: '-fsanitize-cfi-icall-generalize-pointers',
1387 args: ['-flto', '-fsanitize=cfi-icall',
1388 '-fsanitize-cfi-icall-generalize-pointers'] )
1389 cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1391 error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1393 if get_option('cfi_debug')
1394 if cc.compiles('int main () { return 0; }',
1395 name: '-fno-sanitize-trap=cfi-icall',
1396 args: ['-flto', '-fsanitize=cfi-icall',
1397 '-fno-sanitize-trap=cfi-icall'] )
1398 cfi_flags += '-fno-sanitize-trap=cfi-icall'
1400 error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1403 add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1404 add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1407 have_host_block_device = (targetos != 'darwin' or
1408 cc.has_header('IOKit/storage/IOMedia.h'))
1410 dbus_display = false
1411 if not get_option('dbus_display').disabled()
1412 # FIXME enable_modules shouldn't be necessary, but: https://github.com/mesonbuild/meson/issues/8333
1413 dbus_display = gio.version().version_compare('>=2.64') and config_host.has_key('GDBUS_CODEGEN') and enable_modules
1414 if get_option('dbus_display').enabled() and not dbus_display
1415 error('Requirements missing to enable -display dbus (glib>=2.64 && --enable-modules)')
1419 have_virtfs = (targetos == 'linux' and
1424 have_virtfs_proxy_helper = have_virtfs and have_tools
1426 if get_option('virtfs').enabled()
1428 if targetos != 'linux'
1429 error('virtio-9p (virtfs) requires Linux')
1430 elif not libcap_ng.found() or not libattr.found()
1431 error('virtio-9p (virtfs) requires libcap-ng-devel and libattr-devel')
1432 elif not have_system
1433 error('virtio-9p (virtfs) needs system emulation support')
1436 elif get_option('virtfs').disabled()
1440 foreach k : get_option('trace_backends')
1441 config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
1443 config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
1445 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1446 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1447 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1448 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1449 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1450 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
1451 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1452 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1453 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1454 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1455 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1456 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1458 config_host_data.set('HOST_' + host_arch.to_upper(), 1)
1460 config_host_data.set('CONFIG_ATTR', libattr.found())
1461 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1462 config_host_data.set('CONFIG_COCOA', cocoa.found())
1463 config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
1464 config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
1465 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1466 config_host_data.set('CONFIG_LZO', lzo.found())
1467 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1468 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1469 config_host_data.set('CONFIG_CURL', curl.found())
1470 config_host_data.set('CONFIG_CURSES', curses.found())
1471 config_host_data.set('CONFIG_GBM', gbm.found())
1472 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1473 if glusterfs.found()
1474 config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1475 config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1476 config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1477 config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1478 config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1479 config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1481 config_host_data.set('CONFIG_GTK', gtk.found())
1482 config_host_data.set('CONFIG_VTE', vte.found())
1483 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1484 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1485 config_host_data.set('CONFIG_EBPF', libbpf.found())
1486 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
1487 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1488 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1489 config_host_data.set('CONFIG_LIBSSH', libssh.found())
1490 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
1491 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
1492 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
1493 config_host_data.set('CONFIG_RBD', rbd.found())
1494 config_host_data.set('CONFIG_SDL', sdl.found())
1495 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1496 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1497 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1498 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
1499 config_host_data.set('CONFIG_VDE', vde.found())
1500 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1501 config_host_data.set('CONFIG_VNC', vnc.found())
1502 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1503 config_host_data.set('CONFIG_VNC_PNG', png.found())
1504 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1505 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1506 config_host_data.set('CONFIG_VTE', vte.found())
1507 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1508 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1509 config_host_data.set('CONFIG_GETTID', has_gettid)
1510 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
1511 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
1512 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
1513 config_host_data.set('CONFIG_NETTLE', nettle.found())
1514 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
1515 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1516 config_host_data.set('CONFIG_STATX', has_statx)
1517 config_host_data.set('CONFIG_ZSTD', zstd.found())
1518 config_host_data.set('CONFIG_FUSE', fuse.found())
1519 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1520 config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
1521 if spice_protocol.found()
1522 config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
1523 config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
1524 config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
1526 config_host_data.set('CONFIG_SPICE', spice.found())
1527 config_host_data.set('CONFIG_X11', x11.found())
1528 config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
1529 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1530 config_host_data.set('CONFIG_SELINUX', selinux.found())
1531 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1532 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1533 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1534 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1536 config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
1537 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
1538 config_host_data.set('HOST_WORDS_BIGENDIAN', host_machine.endian() == 'big')
1541 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1542 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1543 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1544 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1545 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1546 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1547 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1548 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1549 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1552 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1553 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1554 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1555 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1556 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1557 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign'))
1558 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
1559 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1560 config_host_data.set('CONFIG_SEM_TIMEDWAIT', cc.has_function('sem_timedwait', dependencies: threads))
1561 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
1562 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
1563 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
1564 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
1565 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
1566 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
1567 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
1568 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
1569 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1571 config_host_data.set('HAVE_IBV_ADVISE_MR',
1572 cc.has_function('ibv_advise_mr',
1573 args: config_host['RDMA_LIBS'].split(),
1574 prefix: '#include <infiniband/verbs.h>'))
1578 config_host_data.set('CONFIG_BYTESWAP_H',
1579 cc.has_header_symbol('byteswap.h', 'bswap_32'))
1580 config_host_data.set('CONFIG_EPOLL_CREATE1',
1581 cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
1582 config_host_data.set('CONFIG_HAS_ENVIRON',
1583 cc.has_header_symbol('unistd.h', 'environ', prefix: gnu_source_prefix))
1584 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
1585 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
1586 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
1587 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
1588 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
1589 config_host_data.set('CONFIG_FIEMAP',
1590 cc.has_header('linux/fiemap.h') and
1591 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
1592 config_host_data.set('CONFIG_GETRANDOM',
1593 cc.has_function('getrandom') and
1594 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
1595 config_host_data.set('CONFIG_INOTIFY',
1596 cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
1597 config_host_data.set('CONFIG_INOTIFY1',
1598 cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
1599 config_host_data.set('CONFIG_MACHINE_BSWAP_H',
1600 cc.has_header_symbol('machine/bswap.h', 'bswap32',
1601 prefix: '''#include <sys/endian.h>
1602 #include <sys/types.h>'''))
1603 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
1604 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
1605 config_host_data.set('CONFIG_RTNETLINK',
1606 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
1607 config_host_data.set('CONFIG_SYSMACROS',
1608 cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1609 config_host_data.set('HAVE_OPTRESET',
1610 cc.has_header_symbol('getopt.h', 'optreset'))
1611 config_host_data.set('HAVE_IPPROTO_MPTCP',
1612 cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
1615 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
1616 cc.has_member('struct sigevent', 'sigev_notify_thread_id',
1617 prefix: '#include <signal.h>'))
1618 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
1619 cc.has_member('struct stat', 'st_atim',
1620 prefix: '#include <sys/stat.h>'))
1623 config_host_data.set('CONFIG_IOVEC',
1624 cc.has_type('struct iovec',
1625 prefix: '#include <sys/uio.h>'))
1626 config_host_data.set('HAVE_UTMPX',
1627 cc.has_type('struct utmpx',
1628 prefix: '#include <utmpx.h>'))
1630 config_host_data.set('CONFIG_EVENTFD', cc.links('''
1631 #include <sys/eventfd.h>
1632 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
1633 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
1636 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
1637 return fdatasync(0);
1639 #error Not supported
1642 config_host_data.set('CONFIG_MADVISE', cc.links(gnu_source_prefix + '''
1643 #include <sys/types.h>
1644 #include <sys/mman.h>
1646 int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }'''))
1647 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
1648 #include <sys/mman.h>
1649 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
1650 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
1652 #if !defined(AT_EMPTY_PATH)
1653 # error missing definition
1655 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
1657 config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
1664 return pipe2(pipefd, O_CLOEXEC);
1666 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
1667 #include <sys/mman.h>
1669 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
1671 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
1672 #include <pthread.h>
1674 static void *f(void *p) { return NULL; }
1678 pthread_create(&thread, 0, f, 0);
1679 pthread_setname_np(thread, "QEMU");
1681 }''', dependencies: threads))
1682 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
1683 #include <pthread.h>
1685 static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
1689 pthread_create(&thread, 0, f, 0);
1691 }''', dependencies: threads))
1693 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
1694 #include <sys/signalfd.h>
1696 int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
1697 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
1705 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
1706 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
1710 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
1711 #include <sys/mman.h>
1712 int main(int argc, char *argv[]) {
1713 return mlockall(MCL_FUTURE);
1717 if not get_option('l2tpv3').disabled() and have_system
1718 have_l2tpv3 = cc.has_type('struct mmsghdr',
1719 prefix: gnu_source_prefix + '''
1720 #include <sys/socket.h>
1721 #include <linux/ip.h>''')
1723 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
1726 if not get_option('netmap').disabled() and have_system
1727 have_netmap = cc.compiles('''
1728 #include <inttypes.h>
1730 #include <net/netmap.h>
1731 #include <net/netmap_user.h>
1732 #if (NETMAP_API < 11) || (NETMAP_API > 15)
1735 int main(void) { return 0; }''')
1736 if not have_netmap and get_option('netmap').enabled()
1737 error('Netmap headers not available')
1740 config_host_data.set('CONFIG_NETMAP', have_netmap)
1742 # Work around a system header bug with some kernel/XFS header
1743 # versions where they both try to define 'struct fsxattr':
1744 # xfs headers will not try to redefine structs from linux headers
1745 # if this macro is set.
1746 config_host_data.set('HAVE_FSXATTR', cc.links('''
1747 #include <linux/fs.h>
1753 # Some versions of Mac OS X incorrectly define SIZE_MAX
1754 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
1757 int main(int argc, char *argv[]) {
1758 return printf("%zu", SIZE_MAX);
1759 }''', args: ['-Werror']))
1761 # See if 64-bit atomic operations are supported.
1762 # Note that without __atomic builtins, we can only
1763 # assume atomic loads/stores max at pointer size.
1764 config_host_data.set('CONFIG_ATOMIC64', cc.links('''
1768 uint64_t x = 0, y = 0;
1769 y = __atomic_load_n(&x, __ATOMIC_RELAXED);
1770 __atomic_store_n(&x, y, __ATOMIC_RELAXED);
1771 __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
1772 __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
1773 __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
1777 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
1778 #include <sys/auxv.h>
1780 return getauxval(AT_HWCAP) == 0;
1783 config_host_data.set('CONFIG_AF_VSOCK', cc.compiles(gnu_source_prefix + '''
1785 #include <sys/types.h>
1786 #include <sys/socket.h>
1787 #if !defined(AF_VSOCK)
1788 # error missing AF_VSOCK flag
1790 #include <linux/vm_sockets.h>
1793 struct sockaddr_vm svm;
1794 socklen_t len = sizeof(svm);
1795 sock = socket(AF_VSOCK, SOCK_STREAM, 0);
1796 ret = getpeername(sock, (struct sockaddr *)&svm, &len);
1797 if ((ret == -1) && (errno == ENOTCONN)) {
1803 ignored = ['CONFIG_QEMU_INTERP_PREFIX', # actually per-target
1805 arrays = ['CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1806 strings = ['CONFIG_IASL']
1807 foreach k, v: config_host
1808 if ignored.contains(k)
1810 elif arrays.contains(k)
1812 v = '"' + '", "'.join(v.split()) + '", '
1814 config_host_data.set(k, v)
1815 elif strings.contains(k)
1816 config_host_data.set_quoted(k, v)
1817 elif k.startswith('CONFIG_')
1818 config_host_data.set(k, v == 'y' ? 1 : v)
1822 ########################
1823 # Target configuration #
1824 ########################
1826 minikconf = find_program('scripts/minikconf.py')
1828 config_all_devices = {}
1829 config_all_disas = {}
1830 config_devices_mak_list = []
1831 config_devices_h = {}
1832 config_target_h = {}
1833 config_target_mak = {}
1836 'alpha' : ['CONFIG_ALPHA_DIS'],
1837 'arm' : ['CONFIG_ARM_DIS'],
1838 'avr' : ['CONFIG_AVR_DIS'],
1839 'cris' : ['CONFIG_CRIS_DIS'],
1840 'hexagon' : ['CONFIG_HEXAGON_DIS'],
1841 'hppa' : ['CONFIG_HPPA_DIS'],
1842 'i386' : ['CONFIG_I386_DIS'],
1843 'x86_64' : ['CONFIG_I386_DIS'],
1844 'm68k' : ['CONFIG_M68K_DIS'],
1845 'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
1846 'mips' : ['CONFIG_MIPS_DIS'],
1847 'nios2' : ['CONFIG_NIOS2_DIS'],
1848 'or1k' : ['CONFIG_OPENRISC_DIS'],
1849 'ppc' : ['CONFIG_PPC_DIS'],
1850 'riscv' : ['CONFIG_RISCV_DIS'],
1851 'rx' : ['CONFIG_RX_DIS'],
1852 's390' : ['CONFIG_S390_DIS'],
1853 'sh4' : ['CONFIG_SH4_DIS'],
1854 'sparc' : ['CONFIG_SPARC_DIS'],
1855 'xtensa' : ['CONFIG_XTENSA_DIS'],
1857 if link_language == 'cpp'
1859 'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
1860 'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
1861 'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
1865 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
1867 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
1868 ('CONFIG_TPM' in config_host ? ['CONFIG_TPM=y'] : []) + \
1869 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
1870 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
1871 ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
1872 (x11.found() ? ['CONFIG_X11=y'] : []) + \
1873 ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
1874 ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
1875 ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
1876 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
1877 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
1878 ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
1879 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
1881 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
1883 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
1884 actual_target_dirs = []
1886 foreach target : target_dirs
1887 config_target = { 'TARGET_NAME': target.split('-')[0] }
1888 if target.endswith('linux-user')
1889 if targetos != 'linux'
1893 error('Target @0@ is only available on a Linux host'.format(target))
1895 config_target += { 'CONFIG_LINUX_USER': 'y' }
1896 elif target.endswith('bsd-user')
1897 if 'CONFIG_BSD' not in config_host
1901 error('Target @0@ is only available on a BSD host'.format(target))
1903 config_target += { 'CONFIG_BSD_USER': 'y' }
1904 elif target.endswith('softmmu')
1905 config_target += { 'CONFIG_SOFTMMU': 'y' }
1907 if target.endswith('-user')
1909 'CONFIG_USER_ONLY': 'y',
1910 'CONFIG_QEMU_INTERP_PREFIX':
1911 config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
1916 foreach sym: accelerators
1917 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
1918 config_target += { sym: 'y' }
1919 config_all += { sym: 'y' }
1920 if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
1921 config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
1922 elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
1923 config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
1925 if target in modular_tcg
1926 config_target += { 'CONFIG_TCG_MODULAR': 'y' }
1928 config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
1930 accel_kconfig += [ sym + '=y' ]
1933 if accel_kconfig.length() == 0
1937 error('No accelerator available for target @0@'.format(target))
1940 actual_target_dirs += target
1941 config_target += keyval.load('configs/targets' / target + '.mak')
1942 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
1944 if 'TARGET_NEED_FDT' in config_target
1945 fdt_required += target
1949 if 'TARGET_BASE_ARCH' not in config_target
1950 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
1952 if 'TARGET_ABI_DIR' not in config_target
1953 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
1956 foreach k, v: disassemblers
1957 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
1959 config_target += { sym: 'y' }
1960 config_all_disas += { sym: 'y' }
1965 config_target_data = configuration_data()
1966 foreach k, v: config_target
1967 if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
1969 elif ignored.contains(k)
1971 elif k == 'TARGET_BASE_ARCH'
1972 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
1973 # not used to select files from sourcesets.
1974 config_target_data.set('TARGET_' + v.to_upper(), 1)
1975 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
1976 config_target_data.set_quoted(k, v)
1978 config_target_data.set(k, 1)
1980 config_target_data.set(k, v)
1983 config_target_data.set('QEMU_ARCH',
1984 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
1985 config_target_h += {target: configure_file(output: target + '-config-target.h',
1986 configuration: config_target_data)}
1988 if target.endswith('-softmmu')
1989 config_input = meson.get_external_property(target, 'default')
1990 config_devices_mak = target + '-config-devices.mak'
1991 config_devices_mak = configure_file(
1992 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
1993 output: config_devices_mak,
1994 depfile: config_devices_mak + '.d',
1996 command: [minikconf,
1997 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
1998 config_devices_mak, '@DEPFILE@', '@INPUT@',
1999 host_kconfig, accel_kconfig,
2000 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2002 config_devices_data = configuration_data()
2003 config_devices = keyval.load(config_devices_mak)
2004 foreach k, v: config_devices
2005 config_devices_data.set(k, 1)
2007 config_devices_mak_list += config_devices_mak
2008 config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2009 configuration: config_devices_data)}
2010 config_target += config_devices
2011 config_all_devices += config_devices
2013 config_target_mak += {target: config_target}
2015 target_dirs = actual_target_dirs
2017 # This configuration is used to build files that are shared by
2018 # multiple binaries, and then extracted out of the "common"
2019 # static_library target.
2021 # We do not use all_sources()/all_dependencies(), because it would
2022 # build literally all source files, including devices only used by
2023 # targets that are not built for this compilation. The CONFIG_ALL
2024 # pseudo symbol replaces it.
2026 config_all += config_all_devices
2027 config_all += config_host
2028 config_all += config_all_disas
2030 'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
2031 'CONFIG_SOFTMMU': have_system,
2032 'CONFIG_USER_ONLY': have_user,
2036 target_configs_h = []
2037 foreach target: target_dirs
2038 target_configs_h += config_target_h[target]
2039 target_configs_h += config_devices_h.get(target, [])
2041 genh += custom_target('config-poison.h',
2042 input: [target_configs_h],
2043 output: 'config-poison.h',
2045 command: [find_program('scripts/make-config-poison.sh'),
2052 capstone = not_found
2053 capstone_opt = get_option('capstone')
2054 if capstone_opt in ['enabled', 'auto', 'system']
2055 have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
2056 capstone = dependency('capstone', version: '>=4.0',
2057 kwargs: static_kwargs, method: 'pkg-config',
2058 required: capstone_opt == 'system' or
2059 capstone_opt == 'enabled' and not have_internal)
2061 # Some versions of capstone have broken pkg-config file
2062 # that reports a wrong -I path, causing the #include to
2063 # fail later. If the system has such a broken version
2065 if capstone.found() and not cc.compiles('#include <capstone.h>',
2066 dependencies: [capstone])
2067 capstone = not_found
2068 if capstone_opt == 'system'
2069 error('system capstone requested, it does not appear to work')
2074 capstone_opt = 'system'
2076 capstone_opt = 'internal'
2078 capstone_opt = 'disabled'
2081 if capstone_opt == 'internal'
2082 capstone_data = configuration_data()
2083 capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
2085 capstone_files = files(
2087 'capstone/MCInst.c',
2088 'capstone/MCInstrDesc.c',
2089 'capstone/MCRegisterInfo.c',
2090 'capstone/SStream.c',
2094 if 'CONFIG_ARM_DIS' in config_all_disas
2095 capstone_data.set('CAPSTONE_HAS_ARM', '1')
2096 capstone_files += files(
2097 'capstone/arch/ARM/ARMDisassembler.c',
2098 'capstone/arch/ARM/ARMInstPrinter.c',
2099 'capstone/arch/ARM/ARMMapping.c',
2100 'capstone/arch/ARM/ARMModule.c'
2104 # FIXME: This config entry currently depends on a c++ compiler.
2105 # Which is needed for building libvixl, but not for capstone.
2106 if 'CONFIG_ARM_A64_DIS' in config_all_disas
2107 capstone_data.set('CAPSTONE_HAS_ARM64', '1')
2108 capstone_files += files(
2109 'capstone/arch/AArch64/AArch64BaseInfo.c',
2110 'capstone/arch/AArch64/AArch64Disassembler.c',
2111 'capstone/arch/AArch64/AArch64InstPrinter.c',
2112 'capstone/arch/AArch64/AArch64Mapping.c',
2113 'capstone/arch/AArch64/AArch64Module.c'
2117 if 'CONFIG_PPC_DIS' in config_all_disas
2118 capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
2119 capstone_files += files(
2120 'capstone/arch/PowerPC/PPCDisassembler.c',
2121 'capstone/arch/PowerPC/PPCInstPrinter.c',
2122 'capstone/arch/PowerPC/PPCMapping.c',
2123 'capstone/arch/PowerPC/PPCModule.c'
2127 if 'CONFIG_S390_DIS' in config_all_disas
2128 capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
2129 capstone_files += files(
2130 'capstone/arch/SystemZ/SystemZDisassembler.c',
2131 'capstone/arch/SystemZ/SystemZInstPrinter.c',
2132 'capstone/arch/SystemZ/SystemZMapping.c',
2133 'capstone/arch/SystemZ/SystemZModule.c',
2134 'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
2138 if 'CONFIG_I386_DIS' in config_all_disas
2139 capstone_data.set('CAPSTONE_HAS_X86', 1)
2140 capstone_files += files(
2141 'capstone/arch/X86/X86Disassembler.c',
2142 'capstone/arch/X86/X86DisassemblerDecoder.c',
2143 'capstone/arch/X86/X86ATTInstPrinter.c',
2144 'capstone/arch/X86/X86IntelInstPrinter.c',
2145 'capstone/arch/X86/X86InstPrinterCommon.c',
2146 'capstone/arch/X86/X86Mapping.c',
2147 'capstone/arch/X86/X86Module.c'
2151 configure_file(output: 'capstone-defs.h', configuration: capstone_data)
2154 # FIXME: There does not seem to be a way to completely replace the c_args
2155 # that come from add_project_arguments() -- we can only add to them.
2156 # So: disable all warnings with a big hammer.
2159 # Include all configuration defines via a header file, which will wind up
2160 # as a dependency on the object file, and thus changes here will result
2162 '-include', 'capstone-defs.h'
2165 libcapstone = static_library('capstone',
2166 build_by_default: false,
2167 sources: capstone_files,
2168 c_args: capstone_cargs,
2169 include_directories: 'capstone/include')
2170 capstone = declare_dependency(link_with: libcapstone,
2171 include_directories: 'capstone/include/capstone')
2175 slirp_opt = 'disabled'
2177 slirp_opt = get_option('slirp')
2178 if slirp_opt in ['enabled', 'auto', 'system']
2179 have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2180 slirp = dependency('slirp', kwargs: static_kwargs,
2181 method: 'pkg-config',
2182 required: slirp_opt == 'system' or
2183 slirp_opt == 'enabled' and not have_internal)
2185 slirp_opt = 'system'
2187 slirp_opt = 'internal'
2189 slirp_opt = 'disabled'
2192 if slirp_opt == 'internal'
2194 if targetos == 'windows'
2195 slirp_deps = cc.find_library('iphlpapi')
2196 elif targetos == 'darwin'
2197 slirp_deps = cc.find_library('resolv')
2199 slirp_conf = configuration_data()
2200 slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2201 slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2202 slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2203 slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2204 slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2206 'slirp/src/arp_table.c',
2207 'slirp/src/bootp.c',
2208 'slirp/src/cksum.c',
2209 'slirp/src/dhcpv6.c',
2210 'slirp/src/dnssearch.c',
2212 'slirp/src/ip6_icmp.c',
2213 'slirp/src/ip6_input.c',
2214 'slirp/src/ip6_output.c',
2215 'slirp/src/ip_icmp.c',
2216 'slirp/src/ip_input.c',
2217 'slirp/src/ip_output.c',
2221 'slirp/src/ndp_table.c',
2223 'slirp/src/slirp.c',
2224 'slirp/src/socket.c',
2225 'slirp/src/state.c',
2226 'slirp/src/stream.c',
2227 'slirp/src/tcp_input.c',
2228 'slirp/src/tcp_output.c',
2229 'slirp/src/tcp_subr.c',
2230 'slirp/src/tcp_timer.c',
2235 'slirp/src/version.c',
2236 'slirp/src/vmstate.c',
2240 input : 'slirp/src/libslirp-version.h.in',
2241 output : 'libslirp-version.h',
2242 configuration: slirp_conf)
2244 slirp_inc = include_directories('slirp', 'slirp/src')
2245 libslirp = static_library('slirp',
2246 build_by_default: false,
2247 sources: slirp_files,
2248 c_args: slirp_cargs,
2249 include_directories: slirp_inc)
2250 slirp = declare_dependency(link_with: libslirp,
2251 dependencies: slirp_deps,
2252 include_directories: slirp_inc)
2256 # For CFI, we need to compile slirp as a static library together with qemu.
2257 # This is because we register slirp functions as callbacks for QEMU Timers.
2258 # When using a system-wide shared libslirp, the type information for the
2259 # callback is missing and the timer call produces a false positive with CFI.
2261 # Now that slirp_opt has been defined, check if the selected slirp is compatible
2262 # with control-flow integrity.
2263 if get_option('cfi') and slirp_opt == 'system'
2264 error('Control-Flow Integrity is not compatible with system-wide slirp.' \
2265 + ' Please configure with --enable-slirp=git')
2269 fdt_opt = get_option('fdt')
2271 if fdt_opt in ['enabled', 'auto', 'system']
2272 have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2273 fdt = cc.find_library('fdt', kwargs: static_kwargs,
2274 required: fdt_opt == 'system' or
2275 fdt_opt == 'enabled' and not have_internal)
2276 if fdt.found() and cc.links('''
2278 #include <libfdt_env.h>
2279 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2282 elif fdt_opt == 'system'
2283 error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2285 fdt_opt = 'internal'
2287 fdt_opt = 'disabled'
2291 if fdt_opt == 'internal'
2294 'dtc/libfdt/fdt_ro.c',
2295 'dtc/libfdt/fdt_wip.c',
2296 'dtc/libfdt/fdt_sw.c',
2297 'dtc/libfdt/fdt_rw.c',
2298 'dtc/libfdt/fdt_strerror.c',
2299 'dtc/libfdt/fdt_empty_tree.c',
2300 'dtc/libfdt/fdt_addresses.c',
2301 'dtc/libfdt/fdt_overlay.c',
2302 'dtc/libfdt/fdt_check.c',
2305 fdt_inc = include_directories('dtc/libfdt')
2306 libfdt = static_library('fdt',
2307 build_by_default: false,
2309 include_directories: fdt_inc)
2310 fdt = declare_dependency(link_with: libfdt,
2311 include_directories: fdt_inc)
2314 if not fdt.found() and fdt_required.length() > 0
2315 error('fdt not available but required by targets ' + ', '.join(fdt_required))
2318 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2319 config_host_data.set('CONFIG_FDT', fdt.found())
2320 config_host_data.set('CONFIG_SLIRP', slirp.found())
2322 #####################
2323 # Generated sources #
2324 #####################
2326 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2328 hxtool = find_program('scripts/hxtool')
2329 shaderinclude = find_program('scripts/shaderinclude.pl')
2330 qapi_gen = find_program('scripts/qapi-gen.py')
2331 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2332 meson.current_source_dir() / 'scripts/qapi/commands.py',
2333 meson.current_source_dir() / 'scripts/qapi/common.py',
2334 meson.current_source_dir() / 'scripts/qapi/error.py',
2335 meson.current_source_dir() / 'scripts/qapi/events.py',
2336 meson.current_source_dir() / 'scripts/qapi/expr.py',
2337 meson.current_source_dir() / 'scripts/qapi/gen.py',
2338 meson.current_source_dir() / 'scripts/qapi/introspect.py',
2339 meson.current_source_dir() / 'scripts/qapi/parser.py',
2340 meson.current_source_dir() / 'scripts/qapi/schema.py',
2341 meson.current_source_dir() / 'scripts/qapi/source.py',
2342 meson.current_source_dir() / 'scripts/qapi/types.py',
2343 meson.current_source_dir() / 'scripts/qapi/visit.py',
2344 meson.current_source_dir() / 'scripts/qapi/common.py',
2345 meson.current_source_dir() / 'scripts/qapi-gen.py'
2349 python, files('scripts/tracetool.py'),
2350 '--backend=' + ','.join(get_option('trace_backends'))
2352 tracetool_depends = files(
2353 'scripts/tracetool/backend/log.py',
2354 'scripts/tracetool/backend/__init__.py',
2355 'scripts/tracetool/backend/dtrace.py',
2356 'scripts/tracetool/backend/ftrace.py',
2357 'scripts/tracetool/backend/simple.py',
2358 'scripts/tracetool/backend/syslog.py',
2359 'scripts/tracetool/backend/ust.py',
2360 'scripts/tracetool/format/tcg_h.py',
2361 'scripts/tracetool/format/ust_events_c.py',
2362 'scripts/tracetool/format/ust_events_h.py',
2363 'scripts/tracetool/format/__init__.py',
2364 'scripts/tracetool/format/d.py',
2365 'scripts/tracetool/format/tcg_helper_c.py',
2366 'scripts/tracetool/format/simpletrace_stap.py',
2367 'scripts/tracetool/format/c.py',
2368 'scripts/tracetool/format/h.py',
2369 'scripts/tracetool/format/tcg_helper_h.py',
2370 'scripts/tracetool/format/log_stap.py',
2371 'scripts/tracetool/format/stap.py',
2372 'scripts/tracetool/format/tcg_helper_wrapper_h.py',
2373 'scripts/tracetool/__init__.py',
2374 'scripts/tracetool/transform.py',
2375 'scripts/tracetool/vcpu.py'
2378 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2379 meson.current_source_dir(),
2380 config_host['PKGVERSION'], meson.project_version()]
2381 qemu_version = custom_target('qemu-version.h',
2382 output: 'qemu-version.h',
2383 command: qemu_version_cmd,
2385 build_by_default: true,
2386 build_always_stale: true)
2387 genh += qemu_version
2391 ['qemu-options.hx', 'qemu-options.def'],
2392 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2396 ['hmp-commands.hx', 'hmp-commands.h'],
2397 ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2400 foreach d : hx_headers
2401 hxdep += custom_target(d[1],
2405 build_by_default: true, # to be removed when added to a target
2406 command: [hxtool, '-h', '@INPUT0@'])
2414 authz_ss = ss.source_set()
2415 blockdev_ss = ss.source_set()
2416 block_ss = ss.source_set()
2417 chardev_ss = ss.source_set()
2418 common_ss = ss.source_set()
2419 crypto_ss = ss.source_set()
2420 hwcore_ss = ss.source_set()
2421 io_ss = ss.source_set()
2422 qmp_ss = ss.source_set()
2423 qom_ss = ss.source_set()
2424 softmmu_ss = ss.source_set()
2425 specific_fuzz_ss = ss.source_set()
2426 specific_ss = ss.source_set()
2427 stub_ss = ss.source_set()
2428 trace_ss = ss.source_set()
2429 user_ss = ss.source_set()
2430 util_ss = ss.source_set()
2433 qtest_module_ss = ss.source_set()
2434 tcg_module_ss = ss.source_set()
2440 target_softmmu_arch = {}
2441 target_user_arch = {}
2447 # TODO: add each directory to the subdirs from its own meson.build, once
2449 trace_events_subdirs = [
2457 trace_events_subdirs += [ 'linux-user' ]
2460 trace_events_subdirs += [ 'bsd-user' ]
2463 trace_events_subdirs += [
2472 trace_events_subdirs += [
2486 'hw/block/dataplane',
2536 if have_system or have_user
2537 trace_events_subdirs += [
2554 vhost_user = not_found
2555 if 'CONFIG_VHOST_USER' in config_host
2556 libvhost_user = subproject('libvhost-user')
2557 vhost_user = libvhost_user.get_variable('vhost_user_dep')
2560 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
2561 # that is filled in by qapi/.
2574 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2575 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2578 stub_ss = stub_ss.apply(config_all, strict: false)
2580 util_ss.add_all(trace_ss)
2581 util_ss = util_ss.apply(config_all, strict: false)
2582 libqemuutil = static_library('qemuutil',
2583 sources: util_ss.sources() + stub_ss.sources() + genh,
2584 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2585 qemuutil = declare_dependency(link_with: libqemuutil,
2586 sources: genh + version_res)
2588 if have_system or have_user
2589 decodetree = generator(find_program('scripts/decodetree.py'),
2590 output: 'decode-@BASENAME@.c.inc',
2591 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2592 subdir('libdecnumber')
2609 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
2615 blockdev_ss.add(files(
2622 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2623 # os-win32.c does not
2624 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2625 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2628 common_ss.add(files('cpus-common.c'))
2632 common_ss.add(capstone)
2633 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2635 # Work around a gcc bug/misfeature wherein constant propagation looks
2637 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2638 # to guess that a const variable is always zero. Without lto, this is
2639 # impossible, as the alias is restricted to page-vary-common.c. Indeed,
2640 # without lto, not even the alias is required -- we simply use different
2641 # declarations in different compilation units.
2642 pagevary = files('page-vary-common.c')
2643 if get_option('b_lto')
2644 pagevary_flags = ['-fno-lto']
2645 if get_option('cfi')
2646 pagevary_flags += '-fno-sanitize=cfi-icall'
2648 pagevary = static_library('page-vary-common', sources: pagevary,
2649 c_args: pagevary_flags)
2650 pagevary = declare_dependency(link_with: pagevary)
2652 common_ss.add(pagevary)
2653 specific_ss.add(files('page-vary.c'))
2661 subdir('semihosting')
2669 common_user_inc = []
2671 subdir('common-user')
2673 subdir('linux-user')
2675 # needed for fuzzing binaries
2676 subdir('tests/qtest/libqos')
2677 subdir('tests/qtest/fuzz')
2680 tcg_real_module_ss = ss.source_set()
2681 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2682 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2683 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2684 'tcg': tcg_real_module_ss }}
2686 ########################
2687 # Library dependencies #
2688 ########################
2690 modinfo_collect = find_program('scripts/modinfo-collect.py')
2691 modinfo_generate = find_program('scripts/modinfo-generate.py')
2696 foreach d, list : modules
2697 foreach m, module_ss : list
2698 if enable_modules and targetos != 'windows'
2699 module_ss = module_ss.apply(config_all, strict: false)
2700 sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2701 dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2707 if module_ss.sources() != []
2708 # FIXME: Should use sl.extract_all_objects(recursive: true) as
2709 # input. Sources can be used multiple times but objects are
2710 # unique when it comes to lookup in compile_commands.json.
2711 # Depnds on a mesion version with
2712 # https://github.com/mesonbuild/meson/pull/8900
2713 modinfo_files += custom_target(d + '-' + m + '.modinfo',
2714 output: d + '-' + m + '.modinfo',
2715 input: module_ss.sources() + genh,
2717 command: [modinfo_collect, module_ss.sources()])
2721 block_ss.add_all(module_ss)
2723 softmmu_ss.add_all(module_ss)
2729 foreach d, list : target_modules
2730 foreach m, module_ss : list
2731 if enable_modules and targetos != 'windows'
2732 foreach target : target_dirs
2733 if target.endswith('-softmmu')
2734 config_target = config_target_mak[target]
2735 config_target += config_host
2736 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2737 c_args = ['-DNEED_CPU_H',
2738 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2739 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2740 target_module_ss = module_ss.apply(config_target, strict: false)
2741 if target_module_ss.sources() != []
2742 module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2743 sl = static_library(module_name,
2744 [genh, target_module_ss.sources()],
2745 dependencies: [modulecommon, target_module_ss.dependencies()],
2746 include_directories: target_inc,
2750 # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2751 modinfo_files += custom_target(module_name + '.modinfo',
2752 output: module_name + '.modinfo',
2753 input: target_module_ss.sources() + genh,
2755 command: [modinfo_collect, '--target', target, target_module_ss.sources()])
2760 specific_ss.add_all(module_ss)
2766 modinfo_src = custom_target('modinfo.c',
2767 output: 'modinfo.c',
2768 input: modinfo_files,
2769 command: [modinfo_generate, '@INPUT@'],
2771 modinfo_lib = static_library('modinfo', modinfo_src)
2772 modinfo_dep = declare_dependency(link_whole: modinfo_lib)
2773 softmmu_ss.add(modinfo_dep)
2776 nm = find_program('nm')
2777 undefsym = find_program('scripts/undefsym.py')
2778 block_syms = custom_target('block.syms', output: 'block.syms',
2779 input: [libqemuutil, block_mods],
2781 command: [undefsym, nm, '@INPUT@'])
2782 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
2783 input: [libqemuutil, softmmu_mods],
2785 command: [undefsym, nm, '@INPUT@'])
2787 qom_ss = qom_ss.apply(config_host, strict: false)
2788 libqom = static_library('qom', qom_ss.sources() + genh,
2789 dependencies: [qom_ss.dependencies()],
2792 qom = declare_dependency(link_whole: libqom)
2794 authz_ss = authz_ss.apply(config_host, strict: false)
2795 libauthz = static_library('authz', authz_ss.sources() + genh,
2796 dependencies: [authz_ss.dependencies()],
2798 build_by_default: false)
2800 authz = declare_dependency(link_whole: libauthz,
2803 crypto_ss = crypto_ss.apply(config_host, strict: false)
2804 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2805 dependencies: [crypto_ss.dependencies()],
2807 build_by_default: false)
2809 crypto = declare_dependency(link_whole: libcrypto,
2810 dependencies: [authz, qom])
2812 io_ss = io_ss.apply(config_host, strict: false)
2813 libio = static_library('io', io_ss.sources() + genh,
2814 dependencies: [io_ss.dependencies()],
2815 link_with: libqemuutil,
2817 build_by_default: false)
2819 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
2821 libmigration = static_library('migration', sources: migration_files + genh,
2823 build_by_default: false)
2824 migration = declare_dependency(link_with: libmigration,
2825 dependencies: [zlib, qom, io])
2826 softmmu_ss.add(migration)
2828 block_ss = block_ss.apply(config_host, strict: false)
2829 libblock = static_library('block', block_ss.sources() + genh,
2830 dependencies: block_ss.dependencies(),
2831 link_depends: block_syms,
2833 build_by_default: false)
2835 block = declare_dependency(link_whole: [libblock],
2836 link_args: '@block.syms',
2837 dependencies: [crypto, io])
2839 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
2840 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
2841 dependencies: blockdev_ss.dependencies(),
2843 build_by_default: false)
2845 blockdev = declare_dependency(link_whole: [libblockdev],
2846 dependencies: [block])
2848 qmp_ss = qmp_ss.apply(config_host, strict: false)
2849 libqmp = static_library('qmp', qmp_ss.sources() + genh,
2850 dependencies: qmp_ss.dependencies(),
2852 build_by_default: false)
2854 qmp = declare_dependency(link_whole: [libqmp])
2856 libchardev = static_library('chardev', chardev_ss.sources() + genh,
2858 dependencies: [gnutls],
2859 build_by_default: false)
2861 chardev = declare_dependency(link_whole: libchardev)
2863 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
2864 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
2866 build_by_default: false)
2867 hwcore = declare_dependency(link_whole: libhwcore)
2868 common_ss.add(hwcore)
2874 emulator_modules = []
2875 foreach m : block_mods + softmmu_mods
2876 emulator_modules += shared_module(m.name(),
2877 build_by_default: true,
2881 install_dir: qemu_moddir)
2884 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
2885 common_ss.add(qom, qemuutil)
2887 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
2888 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
2890 common_all = common_ss.apply(config_all, strict: false)
2891 common_all = static_library('common',
2892 build_by_default: false,
2893 sources: common_all.sources() + genh,
2894 include_directories: common_user_inc,
2895 implicit_include_directories: false,
2896 dependencies: common_all.dependencies(),
2899 feature_to_c = find_program('scripts/feature_to_c.sh')
2902 foreach target : target_dirs
2903 config_target = config_target_mak[target]
2904 target_name = config_target['TARGET_NAME']
2905 target_base_arch = config_target['TARGET_BASE_ARCH']
2906 arch_srcs = [config_target_h[target]]
2908 c_args = ['-DNEED_CPU_H',
2909 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2910 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2911 link_args = emulator_link_args
2913 config_target += config_host
2914 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2915 if targetos == 'linux'
2916 target_inc += include_directories('linux-headers', is_system: true)
2918 if target.endswith('-softmmu')
2919 qemu_target_name = 'qemu-system-' + target_name
2920 target_type='system'
2921 t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
2922 arch_srcs += t.sources()
2923 arch_deps += t.dependencies()
2925 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
2926 hw = hw_arch[hw_dir].apply(config_target, strict: false)
2927 arch_srcs += hw.sources()
2928 arch_deps += hw.dependencies()
2930 arch_srcs += config_devices_h[target]
2931 link_args += ['@block.syms', '@qemu.syms']
2933 abi = config_target['TARGET_ABI_DIR']
2935 target_inc += common_user_inc
2936 qemu_target_name = 'qemu-' + target_name
2937 if target_base_arch in target_user_arch
2938 t = target_user_arch[target_base_arch].apply(config_target, strict: false)
2939 arch_srcs += t.sources()
2940 arch_deps += t.dependencies()
2942 if 'CONFIG_LINUX_USER' in config_target
2943 base_dir = 'linux-user'
2945 if 'CONFIG_BSD_USER' in config_target
2946 base_dir = 'bsd-user'
2947 target_inc += include_directories('bsd-user/' / targetos)
2948 target_inc += include_directories('bsd-user/host/' / host_arch)
2949 dir = base_dir / abi
2950 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
2952 target_inc += include_directories(
2956 if 'CONFIG_LINUX_USER' in config_target
2957 dir = base_dir / abi
2958 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
2959 if config_target.has_key('TARGET_SYSTBL_ABI')
2961 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
2962 extra_args : config_target['TARGET_SYSTBL_ABI'])
2967 if 'TARGET_XML_FILES' in config_target
2968 gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
2969 output: target + '-gdbstub-xml.c',
2970 input: files(config_target['TARGET_XML_FILES'].split()),
2971 command: [feature_to_c, '@INPUT@'],
2973 arch_srcs += gdbstub_xml
2976 t = target_arch[target_base_arch].apply(config_target, strict: false)
2977 arch_srcs += t.sources()
2978 arch_deps += t.dependencies()
2980 target_common = common_ss.apply(config_target, strict: false)
2981 objects = common_all.extract_objects(target_common.sources())
2982 deps = target_common.dependencies()
2984 target_specific = specific_ss.apply(config_target, strict: false)
2985 arch_srcs += target_specific.sources()
2986 arch_deps += target_specific.dependencies()
2988 lib = static_library('qemu-' + target,
2989 sources: arch_srcs + genh,
2990 dependencies: arch_deps,
2992 include_directories: target_inc,
2994 build_by_default: false,
2997 if target.endswith('-softmmu')
2999 'name': 'qemu-system-' + target_name,
3000 'win_subsystem': 'console',
3001 'sources': files('softmmu/main.c'),
3004 if targetos == 'windows' and (sdl.found() or gtk.found())
3006 'name': 'qemu-system-' + target_name + 'w',
3007 'win_subsystem': 'windows',
3008 'sources': files('softmmu/main.c'),
3012 if get_option('fuzzing')
3013 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3015 'name': 'qemu-fuzz-' + target_name,
3016 'win_subsystem': 'console',
3017 'sources': specific_fuzz.sources(),
3018 'dependencies': specific_fuzz.dependencies(),
3023 'name': 'qemu-' + target_name,
3024 'win_subsystem': 'console',
3030 exe_name = exe['name']
3031 if targetos == 'darwin'
3032 exe_name += '-unsigned'
3035 emulator = executable(exe_name, exe['sources'],
3038 dependencies: arch_deps + deps + exe['dependencies'],
3039 objects: lib.extract_all_objects(recursive: true),
3040 link_language: link_language,
3041 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3042 link_args: link_args,
3043 win_subsystem: exe['win_subsystem'])
3045 if targetos == 'darwin'
3046 icon = 'pc-bios/qemu.rsrc'
3047 build_input = [emulator, files(icon)]
3049 get_option('bindir') / exe_name,
3050 meson.current_source_dir() / icon
3052 if 'CONFIG_HVF' in config_target
3053 entitlements = 'accel/hvf/entitlements.plist'
3054 build_input += files(entitlements)
3055 install_input += meson.current_source_dir() / entitlements
3058 entitlement = find_program('scripts/entitlement.sh')
3059 emulators += {exe['name'] : custom_target(exe['name'],
3061 output: exe['name'],
3062 command: [entitlement, '@OUTPUT@', '@INPUT@'])
3065 meson.add_install_script(entitlement, '--install',
3066 get_option('bindir') / exe['name'],
3069 emulators += {exe['name']: emulator}
3074 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3075 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3076 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3077 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3079 custom_target(exe['name'] + stp['ext'],
3080 input: trace_events_all,
3081 output: exe['name'] + stp['ext'],
3082 install: stp['install'],
3083 install_dir: get_option('datadir') / 'systemtap/tapset',
3085 tracetool, '--group=all', '--format=' + stp['fmt'],
3086 '--binary=' + stp['bin'],
3087 '--target-name=' + target_name,
3088 '--target-type=' + target_type,
3089 '--probe-prefix=qemu.' + target_type + '.' + target_name,
3090 '@INPUT@', '@OUTPUT@'
3092 depend_files: tracetool_depends)
3098 # Other build targets
3100 if 'CONFIG_PLUGIN' in config_host
3101 install_headers('include/qemu/qemu-plugin.h')
3104 if 'CONFIG_GUEST_AGENT' in config_host
3106 elif get_option('guest_agent_msi').enabled()
3107 error('Guest agent MSI requested, but the guest agent is not being built')
3110 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3111 # when we don't build tools or system
3112 if xkbcommon.found()
3113 # used for the update-keymaps target, so include rules even if !have_tools
3114 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3115 dependencies: [qemuutil, xkbcommon], install: have_tools)
3119 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3120 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3121 qemu_io = executable('qemu-io', files('qemu-io.c'),
3122 dependencies: [block, qemuutil], install: true)
3123 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3124 dependencies: [blockdev, qemuutil, gnutls, selinux],
3127 subdir('storage-daemon')
3128 subdir('contrib/rdmacm-mux')
3129 subdir('contrib/elf2dmp')
3131 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3132 dependencies: qemuutil,
3135 if 'CONFIG_VHOST_USER' in config_host
3136 subdir('contrib/vhost-user-blk')
3137 subdir('contrib/vhost-user-gpu')
3138 subdir('contrib/vhost-user-input')
3139 subdir('contrib/vhost-user-scsi')
3142 if targetos == 'linux'
3143 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3144 dependencies: [qemuutil, libcap_ng],
3146 install_dir: get_option('libexecdir'))
3148 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3149 dependencies: [authz, crypto, io, qom, qemuutil,
3150 libcap_ng, mpathpersist],
3155 subdir('contrib/ivshmem-client')
3156 subdir('contrib/ivshmem-server')
3169 if host_machine.system() == 'windows'
3171 find_program('scripts/nsis.py'),
3173 get_option('prefix'),
3174 meson.current_source_dir(),
3177 '-DDISPLAYVERSION=' + meson.project_version(),
3180 nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3183 nsis_cmd += '-DCONFIG_GTK=y'
3186 nsis = custom_target('nsis',
3187 output: 'qemu-setup-' + meson.project_version() + '.exe',
3188 input: files('qemu.nsi'),
3189 build_always_stale: true,
3190 command: nsis_cmd + ['@INPUT@'])
3191 alias_target('installer', nsis)
3194 #########################
3195 # Configuration summary #
3196 #########################
3200 summary_info += {'Install prefix': get_option('prefix')}
3201 summary_info += {'BIOS directory': qemu_datadir}
3202 summary_info += {'firmware path': get_option('qemu_firmwarepath')}
3203 summary_info += {'binary directory': get_option('bindir')}
3204 summary_info += {'library directory': get_option('libdir')}
3205 summary_info += {'module directory': qemu_moddir}
3206 summary_info += {'libexec directory': get_option('libexecdir')}
3207 summary_info += {'include directory': get_option('includedir')}
3208 summary_info += {'config directory': get_option('sysconfdir')}
3209 if targetos != 'windows'
3210 summary_info += {'local state directory': get_option('localstatedir')}
3211 summary_info += {'Manual directory': get_option('mandir')}
3213 summary_info += {'local state directory': 'queried at runtime'}
3215 summary_info += {'Doc directory': get_option('docdir')}
3216 summary_info += {'Build directory': meson.current_build_dir()}
3217 summary_info += {'Source path': meson.current_source_dir()}
3218 summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']}
3219 summary(summary_info, bool_yn: true, section: 'Directories')
3223 summary_info += {'git': config_host['GIT']}
3224 summary_info += {'make': config_host['MAKE']}
3225 summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3226 summary_info += {'sphinx-build': sphinx_build}
3227 if config_host.has_key('HAVE_GDB_BIN')
3228 summary_info += {'gdb': config_host['HAVE_GDB_BIN']}
3230 summary_info += {'genisoimage': config_host['GENISOIMAGE']}
3231 if targetos == 'windows' and config_host.has_key('CONFIG_GUEST_AGENT')
3232 summary_info += {'wixl': wixl}
3234 if slirp_opt != 'disabled' and 'CONFIG_SLIRP_SMBD' in config_host
3235 summary_info += {'smbd': config_host['CONFIG_SMBD_COMMAND']}
3237 summary(summary_info, bool_yn: true, section: 'Host binaries')
3239 # Configurable features
3241 summary_info += {'Documentation': build_docs}
3242 summary_info += {'system-mode emulation': have_system}
3243 summary_info += {'user-mode emulation': have_user}
3244 summary_info += {'block layer': have_block}
3245 summary_info += {'Install blobs': get_option('install_blobs')}
3246 summary_info += {'module support': config_host.has_key('CONFIG_MODULES')}
3247 if config_host.has_key('CONFIG_MODULES')
3248 summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
3250 summary_info += {'fuzzing support': get_option('fuzzing')}
3252 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)}
3254 summary_info += {'Trace backends': ','.join(get_option('trace_backends'))}
3255 if 'simple' in get_option('trace_backends')
3256 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3258 summary_info += {'D-Bus display': dbus_display}
3259 summary_info += {'QOM debugging': config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
3260 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
3261 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
3262 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
3263 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
3264 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
3265 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
3266 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3267 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
3268 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
3269 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
3270 summary(summary_info, bool_yn: true, section: 'Configurable features')
3272 # Compilation information
3274 summary_info += {'host CPU': cpu}
3275 summary_info += {'host endianness': build_machine.endian()}
3276 summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())}
3277 summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3278 if link_language == 'cpp'
3279 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())}
3281 summary_info += {'C++ compiler': false}
3283 if targetos == 'darwin'
3284 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3286 if targetos == 'windows'
3287 if 'WIN_SDK' in config_host
3288 summary_info += {'Windows SDK': config_host['WIN_SDK']}
3291 summary_info += {'CFLAGS': ' '.join(get_option('c_args')
3292 + ['-O' + get_option('optimization')]
3293 + (get_option('debug') ? ['-g'] : []))}
3294 if link_language == 'cpp'
3295 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args')
3296 + ['-O' + get_option('optimization')]
3297 + (get_option('debug') ? ['-g'] : []))}
3299 link_args = get_option(link_language + '_link_args')
3300 if link_args.length() > 0
3301 summary_info += {'LDFLAGS': ' '.join(link_args)}
3303 summary_info += {'QEMU_CFLAGS': config_host['QEMU_CFLAGS']}
3304 summary_info += {'QEMU_LDFLAGS': config_host['QEMU_LDFLAGS']}
3305 summary_info += {'profiler': config_host.has_key('CONFIG_PROFILER')}
3306 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3307 summary_info += {'PIE': get_option('b_pie')}
3308 summary_info += {'static build': config_host.has_key('CONFIG_STATIC')}
3309 summary_info += {'malloc trim support': has_malloc_trim}
3310 summary_info += {'membarrier': config_host.has_key('CONFIG_MEMBARRIER')}
3311 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
3312 summary_info += {'mutex debugging': config_host.has_key('CONFIG_DEBUG_MUTEX')}
3313 summary_info += {'memory allocator': get_option('malloc')}
3314 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
3315 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
3316 summary_info += {'gprof enabled': config_host.has_key('CONFIG_GPROF')}
3317 summary_info += {'gcov': get_option('b_coverage')}
3318 summary_info += {'thread sanitizer': config_host.has_key('CONFIG_TSAN')}
3319 summary_info += {'CFI support': get_option('cfi')}
3320 if get_option('cfi')
3321 summary_info += {'CFI debug support': get_option('cfi_debug')}
3323 summary_info += {'strip binaries': get_option('strip')}
3324 summary_info += {'sparse': sparse}
3325 summary_info += {'mingw32 support': targetos == 'windows'}
3327 # snarf the cross-compilation information for tests
3328 foreach target: target_dirs
3329 tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3330 if fs.exists(tcg_mak)
3331 config_cross_tcg = keyval.load(tcg_mak)
3332 target = config_cross_tcg['TARGET_NAME']
3334 if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
3335 summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
3336 ' via ' + config_cross_tcg['DOCKER_IMAGE']}
3337 elif 'CROSS_CC_GUEST' in config_cross_tcg
3338 summary_info += {target + ' tests'
3339 : config_cross_tcg['CROSS_CC_GUEST'] }
3344 summary(summary_info, bool_yn: true, section: 'Compilation')
3346 # Targets and accelerators
3349 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')}
3350 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')}
3351 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')}
3352 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')}
3353 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')}
3354 summary_info += {'Xen support': config_host.has_key('CONFIG_XEN_BACKEND')}
3355 if config_host.has_key('CONFIG_XEN_BACKEND')
3356 summary_info += {'xen ctrl version': config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
3359 summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')}
3360 if config_all.has_key('CONFIG_TCG')
3361 if get_option('tcg_interpreter')
3362 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'}
3364 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)}
3366 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3367 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3369 summary_info += {'target list': ' '.join(target_dirs)}
3371 summary_info += {'default devices': get_option('default_devices')}
3372 summary_info += {'out of process emulation': multiprocess_allowed}
3374 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3378 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3379 summary_info += {'coroutine pool': config_host['CONFIG_COROUTINE_POOL'] == '1'}
3381 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3382 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3383 summary_info += {'Use block whitelist in tools': config_host.has_key('CONFIG_BDRV_WHITELIST_TOOLS')}
3384 summary_info += {'VirtFS support': have_virtfs}
3385 summary_info += {'build virtiofs daemon': have_virtiofsd}
3386 summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
3387 summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
3388 summary_info += {'bochs support': config_host.has_key('CONFIG_BOCHS')}
3389 summary_info += {'cloop support': config_host.has_key('CONFIG_CLOOP')}
3390 summary_info += {'dmg support': config_host.has_key('CONFIG_DMG')}
3391 summary_info += {'qcow v1 support': config_host.has_key('CONFIG_QCOW1')}
3392 summary_info += {'vdi support': config_host.has_key('CONFIG_VDI')}
3393 summary_info += {'vvfat support': config_host.has_key('CONFIG_VVFAT')}
3394 summary_info += {'qed support': config_host.has_key('CONFIG_QED')}
3395 summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
3396 summary_info += {'FUSE exports': fuse}
3398 summary(summary_info, bool_yn: true, section: 'Block layer support')
3402 summary_info += {'TLS priority': config_host['CONFIG_TLS_PRIORITY']}
3403 summary_info += {'GNUTLS support': gnutls}
3405 summary_info += {' GNUTLS crypto': gnutls_crypto.found()}
3407 summary_info += {'libgcrypt': gcrypt}
3408 summary_info += {'nettle': nettle}
3410 summary_info += {' XTS': xts != 'private'}
3412 summary_info += {'crypto afalg': config_host.has_key('CONFIG_AF_ALG')}
3413 summary_info += {'rng-none': config_host.has_key('CONFIG_RNG_NONE')}
3414 summary_info += {'Linux keyring': config_host.has_key('CONFIG_SECRET_KEYRING')}
3415 summary(summary_info, bool_yn: true, section: 'Crypto')
3419 if targetos == 'darwin'
3420 summary_info += {'Cocoa support': cocoa}
3422 summary_info += {'SDL support': sdl}
3423 summary_info += {'SDL image support': sdl_image}
3424 summary_info += {'GTK support': gtk}
3425 summary_info += {'pixman': pixman}
3426 summary_info += {'VTE support': vte}
3427 summary_info += {'slirp support': slirp_opt == 'internal' ? slirp_opt : slirp}
3428 summary_info += {'libtasn1': tasn1}
3429 summary_info += {'PAM': pam}
3430 summary_info += {'iconv support': iconv}
3431 summary_info += {'curses support': curses}
3432 summary_info += {'virgl support': virgl}
3433 summary_info += {'curl support': curl}
3434 summary_info += {'Multipath support': mpathpersist}
3435 summary_info += {'VNC support': vnc}
3437 summary_info += {'VNC SASL support': sasl}
3438 summary_info += {'VNC JPEG support': jpeg}
3439 summary_info += {'VNC PNG support': png}
3441 if targetos not in ['darwin', 'haiku', 'windows']
3442 summary_info += {'OSS support': oss}
3443 elif targetos == 'darwin'
3444 summary_info += {'CoreAudio support': coreaudio}
3445 elif targetos == 'windows'
3446 summary_info += {'DirectSound support': dsound}
3448 if targetos == 'linux'
3449 summary_info += {'ALSA support': alsa}
3450 summary_info += {'PulseAudio support': pulse}
3452 summary_info += {'JACK support': jack}
3453 summary_info += {'brlapi support': brlapi}
3454 summary_info += {'vde support': vde}
3455 summary_info += {'netmap support': have_netmap}
3456 summary_info += {'l2tpv3 support': have_l2tpv3}
3457 summary_info += {'Linux AIO support': libaio}
3458 summary_info += {'Linux io_uring support': linux_io_uring}
3459 summary_info += {'ATTR/XATTR support': libattr}
3460 summary_info += {'RDMA support': config_host.has_key('CONFIG_RDMA')}
3461 summary_info += {'PVRDMA support': config_host.has_key('CONFIG_PVRDMA')}
3462 summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt}
3463 summary_info += {'libcap-ng support': libcap_ng}
3464 summary_info += {'bpf support': libbpf}
3465 summary_info += {'spice protocol support': spice_protocol}
3466 if spice_protocol.found()
3467 summary_info += {' spice server support': spice}
3469 summary_info += {'rbd support': rbd}
3470 summary_info += {'smartcard support': cacard}
3471 summary_info += {'U2F support': u2f}
3472 summary_info += {'libusb': libusb}
3473 summary_info += {'usb net redir': usbredir}
3474 summary_info += {'OpenGL support': config_host.has_key('CONFIG_OPENGL')}
3475 summary_info += {'GBM': gbm}
3476 summary_info += {'libiscsi support': libiscsi}
3477 summary_info += {'libnfs support': libnfs}
3478 if targetos == 'windows'
3479 if config_host.has_key('CONFIG_GUEST_AGENT')
3480 summary_info += {'QGA VSS support': config_host.has_key('CONFIG_QGA_VSS')}
3481 summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
3484 summary_info += {'seccomp support': seccomp}
3485 summary_info += {'GlusterFS support': glusterfs}
3486 summary_info += {'TPM support': config_host.has_key('CONFIG_TPM')}
3487 summary_info += {'libssh support': libssh}
3488 summary_info += {'lzo support': lzo}
3489 summary_info += {'snappy support': snappy}
3490 summary_info += {'bzip2 support': libbzip2}
3491 summary_info += {'lzfse support': liblzfse}
3492 summary_info += {'zstd support': zstd}
3493 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
3494 summary_info += {'capstone': capstone_opt == 'internal' ? capstone_opt : capstone}
3495 summary_info += {'libpmem support': libpmem}
3496 summary_info += {'libdaxctl support': libdaxctl}
3497 summary_info += {'libudev': libudev}
3498 # Dummy dependency, keep .found()
3499 summary_info += {'FUSE lseek': fuse_lseek.found()}
3500 summary_info += {'selinux': selinux}
3501 summary(summary_info, bool_yn: true, section: 'Dependencies')
3503 if not supported_cpus.contains(cpu)
3505 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3507 message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3508 message('The QEMU project intends to remove support for this host CPU in')
3509 message('a future release if nobody volunteers to maintain it and to')
3510 message('provide a build host for our continuous integration setup.')
3511 message('configure has succeeded and you can continue to build, but')
3512 message('if you care about QEMU on this platform you should contact')
3513 message('us upstream at qemu-devel@nongnu.org.')
3516 if not supported_oses.contains(targetos)
3518 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3520 message('Host OS ' + targetos + 'support is not currently maintained.')
3521 message('The QEMU project intends to remove support for this host OS in')
3522 message('a future release if nobody volunteers to maintain it and to')
3523 message('provide a build host for our continuous integration setup.')
3524 message('configure has succeeded and you can continue to build, but')
3525 message('if you care about QEMU on this platform you should contact')
3526 message('us upstream at qemu-devel@nongnu.org.')