2020-03-04 12:35:06 +03:00
#!/usr/bin/env bash
2021-04-16 19:36:27 +03:00
# shellcheck disable=SC2031
2012-05-21 20:55:48 +04:00
# -*- mode: shell-script; indent-tabs-mode: nil; sh-basic-offset: 4; -*-
2021-04-16 19:36:27 +03:00
# ex: ts=8 sw=4 sts=4 et filetype=sh tw=180
# Note: the shellcheck line above disables warning for variables which were
# modified in a subshell. In our case this behavior is expected, but
# `shellcheck` can't distinguish this because of poor variable tracking,
# which results in warning for every instance of such variable used
# throughout this file.
# See:
# * comment in function install_verity_minimal()
# * koalaman/shellcheck#280
set -o pipefail
2012-05-21 20:55:48 +04:00
PATH=/sbin:/bin:/usr/sbin:/usr/bin
export PATH
2020-08-27 12:59:45 +03:00
os_release=$(test -e /etc/os-release && echo /etc/os-release || echo /usr/lib/os-release)
2021-04-16 19:33:44 +03:00
# shellcheck source=/dev/null
source "$os_release"
[[ "$ID" = "debian" || " $ID_LIKE " = *" debian "* ]] && LOOKS_LIKE_DEBIAN=yes || LOOKS_LIKE_DEBIAN=""
[[ "$ID" = "arch" || " $ID_LIKE " = *" arch "* ]] && LOOKS_LIKE_ARCH=yes || LOOKS_LIKE_ARCH=""
[[ " $ID_LIKE " = *" suse "* ]] && LOOKS_LIKE_SUSE=yes || LOOKS_LIKE_SUSE=""
KERNEL_VER="${KERNEL_VER-$(uname -r)}"
2016-02-24 21:22:06 +03:00
QEMU_TIMEOUT="${QEMU_TIMEOUT:-infinity}"
2016-04-13 16:57:06 +03:00
NSPAWN_TIMEOUT="${NSPAWN_TIMEOUT:-infinity}"
2016-06-24 13:11:19 +03:00
TIMED_OUT= # will be 1 after run_* if *_TIMEOUT is set and test timed out
2017-11-07 17:51:30 +03:00
[[ "$LOOKS_LIKE_SUSE" ]] && FSTYPE="${FSTYPE:-btrfs}" || FSTYPE="${FSTYPE:-ext4}"
2016-11-15 19:38:04 +03:00
UNIFIED_CGROUP_HIERARCHY="${UNIFIED_CGROUP_HIERARCHY:-default}"
2019-12-09 20:52:35 +03:00
EFI_MOUNT="${EFI_MOUNT:-$(bootctl -x 2>/dev/null || echo /boot)}"
2019-01-11 17:51:07 +03:00
QEMU_MEM="${QEMU_MEM:-512M}"
2021-01-07 00:42:28 +03:00
# Note that defining a different IMAGE_NAME in a test setup script will only result
# in default.img being copied and renamed. It can then be extended by defining
# a test_append_files() function. The $1 parameter will be the root directory.
# To force creating a new image from scratch (eg: to encrypt it), also define
# TEST_FORCE_NEWIMAGE=1 in the test setup script.
2019-12-12 11:37:19 +03:00
IMAGE_NAME=${IMAGE_NAME:-default}
2021-07-09 15:59:11 +03:00
STRIP_BINARIES="${STRIP_BINARIES:-yes}"
2019-12-17 14:52:35 +03:00
TEST_REQUIRE_INSTALL_TESTS="${TEST_REQUIRE_INSTALL_TESTS:-1}"
2020-05-17 11:48:16 +03:00
TEST_PARALLELIZE="${TEST_PARALLELIZE:-0}"
2020-03-20 22:17:11 +03:00
LOOPDEV=
2012-05-21 20:55:48 +04:00
2021-07-04 13:21:23 +03:00
# Simple wrapper to unify boolean checks.
# Note: this function needs to stay near the top of the file, so we can use it
# in code in the outermost scope.
get_bool() {
# Make the value lowercase to make the regex matching simpler
local _bool="${1,,}"
# Consider empty value as "false"
if [[ -z "$_bool" || "$_bool" =~ ^(0|no|false)$ ]]; then
return 1
elif [[ "$_bool" =~ ^(1|yes|true)$ ]]; then
return 0
else
echo >&2 "Value '$_bool' is not a valid boolean value"
exit 1
fi
}
2019-09-27 00:29:38 +03:00
# Decide if we can (and want to) run QEMU with KVM acceleration.
# Check if nested KVM is explicitly enabled (TEST_NESTED_KVM). If not,
# check if it's not explicitly disabled (TEST_NO_KVM) and we're not already
# running under KVM. If these conditions are met, enable KVM (and possibly
# nested KVM), otherwise disable it.
2021-07-04 13:21:23 +03:00
if get_bool "${TEST_NESTED_KVM:=}" || (! get_bool "${TEST_NO_KVM:=}" && [[ "$(systemd-detect-virt -v)" != kvm ]]); then
2019-09-27 00:29:38 +03:00
QEMU_KVM=yes
else
QEMU_KVM=no
fi
2015-02-02 02:19:29 +03:00
if ! ROOTLIBDIR=$(pkg-config --variable=systemdutildir systemd); then
echo "WARNING! Cannot determine rootlibdir from pkg-config, assuming /usr/lib/systemd" >&2
ROOTLIBDIR=/usr/lib/systemd
fi
2021-01-27 00:46:10 +03:00
# The calling test.sh scripts have TEST_BASE_DIR set via their Makefile, but we don't need them to provide it
2021-04-16 19:33:44 +03:00
TEST_BASE_DIR=${TEST_BASE_DIR:-$(realpath "$(dirname "${BASH_SOURCE[0]}")")}
2021-04-26 20:20:18 +03:00
TEST_UNITS_DIR="$(realpath "$TEST_BASE_DIR/units")"
2021-01-27 00:46:10 +03:00
SOURCE_DIR=$(realpath "$TEST_BASE_DIR/..")
TOOLS_DIR="$SOURCE_DIR/tools"
2021-04-16 19:33:44 +03:00
# These variables are used by test scripts
export TEST_BASE_DIR TEST_UNITS_DIR SOURCE_DIR TOOLS_DIR
2021-01-27 00:46:10 +03:00
2020-11-17 23:39:37 +03:00
# note that find-build-dir.sh will return $BUILD_DIR if provided, else it will try to find it
2021-04-16 19:33:44 +03:00
if ! BUILD_DIR="$("$TOOLS_DIR"/find-build-dir.sh)"; then
2021-07-04 13:21:23 +03:00
if get_bool "${NO_BUILD:=}"; then
2021-04-16 19:33:44 +03:00
BUILD_DIR="$SOURCE_DIR"
2020-11-18 01:20:22 +03:00
else
echo "ERROR: no build found, please set BUILD_DIR or use NO_BUILD" >&2
exit 1
fi
2020-11-17 23:39:37 +03:00
fi
2021-04-16 19:37:49 +03:00
PATH_TO_INIT="$ROOTLIBDIR/systemd"
SYSTEMD_JOURNALD="${SYSTEMD_JOURNALD:-$(command -v "$BUILD_DIR/systemd-journald" || command -v "$ROOTLIBDIR/systemd-journald")}"
SYSTEMD_JOURNAL_REMOTE="${SYSTEMD_JOURNAL_REMOTE:-$(command -v "$BUILD_DIR/systemd-journal-remote" || command -v "$ROOTLIBDIR/systemd-journal-remote")}"
SYSTEMD="${SYSTEMD:-$(command -v "$BUILD_DIR/systemd" || command -v "$ROOTLIBDIR/systemd")}"
SYSTEMD_NSPAWN="${SYSTEMD_NSPAWN:-$(command -v "$BUILD_DIR/systemd-nspawn" || command -v systemd-nspawn)}"
JOURNALCTL="${JOURNALCTL:-$(command -v "$BUILD_DIR/journalctl" || command -v journalctl)}"
2018-07-05 18:14:07 +03:00
2021-04-16 19:33:44 +03:00
TESTFILE="${BASH_SOURCE[1]}"
2021-01-27 00:46:10 +03:00
if [ -z "$TESTFILE" ]; then
echo "ERROR: test-functions must be sourced from one of the TEST-*/test.sh scripts" >&2
exit 1
fi
2021-04-16 19:33:44 +03:00
TESTNAME="$(basename "$(dirname "$(realpath "$TESTFILE")")")"
2021-01-27 00:46:10 +03:00
STATEDIR="$BUILD_DIR/test/$TESTNAME"
2020-11-18 00:02:14 +03:00
STATEFILE="$STATEDIR/.testdir"
IMAGESTATEDIR="$STATEDIR/.."
TESTLOG="$STATEDIR/test.log"
2021-04-26 20:20:18 +03:00
if ! [[ "$TESTNAME" =~ ^TEST\-([0-9]+)\-.+$ ]]; then
echo "ERROR: Test name '$TESTNAME' is not in the expected format: TEST-[0-9]+-*" >&2
exit 1
fi
TESTID="${BASH_REMATCH[1]:?}"
if [[ ! -f "$TEST_UNITS_DIR/testsuite-$TESTID.service" ]]; then
echo "ERROR: Test '$TESTNAME' is missing its service file '$TEST_UNITS_DIR/testsuite-$TESTID.service" >&2
exit 1
fi
2019-12-09 22:35:51 +03:00
BASICTOOLS=(
2019-12-10 17:31:09 +03:00
awk
2021-06-15 09:34:41 +03:00
base64
2019-12-10 17:31:09 +03:00
basename
2019-12-09 22:35:51 +03:00
bash
2019-12-09 23:45:46 +03:00
busybox
2019-12-10 17:31:09 +03:00
capsh
2019-12-09 22:35:51 +03:00
cat
chmod
chown
cmp
cryptsetup
2019-12-10 17:31:09 +03:00
cut
2019-12-09 22:35:51 +03:00
date
2019-12-10 17:31:09 +03:00
dd
diff
dirname
2019-12-09 22:35:51 +03:00
dmsetup
echo
env
false
2020-08-14 11:20:43 +03:00
getconf
2019-12-10 17:31:09 +03:00
getent
getfacl
2020-03-20 22:22:42 +03:00
grep
2019-12-10 17:31:09 +03:00
gunzip
2019-12-09 22:35:51 +03:00
gzip
head
2019-12-10 17:31:09 +03:00
ionice
2019-12-09 23:45:46 +03:00
ip
2019-12-09 22:35:51 +03:00
ln
loadkeys
login
2019-12-10 17:31:09 +03:00
lz4cat
2019-12-10 15:32:20 +03:00
mkfifo
mktemp
2019-12-09 22:35:51 +03:00
modprobe
mount
2020-06-09 17:51:55 +03:00
mountpoint
2019-12-09 23:26:59 +03:00
mv
nc
2019-12-10 17:31:09 +03:00
nproc
2019-12-10 15:32:20 +03:00
readlink
2019-12-10 17:31:09 +03:00
rev
2019-12-09 22:35:51 +03:00
rm
2019-12-09 23:45:46 +03:00
rmdir
2019-12-09 22:35:51 +03:00
sed
2019-12-10 17:31:09 +03:00
seq
2021-02-09 12:47:34 +03:00
setfattr
2019-12-09 22:35:51 +03:00
setfont
setsid
2020-03-20 22:22:42 +03:00
sfdisk
2019-12-09 22:35:51 +03:00
sh
sleep
2019-12-09 22:42:48 +03:00
socat
2019-12-09 23:26:59 +03:00
stat
2020-03-20 21:05:36 +03:00
su
2019-12-09 22:35:51 +03:00
sulogin
2019-12-09 23:45:46 +03:00
sysctl
2019-12-09 22:35:51 +03:00
tail
2019-12-10 11:10:28 +03:00
tar
2019-12-09 22:35:51 +03:00
tee
test
2020-04-03 10:13:51 +03:00
timeout
2019-12-09 22:53:38 +03:00
touch
2019-12-10 17:31:09 +03:00
tr
2019-12-09 22:35:51 +03:00
true
2020-03-20 22:22:42 +03:00
truncate
2019-12-09 22:35:51 +03:00
umount
2019-12-10 17:31:09 +03:00
uname
2019-12-09 23:45:46 +03:00
unshare
2019-12-09 22:35:51 +03:00
xargs
2019-12-10 17:31:09 +03:00
xzcat
2019-12-09 22:35:51 +03:00
)
DEBUGTOOLS=(
cp
df
dhclient
dmesg
du
find
free
grep
hostname
id
less
ln
ls
mkdir
ping
ps
route
sort
strace
stty
tty
vi
)
2013-11-06 02:32:56 +04:00
2018-07-05 07:09:30 +03:00
is_built_with_asan() {
if ! type -P objdump >/dev/null; then
ddebug "Failed to find objdump. Assuming systemd hasn't been built with ASAN."
return 1
fi
# Borrowed from https://github.com/google/oss-fuzz/blob/cd9acd02f9d3f6e80011cc1e9549be526ce5f270/infra/base-images/base-runner/bad_build_check#L182
2021-04-16 19:33:44 +03:00
local _asan_calls
_asan_calls="$(objdump -dC "$SYSTEMD_JOURNALD" | grep -E "callq?\s+[0-9a-f]+\s+<__asan" -c)"
if ((_asan_calls < 1000)); then
2018-07-05 07:09:30 +03:00
return 1
else
return 0
fi
}
IS_BUILT_WITH_ASAN=$(is_built_with_asan && echo yes || echo no)
2021-07-04 13:21:23 +03:00
if get_bool "$IS_BUILT_WITH_ASAN"; then
2018-07-05 07:09:30 +03:00
STRIP_BINARIES=no
2019-05-09 20:30:13 +03:00
SKIP_INITRD="${SKIP_INITRD:-yes}"
2018-07-05 18:14:07 +03:00
PATH_TO_INIT=$ROOTLIBDIR/systemd-under-asan
2019-07-16 18:01:26 +03:00
QEMU_MEM="2048M"
2021-03-07 00:21:30 +03:00
QEMU_SMP="${QEMU_SMP:-4}"
2019-05-24 23:35:52 +03:00
# We need to correctly distinguish between gcc's and clang's ASan DSOs.
2021-04-30 14:26:54 +03:00
if ASAN_RT_NAME="$(awk '/libasan.so/ {x=$1; exit} END {print x; exit x==""}' < <(ldd "$SYSTEMD"))"; then
2019-05-24 23:35:52 +03:00
ASAN_COMPILER=gcc
2021-03-07 00:21:30 +03:00
ASAN_RT_PATH="$(readlink -f "$(${CC:-gcc} --print-file-name "$ASAN_RT_NAME")")"
2021-04-30 14:26:54 +03:00
elif ASAN_RT_NAME="$(awk '/libclang_rt.asan/ {x=$1; exit} END {print x; exit x==""}' < <(ldd "$SYSTEMD"))"; then
2019-05-24 23:35:52 +03:00
ASAN_COMPILER=clang
2021-03-07 00:21:30 +03:00
ASAN_RT_PATH="$(readlink -f "$(${CC:-clang} --print-file-name "$ASAN_RT_NAME")")"
2019-05-24 23:35:52 +03:00
# As clang's ASan DSO is usually in a non-standard path, let's check if
# the environment is set accordingly. If not, warn the user and exit.
# We're not setting the LD_LIBRARY_PATH automagically here, because
# user should encounter (and fix) the same issue when running the unit
# tests (meson test)
2019-08-13 14:52:57 +03:00
if ldd "$SYSTEMD" | grep -q "libclang_rt.asan.*not found"; then
2021-03-07 00:21:30 +03:00
echo >&2 "clang's ASan DSO ($ASAN_RT_NAME) is not present in the runtime library path"
echo >&2 "Consider setting LD_LIBRARY_PATH=${ASAN_RT_PATH%/*}"
2019-05-24 23:35:52 +03:00
exit 1
fi
else
echo >&2 "systemd is not linked against the ASan DSO"
echo >&2 "gcc does this by default, for clang compile with -shared-libasan"
exit 1
fi
2021-03-07 00:21:30 +03:00
echo "Detected ASan RT '$ASAN_RT_NAME' located at '$ASAN_RT_PATH'"
2018-07-05 07:09:30 +03:00
fi
2021-04-16 19:33:44 +03:00
find_qemu_bin() {
QEMU_BIN="${QEMU_BIN:-""}"
2018-05-02 21:06:13 +03:00
# SUSE and Red Hat call the binary qemu-kvm. Debian and Gentoo call it kvm.
2021-07-04 13:21:23 +03:00
if get_bool "$QEMU_KVM"; then
2021-04-16 19:33:44 +03:00
[[ -n "$QEMU_BIN" ]] || QEMU_BIN="$(command -v kvm qemu-kvm 2>/dev/null | grep '^/' -m1)"
2018-05-02 21:06:13 +03:00
fi
2013-12-08 03:01:53 +04:00
2021-04-16 19:33:44 +03:00
[[ -n "$ARCH" ]] || ARCH="$(uname -m)"
2013-12-08 03:01:53 +04:00
case $ARCH in
x86_64)
# QEMU's own build system calls it qemu-system-x86_64
2021-04-16 19:33:44 +03:00
[[ -n "$QEMU_BIN" ]] || QEMU_BIN="$(command -v qemu-system-x86_64 2>/dev/null | grep '^/' -m1)"
2013-12-08 03:01:53 +04:00
;;
i*86)
# new i386 version of QEMU
2021-04-16 19:33:44 +03:00
[[ -n "$QEMU_BIN" ]] || QEMU_BIN="$(command -v qemu-system-i386 2>/dev/null | grep '^/' -m1)"
2013-12-08 03:01:53 +04:00
# i386 version of QEMU
2021-04-16 19:33:44 +03:00
[[ -n "$QEMU_BIN" ]] || QEMU_BIN="$(command -v qemu 2>/dev/null | grep '^/' -m1)"
2013-12-08 03:01:53 +04:00
;;
2016-11-20 06:45:23 +03:00
ppc64*)
2021-04-16 19:33:44 +03:00
[[ -n "$QEMU_BIN" ]] || QEMU_BIN="$(command -v qemu-system-ppc64 2>/dev/null | grep '^/' -m1)"
2016-11-20 06:45:23 +03:00
;;
2013-12-08 03:01:53 +04:00
esac
2021-04-16 19:33:44 +03:00
if [[ ! -e "$QEMU_BIN" ]]; then
2013-12-08 03:01:53 +04:00
echo "Could not find a suitable QEMU binary" >&2
return 1
fi
}
2020-12-15 14:05:14 +03:00
# Compares argument #1=X.Y.Z (X&Y&Z = numeric) to the version of the installed qemu
# returns 0 if newer or equal
# returns 1 if older
# returns 2 if failing
2021-04-16 19:33:44 +03:00
qemu_min_version() {
2020-12-15 14:05:14 +03:00
find_qemu_bin || return 2
# get version from binary
2021-04-16 19:33:44 +03:00
local qemu_ver
qemu_ver="$("$QEMU_BIN" --version | awk '/^QEMU emulator version ([0-9]*\.[0-9]*\.[0-9]*)/ {print $4}')"
2020-12-15 14:05:14 +03:00
# Check version string format
echo "$qemu_ver" | grep -q '^[0-9]*\.[0-9]*\.[0-9]*$' || return 2
echo "$1" | grep -q '^[0-9]*\.[0-9]*\.[0-9]*$' || return 2
# compare as last command to return that value
printf "%s\n%s\n" "$1" "$qemu_ver" | sort -V -C
}
2016-06-24 13:11:19 +03:00
# Return 0 if QEMU did run (then you must check the result state/logs for actual
# success), or 1 if QEMU is not available.
2013-11-06 02:32:56 +04:00
run_qemu() {
2015-02-03 12:43:24 +03:00
if [ -f /etc/machine-id ]; then
2021-04-16 19:33:44 +03:00
read -r MACHINE_ID </etc/machine-id
2017-11-17 16:09:11 +03:00
[ -z "$INITRD" ] && [ -e "$EFI_MOUNT/$MACHINE_ID/$KERNEL_VER/initrd" ] \
&& INITRD="$EFI_MOUNT/$MACHINE_ID/$KERNEL_VER/initrd"
[ -z "$KERNEL_BIN" ] && [ -e "$EFI_MOUNT/$MACHINE_ID/$KERNEL_VER/linux" ] \
&& KERNEL_BIN="$EFI_MOUNT/$MACHINE_ID/$KERNEL_VER/linux"
2015-02-03 12:43:24 +03:00
fi
2021-04-16 19:33:44 +03:00
local CONSOLE=ttyS0
2018-02-20 15:01:40 +03:00
2020-04-21 14:18:36 +03:00
rm -f "$initdir"/{testok,failed,skipped}
2019-12-13 16:21:31 +03:00
# make sure the initdir is not mounted to avoid concurrent access
cleanup_initdir
umount_loopback
2016-11-11 05:45:38 +03:00
if [[ ! "$KERNEL_BIN" ]]; then
2021-07-04 13:21:23 +03:00
if get_bool "$LOOKS_LIKE_ARCH"; then
2016-11-11 05:45:38 +03:00
KERNEL_BIN=/boot/vmlinuz-linux
else
2018-02-19 23:47:41 +03:00
[ "$ARCH" ] || ARCH=$(uname -m)
case $ARCH in
ppc64*)
2021-04-16 19:33:44 +03:00
KERNEL_BIN="/boot/vmlinux-$KERNEL_VER"
2018-02-20 15:01:40 +03:00
CONSOLE=hvc0
2018-02-19 23:47:41 +03:00
;;
*)
2021-04-16 19:33:44 +03:00
KERNEL_BIN="/boot/vmlinuz-$KERNEL_VER"
2018-02-19 23:47:41 +03:00
;;
esac
2016-11-11 05:45:38 +03:00
fi
fi
2021-04-16 19:33:44 +03:00
local default_fedora_initrd="/boot/initramfs-${KERNEL_VER}.img"
local default_debian_initrd="/boot/initrd.img-${KERNEL_VER}"
local default_arch_initrd="/boot/initramfs-linux-fallback.img"
local default_suse_initrd="/boot/initrd-${KERNEL_VER}"
2016-11-11 05:45:38 +03:00
if [[ ! "$INITRD" ]]; then
if [[ -e "$default_fedora_initrd" ]]; then
INITRD="$default_fedora_initrd"
elif [[ "$LOOKS_LIKE_DEBIAN" && -e "$default_debian_initrd" ]]; then
INITRD="$default_debian_initrd"
elif [[ "$LOOKS_LIKE_ARCH" && -e "$default_arch_initrd" ]]; then
INITRD="$default_arch_initrd"
2017-07-06 21:30:14 +03:00
elif [[ "$LOOKS_LIKE_SUSE" && -e "$default_suse_initrd" ]]; then
INITRD="$default_suse_initrd"
2016-11-11 05:45:38 +03:00
fi
fi
2019-03-05 18:08:00 +03:00
# If QEMU_SMP was not explicitly set, try to determine the value 'dynamically'
# i.e. use the number of online CPUs on the host machine. If the nproc utility
# is not installed or there's some other error when calling it, fall back
# to the original value (QEMU_SMP=1).
2021-04-16 19:33:44 +03:00
if [[ -z "${QEMU_SMP:=}" ]]; then
2019-03-05 18:08:00 +03:00
if ! QEMU_SMP=$(nproc); then
dwarn "nproc utility is not installed, falling back to QEMU_SMP=1"
QEMU_SMP=1
fi
fi
2013-12-08 03:01:53 +04:00
find_qemu_bin || return 1
2019-12-12 11:37:19 +03:00
# Umount initdir to avoid concurrent access to the filesystem
2021-04-16 19:40:30 +03:00
_umount_dir "$initdir"
local kernel_params=()
local qemu_options=()
local qemu_cmd=("$QEMU_BIN")
2019-12-12 11:37:19 +03:00
2016-11-15 19:38:04 +03:00
if [[ "$UNIFIED_CGROUP_HIERARCHY" = "yes" ]]; then
2021-04-16 19:40:30 +03:00
kernel_params+=("systemd.unified_cgroup_hierarchy=yes")
2016-11-15 19:38:04 +03:00
elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "no" ]]; then
2021-04-16 19:40:30 +03:00
kernel_params+=("systemd.unified_cgroup_hierarchy=no" "systemd.legacy_systemd_cgroup_controller=yes")
2016-11-15 19:38:04 +03:00
elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "hybrid" ]]; then
2021-04-16 19:40:30 +03:00
kernel_params+=("systemd.unified_cgroup_hierarchy=no" "systemd.legacy_systemd_cgroup_controller=no")
2016-11-15 19:38:04 +03:00
elif [[ "$UNIFIED_CGROUP_HIERARCHY" != "default" ]]; then
dfatal "Unknown UNIFIED_CGROUP_HIERARCHY. Got $UNIFIED_CGROUP_HIERARCHY, expected [yes|no|hybrid|default]"
exit 1
fi
2021-07-04 13:21:23 +03:00
if get_bool "$LOOKS_LIKE_SUSE"; then
2021-04-16 19:40:30 +03:00
kernel_params+=("rd.hostonly=0")
scripts: use 4 space indentation
We had all kinds of indentation: 2 sp, 3 sp, 4 sp, 8 sp, and mixed.
4 sp was the most common, in particular the majority of scripts under test/
used that. Let's standarize on 4 sp, because many commandlines are long and
there's a lot of nesting, and with 8sp indentation less stuff fits. 4 sp
also seems to be the default indentation, so this will make it less likely
that people will mess up if they don't load the editor config. (I think people
often use vi, and vi has no support to load project-wide configuration
automatically. We distribute a .vimrc file, but it is not loaded by default,
and even the instructions in it seem to discourage its use for security
reasons.)
Also remove the few vim config lines that were left. We should either have them
on all files, or none.
Also remove some strange stuff like '#!/bin/env bash', yikes.
2019-04-04 15:10:42 +03:00
fi
2017-07-06 21:30:14 +03:00
2021-04-16 19:40:30 +03:00
kernel_params+=(
"root=/dev/sda1"
"rw"
"raid=noautodetect"
"rd.luks=0"
"loglevel=2"
"init=$PATH_TO_INIT"
"console=$CONSOLE"
"SYSTEMD_UNIT_PATH=/usr/lib/systemd/tests/testdata/testsuite-$1.units:/usr/lib/systemd/tests/testdata/units:"
"systemd.unit=testsuite.target"
"systemd.wants=testsuite-$1.service"
)
2021-07-04 13:21:23 +03:00
if ! get_bool "$INTERACTIVE_DEBUG"; then
2021-04-16 19:40:30 +03:00
kernel_params+=("systemd.wants=end.service")
2019-12-09 20:56:13 +03:00
fi
2020-05-17 11:46:34 +03:00
[ -e "$IMAGE_PRIVATE" ] && image="$IMAGE_PRIVATE" || image="$IMAGE_PUBLIC"
2021-04-16 19:40:30 +03:00
qemu_options+=(
-smp "$QEMU_SMP"
-net none
-m "$QEMU_MEM"
-nographic
-kernel "$KERNEL_BIN"
-drive "format=raw,cache=unsafe,file=$image"
)
if [[ -n "${QEMU_OPTIONS:=}" ]]; then
local user_qemu_options
read -ra user_qemu_options <<< "$QEMU_OPTIONS"
qemu_options+=("${user_qemu_options[@]}")
fi
if [[ -n "${KERNEL_APPEND:=}" ]]; then
local user_kernel_append
read -ra user_kernel_append <<< "$KERNEL_APPEND"
kernel_params+=("${user_kernel_append[@]}")
fi
2013-12-08 03:01:53 +04:00
2021-07-04 13:21:23 +03:00
if [[ "$INITRD" ]] && ! get_bool "$SKIP_INITRD"; then
2021-04-16 19:40:30 +03:00
qemu_options+=(-initrd "$INITRD")
2013-12-08 03:01:53 +04:00
fi
2019-09-27 00:29:38 +03:00
# Let's use KVM if possible
2021-07-04 13:21:23 +03:00
if [[ -c /dev/kvm ]] && get_bool $QEMU_KVM; then
2021-04-16 19:40:30 +03:00
qemu_options+=(-machine "accel=kvm" -enable-kvm -cpu host)
2015-11-19 15:17:15 +03:00
fi
2016-02-24 21:22:06 +03:00
if [[ "$QEMU_TIMEOUT" != "infinity" ]]; then
2021-04-16 19:40:30 +03:00
qemu_cmd=(timeout --foreground "$QEMU_TIMEOUT" "$QEMU_BIN")
2016-02-24 21:22:06 +03:00
fi
2021-04-16 19:40:30 +03:00
(set -x; "${qemu_cmd[@]}" "${qemu_options[@]}" -append "${kernel_params[*]}")
2016-06-24 13:11:19 +03:00
rc=$?
2021-07-04 13:21:23 +03:00
if [ "$rc" -eq 124 ] && [ "$QEMU_TIMEOUT" != "infinity" ]; then
derror "Test timed out after ${QEMU_TIMEOUT}s"
2016-06-24 13:11:19 +03:00
TIMED_OUT=1
else
[ "$rc" != 0 ] && derror "QEMU failed with exit code $rc"
fi
return 0
2013-11-06 02:32:56 +04:00
}
2016-06-24 17:23:39 +03:00
# Return 0 if nspawn did run (then you must check the result state/logs for actual
# success), or 1 if nspawn is not available.
2013-11-06 02:32:56 +04:00
run_nspawn() {
2016-06-24 17:23:39 +03:00
[[ -d /run/systemd/system ]] || return 1
2021-04-16 19:40:30 +03:00
rm -f "${initdir:?}"/{testok,failed,skipped}
local nspawn_cmd=()
local nspawn_options=(
"--register=no"
"--kill-signal=SIGKILL"
"--directory=${1:?}"
"--setenv=SYSTEMD_UNIT_PATH=/usr/lib/systemd/tests/testdata/testsuite-$2.units:/usr/lib/systemd/tests/testdata/units:"
)
local kernel_params=(
"$PATH_TO_INIT"
"systemd.unit=testsuite.target"
"systemd.wants=testsuite-$2.service"
2019-12-09 20:56:13 +03:00
)
2021-07-04 13:21:23 +03:00
if ! get_bool "$INTERACTIVE_DEBUG"; then
2021-04-16 19:40:30 +03:00
kernel_params+=("systemd.wants=end.service")
2019-12-09 20:56:13 +03:00
fi
2021-04-16 19:40:30 +03:00
if [[ -n "${NSPAWN_ARGUMENTS:=}" ]]; then
local user_nspawn_arguments
read -ra user_nspawn_arguments <<< "$NSPAWN_ARGUMENTS"
nspawn_options+=("${user_nspawn_arguments[@]}")
fi
if [[ -n "${KERNEL_APPEND:=}" ]]; then
local user_kernel_append
read -ra user_kernel_append <<< "$KERNEL_APPEND"
kernel_params+=("${user_kernel_append[@]}")
2016-04-13 16:57:06 +03:00
fi
2016-06-03 12:17:00 +03:00
2016-11-15 19:38:04 +03:00
if [[ "$UNIFIED_CGROUP_HIERARCHY" = "hybrid" ]]; then
2019-09-27 15:17:41 +03:00
dwarn "nspawn doesn't support SYSTEMD_NSPAWN_UNIFIED_HIERARCHY=hybrid, skipping"
2016-11-15 19:38:04 +03:00
exit
elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "yes" || "$UNIFIED_CGROUP_HIERARCHY" = "no" ]]; then
2021-04-16 19:40:30 +03:00
nspawn_cmd+=(env "SYSTEMD_NSPAWN_UNIFIED_HIERARCHY=$UNIFIED_CGROUP_HIERARCHY")
2016-11-15 19:38:04 +03:00
elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "default" ]]; then
2021-04-16 19:40:30 +03:00
nspawn_cmd+=(env "--unset=UNIFIED_CGROUP_HIERARCHY" "--unset=SYSTEMD_NSPAWN_UNIFIED_HIERARCHY")
2016-11-15 19:38:04 +03:00
else
dfatal "Unknown UNIFIED_CGROUP_HIERARCHY. Got $UNIFIED_CGROUP_HIERARCHY, expected [yes|no|hybrid|default]"
exit 1
fi
2016-06-03 12:17:00 +03:00
2021-04-16 19:40:30 +03:00
if [[ "$NSPAWN_TIMEOUT" != "infinity" ]]; then
nspawn_cmd+=(timeout --foreground "$NSPAWN_TIMEOUT" "$SYSTEMD_NSPAWN")
else
nspawn_cmd+=("$SYSTEMD_NSPAWN")
fi
(set -x; "${nspawn_cmd[@]}" "${nspawn_options[@]}" "${kernel_params[@]}")
2016-06-24 13:11:19 +03:00
rc=$?
2021-07-04 13:21:23 +03:00
if [ "$rc" -eq 124 ] && [ "$NSPAWN_TIMEOUT" != "infinity" ]; then
derror "Test timed out after ${NSPAWN_TIMEOUT}s"
2016-06-24 13:11:19 +03:00
TIMED_OUT=1
else
[ "$rc" != 0 ] && derror "nspawn failed with exit code $rc"
fi
return 0
2013-11-06 02:32:56 +04:00
}
2020-08-28 16:17:31 +03:00
# Build two very minimal root images, with two units, one is the same and one is different across them
install_verity_minimal() {
2021-04-16 19:33:44 +03:00
dinfo "Set up a set of minimal images for verity verification"
if [ -e "$initdir/usr/share/minimal.raw" ]; then
2020-08-28 16:17:31 +03:00
return
fi
if ! command -v mksquashfs >/dev/null 2>&1; then
dfatal "mksquashfs not found"
exit 1
fi
if ! command -v veritysetup >/dev/null 2>&1; then
dfatal "veritysetup not found"
exit 1
fi
2021-04-16 19:33:44 +03:00
# Local modifications of some global variables is intentional in this
# subshell (SC2030)
# shellcheck disable=SC2030
2020-08-28 16:17:31 +03:00
(
BASICTOOLS=(
bash
cat
2021-02-22 15:20:33 +03:00
grep
2020-08-28 16:17:31 +03:00
mount
sleep
)
2021-04-16 19:33:44 +03:00
oldinitdir="$initdir"
rm -rfv "$TESTDIR/minimal"
export initdir="$TESTDIR/minimal"
mkdir -p "$initdir/usr/lib/systemd/system" "$initdir/usr/lib/extension-release.d" "$initdir/etc" "$initdir/var/tmp" "$initdir/opt"
2020-08-28 16:17:31 +03:00
setup_basic_dirs
install_basic_tools
2021-04-16 19:33:44 +03:00
# Shellcheck treats [[ -v VAR ]] as an assignment to avoid a different
# issue, thus falsely triggering SC2030 in this case
# See: koalaman/shellcheck#1409
2021-03-07 00:22:32 +03:00
if [[ -v ASAN_RT_PATH ]]; then
# If we're compiled with ASan, install the ASan RT (and its dependencies)
# into the verity images to get rid of the annoying errors about
# missing $LD_PRELOAD libraries.
inst_libs "$ASAN_RT_PATH"
inst_library "$ASAN_RT_PATH"
fi
2021-04-16 19:33:44 +03:00
cp "$os_release" "$initdir/usr/lib/os-release"
ln -s ../usr/lib/os-release "$initdir/etc/os-release"
touch "$initdir/etc/machine-id" "$initdir/etc/resolv.conf"
touch "$initdir/opt/some_file"
echo MARKER=1 >>"$initdir/usr/lib/os-release"
echo -e "[Service]\nExecStartPre=cat /usr/lib/os-release\nExecStart=sleep 120" >"$initdir/usr/lib/systemd/system/app0.service"
cp "$initdir/usr/lib/systemd/system/app0.service" "$initdir/usr/lib/systemd/system/app0-foo.service"
mksquashfs "$initdir" "$oldinitdir/usr/share/minimal_0.raw"
veritysetup format "$oldinitdir/usr/share/minimal_0.raw" "$oldinitdir/usr/share/minimal_0.verity" | \
grep '^Root hash:' | cut -f2 | tr -d '\n' >"$oldinitdir/usr/share/minimal_0.roothash"
sed -i "s/MARKER=1/MARKER=2/g" "$initdir/usr/lib/os-release"
rm "$initdir/usr/lib/systemd/system/app0-foo.service"
cp "$initdir/usr/lib/systemd/system/app0.service" "$initdir/usr/lib/systemd/system/app0-bar.service"
mksquashfs "$initdir" "$oldinitdir/usr/share/minimal_1.raw"
veritysetup format "$oldinitdir/usr/share/minimal_1.raw" "$oldinitdir/usr/share/minimal_1.verity" | \
grep '^Root hash:' | cut -f2 | tr -d '\n' >"$oldinitdir/usr/share/minimal_1.roothash"
2021-02-22 15:20:33 +03:00
# Rolling distros like Arch do not set VERSION_ID
local version_id=""
2021-04-16 19:33:44 +03:00
if grep -q "^VERSION_ID=" "$os_release"; then
version_id="$(grep "^VERSION_ID=" "$os_release")"
2021-02-22 15:20:33 +03:00
fi
2021-04-16 19:33:44 +03:00
export initdir="$TESTDIR/app0"
mkdir -p "$initdir/usr/lib/extension-release.d" "$initdir/usr/lib/systemd/system" "$initdir/opt"
grep "^ID=" "$os_release" >"$initdir/usr/lib/extension-release.d/extension-release.app0"
echo "${version_id}" >>"$initdir/usr/lib/extension-release.d/extension-release.app0"
cat >"$initdir/usr/lib/systemd/system/app0.service" <<EOF
2021-02-22 15:20:33 +03:00
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/opt/script0.sh
EOF
2021-04-16 19:33:44 +03:00
cat >"$initdir/opt/script0.sh" <<EOF
2021-02-22 15:20:33 +03:00
#!/bin/bash
set -e
test -e /usr/lib/os-release
cat /usr/lib/extension-release.d/extension-release.app0
EOF
2021-04-16 19:33:44 +03:00
chmod +x "$initdir/opt/script0.sh"
echo MARKER=1 >"$initdir/usr/lib/systemd/system/some_file"
mksquashfs "$initdir" "$oldinitdir/usr/share/app0.raw"
export initdir="$TESTDIR/app1"
mkdir -p "$initdir/usr/lib/extension-release.d" "$initdir/usr/lib/systemd/system" "$initdir/opt"
grep "^ID=" "$os_release" >"$initdir/usr/lib/extension-release.d/extension-release.app1"
echo "${version_id}" >>"$initdir/usr/lib/extension-release.d/extension-release.app1"
cat >"$initdir/usr/lib/systemd/system/app1.service" <<EOF
2021-02-22 15:20:33 +03:00
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/opt/script1.sh
EOF
2021-04-16 19:33:44 +03:00
cat >"$initdir/opt/script1.sh" <<EOF
2021-02-22 15:20:33 +03:00
#!/bin/bash
set -e
test -e /usr/lib/os-release
cat /usr/lib/extension-release.d/extension-release.app1
EOF
2021-04-16 19:33:44 +03:00
chmod +x "$initdir/opt/script1.sh"
echo MARKER=1 >"$initdir/usr/lib/systemd/system/other_file"
mksquashfs "$initdir" "$oldinitdir/usr/share/app1.raw"
2020-08-28 16:17:31 +03:00
)
}
2013-11-06 02:32:56 +04:00
setup_basic_environment() {
# create the basic filesystem layout
setup_basic_dirs
install_systemd
install_missing_libraries
install_config_files
2019-12-10 17:31:09 +03:00
install_zoneinfo
2013-11-06 02:32:56 +04:00
create_rc_local
install_basic_tools
install_libnss
install_pam
install_dbus
install_fonts
install_keymaps
install_terminfo
install_execs
2021-04-21 10:58:26 +03:00
install_fs_tools
install_modules
2013-11-06 02:32:56 +04:00
install_plymouth
install_debug_tools
install_ld_so_conf
2020-03-20 21:05:36 +03:00
install_testuser
has_user_dbus_socket && install_user_dbus
2016-01-25 05:45:43 +03:00
setup_selinux
2013-11-06 02:32:56 +04:00
strip_binaries
install_depmod_files
generate_module_dependencies
2021-07-04 13:21:23 +03:00
if get_bool "$IS_BUILT_WITH_ASAN"; then
2019-05-24 23:35:52 +03:00
create_asan_wrapper
2018-07-05 07:09:30 +03:00
fi
2021-07-04 13:21:23 +03:00
if get_bool "$TEST_INSTALL_VERITY_MINIMAL"; then
2020-08-28 16:17:31 +03:00
install_verity_minimal
fi
2013-11-06 02:32:56 +04:00
}
2016-01-25 05:45:43 +03:00
setup_selinux() {
2021-04-16 19:33:44 +03:00
dinfo "Setup SELinux"
2016-01-25 05:45:43 +03:00
# don't forget KERNEL_APPEND='... selinux=1 ...'
2021-07-04 13:21:23 +03:00
if ! get_bool "$SETUP_SELINUX"; then
2021-04-16 19:33:44 +03:00
dinfo "SETUP_SELINUX != yes, skipping SELinux configuration"
2016-01-25 05:45:43 +03:00
return 0
fi
2021-04-16 19:33:44 +03:00
local conf_dir=/etc/selinux
local fixfiles_tools=(bash uname cat sort uniq awk grep egrep head expr find rm secon setfiles)
# Make sure the following statement can't expand to "/" to prevent
# a potential where-are-my-backups situation
rm -rf "${initdir:?}/$conf_dir"
if ! cp -ar "$conf_dir" "$initdir/$conf_dir"; then
dfatal "Failed to copy $conf_dir"
2016-01-25 05:45:43 +03:00
exit 1
fi
2021-04-16 19:33:44 +03:00
touch "$initdir/.autorelabel"
mkdir -p "$initdir/usr/lib/systemd/tests/testdata/units/basic.target.wants"
ln -sf ../autorelabel.service "$initdir/usr/lib/systemd/tests/testdata/units/basic.target.wants/"
2016-01-25 05:45:43 +03:00
2021-04-16 19:33:44 +03:00
dracut_install "${fixfiles_tools[@]}"
2016-01-25 05:45:43 +03:00
dracut_install fixfiles
dracut_install sestatus
}
2016-01-14 11:09:09 +03:00
install_valgrind() {
if ! type -p valgrind; then
dfatal "Failed to install valgrind"
exit 1
fi
2021-04-16 19:33:44 +03:00
local valgrind_bins valgrind_libs valgrind_dbg_and_supp
valgrind_bins="$(strace -e execve valgrind /bin/true 2>&1 >/dev/null | perl -lne 'print $1 if /^execve\("([^"]+)"/')"
dracut_install "$valgrind_bins"
2016-01-14 11:09:09 +03:00
2021-04-16 19:33:44 +03:00
valgrind_libs="$(LD_DEBUG=files valgrind /bin/true 2>&1 >/dev/null | perl -lne 'print $1 if m{calling init: (/.*vgpreload_.*)}')"
dracut_install "$valgrind_libs"
2016-01-14 11:09:09 +03:00
2021-04-16 19:33:44 +03:00
valgrind_dbg_and_supp="$(
2016-01-14 11:09:09 +03:00
strace -e open valgrind /bin/true 2>&1 >/dev/null |
perl -lne 'if (my ($fname) = /^open\("([^"]+).*= (?!-)\d+/) { print $fname if $fname =~ /debug|\.supp$/ }'
2021-04-16 19:33:44 +03:00
)"
dracut_install "$valgrind_dbg_and_supp"
2016-01-14 11:09:09 +03:00
}
2016-01-15 05:52:12 +03:00
create_valgrind_wrapper() {
2021-04-16 19:33:44 +03:00
local valgrind_wrapper="$initdir/$ROOTLIBDIR/systemd-under-valgrind"
ddebug "Create $valgrind_wrapper"
cat >"$valgrind_wrapper" <<EOF
2020-03-04 12:35:06 +03:00
#!/usr/bin/env bash
2016-01-15 05:52:12 +03:00
2016-08-26 18:49:56 +03:00
mount -t proc proc /proc
2016-01-15 05:52:12 +03:00
exec valgrind --leak-check=full --log-file=/valgrind.out $ROOTLIBDIR/systemd "\$@"
EOF
2021-04-16 19:33:44 +03:00
chmod 0755 "$valgrind_wrapper"
2016-01-15 05:52:12 +03:00
}
2018-07-03 06:25:53 +03:00
create_asan_wrapper() {
2021-04-16 19:33:44 +03:00
local asan_wrapper="$initdir/$ROOTLIBDIR/systemd-under-asan"
dinfo "Create ASan wrapper as '$asan_wrapper'"
2019-05-24 23:35:52 +03:00
2021-03-07 00:21:30 +03:00
[[ -z "$ASAN_RT_PATH" ]] && dfatal "ASAN_RT_PATH is empty, but it shouldn't be"
# clang: install llvm-symbolizer to generate useful reports
# See: https://clang.llvm.org/docs/AddressSanitizer.html#symbolizing-the-reports
[[ "$ASAN_COMPILER" == "clang" ]] && dracut_install "llvm-symbolizer"
2019-05-24 23:35:52 +03:00
2021-04-16 19:33:44 +03:00
cat >"$asan_wrapper" <<EOF
2020-03-04 12:35:06 +03:00
#!/usr/bin/env bash
2018-07-03 06:25:53 +03:00
set -x
2021-03-07 00:21:30 +03:00
echo "ASan RT: $ASAN_RT_PATH"
if [[ ! -e "$ASAN_RT_PATH" ]]; then
echo >&2 "Couldn't find ASan RT at '$ASAN_RT_PATH', can't continue"
exit 1
fi
2019-07-08 14:47:46 +03:00
DEFAULT_ASAN_OPTIONS=${ASAN_OPTIONS:-strict_string_checks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1}
DEFAULT_UBSAN_OPTIONS=${UBSAN_OPTIONS:-print_stacktrace=1:print_summary=1:halt_on_error=1}
2019-01-30 05:16:14 +03:00
DEFAULT_ENVIRONMENT="ASAN_OPTIONS=\$DEFAULT_ASAN_OPTIONS UBSAN_OPTIONS=\$DEFAULT_UBSAN_OPTIONS"
2018-07-03 06:25:53 +03:00
2019-05-24 23:35:52 +03:00
# As right now bash is the PID 1, we can't expect PATH to have a sane value.
# Let's make one to prevent unexpected "<bin> not found" issues in the future
export PATH="/sbin:/bin:/usr/sbin:/usr/bin"
2018-07-03 06:25:53 +03:00
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -o remount,rw /
2021-03-07 00:21:30 +03:00
# A lot of services (most notably dbus) won't start without preloading libasan
# See https://github.com/systemd/systemd/issues/5004
DEFAULT_ENVIRONMENT="\$DEFAULT_ENVIRONMENT LD_PRELOAD=$ASAN_RT_PATH"
if [[ "$ASAN_COMPILER" == "clang" ]]; then
2019-05-24 23:35:52 +03:00
# Let's add the ASan DSO's path to the dynamic linker's cache. This is pretty
# unnecessary for gcc & libasan, however, for clang this is crucial, as its
# runtime ASan DSO is in a non-standard (library) path.
2021-04-08 01:09:55 +03:00
echo "${ASAN_RT_PATH%/*}" >/etc/ld.so.conf.d/asan-path-override.conf
2019-05-24 23:35:52 +03:00
ldconfig
2018-07-03 06:25:53 +03:00
fi
echo DefaultEnvironment=\$DEFAULT_ENVIRONMENT >>/etc/systemd/system.conf
2018-12-25 08:13:45 +03:00
echo DefaultTimeoutStartSec=180s >>/etc/systemd/system.conf
2019-05-24 23:35:52 +03:00
echo DefaultStandardOutput=journal+console >>/etc/systemd/system.conf
2018-07-03 06:25:53 +03:00
# ASAN and syscall filters aren't compatible with each other.
find / -name '*.service' -type f | xargs sed -i 's/^\\(MemoryDeny\\|SystemCall\\)/#\\1/'
2018-07-03 22:29:42 +03:00
# The redirection of ASAN reports to a file prevents them from ending up in /dev/null.
# But, apparently, sometimes it doesn't work: https://github.com/google/sanitizers/issues/886.
JOURNALD_CONF_DIR=/etc/systemd/system/systemd-journald.service.d
mkdir -p "\$JOURNALD_CONF_DIR"
2019-05-10 02:00:29 +03:00
printf "[Service]\nEnvironment=ASAN_OPTIONS=\$DEFAULT_ASAN_OPTIONS:log_path=/systemd-journald.asan.log UBSAN_OPTIONS=\$DEFAULT_UBSAN_OPTIONS:log_path=/systemd-journald.ubsan.log\n" >"\$JOURNALD_CONF_DIR/env.conf"
2018-07-03 22:29:42 +03:00
2019-05-10 03:47:03 +03:00
# Sometimes UBSan sends its reports to stderr regardless of what is specified in log_path
# Let's try to catch them by redirecting stderr (and stdout just in case) to a file
# See https://github.com/systemd/systemd/pull/12524#issuecomment-491108821
printf "[Service]\nStandardOutput=file:/systemd-journald.out\n" >"\$JOURNALD_CONF_DIR/out.conf"
2018-12-24 03:15:43 +03:00
# 90s isn't enough for some services to finish when literally everything is run
# under ASan+UBSan in containers, which, in turn, are run in VMs.
2019-01-12 12:48:13 +03:00
# Let's limit which environments such services should be executed in.
2018-12-24 03:15:43 +03:00
mkdir -p /etc/systemd/system/systemd-hwdb-update.service.d
2020-06-28 19:53:28 +03:00
printf "[Unit]\nConditionVirtualization=container\n\n[Service]\nTimeoutSec=240s\n" >/etc/systemd/system/systemd-hwdb-update.service.d/env-override.conf
2018-12-24 03:15:43 +03:00
2019-05-10 19:33:35 +03:00
# Let's override another hard-coded timeout that kicks in too early
mkdir -p /etc/systemd/system/systemd-journal-flush.service.d
printf "[Service]\nTimeoutSec=180s\n" >/etc/systemd/system/systemd-journal-flush.service.d/timeout.conf
2021-03-06 01:20:45 +03:00
# D-Bus has troubles during system shutdown causing it to fail. Although it's
# harmless, it causes unnecessary noise in the logs, so let's disable LSan's
# at_exit check just for the dbus.service
mkdir -p /etc/systemd/system/dbus.service.d
printf "[Service]\nEnvironment=ASAN_OPTIONS=leak_check_at_exit=false\n" >/etc/systemd/system/dbus.service.d/disable-lsan.conf
2021-03-07 00:22:32 +03:00
# Some utilities run via IMPORT/RUN/PROGRAM udev directives fail because
# they're uninstrumented (like dmsetup). Let's add a simple rule which sets
# LD_PRELOAD to the ASan RT library to fix this.
mkdir -p /etc/udev/rules.d
2021-04-08 01:09:55 +03:00
cat >/etc/udev/rules.d/00-set-LD_PRELOAD.rules <<INNER_EOF
2021-03-07 00:22:32 +03:00
SUBSYSTEM=="block", ENV{LD_PRELOAD}="$ASAN_RT_PATH"
INNER_EOF
2021-03-10 14:30:04 +03:00
chmod 0644 /etc/udev/rules.d/00-set-LD_PRELOAD.rules
2021-03-07 00:22:32 +03:00
2019-05-09 20:20:34 +03:00
# The 'mount' utility doesn't behave well under libasan, causing unexpected
# fails during boot and subsequent test results check:
# bash-5.0# mount -o remount,rw -v /
# mount: /dev/sda1 mounted on /.
# bash-5.0# echo \$?
# 1
# Let's workaround this by clearing the previously set LD_PRELOAD env variable,
# so the libasan library is not loaded for this particular service
2020-01-31 09:13:14 +03:00
unset_ld_preload() {
local _dropin_dir="/etc/systemd/system/\$1.service.d"
mkdir -p "\$_dropin_dir"
printf "[Service]\nUnsetEnvironment=LD_PRELOAD\n" >"\$_dropin_dir/unset_ld_preload.conf"
}
unset_ld_preload systemd-remount-fs
2019-12-09 20:56:13 +03:00
unset_ld_preload testsuite-
2019-05-09 20:20:34 +03:00
2018-09-15 17:21:33 +03:00
export ASAN_OPTIONS=\$DEFAULT_ASAN_OPTIONS:log_path=/systemd.asan.log UBSAN_OPTIONS=\$DEFAULT_UBSAN_OPTIONS
2021-04-16 19:33:44 +03:00
exec "$ROOTLIBDIR/systemd" "\$@"
2018-07-03 06:25:53 +03:00
EOF
2021-04-16 19:33:44 +03:00
chmod 0755 "$asan_wrapper"
2018-07-03 06:25:53 +03:00
}
2016-03-04 04:55:46 +03:00
create_strace_wrapper() {
2021-04-16 19:33:44 +03:00
local strace_wrapper="$initdir/$ROOTLIBDIR/systemd-under-strace"
ddebug "Create $strace_wrapper"
cat >"$strace_wrapper" <<EOF
2020-03-04 12:35:06 +03:00
#!/usr/bin/env bash
2016-03-04 04:55:46 +03:00
2021-04-16 19:33:44 +03:00
exec strace -f -D -o /strace.out "$ROOTLIBDIR/systemd" "\$@"
2016-03-04 04:55:46 +03:00
EOF
2021-04-16 19:33:44 +03:00
chmod 0755 "$strace_wrapper"
2016-03-04 04:55:46 +03:00
}
2021-04-21 10:58:26 +03:00
install_fs_tools() {
2021-04-16 19:33:44 +03:00
dinfo "Install fsck"
2016-01-16 11:06:59 +03:00
dracut_install /sbin/fsck*
dracut_install -o /bin/fsck*
2016-04-04 14:07:56 +03:00
# fskc.reiserfs calls reiserfsck. so, install it
dracut_install -o reiserfsck
2021-04-21 10:58:26 +03:00
# we use mkfs in system-repart tests
dracut_install /sbin/mkfs.ext4
dracut_install /sbin/mkfs.vfat
}
install_modules() {
dinfo "Install modules"
instmods loop
instmods vfat
2021-06-18 18:10:30 +03:00
instmods nls_ascii =nls
2021-06-11 09:42:04 +03:00
instmods dummy
2021-04-21 10:58:26 +03:00
2021-07-04 13:21:23 +03:00
if get_bool "$LOOKS_LIKE_SUSE"; then
2021-04-21 10:58:26 +03:00
instmods ext4
fi
2016-01-16 11:06:59 +03:00
}
2013-11-06 02:32:56 +04:00
install_dmevent() {
instmods dm_crypt =crypto
2019-07-14 06:03:26 +03:00
inst_binary dmeventd
2021-07-04 13:21:23 +03:00
if get_bool "$LOOKS_LIKE_DEBIAN"; then
2016-01-17 06:32:37 +03:00
# dmsetup installs 55-dm and 60-persistent-storage-dm on Debian/Ubuntu
2018-02-14 23:34:55 +03:00
# and since buster/bionic 95-dm-notify.rules
# see https://gitlab.com/debian-lvm/lvm2/blob/master/debian/patches/udev.patch
inst_rules 55-dm.rules 60-persistent-storage-dm.rules 95-dm-notify.rules
2016-01-17 06:32:37 +03:00
else
inst_rules 10-dm.rules 13-dm-disk.rules 95-dm-notify.rules
fi
2021-07-04 13:21:23 +03:00
if get_bool "$LOOKS_LIKE_SUSE"; then
2020-07-21 23:14:53 +03:00
inst_rules 60-persistent-storage.rules 61-persistent-storage-compat.rules 99-systemd.rules
fi
2013-11-06 02:32:56 +04:00
}
2020-11-18 01:20:22 +03:00
install_compiled_systemd() {
2021-04-16 19:33:44 +03:00
dinfo "Install compiled systemd"
2020-08-27 14:10:30 +03:00
2021-04-16 19:33:44 +03:00
local ninja_bin
ninja_bin="$(type -P ninja || type -P ninja-build)"
if [[ -z "$ninja_bin" ]]; then
2017-08-07 12:06:07 +03:00
dfatal "ninja was not found"
exit 1
fi
2021-04-16 19:33:44 +03:00
(set -x; DESTDIR="$initdir" "$ninja_bin" -C "$BUILD_DIR" install)
2020-11-18 01:20:22 +03:00
}
install_debian_systemd() {
2021-04-16 19:33:44 +03:00
dinfo "Install debian systemd"
2020-11-18 01:20:22 +03:00
2021-04-16 19:36:27 +03:00
local files
while read -r deb; do
files="$(dpkg-query -L "$deb" 2>/dev/null)" || continue
2020-11-18 01:20:22 +03:00
ddebug "Install debian files from package $deb"
2021-04-16 19:36:27 +03:00
for file in $files; do
2020-11-18 01:20:22 +03:00
[ -e "$file" ] || continue
[ -d "$file" ] && continue
2021-04-16 19:36:27 +03:00
inst "$file"
2020-11-18 01:20:22 +03:00
done
2021-04-16 19:36:27 +03:00
done < <(grep -E '^Package:' "${SOURCE_DIR}/debian/control" | cut -d ':' -f 2)
2020-11-18 01:20:22 +03:00
}
install_distro_systemd() {
2021-04-16 19:33:44 +03:00
dinfo "Install distro systemd"
2020-11-18 01:20:22 +03:00
2021-07-04 13:21:23 +03:00
if get_bool "$LOOKS_LIKE_DEBIAN"; then
2020-11-18 01:20:22 +03:00
install_debian_systemd
else
dfatal "NO_BUILD not supported for this distro"
exit 1
fi
}
install_systemd() {
2021-04-16 19:33:44 +03:00
dinfo "Install systemd"
2021-07-04 13:21:23 +03:00
if get_bool "$NO_BUILD"; then
2020-11-18 01:20:22 +03:00
install_distro_systemd
else
install_compiled_systemd
fi
2013-11-06 02:32:56 +04:00
# remove unneeded documentation
2021-04-16 19:33:44 +03:00
rm -fr "$initdir"/usr/share/{man,doc}
2016-04-25 21:20:57 +03:00
2021-07-04 13:21:23 +03:00
get_bool "$LOOKS_LIKE_SUSE" && setup_suse
2017-07-06 21:30:14 +03:00
2016-04-25 21:20:57 +03:00
# enable debug logging in PID1
2021-04-16 19:33:44 +03:00
echo LogLevel=debug >>"$initdir/etc/systemd/system.conf"
2019-08-13 01:14:54 +03:00
# store coredumps in journal
2021-04-16 19:33:44 +03:00
echo Storage=journal >>"$initdir/etc/systemd/coredump.conf"
2013-11-06 02:32:56 +04:00
}
2016-07-03 18:17:13 +03:00
get_ldpath() {
2021-04-16 19:33:44 +03:00
local rpath
rpath="$(objdump -p "${1:?}" 2>/dev/null | awk "/R(UN)?PATH/ { print \"$initdir\" \$2 }" | paste -sd :)"
2019-11-27 20:25:52 +03:00
if [ -z "$rpath" ] ; then
2021-04-16 19:33:44 +03:00
echo "$BUILD_DIR"
2019-11-27 20:25:52 +03:00
else
2021-04-16 19:33:44 +03:00
echo "$rpath"
2019-11-27 20:25:52 +03:00
fi
2016-07-03 18:17:13 +03:00
}
2013-11-06 02:32:56 +04:00
install_missing_libraries() {
2021-04-16 19:33:44 +03:00
dinfo "Install missing libraries"
2013-11-06 02:32:56 +04:00
# install possible missing libraries
2021-04-16 19:33:44 +03:00
for i in "${initdir:?}"{,/usr}/{sbin,bin}/* "$initdir"{,/usr}/lib/systemd/{,tests/{,manual/,unsafe/}}*; do
LD_LIBRARY_PATH="${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$(get_ldpath "$i")" inst_libs "$i"
2013-11-06 02:32:56 +04:00
done
2020-12-09 12:15:36 +03:00
2021-04-16 19:33:44 +03:00
local lib path
2020-12-09 12:15:36 +03:00
# A number of dependencies is now optional via dlopen, so the install
# script will not pick them up, since it looks at linkage.
2021-05-23 15:04:53 +03:00
for lib in libcryptsetup libidn libidn2 pwquality libqrencode tss2-esys tss2-rc tss2-mu libfido2 libbpf; do
2021-01-14 19:48:13 +03:00
ddebug "Searching for $lib via pkg-config"
2021-04-16 19:33:44 +03:00
if pkg-config --exists "$lib"; then
path="$(pkg-config --variable=libdir "$lib")"
2021-01-14 19:48:13 +03:00
if [ -z "${path}" ]; then
ddebug "$lib.pc does not contain a libdir variable, skipping"
continue
fi
if ! [[ ${lib} =~ ^lib ]]; then
lib="lib${lib}"
fi
# Some pkg-config files are broken and give out the wrong paths
# (eg: libcryptsetup), so just ignore them
inst_libs "${path}/${lib}.so" || true
inst_library "${path}/${lib}.so" || true
else
ddebug "$lib.pc not found, skipping"
continue
fi
2020-12-09 12:15:36 +03:00
done
2013-11-06 02:32:56 +04:00
}
2020-03-20 22:17:11 +03:00
cleanup_loopdev() {
2021-04-16 19:33:44 +03:00
if [ -n "${LOOPDEV:=}" ]; then
2020-03-20 22:17:11 +03:00
ddebug "losetup -d $LOOPDEV"
losetup -d "${LOOPDEV}"
2020-05-25 23:48:01 +03:00
unset LOOPDEV
2020-03-20 22:17:11 +03:00
fi
}
2020-03-31 12:46:00 +03:00
trap cleanup_loopdev EXIT INT QUIT PIPE
2020-03-20 22:17:11 +03:00
2013-11-06 02:32:56 +04:00
create_empty_image() {
2021-04-16 19:33:44 +03:00
if [ -z "${IMAGE_NAME:=}" ]; then
2019-12-12 11:37:19 +03:00
echo "create_empty_image: \$IMAGE_NAME not set"
exit 1
fi
2021-04-16 19:33:44 +03:00
local size=500
2021-07-04 13:21:23 +03:00
if ! get_bool "$NO_BUILD"; then
2021-06-16 23:50:23 +03:00
if meson configure "${BUILD_DIR:?}" | grep 'static-lib\|standalone-binaries' | awk '{ print $2 }' | grep -q 'true'; then
size=$((size+=200))
fi
if meson configure "${BUILD_DIR:?}" | grep 'link-.*-shared' | awk '{ print $2 }' | grep -q 'false'; then
size=$((size+=200))
fi
2021-05-06 07:28:19 +03:00
fi
2021-07-04 13:21:23 +03:00
if ! get_bool "$STRIP_BINARIES"; then
2021-04-16 19:33:44 +03:00
size=$((4 * size))
2018-06-30 08:19:01 +03:00
fi
2019-12-10 19:33:58 +03:00
2021-04-16 19:33:44 +03:00
echo "Setting up ${IMAGE_PUBLIC:?} (${size} MB)"
rm -f "${IMAGE_PRIVATE:?}" "$IMAGE_PUBLIC"
2019-12-13 16:21:31 +03:00
2013-11-06 02:32:56 +04:00
# Create the blank file to use as a root filesystem
2021-04-16 19:33:44 +03:00
truncate -s "${size}M" "$IMAGE_PUBLIC"
2019-12-13 16:21:31 +03:00
2020-05-17 11:46:34 +03:00
LOOPDEV=$(losetup --show -P -f "$IMAGE_PUBLIC")
2013-12-10 16:39:42 +04:00
[ -b "$LOOPDEV" ] || return 1
2015-02-03 12:44:27 +03:00
sfdisk "$LOOPDEV" <<EOF
2021-04-16 19:33:44 +03:00
,$((size - 50))M
2013-11-06 02:32:56 +04:00
,
EOF
2018-03-29 07:20:57 +03:00
udevadm settle
2021-04-16 19:33:44 +03:00
local label=(-L systemd)
2016-04-04 14:07:56 +03:00
# mkfs.reiserfs doesn't know -L. so, use --label instead
2021-04-16 19:33:44 +03:00
[[ "$FSTYPE" == "reiserfs" ]] && label=(--label systemd)
if ! mkfs -t "${FSTYPE}" "${label[@]}" "${LOOPDEV}p1" -q; then
2016-04-04 14:07:56 +03:00
dfatal "Failed to mkfs -t ${FSTYPE}"
exit 1
fi
2013-11-06 02:32:56 +04:00
}
2019-12-12 11:37:19 +03:00
mount_initdir() {
2021-04-16 19:33:44 +03:00
if [ -z "${LOOPDEV:=}" ]; then
[ -e "${IMAGE_PRIVATE:?}" ] && image="$IMAGE_PRIVATE" || image="${IMAGE_PUBLIC:?}"
LOOPDEV="$(losetup --show -P -f "$image")"
2019-12-12 11:37:19 +03:00
[ -b "$LOOPDEV" ] || return 1
2020-03-20 22:17:11 +03:00
udevadm settle
fi
2019-07-12 18:47:26 +03:00
2021-04-16 19:33:44 +03:00
if ! mountpoint -q "${initdir:?}"; then
mkdir -p "$initdir"
mount "${LOOPDEV}p1" "$initdir"
2020-03-20 22:17:11 +03:00
TEST_SETUP_CLEANUP_ROOTDIR=1
2019-12-12 11:37:19 +03:00
fi
}
2019-12-13 16:21:31 +03:00
cleanup_initdir() {
# only umount if create_empty_image_rootdir() was called to mount it
2021-07-04 13:21:23 +03:00
get_bool "$TEST_SETUP_CLEANUP_ROOTDIR" && _umount_dir "${initdir:?}"
2019-12-13 16:21:31 +03:00
}
umount_loopback() {
# unmount the loopback device from all places. Otherwise we risk file
# system corruption.
2021-04-16 19:33:44 +03:00
for device in $(losetup -l | awk '$6=="'"${IMAGE_PUBLIC:?}"'" {print $1}'); do
2019-12-13 16:21:31 +03:00
ddebug "Unmounting all uses of $device"
mount | awk '/^'"${device}"'p/{print $1}' | xargs --no-run-if-empty umount -v
done
}
2019-12-12 11:37:19 +03:00
create_empty_image_rootdir() {
create_empty_image
mount_initdir
}
2018-12-25 10:31:50 +03:00
check_asan_reports() {
local ret=0
2021-04-16 19:33:44 +03:00
local root="${1:?}"
2018-12-25 10:31:50 +03:00
2021-07-04 13:21:23 +03:00
if get_bool "$IS_BUILT_WITH_ASAN"; then
2018-12-25 10:31:50 +03:00
ls -l "$root"
if [[ -e "$root/systemd.asan.log.1" ]]; then
cat "$root/systemd.asan.log.1"
2021-04-16 19:33:44 +03:00
ret=$((ret+1))
2018-12-23 16:46:00 +03:00
fi
2018-12-23 17:30:41 +03:00
2021-04-16 19:33:44 +03:00
journald_report="$(find "$root" -name "systemd-journald.*san.log*" -exec cat {} \;)"
if [[ -n "$journald_report" ]]; then
2019-05-10 03:47:03 +03:00
printf "%s\n" "$journald_report"
2019-07-19 03:34:57 +03:00
cat "$root/systemd-journald.out" || :
2021-04-16 19:33:44 +03:00
ret=$((ret+1))
2019-01-30 04:19:45 +03:00
fi
2018-12-23 17:48:18 +03:00
2021-04-16 19:33:44 +03:00
pids="$(
2019-08-13 14:52:57 +03:00
"$JOURNALCTL" -D "$root/var/log/journal" | perl -alne '
2019-01-30 04:19:45 +03:00
BEGIN {
%services_to_ignore = (
"dbus-daemon" => undef,
);
}
2019-03-16 17:49:43 +03:00
print $2 if /\s(\S*)\[(\d+)\]:\s*SUMMARY:\s+\w+Sanitizer/ && !exists $services_to_ignore{$1}'
2021-04-16 19:33:44 +03:00
)"
if [[ -n "$pids" ]]; then
ret=$((ret+1))
2018-12-23 17:48:18 +03:00
for pid in $pids; do
2021-04-16 19:33:44 +03:00
"$JOURNALCTL" -D "$root/var/log/journal" _PID="$pid" --no-pager
2018-12-23 17:48:18 +03:00
done
2019-01-30 04:19:45 +03:00
fi
2018-12-23 16:46:00 +03:00
fi
2013-11-06 02:32:56 +04:00
return $ret
}
2020-03-30 17:39:31 +03:00
save_journal() {
2021-07-02 17:38:14 +03:00
# Default to always saving journal
local save="yes"
if [ "${TEST_SAVE_JOURNAL}" = "no" ]; then
save="no"
elif [ "${TEST_SAVE_JOURNAL}" = "fail" ] && [ "$2" = "0" ]; then
save="no"
fi
2020-03-30 22:29:52 +03:00
if [ -n "${ARTIFACT_DIRECTORY}" ]; then
2021-04-16 19:33:44 +03:00
dest="${ARTIFACT_DIRECTORY}/${testname:?}.journal"
2020-03-30 22:29:52 +03:00
else
2021-04-16 19:33:44 +03:00
dest="${TESTDIR:?}/system.journal"
2020-03-30 22:29:52 +03:00
fi
2020-03-30 17:39:31 +03:00
2021-04-16 19:33:44 +03:00
for j in "${1:?}"/*; do
2021-07-04 13:21:23 +03:00
if get_bool "$save"; then
2021-07-02 17:38:14 +03:00
"$SYSTEMD_JOURNAL_REMOTE" -o "$dest" --getter="$JOURNALCTL -o export -D $j"
fi
2020-03-30 22:45:21 +03:00
if [ -n "${TEST_SHOW_JOURNAL}" ]; then
echo "---- $j ----"
2021-04-16 19:33:44 +03:00
"$JOURNALCTL" --no-pager -o short-monotonic --no-hostname --priority="${TEST_SHOW_JOURNAL}" -D "$j"
2020-03-30 22:45:21 +03:00
fi
2021-04-16 19:33:44 +03:00
rm -r "$j"
2020-03-30 22:29:52 +03:00
done
2020-03-30 17:39:31 +03:00
2021-07-04 13:21:23 +03:00
if ! get_bool "$save"; then
2021-07-02 17:38:14 +03:00
return 0
fi
2021-05-06 09:47:01 +03:00
if [ -n "${SUDO_USER}" ]; then
setfacl -m "user:${SUDO_USER:?}:r-X" "$dest"*
fi
2020-03-30 17:39:31 +03:00
# we want to print this sometime later, so save this in a variable
2021-04-16 19:33:44 +03:00
JOURNAL_LIST="$(ls -l "$dest"*)"
2020-03-30 17:39:31 +03:00
}
2021-04-23 11:55:49 +03:00
check_result_common() {
2021-04-16 19:33:44 +03:00
local workspace="${1:?}"
2021-04-23 11:55:49 +03:00
local ret
if [ -s "$workspace/failed" ]; then
2021-04-29 10:13:12 +03:00
# Non-empty …/failed has highest priority
2021-04-23 11:55:49 +03:00
cp -a "$workspace/failed" "${TESTDIR:?}/"
2021-05-06 09:47:01 +03:00
if [ -n "${SUDO_USER}" ]; then
setfacl -m "user:${SUDO_USER:?}:r-X" "${TESTDIR:?}/"failed
fi
2021-04-23 11:55:49 +03:00
ret=1
elif [ -e "$workspace/testok" ]; then
# …/testok always counts (but with lower priority than …/failed)
ret=0
elif [ -e "$workspace/skipped" ]; then
# …/skipped always counts (a message is expected)
echo "${TESTNAME:?} was skipped:"
cat "$workspace/skipped"
ret=0
2021-07-04 13:21:23 +03:00
elif get_bool "$TIMED_OUT"; then
2021-04-29 10:13:12 +03:00
echo "(timeout)" >"${TESTDIR:?}/failed"
2021-04-23 11:55:49 +03:00
ret=2
else
2021-04-29 10:13:12 +03:00
echo "(failed; see logs)" >"${TESTDIR:?}/failed"
ret=3
2021-04-23 11:55:49 +03:00
fi
2021-04-29 10:13:12 +03:00
check_asan_reports "$workspace" || ret=4
2021-04-23 11:55:49 +03:00
2021-07-02 17:38:14 +03:00
save_journal "$workspace/var/log/journal" $ret
2021-04-16 19:33:44 +03:00
if [ -d "${ARTIFACT_DIRECTORY}" ] && [ -f "$workspace/strace.out" ]; then
cp "$workspace/strace.out" "${ARTIFACT_DIRECTORY}/"
fi
2021-04-23 11:55:49 +03:00
2021-04-29 10:13:12 +03:00
if [ ${ret:?} != 0 ] && [ -f "$TESTDIR/failed" ]; then
echo -n "${TESTNAME:?}: "
cat "$TESTDIR/failed"
fi
2021-04-23 11:55:49 +03:00
echo "${JOURNAL_LIST:-"No journals were saved"}"
2021-04-29 10:13:12 +03:00
return ${ret:?}
2021-04-23 11:55:49 +03:00
}
check_result_nspawn() {
local workspace="${1:?}"
local ret
check_result_common "${workspace}"
ret=$?
2021-04-26 20:22:42 +03:00
# Run additional test-specific checks if defined by check_result_nspawn_hook()
if declare -F check_result_nspawn_hook >/dev/null; then
if ! check_result_nspawn_hook; then
derror "check_result_nspawn_hook() returned with EC > 0"
ret=4
fi
fi
2021-04-16 19:33:44 +03:00
_umount_dir "${initdir:?}"
2021-04-23 11:55:49 +03:00
2018-12-25 10:31:50 +03:00
return $ret
}
2017-08-04 15:34:14 +03:00
# can be overridden in specific test
check_result_qemu() {
2021-04-23 11:55:49 +03:00
local ret
2019-12-12 11:37:19 +03:00
mount_initdir
2021-04-23 11:55:49 +03:00
check_result_common "${initdir:?}"
ret=$?
_umount_dir "${initdir:?}"
2021-04-26 20:22:42 +03:00
# Run additional test-specific checks if defined by check_result_qemu_hook()
if declare -F check_result_qemu_hook >/dev/null; then
if ! check_result_qemu_hook; then
derror "check_result_qemu_hook() returned with EC > 0"
ret=4
fi
fi
2017-08-04 15:34:14 +03:00
return $ret
}
2021-06-21 22:05:47 +03:00
check_result_nspawn_unittests() {
local workspace="${1:?}"
local ret=1
[[ -e "$workspace/testok" ]] && ret=0
if [[ -s "$workspace/failed" ]]; then
ret=$((ret + 1))
echo "=== Failed test log ==="
cat "$workspace/failed"
else
if [[ -s "$workspace/skipped" ]]; then
echo "=== Skipped test log =="
cat "$workspace/skipped"
# We might have only skipped tests - that should not fail the job
ret=0
fi
if [[ -s "$workspace/testok" ]]; then
echo "=== Passed tests ==="
cat "$workspace/testok"
fi
fi
2021-07-04 13:21:23 +03:00
get_bool "${TIMED_OUT:=}" && ret=1
2021-07-02 17:38:14 +03:00
save_journal "$workspace/var/log/journal" $ret
2021-06-21 22:05:47 +03:00
_umount_dir "${initdir:?}"
return $ret
}
check_result_qemu_unittests() {
local ret=1
mount_initdir
[[ -e "${initdir:?}/testok" ]] && ret=0
if [[ -s "$initdir/failed" ]]; then
ret=$((ret + 1))
echo "=== Failed test log ==="
cat "$initdir/failed"
else
if [[ -s "$initdir/skipped" ]]; then
echo "=== Skipped test log =="
cat "$initdir/skipped"
# We might have only skipped tests - that should not fail the job
ret=0
fi
if [[ -s "$initdir/testok" ]]; then
echo "=== Passed tests ==="
cat "$initdir/testok"
fi
fi
2021-07-04 13:21:23 +03:00
get_bool "${TIMED_OUT:=}" && ret=1
2021-07-02 17:38:14 +03:00
save_journal "$initdir/var/log/journal" $ret
2021-06-21 22:05:47 +03:00
_umount_dir "$initdir"
return $ret
}
2013-11-06 02:32:56 +04:00
strip_binaries() {
2021-04-16 19:33:44 +03:00
dinfo "Strip binaries"
2021-07-04 13:21:23 +03:00
if ! get_bool "$STRIP_BINARIES"; then
2021-04-16 19:33:44 +03:00
dinfo "STRIP_BINARIES == no, keeping binaries unstripped"
2016-01-18 09:45:20 +03:00
return 0
fi
2021-04-16 19:33:44 +03:00
while read -r bin; do
strip --strip-unneeded "$bin" |& grep -vi 'file format not recognized' | ddebug || :
done < <(find "${initdir:?}" -executable -not -path '*/lib/modules/*.ko' -type f)
2013-11-06 02:32:56 +04:00
}
create_rc_local() {
2021-04-16 19:33:44 +03:00
dinfo "Create rc.local"
mkdir -p "${initdir:?}/etc/rc.d"
cat >"$initdir/etc/rc.d/rc.local" <<EOF
2020-03-04 12:35:06 +03:00
#!/usr/bin/env bash
2013-11-06 02:32:56 +04:00
exit 0
EOF
2021-04-16 19:33:44 +03:00
chmod 0755 "$initdir/etc/rc.d/rc.local"
2013-11-06 02:32:56 +04:00
}
install_execs() {
2021-04-16 19:33:44 +03:00
ddebug "Install executables from the service files"
local pkg_config_path="${BUILD_DIR:?}/src/core/"
local systemunitdir userunitdir exe
systemunitdir="$(PKG_CONFIG_PATH="$pkg_config_path" pkg-config --variable=systemdsystemunitdir systemd)"
userunitdir="$(PKG_CONFIG_PATH="$pkg_config_path" pkg-config --variable=systemduserunitdir systemd)"
while read -r exe; do
# some {rc,halt}.local scripts and programs are okay to not exist, the rest should
# also, plymouth is pulled in by rescue.service, but even there the exit code
# is ignored; as it's not present on some distros, don't fail if it doesn't exist
dinfo "Attempting to install $exe (based on unit file reference)"
inst "$exe" || [ "${exe%.local}" != "$exe" ] || [ "${exe%systemd-update-done}" != "$exe" ] || [ "${exe##*/}" == "plymouth" ]
done < <(sed -r -n 's|^Exec[a-zA-Z]*=[@+!-]*([^ ]+).*|\1|gp' "${initdir:?}"/{"$systemunitdir","$userunitdir"}/*.service | sort -u)
2013-11-06 02:32:56 +04:00
}
generate_module_dependencies() {
2021-04-16 19:33:44 +03:00
dinfo "Generate modules dependencies"
if [[ -d "${initdir:?}/lib/modules/${KERNEL_VER:?}" ]] && \
! depmod -a -b "$initdir" "$KERNEL_VER"; then
2013-11-06 02:32:56 +04:00
dfatal "\"depmod -a $KERNEL_VER\" failed."
exit 1
fi
}
install_depmod_files() {
2021-04-16 19:33:44 +03:00
dinfo "Install depmod files"
inst "/lib/modules/${KERNEL_VER:?}/modules.order"
inst "/lib/modules/$KERNEL_VER/modules.builtin"
2013-11-06 02:32:56 +04:00
}
install_plymouth() {
2021-04-16 19:33:44 +03:00
dinfo "Install plymouth"
2013-11-06 02:32:56 +04:00
# install plymouth, if found... else remove plymouth service files
# if [ -x /usr/libexec/plymouth/plymouth-populate-initrd ]; then
# PLYMOUTH_POPULATE_SOURCE_FUNCTIONS="$TEST_BASE_DIR/test-functions" \
# /usr/libexec/plymouth/plymouth-populate-initrd -t $initdir
# dracut_install plymouth plymouthd
# else
2021-04-16 19:33:44 +03:00
rm -f "${initdir:?}"/{usr/lib,lib,etc}/systemd/system/plymouth* "$initdir"/{usr/lib,lib,etc}/systemd/system/*/plymouth*
2013-11-06 02:32:56 +04:00
# fi
}
install_ld_so_conf() {
2021-04-16 19:33:44 +03:00
dinfo "Install /etc/ld.so.conf*"
cp -a /etc/ld.so.conf* "${initdir:?}/etc"
2013-11-06 02:32:56 +04:00
ldconfig -r "$initdir"
}
2020-03-20 21:05:36 +03:00
install_testuser() {
2021-04-16 19:33:44 +03:00
dinfo "Set up a test user"
2020-03-20 21:05:36 +03:00
# create unprivileged user for user manager tests
2021-04-16 19:33:44 +03:00
mkdir -p "${initdir:?}/etc/sysusers.d"
cat >"$initdir/etc/sysusers.d/testuser.conf" <<EOF
2020-03-20 21:05:36 +03:00
u testuser 4711 "Test User" /home/testuser
EOF
2021-04-16 19:33:44 +03:00
mkdir -p "$initdir/home/testuser"
chmod 0700 "$initdir/home/testuser"
chown 4711:4711 "$initdir/home/testuser"
2020-03-20 21:05:36 +03:00
}
2013-11-06 02:32:56 +04:00
install_config_files() {
2021-04-16 19:33:44 +03:00
dinfo "Install config files"
2019-07-19 03:34:57 +03:00
inst /etc/sysconfig/init || :
2013-11-06 02:32:56 +04:00
inst /etc/passwd
inst /etc/shadow
2020-07-21 23:14:53 +03:00
inst_any /etc/login.defs /usr/etc/login.defs
2013-11-06 02:32:56 +04:00
inst /etc/group
inst /etc/shells
2020-06-23 08:42:15 +03:00
inst_any /etc/nsswitch.conf /usr/etc/nsswitch.conf
2019-07-19 03:34:57 +03:00
inst /etc/pam.conf || :
2020-08-27 12:59:45 +03:00
inst_any /etc/os-release /usr/lib/os-release
2013-11-06 02:32:56 +04:00
inst /etc/localtime
# we want an empty environment
2021-04-16 19:33:44 +03:00
: >"${initdir:?}/etc/environment"
: >"$initdir/etc/machine-id"
: >"$initdir/etc/resolv.conf"
2019-12-10 15:45:48 +03:00
2013-11-06 02:32:56 +04:00
# set the hostname
2021-05-04 14:54:33 +03:00
echo 'H' >"$initdir/etc/hostname"
2020-03-25 15:43:20 +03:00
# let's set up just one image with the traditional verbose output
2021-04-16 19:33:44 +03:00
if [ "${IMAGE_NAME:?}" != "basic" ]; then
mkdir -p "$initdir/etc/systemd/system.conf.d"
echo -e '[Manager]\nStatusUnitFormat=name' >"$initdir/etc/systemd/system.conf.d/status.conf"
2020-03-25 15:43:20 +03:00
fi
2013-11-06 02:32:56 +04:00
}
install_basic_tools() {
2021-04-16 19:33:44 +03:00
dinfo "Install basic tools"
2019-12-09 22:35:51 +03:00
dracut_install "${BASICTOOLS[@]}"
2015-02-02 02:19:28 +03:00
dracut_install -o sushell
2015-02-02 02:19:33 +03:00
# in Debian ldconfig is just a shell script wrapper around ldconfig.real
dracut_install -o ldconfig.real
2013-11-06 02:32:56 +04:00
}
install_debug_tools() {
2021-04-16 19:33:44 +03:00
dinfo "Install debug tools"
2019-12-09 22:35:51 +03:00
dracut_install "${DEBUGTOOLS[@]}"
2019-03-16 19:46:08 +03:00
2021-07-04 13:21:23 +03:00
if get_bool "$INTERACTIVE_DEBUG"; then
2019-03-16 19:46:08 +03:00
# Set default TERM from vt220 to linux, so at least basic key shortcuts work
2021-04-16 19:33:44 +03:00
local getty_override="${initdir:?}/etc/systemd/system/serial-getty@.service.d"
mkdir -p "$getty_override"
echo -e "[Service]\nEnvironment=TERM=linux" >"$getty_override/default-TERM.conf"
2019-03-16 19:46:08 +03:00
2021-04-08 01:09:55 +03:00
cat >"$initdir/etc/motd" <<EOF
2019-03-16 19:46:08 +03:00
To adjust the terminal size use:
export COLUMNS=xx
export LINES=yy
or
stty cols xx rows yy
EOF
fi
2013-11-06 02:32:56 +04:00
}
install_libnss() {
2021-04-16 19:33:44 +03:00
dinfo "Install libnss"
2013-11-06 02:32:56 +04:00
# install libnss_files for login
2021-04-16 19:40:30 +03:00
local NSS_LIBS
mapfile -t NSS_LIBS < <(LD_DEBUG=files getent passwd 2>&1 >/dev/null | sed -n '/calling init: .*libnss_/ {s!^.* /!/!; p}')
dracut_install "${NSS_LIBS[@]}"
2013-11-06 02:32:56 +04:00
}
install_dbus() {
2021-04-16 19:33:44 +03:00
dinfo "Install dbus"
inst "${ROOTLIBDIR:?}/system/dbus.socket"
2018-11-11 14:13:48 +03:00
2019-11-13 21:32:24 +03:00
# Newer Fedora versions use dbus-broker by default. Let's install it if it's available.
2021-04-16 19:33:44 +03:00
if [ -f "$ROOTLIBDIR/system/dbus-broker.service" ]; then
inst "$ROOTLIBDIR/system/dbus-broker.service"
2019-04-29 17:09:36 +03:00
inst_symlink /etc/systemd/system/dbus.service
inst /usr/bin/dbus-broker
inst /usr/bin/dbus-broker-launch
2021-04-16 19:33:44 +03:00
elif [ -f "$ROOTLIBDIR/system/dbus-daemon.service" ]; then
2019-04-29 17:09:36 +03:00
# Fedora rawhide replaced dbus.service with dbus-daemon.service
2021-04-16 19:33:44 +03:00
inst "$ROOTLIBDIR/system/dbus-daemon.service"
2018-11-11 14:13:48 +03:00
# Alias symlink
inst_symlink /etc/systemd/system/dbus.service
else
2021-04-16 19:33:44 +03:00
inst "$ROOTLIBDIR/system/dbus.service"
2018-11-11 14:13:48 +03:00
fi
2013-11-06 02:32:56 +04:00
2021-04-16 19:36:27 +03:00
while read -r file; do
inst "$file"
done < <(find /etc/dbus-1 /usr/share/dbus-1 -xtype f 2>/dev/null)
2019-12-10 13:49:39 +03:00
# setup policy for Type=dbus test
2021-04-16 19:33:44 +03:00
mkdir -p "${initdir:?}/etc/dbus-1/system.d"
cat >"$initdir/etc/dbus-1/system.d/systemd.test.ExecStopPost.conf" <<EOF
2019-12-10 13:49:39 +03:00
<?xml version="1.0"?>
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<busconfig>
<policy user="root">
<allow own="systemd.test.ExecStopPost"/>
</policy>
</busconfig>
EOF
2013-11-06 02:32:56 +04:00
}
2019-11-13 21:32:24 +03:00
install_user_dbus() {
2021-04-16 19:33:44 +03:00
dinfo "Install user dbus"
2020-12-22 20:47:39 +03:00
local userunitdir
2021-04-16 19:33:44 +03:00
if ! userunitdir="$(pkg-config --variable=systemduserunitdir systemd)"; then
dwarn "WARNING! Cannot determine userunitdir from pkg-config, assuming /usr/lib/systemd/user"
userunitdir=/usr/lib/systemd/user
2020-12-22 20:47:39 +03:00
fi
2021-04-16 19:33:44 +03:00
inst "$userunitdir/dbus.socket"
inst_symlink "$userunitdir/sockets.target.wants/dbus.socket" || inst_symlink /etc/systemd/user/sockets.target.wants/dbus.socket
2019-11-13 21:32:24 +03:00
# Append the After= dependency on dbus in case it isn't already set up
2021-04-16 19:33:44 +03:00
mkdir -p "${initdir:?}/etc/systemd/system/user@.service.d/"
cat >"$initdir/etc/systemd/system/user@.service.d/dbus.conf" <<EOF
2019-11-13 21:32:24 +03:00
[Unit]
After=dbus.service
EOF
# Newer Fedora versions use dbus-broker by default. Let's install it if it's available.
2021-04-16 19:33:44 +03:00
if [ -f "$userunitdir/dbus-broker.service" ]; then
inst "$userunitdir/dbus-broker.service"
2019-11-13 21:32:24 +03:00
inst_symlink /etc/systemd/user/dbus.service
2021-04-16 19:33:44 +03:00
elif [ -f "${ROOTLIBDIR:?}/system/dbus-daemon.service" ]; then
2019-11-13 21:32:24 +03:00
# Fedora rawhide replaced dbus.service with dbus-daemon.service
2021-04-16 19:33:44 +03:00
inst "$userunitdir/dbus-daemon.service"
2019-11-13 21:32:24 +03:00
# Alias symlink
inst_symlink /etc/systemd/user/dbus.service
else
2021-04-16 19:33:44 +03:00
inst "$userunitdir/dbus.service"
2019-11-13 21:32:24 +03:00
fi
}
2013-11-06 02:32:56 +04:00
install_pam() {
2021-04-16 19:36:27 +03:00
dinfo "Install PAM"
local paths=()
2021-07-04 13:21:23 +03:00
if get_bool "$LOOKS_LIKE_DEBIAN" && type -p dpkg-architecture &>/dev/null; then
2021-04-16 19:36:27 +03:00
paths+=("/lib/$(dpkg-architecture -qDEB_HOST_MULTIARCH)/security")
2017-08-07 22:09:21 +03:00
else
2021-04-16 19:36:27 +03:00
paths+=(/lib*/security)
2017-08-07 22:09:21 +03:00
fi
2021-04-16 19:36:27 +03:00
2020-11-20 21:41:03 +03:00
for d in /etc/pam.d /etc/security /usr/lib/pam.d; do
2021-04-16 19:36:27 +03:00
[ -d "$d" ] && paths+=("$d")
2013-11-06 02:32:56 +04:00
done
2015-11-17 02:58:20 +03:00
2021-04-16 19:36:27 +03:00
while read -r file; do
inst "$file"
done < <(find "${paths[@]}" -xtype f)
2016-01-25 08:00:34 +03:00
# pam_unix depends on unix_chkpwd.
# see http://www.linux-pam.org/Linux-PAM-html/sag-pam_unix.html
dracut_install -o unix_chkpwd
2016-04-25 21:03:27 +03:00
# set empty root password for easy debugging
2021-04-16 19:33:44 +03:00
sed -i 's/^root:x:/root::/' "${initdir:?}/etc/passwd"
2013-11-06 02:32:56 +04:00
}
install_keymaps() {
2021-04-16 19:33:44 +03:00
dinfo "Install keymaps"
2018-09-19 04:54:16 +03:00
# The first three paths may be deprecated.
# It seems now the last two paths are used by many distributions.
2013-11-06 02:32:56 +04:00
for i in \
/usr/lib/kbd/keymaps/include/* \
/usr/lib/kbd/keymaps/i386/include/* \
2018-09-19 04:54:16 +03:00
/usr/lib/kbd/keymaps/i386/qwerty/us.* \
/usr/lib/kbd/keymaps/legacy/include/* \
/usr/lib/kbd/keymaps/legacy/i386/qwerty/us.*; do
2021-04-16 19:33:44 +03:00
[[ -f "$i" ]] || continue
inst "$i"
2013-11-06 02:32:56 +04:00
done
2018-09-19 04:54:28 +03:00
# When it takes any argument, then install more keymaps.
2021-04-16 19:33:44 +03:00
if [[ $# -gt 1 ]]; then
2018-09-19 04:54:28 +03:00
for i in \
/usr/lib/kbd/keymaps/i386/*/* \
/usr/lib/kbd/keymaps/legacy/i386/*/*; do
2021-04-16 19:33:44 +03:00
[[ -f "$i" ]] || continue
inst "$i"
2018-09-19 04:54:28 +03:00
done
fi
2013-11-06 02:32:56 +04:00
}
2018-09-12 12:20:31 +03:00
install_zoneinfo() {
2021-04-16 19:33:44 +03:00
dinfo "Install time zones"
2019-12-10 17:31:09 +03:00
inst_any /usr/share/zoneinfo/Asia/Seoul
inst_any /usr/share/zoneinfo/Asia/Vladivostok
inst_any /usr/share/zoneinfo/Australia/Sydney
inst_any /usr/share/zoneinfo/Europe/Berlin
2021-03-22 14:51:47 +03:00
inst_any /usr/share/zoneinfo/Europe/Dublin
2019-12-10 17:31:09 +03:00
inst_any /usr/share/zoneinfo/Europe/Kiev
inst_any /usr/share/zoneinfo/Pacific/Auckland
inst_any /usr/share/zoneinfo/Pacific/Honolulu
inst_any /usr/share/zoneinfo/CET
inst_any /usr/share/zoneinfo/EET
inst_any /usr/share/zoneinfo/UTC
2018-09-12 12:20:31 +03:00
}
2013-11-06 02:32:56 +04:00
install_fonts() {
2021-04-16 19:33:44 +03:00
dinfo "Install system fonts"
2013-11-06 02:32:56 +04:00
for i in \
2015-01-15 15:44:17 +03:00
/usr/lib/kbd/consolefonts/eurlatgr* \
2013-11-06 02:32:56 +04:00
/usr/lib/kbd/consolefonts/latarcyrheb-sun16*; do
2021-04-16 19:33:44 +03:00
[[ -f "$i" ]] || continue
inst "$i"
2013-11-06 02:32:56 +04:00
done
}
install_terminfo() {
2021-04-16 19:33:44 +03:00
dinfo "Install terminfo files"
local terminfodir
for terminfodir in /lib/terminfo /etc/terminfo /usr/share/terminfo; do
[ -f "${terminfodir}/l/linux" ] && break
2013-11-06 02:32:56 +04:00
done
2021-04-16 19:33:44 +03:00
dracut_install -o "${terminfodir}/l/linux"
2013-11-06 02:32:56 +04:00
}
2019-11-13 21:32:24 +03:00
has_user_dbus_socket() {
if [ -f /usr/lib/systemd/user/dbus.socket ] || [ -f /etc/systemd/user/dbus.socket ]; then
return 0
else
echo "Per-user instances are not supported. Skipping..."
return 1
fi
}
2013-11-06 02:32:56 +04:00
setup_nspawn_root() {
2019-12-12 11:37:19 +03:00
if [ -z "${initdir}" ]; then
dfatal "\$initdir not defined"
exit 1
fi
2019-12-13 16:21:31 +03:00
2021-04-16 19:33:44 +03:00
rm -rf "${TESTDIR:?}/unprivileged-nspawn-root"
2020-03-20 21:09:35 +03:00
2021-07-04 13:21:23 +03:00
if get_bool "$RUN_IN_UNPRIVILEGED_CONTAINER"; then
2019-12-13 16:21:31 +03:00
ddebug "cp -ar $initdir $TESTDIR/unprivileged-nspawn-root"
2021-04-16 19:33:44 +03:00
cp -ar "$initdir" "$TESTDIR/unprivileged-nspawn-root"
2018-08-30 07:01:18 +03:00
fi
2013-11-06 02:32:56 +04:00
}
2012-05-25 20:32:55 +04:00
setup_basic_dirs() {
2021-04-16 19:33:44 +03:00
mkdir -p "${initdir:?}/run"
mkdir -p "$initdir/etc/systemd/system"
mkdir -p "$initdir/var/log/journal"
2013-11-06 02:32:56 +04:00
2021-04-16 19:33:44 +03:00
for d in usr/bin usr/sbin bin etc lib "${libdir:?}" sbin tmp usr var var/log var/tmp dev proc sys sysroot root run run/lock run/initramfs; do
2012-05-21 20:55:48 +04:00
if [ -L "/$d" ]; then
inst_symlink "/$d"
else
2012-05-25 20:32:55 +04:00
inst_dir "/$d"
2012-05-21 20:55:48 +04:00
fi
done
ln -sfn /run "$initdir/var/run"
ln -sfn /run/lock "$initdir/var/lock"
}
2019-10-08 10:10:12 +03:00
mask_supporting_services() {
# mask some services that we do not want to run in these tests
2021-04-30 22:02:41 +03:00
ln -fsv /dev/null "${initdir:?}/etc/systemd/system/systemd-hwdb-update.service"
ln -fsv /dev/null "$initdir/etc/systemd/system/systemd-journal-catalog-update.service"
ln -fsv /dev/null "$initdir/etc/systemd/system/systemd-networkd.service"
ln -fsv /dev/null "$initdir/etc/systemd/system/systemd-networkd.socket"
ln -fsv /dev/null "$initdir/etc/systemd/system/systemd-resolved.service"
2019-10-08 10:10:12 +03:00
}
2012-05-21 20:55:48 +04:00
inst_libs() {
2021-04-16 19:36:27 +03:00
local bin="${1:?}"
local so_regex='([^ ]*/lib[^/]*/[^ ]*\.so[^ ]*)'
local file line
2012-05-21 20:55:48 +04:00
2021-04-16 19:36:27 +03:00
while read -r line; do
[[ "$line" = 'not a dynamic executable' ]] && break
2012-05-21 20:55:48 +04:00
2021-04-16 19:36:27 +03:00
if [[ "$line" =~ $so_regex ]]; then
file="${BASH_REMATCH[1]}"
[[ -e "${initdir:?}/$file" ]] && continue
inst_library "$file"
2012-05-21 20:55:48 +04:00
continue
fi
2021-04-16 19:36:27 +03:00
if [[ "$line" =~ not\ found ]]; then
dfatal "Missing a shared library required by $bin."
dfatal "Run \"ldd $bin\" to find out what it is."
dfatal "$line"
2012-05-21 20:55:48 +04:00
dfatal "dracut cannot create an initrd."
exit 1
fi
2021-04-16 19:36:27 +03:00
done < <(LC_ALL=C ldd "$bin" 2>/dev/null)
2012-05-21 20:55:48 +04:00
}
import_testdir() {
2020-03-20 22:17:11 +03:00
# make sure we don't get a stale LOOPDEV value from old times
2021-04-16 19:33:44 +03:00
local _LOOPDEV="${LOOPDEV:=}"
# We don't want shellcheck to follow & check the $STATEFILE
# shellcheck source=/dev/null
[[ -e "$STATEFILE" ]] && . "$STATEFILE"
LOOPDEV="$_LOOPDEV"
2019-03-13 00:44:25 +03:00
if [[ ! -d "$TESTDIR" ]]; then
if [[ -z "$TESTDIR" ]]; then
2021-04-16 19:33:44 +03:00
TESTDIR="$(mktemp --tmpdir=/var/tmp -d -t systemd-test.XXXXXX)"
2019-03-13 00:44:25 +03:00
else
mkdir -p "$TESTDIR"
fi
2021-04-16 19:33:44 +03:00
cat >"$STATEFILE" <<EOF
2019-12-12 11:37:19 +03:00
TESTDIR="$TESTDIR"
EOF
2012-05-21 20:55:48 +04:00
export TESTDIR
fi
2020-05-17 11:46:34 +03:00
2021-04-16 19:33:44 +03:00
IMAGE_PRIVATE="${TESTDIR}/${IMAGE_NAME:?}.img"
IMAGE_PUBLIC="${IMAGESTATEDIR:?}/${IMAGE_NAME}.img"
2012-05-21 20:55:48 +04:00
}
2013-11-06 02:32:56 +04:00
import_initdir() {
2021-04-16 19:33:44 +03:00
initdir="${TESTDIR:?}/root"
mkdir -p "$initdir"
2013-11-06 02:32:56 +04:00
export initdir
}
2012-05-21 20:55:48 +04:00
## @brief Converts numeric logging level to the first letter of level name.
#
# @param lvl Numeric logging level in range from 1 to 6.
# @retval 1 if @a lvl is out of range.
# @retval 0 if @a lvl is correct.
# @result Echoes first letter of level name.
_lvl2char() {
case "$1" in
1) echo F;;
2) echo E;;
3) echo W;;
4) echo I;;
5) echo D;;
6) echo T;;
*) return 1;;
esac
}
## @brief Internal helper function for _do_dlog()
#
# @param lvl Numeric logging level.
# @param msg Message.
# @retval 0 It's always returned, even if logging failed.
#
# @note This function is not supposed to be called manually. Please use
# dtrace(), ddebug(), or others instead which wrap this one.
#
# This function calls _do_dlog() either with parameter msg, or if
# none is given, it will read standard input and will use every line as
# a message.
#
# This enables:
# dwarn "This is a warning"
# echo "This is a warning" | dwarn
2021-04-16 19:33:44 +03:00
LOG_LEVEL="${LOG_LEVEL:-4}"
2012-05-21 20:55:48 +04:00
dlog() {
2021-04-16 19:33:44 +03:00
local lvl lvlc
2012-05-21 20:55:48 +04:00
[ -z "$LOG_LEVEL" ] && return 0
2021-04-16 19:33:44 +03:00
lvl="${1:?}"; shift
[ "$lvl" -le "$LOG_LEVEL" ] || return 0
lvlc="$(_lvl2char "$lvl")" || return 0
2012-05-21 20:55:48 +04:00
if [ $# -ge 1 ]; then
echo "$lvlc: $*"
else
2021-04-16 19:33:44 +03:00
while read -r line; do
2012-05-21 20:55:48 +04:00
echo "$lvlc: " "$line"
done
fi
}
## @brief Logs message at TRACE level (6)
#
# @param msg Message.
# @retval 0 It's always returned, even if logging failed.
dtrace() {
set +x
dlog 6 "$@"
2021-07-04 13:21:23 +03:00
if get_bool "${debug:=}"; then
2021-04-16 19:33:44 +03:00
set -x
fi
2012-05-21 20:55:48 +04:00
}
## @brief Logs message at DEBUG level (5)
#
# @param msg Message.
# @retval 0 It's always returned, even if logging failed.
ddebug() {
dlog 5 "$@"
}
## @brief Logs message at INFO level (4)
#
# @param msg Message.
# @retval 0 It's always returned, even if logging failed.
dinfo() {
set +x
dlog 4 "$@"
2021-07-04 13:21:23 +03:00
if get_bool "${debug:=}"; then
2021-04-16 19:33:44 +03:00
set -x
fi
2012-05-21 20:55:48 +04:00
}
## @brief Logs message at WARN level (3)
#
# @param msg Message.
# @retval 0 It's always returned, even if logging failed.
dwarn() {
set +x
dlog 3 "$@"
2021-07-04 13:21:23 +03:00
if get_bool "${debug:=}"; then
2021-04-16 19:33:44 +03:00
set -x
fi
2012-05-21 20:55:48 +04:00
}
## @brief Logs message at ERROR level (2)
#
# @param msg Message.
# @retval 0 It's always returned, even if logging failed.
derror() {
dlog 2 "$@"
}
## @brief Logs message at FATAL level (1)
#
# @param msg Message.
# @retval 0 It's always returned, even if logging failed.
dfatal() {
set +x
dlog 1 "$@"
2021-07-04 13:21:23 +03:00
if get_bool "${debug:=}"; then
2021-04-16 19:33:44 +03:00
set -x
fi
2012-05-21 20:55:48 +04:00
}
# Generic substring function. If $2 is in $1, return 0.
strstr() { [ "${1#*$2*}" != "$1" ]; }
# normalize_path <path>
# Prints the normalized path, where it removes any duplicated
# and trailing slashes.
# Example:
# $ normalize_path ///test/test//
# /test/test
normalize_path() {
shopt -q -s extglob
set -- "${1//+(\/)//}"
shopt -q -u extglob
echo "${1%/}"
}
# convert_abs_rel <from> <to>
# Prints the relative path, when creating a symlink to <to> from <from>.
# Example:
# $ convert_abs_rel /usr/bin/test /bin/test-2
# ../../bin/test-2
# $ ln -s $(convert_abs_rel /usr/bin/test /bin/test-2) /usr/bin/test
convert_abs_rel() {
local __current __absolute __abssize __cursize __newpath
local -i __i __level
2021-04-16 19:33:44 +03:00
set -- "$(normalize_path "${1:?}")" "$(normalize_path "${2:?}")"
2012-05-21 20:55:48 +04:00
# corner case #1 - self looping link
[[ "$1" == "$2" ]] && { echo "${1##*/}"; return; }
# corner case #2 - own dir link
[[ "${1%/*}" == "$2" ]] && { echo "."; return; }
2021-04-16 19:33:44 +03:00
IFS="/" read -ra __current <<< "$1"
IFS="/" read -ra __absolute <<< "$2"
2012-05-21 20:55:48 +04:00
__abssize=${#__absolute[@]}
__cursize=${#__current[@]}
2021-04-16 19:33:44 +03:00
while [[ "${__absolute[__level]}" == "${__current[__level]}" ]]
2012-05-21 20:55:48 +04:00
do
(( __level++ ))
if (( __level > __abssize || __level > __cursize ))
then
break
fi
done
for ((__i = __level; __i < __cursize-1; __i++))
do
if ((__i > __level))
then
__newpath=$__newpath"/"
fi
__newpath=$__newpath".."
done
for ((__i = __level; __i < __abssize; __i++))
do
if [[ -n $__newpath ]]
then
__newpath=$__newpath"/"
fi
__newpath=$__newpath${__absolute[__i]}
done
echo "$__newpath"
}
# Install a directory, keeping symlinks as on the original system.
# Example: if /lib points to /lib64 on the host, "inst_dir /lib/file"
# will create ${initdir}/lib64, ${initdir}/lib64/file,
# and a symlink ${initdir}/lib -> lib64.
inst_dir() {
2021-04-16 19:33:44 +03:00
local dir="${1:?}"
local part="${dir%/*}"
local file
2012-05-21 20:55:48 +04:00
2021-04-16 19:33:44 +03:00
[[ -e "${initdir:?}/${dir}" ]] && return 0 # already there
while [[ "$part" != "${part%/*}" ]] && ! [[ -e "${initdir}/${part}" ]]; do
dir="$part $dir"
part="${part%/*}"
2012-05-21 20:55:48 +04:00
done
# iterate over parent directories
2021-04-16 19:33:44 +03:00
for file in $dir; do
[[ -e "${initdir}/$file" ]] && continue
if [[ -L $file ]]; then
inst_symlink "$file"
2012-05-21 20:55:48 +04:00
else
# create directory
2021-04-16 19:33:44 +03:00
mkdir -m 0755 "${initdir}/$file" || return 1
[[ -e "$file" ]] && chmod --reference="$file" "${initdir}/$file"
chmod u+w "${initdir}/$file"
2012-05-21 20:55:48 +04:00
fi
done
}
# $1 = file to copy to ramdisk
# $2 (optional) Name for the file on the ramdisk
# Location of the image dir is assumed to be $initdir
# We never overwrite the target if it exists.
inst_simple() {
2021-04-16 19:33:44 +03:00
[[ -f "${1:?}" ]] || return 1
2012-05-21 20:55:48 +04:00
strstr "$1" "/" || return 1
2021-04-16 19:33:44 +03:00
local src="$1"
local target="${2:-$1}"
if ! [[ -d ${initdir:?}/$target ]]; then
2012-05-21 20:55:48 +04:00
[[ -e ${initdir}/$target ]] && return 0
[[ -L ${initdir}/$target ]] && return 0
[[ -d "${initdir}/${target%/*}" ]] || inst_dir "${target%/*}"
fi
# install checksum files also
2021-04-16 19:33:44 +03:00
if [[ -e "${src%/*}/.${src##*/}.hmac" ]]; then
inst "${src%/*}/.${src##*/}.hmac" "${target%/*}/.${target##*/}.hmac"
2012-05-21 20:55:48 +04:00
fi
2021-04-16 19:33:44 +03:00
ddebug "Installing $src"
cp --sparse=always -pfL "$src" "${initdir}/$target"
2012-05-21 20:55:48 +04:00
}
# find symlinks linked to given library file
# $1 = library file
# Function searches for symlinks by stripping version numbers appended to
# library filename, checks if it points to the same target and finally
# prints the list of symlinks to stdout.
#
# Example:
# rev_lib_symlinks libfoo.so.8.1
# output: libfoo.so.8 libfoo.so
# (Only if libfoo.so.8 and libfoo.so exists on host system.)
rev_lib_symlinks() {
2021-04-16 19:33:44 +03:00
local fn="${1:?}"
local links=""
local orig
orig="$(readlink -f "$1")"
2012-05-21 20:55:48 +04:00
2021-04-16 19:33:44 +03:00
[[ "${fn}" =~ .*\.so\..* ]] || return 1
2012-05-21 20:55:48 +04:00
2021-04-16 19:33:44 +03:00
until [[ "${fn##*.}" == so ]]; do
2012-05-21 20:55:48 +04:00
fn="${fn%.*}"
2021-04-16 19:33:44 +03:00
[[ -L "${fn}" && "$(readlink -f "${fn}")" == "${orig}" ]] && links+=" ${fn}"
2012-05-21 20:55:48 +04:00
done
echo "${links}"
}
# Same as above, but specialized to handle dynamic libraries.
# It handles making symlinks according to how the original library
# is referenced.
inst_library() {
2021-04-16 19:33:44 +03:00
local src="${1:?}"
local dest="${2:-$1}"
local reallib symlink
2012-05-21 20:55:48 +04:00
strstr "$1" "/" || return 1
2021-04-16 19:33:44 +03:00
[[ -e ${initdir:?}/$dest ]] && return 0
if [[ -L $src ]]; then
2012-05-21 20:55:48 +04:00
# install checksum files also
2021-04-16 19:33:44 +03:00
if [[ -e "${src%/*}/.${src##*/}.hmac" ]]; then
inst "${src%/*}/.${src##*/}.hmac" "${dest%/*}/.${dest##*/}.hmac"
2012-05-21 20:55:48 +04:00
fi
2021-04-16 19:33:44 +03:00
reallib="$(readlink -f "$src")"
inst_simple "$reallib" "$reallib"
inst_dir "${dest%/*}"
[[ -d "${dest%/*}" ]] && dest="$(readlink -f "${dest%/*}")/${dest##*/}"
ln -sfn -- "$(convert_abs_rel "${dest}" "${reallib}")" "${initdir}/${dest}"
2012-05-21 20:55:48 +04:00
else
2021-04-16 19:33:44 +03:00
inst_simple "$src" "$dest"
2012-05-21 20:55:48 +04:00
fi
# Create additional symlinks. See rev_symlinks description.
2021-04-16 19:33:44 +03:00
for symlink in $(rev_lib_symlinks "$src") ${reallib:+$(rev_lib_symlinks "$reallib")}; do
if [[ ! -e "$initdir/$symlink" ]]; then
ddebug "Creating extra symlink: $symlink"
inst_symlink "$symlink"
fi
2012-05-21 20:55:48 +04:00
done
}
# find a binary. If we were not passed the full path directly,
# search in the usual places to find the binary.
find_binary() {
2021-04-16 19:33:44 +03:00
local bin="${1:?}"
if [[ -z ${bin##/*} ]]; then
if [[ -x "$bin" ]] || { strstr "$bin" ".so" && ldd "$bin" &>/dev/null; }; then
echo "$bin"
2012-05-21 20:55:48 +04:00
return 0
fi
fi
2021-04-16 19:33:44 +03:00
type -P "$bin"
2012-05-21 20:55:48 +04:00
}
# Same as above, but specialized to install binary executables.
# Install binary executable, and all shared library dependencies, if any.
inst_binary() {
2021-04-16 19:33:44 +03:00
local bin="${1:?}"
local path target
2019-07-08 22:05:51 +03:00
# In certain cases we might attempt to install a binary which is already
# present in the test image, yet it's missing from the host system.
# In such cases, let's check if the binary indeed exists in the image
# before doing any other chcecks. If it does, immediately return with
# success.
2021-04-16 19:33:44 +03:00
if [[ $# -eq 1 ]]; then
for path in "" bin sbin usr/bin usr/sbin; do
[[ -e "${initdir:?}${path:+/$path}/${bin}" ]] && return 0
done
fi
2019-07-08 22:05:51 +03:00
2021-04-16 19:33:44 +03:00
bin="$(find_binary "$bin")" || return 1
target="${2:-$bin}"
[[ -e "${initdir:?}/$target" ]] && return 0
[[ -L "$bin" ]] && inst_symlink "$bin" "$target" && return 0
local file line
local so_regex='([^ ]*/lib[^/]*/[^ ]*\.so[^ ]*)'
2012-05-21 20:55:48 +04:00
# I love bash!
2021-04-16 19:33:44 +03:00
while read -r line; do
[[ "$line" = 'not a dynamic executable' ]] && break
2012-05-21 20:55:48 +04:00
2021-04-16 19:33:44 +03:00
if [[ "$line" =~ $so_regex ]]; then
file="${BASH_REMATCH[1]}"
[[ -e "${initdir}/$file" ]] && continue
inst_library "$file"
2012-05-21 20:55:48 +04:00
continue
fi
2021-04-16 19:33:44 +03:00
if [[ "$line" =~ not\ found ]]; then
dfatal "Missing a shared library required by $bin."
dfatal "Run \"ldd $bin\" to find out what it is."
dfatal "$line"
2012-05-21 20:55:48 +04:00
dfatal "dracut cannot create an initrd."
exit 1
fi
2021-04-16 19:33:44 +03:00
done < <(LC_ALL=C ldd "$bin" 2>/dev/null)
inst_simple "$bin" "$target"
2012-05-21 20:55:48 +04:00
}
# same as above, except for shell scripts.
# If your shell script does not start with shebang, it is not a shell script.
inst_script() {
2021-04-16 19:33:44 +03:00
local bin line shebang_regex
bin="$(find_binary "${1:?}")" || return 1
2012-05-21 20:55:48 +04:00
shift
2021-04-16 19:33:44 +03:00
read -r -n 80 line <"$bin"
2012-05-21 20:55:48 +04:00
# If debug is set, clean unprintable chars to prevent messing up the term
2021-07-04 13:21:23 +03:00
get_bool "${debug:=}" && line="$(echo -n "$line" | tr -c -d '[:print:][:space:]')"
2021-04-16 19:33:44 +03:00
shebang_regex='(#! *)(/[^ ]+).*'
[[ "$line" =~ $shebang_regex ]] || return 1
inst "${BASH_REMATCH[2]}" && inst_simple "$bin" "$@"
2012-05-21 20:55:48 +04:00
}
# same as above, but specialized for symlinks
inst_symlink() {
2021-04-16 19:33:44 +03:00
local src="${1:?}"
local target="${2:-$src}"
local realsrc
strstr "$src" "/" || return 1
[[ -L "$src" ]] || return 1
[[ -L "${initdir:?}/$target" ]] && return 0
realsrc="$(readlink -f "$src")"
if ! [[ -e "$initdir/$realsrc" ]]; then
if [[ -d "$realsrc" ]]; then
inst_dir "$realsrc"
2012-05-21 20:55:48 +04:00
else
2021-04-16 19:33:44 +03:00
inst "$realsrc"
2012-05-21 20:55:48 +04:00
fi
fi
2021-04-16 19:33:44 +03:00
[[ ! -e "$initdir/${target%/*}" ]] && inst_dir "${target%/*}"
[[ -d "${target%/*}" ]] && target="$(readlink -f "${target%/*}")/${target##*/}"
ln -sfn -- "$(convert_abs_rel "${target}" "${realsrc}")" "$initdir/$target"
2012-05-21 20:55:48 +04:00
}
# attempt to install any programs specified in a udev rule
inst_rule_programs() {
2021-04-16 19:33:44 +03:00
local rule="${1:?}"
local prog bin
2012-05-21 20:55:48 +04:00
2021-06-17 15:38:21 +03:00
sed -rn 's/^.*?PROGRAM==?"([^ "]+).*$/\1/p' "$rule" | while read -r prog; do
2021-04-16 19:33:44 +03:00
if [ -x "/lib/udev/$prog" ]; then
bin="/lib/udev/$prog"
else
if ! bin="$(find_binary "$prog")"; then
dinfo "Skipping program $prog used in udev rule $(basename "$rule") as it cannot be found"
continue
2012-05-21 20:55:48 +04:00
fi
2021-04-16 19:33:44 +03:00
fi
2012-05-21 20:55:48 +04:00
2021-04-16 19:33:44 +03:00
#dinfo "Installing $_bin due to it's use in the udev rule $(basename $1)"
dracut_install "$bin"
done
2012-05-21 20:55:48 +04:00
}
# udev rules always get installed in the same place, so
# create a function to install them to make life simpler.
inst_rules() {
2021-04-16 19:33:44 +03:00
local target=/etc/udev/rules.d
local found rule
2012-05-21 20:55:48 +04:00
inst_dir "/lib/udev/rules.d"
2021-04-16 19:33:44 +03:00
inst_dir "$target"
for rule in "$@"; do
2012-05-21 20:55:48 +04:00
if [ "${rule#/}" = "$rule" ]; then
for r in /lib/udev/rules.d /etc/udev/rules.d; do
2021-04-16 19:33:44 +03:00
if [[ -f "$r/$rule" ]]; then
found="$r/$rule"
inst_simple "$found"
inst_rule_programs "$found"
2012-05-21 20:55:48 +04:00
fi
done
fi
2021-04-16 19:33:44 +03:00
for r in '' ./; do
if [[ -f "${r}${rule}" ]]; then
found="${r}${rule}"
inst_simple "$found" "$target/${found##*/}"
inst_rule_programs "$found"
2012-05-21 20:55:48 +04:00
fi
done
2021-04-16 19:33:44 +03:00
[[ $found ]] || dinfo "Skipping udev rule: $rule"
found=
2012-05-21 20:55:48 +04:00
done
}
# general purpose installation function
# Same args as above.
inst() {
case $# in
1) ;;
2021-04-16 19:33:44 +03:00
2)
[[ ! "$initdir" && -d "$2" ]] && export initdir="$2"
[[ "$initdir" = "$2" ]] && set "$1"
;;
3)
[[ -z "$initdir" ]] && export initdir="$2"
set "$1" "$3"
;;
*)
dfatal "inst only takes 1 or 2 or 3 arguments"
exit 1
;;
2012-05-21 20:55:48 +04:00
esac
2021-04-16 19:33:44 +03:00
local fun
for fun in inst_symlink inst_script inst_binary inst_simple; do
"$fun" "$@" && return 0
2012-05-21 20:55:48 +04:00
done
return 1
}
# install any of listed files
#
# If first argument is '-d' and second some destination path, first accessible
# source is installed into this path, otherwise it will installed in the same
# path as source. If none of listed files was installed, function return 1.
# On first successful installation it returns with 0 status.
#
# Example:
#
# inst_any -d /bin/foo /bin/bar /bin/baz
#
# Lets assume that /bin/baz exists, so it will be installed as /bin/foo in
# initramfs.
inst_any() {
2021-04-16 19:33:44 +03:00
local dest file
2012-05-21 20:55:48 +04:00
2021-04-16 19:33:44 +03:00
[[ "${1:?}" = '-d' ]] && dest="${2:?}" && shift 2
2012-05-21 20:55:48 +04:00
2021-04-16 19:33:44 +03:00
for file in "$@"; do
if [[ -e "$file" ]]; then
[[ -n "$dest" ]] && inst "$file" "$dest" && return 0
inst "$file" && return 0
2012-05-21 20:55:48 +04:00
fi
done
return 1
}
# dracut_install [-o ] <file> [<file> ... ]
# Install <file> to the initramfs image
# -o optionally install the <file> and don't fail, if it is not there
dracut_install() {
2021-04-16 19:33:44 +03:00
local optional=no
local prog="${1:?}"
if [[ "$prog" = '-o' ]]; then
optional=yes
2012-05-21 20:55:48 +04:00
shift
fi
2021-04-16 19:33:44 +03:00
for prog in "$@"; do
if ! inst "$prog" ; then
2021-07-04 13:21:23 +03:00
if get_bool "$optional"; then
2021-04-16 19:33:44 +03:00
dinfo "Skipping program $prog as it cannot be found and is" \
2012-05-21 20:55:48 +04:00
"flagged to be optional"
else
2021-04-16 19:33:44 +03:00
dfatal "Failed to install $prog"
2012-05-21 20:55:48 +04:00
exit 1
fi
fi
done
}
2012-05-25 20:32:55 +04:00
# Install a single kernel module along with any firmware it may require.
# $1 = full path to kernel module to install
install_kmod_with_fw() {
2021-04-16 19:42:00 +03:00
local module="${1:?}"
2012-05-25 20:32:55 +04:00
# no need to go further if the module is already installed
2021-04-16 19:42:00 +03:00
[[ -e "${initdir:?}/lib/modules/${KERNEL_VER:?}/${module##*/lib/modules/$KERNEL_VER/}" ]] && return 0
[[ -e "$initdir/.kernelmodseen/${module##*/}" ]] && return 0
2012-05-25 20:32:55 +04:00
2021-04-16 19:42:00 +03:00
[ -d "$initdir/.kernelmodseen" ] && : >"$initdir/.kernelmodseen/${module##*/}"
2012-05-25 20:32:55 +04:00
2021-04-16 19:42:00 +03:00
inst_simple "$module" "/lib/modules/$KERNEL_VER/${module##*/lib/modules/$KERNEL_VER/}" || return $?
2012-05-25 20:32:55 +04:00
2021-04-16 19:42:00 +03:00
local modname="${module##*/}"
local fwdir found fw
modname="${modname%.ko*}"
2012-05-25 20:32:55 +04:00
2021-04-16 19:42:00 +03:00
while read -r fw; do
found=
for fwdir in /lib/firmware/updates /lib/firmware; do
if [[ -d "$fwdir" && -f "$fwdir/$fw" ]]; then
inst_simple "$fwdir/$fw" "/lib/firmware/$fw"
found=yes
2012-05-25 20:32:55 +04:00
fi
done
2021-07-04 13:21:23 +03:00
if ! get_bool "$found"; then
2021-04-16 19:42:00 +03:00
if ! grep -qe "\<${modname//-/_}\>" /proc/modules; then
dinfo "Possible missing firmware \"${fw}\" for kernel module" \
"\"${modname}.ko\""
2012-05-25 20:32:55 +04:00
else
2021-04-16 19:42:00 +03:00
dwarn "Possible missing firmware \"${fw}\" for kernel module" \
"\"${modname}.ko\""
2012-05-25 20:32:55 +04:00
fi
fi
2021-04-16 19:42:00 +03:00
done < <(modinfo -k "$KERNEL_VER" -F firmware "$module" 2>/dev/null)
2012-05-25 20:32:55 +04:00
return 0
}
# Do something with all the dependencies of a kernel module.
# Note that kernel modules depend on themselves using the technique we use
# $1 = function to call for each dependency we find
# It will be passed the full path to the found kernel module
# $2 = module to get dependencies for
# rest of args = arguments to modprobe
for_each_kmod_dep() {
2021-04-16 19:42:00 +03:00
local func="${1:?}"
local kmod="${2:?}"
local found=0
local cmd modpath
2012-05-25 20:32:55 +04:00
shift 2
2021-04-16 19:42:00 +03:00
while read -r cmd modpath _; do
[[ "$cmd" = insmod ]] || continue
"$func" "$modpath" || return $?
found=1
done < <(modprobe "$@" --ignore-install --show-depends "$kmod")
2012-05-25 20:32:55 +04:00
2021-07-04 13:21:23 +03:00
! get_bool "$found" && return 1
2021-04-16 19:42:00 +03:00
return 0
2012-05-25 20:32:55 +04:00
}
# instmods [-c] <kernel module> [<kernel module> ... ]
# instmods [-c] <kernel subsystem>
# install kernel modules along with all their dependencies.
# <kernel subsystem> can be e.g. "=block" or "=drivers/usb/storage"
2021-04-16 19:42:00 +03:00
# FIXME(?): dracutdevs/dracut@f4e38c0da8d6bf3764c1ad753d9d52aef63050e5
2012-05-25 20:32:55 +04:00
instmods() {
2021-04-16 19:42:00 +03:00
local check=no
if [[ $# -ge 0 && "$1" = '-c' ]]; then
check=yes
2012-05-25 20:32:55 +04:00
shift
fi
2021-04-16 19:42:00 +03:00
inst1mod() {
local mod="${1:?}"
local ret=0
local mod_dir="/lib/modules/${KERNEL_VER:?}/"
case "$mod" in
2012-05-25 20:32:55 +04:00
=*)
2021-04-16 19:42:00 +03:00
if [ -f "${mod_dir}/modules.${mod#=}" ]; then
(
[[ "$mpargs" ]] && echo "$mpargs"
cat "${mod_dir}/modules.${mod#=}"
) | instmods
2012-05-25 20:32:55 +04:00
else
2021-04-16 19:42:00 +03:00
(
[[ "$mpargs" ]] && echo "$mpargs"
find "$mod_dir" -path "*/${mod#=}/*" -type f -printf '%f\n'
) | instmods
2012-05-25 20:32:55 +04:00
fi
;;
2021-04-16 19:42:00 +03:00
--*)
mpargs+=" $mod"
;;
i2o_scsi)
# Do not load this diagnostic-only module
return
;;
2012-05-25 20:32:55 +04:00
*)
2021-04-16 19:42:00 +03:00
mod=${mod##*/}
2012-05-25 20:32:55 +04:00
# if we are already installed, skip this module and go on
# to the next one.
2021-04-16 19:42:00 +03:00
[[ -f "${initdir:?}/.kernelmodseen/${mod%.ko}.ko" ]] && return
2012-05-25 20:32:55 +04:00
# We use '-d' option in modprobe only if modules prefix path
# differs from default '/'. This allows us to use Dracut with
# old version of modprobe which doesn't have '-d' option.
2021-04-16 19:42:00 +03:00
local mod_dirname=${mod_dir%%/lib/modules/*}
[[ -n ${mod_dirname} ]] && mod_dirname="-d ${mod_dirname}/"
2012-05-25 20:32:55 +04:00
# ok, load the module, all its dependencies, and any firmware
# it may require
2021-04-16 19:42:00 +03:00
for_each_kmod_dep install_kmod_with_fw "$mod" \
--set-version "$KERNEL_VER" \
${mod_dirname:+"$mod_dirname"} \
${mpargs:+"$mpargs"}
((ret+=$?))
2012-05-25 20:32:55 +04:00
;;
esac
2021-04-23 11:55:49 +03:00
return "$ret"
2012-05-25 20:32:55 +04:00
}
2021-04-16 19:42:00 +03:00
local mod mpargs
if [[ $# -eq 0 ]]; then # filenames from stdin
while read -r mod; do
if ! inst1mod "${mod%.ko*}" && [ "$check" = "yes" ]; then
dfatal "Failed to install $mod"
return 1
fi
2012-05-25 20:32:55 +04:00
done
2021-04-16 19:42:00 +03:00
fi
2012-05-25 20:32:55 +04:00
2021-04-16 19:42:00 +03:00
for mod in "$@"; do # filenames as arguments
if ! inst1mod "${mod%.ko*}" && [ "$check" = "yes" ]; then
dfatal "Failed to install $mod"
return 1
fi
done
return 0
2012-05-25 20:32:55 +04:00
}
2012-05-21 20:55:48 +04:00
2017-07-06 21:30:14 +03:00
setup_suse() {
2021-04-16 19:33:44 +03:00
ln -fs ../usr/bin/systemctl "${initdir:?}/bin/"
ln -fs ../usr/lib/systemd "$initdir/lib/"
2017-07-06 21:30:14 +03:00
inst_simple "/usr/lib/systemd/system/haveged.service"
}
2019-08-13 14:50:59 +03:00
_umount_dir() {
2021-04-16 19:33:44 +03:00
local mountpoint="${1:?}"
if mountpoint -q "$mountpoint"; then
ddebug "umount $mountpoint"
umount "$mountpoint"
2019-08-13 14:50:59 +03:00
fi
}
2019-07-12 18:47:26 +03:00
# can be overridden in specific test
test_setup_cleanup() {
2019-12-13 16:21:31 +03:00
cleanup_initdir
2019-07-12 18:47:26 +03:00
}
_test_cleanup() {
2019-07-12 21:09:48 +03:00
# (post-test) cleanup should always ignore failure and cleanup as much as possible
(
set +e
2021-04-16 19:33:44 +03:00
[[ -n "$initdir" ]] && _umount_dir "$initdir"
[[ -n "$IMAGE_PUBLIC" ]] && rm -vf "$IMAGE_PUBLIC"
2021-01-28 16:26:35 +03:00
# If multiple setups/cleans are ran in parallel, this can cause a race
2021-04-16 19:33:44 +03:00
if [[ -n "$IMAGESTATEDIR" && $TEST_PARALLELIZE -ne 1 ]]; then
2021-01-28 16:26:35 +03:00
rm -vf "${IMAGESTATEDIR}/default.img"
fi
2021-04-16 19:33:44 +03:00
[[ -n "$TESTDIR" ]] && rm -vfr "$TESTDIR"
[[ -n "$STATEFILE" ]] && rm -vf "$STATEFILE"
2019-07-19 03:34:57 +03:00
) || :
2019-07-12 18:47:26 +03:00
}
2017-08-04 15:34:14 +03:00
# can be overridden in specific test
test_cleanup() {
2019-07-12 18:47:26 +03:00
_test_cleanup
2017-08-04 15:34:14 +03:00
}
2020-03-20 21:09:35 +03:00
test_cleanup_again() {
[ -n "$TESTDIR" ] || return
rm -rf "$TESTDIR/unprivileged-nspawn-root"
2021-04-16 19:33:44 +03:00
[[ -n "$initdir" ]] && _umount_dir "$initdir"
2020-03-20 21:09:35 +03:00
}
2019-12-12 11:37:19 +03:00
test_create_image() {
2019-12-10 18:40:31 +03:00
create_empty_image_rootdir
# Create what will eventually be our root filesystem onto an overlay
(
LOG_LEVEL=5
setup_basic_environment
)
2019-12-12 11:37:19 +03:00
}
test_setup() {
2021-07-04 13:21:23 +03:00
if get_bool "${TEST_REQUIRE_INSTALL_TESTS:?}" && \
2021-04-16 19:33:44 +03:00
command -v meson >/dev/null && \
[[ "$(meson configure "${BUILD_DIR:?}" | grep install-tests | awk '{ print $2 }')" != "true" ]]; then
2020-03-31 16:13:13 +03:00
dfatal "$BUILD_DIR needs to be built with -Dinstall-tests=true"
2019-12-12 11:37:19 +03:00
exit 1
fi
2021-04-16 19:33:44 +03:00
if [ -e "${IMAGE_PRIVATE:?}" ]; then
echo "Reusing existing image $IMAGE_PRIVATE → $(realpath "$IMAGE_PRIVATE")"
2019-12-12 11:37:19 +03:00
mount_initdir
2020-05-25 23:48:01 +03:00
else
2021-04-16 19:33:44 +03:00
if [ ! -e "${IMAGE_PUBLIC:?}" ]; then
2021-01-07 00:42:28 +03:00
# default.img is the base that every test uses and optionally appends to
2021-04-16 19:33:44 +03:00
if [ ! -e "${IMAGESTATEDIR:?}/default.img" ] || [ -n "${TEST_FORCE_NEWIMAGE:=}" ]; then
2021-01-07 00:42:28 +03:00
# Create the backing public image, but then completely unmount
# it and drop the loopback device responsible for it, since we're
# going to symlink/copy the image and mount it again from
# elsewhere.
2021-04-16 19:33:44 +03:00
local image_old="${IMAGE_PUBLIC}"
2021-01-07 00:42:28 +03:00
if [ -z "${TEST_FORCE_NEWIMAGE}" ]; then
IMAGE_PUBLIC="${IMAGESTATEDIR}/default.img"
fi
test_create_image
test_setup_cleanup
umount_loopback
cleanup_loopdev
IMAGE_PUBLIC="${image_old}"
fi
2021-07-04 13:21:23 +03:00
if [ "${IMAGE_NAME:?}" != "default" ] && ! get_bool "${TEST_FORCE_NEWIMAGE}"; then
2021-01-07 00:42:28 +03:00
cp -v "$(realpath "${IMAGESTATEDIR}/default.img")" "$IMAGE_PUBLIC"
fi
fi
2021-07-04 13:21:23 +03:00
local hook_defined
declare -f -F test_append_files >/dev/null && hook_defined=yes || hook_defined=no
2020-05-25 23:48:01 +03:00
2021-04-16 19:33:44 +03:00
echo "Reusing existing cached image $IMAGE_PUBLIC → $(realpath "$IMAGE_PUBLIC")"
2021-07-04 13:21:23 +03:00
if get_bool "$TEST_PARALLELIZE" || get_bool "$hook_defined"; then
2021-04-16 19:33:44 +03:00
cp -v -- "$(realpath "$IMAGE_PUBLIC")" "$IMAGE_PRIVATE"
2020-05-17 11:48:16 +03:00
else
2021-04-16 19:33:44 +03:00
ln -sv -- "$(realpath "$IMAGE_PUBLIC")" "$IMAGE_PRIVATE"
2020-05-17 11:48:16 +03:00
fi
2020-05-25 23:48:01 +03:00
2019-12-12 11:37:19 +03:00
mount_initdir
2021-06-24 13:13:52 +03:00
# We want to test all services in TEST-01-BASIC, but mask them in
# all other tests
if [[ "${TESTID:?}" != "01" ]]; then
dinfo "Masking supporting services"
mask_supporting_services
fi
2021-07-04 13:21:23 +03:00
if get_bool "$hook_defined"; then
2021-04-16 19:33:44 +03:00
test_append_files "${initdir:?}"
2021-01-07 00:42:28 +03:00
fi
2019-12-12 11:37:19 +03:00
fi
2019-12-10 18:40:31 +03:00
setup_nspawn_root
}
2017-08-04 15:34:14 +03:00
test_run() {
2021-04-16 19:33:44 +03:00
local test_id="${1:?}"
2019-12-13 14:34:41 +03:00
mount_initdir
2021-07-04 13:21:23 +03:00
if ! get_bool "${TEST_NO_QEMU:=}"; then
2021-04-16 19:33:44 +03:00
if run_qemu "$test_id"; then
2020-03-20 19:16:30 +03:00
check_result_qemu || { echo "QEMU test failed"; return 1; }
2017-08-04 15:34:14 +03:00
else
dwarn "can't run QEMU, skipping"
fi
fi
2021-07-04 13:21:23 +03:00
if ! get_bool "${TEST_NO_NSPAWN:=}"; then
2019-12-13 16:21:31 +03:00
mount_initdir
2021-04-16 19:33:44 +03:00
if run_nspawn "${initdir:?}" "$test_id"; then
2019-12-13 16:21:31 +03:00
check_result_nspawn "$initdir" || { echo "nspawn-root test failed"; return 1; }
2017-08-04 15:34:14 +03:00
else
dwarn "can't run systemd-nspawn, skipping"
fi
2018-08-30 07:01:18 +03:00
2021-07-04 13:21:23 +03:00
if get_bool "${RUN_IN_UNPRIVILEGED_CONTAINER:=}"; then
2019-12-13 16:21:31 +03:00
dir="$TESTDIR/unprivileged-nspawn-root"
2021-04-16 19:33:44 +03:00
if NSPAWN_ARGUMENTS="-U --private-network ${NSPAWN_ARGUMENTS:-}" run_nspawn "$dir" "$test_id"; then
2019-12-13 16:21:31 +03:00
check_result_nspawn "$dir" || { echo "unprivileged-nspawn-root test failed"; return 1; }
2018-08-30 07:01:18 +03:00
else
dwarn "can't run systemd-nspawn, skipping"
fi
2019-01-30 04:19:45 +03:00
fi
2017-08-04 15:34:14 +03:00
fi
return 0
}
2012-05-21 20:55:48 +04:00
do_test() {
2012-05-25 16:53:29 +04:00
if [[ $UID != "0" ]]; then
echo "TEST: $TEST_DESCRIPTION [SKIPPED]: not root" >&2
exit 0
fi
2021-07-04 13:21:23 +03:00
if get_bool "${TEST_NO_QEMU:=}" && get_bool "${TEST_NO_NSPAWN:=}"; then
2020-12-22 20:51:40 +03:00
echo "TEST: $TEST_DESCRIPTION [SKIPPED]: both QEMU and nspawn disabled" >&2
exit 0
fi
2021-07-04 13:21:23 +03:00
if get_bool "${TEST_QEMU_ONLY:=}" && ! get_bool "$TEST_NO_NSPAWN"; then
2020-12-26 23:11:55 +03:00
echo "TEST: $TEST_DESCRIPTION [SKIPPED]: QEMU-only tests requested" >&2
exit 0
fi
2021-07-04 13:21:23 +03:00
if get_bool "${TEST_PREFER_NSPAWN:=}" && ! get_bool "$TEST_NO_NSPAWN"; then
2020-12-31 20:29:58 +03:00
TEST_NO_QEMU=1
fi
scripts: use 4 space indentation
We had all kinds of indentation: 2 sp, 3 sp, 4 sp, 8 sp, and mixed.
4 sp was the most common, in particular the majority of scripts under test/
used that. Let's standarize on 4 sp, because many commandlines are long and
there's a lot of nesting, and with 8sp indentation less stuff fits. 4 sp
also seems to be the default indentation, so this will make it less likely
that people will mess up if they don't load the editor config. (I think people
often use vi, and vi has no support to load project-wide configuration
automatically. We distribute a .vimrc file, but it is not loaded by default,
and even the instructions in it seem to discourage its use for security
reasons.)
Also remove the few vim config lines that were left. We should either have them
on all files, or none.
Also remove some strange stuff like '#!/bin/env bash', yikes.
2019-04-04 15:10:42 +03:00
# Detect lib paths
2021-04-16 19:33:44 +03:00
[[ "$libdir" ]] || for libdir in /lib64 /lib; do
2012-05-21 20:55:48 +04:00
[[ -d $libdir ]] && libdirs+=" $libdir" && break
done
2021-04-16 19:33:44 +03:00
[[ "$usrlibdir" ]] || for usrlibdir in /usr/lib64 /usr/lib; do
2012-05-21 20:55:48 +04:00
[[ -d $usrlibdir ]] && libdirs+=" $usrlibdir" && break
done
2017-08-07 18:30:11 +03:00
mkdir -p "$STATEDIR"
2012-05-21 20:55:48 +04:00
import_testdir
2013-11-06 02:32:56 +04:00
import_initdir
2012-05-21 20:55:48 +04:00
2021-04-20 18:47:50 +03:00
if [ -n "${SUDO_USER}" ]; then
ddebug "Making ${TESTDIR:?} readable for ${SUDO_USER} (acquired from sudo)"
setfacl -m "user:${SUDO_USER:?}:r-X" "${TESTDIR:?}"
fi
2021-04-16 19:33:44 +03:00
testname="$(basename "$PWD")"
2020-03-25 15:15:37 +03:00
2012-05-21 20:55:48 +04:00
while (($# > 0)); do
case $1 in
--run)
2020-03-25 15:15:37 +03:00
echo "${testname} RUN: $TEST_DESCRIPTION"
2021-04-26 20:20:18 +03:00
test_run "$TESTID"
2018-09-14 07:25:02 +03:00
ret=$?
2021-04-16 19:33:44 +03:00
if [ $ret -eq 0 ]; then
2020-03-25 15:15:37 +03:00
echo "${testname} RUN: $TEST_DESCRIPTION [OK]"
2012-05-21 20:55:48 +04:00
else
2020-03-25 15:15:37 +03:00
echo "${testname} RUN: $TEST_DESCRIPTION [FAILED]"
2012-05-21 20:55:48 +04:00
fi
2021-07-04 13:21:23 +03:00
exit $ret
;;
2012-05-21 20:55:48 +04:00
--setup)
2020-03-25 15:15:37 +03:00
echo "${testname} SETUP: $TEST_DESCRIPTION"
2012-05-21 20:55:48 +04:00
test_setup
2019-07-12 18:47:26 +03:00
test_setup_cleanup
2017-08-07 22:09:21 +03:00
;;
2020-03-20 21:09:35 +03:00
--clean)
2020-03-25 15:15:37 +03:00
echo "${testname} CLEANUP: $TEST_DESCRIPTION"
2012-05-21 20:55:48 +04:00
test_cleanup
2017-08-07 22:09:21 +03:00
;;
2020-03-20 21:09:35 +03:00
--clean-again)
2020-03-25 15:15:37 +03:00
echo "${testname} CLEANUP AGAIN: $TEST_DESCRIPTION"
2020-03-20 21:09:35 +03:00
test_cleanup_again
;;
2012-05-21 20:55:48 +04:00
--all)
2017-08-07 22:09:21 +03:00
ret=0
2020-03-25 15:15:37 +03:00
echo -n "${testname}: $TEST_DESCRIPTION "
2021-02-17 02:47:34 +03:00
# Do not use a subshell, otherwise cleanup variables (LOOPDEV) will be lost
# and loop devices will leak
test_setup </dev/null >"$TESTLOG" 2>&1 || ret=$?
if [ $ret -eq 0 ]; then
test_setup_cleanup </dev/null >>"$TESTLOG" 2>&1 || ret=$?
fi
if [ $ret -eq 0 ]; then
2021-04-26 20:20:18 +03:00
test_run "$TESTID" </dev/null >>"$TESTLOG" 2>&1 || ret=$?
2021-02-17 02:47:34 +03:00
fi
2019-07-12 21:09:48 +03:00
test_cleanup
2012-05-21 20:55:48 +04:00
if [ $ret -eq 0 ]; then
2017-08-07 18:30:11 +03:00
rm "$TESTLOG"
2012-05-21 20:55:48 +04:00
echo "[OK]"
else
echo "[FAILED]"
2017-08-07 18:30:11 +03:00
echo "see $TESTLOG"
2012-05-21 20:55:48 +04:00
fi
2021-07-04 13:21:23 +03:00
exit $ret
;;
*)
break
;;
2012-05-21 20:55:48 +04:00
esac
shift
done
}