#!/usr/bin/env bash # -*- mode: shell-script; indent-tabs-mode: nil; sh-basic-offset: 4; -*- # ex: ts=8 sw=4 sts=4 et filetype=sh PATH=/sbin:/bin:/usr/sbin:/usr/bin export PATH os_release=$(test -e /etc/os-release && echo /etc/os-release || echo /usr/lib/os-release) LOOKS_LIKE_DEBIAN=$(source $os_release && [[ "$ID" = "debian" || " $ID_LIKE " = *" debian "* ]] && echo yes || :) LOOKS_LIKE_ARCH=$(source $os_release && [[ "$ID" = "arch" || " $ID_LIKE " = *" arch "* ]] && echo yes || :) LOOKS_LIKE_SUSE=$(source $os_release && [[ " $ID_LIKE " = *" suse "* ]] && echo yes || :) KERNEL_VER=${KERNEL_VER-$(uname -r)} KERNEL_MODS="/lib/modules/$KERNEL_VER/" QEMU_TIMEOUT="${QEMU_TIMEOUT:-infinity}" NSPAWN_TIMEOUT="${NSPAWN_TIMEOUT:-infinity}" TIMED_OUT= # will be 1 after run_* if *_TIMEOUT is set and test timed out [[ "$LOOKS_LIKE_SUSE" ]] && FSTYPE="${FSTYPE:-btrfs}" || FSTYPE="${FSTYPE:-ext4}" UNIFIED_CGROUP_HIERARCHY="${UNIFIED_CGROUP_HIERARCHY:-default}" EFI_MOUNT="${EFI_MOUNT:-$(bootctl -x 2>/dev/null || echo /boot)}" QEMU_MEM="${QEMU_MEM:-512M}" IMAGE_NAME=${IMAGE_NAME:-default} TEST_REQUIRE_INSTALL_TESTS="${TEST_REQUIRE_INSTALL_TESTS:-1}" TEST_PARALLELIZE="${TEST_PARALLELIZE:-0}" LOOPDEV= # 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. if [[ -n "$TEST_NESTED_KVM" || ( -z "$TEST_NO_KVM" && $(systemd-detect-virt -v) != kvm ) ]]; then QEMU_KVM=yes else QEMU_KVM=no fi 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 PATH_TO_INIT=$ROOTLIBDIR/systemd [ "$SYSTEMD_JOURNALD" ] || SYSTEMD_JOURNALD=$(which -a $BUILD_DIR/systemd-journald $ROOTLIBDIR/systemd-journald 2>/dev/null | grep '^/' -m1) [ "$SYSTEMD_JOURNAL_REMOTE" ] || SYSTEMD_JOURNAL_REMOTE=$(which -a $BUILD_DIR/systemd-journal-remote $ROOTLIBDIR/systemd-journal-remote 2>/dev/null | grep '^/' -m1) [ "$SYSTEMD" ] || SYSTEMD=$(which -a $BUILD_DIR/systemd $ROOTLIBDIR/systemd 2>/dev/null | grep '^/' -m1) [ "$SYSTEMD_NSPAWN" ] || SYSTEMD_NSPAWN=$(which -a $BUILD_DIR/systemd-nspawn systemd-nspawn 2>/dev/null | grep '^/' -m1) [ "$JOURNALCTL" ] || JOURNALCTL=$(which -a $BUILD_DIR/journalctl journalctl 2>/dev/null | grep '^/' -m1) BASICTOOLS=( awk basename bash busybox capsh cat chmod chown cmp cryptsetup cut date dd diff dirname dmsetup echo env false getconf getent getfacl grep gunzip gzip head ionice ip ln loadkeys login lz4cat mkfifo mktemp modprobe mount mountpoint mv nc nproc readlink rev rm rmdir sed seq setfont setsid sfdisk sh sleep socat stat su sulogin sysctl tail tar tee test timeout touch tr true truncate umount uname unshare xargs xzcat ) DEBUGTOOLS=( cp df dhclient dmesg du find free grep hostname id less ln ls mkdir ping ps route sort strace stty tty vi ) STATEDIR="${BUILD_DIR:-.}/test/$(basename $(dirname $(realpath $0)))" STATEFILE="$STATEDIR/.testdir" IMAGESTATEDIR="$STATEDIR/.." TESTLOG="$STATEDIR/test.log" 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 local _asan_calls=$(objdump -dC $SYSTEMD_JOURNALD | egrep "callq\s+[0-9a-f]+\s+<__asan" -c) if (( $_asan_calls < 1000 )); then return 1 else return 0 fi } IS_BUILT_WITH_ASAN=$(is_built_with_asan && echo yes || echo no) if [[ "$IS_BUILT_WITH_ASAN" = "yes" ]]; then STRIP_BINARIES=no SKIP_INITRD="${SKIP_INITRD:-yes}" PATH_TO_INIT=$ROOTLIBDIR/systemd-under-asan QEMU_MEM="2048M" QEMU_SMP=4 # We need to correctly distinguish between gcc's and clang's ASan DSOs. if ldd $SYSTEMD | grep -q libasan.so; then ASAN_COMPILER=gcc elif ldd $SYSTEMD | grep -q libclang_rt.asan; then ASAN_COMPILER=clang # 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) if ldd "$SYSTEMD" | grep -q "libclang_rt.asan.*not found"; then _asan_rt_name="$(ldd $SYSTEMD | awk '/libclang_rt.asan/ {print $1; exit}')" _asan_rt_path="$(find /usr/lib* /usr/local/lib* -type f -name "$_asan_rt_name" 2>/dev/null | sed 1q)" 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%/*}" 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 fi function find_qemu_bin() { # SUSE and Red Hat call the binary qemu-kvm. Debian and Gentoo call it kvm. if [[ $QEMU_KVM == "yes" ]]; then [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a kvm qemu-kvm 2>/dev/null | grep '^/' -m1) fi [ "$ARCH" ] || ARCH=$(uname -m) case $ARCH in x86_64) # QEMU's own build system calls it qemu-system-x86_64 [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a qemu-system-x86_64 2>/dev/null | grep '^/' -m1) ;; i*86) # new i386 version of QEMU [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a qemu-system-i386 2>/dev/null | grep '^/' -m1) # i386 version of QEMU [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a qemu 2>/dev/null | grep '^/' -m1) ;; ppc64*) [ "$QEMU_BIN" ] || QEMU_BIN=$(which -a qemu-system-ppc64 2>/dev/null | grep '^/' -m1) ;; esac if [ ! -e "$QEMU_BIN" ]; then echo "Could not find a suitable QEMU binary" >&2 return 1 fi } # 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 function qemu_min_version() { find_qemu_bin || return 2 # get version from binary qemu_ver=$($QEMU_BIN --version | awk '/^QEMU emulator version ([0-9]*\.[0-9]*\.[0-9]*)/ {print $4}') # 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 } # Return 0 if QEMU did run (then you must check the result state/logs for actual # success), or 1 if QEMU is not available. run_qemu() { if [ -f /etc/machine-id ]; then read MACHINE_ID < /etc/machine-id [ -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" fi CONSOLE=ttyS0 rm -f "$initdir"/{testok,failed,skipped} # make sure the initdir is not mounted to avoid concurrent access cleanup_initdir umount_loopback if [[ ! "$KERNEL_BIN" ]]; then if [[ "$LOOKS_LIKE_ARCH" ]]; then KERNEL_BIN=/boot/vmlinuz-linux else [ "$ARCH" ] || ARCH=$(uname -m) case $ARCH in ppc64*) KERNEL_BIN=/boot/vmlinux-$KERNEL_VER CONSOLE=hvc0 ;; *) KERNEL_BIN=/boot/vmlinuz-$KERNEL_VER ;; esac fi fi default_fedora_initrd=/boot/initramfs-${KERNEL_VER}.img default_debian_initrd=/boot/initrd.img-${KERNEL_VER} default_arch_initrd=/boot/initramfs-linux-fallback.img default_suse_initrd=/boot/initrd-${KERNEL_VER} 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" elif [[ "$LOOKS_LIKE_SUSE" && -e "$default_suse_initrd" ]]; then INITRD="$default_suse_initrd" fi fi # 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). if ! [ "$QEMU_SMP" ]; then if ! QEMU_SMP=$(nproc); then dwarn "nproc utility is not installed, falling back to QEMU_SMP=1" QEMU_SMP=1 fi fi find_qemu_bin || return 1 # Umount initdir to avoid concurrent access to the filesystem _umount_dir $initdir local _cgroup_args if [[ "$UNIFIED_CGROUP_HIERARCHY" = "yes" ]]; then _cgroup_args="systemd.unified_cgroup_hierarchy=yes" elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "no" ]]; then _cgroup_args="systemd.unified_cgroup_hierarchy=no systemd.legacy_systemd_cgroup_controller=yes" elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "hybrid" ]]; then _cgroup_args="systemd.unified_cgroup_hierarchy=no systemd.legacy_systemd_cgroup_controller=no" elif [[ "$UNIFIED_CGROUP_HIERARCHY" != "default" ]]; then dfatal "Unknown UNIFIED_CGROUP_HIERARCHY. Got $UNIFIED_CGROUP_HIERARCHY, expected [yes|no|hybrid|default]" exit 1 fi if [[ "$LOOKS_LIKE_SUSE" ]]; then PARAMS+="rd.hostonly=0" fi local _end if [[ ! "$INTERACTIVE_DEBUG" ]]; then _end="systemd.wants=end.service" else _end="" fi KERNEL_APPEND="$PARAMS \ root=/dev/sda1 \ rw \ raid=noautodetect \ rd.luks=0 \ loglevel=2 \ init=$PATH_TO_INIT \ console=$CONSOLE \ selinux=0 \ $_cgroup_args \ 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 ${_end} \ $KERNEL_APPEND \ " [ -e "$IMAGE_PRIVATE" ] && image="$IMAGE_PRIVATE" || image="$IMAGE_PUBLIC" QEMU_OPTIONS="-smp $QEMU_SMP \ -net none \ -m $QEMU_MEM \ -nographic \ -kernel $KERNEL_BIN \ -drive format=raw,cache=unsafe,file=$image \ $QEMU_OPTIONS \ " if [[ "$INITRD" && "$SKIP_INITRD" != "yes" ]]; then QEMU_OPTIONS="$QEMU_OPTIONS -initrd $INITRD" fi # Let's use KVM if possible if [[ -c /dev/kvm && $QEMU_KVM == "yes" ]]; then QEMU_OPTIONS="$QEMU_OPTIONS -machine accel=kvm -enable-kvm -cpu host" fi if [[ "$QEMU_TIMEOUT" != "infinity" ]]; then QEMU_BIN="timeout --foreground $QEMU_TIMEOUT $QEMU_BIN" fi (set -x; $QEMU_BIN $QEMU_OPTIONS -append "$KERNEL_APPEND") rc=$? if [ "$rc" = 124 ] && [ "$QEMU_TIMEOUT" != "infinity" ]; then derror "test timed out after $QEMU_TIMEOUT s" TIMED_OUT=1 else [ "$rc" != 0 ] && derror "QEMU failed with exit code $rc" fi return 0 } # Return 0 if nspawn did run (then you must check the result state/logs for actual # success), or 1 if nspawn is not available. run_nspawn() { [[ -d /run/systemd/system ]] || return 1 rm -f "$initdir"/{testok,failed,skipped} local _nspawn_cmd=( --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: $PATH_TO_INIT $KERNEL_APPEND systemd.unit=testsuite.target systemd.wants=testsuite-$2.service ) if [[ ! "$INTERACTIVE_DEBUG" ]]; then _nspawn_cmd+=( systemd.wants=end.service ) fi local _nspawn_pre if [[ "$NSPAWN_TIMEOUT" != "infinity" ]]; then _nspawn_pre=(timeout --foreground $NSPAWN_TIMEOUT) else _nspawn_pre=() fi if [[ "$UNIFIED_CGROUP_HIERARCHY" = "hybrid" ]]; then dwarn "nspawn doesn't support SYSTEMD_NSPAWN_UNIFIED_HIERARCHY=hybrid, skipping" exit elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "yes" || "$UNIFIED_CGROUP_HIERARCHY" = "no" ]]; then _nspawn_pre=("${_nspawn_pre[@]}" env SYSTEMD_NSPAWN_UNIFIED_HIERARCHY=$UNIFIED_CGROUP_HIERARCHY) elif [[ "$UNIFIED_CGROUP_HIERARCHY" = "default" ]]; then _nspawn_pre=("${_nspawn_pre[@]}" env --unset=UNIFIED_CGROUP_HIERARCHY --unset=SYSTEMD_NSPAWN_UNIFIED_HIERARCHY) else dfatal "Unknown UNIFIED_CGROUP_HIERARCHY. Got $UNIFIED_CGROUP_HIERARCHY, expected [yes|no|hybrid|default]" exit 1 fi (set -x; "${_nspawn_pre[@]}" "$SYSTEMD_NSPAWN" $NSPAWN_ARGUMENTS "${_nspawn_cmd[@]}") rc=$? if [ "$rc" = 124 ] && [ "$NSPAWN_TIMEOUT" != "infinity" ]; then derror "test timed out after $NSPAWN_TIMEOUT s" TIMED_OUT=1 else [ "$rc" != 0 ] && derror "nspawn failed with exit code $rc" fi return 0 } setup_basic_environment() { # create the basic filesystem layout setup_basic_dirs install_systemd install_missing_libraries install_config_files install_zoneinfo create_rc_local install_basic_tools install_libnss install_pam install_dbus install_fonts install_keymaps install_terminfo install_execs install_fsck install_plymouth install_debug_tools install_ld_so_conf install_testuser has_user_dbus_socket && install_user_dbus setup_selinux strip_binaries install_depmod_files generate_module_dependencies if [[ "$IS_BUILT_WITH_ASAN" = "yes" ]]; then create_asan_wrapper fi } setup_selinux() { # don't forget KERNEL_APPEND='... selinux=1 ...' if [[ "$SETUP_SELINUX" != "yes" ]]; then ddebug "Don't setup SELinux" return 0 fi ddebug "Setup SELinux" local _conf_dir=/etc/selinux local _fixfiles_tools="bash uname cat sort uniq awk grep egrep head expr find rm secon setfiles" rm -rf $initdir/$_conf_dir if ! cp -ar $_conf_dir $initdir/$_conf_dir; then dfatal "Failed to copy $_conf_dir" exit 1 fi 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/ dracut_install $_fixfiles_tools dracut_install fixfiles dracut_install sestatus } install_valgrind() { if ! type -p valgrind; then dfatal "Failed to install valgrind" exit 1 fi local _valgrind_bins=$(strace -e execve valgrind /bin/true 2>&1 >/dev/null | perl -lne 'print $1 if /^execve\("([^"]+)"/') dracut_install $_valgrind_bins local _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 local _valgrind_dbg_and_supp=$( strace -e open valgrind /bin/true 2>&1 >/dev/null | perl -lne 'if (my ($fname) = /^open\("([^"]+).*= (?!-)\d+/) { print $fname if $fname =~ /debug|\.supp$/ }' ) dracut_install $_valgrind_dbg_and_supp } create_valgrind_wrapper() { local _valgrind_wrapper=$initdir/$ROOTLIBDIR/systemd-under-valgrind ddebug "Create $_valgrind_wrapper" cat >$_valgrind_wrapper <$_asan_wrapper < not found" issues in the future export PATH="/sbin:/bin:/usr/sbin:/usr/bin" mount -t proc proc /proc mount -t sysfs sysfs /sys mount -o remount,rw / PATH_TO_ASAN=\$(find / -name '$_asan_rt_pattern' | sed 1q) if [[ "\$PATH_TO_ASAN" ]]; then # 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=\$PATH_TO_ASAN" # 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. echo \${PATH_TO_ASAN%/*} > /etc/ld.so.conf.d/asan-path-override.conf ldconfig fi echo DefaultEnvironment=\$DEFAULT_ENVIRONMENT >>/etc/systemd/system.conf echo DefaultTimeoutStartSec=180s >>/etc/systemd/system.conf echo DefaultStandardOutput=journal+console >>/etc/systemd/system.conf # ASAN and syscall filters aren't compatible with each other. find / -name '*.service' -type f | xargs sed -i 's/^\\(MemoryDeny\\|SystemCall\\)/#\\1/' # 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" 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" # 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" # 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. # Let's limit which environments such services should be executed in. mkdir -p /etc/systemd/system/systemd-hwdb-update.service.d printf "[Unit]\nConditionVirtualization=container\n\n[Service]\nTimeoutSec=240s\n" >/etc/systemd/system/systemd-hwdb-update.service.d/env-override.conf # 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 # 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 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 unset_ld_preload testsuite- export ASAN_OPTIONS=\$DEFAULT_ASAN_OPTIONS:log_path=/systemd.asan.log UBSAN_OPTIONS=\$DEFAULT_UBSAN_OPTIONS exec $ROOTLIBDIR/systemd "\$@" EOF chmod 0755 $_asan_wrapper } create_strace_wrapper() { local _strace_wrapper=$initdir/$ROOTLIBDIR/systemd-under-strace ddebug "Create $_strace_wrapper" cat >$_strace_wrapper <> $initdir/etc/systemd/system.conf # store coredumps in journal echo Storage=journal >> $initdir/etc/systemd/coredump.conf } get_ldpath() { local _bin="$1" local rpath=$(objdump -p "$_bin" 2>/dev/null | awk "/R(UN)?PATH/ { print \"$initdir\" \$2 }" | paste -sd :) if [ -z "$rpath" ] ; then echo $BUILD_DIR else echo $rpath fi } install_missing_libraries() { # install possible missing libraries 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):$(get_ldpath $i)/src/udev" inst_libs $i done # A number of dependencies is now optional via dlopen, so the install # script will not pick them up, since it looks at linkage. for lib in libcryptsetup libidn libidn2 pwquality libqrencode tss2-esys tss2-rc tss2-mu libfido2; do if pkg-config --exists ${lib}; then path=$(pkg-config --variable=libdir ${lib}) if ! [[ ${lib} =~ ^lib ]]; then lib="lib${lib}" fi inst_libs "${path}/${lib}.so" inst_library "${path}/${lib}.so" fi done } cleanup_loopdev() { if [ -n "${LOOPDEV}" ]; then ddebug "losetup -d $LOOPDEV" losetup -d "${LOOPDEV}" unset LOOPDEV fi } trap cleanup_loopdev EXIT INT QUIT PIPE create_empty_image() { if [ -z "$IMAGE_NAME" ]; then echo "create_empty_image: \$IMAGE_NAME not set" exit 1 fi local _size=500 if [[ "$STRIP_BINARIES" = "no" ]]; then _size=$((4*_size)) fi echo "Setting up $IMAGE_PUBLIC (${_size} MB)" rm -f "$IMAGE_PRIVATE" "$IMAGE_PUBLIC" # Create the blank file to use as a root filesystem truncate -s "${_size}M" "$IMAGE_PUBLIC" LOOPDEV=$(losetup --show -P -f "$IMAGE_PUBLIC") [ -b "$LOOPDEV" ] || return 1 sfdisk "$LOOPDEV" < undef, ); } print $2 if /\s(\S*)\[(\d+)\]:\s*SUMMARY:\s+\w+Sanitizer/ && !exists $services_to_ignore{$1}' ) if [[ ! -z "$pids" ]]; then ret=$(($ret+1)) for pid in $pids; do "$JOURNALCTL" -D "$root/var/log/journal" _PID=$pid --no-pager done fi fi return $ret } save_journal() { if [ -n "${ARTIFACT_DIRECTORY}" ]; then dest="${ARTIFACT_DIRECTORY}/${testname}.journal" else dest="$TESTDIR/system.journal" fi for j in $1/*; do $SYSTEMD_JOURNAL_REMOTE \ -o $dest \ --getter="$JOURNALCTL -o export -D $j" if [ -n "${TEST_SHOW_JOURNAL}" ]; then echo "---- $j ----" $JOURNALCTL --no-pager -o short-monotonic --no-hostname --priority=${TEST_SHOW_JOURNAL} -D $j fi rm -r $j done # we want to print this sometime later, so save this in a variable JOURNAL_LIST="$(ls -l $dest*)" } check_result_nspawn() { local ret=1 local journald_report="" local pids="" [[ -e $1/testok ]] && ret=0 [[ -f $1/failed ]] && cp -a $1/failed $TESTDIR save_journal $1/var/log/journal [[ -f $TESTDIR/failed ]] && cat $TESTDIR/failed echo $JOURNAL_LIST test -s $TESTDIR/failed && ret=$(($ret+1)) [ -n "$TIMED_OUT" ] && ret=$(($ret+1)) check_asan_reports "$1" || ret=$(($ret+1)) _umount_dir $initdir return $ret } # can be overridden in specific test check_result_qemu() { local ret=1 mount_initdir [[ -e $initdir/testok ]] && ret=0 [[ -f $initdir/failed ]] && cp -a $initdir/failed $TESTDIR save_journal $initdir/var/log/journal check_asan_reports "$initdir" || ret=$(($ret+1)) _umount_dir $initdir [[ -f $TESTDIR/failed ]] && cat $TESTDIR/failed echo $JOURNAL_LIST test -s $TESTDIR/failed && ret=$(($ret+1)) [ -n "$TIMED_OUT" ] && ret=$(($ret+1)) return $ret } strip_binaries() { if [[ "$STRIP_BINARIES" = "no" ]]; then ddebug "Don't strip binaries" return 0 fi ddebug "Strip binaries" find "$initdir" -executable -not -path '*/lib/modules/*.ko' -type f | \ xargs strip --strip-unneeded |& \ grep -vi 'file format not recognized' | \ ddebug } create_rc_local() { mkdir -p $initdir/etc/rc.d cat >$initdir/etc/rc.d/rc.local <$initdir/etc/sysusers.d/testuser.conf < $initdir/etc/environment > $initdir/etc/machine-id # set the hostname echo systemd-testsuite > $initdir/etc/hostname # let's set up just one image with the traditional verbose output 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 fi } install_basic_tools() { dracut_install "${BASICTOOLS[@]}" dracut_install -o sushell # in Debian ldconfig is just a shell script wrapper around ldconfig.real dracut_install -o ldconfig.real } install_debug_tools() { dracut_install "${DEBUGTOOLS[@]}" if [[ $INTERACTIVE_DEBUG ]]; then # Set default TERM from vt220 to linux, so at least basic key shortcuts work 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" cat > "$initdir/etc/motd" << EOF To adjust the terminal size use: export COLUMNS=xx export LINES=yy or stty cols xx rows yy EOF fi } install_libnss() { # install libnss_files for login NSS_LIBS=$(LD_DEBUG=files getent passwd 2>&1 >/dev/null |sed -n '/calling init: .*libnss_/ {s!^.* /!/!; p}') dracut_install $NSS_LIBS } install_dbus() { inst $ROOTLIBDIR/system/dbus.socket # Newer Fedora versions use dbus-broker by default. Let's install it if it's available. if [ -f $ROOTLIBDIR/system/dbus-broker.service ]; then inst $ROOTLIBDIR/system/dbus-broker.service inst_symlink /etc/systemd/system/dbus.service inst /usr/bin/dbus-broker inst /usr/bin/dbus-broker-launch elif [ -f $ROOTLIBDIR/system/dbus-daemon.service ]; then # Fedora rawhide replaced dbus.service with dbus-daemon.service inst $ROOTLIBDIR/system/dbus-daemon.service # Alias symlink inst_symlink /etc/systemd/system/dbus.service else inst $ROOTLIBDIR/system/dbus.service fi find \ /etc/dbus-1 /usr/share/dbus-1 -xtype f \ | while read file; do inst $file done # setup policy for Type=dbus test mkdir -p $initdir/etc/dbus-1/system.d cat > $initdir/etc/dbus-1/system.d/systemd.test.ExecStopPost.conf < EOF } install_user_dbus() { local userunitdir if ! userunitdir=$(pkg-config --variable=systemduserunitdir systemd); then echo "WARNING! Cannot determine userunitdir from pkg-config, assuming /usr/lib/systemd/user" >&2 local userunitdir=/usr/lib/systemd/user fi inst $userunitdir/dbus.socket inst_symlink $userunitdir/sockets.target.wants/dbus.socket || inst_symlink /etc/systemd/user/sockets.target.wants/dbus.socket # Append the After= dependency on dbus in case it isn't already set up mkdir -p "$initdir/etc/systemd/system/user@.service.d/" cat <"$initdir/etc/systemd/system/user@.service.d/dbus.conf" [Unit] After=dbus.service EOF # Newer Fedora versions use dbus-broker by default. Let's install it if it's available. if [ -f $userunitdir/dbus-broker.service ]; then inst $userunitdir/dbus-broker.service inst_symlink /etc/systemd/user/dbus.service elif [ -f $ROOTLIBDIR/system/dbus-daemon.service ]; then # Fedora rawhide replaced dbus.service with dbus-daemon.service inst $userunitdir/dbus-daemon.service # Alias symlink inst_symlink /etc/systemd/user/dbus.service else inst $userunitdir/dbus.service fi } install_pam() { ( if [[ "$LOOKS_LIKE_DEBIAN" ]] && type -p dpkg-architecture &>/dev/null; then find "/lib/$(dpkg-architecture -qDEB_HOST_MULTIARCH)/security" -xtype f else find /lib*/security -xtype f fi for d in /etc/pam.d /etc/security /usr/lib/pam.d; do [ -d "$d" ] && find $d -xtype f done ) | while read file; do inst $file done # pam_unix depends on unix_chkpwd. # see http://www.linux-pam.org/Linux-PAM-html/sag-pam_unix.html dracut_install -o unix_chkpwd # set empty root password for easy debugging sed -i 's/^root:x:/root::/' $initdir/etc/passwd } install_keymaps() { # The first three paths may be deprecated. # It seems now the last two paths are used by many distributions. for i in \ /usr/lib/kbd/keymaps/include/* \ /usr/lib/kbd/keymaps/i386/include/* \ /usr/lib/kbd/keymaps/i386/qwerty/us.* \ /usr/lib/kbd/keymaps/legacy/include/* \ /usr/lib/kbd/keymaps/legacy/i386/qwerty/us.*; do [[ -f $i ]] || continue inst $i done # When it takes any argument, then install more keymaps. if [[ -n $1 ]]; then for i in \ /usr/lib/kbd/keymaps/i386/*/* \ /usr/lib/kbd/keymaps/legacy/i386/*/*; do [[ -f $i ]] || continue inst $i done fi } install_zoneinfo() { 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 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 } install_fonts() { for i in \ /usr/lib/kbd/consolefonts/eurlatgr* \ /usr/lib/kbd/consolefonts/latarcyrheb-sun16*; do [[ -f $i ]] || continue inst $i done } install_terminfo() { for _terminfodir in /lib/terminfo /etc/terminfo /usr/share/terminfo; do [ -f ${_terminfodir}/l/linux ] && break done dracut_install -o ${_terminfodir}/l/linux } 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 } setup_nspawn_root() { if [ -z "${initdir}" ]; then dfatal "\$initdir not defined" exit 1 fi rm -rf "$TESTDIR/unprivileged-nspawn-root" if [[ "$RUN_IN_UNPRIVILEGED_CONTAINER" = "yes" ]]; then ddebug "cp -ar $initdir $TESTDIR/unprivileged-nspawn-root" cp -ar $initdir $TESTDIR/unprivileged-nspawn-root fi } setup_basic_dirs() { mkdir -p $initdir/run mkdir -p $initdir/etc/systemd/system mkdir -p $initdir/var/log/journal for d in usr/bin usr/sbin bin etc lib "$libdir" sbin tmp usr var var/log dev proc sys sysroot root run run/lock run/initramfs; do if [ -L "/$d" ]; then inst_symlink "/$d" else inst_dir "/$d" fi done ln -sfn /run "$initdir/var/run" ln -sfn /run/lock "$initdir/var/lock" } mask_supporting_services() { # mask some services that we do not want to run in these tests ln -fs /dev/null $initdir/etc/systemd/system/systemd-hwdb-update.service ln -fs /dev/null $initdir/etc/systemd/system/systemd-journal-catalog-update.service ln -fs /dev/null $initdir/etc/systemd/system/systemd-networkd.service ln -fs /dev/null $initdir/etc/systemd/system/systemd-networkd.socket ln -fs /dev/null $initdir/etc/systemd/system/systemd-resolved.service } inst_libs() { local _bin=$1 local _so_regex='([^ ]*/lib[^/]*/[^ ]*\.so[^ ]*)' local _file _line LC_ALL=C ldd "$_bin" 2>/dev/null | while read _line; do [[ $_line = 'not a dynamic executable' ]] && break if [[ $_line =~ $_so_regex ]]; then _file=${BASH_REMATCH[1]} [[ -e ${initdir}/$_file ]] && continue inst_library "$_file" continue fi 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" dfatal "dracut cannot create an initrd." exit 1 fi done } import_testdir() { # make sure we don't get a stale LOOPDEV value from old times __LOOPDEV=$LOOPDEV [[ -e $STATEFILE ]] && . $STATEFILE LOOPDEV=$__LOOPDEV if [[ ! -d "$TESTDIR" ]]; then if [[ -z "$TESTDIR" ]]; then TESTDIR=$(mktemp --tmpdir=/var/tmp -d -t systemd-test.XXXXXX) else mkdir -p "$TESTDIR" fi cat >$STATEFILE< # 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 # Prints the relative path, when creating a symlink to 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 set -- "$(normalize_path "$1")" "$(normalize_path "$2")" # corner case #1 - self looping link [[ "$1" == "$2" ]] && { echo "${1##*/}"; return; } # corner case #2 - own dir link [[ "${1%/*}" == "$2" ]] && { echo "."; return; } IFS="/" __current=($1) IFS="/" __absolute=($2) __abssize=${#__absolute[@]} __cursize=${#__current[@]} while [[ ${__absolute[__level]} == ${__current[__level]} ]] 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() { [[ -e ${initdir}/"$1" ]] && return 0 # already there local _dir="$1" _part="${1%/*}" _file while [[ "$_part" != "${_part%/*}" ]] && ! [[ -e "${initdir}/${_part}" ]]; do _dir="$_part $_dir" _part=${_part%/*} done # iterate over parent directories for _file in $_dir; do [[ -e "${initdir}/$_file" ]] && continue if [[ -L $_file ]]; then inst_symlink "$_file" else # create directory mkdir -m 0755 -p "${initdir}/$_file" || return 1 [[ -e "$_file" ]] && chmod --reference="$_file" "${initdir}/$_file" chmod u+w "${initdir}/$_file" 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() { [[ -f "$1" ]] || return 1 strstr "$1" "/" || return 1 local _src=$1 target="${2:-$1}" if ! [[ -d ${initdir}/$target ]]; then [[ -e ${initdir}/$target ]] && return 0 [[ -L ${initdir}/$target ]] && return 0 [[ -d "${initdir}/${target%/*}" ]] || inst_dir "${target%/*}" fi # install checksum files also if [[ -e "${_src%/*}/.${_src##*/}.hmac" ]]; then inst "${_src%/*}/.${_src##*/}.hmac" "${target%/*}/.${target##*/}.hmac" fi ddebug "Installing $_src" cp --sparse=always -pfL "$_src" "${initdir}/$target" } # 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() { [[ ! $1 ]] && return 0 local fn="$1" orig="$(readlink -f "$1")" links='' [[ ${fn} =~ .*\.so\..* ]] || return 1 until [[ ${fn##*.} == so ]]; do fn="${fn%.*}" [[ -L ${fn} && $(readlink -f "${fn}") == ${orig} ]] && links+=" ${fn}" 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() { local _src="$1" _dest=${2:-$1} _lib _reallib _symlink strstr "$1" "/" || return 1 [[ -e $initdir/$_dest ]] && return 0 if [[ -L $_src ]]; then # install checksum files also if [[ -e "${_src%/*}/.${_src##*/}.hmac" ]]; then inst "${_src%/*}/.${_src##*/}.hmac" "${_dest%/*}/.${_dest##*/}.hmac" fi _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}" else inst_simple "$_src" "$_dest" fi # Create additional symlinks. See rev_symlinks description. for _symlink in $(rev_lib_symlinks $_src) $(rev_lib_symlinks $_reallib); do [[ -e $initdir/$_symlink ]] || { ddebug "Creating extra symlink: $_symlink" inst_symlink $_symlink } done } # find a binary. If we were not passed the full path directly, # search in the usual places to find the binary. find_binary() { if [[ -z ${1##/*} ]]; then if [[ -x $1 ]] || { strstr "$1" ".so" && ldd $1 &>/dev/null; }; then echo $1 return 0 fi fi type -P $1 } # Same as above, but specialized to install binary executables. # Install binary executable, and all shared library dependencies, if any. inst_binary() { local _bin _target # 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. [[ $# -eq 1 && -e $initdir/$1 || -e $initdir/bin/$1 || -e $initdir/sbin/$1 || -e $initdir/usr/bin/$1 || -e $initdir/usr/sbin/$1 ]] && return 0 _bin=$(find_binary "$1") || 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[^ ]*)' # I love bash! LC_ALL=C ldd "$_bin" 2>/dev/null | while read _line; do [[ $_line = 'not a dynamic executable' ]] && break if [[ $_line =~ $_so_regex ]]; then _file=${BASH_REMATCH[1]} [[ -e ${initdir}/$_file ]] && continue inst_library "$_file" continue fi 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" dfatal "dracut cannot create an initrd." exit 1 fi done inst_simple "$_bin" "$_target" } # same as above, except for shell scripts. # If your shell script does not start with shebang, it is not a shell script. inst_script() { local _bin _bin=$(find_binary "$1") || return 1 shift local _line _shebang_regex read -r -n 80 _line <"$_bin" # If debug is set, clean unprintable chars to prevent messing up the term [[ $debug ]] && _line=$(echo -n "$_line" | tr -c -d '[:print:][:space:]') _shebang_regex='(#! *)(/[^ ]+).*' [[ $_line =~ $_shebang_regex ]] || return 1 inst "${BASH_REMATCH[2]}" && inst_simple "$_bin" "$@" } # same as above, but specialized for symlinks inst_symlink() { local _src=$1 _target=${2:-$1} _realsrc strstr "$1" "/" || return 1 [[ -L $1 ]] || return 1 [[ -L $initdir/$_target ]] && return 0 _realsrc=$(readlink -f "$_src") if ! [[ -e $initdir/$_realsrc ]]; then if [[ -d $_realsrc ]]; then inst_dir "$_realsrc" else inst "$_realsrc" fi fi [[ ! -e $initdir/${_target%/*} ]] && inst_dir "${_target%/*}" [[ -d ${_target%/*} ]] && _target=$(readlink -f ${_target%/*})/${_target##*/} ln -sfn $(convert_abs_rel "${_target}" "${_realsrc}") "$initdir/$_target" } # attempt to install any programs specified in a udev rule inst_rule_programs() { local _prog _bin if grep -qE 'PROGRAM==?"[^ "]+' "$1"; then for _prog in $(grep -E 'PROGRAM==?"[^ "]+' "$1" | sed -r 's/.*PROGRAM==?"([^ "]+).*/\1/'); do if [ -x /lib/udev/$_prog ]; then _bin=/lib/udev/$_prog else _bin=$(find_binary "$_prog") || { dinfo "Skipping program $_prog using in udev rule $(basename $1) as it cannot be found" continue; } fi #dinfo "Installing $_bin due to it's use in the udev rule $(basename $1)" dracut_install "$_bin" done fi } # udev rules always get installed in the same place, so # create a function to install them to make life simpler. inst_rules() { local _target=/etc/udev/rules.d _rule _found inst_dir "/lib/udev/rules.d" inst_dir "$_target" for _rule in "$@"; do if [ "${rule#/}" = "$rule" ]; then for r in /lib/udev/rules.d /etc/udev/rules.d; do if [[ -f $r/$_rule ]]; then _found="$r/$_rule" inst_simple "$_found" inst_rule_programs "$_found" fi done fi for r in '' ./ $dracutbasedir/rules.d/; do if [[ -f ${r}$_rule ]]; then _found="${r}$_rule" inst_simple "$_found" "$_target/${_found##*/}" inst_rule_programs "$_found" fi done [[ $_found ]] || dinfo "Skipping udev rule: $_rule" _found= done } # general purpose installation function # Same args as above. inst() { local _x case $# in 1) ;; 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;; esac for _x in inst_symlink inst_script inst_binary inst_simple; do $_x "$@" && return 0 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() { local to f [[ $1 = '-d' ]] && to="$2" && shift 2 for f in "$@"; do if [[ -e $f ]]; then [[ $to ]] && inst "$f" "$to" && return 0 inst "$f" && return 0 fi done return 1 } # dracut_install [-o ] [ ... ] # Install to the initramfs image # -o optionally install the and don't fail, if it is not there dracut_install() { local _optional=no if [[ $1 = '-o' ]]; then _optional=yes shift fi while (($# > 0)); do if ! inst "$1" ; then if [[ $_optional = yes ]]; then dinfo "Skipping program $1 as it cannot be found and is" \ "flagged to be optional" else dfatal "Failed to install $1" exit 1 fi fi shift done } # Install a single kernel module along with any firmware it may require. # $1 = full path to kernel module to install install_kmod_with_fw() { # no need to go further if the module is already installed [[ -e "${initdir}/lib/modules/$KERNEL_VER/${1##*/lib/modules/$KERNEL_VER/}" ]] \ && return 0 [[ -e "$initdir/.kernelmodseen/${1##*/}" ]] && return 0 if [[ $omit_drivers ]]; then local _kmod=${1##*/} _kmod=${_kmod%.ko} _kmod=${_kmod/-/_} if [[ "$_kmod" =~ $omit_drivers ]]; then dinfo "Omitting driver $_kmod" return 1 fi if [[ "${1##*/lib/modules/$KERNEL_VER/}" =~ $omit_drivers ]]; then dinfo "Omitting driver $_kmod" return 1 fi fi [ -d "$initdir/.kernelmodseen" ] && \ > "$initdir/.kernelmodseen/${1##*/}" inst_simple "$1" "/lib/modules/$KERNEL_VER/${1##*/lib/modules/$KERNEL_VER/}" \ || return $? local _modname=${1##*/} _fwdir _found _fw _modname=${_modname%.ko*} for _fw in $(modinfo -k $KERNEL_VER -F firmware $1 2>/dev/null); do _found='' for _fwdir in $fw_dir; do if [[ -d $_fwdir && -f $_fwdir/$_fw ]]; then inst_simple "$_fwdir/$_fw" "/lib/firmware/$_fw" _found=yes fi done if [[ $_found != yes ]]; then if ! grep -qe "\<${_modname//-/_}\>" /proc/modules; then dinfo "Possible missing firmware \"${_fw}\" for kernel module" \ "\"${_modname}.ko\"" else dwarn "Possible missing firmware \"${_fw}\" for kernel module" \ "\"${_modname}.ko\"" fi fi done 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 # _fderr specifies FD passed from surrounding scope for_each_kmod_dep() { local _func=$1 _kmod=$2 _cmd _modpath _options _found=0 shift 2 modprobe "$@" --ignore-install --show-depends $_kmod 2>&${_fderr} | ( while read _cmd _modpath _options; do [[ $_cmd = insmod ]] || continue $_func ${_modpath} || exit $? _found=1 done [[ $_found -eq 0 ]] && exit 1 exit 0 ) } # filter kernel modules to install certain modules that meet specific # requirements. # $1 = search only in subdirectory of /kernel/$1 # $2 = function to call with module name to filter. # This function will be passed the full path to the module to test. # The behavior of this function can vary depending on whether $hostonly is set. # If it is, we will only look at modules that are already in memory. # If it is not, we will look at all kernel modules # This function returns the full filenames of modules that match $1 filter_kernel_modules_by_path () ( local _modname _filtercmd if ! [[ $hostonly ]]; then _filtercmd='find "$KERNEL_MODS/kernel/$1" "$KERNEL_MODS/extra"' _filtercmd+=' "$KERNEL_MODS/weak-updates" -name "*.ko" -o -name "*.ko.gz"' _filtercmd+=' -o -name "*.ko.xz"' _filtercmd+=' 2>/dev/null' else _filtercmd='cut -d " " -f 1 $initdir/$$.ko $2 $initdir/$$.ko && echo "$_modname" rm -f $initdir/$$.ko ;; *.ko.xz) xz -dc "$_modname" > $initdir/$$.ko $2 $initdir/$$.ko && echo "$_modname" rm -f $initdir/$$.ko ;; esac done ) find_kernel_modules_by_path () ( if ! [[ $hostonly ]]; then find "$KERNEL_MODS/kernel/$1" "$KERNEL_MODS/extra" "$KERNEL_MODS/weak-updates" \ -name "*.ko" -o -name "*.ko.gz" -o -name "*.ko.xz" 2>/dev/null else cut -d " " -f 1 /dev/null fi ) filter_kernel_modules () { filter_kernel_modules_by_path drivers "$1" } find_kernel_modules () { find_kernel_modules_by_path drivers } # instmods [-c] [ ... ] # instmods [-c] # install kernel modules along with all their dependencies. # can be e.g. "=block" or "=drivers/usb/storage" instmods() { [[ $no_kernel = yes ]] && return # called [sub]functions inherit _fderr local _fderr=9 local _check=no if [[ $1 = '-c' ]]; then _check=yes shift fi function inst1mod() { local _ret=0 _mod="$1" case $_mod in =*) if [ -f $KERNEL_MODS/modules.${_mod#=} ]; then ( [[ "$_mpargs" ]] && echo $_mpargs cat "${KERNEL_MODS}/modules.${_mod#=}" ) \ | instmods else ( [[ "$_mpargs" ]] && echo $_mpargs find "$KERNEL_MODS" -path "*/${_mod#=}/*" -type f -printf '%f\n' ) \ | instmods fi ;; --*) _mpargs+=" $_mod" ;; i2o_scsi) return ;; # Do not load this diagnostic-only module *) _mod=${_mod##*/} # if we are already installed, skip this module and go on # to the next one. [[ -f "$initdir/.kernelmodseen/${_mod%.ko}.ko" ]] && return if [[ $omit_drivers ]] && [[ "$1" =~ $omit_drivers ]]; then dinfo "Omitting driver ${_mod##$KERNEL_MODS}" return fi # If we are building a host-specific initramfs and this # module is not already loaded, move on to the next one. [[ $hostonly ]] && ! grep -qe "\<${_mod//-/_}\>" /proc/modules \ && ! echo $add_drivers | grep -qe "\<${_mod}\>" \ && return # 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. local _moddirname=${KERNEL_MODS%%/lib/modules/*} [[ -n ${_moddirname} ]] && _moddirname="-d ${_moddirname}/" # ok, load the module, all its dependencies, and any firmware # it may require for_each_kmod_dep install_kmod_with_fw $_mod \ --set-version $KERNEL_VER ${_moddirname} $_mpargs ((_ret+=$?)) ;; esac return $_ret } function instmods_1() { local _mod _mpargs if (($# == 0)); then # filenames from stdin while read _mod; do inst1mod "${_mod%.ko*}" || { if [ "$_check" = "yes" ]; then dfatal "Failed to install $_mod" return 1 fi } done fi while (($# > 0)); do # filenames as arguments inst1mod ${1%.ko*} || { if [ "$_check" = "yes" ]; then dfatal "Failed to install $1" return 1 fi } shift done return 0 } local _ret _filter_not_found='FATAL: Module .* not found.' set -o pipefail # Capture all stderr from modprobe to _fderr. We could use {var}>... # redirections, but that would make dracut require bash4 at least. eval "( instmods_1 \"\$@\" ) ${_fderr}>&1" \ | while read line; do [[ "$line" =~ $_filter_not_found ]] && echo $line || echo $line >&2 ;done | derror _ret=$? set +o pipefail return $_ret } setup_suse() { ln -fs ../usr/bin/systemctl $initdir/bin/ ln -fs ../usr/lib/systemd $initdir/lib/ inst_simple "/usr/lib/systemd/system/haveged.service" instmods ext4 } _umount_dir() { if mountpoint -q $1; then ddebug "umount $1" umount $1 fi } # can be overridden in specific test test_setup_cleanup() { cleanup_initdir } _test_cleanup() { # (post-test) cleanup should always ignore failure and cleanup as much as possible ( set +e _umount_dir $initdir rm -vf "$IMAGE_PUBLIC" rm -vfr "$TESTDIR" rm -vf "$STATEFILE" ) || : } # can be overridden in specific test test_cleanup() { _test_cleanup } test_cleanup_again() { [ -n "$TESTDIR" ] || return rm -rf "$TESTDIR/unprivileged-nspawn-root" _umount_dir $initdir } test_create_image() { create_empty_image_rootdir # Create what will eventually be our root filesystem onto an overlay ( LOG_LEVEL=5 setup_basic_environment mask_supporting_services ) } test_setup() { if [ ${TEST_REQUIRE_INSTALL_TESTS} -ne 0 ] && \ type -P meson >/dev/null && \ [[ "$(meson configure $BUILD_DIR | grep install-tests | awk '{ print $2 }')" != "true" ]]; then dfatal "$BUILD_DIR needs to be built with -Dinstall-tests=true" exit 1 fi if [ -e "$IMAGE_PRIVATE" ]; then echo "Reusing existing image $IMAGE_PRIVATE → $(realpath $IMAGE_PRIVATE)" mount_initdir else if [ ! -e "$IMAGE_PUBLIC" ]; then # 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. test_create_image test_setup_cleanup umount_loopback cleanup_loopdev fi echo "Reusing existing cached image $IMAGE_PUBLIC → $(realpath $IMAGE_PUBLIC)" if [ ${TEST_PARALLELIZE} -ne 0 ]; then cp -v "$(realpath $IMAGE_PUBLIC)" "$IMAGE_PRIVATE" else ln -sv "$(realpath $IMAGE_PUBLIC)" "$IMAGE_PRIVATE" fi mount_initdir fi setup_nspawn_root } test_run() { mount_initdir if [ -z "$TEST_NO_QEMU" ]; then if run_qemu "$1"; then check_result_qemu || { echo "QEMU test failed"; return 1; } else dwarn "can't run QEMU, skipping" fi fi if [ -z "$TEST_NO_NSPAWN" ]; then mount_initdir if run_nspawn "$initdir" "$1"; then check_result_nspawn "$initdir" || { echo "nspawn-root test failed"; return 1; } else dwarn "can't run systemd-nspawn, skipping" fi if [[ "$RUN_IN_UNPRIVILEGED_CONTAINER" = "yes" ]]; then dir="$TESTDIR/unprivileged-nspawn-root" if NSPAWN_ARGUMENTS="-U --private-network $NSPAWN_ARGUMENTS" run_nspawn "$dir" "$1"; then check_result_nspawn "$dir" || { echo "unprivileged-nspawn-root test failed"; return 1; } else dwarn "can't run systemd-nspawn, skipping" fi fi fi return 0 } do_test() { if [[ $UID != "0" ]]; then echo "TEST: $TEST_DESCRIPTION [SKIPPED]: not root" >&2 exit 0 fi if [ -n "$TEST_NO_QEMU" ] && [ -n "$TEST_NO_NSPAWN" ]; then echo "TEST: $TEST_DESCRIPTION [SKIPPED]: both QEMU and nspawn disabled" >&2 exit 0 fi # Detect lib paths [[ $libdir ]] || for libdir in /lib64 /lib; do [[ -d $libdir ]] && libdirs+=" $libdir" && break done [[ $usrlibdir ]] || for usrlibdir in /usr/lib64 /usr/lib; do [[ -d $usrlibdir ]] && libdirs+=" $usrlibdir" && break done mkdir -p "$STATEDIR" import_testdir import_initdir testname="$(basename $PWD)" while (($# > 0)); do case $1 in --run) echo "${testname} RUN: $TEST_DESCRIPTION" test_run "$2" ret=$? if (( $ret == 0 )); then echo "${testname} RUN: $TEST_DESCRIPTION [OK]" else echo "${testname} RUN: $TEST_DESCRIPTION [FAILED]" fi exit $ret;; --setup) echo "${testname} SETUP: $TEST_DESCRIPTION" test_setup test_setup_cleanup ;; --clean) echo "${testname} CLEANUP: $TEST_DESCRIPTION" test_cleanup ;; --clean-again) echo "${testname} CLEANUP AGAIN: $TEST_DESCRIPTION" test_cleanup_again ;; --all) ret=0 echo -n "${testname}: $TEST_DESCRIPTION " ( test_setup test_setup_cleanup test_run "$2" ) "$TESTLOG" 2>&1 || ret=$? test_cleanup if [ $ret -eq 0 ]; then rm "$TESTLOG" echo "[OK]" else echo "[FAILED]" echo "see $TESTLOG" fi exit $ret;; *) break ;; esac shift done }