| blob | 7bdbbbdf02ed0e9428a5c4f00676ebb7fade44af |
1 project('qemu', ['c'], meson_version: '>=0.55.0',
2 default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto'] +
3 (meson.version().version_compare('>=0.56.0') ? [ 'b_staticpic=false' ] : []),
4 version: run_command('head', meson.source_root() / 'VERSION').stdout().strip())
6 not_found = dependency('', required: false)
7 if meson.version().version_compare('>=0.56.0')
8 keyval = import('keyval')
9 else
10 keyval = import('unstable-keyval')
11 endif
12 ss = import('sourceset')
13 fs = import('fs')
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 /')
33 endif
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()
44 genh = []
46 target_dirs = config_host['TARGET_DIRS'].split()
47 have_user = false
48 have_system = false
49 foreach target : target_dirs
50 have_user = have_user or target.endswith('-user')
51 have_system = have_system or target.endswith('-softmmu')
52 endforeach
53 have_tools = 'CONFIG_TOOLS' in config_host
54 have_block = have_system or have_tools
56 python = import('python').find_installation()
58 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
59 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64',
60 'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
62 cpu = host_machine.cpu_family()
63 targetos = host_machine.system()
65 if cpu in ['x86', 'x86_64']
66 kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
67 elif cpu == 'aarch64'
68 kvm_targets = ['aarch64-softmmu']
69 elif cpu == 's390x'
70 kvm_targets = ['s390x-softmmu']
71 elif cpu in ['ppc', 'ppc64']
72 kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
73 elif cpu in ['mips', 'mips64']
74 kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
75 else
76 kvm_targets = []
77 endif
79 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
81 if cpu in ['aarch64']
82 accelerator_targets += {
83 'CONFIG_HVF': ['aarch64-softmmu']
84 }
85 endif
87 if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
88 # i386 emulator provides xenpv machine type for multiple architectures
89 accelerator_targets += {
90 'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
91 }
92 endif
93 if cpu in ['x86', 'x86_64']
94 accelerator_targets += {
95 'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
96 'CONFIG_HVF': ['x86_64-softmmu'],
97 'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
98 'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
99 }
100 endif
102 modular_tcg = []
103 # Darwin does not support references to thread-local variables in modules
104 if targetos != 'darwin'
105 modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
106 endif
108 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
109 install_edk2_blobs = false
110 if get_option('install_blobs')
111 foreach target : target_dirs
112 install_edk2_blobs = install_edk2_blobs or target in edk2_targets
113 endforeach
114 endif
116 bzip2 = find_program('bzip2', required: install_edk2_blobs)
118 ##################
119 # Compiler flags #
120 ##################
122 # Specify linker-script with add_project_link_arguments so that it is not placed
123 # within a linker --start-group/--end-group pair
124 if 'CONFIG_FUZZ' in config_host
125 add_project_link_arguments(['-Wl,-T,',
126 (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
127 native: false, language: ['c', 'cpp', 'objc'])
128 endif
130 add_global_arguments(config_host['QEMU_CFLAGS'].split(),
131 native: false, language: ['c', 'objc'])
132 add_global_arguments(config_host['QEMU_CXXFLAGS'].split(),
133 native: false, language: 'cpp')
134 add_global_link_arguments(config_host['QEMU_LDFLAGS'].split(),
135 native: false, language: ['c', 'cpp', 'objc'])
137 if targetos == 'linux'
138 add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
139 '-isystem', 'linux-headers',
140 language: ['c', 'cpp'])
141 endif
143 add_project_arguments('-iquote', '.',
144 '-iquote', meson.current_source_dir(),
145 '-iquote', meson.current_source_dir() / 'include',
146 '-iquote', meson.current_source_dir() / 'disas/libvixl',
147 language: ['c', 'cpp', 'objc'])
149 link_language = meson.get_external_property('link_language', 'cpp')
150 if link_language == 'cpp'
151 add_languages('cpp', required: true, native: false)
152 endif
153 if host_machine.system() == 'darwin'
154 add_languages('objc', required: false, native: false)
155 endif
157 sparse = find_program('cgcc', required: get_option('sparse'))
158 if sparse.found()
159 run_target('sparse',
160 command: [find_program('scripts/check_sparse.py'),
161 'compile_commands.json', sparse.full_path(), '-Wbitwise',
162 '-Wno-transparent-union', '-Wno-old-initializer',
163 '-Wno-non-pointer-null'])
164 endif
166 ###########################################
167 # Target-specific checks and dependencies #
168 ###########################################
170 if targetos != 'linux' and get_option('mpath').enabled()
171 error('Multipath is supported only on Linux')
172 endif
174 if targetos != 'linux' and get_option('multiprocess').enabled()
175 error('Multiprocess QEMU is supported only on Linux')
176 endif
177 multiprocess_allowed = targetos == 'linux' and not get_option('multiprocess').disabled()
179 libm = cc.find_library('m', required: false)
180 threads = dependency('threads')
181 util = cc.find_library('util', required: false)
182 winmm = []
183 socket = []
184 version_res = []
185 coref = []
186 iokit = []
187 emulator_link_args = []
188 nvmm =not_found
189 hvf = not_found
190 if targetos == 'windows'
191 socket = cc.find_library('ws2_32')
192 winmm = cc.find_library('winmm')
194 win = import('windows')
195 version_res = win.compile_resources('version.rc',
196 depend_files: files('pc-bios/qemu-nsis.ico'),
197 include_directories: include_directories('.'))
198 elif targetos == 'darwin'
199 coref = dependency('appleframeworks', modules: 'CoreFoundation')
200 iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
201 elif targetos == 'sunos'
202 socket = [cc.find_library('socket'),
203 cc.find_library('nsl'),
204 cc.find_library('resolv')]
205 elif targetos == 'haiku'
206 socket = [cc.find_library('posix_error_mapper'),
207 cc.find_library('network'),
208 cc.find_library('bsd')]
209 elif targetos == 'openbsd'
210 if not get_option('tcg').disabled() and target_dirs.length() > 0
211 # Disable OpenBSD W^X if available
212 emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
213 endif
214 endif
216 accelerators = []
217 if not get_option('kvm').disabled() and targetos == 'linux'
218 accelerators += 'CONFIG_KVM'
219 endif
220 if not get_option('xen').disabled() and 'CONFIG_XEN_BACKEND' in config_host
221 accelerators += 'CONFIG_XEN'
222 have_xen_pci_passthrough = not get_option('xen_pci_passthrough').disabled() and targetos == 'linux'
223 else
224 have_xen_pci_passthrough = false
225 endif
226 if not get_option('whpx').disabled() and targetos == 'windows'
227 if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
228 error('WHPX requires 64-bit host')
229 elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
230 cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
231 accelerators += 'CONFIG_WHPX'
232 endif
233 endif
234 if not get_option('hvf').disabled()
235 hvf = dependency('appleframeworks', modules: 'Hypervisor',
236 required: get_option('hvf'))
237 if hvf.found()
238 accelerators += 'CONFIG_HVF'
239 endif
240 endif
241 if not get_option('hax').disabled()
242 if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
243 accelerators += 'CONFIG_HAX'
244 endif
245 endif
246 if targetos == 'netbsd'
247 if cc.has_header_symbol('nvmm.h', 'nvmm_cpu_stop', required: get_option('nvmm'))
248 nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
249 endif
250 if nvmm.found()
251 accelerators += 'CONFIG_NVMM'
252 endif
253 endif
255 tcg_arch = config_host['ARCH']
256 if not get_option('tcg').disabled()
257 if cpu not in supported_cpus
258 if get_option('tcg_interpreter')
259 warning('Unsupported CPU @0@, will use TCG with TCI (experimental and slow)'.format(cpu))
260 else
261 error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
262 endif
263 elif get_option('tcg_interpreter')
264 warning('Use of the TCG interpretor is not recommended on this host')
265 warning('architecture. There is a native TCG execution backend available')
266 warning('which provides substantially better performance and reliability.')
267 warning('It is strongly recommended to remove the --enable-tcg-interpreter')
268 warning('configuration option on this architecture to use the native')
269 warning('backend.')
270 endif
271 if get_option('tcg_interpreter')
272 tcg_arch = 'tci'
273 elif config_host['ARCH'] == 'sparc64'
274 tcg_arch = 'sparc'
275 elif config_host['ARCH'] == 's390x'
276 tcg_arch = 's390'
277 elif config_host['ARCH'] in ['x86_64', 'x32']
278 tcg_arch = 'i386'
279 elif config_host['ARCH'] == 'ppc64'
280 tcg_arch = 'ppc'
281 elif config_host['ARCH'] in ['riscv32', 'riscv64']
282 tcg_arch = 'riscv'
283 endif
284 add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
285 language: ['c', 'cpp', 'objc'])
287 accelerators += 'CONFIG_TCG'
288 config_host += { 'CONFIG_TCG': 'y' }
289 endif
291 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
292 error('KVM not available on this platform')
293 endif
294 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
295 error('HVF not available on this platform')
296 endif
297 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
298 error('NVMM not available on this platform')
299 endif
300 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
301 error('WHPX not available on this platform')
302 endif
303 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
304 if 'CONFIG_XEN' in accelerators
305 error('Xen PCI passthrough not available on this platform')
306 else
307 error('Xen PCI passthrough requested but Xen not enabled')
308 endif
309 endif
311 ################
312 # Dependencies #
313 ################
315 # The path to glib.h is added to all compilation commands. This was
316 # grandfathered in from the QEMU Makefiles.
317 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
318 native: false, language: ['c', 'cpp', 'objc'])
319 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
320 link_args: config_host['GLIB_LIBS'].split())
321 # override glib dep with the configure results (for subprojects)
322 meson.override_dependency('glib-2.0', glib)
324 gio = not_found
325 if 'CONFIG_GIO' in config_host
326 gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
327 link_args: config_host['GIO_LIBS'].split())
328 endif
329 lttng = not_found
330 if 'CONFIG_TRACE_UST' in config_host
331 lttng = declare_dependency(link_args: config_host['LTTNG_UST_LIBS'].split())
332 endif
333 pixman = not_found
334 if have_system or have_tools
335 pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
336 method: 'pkg-config', kwargs: static_kwargs)
337 endif
338 libaio = cc.find_library('aio', required: false)
339 zlib = dependency('zlib', required: true, kwargs: static_kwargs)
341 linux_io_uring = not_found
342 if not get_option('linux_io_uring').auto() or have_block
343 linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
344 method: 'pkg-config', kwargs: static_kwargs)
345 endif
346 libxml2 = not_found
347 if not get_option('libxml2').auto() or have_block
348 libxml2 = dependency('libxml-2.0', required: get_option('libxml2'),
349 method: 'pkg-config', kwargs: static_kwargs)
350 endif
351 libnfs = not_found
352 if not get_option('libnfs').auto() or have_block
353 libnfs = dependency('libnfs', version: '>=1.9.3',
354 required: get_option('libnfs'),
355 method: 'pkg-config', kwargs: static_kwargs)
356 endif
358 libattr_test = '''
359 #include <stddef.h>
360 #include <sys/types.h>
361 #ifdef CONFIG_LIBATTR
362 #include <attr/xattr.h>
363 #else
364 #include <sys/xattr.h>
365 #endif
366 int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
368 libattr = not_found
369 have_old_libattr = false
370 if not get_option('attr').disabled()
371 if cc.links(libattr_test)
372 libattr = declare_dependency()
373 else
374 libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
375 required: get_option('attr'),
376 kwargs: static_kwargs)
377 if libattr.found() and not \
378 cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
379 libattr = not_found
380 if get_option('attr').enabled()
381 error('could not link libattr')
382 else
383 warning('could not link libattr, disabling')
384 endif
385 else
386 have_old_libattr = libattr.found()
387 endif
388 endif
389 endif
391 cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
392 if cocoa.found() and get_option('sdl').enabled()
393 error('Cocoa and SDL cannot be enabled at the same time')
394 endif
395 if cocoa.found() and get_option('gtk').enabled()
396 error('Cocoa and GTK+ cannot be enabled at the same time')
397 endif
399 seccomp = not_found
400 if not get_option('seccomp').auto() or have_system or have_tools
401 seccomp = dependency('libseccomp', version: '>=2.3.0',
402 required: get_option('seccomp'),
403 method: 'pkg-config', kwargs: static_kwargs)
404 endif
406 libcap_ng = not_found
407 if not get_option('cap_ng').auto() or have_system or have_tools
408 libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
409 required: get_option('cap_ng'),
410 kwargs: static_kwargs)
411 endif
412 if libcap_ng.found() and not cc.links('''
413 #include <cap-ng.h>
414 int main(void)
415 {
416 capng_capability_to_name(CAPNG_EFFECTIVE);
417 return 0;
418 }''', dependencies: libcap_ng)
419 libcap_ng = not_found
420 if get_option('cap_ng').enabled()
421 error('could not link libcap-ng')
422 else
423 warning('could not link libcap-ng, disabling')
424 endif
425 endif
427 if get_option('xkbcommon').auto() and not have_system and not have_tools
428 xkbcommon = not_found
429 else
430 xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
431 method: 'pkg-config', kwargs: static_kwargs)
432 endif
433 vde = not_found
434 if config_host.has_key('CONFIG_VDE')
435 vde = declare_dependency(link_args: config_host['VDE_LIBS'].split())
436 endif
437 pulse = not_found
438 if 'CONFIG_LIBPULSE' in config_host
439 pulse = declare_dependency(compile_args: config_host['PULSE_CFLAGS'].split(),
440 link_args: config_host['PULSE_LIBS'].split())
441 endif
442 alsa = not_found
443 if 'CONFIG_ALSA' in config_host
444 alsa = declare_dependency(compile_args: config_host['ALSA_CFLAGS'].split(),
445 link_args: config_host['ALSA_LIBS'].split())
446 endif
447 jack = not_found
448 if 'CONFIG_LIBJACK' in config_host
449 jack = declare_dependency(link_args: config_host['JACK_LIBS'].split())
450 endif
451 spice = not_found
452 spice_headers = not_found
453 spice_protocol = not_found
454 if 'CONFIG_SPICE' in config_host
455 spice = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split(),
456 link_args: config_host['SPICE_LIBS'].split())
457 spice_headers = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split())
458 endif
459 if 'CONFIG_SPICE_PROTOCOL' in config_host
460 spice_protocol = declare_dependency(compile_args: config_host['SPICE_PROTOCOL_CFLAGS'].split())
461 endif
462 rt = cc.find_library('rt', required: false)
463 libdl = not_found
464 if 'CONFIG_PLUGIN' in config_host
465 libdl = cc.find_library('dl', required: false)
466 if not cc.has_function('dlopen', dependencies: libdl)
467 error('dlopen not found')
468 endif
469 endif
470 libiscsi = not_found
471 if not get_option('libiscsi').auto() or have_block
472 libiscsi = dependency('libiscsi', version: '>=1.9.0',
473 required: get_option('libiscsi'),
474 method: 'pkg-config', kwargs: static_kwargs)
475 endif
476 zstd = not_found
477 if not get_option('zstd').auto() or have_block
478 zstd = dependency('libzstd', version: '>=1.4.0',
479 required: get_option('zstd'),
480 method: 'pkg-config', kwargs: static_kwargs)
481 endif
482 virgl = not_found
483 if not get_option('virglrenderer').auto() or have_system
484 virgl = dependency('virglrenderer',
485 method: 'pkg-config',
486 required: get_option('virglrenderer'),
487 kwargs: static_kwargs)
488 endif
489 curl = not_found
490 if not get_option('curl').auto() or have_block
491 curl = dependency('libcurl', version: '>=7.29.0',
492 method: 'pkg-config',
493 required: get_option('curl'),
494 kwargs: static_kwargs)
495 endif
496 libudev = not_found
497 if targetos == 'linux' and (have_system or have_tools)
498 libudev = dependency('libudev',
499 method: 'pkg-config',
500 required: get_option('libudev'),
501 kwargs: static_kwargs)
502 endif
504 mpathlibs = [libudev]
505 mpathpersist = not_found
506 mpathpersist_new_api = false
507 if targetos == 'linux' and have_tools and not get_option('mpath').disabled()
508 mpath_test_source_new = '''
509 #include <libudev.h>
510 #include <mpath_persist.h>
511 unsigned mpath_mx_alloc_len = 1024;
512 int logsink;
513 static struct config *multipath_conf;
514 extern struct udev *udev;
515 extern struct config *get_multipath_config(void);
516 extern void put_multipath_config(struct config *conf);
517 struct udev *udev;
518 struct config *get_multipath_config(void) { return multipath_conf; }
519 void put_multipath_config(struct config *conf) { }
520 int main(void) {
521 udev = udev_new();
522 multipath_conf = mpath_lib_init();
523 return 0;
524 }'''
525 mpath_test_source_old = '''
526 #include <libudev.h>
527 #include <mpath_persist.h>
528 unsigned mpath_mx_alloc_len = 1024;
529 int logsink;
530 int main(void) {
531 struct udev *udev = udev_new();
532 mpath_lib_init(udev);
533 return 0;
534 }'''
535 libmpathpersist = cc.find_library('mpathpersist',
536 required: get_option('mpath'),
537 kwargs: static_kwargs)
538 if libmpathpersist.found()
539 mpathlibs += libmpathpersist
540 if enable_static
541 mpathlibs += cc.find_library('devmapper',
542 required: get_option('mpath'),
543 kwargs: static_kwargs)
544 endif
545 mpathlibs += cc.find_library('multipath',
546 required: get_option('mpath'),
547 kwargs: static_kwargs)
548 foreach lib: mpathlibs
549 if not lib.found()
550 mpathlibs = []
551 break
552 endif
553 endforeach
554 if mpathlibs.length() == 0
555 msg = 'Dependencies missing for libmpathpersist'
556 elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
557 mpathpersist = declare_dependency(dependencies: mpathlibs)
558 mpathpersist_new_api = true
559 elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
560 mpathpersist = declare_dependency(dependencies: mpathlibs)
561 else
562 msg = 'Cannot detect libmpathpersist API'
563 endif
564 if not mpathpersist.found()
565 if get_option('mpath').enabled()
566 error(msg)
567 else
568 warning(msg + ', disabling')
569 endif
570 endif
571 endif
572 endif
574 iconv = not_found
575 curses = not_found
576 if have_system and not get_option('curses').disabled()
577 curses_test = '''
578 #include <locale.h>
579 #include <curses.h>
580 #include <wchar.h>
581 int main(void) {
582 wchar_t wch = L'w';
583 setlocale(LC_ALL, "");
584 resize_term(0, 0);
585 addwstr(L"wide chars\n");
586 addnwstr(&wch, 1);
587 add_wch(WACS_DEGREE);
588 return 0;
589 }'''
591 curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
592 foreach curses_dep : curses_dep_list
593 if not curses.found()
594 curses = dependency(curses_dep,
595 required: false,
596 method: 'pkg-config',
597 kwargs: static_kwargs)
598 endif
599 endforeach
600 msg = get_option('curses').enabled() ? 'curses library not found' : ''
601 curses_compile_args = ['-DNCURSES_WIDECHAR']
602 if curses.found()
603 if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
604 curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
605 else
606 msg = 'curses package not usable'
607 curses = not_found
608 endif
609 endif
610 if not curses.found()
611 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
612 if targetos != 'windows' and not has_curses_h
613 message('Trying with /usr/include/ncursesw')
614 curses_compile_args += ['-I/usr/include/ncursesw']
615 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
616 endif
617 if has_curses_h
618 curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
619 foreach curses_libname : curses_libname_list
620 libcurses = cc.find_library(curses_libname,
621 required: false,
622 kwargs: static_kwargs)
623 if libcurses.found()
624 if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
625 curses = declare_dependency(compile_args: curses_compile_args,
626 dependencies: [libcurses])
627 break
628 else
629 msg = 'curses library not usable'
630 endif
631 endif
632 endforeach
633 endif
634 endif
635 if not get_option('iconv').disabled()
636 foreach link_args : [ ['-liconv'], [] ]
637 # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
638 # We need to use libiconv if available because mixing libiconv's headers with
639 # the system libc does not work.
640 # However, without adding glib to the dependencies -L/usr/local/lib will not be
641 # included in the command line and libiconv will not be found.
642 if cc.links('''
643 #include <iconv.h>
644 int main(void) {
645 iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
646 return conv != (iconv_t) -1;
647 }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
648 iconv = declare_dependency(link_args: link_args, dependencies: glib)
649 break
650 endif
651 endforeach
652 endif
653 if curses.found() and not iconv.found()
654 if get_option('iconv').enabled()
655 error('iconv not available')
656 endif
657 msg = 'iconv required for curses UI but not available'
658 curses = not_found
659 endif
660 if not curses.found() and msg != ''
661 if get_option('curses').enabled()
662 error(msg)
663 else
664 warning(msg + ', disabling')
665 endif
666 endif
667 endif
669 brlapi = not_found
670 if not get_option('brlapi').auto() or have_system
671 brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
672 required: get_option('brlapi'),
673 kwargs: static_kwargs)
674 if brlapi.found() and not cc.links('''
675 #include <brlapi.h>
676 #include <stddef.h>
677 int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
678 brlapi = not_found
679 if get_option('brlapi').enabled()
680 error('could not link brlapi')
681 else
682 warning('could not link brlapi, disabling')
683 endif
684 endif
685 endif
687 sdl = not_found
688 if not get_option('sdl').auto() or (have_system and not cocoa.found())
689 sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
690 sdl_image = not_found
691 endif
692 if sdl.found()
693 # work around 2.0.8 bug
694 sdl = declare_dependency(compile_args: '-Wno-undef',
695 dependencies: sdl)
696 sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
697 method: 'pkg-config', kwargs: static_kwargs)
698 else
699 if get_option('sdl_image').enabled()
700 error('sdl-image required, but SDL was @0@'.format(
701 get_option('sdl').disabled() ? 'disabled' : 'not found'))
702 endif
703 sdl_image = not_found
704 endif
706 rbd = not_found
707 if not get_option('rbd').auto() or have_block
708 librados = cc.find_library('rados', required: get_option('rbd'),
709 kwargs: static_kwargs)
710 librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
711 required: get_option('rbd'),
712 kwargs: static_kwargs)
713 if librados.found() and librbd.found()
714 if cc.links('''
715 #include <stdio.h>
716 #include <rbd/librbd.h>
717 int main(void) {
718 rados_t cluster;
719 rados_create(&cluster, NULL);
720 #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
721 #error
722 #endif
723 return 0;
724 }''', dependencies: [librbd, librados])
725 rbd = declare_dependency(dependencies: [librbd, librados])
726 elif get_option('rbd').enabled()
727 error('librbd >= 1.12.0 required')
728 else
729 warning('librbd >= 1.12.0 not found, disabling')
730 endif
731 endif
732 endif
734 glusterfs = not_found
735 glusterfs_ftruncate_has_stat = false
736 glusterfs_iocb_has_stat = false
737 if not get_option('glusterfs').auto() or have_block
738 glusterfs = dependency('glusterfs-api', version: '>=3',
739 required: get_option('glusterfs'),
740 method: 'pkg-config', kwargs: static_kwargs)
741 if glusterfs.found()
742 glusterfs_ftruncate_has_stat = cc.links('''
743 #include <glusterfs/api/glfs.h>
745 int
746 main(void)
747 {
748 /* new glfs_ftruncate() passes two additional args */
749 return glfs_ftruncate(NULL, 0, NULL, NULL);
750 }
751 ''', dependencies: glusterfs)
752 glusterfs_iocb_has_stat = cc.links('''
753 #include <glusterfs/api/glfs.h>
755 /* new glfs_io_cbk() passes two additional glfs_stat structs */
756 static void
757 glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
758 {}
760 int
761 main(void)
762 {
763 glfs_io_cbk iocb = &glusterfs_iocb;
764 iocb(NULL, 0 , NULL, NULL, NULL);
765 return 0;
766 }
767 ''', dependencies: glusterfs)
768 endif
769 endif
770 libssh = not_found
771 if 'CONFIG_LIBSSH' in config_host
772 libssh = declare_dependency(compile_args: config_host['LIBSSH_CFLAGS'].split(),
773 link_args: config_host['LIBSSH_LIBS'].split())
774 endif
775 libbzip2 = not_found
776 if not get_option('bzip2').auto() or have_block
777 libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
778 required: get_option('bzip2'),
779 kwargs: static_kwargs)
780 if libbzip2.found() and not cc.links('''
781 #include <bzlib.h>
782 int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
783 libbzip2 = not_found
784 if get_option('bzip2').enabled()
785 error('could not link libbzip2')
786 else
787 warning('could not link libbzip2, disabling')
788 endif
789 endif
790 endif
792 liblzfse = not_found
793 if not get_option('lzfse').auto() or have_block
794 liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
795 required: get_option('lzfse'),
796 kwargs: static_kwargs)
797 endif
798 if liblzfse.found() and not cc.links('''
799 #include <lzfse.h>
800 int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
801 liblzfse = not_found
802 if get_option('lzfse').enabled()
803 error('could not link liblzfse')
804 else
805 warning('could not link liblzfse, disabling')
806 endif
807 endif
809 oss = not_found
810 if 'CONFIG_AUDIO_OSS' in config_host
811 oss = declare_dependency(link_args: config_host['OSS_LIBS'].split())
812 endif
813 dsound = not_found
814 if 'CONFIG_AUDIO_DSOUND' in config_host
815 dsound = declare_dependency(link_args: config_host['DSOUND_LIBS'].split())
816 endif
817 coreaudio = not_found
818 if 'CONFIG_AUDIO_COREAUDIO' in config_host
819 coreaudio = declare_dependency(link_args: config_host['COREAUDIO_LIBS'].split())
820 endif
822 opengl = not_found
823 if 'CONFIG_OPENGL' in config_host
824 opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
825 link_args: config_host['OPENGL_LIBS'].split())
826 endif
827 gbm = not_found
828 if (have_system or have_tools) and (virgl.found() or opengl.found())
829 gbm = dependency('gbm', method: 'pkg-config', required: false,
830 kwargs: static_kwargs)
831 endif
833 gnutls = not_found
834 gnutls_crypto = not_found
835 if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
836 # For general TLS support our min gnutls matches
837 # that implied by our platform support matrix
838 #
839 # For the crypto backends, we look for a newer
840 # gnutls:
841 #
842 # Version 3.6.8 is needed to get XTS
843 # Version 3.6.13 is needed to get PBKDF
844 # Version 3.6.14 is needed to get HW accelerated XTS
845 #
846 # If newer enough gnutls isn't available, we can
847 # still use a different crypto backend to satisfy
848 # the platform support requirements
849 gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
850 method: 'pkg-config',
851 required: false,
852 kwargs: static_kwargs)
853 if gnutls_crypto.found()
854 gnutls = gnutls_crypto
855 else
856 # Our min version if all we need is TLS
857 gnutls = dependency('gnutls', version: '>=3.5.18',
858 method: 'pkg-config',
859 required: get_option('gnutls'),
860 kwargs: static_kwargs)
861 endif
862 endif
864 # We prefer use of gnutls for crypto, unless the options
865 # explicitly asked for nettle or gcrypt.
866 #
867 # If gnutls isn't available for crypto, then we'll prefer
868 # gcrypt over nettle for performance reasons.
869 gcrypt = not_found
870 nettle = not_found
871 xts = 'none'
873 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
874 error('Only one of gcrypt & nettle can be enabled')
875 endif
877 # Explicit nettle/gcrypt request, so ignore gnutls for crypto
878 if get_option('nettle').enabled() or get_option('gcrypt').enabled()
879 gnutls_crypto = not_found
880 endif
882 if not gnutls_crypto.found()
883 if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
884 gcrypt = dependency('libgcrypt', version: '>=1.8',
885 method: 'config-tool',
886 required: get_option('gcrypt'),
887 kwargs: static_kwargs)
888 # Debian has removed -lgpg-error from libgcrypt-config
889 # as it "spreads unnecessary dependencies" which in
890 # turn breaks static builds...
891 if gcrypt.found() and enable_static
892 gcrypt = declare_dependency(dependencies: [
893 gcrypt,
894 cc.find_library('gpg-error', required: true, kwargs: static_kwargs)])
895 endif
896 endif
897 if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
898 nettle = dependency('nettle', version: '>=3.4',
899 method: 'pkg-config',
900 required: get_option('nettle'),
901 kwargs: static_kwargs)
902 if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
903 xts = 'private'
904 endif
905 endif
906 endif
908 gtk = not_found
909 gtkx11 = not_found
910 vte = not_found
911 if not get_option('gtk').auto() or (have_system and not cocoa.found())
912 gtk = dependency('gtk+-3.0', version: '>=3.22.0',
913 method: 'pkg-config',
914 required: get_option('gtk'),
915 kwargs: static_kwargs)
916 if gtk.found()
917 gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
918 method: 'pkg-config',
919 required: false,
920 kwargs: static_kwargs)
921 gtk = declare_dependency(dependencies: [gtk, gtkx11])
923 if not get_option('vte').auto() or have_system
924 vte = dependency('vte-2.91',
925 method: 'pkg-config',
926 required: get_option('vte'),
927 kwargs: static_kwargs)
928 endif
929 endif
930 endif
932 x11 = not_found
933 if gtkx11.found()
934 x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
935 kwargs: static_kwargs)
936 endif
937 vnc = not_found
938 png = not_found
939 jpeg = not_found
940 sasl = not_found
941 if have_system and not get_option('vnc').disabled()
942 vnc = declare_dependency() # dummy dependency
943 png = dependency('libpng', required: get_option('vnc_png'),
944 method: 'pkg-config', kwargs: static_kwargs)
945 jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
946 method: 'pkg-config', kwargs: static_kwargs)
947 sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
948 required: get_option('vnc_sasl'),
949 kwargs: static_kwargs)
950 if sasl.found()
951 sasl = declare_dependency(dependencies: sasl,
952 compile_args: '-DSTRUCT_IOVEC_DEFINED')
953 endif
954 endif
956 pam = not_found
957 if not get_option('auth_pam').auto() or have_system
958 pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
959 required: get_option('auth_pam'),
960 kwargs: static_kwargs)
961 endif
962 if pam.found() and not cc.links('''
963 #include <stddef.h>
964 #include <security/pam_appl.h>
965 int main(void) {
966 const char *service_name = "qemu";
967 const char *user = "frank";
968 const struct pam_conv pam_conv = { 0 };
969 pam_handle_t *pamh = NULL;
970 pam_start(service_name, user, &pam_conv, &pamh);
971 return 0;
972 }''', dependencies: pam)
973 pam = not_found
974 if get_option('auth_pam').enabled()
975 error('could not link libpam')
976 else
977 warning('could not link libpam, disabling')
978 endif
979 endif
981 snappy = not_found
982 if not get_option('snappy').auto() or have_system
983 snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
984 required: get_option('snappy'),
985 kwargs: static_kwargs)
986 endif
987 if snappy.found() and not cc.links('''
988 #include <snappy-c.h>
989 int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
990 snappy = not_found
991 if get_option('snappy').enabled()
992 error('could not link libsnappy')
993 else
994 warning('could not link libsnappy, disabling')
995 endif
996 endif
998 lzo = not_found
999 if not get_option('lzo').auto() or have_system
1000 lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1001 required: get_option('lzo'),
1002 kwargs: static_kwargs)
1003 endif
1004 if lzo.found() and not cc.links('''
1005 #include <lzo/lzo1x.h>
1006 int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1007 lzo = not_found
1008 if get_option('lzo').enabled()
1009 error('could not link liblzo2')
1010 else
1011 warning('could not link liblzo2, disabling')
1012 endif
1013 endif
1015 rdma = not_found
1016 if 'CONFIG_RDMA' in config_host
1017 rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
1018 endif
1019 numa = not_found
1020 if 'CONFIG_NUMA' in config_host
1021 numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
1022 endif
1023 xen = not_found
1024 if 'CONFIG_XEN_BACKEND' in config_host
1025 xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
1026 link_args: config_host['XEN_LIBS'].split())
1027 endif
1028 cacard = not_found
1029 if not get_option('smartcard').auto() or have_system
1030 cacard = dependency('libcacard', required: get_option('smartcard'),
1031 version: '>=2.5.1', method: 'pkg-config',
1032 kwargs: static_kwargs)
1033 endif
1034 u2f = not_found
1035 if have_system
1036 u2f = dependency('u2f-emu', required: get_option('u2f'),
1037 method: 'pkg-config',
1038 kwargs: static_kwargs)
1039 endif
1040 usbredir = not_found
1041 if not get_option('usb_redir').auto() or have_system
1042 usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1043 version: '>=0.6', method: 'pkg-config',
1044 kwargs: static_kwargs)
1045 endif
1046 libusb = not_found
1047 if not get_option('libusb').auto() or have_system
1048 libusb = dependency('libusb-1.0', required: get_option('libusb'),
1049 version: '>=1.0.13', method: 'pkg-config',
1050 kwargs: static_kwargs)
1051 endif
1053 libpmem = not_found
1054 if not get_option('libpmem').auto() or have_system
1055 libpmem = dependency('libpmem', required: get_option('libpmem'),
1056 method: 'pkg-config', kwargs: static_kwargs)
1057 endif
1058 libdaxctl = not_found
1059 if not get_option('libdaxctl').auto() or have_system
1060 libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1061 version: '>=57', method: 'pkg-config',
1062 kwargs: static_kwargs)
1063 endif
1064 tasn1 = not_found
1065 if gnutls.found()
1066 tasn1 = dependency('libtasn1',
1067 method: 'pkg-config',
1068 kwargs: static_kwargs)
1069 endif
1070 keyutils = dependency('libkeyutils', required: false,
1071 method: 'pkg-config', kwargs: static_kwargs)
1073 has_gettid = cc.has_function('gettid')
1075 # Malloc tests
1077 malloc = []
1078 if get_option('malloc') == 'system'
1079 has_malloc_trim = \
1080 not get_option('malloc_trim').disabled() and \
1081 cc.links('''#include <malloc.h>
1082 int main(void) { malloc_trim(0); return 0; }''')
1083 else
1084 has_malloc_trim = false
1085 malloc = cc.find_library(get_option('malloc'), required: true)
1086 endif
1087 if not has_malloc_trim and get_option('malloc_trim').enabled()
1088 if get_option('malloc') == 'system'
1089 error('malloc_trim not available on this platform.')
1090 else
1091 error('malloc_trim not available with non-libc memory allocator')
1092 endif
1093 endif
1095 # Check whether the glibc provides statx()
1097 gnu_source_prefix = '''
1098 #ifndef _GNU_SOURCE
1099 #define _GNU_SOURCE
1100 #endif
1101 '''
1102 statx_test = gnu_source_prefix + '''
1103 #include <sys/stat.h>
1104 int main(void) {
1105 struct statx statxbuf;
1106 statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
1107 return 0;
1108 }'''
1110 has_statx = cc.links(statx_test)
1112 have_vhost_user_blk_server = (targetos == 'linux' and
1113 'CONFIG_VHOST_USER' in config_host)
1115 if get_option('vhost_user_blk_server').enabled()
1116 if targetos != 'linux'
1117 error('vhost_user_blk_server requires linux')
1118 elif 'CONFIG_VHOST_USER' not in config_host
1119 error('vhost_user_blk_server requires vhost-user support')
1120 endif
1121 elif get_option('vhost_user_blk_server').disabled() or not have_system
1122 have_vhost_user_blk_server = false
1123 endif
1126 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1127 error('Cannot enable fuse-lseek while fuse is disabled')
1128 endif
1130 fuse = dependency('fuse3', required: get_option('fuse'),
1131 version: '>=3.1', method: 'pkg-config',
1132 kwargs: static_kwargs)
1134 fuse_lseek = not_found
1135 if not get_option('fuse_lseek').disabled()
1136 if fuse.version().version_compare('>=3.8')
1137 # Dummy dependency
1138 fuse_lseek = declare_dependency()
1139 elif get_option('fuse_lseek').enabled()
1140 if fuse.found()
1141 error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1142 else
1143 error('fuse-lseek requires libfuse, which was not found')
1144 endif
1145 endif
1146 endif
1148 # libbpf
1149 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1150 if libbpf.found() and not cc.links('''
1151 #include <bpf/libbpf.h>
1152 int main(void)
1153 {
1154 bpf_object__destroy_skeleton(NULL);
1155 return 0;
1156 }''', dependencies: libbpf)
1157 libbpf = not_found
1158 if get_option('bpf').enabled()
1159 error('libbpf skeleton test failed')
1160 else
1161 warning('libbpf skeleton test failed, disabling')
1162 endif
1163 endif
1165 if get_option('cfi')
1166 cfi_flags=[]
1167 # Check for dependency on LTO
1168 if not get_option('b_lto')
1169 error('Selected Control-Flow Integrity but LTO is disabled')
1170 endif
1171 if config_host.has_key('CONFIG_MODULES')
1172 error('Selected Control-Flow Integrity is not compatible with modules')
1173 endif
1174 # Check for cfi flags. CFI requires LTO so we can't use
1175 # get_supported_arguments, but need a more complex "compiles" which allows
1176 # custom arguments
1177 if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1178 args: ['-flto', '-fsanitize=cfi-icall'] )
1179 cfi_flags += '-fsanitize=cfi-icall'
1180 else
1181 error('-fsanitize=cfi-icall is not supported by the compiler')
1182 endif
1183 if cc.compiles('int main () { return 0; }',
1184 name: '-fsanitize-cfi-icall-generalize-pointers',
1185 args: ['-flto', '-fsanitize=cfi-icall',
1186 '-fsanitize-cfi-icall-generalize-pointers'] )
1187 cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1188 else
1189 error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1190 endif
1191 if get_option('cfi_debug')
1192 if cc.compiles('int main () { return 0; }',
1193 name: '-fno-sanitize-trap=cfi-icall',
1194 args: ['-flto', '-fsanitize=cfi-icall',
1195 '-fno-sanitize-trap=cfi-icall'] )
1196 cfi_flags += '-fno-sanitize-trap=cfi-icall'
1197 else
1198 error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1199 endif
1200 endif
1201 add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1202 add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1203 endif
1205 have_host_block_device = (targetos != 'darwin' or
1206 cc.has_header('IOKit/storage/IOMedia.h'))
1208 #################
1209 # config-host.h #
1210 #################
1212 have_virtfs = (targetos == 'linux' and
1213 have_system and
1214 libattr.found() and
1215 libcap_ng.found())
1217 have_virtfs_proxy_helper = have_virtfs and have_tools
1219 if get_option('virtfs').enabled()
1220 if not have_virtfs
1221 if targetos != 'linux'
1222 error('virtio-9p (virtfs) requires Linux')
1223 elif not libcap_ng.found() or not libattr.found()
1224 error('virtio-9p (virtfs) requires libcap-ng-devel and libattr-devel')
1225 elif not have_system
1226 error('virtio-9p (virtfs) needs system emulation support')
1227 endif
1228 endif
1229 elif get_option('virtfs').disabled()
1230 have_virtfs = false
1231 endif
1233 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1234 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1235 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1236 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1237 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1238 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
1239 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1240 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1241 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1242 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1243 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1244 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1246 config_host_data.set('CONFIG_ATTR', libattr.found())
1247 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1248 config_host_data.set('CONFIG_COCOA', cocoa.found())
1249 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1250 config_host_data.set('CONFIG_LZO', lzo.found())
1251 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1252 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1253 config_host_data.set('CONFIG_CURL', curl.found())
1254 config_host_data.set('CONFIG_CURSES', curses.found())
1255 config_host_data.set('CONFIG_GBM', gbm.found())
1256 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1257 if glusterfs.found()
1258 config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1259 config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1260 config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1261 config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1262 config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1263 config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1264 endif
1265 config_host_data.set('CONFIG_GTK', gtk.found())
1266 config_host_data.set('CONFIG_VTE', vte.found())
1267 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1268 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1269 config_host_data.set('CONFIG_EBPF', libbpf.found())
1270 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
1271 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1272 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1273 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
1274 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
1275 config_host_data.set('CONFIG_RBD', rbd.found())
1276 config_host_data.set('CONFIG_SDL', sdl.found())
1277 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1278 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1279 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1280 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
1281 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1282 config_host_data.set('CONFIG_VNC', vnc.found())
1283 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1284 config_host_data.set('CONFIG_VNC_PNG', png.found())
1285 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1286 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1287 config_host_data.set('CONFIG_VTE', vte.found())
1288 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1289 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1290 config_host_data.set('CONFIG_GETTID', has_gettid)
1291 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
1292 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
1293 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
1294 config_host_data.set('CONFIG_NETTLE', nettle.found())
1295 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
1296 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1297 config_host_data.set('CONFIG_STATX', has_statx)
1298 config_host_data.set('CONFIG_ZSTD', zstd.found())
1299 config_host_data.set('CONFIG_FUSE', fuse.found())
1300 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1301 config_host_data.set('CONFIG_X11', x11.found())
1302 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1303 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1304 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1305 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1306 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1308 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
1310 # has_header
1311 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1312 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1313 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1314 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1315 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1316 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1317 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1318 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1319 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1321 # has_function
1322 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1323 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1324 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1325 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1326 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1327 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign'))
1328 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
1329 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1330 config_host_data.set('CONFIG_SEM_TIMEDWAIT', cc.has_function('sem_timedwait', dependencies: threads))
1331 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
1332 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
1333 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
1334 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
1335 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
1336 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
1337 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
1338 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
1339 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1341 # has_header_symbol
1342 config_host_data.set('CONFIG_BYTESWAP_H',
1343 cc.has_header_symbol('byteswap.h', 'bswap_32'))
1344 config_host_data.set('CONFIG_EPOLL_CREATE1',
1345 cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
1346 config_host_data.set('CONFIG_HAS_ENVIRON',
1347 cc.has_header_symbol('unistd.h', 'environ', prefix: gnu_source_prefix))
1348 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
1349 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
1350 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
1351 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
1352 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
1353 config_host_data.set('CONFIG_FIEMAP',
1354 cc.has_header('linux/fiemap.h') and
1355 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
1356 config_host_data.set('CONFIG_GETRANDOM',
1357 cc.has_function('getrandom') and
1358 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
1359 config_host_data.set('CONFIG_INOTIFY',
1360 cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
1361 config_host_data.set('CONFIG_INOTIFY1',
1362 cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
1363 config_host_data.set('CONFIG_MACHINE_BSWAP_H',
1364 cc.has_header_symbol('machine/bswap.h', 'bswap32',
1365 prefix: '''#include <sys/endian.h>
1366 #include <sys/types.h>'''))
1367 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
1368 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
1369 config_host_data.set('CONFIG_RTNETLINK',
1370 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
1371 config_host_data.set('CONFIG_SYSMACROS',
1372 cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1373 config_host_data.set('HAVE_OPTRESET',
1374 cc.has_header_symbol('getopt.h', 'optreset'))
1375 config_host_data.set('HAVE_UTMPX',
1376 cc.has_header_symbol('utmpx.h', 'struct utmpx'))
1378 # has_member
1379 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
1380 cc.has_member('struct sigevent', 'sigev_notify_thread_id',
1381 prefix: '#include <signal.h>'))
1382 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
1383 cc.has_member('struct stat', 'st_atim',
1384 prefix: '#include <sys/stat.h>'))
1386 config_host_data.set('CONFIG_EVENTFD', cc.links('''
1387 #include <sys/eventfd.h>
1388 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
1389 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
1390 #include <unistd.h>
1391 int main(void) {
1392 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
1393 return fdatasync(0);
1394 #else
1395 #error Not supported
1396 #endif
1397 }'''))
1398 config_host_data.set('CONFIG_MADVISE', cc.links(gnu_source_prefix + '''
1399 #include <sys/types.h>
1400 #include <sys/mman.h>
1401 #include <stddef.h>
1402 int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }'''))
1403 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
1404 #include <sys/mman.h>
1405 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
1406 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
1407 #include <fcntl.h>
1408 #if !defined(AT_EMPTY_PATH)
1409 # error missing definition
1410 #else
1411 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
1412 #endif'''))
1413 config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
1414 #include <unistd.h>
1415 #include <fcntl.h>
1417 int main(void)
1418 {
1419 int pipefd[2];
1420 return pipe2(pipefd, O_CLOEXEC);
1421 }'''))
1422 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
1423 #include <sys/mman.h>
1424 #include <stddef.h>
1425 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
1426 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
1427 #include <unistd.h>
1428 #include <sys/syscall.h>
1429 #include <signal.h>
1430 int main(void) { return syscall(SYS_signalfd, -1, NULL, _NSIG / 8); }'''))
1431 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
1432 #include <unistd.h>
1433 #include <fcntl.h>
1434 #include <limits.h>
1436 int main(void)
1437 {
1438 int len, fd = 0;
1439 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
1440 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
1441 return 0;
1442 }'''))
1444 # Some versions of Mac OS X incorrectly define SIZE_MAX
1445 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
1446 #include <stdint.h>
1447 #include <stdio.h>
1448 int main(int argc, char *argv[]) {
1449 return printf("%zu", SIZE_MAX);
1450 }''', args: ['-Werror']))
1453 ignored = ['CONFIG_QEMU_INTERP_PREFIX'] # actually per-target
1454 arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1455 strings = ['HOST_DSOSUF', 'CONFIG_IASL']
1456 foreach k, v: config_host
1457 if ignored.contains(k)
1458 # do nothing
1459 elif arrays.contains(k)
1460 if v != ''
1461 v = '"' + '", "'.join(v.split()) + '", '
1462 endif
1463 config_host_data.set(k, v)
1464 elif k == 'ARCH'
1465 config_host_data.set('HOST_' + v.to_upper(), 1)
1466 elif strings.contains(k)
1467 if not k.startswith('CONFIG_')
1468 k = 'CONFIG_' + k.to_upper()
1469 endif
1470 config_host_data.set_quoted(k, v)
1471 elif k.startswith('CONFIG_') or k.startswith('HAVE_') or k.startswith('HOST_')
1472 config_host_data.set(k, v == 'y' ? 1 : v)
1473 endif
1474 endforeach
1476 ########################
1477 # Target configuration #
1478 ########################
1480 minikconf = find_program('scripts/minikconf.py')
1481 config_all = {}
1482 config_all_devices = {}
1483 config_all_disas = {}
1484 config_devices_mak_list = []
1485 config_devices_h = {}
1486 config_target_h = {}
1487 config_target_mak = {}
1489 disassemblers = {
1490 'alpha' : ['CONFIG_ALPHA_DIS'],
1491 'arm' : ['CONFIG_ARM_DIS'],
1492 'avr' : ['CONFIG_AVR_DIS'],
1493 'cris' : ['CONFIG_CRIS_DIS'],
1494 'hexagon' : ['CONFIG_HEXAGON_DIS'],
1495 'hppa' : ['CONFIG_HPPA_DIS'],
1496 'i386' : ['CONFIG_I386_DIS'],
1497 'x86_64' : ['CONFIG_I386_DIS'],
1498 'x32' : ['CONFIG_I386_DIS'],
1499 'm68k' : ['CONFIG_M68K_DIS'],
1500 'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
1501 'mips' : ['CONFIG_MIPS_DIS'],
1502 'nios2' : ['CONFIG_NIOS2_DIS'],
1503 'or1k' : ['CONFIG_OPENRISC_DIS'],
1504 'ppc' : ['CONFIG_PPC_DIS'],
1505 'riscv' : ['CONFIG_RISCV_DIS'],
1506 'rx' : ['CONFIG_RX_DIS'],
1507 's390' : ['CONFIG_S390_DIS'],
1508 'sh4' : ['CONFIG_SH4_DIS'],
1509 'sparc' : ['CONFIG_SPARC_DIS'],
1510 'xtensa' : ['CONFIG_XTENSA_DIS'],
1511 }
1512 if link_language == 'cpp'
1513 disassemblers += {
1514 'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
1515 'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
1516 'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
1517 }
1518 endif
1520 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
1521 host_kconfig = \
1522 ('CONFIG_TPM' in config_host ? ['CONFIG_TPM=y'] : []) + \
1523 ('CONFIG_SPICE' in config_host ? ['CONFIG_SPICE=y'] : []) + \
1524 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
1525 ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
1526 (x11.found() ? ['CONFIG_X11=y'] : []) + \
1527 ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
1528 ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
1529 ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
1530 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
1531 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
1532 ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
1533 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
1535 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
1537 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
1538 actual_target_dirs = []
1539 fdt_required = []
1540 foreach target : target_dirs
1541 config_target = { 'TARGET_NAME': target.split('-')[0] }
1542 if target.endswith('linux-user')
1543 if targetos != 'linux'
1544 if default_targets
1545 continue
1546 endif
1547 error('Target @0@ is only available on a Linux host'.format(target))
1548 endif
1549 config_target += { 'CONFIG_LINUX_USER': 'y' }
1550 elif target.endswith('bsd-user')
1551 if 'CONFIG_BSD' not in config_host
1552 if default_targets
1553 continue
1554 endif
1555 error('Target @0@ is only available on a BSD host'.format(target))
1556 endif
1557 config_target += { 'CONFIG_BSD_USER': 'y' }
1558 elif target.endswith('softmmu')
1559 config_target += { 'CONFIG_SOFTMMU': 'y' }
1560 endif
1561 if target.endswith('-user')
1562 config_target += {
1563 'CONFIG_USER_ONLY': 'y',
1564 'CONFIG_QEMU_INTERP_PREFIX':
1565 config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
1566 }
1567 endif
1569 accel_kconfig = []
1570 foreach sym: accelerators
1571 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
1572 config_target += { sym: 'y' }
1573 config_all += { sym: 'y' }
1574 if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
1575 config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
1576 elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
1577 config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
1578 endif
1579 if target in modular_tcg
1580 config_target += { 'CONFIG_TCG_MODULAR': 'y' }
1581 else
1582 config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
1583 endif
1584 accel_kconfig += [ sym + '=y' ]
1585 endif
1586 endforeach
1587 if accel_kconfig.length() == 0
1588 if default_targets
1589 continue
1590 endif
1591 error('No accelerator available for target @0@'.format(target))
1592 endif
1594 actual_target_dirs += target
1595 config_target += keyval.load('configs/targets' / target + '.mak')
1596 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
1598 if 'TARGET_NEED_FDT' in config_target
1599 fdt_required += target
1600 endif
1602 # Add default keys
1603 if 'TARGET_BASE_ARCH' not in config_target
1604 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
1605 endif
1606 if 'TARGET_ABI_DIR' not in config_target
1607 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
1608 endif
1610 foreach k, v: disassemblers
1611 if config_host['ARCH'].startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
1612 foreach sym: v
1613 config_target += { sym: 'y' }
1614 config_all_disas += { sym: 'y' }
1615 endforeach
1616 endif
1617 endforeach
1619 config_target_data = configuration_data()
1620 foreach k, v: config_target
1621 if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
1622 # do nothing
1623 elif ignored.contains(k)
1624 # do nothing
1625 elif k == 'TARGET_BASE_ARCH'
1626 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
1627 # not used to select files from sourcesets.
1628 config_target_data.set('TARGET_' + v.to_upper(), 1)
1629 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
1630 config_target_data.set_quoted(k, v)
1631 elif v == 'y'
1632 config_target_data.set(k, 1)
1633 else
1634 config_target_data.set(k, v)
1635 endif
1636 endforeach
1637 config_target_data.set('QEMU_ARCH',
1638 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
1639 config_target_h += {target: configure_file(output: target + '-config-target.h',
1640 configuration: config_target_data)}
1642 if target.endswith('-softmmu')
1643 config_input = meson.get_external_property(target, 'default')
1644 config_devices_mak = target + '-config-devices.mak'
1645 config_devices_mak = configure_file(
1646 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
1647 output: config_devices_mak,
1648 depfile: config_devices_mak + '.d',
1649 capture: true,
1650 command: [minikconf,
1651 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
1652 config_devices_mak, '@DEPFILE@', '@INPUT@',
1653 host_kconfig, accel_kconfig,
1654 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
1656 config_devices_data = configuration_data()
1657 config_devices = keyval.load(config_devices_mak)
1658 foreach k, v: config_devices
1659 config_devices_data.set(k, 1)
1660 endforeach
1661 config_devices_mak_list += config_devices_mak
1662 config_devices_h += {target: configure_file(output: target + '-config-devices.h',
1663 configuration: config_devices_data)}
1664 config_target += config_devices
1665 config_all_devices += config_devices
1666 endif
1667 config_target_mak += {target: config_target}
1668 endforeach
1669 target_dirs = actual_target_dirs
1671 # This configuration is used to build files that are shared by
1672 # multiple binaries, and then extracted out of the "common"
1673 # static_library target.
1674 #
1675 # We do not use all_sources()/all_dependencies(), because it would
1676 # build literally all source files, including devices only used by
1677 # targets that are not built for this compilation. The CONFIG_ALL
1678 # pseudo symbol replaces it.
1680 config_all += config_all_devices
1681 config_all += config_host
1682 config_all += config_all_disas
1683 config_all += {
1684 'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
1685 'CONFIG_SOFTMMU': have_system,
1686 'CONFIG_USER_ONLY': have_user,
1687 'CONFIG_ALL': true,
1688 }
1690 ##############
1691 # Submodules #
1692 ##############
1694 capstone = not_found
1695 capstone_opt = get_option('capstone')
1696 if capstone_opt in ['enabled', 'auto', 'system']
1697 have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
1698 capstone = dependency('capstone', version: '>=4.0',
1699 kwargs: static_kwargs, method: 'pkg-config',
1700 required: capstone_opt == 'system' or
1701 capstone_opt == 'enabled' and not have_internal)
1703 # Some versions of capstone have broken pkg-config file
1704 # that reports a wrong -I path, causing the #include to
1705 # fail later. If the system has such a broken version
1706 # do not use it.
1707 if capstone.found() and not cc.compiles('#include <capstone.h>',
1708 dependencies: [capstone])
1709 capstone = not_found
1710 if capstone_opt == 'system'
1711 error('system capstone requested, it does not appear to work')
1712 endif
1713 endif
1715 if capstone.found()
1716 capstone_opt = 'system'
1717 elif have_internal
1718 capstone_opt = 'internal'
1719 else
1720 capstone_opt = 'disabled'
1721 endif
1722 endif
1723 if capstone_opt == 'internal'
1724 capstone_data = configuration_data()
1725 capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
1727 capstone_files = files(
1728 'capstone/cs.c',
1729 'capstone/MCInst.c',
1730 'capstone/MCInstrDesc.c',
1731 'capstone/MCRegisterInfo.c',
1732 'capstone/SStream.c',
1733 'capstone/utils.c'
1734 )
1736 if 'CONFIG_ARM_DIS' in config_all_disas
1737 capstone_data.set('CAPSTONE_HAS_ARM', '1')
1738 capstone_files += files(
1739 'capstone/arch/ARM/ARMDisassembler.c',
1740 'capstone/arch/ARM/ARMInstPrinter.c',
1741 'capstone/arch/ARM/ARMMapping.c',
1742 'capstone/arch/ARM/ARMModule.c'
1743 )
1744 endif
1746 # FIXME: This config entry currently depends on a c++ compiler.
1747 # Which is needed for building libvixl, but not for capstone.
1748 if 'CONFIG_ARM_A64_DIS' in config_all_disas
1749 capstone_data.set('CAPSTONE_HAS_ARM64', '1')
1750 capstone_files += files(
1751 'capstone/arch/AArch64/AArch64BaseInfo.c',
1752 'capstone/arch/AArch64/AArch64Disassembler.c',
1753 'capstone/arch/AArch64/AArch64InstPrinter.c',
1754 'capstone/arch/AArch64/AArch64Mapping.c',
1755 'capstone/arch/AArch64/AArch64Module.c'
1756 )
1757 endif
1759 if 'CONFIG_PPC_DIS' in config_all_disas
1760 capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
1761 capstone_files += files(
1762 'capstone/arch/PowerPC/PPCDisassembler.c',
1763 'capstone/arch/PowerPC/PPCInstPrinter.c',
1764 'capstone/arch/PowerPC/PPCMapping.c',
1765 'capstone/arch/PowerPC/PPCModule.c'
1766 )
1767 endif
1769 if 'CONFIG_S390_DIS' in config_all_disas
1770 capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
1771 capstone_files += files(
1772 'capstone/arch/SystemZ/SystemZDisassembler.c',
1773 'capstone/arch/SystemZ/SystemZInstPrinter.c',
1774 'capstone/arch/SystemZ/SystemZMapping.c',
1775 'capstone/arch/SystemZ/SystemZModule.c',
1776 'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
1777 )
1778 endif
1780 if 'CONFIG_I386_DIS' in config_all_disas
1781 capstone_data.set('CAPSTONE_HAS_X86', 1)
1782 capstone_files += files(
1783 'capstone/arch/X86/X86Disassembler.c',
1784 'capstone/arch/X86/X86DisassemblerDecoder.c',
1785 'capstone/arch/X86/X86ATTInstPrinter.c',
1786 'capstone/arch/X86/X86IntelInstPrinter.c',
1787 'capstone/arch/X86/X86InstPrinterCommon.c',
1788 'capstone/arch/X86/X86Mapping.c',
1789 'capstone/arch/X86/X86Module.c'
1790 )
1791 endif
1793 configure_file(output: 'capstone-defs.h', configuration: capstone_data)
1795 capstone_cargs = [
1796 # FIXME: There does not seem to be a way to completely replace the c_args
1797 # that come from add_project_arguments() -- we can only add to them.
1798 # So: disable all warnings with a big hammer.
1799 '-Wno-error', '-w',
1801 # Include all configuration defines via a header file, which will wind up
1802 # as a dependency on the object file, and thus changes here will result
1803 # in a rebuild.
1804 '-include', 'capstone-defs.h'
1805 ]
1807 libcapstone = static_library('capstone',
1808 build_by_default: false,
1809 sources: capstone_files,
1810 c_args: capstone_cargs,
1811 include_directories: 'capstone/include')
1812 capstone = declare_dependency(link_with: libcapstone,
1813 include_directories: 'capstone/include/capstone')
1814 endif
1816 slirp = not_found
1817 slirp_opt = 'disabled'
1818 if have_system
1819 slirp_opt = get_option('slirp')
1820 if slirp_opt in ['enabled', 'auto', 'system']
1821 have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
1822 slirp = dependency('slirp', kwargs: static_kwargs,
1823 method: 'pkg-config',
1824 required: slirp_opt == 'system' or
1825 slirp_opt == 'enabled' and not have_internal)
1826 if slirp.found()
1827 slirp_opt = 'system'
1828 elif have_internal
1829 slirp_opt = 'internal'
1830 else
1831 slirp_opt = 'disabled'
1832 endif
1833 endif
1834 if slirp_opt == 'internal'
1835 slirp_deps = []
1836 if targetos == 'windows'
1837 slirp_deps = cc.find_library('iphlpapi')
1838 elif targetos == 'darwin'
1839 slirp_deps = cc.find_library('resolv')
1840 endif
1841 slirp_conf = configuration_data()
1842 slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
1843 slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
1844 slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
1845 slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
1846 slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
1847 slirp_files = [
1848 'slirp/src/arp_table.c',
1849 'slirp/src/bootp.c',
1850 'slirp/src/cksum.c',
1851 'slirp/src/dhcpv6.c',
1852 'slirp/src/dnssearch.c',
1853 'slirp/src/if.c',
1854 'slirp/src/ip6_icmp.c',
1855 'slirp/src/ip6_input.c',
1856 'slirp/src/ip6_output.c',
1857 'slirp/src/ip_icmp.c',
1858 'slirp/src/ip_input.c',
1859 'slirp/src/ip_output.c',
1860 'slirp/src/mbuf.c',
1861 'slirp/src/misc.c',
1862 'slirp/src/ncsi.c',
1863 'slirp/src/ndp_table.c',
1864 'slirp/src/sbuf.c',
1865 'slirp/src/slirp.c',
1866 'slirp/src/socket.c',
1867 'slirp/src/state.c',
1868 'slirp/src/stream.c',
1869 'slirp/src/tcp_input.c',
1870 'slirp/src/tcp_output.c',
1871 'slirp/src/tcp_subr.c',
1872 'slirp/src/tcp_timer.c',
1873 'slirp/src/tftp.c',
1874 'slirp/src/udp.c',
1875 'slirp/src/udp6.c',
1876 'slirp/src/util.c',
1877 'slirp/src/version.c',
1878 'slirp/src/vmstate.c',
1879 ]
1881 configure_file(
1882 input : 'slirp/src/libslirp-version.h.in',
1883 output : 'libslirp-version.h',
1884 configuration: slirp_conf)
1886 slirp_inc = include_directories('slirp', 'slirp/src')
1887 libslirp = static_library('slirp',
1888 build_by_default: false,
1889 sources: slirp_files,
1890 c_args: slirp_cargs,
1891 include_directories: slirp_inc)
1892 slirp = declare_dependency(link_with: libslirp,
1893 dependencies: slirp_deps,
1894 include_directories: slirp_inc)
1895 endif
1896 endif
1898 # For CFI, we need to compile slirp as a static library together with qemu.
1899 # This is because we register slirp functions as callbacks for QEMU Timers.
1900 # When using a system-wide shared libslirp, the type information for the
1901 # callback is missing and the timer call produces a false positive with CFI.
1902 #
1903 # Now that slirp_opt has been defined, check if the selected slirp is compatible
1904 # with control-flow integrity.
1905 if get_option('cfi') and slirp_opt == 'system'
1906 error('Control-Flow Integrity is not compatible with system-wide slirp.' \
1907 + ' Please configure with --enable-slirp=git')
1908 endif
1910 fdt = not_found
1911 fdt_opt = get_option('fdt')
1912 if have_system
1913 if fdt_opt in ['enabled', 'auto', 'system']
1914 have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
1915 fdt = cc.find_library('fdt', kwargs: static_kwargs,
1916 required: fdt_opt == 'system' or
1917 fdt_opt == 'enabled' and not have_internal)
1918 if fdt.found() and cc.links('''
1919 #include <libfdt.h>
1920 #include <libfdt_env.h>
1921 int main(void) { fdt_check_full(NULL, 0); return 0; }''',
1922 dependencies: fdt)
1923 fdt_opt = 'system'
1924 elif fdt_opt == 'system'
1925 error('system libfdt requested, but it is too old (1.5.1 or newer required)')
1926 elif have_internal
1927 fdt_opt = 'internal'
1928 else
1929 fdt_opt = 'disabled'
1930 fdt = not_found
1931 endif
1932 endif
1933 if fdt_opt == 'internal'
1934 fdt_files = files(
1935 'dtc/libfdt/fdt.c',
1936 'dtc/libfdt/fdt_ro.c',
1937 'dtc/libfdt/fdt_wip.c',
1938 'dtc/libfdt/fdt_sw.c',
1939 'dtc/libfdt/fdt_rw.c',
1940 'dtc/libfdt/fdt_strerror.c',
1941 'dtc/libfdt/fdt_empty_tree.c',
1942 'dtc/libfdt/fdt_addresses.c',
1943 'dtc/libfdt/fdt_overlay.c',
1944 'dtc/libfdt/fdt_check.c',
1945 )
1947 fdt_inc = include_directories('dtc/libfdt')
1948 libfdt = static_library('fdt',
1949 build_by_default: false,
1950 sources: fdt_files,
1951 include_directories: fdt_inc)
1952 fdt = declare_dependency(link_with: libfdt,
1953 include_directories: fdt_inc)
1954 endif
1955 endif
1956 if not fdt.found() and fdt_required.length() > 0
1957 error('fdt not available but required by targets ' + ', '.join(fdt_required))
1958 endif
1960 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
1961 config_host_data.set('CONFIG_FDT', fdt.found())
1962 config_host_data.set('CONFIG_SLIRP', slirp.found())
1964 #####################
1965 # Generated sources #
1966 #####################
1968 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
1970 hxtool = find_program('scripts/hxtool')
1971 shaderinclude = find_program('scripts/shaderinclude.pl')
1972 qapi_gen = find_program('scripts/qapi-gen.py')
1973 qapi_gen_depends = [ meson.source_root() / 'scripts/qapi/__init__.py',
1974 meson.source_root() / 'scripts/qapi/commands.py',
1975 meson.source_root() / 'scripts/qapi/common.py',
1976 meson.source_root() / 'scripts/qapi/error.py',
1977 meson.source_root() / 'scripts/qapi/events.py',
1978 meson.source_root() / 'scripts/qapi/expr.py',
1979 meson.source_root() / 'scripts/qapi/gen.py',
1980 meson.source_root() / 'scripts/qapi/introspect.py',
1981 meson.source_root() / 'scripts/qapi/parser.py',
1982 meson.source_root() / 'scripts/qapi/schema.py',
1983 meson.source_root() / 'scripts/qapi/source.py',
1984 meson.source_root() / 'scripts/qapi/types.py',
1985 meson.source_root() / 'scripts/qapi/visit.py',
1986 meson.source_root() / 'scripts/qapi/common.py',
1987 meson.source_root() / 'scripts/qapi-gen.py'
1988 ]
1990 tracetool = [
1991 python, files('scripts/tracetool.py'),
1992 '--backend=' + config_host['TRACE_BACKENDS']
1993 ]
1994 tracetool_depends = files(
1995 'scripts/tracetool/backend/log.py',
1996 'scripts/tracetool/backend/__init__.py',
1997 'scripts/tracetool/backend/dtrace.py',
1998 'scripts/tracetool/backend/ftrace.py',
1999 'scripts/tracetool/backend/simple.py',
2000 'scripts/tracetool/backend/syslog.py',
2001 'scripts/tracetool/backend/ust.py',
2002 'scripts/tracetool/format/tcg_h.py',
2003 'scripts/tracetool/format/ust_events_c.py',
2004 'scripts/tracetool/format/ust_events_h.py',
2005 'scripts/tracetool/format/__init__.py',
2006 'scripts/tracetool/format/d.py',
2007 'scripts/tracetool/format/tcg_helper_c.py',
2008 'scripts/tracetool/format/simpletrace_stap.py',
2009 'scripts/tracetool/format/c.py',
2010 'scripts/tracetool/format/h.py',
2011 'scripts/tracetool/format/tcg_helper_h.py',
2012 'scripts/tracetool/format/log_stap.py',
2013 'scripts/tracetool/format/stap.py',
2014 'scripts/tracetool/format/tcg_helper_wrapper_h.py',
2015 'scripts/tracetool/__init__.py',
2016 'scripts/tracetool/transform.py',
2017 'scripts/tracetool/vcpu.py'
2018 )
2020 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2021 meson.current_source_dir(),
2022 config_host['PKGVERSION'], meson.project_version()]
2023 qemu_version = custom_target('qemu-version.h',
2024 output: 'qemu-version.h',
2025 command: qemu_version_cmd,
2026 capture: true,
2027 build_by_default: true,
2028 build_always_stale: true)
2029 genh += qemu_version
2031 hxdep = []
2032 hx_headers = [
2033 ['qemu-options.hx', 'qemu-options.def'],
2034 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2035 ]
2036 if have_system
2037 hx_headers += [
2038 ['hmp-commands.hx', 'hmp-commands.h'],
2039 ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2040 ]
2041 endif
2042 foreach d : hx_headers
2043 hxdep += custom_target(d[1],
2044 input: files(d[0]),
2045 output: d[1],
2046 capture: true,
2047 build_by_default: true, # to be removed when added to a target
2048 command: [hxtool, '-h', '@INPUT0@'])
2049 endforeach
2050 genh += hxdep
2052 ###################
2053 # Collect sources #
2054 ###################
2056 authz_ss = ss.source_set()
2057 blockdev_ss = ss.source_set()
2058 block_ss = ss.source_set()
2059 bsd_user_ss = ss.source_set()
2060 chardev_ss = ss.source_set()
2061 common_ss = ss.source_set()
2062 crypto_ss = ss.source_set()
2063 io_ss = ss.source_set()
2064 linux_user_ss = ss.source_set()
2065 qmp_ss = ss.source_set()
2066 qom_ss = ss.source_set()
2067 softmmu_ss = ss.source_set()
2068 specific_fuzz_ss = ss.source_set()
2069 specific_ss = ss.source_set()
2070 stub_ss = ss.source_set()
2071 trace_ss = ss.source_set()
2072 user_ss = ss.source_set()
2073 util_ss = ss.source_set()
2075 # accel modules
2076 qtest_module_ss = ss.source_set()
2077 tcg_module_ss = ss.source_set()
2079 modules = {}
2080 target_modules = {}
2081 hw_arch = {}
2082 target_arch = {}
2083 target_softmmu_arch = {}
2084 target_user_arch = {}
2086 ###############
2087 # Trace files #
2088 ###############
2090 # TODO: add each directory to the subdirs from its own meson.build, once
2091 # we have those
2092 trace_events_subdirs = [
2093 'crypto',
2094 'qapi',
2095 'qom',
2096 'monitor',
2097 'util',
2098 ]
2099 if have_user
2100 trace_events_subdirs += [ 'linux-user' ]
2101 endif
2102 if have_block
2103 trace_events_subdirs += [
2104 'authz',
2105 'block',
2106 'io',
2107 'nbd',
2108 'scsi',
2109 ]
2110 endif
2111 if have_system
2112 trace_events_subdirs += [
2113 'accel/kvm',
2114 'audio',
2115 'backends',
2116 'backends/tpm',
2117 'chardev',
2118 'ebpf',
2119 'hw/9pfs',
2120 'hw/acpi',
2121 'hw/adc',
2122 'hw/alpha',
2123 'hw/arm',
2124 'hw/audio',
2125 'hw/block',
2126 'hw/block/dataplane',
2127 'hw/char',
2128 'hw/display',
2129 'hw/dma',
2130 'hw/hppa',
2131 'hw/hyperv',
2132 'hw/i2c',
2133 'hw/i386',
2134 'hw/i386/xen',
2135 'hw/ide',
2136 'hw/input',
2137 'hw/intc',
2138 'hw/isa',
2139 'hw/mem',
2140 'hw/mips',
2141 'hw/misc',
2142 'hw/misc/macio',
2143 'hw/net',
2144 'hw/net/can',
2145 'hw/nubus',
2146 'hw/nvme',
2147 'hw/nvram',
2148 'hw/pci',
2149 'hw/pci-host',
2150 'hw/ppc',
2151 'hw/rdma',
2152 'hw/rdma/vmw',
2153 'hw/rtc',
2154 'hw/s390x',
2155 'hw/scsi',
2156 'hw/sd',
2157 'hw/sparc',
2158 'hw/sparc64',
2159 'hw/ssi',
2160 'hw/timer',
2161 'hw/tpm',
2162 'hw/usb',
2163 'hw/vfio',
2164 'hw/virtio',
2165 'hw/watchdog',
2166 'hw/xen',
2167 'hw/gpio',
2168 'migration',
2169 'net',
2170 'softmmu',
2171 'ui',
2172 'hw/remote',
2173 ]
2174 endif
2175 if have_system or have_user
2176 trace_events_subdirs += [
2177 'accel/tcg',
2178 'hw/core',
2179 'target/arm',
2180 'target/arm/hvf',
2181 'target/hppa',
2182 'target/i386',
2183 'target/i386/kvm',
2184 'target/mips/tcg',
2185 'target/ppc',
2186 'target/riscv',
2187 'target/s390x',
2188 'target/s390x/kvm',
2189 'target/sparc',
2190 ]
2191 endif
2193 vhost_user = not_found
2194 if 'CONFIG_VHOST_USER' in config_host
2195 libvhost_user = subproject('libvhost-user')
2196 vhost_user = libvhost_user.get_variable('vhost_user_dep')
2197 endif
2199 subdir('qapi')
2200 subdir('qobject')
2201 subdir('stubs')
2202 subdir('trace')
2203 subdir('util')
2204 subdir('qom')
2205 subdir('authz')
2206 subdir('crypto')
2207 subdir('ui')
2210 if enable_modules
2211 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2212 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2213 endif
2215 stub_ss = stub_ss.apply(config_all, strict: false)
2217 util_ss.add_all(trace_ss)
2218 util_ss = util_ss.apply(config_all, strict: false)
2219 libqemuutil = static_library('qemuutil',
2220 sources: util_ss.sources() + stub_ss.sources() + genh,
2221 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2222 qemuutil = declare_dependency(link_with: libqemuutil,
2223 sources: genh + version_res)
2225 if have_system or have_user
2226 decodetree = generator(find_program('scripts/decodetree.py'),
2227 output: 'decode-@BASENAME@.c.inc',
2228 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2229 subdir('libdecnumber')
2230 subdir('target')
2231 endif
2233 subdir('audio')
2234 subdir('io')
2235 subdir('chardev')
2236 subdir('fsdev')
2237 subdir('dump')
2239 if have_block
2240 block_ss.add(files(
2241 'block.c',
2242 'blockjob.c',
2243 'job.c',
2244 'qemu-io-cmds.c',
2245 ))
2246 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
2248 subdir('nbd')
2249 subdir('scsi')
2250 subdir('block')
2252 blockdev_ss.add(files(
2253 'blockdev.c',
2254 'blockdev-nbd.c',
2255 'iothread.c',
2256 'job-qmp.c',
2257 ), gnutls)
2259 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2260 # os-win32.c does not
2261 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2262 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2263 endif
2265 common_ss.add(files('cpus-common.c'))
2267 subdir('softmmu')
2269 common_ss.add(capstone)
2270 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2272 # Work around a gcc bug/misfeature wherein constant propagation looks
2273 # through an alias:
2274 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2275 # to guess that a const variable is always zero. Without lto, this is
2276 # impossible, as the alias is restricted to page-vary-common.c. Indeed,
2277 # without lto, not even the alias is required -- we simply use different
2278 # declarations in different compilation units.
2279 pagevary = files('page-vary-common.c')
2280 if get_option('b_lto')
2281 pagevary_flags = ['-fno-lto']
2282 if get_option('cfi')
2283 pagevary_flags += '-fno-sanitize=cfi-icall'
2284 endif
2285 pagevary = static_library('page-vary-common', sources: pagevary,
2286 c_args: pagevary_flags)
2287 pagevary = declare_dependency(link_with: pagevary)
2288 endif
2289 common_ss.add(pagevary)
2290 specific_ss.add(files('page-vary.c'))
2292 subdir('backends')
2293 subdir('disas')
2294 subdir('migration')
2295 subdir('monitor')
2296 subdir('net')
2297 subdir('replay')
2298 subdir('semihosting')
2299 subdir('hw')
2300 subdir('tcg')
2301 subdir('fpu')
2302 subdir('accel')
2303 subdir('plugins')
2304 subdir('bsd-user')
2305 subdir('linux-user')
2306 subdir('ebpf')
2308 common_ss.add(libbpf)
2310 bsd_user_ss.add(files('gdbstub.c'))
2311 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
2313 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
2314 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
2316 # needed for fuzzing binaries
2317 subdir('tests/qtest/libqos')
2318 subdir('tests/qtest/fuzz')
2320 # accel modules
2321 tcg_real_module_ss = ss.source_set()
2322 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2323 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2324 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2325 'tcg': tcg_real_module_ss }}
2327 ########################
2328 # Library dependencies #
2329 ########################
2331 modinfo_collect = find_program('scripts/modinfo-collect.py')
2332 modinfo_generate = find_program('scripts/modinfo-generate.py')
2333 modinfo_files = []
2335 block_mods = []
2336 softmmu_mods = []
2337 foreach d, list : modules
2338 foreach m, module_ss : list
2339 if enable_modules and targetos != 'windows'
2340 module_ss = module_ss.apply(config_all, strict: false)
2341 sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2342 dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2343 if d == 'block'
2344 block_mods += sl
2345 else
2346 softmmu_mods += sl
2347 endif
2348 if module_ss.sources() != []
2349 # FIXME: Should use sl.extract_all_objects(recursive: true) as
2350 # input. Sources can be used multiple times but objects are
2351 # unique when it comes to lookup in compile_commands.json.
2352 # Depnds on a mesion version with
2353 # https://github.com/mesonbuild/meson/pull/8900
2354 modinfo_files += custom_target(d + '-' + m + '.modinfo',
2355 output: d + '-' + m + '.modinfo',
2356 input: module_ss.sources() + genh,
2357 capture: true,
2358 command: [modinfo_collect, module_ss.sources()])
2359 endif
2360 else
2361 if d == 'block'
2362 block_ss.add_all(module_ss)
2363 else
2364 softmmu_ss.add_all(module_ss)
2365 endif
2366 endif
2367 endforeach
2368 endforeach
2370 foreach d, list : target_modules
2371 foreach m, module_ss : list
2372 if enable_modules and targetos != 'windows'
2373 foreach target : target_dirs
2374 if target.endswith('-softmmu')
2375 config_target = config_target_mak[target]
2376 config_target += config_host
2377 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2378 c_args = ['-DNEED_CPU_H',
2379 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2380 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2381 target_module_ss = module_ss.apply(config_target, strict: false)
2382 if target_module_ss.sources() != []
2383 module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2384 sl = static_library(module_name,
2385 [genh, target_module_ss.sources()],
2386 dependencies: [modulecommon, target_module_ss.dependencies()],
2387 include_directories: target_inc,
2388 c_args: c_args,
2389 pic: true)
2390 softmmu_mods += sl
2391 # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2392 modinfo_files += custom_target(module_name + '.modinfo',
2393 output: module_name + '.modinfo',
2394 input: target_module_ss.sources() + genh,
2395 capture: true,
2396 command: [modinfo_collect, '--target', target, target_module_ss.sources()])
2397 endif
2398 endif
2399 endforeach
2400 else
2401 specific_ss.add_all(module_ss)
2402 endif
2403 endforeach
2404 endforeach
2406 if enable_modules
2407 modinfo_src = custom_target('modinfo.c',
2408 output: 'modinfo.c',
2409 input: modinfo_files,
2410 command: [modinfo_generate, '@INPUT@'],
2411 capture: true)
2412 modinfo_lib = static_library('modinfo', modinfo_src)
2413 modinfo_dep = declare_dependency(link_whole: modinfo_lib)
2414 softmmu_ss.add(modinfo_dep)
2415 endif
2417 nm = find_program('nm')
2418 undefsym = find_program('scripts/undefsym.py')
2419 block_syms = custom_target('block.syms', output: 'block.syms',
2420 input: [libqemuutil, block_mods],
2421 capture: true,
2422 command: [undefsym, nm, '@INPUT@'])
2423 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
2424 input: [libqemuutil, softmmu_mods],
2425 capture: true,
2426 command: [undefsym, nm, '@INPUT@'])
2428 qom_ss = qom_ss.apply(config_host, strict: false)
2429 libqom = static_library('qom', qom_ss.sources() + genh,
2430 dependencies: [qom_ss.dependencies()],
2431 name_suffix: 'fa')
2433 qom = declare_dependency(link_whole: libqom)
2435 authz_ss = authz_ss.apply(config_host, strict: false)
2436 libauthz = static_library('authz', authz_ss.sources() + genh,
2437 dependencies: [authz_ss.dependencies()],
2438 name_suffix: 'fa',
2439 build_by_default: false)
2441 authz = declare_dependency(link_whole: libauthz,
2442 dependencies: qom)
2444 crypto_ss = crypto_ss.apply(config_host, strict: false)
2445 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2446 dependencies: [crypto_ss.dependencies()],
2447 name_suffix: 'fa',
2448 build_by_default: false)
2450 crypto = declare_dependency(link_whole: libcrypto,
2451 dependencies: [authz, qom])
2453 io_ss = io_ss.apply(config_host, strict: false)
2454 libio = static_library('io', io_ss.sources() + genh,
2455 dependencies: [io_ss.dependencies()],
2456 link_with: libqemuutil,
2457 name_suffix: 'fa',
2458 build_by_default: false)
2460 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
2462 libmigration = static_library('migration', sources: migration_files + genh,
2463 name_suffix: 'fa',
2464 build_by_default: false)
2465 migration = declare_dependency(link_with: libmigration,
2466 dependencies: [zlib, qom, io])
2467 softmmu_ss.add(migration)
2469 block_ss = block_ss.apply(config_host, strict: false)
2470 libblock = static_library('block', block_ss.sources() + genh,
2471 dependencies: block_ss.dependencies(),
2472 link_depends: block_syms,
2473 name_suffix: 'fa',
2474 build_by_default: false)
2476 block = declare_dependency(link_whole: [libblock],
2477 link_args: '@block.syms',
2478 dependencies: [crypto, io])
2480 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
2481 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
2482 dependencies: blockdev_ss.dependencies(),
2483 name_suffix: 'fa',
2484 build_by_default: false)
2486 blockdev = declare_dependency(link_whole: [libblockdev],
2487 dependencies: [block])
2489 qmp_ss = qmp_ss.apply(config_host, strict: false)
2490 libqmp = static_library('qmp', qmp_ss.sources() + genh,
2491 dependencies: qmp_ss.dependencies(),
2492 name_suffix: 'fa',
2493 build_by_default: false)
2495 qmp = declare_dependency(link_whole: [libqmp])
2497 libchardev = static_library('chardev', chardev_ss.sources() + genh,
2498 name_suffix: 'fa',
2499 dependencies: [gnutls],
2500 build_by_default: false)
2502 chardev = declare_dependency(link_whole: libchardev)
2504 libhwcore = static_library('hwcore', sources: hwcore_files + genh,
2505 name_suffix: 'fa',
2506 build_by_default: false)
2507 hwcore = declare_dependency(link_whole: libhwcore)
2508 common_ss.add(hwcore)
2510 ###########
2511 # Targets #
2512 ###########
2514 foreach m : block_mods + softmmu_mods
2515 shared_module(m.name(),
2516 name_prefix: '',
2517 link_whole: m,
2518 install: true,
2519 install_dir: qemu_moddir)
2520 endforeach
2522 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
2523 common_ss.add(qom, qemuutil)
2525 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
2526 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
2528 common_all = common_ss.apply(config_all, strict: false)
2529 common_all = static_library('common',
2530 build_by_default: false,
2531 sources: common_all.sources() + genh,
2532 implicit_include_directories: false,
2533 dependencies: common_all.dependencies(),
2534 name_suffix: 'fa')
2536 feature_to_c = find_program('scripts/feature_to_c.sh')
2538 emulators = {}
2539 foreach target : target_dirs
2540 config_target = config_target_mak[target]
2541 target_name = config_target['TARGET_NAME']
2542 arch = config_target['TARGET_BASE_ARCH']
2543 arch_srcs = [config_target_h[target]]
2544 arch_deps = []
2545 c_args = ['-DNEED_CPU_H',
2546 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2547 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2548 link_args = emulator_link_args
2550 config_target += config_host
2551 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2552 if targetos == 'linux'
2553 target_inc += include_directories('linux-headers', is_system: true)
2554 endif
2555 if target.endswith('-softmmu')
2556 qemu_target_name = 'qemu-system-' + target_name
2557 target_type='system'
2558 t = target_softmmu_arch[arch].apply(config_target, strict: false)
2559 arch_srcs += t.sources()
2560 arch_deps += t.dependencies()
2562 hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
2563 hw = hw_arch[hw_dir].apply(config_target, strict: false)
2564 arch_srcs += hw.sources()
2565 arch_deps += hw.dependencies()
2567 arch_srcs += config_devices_h[target]
2568 link_args += ['@block.syms', '@qemu.syms']
2569 else
2570 abi = config_target['TARGET_ABI_DIR']
2571 target_type='user'
2572 qemu_target_name = 'qemu-' + target_name
2573 if arch in target_user_arch
2574 t = target_user_arch[arch].apply(config_target, strict: false)
2575 arch_srcs += t.sources()
2576 arch_deps += t.dependencies()
2577 endif
2578 if 'CONFIG_LINUX_USER' in config_target
2579 base_dir = 'linux-user'
2580 target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
2581 endif
2582 if 'CONFIG_BSD_USER' in config_target
2583 base_dir = 'bsd-user'
2584 target_inc += include_directories('bsd-user/' / targetos)
2585 dir = base_dir / abi
2586 arch_srcs += files(dir / 'target_arch_cpu.c')
2587 endif
2588 target_inc += include_directories(
2589 base_dir,
2590 base_dir / abi,
2591 )
2592 if 'CONFIG_LINUX_USER' in config_target
2593 dir = base_dir / abi
2594 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
2595 if config_target.has_key('TARGET_SYSTBL_ABI')
2596 arch_srcs += \
2597 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
2598 extra_args : config_target['TARGET_SYSTBL_ABI'])
2599 endif
2600 endif
2601 endif
2603 if 'TARGET_XML_FILES' in config_target
2604 gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
2605 output: target + '-gdbstub-xml.c',
2606 input: files(config_target['TARGET_XML_FILES'].split()),
2607 command: [feature_to_c, '@INPUT@'],
2608 capture: true)
2609 arch_srcs += gdbstub_xml
2610 endif
2612 t = target_arch[arch].apply(config_target, strict: false)
2613 arch_srcs += t.sources()
2614 arch_deps += t.dependencies()
2616 target_common = common_ss.apply(config_target, strict: false)
2617 objects = common_all.extract_objects(target_common.sources())
2618 deps = target_common.dependencies()
2620 target_specific = specific_ss.apply(config_target, strict: false)
2621 arch_srcs += target_specific.sources()
2622 arch_deps += target_specific.dependencies()
2624 lib = static_library('qemu-' + target,
2625 sources: arch_srcs + genh,
2626 dependencies: arch_deps,
2627 objects: objects,
2628 include_directories: target_inc,
2629 c_args: c_args,
2630 build_by_default: false,
2631 name_suffix: 'fa')
2633 if target.endswith('-softmmu')
2634 execs = [{
2635 'name': 'qemu-system-' + target_name,
2636 'gui': false,
2637 'sources': files('softmmu/main.c'),
2638 'dependencies': []
2639 }]
2640 if targetos == 'windows' and (sdl.found() or gtk.found())
2641 execs += [{
2642 'name': 'qemu-system-' + target_name + 'w',
2643 'gui': true,
2644 'sources': files('softmmu/main.c'),
2645 'dependencies': []
2646 }]
2647 endif
2648 if config_host.has_key('CONFIG_FUZZ')
2649 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
2650 execs += [{
2651 'name': 'qemu-fuzz-' + target_name,
2652 'gui': false,
2653 'sources': specific_fuzz.sources(),
2654 'dependencies': specific_fuzz.dependencies(),
2655 }]
2656 endif
2657 else
2658 execs = [{
2659 'name': 'qemu-' + target_name,
2660 'gui': false,
2661 'sources': [],
2662 'dependencies': []
2663 }]
2664 endif
2665 foreach exe: execs
2666 exe_name = exe['name']
2667 if targetos == 'darwin'
2668 exe_name += '-unsigned'
2669 endif
2671 emulator = executable(exe_name, exe['sources'],
2672 install: true,
2673 c_args: c_args,
2674 dependencies: arch_deps + deps + exe['dependencies'],
2675 objects: lib.extract_all_objects(recursive: true),
2676 link_language: link_language,
2677 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
2678 link_args: link_args,
2679 gui_app: exe['gui'])
2681 if targetos == 'darwin'
2682 icon = 'pc-bios/qemu.rsrc'
2683 build_input = [emulator, files(icon)]
2684 install_input = [
2685 get_option('bindir') / exe_name,
2686 meson.current_source_dir() / icon
2687 ]
2688 if 'CONFIG_HVF' in config_target
2689 entitlements = 'accel/hvf/entitlements.plist'
2690 build_input += files(entitlements)
2691 install_input += meson.current_source_dir() / entitlements
2692 endif
2694 emulators += {exe['name'] : custom_target(exe['name'],
2695 input: build_input,
2696 output: exe['name'],
2697 command: [
2698 files('scripts/entitlement.sh'),
2699 '@OUTPUT@',
2700 '@INPUT@'
2701 ])
2702 }
2704 meson.add_install_script('scripts/entitlement.sh', '--install',
2705 get_option('bindir') / exe['name'],
2706 install_input)
2707 else
2708 emulators += {exe['name']: emulator}
2709 endif
2711 if 'CONFIG_TRACE_SYSTEMTAP' in config_host
2712 foreach stp: [
2713 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
2714 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
2715 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
2716 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
2717 ]
2718 custom_target(exe['name'] + stp['ext'],
2719 input: trace_events_all,
2720 output: exe['name'] + stp['ext'],
2721 install: stp['install'],
2722 install_dir: get_option('datadir') / 'systemtap/tapset',
2723 command: [
2724 tracetool, '--group=all', '--format=' + stp['fmt'],
2725 '--binary=' + stp['bin'],
2726 '--target-name=' + target_name,
2727 '--target-type=' + target_type,
2728 '--probe-prefix=qemu.' + target_type + '.' + target_name,
2729 '@INPUT@', '@OUTPUT@'
2730 ],
2731 depend_files: tracetool_depends)
2732 endforeach
2733 endif
2734 endforeach
2735 endforeach
2737 # Other build targets
2739 if 'CONFIG_PLUGIN' in config_host
2740 install_headers('include/qemu/qemu-plugin.h')
2741 endif
2743 if 'CONFIG_GUEST_AGENT' in config_host
2744 subdir('qga')
2745 elif get_option('guest_agent_msi').enabled()
2746 error('Guest agent MSI requested, but the guest agent is not being built')
2747 endif
2749 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
2750 # when we don't build tools or system
2751 if xkbcommon.found()
2752 # used for the update-keymaps target, so include rules even if !have_tools
2753 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
2754 dependencies: [qemuutil, xkbcommon], install: have_tools)
2755 endif
2757 if have_tools
2758 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
2759 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
2760 qemu_io = executable('qemu-io', files('qemu-io.c'),
2761 dependencies: [block, qemuutil], install: true)
2762 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
2763 dependencies: [blockdev, qemuutil, gnutls], install: true)
2765 subdir('storage-daemon')
2766 subdir('contrib/rdmacm-mux')
2767 subdir('contrib/elf2dmp')
2769 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
2770 dependencies: qemuutil,
2771 install: true)
2773 if 'CONFIG_VHOST_USER' in config_host
2774 subdir('contrib/vhost-user-blk')
2775 subdir('contrib/vhost-user-gpu')
2776 subdir('contrib/vhost-user-input')
2777 subdir('contrib/vhost-user-scsi')
2778 endif
2780 if targetos == 'linux'
2781 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
2782 dependencies: [qemuutil, libcap_ng],
2783 install: true,
2784 install_dir: get_option('libexecdir'))
2786 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
2787 dependencies: [authz, crypto, io, qom, qemuutil,
2788 libcap_ng, mpathpersist],
2789 install: true)
2790 endif
2792 if have_ivshmem
2793 subdir('contrib/ivshmem-client')
2794 subdir('contrib/ivshmem-server')
2795 endif
2796 endif
2798 subdir('scripts')
2799 subdir('tools')
2800 subdir('pc-bios')
2801 subdir('docs')
2802 subdir('tests')
2803 if gtk.found()
2804 subdir('po')
2805 endif
2807 if host_machine.system() == 'windows'
2808 nsis_cmd = [
2809 find_program('scripts/nsis.py'),
2810 '@OUTPUT@',
2811 get_option('prefix'),
2812 meson.current_source_dir(),
2813 host_machine.cpu(),
2814 '--',
2815 '-DDISPLAYVERSION=' + meson.project_version(),
2816 ]
2817 if build_docs
2818 nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
2819 endif
2820 if gtk.found()
2821 nsis_cmd += '-DCONFIG_GTK=y'
2822 endif
2824 nsis = custom_target('nsis',
2825 output: 'qemu-setup-' + meson.project_version() + '.exe',
2826 input: files('qemu.nsi'),
2827 build_always_stale: true,
2828 command: nsis_cmd + ['@INPUT@'])
2829 alias_target('installer', nsis)
2830 endif
2832 #########################
2833 # Configuration summary #
2834 #########################
2836 # Directories
2837 summary_info = {}
2838 summary_info += {'Install prefix': get_option('prefix')}
2839 summary_info += {'BIOS directory': qemu_datadir}
2840 summary_info += {'firmware path': get_option('qemu_firmwarepath')}
2841 summary_info += {'binary directory': get_option('bindir')}
2842 summary_info += {'library directory': get_option('libdir')}
2843 summary_info += {'module directory': qemu_moddir}
2844 summary_info += {'libexec directory': get_option('libexecdir')}
2845 summary_info += {'include directory': get_option('includedir')}
2846 summary_info += {'config directory': get_option('sysconfdir')}
2847 if targetos != 'windows'
2848 summary_info += {'local state directory': get_option('localstatedir')}
2849 summary_info += {'Manual directory': get_option('mandir')}
2850 else
2851 summary_info += {'local state directory': 'queried at runtime'}
2852 endif
2853 summary_info += {'Doc directory': get_option('docdir')}
2854 summary_info += {'Build directory': meson.current_build_dir()}
2855 summary_info += {'Source path': meson.current_source_dir()}
2856 summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']}
2857 summary(summary_info, bool_yn: true, section: 'Directories')
2859 # Host binaries
2860 summary_info = {}
2861 summary_info += {'git': config_host['GIT']}
2862 summary_info += {'make': config_host['MAKE']}
2863 summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
2864 summary_info += {'sphinx-build': sphinx_build.found()}
2865 if config_host.has_key('HAVE_GDB_BIN')
2866 summary_info += {'gdb': config_host['HAVE_GDB_BIN']}
2867 endif
2868 summary_info += {'genisoimage': config_host['GENISOIMAGE']}
2869 if targetos == 'windows' and config_host.has_key('CONFIG_GUEST_AGENT')
2870 summary_info += {'wixl': wixl.found() ? wixl.full_path() : false}
2871 endif
2872 if slirp_opt != 'disabled' and 'CONFIG_SLIRP_SMBD' in config_host
2873 summary_info += {'smbd': config_host['CONFIG_SMBD_COMMAND']}
2874 endif
2875 summary(summary_info, bool_yn: true, section: 'Host binaries')
2877 # Configurable features
2878 summary_info = {}
2879 summary_info += {'Documentation': build_docs}
2880 summary_info += {'system-mode emulation': have_system}
2881 summary_info += {'user-mode emulation': have_user}
2882 summary_info += {'block layer': have_block}
2883 summary_info += {'Install blobs': get_option('install_blobs')}
2884 summary_info += {'module support': config_host.has_key('CONFIG_MODULES')}
2885 if config_host.has_key('CONFIG_MODULES')
2886 summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
2887 endif
2888 summary_info += {'fuzzing support': config_host.has_key('CONFIG_FUZZ')}
2889 if have_system
2890 summary_info += {'Audio drivers': config_host['CONFIG_AUDIO_DRIVERS']}
2891 endif
2892 summary_info += {'Trace backends': config_host['TRACE_BACKENDS']}
2893 if config_host['TRACE_BACKENDS'].split().contains('simple')
2894 summary_info += {'Trace output file': config_host['CONFIG_TRACE_FILE'] + '-<pid>'}
2895 endif
2896 summary_info += {'QOM debugging': config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
2897 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
2898 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
2899 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
2900 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
2901 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
2902 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
2903 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
2904 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
2905 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
2906 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
2907 summary(summary_info, bool_yn: true, section: 'Configurable features')
2909 # Compilation information
2910 summary_info = {}
2911 summary_info += {'host CPU': cpu}
2912 summary_info += {'host endianness': build_machine.endian()}
2913 summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())}
2914 summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())}
2915 if link_language == 'cpp'
2916 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())}
2917 else
2918 summary_info += {'C++ compiler': false}
2919 endif
2920 if targetos == 'darwin'
2921 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
2922 endif
2923 if targetos == 'windows'
2924 if 'WIN_SDK' in config_host
2925 summary_info += {'Windows SDK': config_host['WIN_SDK']}
2926 endif
2927 endif
2928 summary_info += {'CFLAGS': ' '.join(get_option('c_args')
2929 + ['-O' + get_option('optimization')]
2930 + (get_option('debug') ? ['-g'] : []))}
2931 if link_language == 'cpp'
2932 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args')
2933 + ['-O' + get_option('optimization')]
2934 + (get_option('debug') ? ['-g'] : []))}
2935 endif
2936 link_args = get_option(link_language + '_link_args')
2937 if link_args.length() > 0
2938 summary_info += {'LDFLAGS': ' '.join(link_args)}
2939 endif
2940 summary_info += {'QEMU_CFLAGS': config_host['QEMU_CFLAGS']}
2941 summary_info += {'QEMU_LDFLAGS': config_host['QEMU_LDFLAGS']}
2942 summary_info += {'profiler': config_host.has_key('CONFIG_PROFILER')}
2943 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
2944 summary_info += {'PIE': get_option('b_pie')}
2945 summary_info += {'static build': config_host.has_key('CONFIG_STATIC')}
2946 summary_info += {'malloc trim support': has_malloc_trim}
2947 summary_info += {'membarrier': config_host.has_key('CONFIG_MEMBARRIER')}
2948 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
2949 summary_info += {'mutex debugging': config_host.has_key('CONFIG_DEBUG_MUTEX')}
2950 summary_info += {'memory allocator': get_option('malloc')}
2951 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
2952 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
2953 summary_info += {'gprof enabled': config_host.has_key('CONFIG_GPROF')}
2954 summary_info += {'gcov': get_option('b_coverage')}
2955 summary_info += {'thread sanitizer': config_host.has_key('CONFIG_TSAN')}
2956 summary_info += {'CFI support': get_option('cfi')}
2957 if get_option('cfi')
2958 summary_info += {'CFI debug support': get_option('cfi_debug')}
2959 endif
2960 summary_info += {'strip binaries': get_option('strip')}
2961 summary_info += {'sparse': sparse.found() ? sparse.full_path() : false}
2962 summary_info += {'mingw32 support': targetos == 'windows'}
2964 # snarf the cross-compilation information for tests
2965 foreach target: target_dirs
2966 tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
2967 if fs.exists(tcg_mak)
2968 config_cross_tcg = keyval.load(tcg_mak)
2969 target = config_cross_tcg['TARGET_NAME']
2970 compiler = ''
2971 if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
2972 summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
2973 ' via ' + config_cross_tcg['DOCKER_IMAGE']}
2974 elif 'CROSS_CC_GUEST' in config_cross_tcg
2975 summary_info += {target + ' tests'
2976 : config_cross_tcg['CROSS_CC_GUEST'] }
2977 endif
2978 endif
2979 endforeach
2981 summary(summary_info, bool_yn: true, section: 'Compilation')
2983 # Targets and accelerators
2984 summary_info = {}
2985 if have_system
2986 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')}
2987 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')}
2988 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')}
2989 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')}
2990 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')}
2991 summary_info += {'Xen support': config_host.has_key('CONFIG_XEN_BACKEND')}
2992 if config_host.has_key('CONFIG_XEN_BACKEND')
2993 summary_info += {'xen ctrl version': config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
2994 endif
2995 endif
2996 summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')}
2997 if config_all.has_key('CONFIG_TCG')
2998 if get_option('tcg_interpreter')
2999 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, experimental and slow)'}
3000 else
3001 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)}
3002 endif
3003 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3004 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3005 endif
3006 summary_info += {'target list': ' '.join(target_dirs)}
3007 if have_system
3008 summary_info += {'default devices': get_option('default_devices')}
3009 summary_info += {'out of process emulation': multiprocess_allowed}
3010 endif
3011 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3013 # Block layer
3014 summary_info = {}
3015 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3016 summary_info += {'coroutine pool': config_host['CONFIG_COROUTINE_POOL'] == '1'}
3017 if have_block
3018 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3019 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3020 summary_info += {'Use block whitelist in tools': config_host.has_key('CONFIG_BDRV_WHITELIST_TOOLS')}
3021 summary_info += {'VirtFS support': have_virtfs}
3022 summary_info += {'build virtiofs daemon': have_virtiofsd}
3023 summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
3024 summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
3025 summary_info += {'bochs support': config_host.has_key('CONFIG_BOCHS')}
3026 summary_info += {'cloop support': config_host.has_key('CONFIG_CLOOP')}
3027 summary_info += {'dmg support': config_host.has_key('CONFIG_DMG')}
3028 summary_info += {'qcow v1 support': config_host.has_key('CONFIG_QCOW1')}
3029 summary_info += {'vdi support': config_host.has_key('CONFIG_VDI')}
3030 summary_info += {'vvfat support': config_host.has_key('CONFIG_VVFAT')}
3031 summary_info += {'qed support': config_host.has_key('CONFIG_QED')}
3032 summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
3033 summary_info += {'FUSE exports': fuse.found()}
3034 endif
3035 summary(summary_info, bool_yn: true, section: 'Block layer support')
3037 # Crypto
3038 summary_info = {}
3039 summary_info += {'TLS priority': config_host['CONFIG_TLS_PRIORITY']}
3040 summary_info += {'GNUTLS support': gnutls.found()}
3041 summary_info += {'GNUTLS crypto': gnutls_crypto.found()}
3042 # TODO: add back version
3043 summary_info += {'libgcrypt': gcrypt.found()}
3044 # TODO: add back version
3045 summary_info += {'nettle': nettle.found()}
3046 if nettle.found()
3047 summary_info += {' XTS': xts != 'private'}
3048 endif
3049 summary_info += {'crypto afalg': config_host.has_key('CONFIG_AF_ALG')}
3050 summary_info += {'rng-none': config_host.has_key('CONFIG_RNG_NONE')}
3051 summary_info += {'Linux keyring': config_host.has_key('CONFIG_SECRET_KEYRING')}
3052 summary(summary_info, bool_yn: true, section: 'Crypto')
3054 # Libraries
3055 summary_info = {}
3056 if targetos == 'darwin'
3057 summary_info += {'Cocoa support': cocoa.found()}
3058 endif
3059 # TODO: add back version
3060 summary_info += {'SDL support': sdl.found()}
3061 summary_info += {'SDL image support': sdl_image.found()}
3062 # TODO: add back version
3063 summary_info += {'GTK support': gtk.found()}
3064 summary_info += {'pixman': pixman.found()}
3065 # TODO: add back version
3066 summary_info += {'VTE support': vte.found()}
3067 # TODO: add back version
3068 summary_info += {'slirp support': slirp_opt == 'disabled' ? false : slirp_opt}
3069 summary_info += {'libtasn1': tasn1.found()}
3070 summary_info += {'PAM': pam.found()}
3071 summary_info += {'iconv support': iconv.found()}
3072 summary_info += {'curses support': curses.found()}
3073 # TODO: add back version
3074 summary_info += {'virgl support': virgl.found()}
3075 summary_info += {'curl support': curl.found()}
3076 summary_info += {'Multipath support': mpathpersist.found()}
3077 summary_info += {'VNC support': vnc.found()}
3078 if vnc.found()
3079 summary_info += {'VNC SASL support': sasl.found()}
3080 summary_info += {'VNC JPEG support': jpeg.found()}
3081 summary_info += {'VNC PNG support': png.found()}
3082 endif
3083 summary_info += {'brlapi support': brlapi.found()}
3084 summary_info += {'vde support': config_host.has_key('CONFIG_VDE')}
3085 summary_info += {'netmap support': config_host.has_key('CONFIG_NETMAP')}
3086 summary_info += {'Linux AIO support': config_host.has_key('CONFIG_LINUX_AIO')}
3087 summary_info += {'Linux io_uring support': linux_io_uring.found()}
3088 summary_info += {'ATTR/XATTR support': libattr.found()}
3089 summary_info += {'RDMA support': config_host.has_key('CONFIG_RDMA')}
3090 summary_info += {'PVRDMA support': config_host.has_key('CONFIG_PVRDMA')}
3091 summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt}
3092 summary_info += {'libcap-ng support': libcap_ng.found()}
3093 summary_info += {'bpf support': libbpf.found()}
3094 # TODO: add back protocol and server version
3095 summary_info += {'spice support': config_host.has_key('CONFIG_SPICE')}
3096 summary_info += {'rbd support': rbd.found()}
3097 summary_info += {'xfsctl support': config_host.has_key('CONFIG_XFS')}
3098 summary_info += {'smartcard support': cacard.found()}
3099 summary_info += {'U2F support': u2f.found()}
3100 summary_info += {'libusb': libusb.found()}
3101 summary_info += {'usb net redir': usbredir.found()}
3102 summary_info += {'OpenGL support': config_host.has_key('CONFIG_OPENGL')}
3103 summary_info += {'GBM': gbm.found()}
3104 summary_info += {'libiscsi support': libiscsi.found()}
3105 summary_info += {'libnfs support': libnfs.found()}
3106 if targetos == 'windows'
3107 if config_host.has_key('CONFIG_GUEST_AGENT')
3108 summary_info += {'QGA VSS support': config_host.has_key('CONFIG_QGA_VSS')}
3109 summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
3110 endif
3111 endif
3112 summary_info += {'seccomp support': seccomp.found()}
3113 summary_info += {'GlusterFS support': glusterfs.found()}
3114 summary_info += {'TPM support': config_host.has_key('CONFIG_TPM')}
3115 summary_info += {'libssh support': config_host.has_key('CONFIG_LIBSSH')}
3116 summary_info += {'lzo support': lzo.found()}
3117 summary_info += {'snappy support': snappy.found()}
3118 summary_info += {'bzip2 support': libbzip2.found()}
3119 summary_info += {'lzfse support': liblzfse.found()}
3120 summary_info += {'zstd support': zstd.found()}
3121 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
3122 summary_info += {'libxml2': libxml2.found()}
3123 summary_info += {'capstone': capstone_opt == 'disabled' ? false : capstone_opt}
3124 summary_info += {'libpmem support': libpmem.found()}
3125 summary_info += {'libdaxctl support': libdaxctl.found()}
3126 summary_info += {'libudev': libudev.found()}
3127 summary_info += {'FUSE lseek': fuse_lseek.found()}
3128 summary(summary_info, bool_yn: true, section: 'Dependencies')
3130 if not supported_cpus.contains(cpu)
3131 message()
3132 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3133 message()
3134 message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3135 message('The QEMU project intends to remove support for this host CPU in')
3136 message('a future release if nobody volunteers to maintain it and to')
3137 message('provide a build host for our continuous integration setup.')
3138 message('configure has succeeded and you can continue to build, but')
3139 message('if you care about QEMU on this platform you should contact')
3140 message('us upstream at qemu-devel@nongnu.org.')
3141 endif
3143 if not supported_oses.contains(targetos)
3144 message()
3145 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3146 message()
3147 message('Host OS ' + targetos + 'support is not currently maintained.')
3148 message('The QEMU project intends to remove support for this host OS in')
3149 message('a future release if nobody volunteers to maintain it and to')
3150 message('provide a build host for our continuous integration setup.')
3151 message('configure has succeeded and you can continue to build, but')
3152 message('if you care about QEMU on this platform you should contact')
3153 message('us upstream at qemu-devel@nongnu.org.')
3154 endif