[thirdparty/util-linux.git] / tests / functions.sh

#
# 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_skip_subtest {
	echo " IGNORE ($1)"
}

function ts_skip {
	ts_skip_subtest "$1"
	if [ -n "$2" -a -b "$2" ]; then
		ts_device_deinit "$2"
	fi
	exit 0
}

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

function ts_failed_subtest {
	if [ x"$1" == x"" ]; then
		echo " FAILED ($TS_NS)"
	else
		echo " FAILED ($1)"
	fi
}

function ts_failed {
	ts_failed_subtest "$1"
	exit 1
}

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

function ts_ok {
	ts_ok_subtest "$1"
	exit 0
}

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

function ts_has_option {
	NAME="$1"
	ALL="$2"
	echo -n $ALL | sed 's/ //g' | awk 'BEGIN { FS="="; RS="--" } /('$NAME'$|'$NAME'=)/ { print "yes" }'
}

function ts_option_argument {
	NAME="$1"
	ALL="$2"
	echo -n $ALL | sed 's/ //g' | awk 'BEGIN { FS="="; RS="--" } /'$NAME'=/ { print $2 }'
}

function ts_init_core_env {
	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%/*})

	LANG="POSIX"
	LANGUAGE="POSIX"
	LC_ALL="POSIX"
	CHARSET="UTF-8"

	export LANG LANGUAGE LC_ALL CHARSET

	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)

	TS_SCRIPT="$mydir/$(basename $0)"
	TS_SUBDIR=$(dirname $TS_SCRIPT)
	TS_TESTNAME=$(basename $TS_SCRIPT)
	TS_COMPONENT=$(basename $TS_SUBDIR)

	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_init_core_env

	TS_VERBOSE=$(ts_has_option "verbose" "$*")

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

	declare -a TS_SUID_PROGS
	declare -a TS_SUID_USER
	declare -a TS_SUID_GROUP

	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 -eq 0 ] && echo
	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))

	printf "%16s: %-27s ..." "" "$TS_SUBNAME"
}

function ts_init {
	local is_fake=$( ts_has_option "fake" "$*")
	local is_force=$( ts_has_option "force" "$*")
	local is_memcheck=$( ts_has_option "memcheck" "$*")

	if [ "$is_memcheck" == "yes" -a -f /usr/bin/valgrind ]; then
		TS_VALGRIND_CMD="/usr/bin/valgrind"
	fi

	ts_init_env "$*"

	printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC"

	[ "$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 "$TS_TOPDIR/../py${LIBNAME}.la" ] || ts_skip "py${LIBNAME} not compiled"

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

	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_valgrind {
	if [ -z "$TS_VALGRIND_CMD" ]; then
		$*
	else
		$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
				 --leak-resolution=high --num-callers=20 \
				 --log-file="$TS_VGDUMP" $*
	fi
}

function ts_gen_diff {
	local res=0

	if [ -s "$TS_OUTPUT" ]; then

		# 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 [ -s $TS_DIFF ]; then
			res=1
		else
			rm -f $TS_DIFF;
		fi
	else
		res=1
	fi
	return $res
}

function tt_gen_mem_report {
	[ -z "$TS_VALGRIND_CMD" ] && echo "$1"

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

function ts_finalize_subtest {
	local res=0

	if [ -s "$TS_EXPECTED" ]; then
		ts_gen_diff
		if [ $? -eq 1 ]; then
			ts_failed_subtest "$1"
			res=1
		else
			ts_ok_subtest "$(tt_gen_mem_report "$1")"
		fi
	else
		ts_skip_subtest "output undefined"
	fi

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

	# reset environment back to parental test
	ts_init_core_env

	return $res
}

function ts_finalize {
	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

	if [ $TS_NSUBTESTS -ne 0 ]; then
		printf "%11s..."
		if [ $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

	if [ -s $TS_EXPECTED ]; then
		ts_gen_diff
		if [ $? -eq 1 ]; then
			ts_failed "$1"
		fi
		ts_ok "$1"
	fi

	ts_skip "output undefined"
}

function ts_die {
	ts_log "$1"
	if [ -n "$2" ] && [ -b "$2" ]; then
		ts_device_deinit "$2"
		ts_fstab_clean		# for sure... 
	fi
	ts_finalize
}

function ts_image_md5sum {
	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	echo $(md5sum "$img" | awk '{printf $1}') $(basename "$img")
}

function ts_image_init {
	local mib=${1:-"5"}	# size in MiBs
	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	
	dd if=/dev/zero of="$img" bs=1M count=$mib &> /dev/null
	echo "$img"
	return 0
}

function ts_device_init {
	local img=$(ts_image_init $1 $2)
	local dev=$($TS_CMD_LOSETUP --show -f "$img")

	if [ -z "$dev" ]; then
		ts_device_deinit $dev
		return 1		# error
	fi

	echo $dev
	return 0			# succes
}

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_uuid_by_devname {
	echo $($TS_CMD_BLKID -p -s UUID -o value $1)
}

function ts_label_by_devname {
	echo $($TS_CMD_BLKID -p -s LABEL -o value $1)
}

function ts_fstype_by_devname {
	echo $($TS_CMD_BLKID -p -s TYPE -o value $1)
}

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

	case $TAG in
		"TYPE") vl=$(ts_fstype_by_devname $DEV);;
		"LABEL") vl=$(ts_label_by_devname $DEV);;
		"UUID") vl=$(ts_uuid_by_devname $DEV);;
		*) return 1;;
	esac

	if [ "$vl" == "$VAL" ]; then
		return 0
	fi
	return 1
}

function ts_device_has_uuid {
	ts_uuid_by_devname "$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_is_mounted {
	local DEV=$(ts_canonicalize "$1")

	grep -q $DEV /proc/mounts && return 0

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

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

function ts_fstab_close {
	echo "# -->" >> /etc/fstab
}

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_add {
	ts_fstab_open
	ts_fstab_addline $*
	ts_fstab_close
}

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

function ts_fdisk_clean {
	local DEVNAME=$1

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

	sed -i -e 's/Disk identifier:.*/Disk identifier: <removed>/g' \
	       -e 's/Created a new.*/Created a new <removed>./g' \
	       -e 's/^Device[[:blank:]]*Start/Device             Start/g' \
	       -e 's/^Device[[:blank:]]*Boot/Device     Boot/g' \
	       -e 's/^Device[[:blank:]]*Flag/Device     Flag/g' \
	       -e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./g' \
	       $TS_OUTPUT
}

function ts_scsi_debug_init {

	modprobe --dry-run --quiet scsi_debug
	[ "$?" == 0 ] || ts_skip "missing scsi_debug module"

	rmmod scsi_debug &> /dev/null
	modprobe scsi_debug $*
	[ "$?" == 0 ] || ts_die "Cannot init device"

	DEVNAME=$(grep --with-filename scsi_debug /sys/block/*/device/model | awk -F '/' '{print $4}')
	[ "x${DEVNAME}" == "x" ] && ts_die "Cannot find device"

	DEVICE="/dev/${DEVNAME}"

	sleep 1
	udevadm settle

	echo $DEVICE
}
Commit	Line	Data
92f2c23e KZ	1	#
	2	# Copyright (C) 2007 Karel Zak <kzak@redhat.com>
	3	#
601d12fb	4	# This file is part of util-linux.
92f2c23e KZ	5	#
	6	# This file is free software; you can redistribute it and/or modify
	7	# it under the terms of the GNU General Public License as published by
	8	# the Free Software Foundation; either version 2 of the License, or
	9	# (at your option) any later version.
	10	#
	11	# This file is distributed in the hope that it will be useful,
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	# GNU General Public License for more details.
	15	#
e83446da	16
e83446da	17
a02f320d KZ	18	function ts_abspath {
	19	cd $1
	20	pwd
	21	}
d42bbae5	22
6dfe6f0e KZ	23	function ts_canonicalize {
	24	P="$1"
	25	C=$(readlink -f $P)
	26
	27	if [ -n "$C" ]; then
	28	echo "$C"
	29	else
	30	echo "$P"
	31	fi
	32	}
	33
09888efe	34	function ts_skip_subtest {
b30cd7ee	35	echo " IGNORE ($1)"
09888efe KZ	36	}
	37
	38	function ts_skip {
	39	ts_skip_subtest "$1"
f0b561b6	40	if [ -n "$2" -a -b "$2" ]; then
3dfa278e KZ	41	ts_device_deinit "$2"
3dfa278e KZ	42	fi
b30cd7ee KZ	43	exit 0
	44	}
	45
09892fb6	46	function ts_skip_nonroot {
f0b561b6	47	if [ $UID -ne 0 ]; then
09892fb6 KZ	48	ts_skip "not root permissions"
	49	fi
	50	}
	51
09888efe	52	function ts_failed_subtest {
05de8126	53	if [ x"$1" == x"" ]; then
d42bbae5	54	echo " FAILED ($TS_NS)"
05de8126 KZ	55	else
	56	echo " FAILED ($1)"
	57	fi
05de8126 KZ	58	}
05de8126 KZ	59
09888efe KZ	60	function ts_failed {
	61	ts_failed_subtest "$1"
	62	exit 1
	63	}
	64
	65	function ts_ok_subtest {
05de8126 KZ	66	if [ x"$1" == x"" ]; then
	67	echo " OK"
	68	else
	69	echo " OK ($1)"
	70	fi
09888efe KZ	71	}
	72
	73	function ts_ok {
	74	ts_ok_subtest "$1"
05de8126 KZ	75	exit 0
	76	}
	77
57a917d6 KZ	78	function ts_log {
	79	echo "$1" >> $TS_OUTPUT
	80	[ "$TS_VERBOSE" == "yes" ] && echo "$1"
	81	}
	82
1d9acab1 KZ	83	function ts_has_option {
	84	NAME="$1"
	85	ALL="$2"
a02f320d	86	echo -n $ALL \| sed 's/ //g' \| awk 'BEGIN { FS="="; RS="--" } /('$NAME'$\|'$NAME'=)/ { print "yes" }'
1d9acab1 KZ	87	}
1d9acab1 KZ	88
1b03e2cd KZ	89	function ts_option_argument {
	90	NAME="$1"
	91	ALL="$2"
	92	echo -n $ALL \| sed 's/ //g' \| awk 'BEGIN { FS="="; RS="--" } /'$NAME'=/ { print $2 }'
	93	}
	94
db17c74b KZ	95	function ts_init_core_env {
	96	TS_NS="$TS_COMPONENT/$TS_TESTNAME"
	97	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME"
495674f8	98	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME.vgdump"
db17c74b KZ	99	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME"
	100	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	101	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-mnt"
	102	}
	103
	104	function ts_init_core_subtest_env {
	105	TS_NS="$TS_COMPONENT/$TS_TESTNAME-$TS_SUBNAME"
	106	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME"
495674f8	107	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME.vgdump"
db17c74b KZ	108	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME-$TS_SUBNAME"
db17c74b KZ	109	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
64a2331f	110	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-${TS_SUBNAME}-mnt"
495674f8 KZ	111
495674f8 KZ	112	rm -f $TS_OUTPUT $TS_VGDUMP
4210c47a KZ	113	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"
4210c47a KZ	114
495674f8 KZ	115	touch $TS_OUTPUT
495674f8 KZ	116	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
db17c74b KZ	117	}
db17c74b KZ	118
905d0b9b	119	function ts_init_env {
e130ce53	120	local mydir=$(ts_abspath ${0%/*})
d42bbae5	121
08b825db YD	122	LANG="POSIX"
	123	LANGUAGE="POSIX"
	124	LC_ALL="POSIX"
	125	CHARSET="UTF-8"
	126
1b03e2cd KZ	127	export LANG LANGUAGE LC_ALL CHARSET
1b03e2cd KZ	128
6dfe6f0e KZ	129	mydir=$(ts_canonicalize "$mydir")
6dfe6f0e KZ	130
1b03e2cd KZ	131	# automake directories
	132	top_srcdir=$(ts_option_argument "srcdir" "$*")
	133	top_builddir=$(ts_option_argument "builddir" "$*")
d42bbae5	134
1b03e2cd	135	# where is this script
a02f320d	136	TS_TOPDIR=$(ts_abspath $mydir/../../)
1b03e2cd KZ	137
	138	# default
	139	if [ -z "$top_srcdir" ]; then
	140	top_srcdir="$TS_TOPDIR/.."
	141	fi
	142	if [ -z "$top_builddir" ]; then
	143	top_builddir="$TS_TOPDIR/.."
	144	fi
	145
	146	top_srcdir=$(ts_abspath $top_srcdir)
	147	top_builddir=$(ts_abspath $top_builddir)
	148
a02f320d	149	TS_SCRIPT="$mydir/$(basename $0)"
d42bbae5 KZ	150	TS_SUBDIR=$(dirname $TS_SCRIPT)
	151	TS_TESTNAME=$(basename $TS_SCRIPT)
	152	TS_COMPONENT=$(basename $TS_SUBDIR)
	153
09888efe KZ	154	TS_NSUBTESTS=0
	155	TS_NSUBFAILED=0
	156
d42bbae5 KZ	157	TS_SELF="$TS_SUBDIR"
d42bbae5 KZ	158
1b03e2cd KZ	159	TS_OUTDIR="$top_builddir/tests/output/$TS_COMPONENT"
1b03e2cd KZ	160	TS_DIFFDIR="$top_builddir/tests/diff/$TS_COMPONENT"
db17c74b KZ	161
db17c74b KZ	162	ts_init_core_env
d42bbae5	163
cbac71bd	164	TS_VERBOSE=$(ts_has_option "verbose" "$*")
d42bbae5	165
632830cc	166	BLKID_FILE="$TS_OUTDIR/${TS_TESTNAME}.blkidtab"
d42bbae5	167
1b5417ac KZ	168	declare -a TS_SUID_PROGS
	169	declare -a TS_SUID_USER
	170	declare -a TS_SUID_GROUP
	171
adc8c80f KZ	172	if [ -f $TS_TOPDIR/commands.sh ]; then
	173	. $TS_TOPDIR/commands.sh
	174	fi
a02f320d	175
b7ea07e0	176	export BLKID_FILE
66822df3	177
495674f8	178	rm -f $TS_OUTPUT $TS_VGDUMP
4210c47a KZ	179	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"
4210c47a KZ	180
3dfa278e	181	touch $TS_OUTPUT
495674f8	182	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
97cdb3cb	183
d42bbae5 KZ	184	if [ "$TS_VERBOSE" == "yes" ]; then
	185	echo
	186	echo " script: $TS_SCRIPT"
d42bbae5	187	echo " sub dir: $TS_SUBDIR"
a02f320d	188	echo " top dir: $TS_TOPDIR"
d42bbae5 KZ	189	echo " self: $TS_SELF"
	190	echo " test name: $TS_TESTNAME"
	191	echo " test desc: $TS_DESC"
	192	echo " component: $TS_COMPONENT"
	193	echo " namespace: $TS_NS"
	194	echo " verbose: $TS_VERBOSE"
	195	echo " output: $TS_OUTPUT"
495674f8	196	echo " valgrind: $TS_VGDUMP"
d42bbae5 KZ	197	echo " expected: $TS_EXPECTED"
	198	echo " mountpoint: $TS_MOUNTPOINT"
	199	echo
	200	fi
905d0b9b KZ	201	}
905d0b9b KZ	202
09888efe KZ	203	function ts_init_subtest {
	204
	205	TS_SUBNAME="$1"
	206
db17c74b	207	ts_init_core_subtest_env
09888efe KZ	208
	209	[ $TS_NSUBTESTS -eq 0 ] && echo
	210	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))
	211
b8ab3744	212	printf "%16s: %-27s ..." "" "$TS_SUBNAME"
09888efe KZ	213	}
09888efe KZ	214
905d0b9b KZ	215	function ts_init {
905d0b9b KZ	216	local is_fake=$( ts_has_option "fake" "$*")
949cf64b	217	local is_force=$( ts_has_option "force" "$*")
495674f8 KZ	218	local is_memcheck=$( ts_has_option "memcheck" "$*")
	219
	220	if [ "$is_memcheck" == "yes" -a -f /usr/bin/valgrind ]; then
	221	TS_VALGRIND_CMD="/usr/bin/valgrind"
	222	fi
905d0b9b KZ	223
	224	ts_init_env "$*"
	225
b8ab3744	226	printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC"
d42bbae5 KZ	227
d42bbae5 KZ	228	[ "$is_fake" == "yes" ] && ts_skip "fake mode"
949cf64b	229	[ "$TS_OPTIONAL" == "yes" -a "$is_force" != "yes" ] && ts_skip "optional"
e83446da KZ	230	}
e83446da KZ	231
1b5417ac KZ	232	function ts_init_suid {
	233	PROG="$1"
	234	ct=${#TS_SUID_PROGS[*]}
	235
	236	# Save info about original setting
	237	TS_SUID_PROGS[$ct]=$PROG
	238	TS_SUID_USER[$ct]=$(stat --printf="%U" $PROG)
	239	TS_SUID_GROUP[$ct]=$(stat --printf="%G" $PROG)
	240
	241	chown root.root $PROG &> /dev/null
	242	chmod u+s $PROG &> /dev/null
	243	}
	244
a731b541 KZ	245	function ts_init_py {
	246	LIBNAME="$1"
	247
f48145b5	248	[ -f "$TS_TOPDIR/../py${LIBNAME}.la" ] \|\| ts_skip "py${LIBNAME} not compiled"
a731b541 KZ	249
	250	export LD_LIBRARY_PATH="$TS_TOPDIR/../.libs"
	251	export PYTHONPATH="$TS_TOPDIR/../$LIBNAME/python:$TS_TOPDIR/../.libs"
46407453 OO	252
	253	export PYTHON_VERSION=$(awk '/^PYTHON_VERSION/ { print $3 }' $top_builddir/Makefile)
	254	export PYTHON_MAJOR_VERSION=$(echo $PYTHON_VERSION \| sed 's/\..*//')
	255
	256	export PYTHON="python${PYTHON_MAJOR_VERSION}"
a731b541 KZ	257	}
a731b541 KZ	258
495674f8 KZ	259	function ts_valgrind {
	260	if [ -z "$TS_VALGRIND_CMD" ]; then
	261	$*
	262	else
	263	$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
	264	--leak-resolution=high --num-callers=20 \
	265	--log-file="$TS_VGDUMP" $*
	266	fi
	267	}
	268
09888efe KZ	269	function ts_gen_diff {
	270	local res=0
	271
64a2331f	272	if [ -s "$TS_OUTPUT" ]; then
4210c47a	273
46949388 KZ	274	# remove libtool lt- prefixes
	275	sed --in-place 's/^lt\-\(.*\: \)/\1/g' $TS_OUTPUT
	276
4210c47a	277	[ -d "$TS_DIFFDIR" ] \|\| mkdir -p "$TS_DIFFDIR"
09888efe	278	diff -u $TS_EXPECTED $TS_OUTPUT > $TS_DIFF
4210c47a KZ	279
	280	if [ -s $TS_DIFF ]; then
	281	res=1
	282	else
	283	rm -f $TS_DIFF;
	284	fi
09888efe KZ	285	else
	286	res=1
	287	fi
	288	return $res
	289	}
	290
495674f8 KZ	291	function tt_gen_mem_report {
	292	[ -z "$TS_VALGRIND_CMD" ] && echo "$1"
	293
	294	grep -q -E 'ERROR SUMMARY: [1-9]' $TS_VGDUMP &> /dev/null
	295	if [ $? -eq 0 ]; then
	296	echo "mem-error detected!"
	297	fi
	298	}
	299
09888efe	300	function ts_finalize_subtest {
e83446da KZ	301	local res=0
e83446da KZ	302
64a2331f	303	if [ -s "$TS_EXPECTED" ]; then
09888efe KZ	304	ts_gen_diff
	305	if [ $? -eq 1 ]; then
	306	ts_failed_subtest "$1"
	307	res=1
	308	else
495674f8	309	ts_ok_subtest "$(tt_gen_mem_report "$1")"
09888efe KZ	310	fi
	311	else
	312	ts_skip_subtest "output undefined"
	313	fi
	314
	315	[ $res -ne 0 ] && TS_NSUBFAILED=$(( $TS_NSUBFAILED + 1 ))
db17c74b KZ	316
	317	# reset environment back to parental test
	318	ts_init_core_env
	319
09888efe KZ	320	return $res
	321	}
	322
	323	function ts_finalize {
1b5417ac KZ	324	for idx in $(seq 0 $((${#TS_SUID_PROGS[*]} - 1))); do
	325	PROG=${TS_SUID_PROGS[$idx]}
	326	chmod a-s $PROG &> /dev/null
	327	chown ${TS_SUID_USER[$idx]}.${TS_SUID_GROUP[$idx]} $PROG &> /dev/null
	328	done
	329
09888efe	330	if [ $TS_NSUBTESTS -ne 0 ]; then
b8ab3744	331	printf "%11s..."
09888efe KZ	332	if [ $TS_NSUBFAILED -ne 0 ]; then
	333	ts_failed "$TS_NSUBFAILED from $TS_NSUBTESTS sub-tests"
	334	else
	335	ts_ok "all $TS_NSUBTESTS sub-tests PASSED"
	336	fi
e83446da	337	fi
425ca40a KZ	338
	339	if [ -s $TS_EXPECTED ]; then
	340	ts_gen_diff
	341	if [ $? -eq 1 ]; then
	342	ts_failed "$1"
	343	fi
	344	ts_ok "$1"
	345	fi
	346
09888efe	347	ts_skip "output undefined"
e83446da KZ	348	}
e83446da KZ	349
3dfa278e	350	function ts_die {
57a917d6	351	ts_log "$1"
3dfa278e KZ	352	if [ -n "$2" ] && [ -b "$2" ]; then
3dfa278e KZ	353	ts_device_deinit "$2"
c98825ac	354	ts_fstab_clean # for sure...
3dfa278e KZ	355	fi
	356	ts_finalize
	357	}
	358
35c636e1 KZ	359	function ts_image_md5sum {
	360	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	361	echo $(md5sum "$img" \| awk '{printf $1}') $(basename "$img")
	362	}
05de8126	363
35c636e1 KZ	364	function ts_image_init {
	365	local mib=${1:-"5"} # size in MiBs
	366	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	367
	368	dd if=/dev/zero of="$img" bs=1M count=$mib &> /dev/null
	369	echo "$img"
	370	return 0
	371	}
05de8126	372
35c636e1	373	function ts_device_init {
5792255b	374	local img=$(ts_image_init $1 $2)
e2f092d3	375	local dev=$($TS_CMD_LOSETUP --show -f "$img")
df7e52d7	376
632830cc KZ	377	if [ -z "$dev" ]; then
632830cc KZ	378	ts_device_deinit $dev
df7e52d7 KZ	379	return 1 # error
	380	fi
	381
632830cc	382	echo $dev
df7e52d7 KZ	383	return 0 # succes
	384	}
	385
	386	function ts_device_deinit {
3dfa278e KZ	387	local DEV="$1"
	388
	389	if [ -b "$DEV" ]; then
	390	$TS_CMD_UMOUNT "$DEV" &> /dev/null
	391	$TS_CMD_LOSETUP -d "$DEV" &> /dev/null
df7e52d7 KZ	392	fi
df7e52d7 KZ	393	}
064b8c38	394
3f5bda01	395	function ts_uuid_by_devname {
283a8c15	396	echo $($TS_CMD_BLKID -p -s UUID -o value $1)
3f5bda01 KZ	397	}
	398
	399	function ts_label_by_devname {
283a8c15	400	echo $($TS_CMD_BLKID -p -s LABEL -o value $1)
3f5bda01 KZ	401	}
	402
	403	function ts_fstype_by_devname {
283a8c15	404	echo $($TS_CMD_BLKID -p -s TYPE -o value $1)
3f5bda01 KZ	405	}
	406
	407	function ts_device_has {
	408	local TAG="$1"
	409	local VAL="$2"
	410	local DEV="$3"
3dfa278e	411	local vl=""
3f5bda01 KZ	412
	413	case $TAG in
	414	"TYPE") vl=$(ts_fstype_by_devname $DEV);;
	415	"LABEL") vl=$(ts_label_by_devname $DEV);;
	416	"UUID") vl=$(ts_uuid_by_devname $DEV);;
	417	*) return 1;;
	418	esac
	419
	420	if [ "$vl" == "$VAL" ]; then
	421	return 0
	422	fi
	423	return 1
	424	}
3dfa278e KZ	425
	426	function ts_device_has_uuid {
	427	ts_uuid_by_devname "$1" \| egrep -q '^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$'
	428	return $?
	429	}
	430
3ff2557c	431	function ts_is_mounted {
6dfe6f0e	432	local DEV=$(ts_canonicalize "$1")
3ff2557c KZ	433
	434	grep -q $DEV /proc/mounts && return 0
	435
	436	if [ "${DEV#/dev/loop/}" != "$DEV" ]; then
	437	return grep -q "/dev/loop${DEV#/dev/loop/}" /proc/mounts
	438	fi
	439	return 1
	440	}
	441
c98825ac	442	function ts_fstab_open {
601d12fb	443	echo "# <!-- util-linux test entry" >> /etc/fstab
c98825ac KZ	444	}
	445
	446	function ts_fstab_close {
	447	echo "# -->" >> /etc/fstab
	448	}
	449
	450	function ts_fstab_addline {
	451	local SPEC="$1"
	452	local MNT=${2:-"$TS_MOUNTPOINT"}
	453	local FS=${3:-"auto"}
b002d021	454	local OPT=${4:-"defaults"}
c98825ac	455
b002d021	456	echo "$SPEC $MNT $FS $OPT 0 0" >> /etc/fstab
c98825ac KZ	457	}
	458
	459	function ts_fstab_add {
	460	ts_fstab_open
b002d021	461	ts_fstab_addline $*
c98825ac KZ	462	ts_fstab_close
	463	}
	464
	465	function ts_fstab_clean {
	466	sed --in-place "
601d12fb	467	/# <!-- util-linux/!b
c98825ac KZ	468	:a
	469	/# -->/!{
	470	N
	471	ba
	472	}
601d12fb	473	s/# <!-- util-linux.*-->//;
c98825ac KZ	474	/^$/d" /etc/fstab
	475	}
	476
d0bcd9b3	477	function ts_fdisk_clean {
e1fe1815	478	local DEVNAME=$1
618ec053	479
d0bcd9b3	480	# remove non comparable parts of fdisk output
618ec053	481	if [ x"${DEVNAME}" != x"" ]; then
e1fe1815	482	sed -i -e "s:${DEVNAME}:<removed>:g" $TS_OUTPUT
618ec053 KZ	483	fi
618ec053 KZ	484
e1fe1815 KZ	485	sed -i -e 's/Disk identifier:.*/Disk identifier: <removed>/g' \
	486	-e 's/Created a new.*/Created a new <removed>./g' \
	487	-e 's/^Device[[:blank:]]*Start/Device Start/g' \
	488	-e 's/^Device[[:blank:]]*Boot/Device Boot/g' \
	489	-e 's/^Device[[:blank:]]*Flag/Device Flag/g' \
	490	-e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./g' \
d0bcd9b3 FC	491	$TS_OUTPUT
d0bcd9b3 FC	492	}
618ec053 KZ	493
	494	function ts_scsi_debug_init {
	495
	496	modprobe --dry-run --quiet scsi_debug
	497	[ "$?" == 0 ] \|\| ts_skip "missing scsi_debug module"
	498
	499	rmmod scsi_debug &> /dev/null
	500	modprobe scsi_debug $*
	501	[ "$?" == 0 ] \|\| ts_die "Cannot init device"
	502
ef2c9e3f	503	DEVNAME=$(grep --with-filename scsi_debug /sys/block/*/device/model \| awk -F '/' '{print $4}')
618ec053 KZ	504	[ "x${DEVNAME}" == "x" ] && ts_die "Cannot find device"
	505
	506	DEVICE="/dev/${DEVNAME}"
	507
	508	sleep 1
	509	udevadm settle
	510
	511	echo $DEVICE
	512	}