2021-12-18 18:39:43 +03:00
|
|
|
project('qemu', ['c'], meson_version: '>=0.59.3',
|
2021-02-09 16:59:26 +03:00
|
|
|
default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto',
|
2022-04-20 18:33:59 +03:00
|
|
|
'b_staticpic=false', 'stdsplit=false', 'optimization=2', 'b_pie=true'],
|
2021-02-09 16:59:26 +03:00
|
|
|
version: files('VERSION'))
|
2019-06-10 13:05:14 +03:00
|
|
|
|
2022-03-10 10:50:48 +03:00
|
|
|
add_test_setup('quick', exclude_suites: ['slow', 'thorough'], is_default: true)
|
|
|
|
add_test_setup('slow', exclude_suites: ['thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
|
|
|
|
add_test_setup('thorough', env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
|
2021-02-11 14:15:12 +03:00
|
|
|
|
2019-06-10 13:05:14 +03:00
|
|
|
not_found = dependency('', required: false)
|
2021-02-09 16:59:26 +03:00
|
|
|
keyval = import('keyval')
|
2020-08-19 15:44:56 +03:00
|
|
|
ss = import('sourceset')
|
2020-09-13 22:19:25 +03:00
|
|
|
fs = import('fs')
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2020-01-28 18:41:44 +03:00
|
|
|
sh = find_program('sh')
|
2020-08-19 15:44:56 +03:00
|
|
|
cc = meson.get_compiler('c')
|
2019-06-10 13:05:14 +03:00
|
|
|
config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
|
2019-08-29 21:07:01 +03:00
|
|
|
enable_modules = 'CONFIG_MODULES' in config_host
|
2020-02-06 16:17:15 +03:00
|
|
|
enable_static = 'CONFIG_STATIC' in config_host
|
2020-10-16 01:06:25 +03:00
|
|
|
|
2021-01-26 13:15:33 +03:00
|
|
|
# Allow both shared and static libraries unless --enable-static
|
|
|
|
static_kwargs = enable_static ? {'static': true} : {}
|
|
|
|
|
2020-10-16 01:06:25 +03:00
|
|
|
# Temporary directory used for files created while
|
|
|
|
# configure runs. Since it is in the build directory
|
|
|
|
# we can safely blow away any previous version of it
|
|
|
|
# (and we need not jump through hoops to try to delete
|
|
|
|
# it when configure exits.)
|
|
|
|
tmpdir = meson.current_build_dir() / 'meson-private/temp'
|
2020-09-11 15:42:48 +03:00
|
|
|
|
|
|
|
if get_option('qemu_suffix').startswith('/')
|
|
|
|
error('qemu_suffix cannot start with a /')
|
|
|
|
endif
|
|
|
|
|
2020-10-16 10:19:14 +03:00
|
|
|
qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
|
2020-08-26 14:04:16 +03:00
|
|
|
qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
|
2020-08-26 14:04:17 +03:00
|
|
|
qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
|
2020-10-16 10:19:14 +03:00
|
|
|
qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
|
|
|
|
|
|
|
|
qemu_desktopdir = get_option('datadir') / 'applications'
|
|
|
|
qemu_icondir = get_option('datadir') / 'icons'
|
|
|
|
|
2020-08-04 19:14:26 +03:00
|
|
|
config_host_data = configuration_data()
|
|
|
|
genh = []
|
2022-01-26 19:11:27 +03:00
|
|
|
qapi_trace_events = []
|
2019-06-10 13:05:14 +03:00
|
|
|
|
2021-10-15 17:47:43 +03:00
|
|
|
bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin']
|
|
|
|
supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
|
|
|
|
supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv', 'x86', 'x86_64',
|
|
|
|
'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc', 'sparc64']
|
|
|
|
|
|
|
|
cpu = host_machine.cpu_family()
|
|
|
|
|
|
|
|
# Unify riscv* to a single family.
|
|
|
|
if cpu in ['riscv32', 'riscv64']
|
|
|
|
cpu = 'riscv'
|
|
|
|
endif
|
|
|
|
|
|
|
|
targetos = host_machine.system()
|
|
|
|
|
2020-08-26 09:09:48 +03:00
|
|
|
target_dirs = config_host['TARGET_DIRS'].split()
|
2021-10-09 01:47:37 +03:00
|
|
|
have_linux_user = false
|
|
|
|
have_bsd_user = false
|
2020-08-26 09:09:48 +03:00
|
|
|
have_system = false
|
|
|
|
foreach target : target_dirs
|
2021-10-09 01:47:37 +03:00
|
|
|
have_linux_user = have_linux_user or target.endswith('linux-user')
|
|
|
|
have_bsd_user = have_bsd_user or target.endswith('bsd-user')
|
2020-08-26 09:09:48 +03:00
|
|
|
have_system = have_system or target.endswith('-softmmu')
|
|
|
|
endforeach
|
2021-10-09 01:47:37 +03:00
|
|
|
have_user = have_linux_user or have_bsd_user
|
2021-10-15 17:47:43 +03:00
|
|
|
have_tools = get_option('tools') \
|
|
|
|
.disable_auto_if(not have_system) \
|
|
|
|
.allowed()
|
|
|
|
have_ga = get_option('guest_agent') \
|
|
|
|
.disable_auto_if(not have_system and not have_tools) \
|
|
|
|
.require(targetos in ['sunos', 'linux', 'windows'],
|
|
|
|
error_message: 'unsupported OS for QEMU guest agent') \
|
|
|
|
.allowed()
|
2020-08-26 09:09:48 +03:00
|
|
|
have_block = have_system or have_tools
|
|
|
|
|
2020-09-01 14:45:54 +03:00
|
|
|
python = import('python').find_installation()
|
|
|
|
|
2021-11-08 16:18:17 +03:00
|
|
|
if cpu not in supported_cpus
|
|
|
|
host_arch = 'unknown'
|
|
|
|
elif cpu == 'x86'
|
|
|
|
host_arch = 'i386'
|
2021-12-31 08:25:11 +03:00
|
|
|
elif cpu == 'mips64'
|
|
|
|
host_arch = 'mips'
|
2021-11-08 16:18:17 +03:00
|
|
|
else
|
|
|
|
host_arch = cpu
|
|
|
|
endif
|
|
|
|
|
2020-09-18 12:37:01 +03:00
|
|
|
if cpu in ['x86', 'x86_64']
|
|
|
|
kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
|
|
|
|
elif cpu == 'aarch64'
|
|
|
|
kvm_targets = ['aarch64-softmmu']
|
|
|
|
elif cpu == 's390x'
|
|
|
|
kvm_targets = ['s390x-softmmu']
|
|
|
|
elif cpu in ['ppc', 'ppc64']
|
|
|
|
kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
|
2020-10-07 11:39:28 +03:00
|
|
|
elif cpu in ['mips', 'mips64']
|
|
|
|
kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
|
2022-01-12 11:13:29 +03:00
|
|
|
elif cpu in ['riscv']
|
|
|
|
kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu']
|
2020-09-18 12:37:01 +03:00
|
|
|
else
|
|
|
|
kvm_targets = []
|
|
|
|
endif
|
|
|
|
|
2021-10-27 18:10:12 +03:00
|
|
|
kvm_targets_c = '""'
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('kvm').allowed() and targetos == 'linux'
|
2021-09-02 14:35:38 +03:00
|
|
|
kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"'
|
|
|
|
endif
|
|
|
|
config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c)
|
|
|
|
|
2020-09-18 12:37:01 +03:00
|
|
|
accelerator_targets = { 'CONFIG_KVM': kvm_targets }
|
2021-09-16 18:54:02 +03:00
|
|
|
|
|
|
|
if cpu in ['aarch64']
|
|
|
|
accelerator_targets += {
|
|
|
|
'CONFIG_HVF': ['aarch64-softmmu']
|
|
|
|
}
|
|
|
|
endif
|
|
|
|
|
2020-11-10 22:23:09 +03:00
|
|
|
if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
|
2021-09-14 15:30:45 +03:00
|
|
|
# i386 emulator provides xenpv machine type for multiple architectures
|
2020-11-10 22:23:09 +03:00
|
|
|
accelerator_targets += {
|
|
|
|
'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
|
|
|
|
}
|
|
|
|
endif
|
2020-09-18 12:37:01 +03:00
|
|
|
if cpu in ['x86', 'x86_64']
|
|
|
|
accelerator_targets += {
|
|
|
|
'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
|
|
|
|
'CONFIG_HVF': ['x86_64-softmmu'],
|
2021-04-02 23:25:32 +03:00
|
|
|
'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
|
2020-09-18 12:37:01 +03:00
|
|
|
'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
|
|
|
|
}
|
|
|
|
endif
|
|
|
|
|
2021-07-12 15:22:08 +03:00
|
|
|
modular_tcg = []
|
|
|
|
# Darwin does not support references to thread-local variables in modules
|
|
|
|
if targetos != 'darwin'
|
|
|
|
modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
|
|
|
|
endif
|
2021-06-24 13:38:31 +03:00
|
|
|
|
2021-01-14 20:45:08 +03:00
|
|
|
edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
|
2021-09-23 13:55:28 +03:00
|
|
|
unpack_edk2_blobs = false
|
|
|
|
foreach target : edk2_targets
|
|
|
|
if target in target_dirs
|
|
|
|
bzip2 = find_program('bzip2', required: get_option('install_blobs'))
|
|
|
|
unpack_edk2_blobs = bzip2.found()
|
|
|
|
break
|
|
|
|
endif
|
|
|
|
endforeach
|
2021-01-14 20:45:09 +03:00
|
|
|
|
2021-10-07 16:08:14 +03:00
|
|
|
dtrace = not_found
|
|
|
|
stap = not_found
|
|
|
|
if 'dtrace' in get_option('trace_backends')
|
|
|
|
dtrace = find_program('dtrace', required: true)
|
|
|
|
stap = find_program('stap', required: false)
|
|
|
|
if stap.found()
|
|
|
|
# Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
|
|
|
|
# visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
|
|
|
|
# instead. QEMU --enable-modules depends on this because the SystemTap
|
|
|
|
# semaphores are linked into the main binary and not the module's shared
|
|
|
|
# object.
|
|
|
|
add_global_arguments('-DSTAP_SDT_V2',
|
|
|
|
native: false, language: ['c', 'cpp', 'objc'])
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2022-04-20 18:33:49 +03:00
|
|
|
if get_option('iasl') == ''
|
|
|
|
iasl = find_program('iasl', required: false)
|
|
|
|
else
|
|
|
|
iasl = find_program(get_option('iasl'), required: true)
|
|
|
|
endif
|
|
|
|
|
2020-09-01 14:45:54 +03:00
|
|
|
##################
|
|
|
|
# Compiler flags #
|
|
|
|
##################
|
|
|
|
|
2021-11-08 14:36:29 +03:00
|
|
|
qemu_cflags = config_host['QEMU_CFLAGS'].split()
|
|
|
|
qemu_cxxflags = config_host['QEMU_CXXFLAGS'].split()
|
2022-02-15 18:15:13 +03:00
|
|
|
qemu_objcflags = config_host['QEMU_OBJCFLAGS'].split()
|
2021-11-08 14:36:29 +03:00
|
|
|
qemu_ldflags = config_host['QEMU_LDFLAGS'].split()
|
|
|
|
|
2022-04-20 18:33:50 +03:00
|
|
|
if targetos == 'windows'
|
|
|
|
qemu_ldflags += cc.get_supported_link_arguments('-Wl,--no-seh', '-Wl,--nxcompat')
|
|
|
|
# Disable ASLR for debug builds to allow debugging with gdb
|
|
|
|
if get_option('optimization') == '0'
|
|
|
|
qemu_ldflags += cc.get_supported_link_arguments('-Wl,--dynamicbase')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2021-10-13 12:46:09 +03:00
|
|
|
if get_option('gprof')
|
|
|
|
qemu_cflags += ['-p']
|
|
|
|
qemu_cxxflags += ['-p']
|
2022-02-15 18:15:13 +03:00
|
|
|
qemu_objcflags += ['-p']
|
2021-10-13 12:46:09 +03:00
|
|
|
qemu_ldflags += ['-p']
|
|
|
|
endif
|
|
|
|
|
2020-09-10 01:05:16 +03:00
|
|
|
# Specify linker-script with add_project_link_arguments so that it is not placed
|
|
|
|
# within a linker --start-group/--end-group pair
|
2021-10-07 16:08:12 +03:00
|
|
|
if get_option('fuzzing')
|
|
|
|
add_project_link_arguments(['-Wl,-T,',
|
|
|
|
(meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
|
|
|
|
native: false, language: ['c', 'cpp', 'objc'])
|
|
|
|
|
|
|
|
# Specify a filter to only instrument code that is directly related to
|
|
|
|
# virtual-devices.
|
|
|
|
configure_file(output: 'instrumentation-filter',
|
|
|
|
input: 'scripts/oss-fuzz/instrumentation-filter-template',
|
|
|
|
copy: true)
|
2022-06-14 18:54:15 +03:00
|
|
|
|
|
|
|
if cc.compiles('int main () { return 0; }',
|
|
|
|
name: '-fsanitize-coverage-allowlist=/dev/null',
|
|
|
|
args: ['-fsanitize-coverage-allowlist=/dev/null'] )
|
|
|
|
add_global_arguments('-fsanitize-coverage-allowlist=instrumentation-filter',
|
|
|
|
native: false, language: ['c', 'cpp', 'objc'])
|
|
|
|
endif
|
2021-10-07 16:08:12 +03:00
|
|
|
|
|
|
|
if get_option('fuzzing_engine') == ''
|
|
|
|
# Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
|
|
|
|
# compiled code. To build non-fuzzer binaries with --enable-fuzzing, link
|
|
|
|
# everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
|
|
|
|
# unable to bind the fuzzer-related callbacks added by instrumentation.
|
|
|
|
add_global_arguments('-fsanitize=fuzzer-no-link',
|
|
|
|
native: false, language: ['c', 'cpp', 'objc'])
|
|
|
|
add_global_link_arguments('-fsanitize=fuzzer-no-link',
|
2020-09-10 01:05:16 +03:00
|
|
|
native: false, language: ['c', 'cpp', 'objc'])
|
2021-10-07 16:08:12 +03:00
|
|
|
# For the actual fuzzer binaries, we need to link against the libfuzzer
|
|
|
|
# library. They need to be configurable, to support OSS-Fuzz
|
|
|
|
fuzz_exe_ldflags = ['-fsanitize=fuzzer']
|
|
|
|
else
|
|
|
|
# LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
|
|
|
|
# the needed CFLAGS have already been provided
|
|
|
|
fuzz_exe_ldflags = get_option('fuzzing_engine').split()
|
|
|
|
endif
|
2020-09-10 01:05:16 +03:00
|
|
|
endif
|
|
|
|
|
2022-02-15 18:15:13 +03:00
|
|
|
add_global_arguments(qemu_cflags, native: false, language: ['c'])
|
2021-11-08 14:36:29 +03:00
|
|
|
add_global_arguments(qemu_cxxflags, native: false, language: ['cpp'])
|
2022-02-15 18:15:13 +03:00
|
|
|
add_global_arguments(qemu_objcflags, native: false, language: ['objc'])
|
2021-11-08 14:36:29 +03:00
|
|
|
add_global_link_arguments(qemu_ldflags, native: false, language: ['c', 'cpp', 'objc'])
|
2019-06-10 13:05:14 +03:00
|
|
|
|
2020-10-14 15:45:42 +03:00
|
|
|
if targetos == 'linux'
|
|
|
|
add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
|
|
|
|
'-isystem', 'linux-headers',
|
|
|
|
language: ['c', 'cpp'])
|
|
|
|
endif
|
|
|
|
|
2020-12-14 14:01:45 +03:00
|
|
|
add_project_arguments('-iquote', '.',
|
2020-10-14 15:45:42 +03:00
|
|
|
'-iquote', meson.current_source_dir(),
|
|
|
|
'-iquote', meson.current_source_dir() / 'include',
|
|
|
|
'-iquote', meson.current_source_dir() / 'disas/libvixl',
|
|
|
|
language: ['c', 'cpp', 'objc'])
|
2020-09-02 20:36:50 +03:00
|
|
|
|
2019-07-13 00:47:54 +03:00
|
|
|
link_language = meson.get_external_property('link_language', 'cpp')
|
|
|
|
if link_language == 'cpp'
|
|
|
|
add_languages('cpp', required: true, native: false)
|
2021-11-04 16:35:14 +03:00
|
|
|
cxx = meson.get_compiler('cpp')
|
|
|
|
linker = cxx
|
|
|
|
else
|
|
|
|
linker = cc
|
2019-07-13 00:47:54 +03:00
|
|
|
endif
|
2019-06-10 13:05:14 +03:00
|
|
|
if host_machine.system() == 'darwin'
|
|
|
|
add_languages('objc', required: false, native: false)
|
|
|
|
endif
|
|
|
|
|
2020-09-01 14:51:16 +03:00
|
|
|
sparse = find_program('cgcc', required: get_option('sparse'))
|
|
|
|
if sparse.found()
|
2020-02-03 16:45:33 +03:00
|
|
|
run_target('sparse',
|
|
|
|
command: [find_program('scripts/check_sparse.py'),
|
2020-09-01 14:51:16 +03:00
|
|
|
'compile_commands.json', sparse.full_path(), '-Wbitwise',
|
|
|
|
'-Wno-transparent-union', '-Wno-old-initializer',
|
|
|
|
'-Wno-non-pointer-null'])
|
2020-02-03 16:45:33 +03:00
|
|
|
endif
|
|
|
|
|
2020-09-16 19:07:29 +03:00
|
|
|
###########################################
|
|
|
|
# Target-specific checks and dependencies #
|
|
|
|
###########################################
|
|
|
|
|
2021-11-08 14:59:16 +03:00
|
|
|
# Fuzzing
|
2021-10-07 16:08:12 +03:00
|
|
|
if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
|
|
|
|
not cc.links('''
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
|
|
|
|
int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
|
|
|
|
''',
|
|
|
|
args: ['-Werror', '-fsanitize=fuzzer'])
|
|
|
|
error('Your compiler does not support -fsanitize=fuzzer')
|
|
|
|
endif
|
|
|
|
|
2021-11-08 14:59:16 +03:00
|
|
|
# Tracing backends
|
2021-10-07 16:08:14 +03:00
|
|
|
if 'ftrace' in get_option('trace_backends') and targetos != 'linux'
|
|
|
|
error('ftrace is supported only on Linux')
|
|
|
|
endif
|
|
|
|
if 'syslog' in get_option('trace_backends') and not cc.compiles('''
|
|
|
|
#include <syslog.h>
|
|
|
|
int main(void) {
|
|
|
|
openlog("qemu", LOG_PID, LOG_DAEMON);
|
|
|
|
syslog(LOG_INFO, "configure");
|
|
|
|
return 0;
|
|
|
|
}''')
|
|
|
|
error('syslog is not supported on this system')
|
|
|
|
endif
|
|
|
|
|
2021-11-08 14:59:16 +03:00
|
|
|
# Miscellaneous Linux-only features
|
meson: use .require() and .disable_auto_if() method for features
The method is now in 0.59, using it simplifies some conditionals.
There is a small change, which is to build virtfs-proxy-helper in a
tools-only build. This is done for consistency with other tools,
which are not culled by the absence of system emulator binaries.
.disable_auto_if() would also be useful to check for packages,
for example
-linux_io_uring = not_found
-if not get_option('linux_io_uring').auto() or have_block
- linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
+linux_io_uring = dependency('liburing',
+ required: get_option('linux_io_uring').disable_auto_if(not have_block),
+ method: 'pkg-config', kwargs: static_kwargs)
This change however is much larger and I am not sure about the improved
readability, so I am not performing it right now.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-12-18 18:39:43 +03:00
|
|
|
get_option('mpath') \
|
|
|
|
.require(targetos == 'linux', error_message: 'Multipath is supported only on Linux')
|
2020-09-16 19:07:29 +03:00
|
|
|
|
meson: use .require() and .disable_auto_if() method for features
The method is now in 0.59, using it simplifies some conditionals.
There is a small change, which is to build virtfs-proxy-helper in a
tools-only build. This is done for consistency with other tools,
which are not culled by the absence of system emulator binaries.
.disable_auto_if() would also be useful to check for packages,
for example
-linux_io_uring = not_found
-if not get_option('linux_io_uring').auto() or have_block
- linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
+linux_io_uring = dependency('liburing',
+ required: get_option('linux_io_uring').disable_auto_if(not have_block),
+ method: 'pkg-config', kwargs: static_kwargs)
This change however is much larger and I am not sure about the improved
readability, so I am not performing it right now.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-12-18 18:39:43 +03:00
|
|
|
multiprocess_allowed = get_option('multiprocess') \
|
|
|
|
.require(targetos == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
|
|
|
|
.allowed()
|
2021-02-17 18:24:25 +03:00
|
|
|
|
2022-06-13 23:26:24 +03:00
|
|
|
vfio_user_server_allowed = get_option('vfio_user_server') \
|
|
|
|
.require(targetos == 'linux', error_message: 'vfio-user server is supported only on Linux') \
|
|
|
|
.allowed()
|
|
|
|
|
2021-12-21 14:38:27 +03:00
|
|
|
have_tpm = get_option('tpm') \
|
|
|
|
.require(targetos != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
|
|
|
|
.allowed()
|
|
|
|
|
2022-04-20 18:34:05 +03:00
|
|
|
# vhost
|
2022-04-20 18:34:07 +03:00
|
|
|
have_vhost_user = get_option('vhost_user') \
|
|
|
|
.disable_auto_if(targetos != 'linux') \
|
|
|
|
.require(targetos != 'windows',
|
|
|
|
error_message: 'vhost-user is not available on Windows').allowed()
|
|
|
|
have_vhost_vdpa = get_option('vhost_vdpa') \
|
|
|
|
.require(targetos == 'linux',
|
|
|
|
error_message: 'vhost-vdpa is only available on Linux').allowed()
|
|
|
|
have_vhost_kernel = get_option('vhost_kernel') \
|
|
|
|
.require(targetos == 'linux',
|
|
|
|
error_message: 'vhost-kernel is only available on Linux').allowed()
|
|
|
|
have_vhost_user_crypto = get_option('vhost_crypto') \
|
|
|
|
.require(have_vhost_user,
|
|
|
|
error_message: 'vhost-crypto requires vhost-user to be enabled').allowed()
|
|
|
|
|
2022-04-20 18:34:06 +03:00
|
|
|
have_vhost = have_vhost_user or have_vhost_vdpa or have_vhost_kernel
|
2022-04-20 18:34:07 +03:00
|
|
|
|
|
|
|
have_vhost_net_user = have_vhost_user and get_option('vhost_net').allowed()
|
|
|
|
have_vhost_net_vdpa = have_vhost_vdpa and get_option('vhost_net').allowed()
|
|
|
|
have_vhost_net_kernel = have_vhost_kernel and get_option('vhost_net').allowed()
|
|
|
|
have_vhost_net = have_vhost_net_kernel or have_vhost_net_user or have_vhost_net_vdpa
|
2022-04-20 18:34:05 +03:00
|
|
|
|
2021-11-08 14:59:16 +03:00
|
|
|
# Target-specific libraries and flags
|
2021-06-01 11:00:48 +03:00
|
|
|
libm = cc.find_library('m', required: false)
|
2021-06-03 16:01:35 +03:00
|
|
|
threads = dependency('threads')
|
2020-08-19 15:44:56 +03:00
|
|
|
util = cc.find_library('util', required: false)
|
2020-08-03 17:22:28 +03:00
|
|
|
winmm = []
|
2020-08-19 15:44:56 +03:00
|
|
|
socket = []
|
2019-07-17 23:31:05 +03:00
|
|
|
version_res = []
|
2019-08-20 18:48:59 +03:00
|
|
|
coref = []
|
|
|
|
iokit = []
|
2020-09-21 11:49:50 +03:00
|
|
|
emulator_link_args = []
|
2021-04-02 23:25:32 +03:00
|
|
|
nvmm =not_found
|
2020-09-18 12:37:01 +03:00
|
|
|
hvf = not_found
|
2022-02-01 11:55:21 +03:00
|
|
|
midl = not_found
|
|
|
|
widl = not_found
|
2021-10-07 16:08:15 +03:00
|
|
|
host_dsosuf = '.so'
|
2020-08-19 15:44:56 +03:00
|
|
|
if targetos == 'windows'
|
2022-02-01 11:55:21 +03:00
|
|
|
midl = find_program('midl', required: false)
|
|
|
|
widl = find_program('widl', required: false)
|
2020-08-19 15:44:56 +03:00
|
|
|
socket = cc.find_library('ws2_32')
|
2020-08-03 17:22:28 +03:00
|
|
|
winmm = cc.find_library('winmm')
|
2019-07-17 23:31:05 +03:00
|
|
|
|
|
|
|
win = import('windows')
|
|
|
|
version_res = win.compile_resources('version.rc',
|
|
|
|
depend_files: files('pc-bios/qemu-nsis.ico'),
|
|
|
|
include_directories: include_directories('.'))
|
2021-10-07 16:08:15 +03:00
|
|
|
host_dsosuf = '.dll'
|
2019-08-20 18:48:59 +03:00
|
|
|
elif targetos == 'darwin'
|
|
|
|
coref = dependency('appleframeworks', modules: 'CoreFoundation')
|
2021-03-15 21:03:38 +03:00
|
|
|
iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
|
2021-10-07 16:08:15 +03:00
|
|
|
host_dsosuf = '.dylib'
|
2020-08-10 00:47:45 +03:00
|
|
|
elif targetos == 'sunos'
|
|
|
|
socket = [cc.find_library('socket'),
|
|
|
|
cc.find_library('nsl'),
|
|
|
|
cc.find_library('resolv')]
|
|
|
|
elif targetos == 'haiku'
|
|
|
|
socket = [cc.find_library('posix_error_mapper'),
|
|
|
|
cc.find_library('network'),
|
|
|
|
cc.find_library('bsd')]
|
2020-09-21 11:49:50 +03:00
|
|
|
elif targetos == 'openbsd'
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('tcg').allowed() and target_dirs.length() > 0
|
2020-09-21 11:49:50 +03:00
|
|
|
# Disable OpenBSD W^X if available
|
|
|
|
emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
|
|
|
|
endif
|
2020-08-19 15:44:56 +03:00
|
|
|
endif
|
2020-09-16 19:07:29 +03:00
|
|
|
|
2021-11-08 14:59:16 +03:00
|
|
|
# Target-specific configuration of accelerators
|
2020-09-18 12:37:01 +03:00
|
|
|
accelerators = []
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('kvm').allowed() and targetos == 'linux'
|
2020-09-18 12:37:01 +03:00
|
|
|
accelerators += 'CONFIG_KVM'
|
|
|
|
endif
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('whpx').allowed() and targetos == 'windows'
|
2020-10-22 03:27:55 +03:00
|
|
|
if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
|
2020-09-18 12:37:01 +03:00
|
|
|
error('WHPX requires 64-bit host')
|
|
|
|
elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
|
|
|
|
cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
|
|
|
|
accelerators += 'CONFIG_WHPX'
|
|
|
|
endif
|
|
|
|
endif
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('hvf').allowed()
|
2020-09-18 12:37:01 +03:00
|
|
|
hvf = dependency('appleframeworks', modules: 'Hypervisor',
|
|
|
|
required: get_option('hvf'))
|
|
|
|
if hvf.found()
|
|
|
|
accelerators += 'CONFIG_HVF'
|
|
|
|
endif
|
|
|
|
endif
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('hax').allowed()
|
2020-09-18 12:37:01 +03:00
|
|
|
if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
|
|
|
|
accelerators += 'CONFIG_HAX'
|
|
|
|
endif
|
|
|
|
endif
|
2021-04-02 23:25:32 +03:00
|
|
|
if targetos == 'netbsd'
|
2021-10-13 16:54:17 +03:00
|
|
|
nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
|
2021-04-02 23:25:32 +03:00
|
|
|
if nvmm.found()
|
|
|
|
accelerators += 'CONFIG_NVMM'
|
|
|
|
endif
|
|
|
|
endif
|
2020-12-14 14:01:45 +03:00
|
|
|
|
2021-11-08 16:18:17 +03:00
|
|
|
tcg_arch = host_arch
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('tcg').allowed()
|
2021-11-08 16:18:17 +03:00
|
|
|
if host_arch == 'unknown'
|
2020-12-14 14:01:45 +03:00
|
|
|
if get_option('tcg_interpreter')
|
2021-11-06 14:14:57 +03:00
|
|
|
warning('Unsupported CPU @0@, will use TCG with TCI (slow)'.format(cpu))
|
2020-09-18 12:37:01 +03:00
|
|
|
else
|
|
|
|
error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
|
|
|
|
endif
|
2021-01-25 17:45:30 +03:00
|
|
|
elif get_option('tcg_interpreter')
|
2021-05-21 13:34:23 +03:00
|
|
|
warning('Use of the TCG interpreter is not recommended on this host')
|
2021-01-25 17:45:30 +03:00
|
|
|
warning('architecture. There is a native TCG execution backend available')
|
|
|
|
warning('which provides substantially better performance and reliability.')
|
|
|
|
warning('It is strongly recommended to remove the --enable-tcg-interpreter')
|
|
|
|
warning('configuration option on this architecture to use the native')
|
|
|
|
warning('backend.')
|
2020-09-18 12:37:01 +03:00
|
|
|
endif
|
2020-12-14 14:01:45 +03:00
|
|
|
if get_option('tcg_interpreter')
|
|
|
|
tcg_arch = 'tci'
|
2021-11-08 16:18:17 +03:00
|
|
|
elif host_arch == 'sparc64'
|
2020-12-14 14:01:45 +03:00
|
|
|
tcg_arch = 'sparc'
|
2021-11-08 16:18:17 +03:00
|
|
|
elif host_arch == 'x86_64'
|
2020-12-14 14:01:45 +03:00
|
|
|
tcg_arch = 'i386'
|
2021-11-08 16:18:17 +03:00
|
|
|
elif host_arch == 'ppc64'
|
2020-12-14 14:01:45 +03:00
|
|
|
tcg_arch = 'ppc'
|
|
|
|
endif
|
|
|
|
add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
|
|
|
|
language: ['c', 'cpp', 'objc'])
|
|
|
|
|
2020-09-18 12:37:01 +03:00
|
|
|
accelerators += 'CONFIG_TCG'
|
|
|
|
config_host += { 'CONFIG_TCG': 'y' }
|
|
|
|
endif
|
|
|
|
|
|
|
|
if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
|
|
|
|
error('KVM not available on this platform')
|
|
|
|
endif
|
|
|
|
if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
|
|
|
|
error('HVF not available on this platform')
|
|
|
|
endif
|
2021-04-02 23:25:32 +03:00
|
|
|
if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
|
|
|
|
error('NVMM not available on this platform')
|
|
|
|
endif
|
2020-09-18 12:37:01 +03:00
|
|
|
if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
|
|
|
|
error('WHPX not available on this platform')
|
|
|
|
endif
|
2020-09-01 18:28:59 +03:00
|
|
|
|
2020-09-16 19:07:29 +03:00
|
|
|
################
|
|
|
|
# Dependencies #
|
|
|
|
################
|
|
|
|
|
2020-09-01 15:41:17 +03:00
|
|
|
# The path to glib.h is added to all compilation commands. This was
|
|
|
|
# grandfathered in from the QEMU Makefiles.
|
|
|
|
add_project_arguments(config_host['GLIB_CFLAGS'].split(),
|
|
|
|
native: false, language: ['c', 'cpp', 'objc'])
|
2020-12-15 11:03:19 +03:00
|
|
|
glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
|
2021-10-09 16:37:40 +03:00
|
|
|
link_args: config_host['GLIB_LIBS'].split(),
|
2022-05-25 17:41:39 +03:00
|
|
|
version: config_host['GLIB_VERSION'],
|
|
|
|
variables: {
|
|
|
|
'bindir': config_host['GLIB_BINDIR'],
|
|
|
|
})
|
2020-12-15 11:03:19 +03:00
|
|
|
# override glib dep with the configure results (for subprojects)
|
|
|
|
meson.override_dependency('glib-2.0', glib)
|
|
|
|
|
2020-08-19 15:44:56 +03:00
|
|
|
gio = not_found
|
2022-04-20 18:33:44 +03:00
|
|
|
gdbus_codegen = not_found
|
|
|
|
if not get_option('gio').auto() or have_system
|
|
|
|
gio = dependency('gio-2.0', required: get_option('gio'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
|
|
|
if gio.found() and not cc.links('''
|
|
|
|
#include <gio/gio.h>
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
g_dbus_proxy_new_sync(0, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: [glib, gio])
|
|
|
|
if get_option('gio').enabled()
|
|
|
|
error('The installed libgio is broken for static linking')
|
|
|
|
endif
|
|
|
|
gio = not_found
|
|
|
|
endif
|
|
|
|
if gio.found()
|
|
|
|
gdbus_codegen = find_program(gio.get_variable('gdbus_codegen'),
|
|
|
|
required: get_option('gio'))
|
|
|
|
gio_unix = dependency('gio-unix-2.0', required: get_option('gio'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
|
|
|
gio = declare_dependency(dependencies: [gio, gio_unix],
|
|
|
|
version: gio.version())
|
|
|
|
endif
|
2020-08-19 15:44:56 +03:00
|
|
|
endif
|
2022-04-20 18:33:44 +03:00
|
|
|
|
2020-08-19 15:44:56 +03:00
|
|
|
lttng = not_found
|
2021-10-07 16:08:14 +03:00
|
|
|
if 'ust' in get_option('trace_backends')
|
2022-03-28 11:47:13 +03:00
|
|
|
lttng = dependency('lttng-ust', required: true, version: '>= 2.1',
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-08-19 15:44:56 +03:00
|
|
|
endif
|
2020-08-26 09:22:58 +03:00
|
|
|
pixman = not_found
|
|
|
|
if have_system or have_tools
|
|
|
|
pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-08-26 09:22:58 +03:00
|
|
|
endif
|
2021-01-26 13:15:33 +03:00
|
|
|
zlib = dependency('zlib', required: true, kwargs: static_kwargs)
|
2021-06-03 12:31:35 +03:00
|
|
|
|
2021-10-07 16:08:20 +03:00
|
|
|
libaio = not_found
|
|
|
|
if not get_option('linux_aio').auto() or have_block
|
|
|
|
libaio = cc.find_library('aio', has_headers: ['libaio.h'],
|
|
|
|
required: get_option('linux_aio'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
2022-05-13 09:28:30 +03:00
|
|
|
|
|
|
|
linux_io_uring_test = '''
|
|
|
|
#include <liburing.h>
|
|
|
|
#include <linux/errqueue.h>
|
|
|
|
|
|
|
|
int main(void) { return 0; }'''
|
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
linux_io_uring = not_found
|
2021-06-03 12:31:35 +03:00
|
|
|
if not get_option('linux_io_uring').auto() or have_block
|
2022-01-05 16:49:38 +03:00
|
|
|
linux_io_uring = dependency('liburing', version: '>=0.3',
|
|
|
|
required: get_option('linux_io_uring'),
|
2021-06-03 12:31:35 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2022-05-13 09:28:30 +03:00
|
|
|
if not cc.links(linux_io_uring_test)
|
|
|
|
linux_io_uring = not_found
|
|
|
|
endif
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2022-05-13 09:28:30 +03:00
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
libnfs = not_found
|
2020-11-17 15:11:25 +03:00
|
|
|
if not get_option('libnfs').auto() or have_block
|
|
|
|
libnfs = dependency('libnfs', version: '>=1.9.3',
|
|
|
|
required: get_option('libnfs'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2020-11-17 16:45:24 +03:00
|
|
|
|
|
|
|
libattr_test = '''
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#ifdef CONFIG_LIBATTR
|
|
|
|
#include <attr/xattr.h>
|
|
|
|
#else
|
|
|
|
#include <sys/xattr.h>
|
|
|
|
#endif
|
|
|
|
int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
|
|
|
|
|
2019-07-15 14:04:49 +03:00
|
|
|
libattr = not_found
|
2020-11-17 16:45:24 +03:00
|
|
|
have_old_libattr = false
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('attr').allowed()
|
2020-11-17 16:45:24 +03:00
|
|
|
if cc.links(libattr_test)
|
|
|
|
libattr = declare_dependency()
|
|
|
|
else
|
|
|
|
libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
|
|
|
|
required: get_option('attr'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 16:45:24 +03:00
|
|
|
if libattr.found() and not \
|
|
|
|
cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
|
|
|
|
libattr = not_found
|
|
|
|
if get_option('attr').enabled()
|
|
|
|
error('could not link libattr')
|
|
|
|
else
|
|
|
|
warning('could not link libattr, disabling')
|
|
|
|
endif
|
|
|
|
else
|
|
|
|
have_old_libattr = libattr.found()
|
|
|
|
endif
|
|
|
|
endif
|
2019-07-15 14:04:49 +03:00
|
|
|
endif
|
2020-11-17 16:45:24 +03:00
|
|
|
|
2021-01-07 16:04:00 +03:00
|
|
|
cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
|
|
|
|
if cocoa.found() and get_option('sdl').enabled()
|
|
|
|
error('Cocoa and SDL cannot be enabled at the same time')
|
|
|
|
endif
|
|
|
|
if cocoa.found() and get_option('gtk').enabled()
|
|
|
|
error('Cocoa and GTK+ cannot be enabled at the same time')
|
|
|
|
endif
|
|
|
|
|
2022-03-17 20:28:33 +03:00
|
|
|
vmnet = dependency('appleframeworks', modules: 'vmnet', required: get_option('vmnet'))
|
|
|
|
if vmnet.found() and not cc.has_header_symbol('vmnet/vmnet.h',
|
|
|
|
'VMNET_BRIDGED_MODE',
|
|
|
|
dependencies: vmnet)
|
|
|
|
vmnet = not_found
|
|
|
|
if get_option('vmnet').enabled()
|
|
|
|
error('vmnet.framework API is outdated')
|
|
|
|
else
|
|
|
|
warning('vmnet.framework API is outdated, disabling')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2020-02-05 11:45:39 +03:00
|
|
|
seccomp = not_found
|
2020-11-17 16:22:24 +03:00
|
|
|
if not get_option('seccomp').auto() or have_system or have_tools
|
|
|
|
seccomp = dependency('libseccomp', version: '>=2.3.0',
|
|
|
|
required: get_option('seccomp'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-02-05 11:45:39 +03:00
|
|
|
endif
|
2020-11-17 16:46:58 +03:00
|
|
|
|
2020-02-05 11:45:39 +03:00
|
|
|
libcap_ng = not_found
|
2020-11-17 16:46:58 +03:00
|
|
|
if not get_option('cap_ng').auto() or have_system or have_tools
|
|
|
|
libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
|
|
|
|
required: get_option('cap_ng'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 16:46:58 +03:00
|
|
|
endif
|
|
|
|
if libcap_ng.found() and not cc.links('''
|
|
|
|
#include <cap-ng.h>
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
capng_capability_to_name(CAPNG_EFFECTIVE);
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: libcap_ng)
|
|
|
|
libcap_ng = not_found
|
|
|
|
if get_option('cap_ng').enabled()
|
|
|
|
error('could not link libcap-ng')
|
|
|
|
else
|
|
|
|
warning('could not link libcap-ng, disabling')
|
|
|
|
endif
|
2020-02-05 11:45:39 +03:00
|
|
|
endif
|
2020-11-17 16:46:58 +03:00
|
|
|
|
2020-08-26 10:24:11 +03:00
|
|
|
if get_option('xkbcommon').auto() and not have_system and not have_tools
|
|
|
|
xkbcommon = not_found
|
|
|
|
else
|
|
|
|
xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2019-07-15 13:48:31 +03:00
|
|
|
endif
|
2021-10-07 16:08:21 +03:00
|
|
|
|
2019-07-22 22:47:50 +03:00
|
|
|
vde = not_found
|
2021-10-07 16:08:21 +03:00
|
|
|
if not get_option('vde').auto() or have_system or have_tools
|
|
|
|
vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
|
|
|
|
required: get_option('vde'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
|
|
|
if vde.found() and not cc.links('''
|
|
|
|
#include <libvdeplug.h>
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
struct vde_open_args a = {0, 0, 0};
|
|
|
|
char s[] = "";
|
|
|
|
vde_open(s, s, &a);
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: vde)
|
|
|
|
vde = not_found
|
|
|
|
if get_option('cap_ng').enabled()
|
|
|
|
error('could not link libvdeplug')
|
|
|
|
else
|
|
|
|
warning('could not link libvdeplug, disabling')
|
|
|
|
endif
|
2019-07-22 22:47:50 +03:00
|
|
|
endif
|
2021-10-07 16:06:09 +03:00
|
|
|
|
2020-08-17 13:47:55 +03:00
|
|
|
pulse = not_found
|
2021-10-07 16:06:09 +03:00
|
|
|
if not get_option('pa').auto() or (targetos == 'linux' and have_system)
|
|
|
|
pulse = dependency('libpulse', required: get_option('pa'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-08-17 13:47:55 +03:00
|
|
|
endif
|
|
|
|
alsa = not_found
|
2021-10-07 16:06:09 +03:00
|
|
|
if not get_option('alsa').auto() or (targetos == 'linux' and have_system)
|
|
|
|
alsa = dependency('alsa', required: get_option('alsa'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-08-17 13:47:55 +03:00
|
|
|
endif
|
|
|
|
jack = not_found
|
2021-10-07 16:06:09 +03:00
|
|
|
if not get_option('jack').auto() or have_system
|
|
|
|
jack = dependency('jack', required: get_option('jack'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-08-17 13:47:55 +03:00
|
|
|
endif
|
2021-10-07 16:06:09 +03:00
|
|
|
|
2021-05-19 08:39:32 +03:00
|
|
|
spice_protocol = not_found
|
2021-10-07 16:08:23 +03:00
|
|
|
if not get_option('spice_protocol').auto() or have_system
|
|
|
|
spice_protocol = dependency('spice-protocol', version: '>=0.12.3',
|
|
|
|
required: get_option('spice_protocol'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2019-07-29 16:40:07 +03:00
|
|
|
endif
|
2021-10-07 16:08:23 +03:00
|
|
|
spice = not_found
|
|
|
|
if not get_option('spice').auto() or have_system
|
|
|
|
spice = dependency('spice-server', version: '>=0.12.5',
|
|
|
|
required: get_option('spice'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2021-05-19 08:39:32 +03:00
|
|
|
endif
|
2021-10-07 16:08:23 +03:00
|
|
|
spice_headers = spice.partial_dependency(compile_args: true, includes: true)
|
|
|
|
|
2019-07-12 22:16:54 +03:00
|
|
|
rt = cc.find_library('rt', required: false)
|
2021-11-15 17:29:13 +03:00
|
|
|
|
2019-06-10 13:21:14 +03:00
|
|
|
libiscsi = not_found
|
2020-11-17 15:11:25 +03:00
|
|
|
if not get_option('libiscsi').auto() or have_block
|
|
|
|
libiscsi = dependency('libiscsi', version: '>=1.9.0',
|
|
|
|
required: get_option('libiscsi'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2019-06-10 13:21:14 +03:00
|
|
|
endif
|
2019-08-29 21:34:43 +03:00
|
|
|
zstd = not_found
|
2020-11-17 15:37:39 +03:00
|
|
|
if not get_option('zstd').auto() or have_block
|
|
|
|
zstd = dependency('libzstd', version: '>=1.4.0',
|
|
|
|
required: get_option('zstd'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2019-07-12 21:23:46 +03:00
|
|
|
virgl = not_found
|
2021-12-17 14:36:26 +03:00
|
|
|
|
|
|
|
have_vhost_user_gpu = have_tools and targetos == 'linux' and pixman.found()
|
|
|
|
if not get_option('virglrenderer').auto() or have_system or have_vhost_user_gpu
|
2021-06-03 12:31:35 +03:00
|
|
|
virgl = dependency('virglrenderer',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('virglrenderer'),
|
|
|
|
kwargs: static_kwargs)
|
2019-07-12 21:23:46 +03:00
|
|
|
endif
|
2019-07-12 22:47:06 +03:00
|
|
|
curl = not_found
|
2020-11-17 14:43:15 +03:00
|
|
|
if not get_option('curl').auto() or have_block
|
|
|
|
curl = dependency('libcurl', version: '>=7.29.0',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('curl'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2019-07-12 22:47:06 +03:00
|
|
|
endif
|
2019-07-18 14:19:02 +03:00
|
|
|
libudev = not_found
|
2020-09-16 18:54:14 +03:00
|
|
|
if targetos == 'linux' and (have_system or have_tools)
|
2020-09-16 19:07:29 +03:00
|
|
|
libudev = dependency('libudev',
|
2020-11-17 14:36:15 +03:00
|
|
|
method: 'pkg-config',
|
2020-10-15 13:09:27 +03:00
|
|
|
required: get_option('libudev'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-09-16 19:07:29 +03:00
|
|
|
endif
|
|
|
|
|
2020-10-15 13:09:27 +03:00
|
|
|
mpathlibs = [libudev]
|
2020-09-16 19:07:29 +03:00
|
|
|
mpathpersist = not_found
|
|
|
|
mpathpersist_new_api = false
|
2021-12-18 18:39:43 +03:00
|
|
|
if targetos == 'linux' and have_tools and get_option('mpath').allowed()
|
2020-09-16 19:07:29 +03:00
|
|
|
mpath_test_source_new = '''
|
|
|
|
#include <libudev.h>
|
|
|
|
#include <mpath_persist.h>
|
|
|
|
unsigned mpath_mx_alloc_len = 1024;
|
|
|
|
int logsink;
|
|
|
|
static struct config *multipath_conf;
|
|
|
|
extern struct udev *udev;
|
|
|
|
extern struct config *get_multipath_config(void);
|
|
|
|
extern void put_multipath_config(struct config *conf);
|
|
|
|
struct udev *udev;
|
|
|
|
struct config *get_multipath_config(void) { return multipath_conf; }
|
|
|
|
void put_multipath_config(struct config *conf) { }
|
|
|
|
int main(void) {
|
|
|
|
udev = udev_new();
|
|
|
|
multipath_conf = mpath_lib_init();
|
|
|
|
return 0;
|
|
|
|
}'''
|
|
|
|
mpath_test_source_old = '''
|
|
|
|
#include <libudev.h>
|
|
|
|
#include <mpath_persist.h>
|
|
|
|
unsigned mpath_mx_alloc_len = 1024;
|
|
|
|
int logsink;
|
|
|
|
int main(void) {
|
|
|
|
struct udev *udev = udev_new();
|
|
|
|
mpath_lib_init(udev);
|
|
|
|
return 0;
|
|
|
|
}'''
|
2020-10-15 13:09:27 +03:00
|
|
|
libmpathpersist = cc.find_library('mpathpersist',
|
|
|
|
required: get_option('mpath'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-10-15 13:09:27 +03:00
|
|
|
if libmpathpersist.found()
|
|
|
|
mpathlibs += libmpathpersist
|
|
|
|
if enable_static
|
|
|
|
mpathlibs += cc.find_library('devmapper',
|
|
|
|
required: get_option('mpath'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-09-17 13:25:09 +03:00
|
|
|
endif
|
2020-10-15 13:09:27 +03:00
|
|
|
mpathlibs += cc.find_library('multipath',
|
|
|
|
required: get_option('mpath'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-10-15 13:09:27 +03:00
|
|
|
foreach lib: mpathlibs
|
|
|
|
if not lib.found()
|
|
|
|
mpathlibs = []
|
|
|
|
break
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
if mpathlibs.length() == 0
|
|
|
|
msg = 'Dependencies missing for libmpathpersist'
|
|
|
|
elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
|
2020-09-16 19:07:29 +03:00
|
|
|
mpathpersist = declare_dependency(dependencies: mpathlibs)
|
|
|
|
mpathpersist_new_api = true
|
|
|
|
elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
|
|
|
|
mpathpersist = declare_dependency(dependencies: mpathlibs)
|
|
|
|
else
|
2020-10-15 13:09:27 +03:00
|
|
|
msg = 'Cannot detect libmpathpersist API'
|
|
|
|
endif
|
|
|
|
if not mpathpersist.found()
|
2020-09-16 19:07:29 +03:00
|
|
|
if get_option('mpath').enabled()
|
2020-10-15 13:09:27 +03:00
|
|
|
error(msg)
|
2020-09-16 19:07:29 +03:00
|
|
|
else
|
2020-10-15 13:09:27 +03:00
|
|
|
warning(msg + ', disabling')
|
2020-09-16 19:07:29 +03:00
|
|
|
endif
|
|
|
|
endif
|
|
|
|
endif
|
2019-07-18 14:19:02 +03:00
|
|
|
endif
|
2020-09-16 19:07:29 +03:00
|
|
|
|
2020-10-13 02:43:48 +03:00
|
|
|
iconv = not_found
|
|
|
|
curses = not_found
|
2021-12-18 18:39:43 +03:00
|
|
|
if have_system and get_option('curses').allowed()
|
2020-10-19 11:42:11 +03:00
|
|
|
curses_test = '''
|
2021-11-17 23:53:55 +03:00
|
|
|
#if defined(__APPLE__) || defined(__OpenBSD__)
|
|
|
|
#define _XOPEN_SOURCE_EXTENDED 1
|
|
|
|
#endif
|
2020-10-19 11:42:11 +03:00
|
|
|
#include <locale.h>
|
|
|
|
#include <curses.h>
|
|
|
|
#include <wchar.h>
|
|
|
|
int main(void) {
|
|
|
|
wchar_t wch = L'w';
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
resize_term(0, 0);
|
|
|
|
addwstr(L"wide chars\n");
|
|
|
|
addnwstr(&wch, 1);
|
|
|
|
add_wch(WACS_DEGREE);
|
|
|
|
return 0;
|
|
|
|
}'''
|
|
|
|
|
2020-11-17 00:31:06 +03:00
|
|
|
curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
|
|
|
|
foreach curses_dep : curses_dep_list
|
|
|
|
if not curses.found()
|
|
|
|
curses = dependency(curses_dep,
|
|
|
|
required: false,
|
|
|
|
method: 'pkg-config',
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 00:31:06 +03:00
|
|
|
endif
|
|
|
|
endforeach
|
2020-10-19 11:42:11 +03:00
|
|
|
msg = get_option('curses').enabled() ? 'curses library not found' : ''
|
2021-11-17 23:53:55 +03:00
|
|
|
curses_compile_args = ['-DNCURSES_WIDECHAR=1']
|
2020-10-19 11:42:11 +03:00
|
|
|
if curses.found()
|
2020-11-30 16:07:48 +03:00
|
|
|
if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
|
|
|
|
curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
|
2020-10-19 11:42:11 +03:00
|
|
|
else
|
|
|
|
msg = 'curses package not usable'
|
|
|
|
curses = not_found
|
2020-10-13 02:43:48 +03:00
|
|
|
endif
|
|
|
|
endif
|
2020-10-19 11:42:11 +03:00
|
|
|
if not curses.found()
|
|
|
|
has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
|
|
|
|
if targetos != 'windows' and not has_curses_h
|
|
|
|
message('Trying with /usr/include/ncursesw')
|
|
|
|
curses_compile_args += ['-I/usr/include/ncursesw']
|
|
|
|
has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
|
|
|
|
endif
|
|
|
|
if has_curses_h
|
|
|
|
curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
|
|
|
|
foreach curses_libname : curses_libname_list
|
2020-10-13 02:43:48 +03:00
|
|
|
libcurses = cc.find_library(curses_libname,
|
|
|
|
required: false,
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-10-19 11:42:11 +03:00
|
|
|
if libcurses.found()
|
|
|
|
if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
|
|
|
|
curses = declare_dependency(compile_args: curses_compile_args,
|
|
|
|
dependencies: [libcurses])
|
|
|
|
break
|
|
|
|
else
|
|
|
|
msg = 'curses library not usable'
|
|
|
|
endif
|
2020-10-13 02:43:48 +03:00
|
|
|
endif
|
2020-10-19 11:42:11 +03:00
|
|
|
endforeach
|
|
|
|
endif
|
|
|
|
endif
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('iconv').allowed()
|
2020-10-19 11:42:11 +03:00
|
|
|
foreach link_args : [ ['-liconv'], [] ]
|
|
|
|
# Programs will be linked with glib and this will bring in libiconv on FreeBSD.
|
|
|
|
# We need to use libiconv if available because mixing libiconv's headers with
|
|
|
|
# the system libc does not work.
|
|
|
|
# However, without adding glib to the dependencies -L/usr/local/lib will not be
|
|
|
|
# included in the command line and libiconv will not be found.
|
|
|
|
if cc.links('''
|
|
|
|
#include <iconv.h>
|
|
|
|
int main(void) {
|
|
|
|
iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
|
|
|
|
return conv != (iconv_t) -1;
|
|
|
|
}''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
|
|
|
|
iconv = declare_dependency(link_args: link_args, dependencies: glib)
|
|
|
|
break
|
2020-10-13 02:43:48 +03:00
|
|
|
endif
|
2020-10-15 20:26:50 +03:00
|
|
|
endforeach
|
|
|
|
endif
|
2020-10-19 11:42:11 +03:00
|
|
|
if curses.found() and not iconv.found()
|
|
|
|
if get_option('iconv').enabled()
|
|
|
|
error('iconv not available')
|
|
|
|
endif
|
|
|
|
msg = 'iconv required for curses UI but not available'
|
|
|
|
curses = not_found
|
|
|
|
endif
|
|
|
|
if not curses.found() and msg != ''
|
|
|
|
if get_option('curses').enabled()
|
|
|
|
error(msg)
|
2020-10-15 20:26:50 +03:00
|
|
|
else
|
2020-10-19 11:42:11 +03:00
|
|
|
warning(msg + ', disabling')
|
2020-10-15 20:26:50 +03:00
|
|
|
endif
|
2020-10-13 02:43:48 +03:00
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2019-07-29 16:40:07 +03:00
|
|
|
brlapi = not_found
|
2020-11-17 15:02:17 +03:00
|
|
|
if not get_option('brlapi').auto() or have_system
|
|
|
|
brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
|
|
|
|
required: get_option('brlapi'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 15:02:17 +03:00
|
|
|
if brlapi.found() and not cc.links('''
|
|
|
|
#include <brlapi.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
|
|
|
|
brlapi = not_found
|
|
|
|
if get_option('brlapi').enabled()
|
|
|
|
error('could not link brlapi')
|
|
|
|
else
|
|
|
|
warning('could not link brlapi, disabling')
|
|
|
|
endif
|
|
|
|
endif
|
2019-07-29 16:40:07 +03:00
|
|
|
endif
|
2020-02-06 16:17:15 +03:00
|
|
|
|
2020-08-26 09:09:48 +03:00
|
|
|
sdl = not_found
|
2021-01-07 16:04:00 +03:00
|
|
|
if not get_option('sdl').auto() or (have_system and not cocoa.found())
|
2021-01-26 13:15:33 +03:00
|
|
|
sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
|
2020-08-26 09:09:48 +03:00
|
|
|
sdl_image = not_found
|
|
|
|
endif
|
2020-02-06 16:17:15 +03:00
|
|
|
if sdl.found()
|
|
|
|
# work around 2.0.8 bug
|
|
|
|
sdl = declare_dependency(compile_args: '-Wno-undef',
|
|
|
|
dependencies: sdl)
|
2020-08-29 13:41:58 +03:00
|
|
|
sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-02-06 16:17:15 +03:00
|
|
|
else
|
|
|
|
if get_option('sdl_image').enabled()
|
2020-09-08 10:40:16 +03:00
|
|
|
error('sdl-image required, but SDL was @0@'.format(
|
|
|
|
get_option('sdl').disabled() ? 'disabled' : 'not found'))
|
2020-02-06 16:17:15 +03:00
|
|
|
endif
|
|
|
|
sdl_image = not_found
|
2019-07-29 16:40:07 +03:00
|
|
|
endif
|
2020-02-06 16:17:15 +03:00
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
rbd = not_found
|
2020-11-17 15:11:25 +03:00
|
|
|
if not get_option('rbd').auto() or have_block
|
|
|
|
librados = cc.find_library('rados', required: get_option('rbd'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 15:11:25 +03:00
|
|
|
librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
|
|
|
|
required: get_option('rbd'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2021-01-26 13:20:35 +03:00
|
|
|
if librados.found() and librbd.found()
|
|
|
|
if cc.links('''
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <rbd/librbd.h>
|
|
|
|
int main(void) {
|
|
|
|
rados_t cluster;
|
|
|
|
rados_create(&cluster, NULL);
|
2021-07-02 20:23:51 +03:00
|
|
|
#if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
|
|
|
|
#error
|
|
|
|
#endif
|
2021-01-26 13:20:35 +03:00
|
|
|
return 0;
|
|
|
|
}''', dependencies: [librbd, librados])
|
|
|
|
rbd = declare_dependency(dependencies: [librbd, librados])
|
|
|
|
elif get_option('rbd').enabled()
|
2021-07-02 20:23:51 +03:00
|
|
|
error('librbd >= 1.12.0 required')
|
2021-01-26 13:20:35 +03:00
|
|
|
else
|
2021-07-02 20:23:51 +03:00
|
|
|
warning('librbd >= 1.12.0 not found, disabling')
|
2021-01-26 13:20:35 +03:00
|
|
|
endif
|
2020-11-17 15:11:25 +03:00
|
|
|
endif
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2020-11-17 15:11:25 +03:00
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
glusterfs = not_found
|
2020-11-17 15:01:26 +03:00
|
|
|
glusterfs_ftruncate_has_stat = false
|
|
|
|
glusterfs_iocb_has_stat = false
|
|
|
|
if not get_option('glusterfs').auto() or have_block
|
|
|
|
glusterfs = dependency('glusterfs-api', version: '>=3',
|
|
|
|
required: get_option('glusterfs'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-11-17 15:01:26 +03:00
|
|
|
if glusterfs.found()
|
|
|
|
glusterfs_ftruncate_has_stat = cc.links('''
|
|
|
|
#include <glusterfs/api/glfs.h>
|
|
|
|
|
|
|
|
int
|
|
|
|
main(void)
|
|
|
|
{
|
|
|
|
/* new glfs_ftruncate() passes two additional args */
|
|
|
|
return glfs_ftruncate(NULL, 0, NULL, NULL);
|
|
|
|
}
|
|
|
|
''', dependencies: glusterfs)
|
|
|
|
glusterfs_iocb_has_stat = cc.links('''
|
|
|
|
#include <glusterfs/api/glfs.h>
|
|
|
|
|
|
|
|
/* new glfs_io_cbk() passes two additional glfs_stat structs */
|
|
|
|
static void
|
|
|
|
glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
|
|
|
|
{}
|
|
|
|
|
|
|
|
int
|
|
|
|
main(void)
|
|
|
|
{
|
|
|
|
glfs_io_cbk iocb = &glusterfs_iocb;
|
|
|
|
iocb(NULL, 0 , NULL, NULL, NULL);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
''', dependencies: glusterfs)
|
|
|
|
endif
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2021-12-09 17:48:01 +03:00
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
libssh = not_found
|
2021-12-09 17:48:01 +03:00
|
|
|
if not get_option('libssh').auto() or have_block
|
|
|
|
libssh = dependency('libssh', version: '>=0.8.7',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('libssh'),
|
|
|
|
kwargs: static_kwargs)
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2021-12-09 17:48:01 +03:00
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
libbzip2 = not_found
|
2020-11-17 15:07:52 +03:00
|
|
|
if not get_option('bzip2').auto() or have_block
|
|
|
|
libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
|
|
|
|
required: get_option('bzip2'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 15:07:52 +03:00
|
|
|
if libbzip2.found() and not cc.links('''
|
|
|
|
#include <bzlib.h>
|
|
|
|
int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
|
|
|
|
libbzip2 = not_found
|
|
|
|
if get_option('bzip2').enabled()
|
|
|
|
error('could not link libbzip2')
|
|
|
|
else
|
|
|
|
warning('could not link libbzip2, disabling')
|
|
|
|
endif
|
|
|
|
endif
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2020-11-17 15:35:28 +03:00
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
liblzfse = not_found
|
2020-11-17 15:35:28 +03:00
|
|
|
if not get_option('lzfse').auto() or have_block
|
|
|
|
liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
|
|
|
|
required: get_option('lzfse'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 15:35:28 +03:00
|
|
|
endif
|
|
|
|
if liblzfse.found() and not cc.links('''
|
|
|
|
#include <lzfse.h>
|
|
|
|
int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
|
|
|
|
liblzfse = not_found
|
|
|
|
if get_option('lzfse').enabled()
|
|
|
|
error('could not link liblzfse')
|
|
|
|
else
|
|
|
|
warning('could not link liblzfse, disabling')
|
|
|
|
endif
|
2019-08-29 21:34:43 +03:00
|
|
|
endif
|
2020-11-17 15:35:28 +03:00
|
|
|
|
2020-08-17 13:47:55 +03:00
|
|
|
oss = not_found
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('oss').allowed() and have_system
|
2021-10-07 16:06:09 +03:00
|
|
|
if not cc.has_header('sys/soundcard.h')
|
|
|
|
# not found
|
|
|
|
elif targetos == 'netbsd'
|
|
|
|
oss = cc.find_library('ossaudio', required: get_option('oss'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
else
|
|
|
|
oss = declare_dependency()
|
|
|
|
endif
|
|
|
|
|
|
|
|
if not oss.found()
|
|
|
|
if get_option('oss').enabled()
|
|
|
|
error('OSS not found')
|
|
|
|
endif
|
|
|
|
endif
|
2020-08-17 13:47:55 +03:00
|
|
|
endif
|
|
|
|
dsound = not_found
|
2021-10-07 16:06:09 +03:00
|
|
|
if not get_option('dsound').auto() or (targetos == 'windows' and have_system)
|
|
|
|
if cc.has_header('dsound.h')
|
|
|
|
dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
|
|
|
|
endif
|
|
|
|
|
|
|
|
if not dsound.found()
|
|
|
|
if get_option('dsound').enabled()
|
|
|
|
error('DirectSound not found')
|
|
|
|
endif
|
|
|
|
endif
|
2020-08-17 13:47:55 +03:00
|
|
|
endif
|
2021-10-07 16:06:09 +03:00
|
|
|
|
2020-08-17 13:47:55 +03:00
|
|
|
coreaudio = not_found
|
2021-10-07 16:06:09 +03:00
|
|
|
if not get_option('coreaudio').auto() or (targetos == 'darwin' and have_system)
|
|
|
|
coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
|
|
|
|
required: get_option('coreaudio'))
|
2019-07-16 22:21:02 +03:00
|
|
|
endif
|
2021-07-13 14:09:02 +03:00
|
|
|
|
2019-07-16 22:21:02 +03:00
|
|
|
opengl = not_found
|
2022-04-20 18:33:40 +03:00
|
|
|
if not get_option('opengl').auto() or have_system or have_vhost_user_gpu
|
|
|
|
epoxy = dependency('epoxy', method: 'pkg-config',
|
|
|
|
required: get_option('opengl'), kwargs: static_kwargs)
|
|
|
|
if cc.has_header('epoxy/egl.h', dependencies: epoxy)
|
|
|
|
opengl = epoxy
|
|
|
|
elif get_option('opengl').enabled()
|
|
|
|
error('epoxy/egl.h not found')
|
|
|
|
endif
|
2019-07-16 22:21:02 +03:00
|
|
|
endif
|
2021-07-13 14:09:02 +03:00
|
|
|
gbm = not_found
|
|
|
|
if (have_system or have_tools) and (virgl.found() or opengl.found())
|
|
|
|
gbm = dependency('gbm', method: 'pkg-config', required: false,
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
2021-12-17 14:36:26 +03:00
|
|
|
have_vhost_user_gpu = have_vhost_user_gpu and virgl.found() and gbm.found()
|
2021-01-07 16:02:29 +03:00
|
|
|
|
2021-06-03 12:15:26 +03:00
|
|
|
gnutls = not_found
|
2021-06-30 19:20:02 +03:00
|
|
|
gnutls_crypto = not_found
|
2021-08-06 17:49:47 +03:00
|
|
|
if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
|
2021-06-30 19:20:02 +03:00
|
|
|
# For general TLS support our min gnutls matches
|
|
|
|
# that implied by our platform support matrix
|
|
|
|
#
|
|
|
|
# For the crypto backends, we look for a newer
|
|
|
|
# gnutls:
|
|
|
|
#
|
|
|
|
# Version 3.6.8 is needed to get XTS
|
|
|
|
# Version 3.6.13 is needed to get PBKDF
|
|
|
|
# Version 3.6.14 is needed to get HW accelerated XTS
|
|
|
|
#
|
|
|
|
# If newer enough gnutls isn't available, we can
|
|
|
|
# still use a different crypto backend to satisfy
|
|
|
|
# the platform support requirements
|
|
|
|
gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: false,
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
if gnutls_crypto.found()
|
|
|
|
gnutls = gnutls_crypto
|
|
|
|
else
|
|
|
|
# Our min version if all we need is TLS
|
|
|
|
gnutls = dependency('gnutls', version: '>=3.5.18',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('gnutls'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
2021-06-03 12:15:26 +03:00
|
|
|
endif
|
|
|
|
|
2021-07-02 19:38:33 +03:00
|
|
|
# We prefer use of gnutls for crypto, unless the options
|
|
|
|
# explicitly asked for nettle or gcrypt.
|
|
|
|
#
|
|
|
|
# If gnutls isn't available for crypto, then we'll prefer
|
|
|
|
# gcrypt over nettle for performance reasons.
|
2021-06-03 12:15:26 +03:00
|
|
|
gcrypt = not_found
|
|
|
|
nettle = not_found
|
2022-05-25 12:01:14 +03:00
|
|
|
hogweed = not_found
|
2021-07-02 19:00:32 +03:00
|
|
|
xts = 'none'
|
2021-07-02 19:38:33 +03:00
|
|
|
|
2021-06-03 12:15:26 +03:00
|
|
|
if get_option('nettle').enabled() and get_option('gcrypt').enabled()
|
|
|
|
error('Only one of gcrypt & nettle can be enabled')
|
|
|
|
endif
|
2021-07-02 19:38:33 +03:00
|
|
|
|
|
|
|
# Explicit nettle/gcrypt request, so ignore gnutls for crypto
|
|
|
|
if get_option('nettle').enabled() or get_option('gcrypt').enabled()
|
2021-06-30 19:20:02 +03:00
|
|
|
gnutls_crypto = not_found
|
|
|
|
endif
|
2021-06-03 12:15:26 +03:00
|
|
|
|
2021-07-02 19:38:33 +03:00
|
|
|
if not gnutls_crypto.found()
|
|
|
|
if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
|
|
|
|
gcrypt = dependency('libgcrypt', version: '>=1.8',
|
|
|
|
method: 'config-tool',
|
|
|
|
required: get_option('gcrypt'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
# Debian has removed -lgpg-error from libgcrypt-config
|
|
|
|
# as it "spreads unnecessary dependencies" which in
|
|
|
|
# turn breaks static builds...
|
|
|
|
if gcrypt.found() and enable_static
|
|
|
|
gcrypt = declare_dependency(dependencies: [
|
|
|
|
gcrypt,
|
|
|
|
cc.find_library('gpg-error', required: true, kwargs: static_kwargs)])
|
|
|
|
endif
|
2021-06-03 12:15:26 +03:00
|
|
|
endif
|
2021-07-02 19:38:33 +03:00
|
|
|
if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
|
|
|
|
nettle = dependency('nettle', version: '>=3.4',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('nettle'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
|
|
|
|
xts = 'private'
|
|
|
|
endif
|
2021-06-03 12:15:26 +03:00
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2022-05-25 12:01:14 +03:00
|
|
|
gmp = dependency('gmp', required: false, method: 'pkg-config', kwargs: static_kwargs)
|
|
|
|
if nettle.found() and gmp.found()
|
|
|
|
hogweed = dependency('hogweed', version: '>=3.4',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('nettle'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
2019-07-16 22:21:02 +03:00
|
|
|
gtk = not_found
|
2021-01-07 16:02:29 +03:00
|
|
|
gtkx11 = not_found
|
2021-06-03 12:31:35 +03:00
|
|
|
vte = not_found
|
2021-01-07 16:04:00 +03:00
|
|
|
if not get_option('gtk').auto() or (have_system and not cocoa.found())
|
2021-01-07 16:02:29 +03:00
|
|
|
gtk = dependency('gtk+-3.0', version: '>=3.22.0',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('gtk'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2021-01-07 16:02:29 +03:00
|
|
|
if gtk.found()
|
|
|
|
gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: false,
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2021-01-07 16:02:29 +03:00
|
|
|
gtk = declare_dependency(dependencies: [gtk, gtkx11])
|
2021-06-03 12:31:35 +03:00
|
|
|
|
|
|
|
if not get_option('vte').auto() or have_system
|
|
|
|
vte = dependency('vte-2.91',
|
|
|
|
method: 'pkg-config',
|
|
|
|
required: get_option('vte'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
2021-01-07 16:02:29 +03:00
|
|
|
endif
|
2019-07-16 22:21:02 +03:00
|
|
|
endif
|
2021-01-07 16:02:29 +03:00
|
|
|
|
2019-07-16 22:21:02 +03:00
|
|
|
x11 = not_found
|
2021-05-03 11:40:33 +03:00
|
|
|
if gtkx11.found()
|
2021-01-07 16:02:29 +03:00
|
|
|
x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2019-07-16 22:21:02 +03:00
|
|
|
endif
|
|
|
|
png = not_found
|
2022-04-08 10:13:34 +03:00
|
|
|
if get_option('png').allowed() and have_system
|
|
|
|
png = dependency('libpng', required: get_option('png'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
|
|
|
endif
|
|
|
|
vnc = not_found
|
2019-07-16 22:21:02 +03:00
|
|
|
jpeg = not_found
|
|
|
|
sasl = not_found
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('vnc').allowed() and have_system
|
2020-02-06 17:48:52 +03:00
|
|
|
vnc = declare_dependency() # dummy dependency
|
2020-11-23 21:34:02 +03:00
|
|
|
jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-02-06 17:48:52 +03:00
|
|
|
sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
|
|
|
|
required: get_option('vnc_sasl'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-02-06 17:48:52 +03:00
|
|
|
if sasl.found()
|
|
|
|
sasl = declare_dependency(dependencies: sasl,
|
|
|
|
compile_args: '-DSTRUCT_IOVEC_DEFINED')
|
|
|
|
endif
|
2020-08-17 13:47:55 +03:00
|
|
|
endif
|
2020-11-17 15:32:34 +03:00
|
|
|
|
2021-06-03 12:15:26 +03:00
|
|
|
pam = not_found
|
|
|
|
if not get_option('auth_pam').auto() or have_system
|
|
|
|
pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
|
|
|
|
required: get_option('auth_pam'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
|
|
|
if pam.found() and not cc.links('''
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <security/pam_appl.h>
|
|
|
|
int main(void) {
|
|
|
|
const char *service_name = "qemu";
|
|
|
|
const char *user = "frank";
|
|
|
|
const struct pam_conv pam_conv = { 0 };
|
|
|
|
pam_handle_t *pamh = NULL;
|
|
|
|
pam_start(service_name, user, &pam_conv, &pamh);
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: pam)
|
|
|
|
pam = not_found
|
|
|
|
if get_option('auth_pam').enabled()
|
|
|
|
error('could not link libpam')
|
|
|
|
else
|
|
|
|
warning('could not link libpam, disabling')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2019-09-03 15:59:33 +03:00
|
|
|
snappy = not_found
|
2020-11-17 15:32:34 +03:00
|
|
|
if not get_option('snappy').auto() or have_system
|
|
|
|
snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
|
|
|
|
required: get_option('snappy'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 15:32:34 +03:00
|
|
|
endif
|
2021-11-04 16:35:14 +03:00
|
|
|
if snappy.found() and not linker.links('''
|
2020-11-17 15:32:34 +03:00
|
|
|
#include <snappy-c.h>
|
|
|
|
int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
|
|
|
|
snappy = not_found
|
|
|
|
if get_option('snappy').enabled()
|
|
|
|
error('could not link libsnappy')
|
|
|
|
else
|
|
|
|
warning('could not link libsnappy, disabling')
|
|
|
|
endif
|
2019-09-03 15:59:33 +03:00
|
|
|
endif
|
2020-11-17 15:11:25 +03:00
|
|
|
|
2019-09-03 15:59:33 +03:00
|
|
|
lzo = not_found
|
2020-11-17 15:11:25 +03:00
|
|
|
if not get_option('lzo').auto() or have_system
|
|
|
|
lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
|
|
|
|
required: get_option('lzo'),
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-11-17 15:11:25 +03:00
|
|
|
endif
|
|
|
|
if lzo.found() and not cc.links('''
|
|
|
|
#include <lzo/lzo1x.h>
|
|
|
|
int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
|
|
|
|
lzo = not_found
|
|
|
|
if get_option('lzo').enabled()
|
|
|
|
error('could not link liblzo2')
|
|
|
|
else
|
|
|
|
warning('could not link liblzo2, disabling')
|
|
|
|
endif
|
2019-09-03 15:59:33 +03:00
|
|
|
endif
|
2020-11-17 15:11:25 +03:00
|
|
|
|
2021-12-21 14:38:27 +03:00
|
|
|
numa = not_found
|
|
|
|
if not get_option('numa').auto() or have_system or have_tools
|
|
|
|
numa = cc.find_library('numa', has_headers: ['numa.h'],
|
|
|
|
required: get_option('numa'),
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
|
|
|
if numa.found() and not cc.links('''
|
|
|
|
#include <numa.h>
|
|
|
|
int main(void) { return numa_available(); }
|
|
|
|
''', dependencies: numa)
|
|
|
|
numa = not_found
|
|
|
|
if get_option('numa').enabled()
|
|
|
|
error('could not link numa')
|
|
|
|
else
|
|
|
|
warning('could not link numa, disabling')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2019-07-24 18:16:22 +03:00
|
|
|
rdma = not_found
|
2022-04-20 18:33:41 +03:00
|
|
|
if not get_option('rdma').auto() or have_system
|
|
|
|
libumad = cc.find_library('ibumad', required: get_option('rdma'))
|
|
|
|
rdma_libs = [cc.find_library('rdmacm', has_headers: ['rdma/rdma_cma.h'],
|
|
|
|
required: get_option('rdma'),
|
|
|
|
kwargs: static_kwargs),
|
|
|
|
cc.find_library('ibverbs', required: get_option('rdma'),
|
|
|
|
kwargs: static_kwargs),
|
|
|
|
libumad]
|
|
|
|
rdma = declare_dependency(dependencies: rdma_libs)
|
|
|
|
foreach lib: rdma_libs
|
|
|
|
if not lib.found()
|
|
|
|
rdma = not_found
|
|
|
|
endif
|
|
|
|
endforeach
|
2019-07-24 18:16:22 +03:00
|
|
|
endif
|
2022-04-20 18:33:41 +03:00
|
|
|
|
2019-08-15 14:15:32 +03:00
|
|
|
xen = not_found
|
2022-04-20 18:33:47 +03:00
|
|
|
if get_option('xen').enabled() or (get_option('xen').auto() and have_system)
|
|
|
|
xencontrol = dependency('xencontrol', required: false,
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
|
|
|
if xencontrol.found()
|
|
|
|
xen_pc = declare_dependency(version: xencontrol.version(),
|
|
|
|
dependencies: [
|
|
|
|
xencontrol,
|
|
|
|
# disabler: true makes xen_pc.found() return false if any is not found
|
|
|
|
dependency('xenstore', required: false,
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs,
|
|
|
|
disabler: true),
|
|
|
|
dependency('xenforeignmemory', required: false,
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs,
|
|
|
|
disabler: true),
|
|
|
|
dependency('xengnttab', required: false,
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs,
|
|
|
|
disabler: true),
|
|
|
|
dependency('xenevtchn', required: false,
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs,
|
|
|
|
disabler: true),
|
|
|
|
dependency('xendevicemodel', required: false,
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs,
|
|
|
|
disabler: true),
|
|
|
|
# optional, no "disabler: true"
|
|
|
|
dependency('xentoolcore', required: false,
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)])
|
|
|
|
if xen_pc.found()
|
|
|
|
xen = xen_pc
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
if not xen.found()
|
|
|
|
xen_tests = [ '4.11.0', '4.10.0', '4.9.0', '4.8.0', '4.7.1', '4.6.0', '4.5.0', '4.2.0' ]
|
|
|
|
xen_libs = {
|
|
|
|
'4.11.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
|
|
|
|
'4.10.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
|
|
|
|
'4.9.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
|
|
|
|
'4.8.0': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
|
|
|
|
'4.7.1': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
|
|
|
|
'4.6.0': [ 'xenstore', 'xenctrl' ],
|
|
|
|
'4.5.0': [ 'xenstore', 'xenctrl' ],
|
|
|
|
'4.2.0': [ 'xenstore', 'xenctrl' ],
|
|
|
|
}
|
|
|
|
xen_deps = {}
|
|
|
|
foreach ver: xen_tests
|
|
|
|
# cache the various library tests to avoid polluting the logs
|
|
|
|
xen_test_deps = []
|
|
|
|
foreach l: xen_libs[ver]
|
|
|
|
if l not in xen_deps
|
|
|
|
xen_deps += { l: cc.find_library(l, required: false) }
|
|
|
|
endif
|
|
|
|
xen_test_deps += xen_deps[l]
|
|
|
|
endforeach
|
|
|
|
|
|
|
|
# Use -D to pick just one of the test programs in scripts/xen-detect.c
|
|
|
|
xen_version = ver.split('.')
|
|
|
|
xen_ctrl_version = xen_version[0] + \
|
|
|
|
('0' + xen_version[1]).substring(-2) + \
|
|
|
|
('0' + xen_version[2]).substring(-2)
|
|
|
|
if cc.links(files('scripts/xen-detect.c'),
|
|
|
|
args: '-DCONFIG_XEN_CTRL_INTERFACE_VERSION=' + xen_ctrl_version,
|
|
|
|
dependencies: xen_test_deps)
|
|
|
|
xen = declare_dependency(version: ver, dependencies: xen_test_deps)
|
|
|
|
break
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
endif
|
|
|
|
if xen.found()
|
|
|
|
accelerators += 'CONFIG_XEN'
|
|
|
|
elif get_option('xen').enabled()
|
|
|
|
error('could not compile and link Xen test program')
|
|
|
|
endif
|
2019-08-15 14:15:32 +03:00
|
|
|
endif
|
2022-04-20 18:33:47 +03:00
|
|
|
have_xen_pci_passthrough = get_option('xen_pci_passthrough') \
|
|
|
|
.require(xen.found(),
|
|
|
|
error_message: 'Xen PCI passthrough requested but Xen not enabled') \
|
|
|
|
.require(targetos == 'linux',
|
|
|
|
error_message: 'Xen PCI passthrough not available on this platform') \
|
|
|
|
.allowed()
|
|
|
|
|
|
|
|
|
2020-08-06 14:07:39 +03:00
|
|
|
cacard = not_found
|
2021-06-03 12:15:26 +03:00
|
|
|
if not get_option('smartcard').auto() or have_system
|
|
|
|
cacard = dependency('libcacard', required: get_option('smartcard'),
|
|
|
|
version: '>=2.5.1', method: 'pkg-config',
|
|
|
|
kwargs: static_kwargs)
|
2020-08-06 14:07:39 +03:00
|
|
|
endif
|
2020-08-26 14:42:04 +03:00
|
|
|
u2f = not_found
|
|
|
|
if have_system
|
|
|
|
u2f = dependency('u2f-emu', required: get_option('u2f'),
|
|
|
|
method: 'pkg-config',
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-08-26 14:42:04 +03:00
|
|
|
endif
|
2022-05-19 15:38:57 +03:00
|
|
|
canokey = not_found
|
|
|
|
if have_system
|
|
|
|
canokey = dependency('canokey-qemu', required: get_option('canokey'),
|
|
|
|
method: 'pkg-config',
|
|
|
|
kwargs: static_kwargs)
|
|
|
|
endif
|
2020-08-06 14:07:39 +03:00
|
|
|
usbredir = not_found
|
2021-06-03 12:15:26 +03:00
|
|
|
if not get_option('usb_redir').auto() or have_system
|
|
|
|
usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
|
|
|
|
version: '>=0.6', method: 'pkg-config',
|
|
|
|
kwargs: static_kwargs)
|
2020-08-06 14:07:39 +03:00
|
|
|
endif
|
|
|
|
libusb = not_found
|
2021-06-03 12:15:26 +03:00
|
|
|
if not get_option('libusb').auto() or have_system
|
|
|
|
libusb = dependency('libusb-1.0', required: get_option('libusb'),
|
|
|
|
version: '>=1.0.13', method: 'pkg-config',
|
|
|
|
kwargs: static_kwargs)
|
2020-08-06 14:07:39 +03:00
|
|
|
endif
|
2021-06-03 12:15:26 +03:00
|
|
|
|
2019-08-18 18:51:17 +03:00
|
|
|
libpmem = not_found
|
2021-06-03 12:31:35 +03:00
|
|
|
if not get_option('libpmem').auto() or have_system
|
|
|
|
libpmem = dependency('libpmem', required: get_option('libpmem'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2019-08-18 18:51:17 +03:00
|
|
|
endif
|
2020-08-24 18:52:12 +03:00
|
|
|
libdaxctl = not_found
|
2021-06-03 12:31:35 +03:00
|
|
|
if not get_option('libdaxctl').auto() or have_system
|
|
|
|
libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
|
|
|
|
version: '>=57', method: 'pkg-config',
|
|
|
|
kwargs: static_kwargs)
|
2020-08-24 18:52:12 +03:00
|
|
|
endif
|
2020-08-28 14:07:20 +03:00
|
|
|
tasn1 = not_found
|
2021-06-03 12:15:26 +03:00
|
|
|
if gnutls.found()
|
|
|
|
tasn1 = dependency('libtasn1',
|
|
|
|
method: 'pkg-config',
|
|
|
|
kwargs: static_kwargs)
|
2020-08-28 14:07:20 +03:00
|
|
|
endif
|
2020-08-28 14:07:25 +03:00
|
|
|
keyutils = dependency('libkeyutils', required: false,
|
2021-01-26 13:15:33 +03:00
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2020-08-28 14:07:33 +03:00
|
|
|
has_gettid = cc.has_function('gettid')
|
|
|
|
|
2021-11-15 23:29:43 +03:00
|
|
|
# libselinux
|
|
|
|
selinux = dependency('libselinux',
|
|
|
|
required: get_option('selinux'),
|
|
|
|
method: 'pkg-config', kwargs: static_kwargs)
|
|
|
|
|
2020-09-01 18:15:30 +03:00
|
|
|
# Malloc tests
|
|
|
|
|
|
|
|
malloc = []
|
|
|
|
if get_option('malloc') == 'system'
|
|
|
|
has_malloc_trim = \
|
2021-12-18 18:39:43 +03:00
|
|
|
get_option('malloc_trim').allowed() and \
|
2020-09-01 18:15:30 +03:00
|
|
|
cc.links('''#include <malloc.h>
|
|
|
|
int main(void) { malloc_trim(0); return 0; }''')
|
|
|
|
else
|
|
|
|
has_malloc_trim = false
|
|
|
|
malloc = cc.find_library(get_option('malloc'), required: true)
|
|
|
|
endif
|
|
|
|
if not has_malloc_trim and get_option('malloc_trim').enabled()
|
|
|
|
if get_option('malloc') == 'system'
|
|
|
|
error('malloc_trim not available on this platform.')
|
|
|
|
else
|
|
|
|
error('malloc_trim not available with non-libc memory allocator')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2020-11-02 19:18:55 +03:00
|
|
|
# Check whether the glibc provides statx()
|
|
|
|
|
2021-06-03 13:10:05 +03:00
|
|
|
gnu_source_prefix = '''
|
2020-11-02 19:18:55 +03:00
|
|
|
#ifndef _GNU_SOURCE
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
#endif
|
2021-06-03 13:10:05 +03:00
|
|
|
'''
|
|
|
|
statx_test = gnu_source_prefix + '''
|
2020-11-02 19:18:55 +03:00
|
|
|
#include <sys/stat.h>
|
|
|
|
int main(void) {
|
|
|
|
struct statx statxbuf;
|
|
|
|
statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
|
|
|
|
return 0;
|
|
|
|
}'''
|
|
|
|
|
|
|
|
has_statx = cc.links(statx_test)
|
|
|
|
|
2022-02-23 12:23:40 +03:00
|
|
|
# Check whether statx() provides mount ID information
|
|
|
|
|
|
|
|
statx_mnt_id_test = gnu_source_prefix + '''
|
|
|
|
#include <sys/stat.h>
|
|
|
|
int main(void) {
|
|
|
|
struct statx statxbuf;
|
|
|
|
statx(0, "", 0, STATX_BASIC_STATS | STATX_MNT_ID, &statxbuf);
|
|
|
|
return statxbuf.stx_mnt_id;
|
|
|
|
}'''
|
|
|
|
|
|
|
|
has_statx_mnt_id = cc.links(statx_mnt_id_test)
|
|
|
|
|
meson: use .require() and .disable_auto_if() method for features
The method is now in 0.59, using it simplifies some conditionals.
There is a small change, which is to build virtfs-proxy-helper in a
tools-only build. This is done for consistency with other tools,
which are not culled by the absence of system emulator binaries.
.disable_auto_if() would also be useful to check for packages,
for example
-linux_io_uring = not_found
-if not get_option('linux_io_uring').auto() or have_block
- linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
+linux_io_uring = dependency('liburing',
+ required: get_option('linux_io_uring').disable_auto_if(not have_block),
+ method: 'pkg-config', kwargs: static_kwargs)
This change however is much larger and I am not sure about the improved
readability, so I am not performing it right now.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-12-18 18:39:43 +03:00
|
|
|
have_vhost_user_blk_server = get_option('vhost_user_blk_server') \
|
|
|
|
.require(targetos == 'linux',
|
|
|
|
error_message: 'vhost_user_blk_server requires linux') \
|
2022-04-20 18:34:05 +03:00
|
|
|
.require(have_vhost_user,
|
meson: use .require() and .disable_auto_if() method for features
The method is now in 0.59, using it simplifies some conditionals.
There is a small change, which is to build virtfs-proxy-helper in a
tools-only build. This is done for consistency with other tools,
which are not culled by the absence of system emulator binaries.
.disable_auto_if() would also be useful to check for packages,
for example
-linux_io_uring = not_found
-if not get_option('linux_io_uring').auto() or have_block
- linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
+linux_io_uring = dependency('liburing',
+ required: get_option('linux_io_uring').disable_auto_if(not have_block),
+ method: 'pkg-config', kwargs: static_kwargs)
This change however is much larger and I am not sure about the improved
readability, so I am not performing it right now.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-12-18 18:39:43 +03:00
|
|
|
error_message: 'vhost_user_blk_server requires vhost-user support') \
|
|
|
|
.disable_auto_if(not have_system) \
|
|
|
|
.allowed()
|
2020-12-05 02:06:14 +03:00
|
|
|
|
2020-10-27 22:05:46 +03:00
|
|
|
if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
|
|
|
|
error('Cannot enable fuse-lseek while fuse is disabled')
|
|
|
|
endif
|
|
|
|
|
2020-10-27 22:05:41 +03:00
|
|
|
fuse = dependency('fuse3', required: get_option('fuse'),
|
|
|
|
version: '>=3.1', method: 'pkg-config',
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs)
|
2020-10-27 22:05:41 +03:00
|
|
|
|
2020-10-27 22:05:46 +03:00
|
|
|
fuse_lseek = not_found
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('fuse_lseek').allowed()
|
2020-10-27 22:05:46 +03:00
|
|
|
if fuse.version().version_compare('>=3.8')
|
|
|
|
# Dummy dependency
|
|
|
|
fuse_lseek = declare_dependency()
|
|
|
|
elif get_option('fuse_lseek').enabled()
|
|
|
|
if fuse.found()
|
|
|
|
error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
|
|
|
|
else
|
|
|
|
error('fuse-lseek requires libfuse, which was not found')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2022-05-23 11:46:08 +03:00
|
|
|
have_libvduse = (targetos == 'linux')
|
|
|
|
if get_option('libvduse').enabled()
|
|
|
|
if targetos != 'linux'
|
|
|
|
error('libvduse requires linux')
|
|
|
|
endif
|
|
|
|
elif get_option('libvduse').disabled()
|
|
|
|
have_libvduse = false
|
|
|
|
endif
|
|
|
|
|
2022-05-23 11:46:09 +03:00
|
|
|
have_vduse_blk_export = (have_libvduse and targetos == 'linux')
|
|
|
|
if get_option('vduse_blk_export').enabled()
|
|
|
|
if targetos != 'linux'
|
|
|
|
error('vduse_blk_export requires linux')
|
|
|
|
elif not have_libvduse
|
|
|
|
error('vduse_blk_export requires libvduse support')
|
|
|
|
endif
|
|
|
|
elif get_option('vduse_blk_export').disabled()
|
|
|
|
have_vduse_blk_export = false
|
|
|
|
endif
|
|
|
|
|
2021-05-14 14:48:32 +03:00
|
|
|
# libbpf
|
|
|
|
libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
|
|
|
|
if libbpf.found() and not cc.links('''
|
|
|
|
#include <bpf/libbpf.h>
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
bpf_object__destroy_skeleton(NULL);
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: libbpf)
|
|
|
|
libbpf = not_found
|
|
|
|
if get_option('bpf').enabled()
|
|
|
|
error('libbpf skeleton test failed')
|
|
|
|
else
|
|
|
|
warning('libbpf skeleton test failed, disabling')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2021-10-07 16:06:09 +03:00
|
|
|
#################
|
|
|
|
# config-host.h #
|
|
|
|
#################
|
|
|
|
|
|
|
|
audio_drivers_selected = []
|
|
|
|
if have_system
|
|
|
|
audio_drivers_available = {
|
|
|
|
'alsa': alsa.found(),
|
|
|
|
'coreaudio': coreaudio.found(),
|
|
|
|
'dsound': dsound.found(),
|
|
|
|
'jack': jack.found(),
|
|
|
|
'oss': oss.found(),
|
|
|
|
'pa': pulse.found(),
|
|
|
|
'sdl': sdl.found(),
|
|
|
|
}
|
2021-10-07 16:06:10 +03:00
|
|
|
foreach k, v: audio_drivers_available
|
|
|
|
config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
|
|
|
|
endforeach
|
2021-10-07 16:06:09 +03:00
|
|
|
|
|
|
|
# Default to native drivers first, OSS second, SDL third
|
|
|
|
audio_drivers_priority = \
|
|
|
|
[ 'pa', 'coreaudio', 'dsound', 'oss' ] + \
|
|
|
|
(targetos == 'linux' ? [] : [ 'sdl' ])
|
|
|
|
audio_drivers_default = []
|
|
|
|
foreach k: audio_drivers_priority
|
|
|
|
if audio_drivers_available[k]
|
|
|
|
audio_drivers_default += k
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
|
|
|
|
foreach k: get_option('audio_drv_list')
|
|
|
|
if k == 'default'
|
|
|
|
audio_drivers_selected += audio_drivers_default
|
|
|
|
elif not audio_drivers_available[k]
|
|
|
|
error('Audio driver "@0@" not available.'.format(k))
|
|
|
|
else
|
|
|
|
audio_drivers_selected += k
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
endif
|
|
|
|
config_host_data.set('CONFIG_AUDIO_DRIVERS',
|
|
|
|
'"' + '", "'.join(audio_drivers_selected) + '", ')
|
|
|
|
|
2020-12-05 02:06:14 +03:00
|
|
|
if get_option('cfi')
|
|
|
|
cfi_flags=[]
|
|
|
|
# Check for dependency on LTO
|
|
|
|
if not get_option('b_lto')
|
|
|
|
error('Selected Control-Flow Integrity but LTO is disabled')
|
|
|
|
endif
|
|
|
|
if config_host.has_key('CONFIG_MODULES')
|
|
|
|
error('Selected Control-Flow Integrity is not compatible with modules')
|
|
|
|
endif
|
|
|
|
# Check for cfi flags. CFI requires LTO so we can't use
|
|
|
|
# get_supported_arguments, but need a more complex "compiles" which allows
|
|
|
|
# custom arguments
|
|
|
|
if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
|
|
|
|
args: ['-flto', '-fsanitize=cfi-icall'] )
|
|
|
|
cfi_flags += '-fsanitize=cfi-icall'
|
|
|
|
else
|
|
|
|
error('-fsanitize=cfi-icall is not supported by the compiler')
|
|
|
|
endif
|
|
|
|
if cc.compiles('int main () { return 0; }',
|
|
|
|
name: '-fsanitize-cfi-icall-generalize-pointers',
|
|
|
|
args: ['-flto', '-fsanitize=cfi-icall',
|
|
|
|
'-fsanitize-cfi-icall-generalize-pointers'] )
|
|
|
|
cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
|
|
|
|
else
|
|
|
|
error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
|
|
|
|
endif
|
|
|
|
if get_option('cfi_debug')
|
|
|
|
if cc.compiles('int main () { return 0; }',
|
|
|
|
name: '-fno-sanitize-trap=cfi-icall',
|
|
|
|
args: ['-flto', '-fsanitize=cfi-icall',
|
|
|
|
'-fno-sanitize-trap=cfi-icall'] )
|
|
|
|
cfi_flags += '-fno-sanitize-trap=cfi-icall'
|
|
|
|
else
|
|
|
|
error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
|
|
|
|
endif
|
|
|
|
endif
|
2021-01-14 15:56:02 +03:00
|
|
|
add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
|
|
|
|
add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
|
2020-12-05 02:06:14 +03:00
|
|
|
endif
|
|
|
|
|
2021-03-15 21:03:38 +03:00
|
|
|
have_host_block_device = (targetos != 'darwin' or
|
|
|
|
cc.has_header('IOKit/storage/IOMedia.h'))
|
|
|
|
|
meson: use .require() and .disable_auto_if() method for features
The method is now in 0.59, using it simplifies some conditionals.
There is a small change, which is to build virtfs-proxy-helper in a
tools-only build. This is done for consistency with other tools,
which are not culled by the absence of system emulator binaries.
.disable_auto_if() would also be useful to check for packages,
for example
-linux_io_uring = not_found
-if not get_option('linux_io_uring').auto() or have_block
- linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
+linux_io_uring = dependency('liburing',
+ required: get_option('linux_io_uring').disable_auto_if(not have_block),
+ method: 'pkg-config', kwargs: static_kwargs)
This change however is much larger and I am not sure about the improved
readability, so I am not performing it right now.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-12-18 18:39:43 +03:00
|
|
|
# FIXME enable_modules shouldn't be necessary, but: https://github.com/mesonbuild/meson/issues/8333
|
|
|
|
dbus_display = get_option('dbus_display') \
|
|
|
|
.require(gio.version().version_compare('>=2.64'),
|
|
|
|
error_message: '-display dbus requires glib>=2.64') \
|
|
|
|
.require(enable_modules,
|
|
|
|
error_message: '-display dbus requires --enable-modules') \
|
2022-04-20 18:33:44 +03:00
|
|
|
.require(gdbus_codegen.found(),
|
meson: use .require() and .disable_auto_if() method for features
The method is now in 0.59, using it simplifies some conditionals.
There is a small change, which is to build virtfs-proxy-helper in a
tools-only build. This is done for consistency with other tools,
which are not culled by the absence of system emulator binaries.
.disable_auto_if() would also be useful to check for packages,
for example
-linux_io_uring = not_found
-if not get_option('linux_io_uring').auto() or have_block
- linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
+linux_io_uring = dependency('liburing',
+ required: get_option('linux_io_uring').disable_auto_if(not have_block),
+ method: 'pkg-config', kwargs: static_kwargs)
This change however is much larger and I am not sure about the improved
readability, so I am not performing it right now.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-12-18 18:39:43 +03:00
|
|
|
error_message: '-display dbus requires gdbus-codegen') \
|
|
|
|
.allowed()
|
|
|
|
|
|
|
|
have_virtfs = get_option('virtfs') \
|
2022-02-28 01:35:22 +03:00
|
|
|
.require(targetos == 'linux' or targetos == 'darwin',
|
|
|
|
error_message: 'virtio-9p (virtfs) requires Linux or macOS') \
|
|
|
|
.require(targetos == 'linux' or cc.has_function('pthread_fchdir_np'),
|
|
|
|
error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \
|
|
|
|
.require(targetos == 'darwin' or (libattr.found() and libcap_ng.found()),
|
|
|
|
error_message: 'virtio-9p (virtfs) on Linux requires libcap-ng-devel and libattr-devel') \
|
meson: use .require() and .disable_auto_if() method for features
The method is now in 0.59, using it simplifies some conditionals.
There is a small change, which is to build virtfs-proxy-helper in a
tools-only build. This is done for consistency with other tools,
which are not culled by the absence of system emulator binaries.
.disable_auto_if() would also be useful to check for packages,
for example
-linux_io_uring = not_found
-if not get_option('linux_io_uring').auto() or have_block
- linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
- method: 'pkg-config', kwargs: static_kwargs)
-endif
+linux_io_uring = dependency('liburing',
+ required: get_option('linux_io_uring').disable_auto_if(not have_block),
+ method: 'pkg-config', kwargs: static_kwargs)
This change however is much larger and I am not sure about the improved
readability, so I am not performing it right now.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-12-18 18:39:43 +03:00
|
|
|
.disable_auto_if(not have_tools and not have_system) \
|
|
|
|
.allowed()
|
2020-11-17 16:46:21 +03:00
|
|
|
|
2022-02-28 01:35:22 +03:00
|
|
|
have_virtfs_proxy_helper = targetos != 'darwin' and have_virtfs and have_tools
|
2021-01-20 18:15:39 +03:00
|
|
|
|
2022-04-20 18:33:53 +03:00
|
|
|
if get_option('block_drv_ro_whitelist') == ''
|
|
|
|
config_host_data.set('CONFIG_BDRV_RO_WHITELIST', '')
|
|
|
|
else
|
|
|
|
config_host_data.set('CONFIG_BDRV_RO_WHITELIST',
|
|
|
|
'"' + get_option('block_drv_ro_whitelist').replace(',', '", "') + '", ')
|
|
|
|
endif
|
|
|
|
if get_option('block_drv_rw_whitelist') == ''
|
|
|
|
config_host_data.set('CONFIG_BDRV_RW_WHITELIST', '')
|
|
|
|
else
|
|
|
|
config_host_data.set('CONFIG_BDRV_RW_WHITELIST',
|
|
|
|
'"' + get_option('block_drv_rw_whitelist').replace(',', '", "') + '", ')
|
|
|
|
endif
|
|
|
|
|
2021-10-07 16:08:14 +03:00
|
|
|
foreach k : get_option('trace_backends')
|
|
|
|
config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
|
|
|
|
endforeach
|
|
|
|
config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
|
2022-04-20 18:33:52 +03:00
|
|
|
config_host_data.set_quoted('CONFIG_TLS_PRIORITY', get_option('tls_priority'))
|
2022-04-20 18:33:49 +03:00
|
|
|
if iasl.found()
|
|
|
|
config_host_data.set_quoted('CONFIG_IASL', iasl.full_path())
|
2021-10-13 14:19:00 +03:00
|
|
|
endif
|
2020-10-16 10:19:14 +03:00
|
|
|
config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
|
|
|
|
config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
|
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
|
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
|
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
|
2022-04-20 18:33:56 +03:00
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('prefix') / get_option('qemu_firmwarepath'))
|
2020-10-16 10:19:14 +03:00
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
|
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
|
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
|
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
|
|
|
|
config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
|
|
|
|
config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
|
|
|
|
|
2022-04-20 18:33:54 +03:00
|
|
|
if config_host.has_key('CONFIG_MODULES')
|
|
|
|
config_host_data.set('CONFIG_STAMP', run_command(
|
|
|
|
meson.current_source_dir() / 'scripts/qemu-stamp.py',
|
|
|
|
meson.project_version(), get_option('pkgversion'), '--',
|
|
|
|
meson.current_source_dir() / 'configure',
|
|
|
|
capture: true, check: true).stdout().strip())
|
|
|
|
endif
|
|
|
|
|
2021-10-13 14:43:36 +03:00
|
|
|
have_slirp_smbd = get_option('slirp_smbd') \
|
|
|
|
.require(targetos != 'windows', error_message: 'Host smbd not supported on this platform.') \
|
|
|
|
.allowed()
|
|
|
|
if have_slirp_smbd
|
|
|
|
smbd_path = get_option('smbd')
|
|
|
|
if smbd_path == ''
|
|
|
|
smbd_path = (targetos == 'solaris' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd')
|
|
|
|
endif
|
|
|
|
config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path)
|
|
|
|
endif
|
|
|
|
|
2021-11-08 16:18:17 +03:00
|
|
|
config_host_data.set('HOST_' + host_arch.to_upper(), 1)
|
|
|
|
|
2022-04-20 18:33:46 +03:00
|
|
|
if get_option('module_upgrades') and not enable_modules
|
|
|
|
error('Cannot enable module-upgrades as modules are not enabled')
|
|
|
|
endif
|
|
|
|
config_host_data.set('CONFIG_MODULE_UPGRADES', get_option('module_upgrades'))
|
|
|
|
|
2020-11-17 16:45:24 +03:00
|
|
|
config_host_data.set('CONFIG_ATTR', libattr.found())
|
2021-10-13 12:46:09 +03:00
|
|
|
config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools'))
|
2020-11-17 15:02:17 +03:00
|
|
|
config_host_data.set('CONFIG_BRLAPI', brlapi.found())
|
2020-09-01 18:28:59 +03:00
|
|
|
config_host_data.set('CONFIG_COCOA', cocoa.found())
|
2021-10-07 16:08:12 +03:00
|
|
|
config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
|
2021-10-07 16:08:17 +03:00
|
|
|
config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
|
2020-09-16 18:54:14 +03:00
|
|
|
config_host_data.set('CONFIG_LIBUDEV', libudev.found())
|
2020-11-17 15:11:25 +03:00
|
|
|
config_host_data.set('CONFIG_LZO', lzo.found())
|
2020-09-16 19:07:29 +03:00
|
|
|
config_host_data.set('CONFIG_MPATH', mpathpersist.found())
|
|
|
|
config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
|
2020-11-17 14:43:15 +03:00
|
|
|
config_host_data.set('CONFIG_CURL', curl.found())
|
2020-10-13 02:43:48 +03:00
|
|
|
config_host_data.set('CONFIG_CURSES', curses.found())
|
2021-07-13 14:09:02 +03:00
|
|
|
config_host_data.set('CONFIG_GBM', gbm.found())
|
2022-04-20 18:33:44 +03:00
|
|
|
config_host_data.set('CONFIG_GIO', gio.found())
|
2020-11-17 15:01:26 +03:00
|
|
|
config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
|
|
|
|
if glusterfs.found()
|
|
|
|
config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
|
|
|
|
config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
|
|
|
|
config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
|
|
|
|
config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
|
|
|
|
config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
|
|
|
|
config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
|
|
|
|
endif
|
2021-01-07 16:02:29 +03:00
|
|
|
config_host_data.set('CONFIG_GTK', gtk.found())
|
2021-06-03 12:31:35 +03:00
|
|
|
config_host_data.set('CONFIG_VTE', vte.found())
|
2020-11-17 16:45:24 +03:00
|
|
|
config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
|
2020-11-17 16:46:58 +03:00
|
|
|
config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
|
2021-05-14 14:48:32 +03:00
|
|
|
config_host_data.set('CONFIG_EBPF', libbpf.found())
|
meson: fix missing preprocessor symbols
While most libraries do not need a CONFIG_* symbol because the
"when:" clauses are enough, some do. Add them back or stop
using them if possible.
In the case of libpmem, the statement to add the CONFIG_* symbol
was still in configure, but could not be triggered because it
checked for "no" instead of "disabled" (and it would be wrong anyway
since the test for the library has not been done yet).
Reported-by: Li Zhijian <lizhijian@cn.fujitsu.com>
Fixes: 587d59d6cc ("configure, meson: convert virgl detection to meson", 2021-07-06)
Fixes: 83ef16821a ("configure, meson: convert libdaxctl detection to meson", 2021-07-06)
Fixes: e36e8c70f6 ("configure, meson: convert libpmem detection to meson", 2021-07-06)
Fixes: 53c22b68e3 ("configure, meson: convert liburing detection to meson", 2021-07-06)
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-07-08 14:50:06 +03:00
|
|
|
config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
|
2020-11-17 15:11:25 +03:00
|
|
|
config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
|
2020-11-17 15:11:25 +03:00
|
|
|
config_host_data.set('CONFIG_LIBNFS', libnfs.found())
|
2021-12-09 17:48:01 +03:00
|
|
|
config_host_data.set('CONFIG_LIBSSH', libssh.found())
|
2021-10-07 16:08:20 +03:00
|
|
|
config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
|
meson: fix missing preprocessor symbols
While most libraries do not need a CONFIG_* symbol because the
"when:" clauses are enough, some do. Add them back or stop
using them if possible.
In the case of libpmem, the statement to add the CONFIG_* symbol
was still in configure, but could not be triggered because it
checked for "no" instead of "disabled" (and it would be wrong anyway
since the test for the library has not been done yet).
Reported-by: Li Zhijian <lizhijian@cn.fujitsu.com>
Fixes: 587d59d6cc ("configure, meson: convert virgl detection to meson", 2021-07-06)
Fixes: 83ef16821a ("configure, meson: convert libdaxctl detection to meson", 2021-07-06)
Fixes: e36e8c70f6 ("configure, meson: convert libpmem detection to meson", 2021-07-06)
Fixes: 53c22b68e3 ("configure, meson: convert liburing detection to meson", 2021-07-06)
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-07-08 14:50:06 +03:00
|
|
|
config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
|
2022-05-31 13:50:11 +03:00
|
|
|
config_host_data.set('CONFIG_LIBURING_REGISTER_RING_FD', cc.has_function('io_uring_register_ring_fd', prefix: '#include <liburing.h>', dependencies:linux_io_uring))
|
meson: fix missing preprocessor symbols
While most libraries do not need a CONFIG_* symbol because the
"when:" clauses are enough, some do. Add them back or stop
using them if possible.
In the case of libpmem, the statement to add the CONFIG_* symbol
was still in configure, but could not be triggered because it
checked for "no" instead of "disabled" (and it would be wrong anyway
since the test for the library has not been done yet).
Reported-by: Li Zhijian <lizhijian@cn.fujitsu.com>
Fixes: 587d59d6cc ("configure, meson: convert virgl detection to meson", 2021-07-06)
Fixes: 83ef16821a ("configure, meson: convert libdaxctl detection to meson", 2021-07-06)
Fixes: e36e8c70f6 ("configure, meson: convert libpmem detection to meson", 2021-07-06)
Fixes: 53c22b68e3 ("configure, meson: convert liburing detection to meson", 2021-07-06)
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-07-08 14:50:06 +03:00
|
|
|
config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
|
2021-12-21 14:38:27 +03:00
|
|
|
config_host_data.set('CONFIG_NUMA', numa.found())
|
2022-04-20 18:33:40 +03:00
|
|
|
config_host_data.set('CONFIG_OPENGL', opengl.found())
|
2021-10-13 12:46:09 +03:00
|
|
|
config_host_data.set('CONFIG_PROFILER', get_option('profiler'))
|
2020-11-17 15:11:25 +03:00
|
|
|
config_host_data.set('CONFIG_RBD', rbd.found())
|
2022-04-20 18:33:41 +03:00
|
|
|
config_host_data.set('CONFIG_RDMA', rdma.found())
|
2020-02-06 16:17:15 +03:00
|
|
|
config_host_data.set('CONFIG_SDL', sdl.found())
|
|
|
|
config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
|
2020-11-17 16:22:24 +03:00
|
|
|
config_host_data.set('CONFIG_SECCOMP', seccomp.found())
|
2020-11-17 15:32:34 +03:00
|
|
|
config_host_data.set('CONFIG_SNAPPY', snappy.found())
|
2021-12-21 14:38:27 +03:00
|
|
|
config_host_data.set('CONFIG_TPM', have_tpm)
|
2021-06-03 12:15:26 +03:00
|
|
|
config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
|
2021-10-07 16:08:21 +03:00
|
|
|
config_host_data.set('CONFIG_VDE', vde.found())
|
2022-04-20 18:34:07 +03:00
|
|
|
config_host_data.set('CONFIG_VHOST_NET', have_vhost_net)
|
|
|
|
config_host_data.set('CONFIG_VHOST_NET_USER', have_vhost_net_user)
|
|
|
|
config_host_data.set('CONFIG_VHOST_NET_VDPA', have_vhost_net_vdpa)
|
|
|
|
config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel)
|
|
|
|
config_host_data.set('CONFIG_VHOST_USER', have_vhost_user)
|
|
|
|
config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto)
|
|
|
|
config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa)
|
2022-03-17 20:28:33 +03:00
|
|
|
config_host_data.set('CONFIG_VMNET', vmnet.found())
|
2020-11-10 20:11:19 +03:00
|
|
|
config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
|
2022-05-23 11:46:09 +03:00
|
|
|
config_host_data.set('CONFIG_VDUSE_BLK_EXPORT', have_vduse_blk_export)
|
2022-04-08 10:13:34 +03:00
|
|
|
config_host_data.set('CONFIG_PNG', png.found())
|
2020-02-06 17:48:52 +03:00
|
|
|
config_host_data.set('CONFIG_VNC', vnc.found())
|
|
|
|
config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
|
|
|
|
config_host_data.set('CONFIG_VNC_SASL', sasl.found())
|
2020-11-17 16:46:21 +03:00
|
|
|
config_host_data.set('CONFIG_VIRTFS', have_virtfs)
|
meson: fix missing preprocessor symbols
While most libraries do not need a CONFIG_* symbol because the
"when:" clauses are enough, some do. Add them back or stop
using them if possible.
In the case of libpmem, the statement to add the CONFIG_* symbol
was still in configure, but could not be triggered because it
checked for "no" instead of "disabled" (and it would be wrong anyway
since the test for the library has not been done yet).
Reported-by: Li Zhijian <lizhijian@cn.fujitsu.com>
Fixes: 587d59d6cc ("configure, meson: convert virgl detection to meson", 2021-07-06)
Fixes: 83ef16821a ("configure, meson: convert libdaxctl detection to meson", 2021-07-06)
Fixes: e36e8c70f6 ("configure, meson: convert libpmem detection to meson", 2021-07-06)
Fixes: 53c22b68e3 ("configure, meson: convert liburing detection to meson", 2021-07-06)
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-07-08 14:50:06 +03:00
|
|
|
config_host_data.set('CONFIG_VTE', vte.found())
|
2020-08-24 18:24:29 +03:00
|
|
|
config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
|
2020-08-28 14:07:25 +03:00
|
|
|
config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
|
2020-08-28 14:07:33 +03:00
|
|
|
config_host_data.set('CONFIG_GETTID', has_gettid)
|
2021-06-03 12:15:26 +03:00
|
|
|
config_host_data.set('CONFIG_GNUTLS', gnutls.found())
|
2021-06-30 19:20:02 +03:00
|
|
|
config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
|
2022-04-26 19:00:43 +03:00
|
|
|
config_host_data.set('CONFIG_TASN1', tasn1.found())
|
2021-06-03 12:15:26 +03:00
|
|
|
config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
|
|
|
|
config_host_data.set('CONFIG_NETTLE', nettle.found())
|
2022-05-25 12:01:14 +03:00
|
|
|
config_host_data.set('CONFIG_HOGWEED', hogweed.found())
|
2021-06-03 12:15:26 +03:00
|
|
|
config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
|
2020-09-01 18:15:30 +03:00
|
|
|
config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
|
2020-11-02 19:18:55 +03:00
|
|
|
config_host_data.set('CONFIG_STATX', has_statx)
|
2022-02-23 12:23:40 +03:00
|
|
|
config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id)
|
2020-11-17 15:37:39 +03:00
|
|
|
config_host_data.set('CONFIG_ZSTD', zstd.found())
|
2020-10-27 22:05:41 +03:00
|
|
|
config_host_data.set('CONFIG_FUSE', fuse.found())
|
2020-10-27 22:05:46 +03:00
|
|
|
config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
|
2021-10-07 16:08:23 +03:00
|
|
|
config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
|
2021-10-06 13:18:09 +03:00
|
|
|
if spice_protocol.found()
|
|
|
|
config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
|
|
|
|
config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
|
|
|
|
config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
|
|
|
|
endif
|
2021-10-07 16:08:23 +03:00
|
|
|
config_host_data.set('CONFIG_SPICE', spice.found())
|
2021-01-07 15:54:22 +03:00
|
|
|
config_host_data.set('CONFIG_X11', x11.found())
|
2021-07-15 10:53:53 +03:00
|
|
|
config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
|
2020-12-05 02:06:14 +03:00
|
|
|
config_host_data.set('CONFIG_CFI', get_option('cfi'))
|
2021-11-15 23:29:43 +03:00
|
|
|
config_host_data.set('CONFIG_SELINUX', selinux.found())
|
2022-04-20 18:33:47 +03:00
|
|
|
config_host_data.set('CONFIG_XEN_BACKEND', xen.found())
|
|
|
|
if xen.found()
|
|
|
|
# protect from xen.version() having less than three components
|
|
|
|
xen_version = xen.version().split('.') + ['0', '0']
|
|
|
|
xen_ctrl_version = xen_version[0] + \
|
|
|
|
('0' + xen_version[1]).substring(-2) + \
|
|
|
|
('0' + xen_version[2]).substring(-2)
|
|
|
|
config_host_data.set('CONFIG_XEN_CTRL_INTERFACE_VERSION', xen_ctrl_version)
|
|
|
|
endif
|
2020-08-04 19:14:26 +03:00
|
|
|
config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
|
|
|
|
config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
|
|
|
|
config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
|
|
|
|
config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
|
|
|
|
|
2021-10-07 16:08:15 +03:00
|
|
|
config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
|
2021-06-03 12:56:11 +03:00
|
|
|
config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
|
|
|
|
|
2021-10-13 12:52:03 +03:00
|
|
|
have_coroutine_pool = get_option('coroutine_pool')
|
|
|
|
if get_option('debug_stack_usage') and have_coroutine_pool
|
|
|
|
message('Disabling coroutine pool to measure stack usage')
|
|
|
|
have_coroutine_pool = false
|
|
|
|
endif
|
|
|
|
config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool)
|
2021-10-13 12:46:09 +03:00
|
|
|
config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
|
2021-10-13 12:52:03 +03:00
|
|
|
config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
|
2021-10-13 12:46:09 +03:00
|
|
|
config_host_data.set('CONFIG_GPROF', get_option('gprof'))
|
2021-10-13 12:43:54 +03:00
|
|
|
config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
|
2021-10-13 12:46:09 +03:00
|
|
|
config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
|
2021-10-13 12:43:54 +03:00
|
|
|
config_host_data.set('CONFIG_REPLICATION', get_option('live_block_migration').allowed())
|
|
|
|
|
2021-06-03 12:56:11 +03:00
|
|
|
# has_header
|
2021-06-03 13:10:05 +03:00
|
|
|
config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
|
2021-06-03 13:02:00 +03:00
|
|
|
config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
|
|
|
|
config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
|
2020-11-18 20:10:52 +03:00
|
|
|
config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
|
2020-11-18 20:10:49 +03:00
|
|
|
config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
|
2020-11-18 20:10:48 +03:00
|
|
|
config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
|
2021-06-03 12:56:11 +03:00
|
|
|
config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
|
2020-11-14 13:10:11 +03:00
|
|
|
config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
|
2020-11-18 20:10:51 +03:00
|
|
|
config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
|
2020-11-14 13:10:11 +03:00
|
|
|
|
2021-06-03 12:56:11 +03:00
|
|
|
# has_function
|
2021-06-03 14:04:47 +03:00
|
|
|
config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
|
2021-06-03 13:10:05 +03:00
|
|
|
config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
|
|
|
|
config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
|
|
|
|
config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
|
|
|
|
config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
|
2022-02-26 21:07:19 +03:00
|
|
|
# Note that we need to specify prefix: here to avoid incorrectly
|
|
|
|
# thinking that Windows has posix_memalign()
|
|
|
|
config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
|
2022-02-26 21:07:20 +03:00
|
|
|
config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
|
2022-02-26 21:07:21 +03:00
|
|
|
config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
|
|
|
|
config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
|
2021-06-03 13:10:05 +03:00
|
|
|
config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
|
2021-01-26 18:58:46 +03:00
|
|
|
config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
|
2022-02-28 01:35:20 +03:00
|
|
|
config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
|
2021-06-03 13:10:05 +03:00
|
|
|
config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
|
|
|
|
config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
|
|
|
|
config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
|
|
|
|
config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
|
|
|
|
config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
|
2021-06-03 13:02:00 +03:00
|
|
|
config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
|
2022-04-26 22:55:22 +03:00
|
|
|
config_host_data.set('HAVE_GETIFADDRS', cc.has_function('getifaddrs'))
|
2021-06-03 13:10:05 +03:00
|
|
|
config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
|
2021-06-03 13:14:48 +03:00
|
|
|
config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
|
2021-06-03 12:56:11 +03:00
|
|
|
config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
|
2022-05-17 10:10:12 +03:00
|
|
|
if rbd.found()
|
|
|
|
config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS',
|
|
|
|
cc.has_function('rbd_namespace_exists',
|
|
|
|
dependencies: rbd,
|
|
|
|
prefix: '#include <rbd/librbd.h>'))
|
|
|
|
endif
|
2021-09-10 10:02:55 +03:00
|
|
|
if rdma.found()
|
|
|
|
config_host_data.set('HAVE_IBV_ADVISE_MR',
|
|
|
|
cc.has_function('ibv_advise_mr',
|
2022-04-20 18:33:41 +03:00
|
|
|
dependencies: rdma,
|
2021-09-10 10:02:55 +03:00
|
|
|
prefix: '#include <infiniband/verbs.h>'))
|
|
|
|
endif
|
2021-01-26 18:58:46 +03:00
|
|
|
|
2021-06-03 13:10:05 +03:00
|
|
|
# has_header_symbol
|
|
|
|
config_host_data.set('CONFIG_BYTESWAP_H',
|
|
|
|
cc.has_header_symbol('byteswap.h', 'bswap_32'))
|
|
|
|
config_host_data.set('CONFIG_EPOLL_CREATE1',
|
|
|
|
cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
|
|
|
|
config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
|
|
|
|
cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
|
|
|
|
cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
|
|
|
|
config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
|
|
|
|
cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
|
|
|
|
config_host_data.set('CONFIG_FIEMAP',
|
|
|
|
cc.has_header('linux/fiemap.h') and
|
|
|
|
cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
|
2021-06-03 13:02:00 +03:00
|
|
|
config_host_data.set('CONFIG_GETRANDOM',
|
|
|
|
cc.has_function('getrandom') and
|
|
|
|
cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
|
2021-06-03 14:04:47 +03:00
|
|
|
config_host_data.set('CONFIG_INOTIFY',
|
|
|
|
cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
|
|
|
|
config_host_data.set('CONFIG_INOTIFY1',
|
|
|
|
cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
|
2021-06-03 13:10:05 +03:00
|
|
|
config_host_data.set('CONFIG_MACHINE_BSWAP_H',
|
|
|
|
cc.has_header_symbol('machine/bswap.h', 'bswap32',
|
|
|
|
prefix: '''#include <sys/endian.h>
|
|
|
|
#include <sys/types.h>'''))
|
|
|
|
config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
|
|
|
|
cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
|
2021-06-03 13:02:00 +03:00
|
|
|
config_host_data.set('CONFIG_RTNETLINK',
|
|
|
|
cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
|
|
|
|
config_host_data.set('CONFIG_SYSMACROS',
|
|
|
|
cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
|
2021-06-03 13:02:00 +03:00
|
|
|
config_host_data.set('HAVE_OPTRESET',
|
|
|
|
cc.has_header_symbol('getopt.h', 'optreset'))
|
2021-09-07 15:19:13 +03:00
|
|
|
config_host_data.set('HAVE_IPPROTO_MPTCP',
|
|
|
|
cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
|
2021-06-03 13:10:05 +03:00
|
|
|
|
|
|
|
# has_member
|
|
|
|
config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
|
|
|
|
cc.has_member('struct sigevent', 'sigev_notify_thread_id',
|
|
|
|
prefix: '#include <signal.h>'))
|
2021-06-03 13:14:48 +03:00
|
|
|
config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
|
|
|
|
cc.has_member('struct stat', 'st_atim',
|
|
|
|
prefix: '#include <sys/stat.h>'))
|
2021-06-03 13:10:05 +03:00
|
|
|
|
2021-11-16 10:28:29 +03:00
|
|
|
# has_type
|
|
|
|
config_host_data.set('CONFIG_IOVEC',
|
|
|
|
cc.has_type('struct iovec',
|
|
|
|
prefix: '#include <sys/uio.h>'))
|
|
|
|
config_host_data.set('HAVE_UTMPX',
|
|
|
|
cc.has_type('struct utmpx',
|
|
|
|
prefix: '#include <utmpx.h>'))
|
|
|
|
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_EVENTFD', cc.links('''
|
2021-06-03 13:02:00 +03:00
|
|
|
#include <sys/eventfd.h>
|
|
|
|
int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
|
2021-06-03 13:02:00 +03:00
|
|
|
#include <unistd.h>
|
|
|
|
int main(void) {
|
|
|
|
#if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
|
|
|
|
return fdatasync(0);
|
|
|
|
#else
|
|
|
|
#error Not supported
|
|
|
|
#endif
|
|
|
|
}'''))
|
2022-03-16 06:52:25 +03:00
|
|
|
|
|
|
|
has_madvise = cc.links(gnu_source_prefix + '''
|
2021-06-03 13:02:00 +03:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <stddef.h>
|
2022-03-16 06:52:25 +03:00
|
|
|
int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''')
|
|
|
|
missing_madvise_proto = false
|
|
|
|
if has_madvise
|
|
|
|
# Some platforms (illumos and Solaris before Solaris 11) provide madvise()
|
|
|
|
# but forget to prototype it. In this case, has_madvise will be true (the
|
|
|
|
# test program links despite a compile warning). To detect the
|
|
|
|
# missing-prototype case, we try again with a definitely-bogus prototype.
|
|
|
|
# This will only compile if the system headers don't provide the prototype;
|
|
|
|
# otherwise the conflicting prototypes will cause a compiler error.
|
|
|
|
missing_madvise_proto = cc.links(gnu_source_prefix + '''
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
extern int madvise(int);
|
|
|
|
int main(void) { return madvise(0); }''')
|
|
|
|
endif
|
|
|
|
config_host_data.set('CONFIG_MADVISE', has_madvise)
|
|
|
|
config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
|
|
|
|
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
|
2021-06-03 13:02:00 +03:00
|
|
|
#include <sys/mman.h>
|
|
|
|
int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
|
2021-06-03 13:02:00 +03:00
|
|
|
#include <fcntl.h>
|
|
|
|
#if !defined(AT_EMPTY_PATH)
|
|
|
|
# error missing definition
|
|
|
|
#else
|
|
|
|
int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
|
|
|
|
#endif'''))
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
|
2021-06-03 14:04:47 +03:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
int pipefd[2];
|
|
|
|
return pipe2(pipefd, O_CLOEXEC);
|
|
|
|
}'''))
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
|
2021-06-03 13:02:00 +03:00
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
|
2021-10-07 16:08:19 +03:00
|
|
|
|
2021-11-16 10:28:29 +03:00
|
|
|
config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
|
2021-10-07 16:08:19 +03:00
|
|
|
#include <pthread.h>
|
|
|
|
|
|
|
|
static void *f(void *p) { return NULL; }
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
pthread_t thread;
|
|
|
|
pthread_create(&thread, 0, f, 0);
|
|
|
|
pthread_setname_np(thread, "QEMU");
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: threads))
|
2021-11-16 10:28:29 +03:00
|
|
|
config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
|
2021-10-07 16:08:19 +03:00
|
|
|
#include <pthread.h>
|
|
|
|
|
|
|
|
static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
pthread_t thread;
|
|
|
|
pthread_create(&thread, 0, f, 0);
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: threads))
|
2022-02-22 12:05:05 +03:00
|
|
|
config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
|
|
|
|
#include <pthread.h>
|
|
|
|
#include <time.h>
|
|
|
|
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
pthread_condattr_t attr
|
|
|
|
pthread_condattr_init(&attr);
|
|
|
|
pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
|
|
|
|
return 0;
|
|
|
|
}''', dependencies: threads))
|
2021-10-07 16:08:19 +03:00
|
|
|
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
|
2021-09-05 04:16:22 +03:00
|
|
|
#include <sys/signalfd.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
|
2021-07-07 17:35:26 +03:00
|
|
|
config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
|
2021-06-03 14:04:47 +03:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <limits.h>
|
|
|
|
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
int len, fd = 0;
|
|
|
|
len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
|
|
|
|
splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
|
|
|
|
return 0;
|
|
|
|
}'''))
|
2021-06-03 13:02:00 +03:00
|
|
|
|
2021-10-07 16:08:18 +03:00
|
|
|
config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
|
|
|
|
#include <sys/mman.h>
|
|
|
|
int main(int argc, char *argv[]) {
|
|
|
|
return mlockall(MCL_FUTURE);
|
|
|
|
}'''))
|
|
|
|
|
2021-10-28 21:59:08 +03:00
|
|
|
have_l2tpv3 = false
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('l2tpv3').allowed() and have_system
|
2021-11-16 10:28:29 +03:00
|
|
|
have_l2tpv3 = cc.has_type('struct mmsghdr',
|
|
|
|
prefix: gnu_source_prefix + '''
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <linux/ip.h>''')
|
2021-10-28 21:59:08 +03:00
|
|
|
endif
|
|
|
|
config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
|
|
|
|
|
2021-10-07 16:08:22 +03:00
|
|
|
have_netmap = false
|
2021-12-18 18:39:43 +03:00
|
|
|
if get_option('netmap').allowed() and have_system
|
2021-10-07 16:08:22 +03:00
|
|
|
have_netmap = cc.compiles('''
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/netmap.h>
|
|
|
|
#include <net/netmap_user.h>
|
|
|
|
#if (NETMAP_API < 11) || (NETMAP_API > 15)
|
|
|
|
#error
|
|
|
|
#endif
|
|
|
|
int main(void) { return 0; }''')
|
|
|
|
if not have_netmap and get_option('netmap').enabled()
|
|
|
|
error('Netmap headers not available')
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
config_host_data.set('CONFIG_NETMAP', have_netmap)
|
|
|
|
|
2021-10-07 16:08:18 +03:00
|
|
|
# Work around a system header bug with some kernel/XFS header
|
|
|
|
# versions where they both try to define 'struct fsxattr':
|
|
|
|
# xfs headers will not try to redefine structs from linux headers
|
|
|
|
# if this macro is set.
|
|
|
|
config_host_data.set('HAVE_FSXATTR', cc.links('''
|
2021-11-16 10:28:29 +03:00
|
|
|
#include <linux/fs.h>
|
2021-10-07 16:08:18 +03:00
|
|
|
struct fsxattr foo;
|
|
|
|
int main(void) {
|
|
|
|
return 0;
|
|
|
|
}'''))
|
|
|
|
|
2021-06-03 12:57:04 +03:00
|
|
|
# Some versions of Mac OS X incorrectly define SIZE_MAX
|
|
|
|
config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
int main(int argc, char *argv[]) {
|
|
|
|
return printf("%zu", SIZE_MAX);
|
|
|
|
}''', args: ['-Werror']))
|
|
|
|
|
2022-02-28 15:03:09 +03:00
|
|
|
atomic_test = '''
|
2021-10-07 16:08:25 +03:00
|
|
|
#include <stdint.h>
|
|
|
|
int main(void)
|
|
|
|
{
|
2022-02-28 15:03:09 +03:00
|
|
|
@0@ x = 0, y = 0;
|
2021-10-07 16:08:25 +03:00
|
|
|
y = __atomic_load_n(&x, __ATOMIC_RELAXED);
|
|
|
|
__atomic_store_n(&x, y, __ATOMIC_RELAXED);
|
|
|
|
__atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
|
|
|
|
__atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
|
|
|
|
__atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
|
|
|
|
return 0;
|
2022-02-28 15:03:09 +03:00
|
|
|
}'''
|
|
|
|
|
|
|
|
# See if 64-bit atomic operations are supported.
|
|
|
|
# Note that without __atomic builtins, we can only
|
|
|
|
# assume atomic loads/stores max at pointer size.
|
|
|
|
config_host_data.set('CONFIG_ATOMIC64', cc.links(atomic_test.format('uint64_t')))
|
2021-10-07 16:08:25 +03:00
|
|
|
|
2022-02-28 14:49:19 +03:00
|
|
|
has_int128 = cc.links('''
|
|
|
|
__int128_t a;
|
|
|
|
__uint128_t b;
|
|
|
|
int main (void) {
|
|
|
|
a = a + b;
|
|
|
|
b = a * b;
|
|
|
|
a = a * a;
|
|
|
|
return 0;
|
|
|
|
}''')
|
|
|
|
|
|
|
|
config_host_data.set('CONFIG_INT128', has_int128)
|
|
|
|
|
|
|
|
if has_int128
|
2022-02-28 15:03:09 +03:00
|
|
|
# "do we have 128-bit atomics which are handled inline and specifically not
|
|
|
|
# via libatomic". The reason we can't use libatomic is documented in the
|
|
|
|
# comment starting "GCC is a house divided" in include/qemu/atomic128.h.
|
|
|
|
has_atomic128 = cc.links(atomic_test.format('unsigned __int128'))
|
2022-02-28 14:49:19 +03:00
|
|
|
|
|
|
|
config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
|
|
|
|
|
|
|
|
if not has_atomic128
|
|
|
|
has_cmpxchg128 = cc.links('''
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
unsigned __int128 x = 0, y = 0;
|
|
|
|
__sync_val_compare_and_swap_16(&x, y, x);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
''')
|
|
|
|
|
|
|
|
config_host_data.set('CONFIG_CMPXCHG128', has_cmpxchg128)
|
|
|
|
endif
|
|
|
|
endif
|
2021-10-07 16:08:25 +03:00
|
|
|
|
|
|
|
config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
|
|
|
|
#include <sys/auxv.h>
|
|
|
|
int main(void) {
|
|
|
|
return getauxval(AT_HWCAP) == 0;
|
|
|
|
}'''))
|
|
|
|
|
2022-04-20 18:33:43 +03:00
|
|
|
config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles('''
|
|
|
|
#include <linux/usbdevice_fs.h>
|
|
|
|
|
|
|
|
#ifndef USBDEVFS_GET_CAPABILITIES
|
|
|
|
#error "USBDEVFS_GET_CAPABILITIES undefined"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef USBDEVFS_DISCONNECT_CLAIM
|
|
|
|
#error "USBDEVFS_DISCONNECT_CLAIM undefined"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int main(void) { return 0; }'''))
|
|
|
|
|
2022-04-20 18:33:42 +03:00
|
|
|
have_keyring = get_option('keyring') \
|
|
|
|
.require(targetos == 'linux', error_message: 'keyring is only available on Linux') \
|
|
|
|
.require(cc.compiles('''
|
|
|
|
#include <errno.h>
|
|
|
|
#include <asm/unistd.h>
|
|
|
|
#include <linux/keyctl.h>
|
|
|
|
#include <sys/syscall.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
int main(void) {
|
|
|
|
return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0);
|
|
|
|
}'''), error_message: 'keyctl syscall not available on this system').allowed()
|
|
|
|
config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring)
|
|
|
|
|
2021-11-08 15:38:58 +03:00
|
|
|
have_cpuid_h = cc.links('''
|
|
|
|
#include <cpuid.h>
|
|
|
|
int main(void) {
|
|
|
|
unsigned a, b, c, d;
|
|
|
|
unsigned max = __get_cpuid_max(0, 0);
|
|
|
|
|
|
|
|
if (max >= 1) {
|
|
|
|
__cpuid(1, a, b, c, d);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (max >= 7) {
|
|
|
|
__cpuid_count(7, 0, a, b, c, d);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}''')
|
|
|
|
config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
|
|
|
|
|
|
|
|
config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
|
|
|
|
.require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
|
|
|
|
.require(cc.links('''
|
|
|
|
#pragma GCC push_options
|
|
|
|
#pragma GCC target("avx2")
|
|
|
|
#include <cpuid.h>
|
|
|
|
#include <immintrin.h>
|
|
|
|
static int bar(void *a) {
|
|
|
|
__m256i x = *(__m256i *)a;
|
|
|
|
return _mm256_testz_si256(x, x);
|
|
|
|
}
|
|
|
|
int main(int argc, char *argv[]) { return bar(argv[0]); }
|
|
|
|
'''), error_message: 'AVX2 not available').allowed())
|
|
|
|
|
|
|
|
config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
|
|
|
|
.require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
|
|
|
|
.require(cc.links('''
|
|
|
|
#pragma GCC push_options
|
|
|
|
#pragma GCC target("avx512f")
|
|
|
|
#include <cpuid.h>
|
|
|
|
#include <immintrin.h>
|
|
|
|
static int bar(void *a) {
|
|
|
|
__m512i x = *(__m512i *)a;
|
|
|
|
return _mm512_test_epi64_mask(x, x);
|
|
|
|
}
|
|
|
|
int main(int argc, char *argv[]) { return bar(argv[0]); }
|
|
|
|
'''), error_message: 'AVX512F not available').allowed())
|
|
|
|
|
2022-04-20 18:33:41 +03:00
|
|
|
have_pvrdma = get_option('pvrdma') \
|
|
|
|
.require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \
|
2022-05-02 16:11:19 +03:00
|
|
|
.require(cc.compiles(gnu_source_prefix + '''
|
|
|
|
#include <sys/mman.h>
|
2022-04-20 18:33:41 +03:00
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
char buf = 0;
|
|
|
|
void *addr = &buf;
|
|
|
|
addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}'''), error_message: 'PVRDMA requires mremap').allowed()
|
|
|
|
|
|
|
|
if have_pvrdma
|
2022-05-02 16:11:19 +03:00
|
|
|
config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links('''
|
2022-04-20 18:33:41 +03:00
|
|
|
#include <infiniband/verbs.h>
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
struct ibv_mr *mr;
|
|
|
|
struct ibv_pd *pd = NULL;
|
|
|
|
size_t length = 10;
|
|
|
|
uint64_t iova = 0;
|
|
|
|
int access = 0;
|
|
|
|
void *addr = NULL;
|
|
|
|
|
|
|
|
mr = ibv_reg_mr_iova(pd, addr, length, iova, access);
|
|
|
|
ibv_dereg_mr(mr);
|
|
|
|
return 0;
|
|
|
|
}'''))
|
|
|
|
endif
|
|
|
|
|
2021-11-08 15:52:11 +03:00
|
|
|
if get_option('membarrier').disabled()
|
|
|
|
have_membarrier = false
|
|
|
|
elif targetos == 'windows'
|
|
|
|
have_membarrier = true
|
|
|
|
elif targetos == 'linux'
|
|
|
|
have_membarrier = cc.compiles('''
|
|
|
|
#include <linux/membarrier.h>
|
|
|
|
#include <sys/syscall.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
int main(void) {
|
|
|
|
syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
|
|
|
|
syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
|
|
|
|
exit(0);
|
|
|
|
}''')
|
|
|
|
endif
|
|
|
|
config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
|
|
|
|
.require(have_membarrier, error_message: 'membarrier system call not available') \
|
|
|
|
.allowed())
|
|
|
|
|
2021-11-08 16:02:42 +03:00
|
|
|
have_afalg = get_option('crypto_afalg') \
|
|
|
|
.require(cc.compiles(gnu_source_prefix + '''
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <linux/if_alg.h>
|
|
|
|
int main(void) {
|
|
|
|
int sock;
|
|
|
|
sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
'''), error_message: 'AF_ALG requested but could not be detected').allowed()
|
|
|
|
config_host_data.set('CONFIG_AF_ALG', have_afalg)
|
|
|
|
|
2022-04-01 14:50:05 +03:00
|
|
|
config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol(
|
|
|
|
'linux/vm_sockets.h', 'AF_VSOCK',
|
|
|
|
prefix: '#include <sys/socket.h>',
|
|
|
|
))
|
2021-10-07 16:08:25 +03:00
|
|
|
|
2022-02-01 15:53:43 +03:00
|
|
|
have_vss = false
|
2022-02-22 22:40:02 +03:00
|
|
|
have_vss_sdk = false # old xp/2003 SDK
|
2022-02-01 15:53:43 +03:00
|
|
|
if targetos == 'windows' and link_language == 'cpp'
|
|
|
|
have_vss = cxx.compiles('''
|
|
|
|
#define __MIDL_user_allocate_free_DEFINED__
|
2022-02-22 22:40:01 +03:00
|
|
|
#include <vss.h>
|
2022-02-01 15:53:43 +03:00
|
|
|
int main(void) { return VSS_CTX_BACKUP; }''')
|
2022-02-22 22:40:02 +03:00
|
|
|
have_vss_sdk = cxx.has_header('vscoordint.h')
|
2022-02-01 15:53:43 +03:00
|
|
|
endif
|
2022-02-22 22:40:02 +03:00
|
|
|
config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
|
2022-02-01 15:53:43 +03:00
|
|
|
|
2020-08-04 19:14:26 +03:00
|
|
|
foreach k, v: config_host
|
2022-04-20 18:33:55 +03:00
|
|
|
if k.startswith('CONFIG_')
|
2020-08-04 19:14:26 +03:00
|
|
|
config_host_data.set(k, v == 'y' ? 1 : v)
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
|
2022-04-17 21:30:06 +03:00
|
|
|
# Older versions of MinGW do not import _lock_file and _unlock_file properly.
|
|
|
|
# This was fixed for v6.0.0 with commit b48e3ac8969d.
|
|
|
|
if targetos == 'windows'
|
|
|
|
config_host_data.set('HAVE__LOCK_FILE', cc.links('''
|
|
|
|
#include <stdio.h>
|
|
|
|
int main(void) {
|
|
|
|
_lock_file(NULL);
|
|
|
|
_unlock_file(NULL);
|
|
|
|
return 0;
|
|
|
|
}''', name: '_lock_file and _unlock_file'))
|
|
|
|
endif
|
|
|
|
|
2020-10-07 18:01:51 +03:00
|
|
|
########################
|
|
|
|
# Target configuration #
|
|
|
|
########################
|
|
|
|
|
2020-02-03 13:42:03 +03:00
|
|
|
minikconf = find_program('scripts/minikconf.py')
|
2020-09-16 22:31:11 +03:00
|
|
|
config_all = {}
|
2020-09-01 12:32:23 +03:00
|
|
|
config_all_devices = {}
|
2020-09-01 13:04:28 +03:00
|
|
|
config_all_disas = {}
|
2020-02-03 13:42:03 +03:00
|
|
|
config_devices_mak_list = []
|
|
|
|
config_devices_h = {}
|
2020-08-04 19:14:26 +03:00
|
|
|
config_target_h = {}
|
2020-02-03 13:42:03 +03:00
|
|
|
config_target_mak = {}
|
2020-09-01 13:04:28 +03:00
|
|
|
|
|
|
|
disassemblers = {
|
|
|
|
'alpha' : ['CONFIG_ALPHA_DIS'],
|
|
|
|
'arm' : ['CONFIG_ARM_DIS'],
|
|
|
|
'avr' : ['CONFIG_AVR_DIS'],
|
|
|
|
'cris' : ['CONFIG_CRIS_DIS'],
|
2021-02-08 08:46:24 +03:00
|
|
|
'hexagon' : ['CONFIG_HEXAGON_DIS'],
|
2020-09-01 13:04:28 +03:00
|
|
|
'hppa' : ['CONFIG_HPPA_DIS'],
|
|
|
|
'i386' : ['CONFIG_I386_DIS'],
|
|
|
|
'x86_64' : ['CONFIG_I386_DIS'],
|
|
|
|
'm68k' : ['CONFIG_M68K_DIS'],
|
|
|
|
'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
|
|
|
|
'mips' : ['CONFIG_MIPS_DIS'],
|
|
|
|
'nios2' : ['CONFIG_NIOS2_DIS'],
|
|
|
|
'or1k' : ['CONFIG_OPENRISC_DIS'],
|
|
|
|
'ppc' : ['CONFIG_PPC_DIS'],
|
|
|
|
'riscv' : ['CONFIG_RISCV_DIS'],
|
|
|
|
'rx' : ['CONFIG_RX_DIS'],
|
|
|
|
's390' : ['CONFIG_S390_DIS'],
|
|
|
|
'sh4' : ['CONFIG_SH4_DIS'],
|
|
|
|
'sparc' : ['CONFIG_SPARC_DIS'],
|
|
|
|
'xtensa' : ['CONFIG_XTENSA_DIS'],
|
2022-06-06 15:43:06 +03:00
|
|
|
'loongarch' : ['CONFIG_LOONGARCH_DIS'],
|
2020-09-01 13:04:28 +03:00
|
|
|
}
|
|
|
|
if link_language == 'cpp'
|
|
|
|
disassemblers += {
|
|
|
|
'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
|
|
|
|
'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
|
|
|
|
'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
|
|
|
|
}
|
|
|
|
endif
|
|
|
|
|
2021-06-03 13:02:00 +03:00
|
|
|
have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
|
2020-11-17 16:58:32 +03:00
|
|
|
host_kconfig = \
|
2021-10-07 16:08:12 +03:00
|
|
|
(get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
|
2021-12-21 14:38:27 +03:00
|
|
|
(have_tpm ? ['CONFIG_TPM=y'] : []) + \
|
2021-10-07 16:08:23 +03:00
|
|
|
(spice.found() ? ['CONFIG_SPICE=y'] : []) + \
|
2021-06-03 13:50:17 +03:00
|
|
|
(have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
|
2022-04-20 18:33:40 +03:00
|
|
|
(opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \
|
2021-01-07 15:54:22 +03:00
|
|
|
(x11.found() ? ['CONFIG_X11=y'] : []) + \
|
2022-04-20 18:34:05 +03:00
|
|
|
(have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \
|
|
|
|
(have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \
|
|
|
|
(have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
|
2020-11-17 16:46:21 +03:00
|
|
|
(have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
|
2020-11-17 16:58:32 +03:00
|
|
|
('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
|
2022-04-20 18:33:41 +03:00
|
|
|
(have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
|
2022-06-13 23:26:24 +03:00
|
|
|
(multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
|
|
|
|
(vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : [])
|
2020-11-17 16:58:32 +03:00
|
|
|
|
2020-09-21 12:11:01 +03:00
|
|
|
ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
|
2020-09-16 22:31:11 +03:00
|
|
|
|
2020-09-21 11:37:49 +03:00
|
|
|
default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
|
|
|
|
actual_target_dirs = []
|
2020-10-05 12:31:15 +03:00
|
|
|
fdt_required = []
|
2020-08-19 15:44:56 +03:00
|
|
|
foreach target : target_dirs
|
2020-09-18 13:37:21 +03:00
|
|
|
config_target = { 'TARGET_NAME': target.split('-')[0] }
|
|
|
|
if target.endswith('linux-user')
|
2020-09-21 11:37:49 +03:00
|
|
|
if targetos != 'linux'
|
|
|
|
if default_targets
|
|
|
|
continue
|
|
|
|
endif
|
|
|
|
error('Target @0@ is only available on a Linux host'.format(target))
|
|
|
|
endif
|
2020-09-18 13:37:21 +03:00
|
|
|
config_target += { 'CONFIG_LINUX_USER': 'y' }
|
|
|
|
elif target.endswith('bsd-user')
|
2020-09-21 11:37:49 +03:00
|
|
|
if 'CONFIG_BSD' not in config_host
|
|
|
|
if default_targets
|
|
|
|
continue
|
|
|
|
endif
|
|
|
|
error('Target @0@ is only available on a BSD host'.format(target))
|
|
|
|
endif
|
2020-09-18 13:37:21 +03:00
|
|
|
config_target += { 'CONFIG_BSD_USER': 'y' }
|
|
|
|
elif target.endswith('softmmu')
|
|
|
|
config_target += { 'CONFIG_SOFTMMU': 'y' }
|
|
|
|
endif
|
|
|
|
if target.endswith('-user')
|
|
|
|
config_target += {
|
|
|
|
'CONFIG_USER_ONLY': 'y',
|
|
|
|
'CONFIG_QEMU_INTERP_PREFIX':
|
2022-04-20 18:33:55 +03:00
|
|
|
get_option('interp_prefix').replace('%M', config_target['TARGET_NAME'])
|
2020-09-18 13:37:21 +03:00
|
|
|
}
|
|
|
|
endif
|
2020-08-04 19:14:26 +03:00
|
|
|
|
2020-11-17 16:58:32 +03:00
|
|
|
accel_kconfig = []
|
2020-09-18 12:37:01 +03:00
|
|
|
foreach sym: accelerators
|
|
|
|
if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
|
|
|
|
config_target += { sym: 'y' }
|
|
|
|
config_all += { sym: 'y' }
|
2020-12-14 14:01:45 +03:00
|
|
|
if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
|
|
|
|
config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
|
2020-09-18 12:37:01 +03:00
|
|
|
endif
|
2021-06-24 13:38:31 +03:00
|
|
|
if target in modular_tcg
|
|
|
|
config_target += { 'CONFIG_TCG_MODULAR': 'y' }
|
|
|
|
else
|
|
|
|
config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
|
|
|
|
endif
|
2020-11-17 16:58:32 +03:00
|
|
|
accel_kconfig += [ sym + '=y' ]
|
2020-09-18 12:37:01 +03:00
|
|
|
endif
|
|
|
|
endforeach
|
2020-11-17 16:58:32 +03:00
|
|
|
if accel_kconfig.length() == 0
|
2020-09-21 11:37:49 +03:00
|
|
|
if default_targets
|
|
|
|
continue
|
|
|
|
endif
|
|
|
|
error('No accelerator available for target @0@'.format(target))
|
|
|
|
endif
|
2020-09-18 12:37:01 +03:00
|
|
|
|
2020-09-21 11:37:49 +03:00
|
|
|
actual_target_dirs += target
|
2021-07-07 16:17:43 +03:00
|
|
|
config_target += keyval.load('configs/targets' / target + '.mak')
|
2020-09-21 12:11:01 +03:00
|
|
|
config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
|
2020-09-18 13:37:21 +03:00
|
|
|
|
2020-10-05 12:31:15 +03:00
|
|
|
if 'TARGET_NEED_FDT' in config_target
|
|
|
|
fdt_required += target
|
|
|
|
endif
|
|
|
|
|
2020-09-21 12:19:07 +03:00
|
|
|
# Add default keys
|
|
|
|
if 'TARGET_BASE_ARCH' not in config_target
|
|
|
|
config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
|
|
|
|
endif
|
|
|
|
if 'TARGET_ABI_DIR' not in config_target
|
|
|
|
config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
|
|
|
|
endif
|
2022-03-23 18:57:18 +03:00
|
|
|
if 'TARGET_BIG_ENDIAN' not in config_target
|
|
|
|
config_target += {'TARGET_BIG_ENDIAN': 'n'}
|
|
|
|
endif
|
2020-08-04 19:14:26 +03:00
|
|
|
|
2020-09-01 13:04:28 +03:00
|
|
|
foreach k, v: disassemblers
|
2021-11-08 16:18:17 +03:00
|
|
|
if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
|
2020-09-01 13:04:28 +03:00
|
|
|
foreach sym: v
|
|
|
|
config_target += { sym: 'y' }
|
|
|
|
config_all_disas += { sym: 'y' }
|
|
|
|
endforeach
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
|
2020-08-04 19:14:26 +03:00
|
|
|
config_target_data = configuration_data()
|
|
|
|
foreach k, v: config_target
|
|
|
|
if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
|
|
|
|
# do nothing
|
|
|
|
elif ignored.contains(k)
|
|
|
|
# do nothing
|
|
|
|
elif k == 'TARGET_BASE_ARCH'
|
2020-09-21 12:11:01 +03:00
|
|
|
# Note that TARGET_BASE_ARCH ends up in config-target.h but it is
|
|
|
|
# not used to select files from sourcesets.
|
2020-08-04 19:14:26 +03:00
|
|
|
config_target_data.set('TARGET_' + v.to_upper(), 1)
|
2020-09-18 13:37:21 +03:00
|
|
|
elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
|
2020-08-04 19:14:26 +03:00
|
|
|
config_target_data.set_quoted(k, v)
|
|
|
|
elif v == 'y'
|
|
|
|
config_target_data.set(k, 1)
|
2022-03-23 18:57:18 +03:00
|
|
|
elif v == 'n'
|
|
|
|
config_target_data.set(k, 0)
|
2020-08-04 19:14:26 +03:00
|
|
|
else
|
|
|
|
config_target_data.set(k, v)
|
|
|
|
endif
|
|
|
|
endforeach
|
2021-07-30 13:59:43 +03:00
|
|
|
config_target_data.set('QEMU_ARCH',
|
|
|
|
'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
|
2020-08-04 19:14:26 +03:00
|
|
|
config_target_h += {target: configure_file(output: target + '-config-target.h',
|
|
|
|
configuration: config_target_data)}
|
2020-02-03 13:42:03 +03:00
|
|
|
|
|
|
|
if target.endswith('-softmmu')
|
2021-07-07 16:17:44 +03:00
|
|
|
config_input = meson.get_external_property(target, 'default')
|
2020-02-03 13:42:03 +03:00
|
|
|
config_devices_mak = target + '-config-devices.mak'
|
|
|
|
config_devices_mak = configure_file(
|
2021-07-07 16:17:44 +03:00
|
|
|
input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
|
2020-02-03 13:42:03 +03:00
|
|
|
output: config_devices_mak,
|
|
|
|
depfile: config_devices_mak + '.d',
|
|
|
|
capture: true,
|
2020-11-20 10:38:22 +03:00
|
|
|
command: [minikconf,
|
|
|
|
get_option('default_devices') ? '--defconfig' : '--allnoconfig',
|
2020-02-03 13:42:03 +03:00
|
|
|
config_devices_mak, '@DEPFILE@', '@INPUT@',
|
2021-07-07 16:17:40 +03:00
|
|
|
host_kconfig, accel_kconfig,
|
|
|
|
'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
|
2020-08-04 19:14:26 +03:00
|
|
|
|
|
|
|
config_devices_data = configuration_data()
|
|
|
|
config_devices = keyval.load(config_devices_mak)
|
|
|
|
foreach k, v: config_devices
|
|
|
|
config_devices_data.set(k, 1)
|
|
|
|
endforeach
|
2020-02-03 13:42:03 +03:00
|
|
|
config_devices_mak_list += config_devices_mak
|
2020-08-04 19:14:26 +03:00
|
|
|
config_devices_h += {target: configure_file(output: target + '-config-devices.h',
|
|
|
|
configuration: config_devices_data)}
|
|
|
|
config_target += config_devices
|
2020-09-01 12:32:23 +03:00
|
|
|
config_all_devices += config_devices
|
2020-02-03 13:42:03 +03:00
|
|
|
endif
|
|
|
|
config_target_mak += {target: config_target}
|
2020-08-19 15:44:56 +03:00
|
|
|
endforeach
|
2020-09-21 11:37:49 +03:00
|
|
|
target_dirs = actual_target_dirs
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2020-02-03 13:42:03 +03:00
|
|
|
# This configuration is used to build files that are shared by
|
|
|
|
# multiple binaries, and then extracted out of the "common"
|
|
|
|
# static_library target.
|
|
|
|
#
|
|
|
|
# We do not use all_sources()/all_dependencies(), because it would
|
|
|
|
# build literally all source files, including devices only used by
|
|
|
|
# targets that are not built for this compilation. The CONFIG_ALL
|
|
|
|
# pseudo symbol replaces it.
|
|
|
|
|
2020-09-16 22:31:11 +03:00
|
|
|
config_all += config_all_devices
|
2020-02-03 13:42:03 +03:00
|
|
|
config_all += config_host
|
|
|
|
config_all += config_all_disas
|
|
|
|
config_all += {
|
2022-04-20 18:33:47 +03:00
|
|
|
'CONFIG_XEN': xen.found(),
|
2020-02-03 13:42:03 +03:00
|
|
|
'CONFIG_SOFTMMU': have_system,
|
|
|
|
'CONFIG_USER_ONLY': have_user,
|
|
|
|
'CONFIG_ALL': true,
|
|
|
|
}
|
|
|
|
|
2021-11-10 13:01:26 +03:00
|
|
|
target_configs_h = []
|
|
|
|
foreach target: target_dirs
|
|
|
|
target_configs_h += config_target_h[target]
|
|
|
|
target_configs_h += config_devices_h.get(target, [])
|
|
|
|
endforeach
|
|
|
|
genh += custom_target('config-poison.h',
|
|
|
|
input: [target_configs_h],
|
|
|
|
output: 'config-poison.h',
|
|
|
|
capture: true,
|
|
|
|
command: [find_program('scripts/make-config-poison.sh'),
|
|
|
|
target_configs_h])
|
|
|
|
|
2020-10-07 18:01:51 +03:00
|
|
|
##############
|
|
|
|
# Submodules #
|
|
|
|
##############
|
2020-09-13 22:19:25 +03:00
|
|
|
|
|
|
|
capstone = not_found
|
2022-05-16 17:58:23 +03:00
|
|
|
if not get_option('capstone').auto() or have_system or have_user
|
2022-05-16 17:58:22 +03:00
|
|
|
capstone = dependency('capstone', version: '>=3.0.5',
|
2021-01-26 13:15:33 +03:00
|
|
|
kwargs: static_kwargs, method: 'pkg-config',
|
2022-05-16 17:58:23 +03:00
|
|
|
required: get_option('capstone'))
|
2021-07-09 17:29:31 +03:00
|
|
|
|
|
|
|
# Some versions of capstone have broken pkg-config file
|
|
|
|
# that reports a wrong -I path, causing the #include to
|
|
|
|
# fail later. If the system has such a broken version
|
|
|
|
# do not use it.
|
|
|
|
if capstone.found() and not cc.compiles('#include <capstone.h>',
|
|
|
|
dependencies: [capstone])
|
|
|
|
capstone = not_found
|
2022-05-16 17:58:23 +03:00
|
|
|
if get_option('capstone').enabled()
|
|
|
|
error('capstone requested, but it does not appear to work')
|
2021-07-09 17:29:31 +03:00
|
|
|
endif
|
|
|
|
endif
|
2020-09-13 22:19:25 +03:00
|
|
|
endif
|
2020-10-05 12:31:15 +03:00
|
|
|
|
|
|
|
slirp = not_found
|
|
|
|
slirp_opt = 'disabled'
|
|
|
|
if have_system
|
|
|
|
slirp_opt = get_option('slirp')
|
|
|
|
if slirp_opt in ['enabled', 'auto', 'system']
|
|
|
|
have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
|
2022-04-11 10:41:27 +03:00
|
|
|
slirp_dep_required = (slirp_opt == 'system' or
|
|
|
|
slirp_opt == 'enabled' and not have_internal)
|
2021-01-26 13:15:33 +03:00
|
|
|
slirp = dependency('slirp', kwargs: static_kwargs,
|
2022-04-11 11:16:36 +03:00
|
|
|
method: 'pkg-config', version: '>=4.1.0',
|
2022-04-11 10:41:27 +03:00
|
|
|
required: slirp_dep_required)
|
|
|
|
# slirp <4.7 is incompatible with CFI support in QEMU. This is because
|
|
|
|
# it passes function pointers within libslirp as callbacks for timers.
|
|
|
|
# When using a system-wide shared libslirp, the type information for the
|
|
|
|
# callback is missing and the timer call produces a false positive with CFI.
|
|
|
|
# Do not use the "version" keyword argument to produce a better error.
|
|
|
|
# with control-flow integrity.
|
|
|
|
if get_option('cfi') and slirp.found() and slirp.version().version_compare('<4.7')
|
|
|
|
if slirp_dep_required
|
|
|
|
error('Control-Flow Integrity requires libslirp 4.7.')
|
|
|
|
else
|
|
|
|
warning('Control-Flow Integrity requires libslirp 4.7, not using system-wide libslirp.')
|
|
|
|
slirp = not_found
|
|
|
|
endif
|
|
|
|
endif
|
2020-10-05 12:31:15 +03:00
|
|
|
if slirp.found()
|
|
|
|
slirp_opt = 'system'
|
|
|
|
elif have_internal
|
|
|
|
slirp_opt = 'internal'
|
|
|
|
else
|
|
|
|
slirp_opt = 'disabled'
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
if slirp_opt == 'internal'
|
|
|
|
slirp_deps = []
|
|
|
|
if targetos == 'windows'
|
|
|
|
slirp_deps = cc.find_library('iphlpapi')
|
2021-05-18 18:51:11 +03:00
|
|
|
elif targetos == 'darwin'
|
|
|
|
slirp_deps = cc.find_library('resolv')
|
2020-10-05 12:31:15 +03:00
|
|
|
endif
|
|
|
|
slirp_conf = configuration_data()
|
|
|
|
slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
|
|
|
|
slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
|
|
|
|
slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
|
|
|
|
slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
|
|
|
|
slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
|
|
|
|
slirp_files = [
|
|
|
|
'slirp/src/arp_table.c',
|
|
|
|
'slirp/src/bootp.c',
|
|
|
|
'slirp/src/cksum.c',
|
|
|
|
'slirp/src/dhcpv6.c',
|
|
|
|
'slirp/src/dnssearch.c',
|
|
|
|
'slirp/src/if.c',
|
|
|
|
'slirp/src/ip6_icmp.c',
|
|
|
|
'slirp/src/ip6_input.c',
|
|
|
|
'slirp/src/ip6_output.c',
|
|
|
|
'slirp/src/ip_icmp.c',
|
|
|
|
'slirp/src/ip_input.c',
|
|
|
|
'slirp/src/ip_output.c',
|
|
|
|
'slirp/src/mbuf.c',
|
|
|
|
'slirp/src/misc.c',
|
|
|
|
'slirp/src/ncsi.c',
|
|
|
|
'slirp/src/ndp_table.c',
|
|
|
|
'slirp/src/sbuf.c',
|
|
|
|
'slirp/src/slirp.c',
|
|
|
|
'slirp/src/socket.c',
|
|
|
|
'slirp/src/state.c',
|
|
|
|
'slirp/src/stream.c',
|
|
|
|
'slirp/src/tcp_input.c',
|
|
|
|
'slirp/src/tcp_output.c',
|
|
|
|
'slirp/src/tcp_subr.c',
|
|
|
|
'slirp/src/tcp_timer.c',
|
|
|
|
'slirp/src/tftp.c',
|
|
|
|
'slirp/src/udp.c',
|
|
|
|
'slirp/src/udp6.c',
|
|
|
|
'slirp/src/util.c',
|
|
|
|
'slirp/src/version.c',
|
|
|
|
'slirp/src/vmstate.c',
|
|
|
|
]
|
|
|
|
|
|
|
|
configure_file(
|
|
|
|
input : 'slirp/src/libslirp-version.h.in',
|
|
|
|
output : 'libslirp-version.h',
|
|
|
|
configuration: slirp_conf)
|
|
|
|
|
|
|
|
slirp_inc = include_directories('slirp', 'slirp/src')
|
|
|
|
libslirp = static_library('slirp',
|
2021-01-22 23:44:33 +03:00
|
|
|
build_by_default: false,
|
2020-10-05 12:31:15 +03:00
|
|
|
sources: slirp_files,
|
|
|
|
c_args: slirp_cargs,
|
|
|
|
include_directories: slirp_inc)
|
|
|
|
slirp = declare_dependency(link_with: libslirp,
|
|
|
|
dependencies: slirp_deps,
|
|
|
|
include_directories: slirp_inc)
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
|
2022-06-13 23:26:24 +03:00
|
|
|
libvfio_user_dep = not_found
|
|
|
|
if have_system and vfio_user_server_allowed
|
|
|
|
have_internal = fs.exists(meson.current_source_dir() / 'subprojects/libvfio-user/meson.build')
|
|
|
|
|
|
|
|
if not have_internal
|
|
|
|
error('libvfio-user source not found - please pull git submodule')
|
|
|
|
endif
|
|
|
|
|
|
|
|
libvfio_user_proj = subproject('libvfio-user')
|
|
|
|
|
|
|
|
libvfio_user_lib = libvfio_user_proj.get_variable('libvfio_user_dep')
|
|
|
|
|
|
|
|
libvfio_user_dep = declare_dependency(dependencies: [libvfio_user_lib])
|
|
|
|
endif
|
|
|
|
|
2020-10-05 12:31:15 +03:00
|
|
|
fdt = not_found
|
|
|
|
if have_system
|
2022-02-08 13:19:46 +03:00
|
|
|
fdt_opt = get_option('fdt')
|
2020-10-05 12:31:15 +03:00
|
|
|
if fdt_opt in ['enabled', 'auto', 'system']
|
|
|
|
have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
|
2021-01-26 13:15:33 +03:00
|
|
|
fdt = cc.find_library('fdt', kwargs: static_kwargs,
|
2020-10-05 12:31:15 +03:00
|
|
|
required: fdt_opt == 'system' or
|
|
|
|
fdt_opt == 'enabled' and not have_internal)
|
|
|
|
if fdt.found() and cc.links('''
|
|
|
|
#include <libfdt.h>
|
|
|
|
#include <libfdt_env.h>
|
2022-01-18 20:05:48 +03:00
|
|
|
int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
|
2020-10-05 12:31:15 +03:00
|
|
|
dependencies: fdt)
|
|
|
|
fdt_opt = 'system'
|
2021-08-27 15:09:00 +03:00
|
|
|
elif fdt_opt == 'system'
|
|
|
|
error('system libfdt requested, but it is too old (1.5.1 or newer required)')
|
2020-10-05 12:31:15 +03:00
|
|
|
elif have_internal
|
|
|
|
fdt_opt = 'internal'
|
|
|
|
else
|
|
|
|
fdt_opt = 'disabled'
|
2021-08-27 15:08:59 +03:00
|
|
|
fdt = not_found
|
2020-10-05 12:31:15 +03:00
|
|
|
endif
|
|
|
|
endif
|
|
|
|
if fdt_opt == 'internal'
|
|
|
|
fdt_files = files(
|
|
|
|
'dtc/libfdt/fdt.c',
|
|
|
|
'dtc/libfdt/fdt_ro.c',
|
|
|
|
'dtc/libfdt/fdt_wip.c',
|
|
|
|
'dtc/libfdt/fdt_sw.c',
|
|
|
|
'dtc/libfdt/fdt_rw.c',
|
|
|
|
'dtc/libfdt/fdt_strerror.c',
|
|
|
|
'dtc/libfdt/fdt_empty_tree.c',
|
|
|
|
'dtc/libfdt/fdt_addresses.c',
|
|
|
|
'dtc/libfdt/fdt_overlay.c',
|
|
|
|
'dtc/libfdt/fdt_check.c',
|
|
|
|
)
|
|
|
|
|
|
|
|
fdt_inc = include_directories('dtc/libfdt')
|
|
|
|
libfdt = static_library('fdt',
|
2021-01-22 23:44:33 +03:00
|
|
|
build_by_default: false,
|
2020-10-05 12:31:15 +03:00
|
|
|
sources: fdt_files,
|
|
|
|
include_directories: fdt_inc)
|
|
|
|
fdt = declare_dependency(link_with: libfdt,
|
|
|
|
include_directories: fdt_inc)
|
|
|
|
endif
|
2022-02-08 13:19:46 +03:00
|
|
|
else
|
|
|
|
fdt_opt = 'disabled'
|
2020-10-05 12:31:15 +03:00
|
|
|
endif
|
|
|
|
if not fdt.found() and fdt_required.length() > 0
|
|
|
|
error('fdt not available but required by targets ' + ', '.join(fdt_required))
|
|
|
|
endif
|
|
|
|
|
2020-09-13 22:19:25 +03:00
|
|
|
config_host_data.set('CONFIG_CAPSTONE', capstone.found())
|
2020-10-05 12:31:15 +03:00
|
|
|
config_host_data.set('CONFIG_FDT', fdt.found())
|
2020-10-05 12:31:15 +03:00
|
|
|
config_host_data.set('CONFIG_SLIRP', slirp.found())
|
2020-09-13 22:19:25 +03:00
|
|
|
|
2020-10-07 18:01:51 +03:00
|
|
|
#####################
|
|
|
|
# Generated sources #
|
|
|
|
#####################
|
2020-09-13 22:19:25 +03:00
|
|
|
|
2020-10-07 18:01:51 +03:00
|
|
|
genh += configure_file(output: 'config-host.h', configuration: config_host_data)
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2019-07-15 17:06:04 +03:00
|
|
|
hxtool = find_program('scripts/hxtool')
|
2019-07-15 16:36:47 +03:00
|
|
|
shaderinclude = find_program('scripts/shaderinclude.pl')
|
2020-08-19 15:44:56 +03:00
|
|
|
qapi_gen = find_program('scripts/qapi-gen.py')
|
2021-02-09 16:59:26 +03:00
|
|
|
qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/commands.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/common.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/error.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/events.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/expr.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/gen.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/introspect.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/parser.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/schema.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/source.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/types.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/visit.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi/common.py',
|
|
|
|
meson.current_source_dir() / 'scripts/qapi-gen.py'
|
2020-08-19 15:44:56 +03:00
|
|
|
]
|
|
|
|
|
|
|
|
tracetool = [
|
|
|
|
python, files('scripts/tracetool.py'),
|
2021-10-07 16:08:14 +03:00
|
|
|
'--backend=' + ','.join(get_option('trace_backends'))
|
2020-08-19 15:44:56 +03:00
|
|
|
]
|
2021-01-25 14:09:58 +03:00
|
|
|
tracetool_depends = files(
|
|
|
|
'scripts/tracetool/backend/log.py',
|
|
|
|
'scripts/tracetool/backend/__init__.py',
|
|
|
|
'scripts/tracetool/backend/dtrace.py',
|
|
|
|
'scripts/tracetool/backend/ftrace.py',
|
|
|
|
'scripts/tracetool/backend/simple.py',
|
|
|
|
'scripts/tracetool/backend/syslog.py',
|
|
|
|
'scripts/tracetool/backend/ust.py',
|
|
|
|
'scripts/tracetool/format/ust_events_c.py',
|
|
|
|
'scripts/tracetool/format/ust_events_h.py',
|
|
|
|
'scripts/tracetool/format/__init__.py',
|
|
|
|
'scripts/tracetool/format/d.py',
|
|
|
|
'scripts/tracetool/format/simpletrace_stap.py',
|
|
|
|
'scripts/tracetool/format/c.py',
|
|
|
|
'scripts/tracetool/format/h.py',
|
|
|
|
'scripts/tracetool/format/log_stap.py',
|
|
|
|
'scripts/tracetool/format/stap.py',
|
|
|
|
'scripts/tracetool/__init__.py',
|
|
|
|
'scripts/tracetool/transform.py',
|
|
|
|
'scripts/tracetool/vcpu.py'
|
|
|
|
)
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2019-07-15 16:10:19 +03:00
|
|
|
qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
|
|
|
|
meson.current_source_dir(),
|
2022-04-20 18:33:54 +03:00
|
|
|
get_option('pkgversion'), meson.project_version()]
|
2019-07-15 16:10:19 +03:00
|
|
|
qemu_version = custom_target('qemu-version.h',
|
|
|
|
output: 'qemu-version.h',
|
|
|
|
command: qemu_version_cmd,
|
|
|
|
capture: true,
|
|
|
|
build_by_default: true,
|
|
|
|
build_always_stale: true)
|
|
|
|
genh += qemu_version
|
|
|
|
|
2019-07-15 17:06:04 +03:00
|
|
|
hxdep = []
|
|
|
|
hx_headers = [
|
|
|
|
['qemu-options.hx', 'qemu-options.def'],
|
|
|
|
['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
|
|
|
|
]
|
|
|
|
if have_system
|
|
|
|
hx_headers += [
|
|
|
|
['hmp-commands.hx', 'hmp-commands.h'],
|
|
|
|
['hmp-commands-info.hx', 'hmp-commands-info.h'],
|
|
|
|
]
|
|
|
|
endif
|
|
|
|
foreach d : hx_headers
|
2019-07-16 20:37:25 +03:00
|
|
|
hxdep += custom_target(d[1],
|
2019-07-15 17:06:04 +03:00
|
|
|
input: files(d[0]),
|
|
|
|
output: d[1],
|
|
|
|
capture: true,
|
|
|
|
build_by_default: true, # to be removed when added to a target
|
|
|
|
command: [hxtool, '-h', '@INPUT0@'])
|
|
|
|
endforeach
|
|
|
|
genh += hxdep
|
|
|
|
|
2020-10-07 18:01:51 +03:00
|
|
|
###################
|
|
|
|
# Collect sources #
|
|
|
|
###################
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2020-10-06 15:56:01 +03:00
|
|
|
authz_ss = ss.source_set()
|
2020-08-03 17:22:28 +03:00
|
|
|
blockdev_ss = ss.source_set()
|
2020-10-06 15:55:55 +03:00
|
|
|
block_ss = ss.source_set()
|
2020-10-06 15:55:57 +03:00
|
|
|
chardev_ss = ss.source_set()
|
2020-10-06 15:55:55 +03:00
|
|
|
common_ss = ss.source_set()
|
2020-10-06 15:56:00 +03:00
|
|
|
crypto_ss = ss.source_set()
|
2021-10-28 17:34:19 +03:00
|
|
|
hwcore_ss = ss.source_set()
|
2020-10-06 15:55:59 +03:00
|
|
|
io_ss = ss.source_set()
|
2020-10-06 15:55:55 +03:00
|
|
|
qmp_ss = ss.source_set()
|
2020-10-06 15:56:02 +03:00
|
|
|
qom_ss = ss.source_set()
|
2020-10-06 15:55:55 +03:00
|
|
|
softmmu_ss = ss.source_set()
|
2020-08-03 18:04:25 +03:00
|
|
|
specific_fuzz_ss = ss.source_set()
|
2020-10-06 15:55:55 +03:00
|
|
|
specific_ss = ss.source_set()
|
|
|
|
stub_ss = ss.source_set()
|
|
|
|
trace_ss = ss.source_set()
|
|
|
|
user_ss = ss.source_set()
|
|
|
|
util_ss = ss.source_set()
|
2020-02-03 13:42:03 +03:00
|
|
|
|
2021-06-24 13:38:29 +03:00
|
|
|
# accel modules
|
|
|
|
qtest_module_ss = ss.source_set()
|
2021-06-24 13:38:31 +03:00
|
|
|
tcg_module_ss = ss.source_set()
|
2021-06-24 13:38:29 +03:00
|
|
|
|
2019-08-29 21:07:01 +03:00
|
|
|
modules = {}
|
2021-06-24 13:38:22 +03:00
|
|
|
target_modules = {}
|
2020-02-03 13:42:03 +03:00
|
|
|
hw_arch = {}
|
|
|
|
target_arch = {}
|
|
|
|
target_softmmu_arch = {}
|
2021-04-13 12:27:09 +03:00
|
|
|
target_user_arch = {}
|
2020-08-19 15:44:56 +03:00
|
|
|
|
|
|
|
###############
|
|
|
|
# Trace files #
|
|
|
|
###############
|
|
|
|
|
2019-08-18 18:51:17 +03:00
|
|
|
# TODO: add each directory to the subdirs from its own meson.build, once
|
|
|
|
# we have those
|
2020-08-19 15:44:56 +03:00
|
|
|
trace_events_subdirs = [
|
|
|
|
'crypto',
|
2021-01-22 23:44:35 +03:00
|
|
|
'qapi',
|
|
|
|
'qom',
|
2020-08-19 15:44:56 +03:00
|
|
|
'monitor',
|
2021-01-22 23:44:35 +03:00
|
|
|
'util',
|
2020-08-19 15:44:56 +03:00
|
|
|
]
|
2022-01-09 03:37:23 +03:00
|
|
|
if have_linux_user
|
2020-08-19 15:44:56 +03:00
|
|
|
trace_events_subdirs += [ 'linux-user' ]
|
|
|
|
endif
|
2022-01-09 03:37:23 +03:00
|
|
|
if have_bsd_user
|
|
|
|
trace_events_subdirs += [ 'bsd-user' ]
|
|
|
|
endif
|
2020-08-19 15:44:56 +03:00
|
|
|
if have_block
|
|
|
|
trace_events_subdirs += [
|
|
|
|
'authz',
|
|
|
|
'block',
|
|
|
|
'io',
|
|
|
|
'nbd',
|
|
|
|
'scsi',
|
|
|
|
]
|
|
|
|
endif
|
|
|
|
if have_system
|
|
|
|
trace_events_subdirs += [
|
2021-01-22 23:44:36 +03:00
|
|
|
'accel/kvm',
|
2020-08-19 15:44:56 +03:00
|
|
|
'audio',
|
|
|
|
'backends',
|
|
|
|
'backends/tpm',
|
|
|
|
'chardev',
|
2021-05-14 14:48:32 +03:00
|
|
|
'ebpf',
|
2020-08-19 15:44:56 +03:00
|
|
|
'hw/9pfs',
|
|
|
|
'hw/acpi',
|
2021-01-08 22:09:42 +03:00
|
|
|
'hw/adc',
|
2020-08-19 15:44:56 +03:00
|
|
|
'hw/alpha',
|
|
|
|
'hw/arm',
|
|
|
|
'hw/audio',
|
|
|
|
'hw/block',
|
|
|
|
'hw/block/dataplane',
|
|
|
|
'hw/char',
|
|
|
|
'hw/display',
|
|
|
|
'hw/dma',
|
|
|
|
'hw/hyperv',
|
|
|
|
'hw/i2c',
|
|
|
|
'hw/i386',
|
|
|
|
'hw/i386/xen',
|
|
|
|
'hw/ide',
|
|
|
|
'hw/input',
|
|
|
|
'hw/intc',
|
|
|
|
'hw/isa',
|
|
|
|
'hw/mem',
|
|
|
|
'hw/mips',
|
|
|
|
'hw/misc',
|
|
|
|
'hw/misc/macio',
|
|
|
|
'hw/net',
|
hw/net/can: Introduce Xilinx ZynqMP CAN controller
The Xilinx ZynqMP CAN controller is developed based on SocketCAN, QEMU CAN bus
implementation. Bus connection and socketCAN connection for each CAN module
can be set through command lines.
Example for using single CAN:
-object can-bus,id=canbus0 \
-machine xlnx-zcu102.canbus0=canbus0 \
-object can-host-socketcan,id=socketcan0,if=vcan0,canbus=canbus0
Example for connecting both CAN to same virtual CAN on host machine:
-object can-bus,id=canbus0 -object can-bus,id=canbus1 \
-machine xlnx-zcu102.canbus0=canbus0 \
-machine xlnx-zcu102.canbus1=canbus1 \
-object can-host-socketcan,id=socketcan0,if=vcan0,canbus=canbus0 \
-object can-host-socketcan,id=socketcan1,if=vcan0,canbus=canbus1
To create virtual CAN on the host machine, please check the QEMU CAN docs:
https://github.com/qemu/qemu/blob/master/docs/can.txt
Signed-off-by: Vikram Garhwal <fnu.vikram@xilinx.com>
Message-id: 1605728926-352690-2-git-send-email-fnu.vikram@xilinx.com
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2020-11-18 22:48:43 +03:00
|
|
|
'hw/net/can',
|
2021-09-24 10:37:55 +03:00
|
|
|
'hw/nubus',
|
2021-04-14 23:14:30 +03:00
|
|
|
'hw/nvme',
|
2020-08-19 15:44:56 +03:00
|
|
|
'hw/nvram',
|
|
|
|
'hw/pci',
|
|
|
|
'hw/pci-host',
|
|
|
|
'hw/ppc',
|
|
|
|
'hw/rdma',
|
|
|
|
'hw/rdma/vmw',
|
|
|
|
'hw/rtc',
|
|
|
|
'hw/s390x',
|
|
|
|
'hw/scsi',
|
|
|
|
'hw/sd',
|
2021-10-30 00:02:09 +03:00
|
|
|
'hw/sh4',
|
2020-08-19 15:44:56 +03:00
|
|
|
'hw/sparc',
|
|
|
|
'hw/sparc64',
|
|
|
|
'hw/ssi',
|
|
|
|
'hw/timer',
|
|
|
|
'hw/tpm',
|
|
|
|
'hw/usb',
|
|
|
|
'hw/vfio',
|
|
|
|
'hw/virtio',
|
|
|
|
'hw/watchdog',
|
|
|
|
'hw/xen',
|
|
|
|
'hw/gpio',
|
|
|
|
'migration',
|
|
|
|
'net',
|
2020-08-05 16:02:20 +03:00
|
|
|
'softmmu',
|
2020-08-19 15:44:56 +03:00
|
|
|
'ui',
|
2021-01-29 19:46:10 +03:00
|
|
|
'hw/remote',
|
2020-08-19 15:44:56 +03:00
|
|
|
]
|
|
|
|
endif
|
2021-01-22 23:44:36 +03:00
|
|
|
if have_system or have_user
|
|
|
|
trace_events_subdirs += [
|
|
|
|
'accel/tcg',
|
|
|
|
'hw/core',
|
|
|
|
'target/arm',
|
2021-09-16 18:53:58 +03:00
|
|
|
'target/arm/hvf',
|
2021-01-22 23:44:36 +03:00
|
|
|
'target/hppa',
|
|
|
|
'target/i386',
|
|
|
|
'target/i386/kvm',
|
2021-05-30 10:02:16 +03:00
|
|
|
'target/mips/tcg',
|
2022-02-26 10:06:20 +03:00
|
|
|
'target/nios2',
|
2021-01-22 23:44:36 +03:00
|
|
|
'target/ppc',
|
|
|
|
'target/riscv',
|
|
|
|
'target/s390x',
|
2021-07-07 13:53:23 +03:00
|
|
|
'target/s390x/kvm',
|
2021-01-22 23:44:36 +03:00
|
|
|
'target/sparc',
|
|
|
|
]
|
|
|
|
endif
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2020-11-25 13:06:37 +03:00
|
|
|
vhost_user = not_found
|
2022-04-20 18:34:05 +03:00
|
|
|
if targetos == 'linux' and have_vhost_user
|
2020-11-25 13:06:37 +03:00
|
|
|
libvhost_user = subproject('libvhost-user')
|
|
|
|
vhost_user = libvhost_user.get_variable('vhost_user_dep')
|
|
|
|
endif
|
|
|
|
|
2022-05-23 11:46:08 +03:00
|
|
|
libvduse = not_found
|
|
|
|
if have_libvduse
|
|
|
|
libvduse_proj = subproject('libvduse')
|
|
|
|
libvduse = libvduse_proj.get_variable('libvduse_dep')
|
|
|
|
endif
|
|
|
|
|
2022-01-26 19:11:27 +03:00
|
|
|
# NOTE: the trace/ subdirectory needs the qapi_trace_events variable
|
|
|
|
# that is filled in by qapi/.
|
2020-08-19 15:44:56 +03:00
|
|
|
subdir('qapi')
|
|
|
|
subdir('qobject')
|
|
|
|
subdir('stubs')
|
|
|
|
subdir('trace')
|
|
|
|
subdir('util')
|
2019-07-16 18:28:54 +03:00
|
|
|
subdir('qom')
|
|
|
|
subdir('authz')
|
2020-08-19 15:44:56 +03:00
|
|
|
subdir('crypto')
|
2019-07-15 15:00:36 +03:00
|
|
|
subdir('ui')
|
2022-04-25 10:57:21 +03:00
|
|
|
subdir('hw')
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2019-08-29 21:07:01 +03:00
|
|
|
|
|
|
|
if enable_modules
|
|
|
|
libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
|
|
|
|
modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
|
|
|
|
endif
|
|
|
|
|
2022-04-25 10:57:21 +03:00
|
|
|
qom_ss = qom_ss.apply(config_host, strict: false)
|
|
|
|
libqom = static_library('qom', qom_ss.sources() + genh,
|
|
|
|
dependencies: [qom_ss.dependencies()],
|
|
|
|
name_suffix: 'fa')
|
|
|
|
qom = declare_dependency(link_whole: libqom)
|
|
|
|
|
|
|
|
event_loop_base = files('event-loop-base.c')
|
|
|
|
event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
|
|
|
|
build_by_default: true)
|
|
|
|
event_loop_base = declare_dependency(link_whole: event_loop_base,
|
|
|
|
dependencies: [qom])
|
|
|
|
|
2020-02-03 13:42:03 +03:00
|
|
|
stub_ss = stub_ss.apply(config_all, strict: false)
|
2020-08-19 15:44:56 +03:00
|
|
|
|
|
|
|
util_ss.add_all(trace_ss)
|
2020-02-03 13:42:03 +03:00
|
|
|
util_ss = util_ss.apply(config_all, strict: false)
|
2020-08-19 15:44:56 +03:00
|
|
|
libqemuutil = static_library('qemuutil',
|
|
|
|
sources: util_ss.sources() + stub_ss.sources() + genh,
|
2021-06-03 16:01:35 +03:00
|
|
|
dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
|
2020-08-19 15:44:56 +03:00
|
|
|
qemuutil = declare_dependency(link_with: libqemuutil,
|
2022-04-25 10:57:22 +03:00
|
|
|
sources: genh + version_res,
|
|
|
|
dependencies: [event_loop_base])
|
2020-08-19 15:44:56 +03:00
|
|
|
|
2021-01-22 23:44:37 +03:00
|
|
|
if have_system or have_user
|
|
|
|
decodetree = generator(find_program('scripts/decodetree.py'),
|
|
|
|
output: 'decode-@BASENAME@.c.inc',
|
|
|
|
arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
|
|
|
|
subdir('libdecnumber')
|
|
|
|
subdir('target')
|
|
|
|
endif
|
2020-08-07 13:10:23 +03:00
|
|
|
|
2020-08-17 13:47:55 +03:00
|
|
|
subdir('audio')
|
2019-07-16 18:33:55 +03:00
|
|
|
subdir('io')
|
2019-07-15 22:18:07 +03:00
|
|
|
subdir('chardev')
|
2019-07-15 14:04:49 +03:00
|
|
|
subdir('fsdev')
|
2019-09-03 15:59:33 +03:00
|
|
|
subdir('dump')
|
2019-07-15 14:04:49 +03:00
|
|
|
|
2021-01-22 23:44:34 +03:00
|
|
|
if have_block
|
|
|
|
block_ss.add(files(
|
|
|
|
'block.c',
|
|
|
|
'blockjob.c',
|
|
|
|
'job.c',
|
|
|
|
'qemu-io-cmds.c',
|
|
|
|
))
|
2021-10-13 12:43:54 +03:00
|
|
|
if config_host_data.get('CONFIG_REPLICATION')
|
|
|
|
block_ss.add(files('replication.c'))
|
|
|
|
endif
|
2021-01-22 23:44:34 +03:00
|
|
|
|
|
|
|
subdir('nbd')
|
|
|
|
subdir('scsi')
|
|
|
|
subdir('block')
|
|
|
|
|
|
|
|
blockdev_ss.add(files(
|
|
|
|
'blockdev.c',
|
|
|
|
'blockdev-nbd.c',
|
|
|
|
'iothread.c',
|
|
|
|
'job-qmp.c',
|
|
|
|
), gnutls)
|
|
|
|
|
|
|
|
# os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
|
|
|
|
# os-win32.c does not
|
|
|
|
blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
|
|
|
|
softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
|
|
|
|
endif
|
2020-08-03 17:22:28 +03:00
|
|
|
|
|
|
|
common_ss.add(files('cpus-common.c'))
|
|
|
|
|
2020-08-06 14:40:26 +03:00
|
|
|
subdir('softmmu')
|
2019-08-18 18:51:17 +03:00
|
|
|
|
2020-09-12 20:47:33 +03:00
|
|
|
common_ss.add(capstone)
|
2020-10-06 10:05:29 +03:00
|
|
|
specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
|
2019-08-18 18:51:17 +03:00
|
|
|
|
exec: Build page-vary-common.c with -fno-lto
In bbc17caf81f, we used an alias attribute to allow target_page
to be declared const, and yet be initialized late.
This fails when using LTO with several versions of gcc.
The compiler looks through the alias and decides that the const
variable is statically initialized to zero, then propagates that
zero to many uses of the variable.
This can be avoided by compiling one object file with -fno-lto.
In this way, any initializer cannot be seen, and the constant
propagation does not occur.
Since we are certain to have this separate compilation unit, we
can drop the alias attribute as well. We simply have differing
declarations for target_page in different compilation units.
Drop the use of init_target_page, and drop the configure detection
for CONFIG_ATTRIBUTE_ALIAS.
In order to change the compilation flags for a file with meson,
we must use a static_library. This runs into specific_ss, where
we would need to create many static_library instances.
Fix this by splitting page-vary.c: the page-vary-common.c part is
compiled once as a static_library, while the page-vary.c part is
left in specific_ss in order to handle the target-specific value
of TARGET_PAGE_BITS_MIN.
Reported-by: Gavin Shan <gshan@redhat.com>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20210321211534.2101231-1-richard.henderson@linaro.org>
[PMD: Fix typo in subject, split original patch in 3]
Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Tested-by: Gavin Shan <gshan@redhat.com>
Message-Id: <20210322112427.4045204-4-f4bug@amsat.org>
[rth: Update MAINTAINERS]
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2021-03-22 14:24:26 +03:00
|
|
|
# Work around a gcc bug/misfeature wherein constant propagation looks
|
|
|
|
# through an alias:
|
|
|
|
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
|
|
|
|
# to guess that a const variable is always zero. Without lto, this is
|
|
|
|
# impossible, as the alias is restricted to page-vary-common.c. Indeed,
|
|
|
|
# without lto, not even the alias is required -- we simply use different
|
|
|
|
# declarations in different compilation units.
|
|
|
|
pagevary = files('page-vary-common.c')
|
|
|
|
if get_option('b_lto')
|
|
|
|
pagevary_flags = ['-fno-lto']
|
|
|
|
if get_option('cfi')
|
|
|
|
pagevary_flags += '-fno-sanitize=cfi-icall'
|
|
|
|
endif
|
2022-03-30 14:48:08 +03:00
|
|
|
pagevary = static_library('page-vary-common', sources: pagevary + genh,
|
exec: Build page-vary-common.c with -fno-lto
In bbc17caf81f, we used an alias attribute to allow target_page
to be declared const, and yet be initialized late.
This fails when using LTO with several versions of gcc.
The compiler looks through the alias and decides that the const
variable is statically initialized to zero, then propagates that
zero to many uses of the variable.
This can be avoided by compiling one object file with -fno-lto.
In this way, any initializer cannot be seen, and the constant
propagation does not occur.
Since we are certain to have this separate compilation unit, we
can drop the alias attribute as well. We simply have differing
declarations for target_page in different compilation units.
Drop the use of init_target_page, and drop the configure detection
for CONFIG_ATTRIBUTE_ALIAS.
In order to change the compilation flags for a file with meson,
we must use a static_library. This runs into specific_ss, where
we would need to create many static_library instances.
Fix this by splitting page-vary.c: the page-vary-common.c part is
compiled once as a static_library, while the page-vary.c part is
left in specific_ss in order to handle the target-specific value
of TARGET_PAGE_BITS_MIN.
Reported-by: Gavin Shan <gshan@redhat.com>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20210321211534.2101231-1-richard.henderson@linaro.org>
[PMD: Fix typo in subject, split original patch in 3]
Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Tested-by: Gavin Shan <gshan@redhat.com>
Message-Id: <20210322112427.4045204-4-f4bug@amsat.org>
[rth: Update MAINTAINERS]
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2021-03-22 14:24:26 +03:00
|
|
|
c_args: pagevary_flags)
|
|
|
|
pagevary = declare_dependency(link_with: pagevary)
|
|
|
|
endif
|
|
|
|
common_ss.add(pagevary)
|
2021-03-22 14:24:24 +03:00
|
|
|
specific_ss.add(files('page-vary.c'))
|
|
|
|
|
2019-07-24 18:23:16 +03:00
|
|
|
subdir('backends')
|
2019-07-26 11:02:31 +03:00
|
|
|
subdir('disas')
|
2019-07-24 18:16:22 +03:00
|
|
|
subdir('migration')
|
2020-08-04 22:14:26 +03:00
|
|
|
subdir('monitor')
|
2019-07-22 22:47:50 +03:00
|
|
|
subdir('net')
|
2019-07-22 22:40:45 +03:00
|
|
|
subdir('replay')
|
2021-03-05 16:54:50 +03:00
|
|
|
subdir('semihosting')
|
2021-03-08 23:04:33 +03:00
|
|
|
subdir('tcg')
|
2021-03-08 23:15:06 +03:00
|
|
|
subdir('fpu')
|
2019-08-18 15:13:08 +03:00
|
|
|
subdir('accel')
|
2020-01-24 15:08:01 +03:00
|
|
|
subdir('plugins')
|
2021-11-17 18:14:00 +03:00
|
|
|
subdir('ebpf')
|
|
|
|
|
|
|
|
common_user_inc = []
|
|
|
|
|
|
|
|
subdir('common-user')
|
2019-08-18 18:20:37 +03:00
|
|
|
subdir('bsd-user')
|
2019-08-18 15:13:08 +03:00
|
|
|
subdir('linux-user')
|
2021-05-14 14:48:32 +03:00
|
|
|
|
2020-08-04 21:00:40 +03:00
|
|
|
# needed for fuzzing binaries
|
|
|
|
subdir('tests/qtest/libqos')
|
2020-08-03 18:04:25 +03:00
|
|
|
subdir('tests/qtest/fuzz')
|
2020-08-04 21:00:40 +03:00
|
|
|
|
2021-06-24 13:38:29 +03:00
|
|
|
# accel modules
|
2021-06-24 13:38:31 +03:00
|
|
|
tcg_real_module_ss = ss.source_set()
|
|
|
|
tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
|
|
|
|
specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
|
|
|
|
target_modules += { 'accel' : { 'qtest': qtest_module_ss,
|
|
|
|
'tcg': tcg_real_module_ss }}
|
2021-06-24 13:38:29 +03:00
|
|
|
|
2020-10-07 18:01:51 +03:00
|
|
|
########################
|
|
|
|
# Library dependencies #
|
|
|
|
########################
|
|
|
|
|
2021-06-24 13:38:04 +03:00
|
|
|
modinfo_collect = find_program('scripts/modinfo-collect.py')
|
2021-06-24 13:38:05 +03:00
|
|
|
modinfo_generate = find_program('scripts/modinfo-generate.py')
|
2021-06-24 13:38:04 +03:00
|
|
|
modinfo_files = []
|
|
|
|
|
2019-08-29 21:07:01 +03:00
|
|
|
block_mods = []
|
|
|
|
softmmu_mods = []
|
|
|
|
foreach d, list : modules
|
|
|
|
foreach m, module_ss : list
|
|
|
|
if enable_modules and targetos != 'windows'
|
2020-09-14 16:42:20 +03:00
|
|
|
module_ss = module_ss.apply(config_all, strict: false)
|
2019-08-29 21:07:01 +03:00
|
|
|
sl = static_library(d + '-' + m, [genh, module_ss.sources()],
|
|
|
|
dependencies: [modulecommon, module_ss.dependencies()], pic: true)
|
|
|
|
if d == 'block'
|
|
|
|
block_mods += sl
|
|
|
|
else
|
|
|
|
softmmu_mods += sl
|
|
|
|
endif
|
2021-06-24 13:38:04 +03:00
|
|
|
if module_ss.sources() != []
|
|
|
|
# FIXME: Should use sl.extract_all_objects(recursive: true) as
|
|
|
|
# input. Sources can be used multiple times but objects are
|
|
|
|
# unique when it comes to lookup in compile_commands.json.
|
|
|
|
# Depnds on a mesion version with
|
|
|
|
# https://github.com/mesonbuild/meson/pull/8900
|
|
|
|
modinfo_files += custom_target(d + '-' + m + '.modinfo',
|
|
|
|
output: d + '-' + m + '.modinfo',
|
2021-07-21 19:51:57 +03:00
|
|
|
input: module_ss.sources() + genh,
|
2021-06-24 13:38:04 +03:00
|
|
|
capture: true,
|
2021-07-21 19:51:57 +03:00
|
|
|
command: [modinfo_collect, module_ss.sources()])
|
2021-06-24 13:38:04 +03:00
|
|
|
endif
|
2019-08-29 21:07:01 +03:00
|
|
|
else
|
|
|
|
if d == 'block'
|
|
|
|
block_ss.add_all(module_ss)
|
|
|
|
else
|
|
|
|
softmmu_ss.add_all(module_ss)
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
endforeach
|
|
|
|
|
2021-06-24 13:38:22 +03:00
|
|
|
foreach d, list : target_modules
|
|
|
|
foreach m, module_ss : list
|
|
|
|
if enable_modules and targetos != 'windows'
|
|
|
|
foreach target : target_dirs
|
|
|
|
if target.endswith('-softmmu')
|
|
|
|
config_target = config_target_mak[target]
|
|
|
|
config_target += config_host
|
|
|
|
target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
|
|
|
|
c_args = ['-DNEED_CPU_H',
|
|
|
|
'-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
|
|
|
|
'-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
|
|
|
|
target_module_ss = module_ss.apply(config_target, strict: false)
|
|
|
|
if target_module_ss.sources() != []
|
|
|
|
module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
|
|
|
|
sl = static_library(module_name,
|
|
|
|
[genh, target_module_ss.sources()],
|
|
|
|
dependencies: [modulecommon, target_module_ss.dependencies()],
|
|
|
|
include_directories: target_inc,
|
|
|
|
c_args: c_args,
|
|
|
|
pic: true)
|
|
|
|
softmmu_mods += sl
|
|
|
|
# FIXME: Should use sl.extract_all_objects(recursive: true) too.
|
|
|
|
modinfo_files += custom_target(module_name + '.modinfo',
|
|
|
|
output: module_name + '.modinfo',
|
2021-07-23 15:01:56 +03:00
|
|
|
input: target_module_ss.sources() + genh,
|
2021-06-24 13:38:22 +03:00
|
|
|
capture: true,
|
2021-07-23 15:01:56 +03:00
|
|
|
command: [modinfo_collect, '--target', target, target_module_ss.sources()])
|
2021-06-24 13:38:22 +03:00
|
|
|
endif
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
else
|
|
|
|
specific_ss.add_all(module_ss)
|
|
|
|
endif
|
|
|
|
endforeach
|
|
|
|
endforeach
|
|
|
|
|
2021-06-24 13:38:05 +03:00
|
|
|
if enable_modules
|
2022-05-28 01:20:35 +03:00
|
|
|
foreach target : target_dirs
|
|
|
|
if target.endswith('-softmmu')
|
|
|
|
config_target = config_target_mak[target]
|
|
|
|
config_devices_mak = target + '-config-devices.mak'
|
|
|
|
modinfo_src = custom_target('modinfo-' + target + '.c',
|
|
|
|
output: 'modinfo-' + target + '.c',
|
|
|
|
input: modinfo_files,
|
|
|
|
command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
|
|
|
|
capture: true)
|
|
|
|
|
|
|
|
modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
|
|
|
|
modinfo_dep = declare_dependency(link_with: modinfo_lib)
|
|
|
|
|
|
|
|
arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
|
|
|
|
hw_arch[arch].add(modinfo_dep)
|
|
|
|
endif
|
|
|
|
endforeach
|
2021-06-24 13:38:05 +03:00
|
|
|
endif
|
|
|
|
|
2019-08-29 21:07:01 +03:00
|
|
|
nm = find_program('nm')
|
2020-09-02 20:00:50 +03:00
|
|
|
undefsym = find_program('scripts/undefsym.py')
|
2019-08-29 21:07:01 +03:00
|
|
|
block_syms = custom_target('block.syms', output: 'block.syms',
|
|
|
|
input: [libqemuutil, block_mods],
|
|
|
|
capture: true,
|
|
|
|
command: [undefsym, nm, '@INPUT@'])
|
|
|
|
qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
|
|
|
|
input: [libqemuutil, softmmu_mods],
|
|
|
|
capture: true,
|
|
|
|
command: [undefsym, nm, '@INPUT@'])
|
|
|
|
|
2020-10-06 15:56:01 +03:00
|
|
|
authz_ss = authz_ss.apply(config_host, strict: false)
|
|
|
|
libauthz = static_library('authz', authz_ss.sources() + genh,
|
|
|
|
dependencies: [authz_ss.dependencies()],
|
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
|
|
|
|
authz = declare_dependency(link_whole: libauthz,
|
|
|
|
dependencies: qom)
|
|
|
|
|
2020-10-06 15:56:00 +03:00
|
|
|
crypto_ss = crypto_ss.apply(config_host, strict: false)
|
|
|
|
libcrypto = static_library('crypto', crypto_ss.sources() + genh,
|
|
|
|
dependencies: [crypto_ss.dependencies()],
|
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
|
|
|
|
crypto = declare_dependency(link_whole: libcrypto,
|
|
|
|
dependencies: [authz, qom])
|
|
|
|
|
2020-10-06 15:55:59 +03:00
|
|
|
io_ss = io_ss.apply(config_host, strict: false)
|
|
|
|
libio = static_library('io', io_ss.sources() + genh,
|
|
|
|
dependencies: [io_ss.dependencies()],
|
|
|
|
link_with: libqemuutil,
|
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
|
|
|
|
io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
|
|
|
|
|
2020-10-06 15:55:58 +03:00
|
|
|
libmigration = static_library('migration', sources: migration_files + genh,
|
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
migration = declare_dependency(link_with: libmigration,
|
|
|
|
dependencies: [zlib, qom, io])
|
|
|
|
softmmu_ss.add(migration)
|
|
|
|
|
2019-08-29 21:34:43 +03:00
|
|
|
block_ss = block_ss.apply(config_host, strict: false)
|
|
|
|
libblock = static_library('block', block_ss.sources() + genh,
|
|
|
|
dependencies: block_ss.dependencies(),
|
|
|
|
link_depends: block_syms,
|
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
|
|
|
|
block = declare_dependency(link_whole: [libblock],
|
2019-07-16 20:37:25 +03:00
|
|
|
link_args: '@block.syms',
|
|
|
|
dependencies: [crypto, io])
|
2019-08-29 21:34:43 +03:00
|
|
|
|
2020-09-29 15:55:14 +03:00
|
|
|
blockdev_ss = blockdev_ss.apply(config_host, strict: false)
|
|
|
|
libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
|
|
|
|
dependencies: blockdev_ss.dependencies(),
|
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
|
|
|
|
blockdev = declare_dependency(link_whole: [libblockdev],
|
2022-04-25 10:57:21 +03:00
|
|
|
dependencies: [block, event_loop_base])
|
2020-09-29 15:55:14 +03:00
|
|
|
|
2020-08-04 22:14:26 +03:00
|
|
|
qmp_ss = qmp_ss.apply(config_host, strict: false)
|
|
|
|
libqmp = static_library('qmp', qmp_ss.sources() + genh,
|
|
|
|
dependencies: qmp_ss.dependencies(),
|
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
|
|
|
|
qmp = declare_dependency(link_whole: [libqmp])
|
|
|
|
|
2020-10-06 15:55:57 +03:00
|
|
|
libchardev = static_library('chardev', chardev_ss.sources() + genh,
|
|
|
|
name_suffix: 'fa',
|
2022-03-23 18:57:12 +03:00
|
|
|
dependencies: chardev_ss.dependencies(),
|
2020-10-06 15:55:57 +03:00
|
|
|
build_by_default: false)
|
|
|
|
|
|
|
|
chardev = declare_dependency(link_whole: libchardev)
|
|
|
|
|
2021-10-28 17:34:19 +03:00
|
|
|
hwcore_ss = hwcore_ss.apply(config_host, strict: false)
|
|
|
|
libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
|
2020-10-06 15:55:56 +03:00
|
|
|
name_suffix: 'fa',
|
|
|
|
build_by_default: false)
|
|
|
|
hwcore = declare_dependency(link_whole: libhwcore)
|
|
|
|
common_ss.add(hwcore)
|
|
|
|
|
2020-10-06 15:55:54 +03:00
|
|
|
###########
|
|
|
|
# Targets #
|
|
|
|
###########
|
|
|
|
|
2022-01-07 15:00:44 +03:00
|
|
|
emulator_modules = []
|
2019-08-29 21:07:01 +03:00
|
|
|
foreach m : block_mods + softmmu_mods
|
2022-01-07 15:00:44 +03:00
|
|
|
emulator_modules += shared_module(m.name(),
|
|
|
|
build_by_default: true,
|
2019-08-29 21:07:01 +03:00
|
|
|
name_prefix: '',
|
|
|
|
link_whole: m,
|
|
|
|
install: true,
|
2020-10-16 10:19:14 +03:00
|
|
|
install_dir: qemu_moddir)
|
2019-08-29 21:07:01 +03:00
|
|
|
endforeach
|
2022-05-30 15:24:34 +03:00
|
|
|
if emulator_modules.length() > 0
|
|
|
|
alias_target('modules', emulator_modules)
|
|
|
|
endif
|
2019-08-29 21:07:01 +03:00
|
|
|
|
2020-09-29 15:55:14 +03:00
|
|
|
softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
|
2020-08-03 18:04:25 +03:00
|
|
|
common_ss.add(qom, qemuutil)
|
|
|
|
|
|
|
|
common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
|
2020-02-03 13:42:03 +03:00
|
|
|
common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
|
|
|
|
|
|
|
|
common_all = common_ss.apply(config_all, strict: false)
|
|
|
|
common_all = static_library('common',
|
|
|
|
build_by_default: false,
|
|
|
|
sources: common_all.sources() + genh,
|
2021-12-21 18:09:54 +03:00
|
|
|
include_directories: common_user_inc,
|
2021-04-29 05:43:07 +03:00
|
|
|
implicit_include_directories: false,
|
2020-02-03 13:42:03 +03:00
|
|
|
dependencies: common_all.dependencies(),
|
|
|
|
name_suffix: 'fa')
|
|
|
|
|
2019-08-18 18:51:17 +03:00
|
|
|
feature_to_c = find_program('scripts/feature_to_c.sh')
|
|
|
|
|
2022-02-15 19:25:03 +03:00
|
|
|
if targetos == 'darwin'
|
|
|
|
entitlement = find_program('scripts/entitlement.sh')
|
|
|
|
endif
|
|
|
|
|
2020-09-16 12:00:53 +03:00
|
|
|
emulators = {}
|
2020-02-03 13:42:03 +03:00
|
|
|
foreach target : target_dirs
|
|
|
|
config_target = config_target_mak[target]
|
|
|
|
target_name = config_target['TARGET_NAME']
|
2021-11-08 17:44:39 +03:00
|
|
|
target_base_arch = config_target['TARGET_BASE_ARCH']
|
2020-08-04 19:14:26 +03:00
|
|
|
arch_srcs = [config_target_h[target]]
|
2020-08-03 18:04:25 +03:00
|
|
|
arch_deps = []
|
|
|
|
c_args = ['-DNEED_CPU_H',
|
|
|
|
'-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
|
|
|
|
'-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
|
2020-09-21 11:49:50 +03:00
|
|
|
link_args = emulator_link_args
|
2020-02-03 13:42:03 +03:00
|
|
|
|
2020-08-04 19:14:26 +03:00
|
|
|
config_target += config_host
|
2020-02-03 13:42:03 +03:00
|
|
|
target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
|
|
|
|
if targetos == 'linux'
|
|
|
|
target_inc += include_directories('linux-headers', is_system: true)
|
|
|
|
endif
|
|
|
|
if target.endswith('-softmmu')
|
|
|
|
qemu_target_name = 'qemu-system-' + target_name
|
|
|
|
target_type='system'
|
2021-11-08 17:44:39 +03:00
|
|
|
t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
|
2020-08-07 13:10:23 +03:00
|
|
|
arch_srcs += t.sources()
|
2020-08-03 18:04:25 +03:00
|
|
|
arch_deps += t.dependencies()
|
2020-08-07 13:10:23 +03:00
|
|
|
|
2021-11-08 17:44:39 +03:00
|
|
|
hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
|
2019-08-17 12:55:58 +03:00
|
|
|
hw = hw_arch[hw_dir].apply(config_target, strict: false)
|
|
|
|
arch_srcs += hw.sources()
|
2020-08-03 18:04:25 +03:00
|
|
|
arch_deps += hw.dependencies()
|
2019-08-17 12:55:58 +03:00
|
|
|
|
2020-02-03 13:42:03 +03:00
|
|
|
arch_srcs += config_devices_h[target]
|
2020-08-03 18:04:25 +03:00
|
|
|
link_args += ['@block.syms', '@qemu.syms']
|
2020-02-03 13:42:03 +03:00
|
|
|
else
|
2019-08-18 15:13:08 +03:00
|
|
|
abi = config_target['TARGET_ABI_DIR']
|
2020-02-03 13:42:03 +03:00
|
|
|
target_type='user'
|
2021-12-21 18:23:55 +03:00
|
|
|
target_inc += common_user_inc
|
2020-02-03 13:42:03 +03:00
|
|
|
qemu_target_name = 'qemu-' + target_name
|
2021-11-08 17:44:39 +03:00
|
|
|
if target_base_arch in target_user_arch
|
|
|
|
t = target_user_arch[target_base_arch].apply(config_target, strict: false)
|
2021-04-13 12:27:09 +03:00
|
|
|
arch_srcs += t.sources()
|
|
|
|
arch_deps += t.dependencies()
|
|
|
|
endif
|
2020-02-03 13:42:03 +03:00
|
|
|
if 'CONFIG_LINUX_USER' in config_target
|
|
|
|
base_dir = 'linux-user'
|
2021-08-04 02:17:17 +03:00
|
|
|
endif
|
|
|
|
if 'CONFIG_BSD_USER' in config_target
|
2020-02-03 13:42:03 +03:00
|
|
|
base_dir = 'bsd-user'
|
2021-08-04 02:17:17 +03:00
|
|
|
target_inc += include_directories('bsd-user/' / targetos)
|
2022-01-09 03:27:34 +03:00
|
|
|
target_inc += include_directories('bsd-user/host/' / host_arch)
|
2021-08-04 02:17:17 +03:00
|
|
|
dir = base_dir / abi
|
2021-11-05 01:34:48 +03:00
|
|
|
arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
|
2020-02-03 13:42:03 +03:00
|
|
|
endif
|
|
|
|
target_inc += include_directories(
|
|
|
|
base_dir,
|
2019-08-18 15:13:08 +03:00
|
|
|
base_dir / abi,
|
2020-02-03 13:42:03 +03:00
|
|
|
)
|
2019-08-18 15:13:08 +03:00
|
|
|
if 'CONFIG_LINUX_USER' in config_target
|
|
|
|
dir = base_dir / abi
|
|
|
|
arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
|
|
|
|
if config_target.has_key('TARGET_SYSTBL_ABI')
|
|
|
|
arch_srcs += \
|
|
|
|
syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
|
|
|
|
extra_args : config_target['TARGET_SYSTBL_ABI'])
|
|
|
|
endif
|
|
|
|
endif
|
2020-02-03 13:42:03 +03:00
|
|
|
endif
|
|
|
|
|
2019-08-18 18:51:17 +03:00
|
|
|
if 'TARGET_XML_FILES' in config_target
|
|
|
|
gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
|
|
|
|
output: target + '-gdbstub-xml.c',
|
|
|
|
input: files(config_target['TARGET_XML_FILES'].split()),
|
|
|
|
command: [feature_to_c, '@INPUT@'],
|
|
|
|
capture: true)
|
|
|
|
arch_srcs += gdbstub_xml
|
|
|
|
endif
|
|
|
|
|
2021-11-08 17:44:39 +03:00
|
|
|
t = target_arch[target_base_arch].apply(config_target, strict: false)
|
2020-08-07 13:10:23 +03:00
|
|
|
arch_srcs += t.sources()
|
2020-08-03 18:04:25 +03:00
|
|
|
arch_deps += t.dependencies()
|
2020-08-07 13:10:23 +03:00
|
|
|
|
2020-02-03 13:42:03 +03:00
|
|
|
target_common = common_ss.apply(config_target, strict: false)
|
|
|
|
objects = common_all.extract_objects(target_common.sources())
|
2020-08-03 18:04:25 +03:00
|
|
|
deps = target_common.dependencies()
|
2020-02-03 13:42:03 +03:00
|
|
|
|
|
|
|
target_specific = specific_ss.apply(config_target, strict: false)
|
|
|
|
arch_srcs += target_specific.sources()
|
2020-08-03 18:04:25 +03:00
|
|
|
arch_deps += target_specific.dependencies()
|
2020-02-03 13:42:03 +03:00
|
|
|
|
2020-08-03 18:04:25 +03:00
|
|
|
lib = static_library('qemu-' + target,
|
2020-08-04 19:14:26 +03:00
|
|
|
sources: arch_srcs + genh,
|
2020-08-26 09:22:58 +03:00
|
|
|
dependencies: arch_deps,
|
2020-02-03 13:42:03 +03:00
|
|
|
objects: objects,
|
|
|
|
include_directories: target_inc,
|
2020-08-03 18:04:25 +03:00
|
|
|
c_args: c_args,
|
|
|
|
build_by_default: false,
|
2020-02-03 13:42:03 +03:00
|
|
|
name_suffix: 'fa')
|
2020-08-03 18:04:25 +03:00
|
|
|
|
|
|
|
if target.endswith('-softmmu')
|
|
|
|
execs = [{
|
|
|
|
'name': 'qemu-system-' + target_name,
|
2021-02-09 16:59:26 +03:00
|
|
|
'win_subsystem': 'console',
|
2020-08-03 18:04:25 +03:00
|
|
|
'sources': files('softmmu/main.c'),
|
|
|
|
'dependencies': []
|
|
|
|
}]
|
2020-02-06 16:17:15 +03:00
|
|
|
if targetos == 'windows' and (sdl.found() or gtk.found())
|
2020-08-03 18:04:25 +03:00
|
|
|
execs += [{
|
|
|
|
'name': 'qemu-system-' + target_name + 'w',
|
2021-02-09 16:59:26 +03:00
|
|
|
'win_subsystem': 'windows',
|
2020-08-03 18:04:25 +03:00
|
|
|
'sources': files('softmmu/main.c'),
|
|
|
|
'dependencies': []
|
|
|
|
}]
|
|
|
|
endif
|
2021-10-07 16:08:12 +03:00
|
|
|
if get_option('fuzzing')
|
2020-08-03 18:04:25 +03:00
|
|
|
specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
|
|
|
|
execs += [{
|
|
|
|
'name': 'qemu-fuzz-' + target_name,
|
2021-02-09 16:59:26 +03:00
|
|
|
'win_subsystem': 'console',
|
2020-08-03 18:04:25 +03:00
|
|
|
'sources': specific_fuzz.sources(),
|
|
|
|
'dependencies': specific_fuzz.dependencies(),
|
|
|
|
}]
|
|
|
|
endif
|
|
|
|
else
|
|
|
|
execs = [{
|
|
|
|
'name': 'qemu-' + target_name,
|
2021-02-09 16:59:26 +03:00
|
|
|
'win_subsystem': 'console',
|
2020-08-03 18:04:25 +03:00
|
|
|
'sources': [],
|
|
|
|
'dependencies': []
|
|
|
|
}]
|
|
|
|
endif
|
|
|
|
foreach exe: execs
|
2021-01-21 01:44:34 +03:00
|
|
|
exe_name = exe['name']
|
2021-07-05 22:53:28 +03:00
|
|
|
if targetos == 'darwin'
|
2021-01-21 01:44:34 +03:00
|
|
|
exe_name += '-unsigned'
|
|
|
|
endif
|
|
|
|
|
|
|
|
emulator = executable(exe_name, exe['sources'],
|
2021-02-25 03:06:14 +03:00
|
|
|
install: true,
|
2020-08-03 18:04:25 +03:00
|
|
|
c_args: c_args,
|
|
|
|
dependencies: arch_deps + deps + exe['dependencies'],
|
|
|
|
objects: lib.extract_all_objects(recursive: true),
|
|
|
|
link_language: link_language,
|
|
|
|
link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
|
|
|
|
link_args: link_args,
|
2021-02-09 16:59:26 +03:00
|
|
|
win_subsystem: exe['win_subsystem'])
|
2021-01-21 01:44:34 +03:00
|
|
|
|
2021-07-05 22:53:28 +03:00
|
|
|
if targetos == 'darwin'
|
2021-07-09 04:25:33 +03:00
|
|
|
icon = 'pc-bios/qemu.rsrc'
|
|
|
|
build_input = [emulator, files(icon)]
|
|
|
|
install_input = [
|
|
|
|
get_option('bindir') / exe_name,
|
|
|
|
meson.current_source_dir() / icon
|
|
|
|
]
|
|
|
|
if 'CONFIG_HVF' in config_target
|
|
|
|
entitlements = 'accel/hvf/entitlements.plist'
|
|
|
|
build_input += files(entitlements)
|
|
|
|
install_input += meson.current_source_dir() / entitlements
|
|
|
|
endif
|
|
|
|
|
2021-01-21 01:44:34 +03:00
|
|
|
emulators += {exe['name'] : custom_target(exe['name'],
|
2021-07-09 04:25:33 +03:00
|
|
|
input: build_input,
|
2021-01-21 01:44:34 +03:00
|
|
|
output: exe['name'],
|
2022-01-22 03:20:52 +03:00
|
|
|
command: [entitlement, '@OUTPUT@', '@INPUT@'])
|
2021-01-21 01:44:34 +03:00
|
|
|
}
|
2021-02-25 03:06:14 +03:00
|
|
|
|
2022-01-22 03:20:52 +03:00
|
|
|
meson.add_install_script(entitlement, '--install',
|
2021-02-25 03:06:14 +03:00
|
|
|
get_option('bindir') / exe['name'],
|
2021-07-09 04:25:33 +03:00
|
|
|
install_input)
|
2021-01-21 01:44:34 +03:00
|
|
|
else
|
|
|
|
emulators += {exe['name']: emulator}
|
|
|
|
endif
|
2019-08-20 11:29:52 +03:00
|
|
|
|
2021-10-07 16:08:14 +03:00
|
|
|
if stap.found()
|
2019-08-20 11:29:52 +03:00
|
|
|
foreach stp: [
|
2020-08-25 09:49:53 +03:00
|
|
|
{'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
|
|
|
|
{'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
|
2019-08-20 11:29:52 +03:00
|
|
|
{'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
|
|
|
|
{'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
|
|
|
|
]
|
2020-08-25 09:49:53 +03:00
|
|
|
custom_target(exe['name'] + stp['ext'],
|
2019-08-20 11:29:52 +03:00
|
|
|
input: trace_events_all,
|
2020-08-25 09:49:53 +03:00
|
|
|
output: exe['name'] + stp['ext'],
|
2019-08-20 11:29:52 +03:00
|
|
|
install: stp['install'],
|
2020-10-16 10:19:14 +03:00
|
|
|
install_dir: get_option('datadir') / 'systemtap/tapset',
|
2019-08-20 11:29:52 +03:00
|
|
|
command: [
|
|
|
|
tracetool, '--group=all', '--format=' + stp['fmt'],
|
|
|
|
'--binary=' + stp['bin'],
|
|
|
|
'--target-name=' + target_name,
|
|
|
|
'--target-type=' + target_type,
|
|
|
|
'--probe-prefix=qemu.' + target_type + '.' + target_name,
|
2020-08-27 17:29:12 +03:00
|
|
|
'@INPUT@', '@OUTPUT@'
|
2021-01-25 14:09:58 +03:00
|
|
|
],
|
|
|
|
depend_files: tracetool_depends)
|
2019-08-20 11:29:52 +03:00
|
|
|
endforeach
|
|
|
|
endif
|
2020-08-03 18:04:25 +03:00
|
|
|
endforeach
|
2020-02-03 13:42:03 +03:00
|
|
|
endforeach
|
|
|
|
|
2020-02-05 11:44:24 +03:00
|
|
|
# Other build targets
|
2019-07-16 20:54:15 +03:00
|
|
|
|
2020-01-24 15:08:01 +03:00
|
|
|
if 'CONFIG_PLUGIN' in config_host
|
|
|
|
install_headers('include/qemu/qemu-plugin.h')
|
|
|
|
endif
|
|
|
|
|
2021-10-15 17:47:43 +03:00
|
|
|
subdir('qga')
|
2019-07-18 14:19:02 +03:00
|
|
|
|
2020-08-24 18:24:30 +03:00
|
|
|
# Don't build qemu-keymap if xkbcommon is not explicitly enabled
|
|
|
|
# when we don't build tools or system
|
2020-08-24 18:24:29 +03:00
|
|
|
if xkbcommon.found()
|
2019-09-19 19:24:43 +03:00
|
|
|
# used for the update-keymaps target, so include rules even if !have_tools
|
|
|
|
qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
|
|
|
|
dependencies: [qemuutil, xkbcommon], install: have_tools)
|
|
|
|
endif
|
|
|
|
|
2020-02-05 11:44:24 +03:00
|
|
|
if have_tools
|
2019-07-16 20:37:25 +03:00
|
|
|
qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
|
|
|
|
dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
|
|
|
|
qemu_io = executable('qemu-io', files('qemu-io.c'),
|
|
|
|
dependencies: [block, qemuutil], install: true)
|
2020-08-25 13:38:50 +03:00
|
|
|
qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
|
2021-11-15 23:29:43 +03:00
|
|
|
dependencies: [blockdev, qemuutil, gnutls, selinux],
|
|
|
|
install: true)
|
2019-07-16 20:37:25 +03:00
|
|
|
|
2020-08-04 21:18:36 +03:00
|
|
|
subdir('storage-daemon')
|
2019-06-10 13:27:52 +03:00
|
|
|
subdir('contrib/rdmacm-mux')
|
2019-07-12 22:47:06 +03:00
|
|
|
subdir('contrib/elf2dmp')
|
2019-06-10 13:27:52 +03:00
|
|
|
|
2019-07-15 13:50:58 +03:00
|
|
|
executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
|
|
|
|
dependencies: qemuutil,
|
|
|
|
install: true)
|
|
|
|
|
2022-04-20 18:34:05 +03:00
|
|
|
if have_vhost_user
|
2019-06-10 13:18:02 +03:00
|
|
|
subdir('contrib/vhost-user-blk')
|
2020-08-26 09:22:58 +03:00
|
|
|
subdir('contrib/vhost-user-gpu')
|
2019-07-12 21:11:20 +03:00
|
|
|
subdir('contrib/vhost-user-input')
|
2019-06-10 13:21:14 +03:00
|
|
|
subdir('contrib/vhost-user-scsi')
|
2020-02-05 11:44:24 +03:00
|
|
|
endif
|
2019-07-15 13:39:25 +03:00
|
|
|
|
|
|
|
if targetos == 'linux'
|
|
|
|
executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
|
|
|
|
dependencies: [qemuutil, libcap_ng],
|
|
|
|
install: true,
|
|
|
|
install_dir: get_option('libexecdir'))
|
2019-07-16 20:54:15 +03:00
|
|
|
|
|
|
|
executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
|
|
|
|
dependencies: [authz, crypto, io, qom, qemuutil,
|
2020-09-16 19:07:29 +03:00
|
|
|
libcap_ng, mpathpersist],
|
2019-07-16 20:54:15 +03:00
|
|
|
install: true)
|
2019-07-15 13:39:25 +03:00
|
|
|
endif
|
|
|
|
|
2021-06-03 13:50:17 +03:00
|
|
|
if have_ivshmem
|
2019-07-12 22:16:54 +03:00
|
|
|
subdir('contrib/ivshmem-client')
|
|
|
|
subdir('contrib/ivshmem-server')
|
|
|
|
endif
|
2020-02-05 11:44:24 +03:00
|
|
|
endif
|
|
|
|
|
2020-08-26 16:06:18 +03:00
|
|
|
subdir('scripts')
|
2020-02-05 11:45:39 +03:00
|
|
|
subdir('tools')
|
2019-07-15 20:22:31 +03:00
|
|
|
subdir('pc-bios')
|
2020-08-05 16:49:10 +03:00
|
|
|
subdir('docs')
|
2020-10-16 01:06:25 +03:00
|
|
|
subdir('tests')
|
2021-01-07 16:02:29 +03:00
|
|
|
if gtk.found()
|
2019-09-19 20:02:09 +03:00
|
|
|
subdir('po')
|
|
|
|
endif
|
2020-02-05 11:45:39 +03:00
|
|
|
|
2020-08-26 14:04:19 +03:00
|
|
|
if host_machine.system() == 'windows'
|
|
|
|
nsis_cmd = [
|
|
|
|
find_program('scripts/nsis.py'),
|
|
|
|
'@OUTPUT@',
|
|
|
|
get_option('prefix'),
|
|
|
|
meson.current_source_dir(),
|
2020-11-25 22:18:33 +03:00
|
|
|
host_machine.cpu(),
|
2020-08-26 14:04:19 +03:00
|
|
|
'--',
|
|
|
|
'-DDISPLAYVERSION=' + meson.project_version(),
|
|
|
|
]
|
|
|
|
if build_docs
|
|
|
|
nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
|
|
|
|
endif
|
2021-01-07 16:02:29 +03:00
|
|
|
if gtk.found()
|
2020-08-26 14:04:19 +03:00
|
|
|
nsis_cmd += '-DCONFIG_GTK=y'
|
|
|
|
endif
|
|
|
|
|
|
|
|
nsis = custom_target('nsis',
|
|
|
|
output: 'qemu-setup-' + meson.project_version() + '.exe',
|
|
|
|
input: files('qemu.nsi'),
|
|
|
|
build_always_stale: true,
|
|
|
|
command: nsis_cmd + ['@INPUT@'])
|
|
|
|
alias_target('installer', nsis)
|
|
|
|
endif
|
|
|
|
|
2020-10-07 18:01:51 +03:00
|
|
|
#########################
|
|
|
|
# Configuration summary #
|
|
|
|
#########################
|
|
|
|
|
2021-01-21 12:56:09 +03:00
|
|
|
# Directories
|
2020-02-03 15:28:38 +03:00
|
|
|
summary_info = {}
|
2020-10-16 10:19:14 +03:00
|
|
|
summary_info += {'Install prefix': get_option('prefix')}
|
|
|
|
summary_info += {'BIOS directory': qemu_datadir}
|
2022-04-20 18:33:56 +03:00
|
|
|
summary_info += {'firmware path': get_option('prefix') / get_option('qemu_firmwarepath')}
|
|
|
|
summary_info += {'binary directory': get_option('prefix') / get_option('bindir')}
|
|
|
|
summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
|
2020-10-16 10:19:14 +03:00
|
|
|
summary_info += {'module directory': qemu_moddir}
|
2022-04-20 18:33:56 +03:00
|
|
|
summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
|
|
|
|
summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
|
|
|
|
summary_info += {'config directory': get_option('prefix') / get_option('sysconfdir')}
|
2020-02-03 15:28:38 +03:00
|
|
|
if targetos != 'windows'
|
2022-04-20 18:33:56 +03:00
|
|
|
summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
|
|
|
|
summary_info += {'Manual directory': get_option('prefix') / get_option('mandir')}
|
2020-02-03 15:28:38 +03:00
|
|
|
else
|
|
|
|
summary_info += {'local state directory': 'queried at runtime'}
|
|
|
|
endif
|
2022-04-20 18:33:56 +03:00
|
|
|
summary_info += {'Doc directory': get_option('prefix') / get_option('docdir')}
|
2020-02-03 15:28:38 +03:00
|
|
|
summary_info += {'Build directory': meson.current_build_dir()}
|
|
|
|
summary_info += {'Source path': meson.current_source_dir()}
|
|
|
|
summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']}
|
2021-01-21 12:56:09 +03:00
|
|
|
summary(summary_info, bool_yn: true, section: 'Directories')
|
|
|
|
|
2021-01-21 12:56:10 +03:00
|
|
|
# Host binaries
|
|
|
|
summary_info = {}
|
|
|
|
summary_info += {'git': config_host['GIT']}
|
|
|
|
summary_info += {'make': config_host['MAKE']}
|
|
|
|
summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'sphinx-build': sphinx_build}
|
2021-01-21 12:56:10 +03:00
|
|
|
if config_host.has_key('HAVE_GDB_BIN')
|
|
|
|
summary_info += {'gdb': config_host['HAVE_GDB_BIN']}
|
|
|
|
endif
|
2022-04-20 18:33:49 +03:00
|
|
|
summary_info += {'iasl': iasl}
|
2021-01-21 12:56:10 +03:00
|
|
|
summary_info += {'genisoimage': config_host['GENISOIMAGE']}
|
2021-10-15 17:47:43 +03:00
|
|
|
if targetos == 'windows' and have_ga
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'wixl': wixl}
|
2021-01-21 12:56:10 +03:00
|
|
|
endif
|
2021-10-13 14:43:36 +03:00
|
|
|
if slirp_opt != 'disabled' and have_system
|
|
|
|
summary_info += {'smbd': have_slirp_smbd ? smbd_path : false}
|
2021-01-21 12:56:10 +03:00
|
|
|
endif
|
|
|
|
summary(summary_info, bool_yn: true, section: 'Host binaries')
|
|
|
|
|
2021-01-21 12:56:11 +03:00
|
|
|
# Configurable features
|
|
|
|
summary_info = {}
|
|
|
|
summary_info += {'Documentation': build_docs}
|
2021-01-21 12:56:13 +03:00
|
|
|
summary_info += {'system-mode emulation': have_system}
|
|
|
|
summary_info += {'user-mode emulation': have_user}
|
2021-01-21 12:56:14 +03:00
|
|
|
summary_info += {'block layer': have_block}
|
2021-01-21 12:56:11 +03:00
|
|
|
summary_info += {'Install blobs': get_option('install_blobs')}
|
|
|
|
summary_info += {'module support': config_host.has_key('CONFIG_MODULES')}
|
|
|
|
if config_host.has_key('CONFIG_MODULES')
|
2022-04-20 18:33:46 +03:00
|
|
|
summary_info += {'alternative module path': get_option('module_upgrades')}
|
2021-01-21 12:56:11 +03:00
|
|
|
endif
|
2021-10-07 16:08:12 +03:00
|
|
|
summary_info += {'fuzzing support': get_option('fuzzing')}
|
2021-01-21 12:56:11 +03:00
|
|
|
if have_system
|
2021-10-07 16:06:09 +03:00
|
|
|
summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)}
|
2021-01-21 12:56:11 +03:00
|
|
|
endif
|
2021-10-07 16:08:14 +03:00
|
|
|
summary_info += {'Trace backends': ','.join(get_option('trace_backends'))}
|
|
|
|
if 'simple' in get_option('trace_backends')
|
|
|
|
summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
|
2021-01-21 12:56:11 +03:00
|
|
|
endif
|
2021-07-15 10:53:53 +03:00
|
|
|
summary_info += {'D-Bus display': dbus_display}
|
2021-10-13 12:46:09 +03:00
|
|
|
summary_info += {'QOM debugging': get_option('qom_cast_debug')}
|
2022-04-20 18:34:05 +03:00
|
|
|
summary_info += {'vhost-kernel support': have_vhost_kernel}
|
|
|
|
summary_info += {'vhost-net support': have_vhost_net}
|
|
|
|
summary_info += {'vhost-user support': have_vhost_user}
|
|
|
|
summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
|
2021-01-21 12:56:11 +03:00
|
|
|
summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
|
2022-04-20 18:34:05 +03:00
|
|
|
summary_info += {'vhost-vdpa support': have_vhost_vdpa}
|
2021-10-15 17:47:43 +03:00
|
|
|
summary_info += {'build guest agent': have_ga}
|
2021-01-21 12:56:11 +03:00
|
|
|
summary(summary_info, bool_yn: true, section: 'Configurable features')
|
|
|
|
|
2021-01-21 12:56:12 +03:00
|
|
|
# Compilation information
|
2021-01-21 12:56:09 +03:00
|
|
|
summary_info = {}
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info += {'host CPU': cpu}
|
|
|
|
summary_info += {'host endianness': build_machine.endian()}
|
2021-05-27 19:03:15 +03:00
|
|
|
summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())}
|
|
|
|
summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())}
|
2020-02-03 15:28:38 +03:00
|
|
|
if link_language == 'cpp'
|
2021-05-27 19:03:15 +03:00
|
|
|
summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())}
|
2020-02-03 15:28:38 +03:00
|
|
|
else
|
|
|
|
summary_info += {'C++ compiler': false}
|
|
|
|
endif
|
|
|
|
if targetos == 'darwin'
|
2021-05-27 19:03:15 +03:00
|
|
|
summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
|
2020-02-03 15:28:38 +03:00
|
|
|
endif
|
2020-09-23 12:26:17 +03:00
|
|
|
summary_info += {'CFLAGS': ' '.join(get_option('c_args')
|
|
|
|
+ ['-O' + get_option('optimization')]
|
|
|
|
+ (get_option('debug') ? ['-g'] : []))}
|
|
|
|
if link_language == 'cpp'
|
|
|
|
summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args')
|
|
|
|
+ ['-O' + get_option('optimization')]
|
|
|
|
+ (get_option('debug') ? ['-g'] : []))}
|
|
|
|
endif
|
2022-01-09 00:38:55 +03:00
|
|
|
if targetos == 'darwin'
|
|
|
|
summary_info += {'OBJCFLAGS': ' '.join(get_option('objc_args')
|
|
|
|
+ ['-O' + get_option('optimization')]
|
|
|
|
+ (get_option('debug') ? ['-g'] : []))}
|
|
|
|
endif
|
2020-09-23 12:26:17 +03:00
|
|
|
link_args = get_option(link_language + '_link_args')
|
|
|
|
if link_args.length() > 0
|
|
|
|
summary_info += {'LDFLAGS': ' '.join(link_args)}
|
|
|
|
endif
|
2022-04-20 18:33:34 +03:00
|
|
|
summary_info += {'QEMU_CFLAGS': ' '.join(qemu_cflags)}
|
|
|
|
summary_info += {'QEMU_CXXFLAGS': ' '.join(qemu_cxxflags)}
|
|
|
|
summary_info += {'QEMU_OBJCFLAGS': ' '.join(qemu_objcflags)}
|
|
|
|
summary_info += {'QEMU_LDFLAGS': ' '.join(qemu_ldflags)}
|
2021-10-13 12:46:09 +03:00
|
|
|
summary_info += {'profiler': get_option('profiler')}
|
2020-12-05 02:06:11 +03:00
|
|
|
summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info += {'PIE': get_option('b_pie')}
|
2020-09-17 17:07:00 +03:00
|
|
|
summary_info += {'static build': config_host.has_key('CONFIG_STATIC')}
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info += {'malloc trim support': has_malloc_trim}
|
2021-11-08 15:52:11 +03:00
|
|
|
summary_info += {'membarrier': have_membarrier}
|
2021-10-13 12:52:03 +03:00
|
|
|
summary_info += {'debug stack usage': get_option('debug_stack_usage')}
|
2021-10-13 12:46:09 +03:00
|
|
|
summary_info += {'mutex debugging': get_option('debug_mutex')}
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info += {'memory allocator': get_option('malloc')}
|
2021-11-08 15:38:58 +03:00
|
|
|
summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
|
|
|
|
summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
|
2021-10-13 12:46:09 +03:00
|
|
|
summary_info += {'gprof enabled': get_option('gprof')}
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info += {'gcov': get_option('b_coverage')}
|
|
|
|
summary_info += {'thread sanitizer': config_host.has_key('CONFIG_TSAN')}
|
|
|
|
summary_info += {'CFI support': get_option('cfi')}
|
|
|
|
if get_option('cfi')
|
|
|
|
summary_info += {'CFI debug support': get_option('cfi_debug')}
|
|
|
|
endif
|
|
|
|
summary_info += {'strip binaries': get_option('strip')}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'sparse': sparse}
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info += {'mingw32 support': targetos == 'windows'}
|
2022-06-06 12:48:47 +03:00
|
|
|
summary(summary_info, bool_yn: true, section: 'Compilation')
|
2021-02-22 13:14:50 +03:00
|
|
|
|
|
|
|
# snarf the cross-compilation information for tests
|
2022-06-06 12:48:47 +03:00
|
|
|
summary_info = {}
|
|
|
|
have_cross = false
|
2021-02-22 13:14:50 +03:00
|
|
|
foreach target: target_dirs
|
|
|
|
tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
|
|
|
|
if fs.exists(tcg_mak)
|
|
|
|
config_cross_tcg = keyval.load(tcg_mak)
|
2022-05-27 18:35:34 +03:00
|
|
|
if 'CC' in config_cross_tcg
|
2022-06-06 12:48:47 +03:00
|
|
|
summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
|
|
|
|
have_cross = true
|
2021-02-22 13:14:50 +03:00
|
|
|
endif
|
2022-06-06 12:48:47 +03:00
|
|
|
endif
|
2021-02-22 13:14:50 +03:00
|
|
|
endforeach
|
2022-06-06 12:48:47 +03:00
|
|
|
if have_cross
|
|
|
|
summary(summary_info, bool_yn: true, section: 'Cross compilers')
|
|
|
|
endif
|
2021-01-21 12:56:12 +03:00
|
|
|
|
2021-01-21 12:56:13 +03:00
|
|
|
# Targets and accelerators
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info = {}
|
2021-01-21 12:56:13 +03:00
|
|
|
if have_system
|
|
|
|
summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')}
|
|
|
|
summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')}
|
|
|
|
summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')}
|
|
|
|
summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')}
|
2021-04-02 23:25:32 +03:00
|
|
|
summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')}
|
2022-04-20 18:33:47 +03:00
|
|
|
summary_info += {'Xen support': xen.found()}
|
|
|
|
if xen.found()
|
|
|
|
summary_info += {'xen ctrl version': xen.version()}
|
2021-01-21 12:56:13 +03:00
|
|
|
endif
|
|
|
|
endif
|
|
|
|
summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')}
|
|
|
|
if config_all.has_key('CONFIG_TCG')
|
2021-01-25 17:45:29 +03:00
|
|
|
if get_option('tcg_interpreter')
|
2021-11-06 14:14:57 +03:00
|
|
|
summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'}
|
2021-01-25 17:45:29 +03:00
|
|
|
else
|
|
|
|
summary_info += {'TCG backend': 'native (@0@)'.format(cpu)}
|
|
|
|
endif
|
2021-07-09 17:29:53 +03:00
|
|
|
summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
|
2021-01-21 12:56:13 +03:00
|
|
|
summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
|
|
|
|
endif
|
2021-01-21 12:56:12 +03:00
|
|
|
summary_info += {'target list': ' '.join(target_dirs)}
|
2021-01-21 12:56:13 +03:00
|
|
|
if have_system
|
|
|
|
summary_info += {'default devices': get_option('default_devices')}
|
2021-02-17 18:24:25 +03:00
|
|
|
summary_info += {'out of process emulation': multiprocess_allowed}
|
2022-06-13 23:26:24 +03:00
|
|
|
summary_info += {'vfio-user server': vfio_user_server_allowed}
|
2021-01-21 12:56:13 +03:00
|
|
|
endif
|
|
|
|
summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
|
|
|
|
|
2021-01-21 12:56:14 +03:00
|
|
|
# Block layer
|
|
|
|
summary_info = {}
|
|
|
|
summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
|
2021-10-13 12:52:03 +03:00
|
|
|
summary_info += {'coroutine pool': have_coroutine_pool}
|
2021-01-21 12:56:14 +03:00
|
|
|
if have_block
|
2022-04-20 18:33:53 +03:00
|
|
|
summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
|
|
|
|
summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
|
2021-10-13 12:46:09 +03:00
|
|
|
summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
|
2021-01-21 12:56:14 +03:00
|
|
|
summary_info += {'VirtFS support': have_virtfs}
|
|
|
|
summary_info += {'build virtiofs daemon': have_virtiofsd}
|
2021-10-13 12:43:54 +03:00
|
|
|
summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
|
|
|
|
summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
|
2021-10-13 12:42:25 +03:00
|
|
|
summary_info += {'bochs support': get_option('bochs').allowed()}
|
|
|
|
summary_info += {'cloop support': get_option('cloop').allowed()}
|
|
|
|
summary_info += {'dmg support': get_option('dmg').allowed()}
|
|
|
|
summary_info += {'qcow v1 support': get_option('qcow1').allowed()}
|
|
|
|
summary_info += {'vdi support': get_option('vdi').allowed()}
|
|
|
|
summary_info += {'vvfat support': get_option('vvfat').allowed()}
|
|
|
|
summary_info += {'qed support': get_option('qed').allowed()}
|
|
|
|
summary_info += {'parallels support': get_option('parallels').allowed()}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'FUSE exports': fuse}
|
2022-05-23 11:46:09 +03:00
|
|
|
summary_info += {'VDUSE block exports': have_vduse_blk_export}
|
2021-01-21 12:56:14 +03:00
|
|
|
endif
|
|
|
|
summary(summary_info, bool_yn: true, section: 'Block layer support')
|
|
|
|
|
2021-01-21 12:56:15 +03:00
|
|
|
# Crypto
|
2021-01-21 12:56:13 +03:00
|
|
|
summary_info = {}
|
2022-04-20 18:33:52 +03:00
|
|
|
summary_info += {'TLS priority': get_option('tls_priority')}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'GNUTLS support': gnutls}
|
|
|
|
if gnutls.found()
|
|
|
|
summary_info += {' GNUTLS crypto': gnutls_crypto.found()}
|
|
|
|
endif
|
|
|
|
summary_info += {'libgcrypt': gcrypt}
|
|
|
|
summary_info += {'nettle': nettle}
|
2021-06-03 12:15:26 +03:00
|
|
|
if nettle.found()
|
|
|
|
summary_info += {' XTS': xts != 'private'}
|
2020-02-03 15:28:38 +03:00
|
|
|
endif
|
2021-11-08 16:02:42 +03:00
|
|
|
summary_info += {'AF_ALG support': have_afalg}
|
2021-10-13 12:46:09 +03:00
|
|
|
summary_info += {'rng-none': get_option('rng_none')}
|
2022-04-20 18:33:42 +03:00
|
|
|
summary_info += {'Linux keyring': have_keyring}
|
2021-01-21 12:56:15 +03:00
|
|
|
summary(summary_info, bool_yn: true, section: 'Crypto')
|
|
|
|
|
2021-01-21 12:56:16 +03:00
|
|
|
# Libraries
|
2021-01-21 12:56:15 +03:00
|
|
|
summary_info = {}
|
|
|
|
if targetos == 'darwin'
|
2022-03-17 20:28:33 +03:00
|
|
|
summary_info += {'Cocoa support': cocoa}
|
|
|
|
summary_info += {'vmnet.framework support': vmnet}
|
2021-06-03 12:24:56 +03:00
|
|
|
endif
|
|
|
|
summary_info += {'SDL support': sdl}
|
|
|
|
summary_info += {'SDL image support': sdl_image}
|
|
|
|
summary_info += {'GTK support': gtk}
|
|
|
|
summary_info += {'pixman': pixman}
|
|
|
|
summary_info += {'VTE support': vte}
|
|
|
|
summary_info += {'slirp support': slirp_opt == 'internal' ? slirp_opt : slirp}
|
|
|
|
summary_info += {'libtasn1': tasn1}
|
|
|
|
summary_info += {'PAM': pam}
|
|
|
|
summary_info += {'iconv support': iconv}
|
|
|
|
summary_info += {'curses support': curses}
|
|
|
|
summary_info += {'virgl support': virgl}
|
|
|
|
summary_info += {'curl support': curl}
|
|
|
|
summary_info += {'Multipath support': mpathpersist}
|
2022-04-08 10:13:34 +03:00
|
|
|
summary_info += {'PNG support': png}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'VNC support': vnc}
|
2020-02-06 17:48:52 +03:00
|
|
|
if vnc.found()
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'VNC SASL support': sasl}
|
|
|
|
summary_info += {'VNC JPEG support': jpeg}
|
2020-02-03 15:28:38 +03:00
|
|
|
endif
|
2021-10-07 16:06:09 +03:00
|
|
|
if targetos not in ['darwin', 'haiku', 'windows']
|
|
|
|
summary_info += {'OSS support': oss}
|
|
|
|
elif targetos == 'darwin'
|
|
|
|
summary_info += {'CoreAudio support': coreaudio}
|
|
|
|
elif targetos == 'windows'
|
|
|
|
summary_info += {'DirectSound support': dsound}
|
|
|
|
endif
|
|
|
|
if targetos == 'linux'
|
|
|
|
summary_info += {'ALSA support': alsa}
|
|
|
|
summary_info += {'PulseAudio support': pulse}
|
|
|
|
endif
|
|
|
|
summary_info += {'JACK support': jack}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'brlapi support': brlapi}
|
2021-10-07 16:08:21 +03:00
|
|
|
summary_info += {'vde support': vde}
|
2021-10-07 16:08:22 +03:00
|
|
|
summary_info += {'netmap support': have_netmap}
|
2021-10-28 21:59:08 +03:00
|
|
|
summary_info += {'l2tpv3 support': have_l2tpv3}
|
2021-10-07 16:08:20 +03:00
|
|
|
summary_info += {'Linux AIO support': libaio}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'Linux io_uring support': linux_io_uring}
|
|
|
|
summary_info += {'ATTR/XATTR support': libattr}
|
2022-04-20 18:33:41 +03:00
|
|
|
summary_info += {'RDMA support': rdma}
|
|
|
|
summary_info += {'PVRDMA support': have_pvrdma}
|
2020-10-05 12:31:15 +03:00
|
|
|
summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'libcap-ng support': libcap_ng}
|
|
|
|
summary_info += {'bpf support': libbpf}
|
2021-10-07 16:08:23 +03:00
|
|
|
summary_info += {'spice protocol support': spice_protocol}
|
|
|
|
if spice_protocol.found()
|
|
|
|
summary_info += {' spice server support': spice}
|
|
|
|
endif
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'rbd support': rbd}
|
|
|
|
summary_info += {'smartcard support': cacard}
|
|
|
|
summary_info += {'U2F support': u2f}
|
|
|
|
summary_info += {'libusb': libusb}
|
|
|
|
summary_info += {'usb net redir': usbredir}
|
2022-04-20 18:33:40 +03:00
|
|
|
summary_info += {'OpenGL support (epoxy)': opengl}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'GBM': gbm}
|
|
|
|
summary_info += {'libiscsi support': libiscsi}
|
|
|
|
summary_info += {'libnfs support': libnfs}
|
2020-02-03 15:28:38 +03:00
|
|
|
if targetos == 'windows'
|
2021-10-15 17:47:43 +03:00
|
|
|
if have_ga
|
2022-02-01 15:53:43 +03:00
|
|
|
summary_info += {'QGA VSS support': have_qga_vss}
|
2021-01-21 13:49:04 +03:00
|
|
|
endif
|
2020-02-03 15:28:38 +03:00
|
|
|
endif
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'seccomp support': seccomp}
|
|
|
|
summary_info += {'GlusterFS support': glusterfs}
|
2021-12-21 14:38:27 +03:00
|
|
|
summary_info += {'TPM support': have_tpm}
|
2021-12-09 17:48:01 +03:00
|
|
|
summary_info += {'libssh support': libssh}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'lzo support': lzo}
|
|
|
|
summary_info += {'snappy support': snappy}
|
|
|
|
summary_info += {'bzip2 support': libbzip2}
|
|
|
|
summary_info += {'lzfse support': liblzfse}
|
|
|
|
summary_info += {'zstd support': zstd}
|
2021-12-21 14:38:27 +03:00
|
|
|
summary_info += {'NUMA host support': numa}
|
2022-05-16 17:58:23 +03:00
|
|
|
summary_info += {'capstone': capstone}
|
2021-06-03 12:24:56 +03:00
|
|
|
summary_info += {'libpmem support': libpmem}
|
|
|
|
summary_info += {'libdaxctl support': libdaxctl}
|
|
|
|
summary_info += {'libudev': libudev}
|
|
|
|
# Dummy dependency, keep .found()
|
2020-10-27 22:05:46 +03:00
|
|
|
summary_info += {'FUSE lseek': fuse_lseek.found()}
|
2021-11-15 23:29:43 +03:00
|
|
|
summary_info += {'selinux': selinux}
|
2021-01-21 12:56:16 +03:00
|
|
|
summary(summary_info, bool_yn: true, section: 'Dependencies')
|
2020-02-03 15:28:38 +03:00
|
|
|
|
|
|
|
if not supported_cpus.contains(cpu)
|
|
|
|
message()
|
|
|
|
warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
|
|
|
|
message()
|
|
|
|
message('CPU host architecture ' + cpu + ' support is not currently maintained.')
|
|
|
|
message('The QEMU project intends to remove support for this host CPU in')
|
|
|
|
message('a future release if nobody volunteers to maintain it and to')
|
|
|
|
message('provide a build host for our continuous integration setup.')
|
|
|
|
message('configure has succeeded and you can continue to build, but')
|
|
|
|
message('if you care about QEMU on this platform you should contact')
|
|
|
|
message('us upstream at qemu-devel@nongnu.org.')
|
|
|
|
endif
|
|
|
|
|
|
|
|
if not supported_oses.contains(targetos)
|
|
|
|
message()
|
|
|
|
warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
|
|
|
|
message()
|
|
|
|
message('Host OS ' + targetos + 'support is not currently maintained.')
|
|
|
|
message('The QEMU project intends to remove support for this host OS in')
|
|
|
|
message('a future release if nobody volunteers to maintain it and to')
|
|
|
|
message('provide a build host for our continuous integration setup.')
|
|
|
|
message('configure has succeeded and you can continue to build, but')
|
|
|
|
message('if you care about QEMU on this platform you should contact')
|
|
|
|
message('us upstream at qemu-devel@nongnu.org.')
|
|
|
|
endif
|