blob: 792fff2efef46d95c4d91dc65ce1c73d1f389e86 [file] [log] [blame]
#!/bin/bash
#
# Copyright (c) International Business Machines Corp., 2005
# Authors: Avantika Mathur (mathurav@us.ibm.com)
# Matt Helsley (matthltc@us.ibm.com)
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
if tst_kvercmp 2 6 15 ; then
tst_resm TCONF "System kernel version is less than 2.6.15"
tst_resm TCONF "Cannot execute test"
exit 0
fi
test_setup()
{
#######################################################################
## Configure
#######################################################################
dopts='-dEBb'
## Remove logged test state depending on results. 0 means do not remove,
## 1 means OK to remove.
# rm saved state from tests that appear to have cleaned up properly?
rm_ok=1
# rm saved state from tests that don't appear to have fully cleaned up?
rm_err=0
#######################################################################
## Initialize some variables
#######################################################################
TCID="$0"
TST_COUNT=0
test_dirs=( move bind rbind regression ) #cloneNS
nfailed=0
nsucceeded=0
# set the LTPROOT directory
cd `dirname $0`
LTPROOT="${PWD}"
echo "${LTPROOT}" | grep testscripts > /dev/null 2>&1
if [ $? -eq 0 ]; then
cd ..
LTPROOT="${PWD}"
fi
FS_BIND_ROOT="${LTPROOT}/testcases/bin/fs_bind"
total=0 # total number of tests
for dir in "${test_dirs[@]}" ; do
((total += `ls "${FS_BIND_ROOT}/${dir}/test"* | wc -l`))
done
TST_TOTAL=${total}
# set the PATH to include testcases/bin
LTPBIN="${LTPROOT}/testcases/bin"
PATH="${PATH}:/usr/sbin:${LTPBIN}:${FS_BIND_ROOT}/bin"
# Results directory
resdir="${LTPROOT}/results/fs_bind"
if [ ! -d "${resdir}" ]; then
mkdir -p "${resdir}" 2> /dev/null
fi
TMPDIR="${TMPDIR:-/tmp}"
# A temporary directory where we can do stuff and that is
# safe to remove
sandbox="${TMPDIR}/sandbox"
ERR_MSG=""
export LTPBIN PATH FS_BIND_ROOT ERR_MSG TCID TST_COUNT TST_TOTAL
if [ ! -d "${resdir}" ]; then
tst_brkm TBROK true "$0: failed to make results directory"
exit 1
fi
}
test_prereqs()
{
# Must be root to run the containers testsuite
if [ $UID != 0 ]; then
tst_brkm TBROK true "FAILED: Must be root to execute this script"
exit 1
fi
mkdir "${sandbox}" >& /dev/null
if [ ! -d "${sandbox}" -o ! -x "${sandbox}" ]; then
tst_brkm TBROK true "$0: failed to make directory \"${sandbox}\""
exit -1
fi
mount --bind "${sandbox}" "${sandbox}" >& /dev/null
if [ $? -ne 0 ]; then
tst_brkm TBROK true "$0: failed to perform bind mount on directory \"${sandbox}\""
exit 1
fi
mount --make-private "${sandbox}" >& /dev/null
if [ $? -ne 0 ]; then
tst_brkm TBROK true "$0: failed to make private mountpoint on directory \"${sandbox}\""
exit 1
fi
local mnt_bind=1
local mnt_move=1
pushd "${sandbox}" > /dev/null && {
mkdir bind_test move_test && {
mount --bind bind_test bind_test && {
mnt_bind=0
mount --move bind_test move_test && {
mnt_move=0
umount move_test
} || {
# bind mount succeeded but move mount
# failed
umount bind_test
}
} || {
# mount failed -- check if it's because we
# don't have privileges we need
if [ $? -eq 32 ]; then
tst_brkm TBROK true "$0 requires the privilege to use the mount command"
exit 32
fi
}
rmdir bind_test move_test
}
popd > /dev/null
}
if [ ${mnt_bind} -eq 1 -o ${mnt_move} -eq 1 ]; then
tst_brkm TBROK true "$0: requires that mount support the --bind and --move options"
exit 1
fi
tst_kvercmp 2 6 15
X=$?
if [ $X -lt 0 ]; then
tst_brkm TBROK "$0: failed to get the running kernel version"
exit 1
elif [ $X -lt 1 ]; then
tst_resm TWARN "$0: the remaining tests require 2.6.15 or later"
tst_exit 0
exit
else
tst_resm TINFO "$0: kernel >= 2.6.15 detected -- continuing"
fi
mount --make-shared "${sandbox}" > /dev/null 2>&1 || "${FS_BIND_ROOT}/bin/smount" "${sandbox}" shared
umount "${sandbox}" || {
tst_resm TFAIL "$0: failed to umount simplest shared subtree"
exit 1
}
tst_resm TPASS "$0: umounted simplest shared subtree"
}
# mounts we are concerned with in a well-defined order (helps diff)
# returns grep return codes
grep_proc_mounts()
{
local rc=0
# Save the pipefail shell option
shopt -o -q pipefail
local save=$?
set -o pipefail
# Grep /proc/mounts which is often more up-to-date than mounts
# We use pipefail because if the grep fails we want to pass that along
grep -F "${sandbox}" /proc/mounts | sort -b
rc=$?
# Restore the pipefail shell options
[ $save -eq 0 ] && shopt -o -s pipefail || shopt -o -u pipefail
return $rc
}
# Record the mount state
save_proc_mounts()
{
touch "$2/proc_mounts.before" >& /dev/null
if [ $? -ne 0 ]; then
tst_brkm TBROK true "$1: failed to record proc mounts"
return 1
fi
grep_proc_mounts 2> /dev/null > "$2/proc_mounts.before"
return 0
}
# Compare mount list after the test with the list from before.
# If there are no differences then remove the before list and silently
# return 0. Else print the differences to stderr and return 1.
check_proc_mounts()
{
local tname="$1"
if [ ! -r "$2/proc_mounts.before" ]; then
tst_brkm TBROK true "${tname}: Could not find pre-test proc mount list"
return 1
fi
grep_proc_mounts 2> /dev/null > "$2/proc_mounts.after"
# If the mounts are the same then just return
diff ${dopts} -q "$2/proc_mounts.before" "$2/proc_mounts.after" >& /dev/null
if [ $? -eq 0 ]; then
[ $rm_ok -eq 1 ] && rm -f "$2/proc_mounts."{before,after}
return 0
fi
tst_resm TWARN "${tname}: did not properly clean up its proc mounts"
diff ${dopts} -U 0 "$2/proc_mounts.before" "$2/proc_mounts.after" | grep -vE '^\@\@' 1>&2
[ $rm_err -eq 1 ] && rm -f "$2/proc_mounts."{before,after}
return 1
}
# Undo leftover mounts
restore_proc_mounts()
{
#local tname="$1"
# do lazy umounts -- we're assuming that tests will only leave
# new mounts around and will never remove mounts outside the test
# directory
( while grep_proc_mounts ; do
grep_proc_mounts | awk '{print $2}' | xargs -r -n 1 umount -l
done ) >& /dev/null
# mount list and exit with 0
[ $rm_err -eq 1 ] && rm -f "$2/proc_mounts."{before,after} 1>&2 # >& /dev/null
return 0
# if returning error do this:
# tst_brkm TBROK true "${tname}: failed to restore mounts"
}
# mounts we are concerned with in a well-defined order (helps diff)
# returns grep return codes
grep_mounts()
{
local rc=0
# Save the pipefail shell option
shopt -o -q pipefail
local save=$?
set -o pipefail
# Grep mount command output (which tends to come from /etc/mtab)
# We use pipefail because if the grep fails we want to pass that along
mount | grep -F "${sandbox}" | sort -b
rc=$?
# Restore the pipefail shell options
[ $save -eq 0 ] && shopt -o -s pipefail || shopt -o -u pipefail
return $rc
}
# Record the mount state
save_mounts()
{
touch "$2/mtab.before" >& /dev/null
if [ $? -ne 0 ]; then
tst_brkm TBROK true "$1: failed to record mtab mounts"
return 1
fi
grep_mounts 2> /dev/null > "$2/mtab.before"
return 0
}
# Compare mount list after the test with the list from before.
# If there are no differences then remove the before list and silently
# return 0. Else print the differences to stderr and return 1.
check_mounts()
{
local tname="$1"
if [ ! -r "$2/mtab.before" ]; then
tst_brkm TBROK true "${tname}: Could not find pre-test mtab mount list"
return 1
fi
grep_mounts 2> /dev/null > "$2/mtab.after"
# If the mounts are the same then just return
diff ${dopts} -q "$2/mtab.before" "$2/mtab.after" >& /dev/null
if [ $? -eq 0 ]; then
[ $rm_ok -eq 1 ] && rm -f "$2/mtab."{before,after}
return 0
fi
tst_resm TWARN "${tname}: did not properly clean up its mtab mounts"
diff ${dopts} -U 0 "$2/mtab.before" "$2/mtab.after" | grep -vE '^\@\@' 1>&2
[ $rm_err -eq 1 ] && rm -f "$2/mtab."{before,after}
return 1
}
# Undo leftover mounts
restore_mounts()
{
#local tname="$1"
# do lazy umounts -- we're assuming that tests will only leave
# new mounts around and will never remove mounts outside the test
# directory
( while grep_mounts ; do
grep_mounts | awk '{print $3}' | xargs -r -n 1 umount -l
done ) >& /dev/null
# mount list and exit with 0
[ $rm_err -eq 1 ] && rm -f "$2/mtab."{before,after} 1>&2 # >& /dev/null
return 0
# if returning error do this:
# tst_brkm TBROK true "${tname}: failed to restore mounts"
}
# Record the sandbox state
# We don't save full sandbox state -- just the names of files and dirs present
save_sandbox()
{
local when="before"
local tname="$1"
if [ -e "$2/files.before" ]; then
if [ -e "$2/files.after" ]; then
tst_brkm TBROK true "${tname}: stale catalog of \"${sandbox}\""
return 1
fi
when="after"
fi
( find "${sandbox}" -type d -print | sort > "$2/dirs.$when"
find "${sandbox}" -type f -print | sort | \
grep -vE '^'"$2"'/(dirs|files)\.(before|after)$' > "$2/files.$when" ) >& /dev/null
return 0
}
# Save sandbox after test and then compare. If the sandbox state is not
# clean then print the differences to stderr and return 1. Else remove all
# saved sandbox state and silently return 0
check_sandbox()
{
local tname="$1"
if [ ! -r "$2/files.before" -o ! -r "$2/dirs.before" ]; then
tst_brkm TBROK true "${tname} missing saved catalog of \"${sandbox}\""
return 1
fi
save_sandbox "${tname} (check)" "$2"
( diff ${dopts} -q "$2/dirs.before" "$2/dirs.after" && \
diff ${dopts} -q "$2/files.before" "$2/files.after" ) >& /dev/null \
&& {
[ $rm_ok -eq 1 ] && rm -f "$2/"{files,dirs}.{before,after}
return 0
}
tst_resm TWARN "${tname} did not properly clean up \"${sandbox}\""
diff ${dopts} -U 0 "$2/dirs.before" "$2/dirs.after" 1>&2
diff ${dopts} -U 0 "$2/files.before" "$2/files.after" 1>&2
[ $rm_err -eq 1 ] && rm -f "$2/"{files,dirs}.{before,after} 1>&2
return 1
}
# Robust sandbox cleanup
clean_sandbox()
{
local tname="$1"
{ rm -rf "${sandbox}" ; mkdir "${sandbox}" ; } >& /dev/null
if [ ! -d "${sandbox}" -o ! -x "${sandbox}" ]; then
tst_brkm TBROK true "$tname: failed to make directory \"${sandbox}\""
return 1
fi
return 0
}
# Check file for non-whitespace chars
is_file_empty()
{
awk '/^[[:space:]]*$/ { next }
{ exit 1; }' < "$1"
}
#
# Run the specified test script.
#
# Return 1 if the test was broken but should not stop the remaining test
# categories from being run.
# Return 2 if the test was broken and no further tests should be run.
# Return 0 otherwise (if the test was broken but it shouldn't affect other
# test runs)
# Note that this means the return status is not the success or failure of the
# test itself.
#
run_test()
{
local t="$1"
local tname="$(basename "$(dirname "$t")")/$(basename "$t")"
local log="$resdir/$tname/log"
local errlog="$resdir/$tname/err"
local do_break=0
ERR_MSG=""
# Pre-test
mkdir -p "$resdir/$tname"
if [ ! -d "$resdir/$tname" -o ! -x "$resdir/$tname" ]; then
tst_brkm TBROK true "$0: can't make or use \"$resdir/$tname\" as a log directory"
return 1
fi
save_sandbox "$tname" "$resdir/$tname" || do_break=1
save_mounts "$tname" "$resdir/$tname" || do_break=1
save_proc_mounts "$tname" "$resdir/$tname" || do_break=1
mount --bind "${sandbox}" "${sandbox}" >& /dev/null || do_break=1
mount --make-private "${sandbox}" >& /dev/null || do_break=1
if [ $do_break -eq 1 ]; then
tst_brkm TBROK true "$tname: failed to save pre-test state of \"${sandbox}\""
return 2
fi
pushd "${sandbox}" > /dev/null
# Run the test
(
TCID="$tname"
declare -r TST_COUNT
export LTPBIN PATH FS_BIND_ROOT ERR_MSG TCID TST_COUNT TST_TOTAL
"$t" #> "$log" 2> "$errlog"
)
local rc=$?
TCID="$0"
# Post-test
popd > /dev/null
if [ $rc -ne 0 ]; then
#echo "FAILED"
((nfailed++))
else
#echo "SUCCEEDED"
((nsucceeded++))
fi
umount -l "${sandbox}" >& /dev/null
check_proc_mounts "$tname" "$resdir/$tname" || \
restore_proc_mounts "$tname" "$resdir/$tname" || do_break=1
check_mounts "$tname" "$resdir/$tname" || \
restore_mounts "$tname" "$resdir/$tname" || do_break=1
check_sandbox "$tname" "$resdir/$tname"
clean_sandbox "$tname" || do_break=1
if [ $do_break -eq 1 ]; then
tst_brkm TBROK true "$tname: failed to restore pre-test state of \"${sandbox}\""
return 2
fi
# If we succeeded and the error log is empty remove it
if [ $rc -eq 0 -a -w "$errlog" ] && is_file_empty "$errlog" ; then
rm -f "$errlog"
fi
return 0
}
main()
{
TST_COUNT=1
for dir in "${test_dirs[@]}" ; do
tests=( $(find "${FS_BIND_ROOT}/${dir}" -type f -name 'test*') )
clean_sandbox "$0" || break
for t in "${tests[@]}" ; do
run_test "$t"
local rc=$?
if [ $rc -ne 0 ]; then
break $rc
fi
((TST_COUNT++))
done
done
rm -rf "${sandbox}"
return 0
skipped=$((total - nsucceeded - nfailed))
if [ $nfailed -eq 0 -a $skipped -eq 0 ]; then
# Use PASSED for the summary rather than SUCCEEDED to make it
# easy to determine 100% success from a calling script
summary="PASSED"
else
# Use FAILED to make it easy to find > 0% failure from a
# calling script
summary="FAILED"
fi
cat - <<-EOF
*********************************
RESULTS SUMMARY:
passed: $nsucceeded/$total
failed: $nfailed/$total
skipped: $skipped/$total
summary: $summary
*********************************
EOF
}
test_setup || exit 1
test_prereqs || exit 1
declare -r FS_BIND_ROOT
declare -r TST_TOTAL
main #2> "$resdir/errors" 1> "$resdir/summary"