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'))
6 add_test_setup('quick', exclude_suites: ['slow', 'thorough'], is_default: true)
7 add_test_setup('slow', exclude_suites: ['thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
8 add_test_setup('thorough', env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
10 meson.add_postconf_script(find_program('scripts/symlink-install-tree.py'))
16 not_found = dependency('', required: false)
17 keyval = import('keyval')
18 ss = import('sourceset')
21 host_os = host_machine.system()
22 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
24 # Temporary directory used for files created while
25 # configure runs. Since it is in the build directory
26 # we can safely blow away any previous version of it
27 # (and we need not jump through hoops to try to delete
28 # it when configure exits.)
29 tmpdir = meson.current_build_dir() / 'meson-private/temp'
31 if get_option('qemu_suffix').startswith('/')
32 error('qemu_suffix cannot start with a /')
35 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
36 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
37 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
38 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
40 qemu_desktopdir = get_option('datadir') / 'applications'
41 qemu_icondir = get_option('datadir') / 'icons'
44 qapi_trace_events = []
46 bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin']
47 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
48 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64',
49 'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc64']
51 cpu = host_machine.cpu_family()
53 target_dirs = config_host['TARGET_DIRS'].split()
59 sh = find_program('sh')
60 python = import('python').find_installation()
62 cc = meson.get_compiler('c')
64 if host_os == 'windows' and add_languages('cpp', required: false, native: false)
65 all_languages += ['cpp']
66 cxx = meson.get_compiler('cpp')
68 if host_os == 'darwin' and \
69 add_languages('objc', required: get_option('cocoa'), native: false)
70 all_languages += ['objc']
71 objc = meson.get_compiler('objc')
76 if 'dtrace' in get_option('trace_backends')
77 dtrace = find_program('dtrace', required: true)
78 stap = find_program('stap', required: false)
80 # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
81 # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
82 # instead. QEMU --enable-modules depends on this because the SystemTap
83 # semaphores are linked into the main binary and not the module's shared
85 add_global_arguments('-DSTAP_SDT_V2',
86 native: false, language: all_languages)
90 if get_option('iasl') == ''
91 iasl = find_program('iasl', required: false)
93 iasl = find_program(get_option('iasl'), required: true)
96 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
97 unpack_edk2_blobs = false
98 foreach target : edk2_targets
99 if target in target_dirs
100 bzip2 = find_program('bzip2', required: get_option('install_blobs'))
101 unpack_edk2_blobs = bzip2.found()
106 #####################
107 # Option validation #
108 #####################
111 if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
114 #include <sys/types.h>
115 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
116 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
118 args: ['-Werror', '-fsanitize=fuzzer'])
119 error('Your compiler does not support -fsanitize=fuzzer')
123 if 'ftrace' in get_option('trace_backends') and host_os != 'linux'
124 error('ftrace is supported only on Linux')
126 if 'syslog' in get_option('trace_backends') and not cc.compiles('''
129 openlog("qemu", LOG_PID, LOG_DAEMON);
130 syslog(LOG_INFO, "configure");
133 error('syslog is not supported on this system')
136 # Miscellaneous Linux-only features
137 get_option('mpath') \
138 .require(host_os == 'linux', error_message: 'Multipath is supported only on Linux')
140 multiprocess_allowed = get_option('multiprocess') \
141 .require(host_os == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
144 vfio_user_server_allowed = get_option('vfio_user_server') \
145 .require(host_os == 'linux', error_message: 'vfio-user server is supported only on Linux') \
148 have_tpm = get_option('tpm') \
149 .require(host_os != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
153 have_vhost_user = get_option('vhost_user') \
154 .disable_auto_if(host_os != 'linux') \
155 .require(host_os != 'windows',
156 error_message: 'vhost-user is not available on Windows').allowed()
157 have_vhost_vdpa = get_option('vhost_vdpa') \
158 .require(host_os == 'linux',
159 error_message: 'vhost-vdpa is only available on Linux').allowed()
160 have_vhost_kernel = get_option('vhost_kernel') \
161 .require(host_os == 'linux',
162 error_message: 'vhost-kernel is only available on Linux').allowed()
163 have_vhost_user_crypto = get_option('vhost_crypto') \
164 .require(have_vhost_user,
165 error_message: 'vhost-crypto requires vhost-user to be enabled').allowed()
167 have_vhost = have_vhost_user or have_vhost_vdpa or have_vhost_kernel
169 have_vhost_net_user = have_vhost_user and get_option('vhost_net').allowed()
170 have_vhost_net_vdpa = have_vhost_vdpa and get_option('vhost_net').allowed()
171 have_vhost_net_kernel = have_vhost_kernel and get_option('vhost_net').allowed()
172 have_vhost_net = have_vhost_net_kernel or have_vhost_net_user or have_vhost_net_vdpa
174 # type of binaries to build
175 have_linux_user = false
176 have_bsd_user = false
178 foreach target : target_dirs
179 have_linux_user = have_linux_user or target.endswith('linux-user')
180 have_bsd_user = have_bsd_user or target.endswith('bsd-user')
181 have_system = have_system or target.endswith('-softmmu')
183 have_user = have_linux_user or have_bsd_user
185 have_tools = get_option('tools') \
186 .disable_auto_if(not have_system) \
188 have_ga = get_option('guest_agent') \
189 .disable_auto_if(not have_system and not have_tools) \
190 .require(host_os in ['sunos', 'linux', 'windows', 'freebsd', 'netbsd', 'openbsd'],
191 error_message: 'unsupported OS for QEMU guest agent') \
193 have_block = have_system or have_tools
195 enable_modules = get_option('modules') \
196 .require(host_os != 'windows',
197 error_message: 'Modules are not available for Windows') \
198 .require(not get_option('prefer_static'),
199 error_message: 'Modules are incompatible with static linking') \
202 #######################################
203 # Variables for host and accelerators #
204 #######################################
206 if cpu not in supported_cpus
207 host_arch = 'unknown'
212 elif cpu in ['riscv32', 'riscv64']
218 if cpu in ['x86', 'x86_64']
219 kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
220 elif cpu == 'aarch64'
221 kvm_targets = ['aarch64-softmmu']
223 kvm_targets = ['s390x-softmmu']
224 elif cpu in ['ppc', 'ppc64']
225 kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
226 elif cpu in ['mips', 'mips64']
227 kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
228 elif cpu in ['riscv32']
229 kvm_targets = ['riscv32-softmmu']
230 elif cpu in ['riscv64']
231 kvm_targets = ['riscv64-softmmu']
235 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
237 if cpu in ['x86', 'x86_64']
238 xen_targets = ['i386-softmmu', 'x86_64-softmmu']
239 elif cpu in ['arm', 'aarch64']
240 # i386 emulator provides xenpv machine type for multiple architectures
241 xen_targets = ['i386-softmmu', 'x86_64-softmmu', 'aarch64-softmmu']
245 accelerator_targets += { 'CONFIG_XEN': xen_targets }
247 if cpu in ['aarch64']
248 accelerator_targets += {
249 'CONFIG_HVF': ['aarch64-softmmu']
253 if cpu in ['x86', 'x86_64']
254 accelerator_targets += {
255 'CONFIG_HVF': ['x86_64-softmmu'],
256 'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
257 'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
262 # Darwin does not support references to thread-local variables in modules
263 if host_os != 'darwin'
264 modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
271 foreach lang : all_languages
272 compiler = meson.get_compiler(lang)
273 if compiler.get_id() == 'gcc' and compiler.version().version_compare('>=7.4')
275 elif compiler.get_id() == 'clang' and compiler.compiles('''
276 #ifdef __apple_build_version__
277 # if __clang_major__ < 12 || (__clang_major__ == 12 && __clang_minor__ < 0)
278 # error You need at least XCode Clang v12.0 to compile QEMU
281 # if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0)
282 # error You need at least Clang v10.0 to compile QEMU
287 error('You either need GCC v7.4 or Clang v10.0 (or XCode Clang v12.0) to compile QEMU')
291 # default flags for all hosts
292 # We use -fwrapv to tell the compiler that we require a C dialect where
293 # left shift of signed integers is well defined and has the expected
294 # 2s-complement style results. (Both clang and gcc agree that it
295 # provides these semantics.)
297 qemu_common_flags = [
298 '-D_GNU_SOURCE', '-D_FILE_OFFSET_BITS=64', '-D_LARGEFILE_SOURCE',
299 '-fno-strict-aliasing', '-fno-common', '-fwrapv' ]
303 if host_os == 'darwin'
304 # Disable attempts to use ObjectiveC features in os/object.h since they
305 # won't work when we're compiling with gcc as a C compiler.
306 if compiler.get_id() == 'gcc'
307 qemu_common_flags += '-DOS_OBJECT_USE_OBJC=0'
309 elif host_os == 'sunos'
310 # needed for CMSG_ macros in sys/socket.h
311 qemu_common_flags += '-D_XOPEN_SOURCE=600'
312 # needed for TIOCWIN* defines in termios.h
313 qemu_common_flags += '-D__EXTENSIONS__'
314 elif host_os == 'haiku'
315 qemu_common_flags += ['-DB_USE_POSITIVE_POSIX_ERRORS', '-D_BSD_SOURCE', '-fPIC']
318 # __sync_fetch_and_and requires at least -march=i486. Many toolchains
319 # use i686 as default anyway, but for those that don't, an explicit
320 # specification is necessary
321 if host_arch == 'i386' and not cc.links('''
322 static int sfaa(int *ptr)
324 return __sync_fetch_and_and(ptr, 0);
330 val = __sync_val_compare_and_swap(&val, 0, 1);
334 qemu_common_flags = ['-march=i486'] + qemu_common_flags
337 if get_option('prefer_static')
338 qemu_ldflags += get_option('b_pie') ? '-static-pie' : '-static'
341 # Meson currently only handles pie as a boolean for now, so if the user
342 # has explicitly disabled PIE we need to extend our cflags.
344 # -no-pie is supposedly a linker flag that has no effect on the compiler
345 # command line, but some distros, that didn't quite know what they were
346 # doing, made local changes to gcc's specs file that turned it into
347 # a compiler command-line flag.
349 # What about linker flags? For a static build, no PIE is implied by -static
350 # which we added above (and if it's not because of the same specs patching,
351 # there's nothing we can do: compilation will fail, report a bug to your
352 # distro and do not use --disable-pie in the meanwhile). For dynamic linking,
353 # instead, we can't add -no-pie because it overrides -shared: the linker then
354 # tries to build an executable instead of a shared library and fails. So
355 # don't add -no-pie anywhere and cross fingers. :(
356 if not get_option('b_pie')
357 qemu_common_flags += cc.get_supported_arguments('-fno-pie', '-no-pie')
360 if not get_option('stack_protector').disabled()
361 stack_protector_probe = '''
362 int main(int argc, char *argv[])
364 char arr[64], *p = arr, *c = argv[argc - 1];
370 have_stack_protector = false
371 foreach arg : ['-fstack-protector-strong', '-fstack-protector-all']
372 # We need to check both a compile and a link, since some compiler
373 # setups fail only on a .c->.o compile and some only at link time
374 if cc.compiles(stack_protector_probe, args: ['-Werror', arg]) and \
375 cc.links(stack_protector_probe, args: ['-Werror', arg])
376 have_stack_protector = true
382 get_option('stack_protector') \
383 .require(have_stack_protector, error_message: 'Stack protector not supported')
386 coroutine_backend = get_option('coroutine_backend')
388 #include <ucontext.h>
389 #ifdef __stub_makecontext
390 #error Ignoring glibc stub makecontext which will always fail
392 int main(void) { makecontext(0, 0, 0); return 0; }'''
394 # On Windows the only valid backend is the Windows specific one.
395 # For POSIX prefer ucontext, but it's not always possible. The fallback
397 supported_backends = []
398 if host_os == 'windows'
399 supported_backends += ['windows']
401 if host_os != 'darwin' and cc.links(ucontext_probe)
402 supported_backends += ['ucontext']
404 supported_backends += ['sigaltstack']
407 if coroutine_backend == 'auto'
408 coroutine_backend = supported_backends[0]
409 elif coroutine_backend not in supported_backends
410 error('"@0@" backend requested but not available. Available backends: @1@' \
411 .format(coroutine_backend, ', '.join(supported_backends)))
414 # Compiles if SafeStack *not* enabled
415 safe_stack_probe = '''
418 #if defined(__has_feature)
419 #if __has_feature(safe_stack)
420 #error SafeStack Enabled
425 if get_option('safe_stack') != not cc.compiles(safe_stack_probe)
426 safe_stack_arg = get_option('safe_stack') ? '-fsanitize=safe-stack' : '-fno-sanitize=safe-stack'
427 if get_option('safe_stack') != not cc.compiles(safe_stack_probe, args: safe_stack_arg)
428 error(get_option('safe_stack') \
429 ? 'SafeStack not supported by your compiler' \
430 : 'Cannot disable SafeStack')
432 qemu_cflags += safe_stack_arg
433 qemu_ldflags += safe_stack_arg
435 if get_option('safe_stack') and coroutine_backend != 'ucontext'
436 error('SafeStack is only supported with the ucontext coroutine backend')
439 if get_option('sanitizers')
440 if cc.has_argument('-fsanitize=address')
441 qemu_cflags = ['-fsanitize=address'] + qemu_cflags
442 qemu_ldflags = ['-fsanitize=address'] + qemu_ldflags
445 # Detect static linking issue with ubsan - https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84285
446 if cc.links('int main(int argc, char **argv) { return argc + 1; }',
447 args: [qemu_ldflags, '-fsanitize=undefined'])
448 qemu_cflags = ['-fsanitize=undefined'] + qemu_cflags
449 qemu_ldflags = ['-fsanitize=undefined'] + qemu_ldflags
453 # Thread sanitizer is, for now, much noisier than the other sanitizers;
454 # keep it separate until that is not the case.
455 if get_option('tsan')
456 if get_option('sanitizers')
457 error('TSAN is not supported with other sanitizers')
459 if not cc.has_function('__tsan_create_fiber',
460 args: '-fsanitize=thread',
461 prefix: '#include <sanitizer/tsan_interface.h>')
462 error('Cannot enable TSAN due to missing fiber annotation interface')
464 qemu_cflags = ['-fsanitize=thread'] + qemu_cflags
465 qemu_ldflags = ['-fsanitize=thread'] + qemu_ldflags
468 # Detect support for PT_GNU_RELRO + DT_BIND_NOW.
469 # The combination is known as "full relro", because .got.plt is read-only too.
470 qemu_ldflags += cc.get_supported_link_arguments('-Wl,-z,relro', '-Wl,-z,now')
472 if host_os == 'windows'
473 qemu_ldflags += cc.get_supported_link_arguments('-Wl,--no-seh', '-Wl,--nxcompat')
474 qemu_ldflags += cc.get_supported_link_arguments('-Wl,--dynamicbase', '-Wl,--high-entropy-va')
477 # Exclude --warn-common with TSan to suppress warnings from the TSan libraries.
478 if host_os != 'sunos' and not get_option('tsan')
479 qemu_ldflags += cc.get_supported_link_arguments('-Wl,--warn-common')
482 if get_option('fuzzing')
483 # Specify a filter to only instrument code that is directly related to
485 configure_file(output: 'instrumentation-filter',
486 input: 'scripts/oss-fuzz/instrumentation-filter-template',
489 if cc.compiles('int main () { return 0; }',
490 name: '-fsanitize-coverage-allowlist=/dev/null',
491 args: ['-fsanitize-coverage-allowlist=/dev/null',
492 '-fsanitize-coverage=trace-pc'] )
493 qemu_common_flags += ['-fsanitize-coverage-allowlist=instrumentation-filter']
496 if get_option('fuzzing_engine') == ''
497 # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
498 # compiled code. To build non-fuzzer binaries with --enable-fuzzing, link
499 # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
500 # unable to bind the fuzzer-related callbacks added by instrumentation.
501 qemu_common_flags += ['-fsanitize=fuzzer-no-link']
502 qemu_ldflags += ['-fsanitize=fuzzer-no-link']
503 # For the actual fuzzer binaries, we need to link against the libfuzzer
504 # library. They need to be configurable, to support OSS-Fuzz
505 fuzz_exe_ldflags = ['-fsanitize=fuzzer']
507 # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
508 # the needed CFLAGS have already been provided
509 fuzz_exe_ldflags = get_option('fuzzing_engine').split()
515 # Check for dependency on LTO
516 if not get_option('b_lto')
517 error('Selected Control-Flow Integrity but LTO is disabled')
520 error('Selected Control-Flow Integrity is not compatible with modules')
522 # Check for cfi flags. CFI requires LTO so we can't use
523 # get_supported_arguments, but need a more complex "compiles" which allows
525 if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
526 args: ['-flto', '-fsanitize=cfi-icall'] )
527 cfi_flags += '-fsanitize=cfi-icall'
529 error('-fsanitize=cfi-icall is not supported by the compiler')
531 if cc.compiles('int main () { return 0; }',
532 name: '-fsanitize-cfi-icall-generalize-pointers',
533 args: ['-flto', '-fsanitize=cfi-icall',
534 '-fsanitize-cfi-icall-generalize-pointers'] )
535 cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
537 error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
539 if get_option('cfi_debug')
540 if cc.compiles('int main () { return 0; }',
541 name: '-fno-sanitize-trap=cfi-icall',
542 args: ['-flto', '-fsanitize=cfi-icall',
543 '-fno-sanitize-trap=cfi-icall'] )
544 cfi_flags += '-fno-sanitize-trap=cfi-icall'
546 error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
549 add_global_arguments(cfi_flags, native: false, language: all_languages)
550 add_global_link_arguments(cfi_flags, native: false, language: all_languages)
553 add_global_arguments(qemu_common_flags, native: false, language: all_languages)
554 add_global_link_arguments(qemu_ldflags, native: false, language: all_languages)
556 # Collect warnings that we want to enable
561 '-Wmissing-prototypes',
562 '-Wstrict-prototypes',
564 '-Wold-style-declaration',
565 '-Wold-style-definition',
570 '-Wignored-qualifiers',
574 '-Wexpansion-to-defined',
575 '-Wimplicit-fallthrough=2',
576 '-Wmissing-format-attribute',
577 '-Wno-initializer-overrides',
578 '-Wno-missing-include-dirs',
579 '-Wno-shift-negative-value',
580 '-Wno-string-plus-int',
581 '-Wno-typedef-redefinition',
582 '-Wno-tautological-type-limit-compare',
584 '-Wno-gnu-variable-sized-type-not-at-end',
588 if host_os != 'darwin'
589 warn_flags += ['-Wthread-safety']
592 # Set up C++ compiler flags
594 if 'cpp' in all_languages
595 qemu_cxxflags = ['-D__STDC_LIMIT_MACROS', '-D__STDC_CONSTANT_MACROS', '-D__STDC_FORMAT_MACROS'] + qemu_cflags
598 add_project_arguments(qemu_cflags, native: false, language: 'c')
599 add_project_arguments(cc.get_supported_arguments(warn_flags), native: false, language: 'c')
600 if 'cpp' in all_languages
601 add_project_arguments(qemu_cxxflags, native: false, language: 'cpp')
602 add_project_arguments(cxx.get_supported_arguments(warn_flags), native: false, language: 'cpp')
604 if 'objc' in all_languages
605 # Note sanitizer flags are not applied to Objective-C sources!
606 add_project_arguments(objc.get_supported_arguments(warn_flags), native: false, language: 'objc')
608 if host_os == 'linux'
609 add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
610 '-isystem', 'linux-headers',
611 language: all_languages)
614 add_project_arguments('-iquote', '.',
615 '-iquote', meson.current_source_dir(),
616 '-iquote', meson.current_source_dir() / 'include',
617 language: all_languages)
619 # If a host-specific include directory exists, list that first...
620 host_include = meson.current_source_dir() / 'host/include/'
621 if fs.is_dir(host_include / host_arch)
622 add_project_arguments('-iquote', host_include / host_arch,
623 language: all_languages)
625 # ... followed by the generic fallback.
626 add_project_arguments('-iquote', host_include / 'generic',
627 language: all_languages)
629 sparse = find_program('cgcc', required: get_option('sparse'))
632 command: [find_program('scripts/check_sparse.py'),
633 'compile_commands.json', sparse.full_path(), '-Wbitwise',
634 '-Wno-transparent-union', '-Wno-old-initializer',
635 '-Wno-non-pointer-null'])
638 #####################################
639 # Host-specific libraries and flags #
640 #####################################
642 libm = cc.find_library('m', required: false)
643 threads = dependency('threads')
644 util = cc.find_library('util', required: false)
650 emulator_link_args = []
655 if host_os == 'windows'
656 midl = find_program('midl', required: false)
657 widl = find_program('widl', required: false)
658 pathcch = cc.find_library('pathcch')
659 socket = cc.find_library('ws2_32')
660 winmm = cc.find_library('winmm')
662 win = import('windows')
663 version_res = win.compile_resources('version.rc',
664 depend_files: files('pc-bios/qemu-nsis.ico'),
665 include_directories: include_directories('.'))
667 elif host_os == 'darwin'
668 coref = dependency('appleframeworks', modules: 'CoreFoundation')
669 iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
670 host_dsosuf = '.dylib'
671 elif host_os == 'sunos'
672 socket = [cc.find_library('socket'),
673 cc.find_library('nsl'),
674 cc.find_library('resolv')]
675 elif host_os == 'haiku'
676 socket = [cc.find_library('posix_error_mapper'),
677 cc.find_library('network'),
678 cc.find_library('bsd')]
679 elif host_os == 'openbsd'
680 if get_option('tcg').allowed() and target_dirs.length() > 0
681 # Disable OpenBSD W^X if available
682 emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
686 ###############################################
687 # Host-specific configuration of accelerators #
688 ###############################################
691 if get_option('kvm').allowed() and host_os == 'linux'
692 accelerators += 'CONFIG_KVM'
694 if get_option('whpx').allowed() and host_os == 'windows'
695 if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
696 error('WHPX requires 64-bit host')
697 elif cc.has_header('winhvplatform.h', required: get_option('whpx')) and \
698 cc.has_header('winhvemulation.h', required: get_option('whpx'))
699 accelerators += 'CONFIG_WHPX'
704 if get_option('hvf').allowed()
705 hvf = dependency('appleframeworks', modules: 'Hypervisor',
706 required: get_option('hvf'))
708 accelerators += 'CONFIG_HVF'
713 if host_os == 'netbsd'
714 nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
716 accelerators += 'CONFIG_NVMM'
721 if get_option('tcg').allowed()
722 if host_arch == 'unknown'
723 if not get_option('tcg_interpreter')
724 error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
726 elif get_option('tcg_interpreter')
727 warning('Use of the TCG interpreter is not recommended on this host')
728 warning('architecture. There is a native TCG execution backend available')
729 warning('which provides substantially better performance and reliability.')
730 warning('It is strongly recommended to remove the --enable-tcg-interpreter')
731 warning('configuration option on this architecture to use the native')
734 if get_option('tcg_interpreter')
736 elif host_arch == 'x86_64'
738 elif host_arch == 'ppc64'
741 add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
742 language: all_languages)
744 accelerators += 'CONFIG_TCG'
747 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
748 error('KVM not available on this platform')
750 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
751 error('HVF not available on this platform')
753 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
754 error('NVMM not available on this platform')
756 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
757 error('WHPX not available on this platform')
761 if get_option('xen').enabled() or (get_option('xen').auto() and have_system)
762 xencontrol = dependency('xencontrol', required: false,
763 method: 'pkg-config')
764 if xencontrol.found()
765 xen_pc = declare_dependency(version: xencontrol.version(),
768 # disabler: true makes xen_pc.found() return false if any is not found
769 dependency('xenstore', required: false,
770 method: 'pkg-config',
772 dependency('xenforeignmemory', required: false,
773 method: 'pkg-config',
775 dependency('xengnttab', required: false,
776 method: 'pkg-config',
778 dependency('xenevtchn', required: false,
779 method: 'pkg-config',
781 dependency('xendevicemodel', required: false,
782 method: 'pkg-config',
784 # optional, no "disabler: true"
785 dependency('xentoolcore', required: false,
786 method: 'pkg-config')])
792 xen_tests = [ '4.11.0', '4.10.0', '4.9.0', '4.8.0', '4.7.1' ]
794 '4.11.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
795 '4.10.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
796 '4.9.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
797 '4.8.0': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
798 '4.7.1': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
801 foreach ver: xen_tests
802 # cache the various library tests to avoid polluting the logs
804 foreach l: xen_libs[ver]
806 xen_deps += { l: cc.find_library(l, required: false) }
808 xen_test_deps += xen_deps[l]
811 # Use -D to pick just one of the test programs in scripts/xen-detect.c
812 xen_version = ver.split('.')
813 xen_ctrl_version = xen_version[0] + \
814 ('0' + xen_version[1]).substring(-2) + \
815 ('0' + xen_version[2]).substring(-2)
816 if cc.links(files('scripts/xen-detect.c'),
817 args: '-DCONFIG_XEN_CTRL_INTERFACE_VERSION=' + xen_ctrl_version,
818 dependencies: xen_test_deps)
819 xen = declare_dependency(version: ver, dependencies: xen_test_deps)
825 accelerators += 'CONFIG_XEN'
826 elif get_option('xen').enabled()
827 error('could not compile and link Xen test program')
830 have_xen_pci_passthrough = get_option('xen_pci_passthrough') \
831 .require(xen.found(),
832 error_message: 'Xen PCI passthrough requested but Xen not enabled') \
833 .require(host_os == 'linux',
834 error_message: 'Xen PCI passthrough not available on this platform') \
835 .require(cpu == 'x86' or cpu == 'x86_64',
836 error_message: 'Xen PCI passthrough not available on this platform') \
843 # When bumping glib minimum version, please check also whether to increase
844 # the _WIN32_WINNT setting in osdep.h according to the value from glib
845 glib_req_ver = '>=2.56.0'
846 glib_pc = dependency('glib-2.0', version: glib_req_ver, required: true,
847 method: 'pkg-config')
850 gmodule = dependency('gmodule-export-2.0', version: glib_req_ver, required: true,
851 method: 'pkg-config')
852 elif get_option('plugins')
853 gmodule = dependency('gmodule-no-export-2.0', version: glib_req_ver, required: true,
854 method: 'pkg-config')
859 # This workaround is required due to a bug in pkg-config file for glib as it
860 # doesn't define GLIB_STATIC_COMPILATION for pkg-config --static
861 if host_os == 'windows' and get_option('prefer_static')
862 glib_cflags += ['-DGLIB_STATIC_COMPILATION']
865 # Sanity check that the current size_t matches the
866 # size that glib thinks it should be. This catches
867 # problems on multi-arch where people try to build
868 # 32-bit QEMU while pointing at 64-bit glib headers
870 if not cc.compiles('''
874 #define QEMU_BUILD_BUG_ON(x) \
875 typedef char qemu_build_bug_on[(x)?-1:1] __attribute__((unused));
878 QEMU_BUILD_BUG_ON(sizeof(size_t) != GLIB_SIZEOF_SIZE_T);
880 }''', dependencies: glib_pc, args: glib_cflags)
881 error('''sizeof(size_t) doesn't match GLIB_SIZEOF_SIZE_T.
882 You probably need to set PKG_CONFIG_LIBDIR" to point
883 to the right pkg-config files for your build target.''')
886 # Silence clang warnings triggered by glib < 2.57.2
887 if not cc.compiles('''
892 static void foo_free(Foo *f)
896 G_DEFINE_AUTOPTR_CLEANUP_FUNC(Foo, foo_free)
897 int main(void) { return 0; }''', dependencies: glib_pc, args: ['-Wunused-function', '-Werror'])
898 glib_cflags += cc.get_supported_arguments('-Wno-unused-function')
900 glib = declare_dependency(dependencies: [glib_pc, gmodule],
901 compile_args: glib_cflags,
902 version: glib_pc.version())
904 # Check whether glib has gslice, which we have to avoid for correctness.
905 # TODO: remove this check and the corresponding workaround (qtree) when
906 # the minimum supported glib is >= 2.75.3
907 glib_has_gslice = glib.version().version_compare('<2.75.3')
909 # override glib dep to include the above refinements
910 meson.override_dependency('glib-2.0', glib)
912 # The path to glib.h is added to all compilation commands.
913 add_project_dependencies(glib.partial_dependency(compile_args: true, includes: true),
914 native: false, language: all_languages)
917 gdbus_codegen = not_found
918 gdbus_codegen_error = '@0@ requires gdbus-codegen, please install libgio'
919 if not get_option('gio').auto() or have_system
920 gio = dependency('gio-2.0', required: get_option('gio'),
921 method: 'pkg-config')
922 if gio.found() and not cc.links('''
926 g_dbus_proxy_new_sync(0, 0, 0, 0, 0, 0, 0, 0);
928 }''', dependencies: [glib, gio])
929 if get_option('gio').enabled()
930 error('The installed libgio is broken for static linking')
935 gdbus_codegen = find_program(gio.get_variable('gdbus_codegen'),
936 required: get_option('gio'))
937 gio_unix = dependency('gio-unix-2.0', required: get_option('gio'),
938 method: 'pkg-config')
939 gio = declare_dependency(dependencies: [gio, gio_unix],
940 version: gio.version())
943 if gdbus_codegen.found() and get_option('cfi')
944 gdbus_codegen = not_found
945 gdbus_codegen_error = '@0@ uses gdbus-codegen, which does not support control flow integrity'
948 xml_pp = find_program('scripts/xml-preprocess.py')
951 if 'ust' in get_option('trace_backends')
952 lttng = dependency('lttng-ust', required: true, version: '>= 2.1',
953 method: 'pkg-config')
956 if not get_option('pixman').auto() or have_system or have_tools
957 pixman = dependency('pixman-1', required: get_option('pixman'), version:'>=0.21.8',
958 method: 'pkg-config')
961 zlib = dependency('zlib', required: true)
964 if not get_option('linux_aio').auto() or have_block
965 libaio = cc.find_library('aio', has_headers: ['libaio.h'],
966 required: get_option('linux_aio'))
969 linux_io_uring_test = '''
970 #include <liburing.h>
971 #include <linux/errqueue.h>
973 int main(void) { return 0; }'''
975 linux_io_uring = not_found
976 if not get_option('linux_io_uring').auto() or have_block
977 linux_io_uring = dependency('liburing', version: '>=0.3',
978 required: get_option('linux_io_uring'),
979 method: 'pkg-config')
980 if not cc.links(linux_io_uring_test)
981 linux_io_uring = not_found
986 if not get_option('libnfs').auto() or have_block
987 libnfs = dependency('libnfs', version: '>=1.9.3',
988 required: get_option('libnfs'),
989 method: 'pkg-config')
994 #include <sys/types.h>
995 #ifdef CONFIG_LIBATTR
996 #include <attr/xattr.h>
998 #include <sys/xattr.h>
1000 int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
1003 have_old_libattr = false
1004 if get_option('attr').allowed()
1005 if cc.links(libattr_test)
1006 libattr = declare_dependency()
1008 libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
1009 required: get_option('attr'))
1010 if libattr.found() and not \
1011 cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
1013 if get_option('attr').enabled()
1014 error('could not link libattr')
1016 warning('could not link libattr, disabling')
1019 have_old_libattr = libattr.found()
1024 cocoa = dependency('appleframeworks', modules: ['Cocoa', 'CoreVideo'],
1025 required: get_option('cocoa'))
1027 vmnet = dependency('appleframeworks', modules: 'vmnet', required: get_option('vmnet'))
1028 if vmnet.found() and not cc.has_header_symbol('vmnet/vmnet.h',
1029 'VMNET_BRIDGED_MODE',
1030 dependencies: vmnet)
1032 if get_option('vmnet').enabled()
1033 error('vmnet.framework API is outdated')
1035 warning('vmnet.framework API is outdated, disabling')
1040 seccomp_has_sysrawrc = false
1041 if not get_option('seccomp').auto() or have_system or have_tools
1042 seccomp = dependency('libseccomp', version: '>=2.3.0',
1043 required: get_option('seccomp'),
1044 method: 'pkg-config')
1046 seccomp_has_sysrawrc = cc.has_header_symbol('seccomp.h',
1047 'SCMP_FLTATR_API_SYSRAWRC',
1048 dependencies: seccomp)
1052 libcap_ng = not_found
1053 if not get_option('cap_ng').auto() or have_system or have_tools
1054 libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
1055 required: get_option('cap_ng'))
1057 if libcap_ng.found() and not cc.links('''
1061 capng_capability_to_name(CAPNG_EFFECTIVE);
1063 }''', dependencies: libcap_ng)
1064 libcap_ng = not_found
1065 if get_option('cap_ng').enabled()
1066 error('could not link libcap-ng')
1068 warning('could not link libcap-ng, disabling')
1072 if get_option('xkbcommon').auto() and not have_system and not have_tools
1073 xkbcommon = not_found
1075 xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
1076 method: 'pkg-config')
1080 if not get_option('slirp').auto() or have_system
1081 slirp = dependency('slirp', required: get_option('slirp'),
1082 method: 'pkg-config')
1083 # slirp < 4.7 is incompatible with CFI support in QEMU. This is because
1084 # it passes function pointers within libslirp as callbacks for timers.
1085 # When using a system-wide shared libslirp, the type information for the
1086 # callback is missing and the timer call produces a false positive with CFI.
1087 # Do not use the "version" keyword argument to produce a better error.
1088 # with control-flow integrity.
1089 if get_option('cfi') and slirp.found() and slirp.version().version_compare('<4.7')
1090 if get_option('slirp').enabled()
1091 error('Control-Flow Integrity requires libslirp 4.7.')
1093 warning('Cannot use libslirp since Control-Flow Integrity requires libslirp >= 4.7.')
1100 if not get_option('vde').auto() or have_system or have_tools
1101 vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
1102 required: get_option('vde'))
1104 if vde.found() and not cc.links('''
1105 #include <libvdeplug.h>
1108 struct vde_open_args a = {0, 0, 0};
1112 }''', dependencies: vde)
1114 if get_option('cap_ng').enabled()
1115 error('could not link libvdeplug')
1117 warning('could not link libvdeplug, disabling')
1122 if not get_option('pa').auto() or (host_os == 'linux' and have_system)
1123 pulse = dependency('libpulse', required: get_option('pa'),
1124 method: 'pkg-config')
1127 if not get_option('alsa').auto() or (host_os == 'linux' and have_system)
1128 alsa = dependency('alsa', required: get_option('alsa'),
1129 method: 'pkg-config')
1132 if not get_option('jack').auto() or have_system
1133 jack = dependency('jack', required: get_option('jack'),
1134 method: 'pkg-config')
1136 pipewire = not_found
1137 if not get_option('pipewire').auto() or (host_os == 'linux' and have_system)
1138 pipewire = dependency('libpipewire-0.3', version: '>=0.3.60',
1139 required: get_option('pipewire'),
1140 method: 'pkg-config')
1143 if not get_option('sndio').auto() or have_system
1144 sndio = dependency('sndio', required: get_option('sndio'),
1145 method: 'pkg-config')
1148 spice_protocol = not_found
1149 if not get_option('spice_protocol').auto() or have_system
1150 spice_protocol = dependency('spice-protocol', version: '>=0.14.0',
1151 required: get_option('spice_protocol'),
1152 method: 'pkg-config')
1155 if get_option('spice') \
1156 .disable_auto_if(not have_system) \
1157 .require(pixman.found(),
1158 error_message: 'cannot enable SPICE if pixman is not available') \
1160 spice = dependency('spice-server', version: '>=0.14.0',
1161 required: get_option('spice'),
1162 method: 'pkg-config')
1164 spice_headers = spice.partial_dependency(compile_args: true, includes: true)
1166 rt = cc.find_library('rt', required: false)
1168 libiscsi = not_found
1169 if not get_option('libiscsi').auto() or have_block
1170 libiscsi = dependency('libiscsi', version: '>=1.9.0',
1171 required: get_option('libiscsi'),
1172 method: 'pkg-config')
1175 if not get_option('zstd').auto() or have_block
1176 zstd = dependency('libzstd', version: '>=1.4.0',
1177 required: get_option('zstd'),
1178 method: 'pkg-config')
1182 have_vhost_user_gpu = have_tools and host_os == 'linux' and pixman.found()
1183 if not get_option('virglrenderer').auto() or have_system or have_vhost_user_gpu
1184 virgl = dependency('virglrenderer',
1185 method: 'pkg-config',
1186 required: get_option('virglrenderer'))
1188 rutabaga = not_found
1189 if not get_option('rutabaga_gfx').auto() or have_system or have_vhost_user_gpu
1190 rutabaga = dependency('rutabaga_gfx_ffi',
1191 method: 'pkg-config',
1192 required: get_option('rutabaga_gfx'))
1195 if not get_option('blkio').auto() or have_block
1196 blkio = dependency('blkio',
1197 method: 'pkg-config',
1198 required: get_option('blkio'))
1201 if not get_option('curl').auto() or have_block
1202 curl = dependency('libcurl', version: '>=7.29.0',
1203 method: 'pkg-config',
1204 required: get_option('curl'))
1207 if host_os == 'linux' and (have_system or have_tools)
1208 libudev = dependency('libudev',
1209 method: 'pkg-config',
1210 required: get_option('libudev'))
1213 mpathlibs = [libudev]
1214 mpathpersist = not_found
1215 if host_os == 'linux' and have_tools and get_option('mpath').allowed()
1216 mpath_test_source = '''
1217 #include <libudev.h>
1218 #include <mpath_persist.h>
1219 unsigned mpath_mx_alloc_len = 1024;
1221 static struct config *multipath_conf;
1222 extern struct udev *udev;
1223 extern struct config *get_multipath_config(void);
1224 extern void put_multipath_config(struct config *conf);
1226 struct config *get_multipath_config(void) { return multipath_conf; }
1227 void put_multipath_config(struct config *conf) { }
1230 multipath_conf = mpath_lib_init();
1233 libmpathpersist = cc.find_library('mpathpersist',
1234 required: get_option('mpath'))
1235 if libmpathpersist.found()
1236 mpathlibs += libmpathpersist
1237 if get_option('prefer_static')
1238 mpathlibs += cc.find_library('devmapper',
1239 required: get_option('mpath'))
1241 mpathlibs += cc.find_library('multipath',
1242 required: get_option('mpath'))
1243 foreach lib: mpathlibs
1249 if mpathlibs.length() == 0
1250 msg = 'Dependencies missing for libmpathpersist'
1251 elif cc.links(mpath_test_source, dependencies: mpathlibs)
1252 mpathpersist = declare_dependency(dependencies: mpathlibs)
1254 msg = 'Cannot detect libmpathpersist API'
1256 if not mpathpersist.found()
1257 if get_option('mpath').enabled()
1260 warning(msg + ', disabling')
1268 if have_system and get_option('curses').allowed()
1270 #if defined(__APPLE__) || defined(__OpenBSD__)
1271 #define _XOPEN_SOURCE_EXTENDED 1
1278 setlocale(LC_ALL, "");
1280 addwstr(L"wide chars\n");
1282 add_wch(WACS_DEGREE);
1286 curses_dep_list = host_os == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
1287 curses = dependency(curses_dep_list,
1289 method: 'pkg-config')
1290 msg = get_option('curses').enabled() ? 'curses library not found' : ''
1291 curses_compile_args = ['-DNCURSES_WIDECHAR=1']
1293 if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
1294 curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses],
1295 version: curses.version())
1297 msg = 'curses package not usable'
1301 if not curses.found()
1302 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
1303 if host_os != 'windows' and not has_curses_h
1304 message('Trying with /usr/include/ncursesw')
1305 curses_compile_args += ['-I/usr/include/ncursesw']
1306 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
1309 curses_libname_list = (host_os == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
1310 foreach curses_libname : curses_libname_list
1311 libcurses = cc.find_library(curses_libname,
1313 if libcurses.found()
1314 if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
1315 curses = declare_dependency(compile_args: curses_compile_args,
1316 dependencies: [libcurses])
1319 msg = 'curses library not usable'
1325 if get_option('iconv').allowed()
1326 foreach link_args : [ ['-liconv'], [] ]
1327 # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
1328 # We need to use libiconv if available because mixing libiconv's headers with
1329 # the system libc does not work.
1330 # However, without adding glib to the dependencies -L/usr/local/lib will not be
1331 # included in the command line and libiconv will not be found.
1335 iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
1336 return conv != (iconv_t) -1;
1337 }''', args: link_args, dependencies: glib)
1338 iconv = declare_dependency(link_args: link_args, dependencies: glib)
1343 if curses.found() and not iconv.found()
1344 if get_option('iconv').enabled()
1345 error('iconv not available')
1347 msg = 'iconv required for curses UI but not available'
1350 if not curses.found() and msg != ''
1351 if get_option('curses').enabled()
1354 warning(msg + ', disabling')
1360 if not get_option('brlapi').auto() or have_system
1361 brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
1362 required: get_option('brlapi'))
1363 if brlapi.found() and not cc.links('''
1366 int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
1368 if get_option('brlapi').enabled()
1369 error('could not link brlapi')
1371 warning('could not link brlapi, disabling')
1377 if not get_option('sdl').auto() or have_system
1378 sdl = dependency('sdl2', required: get_option('sdl'))
1379 sdl_image = not_found
1382 # Some versions of SDL have problems with -Wundef
1383 if not cc.compiles('''
1385 #include <SDL_syswm.h>
1386 int main(int argc, char *argv[]) { return 0; }
1387 ''', dependencies: sdl, args: '-Werror=undef')
1388 sdl = declare_dependency(compile_args: '-Wno-undef',
1390 version: sdl.version())
1392 sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
1393 method: 'pkg-config')
1395 if get_option('sdl_image').enabled()
1396 error('sdl-image required, but SDL was @0@'.format(
1397 get_option('sdl').disabled() ? 'disabled' : 'not found'))
1399 sdl_image = not_found
1403 if not get_option('rbd').auto() or have_block
1404 librados = cc.find_library('rados', required: get_option('rbd'))
1405 librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
1406 required: get_option('rbd'))
1407 if librados.found() and librbd.found()
1410 #include <rbd/librbd.h>
1413 rados_create(&cluster, NULL);
1414 #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
1418 }''', dependencies: [librbd, librados])
1419 rbd = declare_dependency(dependencies: [librbd, librados])
1420 elif get_option('rbd').enabled()
1421 error('librbd >= 1.12.0 required')
1423 warning('librbd >= 1.12.0 not found, disabling')
1428 glusterfs = not_found
1429 glusterfs_ftruncate_has_stat = false
1430 glusterfs_iocb_has_stat = false
1431 if not get_option('glusterfs').auto() or have_block
1432 glusterfs = dependency('glusterfs-api', version: '>=3',
1433 required: get_option('glusterfs'),
1434 method: 'pkg-config')
1435 if glusterfs.found()
1436 glusterfs_ftruncate_has_stat = cc.links('''
1437 #include <glusterfs/api/glfs.h>
1442 /* new glfs_ftruncate() passes two additional args */
1443 return glfs_ftruncate(NULL, 0, NULL, NULL);
1445 ''', dependencies: glusterfs)
1446 glusterfs_iocb_has_stat = cc.links('''
1447 #include <glusterfs/api/glfs.h>
1449 /* new glfs_io_cbk() passes two additional glfs_stat structs */
1451 glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
1457 glfs_io_cbk iocb = &glusterfs_iocb;
1458 iocb(NULL, 0 , NULL, NULL, NULL);
1461 ''', dependencies: glusterfs)
1466 if get_option('hv_balloon').allowed() and have_system
1469 #include <gmodule.h>
1473 tree = g_tree_new((GCompareFunc)strcmp);
1474 (void)g_tree_node_first(tree);
1475 g_tree_destroy(tree);
1478 ''', dependencies: glib)
1481 if get_option('hv_balloon').enabled()
1482 error('could not enable hv-balloon, update your glib')
1484 warning('could not find glib support for hv-balloon, disabling')
1490 if not get_option('libssh').auto() or have_block
1491 libssh = dependency('libssh', version: '>=0.8.7',
1492 method: 'pkg-config',
1493 required: get_option('libssh'))
1496 libbzip2 = not_found
1497 if not get_option('bzip2').auto() or have_block
1498 libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
1499 required: get_option('bzip2'))
1500 if libbzip2.found() and not cc.links('''
1502 int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
1503 libbzip2 = not_found
1504 if get_option('bzip2').enabled()
1505 error('could not link libbzip2')
1507 warning('could not link libbzip2, disabling')
1512 liblzfse = not_found
1513 if not get_option('lzfse').auto() or have_block
1514 liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
1515 required: get_option('lzfse'))
1517 if liblzfse.found() and not cc.links('''
1519 int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
1520 liblzfse = not_found
1521 if get_option('lzfse').enabled()
1522 error('could not link liblzfse')
1524 warning('could not link liblzfse, disabling')
1529 if get_option('oss').allowed() and have_system
1530 if not cc.has_header('sys/soundcard.h')
1532 elif host_os == 'netbsd'
1533 oss = cc.find_library('ossaudio', required: get_option('oss'))
1535 oss = declare_dependency()
1539 if get_option('oss').enabled()
1540 error('OSS not found')
1545 if not get_option('dsound').auto() or (host_os == 'windows' and have_system)
1546 if cc.has_header('dsound.h')
1547 dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
1550 if not dsound.found()
1551 if get_option('dsound').enabled()
1552 error('DirectSound not found')
1557 coreaudio = not_found
1558 if not get_option('coreaudio').auto() or (host_os == 'darwin' and have_system)
1559 coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
1560 required: get_option('coreaudio'))
1564 if not get_option('opengl').auto() or have_system or have_vhost_user_gpu
1565 epoxy = dependency('epoxy', method: 'pkg-config',
1566 required: get_option('opengl'))
1567 if cc.has_header('epoxy/egl.h', dependencies: epoxy)
1569 elif get_option('opengl').enabled()
1570 error('epoxy/egl.h not found')
1574 if (have_system or have_tools) and (virgl.found() or opengl.found())
1575 gbm = dependency('gbm', method: 'pkg-config', required: false)
1577 have_vhost_user_gpu = have_vhost_user_gpu and virgl.found() and opengl.found() and gbm.found()
1580 gnutls_crypto = not_found
1581 if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
1582 # For general TLS support our min gnutls matches
1583 # that implied by our platform support matrix
1585 # For the crypto backends, we look for a newer
1588 # Version 3.6.8 is needed to get XTS
1589 # Version 3.6.13 is needed to get PBKDF
1590 # Version 3.6.14 is needed to get HW accelerated XTS
1592 # If newer enough gnutls isn't available, we can
1593 # still use a different crypto backend to satisfy
1594 # the platform support requirements
1595 gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
1596 method: 'pkg-config',
1598 if gnutls_crypto.found()
1599 gnutls = gnutls_crypto
1601 # Our min version if all we need is TLS
1602 gnutls = dependency('gnutls', version: '>=3.5.18',
1603 method: 'pkg-config',
1604 required: get_option('gnutls'))
1608 # We prefer use of gnutls for crypto, unless the options
1609 # explicitly asked for nettle or gcrypt.
1611 # If gnutls isn't available for crypto, then we'll prefer
1612 # gcrypt over nettle for performance reasons.
1618 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
1619 error('Only one of gcrypt & nettle can be enabled')
1622 # Explicit nettle/gcrypt request, so ignore gnutls for crypto
1623 if get_option('nettle').enabled() or get_option('gcrypt').enabled()
1624 gnutls_crypto = not_found
1627 if not gnutls_crypto.found()
1628 if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
1629 gcrypt = dependency('libgcrypt', version: '>=1.8',
1630 method: 'config-tool',
1631 required: get_option('gcrypt'))
1632 # Debian has removed -lgpg-error from libgcrypt-config
1633 # as it "spreads unnecessary dependencies" which in
1634 # turn breaks static builds...
1635 if gcrypt.found() and get_option('prefer_static')
1636 gcrypt = declare_dependency(dependencies:
1638 cc.find_library('gpg-error', required: true)],
1639 version: gcrypt.version())
1642 if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
1643 nettle = dependency('nettle', version: '>=3.4',
1644 method: 'pkg-config',
1645 required: get_option('nettle'))
1646 if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
1652 capstone = not_found
1653 if not get_option('capstone').auto() or have_system or have_user
1654 capstone = dependency('capstone', version: '>=3.0.5',
1655 method: 'pkg-config',
1656 required: get_option('capstone'))
1658 # Some versions of capstone have broken pkg-config file
1659 # that reports a wrong -I path, causing the #include to
1660 # fail later. If the system has such a broken version
1662 if capstone.found() and not cc.compiles('#include <capstone.h>',
1663 dependencies: [capstone])
1664 capstone = not_found
1665 if get_option('capstone').enabled()
1666 error('capstone requested, but it does not appear to work')
1671 gmp = dependency('gmp', required: false, method: 'pkg-config')
1672 if nettle.found() and gmp.found()
1673 hogweed = dependency('hogweed', version: '>=3.4',
1674 method: 'pkg-config',
1675 required: get_option('nettle'))
1682 have_gtk_clipboard = get_option('gtk_clipboard').enabled()
1684 if get_option('gtk') \
1685 .disable_auto_if(not have_system) \
1686 .require(pixman.found(),
1687 error_message: 'cannot enable GTK if pixman is not available') \
1689 gtk = dependency('gtk+-3.0', version: '>=3.22.0',
1690 method: 'pkg-config',
1691 required: get_option('gtk'))
1693 gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
1694 method: 'pkg-config',
1696 gtk = declare_dependency(dependencies: [gtk, gtkx11],
1697 version: gtk.version())
1699 if not get_option('vte').auto() or have_system
1700 vte = dependency('vte-2.91',
1701 method: 'pkg-config',
1702 required: get_option('vte'))
1704 elif have_gtk_clipboard
1705 error('GTK clipboard requested, but GTK not found')
1711 x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found())
1714 if get_option('png').allowed() and have_system
1715 png = dependency('libpng', version: '>=1.6.34', required: get_option('png'),
1716 method: 'pkg-config')
1721 if get_option('vnc') \
1722 .disable_auto_if(not have_system) \
1723 .require(pixman.found(),
1724 error_message: 'cannot enable VNC if pixman is not available') \
1726 vnc = declare_dependency() # dummy dependency
1727 jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
1728 method: 'pkg-config')
1729 sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
1730 required: get_option('vnc_sasl'))
1732 sasl = declare_dependency(dependencies: sasl,
1733 compile_args: '-DSTRUCT_IOVEC_DEFINED')
1738 if not get_option('auth_pam').auto() or have_system
1739 pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
1740 required: get_option('auth_pam'))
1742 if pam.found() and not cc.links('''
1744 #include <security/pam_appl.h>
1746 const char *service_name = "qemu";
1747 const char *user = "frank";
1748 const struct pam_conv pam_conv = { 0 };
1749 pam_handle_t *pamh = NULL;
1750 pam_start(service_name, user, &pam_conv, &pamh);
1752 }''', dependencies: pam)
1754 if get_option('auth_pam').enabled()
1755 error('could not link libpam')
1757 warning('could not link libpam, disabling')
1762 if not get_option('snappy').auto() or have_system
1763 snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
1764 required: get_option('snappy'))
1766 if snappy.found() and not cc.links('''
1767 #include <snappy-c.h>
1768 int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
1770 if get_option('snappy').enabled()
1771 error('could not link libsnappy')
1773 warning('could not link libsnappy, disabling')
1778 if not get_option('lzo').auto() or have_system
1779 lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1780 required: get_option('lzo'))
1782 if lzo.found() and not cc.links('''
1783 #include <lzo/lzo1x.h>
1784 int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1786 if get_option('lzo').enabled()
1787 error('could not link liblzo2')
1789 warning('could not link liblzo2, disabling')
1794 if not get_option('numa').auto() or have_system or have_tools
1795 numa = cc.find_library('numa', has_headers: ['numa.h'],
1796 required: get_option('numa'))
1798 if numa.found() and not cc.links('''
1800 int main(void) { return numa_available(); }
1801 ''', dependencies: numa)
1803 if get_option('numa').enabled()
1804 error('could not link numa')
1806 warning('could not link numa, disabling')
1811 if not get_option('rdma').auto() or have_system
1812 libumad = cc.find_library('ibumad', required: get_option('rdma'))
1813 rdma_libs = [cc.find_library('rdmacm', has_headers: ['rdma/rdma_cma.h'],
1814 required: get_option('rdma')),
1815 cc.find_library('ibverbs', required: get_option('rdma')),
1817 rdma = declare_dependency(dependencies: rdma_libs)
1818 foreach lib: rdma_libs
1826 if not get_option('smartcard').auto() or have_system
1827 cacard = dependency('libcacard', required: get_option('smartcard'),
1828 version: '>=2.5.1', method: 'pkg-config')
1831 if not get_option('u2f').auto() or have_system
1832 u2f = dependency('u2f-emu', required: get_option('u2f'),
1833 method: 'pkg-config')
1836 if not get_option('canokey').auto() or have_system
1837 canokey = dependency('canokey-qemu', required: get_option('canokey'),
1838 method: 'pkg-config')
1840 usbredir = not_found
1841 if not get_option('usb_redir').auto() or have_system
1842 usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1843 version: '>=0.6', method: 'pkg-config')
1846 if not get_option('libusb').auto() or have_system
1847 libusb = dependency('libusb-1.0', required: get_option('libusb'),
1848 version: '>=1.0.13', method: 'pkg-config')
1852 if not get_option('libpmem').auto() or have_system
1853 libpmem = dependency('libpmem', required: get_option('libpmem'),
1854 method: 'pkg-config')
1856 libdaxctl = not_found
1857 if not get_option('libdaxctl').auto() or have_system
1858 libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1859 version: '>=57', method: 'pkg-config')
1863 tasn1 = dependency('libtasn1',
1864 method: 'pkg-config')
1866 keyutils = not_found
1867 if not get_option('libkeyutils').auto() or have_block
1868 keyutils = dependency('libkeyutils', required: get_option('libkeyutils'),
1869 method: 'pkg-config')
1872 has_gettid = cc.has_function('gettid')
1875 selinux = dependency('libselinux',
1876 required: get_option('selinux'),
1877 method: 'pkg-config')
1882 if get_option('malloc') == 'system'
1884 get_option('malloc_trim').allowed() and \
1885 cc.has_function('malloc_trim', prefix: '#include <malloc.h>')
1887 has_malloc_trim = false
1888 malloc = cc.find_library(get_option('malloc'), required: true)
1890 if not has_malloc_trim and get_option('malloc_trim').enabled()
1891 if get_option('malloc') == 'system'
1892 error('malloc_trim not available on this platform.')
1894 error('malloc_trim not available with non-libc memory allocator')
1898 gnu_source_prefix = '''
1904 # Check whether the glibc provides STATX_BASIC_STATS
1906 has_statx = cc.has_header_symbol('sys/stat.h', 'STATX_BASIC_STATS', prefix: gnu_source_prefix)
1908 # Check whether statx() provides mount ID information
1910 has_statx_mnt_id = cc.has_header_symbol('sys/stat.h', 'STATX_MNT_ID', prefix: gnu_source_prefix)
1912 have_vhost_user_blk_server = get_option('vhost_user_blk_server') \
1913 .require(host_os == 'linux',
1914 error_message: 'vhost_user_blk_server requires linux') \
1915 .require(have_vhost_user,
1916 error_message: 'vhost_user_blk_server requires vhost-user support') \
1917 .disable_auto_if(not have_tools and not have_system) \
1920 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1921 error('Cannot enable fuse-lseek while fuse is disabled')
1924 fuse = dependency('fuse3', required: get_option('fuse'),
1925 version: '>=3.1', method: 'pkg-config')
1927 fuse_lseek = not_found
1928 if get_option('fuse_lseek').allowed()
1929 if fuse.version().version_compare('>=3.8')
1931 fuse_lseek = declare_dependency()
1932 elif get_option('fuse_lseek').enabled()
1934 error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1936 error('fuse-lseek requires libfuse, which was not found')
1941 have_libvduse = (host_os == 'linux')
1942 if get_option('libvduse').enabled()
1943 if host_os != 'linux'
1944 error('libvduse requires linux')
1946 elif get_option('libvduse').disabled()
1947 have_libvduse = false
1950 have_vduse_blk_export = (have_libvduse and host_os == 'linux')
1951 if get_option('vduse_blk_export').enabled()
1952 if host_os != 'linux'
1953 error('vduse_blk_export requires linux')
1954 elif not have_libvduse
1955 error('vduse_blk_export requires libvduse support')
1957 elif get_option('vduse_blk_export').disabled()
1958 have_vduse_blk_export = false
1962 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1963 if libbpf.found() and not cc.links('''
1964 #include <bpf/libbpf.h>
1967 bpf_object__destroy_skeleton(NULL);
1969 }''', dependencies: libbpf)
1971 if get_option('bpf').enabled()
1972 error('libbpf skeleton test failed')
1974 warning('libbpf skeleton test failed, disabling')
1980 if not get_option('af_xdp').auto() or have_system
1981 libxdp = dependency('libxdp', required: get_option('af_xdp'),
1982 version: '>=1.4.0', method: 'pkg-config')
1987 if not get_option('libdw').auto() or \
1988 (not get_option('prefer_static') and (have_system or have_user))
1989 libdw = dependency('libdw',
1990 method: 'pkg-config',
1991 required: get_option('libdw'))
1998 config_host_data = configuration_data()
2000 audio_drivers_selected = []
2002 audio_drivers_available = {
2003 'alsa': alsa.found(),
2004 'coreaudio': coreaudio.found(),
2005 'dsound': dsound.found(),
2006 'jack': jack.found(),
2008 'pa': pulse.found(),
2009 'pipewire': pipewire.found(),
2011 'sndio': sndio.found(),
2013 foreach k, v: audio_drivers_available
2014 config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
2017 # Default to native drivers first, OSS second, SDL third
2018 audio_drivers_priority = \
2019 [ 'pa', 'coreaudio', 'dsound', 'sndio', 'oss' ] + \
2020 (host_os == 'linux' ? [] : [ 'sdl' ])
2021 audio_drivers_default = []
2022 foreach k: audio_drivers_priority
2023 if audio_drivers_available[k]
2024 audio_drivers_default += k
2028 foreach k: get_option('audio_drv_list')
2030 audio_drivers_selected += audio_drivers_default
2031 elif not audio_drivers_available[k]
2032 error('Audio driver "@0@" not available.'.format(k))
2034 audio_drivers_selected += k
2038 config_host_data.set('CONFIG_AUDIO_DRIVERS',
2039 '"' + '", "'.join(audio_drivers_selected) + '", ')
2041 have_host_block_device = (host_os != 'darwin' or
2042 cc.has_header('IOKit/storage/IOMedia.h'))
2044 dbus_display = get_option('dbus_display') \
2045 .require(gio.version().version_compare('>=2.64'),
2046 error_message: '-display dbus requires glib>=2.64') \
2047 .require(gdbus_codegen.found(),
2048 error_message: gdbus_codegen_error.format('-display dbus')) \
2051 have_virtfs = get_option('virtfs') \
2052 .require(host_os == 'linux' or host_os == 'darwin',
2053 error_message: 'virtio-9p (virtfs) requires Linux or macOS') \
2054 .require(host_os == 'linux' or cc.has_function('pthread_fchdir_np'),
2055 error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \
2056 .require(host_os == 'darwin' or libattr.found(),
2057 error_message: 'virtio-9p (virtfs) on Linux requires libattr-devel') \
2058 .disable_auto_if(not have_tools and not have_system) \
2061 have_virtfs_proxy_helper = get_option('virtfs_proxy_helper') \
2062 .require(host_os != 'darwin', error_message: 'the virtfs proxy helper is incompatible with macOS') \
2063 .require(have_virtfs, error_message: 'the virtfs proxy helper requires that virtfs is enabled') \
2064 .disable_auto_if(not have_tools) \
2065 .require(libcap_ng.found(), error_message: 'the virtfs proxy helper requires libcap-ng') \
2068 if get_option('block_drv_ro_whitelist') == ''
2069 config_host_data.set('CONFIG_BDRV_RO_WHITELIST', '')
2071 config_host_data.set('CONFIG_BDRV_RO_WHITELIST',
2072 '"' + get_option('block_drv_ro_whitelist').replace(',', '", "') + '", ')
2074 if get_option('block_drv_rw_whitelist') == ''
2075 config_host_data.set('CONFIG_BDRV_RW_WHITELIST', '')
2077 config_host_data.set('CONFIG_BDRV_RW_WHITELIST',
2078 '"' + get_option('block_drv_rw_whitelist').replace(',', '", "') + '", ')
2081 foreach k : get_option('trace_backends')
2082 config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
2084 config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
2085 config_host_data.set_quoted('CONFIG_TLS_PRIORITY', get_option('tls_priority'))
2087 config_host_data.set_quoted('CONFIG_IASL', iasl.full_path())
2089 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
2090 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
2091 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
2092 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
2093 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
2095 qemu_firmwarepath = ''
2096 foreach k : get_option('qemu_firmwarepath')
2097 qemu_firmwarepath += '"' + get_option('prefix') / k + '", '
2099 config_host_data.set('CONFIG_QEMU_FIRMWAREPATH', qemu_firmwarepath)
2101 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
2102 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
2103 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
2104 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
2105 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
2106 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
2109 config_host_data.set('CONFIG_STAMP', run_command(
2110 meson.current_source_dir() / 'scripts/qemu-stamp.py',
2111 meson.project_version(), get_option('pkgversion'), '--',
2112 meson.current_source_dir() / 'configure',
2113 capture: true, check: true).stdout().strip())
2116 have_slirp_smbd = get_option('slirp_smbd') \
2117 .require(host_os != 'windows', error_message: 'Host smbd not supported on this platform.') \
2120 smbd_path = get_option('smbd')
2122 smbd_path = (host_os == 'sunos' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd')
2124 config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path)
2127 config_host_data.set('HOST_' + host_arch.to_upper(), 1)
2129 kvm_targets_c = '""'
2130 if get_option('kvm').allowed() and host_os == 'linux'
2131 kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"'
2133 config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c)
2135 if get_option('module_upgrades') and not enable_modules
2136 error('Cannot enable module-upgrades as modules are not enabled')
2138 config_host_data.set('CONFIG_MODULE_UPGRADES', get_option('module_upgrades'))
2140 config_host_data.set('CONFIG_ATTR', libattr.found())
2141 config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools'))
2142 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
2143 config_host_data.set('CONFIG_BSD', host_os in bsd_oses)
2144 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2145 config_host_data.set('CONFIG_COCOA', cocoa.found())
2146 config_host_data.set('CONFIG_DARWIN', host_os == 'darwin')
2147 config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
2148 config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
2149 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
2150 config_host_data.set('CONFIG_LINUX', host_os == 'linux')
2151 config_host_data.set('CONFIG_POSIX', host_os != 'windows')
2152 config_host_data.set('CONFIG_WIN32', host_os == 'windows')
2153 config_host_data.set('CONFIG_LZO', lzo.found())
2154 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
2155 config_host_data.set('CONFIG_BLKIO', blkio.found())
2157 config_host_data.set('CONFIG_BLKIO_VHOST_VDPA_FD',
2158 blkio.version().version_compare('>=1.3.0'))
2160 config_host_data.set('CONFIG_CURL', curl.found())
2161 config_host_data.set('CONFIG_CURSES', curses.found())
2162 config_host_data.set('CONFIG_GBM', gbm.found())
2163 config_host_data.set('CONFIG_GIO', gio.found())
2164 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
2165 if glusterfs.found()
2166 config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
2167 config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
2168 config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
2169 config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
2170 config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
2171 config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
2173 config_host_data.set('CONFIG_GTK', gtk.found())
2174 config_host_data.set('CONFIG_VTE', vte.found())
2175 config_host_data.set('CONFIG_GTK_CLIPBOARD', have_gtk_clipboard)
2176 config_host_data.set('CONFIG_HEXAGON_IDEF_PARSER', get_option('hexagon_idef_parser'))
2177 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
2178 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
2179 config_host_data.set('CONFIG_EBPF', libbpf.found())
2180 config_host_data.set('CONFIG_AF_XDP', libxdp.found())
2181 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
2182 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
2183 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
2184 config_host_data.set('CONFIG_LIBSSH', libssh.found())
2185 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
2186 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
2187 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
2188 config_host_data.set('CONFIG_MODULES', enable_modules)
2189 config_host_data.set('CONFIG_NUMA', numa.found())
2191 config_host_data.set('HAVE_NUMA_HAS_PREFERRED_MANY',
2192 cc.has_function('numa_has_preferred_many',
2193 dependencies: numa))
2195 config_host_data.set('CONFIG_OPENGL', opengl.found())
2196 config_host_data.set('CONFIG_PLUGIN', get_option('plugins'))
2197 config_host_data.set('CONFIG_RBD', rbd.found())
2198 config_host_data.set('CONFIG_RDMA', rdma.found())
2199 config_host_data.set('CONFIG_RELOCATABLE', get_option('relocatable'))
2200 config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack'))
2201 config_host_data.set('CONFIG_SDL', sdl.found())
2202 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
2203 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
2205 config_host_data.set('CONFIG_SECCOMP_SYSRAWRC', seccomp_has_sysrawrc)
2207 config_host_data.set('CONFIG_PIXMAN', pixman.found())
2208 config_host_data.set('CONFIG_SLIRP', slirp.found())
2209 config_host_data.set('CONFIG_SNAPPY', snappy.found())
2210 config_host_data.set('CONFIG_SOLARIS', host_os == 'sunos')
2211 if get_option('tcg').allowed()
2212 config_host_data.set('CONFIG_TCG', 1)
2213 config_host_data.set('CONFIG_TCG_INTERPRETER', tcg_arch == 'tci')
2215 config_host_data.set('CONFIG_TPM', have_tpm)
2216 config_host_data.set('CONFIG_TSAN', get_option('tsan'))
2217 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
2218 config_host_data.set('CONFIG_VDE', vde.found())
2219 config_host_data.set('CONFIG_VHOST', have_vhost)
2220 config_host_data.set('CONFIG_VHOST_NET', have_vhost_net)
2221 config_host_data.set('CONFIG_VHOST_NET_USER', have_vhost_net_user)
2222 config_host_data.set('CONFIG_VHOST_NET_VDPA', have_vhost_net_vdpa)
2223 config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel)
2224 config_host_data.set('CONFIG_VHOST_USER', have_vhost_user)
2225 config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto)
2226 config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa)
2227 config_host_data.set('CONFIG_VMNET', vmnet.found())
2228 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
2229 config_host_data.set('CONFIG_VDUSE_BLK_EXPORT', have_vduse_blk_export)
2230 config_host_data.set('CONFIG_PNG', png.found())
2231 config_host_data.set('CONFIG_VNC', vnc.found())
2232 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
2233 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
2235 config_host_data.set('HAVE_VIRGL_D3D_INFO_EXT',
2236 cc.has_member('struct virgl_renderer_resource_info_ext', 'd3d_tex2d',
2237 prefix: '#include <virglrenderer.h>',
2238 dependencies: virgl))
2240 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
2241 config_host_data.set('CONFIG_VTE', vte.found())
2242 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
2243 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
2244 config_host_data.set('CONFIG_GETTID', has_gettid)
2245 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
2246 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
2247 config_host_data.set('CONFIG_TASN1', tasn1.found())
2248 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
2249 config_host_data.set('CONFIG_NETTLE', nettle.found())
2250 config_host_data.set('CONFIG_HOGWEED', hogweed.found())
2251 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
2252 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
2253 config_host_data.set('CONFIG_STATX', has_statx)
2254 config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id)
2255 config_host_data.set('CONFIG_ZSTD', zstd.found())
2256 config_host_data.set('CONFIG_FUSE', fuse.found())
2257 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
2258 config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
2259 if spice_protocol.found()
2260 config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
2261 config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
2262 config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
2264 config_host_data.set('CONFIG_SPICE', spice.found())
2265 config_host_data.set('CONFIG_X11', x11.found())
2266 config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
2267 config_host_data.set('CONFIG_CFI', get_option('cfi'))
2268 config_host_data.set('CONFIG_SELINUX', selinux.found())
2269 config_host_data.set('CONFIG_XEN_BACKEND', xen.found())
2270 config_host_data.set('CONFIG_LIBDW', libdw.found())
2272 # protect from xen.version() having less than three components
2273 xen_version = xen.version().split('.') + ['0', '0']
2274 xen_ctrl_version = xen_version[0] + \
2275 ('0' + xen_version[1]).substring(-2) + \
2276 ('0' + xen_version[2]).substring(-2)
2277 config_host_data.set('CONFIG_XEN_CTRL_INTERFACE_VERSION', xen_ctrl_version)
2279 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
2280 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
2281 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
2282 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
2284 config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
2285 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
2287 have_coroutine_pool = get_option('coroutine_pool')
2288 if get_option('debug_stack_usage') and have_coroutine_pool
2289 message('Disabling coroutine pool to measure stack usage')
2290 have_coroutine_pool = false
2292 config_host_data.set('CONFIG_COROUTINE_POOL', have_coroutine_pool)
2293 config_host_data.set('CONFIG_DEBUG_GRAPH_LOCK', get_option('debug_graph_lock'))
2294 config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
2295 config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
2296 config_host_data.set('CONFIG_DEBUG_TCG', get_option('debug_tcg'))
2297 config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
2298 config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
2299 config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed())
2302 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
2303 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
2304 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
2305 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
2306 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
2307 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
2308 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
2309 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
2310 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
2311 if host_os == 'windows'
2312 config_host_data.set('HAVE_AFUNIX_H', cc.has_header('afunix.h'))
2316 config_host_data.set('CONFIG_CLOSE_RANGE', cc.has_function('close_range'))
2317 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
2318 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
2319 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
2320 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
2321 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
2322 config_host_data.set('CONFIG_GETCPU', cc.has_function('getcpu', prefix: gnu_source_prefix))
2323 config_host_data.set('CONFIG_SCHED_GETCPU', cc.has_function('sched_getcpu', prefix: '#include <sched.h>'))
2324 # Note that we need to specify prefix: here to avoid incorrectly
2325 # thinking that Windows has posix_memalign()
2326 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
2327 config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
2328 config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
2329 config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
2330 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
2331 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
2332 config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
2333 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
2334 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
2335 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
2336 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
2337 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
2338 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
2339 config_host_data.set('HAVE_GETIFADDRS', cc.has_function('getifaddrs'))
2340 config_host_data.set('HAVE_GLIB_WITH_SLICE_ALLOCATOR', glib_has_gslice)
2341 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
2342 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
2343 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
2345 config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS',
2346 cc.has_function('rbd_namespace_exists',
2348 prefix: '#include <rbd/librbd.h>'))
2351 config_host_data.set('HAVE_IBV_ADVISE_MR',
2352 cc.has_function('ibv_advise_mr',
2354 prefix: '#include <infiniband/verbs.h>'))
2357 have_asan_fiber = false
2358 if get_option('sanitizers') and \
2359 not cc.has_function('__sanitizer_start_switch_fiber',
2360 args: '-fsanitize=address',
2361 prefix: '#include <sanitizer/asan_interface.h>')
2362 warning('Missing ASAN due to missing fiber annotation interface')
2363 warning('Without code annotation, the report may be inferior.')
2365 have_asan_fiber = true
2367 config_host_data.set('CONFIG_ASAN_IFACE_FIBER', have_asan_fiber)
2370 config_host_data.set('CONFIG_BLKZONED',
2371 cc.has_header_symbol('linux/blkzoned.h', 'BLKOPENZONE'))
2372 config_host_data.set('CONFIG_EPOLL_CREATE1',
2373 cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
2374 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
2375 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
2376 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
2377 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
2378 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
2379 config_host_data.set('CONFIG_FIEMAP',
2380 cc.has_header('linux/fiemap.h') and
2381 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
2382 config_host_data.set('CONFIG_GETRANDOM',
2383 cc.has_function('getrandom') and
2384 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
2385 config_host_data.set('CONFIG_INOTIFY',
2386 cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
2387 config_host_data.set('CONFIG_INOTIFY1',
2388 cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
2389 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
2390 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
2391 config_host_data.set('CONFIG_RTNETLINK',
2392 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
2393 config_host_data.set('CONFIG_SYSMACROS',
2394 cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
2395 config_host_data.set('HAVE_OPTRESET',
2396 cc.has_header_symbol('getopt.h', 'optreset'))
2397 config_host_data.set('HAVE_IPPROTO_MPTCP',
2398 cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
2401 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
2402 cc.has_member('struct sigevent', 'sigev_notify_thread_id',
2403 prefix: '#include <signal.h>'))
2404 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
2405 cc.has_member('struct stat', 'st_atim',
2406 prefix: '#include <sys/stat.h>'))
2407 config_host_data.set('HAVE_BLK_ZONE_REP_CAPACITY',
2408 cc.has_member('struct blk_zone', 'capacity',
2409 prefix: '#include <linux/blkzoned.h>'))
2412 config_host_data.set('CONFIG_IOVEC',
2413 cc.has_type('struct iovec',
2414 prefix: '#include <sys/uio.h>'))
2415 config_host_data.set('HAVE_UTMPX',
2416 cc.has_type('struct utmpx',
2417 prefix: '#include <utmpx.h>'))
2419 config_host_data.set('CONFIG_EVENTFD', cc.links('''
2420 #include <sys/eventfd.h>
2421 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
2422 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
2425 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
2426 return fdatasync(0);
2428 #error Not supported
2432 has_madvise = cc.links(gnu_source_prefix + '''
2433 #include <sys/types.h>
2434 #include <sys/mman.h>
2436 int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''')
2437 missing_madvise_proto = false
2439 # Some platforms (illumos and Solaris before Solaris 11) provide madvise()
2440 # but forget to prototype it. In this case, has_madvise will be true (the
2441 # test program links despite a compile warning). To detect the
2442 # missing-prototype case, we try again with a definitely-bogus prototype.
2443 # This will only compile if the system headers don't provide the prototype;
2444 # otherwise the conflicting prototypes will cause a compiler error.
2445 missing_madvise_proto = cc.links(gnu_source_prefix + '''
2446 #include <sys/types.h>
2447 #include <sys/mman.h>
2449 extern int madvise(int);
2450 int main(void) { return madvise(0); }''')
2452 config_host_data.set('CONFIG_MADVISE', has_madvise)
2453 config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
2455 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
2456 #include <sys/mman.h>
2457 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
2458 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
2460 #if !defined(AT_EMPTY_PATH)
2461 # error missing definition
2463 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
2465 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
2466 #include <sys/mman.h>
2468 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
2470 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
2471 #include <pthread.h>
2473 static void *f(void *p) { return NULL; }
2477 pthread_create(&thread, 0, f, 0);
2478 pthread_setname_np(thread, "QEMU");
2480 }''', dependencies: threads))
2481 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
2482 #include <pthread.h>
2484 static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
2488 pthread_create(&thread, 0, f, 0);
2490 }''', dependencies: threads))
2491 config_host_data.set('CONFIG_PTHREAD_SET_NAME_NP', cc.links(gnu_source_prefix + '''
2492 #include <pthread.h>
2493 #include <pthread_np.h>
2495 static void *f(void *p) { return NULL; }
2499 pthread_create(&thread, 0, f, 0);
2500 pthread_set_name_np(thread, "QEMU");
2502 }''', dependencies: threads))
2503 config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
2504 #include <pthread.h>
2509 pthread_condattr_t attr
2510 pthread_condattr_init(&attr);
2511 pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
2513 }''', dependencies: threads))
2514 config_host_data.set('CONFIG_PTHREAD_AFFINITY_NP', cc.links(gnu_source_prefix + '''
2515 #include <pthread.h>
2517 static void *f(void *p) { return NULL; }
2520 int setsize = CPU_ALLOC_SIZE(64);
2523 pthread_create(&thread, 0, f, 0);
2524 cpuset = CPU_ALLOC(64);
2525 CPU_ZERO_S(setsize, cpuset);
2526 pthread_setaffinity_np(thread, setsize, cpuset);
2527 pthread_getaffinity_np(thread, setsize, cpuset);
2530 }''', dependencies: threads))
2531 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
2532 #include <sys/signalfd.h>
2534 int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
2535 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
2543 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
2544 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
2548 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
2549 #include <sys/mman.h>
2551 return mlockall(MCL_FUTURE);
2555 if get_option('l2tpv3').allowed() and have_system
2556 have_l2tpv3 = cc.has_type('struct mmsghdr',
2557 prefix: gnu_source_prefix + '''
2558 #include <sys/socket.h>
2559 #include <linux/ip.h>''')
2561 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
2564 if get_option('netmap').allowed() and have_system
2565 have_netmap = cc.compiles('''
2566 #include <inttypes.h>
2568 #include <net/netmap.h>
2569 #include <net/netmap_user.h>
2570 #if (NETMAP_API < 11) || (NETMAP_API > 15)
2573 int main(void) { return 0; }''')
2574 if not have_netmap and get_option('netmap').enabled()
2575 error('Netmap headers not available')
2578 config_host_data.set('CONFIG_NETMAP', have_netmap)
2580 # Work around a system header bug with some kernel/XFS header
2581 # versions where they both try to define 'struct fsxattr':
2582 # xfs headers will not try to redefine structs from linux headers
2583 # if this macro is set.
2584 config_host_data.set('HAVE_FSXATTR', cc.links('''
2585 #include <linux/fs.h>
2591 # Some versions of Mac OS X incorrectly define SIZE_MAX
2592 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
2596 return printf("%zu", SIZE_MAX);
2597 }''', args: ['-Werror']))
2599 # See if 64-bit atomic operations are supported.
2600 # Note that without __atomic builtins, we can only
2601 # assume atomic loads/stores max at pointer size.
2602 config_host_data.set('CONFIG_ATOMIC64', cc.links('''
2606 uint64_t x = 0, y = 0;
2607 y = __atomic_load_n(&x, __ATOMIC_RELAXED);
2608 __atomic_store_n(&x, y, __ATOMIC_RELAXED);
2609 __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2610 __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
2611 __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
2615 has_int128_type = cc.compiles('''
2618 int main(void) { b = a; }''')
2619 config_host_data.set('CONFIG_INT128_TYPE', has_int128_type)
2621 has_int128 = has_int128_type and cc.links('''
2630 config_host_data.set('CONFIG_INT128', has_int128)
2633 # "do we have 128-bit atomics which are handled inline and specifically not
2634 # via libatomic". The reason we can't use libatomic is documented in the
2635 # comment starting "GCC is a house divided" in include/qemu/atomic128.h.
2636 # We only care about these operations on 16-byte aligned pointers, so
2637 # force 16-byte alignment of the pointer, which may be greater than
2638 # __alignof(unsigned __int128) for the host.
2639 atomic_test_128 = '''
2640 int main(int ac, char **av) {
2641 __uint128_t *p = __builtin_assume_aligned(av[ac - 1], 16);
2642 p[1] = __atomic_load_n(&p[0], __ATOMIC_RELAXED);
2643 __atomic_store_n(&p[2], p[3], __ATOMIC_RELAXED);
2644 __atomic_compare_exchange_n(&p[4], &p[5], p[6], 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2647 has_atomic128 = cc.links(atomic_test_128)
2649 config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
2651 if not has_atomic128
2652 # Even with __builtin_assume_aligned, the above test may have failed
2653 # without optimization enabled. Try again with optimizations locally
2654 # enabled for the function. See
2655 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107389
2656 has_atomic128_opt = cc.links('__attribute__((optimize("O1")))' + atomic_test_128)
2657 config_host_data.set('CONFIG_ATOMIC128_OPT', has_atomic128_opt)
2659 if not has_atomic128_opt
2660 config_host_data.set('CONFIG_CMPXCHG128', cc.links('''
2663 __uint128_t x = 0, y = 0;
2664 __sync_val_compare_and_swap_16(&x, y, x);
2672 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
2673 #include <sys/auxv.h>
2675 return getauxval(AT_HWCAP) == 0;
2678 config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles('''
2679 #include <linux/usbdevice_fs.h>
2681 #ifndef USBDEVFS_GET_CAPABILITIES
2682 #error "USBDEVFS_GET_CAPABILITIES undefined"
2685 #ifndef USBDEVFS_DISCONNECT_CLAIM
2686 #error "USBDEVFS_DISCONNECT_CLAIM undefined"
2689 int main(void) { return 0; }'''))
2691 have_keyring = get_option('keyring') \
2692 .require(host_os == 'linux', error_message: 'keyring is only available on Linux') \
2693 .require(cc.compiles('''
2695 #include <asm/unistd.h>
2696 #include <linux/keyctl.h>
2697 #include <sys/syscall.h>
2700 return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0);
2701 }'''), error_message: 'keyctl syscall not available on this system').allowed()
2702 config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring)
2704 have_cpuid_h = cc.links('''
2707 unsigned a, b, c, d;
2708 unsigned max = __get_cpuid_max(0, 0);
2711 __cpuid(1, a, b, c, d);
2715 __cpuid_count(7, 0, a, b, c, d);
2720 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
2722 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
2723 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
2724 .require(cc.links('''
2726 #include <immintrin.h>
2727 static int __attribute__((target("avx2"))) bar(void *a) {
2728 __m256i x = *(__m256i *)a;
2729 return _mm256_testz_si256(x, x);
2731 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2732 '''), error_message: 'AVX2 not available').allowed())
2734 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
2735 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
2736 .require(cc.links('''
2738 #include <immintrin.h>
2739 static int __attribute__((target("avx512f"))) bar(void *a) {
2740 __m512i x = *(__m512i *)a;
2741 return _mm512_test_epi64_mask(x, x);
2743 int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2744 '''), error_message: 'AVX512F not available').allowed())
2746 config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \
2747 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \
2748 .require(cc.links('''
2750 #include <immintrin.h>
2751 static int __attribute__((target("avx512bw"))) bar(void *a) {
2753 __m512i res= _mm512_abs_epi8(*x);
2756 int main(int argc, char *argv[]) { return bar(argv[0]); }
2757 '''), error_message: 'AVX512BW not available').allowed())
2759 # For both AArch64 and AArch32, detect if builtins are available.
2760 config_host_data.set('CONFIG_ARM_AES_BUILTIN', cc.compiles('''
2761 #include <arm_neon.h>
2762 #ifndef __ARM_FEATURE_AES
2763 __attribute__((target("+crypto")))
2765 void foo(uint8x16_t *p) { *p = vaesmcq_u8(*p); }
2768 have_pvrdma = get_option('pvrdma') \
2769 .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \
2770 .require(cc.compiles(gnu_source_prefix + '''
2771 #include <sys/mman.h>
2776 addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED);
2779 }'''), error_message: 'PVRDMA requires mremap').allowed()
2782 config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links('''
2783 #include <infiniband/verbs.h>
2787 struct ibv_pd *pd = NULL;
2793 mr = ibv_reg_mr_iova(pd, addr, length, iova, access);
2799 if get_option('membarrier').disabled()
2800 have_membarrier = false
2801 elif host_os == 'windows'
2802 have_membarrier = true
2803 elif host_os == 'linux'
2804 have_membarrier = cc.compiles('''
2805 #include <linux/membarrier.h>
2806 #include <sys/syscall.h>
2810 syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
2811 syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
2815 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
2816 .require(have_membarrier, error_message: 'membarrier system call not available') \
2819 have_afalg = get_option('crypto_afalg') \
2820 .require(cc.compiles(gnu_source_prefix + '''
2822 #include <sys/types.h>
2823 #include <sys/socket.h>
2824 #include <linux/if_alg.h>
2827 sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
2830 '''), error_message: 'AF_ALG requested but could not be detected').allowed()
2831 config_host_data.set('CONFIG_AF_ALG', have_afalg)
2833 config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol(
2834 'linux/vm_sockets.h', 'AF_VSOCK',
2835 prefix: '#include <sys/socket.h>',
2839 have_vss_sdk = false # old xp/2003 SDK
2840 if host_os == 'windows' and 'cpp' in all_languages
2841 have_vss = cxx.compiles('''
2842 #define __MIDL_user_allocate_free_DEFINED__
2844 int main(void) { return VSS_CTX_BACKUP; }''')
2845 have_vss_sdk = cxx.has_header('vscoordint.h')
2847 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
2849 # Older versions of MinGW do not import _lock_file and _unlock_file properly.
2850 # This was fixed for v6.0.0 with commit b48e3ac8969d.
2851 if host_os == 'windows'
2852 config_host_data.set('HAVE__LOCK_FILE', cc.links('''
2858 }''', name: '_lock_file and _unlock_file'))
2861 if host_os == 'windows'
2862 mingw_has_setjmp_longjmp = cc.links('''
2866 * These functions are not available in setjmp header, but may be
2867 * available at link time, from libmingwex.a.
2869 extern int __mingw_setjmp(jmp_buf);
2870 extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int);
2872 __mingw_setjmp(env);
2873 __mingw_longjmp(env, 0);
2875 ''', name: 'mingw setjmp and longjmp')
2877 if cpu == 'aarch64' and not mingw_has_setjmp_longjmp
2878 error('mingw must provide setjmp/longjmp for windows-arm64')
2882 ########################
2883 # Target configuration #
2884 ########################
2886 minikconf = find_program('scripts/minikconf.py')
2888 config_all_accel = {}
2889 config_all_devices = {}
2890 config_devices_mak_list = []
2891 config_devices_h = {}
2892 config_target_h = {}
2893 config_target_mak = {}
2896 'alpha' : ['CONFIG_ALPHA_DIS'],
2897 'avr' : ['CONFIG_AVR_DIS'],
2898 'cris' : ['CONFIG_CRIS_DIS'],
2899 'hexagon' : ['CONFIG_HEXAGON_DIS'],
2900 'hppa' : ['CONFIG_HPPA_DIS'],
2901 'i386' : ['CONFIG_I386_DIS'],
2902 'x86_64' : ['CONFIG_I386_DIS'],
2903 'm68k' : ['CONFIG_M68K_DIS'],
2904 'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2905 'mips' : ['CONFIG_MIPS_DIS'],
2906 'nios2' : ['CONFIG_NIOS2_DIS'],
2907 'or1k' : ['CONFIG_OPENRISC_DIS'],
2908 'ppc' : ['CONFIG_PPC_DIS'],
2909 'riscv' : ['CONFIG_RISCV_DIS'],
2910 'rx' : ['CONFIG_RX_DIS'],
2911 's390' : ['CONFIG_S390_DIS'],
2912 'sh4' : ['CONFIG_SH4_DIS'],
2913 'sparc' : ['CONFIG_SPARC_DIS'],
2914 'xtensa' : ['CONFIG_XTENSA_DIS'],
2915 'loongarch' : ['CONFIG_LOONGARCH_DIS'],
2918 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2920 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2921 (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2922 (pixman.found() ? ['CONFIG_PIXMAN=y'] : []) + \
2923 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2924 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2925 (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \
2926 (x11.found() ? ['CONFIG_X11=y'] : []) + \
2927 (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \
2928 (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2929 (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2930 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2931 (host_os == 'linux' ? ['CONFIG_LINUX=y'] : []) + \
2932 (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
2933 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
2934 (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : []) + \
2935 (hv_balloon ? ['CONFIG_HV_BALLOON_POSSIBLE=y'] : [])
2937 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2939 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2940 actual_target_dirs = []
2942 foreach target : target_dirs
2943 config_target = { 'TARGET_NAME': target.split('-')[0] }
2944 if target.endswith('linux-user')
2945 if host_os != 'linux'
2949 error('Target @0@ is only available on a Linux host'.format(target))
2951 config_target += { 'CONFIG_LINUX_USER': 'y' }
2952 elif target.endswith('bsd-user')
2953 if host_os not in bsd_oses
2957 error('Target @0@ is only available on a BSD host'.format(target))
2959 config_target += { 'CONFIG_BSD_USER': 'y' }
2960 elif target.endswith('softmmu')
2961 config_target += { 'CONFIG_SYSTEM_ONLY': 'y' }
2962 config_target += { 'CONFIG_SOFTMMU': 'y' }
2964 if target.endswith('-user')
2966 'CONFIG_USER_ONLY': 'y',
2967 'CONFIG_QEMU_INTERP_PREFIX':
2968 get_option('interp_prefix').replace('%M', config_target['TARGET_NAME'])
2973 foreach sym: accelerators
2974 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2975 config_target += { sym: 'y' }
2976 config_all_accel += { sym: 'y' }
2977 if target in modular_tcg
2978 config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2980 config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2982 accel_kconfig += [ sym + '=y' ]
2985 if accel_kconfig.length() == 0
2989 error('No accelerator available for target @0@'.format(target))
2992 actual_target_dirs += target
2993 config_target += keyval.load('configs/targets' / target + '.mak')
2994 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2996 if 'TARGET_NEED_FDT' in config_target
2997 fdt_required += target
3001 if 'TARGET_BASE_ARCH' not in config_target
3002 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
3004 if 'TARGET_ABI_DIR' not in config_target
3005 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
3007 if 'TARGET_BIG_ENDIAN' not in config_target
3008 config_target += {'TARGET_BIG_ENDIAN': 'n'}
3011 foreach k, v: disassemblers
3012 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
3014 config_target += { sym: 'y' }
3019 config_target_data = configuration_data()
3020 foreach k, v: config_target
3021 if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
3023 elif ignored.contains(k)
3025 elif k == 'TARGET_BASE_ARCH'
3026 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
3027 # not used to select files from sourcesets.
3028 config_target_data.set('TARGET_' + v.to_upper(), 1)
3029 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
3030 config_target_data.set_quoted(k, v)
3032 config_target_data.set(k, 1)
3034 config_target_data.set(k, 0)
3036 config_target_data.set(k, v)
3039 config_target_data.set('QEMU_ARCH',
3040 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
3041 config_target_h += {target: configure_file(output: target + '-config-target.h',
3042 configuration: config_target_data)}
3044 if target.endswith('-softmmu')
3045 config_input = meson.get_external_property(target, 'default')
3046 config_devices_mak = target + '-config-devices.mak'
3047 config_devices_mak = configure_file(
3048 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
3049 output: config_devices_mak,
3050 depfile: config_devices_mak + '.d',
3052 command: [minikconf,
3053 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
3054 config_devices_mak, '@DEPFILE@', '@INPUT@',
3055 host_kconfig, accel_kconfig,
3056 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
3058 config_devices_data = configuration_data()
3059 config_devices = keyval.load(config_devices_mak)
3060 foreach k, v: config_devices
3061 config_devices_data.set(k, 1)
3063 config_devices_mak_list += config_devices_mak
3064 config_devices_h += {target: configure_file(output: target + '-config-devices.h',
3065 configuration: config_devices_data)}
3066 config_target += config_devices
3067 config_all_devices += config_devices
3069 config_target_mak += {target: config_target}
3071 target_dirs = actual_target_dirs
3073 target_configs_h = []
3074 foreach target: target_dirs
3075 target_configs_h += config_target_h[target]
3076 target_configs_h += config_devices_h.get(target, [])
3078 genh += custom_target('config-poison.h',
3079 input: [target_configs_h],
3080 output: 'config-poison.h',
3082 command: [find_program('scripts/make-config-poison.sh'),
3089 libvfio_user_dep = not_found
3090 if have_system and vfio_user_server_allowed
3091 libvfio_user_proj = subproject('libvfio-user', required: true)
3092 libvfio_user_dep = libvfio_user_proj.get_variable('libvfio_user_dep')
3096 fdt_opt = get_option('fdt')
3097 if fdt_required.length() > 0 or fdt_opt == 'enabled'
3098 if fdt_opt == 'disabled'
3099 error('fdt disabled but required by targets ' + ', '.join(fdt_required))
3102 if fdt_opt in ['enabled', 'auto', 'system']
3103 if get_option('wrap_mode') == 'nodownload'
3106 fdt = cc.find_library('fdt', required: fdt_opt == 'system')
3107 if fdt.found() and cc.links('''
3109 #include <libfdt_env.h>
3110 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
3113 elif fdt_opt == 'system'
3114 error('system libfdt requested, but it is too old (1.5.1 or newer required)')
3116 fdt_opt = 'internal'
3121 assert(fdt_opt == 'internal')
3122 libfdt_proj = subproject('dtc', required: true,
3123 default_options: ['tools=false', 'yaml=disabled',
3124 'python=disabled', 'default_library=static'])
3125 fdt = libfdt_proj.get_variable('libfdt_dep')
3128 fdt_opt = 'disabled'
3131 config_host_data.set('CONFIG_FDT', fdt.found())
3133 vhost_user = not_found
3134 if host_os == 'linux' and have_vhost_user
3135 libvhost_user = subproject('libvhost-user')
3136 vhost_user = libvhost_user.get_variable('vhost_user_dep')
3139 libvduse = not_found
3141 libvduse_proj = subproject('libvduse')
3142 libvduse = libvduse_proj.get_variable('libvduse_dep')
3145 #####################
3146 # Generated sources #
3147 #####################
3149 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
3151 hxtool = find_program('scripts/hxtool')
3152 shaderinclude = find_program('scripts/shaderinclude.py')
3153 qapi_gen = find_program('scripts/qapi-gen.py')
3154 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
3155 meson.current_source_dir() / 'scripts/qapi/commands.py',
3156 meson.current_source_dir() / 'scripts/qapi/common.py',
3157 meson.current_source_dir() / 'scripts/qapi/error.py',
3158 meson.current_source_dir() / 'scripts/qapi/events.py',
3159 meson.current_source_dir() / 'scripts/qapi/expr.py',
3160 meson.current_source_dir() / 'scripts/qapi/gen.py',
3161 meson.current_source_dir() / 'scripts/qapi/introspect.py',
3162 meson.current_source_dir() / 'scripts/qapi/main.py',
3163 meson.current_source_dir() / 'scripts/qapi/parser.py',
3164 meson.current_source_dir() / 'scripts/qapi/schema.py',
3165 meson.current_source_dir() / 'scripts/qapi/source.py',
3166 meson.current_source_dir() / 'scripts/qapi/types.py',
3167 meson.current_source_dir() / 'scripts/qapi/visit.py',
3168 meson.current_source_dir() / 'scripts/qapi-gen.py'
3172 python, files('scripts/tracetool.py'),
3173 '--backend=' + ','.join(get_option('trace_backends'))
3175 tracetool_depends = files(
3176 'scripts/tracetool/backend/log.py',
3177 'scripts/tracetool/backend/__init__.py',
3178 'scripts/tracetool/backend/dtrace.py',
3179 'scripts/tracetool/backend/ftrace.py',
3180 'scripts/tracetool/backend/simple.py',
3181 'scripts/tracetool/backend/syslog.py',
3182 'scripts/tracetool/backend/ust.py',
3183 'scripts/tracetool/format/ust_events_c.py',
3184 'scripts/tracetool/format/ust_events_h.py',
3185 'scripts/tracetool/format/__init__.py',
3186 'scripts/tracetool/format/d.py',
3187 'scripts/tracetool/format/simpletrace_stap.py',
3188 'scripts/tracetool/format/c.py',
3189 'scripts/tracetool/format/h.py',
3190 'scripts/tracetool/format/log_stap.py',
3191 'scripts/tracetool/format/stap.py',
3192 'scripts/tracetool/__init__.py',
3193 'scripts/tracetool/vcpu.py'
3196 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
3197 meson.current_source_dir(),
3198 get_option('pkgversion'), meson.project_version()]
3199 qemu_version = custom_target('qemu-version.h',
3200 output: 'qemu-version.h',
3201 command: qemu_version_cmd,
3203 build_by_default: true,
3204 build_always_stale: true)
3205 genh += qemu_version
3209 ['qemu-options.hx', 'qemu-options.def'],
3210 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
3214 ['hmp-commands.hx', 'hmp-commands.h'],
3215 ['hmp-commands-info.hx', 'hmp-commands-info.h'],
3218 foreach d : hx_headers
3219 hxdep += custom_target(d[1],
3223 command: [hxtool, '-h', '@INPUT0@'])
3231 # TODO: add each directory to the subdirs from its own meson.build, once
3233 trace_events_subdirs = [
3242 trace_events_subdirs += [ 'linux-user' ]
3245 trace_events_subdirs += [ 'bsd-user' ]
3248 trace_events_subdirs += [
3257 trace_events_subdirs += [
3271 'hw/block/dataplane',
3322 if have_system or have_user
3323 trace_events_subdirs += [
3345 authz_ss = ss.source_set()
3346 blockdev_ss = ss.source_set()
3347 block_ss = ss.source_set()
3348 chardev_ss = ss.source_set()
3349 common_ss = ss.source_set()
3350 crypto_ss = ss.source_set()
3351 hwcore_ss = ss.source_set()
3352 io_ss = ss.source_set()
3353 qmp_ss = ss.source_set()
3354 qom_ss = ss.source_set()
3355 system_ss = ss.source_set()
3356 specific_fuzz_ss = ss.source_set()
3357 specific_ss = ss.source_set()
3358 stub_ss = ss.source_set()
3359 trace_ss = ss.source_set()
3360 user_ss = ss.source_set()
3361 util_ss = ss.source_set()
3364 qtest_module_ss = ss.source_set()
3365 tcg_module_ss = ss.source_set()
3371 target_system_arch = {}
3372 target_user_arch = {}
3374 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
3375 # that is filled in by qapi/.
3389 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
3390 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
3393 qom_ss = qom_ss.apply({})
3394 libqom = static_library('qom', qom_ss.sources() + genh,
3395 dependencies: [qom_ss.dependencies()],
3397 build_by_default: false)
3398 qom = declare_dependency(link_whole: libqom)
3400 event_loop_base = files('event-loop-base.c')
3401 event_loop_base = static_library('event-loop-base',
3402 sources: event_loop_base + genh,
3404 build_by_default: false)
3405 event_loop_base = declare_dependency(link_whole: event_loop_base,
3406 dependencies: [qom])
3408 stub_ss = stub_ss.apply({})
3410 util_ss.add_all(trace_ss)
3411 util_ss = util_ss.apply({})
3412 libqemuutil = static_library('qemuutil',
3413 build_by_default: false,
3414 sources: util_ss.sources() + stub_ss.sources() + genh,
3415 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
3416 qemuutil = declare_dependency(link_with: libqemuutil,
3417 sources: genh + version_res,
3418 dependencies: [event_loop_base])
3420 if have_system or have_user
3421 decodetree = generator(find_program('scripts/decodetree.py'),
3422 output: 'decode-@BASENAME@.c.inc',
3423 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
3424 subdir('libdecnumber')
3441 if config_host_data.get('CONFIG_REPLICATION')
3442 block_ss.add(files('replication.c'))
3449 blockdev_ss.add(files(
3456 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
3457 # os-win32.c does not
3458 if host_os == 'windows'
3459 system_ss.add(files('os-win32.c'))
3461 blockdev_ss.add(files('os-posix.c'))
3465 common_ss.add(files('cpu-common.c'))
3466 specific_ss.add(files('cpu-target.c'))
3470 # Work around a gcc bug/misfeature wherein constant propagation looks
3472 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
3473 # to guess that a const variable is always zero. Without lto, this is
3474 # impossible, as the alias is restricted to page-vary-common.c. Indeed,
3475 # without lto, not even the alias is required -- we simply use different
3476 # declarations in different compilation units.
3477 pagevary = files('page-vary-common.c')
3478 if get_option('b_lto')
3479 pagevary_flags = ['-fno-lto']
3480 if get_option('cfi')
3481 pagevary_flags += '-fno-sanitize=cfi-icall'
3483 pagevary = static_library('page-vary-common', sources: pagevary + genh,
3484 c_args: pagevary_flags)
3485 pagevary = declare_dependency(link_with: pagevary)
3487 common_ss.add(pagevary)
3488 specific_ss.add(files('page-vary-target.c'))
3496 subdir('semihosting')
3504 common_user_inc = []
3506 subdir('common-user')
3508 subdir('linux-user')
3510 # needed for fuzzing binaries
3511 subdir('tests/qtest/libqos')
3512 subdir('tests/qtest/fuzz')
3515 tcg_real_module_ss = ss.source_set()
3516 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
3517 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
3518 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
3519 'tcg': tcg_real_module_ss }}
3521 ##############################################
3522 # Internal static_libraries and dependencies #
3523 ##############################################
3525 modinfo_collect = find_program('scripts/modinfo-collect.py')
3526 modinfo_generate = find_program('scripts/modinfo-generate.py')
3531 foreach d, list : modules
3532 if not (d == 'block' ? have_block : have_system)
3536 foreach m, module_ss : list
3538 module_ss = module_ss.apply(config_all_devices, strict: false)
3539 sl = static_library(d + '-' + m, [genh, module_ss.sources()],
3540 dependencies: [modulecommon, module_ss.dependencies()], pic: true)
3546 if module_ss.sources() != []
3547 # FIXME: Should use sl.extract_all_objects(recursive: true) as
3548 # input. Sources can be used multiple times but objects are
3549 # unique when it comes to lookup in compile_commands.json.
3550 # Depnds on a mesion version with
3551 # https://github.com/mesonbuild/meson/pull/8900
3552 modinfo_files += custom_target(d + '-' + m + '.modinfo',
3553 output: d + '-' + m + '.modinfo',
3554 input: module_ss.sources() + genh,
3556 command: [modinfo_collect, module_ss.sources()])
3560 block_ss.add_all(module_ss)
3562 system_ss.add_all(module_ss)
3568 foreach d, list : target_modules
3569 foreach m, module_ss : list
3571 foreach target : target_dirs
3572 if target.endswith('-softmmu')
3573 config_target = config_target_mak[target]
3574 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3575 c_args = ['-DNEED_CPU_H',
3576 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3577 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3578 target_module_ss = module_ss.apply(config_target, strict: false)
3579 if target_module_ss.sources() != []
3580 module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
3581 sl = static_library(module_name,
3582 [genh, target_module_ss.sources()],
3583 dependencies: [modulecommon, target_module_ss.dependencies()],
3584 include_directories: target_inc,
3588 # FIXME: Should use sl.extract_all_objects(recursive: true) too.
3589 modinfo_files += custom_target(module_name + '.modinfo',
3590 output: module_name + '.modinfo',
3591 input: target_module_ss.sources() + genh,
3593 command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3598 specific_ss.add_all(module_ss)
3604 foreach target : target_dirs
3605 if target.endswith('-softmmu')
3606 config_target = config_target_mak[target]
3607 config_devices_mak = target + '-config-devices.mak'
3608 modinfo_src = custom_target('modinfo-' + target + '.c',
3609 output: 'modinfo-' + target + '.c',
3610 input: modinfo_files,
3611 command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
3614 modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
3615 modinfo_dep = declare_dependency(link_with: modinfo_lib)
3617 arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
3618 hw_arch[arch].add(modinfo_dep)
3623 nm = find_program('nm')
3624 undefsym = find_program('scripts/undefsym.py')
3625 block_syms = custom_target('block.syms', output: 'block.syms',
3626 input: [libqemuutil, block_mods],
3628 command: [undefsym, nm, '@INPUT@'])
3629 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3630 input: [libqemuutil, system_mods],
3632 command: [undefsym, nm, '@INPUT@'])
3634 authz_ss = authz_ss.apply({})
3635 libauthz = static_library('authz', authz_ss.sources() + genh,
3636 dependencies: [authz_ss.dependencies()],
3638 build_by_default: false)
3640 authz = declare_dependency(link_whole: libauthz,
3643 crypto_ss = crypto_ss.apply({})
3644 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3645 dependencies: [crypto_ss.dependencies()],
3647 build_by_default: false)
3649 crypto = declare_dependency(link_whole: libcrypto,
3650 dependencies: [authz, qom])
3652 io_ss = io_ss.apply({})
3653 libio = static_library('io', io_ss.sources() + genh,
3654 dependencies: [io_ss.dependencies()],
3655 link_with: libqemuutil,
3657 build_by_default: false)
3659 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3661 libmigration = static_library('migration', sources: migration_files + genh,
3663 build_by_default: false)
3664 migration = declare_dependency(link_with: libmigration,
3665 dependencies: [zlib, qom, io])
3666 system_ss.add(migration)
3668 block_ss = block_ss.apply({})
3669 libblock = static_library('block', block_ss.sources() + genh,
3670 dependencies: block_ss.dependencies(),
3671 link_depends: block_syms,
3673 build_by_default: false)
3675 block = declare_dependency(link_whole: [libblock],
3676 link_args: '@block.syms',
3677 dependencies: [crypto, io])
3679 blockdev_ss = blockdev_ss.apply({})
3680 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3681 dependencies: blockdev_ss.dependencies(),
3683 build_by_default: false)
3685 blockdev = declare_dependency(link_whole: [libblockdev],
3686 dependencies: [block, event_loop_base])
3688 qmp_ss = qmp_ss.apply({})
3689 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3690 dependencies: qmp_ss.dependencies(),
3692 build_by_default: false)
3694 qmp = declare_dependency(link_whole: [libqmp])
3696 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3698 dependencies: chardev_ss.dependencies(),
3699 build_by_default: false)
3701 chardev = declare_dependency(link_whole: libchardev)
3703 hwcore_ss = hwcore_ss.apply({})
3704 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3706 build_by_default: false)
3707 hwcore = declare_dependency(link_whole: libhwcore)
3708 common_ss.add(hwcore)
3714 emulator_modules = []
3715 foreach m : block_mods + system_mods
3716 emulator_modules += shared_module(m.name(),
3717 build_by_default: true,
3721 install_dir: qemu_moddir)
3723 if emulator_modules.length() > 0
3724 alias_target('modules', emulator_modules)
3727 system_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3728 common_ss.add(qom, qemuutil)
3730 common_ss.add_all(when: 'CONFIG_SYSTEM_ONLY', if_true: [system_ss])
3731 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3733 # Note that this library is never used directly (only through extract_objects)
3734 # and is not built by default; therefore, source files not used by the build
3735 # configuration will be in build.ninja, but are never built by default.
3736 common_all = static_library('common',
3737 build_by_default: false,
3738 sources: common_ss.all_sources() + genh,
3739 include_directories: common_user_inc,
3740 implicit_include_directories: false,
3741 dependencies: common_ss.all_dependencies(),
3744 feature_to_c = find_program('scripts/feature_to_c.py')
3746 if host_os == 'darwin'
3747 entitlement = find_program('scripts/entitlement.sh')
3751 foreach target : target_dirs
3752 config_target = config_target_mak[target]
3753 target_name = config_target['TARGET_NAME']
3754 target_base_arch = config_target['TARGET_BASE_ARCH']
3755 arch_srcs = [config_target_h[target]]
3757 c_args = ['-DNEED_CPU_H',
3758 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3759 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3760 link_args = emulator_link_args
3762 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3763 if host_os == 'linux'
3764 target_inc += include_directories('linux-headers', is_system: true)
3766 if target.endswith('-softmmu')
3767 target_type='system'
3768 t = target_system_arch[target_base_arch].apply(config_target, strict: false)
3769 arch_srcs += t.sources()
3770 arch_deps += t.dependencies()
3772 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3773 if hw_arch.has_key(hw_dir)
3774 hw = hw_arch[hw_dir].apply(config_target, strict: false)
3775 arch_srcs += hw.sources()
3776 arch_deps += hw.dependencies()
3779 arch_srcs += config_devices_h[target]
3780 link_args += ['@block.syms', '@qemu.syms']
3782 abi = config_target['TARGET_ABI_DIR']
3784 target_inc += common_user_inc
3785 if target_base_arch in target_user_arch
3786 t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3787 arch_srcs += t.sources()
3788 arch_deps += t.dependencies()
3790 if 'CONFIG_LINUX_USER' in config_target
3791 base_dir = 'linux-user'
3793 if 'CONFIG_BSD_USER' in config_target
3794 base_dir = 'bsd-user'
3795 target_inc += include_directories('bsd-user/' / host_os)
3796 target_inc += include_directories('bsd-user/host/' / host_arch)
3797 dir = base_dir / abi
3798 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3800 target_inc += include_directories(
3804 if 'CONFIG_LINUX_USER' in config_target
3805 dir = base_dir / abi
3806 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3807 if config_target.has_key('TARGET_SYSTBL_ABI')
3809 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3810 extra_args : config_target['TARGET_SYSTBL_ABI'])
3815 if 'TARGET_XML_FILES' in config_target
3816 gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3817 output: target + '-gdbstub-xml.c',
3818 input: files(config_target['TARGET_XML_FILES'].split()),
3819 command: [feature_to_c, '@INPUT@'],
3821 arch_srcs += gdbstub_xml
3824 t = target_arch[target_base_arch].apply(config_target, strict: false)
3825 arch_srcs += t.sources()
3826 arch_deps += t.dependencies()
3828 target_common = common_ss.apply(config_target, strict: false)
3829 objects = common_all.extract_objects(target_common.sources())
3830 deps = target_common.dependencies()
3832 target_specific = specific_ss.apply(config_target, strict: false)
3833 arch_srcs += target_specific.sources()
3834 arch_deps += target_specific.dependencies()
3836 lib = static_library('qemu-' + target,
3837 sources: arch_srcs + genh,
3838 dependencies: arch_deps,
3840 include_directories: target_inc,
3842 build_by_default: false,
3845 if target.endswith('-softmmu')
3847 'name': 'qemu-system-' + target_name,
3848 'win_subsystem': 'console',
3849 'sources': files('system/main.c'),
3852 if host_os == 'windows' and (sdl.found() or gtk.found())
3854 'name': 'qemu-system-' + target_name + 'w',
3855 'win_subsystem': 'windows',
3856 'sources': files('system/main.c'),
3860 if get_option('fuzzing')
3861 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3863 'name': 'qemu-fuzz-' + target_name,
3864 'win_subsystem': 'console',
3865 'sources': specific_fuzz.sources(),
3866 'dependencies': specific_fuzz.dependencies(),
3871 'name': 'qemu-' + target_name,
3872 'win_subsystem': 'console',
3878 exe_name = exe['name']
3879 if host_os == 'darwin'
3880 exe_name += '-unsigned'
3883 emulator = executable(exe_name, exe['sources'],
3886 dependencies: arch_deps + deps + exe['dependencies'],
3887 objects: lib.extract_all_objects(recursive: true),
3888 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3889 link_args: link_args,
3890 win_subsystem: exe['win_subsystem'])
3892 if host_os == 'darwin'
3893 icon = 'pc-bios/qemu.rsrc'
3894 build_input = [emulator, files(icon)]
3896 get_option('bindir') / exe_name,
3897 meson.current_source_dir() / icon
3899 if 'CONFIG_HVF' in config_target
3900 entitlements = 'accel/hvf/entitlements.plist'
3901 build_input += files(entitlements)
3902 install_input += meson.current_source_dir() / entitlements
3905 emulators += {exe['name'] : custom_target(exe['name'],
3907 output: exe['name'],
3908 command: [entitlement, '@OUTPUT@', '@INPUT@'])
3911 meson.add_install_script(entitlement, '--install',
3912 get_option('bindir') / exe['name'],
3915 emulators += {exe['name']: emulator}
3920 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3921 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3922 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3923 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3925 custom_target(exe['name'] + stp['ext'],
3926 input: trace_events_all,
3927 output: exe['name'] + stp['ext'],
3928 install: stp['install'],
3929 install_dir: get_option('datadir') / 'systemtap/tapset',
3931 tracetool, '--group=all', '--format=' + stp['fmt'],
3932 '--binary=' + stp['bin'],
3933 '--target-name=' + target_name,
3934 '--target-type=' + target_type,
3935 '--probe-prefix=qemu.' + target_type + '.' + target_name,
3936 '@INPUT@', '@OUTPUT@'
3938 depend_files: tracetool_depends)
3944 # Other build targets
3946 if get_option('plugins')
3947 install_headers('include/qemu/qemu-plugin.h')
3948 if host_os == 'windows'
3949 # On windows, we want to deliver the qemu_plugin_api.lib file in the qemu installer,
3950 # so that plugin authors can compile against it.
3951 install_data(win32_qemu_plugin_api_lib, install_dir: 'lib')
3957 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3958 # when we don't build tools or system
3959 if xkbcommon.found()
3960 # used for the update-keymaps target, so include rules even if !have_tools
3961 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3962 dependencies: [qemuutil, xkbcommon], install: have_tools)
3966 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3967 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3968 qemu_io = executable('qemu-io', files('qemu-io.c'),
3969 dependencies: [block, qemuutil], install: true)
3970 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3971 dependencies: [blockdev, qemuutil, gnutls, selinux],
3974 subdir('storage-daemon')
3975 subdir('contrib/rdmacm-mux')
3976 subdir('contrib/elf2dmp')
3978 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3979 dependencies: qemuutil,
3983 subdir('contrib/vhost-user-blk')
3984 subdir('contrib/vhost-user-gpu')
3985 subdir('contrib/vhost-user-input')
3986 subdir('contrib/vhost-user-scsi')
3989 if host_os == 'linux'
3990 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3991 dependencies: [qemuutil, libcap_ng],
3993 install_dir: get_option('libexecdir'))
3995 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3996 dependencies: [authz, crypto, io, qom, qemuutil,
3997 libcap_ng, mpathpersist],
4002 subdir('contrib/ivshmem-client')
4003 subdir('contrib/ivshmem-server')
4016 if host_machine.system() == 'windows'
4018 find_program('scripts/nsis.py'),
4020 get_option('prefix'),
4021 meson.current_source_dir(),
4022 glib_pc.get_variable('bindir'),
4025 '-DDISPLAYVERSION=' + meson.project_version(),
4028 nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
4031 nsis_cmd += '-DCONFIG_GTK=y'
4034 nsis = custom_target('nsis',
4035 output: 'qemu-setup-' + meson.project_version() + '.exe',
4036 input: files('qemu.nsi'),
4037 build_always_stale: true,
4038 command: nsis_cmd + ['@INPUT@'])
4039 alias_target('installer', nsis)
4042 #########################
4043 # Configuration summary #
4044 #########################
4048 summary_info += {'Build directory': meson.current_build_dir()}
4049 summary_info += {'Source path': meson.current_source_dir()}
4050 summary_info += {'Download dependencies': get_option('wrap_mode') != 'nodownload'}
4051 summary(summary_info, bool_yn: true, section: 'Build environment')
4054 summary_info += {'Install prefix': get_option('prefix')}
4055 summary_info += {'BIOS directory': qemu_datadir}
4056 pathsep = host_os == 'windows' ? ';' : ':'
4057 summary_info += {'firmware path': pathsep.join(get_option('qemu_firmwarepath'))}
4058 summary_info += {'binary directory': get_option('prefix') / get_option('bindir')}
4059 summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
4060 summary_info += {'module directory': qemu_moddir}
4061 summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
4062 summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
4063 summary_info += {'config directory': get_option('prefix') / get_option('sysconfdir')}
4064 if host_os != 'windows'
4065 summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
4066 summary_info += {'Manual directory': get_option('prefix') / get_option('mandir')}
4068 summary_info += {'local state directory': 'queried at runtime'}
4070 summary_info += {'Doc directory': get_option('prefix') / get_option('docdir')}
4071 summary(summary_info, bool_yn: true, section: 'Directories')
4075 summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
4076 summary_info += {'sphinx-build': sphinx_build}
4078 # FIXME: the [binaries] section of machine files, which can be probed
4079 # with find_program(), would be great for passing gdb and genisoimage
4080 # paths from configure to Meson. However, there seems to be no way to
4081 # hide a program (for example if gdb is too old).
4082 if config_host.has_key('GDB')
4083 summary_info += {'gdb': config_host['GDB']}
4085 summary_info += {'iasl': iasl}
4086 summary_info += {'genisoimage': config_host['GENISOIMAGE']}
4087 if host_os == 'windows' and have_ga
4088 summary_info += {'wixl': wixl}
4090 if slirp.found() and have_system
4091 summary_info += {'smbd': have_slirp_smbd ? smbd_path : false}
4093 summary(summary_info, bool_yn: true, section: 'Host binaries')
4095 # Configurable features
4097 summary_info += {'Documentation': build_docs}
4098 summary_info += {'system-mode emulation': have_system}
4099 summary_info += {'user-mode emulation': have_user}
4100 summary_info += {'block layer': have_block}
4101 summary_info += {'Install blobs': get_option('install_blobs')}
4102 summary_info += {'module support': enable_modules}
4104 summary_info += {'alternative module path': get_option('module_upgrades')}
4106 summary_info += {'fuzzing support': get_option('fuzzing')}
4108 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)}
4110 summary_info += {'Trace backends': ','.join(get_option('trace_backends'))}
4111 if 'simple' in get_option('trace_backends')
4112 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
4114 summary_info += {'D-Bus display': dbus_display}
4115 summary_info += {'QOM debugging': get_option('qom_cast_debug')}
4116 summary_info += {'Relocatable install': get_option('relocatable')}
4117 summary_info += {'vhost-kernel support': have_vhost_kernel}
4118 summary_info += {'vhost-net support': have_vhost_net}
4119 summary_info += {'vhost-user support': have_vhost_user}
4120 summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
4121 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
4122 summary_info += {'vhost-vdpa support': have_vhost_vdpa}
4123 summary_info += {'build guest agent': have_ga}
4124 summary(summary_info, bool_yn: true, section: 'Configurable features')
4126 # Compilation information
4128 summary_info += {'host CPU': cpu}
4129 summary_info += {'host endianness': build_machine.endian()}
4130 summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())}
4131 summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())}
4132 if 'cpp' in all_languages
4133 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())}
4135 summary_info += {'C++ compiler': false}
4137 if 'objc' in all_languages
4138 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
4140 summary_info += {'Objective-C compiler': false}
4142 option_cflags = (get_option('debug') ? ['-g'] : [])
4143 if get_option('optimization') != 'plain'
4144 option_cflags += ['-O' + get_option('optimization')]
4146 summary_info += {'CFLAGS': ' '.join(get_option('c_args') + option_cflags)}
4147 if 'cpp' in all_languages
4148 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args') + option_cflags)}
4150 if 'objc' in all_languages
4151 summary_info += {'OBJCFLAGS': ' '.join(get_option('objc_args') + option_cflags)}
4153 link_args = get_option('c_link_args')
4154 if link_args.length() > 0
4155 summary_info += {'LDFLAGS': ' '.join(link_args)}
4157 summary_info += {'QEMU_CFLAGS': ' '.join(qemu_common_flags + qemu_cflags)}
4158 if 'cpp' in all_languages
4159 summary_info += {'QEMU_CXXFLAGS': ' '.join(qemu_common_flags + qemu_cxxflags)}
4161 if 'objc' in all_languages
4162 summary_info += {'QEMU_OBJCFLAGS': ' '.join(qemu_common_flags)}
4164 summary_info += {'QEMU_LDFLAGS': ' '.join(qemu_ldflags)}
4165 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
4166 summary_info += {'PIE': get_option('b_pie')}
4167 summary_info += {'static build': get_option('prefer_static')}
4168 summary_info += {'malloc trim support': has_malloc_trim}
4169 summary_info += {'membarrier': have_membarrier}
4170 summary_info += {'debug graph lock': get_option('debug_graph_lock')}
4171 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
4172 summary_info += {'mutex debugging': get_option('debug_mutex')}
4173 summary_info += {'memory allocator': get_option('malloc')}
4174 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
4175 summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')}
4176 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
4177 summary_info += {'gcov': get_option('b_coverage')}
4178 summary_info += {'thread sanitizer': get_option('tsan')}
4179 summary_info += {'CFI support': get_option('cfi')}
4180 if get_option('cfi')
4181 summary_info += {'CFI debug support': get_option('cfi_debug')}
4183 summary_info += {'strip binaries': get_option('strip')}
4184 summary_info += {'sparse': sparse}
4185 summary_info += {'mingw32 support': host_os == 'windows'}
4186 summary(summary_info, bool_yn: true, section: 'Compilation')
4188 # snarf the cross-compilation information for tests
4191 foreach target: target_dirs
4192 tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak'
4193 if fs.exists(tcg_mak)
4194 config_cross_tcg = keyval.load(tcg_mak)
4195 if 'CC' in config_cross_tcg
4196 summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
4202 summary(summary_info, bool_yn: true, section: 'Cross compilers')
4205 # Targets and accelerators
4208 summary_info += {'KVM support': config_all_accel.has_key('CONFIG_KVM')}
4209 summary_info += {'HVF support': config_all_accel.has_key('CONFIG_HVF')}
4210 summary_info += {'WHPX support': config_all_accel.has_key('CONFIG_WHPX')}
4211 summary_info += {'NVMM support': config_all_accel.has_key('CONFIG_NVMM')}
4212 summary_info += {'Xen support': xen.found()}
4214 summary_info += {'xen ctrl version': xen.version()}
4216 summary_info += {'Xen emulation': config_all_devices.has_key('CONFIG_XEN_EMU')}
4218 summary_info += {'TCG support': config_all_accel.has_key('CONFIG_TCG')}
4219 if config_all_accel.has_key('CONFIG_TCG')
4220 if get_option('tcg_interpreter')
4221 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'}
4223 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)}
4225 summary_info += {'TCG plugins': get_option('plugins')}
4226 summary_info += {'TCG debug enabled': get_option('debug_tcg')}
4228 summary_info += {'target list': ' '.join(target_dirs)}
4230 summary_info += {'default devices': get_option('default_devices')}
4231 summary_info += {'out of process emulation': multiprocess_allowed}
4232 summary_info += {'vfio-user server': vfio_user_server_allowed}
4234 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
4238 summary_info += {'coroutine backend': coroutine_backend}
4239 summary_info += {'coroutine pool': have_coroutine_pool}
4241 summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
4242 summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
4243 summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
4244 summary_info += {'VirtFS (9P) support': have_virtfs}
4245 summary_info += {'VirtFS (9P) Proxy Helper support (deprecated)': have_virtfs_proxy_helper}
4246 summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
4247 summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
4248 summary_info += {'bochs support': get_option('bochs').allowed()}
4249 summary_info += {'cloop support': get_option('cloop').allowed()}
4250 summary_info += {'dmg support': get_option('dmg').allowed()}
4251 summary_info += {'qcow v1 support': get_option('qcow1').allowed()}
4252 summary_info += {'vdi support': get_option('vdi').allowed()}
4253 summary_info += {'vhdx support': get_option('vhdx').allowed()}
4254 summary_info += {'vmdk support': get_option('vmdk').allowed()}
4255 summary_info += {'vpc support': get_option('vpc').allowed()}
4256 summary_info += {'vvfat support': get_option('vvfat').allowed()}
4257 summary_info += {'qed support': get_option('qed').allowed()}
4258 summary_info += {'parallels support': get_option('parallels').allowed()}
4259 summary_info += {'FUSE exports': fuse}
4260 summary_info += {'VDUSE block exports': have_vduse_blk_export}
4262 summary(summary_info, bool_yn: true, section: 'Block layer support')
4266 summary_info += {'TLS priority': get_option('tls_priority')}
4267 summary_info += {'GNUTLS support': gnutls}
4269 summary_info += {' GNUTLS crypto': gnutls_crypto.found()}
4271 summary_info += {'libgcrypt': gcrypt}
4272 summary_info += {'nettle': nettle}
4274 summary_info += {' XTS': xts != 'private'}
4276 summary_info += {'AF_ALG support': have_afalg}
4277 summary_info += {'rng-none': get_option('rng_none')}
4278 summary_info += {'Linux keyring': have_keyring}
4279 summary_info += {'Linux keyutils': keyutils}
4280 summary(summary_info, bool_yn: true, section: 'Crypto')
4284 if host_os == 'darwin'
4285 summary_info += {'Cocoa support': cocoa}
4287 summary_info += {'SDL support': sdl}
4288 summary_info += {'SDL image support': sdl_image}
4289 summary_info += {'GTK support': gtk}
4290 summary_info += {'pixman': pixman}
4291 summary_info += {'VTE support': vte}
4292 summary_info += {'PNG support': png}
4293 summary_info += {'VNC support': vnc}
4295 summary_info += {'VNC SASL support': sasl}
4296 summary_info += {'VNC JPEG support': jpeg}
4298 summary_info += {'spice protocol support': spice_protocol}
4299 if spice_protocol.found()
4300 summary_info += {' spice server support': spice}
4302 summary_info += {'curses support': curses}
4303 summary_info += {'brlapi support': brlapi}
4304 summary(summary_info, bool_yn: true, section: 'User interface')
4308 summary_info += {'VirGL support': virgl}
4309 summary_info += {'Rutabaga support': rutabaga}
4310 summary(summary_info, bool_yn: true, section: 'Graphics backends')
4314 if host_os not in ['darwin', 'haiku', 'windows']
4315 summary_info += {'OSS support': oss}
4316 summary_info += {'sndio support': sndio}
4317 elif host_os == 'darwin'
4318 summary_info += {'CoreAudio support': coreaudio}
4319 elif host_os == 'windows'
4320 summary_info += {'DirectSound support': dsound}
4322 if host_os == 'linux'
4323 summary_info += {'ALSA support': alsa}
4324 summary_info += {'PulseAudio support': pulse}
4326 summary_info += {'PipeWire support': pipewire}
4327 summary_info += {'JACK support': jack}
4328 summary(summary_info, bool_yn: true, section: 'Audio backends')
4332 if host_os == 'darwin'
4333 summary_info += {'vmnet.framework support': vmnet}
4335 summary_info += {'AF_XDP support': libxdp}
4336 summary_info += {'slirp support': slirp}
4337 summary_info += {'vde support': vde}
4338 summary_info += {'netmap support': have_netmap}
4339 summary_info += {'l2tpv3 support': have_l2tpv3}
4340 summary(summary_info, bool_yn: true, section: 'Network backends')
4344 summary_info += {'libtasn1': tasn1}
4345 summary_info += {'PAM': pam}
4346 summary_info += {'iconv support': iconv}
4347 summary_info += {'blkio support': blkio}
4348 summary_info += {'curl support': curl}
4349 summary_info += {'Multipath support': mpathpersist}
4350 summary_info += {'Linux AIO support': libaio}
4351 summary_info += {'Linux io_uring support': linux_io_uring}
4352 summary_info += {'ATTR/XATTR support': libattr}
4353 summary_info += {'RDMA support': rdma}
4354 summary_info += {'PVRDMA support': have_pvrdma}
4355 summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt}
4356 summary_info += {'libcap-ng support': libcap_ng}
4357 summary_info += {'bpf support': libbpf}
4358 summary_info += {'rbd support': rbd}
4359 summary_info += {'smartcard support': cacard}
4360 summary_info += {'U2F support': u2f}
4361 summary_info += {'libusb': libusb}
4362 summary_info += {'usb net redir': usbredir}
4363 summary_info += {'OpenGL support (epoxy)': opengl}
4364 summary_info += {'GBM': gbm}
4365 summary_info += {'libiscsi support': libiscsi}
4366 summary_info += {'libnfs support': libnfs}
4367 if host_os == 'windows'
4369 summary_info += {'QGA VSS support': have_qga_vss}
4372 summary_info += {'seccomp support': seccomp}
4373 summary_info += {'GlusterFS support': glusterfs}
4374 summary_info += {'hv-balloon support': hv_balloon}
4375 summary_info += {'TPM support': have_tpm}
4376 summary_info += {'libssh support': libssh}
4377 summary_info += {'lzo support': lzo}
4378 summary_info += {'snappy support': snappy}
4379 summary_info += {'bzip2 support': libbzip2}
4380 summary_info += {'lzfse support': liblzfse}
4381 summary_info += {'zstd support': zstd}
4382 summary_info += {'NUMA host support': numa}
4383 summary_info += {'capstone': capstone}
4384 summary_info += {'libpmem support': libpmem}
4385 summary_info += {'libdaxctl support': libdaxctl}
4386 summary_info += {'libudev': libudev}
4387 # Dummy dependency, keep .found()
4388 summary_info += {'FUSE lseek': fuse_lseek.found()}
4389 summary_info += {'selinux': selinux}
4390 summary_info += {'libdw': libdw}
4391 summary(summary_info, bool_yn: true, section: 'Dependencies')
4393 if host_arch == 'unknown'
4395 warning('UNSUPPORTED HOST CPU')
4397 message('Support for CPU host architecture ' + cpu + ' is not currently')
4398 message('maintained. The QEMU project does not guarantee that QEMU will')
4399 message('compile or work on this host CPU. You can help by volunteering')
4400 message('to maintain it and providing a build host for our continuous')
4401 message('integration setup.')
4402 if get_option('tcg').allowed() and target_dirs.length() > 0
4404 message('configure has succeeded and you can continue to build, but')
4405 message('QEMU will use a slow interpreter to emulate the target CPU.')
4409 if not supported_oses.contains(host_os)
4411 warning('UNSUPPORTED HOST OS')
4413 message('Support for host OS ' + host_os + 'is not currently maintained.')
4414 message('configure has succeeded and you can continue to build, but')
4415 message('the QEMU project does not guarantee that QEMU will compile or')
4416 message('work on this operating system. You can help by volunteering')
4417 message('to maintain it and providing a build host for our continuous')
4418 message('integration setup. This will ensure that future versions of QEMU')
4419 message('will keep working on ' + host_os + '.')
4422 if host_arch == 'unknown' or not supported_oses.contains(host_os)
4424 message('If you want to help supporting QEMU on this platform, please')
4425 message('contact the developers at qemu-devel@nongnu.org.')
4428 actually_reloc = get_option('relocatable')
4429 # check if get_relocated_path() is actually able to relocate paths
4430 if get_option('relocatable') and \
4431 not (get_option('prefix') / get_option('bindir')).startswith(get_option('prefix') / '')
4433 warning('bindir not included within prefix, the installation will not be relocatable.')
4434 actually_reloc = false
4436 if not actually_reloc and (host_os == 'windows' or get_option('relocatable'))
4437 if host_os == 'windows'
4439 warning('Windows installs should usually be relocatable.')
4442 message('QEMU will have to be installed under ' + get_option('prefix') + '.')
4443 message('Use --disable-relocatable to remove this warning.')