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