SYS-OSS/FRET-qemu
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

meson related:

Browse Source 
* convert unit tests
 * bugfixes for mtest2make
 * miscellaneous bugfixes
 * dead code removal and configure cleanups
 * oss-fuzz fixes
 * msys fixes
 -----BEGIN PGP SIGNATURE-----
 
 iQFIBAABCAAyFiEE8TM4V0tmI4mGbHaCv/vSX3jHroMFAl9XUj8UHHBib256aW5p
 QHJlZGhhdC5jb20ACgkQv/vSX3jHroOrBAf9EKjYCcDHxlnLyE9dA9gV0Cu2Ro9o
 i9UnQWABZR9WzNs8ar1cePICTzxLleXAQ/OPbZI3GXsRVPg/xth8LRrdJIZjiN3G
 nTrLwQLWkSyLHlZowqX2z2nW3gjwu+b48RNtv6he30HaIBG/DxBmeyw+JamSeedk
 Xr8n5UegfEqPw+0Yxue8cOzcFZzxl+R/cjV9sEyoJXQ+OhDfnBztXfa+6ar6oZxO
 l2JaSJfrKuZFpY7Sl6tUK2/uCllHO3UamVBoo7ZuhqYsJq/v7lfS390r9qS7uAxL
 Jpcxh+eGQAFzgPOGML+ncAuCX3bGDVlwsHNcaV4pvNc1tAp4y3HtJRgT1A==
 =Pedh
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/bonzini-gitlab/tags/for-upstream' into staging

meson related:
* convert unit tests
* bugfixes for mtest2make
* miscellaneous bugfixes
* dead code removal and configure cleanups
* oss-fuzz fixes
* msys fixes

# gpg: Signature made Tue 08 Sep 2020 10:43:27 BST
# gpg:                using RSA key F13338574B662389866C7682BFFBD25F78C7AE83
# gpg:                issuer "pbonzini@redhat.com"
# gpg: Good signature from "Paolo Bonzini <bonzini@gnu.org>" [full]
# gpg:                 aka "Paolo Bonzini <pbonzini@redhat.com>" [full]
# Primary key fingerprint: 46F5 9FBD 57D6 12E7 BFD4  E2F7 7E15 100C CD36 69B1
#      Subkey fingerprint: F133 3857 4B66 2389 866C  7682 BFFB D25F 78C7 AE83

* remotes/bonzini-gitlab/tags/for-upstream: (45 commits)
  docs: update build system documentation
  meson: remove linkage of sdl to baum
  meson: Convert undefsym.sh to undefsym.py
  fuzz: Add support for custom fuzzing library
  meson: specify fuzz linker script as a project arg
  oss-fuzz: fix rpath
  configure: update dtc submodule
  docs: suggest Meson replacements for various configure functions
  configure: drop dead variables and functions
  configure: do not include dependency flags in QEMU_CFLAGS and LIBS
  meson: get opengl compilation flags from OPENGL_CFLAGS
  meson: get glib compilation flags from GLIB_CFLAGS
  configure: do not look for install(1)
  configure: remove unnecessary libm test
  configure: move -ldl test to meson
  meson: keep all compiler flags detection together
  configure: move disassembler configuration to meson
  Makefile: inline the relevant parts of rules.mak
  Makefile: remove dead variables and includes
  meson: compute config_all_devices directly
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2020-09-08 13:23:58 +01:00
commit 46853bd9e7
38 changed files with 666 additions and 1153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -2,8 +2,6 @@
/build/ /build/
/.doctrees /.doctrees
/config-devices.* /config-devices.*
/config-all-devices.*
/config-all-disas.*
/config-host.* /config-host.*
/config-target.* /config-target.*
/config.status /config.status

63
Makefile
View File

@ -10,6 +10,20 @@ BUILD_DIR=$(CURDIR)
# Before including a proper config-host.mak, assume we are in the source tree # Before including a proper config-host.mak, assume we are in the source tree
SRC_PATH=. SRC_PATH=.
# Don't use implicit rules or variables
# we have explicit rules for everything
MAKEFLAGS += -rR
# Usage: $(call quiet-command,command and args,"NAME","args to print")
# This will run "command and args", and either:
# if V=1 just print the whole command and args
# otherwise print the 'quiet' output in the format " NAME args to print"
# NAME should be a short name of the command, 7 letters or fewer.
# If called with only a single argument, will print nothing in quiet mode.
quiet-command-run = $(if $(V),,$(if $2,printf " %-7s %s\n" $2 $3 && ))$1
quiet-@ = $(if $(V),,@)
quiet-command = $(quiet-@)$(call quiet-command-run,$1,$2,$3)
UNCHECKED_GOALS := %clean TAGS cscope ctags dist \ UNCHECKED_GOALS := %clean TAGS cscope ctags dist \
help check-help print-% \ help check-help print-% \
docker docker-% vm-help vm-test vm-build-% docker docker-% vm-help vm-test vm-build-%
@ -64,10 +78,11 @@ ${ninja-targets-c_COMPILER} ${ninja-targets-cpp_COMPILER}: .var.command += -MP
# reread (and MESON won't be empty anymore). # reread (and MESON won't be empty anymore).
ifneq ($(MESON),) ifneq ($(MESON),)
Makefile.mtest: build.ninja scripts/mtest2make.py Makefile.mtest: build.ninja scripts/mtest2make.py
$(MESON) introspect --tests | $(PYTHON) scripts/mtest2make.py > $@ $(MESON) introspect --tests --benchmarks | $(PYTHON) scripts/mtest2make.py > $@
-include Makefile.mtest -include Makefile.mtest
endif endif
Makefile: .git-submodule-status
.git-submodule-status: git-submodule-update config-host.mak .git-submodule-status: git-submodule-update config-host.mak
# Check that we're not trying to do an out-of-tree build from # Check that we're not trying to do an out-of-tree build from
@ -80,13 +95,6 @@ seems to have been used for an in-tree build. You can fix this by running \
endif endif
endif endif
CONFIG_SOFTMMU := $(if $(filter %-softmmu,$(TARGET_DIRS)),y)
CONFIG_USER_ONLY := $(if $(filter %-user,$(TARGET_DIRS)),y)
CONFIG_XEN := $(CONFIG_XEN_BACKEND)
CONFIG_ALL=y
-include config-all-devices.mak
-include config-all-disas.mak
config-host.mak: $(SRC_PATH)/configure $(SRC_PATH)/pc-bios $(SRC_PATH)/VERSION config-host.mak: $(SRC_PATH)/configure $(SRC_PATH)/pc-bios $(SRC_PATH)/VERSION
@echo $@ is out-of-date, running configure @echo $@ is out-of-date, running configure
@if test -f meson-private/coredata.dat; then \ @if test -f meson-private/coredata.dat; then \
@ -115,13 +123,6 @@ ninja-clean::
ninja-distclean:: ninja-distclean::
build.ninja: config-host.mak build.ninja: config-host.mak
include $(SRC_PATH)/rules.mak
# lor is defined in rules.mak
CONFIG_BLOCK := $(call lor,$(CONFIG_SOFTMMU),$(CONFIG_TOOLS))
generated-files-y += .git-submodule-status
# Don't try to regenerate Makefile or configure # Don't try to regenerate Makefile or configure
# We don't generate any of them # We don't generate any of them
Makefile: ; Makefile: ;
@ -130,15 +131,7 @@ configure: ;
.PHONY: all clean cscope distclean install \ .PHONY: all clean cscope distclean install \
recurse-all dist msi FORCE recurse-all dist msi FORCE
$(call set-vpath, $(SRC_PATH)) SUBDIR_MAKEFLAGS=$(if $(V),,--no-print-directory --quiet)
LIBS+=-lz $(LIBS_TOOLS)
SUBDIR_MAKEFLAGS=$(if $(V),,--no-print-directory --quiet) BUILD_DIR=$(BUILD_DIR)
ifneq ($(wildcard config-host.mak),)
include $(SRC_PATH)/Makefile.objs
endif
include $(SRC_PATH)/tests/Makefile.include include $(SRC_PATH)/tests/Makefile.include
@ -162,7 +155,7 @@ dtc/%: .git-submodule-status
# Therefore we replicate some of the logic in the sub-makefile. # Therefore we replicate some of the logic in the sub-makefile.
# Remove all the extra -Warning flags that QEMU uses that Capstone doesn't; # Remove all the extra -Warning flags that QEMU uses that Capstone doesn't;
# no need to annoy QEMU developers with such things. # no need to annoy QEMU developers with such things.
CAP_CFLAGS = $(patsubst -W%,,$(CFLAGS) $(QEMU_CFLAGS)) CAP_CFLAGS = $(patsubst -W%,,$(CFLAGS) $(QEMU_CFLAGS)) $(CAPSTONE_CFLAGS)
CAP_CFLAGS += -DCAPSTONE_USE_SYS_DYN_MEM CAP_CFLAGS += -DCAPSTONE_USE_SYS_DYN_MEM
CAP_CFLAGS += -DCAPSTONE_HAS_ARM CAP_CFLAGS += -DCAPSTONE_HAS_ARM
CAP_CFLAGS += -DCAPSTONE_HAS_ARM64 CAP_CFLAGS += -DCAPSTONE_HAS_ARM64
@ -205,7 +198,6 @@ clean: recurse-clean ninja-clean clean-ctlist
-exec rm {} + -exec rm {} +
rm -f TAGS cscope.* *.pod *~ */*~ rm -f TAGS cscope.* *.pod *~ */*~
rm -f fsdev/*.pod scsi/*.pod rm -f fsdev/*.pod scsi/*.pod
rm -f $(foreach f,$(generated-files-y),$(f) $(f)-timestamp)
VERSION = $(shell cat $(SRC_PATH)/VERSION) VERSION = $(shell cat $(SRC_PATH)/VERSION)
@ -248,18 +240,6 @@ cscope:
# Needed by "meson install" # Needed by "meson install"
export DESTDIR export DESTDIR
# Add a dependency on the generated files, so that they are always
# rebuilt before other object files
ifneq ($(wildcard config-host.mak),)
ifneq ($(filter-out $(UNCHECKED_GOALS),$(MAKECMDGOALS)),$(if $(MAKECMDGOALS),,fail))
Makefile: $(generated-files-y)
endif
endif
# Include automatically generated dependency files
# Dependencies in Makefile.objs files come from our recursive subdir rules
-include $(wildcard *.d tests/*.d)
include $(SRC_PATH)/tests/docker/Makefile.include include $(SRC_PATH)/tests/docker/Makefile.include
include $(SRC_PATH)/tests/vm/Makefile.include include $(SRC_PATH)/tests/vm/Makefile.include
@ -283,6 +263,7 @@ help:
@echo '' @echo ''
@echo 'Test targets:' @echo 'Test targets:'
$(call print-help,check,Run all tests (check-help for details)) $(call print-help,check,Run all tests (check-help for details))
$(call print-help,bench,Run all benchmarks)
$(call print-help,docker,Help about targets running tests inside containers) $(call print-help,docker,Help about targets running tests inside containers)
$(call print-help,vm-help,Help about targets running tests inside VM) $(call print-help,vm-help,Help about targets running tests inside VM)
@echo '' @echo ''
@ -299,3 +280,9 @@ endif
endif endif
$(call print-help,$(MAKE) [targets],(quiet build, default)) $(call print-help,$(MAKE) [targets],(quiet build, default))
$(call print-help,$(MAKE) V=1 [targets],(verbose build)) $(call print-help,$(MAKE) V=1 [targets],(verbose build))
# will delete the target of a rule if commands exit with a nonzero exit status
.DELETE_ON_ERROR:
print-%:
@echo '$*=$($*)'

34
Makefile.objs
View File

@ -1,34 +0,0 @@
#######################################################################
# Common libraries for tools and emulators
qom-obj-y = qom/libqom.fa
#######################################################################
# code used by both qemu system emulation and qemu-img
ifeq ($(call lor,$(CONFIG_SOFTMMU),$(CONFIG_TOOLS)),y)
authz-obj-y = authz/libauthz.fa
authz/libauthz.fa-libs = $(if $(CONFIG_AUTH_PAM),-lpam)
block-obj-y += libblock.fa
libblock.fa-libs = $(ZSTD_LIBS)
libblock.fa-libs += $(LIBNFS_LIBS)
libblock.fa-libs += $(LIBISCSI_LIBS)
libblock.fa-libs += $(CURL_LIBS)
libblock.fa-libs += $(RBD_LIBS)
libblock.fa-libs += $(GLUSTERFS_LIBS)
libblock.fa-libs += $(VXHS_LIBS)
libblock.fa-libs += $(LIBSSH_LIBS)
libblock.fa-libs += $(BZIP2_LIBS)
libblock.fa-libs += $(LZFSE_LIBS)
libblock.fa-libs += $(if $(CONFIG_LINUX_AIO),-laio)
libblock.fa-libs += $(LIBXML2_LIBS)
chardev-obj-y = chardev/libchardev.fa
crypto-obj-y = crypto/libcrypto.fa
io-obj-y = io/libio.fa
endif # CONFIG_SOFTMMU or CONFIG_TOOLS

2
accel/tcg/meson.build
View File

@ -9,7 +9,7 @@ tcg_ss.add(files(
)) ))
tcg_ss.add(when: 'CONFIG_USER_ONLY', if_true: files('user-exec.c')) tcg_ss.add(when: 'CONFIG_USER_ONLY', if_true: files('user-exec.c'))
tcg_ss.add(when: 'CONFIG_SOFTMMU', if_false: files('user-exec-stub.c')) tcg_ss.add(when: 'CONFIG_SOFTMMU', if_false: files('user-exec-stub.c'))
tcg_ss.add(when: 'CONFIG_PLUGIN', if_true: files('plugin-gen.c')) tcg_ss.add(when: 'CONFIG_PLUGIN', if_true: [files('plugin-gen.c'), libdl])
specific_ss.add_all(when: 'CONFIG_TCG', if_true: tcg_ss) specific_ss.add_all(when: 'CONFIG_TCG', if_true: tcg_ss)
specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files('tcg-all.c', 'cputlb.c')) specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files('tcg-all.c', 'cputlb.c'))

4
chardev/meson.build
View File

@ -36,9 +36,9 @@ softmmu_ss.add(when: ['CONFIG_SPICE', spice], if_true: files('spice.c'))
chardev_modules = {} chardev_modules = {}
if config_host.has_key('CONFIG_BRLAPI') and sdl.found() if config_host.has_key('CONFIG_BRLAPI')
module_ss = ss.source_set() module_ss = ss.source_set()
module_ss.add(when: [sdl, brlapi], if_true: [files('baum.c'), pixman]) module_ss.add(when: [brlapi], if_true: [files('baum.c'), pixman])
chardev_modules += { 'baum': module_ss } chardev_modules += { 'baum': module_ss }
endif endif

304
configure vendored
View File

@ -192,36 +192,6 @@ has() {
type "$1" >/dev/null 2>&1 type "$1" >/dev/null 2>&1
} }
# search for an executable in PATH
path_of() {
local_command="$1"
local_ifs="$IFS"
local_dir=""
# pathname has a dir component?
if [ "${local_command#*/}" != "$local_command" ]; then
if [ -x "$local_command" ] && [ ! -d "$local_command" ]; then
echo "$local_command"
return 0
fi
fi
if [ -z "$local_command" ]; then
return 1
fi
IFS=:
for local_dir in $PATH; do
if [ -x "$local_dir/$local_command" ] && [ ! -d "$local_dir/$local_command" ]; then
echo "$local_dir/$local_command"
IFS="${local_ifs:-$(printf ' \t\n')}"
return 0
fi
done
# not found
IFS="${local_ifs:-$(printf ' \t\n')}"
return 1
}
version_ge () { version_ge () {
local_ver1=`echo $1 | tr . ' '` local_ver1=`echo $1 | tr . ' '`
local_ver2=`echo $2 | tr . ' '` local_ver2=`echo $2 | tr . ' '`
@ -361,7 +331,6 @@ audio_drv_list=""
block_drv_rw_whitelist="" block_drv_rw_whitelist=""
block_drv_ro_whitelist="" block_drv_ro_whitelist=""
host_cc="cc" host_cc="cc"
libs_tools=""
audio_win_int="" audio_win_int=""
libs_qga="" libs_qga=""
debug_info="yes" debug_info="yes"
@ -469,7 +438,6 @@ mingw32="no"
gcov="no" gcov="no"
EXESUF="" EXESUF=""
HOST_DSOSUF=".so" HOST_DSOSUF=".so"
LDFLAGS_SHARED="-shared"
modules="no" modules="no"
module_upgrades="no" module_upgrades="no"
prefix="/usr/local" prefix="/usr/local"
@ -665,14 +633,6 @@ QEMU_INCLUDES="$QEMU_INCLUDES -iquote ${source_path}/disas/libvixl"
CFLAGS="-std=gnu99 -Wall" CFLAGS="-std=gnu99 -Wall"
# running configure in the source tree?
# we know that's the case if configure is there.
if test -f "./configure"; then
pwd_is_source_path="y"
else
pwd_is_source_path="n"
fi
check_define() { check_define() {
cat > $TMPC <<EOF cat > $TMPC <<EOF
#if !defined($1) #if !defined($1)
@ -871,7 +831,6 @@ FreeBSD)
audio_drv_list="oss try-sdl" audio_drv_list="oss try-sdl"
audio_possible_drivers="oss sdl pa" audio_possible_drivers="oss sdl pa"
# needed for kinfo_getvmmap(3) in libutil.h # needed for kinfo_getvmmap(3) in libutil.h
LIBS="-lutil $LIBS"
netmap="" # enable netmap autodetect netmap="" # enable netmap autodetect
HOST_VARIANT_DIR="freebsd" HOST_VARIANT_DIR="freebsd"
;; ;;
@ -903,7 +862,6 @@ Darwin)
darwin="yes" darwin="yes"
hax="yes" hax="yes"
hvf="yes" hvf="yes"
LDFLAGS_SHARED="-bundle -undefined dynamic_lookup"
if [ "$cpu" = "x86_64" ] ; then if [ "$cpu" = "x86_64" ] ; then
QEMU_CFLAGS="-arch x86_64 $QEMU_CFLAGS" QEMU_CFLAGS="-arch x86_64 $QEMU_CFLAGS"
QEMU_LDFLAGS="-arch x86_64 $QEMU_LDFLAGS" QEMU_LDFLAGS="-arch x86_64 $QEMU_LDFLAGS"
@ -920,7 +878,6 @@ Darwin)
SunOS) SunOS)
solaris="yes" solaris="yes"
make="${MAKE-gmake}" make="${MAKE-gmake}"
install="${INSTALL-ginstall}"
smbd="${SMBD-/usr/sfw/sbin/smbd}" smbd="${SMBD-/usr/sfw/sbin/smbd}"
if test -f /usr/include/sys/soundcard.h ; then if test -f /usr/include/sys/soundcard.h ; then
audio_drv_list="oss try-sdl" audio_drv_list="oss try-sdl"
@ -930,13 +887,10 @@ SunOS)
QEMU_CFLAGS="-D_XOPEN_SOURCE=600 $QEMU_CFLAGS" QEMU_CFLAGS="-D_XOPEN_SOURCE=600 $QEMU_CFLAGS"
# needed for TIOCWIN* defines in termios.h # needed for TIOCWIN* defines in termios.h
QEMU_CFLAGS="-D__EXTENSIONS__ $QEMU_CFLAGS" QEMU_CFLAGS="-D__EXTENSIONS__ $QEMU_CFLAGS"
solarisnetlibs="-lsocket -lnsl -lresolv"
LIBS="$solarisnetlibs $LIBS"
;; ;;
Haiku) Haiku)
haiku="yes" haiku="yes"
QEMU_CFLAGS="-DB_USE_POSITIVE_POSIX_ERRORS -DBSD_SOURCE $QEMU_CFLAGS" QEMU_CFLAGS="-DB_USE_POSITIVE_POSIX_ERRORS -DBSD_SOURCE $QEMU_CFLAGS"
LIBS="-lposix_error_mapper -lnetwork -lbsd $LIBS"
;; ;;
Linux) Linux)
audio_drv_list="try-pa oss" audio_drv_list="try-pa oss"
@ -944,7 +898,7 @@ Linux)
linux="yes" linux="yes"
linux_user="yes" linux_user="yes"
kvm="yes" kvm="yes"
QEMU_INCLUDES="-isystem ${source_path}/linux-headers -I$PWD/linux-headers $QEMU_INCLUDES" QEMU_INCLUDES="-isystem ${source_path}/linux-headers -Ilinux-headers $QEMU_INCLUDES"
libudev="yes" libudev="yes"
;; ;;
esac esac
@ -956,7 +910,7 @@ if [ "$bsd" = "yes" ] ; then
fi fi
: ${make=${MAKE-make}} : ${make=${MAKE-make}}
: ${install=${INSTALL-install}}
# We prefer python 3.x. A bare 'python' is traditionally # We prefer python 3.x. A bare 'python' is traditionally
# python 2.x, but some distros have it as python 3.x, so # python 2.x, but some distros have it as python 3.x, so
# we check that too # we check that too
@ -1006,11 +960,7 @@ if test "$mingw32" = "yes" ; then
HOST_DSOSUF=".dll" HOST_DSOSUF=".dll"
# MinGW needs -mthreads for TLS and macro _MT. # MinGW needs -mthreads for TLS and macro _MT.
CFLAGS="-mthreads $CFLAGS" CFLAGS="-mthreads $CFLAGS"
LIBS="-lwinmm -lws2_32 $LIBS"
write_c_skeleton; write_c_skeleton;
if compile_prog "" "-liberty" ; then
LIBS="-liberty $LIBS"
fi
prefix="c:/Program Files/QEMU" prefix="c:/Program Files/QEMU"
qemu_suffix="" qemu_suffix=""
libs_qga="-lws2_32 -lwinmm -lpowrprof -lwtsapi32 -lwininet -liphlpapi -lnetapi32 $libs_qga" libs_qga="-lws2_32 -lwinmm -lpowrprof -lwtsapi32 -lwininet -liphlpapi -lnetapi32 $libs_qga"
@ -1043,7 +993,7 @@ for opt do
;; ;;
--make=*) make="$optarg" --make=*) make="$optarg"
;; ;;
--install=*) install="$optarg" --install=*)
;; ;;
--python=*) python="$optarg" ; explicit_python=yes --python=*) python="$optarg" ; explicit_python=yes
;; ;;
@ -1824,7 +1774,6 @@ Advanced options (experts only):
--cross-cc-ARCH=CC use compiler when building ARCH guest test cases --cross-cc-ARCH=CC use compiler when building ARCH guest test cases
--cross-cc-flags-ARCH= use compiler flags when building ARCH guest tests --cross-cc-flags-ARCH= use compiler flags when building ARCH guest tests
--make=MAKE use specified make [$make] --make=MAKE use specified make [$make]
--install=INSTALL use specified install [$install]
--python=PYTHON use specified python [$python] --python=PYTHON use specified python [$python]
--sphinx-build=SPHINX use specified sphinx-build [$sphinx_build] --sphinx-build=SPHINX use specified sphinx-build [$sphinx_build]
--meson=MESON use specified meson [$meson] --meson=MESON use specified meson [$meson]
@ -2054,9 +2003,6 @@ fi
if test "$meson" = git; then if test "$meson" = git; then
git_submodules="${git_submodules} meson" git_submodules="${git_submodules} meson"
fi fi
if test "$git_update" = yes; then
(cd "${source_path}" && GIT="$git" "./scripts/git-submodule.sh" update "$git_submodules")
fi
case "$meson" in case "$meson" in
git | internal) git | internal)
@ -2342,18 +2288,6 @@ fi
# Solaris specific configure tool chain decisions # Solaris specific configure tool chain decisions
if test "$solaris" = "yes" ; then if test "$solaris" = "yes" ; then
if has $install; then
:
else
error_exit "Solaris install program not found. Use --install=/usr/ucb/install or" \
"install fileutils from www.blastwave.org using pkg-get -i fileutils" \
"to get ginstall which is used by default (which lives in /opt/csw/bin)"
fi
if test "$(path_of $install)" = "/usr/sbin/install" ; then
error_exit "Solaris /usr/sbin/install is not an appropriate install program." \
"try ginstall from the GNU fileutils available from www.blastwave.org" \
"using pkg-get -i fileutils, or use --install=/usr/ucb/install"
fi
if has ar; then if has ar; then
: :
else else
@ -2744,7 +2678,6 @@ if test "$xen" != "no" ; then
if $pkg_config --exists xentoolcore; then if $pkg_config --exists xentoolcore; then
xen_pc="$xen_pc xentoolcore" xen_pc="$xen_pc xentoolcore"
fi fi
QEMU_CFLAGS="$QEMU_CFLAGS $($pkg_config --cflags $xen_pc)"
xen_cflags="$($pkg_config --cflags $xen_pc)" xen_cflags="$($pkg_config --cflags $xen_pc)"
xen_libs="$($pkg_config --libs $xen_pc)" xen_libs="$($pkg_config --libs $xen_pc)"
else else
@ -3129,8 +3062,6 @@ if test "$gnutls" != "no"; then
# At least ubuntu 18.04 ships only shared libraries. # At least ubuntu 18.04 ships only shared libraries.
write_c_skeleton write_c_skeleton
if compile_prog "" "$gnutls_libs" ; then if compile_prog "" "$gnutls_libs" ; then
LIBS="$gnutls_libs $LIBS"
QEMU_CFLAGS="$QEMU_CFLAGS $gnutls_cflags"
pass="yes" pass="yes"
fi fi
fi fi
@ -3200,8 +3131,6 @@ if test "$nettle" != "no"; then
# Link test to make sure the given libraries work (e.g for static). # Link test to make sure the given libraries work (e.g for static).
write_c_skeleton write_c_skeleton
if compile_prog "" "$nettle_libs" ; then if compile_prog "" "$nettle_libs" ; then
LIBS="$nettle_libs $LIBS"
QEMU_CFLAGS="$QEMU_CFLAGS $nettle_cflags"
if test -z "$gcrypt"; then if test -z "$gcrypt"; then
gcrypt="no" gcrypt="no"
fi fi
@ -3244,8 +3173,6 @@ if test "$gcrypt" != "no"; then
# Link test to make sure the given libraries work (e.g for static). # Link test to make sure the given libraries work (e.g for static).
write_c_skeleton write_c_skeleton
if compile_prog "" "$gcrypt_libs" ; then if compile_prog "" "$gcrypt_libs" ; then
LIBS="$gcrypt_libs $LIBS"
QEMU_CFLAGS="$QEMU_CFLAGS $gcrypt_cflags"
pass="yes" pass="yes"
fi fi
fi fi
@ -3813,24 +3740,22 @@ if test "$plugins" = yes; then
glib_modules="$glib_modules gmodule-2.0" glib_modules="$glib_modules gmodule-2.0"
fi fi
# This workaround is required due to a bug in pkg-config file for glib as it
# doesn't define GLIB_STATIC_COMPILATION for pkg-config --static
if test "$static" = yes && test "$mingw32" = yes; then
QEMU_CFLAGS="-DGLIB_STATIC_COMPILATION $QEMU_CFLAGS"
fi
for i in $glib_modules; do for i in $glib_modules; do
if $pkg_config --atleast-version=$glib_req_ver $i; then if $pkg_config --atleast-version=$glib_req_ver $i; then
glib_cflags=$($pkg_config --cflags $i) glib_cflags=$($pkg_config --cflags $i)
glib_libs=$($pkg_config --libs $i) glib_libs=$($pkg_config --libs $i)
QEMU_CFLAGS="$glib_cflags $QEMU_CFLAGS"
LIBS="$glib_libs $LIBS"
else else
error_exit "glib-$glib_req_ver $i is required to compile QEMU" error_exit "glib-$glib_req_ver $i is required to compile QEMU"
fi fi
done done
# This workaround is required due to a bug in pkg-config file for glib as it
# doesn't define GLIB_STATIC_COMPILATION for pkg-config --static
if test "$static" = yes && test "$mingw32" = yes; then
glib_cflags="-DGLIB_STATIC_COMPILATION $glib_cflags"
fi
if $pkg_config --atleast-version=$glib_req_ver gio-2.0; then if $pkg_config --atleast-version=$glib_req_ver gio-2.0; then
gio=yes gio=yes
gio_cflags=$($pkg_config --cflags gio-2.0) gio_cflags=$($pkg_config --cflags gio-2.0)
@ -3865,7 +3790,7 @@ int main(void) {
} }
EOF EOF
if ! compile_prog "$CFLAGS" "$LIBS" ; then if ! compile_prog "$glib_cflags" "$glib_libs" ; then
error_exit "sizeof(size_t) doesn't match GLIB_SIZEOF_SIZE_T."\ error_exit "sizeof(size_t) doesn't match GLIB_SIZEOF_SIZE_T."\
"You probably need to set PKG_CONFIG_LIBDIR"\ "You probably need to set PKG_CONFIG_LIBDIR"\
"to point to the right pkg-config files for your"\ "to point to the right pkg-config files for your"\
@ -3880,7 +3805,7 @@ EOF
if ! compile_prog "$glib_cflags -Werror" "$glib_libs" ; then if ! compile_prog "$glib_cflags -Werror" "$glib_libs" ; then
if cc_has_warning_flag "-Wno-unknown-attributes"; then if cc_has_warning_flag "-Wno-unknown-attributes"; then
glib_cflags="-Wno-unknown-attributes $glib_cflags" glib_cflags="-Wno-unknown-attributes $glib_cflags"
QEMU_CFLAGS="-Wno-unknown-attributes $CFLAGS" CFLAGS="-Wno-unknown-attributes $CFLAGS"
fi fi
fi fi
@ -4128,11 +4053,6 @@ if test "$linux_io_uring" != "no" ; then
linux_io_uring_cflags=$($pkg_config --cflags liburing) linux_io_uring_cflags=$($pkg_config --cflags liburing)
linux_io_uring_libs=$($pkg_config --libs liburing) linux_io_uring_libs=$($pkg_config --libs liburing)
linux_io_uring=yes linux_io_uring=yes
# io_uring is used in libqemuutil.a where per-file -libs variables are not
# seen by programs linking the archive. It's not ideal, but just add the
# library dependency globally.
LIBS="$linux_io_uring_libs $LIBS"
else else
if test "$linux_io_uring" = "yes" ; then if test "$linux_io_uring" = "yes" ; then
feature_not_found "linux io_uring" "Install liburing devel" feature_not_found "linux io_uring" "Install liburing devel"
@ -4177,7 +4097,6 @@ EOF
elif compile_prog "-DCONFIG_LIBATTR" "-lattr" ; then elif compile_prog "-DCONFIG_LIBATTR" "-lattr" ; then
attr=yes attr=yes
libattr_libs="-lattr" libattr_libs="-lattr"
LIBS="$libattr_libs $LIBS"
libattr=yes libattr=yes
else else
if test "$attr" = "yes" ; then if test "$attr" = "yes" ; then
@ -4262,11 +4181,8 @@ EOF
if test -d "${source_path}/dtc/libfdt" || test -e "${source_path}/.git" ; then if test -d "${source_path}/dtc/libfdt" || test -e "${source_path}/.git" ; then
fdt=git fdt=git
mkdir -p dtc mkdir -p dtc
if [ "$pwd_is_source_path" != "y" ] ; then
symlink "$source_path/dtc/Makefile" "dtc/Makefile"
fi
fdt_cflags="-I${source_path}/dtc/libfdt" fdt_cflags="-I${source_path}/dtc/libfdt"
fdt_ldflags="-L$PWD/dtc/libfdt" fdt_ldflags="-Ldtc/libfdt"
fdt_libs="$fdt_libs" fdt_libs="$fdt_libs"
elif test "$fdt" = "yes" ; then elif test "$fdt" = "yes" ; then
# Not a git build & no libfdt found, prompt for system install # Not a git build & no libfdt found, prompt for system install
@ -4299,7 +4215,6 @@ if test "$opengl" != "no" ; then
if test "$gtk" = "yes" && $pkg_config --exists "$gtkpackage >= 3.16"; then if test "$gtk" = "yes" && $pkg_config --exists "$gtkpackage >= 3.16"; then
gtk_gl="yes" gtk_gl="yes"
fi fi
QEMU_CFLAGS="$QEMU_CFLAGS $opengl_cflags"
else else
if test "$opengl" = "yes" ; then if test "$opengl" = "yes" ; then
feature_not_found "opengl" "Please install opengl (mesa) devel pkgs: $opengl_pkgs" feature_not_found "opengl" "Please install opengl (mesa) devel pkgs: $opengl_pkgs"
@ -5003,20 +4918,6 @@ if test "$libiscsi" != "no" ; then
fi fi
fi fi
##########################################
# Do we need libm
cat > $TMPC << EOF
#include <math.h>
int main(int argc, char **argv) { return isnan(sin((double)argc)); }
EOF
if compile_prog "" "" ; then
:
elif compile_prog "" "-lm" ; then
LIBS="-lm $LIBS"
else
error_exit "libm check failed"
fi
########################################## ##########################################
# Do we need librt # Do we need librt
# uClibc provides 2 versions of clock_gettime(), one with realtime # uClibc provides 2 versions of clock_gettime(), one with realtime
@ -5039,7 +4940,7 @@ elif compile_prog "" "$pthread_lib -lrt" ; then
LIBS="$LIBS -lrt" LIBS="$LIBS -lrt"
fi fi
# Check whether we need to link libutil for openpty() # Check whether we have openpty() in either libc or libutil
cat > $TMPC << EOF cat > $TMPC << EOF
extern int openpty(int *am, int *as, char *name, void *termp, void *winp); extern int openpty(int *am, int *as, char *name, void *termp, void *winp);
int main(void) { return openpty(0, 0, 0, 0, 0); } int main(void) { return openpty(0, 0, 0, 0, 0); }
@ -5050,7 +4951,6 @@ if compile_prog "" "" ; then
have_openpty="yes" have_openpty="yes"
else else
if compile_prog "" "-lutil" ; then if compile_prog "" "-lutil" ; then
libs_tools="-lutil $libs_tools"
have_openpty="yes" have_openpty="yes"
fi fi
fi fi
@ -5068,7 +4968,6 @@ EOF
$pkg_config --atleast-version=0.12.3 spice-protocol && \ $pkg_config --atleast-version=0.12.3 spice-protocol && \
compile_prog "$spice_cflags" "$spice_libs" ; then compile_prog "$spice_cflags" "$spice_libs" ; then
spice="yes" spice="yes"
QEMU_CFLAGS="$QEMU_CFLAGS $spice_cflags"
else else
if test "$spice" = "yes" ; then if test "$spice" = "yes" ; then
feature_not_found "spice" \ feature_not_found "spice" \
@ -5251,20 +5150,18 @@ case "$capstone" in
git_submodules="${git_submodules} capstone" git_submodules="${git_submodules} capstone"
fi fi
mkdir -p capstone mkdir -p capstone
QEMU_CFLAGS="$QEMU_CFLAGS -I${source_path}/capstone/include"
if test "$mingw32" = "yes"; then if test "$mingw32" = "yes"; then
LIBCAPSTONE=capstone.lib LIBCAPSTONE=capstone.lib
else else
LIBCAPSTONE=libcapstone.a LIBCAPSTONE=libcapstone.a
fi fi
capstone_libs="-L$PWD/capstone -lcapstone" capstone_libs="-Lcapstone -lcapstone"
capstone_cflags="-I${source_path}/capstone/include" capstone_cflags="-I${source_path}/capstone/include"
;; ;;
system) system)
capstone_libs="$($pkg_config --libs capstone)" capstone_libs="$($pkg_config --libs capstone)"
capstone_cflags="$($pkg_config --cflags capstone)" capstone_cflags="$($pkg_config --cflags capstone)"
QEMU_CFLAGS="$QEMU_CFLAGS $($pkg_config --cflags capstone)"
;; ;;
no) no)
@ -5413,8 +5310,6 @@ EOF
else else
urcu_bp_libs="-lurcu-bp" urcu_bp_libs="-lurcu-bp"
fi fi
LIBS="$lttng_ust_libs $urcu_bp_libs $LIBS"
else else
error_exit "Trace backend 'ust' missing lttng-ust header files" error_exit "Trace backend 'ust' missing lttng-ust header files"
fi fi
@ -6153,7 +6048,7 @@ fi
########################################## ##########################################
# checks for fuzzer # checks for fuzzer
if test "$fuzzing" = "yes" ; then if test "$fuzzing" = "yes" && test -z "${LIB_FUZZING_ENGINE+xxx}"; then
write_c_fuzzer_skeleton write_c_fuzzer_skeleton
if compile_prog "$CPU_CFLAGS -Werror -fsanitize=fuzzer" ""; then if compile_prog "$CPU_CFLAGS -Werror -fsanitize=fuzzer" ""; then
have_fuzzer=yes have_fuzzer=yes
@ -6195,7 +6090,6 @@ if test "$libpmem" != "no"; then
libpmem="yes" libpmem="yes"
libpmem_libs=$($pkg_config --libs libpmem) libpmem_libs=$($pkg_config --libs libpmem)
libpmem_cflags=$($pkg_config --cflags libpmem) libpmem_cflags=$($pkg_config --cflags libpmem)
QEMU_CFLAGS="$QEMU_CFLAGS $libpmem_cflags"
else else
if test "$libpmem" = "yes" ; then if test "$libpmem" = "yes" ; then
feature_not_found "libpmem" "Install nvml or pmdk" feature_not_found "libpmem" "Install nvml or pmdk"
@ -6212,7 +6106,6 @@ if test "$libdaxctl" != "no"; then
libdaxctl="yes" libdaxctl="yes"
libdaxctl_libs=$($pkg_config --libs libdaxctl) libdaxctl_libs=$($pkg_config --libs libdaxctl)
libdaxctl_cflags=$($pkg_config --cflags libdaxctl) libdaxctl_cflags=$($pkg_config --cflags libdaxctl)
QEMU_CFLAGS="$QEMU_CFLAGS $libdaxctl_cflags"
else else
if test "$libdaxctl" = "yes" ; then if test "$libdaxctl" = "yes" ; then
feature_not_found "libdaxctl" "Install libdaxctl" feature_not_found "libdaxctl" "Install libdaxctl"
@ -6257,8 +6150,8 @@ case "$slirp" in
git_submodules="${git_submodules} slirp" git_submodules="${git_submodules} slirp"
fi fi
mkdir -p slirp mkdir -p slirp
slirp_cflags="-I${source_path}/slirp/src -I$PWD/slirp/src" slirp_cflags="-I${source_path}/slirp/src -Islirp/src"
slirp_libs="-L$PWD/slirp -lslirp" slirp_libs="-Lslirp -lslirp"
if test "$mingw32" = "yes" ; then if test "$mingw32" = "yes" ; then
slirp_libs="$slirp_libs -lws2_32 -liphlpapi" slirp_libs="$slirp_libs -lws2_32 -liphlpapi"
fi fi
@ -6312,28 +6205,6 @@ but not implemented on your system"
fi fi
fi fi
##########################################
# check for usable keyutils.h
if test "$linux" = "yes" ; then
have_keyutils=no
cat > $TMPC << EOF
#include <errno.h>
#include <asm/unistd.h>
#include <unistd.h>
#include <sys/types.h>
#include <keyutils.h>
int main(void) {
return request_key("user", NULL, NULL, 0);
}
EOF
if compile_prog "" "-lkeyutils"; then
have_keyutils=yes
fi
fi
########################################## ##########################################
# End of CC checks # End of CC checks
# After here, no more $cc or $ld runs # After here, no more $cc or $ld runs
@ -6417,11 +6288,6 @@ if test "$libudev" != "no" ; then
fi fi
fi fi
# Now we've finished running tests it's OK to add -Werror to the compiler flags
if test "$werror" = "yes"; then
QEMU_CFLAGS="-Werror $QEMU_CFLAGS"
fi
# Exclude --warn-common with TSan to suppress warnings from the TSan libraries. # Exclude --warn-common with TSan to suppress warnings from the TSan libraries.
if test "$solaris" = "no" && test "$tsan" = "no"; then if test "$solaris" = "no" && test "$tsan" = "no"; then
if $ld --version 2>/dev/null | grep "GNU ld" >/dev/null 2>/dev/null ; then if $ld --version 2>/dev/null | grep "GNU ld" >/dev/null 2>/dev/null ; then
@ -6632,20 +6498,15 @@ else
cxx= cxx=
fi fi
echo_version() { if test $git_update = 'yes' ; then
if test "$1" = "yes" ; then (cd "${source_path}" && GIT="$git" "./scripts/git-submodule.sh" update "$git_submodules")
echo "($2)" fi
fi if test "$fdt" = "git" ; then
} symlink "$source_path/dtc/Makefile" "dtc/Makefile"
fi
# prepend ftd flags after all config tests are done
QEMU_CFLAGS="$fdt_cflags $QEMU_CFLAGS"
QEMU_LDFLAGS="$fdt_ldflags $QEMU_LDFLAGS"
config_host_mak="config-host.mak" config_host_mak="config-host.mak"
echo "# Automatically generated by configure - do not modify" >config-all-disas.mak
echo "# Automatically generated by configure - do not modify" > $config_host_mak echo "# Automatically generated by configure - do not modify" > $config_host_mak
echo >> $config_host_mak echo >> $config_host_mak
@ -7147,6 +7008,7 @@ fi
if test "$opengl" = "yes" ; then if test "$opengl" = "yes" ; then
echo "CONFIG_OPENGL=y" >> $config_host_mak echo "CONFIG_OPENGL=y" >> $config_host_mak
echo "OPENGL_CFLAGS=$opengl_cflags" >> $config_host_mak
echo "OPENGL_LIBS=$opengl_libs" >> $config_host_mak echo "OPENGL_LIBS=$opengl_libs" >> $config_host_mak
if test "$opengl_dmabuf" = "yes" ; then if test "$opengl_dmabuf" = "yes" ; then
echo "CONFIG_OPENGL_DMABUF=y" >> $config_host_mak echo "CONFIG_OPENGL_DMABUF=y" >> $config_host_mak
@ -7492,12 +7354,18 @@ if test "$have_mlockall" = "yes" ; then
echo "HAVE_MLOCKALL=y" >> $config_host_mak echo "HAVE_MLOCKALL=y" >> $config_host_mak
fi fi
if test "$fuzzing" = "yes" ; then if test "$fuzzing" = "yes" ; then
QEMU_CFLAGS="$QEMU_CFLAGS -fsanitize=fuzzer-no-link" # If LIB_FUZZING_ENGINE is set, assume we are running on OSS-Fuzz, and the
# needed CFLAGS have already been provided
if test -z "${LIB_FUZZING_ENGINE+xxx}" ; then
QEMU_CFLAGS="$QEMU_CFLAGS -fsanitize=fuzzer-no-link"
FUZZ_EXE_LDFLAGS="-fsanitize=fuzzer"
else
FUZZ_EXE_LDFLAGS="$LIB_FUZZING_ENGINE"
fi
fi fi
if test "$plugins" = "yes" ; then if test "$plugins" = "yes" ; then
echo "CONFIG_PLUGIN=y" >> $config_host_mak echo "CONFIG_PLUGIN=y" >> $config_host_mak
LIBS="-ldl $LIBS"
# Copy the export object list to the build dir # Copy the export object list to the build dir
if test "$ld_dynamic_list" = "yes" ; then if test "$ld_dynamic_list" = "yes" ; then
echo "CONFIG_HAS_LD_DYNAMIC_LIST=yes" >> $config_host_mak echo "CONFIG_HAS_LD_DYNAMIC_LIST=yes" >> $config_host_mak
@ -7522,9 +7390,6 @@ fi
if test "$secret_keyring" = "yes" ; then if test "$secret_keyring" = "yes" ; then
echo "CONFIG_SECRET_KEYRING=y" >> $config_host_mak echo "CONFIG_SECRET_KEYRING=y" >> $config_host_mak
if test "$have_keyutils" = "yes" ; then
echo "CONFIG_TEST_SECRET_KEYRING=y" >> $config_host_mak
fi
fi fi
if test "$tcg_interpreter" = "yes"; then if test "$tcg_interpreter" = "yes"; then
@ -7545,11 +7410,6 @@ fi
echo "ROMS=$roms" >> $config_host_mak echo "ROMS=$roms" >> $config_host_mak
echo "MAKE=$make" >> $config_host_mak echo "MAKE=$make" >> $config_host_mak
echo "INSTALL=$install" >> $config_host_mak
echo "INSTALL_DIR=$install -d -m 0755" >> $config_host_mak
echo "INSTALL_DATA=$install -c -m 0644" >> $config_host_mak
echo "INSTALL_PROG=$install -c -m 0755" >> $config_host_mak
echo "INSTALL_LIB=$install -c -m 0644" >> $config_host_mak
echo "PYTHON=$python" >> $config_host_mak echo "PYTHON=$python" >> $config_host_mak
echo "SPHINX_BUILD=$sphinx_build" >> $config_host_mak echo "SPHINX_BUILD=$sphinx_build" >> $config_host_mak
echo "GENISOIMAGE=$genisoimage" >> $config_host_mak echo "GENISOIMAGE=$genisoimage" >> $config_host_mak
@ -7572,7 +7432,6 @@ echo "NM=$nm" >> $config_host_mak
echo "PKG_CONFIG=$pkg_config_exe" >> $config_host_mak echo "PKG_CONFIG=$pkg_config_exe" >> $config_host_mak
echo "WINDRES=$windres" >> $config_host_mak echo "WINDRES=$windres" >> $config_host_mak
echo "CFLAGS=$CFLAGS" >> $config_host_mak echo "CFLAGS=$CFLAGS" >> $config_host_mak
echo "CXXFLAGS=$CXXFLAGS" >> $config_host_mak
echo "CFLAGS_NOPIE=$CFLAGS_NOPIE" >> $config_host_mak echo "CFLAGS_NOPIE=$CFLAGS_NOPIE" >> $config_host_mak
echo "QEMU_CFLAGS=$QEMU_CFLAGS" >> $config_host_mak echo "QEMU_CFLAGS=$QEMU_CFLAGS" >> $config_host_mak
echo "QEMU_CXXFLAGS=$QEMU_CXXFLAGS" >> $config_host_mak echo "QEMU_CXXFLAGS=$QEMU_CXXFLAGS" >> $config_host_mak
@ -7584,14 +7443,10 @@ if test "$sparse" = "yes" ; then
fi fi
echo "QEMU_LDFLAGS=$QEMU_LDFLAGS" >> $config_host_mak echo "QEMU_LDFLAGS=$QEMU_LDFLAGS" >> $config_host_mak
echo "LDFLAGS_NOPIE=$LDFLAGS_NOPIE" >> $config_host_mak echo "LDFLAGS_NOPIE=$LDFLAGS_NOPIE" >> $config_host_mak
echo "LD_REL_FLAGS=$LD_REL_FLAGS" >> $config_host_mak
echo "LD_I386_EMULATION=$ld_i386_emulation" >> $config_host_mak echo "LD_I386_EMULATION=$ld_i386_emulation" >> $config_host_mak
echo "LIBS+=$LIBS" >> $config_host_mak
echo "LIBS_TOOLS+=$libs_tools" >> $config_host_mak
echo "PTHREAD_LIB=$PTHREAD_LIB" >> $config_host_mak echo "PTHREAD_LIB=$PTHREAD_LIB" >> $config_host_mak
echo "EXESUF=$EXESUF" >> $config_host_mak echo "EXESUF=$EXESUF" >> $config_host_mak
echo "HOST_DSOSUF=$HOST_DSOSUF" >> $config_host_mak echo "HOST_DSOSUF=$HOST_DSOSUF" >> $config_host_mak
echo "LDFLAGS_SHARED=$LDFLAGS_SHARED" >> $config_host_mak
echo "LIBS_QGA=$libs_qga" >> $config_host_mak echo "LIBS_QGA=$libs_qga" >> $config_host_mak
echo "TASN1_LIBS=$tasn1_libs" >> $config_host_mak echo "TASN1_LIBS=$tasn1_libs" >> $config_host_mak
echo "TASN1_CFLAGS=$tasn1_cflags" >> $config_host_mak echo "TASN1_CFLAGS=$tasn1_cflags" >> $config_host_mak
@ -7607,6 +7462,7 @@ fi
if test "$fuzzing" != "no"; then if test "$fuzzing" != "no"; then
echo "CONFIG_FUZZ=y" >> $config_host_mak echo "CONFIG_FUZZ=y" >> $config_host_mak
fi fi
echo "FUZZ_EXE_LDFLAGS=$FUZZ_EXE_LDFLAGS" >> $config_host_mak
if test "$edk2_blobs" = "yes" ; then if test "$edk2_blobs" = "yes" ; then
echo "DECOMPRESS_EDK2_BLOBS=y" >> $config_host_mak echo "DECOMPRESS_EDK2_BLOBS=y" >> $config_host_mak
@ -7954,93 +7810,6 @@ if test "$target_bsd_user" = "yes" ; then
echo "CONFIG_BSD_USER=y" >> $config_target_mak echo "CONFIG_BSD_USER=y" >> $config_target_mak
fi fi
# generate QEMU_CFLAGS/QEMU_LDFLAGS for targets
disas_config() {
echo "CONFIG_${1}_DIS=y" >> $config_target_mak
echo "CONFIG_${1}_DIS=y" >> config-all-disas.mak
}
for i in $ARCH $TARGET_BASE_ARCH ; do
case "$i" in
alpha)
disas_config "ALPHA"
;;
aarch64)
if test -n "${cxx}"; then
disas_config "ARM_A64"
fi
;;
arm)
disas_config "ARM"
if test -n "${cxx}"; then
disas_config "ARM_A64"
fi
;;
avr)
disas_config "AVR"
;;
cris)
disas_config "CRIS"
;;
hppa)
disas_config "HPPA"
;;
i386|x86_64|x32)
disas_config "I386"
;;
lm32)
disas_config "LM32"
;;
m68k)
disas_config "M68K"
;;
microblaze*)
disas_config "MICROBLAZE"
;;
mips*)
disas_config "MIPS"
if test -n "${cxx}"; then
disas_config "NANOMIPS"
fi
;;
moxie*)
disas_config "MOXIE"
;;
nios2)
disas_config "NIOS2"
;;
or1k)
disas_config "OPENRISC"
;;
ppc*)
disas_config "PPC"
;;
riscv*)
disas_config "RISCV"
;;
rx)
disas_config "RX"
;;
s390*)
disas_config "S390"
;;
sh4)
disas_config "SH4"
;;
sparc*)
disas_config "SPARC"
;;
xtensa*)
disas_config "XTENSA"
;;
esac
done
if test "$tcg_interpreter" = "yes" ; then
disas_config "TCI"
fi
done # for target in $targets done # for target in $targets
if [ "$fdt" = "git" ]; then if [ "$fdt" = "git" ]; then
@ -8113,7 +7882,7 @@ do
done done
mkdir -p $DIRS mkdir -p $DIRS
for f in $LINKS ; do for f in $LINKS ; do
if [ -e "$source_path/$f" ] && [ "$pwd_is_source_path" != "y" ]; then if [ -e "$source_path/$f" ]; then
symlink "$source_path/$f" "$f" symlink "$source_path/$f" "$f"
fi fi
done done
@ -8168,6 +7937,9 @@ echo "ar = $(meson_quote $ar)" >> $cross
echo "nm = $(meson_quote $nm)" >> $cross echo "nm = $(meson_quote $nm)" >> $cross
echo "pkgconfig = $(meson_quote $pkg_config_exe)" >> $cross echo "pkgconfig = $(meson_quote $pkg_config_exe)" >> $cross
echo "ranlib = $(meson_quote $ranlib)" >> $cross echo "ranlib = $(meson_quote $ranlib)" >> $cross
if has $sdl2_config; then
echo "sdl2-config = $(meson_quote $sdl2_config)" >> $cross
fi
echo "strip = $(meson_quote $strip)" >> $cross echo "strip = $(meson_quote $strip)" >> $cross
echo "windres = $(meson_quote $windres)" >> $cross echo "windres = $(meson_quote $windres)" >> $cross
if test -n "$cross_prefix"; then if test -n "$cross_prefix"; then

4
disas/meson.build
View File

@ -22,6 +22,4 @@ common_ss.add(when: 'CONFIG_SH4_DIS', if_true: files('sh4.c'))
common_ss.add(when: 'CONFIG_SPARC_DIS', if_true: files('sparc.c')) common_ss.add(when: 'CONFIG_SPARC_DIS', if_true: files('sparc.c'))
common_ss.add(when: 'CONFIG_XTENSA_DIS', if_true: files('xtensa.c')) common_ss.add(when: 'CONFIG_XTENSA_DIS', if_true: files('xtensa.c'))
# TODO: As long as the TCG interpreter and its generated code depend specific_ss.add(when: 'CONFIG_TCG_INTERPRETER', if_true: files('tci.c'))
# on the QEMU target, we cannot compile the disassembler here.
#common_ss.add(when: 'CONFIG_TCI_DIS', if_true: files('tci.c'))

115
docs/devel/build-system.rst
View File

@ -125,27 +125,27 @@ developers in checking for system features:
`compile_object $CFLAGS` `compile_object $CFLAGS`
Attempt to compile a test program with the system C compiler using Attempt to compile a test program with the system C compiler using
$CFLAGS. The test program must have been previously written to a file $CFLAGS. The test program must have been previously written to a file
called $TMPC. called $TMPC. The replacement in Meson is the compiler object `cc`,
which has methods such as `cc.compiles()`,
`cc.check_header()`, `cc.has_function()`.
`compile_prog $CFLAGS $LDFLAGS` `compile_prog $CFLAGS $LDFLAGS`
Attempt to compile a test program with the system C compiler using Attempt to compile a test program with the system C compiler using
$CFLAGS and link it with the system linker using $LDFLAGS. The test $CFLAGS and link it with the system linker using $LDFLAGS. The test
program must have been previously written to a file called $TMPC. program must have been previously written to a file called $TMPC.
The replacement in Meson is `cc.find_library()` and `cc.links()`.
`has $COMMAND` `has $COMMAND`
Determine if $COMMAND exists in the current environment, either as a Determine if $COMMAND exists in the current environment, either as a
shell builtin, or executable binary, returning 0 on success. shell builtin, or executable binary, returning 0 on success. The
replacement in Meson is `find_program()`.
`path_of $COMMAND`
Return the fully qualified path of $COMMAND, printing it to stdout,
and returning 0 on success.
`check_define $NAME` `check_define $NAME`
Determine if the macro $NAME is defined by the system C compiler Determine if the macro $NAME is defined by the system C compiler
`check_include $NAME` `check_include $NAME`
Determine if the include $NAME file is available to the system C Determine if the include $NAME file is available to the system C
compiler compiler. The replacement in Meson is `cc.has_header()`.
`write_c_skeleton` `write_c_skeleton`
Write a minimal C program main() function to the temporary file Write a minimal C program main() function to the temporary file
@ -179,7 +179,7 @@ process for:
- Userspace emulators - qemu-$ARCH - Userspace emulators - qemu-$ARCH
- Some (but not all) unit tests - Unit tests
2) documentation 2) documentation
@ -204,8 +204,9 @@ are then turned into static libraries as follows::
chardev = declare_dependency(link_whole: libchardev) chardev = declare_dependency(link_whole: libchardev)
The special `.fa` suffix is needed as long as unit tests are built with As of Meson 0.55.1, the special `.fa` suffix should be used for everything
the older Makefile infrastructure, and will go away later. that is used with `link_whole`, to ensure that the link flags are placed
correctly in the command line.
Files linked into emulator targets there can be split into two distinct groups Files linked into emulator targets there can be split into two distinct groups
of files, those which are independent of the QEMU emulation target and of files, those which are independent of the QEMU emulation target and
@ -221,7 +222,8 @@ only in system emulators, `user_ss` only in user-mode emulators.
In the target-dependent set lives CPU emulation, device emulation and In the target-dependent set lives CPU emulation, device emulation and
much glue code. This sometimes also has to be compiled multiple times, much glue code. This sometimes also has to be compiled multiple times,
once for each target being built. once for each target being built. Target-dependent files are included
in the `specific_ss` sourceset.
All binaries link with a static library `libqemuutil.a`, which is then All binaries link with a static library `libqemuutil.a`, which is then
linked to all the binaries. `libqemuutil.a` is built from several linked to all the binaries. `libqemuutil.a` is built from several
@ -300,84 +302,9 @@ The resulting build system is largely non-recursive in nature, in
contrast to common practices seen with automake. contrast to common practices seen with automake.
Tests are also ran by the Makefile with the traditional `make check` Tests are also ran by the Makefile with the traditional `make check`
phony target. Meson test suites such as `unit` can be ran with `make phony target, while benchmarks are run with `make bench`. Meson test
check-unit` too. It is also possible to run tests defined in meson.build suites such as `unit` can be ran with `make check-unit` too. It is also
with `meson test`. possible to run tests defined in meson.build with `meson test`.
The following text is only relevant for unit tests which still have to
be converted to Meson.
All binaries should link to `libqemuutil.a`, e.g.:
qemu-img$(EXESUF): qemu-img.o ..snip.. libqemuutil.a
On Windows, all binaries have the suffix `.exe`, so all Makefile rules
which create binaries must include the $(EXESUF) variable on the binary
name. e.g.
qemu-img$(EXESUF): qemu-img.o ..snip..
This expands to `.exe` on Windows, or an empty string on other platforms.
Variable naming
---------------
The QEMU convention is to define variables to list different groups of
object files. These are named with the convention $PREFIX-obj-y. The
Meson `chardev` variable in the previous example corresponds to a
variable 'chardev-obj-y'.
Likewise, tests that are executed by `make check-unit` are grouped into
a variable check-unit-y, like this:
check-unit-y += tests/test-visitor-serialization$(EXESUF)
check-unit-y += tests/test-iov$(EXESUF)
check-unit-y += tests/test-bitmap$(EXESUF)
When a test or object file which needs to be conditionally built based
on some characteristic of the host system, the configure script will
define a variable for the conditional. For example, on Windows it will
define $(CONFIG_POSIX) with a value of 'n' and $(CONFIG_WIN32) with a
value of 'y'. It is now possible to use the config variables when
listing object files. For example,
check-unit-$(CONFIG_POSIX) += tests/test-vmstate$(EXESUF)
On Windows this expands to
check-unit-n += tests/vmstate.exe
Since the `check-unit` target only runs tests included in `$(check-unit-y)`,
POSIX specific tests listed in `$(util-obj-n)` are ignored on the Windows
platform builds.
CFLAGS / LDFLAGS / LIBS handling
--------------------------------
There are many different binaries being built with differing purposes,
and some of them might even be 3rd party libraries pulled in via git
submodules. As such the use of the global CFLAGS variable is generally
avoided in QEMU, since it would apply to too many build targets.
Flags that are needed by any QEMU code (i.e. everything *except* GIT
submodule projects) are put in $(QEMU_CFLAGS) variable. For linker
flags the $(LIBS) variable is sometimes used, but a couple of more
targeted variables are preferred.
In addition to these variables, it is possible to provide cflags and
libs against individual source code files, by defining variables of the
form $FILENAME-cflags and $FILENAME-libs. For example, the test
test-crypto-tlscredsx509 needs to link to the libtasn1 library,
so tests/Makefile.include defines some variables:
tests/crypto-tls-x509-helpers.o-cflags := $(TASN1_CFLAGS)
tests/crypto-tls-x509-helpers.o-libs := $(TASN1_LIBS)
The scope is a little different between the two variables. The libs get
used when linking any target binary that includes the curl.o object
file, while the cflags get used when compiling the curl.c file only.
Important files for the build system Important files for the build system
==================================== ====================================
@ -401,15 +328,9 @@ number of dynamically created files listed later.
executables. Build rules for various subdirectories are included in executables. Build rules for various subdirectories are included in
other meson.build files spread throughout the QEMU source tree. other meson.build files spread throughout the QEMU source tree.
`rules.mak`
This file provides the generic helper rules for invoking build tools, in
particular the compiler and linker.
`tests/Makefile.include` `tests/Makefile.include`
Rules for building the unit tests. This file is included directly by the Rules for external test harnesses. These include the TCG tests,
top level Makefile, so anything defined in this file will influence the `qemu-iotests` and the Avocado-based acceptance tests.
entire build system. Care needs to be taken when writing rules for tests
to ensure they only apply to the unit test execution / build.
`tests/docker/Makefile.include` `tests/docker/Makefile.include`
Rules for Docker tests. Like tests/Makefile, this file is included Rules for Docker tests. Like tests/Makefile, this file is included

2
hw/arm/meson.build
View File

@ -1,5 +1,5 @@
arm_ss = ss.source_set() arm_ss = ss.source_set()
arm_ss.add(files('boot.c')) arm_ss.add(files('boot.c'), fdt)
arm_ss.add(when: 'CONFIG_PLATFORM_BUS', if_true: files('sysbus-fdt.c')) arm_ss.add(when: 'CONFIG_PLATFORM_BUS', if_true: files('sysbus-fdt.c'))
arm_ss.add(when: 'CONFIG_ARM_VIRT', if_true: files('virt.c')) arm_ss.add(when: 'CONFIG_ARM_VIRT', if_true: files('virt.c'))
arm_ss.add(when: 'CONFIG_ACPI', if_true: files('virt-acpi-build.c')) arm_ss.add(when: 'CONFIG_ACPI', if_true: files('virt-acpi-build.c'))

2
hw/mips/meson.build
View File

@ -4,7 +4,7 @@ mips_ss.add(when: 'CONFIG_FULOONG', if_true: files('fuloong2e.c'))
mips_ss.add(when: 'CONFIG_JAZZ', if_true: files('jazz.c')) mips_ss.add(when: 'CONFIG_JAZZ', if_true: files('jazz.c'))
mips_ss.add(when: 'CONFIG_MALTA', if_true: files('gt64xxx_pci.c', 'malta.c')) mips_ss.add(when: 'CONFIG_MALTA', if_true: files('gt64xxx_pci.c', 'malta.c'))
mips_ss.add(when: 'CONFIG_MIPSSIM', if_true: files('mipssim.c')) mips_ss.add(when: 'CONFIG_MIPSSIM', if_true: files('mipssim.c'))
mips_ss.add(when: 'CONFIG_MIPS_BOSTON', if_true: files('boston.c')) mips_ss.add(when: 'CONFIG_MIPS_BOSTON', if_true: [files('boston.c'), fdt])
mips_ss.add(when: 'CONFIG_MIPS_CPS', if_true: files('cps.c')) mips_ss.add(when: 'CONFIG_MIPS_CPS', if_true: files('cps.c'))
mips_ss.add(when: 'CONFIG_R4K', if_true: files('r4k.c')) mips_ss.add(when: 'CONFIG_R4K', if_true: files('r4k.c'))

2
hw/riscv/meson.build
View File

@ -1,5 +1,5 @@
riscv_ss = ss.source_set() riscv_ss = ss.source_set()
riscv_ss.add(files('boot.c')) riscv_ss.add(files('boot.c'), fdt)
riscv_ss.add(files('numa.c')) riscv_ss.add(files('numa.c'))
riscv_ss.add(when: 'CONFIG_HART', if_true: files('riscv_hart.c')) riscv_ss.add(when: 'CONFIG_HART', if_true: files('riscv_hart.c'))
riscv_ss.add(when: 'CONFIG_OPENTITAN', if_true: files('opentitan.c')) riscv_ss.add(when: 'CONFIG_OPENTITAN', if_true: files('opentitan.c'))

127
meson.build
View File

@ -1,6 +1,6 @@
project('qemu', ['c'], meson_version: '>=0.55.0', project('qemu', ['c'], meson_version: '>=0.55.0',
default_options: ['warning_level=1', 'c_std=gnu99', 'cpp_std=gnu++11', default_options: ['warning_level=1', 'c_std=gnu99', 'cpp_std=gnu++11',
'b_lundef=false','b_colorout=auto'], 'b_colorout=auto'],
version: run_command('head', meson.source_root() / 'VERSION').stdout().strip()) version: run_command('head', meson.source_root() / 'VERSION').stdout().strip())
not_found = dependency('', required: false) not_found = dependency('', required: false)
@ -14,7 +14,6 @@ ss = import('sourceset')
sh = find_program('sh') sh = find_program('sh')
cc = meson.get_compiler('c') cc = meson.get_compiler('c')
config_host = keyval.load(meson.current_build_dir() / 'config-host.mak') config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
config_all_disas = keyval.load(meson.current_build_dir() / 'config-all-disas.mak')
enable_modules = 'CONFIG_MODULES' in config_host enable_modules = 'CONFIG_MODULES' in config_host
enable_static = 'CONFIG_STATIC' in config_host enable_static = 'CONFIG_STATIC' in config_host
build_docs = 'BUILD_DOCS' in config_host build_docs = 'BUILD_DOCS' in config_host
@ -33,6 +32,23 @@ endforeach
have_tools = 'CONFIG_TOOLS' in config_host have_tools = 'CONFIG_TOOLS' in config_host
have_block = have_system or have_tools have_block = have_system or have_tools
python = import('python').find_installation()
supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
supported_cpus = ['ppc', 'ppc64', 's390x', 'sparc64', 'riscv32', 'riscv64', 'x86', 'x86_64',
'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
cpu = host_machine.cpu_family()
targetos = host_machine.system()
configure_file(input: files('scripts/ninjatool.py'),
output: 'ninjatool',
configuration: config_host)
##################
# Compiler flags #
##################
add_project_arguments(config_host['QEMU_CFLAGS'].split(), add_project_arguments(config_host['QEMU_CFLAGS'].split(),
native: false, language: ['c', 'objc']) native: false, language: ['c', 'objc'])
add_project_arguments(config_host['QEMU_CXXFLAGS'].split(), add_project_arguments(config_host['QEMU_CXXFLAGS'].split(),
@ -42,7 +58,13 @@ add_project_link_arguments(config_host['QEMU_LDFLAGS'].split(),
add_project_arguments(config_host['QEMU_INCLUDES'].split(), add_project_arguments(config_host['QEMU_INCLUDES'].split(),
language: ['c', 'cpp', 'objc']) language: ['c', 'cpp', 'objc'])
python = import('python').find_installation() # Specify linker-script with add_project_link_arguments so that it is not placed
# within a linker --start-group/--end-group pair
if 'CONFIG_FUZZ' in config_host
add_project_link_arguments(['-Wl,-T,',
(meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
native: false, language: ['c', 'cpp', 'objc'])
endif
link_language = meson.get_external_property('link_language', 'cpp') link_language = meson.get_external_property('link_language', 'cpp')
if link_language == 'cpp' if link_language == 'cpp'
@ -59,17 +81,6 @@ if 'SPARSE_CFLAGS' in config_host
'compile_commands.json']) 'compile_commands.json'])
endif endif
configure_file(input: files('scripts/ninjatool.py'),
output: 'ninjatool',
configuration: config_host)
supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
supported_cpus = ['ppc', 'ppc64', 's390x', 'sparc64', 'riscv32', 'riscv64', 'x86', 'x86_64',
'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
cpu = host_machine.cpu_family()
targetos = host_machine.system()
m = cc.find_library('m', required: false) m = cc.find_library('m', required: false)
util = cc.find_library('util', required: false) util = cc.find_library('util', required: false)
winmm = [] winmm = []
@ -101,8 +112,11 @@ elif targetos == 'haiku'
cc.find_library('network'), cc.find_library('network'),
cc.find_library('bsd')] cc.find_library('bsd')]
endif endif
glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(), # The path to glib.h is added to all compilation commands. This was
link_args: config_host['GLIB_LIBS'].split()) # grandfathered in from the QEMU Makefiles.
add_project_arguments(config_host['GLIB_CFLAGS'].split(),
native: false, language: ['c', 'cpp', 'objc'])
glib = declare_dependency(link_args: config_host['GLIB_LIBS'].split())
gio = not_found gio = not_found
if 'CONFIG_GIO' in config_host if 'CONFIG_GIO' in config_host
gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(), gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
@ -208,6 +222,10 @@ libmpathpersist = not_found
if config_host.has_key('CONFIG_MPATH') if config_host.has_key('CONFIG_MPATH')
libmpathpersist = cc.find_library('mpathpersist') libmpathpersist = cc.find_library('mpathpersist')
endif endif
libdl = not_found
if 'CONFIG_PLUGIN' in config_host
libdl = cc.find_library('dl', required: true)
endif
libiscsi = not_found libiscsi = not_found
if 'CONFIG_LIBISCSI' in config_host if 'CONFIG_LIBISCSI' in config_host
libiscsi = declare_dependency(compile_args: config_host['LIBISCSI_CFLAGS'].split(), libiscsi = declare_dependency(compile_args: config_host['LIBISCSI_CFLAGS'].split(),
@ -297,7 +315,8 @@ if 'CONFIG_AUDIO_COREAUDIO' in config_host
endif endif
opengl = not_found opengl = not_found
if 'CONFIG_OPENGL' in config_host if 'CONFIG_OPENGL' in config_host
opengl = declare_dependency(link_args: config_host['OPENGL_LIBS'].split()) opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
link_args: config_host['OPENGL_LIBS'].split())
else else
endif endif
gtk = not_found gtk = not_found
@ -410,6 +429,15 @@ libdaxctl = not_found
if 'CONFIG_LIBDAXCTL' in config_host if 'CONFIG_LIBDAXCTL' in config_host
libdaxctl = declare_dependency(link_args: config_host['LIBDAXCTL_LIBS'].split()) libdaxctl = declare_dependency(link_args: config_host['LIBDAXCTL_LIBS'].split())
endif endif
tasn1 = not_found
if 'CONFIG_TASN1' in config_host
tasn1 = declare_dependency(compile_args: config_host['TASN1_CFLAGS'].split(),
link_args: config_host['TASN1_LIBS'].split())
endif
keyutils = dependency('libkeyutils', required: false,
method: 'pkg-config', static: enable_static)
has_gettid = cc.has_function('gettid')
# Create config-host.h # Create config-host.h
@ -420,6 +448,8 @@ config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
config_host_data.set('CONFIG_VNC_PNG', png.found()) config_host_data.set('CONFIG_VNC_PNG', png.found())
config_host_data.set('CONFIG_VNC_SASL', sasl.found()) config_host_data.set('CONFIG_VNC_SASL', sasl.found())
config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found()) config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
config_host_data.set('CONFIG_GETTID', has_gettid)
config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version())) 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_MAJOR', meson.project_version().split('.')[0])
config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1]) config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
@ -449,10 +479,45 @@ endforeach
genh += configure_file(output: 'config-host.h', configuration: config_host_data) genh += configure_file(output: 'config-host.h', configuration: config_host_data)
minikconf = find_program('scripts/minikconf.py') minikconf = find_program('scripts/minikconf.py')
config_all_devices = {}
config_all_disas = {}
config_devices_mak_list = [] config_devices_mak_list = []
config_devices_h = {} config_devices_h = {}
config_target_h = {} config_target_h = {}
config_target_mak = {} config_target_mak = {}
disassemblers = {
'alpha' : ['CONFIG_ALPHA_DIS'],
'arm' : ['CONFIG_ARM_DIS'],
'avr' : ['CONFIG_AVR_DIS'],
'cris' : ['CONFIG_CRIS_DIS'],
'hppa' : ['CONFIG_HPPA_DIS'],
'i386' : ['CONFIG_I386_DIS'],
'x86_64' : ['CONFIG_I386_DIS'],
'x32' : ['CONFIG_I386_DIS'],
'lm32' : ['CONFIG_LM32_DIS'],
'm68k' : ['CONFIG_M68K_DIS'],
'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
'mips' : ['CONFIG_MIPS_DIS'],
'moxie' : ['CONFIG_MOXIE_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'],
}
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
kconfig_external_symbols = [ kconfig_external_symbols = [
'CONFIG_KVM', 'CONFIG_KVM',
'CONFIG_XEN', 'CONFIG_XEN',
@ -468,9 +533,19 @@ kconfig_external_symbols = [
'CONFIG_PVRDMA', 'CONFIG_PVRDMA',
] ]
ignored = ['TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_DIRS'] ignored = ['TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_DIRS']
foreach target : target_dirs foreach target : target_dirs
config_target = keyval.load(meson.current_build_dir() / target / 'config-target.mak') config_target = keyval.load(meson.current_build_dir() / target / 'config-target.mak')
foreach k, v: disassemblers
if config_host['ARCH'].startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
foreach sym: v
config_target += { sym: 'y' }
config_all_disas += { sym: 'y' }
endforeach
endif
endforeach
config_target_data = configuration_data() config_target_data = configuration_data()
foreach k, v: config_target foreach k, v: config_target
if not k.startswith('TARGET_') and not k.startswith('CONFIG_') if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
@ -517,11 +592,11 @@ foreach target : target_dirs
config_devices_h += {target: configure_file(output: target + '-config-devices.h', config_devices_h += {target: configure_file(output: target + '-config-devices.h',
configuration: config_devices_data)} configuration: config_devices_data)}
config_target += config_devices config_target += config_devices
config_all_devices += config_devices
endif endif
config_target_mak += {target: config_target} config_target_mak += {target: config_target}
endforeach endforeach
grepy = find_program('scripts/grepy.sh')
# This configuration is used to build files that are shared by # This configuration is used to build files that are shared by
# multiple binaries, and then extracted out of the "common" # multiple binaries, and then extracted out of the "common"
# static_library target. # static_library target.
@ -531,17 +606,6 @@ grepy = find_program('scripts/grepy.sh')
# targets that are not built for this compilation. The CONFIG_ALL # targets that are not built for this compilation. The CONFIG_ALL
# pseudo symbol replaces it. # pseudo symbol replaces it.
if have_system
config_all_devices_mak = configure_file(
output: 'config-all-devices.mak',
input: config_devices_mak_list,
capture: true,
command: [grepy, '@INPUT@'],
)
config_all_devices = keyval.load(config_all_devices_mak)
else
config_all_devices = {}
endif
config_all = config_all_devices config_all = config_all_devices
config_all += config_host config_all += config_host
config_all += config_all_disas config_all += config_all_disas
@ -868,7 +932,7 @@ foreach d, list : modules
endforeach endforeach
nm = find_program('nm') nm = find_program('nm')
undefsym = find_program('scripts/undefsym.sh') undefsym = find_program('scripts/undefsym.py')
block_syms = custom_target('block.syms', output: 'block.syms', block_syms = custom_target('block.syms', output: 'block.syms',
input: [libqemuutil, block_mods], input: [libqemuutil, block_mods],
capture: true, capture: true,
@ -1028,7 +1092,6 @@ foreach target : target_dirs
'gui': false, 'gui': false,
'sources': specific_fuzz.sources(), 'sources': specific_fuzz.sources(),
'dependencies': specific_fuzz.dependencies(), 'dependencies': specific_fuzz.dependencies(),
'link_depends': [files('tests/qtest/fuzz/fork_fuzz.ld')],
}] }]
endif endif
else else
@ -1102,7 +1165,6 @@ if have_tools
dependencies: [block, qemuutil], install: true) dependencies: [block, qemuutil], install: true)
qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'), qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
dependencies: [block, qemuutil], install: true) dependencies: [block, qemuutil], install: true)
qemu_block_tools += [qemu_img, qemu_io, qemu_nbd]
subdir('storage-daemon') subdir('storage-daemon')
subdir('contrib/rdmacm-mux') subdir('contrib/rdmacm-mux')
@ -1293,7 +1355,6 @@ summary_info += {'CFLAGS': config_host['CFLAGS']}
summary_info += {'QEMU_CFLAGS': config_host['QEMU_CFLAGS']} summary_info += {'QEMU_CFLAGS': config_host['QEMU_CFLAGS']}
summary_info += {'QEMU_LDFLAGS': config_host['QEMU_LDFLAGS']} summary_info += {'QEMU_LDFLAGS': config_host['QEMU_LDFLAGS']}
summary_info += {'make': config_host['MAKE']} summary_info += {'make': config_host['MAKE']}
summary_info += {'install': config_host['INSTALL']}
summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())} summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
summary_info += {'sphinx-build': config_host['SPHINX_BUILD']} summary_info += {'sphinx-build': config_host['SPHINX_BUILD']}
summary_info += {'genisoimage': config_host['GENISOIMAGE']} summary_info += {'genisoimage': config_host['GENISOIMAGE']}

2
monitor/meson.build
View File

@ -6,4 +6,4 @@ softmmu_ss.add(files(
'qmp-cmds.c', 'qmp-cmds.c',
)) ))
specific_ss.add(when: 'CONFIG_SOFTMMU', if_true: files('misc.c')) specific_ss.add(when: 'CONFIG_SOFTMMU', if_true: [files('misc.c'), spice])

158
rules.mak
View File

@ -1,158 +0,0 @@
# These are used when we want to do substitutions without confusing Make
NULL :=
SPACE := $(NULL) #
COMMA := ,
# Don't use implicit rules or variables
# we have explicit rules for everything
MAKEFLAGS += -rR
# Files with this suffixes are final, don't try to generate them
# using implicit rules
%/trace-events:
%.hx:
%.py:
%.objs:
%.d:
%.h:
%.c:
%.cc:
%.cpp:
%.m:
%.mak:
# Flags for dependency generation
QEMU_DGFLAGS += -MMD -MP -MT $@ -MF $(@D)/$(*F).d
# Compiler searches the source file dir first, but in vpath builds
# we need to make it search the build dir too, before any other
# explicit search paths. There are two search locations in the build
# dir, one absolute and the other relative to the compiler working
# directory. These are the same for target-independent files, but
# different for target-dependent ones.
QEMU_LOCAL_INCLUDES = -iquote $(BUILD_DIR) -iquote $(BUILD_DIR)/$(@D) -iquote $(@D)
WL := -Wl,
ifdef CONFIG_DARWIN
whole-archive = $(WL)-force_load,$1
else
whole-archive = $(WL)--whole-archive $1 $(WL)--no-whole-archive
endif
extract-libs = $(strip $(foreach o,$1,$($o-libs)))
%.o: %.c
@mkdir -p $(dir $@)
$(call quiet-command,$(CC) $(QEMU_LOCAL_INCLUDES) $(QEMU_INCLUDES) \
$(QEMU_CFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) $($@-cflags) \
-c -o $@ $<,"CC","$(TARGET_DIR)$@")
# If we have a CXX we might have some C++ objects, in which case we
# must link with the C++ compiler, not the plain C compiler.
LINKPROG = $(or $(CXX),$(CC))
LINK = $(call quiet-command, $(LINKPROG) $(CFLAGS) $(QEMU_LDFLAGS) -o $@ \
$(filter-out %.a %.fa,$1) \
$(foreach l,$(filter %.fa,$1),$(call whole-archive,$l)) \
$(filter %.a,$1) \
$(call extract-libs,$1) $(LIBS),"LINK","$(TARGET_DIR)$@")
%.o: %.S
$(call quiet-command,$(CCAS) $(QEMU_LOCAL_INCLUDES) $(QEMU_INCLUDES) \
$(QEMU_CFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) \
-c -o $@ $<,"CCAS","$(TARGET_DIR)$@")
%.o: %.cc
$(call quiet-command,$(CXX) $(QEMU_LOCAL_INCLUDES) $(QEMU_INCLUDES) \
$(QEMU_CXXFLAGS) $(QEMU_DGFLAGS) $(CXXFLAGS) $($@-cflags) \
-c -o $@ $<,"CXX","$(TARGET_DIR)$@")
%.o: %.cpp
$(call quiet-command,$(CXX) $(QEMU_LOCAL_INCLUDES) $(QEMU_INCLUDES) \
$(QEMU_CXXFLAGS) $(QEMU_DGFLAGS) $(CXXFLAGS) $($@-cflags) \
-c -o $@ $<,"CXX","$(TARGET_DIR)$@")
%.o: %.m
$(call quiet-command,$(OBJCC) $(QEMU_LOCAL_INCLUDES) $(QEMU_INCLUDES) \
$(QEMU_CFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) $($@-cflags) \
-c -o $@ $<,"OBJC","$(TARGET_DIR)$@")
%.o: %.dtrace
$(call quiet-command,dtrace -o $@ -G -s $<,"GEN","$(TARGET_DIR)$@")
.PHONY: modules
modules:
%$(EXESUF): %.o
$(call LINK,$(filter %.o %.a %.fa, $^))
%.a:
$(call quiet-command,rm -f $@ && $(AR) rcs $@ $^,"AR","$(TARGET_DIR)$@")
# Usage: $(call quiet-command,command and args,"NAME","args to print")
# This will run "command and args", and either:
# if V=1 just print the whole command and args
# otherwise print the 'quiet' output in the format " NAME args to print"
# NAME should be a short name of the command, 7 letters or fewer.
# If called with only a single argument, will print nothing in quiet mode.
quiet-command-run = $(if $(V),,$(if $2,printf " %-7s %s\n" $2 $3 && ))$1
quiet-@ = $(if $(V),,@)
quiet-command = $(quiet-@)$(call quiet-command-run,$1,$2,$3)
# cc-option
# Usage: CFLAGS+=$(call cc-option, -falign-functions=0, -malign-functions=0)
cc-option = $(if $(shell $(CC) $1 $2 -S -o /dev/null -xc /dev/null \
>/dev/null 2>&1 && echo OK), $2, $3)
cc-c-option = $(if $(shell $(CC) $1 $2 -c -o /dev/null -xc /dev/null \
>/dev/null 2>&1 && echo OK), $2, $3)
VPATH_SUFFIXES = %.c %.h %.S %.cc %.cpp %.m %.mak %.texi %.sh %.rc Kconfig% %.json.in
set-vpath = $(if $1,$(foreach PATTERN,$(VPATH_SUFFIXES),$(eval vpath $(PATTERN) $1)))
# install-prog list, dir
define install-prog
$(INSTALL_DIR) "$2"
$(INSTALL_PROG) $1 "$2"
$(if $(STRIP),$(STRIP) $(foreach T,$1,"$2/$(notdir $T)"),)
endef
# Logical functions (for operating on y/n values like CONFIG_FOO vars)
# Inputs to these must be either "y" (true) or "n" or "" (both false)
# Output is always either "y" or "n".
# Usage: $(call land,$(CONFIG_FOO),$(CONFIG_BAR))
# Logical NOT
lnot = $(if $(subst n,,$1),n,y)
# Logical AND
land = $(if $(findstring yy,$1$2),y,n)
# Logical OR
lor = $(if $(findstring y,$1$2),y,n)
# Logical XOR (note that this is the inverse of leqv)
lxor = $(if $(filter $(call lnot,$1),$(call lnot,$2)),n,y)
# Logical equivalence (note that leqv "","n" is true)
leqv = $(if $(filter $(call lnot,$1),$(call lnot,$2)),y,n)
# Logical if: like make's $(if) but with an leqv-like test
lif = $(if $(subst n,,$1),$2,$3)
# String testing functions: inputs to these can be any string;
# the output is always either "y" or "n". Leading and trailing whitespace
# is ignored when comparing strings.
# String equality
eq = $(if $(subst $2,,$1)$(subst $1,,$2),n,y)
# String inequality
ne = $(if $(subst $2,,$1)$(subst $1,,$2),y,n)
# Emptiness/non-emptiness tests:
isempty = $(if $1,n,y)
notempty = $(if $1,y,n)
.PHONY: clean-timestamp
clean-timestamp:
rm -f *.timestamp
clean: clean-timestamp
# will delete the target of a rule if commands exit with a nonzero exit status
.DELETE_ON_ERROR:
print-%:
@echo '$*=$($*)'

3
scripts/grepy.sh
View File

@ -1,3 +0,0 @@
#!/bin/sh
grep -h '=y$' "$@" | sort -u

98
scripts/mtest2make.py
View File

@ -19,38 +19,25 @@ class Suite(object):
print(''' print('''
SPEED = quick SPEED = quick
# $1 = test command, $2 = test name # $1 = environment, $2 = test command, $3 = test name, $4 = dir
.test-human-tap = $1 < /dev/null | ./scripts/tap-driver.pl --test-name="$2" $(if $(V),,--show-failures-only) .test-human-tap = $1 $(if $4,(cd $4 && $2),$2) < /dev/null | ./scripts/tap-driver.pl --test-name="$3" $(if $(V),,--show-failures-only)
.test-human-exitcode = $1 < /dev/null .test-human-exitcode = $1 $(PYTHON) scripts/test-driver.py $(if $4,-C$4) $(if $(V),--verbose) -- $2 < /dev/null
.test-tap-tap = $1 < /dev/null | sed "s/^[a-z][a-z]* [0-9]*/& $2/" || true .test-tap-tap = $1 $(if $4,(cd $4 && $2),$2) < /dev/null | sed "s/^[a-z][a-z]* [0-9]*/& $3/" || true
.test-tap-exitcode = printf "%s\\n" 1..1 "`$1 < /dev/null > /dev/null || echo "not "`ok 1 $2" .test-tap-exitcode = printf "%s\\n" 1..1 "`$1 $(if $4,(cd $4 && $2),$2) < /dev/null > /dev/null || echo "not "`ok 1 $3"
.test.print = echo $(if $(V),'$1','Running test $2') >&3 .test.human-print = echo $(if $(V),'$1 $2','Running test $3') &&
.test.env = MALLOC_PERTURB_=$${MALLOC_PERTURB_:-$$(( $${RANDOM:-0} % 255 + 1))} .test.env = MALLOC_PERTURB_=$${MALLOC_PERTURB_:-$$(( $${RANDOM:-0} % 255 + 1))}
# $1 = test name, $2 = test target (human or tap) # $1 = test name, $2 = test target (human or tap)
.test.run = $(call .test.print,$(.test.cmd.$1),$(.test.name.$1)) && $(call .test-$2-$(.test.driver.$1),$(.test.cmd.$1),$(.test.name.$1)) .test.run = $(call .test.$2-print,$(.test.env.$1),$(.test.cmd.$1),$(.test.name.$1)) $(call .test-$2-$(.test.driver.$1),$(.test.env.$1),$(.test.cmd.$1),$(.test.name.$1),$(.test.dir.$1))
define .test.human_k .test.output-format = human
@exec 3>&1; rc=0; $(foreach TEST, $1, $(call .test.run,$(TEST),human) || rc=$$?;) \\
exit $$rc
endef
define .test.human_no_k
$(foreach TEST, $1, @exec 3>&1; $(call .test.run,$(TEST),human)
)
endef
.test.human = \\
$(if $(findstring k, $(MAKEFLAGS)), $(.test.human_k), $(.test.human_no_k))
define .test.tap
@exec 3>&1; { $(foreach TEST, $1, $(call .test.run,$(TEST),tap); ) } \\
| ./scripts/tap-merge.pl | tee "$@" \\
| ./scripts/tap-driver.pl $(if $(V),, --show-failures-only)
endef
''') ''')
suites = defaultdict(Suite) introspect = json.load(sys.stdin)
i = 0 i = 0
for test in json.load(sys.stdin):
def process_tests(test, suites):
global i
env = ' '.join(('%s=%s' % (shlex.quote(k), shlex.quote(v)) env = ' '.join(('%s=%s' % (shlex.quote(k), shlex.quote(v))
for k, v in test['env'].items())) for k, v in test['env'].items()))
executable = test['cmd'][0] executable = test['cmd'][0]
@ -65,15 +52,19 @@ for test in json.load(sys.stdin):
test['cmd'][0] = executable test['cmd'][0] = executable
else: else:
test['cmd'][0] = executable test['cmd'][0] = executable
cmd = '$(.test.env) %s %s' % (env, ' '.join((shlex.quote(x) for x in test['cmd']))) cmd = ' '.join((shlex.quote(x) for x in test['cmd']))
if test['workdir'] is not None:
cmd = '(cd %s && %s)' % (shlex.quote(test['workdir']), cmd)
driver = test['protocol'] if 'protocol' in test else 'exitcode' driver = test['protocol'] if 'protocol' in test else 'exitcode'
i += 1 i += 1
if test['workdir'] is not None:
print('.test.dir.%d := %s' % (i, shlex.quote(test['workdir'])))
print('.test.name.%d := %s' % (i, test['name'])) print('.test.name.%d := %s' % (i, test['name']))
print('.test.driver.%d := %s' % (i, driver)) print('.test.driver.%d := %s' % (i, driver))
print('.test.env.%d := $(.test.env) %s' % (i, env))
print('.test.cmd.%d := %s' % (i, cmd)) print('.test.cmd.%d := %s' % (i, cmd))
print('.PHONY: run-test-%d' % (i,))
print('run-test-%d: all' % (i,))
print('\t@$(call .test.run,%d,$(.test.output-format))' % (i,))
test_suites = test['suite'] or ['default'] test_suites = test['suite'] or ['default']
is_slow = any(s.endswith('-slow') for s in test_suites) is_slow = any(s.endswith('-slow') for s in test_suites)
@ -88,22 +79,41 @@ for test in json.load(sys.stdin):
suites[s].tests.append(i) suites[s].tests.append(i)
suites[s].executables.add(executable) suites[s].executables.add(executable)
print('.PHONY: check check-report.tap') def emit_prolog(suites, prefix):
print('check:') all_tap = ' '.join(('%s-report-%s.tap' % (prefix, k) for k in suites.keys()))
print('check-report.tap:') print('.PHONY: %s %s-report.tap %s' % (prefix, prefix, all_tap))
print('\t@cat $^ | scripts/tap-merge.pl >$@') print('%s: run-tests' % (prefix,))
for name, suite in suites.items(): print('%s-report.tap %s: %s-report%%.tap: all' % (prefix, all_tap, prefix))
print('''\t$(MAKE) .test.output-format=tap --quiet -Otarget V=1 %s$* | ./scripts/tap-merge.pl | tee "$@" \\
| ./scripts/tap-driver.pl $(if $(V),, --show-failures-only)''' % (prefix, ))
def emit_suite(name, suite, prefix):
executables = ' '.join(suite.executables) executables = ' '.join(suite.executables)
slow_test_numbers = ' '.join((str(x) for x in suite.slow_tests)) slow_test_numbers = ' '.join((str(x) for x in suite.slow_tests))
test_numbers = ' '.join((str(x) for x in suite.tests)) test_numbers = ' '.join((str(x) for x in suite.tests))
print('.test.suite-quick.%s := %s' % (name, test_numbers)) target = '%s-%s' % (prefix, name)
print('.test.suite-slow.%s := $(.test.suite-quick.%s) %s' % (name, name, slow_test_numbers)) print('.test.quick.%s := %s' % (target, test_numbers))
print('check-build: %s' % executables) print('.test.slow.%s := $(.test.quick.%s) %s' % (target, target, slow_test_numbers))
print('.PHONY: check-%s' % name) print('%s-build: %s' % (prefix, executables))
print('.PHONY: check-report-%s.tap' % name) print('.PHONY: %s' % (target, ))
print('check: check-%s' % name) print('.PHONY: %s-report-%s.tap' % (prefix, name))
print('check-%s: all %s' % (name, executables)) print('%s: run-tests' % (target, ))
print('\t$(call .test.human, $(.test.suite-$(SPEED).%s))' % (name, )) print('ifneq ($(filter %s %s, $(MAKECMDGOALS)),)' % (target, prefix))
print('check-report.tap: check-report-%s.tap' % name) print('.tests += $(.test.$(SPEED).%s)' % (target, ))
print('check-report-%s.tap: %s' % (name, executables)) print('endif')
print('\t$(call .test.tap, $(.test.suite-$(SPEED).%s))' % (name, ))
testsuites = defaultdict(Suite)
for test in introspect['tests']:
process_tests(test, testsuites)
emit_prolog(testsuites, 'check')
for name, suite in testsuites.items():
emit_suite(name, suite, 'check')
benchsuites = defaultdict(Suite)
for test in introspect['benchmarks']:
process_tests(test, benchsuites)
emit_prolog(benchsuites, 'bench')
for name, suite in benchsuites.items():
emit_suite(name, suite, 'bench')
print('run-tests: $(patsubst %, run-test-%, $(.tests))')

8
scripts/ninjatool.py
View File

@ -34,6 +34,7 @@ import os
import re import re
import json import json
import argparse import argparse
import hashlib
import shutil import shutil
@ -51,6 +52,9 @@ else:
normpath = os.path.normpath normpath = os.path.normpath
def sha1_text(text):
return hashlib.sha1(text.encode()).hexdigest()
# ---- lexer and parser ---- # ---- lexer and parser ----
PATH_RE = r"[^$\s:|]+|\$[$ :]|\$[a-zA-Z0-9_-]+|\$\{[a-zA-Z0-9_.-]+\}" PATH_RE = r"[^$\s:|]+|\$[$ :]|\$[a-zA-Z0-9_-]+|\$\{[a-zA-Z0-9_.-]+\}"
@ -767,7 +771,6 @@ class Ninja2Make(NinjaParserEventsWithVars):
self.build_vars = defaultdict(lambda: dict()) self.build_vars = defaultdict(lambda: dict())
self.rule_targets = defaultdict(lambda: list()) self.rule_targets = defaultdict(lambda: list())
self.stamp_targets = defaultdict(lambda: list()) self.stamp_targets = defaultdict(lambda: list())
self.num_stamp = defaultdict(lambda: 0)
self.all_outs = set() self.all_outs = set()
self.all_ins = set() self.all_ins = set()
self.all_phony = set() self.all_phony = set()
@ -903,8 +906,7 @@ class Ninja2Make(NinjaParserEventsWithVars):
if len(out) == 1: if len(out) == 1:
stamp = out[0] + '.stamp' stamp = out[0] + '.stamp'
else: else:
stamp = '%s%d.stamp' %(rule, self.num_stamp[rule]) stamp = '%s@%s.stamp' % (rule, sha1_text(targets)[0:11])
self.num_stamp[rule] += 1
self.print('%s: %s; @:' % (targets, stamp)) self.print('%s: %s; @:' % (targets, stamp))
self.print('%s: %s | %s; ${ninja-command-restat}' % (stamp, inputs, orderonly)) self.print('%s: %s | %s; ${ninja-command-restat}' % (stamp, inputs, orderonly))
self.rule_targets[rule].append(stamp) self.rule_targets[rule].append(stamp)

2
scripts/oss-fuzz/build.sh
View File

@ -81,7 +81,7 @@ rm qemu-fuzz-i386
# Build a second time to build the final binary with correct rpath # Build a second time to build the final binary with correct rpath
../configure --disable-werror --cc="$CC" --cxx="$CXX" --enable-fuzzing \ ../configure --disable-werror --cc="$CC" --cxx="$CXX" --enable-fuzzing \
--prefix="$DEST_DIR" --bindir="$DEST_DIR" --datadir="$DEST_DIR/data/" \ --prefix="$DEST_DIR" --bindir="$DEST_DIR" --datadir="$DEST_DIR/data/" \
--extra-cflags="$EXTRA_CFLAGS" --extra-ldflags="-Wl,-rpath,'\$\$ORIGIN/lib'" \ --extra-cflags="$EXTRA_CFLAGS" --extra-ldflags="-Wl,-rpath,\$ORIGIN/lib" \
--target-list="i386-softmmu" --target-list="i386-softmmu"
make "-j$(nproc)" qemu-fuzz-i386 V=1 make "-j$(nproc)" qemu-fuzz-i386 V=1

35
scripts/test-driver.py Normal file
View File

@ -0,0 +1,35 @@
#! /usr/bin/env python3
# Wrapper for tests that hides the output if they succeed.
# Used by "make check"
#
# Copyright (C) 2020 Red Hat, Inc.
#
# Author: Paolo Bonzini <pbonzini@redhat.com>
import subprocess
import sys
import os
import argparse
parser = argparse.ArgumentParser(description='Test driver for QEMU')
parser.add_argument('-C', metavar='DIR', dest='dir', default='.',
help='change to DIR before doing anything else')
parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',
help='be more verbose')
parser.add_argument('test_args', nargs=argparse.REMAINDER)
args = parser.parse_args()
os.chdir(args.dir)
test_args = args.test_args
if test_args[0] == '--':
test_args = test_args[1:]
if args.verbose:
result = subprocess.run(test_args, stdout=None, stderr=None)
else:
result = subprocess.run(test_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
if result.returncode:
sys.stdout.buffer.write(result.stdout)
sys.exit(result.returncode)

49
scripts/undefsym.py Normal file
View File

@ -0,0 +1,49 @@
#!/usr/bin/env python3
# Before a shared module's DSO is produced, a static library is built for it
# and passed to this script. The script generates -Wl,-u options to force
# the inclusion of symbol from libqemuutil.a if the shared modules need them,
# This is necessary because the modules may use functions not needed by the
# executable itself, which would cause the function to not be linked in.
# Then the DSO loading would fail because of the missing symbol.
import sys
import subprocess
def filter_lines_set(stdout, from_staticlib):
linesSet = set()
for line in stdout.splitlines():
tokens = line.split(b' ')
if len(tokens) >= 1:
if len(tokens) > 1:
if from_staticlib and tokens[1] == b'U':
continue
if not from_staticlib and tokens[1] != b'U':
continue
new_line = b'-Wl,-u,' + tokens[0]
if not new_line in linesSet:
linesSet.add(new_line)
return linesSet
def main(args):
if len(args) <= 3:
sys.exit(0)
nm = args[1]
staticlib = args[2]
pc = subprocess.run([nm, "-P", "-g", staticlib], stdout=subprocess.PIPE)
if pc.returncode != 0:
sys.exit(1)
staticlib_syms = filter_lines_set(pc.stdout, True)
shared_modules = args[3:]
pc = subprocess.run([nm, "-P", "-g"] + shared_modules, stdout=subprocess.PIPE)
if pc.returncode != 0:
sys.exit(1)
modules_undef_syms = filter_lines_set(pc.stdout, False)
lines = sorted(staticlib_syms.intersection(modules_undef_syms))
sys.stdout.buffer.write(b'\n'.join(lines))
if __name__ == "__main__":
main(sys.argv)

20
scripts/undefsym.sh
View File

@ -1,20 +0,0 @@
#! /usr/bin/env bash
# Before a shared module's DSO is produced, a static library is built for it
# and passed to this script. The script generates -Wl,-u options to force
# the inclusion of symbol from libqemuutil.a if the shared modules need them,
# This is necessary because the modules may use functions not needed by the
# executable itself, which would cause the function to not be linked in.
# Then the DSO loading would fail because of the missing symbol.
if test $# -le 2; then
exit 0
fi
NM=$1
staticlib=$2
shift 2
# Find symbols defined in static libraries and undefined in shared modules
comm -12 \
<( $NM -P -g $staticlib | awk '$2!="U"{print "-Wl,-u," $1}' | sort -u) \
<( $NM -P -g "$@" | awk '$2=="U"{print "-Wl,-u," $1}' | sort -u)

416
tests/Makefile.include
View File

@ -34,403 +34,12 @@ endif
ifneq ($(wildcard config-host.mak),) ifneq ($(wildcard config-host.mak),)
export SRC_PATH export SRC_PATH
# TODO don't duplicate $(SRC_PATH)/Makefile's qapi-py here
qapi-py = $(SRC_PATH)/scripts/qapi/__init__.py \
$(SRC_PATH)/scripts/qapi/commands.py \
$(SRC_PATH)/scripts/qapi/common.py \
$(SRC_PATH)/scripts/qapi/doc.py \
$(SRC_PATH)/scripts/qapi/error.py \
$(SRC_PATH)/scripts/qapi/events.py \
$(SRC_PATH)/scripts/qapi/expr.py \
$(SRC_PATH)/scripts/qapi/gen.py \
$(SRC_PATH)/scripts/qapi/introspect.py \
$(SRC_PATH)/scripts/qapi/parser.py \
$(SRC_PATH)/scripts/qapi/schema.py \
$(SRC_PATH)/scripts/qapi/source.py \
$(SRC_PATH)/scripts/qapi/types.py \
$(SRC_PATH)/scripts/qapi/visit.py \
$(SRC_PATH)/scripts/qapi-gen.py
# Get the list of all supported sysemu targets # Get the list of all supported sysemu targets
SYSEMU_TARGET_LIST := $(subst -softmmu.mak,,$(notdir \ SYSEMU_TARGET_LIST := $(subst -softmmu.mak,,$(notdir \
$(wildcard $(SRC_PATH)/default-configs/*-softmmu.mak))) $(wildcard $(SRC_PATH)/default-configs/*-softmmu.mak)))
check-unit-y += tests/check-qdict$(EXESUF)
check-unit-y += tests/check-block-qdict$(EXESUF)
check-unit-y += tests/check-qnum$(EXESUF)
check-unit-y += tests/check-qstring$(EXESUF)
check-unit-y += tests/check-qlist$(EXESUF)
check-unit-y += tests/check-qnull$(EXESUF)
check-unit-y += tests/check-qobject$(EXESUF)
check-unit-y += tests/check-qjson$(EXESUF)
check-unit-y += tests/check-qlit$(EXESUF)
check-unit-y += tests/test-qobject-output-visitor$(EXESUF)
check-unit-y += tests/test-clone-visitor$(EXESUF)
check-unit-y += tests/test-qobject-input-visitor$(EXESUF)
check-unit-$(CONFIG_SOFTMMU) += tests/test-qmp-cmds$(EXESUF)
check-unit-y += tests/test-string-input-visitor$(EXESUF)
check-unit-y += tests/test-string-output-visitor$(EXESUF)
check-unit-y += tests/test-qmp-event$(EXESUF)
check-unit-y += tests/test-opts-visitor$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-coroutine$(EXESUF)
check-unit-y += tests/test-visitor-serialization$(EXESUF)
check-unit-$(CONFIG_SOFTMMU) += tests/test-iov$(EXESUF)
check-unit-y += tests/test-bitmap$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-aio$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-aio-multithread$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-throttle$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-thread-pool$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-hbitmap$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-bdrv-drain$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-bdrv-graph-mod$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-blockjob$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-blockjob-txn$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-block-backend$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-block-iothread$(EXESUF)
ifeq ($(CONFIG_POSIX),y)
check-unit-$(CONFIG_BLOCK) += tests/test-image-locking$(EXESUF)
endif
check-unit-y += tests/test-x86-cpuid$(EXESUF)
# all code tested by test-x86-cpuid is inside topology.h
ifeq ($(CONFIG_SOFTMMU),y)
check-unit-y += tests/test-xbzrle$(EXESUF)
check-unit-$(CONFIG_POSIX) += tests/test-vmstate$(EXESUF)
endif
check-unit-y += tests/test-cutils$(EXESUF)
check-unit-y += tests/test-shift128$(EXESUF)
check-unit-y += tests/test-mul64$(EXESUF)
check-unit-y += tests/test-int128$(EXESUF)
# all code tested by test-int128 is inside int128.h
check-unit-y += tests/rcutorture$(EXESUF)
check-unit-y += tests/test-rcu-list$(EXESUF)
check-unit-y += tests/test-rcu-simpleq$(EXESUF)
check-unit-y += tests/test-rcu-tailq$(EXESUF)
check-unit-y += tests/test-rcu-slist$(EXESUF)
check-unit-y += tests/test-qdist$(EXESUF)
check-unit-y += tests/test-qht$(EXESUF)
check-unit-y += tests/test-qht-par$(EXESUF)
check-unit-y += tests/test-bitops$(EXESUF)
check-unit-y += tests/test-bitcnt$(EXESUF)
check-unit-y += tests/test-qgraph$(EXESUF)
check-unit-y += tests/check-qom-interface$(EXESUF)
check-unit-y += tests/check-qom-proplist$(EXESUF)
check-unit-y += tests/test-qemu-opts$(EXESUF)
check-unit-y += tests/test-keyval$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-write-threshold$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-crypto-hash$(EXESUF)
check-speed-$(CONFIG_BLOCK) += tests/benchmark-crypto-hash$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-crypto-hmac$(EXESUF)
check-speed-$(CONFIG_BLOCK) += tests/benchmark-crypto-hmac$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-crypto-cipher$(EXESUF)
check-speed-$(CONFIG_BLOCK) += tests/benchmark-crypto-cipher$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-crypto-secret$(EXESUF)
check-unit-$(call land,$(CONFIG_BLOCK),$(CONFIG_GNUTLS)) += tests/test-crypto-tlscredsx509$(EXESUF)
check-unit-$(call land,$(CONFIG_BLOCK),$(CONFIG_GNUTLS)) += tests/test-crypto-tlssession$(EXESUF)
ifndef CONFIG_TSAN
# Some tests: test-char, test-qdev-global-props, and test-qga,
# are not runnable under TSan due to a known issue.
# https://github.com/google/sanitizers/issues/1116
check-unit-$(CONFIG_SOFTMMU) += tests/test-char$(EXESUF)
check-unit-$(CONFIG_SOFTMMU) += tests/test-qdev-global-props$(EXESUF)
ifeq ($(CONFIG_GUEST_AGENT),y)
check-unit-$(call land,$(CONFIG_LINUX),$(CONFIG_VIRTIO_SERIAL)) += tests/test-qga$(EXESUF)
endif
endif
check-unit-$(CONFIG_SOFTMMU) += tests/test-timed-average$(EXESUF)
check-unit-$(call land,$(CONFIG_SOFTMMU),$(CONFIG_INOTIFY1)) += tests/test-util-filemonitor$(EXESUF)
check-unit-$(CONFIG_SOFTMMU) += tests/test-util-sockets$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-authz-simple$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-authz-list$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-authz-listfile$(EXESUF)
check-unit-$(call land,$(CONFIG_BLOCK),$(CONFIG_AUTH_PAM)) += tests/test-authz-pam$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-io-task$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-io-channel-socket$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-io-channel-file$(EXESUF)
check-unit-$(call land,$(CONFIG_BLOCK),$(CONFIG_GNUTLS)) += tests/test-io-channel-tls$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-io-channel-command$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-io-channel-buffer$(EXESUF)
check-unit-$(CONFIG_SOFTMMU) += tests/test-base64$(EXESUF)
check-unit-$(call land,$(CONFIG_BLOCK),$(if $(CONFIG_NETTLE),y,$(CONFIG_GCRYPT))) += tests/test-crypto-pbkdf$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-crypto-ivgen$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-crypto-afsplit$(EXESUF)
check-unit-$(call land,$(CONFIG_BLOCK),$(CONFIG_QEMU_PRIVATE_XTS)) += tests/test-crypto-xts$(EXESUF)
check-unit-$(CONFIG_BLOCK) += tests/test-crypto-block$(EXESUF)
check-unit-y += tests/test-logging$(EXESUF)
check-unit-$(call land,$(CONFIG_BLOCK),$(CONFIG_REPLICATION)) += tests/test-replication$(EXESUF)
check-unit-$(CONFIG_SOFTMMU) += tests/test-bufferiszero$(EXESUF)
check-unit-y += tests/test-uuid$(EXESUF)
check-unit-y += tests/ptimer-test$(EXESUF)
check-unit-y += tests/test-qapi-util$(EXESUF)
generated-files-y += tests/test-qapi-types.h
generated-files-y += tests/include/test-qapi-types-sub-module.h
generated-files-y += tests/test-qapi-types-sub-sub-module.h
generated-files-y += tests/test-qapi-visit.h
generated-files-y += tests/include/test-qapi-visit-sub-module.h
generated-files-y += tests/test-qapi-visit-sub-sub-module.h
generated-files-y += tests/test-qapi-commands.h
generated-files-y += tests/test-qapi-init-commands.h
generated-files-y += tests/include/test-qapi-commands-sub-module.h
generated-files-y += tests/test-qapi-commands-sub-sub-module.h
generated-files-y += tests/test-qapi-emit-events.h
generated-files-y += tests/test-qapi-events.h
generated-files-y += tests/include/test-qapi-events-sub-module.h
generated-files-y += tests/test-qapi-events-sub-sub-module.h
generated-files-y += tests/test-qapi-introspect.h
QEMU_CFLAGS += -I$(SRC_PATH)/tests -I$(SRC_PATH)/tests/qtest
# Deps that are common to various different sets of tests below
test-util-obj-y = libqemuutil.a
test-qom-obj-y = $(qom-obj-y) $(test-util-obj-y)
test-qapi-obj-y = tests/test-qapi-types.o \
tests/include/test-qapi-types-sub-module.o \
tests/test-qapi-types-sub-sub-module.o \
tests/test-qapi-visit.o \
tests/include/test-qapi-visit-sub-module.o \
tests/test-qapi-visit-sub-sub-module.o \
tests/test-qapi-introspect.o \
$(test-qom-obj-y)
benchmark-crypto-obj-$(CONFIG_BLOCK) = $(authz-obj-y) $(crypto-obj-y) $(test-qom-obj-y)
test-crypto-obj-$(CONFIG_BLOCK) = $(authz-obj-y) $(crypto-obj-y) $(test-qom-obj-y)
test-io-obj-$(CONFIG_BLOCK) = $(io-obj-y) $(test-crypto-obj-y)
test-authz-obj-$(CONFIG_BLOCK) = $(test-qom-obj-y) $(authz-obj-y)
test-block-obj-$(CONFIG_BLOCK) = $(block-obj-y) $(test-io-obj-y) tests/iothread.o
tests/check-qnum$(EXESUF): tests/check-qnum.o $(test-util-obj-y)
tests/check-qstring$(EXESUF): tests/check-qstring.o $(test-util-obj-y)
tests/check-qdict$(EXESUF): tests/check-qdict.o $(test-util-obj-y)
tests/check-block-qdict$(EXESUF): tests/check-block-qdict.o $(test-util-obj-y)
tests/check-qlist$(EXESUF): tests/check-qlist.o $(test-util-obj-y)
tests/check-qnull$(EXESUF): tests/check-qnull.o $(test-util-obj-y)
tests/check-qobject$(EXESUF): tests/check-qobject.o $(test-util-obj-y)
tests/check-qjson$(EXESUF): tests/check-qjson.o $(test-util-obj-y)
tests/check-qlit$(EXESUF): tests/check-qlit.o $(test-util-obj-y)
tests/check-qom-interface$(EXESUF): tests/check-qom-interface.o $(test-qom-obj-y)
tests/check-qom-proplist$(EXESUF): tests/check-qom-proplist.o $(test-qom-obj-y)
tests/test-char$(EXESUF): tests/test-char.o $(test-util-obj-y) $(test-io-obj-y) $(chardev-obj-y) tests/socket-helpers.o
tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(test-block-obj-y)
tests/test-aio$(EXESUF): tests/test-aio.o $(test-block-obj-y)
tests/test-aio-multithread$(EXESUF): tests/test-aio-multithread.o $(test-block-obj-y)
tests/test-throttle$(EXESUF): tests/test-throttle.o $(test-block-obj-y)
tests/test-bdrv-drain$(EXESUF): tests/test-bdrv-drain.o $(test-block-obj-y) $(test-util-obj-y)
tests/test-bdrv-graph-mod$(EXESUF): tests/test-bdrv-graph-mod.o $(test-block-obj-y) $(test-util-obj-y)
tests/test-blockjob$(EXESUF): tests/test-blockjob.o $(test-block-obj-y) $(test-util-obj-y)
tests/test-blockjob-txn$(EXESUF): tests/test-blockjob-txn.o $(test-block-obj-y) $(test-util-obj-y)
tests/test-block-backend$(EXESUF): tests/test-block-backend.o $(test-block-obj-y) $(test-util-obj-y)
tests/test-block-iothread$(EXESUF): tests/test-block-iothread.o $(test-block-obj-y) $(test-util-obj-y)
tests/test-image-locking$(EXESUF): tests/test-image-locking.o $(test-block-obj-y) $(test-util-obj-y)
tests/test-thread-pool$(EXESUF): tests/test-thread-pool.o $(test-block-obj-y)
tests/test-iov$(EXESUF): tests/test-iov.o $(test-util-obj-y)
tests/test-hbitmap$(EXESUF): tests/test-hbitmap.o $(test-util-obj-y) $(test-crypto-obj-y)
tests/test-bitmap$(EXESUF): tests/test-bitmap.o $(test-util-obj-y)
tests/test-x86-cpuid$(EXESUF): tests/test-x86-cpuid.o
tests/test-xbzrle$(EXESUF): tests/test-xbzrle.o migration/libmigration.fa $(test-util-obj-y) \
$(test-io-obj-y)
tests/test-cutils$(EXESUF): tests/test-cutils.o util/cutils.o $(test-util-obj-y)
tests/test-int128$(EXESUF): tests/test-int128.o
tests/rcutorture$(EXESUF): tests/rcutorture.o $(test-util-obj-y)
tests/test-rcu-list$(EXESUF): tests/test-rcu-list.o $(test-util-obj-y)
tests/test-rcu-simpleq$(EXESUF): tests/test-rcu-simpleq.o $(test-util-obj-y)
tests/test-rcu-tailq$(EXESUF): tests/test-rcu-tailq.o $(test-util-obj-y)
tests/test-rcu-slist$(EXESUF): tests/test-rcu-slist.o $(test-util-obj-y)
tests/test-qdist$(EXESUF): tests/test-qdist.o $(test-util-obj-y)
tests/test-qht$(EXESUF): tests/test-qht.o $(test-util-obj-y)
tests/test-qht-par$(EXESUF): tests/test-qht-par.o tests/qht-bench$(EXESUF) $(test-util-obj-y)
tests/qht-bench$(EXESUF): tests/qht-bench.o $(test-util-obj-y)
tests/test-bufferiszero$(EXESUF): tests/test-bufferiszero.o $(test-util-obj-y)
tests/atomic_add-bench$(EXESUF): tests/atomic_add-bench.o $(test-util-obj-y)
tests/atomic64-bench$(EXESUF): tests/atomic64-bench.o $(test-util-obj-y)
tests/test-qdev-global-props$(EXESUF): tests/test-qdev-global-props.o hw/core/libhwcore.fa \
$(test-qapi-obj-y)
tests/test-vmstate$(EXESUF): tests/test-vmstate.o migration/libmigration.fa \
$(test-io-obj-y)
tests/test-timed-average$(EXESUF): tests/test-timed-average.o $(test-util-obj-y)
tests/test-base64$(EXESUF): tests/test-base64.o $(test-util-obj-y)
tests/ptimer-test$(EXESUF): tests/ptimer-test.o tests/ptimer-test-stubs.o hw/core/ptimer.o
tests/test-qemu-opts$(EXESUF): tests/test-qemu-opts.o $(test-util-obj-y)
tests/test-keyval$(EXESUF): tests/test-keyval.o $(test-util-obj-y) $(test-qapi-obj-y)
tests/test-write-threshold$(EXESUF): tests/test-write-threshold.o $(test-block-obj-y)
tests/test-uuid$(EXESUF): tests/test-uuid.o $(test-util-obj-y)
tests/test-qapi-util$(EXESUF): tests/test-qapi-util.o $(test-util-obj-y)
tests/test-logging$(EXESUF): tests/test-logging.o $(test-util-obj-y)
tests/test-replication$(EXESUF): tests/test-replication.o $(test-util-obj-y) \
$(test-block-obj-y)
tests/test-qapi-types.c tests/test-qapi-types.h \
tests/include/test-qapi-types-sub-module.c \
tests/include/test-qapi-types-sub-module.h \
tests/test-qapi-types-sub-sub-module.c \
tests/test-qapi-types-sub-sub-module.h \
tests/test-qapi-visit.c tests/test-qapi-visit.h \
tests/include/test-qapi-visit-sub-module.c \
tests/include/test-qapi-visit-sub-module.h \
tests/test-qapi-visit-sub-sub-module.c \
tests/test-qapi-visit-sub-sub-module.h \
tests/test-qapi-commands.h tests/test-qapi-commands.c \
tests/include/test-qapi-commands-sub-module.h \
tests/include/test-qapi-commands-sub-module.c \
tests/test-qapi-commands-sub-sub-module.h \
tests/test-qapi-commands-sub-sub-module.c \
tests/test-qapi-emit-events.c tests/test-qapi-emit-events.h \
tests/test-qapi-events.c tests/test-qapi-events.h \
tests/test-qapi-init-commands.c \
tests/test-qapi-init-commands.h \
tests/include/test-qapi-events-sub-module.c \
tests/include/test-qapi-events-sub-module.h \
tests/test-qapi-events-sub-sub-module.c \
tests/test-qapi-events-sub-sub-module.h \
tests/test-qapi-introspect.c tests/test-qapi-introspect.h: \
tests/test-qapi-gen-timestamp ;
tests/test-qapi-gen-timestamp: \
$(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json \
$(SRC_PATH)/tests/qapi-schema/include/sub-module.json \
$(SRC_PATH)/tests/qapi-schema/sub-sub-module.json \
$(qapi-py)
$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-gen.py \
-o tests -p "test-" $<, \
"GEN","$(@:%-timestamp=%)")
@rm -f tests/test-qapi-doc.texi
@>$@
tests/test-string-output-visitor$(EXESUF): tests/test-string-output-visitor.o $(test-qapi-obj-y)
tests/test-string-input-visitor$(EXESUF): tests/test-string-input-visitor.o $(test-qapi-obj-y)
tests/test-qmp-event$(EXESUF): tests/test-qmp-event.o $(test-qapi-obj-y) tests/test-qapi-emit-events.o tests/test-qapi-events.o
tests/test-qobject-output-visitor$(EXESUF): tests/test-qobject-output-visitor.o $(test-qapi-obj-y)
tests/test-clone-visitor$(EXESUF): tests/test-clone-visitor.o $(test-qapi-obj-y)
tests/test-qobject-input-visitor$(EXESUF): tests/test-qobject-input-visitor.o $(test-qapi-obj-y)
tests/test-qmp-cmds$(EXESUF): tests/test-qmp-cmds.o tests/test-qapi-commands.o tests/test-qapi-init-commands.o $(test-qapi-obj-y)
tests/test-visitor-serialization$(EXESUF): tests/test-visitor-serialization.o $(test-qapi-obj-y)
tests/test-opts-visitor$(EXESUF): tests/test-opts-visitor.o $(test-qapi-obj-y)
tests/test-shift128$(EXESUF): tests/test-shift128.o $(test-util-obj-y)
tests/test-mul64$(EXESUF): tests/test-mul64.o $(test-util-obj-y)
tests/test-bitops$(EXESUF): tests/test-bitops.o $(test-util-obj-y)
tests/test-bitcnt$(EXESUF): tests/test-bitcnt.o $(test-util-obj-y)
tests/test-qgraph$(EXESUF): tests/test-qgraph.o tests/qtest/libqos/qgraph.o $(test-util-obj-y)
tests/test-crypto-hash$(EXESUF): tests/test-crypto-hash.o $(test-crypto-obj-y)
tests/benchmark-crypto-hash$(EXESUF): tests/benchmark-crypto-hash.o $(test-crypto-obj-y)
tests/test-crypto-hmac$(EXESUF): tests/test-crypto-hmac.o $(test-crypto-obj-y)
tests/benchmark-crypto-hmac$(EXESUF): tests/benchmark-crypto-hmac.o $(test-crypto-obj-y)
tests/test-crypto-cipher$(EXESUF): tests/test-crypto-cipher.o $(test-crypto-obj-y)
tests/benchmark-crypto-cipher$(EXESUF): tests/benchmark-crypto-cipher.o $(test-crypto-obj-y)
tests/test-crypto-secret$(EXESUF): tests/test-crypto-secret.o $(test-crypto-obj-y)
tests/test-crypto-xts$(EXESUF): tests/test-crypto-xts.o $(test-crypto-obj-y)
ifeq ($(CONFIG_TEST_SECRET_KEYRING),y)
tests/test-crypto-secret.o-libs := -lkeyutils
endif
tests/crypto-tls-x509-helpers.o-cflags := $(TASN1_CFLAGS)
tests/crypto-tls-x509-helpers.o-libs := $(TASN1_LIBS)
tests/pkix_asn1_tab.o-cflags := $(TASN1_CFLAGS)
tests/test-crypto-tlscredsx509.o-cflags := $(TASN1_CFLAGS)
tests/test-crypto-tlscredsx509$(EXESUF): tests/test-crypto-tlscredsx509.o \
tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o $(test-crypto-obj-y)
tests/test-crypto-tlssession.o-cflags := $(TASN1_CFLAGS)
tests/test-crypto-tlssession$(EXESUF): tests/test-crypto-tlssession.o \
tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o \
tests/crypto-tls-psk-helpers.o \
$(test-crypto-obj-y)
tests/test-util-filemonitor$(EXESUF): tests/test-util-filemonitor.o \
$(test-util-obj-y)
tests/test-util-sockets$(EXESUF): tests/test-util-sockets.o \
tests/socket-helpers.o $(test-util-obj-y)
tests/test-authz-simple$(EXESUF): tests/test-authz-simple.o $(test-authz-obj-y)
tests/test-authz-list$(EXESUF): tests/test-authz-list.o $(test-authz-obj-y)
tests/test-authz-listfile$(EXESUF): tests/test-authz-listfile.o $(test-authz-obj-y)
tests/test-authz-pam$(EXESUF): tests/test-authz-pam.o $(test-authz-obj-y)
tests/test-io-task$(EXESUF): tests/test-io-task.o $(test-io-obj-y)
tests/test-io-channel-socket$(EXESUF): tests/test-io-channel-socket.o \
tests/io-channel-helpers.o tests/socket-helpers.o $(test-io-obj-y)
tests/test-io-channel-file$(EXESUF): tests/test-io-channel-file.o \
tests/io-channel-helpers.o $(test-io-obj-y)
tests/test-io-channel-tls$(EXESUF): tests/test-io-channel-tls.o \
tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o \
tests/io-channel-helpers.o $(test-io-obj-y)
tests/test-io-channel-command$(EXESUF): tests/test-io-channel-command.o \
tests/io-channel-helpers.o $(test-io-obj-y)
tests/test-io-channel-buffer$(EXESUF): tests/test-io-channel-buffer.o \
tests/io-channel-helpers.o $(test-io-obj-y)
tests/test-crypto-pbkdf$(EXESUF): tests/test-crypto-pbkdf.o $(test-crypto-obj-y)
tests/test-crypto-ivgen$(EXESUF): tests/test-crypto-ivgen.o $(test-crypto-obj-y)
tests/test-crypto-afsplit$(EXESUF): tests/test-crypto-afsplit.o $(test-crypto-obj-y)
tests/test-crypto-block$(EXESUF): tests/test-crypto-block.o $(test-crypto-obj-y)
tests/migration/stress$(EXESUF): tests/migration/stress.o
$(call quiet-command, $(LINKPROG) -static -O3 $(PTHREAD_LIB) -o $@ $< ,"LINK","$(TARGET_DIR)$@")
INITRD_WORK_DIR=tests/migration/initrd
tests/migration/initrd-stress.img: tests/migration/stress$(EXESUF)
mkdir -p $(INITRD_WORK_DIR)
cp $< $(INITRD_WORK_DIR)/init
(cd $(INITRD_WORK_DIR) && (find | cpio --quiet -o -H newc | gzip -9)) > $@
rm $(INITRD_WORK_DIR)/init
rmdir $(INITRD_WORK_DIR)
tests/test-qga$(EXESUF): qga/qemu-ga$(EXESUF)
tests/test-qga$(EXESUF): tests/test-qga.o tests/qtest/libqtest.o $(test-util-obj-y)
tests/vhost-user-bridge$(EXESUF): tests/vhost-user-bridge.o $(test-util-obj-y) libvhost-user.a
tests/qemu-iotests/socket_scm_helper$(EXESUF): tests/qemu-iotests/socket_scm_helper.o
SPEED = quick SPEED = quick
# gtester tests, possibly with verbose output
# do_test_tap runs all tests, even if some of them fail, while do_test_human
# stops at the first failure unless -k is given on the command line
define do_test_human_k
$(quiet-@)rc=0; $(foreach COMMAND, $1, \
$(call quiet-command-run, \
export MALLOC_PERTURB_=$${MALLOC_PERTURB_:-$$(( $${RANDOM:-0} % 255 + 1))} $2; \
$(COMMAND) -m=$(SPEED) -k --tap < /dev/null \
| ./scripts/tap-driver.pl --test-name="$(notdir $(COMMAND))" $(if $(V),, --show-failures-only) \
|| rc=$$?;, "TEST", "$@: $(COMMAND)")) exit $$rc
endef
define do_test_human_no_k
$(foreach COMMAND, $1, \
$(call quiet-command, \
MALLOC_PERTURB_=$${MALLOC_PERTURB_:-$$(( $${RANDOM:-0} % 255 + 1))} $2 \
$(COMMAND) -m=$(SPEED) -k --tap < /dev/null \
| ./scripts/tap-driver.pl --test-name="$(notdir $(COMMAND))" $(if $(V),, --show-failures-only), \
"TEST", "$@: $(COMMAND)")
)
endef
do_test_human = \
$(if $(findstring k, $(MAKEFLAGS)), $(do_test_human_k), $(do_test_human_no_k))
define do_test_tap
$(call quiet-command, \
{ export MALLOC_PERTURB_=$${MALLOC_PERTURB_:-$$(( $${RANDOM:-0} % 255 + 1))} $2; \
$(foreach COMMAND, $1, \
$(COMMAND) -m=$(SPEED) -k --tap < /dev/null \
| sed "s/^\(not \)\?ok [0-9]* /&$(notdir $(COMMAND)) /" || true; ) } \
| ./scripts/tap-merge.pl | tee "$@" \
| ./scripts/tap-driver.pl $(if $(V),, --show-failures-only), \
"TAP","$@")
endef
build-unit: $(check-unit-y)
check-unit: $(check-unit-y)
$(call do_test_human, $^)
check-speed: $(check-speed-y)
$(call do_test_human, $^)
# gtester tests with TAP output
check-report-unit.tap: $(check-unit-y)
$(call do_test_tap,$^)
# Per guest TCG tests # Per guest TCG tests
BUILD_TCG_TARGET_RULES=$(patsubst %,build-tcg-tests-%, $(TARGET_DIRS)) BUILD_TCG_TARGET_RULES=$(patsubst %,build-tcg-tests-%, $(TARGET_DIRS))
@ -470,7 +79,6 @@ check-tcg: $(RUN_TCG_TARGET_RULES)
.PHONY: clean-tcg .PHONY: clean-tcg
clean-tcg: $(CLEAN_TCG_TARGET_RULES) clean-tcg: $(CLEAN_TCG_TARGET_RULES)
# Python venv for running tests # Python venv for running tests
.PHONY: check-venv check-acceptance .PHONY: check-venv check-acceptance
@ -524,21 +132,27 @@ check-acceptance: check-venv $(TESTS_RESULTS_DIR) get-vm-images
# Consolidated targets # Consolidated targets
.PHONY: check-block check-unit check check-clean get-vm-images .PHONY: check-block check check-clean get-vm-images
check-block: check:
check-build: build-unit
ifeq ($(CONFIG_TOOLS)$(CONFIG_POSIX),yy)
QEMU_IOTESTS_HELPERS-$(CONFIG_LINUX) = tests/qemu-iotests/socket_scm_helper$(EXESUF)
check: check-block
check-block: $(SRC_PATH)/tests/check-block.sh qemu-img$(EXESUF) \
qemu-io$(EXESUF) qemu-nbd$(EXESUF) $(QEMU_IOTESTS_HELPERS-y) \
$(patsubst %-softmmu,qemu-system-%,$(filter %-softmmu,$(TARGET_DIRS)))
@$<
endif
check-build: $(QEMU_IOTESTS_HELPERS-y)
check-clean: check-clean:
rm -rf $(check-unit-y) tests/*.o tests/*/*.o $(QEMU_IOTESTS_HELPERS-y)
rm -f tests/test-qapi-gen-timestamp
rm -rf $(TESTS_VENV_DIR) $(TESTS_RESULTS_DIR) rm -rf $(TESTS_VENV_DIR) $(TESTS_RESULTS_DIR)
check: check-unit
clean: check-clean clean: check-clean
# Build the help program automatically # For backwards compatibility
-include $(wildcard tests/*.d) check-speed: bench-speed
endif endif

8
tests/benchmark-crypto-cipher.c
View File

@ -70,8 +70,8 @@ static void test_cipher_speed(size_t chunk_size,
} }
g_test_timer_elapsed(); g_test_timer_elapsed();
g_print("Enc chunk %zu bytes ", chunk_size); g_test_message("Enc chunk %zu bytes ", chunk_size);
g_print("%.2f MB/sec ", (double)total / MiB / g_test_timer_last()); g_test_message("%.2f MB/sec ", (double)total / MiB / g_test_timer_last());
g_test_timer_start(); g_test_timer_start();
remain = total; remain = total;
@ -85,8 +85,8 @@ static void test_cipher_speed(size_t chunk_size,
} }
g_test_timer_elapsed(); g_test_timer_elapsed();
g_print("Dec chunk %zu bytes ", chunk_size); g_test_message("Dec chunk %zu bytes ", chunk_size);
g_print("%.2f MB/sec ", (double)total / MiB / g_test_timer_last()); g_test_message("%.2f MB/sec ", (double)total / MiB / g_test_timer_last());
qcrypto_cipher_free(cipher); qcrypto_cipher_free(cipher);
g_free(plaintext); g_free(plaintext);

2
tests/benchmark-crypto-hash.c
View File

@ -48,7 +48,7 @@ static void test_hash_speed(const void *opaque)
} }
g_test_timer_elapsed(); g_test_timer_elapsed();
g_print("%.2f MB/sec ", (double)total / MiB / g_test_timer_last()); g_test_message("%.2f MB/sec ", (double)total / MiB / g_test_timer_last());
g_free(out); g_free(out);
g_free(in); g_free(in);

8
tests/benchmark-crypto-hmac.c
View File

@ -55,10 +55,10 @@ static void test_hmac_speed(const void *opaque)
} while (g_test_timer_elapsed() < 5.0); } while (g_test_timer_elapsed() < 5.0);
total /= MiB; total /= MiB;
g_print("hmac(sha256): "); g_test_message("hmac(sha256): ");
g_print("Testing chunk_size %zu bytes ", chunk_size); g_test_message("Testing chunk_size %zu bytes ", chunk_size);
g_print("done: %.2f MB in %.2f secs: ", total, g_test_timer_last()); g_test_message("done: %.2f MB in %.2f secs: ", total, g_test_timer_last());
g_print("%.2f MB/sec\n", total / g_test_timer_last()); g_test_message("%.2f MB/sec\n", total / g_test_timer_last());
g_free(out); g_free(out);
g_free(in); g_free(in);

4
tests/docker/Makefile.include
View File

@ -2,6 +2,10 @@
.PHONY: docker docker-test docker-clean docker-image docker-qemu-src .PHONY: docker docker-test docker-clean docker-image docker-qemu-src
NULL :=
SPACE := $(NULL) #
COMMA := ,
HOST_ARCH = $(if $(ARCH),$(ARCH),$(shell uname -m)) HOST_ARCH = $(if $(ARCH),$(ARCH),$(shell uname -m))
DOCKER_SUFFIX := .docker DOCKER_SUFFIX := .docker

16
tests/include/meson.build Normal file
View File

@ -0,0 +1,16 @@
# an extra target to workaround meson limitation on output files location
test_qapi_outputs_extra = [
'test-qapi-commands-sub-module.c',
'test-qapi-commands-sub-module.h',
'test-qapi-events-sub-module.c',
'test-qapi-events-sub-module.h',
'test-qapi-types-sub-module.c',
'test-qapi-types-sub-module.h',
'test-qapi-visit-sub-module.c',
'test-qapi-visit-sub-module.h',
]
test_qapi_outputs_extra = custom_target('QAPI test (include)',
output: test_qapi_outputs_extra,
input: test_qapi_files,
command: 'true')

253
tests/meson.build
View File

@ -1,3 +1,255 @@
py3 = import('python').find_installation()
qht_bench = executable('qht-bench',
sources: 'qht-bench.c',
dependencies: [qemuutil])
executable('atomic_add-bench',
sources: files('atomic_add-bench.c'),
dependencies: [qemuutil],
build_by_default: false)
executable('atomic64-bench',
sources: files('atomic64-bench.c'),
dependencies: [qemuutil],
build_by_default: false)
test_qapi_outputs = [
'qapi-builtin-types.c',
'qapi-builtin-types.h',
'qapi-builtin-visit.c',
'qapi-builtin-visit.h',
'test-qapi-commands-sub-sub-module.c',
'test-qapi-commands-sub-sub-module.h',
'test-qapi-commands.c',
'test-qapi-commands.h',
'test-qapi-emit-events.c',
'test-qapi-emit-events.h',
'test-qapi-events-sub-sub-module.c',
'test-qapi-events-sub-sub-module.h',
'test-qapi-events.c',
'test-qapi-events.h',
'test-qapi-init-commands.c',
'test-qapi-init-commands.h',
'test-qapi-introspect.c',
'test-qapi-introspect.h',
'test-qapi-types-sub-sub-module.c',
'test-qapi-types-sub-sub-module.h',
'test-qapi-types.c',
'test-qapi-types.h',
'test-qapi-visit-sub-sub-module.c',
'test-qapi-visit-sub-sub-module.h',
'test-qapi-visit.c',
'test-qapi-visit.h',
]
test_qapi_files = custom_target('Test QAPI files',
output: test_qapi_outputs,
input: files('qapi-schema/qapi-schema-test.json',
'qapi-schema/include/sub-module.json',
'qapi-schema/sub-sub-module.json'),
command: [ qapi_gen, '-o', meson.current_build_dir(),
'-b', '-p', 'test-', '@INPUT0@' ],
depend_files: qapi_gen_depends)
# meson doesn't like generated output in other directories
# perhaps change qapi_gen to replace / with _, like Meson itself does?
subdir('include')
libtestqapi = static_library('testqapi', sources: [test_qapi_files, test_qapi_outputs_extra])
testqapi = declare_dependency(link_with: libtestqapi)
testblock = declare_dependency(dependencies: [block], sources: 'iothread.c')
tests = {
'check-block-qdict': [],
'check-qdict': [],
'check-qnum': [],
'check-qstring': [],
'check-qlist': [],
'check-qnull': [],
'check-qobject': [],
'check-qjson': [],
'check-qlit': [],
'test-qobject-output-visitor': [testqapi],
'test-clone-visitor': [testqapi],
'test-qobject-input-visitor': [testqapi],
'test-string-input-visitor': [testqapi],
'test-string-output-visitor': [testqapi],
'test-qmp-event': [testqapi],
'test-opts-visitor': [testqapi],
'test-visitor-serialization': [testqapi],
'test-bitmap': [],
# all code tested by test-x86-cpuid is inside topology.h
'test-x86-cpuid': [],
'test-cutils': [],
'test-shift128': [],
'test-mul64': [],
# all code tested by test-int128 is inside int128.h
'test-int128': [],
'rcutorture': [],
'test-rcu-list': [],
'test-rcu-simpleq': [],
'test-rcu-tailq': [],
'test-rcu-slist': [],
'test-qdist': [],
'test-qht': [],
'test-bitops': [],
'test-bitcnt': [],
'test-qgraph': ['qtest/libqos/qgraph.c'],
'check-qom-interface': [qom],
'check-qom-proplist': [qom],
'test-qemu-opts': [],
'test-keyval': [testqapi],
'test-logging': [],
'test-uuid': [],
'ptimer-test': ['ptimer-test-stubs.c', meson.source_root() / 'hw/core/ptimer.c'],
'test-qapi-util': [],
}
test_deps = {
'test-qht-par': qht_bench,
}
benchs = {}
if have_block
tests += {
'test-coroutine': [testblock],
'test-aio': [testblock],
'test-aio-multithread': [testblock],
'test-throttle': [testblock],
'test-thread-pool': [testblock],
'test-hbitmap': [testblock],
'test-bdrv-drain': [testblock],
'test-bdrv-graph-mod': [testblock],
'test-blockjob': [testblock],
'test-blockjob-txn': [testblock],
'test-block-backend': [testblock],
'test-block-iothread': [testblock],
'test-write-threshold': [testblock],
'test-crypto-hash': [crypto],
'test-crypto-hmac': [crypto],
'test-crypto-cipher': [crypto],
'test-crypto-secret': [crypto, keyutils],
'test-authz-simple': [authz],
'test-authz-list': [authz],
'test-authz-listfile': [authz],
'test-io-task': [testblock],
'test-io-channel-socket': ['socket-helpers.c', 'io-channel-helpers.c', io],
'test-io-channel-file': ['io-channel-helpers.c', io],
'test-io-channel-command': ['io-channel-helpers.c', io],
'test-io-channel-buffer': ['io-channel-helpers.c', io],
'test-crypto-ivgen': [io],
'test-crypto-afsplit': [io],
'test-crypto-block': [io],
}
if 'CONFIG_GNUTLS' in config_host and \
'CONFIG_TASN1' in config_host
tests += {
'test-crypto-tlscredsx509': ['crypto-tls-x509-helpers.c', 'pkix_asn1_tab.c',
tasn1, crypto],
'test-crypto-tlssession': ['crypto-tls-x509-helpers.c', 'pkix_asn1_tab.c', 'crypto-tls-psk-helpers.c',
tasn1, crypto],
'test-io-channel-tls': ['io-channel-helpers.c', 'crypto-tls-x509-helpers.c', 'pkix_asn1_tab.c',
tasn1, io, crypto]}
endif
if 'CONFIG_AUTH_PAM' in config_host
tests += {'test-authz-pam': [authz]}
endif
if 'CONFIG_QEMU_PRIVATE_XTS' in config_host
tests += {'test-crypto-xts': [crypto, io]}
endif
if 'CONFIG_POSIX' in config_host
tests += {'test-image-locking': [testblock]}
endif
if 'CONFIG_REPLICATION' in config_host
tests += {'test-replication': [testblock]}
endif
if 'CONFIG_NETTLE' in config_host or 'CONFIG_GCRYPT' in config_host
tests += {'test-crypto-pbkdf': [io]}
endif
benchs += {
'benchmark-crypto-hash': [crypto],
'benchmark-crypto-hmac': [crypto],
'benchmark-crypto-cipher': [crypto],
}
endif
if have_system
tests += {
'test-iov': [],
'test-qmp-cmds': [testqapi],
'test-xbzrle': [migration],
'test-timed-average': [],
'test-util-sockets': ['socket-helpers.c'],
'test-base64': [],
'test-bufferiszero': [],
'test-vmstate': [migration, io]
}
if 'CONFIG_INOTIFY1' in config_host
tests += {'test-util-filemonitor': []}
endif
# Some tests: test-char, test-qdev-global-props, and test-qga,
# are not runnable under TSan due to a known issue.
# https://github.com/google/sanitizers/issues/1116
if 'CONFIG_TSAN' not in config_host
tests += {
'test-char': ['socket-helpers.c', qom, io, chardev],
'test-qdev-global-props': [qom, hwcore, testqapi]
}
endif
endif
if 'CONFIG_TSAN' not in config_host and \
'CONFIG_GUEST_AGENT' in config_host and \
'CONFIG_LINUX' in config_host
tests += {'test-qga': ['qtest/libqtest.c']}
test_deps += {'test-qga': qga}
endif
test_env = environment()
test_env.set('G_TEST_SRCDIR', meson.current_source_dir())
test_env.set('G_TEST_BUILDDIR', meson.current_build_dir())
foreach test_name, extra: tests
src = [test_name + '.c']
deps = [qemuutil]
if extra.length() > 0
# use a sourceset to quickly separate sources and deps
test_ss = ss.source_set()
test_ss.add(extra)
src += test_ss.all_sources()
deps += test_ss.all_dependencies()
endif
exe = executable(test_name, src, dependencies: deps)
test(test_name, exe,
depends: test_deps.get(test_name, []),
env: test_env,
args: ['--tap', '-k'],
protocol: 'tap',
suite: ['unit'])
endforeach
foreach bench_name, deps: benchs
exe = executable(bench_name, bench_name + '.c',
dependencies: [qemuutil] + deps)
benchmark(bench_name, exe,
args: ['--tap', '-k'],
protocol: 'tap',
suite: ['speed'])
endforeach
if have_tools and 'CONFIG_VHOST_USER' in config_host
executable('vhost-user-bridge',
sources: files('vhost-user-bridge.c'),
link_with: [libvhost_user],
dependencies: [qemuutil],
build_by_default: false)
endif
if have_system and 'CONFIG_POSIX' in config_host if have_system and 'CONFIG_POSIX' in config_host
subdir('qemu-iotests') subdir('qemu-iotests')
endif endif
@ -16,3 +268,4 @@ endif
subdir('qapi-schema') subdir('qapi-schema')
subdir('qtest') subdir('qtest')
subdir('migration')

10
tests/migration/initrd-stress.sh Executable file
View File

@ -0,0 +1,10 @@
#!/bin/sh
INITRD="$1"
STRESS="$2"
INITRD_DIR=$(mktemp -d -p '' "initrd-stress.XXXXXX")
trap 'rm -rf $INITRD_DIR' EXIT
cp "$STRESS" "$INITRD_DIR/init"
(cd "$INITRD_DIR" && (find | cpio --quiet -o -H newc | gzip -9)) > "$INITRD"

14
tests/migration/meson.build Normal file
View File

@ -0,0 +1,14 @@
stress = executable(
'stress',
files('stress.c'),
dependencies: [glib],
link_args: ['-static'],
build_by_default: false,
)
custom_target(
'initrd-stress.img',
output: 'initrd-stress.img',
input: stress,
command: [find_program('initrd-stress.sh'), '@OUTPUT@', '@INPUT@']
)

15
tests/migration/stress.c
View File

@ -29,10 +29,12 @@ const char *argv0;
#define PAGE_SIZE 4096 #define PAGE_SIZE 4096
#ifndef CONFIG_GETTID
static int gettid(void) static int gettid(void)
{ {
return syscall(SYS_gettid); return syscall(SYS_gettid);
} }
#endif
static __attribute__((noreturn)) void exit_failure(void) static __attribute__((noreturn)) void exit_failure(void)
{ {
@ -47,19 +49,6 @@ static __attribute__((noreturn)) void exit_failure(void)
} }
} }
static __attribute__((noreturn)) void exit_success(void)
{
if (getpid() == 1) {
sync();
reboot(RB_POWER_OFF);
fprintf(stderr, "%s (%05d): ERROR: cannot reboot: %s\n",
argv0, gettid(), strerror(errno));
abort();
} else {
exit(0);
}
}
static int get_command_arg_str(const char *name, static int get_command_arg_str(const char *name,
char **val) char **val)
{ {

4
tests/qemu-iotests/meson.build
View File

@ -4,7 +4,3 @@ if 'CONFIG_LINUX' in config_host
else else
socket_scm_helper = [] socket_scm_helper = []
endif endif
test('qemu-iotests', sh, args: [files('../check-block.sh')],
depends: [qemu_block_tools, emulators, socket_scm_helper],
suite: 'block', timeout: 10000)

7
tests/qtest/fuzz/meson.build
View File

@ -6,12 +6,9 @@ specific_fuzz_ss.add(when: 'CONFIG_I440FX', if_true: files('i440fx_fuzz.c'))
specific_fuzz_ss.add(when: 'CONFIG_VIRTIO_NET', if_true: files('virtio_net_fuzz.c')) specific_fuzz_ss.add(when: 'CONFIG_VIRTIO_NET', if_true: files('virtio_net_fuzz.c'))
specific_fuzz_ss.add(when: 'CONFIG_VIRTIO_SCSI', if_true: files('virtio_scsi_fuzz.c')) specific_fuzz_ss.add(when: 'CONFIG_VIRTIO_SCSI', if_true: files('virtio_scsi_fuzz.c'))
# unfortunately declare_dependency does not support link_depends, so
# this will be duplicated in meson.build
fork_fuzz = declare_dependency( fork_fuzz = declare_dependency(
link_args: ['-fsanitize=fuzzer', link_args: config_host['FUZZ_EXE_LDFLAGS'].split() +
'-Wl,-T,' + (meson.current_source_dir() / 'fork_fuzz.ld'), ['-Wl,-wrap,qtest_inb',
'-Wl,-wrap,qtest_inb',
'-Wl,-wrap,qtest_inw', '-Wl,-wrap,qtest_inw',
'-Wl,-wrap,qtest_inl', '-Wl,-wrap,qtest_inl',
'-Wl,-wrap,qtest_outb', '-Wl,-wrap,qtest_outb',

9
tests/qtest/libqos/meson.build
View File

@ -1,5 +1,4 @@
libqos = static_library('qos', libqos_srcs = files('../libqtest.c',
files('../libqtest.c',
'qgraph.c', 'qgraph.c',
'qos_external.c', 'qos_external.c',
'pci.c', 'pci.c',
@ -52,6 +51,10 @@ libqos = static_library('qos',
'arm-xilinx-zynq-a9-machine.c', 'arm-xilinx-zynq-a9-machine.c',
'ppc64_pseries-machine.c', 'ppc64_pseries-machine.c',
'x86_64_pc-machine.c', 'x86_64_pc-machine.c',
), build_by_default: false) )
libqos = static_library('qos', libqos_srcs + genh,
name_suffix: 'fa',
build_by_default: false)
qos = declare_dependency(link_whole: libqos) qos = declare_dependency(link_whole: libqos)

2
tests/tcg/Makefile.qemu
View File

@ -8,8 +8,6 @@
# to do it for us. # to do it for us.
# #
include $(SRC_PATH)/rules.mak
# The configure script fills in extra information about # The configure script fills in extra information about
# useful docker images or alternative compiler flags. # useful docker images or alternative compiler flags.

10
tests/test-crypto-secret.c
View File

@ -24,7 +24,7 @@
#include "crypto/secret.h" #include "crypto/secret.h"
#include "qapi/error.h" #include "qapi/error.h"
#include "qemu/module.h" #include "qemu/module.h"
#ifdef CONFIG_TEST_SECRET_KEYRING #ifdef CONFIG_KEYUTILS
#include "crypto/secret_keyring.h" #include "crypto/secret_keyring.h"
#include <keyutils.h> #include <keyutils.h>
#endif #endif
@ -128,7 +128,7 @@ static void test_secret_indirect_emptyfile(void)
g_free(fname); g_free(fname);
} }
#ifdef CONFIG_TEST_SECRET_KEYRING #ifdef CONFIG_KEYUTILS
#define DESCRIPTION "qemu_test_secret" #define DESCRIPTION "qemu_test_secret"
#define PAYLOAD "Test Payload" #define PAYLOAD "Test Payload"
@ -268,7 +268,7 @@ static void test_secret_keyring_bad_key_access_right(void)
keyctl_unlink(key, KEY_SPEC_PROCESS_KEYRING); keyctl_unlink(key, KEY_SPEC_PROCESS_KEYRING);
} }
#endif /* CONFIG_TEST_SECRET_KEYRING */ #endif /* CONFIG_KEYUTILS */
static void test_secret_noconv_base64_good(void) static void test_secret_noconv_base64_good(void)
{ {
@ -571,7 +571,7 @@ int main(int argc, char **argv)
g_test_add_func("/crypto/secret/indirect/emptyfile", g_test_add_func("/crypto/secret/indirect/emptyfile",
test_secret_indirect_emptyfile); test_secret_indirect_emptyfile);
#ifdef CONFIG_TEST_SECRET_KEYRING #ifdef CONFIG_KEYUTILS
g_test_add_func("/crypto/secret/keyring/good", g_test_add_func("/crypto/secret/keyring/good",
test_secret_keyring_good); test_secret_keyring_good);
g_test_add_func("/crypto/secret/keyring/revoked_key", g_test_add_func("/crypto/secret/keyring/revoked_key",
@ -582,7 +582,7 @@ int main(int argc, char **argv)
test_secret_keyring_bad_serial_key); test_secret_keyring_bad_serial_key);
g_test_add_func("/crypto/secret/keyring/bad_key_access_right", g_test_add_func("/crypto/secret/keyring/bad_key_access_right",
test_secret_keyring_bad_key_access_right); test_secret_keyring_bad_key_access_right);
#endif /* CONFIG_TEST_SECRET_KEYRING */ #endif /* CONFIG_KEYUTILS */
g_test_add_func("/crypto/secret/noconv/base64/good", g_test_add_func("/crypto/secret/noconv/base64/good",
test_secret_noconv_base64_good); test_secret_noconv_base64_good);

2
tests/test-qga.c
View File

@ -4,7 +4,7 @@
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/un.h> #include <sys/un.h>
#include "libqos/libqtest.h" #include "qtest/libqos/libqtest.h"
#include "qapi/qmp/qdict.h" #include "qapi/qmp/qdict.h"
#include "qapi/qmp/qlist.h" #include "qapi/qmp/qlist.h"

3
ui/meson.build
View File

@ -1,5 +1,5 @@
softmmu_ss.add(pixman) softmmu_ss.add(pixman)
specific_ss.add(pixman) # for the include path specific_ss.add(when: ['CONFIG_SOFTMMU'], if_true: pixman) # for the include path
softmmu_ss.add(files( softmmu_ss.add(files(
'console.c', 'console.c',
@ -35,6 +35,7 @@ softmmu_ss.add_all(when: vnc, if_true: vnc_ss)
softmmu_ss.add(when: vnc, if_false: files('vnc-stubs.c')) softmmu_ss.add(when: vnc, if_false: files('vnc-stubs.c'))
softmmu_ss.add(when: [opengl, 'CONFIG_OPENGL'], if_true: files('shader.c', 'console-gl.c', 'egl-helpers.c', 'egl-context.c')) softmmu_ss.add(when: [opengl, 'CONFIG_OPENGL'], if_true: files('shader.c', 'console-gl.c', 'egl-helpers.c', 'egl-context.c'))
softmmu_ss.add(when: [opengl, 'CONFIG_OPENGL_DMABUF'], if_true: files('egl-headless.c')) softmmu_ss.add(when: [opengl, 'CONFIG_OPENGL_DMABUF'], if_true: files('egl-headless.c'))
specific_ss.add(when: ['CONFIG_SOFTMMU'], if_true: opengl)
ui_modules = {} ui_modules = {}