tests/functions.sh - manifest_repos/util-linux - Git at Google

 #
 # Copyright (C) 2007 Karel Zak <kzak@redhat.com>
 #
 # This file is part of util-linux.
 #
 # This file is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # This file is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #


 function ts_abspath {
 	cd $1
 	pwd
 }

 function ts_canonicalize {
 	P="$1"
 	C=$(readlink -f $P)

 	if [ -n "$C" ]; then
 		echo "$C"
 	else
 		echo "$P"
 	fi
 }

 function ts_cd {
 	if [ $# -eq 0 ]; then
 		ts_failed "ul_cd: not enough arguments"
 	fi
 	DEST=$(readlink -f "$1" 2>/dev/null)
 	if [ "x$DEST" = "x" ] || [ ! -d "$DEST" ]; then
 		ts_failed "ul_cd: $1: no such directory"
 	fi
 	cd "$DEST" 2>/dev/null || ts_failed "ul_cd: $1: cannot change directory"
 	if [ "$PWD" != "$DEST" ]; then
 		ts_failed "ul_cd: $PWD is not $DEST"
 	fi
 }

 function ts_separator {
 	local header="$1"
 	echo >> $TS_OUTPUT
 	if [ -z "$header" ]; then
 		echo "============================================" >> $TS_OUTPUT
 	else
 		echo "=====$header================================" >> $TS_OUTPUT
 	fi
 }

 function ts_report {
 	local desc=

 	if [ "$TS_PARSABLE" != "yes" ]; then
 		if [ $TS_NSUBTESTS -ne 0 ] && [ -z "$TS_SUBNAME" ]; then
 			desc=$(printf "%11s...")
 		fi
 		echo "$desc$1"
 		return
 	fi

 	if [ -n "$TS_SUBNAME" ]; then
 		desc=$(printf "%s: [%02d] %s" "$TS_DESC" "$TS_NSUBTESTS" "$TS_SUBNAME")
 	else
 		desc=$TS_DESC
 	fi
 	printf "%13s: %-45s ...%s\n" "$TS_COMPONENT" "$desc" "$1"
 }

 function ts_check_test_command {
 	if [ ! -x "$1" ]; then
 		ts_skip "${1##*/} not found"
 	fi
 }

 function ts_check_prog {
 	local cmd=$1
 	type "$cmd" >/dev/null 2>&1 || ts_skip "missing in PATH: $cmd"
 }

 function ts_check_losetup {
 	local tmp
 	ts_check_test_command "$TS_CMD_LOSETUP"

 	if [ "$TS_SKIP_LOOPDEVS" = "yes" ]; then
 		ts_skip "loop-device tests disabled"
 	fi

 	# assuming that losetup -f works ... to be checked somewhere else
 	tmp=$($TS_CMD_LOSETUP -f 2>/dev/null)
 	if test -b "$tmp"; then
 		return 0
 	fi
 	ts_skip "no loop-device support"
 }

 function ts_report_skip {
 	ts_report " SKIPPED ($1)"
 }

 function ts_skip {
 	ts_report_skip "$1"

 	ts_cleanup_on_exit
 	exit 0
 }

 function ts_skip_nonroot {
 	if [ $UID -ne 0 ]; then
 		ts_skip "no root permissions"
 	fi
 }

 function ts_failed_subtest {
 	local msg="FAILED"
 	local ret=1
 	if [ "$TS_KNOWN_FAIL" = "yes" ]; then
 		msg="KNOWN FAILED"
 		ret=0
 	fi

 	if [ x"$1" == x"" ]; then
 		ts_report " $msg ($TS_NS)"
 	else
 		ts_report " $msg ($1)"
 	fi

 	return $ret
 }

 function ts_failed {
 	ts_failed_subtest "$1"
 	exit $?
 }

 function ts_report_ok {
 	if [ x"$1" == x"" ]; then
 		ts_report " OK"
 	else
 		ts_report " OK ($1)"
 	fi
 }

 function ts_ok {
 	ts_report_ok "$1"
 	exit 0
 }

 function ts_log {
 	echo "$1" >> $TS_OUTPUT
 	[ "$TS_VERBOSE" == "yes" ] && echo "$1"
 }

 function ts_has_option {
 	NAME="$1"
 	ALL="$2"

 	# user may set options by env for a single test or whole component
 	# e.g. TS_OPT_ipcs_limits2_fake="yes" or TS_OPT_ipcs_fake="yes"
 	local v_test=${TS_TESTNAME//[-.]/_}
 	local v_comp=${TS_COMPONENT//[-.]/_}
 	local v_name=${NAME//[-.]/_}
 	eval local env_opt_test=\$TS_OPT_${v_comp}_${v_test}_${v_name}
 	eval local env_opt_comp=\$TS_OPT_${v_comp}_${v_name}
 	if [ "$env_opt_test" = "yes" \
 		-o "$env_opt_comp" = "yes" -a "$env_opt_test" != "no" ]; then
 		echo "yes"
 		return
 	elif [ "$env_opt_test" = "no" \
 		-o "$env_opt_comp" = "no" -a "$env_opt_test" != "yes" ]; then
 		return
 	fi

 	# or just check the global command line options
 	if [[ $ALL =~ ([$' \t\n']|^)--$NAME([$'= \t\n']|$) ]]; then
 		echo yes
 		return
 	fi

 	# or the _global_ env, e.g TS_OPT_parsable="yes"
 	eval local env_opt=\$TS_OPT_${v_name}
 	if [ "$env_opt" = "yes" ]; then echo "yes"; fi
 }

 function ts_option_argument {
 	NAME="$1"
 	ALL="$2"

 	# last option wins!
 	echo "$ALL" | sed -n "s/.*[ \t\n]--$NAME=\([^ \t\n]*\).*/\1/p" | tail -n 1
 }

 function ts_init_core_env {
 	TS_SUBNAME=""
 	TS_NS="$TS_COMPONENT/$TS_TESTNAME"
 	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME"
 	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME.vgdump"
 	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME"
 	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
 	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-mnt"
 }

 function ts_init_core_subtest_env {
 	TS_NS="$TS_COMPONENT/$TS_TESTNAME-$TS_SUBNAME"
 	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME"
 	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME.vgdump"
 	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME-$TS_SUBNAME"
 	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
 	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-${TS_SUBNAME}-mnt"

 	rm -f $TS_OUTPUT $TS_VGDUMP
 	[ -d "$TS_OUTDIR" ]  || mkdir -p "$TS_OUTDIR"

 	touch $TS_OUTPUT
 	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
 }

 function ts_init_env {
 	local mydir=$(ts_abspath ${0%/*})
 	local tmp

 	LANG="POSIX"
 	LANGUAGE="POSIX"
 	LC_ALL="POSIX"
 	CHARSET="UTF-8"
 	ASAN_OPTIONS="detect_leaks=0"

 	export LANG LANGUAGE LC_ALL CHARSET ASAN_OPTIONS

 	mydir=$(ts_canonicalize "$mydir")

 	# automake directories
 	top_srcdir=$(ts_option_argument "srcdir" "$*")
 	top_builddir=$(ts_option_argument "builddir" "$*")

 	# where is this script
 	TS_TOPDIR=$(ts_abspath $mydir/../../)

 	# default
 	if [ -z "$top_srcdir" ]; then
 		top_srcdir="$TS_TOPDIR/.."
 	fi
 	if [ -z "$top_builddir" ]; then
 		top_builddir="$TS_TOPDIR/.."
 	fi

 	top_srcdir=$(ts_abspath $top_srcdir)
 	top_builddir=$(ts_abspath $top_builddir)

 	# some ul commands search other ul commands in $PATH
 	export PATH="$top_builddir:$PATH"

 	TS_SCRIPT="$mydir/$(basename $0)"
 	TS_SUBDIR=$(dirname $TS_SCRIPT)
 	TS_TESTNAME=$(basename $TS_SCRIPT)
 	TS_COMPONENT=$(basename $TS_SUBDIR)
 	TS_DESC=${TS_DESC:-$TS_TESTNAME}

 	TS_NSUBTESTS=0
 	TS_NSUBFAILED=0

 	TS_SELF="$TS_SUBDIR"

 	TS_OUTDIR="$top_builddir/tests/output/$TS_COMPONENT"
 	TS_DIFFDIR="$top_builddir/tests/diff/$TS_COMPONENT"

 	TS_NOLOCKS=$(ts_has_option "nolocks" "$*")
 	TS_LOCKDIR="$top_builddir/tests/output"

 	# Don't lock if flock(1) is missing
 	type "flock" >/dev/null 2>&1 || TS_NOLOCKS="yes"

 	ts_init_core_env

 	TS_VERBOSE=$(ts_has_option "verbose" "$*")
 	TS_SHOWDIFF=$(ts_has_option "show-diff" "$*")
 	TS_PARALLEL=$(ts_has_option "parallel" "$*")
 	TS_KNOWN_FAIL=$(ts_has_option "known-fail" "$*")
 	TS_SKIP_LOOPDEVS=$(ts_has_option "skip-loopdevs" "$*")
 	TS_PARSABLE=$(ts_has_option "parsable" "$*")
 	[ "$TS_PARSABLE" = "yes" ] || TS_PARSABLE="$TS_PARALLEL"

 	tmp=$( ts_has_option "memcheck-valgrind" "$*")
 	if [ "$tmp" == "yes" -a -f /usr/bin/valgrind ]; then
 		TS_VALGRIND_CMD="/usr/bin/valgrind"
 	fi
 	tmp=$( ts_has_option "memcheck-asan" "$*")
 	if [ "$tmp" == "yes" ]; then
 		TS_ENABLE_ASAN="yes"
 	fi

 	BLKID_FILE="$TS_OUTDIR/${TS_TESTNAME}.blkidtab"

 	declare -a TS_SUID_PROGS
 	declare -a TS_SUID_USER
 	declare -a TS_SUID_GROUP
 	declare -a TS_LOOP_DEVS
 	declare -a TS_LOCKFILE_FD

 	if [ -f $TS_TOPDIR/commands.sh ]; then
 		. $TS_TOPDIR/commands.sh
 	fi

 	export BLKID_FILE

 	rm -f $TS_OUTPUT $TS_VGDUMP
 	[ -d "$TS_OUTDIR" ]  || mkdir -p "$TS_OUTDIR"

 	touch $TS_OUTPUT
 	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP

 	if [ "$TS_VERBOSE" == "yes" ]; then
 		echo
 		echo "     script: $TS_SCRIPT"
 		echo "    sub dir: $TS_SUBDIR"
 		echo "    top dir: $TS_TOPDIR"
 		echo "       self: $TS_SELF"
 		echo "  test name: $TS_TESTNAME"
 		echo "  test desc: $TS_DESC"
 		echo "  component: $TS_COMPONENT"
 		echo "  namespace: $TS_NS"
 		echo "    verbose: $TS_VERBOSE"
 		echo "     output: $TS_OUTPUT"
 		echo "   valgrind: $TS_VGDUMP"
 		echo "   expected: $TS_EXPECTED"
 		echo " mountpoint: $TS_MOUNTPOINT"
 		echo
 	fi
 }

 function ts_init_subtest {

 	TS_SUBNAME="$1"
 	ts_init_core_subtest_env
 	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))

 	if [ "$TS_PARSABLE" != "yes" ]; then
 		[ $TS_NSUBTESTS -eq 1 ] && echo
 		printf "%16s: %-27s ..." "" "$TS_SUBNAME"
 	fi
 }

 function ts_init {
 	ts_init_env "$*"

 	local is_fake=$( ts_has_option "fake" "$*")
 	local is_force=$( ts_has_option "force" "$*")

 	if [ "$TS_PARSABLE" != "yes" ]; then
 		printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC"
 	fi

 	[ "$is_fake" == "yes" ] && ts_skip "fake mode"
 	[ "$TS_OPTIONAL" == "yes" -a "$is_force" != "yes" ] && ts_skip "optional"
 }

 function ts_init_suid {
 	PROG="$1"
 	ct=${#TS_SUID_PROGS[*]}

 	# Save info about original setting
 	TS_SUID_PROGS[$ct]=$PROG
 	TS_SUID_USER[$ct]=$(stat --printf="%U" $PROG)
 	TS_SUID_GROUP[$ct]=$(stat --printf="%G" $PROG)

 	chown root.root $PROG &> /dev/null
 	chmod u+s $PROG &> /dev/null
 }

 function ts_init_py {
 	LIBNAME="$1"

 	[ -f "$top_builddir/py${LIBNAME}.la" ] || ts_skip "py${LIBNAME} not compiled"

 	export LD_LIBRARY_PATH="$top_builddir/.libs:$LD_LIBRARY_PATH"
 	export PYTHONPATH="$top_builddir/$LIBNAME/python:$top_builddir/.libs:$PYTHONPATH"

 	export PYTHON_VERSION=$(awk '/^PYTHON_VERSION/ { print $3 }' $top_builddir/Makefile)
 	export PYTHON_MAJOR_VERSION=$(echo $PYTHON_VERSION | sed 's/\..*//')

 	export PYTHON="python${PYTHON_MAJOR_VERSION}"
 }

 function ts_run {
 	#
 	# valgrind mode
 	#
 	if [ -n "$TS_VALGRIND_CMD" ]; then
 		libtool --mode=execute \
 		$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
 				 --leak-resolution=high --num-callers=20 \
 				 --log-file="$TS_VGDUMP" "$@"
 	#
 	# ASAN mode
 	#
 	elif [ "$TS_ENABLE_ASAN" == "yes" ]; then
 		ASAN_OPTIONS='detect_leaks=1' "$@"

 	#
 	# Default mode
 	#
 	else
 		"$@"
 	fi
 }

 function ts_gen_diff {
 	local res=0

 	[ -f "$TS_OUTPUT" ] || return 1
 	[ -f "$TS_EXPECTED" ] || TS_EXPECTED=/dev/null

 	# remove libtool lt- prefixes
 	sed --in-place 's/^lt\-\(.*\: \)/\1/g' $TS_OUTPUT

 	[ -d "$TS_DIFFDIR" ] || mkdir -p "$TS_DIFFDIR"
 	diff -u $TS_EXPECTED $TS_OUTPUT > $TS_DIFF

 	if [ $? -ne 0 ] || [ -s $TS_DIFF ]; then
 		res=1
 		if [ "$TS_SHOWDIFF" == "yes" ]; then
 			echo
 			echo "diff-{{{"
 			cat $TS_DIFF
 			echo "}}}-diff"
 			echo
 		fi
 	else
 		rm -f $TS_DIFF;
 	fi

 	return $res
 }

 function tt_gen_mem_report {
 	if [ -n "$TS_VALGRIND_CMD" ]; then
 		grep -q -E 'ERROR SUMMARY: [1-9]' $TS_VGDUMP &> /dev/null
 		if [ $? -eq 0 ]; then
 			echo "mem-error detected!"
 		fi
 	else
 		echo "$1"
 	fi
 }

 function ts_finalize_subtest {
 	local res=0

 	ts_gen_diff
 	if [ $? -eq 1 ]; then
 		ts_failed_subtest "$1"
 		res=1
 	else
 		ts_report_ok "$(tt_gen_mem_report "$1")"
 	fi

 	[ $res -ne 0 ] && TS_NSUBFAILED=$(( $TS_NSUBFAILED + 1 ))

 	# reset environment back to parental test
 	ts_init_core_env

 	return $res
 }

 function ts_skip_subtest {
 	ts_report_skip "$1"
 	# reset environment back to parental test
 	ts_init_core_env

 }

 function ts_finalize {
 	ts_cleanup_on_exit

 	if [ $TS_NSUBTESTS -ne 0 ]; then
 		if ! ts_gen_diff || [ $TS_NSUBFAILED -ne 0 ]; then
 			ts_failed "$TS_NSUBFAILED from $TS_NSUBTESTS sub-tests"
 		else
 			ts_ok "all $TS_NSUBTESTS sub-tests PASSED"
 		fi
 	fi

 	ts_gen_diff || ts_failed "$1"
 	ts_ok "$1"
 }

 function ts_die {
 	ts_log "$1"
 	ts_finalize
 }

 function ts_cleanup_on_exit {

 	for idx in $(seq 0 $((${#TS_SUID_PROGS[*]} - 1))); do
 		PROG=${TS_SUID_PROGS[$idx]}
 		chmod a-s $PROG &> /dev/null
 		chown ${TS_SUID_USER[$idx]}.${TS_SUID_GROUP[$idx]} $PROG &> /dev/null
 	done

 	for dev in "${TS_LOOP_DEVS[@]}"; do
 		ts_device_deinit "$dev"
 	done
 	unset TS_LOOP_DEVS

 	ts_scsi_debug_rmmod
 }

 function ts_image_md5sum {
 	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
 	echo $("$TS_HELPER_MD5" < "$img") $(basename "$img")
 }

 function ts_image_init {
 	local mib=${1:-"5"}	# size in MiBs
 	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}

 	rm -f $img
 	truncate -s "${mib}M" "$img"
 	echo "$img"
 	return 0
 }

 function ts_register_loop_device {
 	local ct=${#TS_LOOP_DEVS[*]}
 	TS_LOOP_DEVS[$ct]=$1
 }

 function ts_device_init {
 	local img
 	local dev

 	img=$(ts_image_init $1 $2)
 	dev=$($TS_CMD_LOSETUP --show -f "$img")
 	if [ "$?" != "0" -o "$dev" = "" ]; then
 		ts_die "Cannot init device"
 	fi

 	ts_register_loop_device "$dev"
 	TS_LODEV=$dev
 }

 # call from ts_cleanup_on_exit() only because of TS_LOOP_DEVS maintenance
 function ts_device_deinit {
 	local DEV="$1"

 	if [ -b "$DEV" ]; then
 		$TS_CMD_UMOUNT "$DEV" &> /dev/null
 		$TS_CMD_LOSETUP -d "$DEV" &> /dev/null
 	fi
 }

 function ts_blkidtag_by_devname()
 {
 	local tag=$1
 	local dev=$2
 	local out
 	local rval

 	out=$($TS_CMD_BLKID -p -s "$tag" -o value "$dev")
 	rval=$?
 	printf "%s\n" "$out"

 	test -n "$out" -a "$rval" = "0"
 	return $?
 }

 function ts_uuid_by_devname {
 	ts_blkidtag_by_devname "UUID" "$1"
 	return $?
 }

 function ts_label_by_devname {
 	ts_blkidtag_by_devname "LABEL" "$1"
 	return $?
 }

 function ts_fstype_by_devname {
 	ts_blkidtag_by_devname "TYPE" "$1"
 	return $?
 }

 function ts_device_has {
 	local TAG="$1"
 	local VAL="$2"
 	local DEV="$3"
 	local vl=""

 	vl=$(ts_blkidtag_by_devname "$TAG" "$DEV")
 	test $? = 0 -a "$vl" = "$VAL"
 	return $?
 }

 function ts_is_uuid()
 {
 	printf "%s\n" "$1" | egrep -q '^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$'
 	return $?
 }

 function ts_udevadm_settle()
 {
 	local dev=$1 # optional, might be empty
 	shift        # all other args are tags, LABEL, UUID, ...
 	udevadm settle
 }

 function ts_mount {
 	local out
 	local result
 	local msg
 	local fs
 	local fs_exp=$1
 	shift

 	out=$($TS_CMD_MOUNT "$@" 2>&1)
 	result=$?
 	echo -n "$out" >> $TS_OUTPUT

 	if [ $result != 0 ] \
 		&& msg=$(echo "$out" | grep -m1 "unknown filesystem type")
 	then
 		# skip only if reported fs correctly and if it's not available
 		fs=$(echo "$msg" | sed -n "s/.*type '\(.*\)'$/\1/p")
 		[ "$fs" = "fs_exp" ] \
 		 && grep -qe "[[:space:]]${fs}$" /proc/filesystems &>/dev/null \
 		 || ts_skip "$msg"
 	fi
 	return $result
 }

 function ts_is_mounted {
 	local DEV=$(ts_canonicalize "$1")

 	grep -q "\(^\| \)$DEV " /proc/mounts && return 0

 	if [ "${DEV#/dev/loop/}" != "$DEV" ]; then
 		grep -q "^/dev/loop${DEV#/dev/loop/} " /proc/mounts && return 0
 	fi
 	return 1
 }

 function ts_fstab_open {
 	echo "# <!-- util-linux test entry" >> /etc/fstab
 }

 function ts_fstab_close {
 	echo "# -->" >> /etc/fstab
 	sync /etc/fstab 2>/dev/null
 }

 function ts_fstab_addline {
 	local SPEC="$1"
 	local MNT=${2:-"$TS_MOUNTPOINT"}
 	local FS=${3:-"auto"}
 	local OPT=${4:-"defaults"}

 	echo "$SPEC   $MNT   $FS   $OPT   0   0" >> /etc/fstab
 }

 function ts_fstab_lock {
 	ts_lock "fstab"
 }

 function ts_fstab_add {
 	ts_fstab_lock
 	ts_fstab_open
 	ts_fstab_addline $*
 	ts_fstab_close
 }

 function ts_fstab_clean {
 	ts_have_lock "fstab" || return 0
 	sed --in-place "
 /# <!-- util-linux/!b
 :a
 /# -->/!{
   N
   ba
 }
 s/# <!-- util-linux.*-->//;
 /^$/d" /etc/fstab

 	sync /etc/fstab 2>/dev/null
 	ts_unlock "fstab"
 }

 function ts_fdisk_clean {
 	local DEVNAME=$1

 	# remove non comparable parts of fdisk output
 	if [ -n "${DEVNAME}" ]; then
 		sed -i -e "s@${DEVNAME}@<removed>@;" $TS_OUTPUT
 	fi

 	sed -i \
 		-e 's/Disk identifier:.*/Disk identifier: <removed>/' \
 		-e 's/Created a new.*/Created a new <removed>./' \
 		-e 's/^Device[[:blank:]]*Start/Device             Start/' \
 		-e 's/^Device[[:blank:]]*Boot/Device     Boot/' \
 		-e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./' \
 		-e 's/typescript file.*/typescript file <removed>./' \
 		-e 's@^\(I/O size (minimum/op.* bytes /\) [1-9][0-9]* @\1 <removed> @' \
 		$TS_OUTPUT
 }


 # https://stackoverflow.com/questions/41603787/how-to-find-next-available-file-descriptor-in-bash
 function ts_find_free_fd()
 {
 	local rco
 	local rci
 	for fd in {3..200}; do
 		rco="$(true 2>/dev/null >&${fd}; echo $?)"
 		rci="$(true 2>/dev/null <&${fd}; echo $?)"
 		if [[ "${rco}${rci}" = "11" ]]; then
 			echo "$fd"
 			return 0
 		fi
 	done
 	return 1
 }

 function ts_get_lock_fd {
 	local resource=$1
 	local fd

 	for fd in "${!TS_LOCKFILE_FD[@]}"; do
 		if [ "${TS_LOCKFILE_FD["$fd"]}" = "$resource" ]; then
 			echo "$fd"
 			return 0
 		fi
 	done
 	return 1
 }

 function ts_have_lock {
 	local resource=$1

 	test "$TS_NOLOCKS" = "yes" && return 0
 	ts_get_lock_fd "$resource" >/dev/null && return 0
 	return 1
 }

 function ts_lock {
 	local resource="$1"
 	local lockfile="${TS_LOCKDIR}/${resource}.lock"
 	local fd

 	if [ "$TS_NOLOCKS" == "yes" ]; then
 		return 0
 	fi

 	# Don't lock again
 	fd=$(ts_get_lock_fd "$resource")
 	if [ -n "$fd" ]; then
 		echo "[$$ $TS_TESTNAME] ${resource} already locked!"
 		return 0
 	fi

 	fd=$(ts_find_free_fd) || ts_skip "failed to find lock fd"

 	eval "exec $fd>$lockfile"
 	flock --exclusive "$fd" || ts_skip "failed to lock $resource"

 	TS_LOCKFILE_FD["$fd"]="$resource"
 	###echo "[$$ $TS_TESTNAME] Locked   $resource"
 }

 function ts_unlock {
 	local resource="$1"
 	local lockfile="${TS_LOCKDIR}/${resource}.lock"
 	local fd

 	if [ "$TS_NOLOCKS" == "yes" ]; then
 		return 0
 	fi

 	fd=$(ts_get_lock_fd "$resource")
 	if [ -n "$fd" ]; then
 		eval "exec $fd<&-"
 		TS_LOCKFILE_FD["$fd"]=""
 		###echo "[$$ $TS_TESTNAME] Unlocked $resource"
 	else
 		echo "[$$ $TS_TESTNAME] unlocking unlocked $resource!?"
 	fi
 }

 function ts_scsi_debug_init {
 	local devname
 	local t
 	TS_DEVICE="none"

 	ts_lock "scsi_debug"

 	# dry run is not really reliable, real modprobe may still fail
 	modprobe --dry-run --quiet scsi_debug &>/dev/null \
 		|| ts_skip "missing scsi_debug module (dry-run)"

 	# skip if still in use or removal of modules not supported at all
 	# We don't want a slow timeout here so we don't use ts_scsi_debug_rmmod!
 	modprobe -r scsi_debug &>/dev/null
 	if [ "$?" -eq 1 ]; then
 		ts_unlock "scsi_debug"
 		ts_skip "cannot remove scsi_debug module (rmmod)"
 	fi

 	modprobe -b scsi_debug "$@" &>/dev/null \
 		|| ts_skip "cannot load scsi_debug module (modprobe)"

 	# it might be still not loaded, modprobe.conf or whatever
 	lsmod 2>/dev/null | grep -q "^scsi_debug " \
 		|| ts_skip "scsi_debug module not loaded (lsmod)"

 	udevadm settle

 	# wait for device if udevadm settle does not work
 	for t in 0 0.02 0.05 0.1 1; do
 		sleep $t
 		devname=$(grep --with-filename scsi_debug /sys/block/*/device/model) && break
 	done
 	[ -n "${devname}" ] || ts_die "timeout waiting for scsi_debug device"

 	devname=$(echo $devname | awk -F '/' '{print $4}')
 	TS_DEVICE="/dev/${devname}"

 	# TODO validate that device is really up, for now just a warning on stderr
 	test -b $TS_DEVICE || echo "warning: scsi_debug device is still down" >&2
 }

 # automatically called once in ts_cleanup_on_exit()
 function ts_scsi_debug_rmmod {
 	local err=1
 	local t
 	local lastmsg

 	# We must not run if we don't have the lock
 	ts_have_lock "scsi_debug" || return 0

 	# Return early most importantly in case we are not root or the module does
 	# not exist at all.
 	[ $UID -eq 0 ] || return 0
 	[ -n "$TS_DEVICE" ] || return 0
 	lsmod 2>/dev/null | grep -q "^scsi_debug " || return 0

 	udevadm settle

 	# wait for successful rmmod if udevadm settle does not work
 	for t in 0 0.02 0.05 0.1 1; do
 		sleep $t
 		lastmsg="$(modprobe -r scsi_debug 2>&1)" && err=0 && break
 	done

 	if [ "$err" = "1" ]; then
 		ts_log "rmmod failed: '$lastmsg'"
 		ts_log "timeout removing scsi_debug module (rmmod)"
 		return 1
 	fi
 	if lsmod | grep -q "^scsi_debug "; then
 		ts_log "BUG! scsi_debug still loaded"
 		return 1
 	fi

 	# TODO Do we need to validate that all devices are gone?
 	udevadm settle
 	test -b "$TS_DEVICE" && echo "warning: scsi_debug device is still up" >&2

 	# TODO unset TS_DEVICE, check that nobody uses it later, e.g. ts_fdisk_clean

 	ts_unlock "scsi_debug"
 	return 0
 }

 function ts_resolve_host {
 	local host="$1"
 	local tmp

 	# currently we just resolve default records (might be "A", ipv4 only)
 	if type "dig" >/dev/null 2>&1; then
 		tmp=$(dig "$host" +short 2>/dev/null) || return 1
 	elif type "nslookup" >/dev/null 2>&1; then
 		tmp=$(nslookup "$host" 2>/dev/null) || return 1
 		tmp=$(echo "$tmp"| grep -A1 "^Name:"| grep "^Address:"| cut -d" " -f2)
 	elif type "host" >/dev/null 2>&1; then
 		tmp=$(host "$host" 2>/dev/null) || return 1
 		tmp=$(echo "$tmp" | grep " has address " | cut -d " " -f4)
 	elif type "getent" >/dev/null 2>&1; then
 		tmp=$(getent ahosts "$host" 2>/dev/null) || return 1
 		tmp=$(echo "$tmp" | cut -d " " -f 1 | sort -u)
 	fi

 	# we return 1 if tmp is empty
 	test -n "$tmp" || return 1
 	echo "$tmp" | sort -R | head -n 1
 }

 # listen to unix socket (background socat)
 function ts_init_socket_to_file {
 	local socket=$1
 	local outfile=$2
 	local pid="0"

 	ts_check_prog "socat"
 	rm -f "$socket" "$outfile"

 	# if socat is too old for these options we'll skip it below
 	socat -u UNIX-LISTEN:$socket,fork,max-children=1,backlog=128 \
 		STDOUT > "$outfile" 2>/dev/null &
 	pid=$!

 	# check for running background process
 	if [ "$pid" -le "0" ] || ! kill -s 0 "$pid" &>/dev/null; then
 		ts_skip "unable to run socat"
 	fi
 	# wait for the socket listener
 	if ! socat -u /dev/null UNIX-CONNECT:$socket,retry=30,interval=0.1 &>/dev/null; then
 		kill -9 "$pid" &>/dev/null
 		ts_skip "timeout waiting for socat socket"
 	fi
 	# check socket again
 	if ! socat -u /dev/null UNIX-CONNECT:$socket &>/dev/null; then
 		kill -9 "$pid" &>/dev/null
 		ts_skip "socat socket stopped listening"
 	fi
 }

 function ts_has_mtab_support {
 	grep -q '#define USE_LIBMOUNT_SUPPORT_MTAB' ${top_builddir}/config.h
 	if [ $? == 0 ]; then
 		echo "yes"
 	else
 		echo "no"
 	fi
 }

 function ts_has_ncurses_support {
 	grep -q '#define HAVE_LIBNCURSES' ${top_builddir}/config.h
 	if [ $? == 0 ]; then
 		echo "yes"
 	else
 		echo "no"
 	fi
 }
	#
	# Copyright (C) 2007 Karel Zak <kzak@redhat.com>
	#
	# This file is part of util-linux.
	#
	# This file is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 2 of the License, or
	# (at your option) any later version.
	#
	# This file is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#


	function ts_abspath {
	cd $1
	pwd
	}

	function ts_canonicalize {
	P="$1"
	C=$(readlink -f $P)

	if [ -n "$C" ]; then
	echo "$C"
	else
	echo "$P"
	fi
	}

	function ts_cd {
	if [ $# -eq 0 ]; then
	ts_failed "ul_cd: not enough arguments"
	fi
	DEST=$(readlink -f "$1" 2>/dev/null)
	if [ "x$DEST" = "x" ] \|\| [ ! -d "$DEST" ]; then
	ts_failed "ul_cd: $1: no such directory"
	fi
	cd "$DEST" 2>/dev/null \|\| ts_failed "ul_cd: $1: cannot change directory"
	if [ "$PWD" != "$DEST" ]; then
	ts_failed "ul_cd: $PWD is not $DEST"
	fi
	}

	function ts_separator {
	local header="$1"
	echo >> $TS_OUTPUT
	if [ -z "$header" ]; then
	echo "============================================" >> $TS_OUTPUT
	else
	echo "=====$header================================" >> $TS_OUTPUT
	fi
	}

	function ts_report {
	local desc=

	if [ "$TS_PARSABLE" != "yes" ]; then
	if [ $TS_NSUBTESTS -ne 0 ] && [ -z "$TS_SUBNAME" ]; then
	desc=$(printf "%11s...")
	fi
	echo "$desc$1"
	return
	fi

	if [ -n "$TS_SUBNAME" ]; then
	desc=$(printf "%s: [%02d] %s" "$TS_DESC" "$TS_NSUBTESTS" "$TS_SUBNAME")
	else
	desc=$TS_DESC
	fi
	printf "%13s: %-45s ...%s\n" "$TS_COMPONENT" "$desc" "$1"
	}

	function ts_check_test_command {
	if [ ! -x "$1" ]; then
	ts_skip "${1##*/} not found"
	fi
	}

	function ts_check_prog {
	local cmd=$1
	type "$cmd" >/dev/null 2>&1 \|\| ts_skip "missing in PATH: $cmd"
	}

	function ts_check_losetup {
	local tmp
	ts_check_test_command "$TS_CMD_LOSETUP"

	if [ "$TS_SKIP_LOOPDEVS" = "yes" ]; then
	ts_skip "loop-device tests disabled"
	fi

	# assuming that losetup -f works ... to be checked somewhere else
	tmp=$($TS_CMD_LOSETUP -f 2>/dev/null)
	if test -b "$tmp"; then
	return 0
	fi
	ts_skip "no loop-device support"
	}

	function ts_report_skip {
	ts_report " SKIPPED ($1)"
	}

	function ts_skip {
	ts_report_skip "$1"

	ts_cleanup_on_exit
	exit 0
	}

	function ts_skip_nonroot {
	if [ $UID -ne 0 ]; then
	ts_skip "no root permissions"
	fi
	}

	function ts_failed_subtest {
	local msg="FAILED"
	local ret=1
	if [ "$TS_KNOWN_FAIL" = "yes" ]; then
	msg="KNOWN FAILED"
	ret=0
	fi

	if [ x"$1" == x"" ]; then
	ts_report " $msg ($TS_NS)"
	else
	ts_report " $msg ($1)"
	fi

	return $ret
	}

	function ts_failed {
	ts_failed_subtest "$1"
	exit $?
	}

	function ts_report_ok {
	if [ x"$1" == x"" ]; then
	ts_report " OK"
	else
	ts_report " OK ($1)"
	fi
	}

	function ts_ok {
	ts_report_ok "$1"
	exit 0
	}

	function ts_log {
	echo "$1" >> $TS_OUTPUT
	[ "$TS_VERBOSE" == "yes" ] && echo "$1"
	}

	function ts_has_option {
	NAME="$1"
	ALL="$2"

	# user may set options by env for a single test or whole component
	# e.g. TS_OPT_ipcs_limits2_fake="yes" or TS_OPT_ipcs_fake="yes"
	local v_test=${TS_TESTNAME//[-.]/_}
	local v_comp=${TS_COMPONENT//[-.]/_}
	local v_name=${NAME//[-.]/_}
	eval local env_opt_test=\$TS_OPT_${v_comp}_${v_test}_${v_name}
	eval local env_opt_comp=\$TS_OPT_${v_comp}_${v_name}
	if [ "$env_opt_test" = "yes" \
	-o "$env_opt_comp" = "yes" -a "$env_opt_test" != "no" ]; then
	echo "yes"
	return
	elif [ "$env_opt_test" = "no" \
	-o "$env_opt_comp" = "no" -a "$env_opt_test" != "yes" ]; then
	return
	fi

	# or just check the global command line options
	if [[ $ALL =~ ([$' \t\n']\|^)--$NAME([$'= \t\n']\|$) ]]; then
	echo yes
	return
	fi

	# or the _global_ env, e.g TS_OPT_parsable="yes"
	eval local env_opt=\$TS_OPT_${v_name}
	if [ "$env_opt" = "yes" ]; then echo "yes"; fi
	}

	function ts_option_argument {
	NAME="$1"
	ALL="$2"

	# last option wins!
	echo "$ALL" \| sed -n "s/.[ \t\n]--$NAME=\([^ \t\n]\).*/\1/p" \| tail -n 1
	}

	function ts_init_core_env {
	TS_SUBNAME=""
	TS_NS="$TS_COMPONENT/$TS_TESTNAME"
	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME"
	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME.vgdump"
	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME"
	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-mnt"
	}

	function ts_init_core_subtest_env {
	TS_NS="$TS_COMPONENT/$TS_TESTNAME-$TS_SUBNAME"
	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME"
	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME.vgdump"
	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME-$TS_SUBNAME"
	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-${TS_SUBNAME}-mnt"

	rm -f $TS_OUTPUT $TS_VGDUMP
	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"

	touch $TS_OUTPUT
	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
	}

	function ts_init_env {
	local mydir=$(ts_abspath ${0%/*})
	local tmp

	LANG="POSIX"
	LANGUAGE="POSIX"
	LC_ALL="POSIX"
	CHARSET="UTF-8"
	ASAN_OPTIONS="detect_leaks=0"

	export LANG LANGUAGE LC_ALL CHARSET ASAN_OPTIONS

	mydir=$(ts_canonicalize "$mydir")

	# automake directories
	top_srcdir=$(ts_option_argument "srcdir" "$*")
	top_builddir=$(ts_option_argument "builddir" "$*")

	# where is this script
	TS_TOPDIR=$(ts_abspath $mydir/../../)

	# default
	if [ -z "$top_srcdir" ]; then
	top_srcdir="$TS_TOPDIR/.."
	fi
	if [ -z "$top_builddir" ]; then
	top_builddir="$TS_TOPDIR/.."
	fi

	top_srcdir=$(ts_abspath $top_srcdir)
	top_builddir=$(ts_abspath $top_builddir)

	# some ul commands search other ul commands in $PATH
	export PATH="$top_builddir:$PATH"

	TS_SCRIPT="$mydir/$(basename $0)"
	TS_SUBDIR=$(dirname $TS_SCRIPT)
	TS_TESTNAME=$(basename $TS_SCRIPT)
	TS_COMPONENT=$(basename $TS_SUBDIR)
	TS_DESC=${TS_DESC:-$TS_TESTNAME}

	TS_NSUBTESTS=0
	TS_NSUBFAILED=0

	TS_SELF="$TS_SUBDIR"

	TS_OUTDIR="$top_builddir/tests/output/$TS_COMPONENT"
	TS_DIFFDIR="$top_builddir/tests/diff/$TS_COMPONENT"

	TS_NOLOCKS=$(ts_has_option "nolocks" "$*")
	TS_LOCKDIR="$top_builddir/tests/output"

	# Don't lock if flock(1) is missing
	type "flock" >/dev/null 2>&1 \|\| TS_NOLOCKS="yes"

	ts_init_core_env

	TS_VERBOSE=$(ts_has_option "verbose" "$*")
	TS_SHOWDIFF=$(ts_has_option "show-diff" "$*")
	TS_PARALLEL=$(ts_has_option "parallel" "$*")
	TS_KNOWN_FAIL=$(ts_has_option "known-fail" "$*")
	TS_SKIP_LOOPDEVS=$(ts_has_option "skip-loopdevs" "$*")
	TS_PARSABLE=$(ts_has_option "parsable" "$*")
	[ "$TS_PARSABLE" = "yes" ] \|\| TS_PARSABLE="$TS_PARALLEL"

	tmp=$( ts_has_option "memcheck-valgrind" "$*")
	if [ "$tmp" == "yes" -a -f /usr/bin/valgrind ]; then
	TS_VALGRIND_CMD="/usr/bin/valgrind"
	fi
	tmp=$( ts_has_option "memcheck-asan" "$*")
	if [ "$tmp" == "yes" ]; then
	TS_ENABLE_ASAN="yes"
	fi

	BLKID_FILE="$TS_OUTDIR/${TS_TESTNAME}.blkidtab"

	declare -a TS_SUID_PROGS
	declare -a TS_SUID_USER
	declare -a TS_SUID_GROUP
	declare -a TS_LOOP_DEVS
	declare -a TS_LOCKFILE_FD

	if [ -f $TS_TOPDIR/commands.sh ]; then
	. $TS_TOPDIR/commands.sh
	fi

	export BLKID_FILE

	rm -f $TS_OUTPUT $TS_VGDUMP
	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"

	touch $TS_OUTPUT
	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP

	if [ "$TS_VERBOSE" == "yes" ]; then
	echo
	echo " script: $TS_SCRIPT"
	echo " sub dir: $TS_SUBDIR"
	echo " top dir: $TS_TOPDIR"
	echo " self: $TS_SELF"
	echo " test name: $TS_TESTNAME"
	echo " test desc: $TS_DESC"
	echo " component: $TS_COMPONENT"
	echo " namespace: $TS_NS"
	echo " verbose: $TS_VERBOSE"
	echo " output: $TS_OUTPUT"
	echo " valgrind: $TS_VGDUMP"
	echo " expected: $TS_EXPECTED"
	echo " mountpoint: $TS_MOUNTPOINT"
	echo
	fi
	}

	function ts_init_subtest {

	TS_SUBNAME="$1"
	ts_init_core_subtest_env
	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))

	if [ "$TS_PARSABLE" != "yes" ]; then
	[ $TS_NSUBTESTS -eq 1 ] && echo
	printf "%16s: %-27s ..." "" "$TS_SUBNAME"
	fi
	}

	function ts_init {
	ts_init_env "$*"

	local is_fake=$( ts_has_option "fake" "$*")
	local is_force=$( ts_has_option "force" "$*")

	if [ "$TS_PARSABLE" != "yes" ]; then
	printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC"
	fi

	[ "$is_fake" == "yes" ] && ts_skip "fake mode"
	[ "$TS_OPTIONAL" == "yes" -a "$is_force" != "yes" ] && ts_skip "optional"
	}

	function ts_init_suid {
	PROG="$1"
	ct=${#TS_SUID_PROGS[*]}

	# Save info about original setting
	TS_SUID_PROGS[$ct]=$PROG
	TS_SUID_USER[$ct]=$(stat --printf="%U" $PROG)
	TS_SUID_GROUP[$ct]=$(stat --printf="%G" $PROG)

	chown root.root $PROG &> /dev/null
	chmod u+s $PROG &> /dev/null
	}

	function ts_init_py {
	LIBNAME="$1"

	[ -f "$top_builddir/py${LIBNAME}.la" ] \|\| ts_skip "py${LIBNAME} not compiled"

	export LD_LIBRARY_PATH="$top_builddir/.libs:$LD_LIBRARY_PATH"
	export PYTHONPATH="$top_builddir/$LIBNAME/python:$top_builddir/.libs:$PYTHONPATH"

	export PYTHON_VERSION=$(awk '/^PYTHON_VERSION/ { print $3 }' $top_builddir/Makefile)
	export PYTHON_MAJOR_VERSION=$(echo $PYTHON_VERSION \| sed 's/\..*//')

	export PYTHON="python${PYTHON_MAJOR_VERSION}"
	}

	function ts_run {
	#
	# valgrind mode
	#
	if [ -n "$TS_VALGRIND_CMD" ]; then
	libtool --mode=execute \
	$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
	--leak-resolution=high --num-callers=20 \
	--log-file="$TS_VGDUMP" "$@"
	#
	# ASAN mode
	#
	elif [ "$TS_ENABLE_ASAN" == "yes" ]; then
	ASAN_OPTIONS='detect_leaks=1' "$@"

	#
	# Default mode
	#
	else
	"$@"
	fi
	}

	function ts_gen_diff {
	local res=0

	[ -f "$TS_OUTPUT" ] \|\| return 1
	[ -f "$TS_EXPECTED" ] \|\| TS_EXPECTED=/dev/null

	# remove libtool lt- prefixes
	sed --in-place 's/^lt\-\(.*\: \)/\1/g' $TS_OUTPUT

	[ -d "$TS_DIFFDIR" ] \|\| mkdir -p "$TS_DIFFDIR"
	diff -u $TS_EXPECTED $TS_OUTPUT > $TS_DIFF

	if [ $? -ne 0 ] \|\| [ -s $TS_DIFF ]; then
	res=1
	if [ "$TS_SHOWDIFF" == "yes" ]; then
	echo
	echo "diff-{{{"
	cat $TS_DIFF
	echo "}}}-diff"
	echo
	fi
	else
	rm -f $TS_DIFF;
	fi

	return $res
	}

	function tt_gen_mem_report {
	if [ -n "$TS_VALGRIND_CMD" ]; then
	grep -q -E 'ERROR SUMMARY: [1-9]' $TS_VGDUMP &> /dev/null
	if [ $? -eq 0 ]; then
	echo "mem-error detected!"
	fi
	else
	echo "$1"
	fi
	}

	function ts_finalize_subtest {
	local res=0

	ts_gen_diff
	if [ $? -eq 1 ]; then
	ts_failed_subtest "$1"
	res=1
	else
	ts_report_ok "$(tt_gen_mem_report "$1")"
	fi

	[ $res -ne 0 ] && TS_NSUBFAILED=$(( $TS_NSUBFAILED + 1 ))

	# reset environment back to parental test
	ts_init_core_env

	return $res
	}

	function ts_skip_subtest {
	ts_report_skip "$1"
	# reset environment back to parental test
	ts_init_core_env

	}

	function ts_finalize {
	ts_cleanup_on_exit

	if [ $TS_NSUBTESTS -ne 0 ]; then
	if ! ts_gen_diff \|\| [ $TS_NSUBFAILED -ne 0 ]; then
	ts_failed "$TS_NSUBFAILED from $TS_NSUBTESTS sub-tests"
	else
	ts_ok "all $TS_NSUBTESTS sub-tests PASSED"
	fi
	fi

	ts_gen_diff \|\| ts_failed "$1"
	ts_ok "$1"
	}

	function ts_die {
	ts_log "$1"
	ts_finalize
	}

	function ts_cleanup_on_exit {

	for idx in $(seq 0 $((${#TS_SUID_PROGS[*]} - 1))); do
	PROG=${TS_SUID_PROGS[$idx]}
	chmod a-s $PROG &> /dev/null
	chown ${TS_SUID_USER[$idx]}.${TS_SUID_GROUP[$idx]} $PROG &> /dev/null
	done

	for dev in "${TS_LOOP_DEVS[@]}"; do
	ts_device_deinit "$dev"
	done
	unset TS_LOOP_DEVS

	ts_scsi_debug_rmmod
	}

	function ts_image_md5sum {
	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	echo $("$TS_HELPER_MD5" < "$img") $(basename "$img")
	}

	function ts_image_init {
	local mib=${1:-"5"} # size in MiBs
	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}

	rm -f $img
	truncate -s "${mib}M" "$img"
	echo "$img"
	return 0
	}

	function ts_register_loop_device {
	local ct=${#TS_LOOP_DEVS[*]}
	TS_LOOP_DEVS[$ct]=$1
	}

	function ts_device_init {
	local img
	local dev

	img=$(ts_image_init $1 $2)
	dev=$($TS_CMD_LOSETUP --show -f "$img")
	if [ "$?" != "0" -o "$dev" = "" ]; then
	ts_die "Cannot init device"
	fi

	ts_register_loop_device "$dev"
	TS_LODEV=$dev
	}

	# call from ts_cleanup_on_exit() only because of TS_LOOP_DEVS maintenance
	function ts_device_deinit {
	local DEV="$1"

	if [ -b "$DEV" ]; then
	$TS_CMD_UMOUNT "$DEV" &> /dev/null
	$TS_CMD_LOSETUP -d "$DEV" &> /dev/null
	fi
	}

	function ts_blkidtag_by_devname()
	{
	local tag=$1
	local dev=$2
	local out
	local rval

	out=$($TS_CMD_BLKID -p -s "$tag" -o value "$dev")
	rval=$?
	printf "%s\n" "$out"

	test -n "$out" -a "$rval" = "0"
	return $?
	}

	function ts_uuid_by_devname {
	ts_blkidtag_by_devname "UUID" "$1"
	return $?
	}

	function ts_label_by_devname {
	ts_blkidtag_by_devname "LABEL" "$1"
	return $?
	}

	function ts_fstype_by_devname {
	ts_blkidtag_by_devname "TYPE" "$1"
	return $?
	}

	function ts_device_has {
	local TAG="$1"
	local VAL="$2"
	local DEV="$3"
	local vl=""

	vl=$(ts_blkidtag_by_devname "$TAG" "$DEV")
	test $? = 0 -a "$vl" = "$VAL"
	return $?
	}

	function ts_is_uuid()
	{
	printf "%s\n" "$1" \| egrep -q '^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$'
	return $?
	}

	function ts_udevadm_settle()
	{
	local dev=$1 # optional, might be empty
	shift # all other args are tags, LABEL, UUID, ...
	udevadm settle
	}

	function ts_mount {
	local out
	local result
	local msg
	local fs
	local fs_exp=$1
	shift

	out=$($TS_CMD_MOUNT "$@" 2>&1)
	result=$?
	echo -n "$out" >> $TS_OUTPUT

	if [ $result != 0 ] \
	&& msg=$(echo "$out" \| grep -m1 "unknown filesystem type")
	then
	# skip only if reported fs correctly and if it's not available
	fs=$(echo "$msg" \| sed -n "s/.type '\(.\)'$/\1/p")
	[ "$fs" = "fs_exp" ] \
	&& grep -qe "[[:space:]]${fs}$" /proc/filesystems &>/dev/null \
	\|\| ts_skip "$msg"
	fi
	return $result
	}

	function ts_is_mounted {
	local DEV=$(ts_canonicalize "$1")

	grep -q "\(^\\| \)$DEV " /proc/mounts && return 0

	if [ "${DEV#/dev/loop/}" != "$DEV" ]; then
	grep -q "^/dev/loop${DEV#/dev/loop/} " /proc/mounts && return 0
	fi
	return 1
	}

	function ts_fstab_open {
	echo "# <!-- util-linux test entry" >> /etc/fstab
	}

	function ts_fstab_close {
	echo "# -->" >> /etc/fstab
	sync /etc/fstab 2>/dev/null
	}

	function ts_fstab_addline {
	local SPEC="$1"
	local MNT=${2:-"$TS_MOUNTPOINT"}
	local FS=${3:-"auto"}
	local OPT=${4:-"defaults"}

	echo "$SPEC $MNT $FS $OPT 0 0" >> /etc/fstab
	}

	function ts_fstab_lock {
	ts_lock "fstab"
	}

	function ts_fstab_add {
	ts_fstab_lock
	ts_fstab_open
	ts_fstab_addline $*
	ts_fstab_close
	}

	function ts_fstab_clean {
	ts_have_lock "fstab" \|\| return 0
	sed --in-place "
	/# <!-- util-linux/!b
	:a
	/# -->/!{
	N
	ba
	}
	s/# <!-- util-linux.*-->//;
	/^$/d" /etc/fstab

	sync /etc/fstab 2>/dev/null
	ts_unlock "fstab"
	}

	function ts_fdisk_clean {
	local DEVNAME=$1

	# remove non comparable parts of fdisk output
	if [ -n "${DEVNAME}" ]; then
	sed -i -e "s@${DEVNAME}@<removed>@;" $TS_OUTPUT
	fi

	sed -i \
	-e 's/Disk identifier:.*/Disk identifier: <removed>/' \
	-e 's/Created a new.*/Created a new <removed>./' \
	-e 's/^Device[[:blank:]]*Start/Device Start/' \
	-e 's/^Device[[:blank:]]*Boot/Device Boot/' \
	-e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./' \
	-e 's/typescript file.*/typescript file <removed>./' \
	-e 's@^\(I/O size (minimum/op.* bytes /\) [1-9][0-9]* @\1 <removed> @' \
	$TS_OUTPUT
	}


	# https://stackoverflow.com/questions/41603787/how-to-find-next-available-file-descriptor-in-bash
	function ts_find_free_fd()
	{
	local rco
	local rci
	for fd in {3..200}; do
	rco="$(true 2>/dev/null >&${fd}; echo $?)"
	rci="$(true 2>/dev/null <&${fd}; echo $?)"
	if [[ "${rco}${rci}" = "11" ]]; then
	echo "$fd"
	return 0
	fi
	done
	return 1
	}

	function ts_get_lock_fd {
	local resource=$1
	local fd

	for fd in "${!TS_LOCKFILE_FD[@]}"; do
	if [ "${TS_LOCKFILE_FD["$fd"]}" = "$resource" ]; then
	echo "$fd"
	return 0
	fi
	done
	return 1
	}

	function ts_have_lock {
	local resource=$1

	test "$TS_NOLOCKS" = "yes" && return 0
	ts_get_lock_fd "$resource" >/dev/null && return 0
	return 1
	}

	function ts_lock {
	local resource="$1"
	local lockfile="${TS_LOCKDIR}/${resource}.lock"
	local fd

	if [ "$TS_NOLOCKS" == "yes" ]; then
	return 0
	fi

	# Don't lock again
	fd=$(ts_get_lock_fd "$resource")
	if [ -n "$fd" ]; then
	echo "[$$ $TS_TESTNAME] ${resource} already locked!"
	return 0
	fi

	fd=$(ts_find_free_fd) \|\| ts_skip "failed to find lock fd"

	eval "exec $fd>$lockfile"
	flock --exclusive "$fd" \|\| ts_skip "failed to lock $resource"

	TS_LOCKFILE_FD["$fd"]="$resource"
	###echo "[$$ $TS_TESTNAME] Locked $resource"
	}

	function ts_unlock {
	local resource="$1"
	local lockfile="${TS_LOCKDIR}/${resource}.lock"
	local fd

	if [ "$TS_NOLOCKS" == "yes" ]; then
	return 0
	fi

	fd=$(ts_get_lock_fd "$resource")
	if [ -n "$fd" ]; then
	eval "exec $fd<&-"
	TS_LOCKFILE_FD["$fd"]=""
	###echo "[$$ $TS_TESTNAME] Unlocked $resource"
	else
	echo "[$$ $TS_TESTNAME] unlocking unlocked $resource!?"
	fi
	}

	function ts_scsi_debug_init {
	local devname
	local t
	TS_DEVICE="none"

	ts_lock "scsi_debug"

	# dry run is not really reliable, real modprobe may still fail
	modprobe --dry-run --quiet scsi_debug &>/dev/null \
	\|\| ts_skip "missing scsi_debug module (dry-run)"

	# skip if still in use or removal of modules not supported at all
	# We don't want a slow timeout here so we don't use ts_scsi_debug_rmmod!
	modprobe -r scsi_debug &>/dev/null
	if [ "$?" -eq 1 ]; then
	ts_unlock "scsi_debug"
	ts_skip "cannot remove scsi_debug module (rmmod)"
	fi

	modprobe -b scsi_debug "$@" &>/dev/null \
	\|\| ts_skip "cannot load scsi_debug module (modprobe)"

	# it might be still not loaded, modprobe.conf or whatever
	lsmod 2>/dev/null \| grep -q "^scsi_debug " \
	\|\| ts_skip "scsi_debug module not loaded (lsmod)"

	udevadm settle

	# wait for device if udevadm settle does not work
	for t in 0 0.02 0.05 0.1 1; do
	sleep $t
	devname=$(grep --with-filename scsi_debug /sys/block/*/device/model) && break
	done
	[ -n "${devname}" ] \|\| ts_die "timeout waiting for scsi_debug device"

	devname=$(echo $devname \| awk -F '/' '{print $4}')
	TS_DEVICE="/dev/${devname}"

	# TODO validate that device is really up, for now just a warning on stderr
	test -b $TS_DEVICE \|\| echo "warning: scsi_debug device is still down" >&2
	}

	# automatically called once in ts_cleanup_on_exit()
	function ts_scsi_debug_rmmod {
	local err=1
	local t
	local lastmsg

	# We must not run if we don't have the lock
	ts_have_lock "scsi_debug" \|\| return 0

	# Return early most importantly in case we are not root or the module does
	# not exist at all.
	[ $UID -eq 0 ] \|\| return 0
	[ -n "$TS_DEVICE" ] \|\| return 0
	lsmod 2>/dev/null \| grep -q "^scsi_debug " \|\| return 0

	udevadm settle

	# wait for successful rmmod if udevadm settle does not work
	for t in 0 0.02 0.05 0.1 1; do
	sleep $t
	lastmsg="$(modprobe -r scsi_debug 2>&1)" && err=0 && break
	done

	if [ "$err" = "1" ]; then
	ts_log "rmmod failed: '$lastmsg'"
	ts_log "timeout removing scsi_debug module (rmmod)"
	return 1
	fi
	if lsmod \| grep -q "^scsi_debug "; then
	ts_log "BUG! scsi_debug still loaded"
	return 1
	fi

	# TODO Do we need to validate that all devices are gone?
	udevadm settle
	test -b "$TS_DEVICE" && echo "warning: scsi_debug device is still up" >&2

	# TODO unset TS_DEVICE, check that nobody uses it later, e.g. ts_fdisk_clean

	ts_unlock "scsi_debug"
	return 0
	}

	function ts_resolve_host {
	local host="$1"
	local tmp

	# currently we just resolve default records (might be "A", ipv4 only)
	if type "dig" >/dev/null 2>&1; then
	tmp=$(dig "$host" +short 2>/dev/null) \|\| return 1
	elif type "nslookup" >/dev/null 2>&1; then
	tmp=$(nslookup "$host" 2>/dev/null) \|\| return 1
	tmp=$(echo "$tmp"\| grep -A1 "^Name:"\| grep "^Address:"\| cut -d" " -f2)
	elif type "host" >/dev/null 2>&1; then
	tmp=$(host "$host" 2>/dev/null) \|\| return 1
	tmp=$(echo "$tmp" \| grep " has address " \| cut -d " " -f4)
	elif type "getent" >/dev/null 2>&1; then
	tmp=$(getent ahosts "$host" 2>/dev/null) \|\| return 1
	tmp=$(echo "$tmp" \| cut -d " " -f 1 \| sort -u)
	fi

	# we return 1 if tmp is empty
	test -n "$tmp" \|\| return 1
	echo "$tmp" \| sort -R \| head -n 1
	}

	# listen to unix socket (background socat)
	function ts_init_socket_to_file {
	local socket=$1
	local outfile=$2
	local pid="0"

	ts_check_prog "socat"
	rm -f "$socket" "$outfile"

	# if socat is too old for these options we'll skip it below
	socat -u UNIX-LISTEN:$socket,fork,max-children=1,backlog=128 \
	STDOUT > "$outfile" 2>/dev/null &
	pid=$!

	# check for running background process
	if [ "$pid" -le "0" ] \|\| ! kill -s 0 "$pid" &>/dev/null; then
	ts_skip "unable to run socat"
	fi
	# wait for the socket listener
	if ! socat -u /dev/null UNIX-CONNECT:$socket,retry=30,interval=0.1 &>/dev/null; then
	kill -9 "$pid" &>/dev/null
	ts_skip "timeout waiting for socat socket"
	fi
	# check socket again
	if ! socat -u /dev/null UNIX-CONNECT:$socket &>/dev/null; then
	kill -9 "$pid" &>/dev/null
	ts_skip "socat socket stopped listening"
	fi
	}

	function ts_has_mtab_support {
	grep -q '#define USE_LIBMOUNT_SUPPORT_MTAB' ${top_builddir}/config.h
	if [ $? == 0 ]; then
	echo "yes"
	else
	echo "no"
	fi
	}

	function ts_has_ncurses_support {
	grep -q '#define HAVE_LIBNCURSES' ${top_builddir}/config.h
	if [ $? == 0 ]; then
	echo "yes"
	else
	echo "no"
	fi
	}