xfstests: use value of FSTYP if defined externally
[xfstests-dev.git] / check
diff --git a/check b/check
index 3b55ebc6ba32fbb360b0c747664f791661e0a88d..268417c258eca9f1ce15dc8f11f70bf4eef21dde 100755 (executable)
--- a/check
+++ b/check
-#!/bin/sh
+#!/bin/bash
 #
 # Control script for QA
 #
-# Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
-# 
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of version 2 of the GNU General Public License as
+# Copyright (c) 2000-2002,2006 Silicon Graphics, Inc.  All Rights Reserved.
+#
+# This program 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.
-# 
-# This program is distributed in the hope that it would be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# 
-# Further, this software is distributed without any warranty that it is
-# free of the rightful claim of any third person regarding infringement
-# or the like.  Any license provided herein, whether implied or
-# otherwise, applies only to this software file.  Patent licenses, if
-# any, provided herein do not apply to combinations of this program with
-# other software, or any other product whatsoever.
-# 
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write the Free Software Foundation, Inc., 59
-# Temple Place - Suite 330, Boston MA 02111-1307, USA.
-# 
-# Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
-# Mountain View, CA  94043, or:
-# 
-# http://www.sgi.com 
-# 
-# For further information regarding this notice, see: 
-# 
-# http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 #
-
-export MKFS_OPTIONS=${MKFS_OPTIONS:=-bsize=4096}
-export MOUNT_OPTIONS=${MOUNT_OPTIONS:=-ologbufs=2}
+# This program is distributed in the hope that it would 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.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write the Free Software Foundation,
+# Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#
 
 tmp=/tmp/$$
 status=0
 needwrap=true
-try=0
+n_try=0
+try=""
 n_bad=0
 bad=""
 notrun=""
 interrupt=true
+diff="diff -u"
+showme=false
+have_test_arg=false
+randomize=false
+here=`pwd`
+xfile=""
 
-# generic initialization
+# start the initialisation work now
 iam=check
-if ! . ./common.rc
+
+export MSGVERB="text:action"
+export QA_CHECK_FS=${QA_CHECK_FS:=true}
+
+# number of diff lines from a failed test, 0 for whole output
+export DIFF_LENGTH=${DIFF_LENGTH:=10}
+
+# by default don't output timestamps
+timestamp=${TIMESTAMP:=false}
+
+rm -f $tmp.list $tmp.tmp $tmp.grep $here/$iam.out $tmp.xlist
+
+# we need common/config
+if ! . ./common/config
 then
-    echo "check: failed to source common.rc"
+    echo "$iam: failed to source common/config"
     exit 1
 fi
 
-if [ $UID -ne 0 ]
-then
-    echo "check: QA must be run as root"
-    exit 1
+# Autodetect fs type based on what's on $TEST_DEV unless it's been set
+# externally
+if [ -z "$FSTYP" -a "$HOSTOS" == "Linux" ]; then
+    FSTYP=`blkid -c /dev/null -s TYPE -o value $TEST_DEV`
 fi
+FSTYP=${FSTYP:=xfs}
+export FSTYP
+
+SUPPORTED_TESTS="[0-9][0-9][0-9] [0-9][0-9][0-9][0-9]"
+SRC_GROUPS="generic shared"
+export SRC_DIR="tests"
+
+usage()
+{
+    echo "Usage: $0 [options] [testlist]"'
+
+check options
+    -nfs                test NFS
+    -tmpfs              test TMPFS
+    -l                 line mode diff
+    -udiff             show unified diff (default)
+    -n                 show me, do not run tests
+    -T                 output timestamps
+    -r                 randomize test order
+    --large-fs         optimise scratch device for large filesystems
+
+testlist options
+    -g group[,group...]        include tests from these groups
+    -x group[,group...]        exclude tests from these groups
+    -X file            exclude individual tests
+    [testlist]         include tests matching names in testlist
+'
+           exit 0
+}
+
+get_group_list()
+{
+       grp=$1
+
+       for d in $SRC_GROUPS $FSTYP; do
+               l=$(sed -n < $SRC_DIR/$d/group \
+                       -e 's/#.*//' \
+                       -e 's/$/ /' \
+                       -e "s;\(^[0-9][0-9][0-9]\).* $grp .*;$SRC_DIR/$d/\1;p")
+               grpl="$grpl $l"
+       done
+       echo $grpl
+}
+
+# find all tests, excluding files that are test metadata such as group files.
+# This assumes that tests are defined purely by alphanumeric filenames with no
+# ".xyz" extensions in the name.
+get_all_tests()
+{
+       touch $tmp.list
+       for d in $SRC_GROUPS $FSTYP; do
+               ls $SRC_DIR/$d/* | \
+                       grep -v "\..*" | \
+                       grep -v "group\|Makefile" >> $tmp.list 2>/dev/null
+       done
+}
+
+# takes the list of tests to run in $tmp.list, and removes the tests passed to
+# the function from that list.
+trim_test_list()
+{
+       test_list="$*"
+
+       rm -f $tmp.grep
+       numsed=0
+       for t in $test_list
+       do
+           if [ $numsed -gt 100 ]; then
+               grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
+               mv $tmp.tmp $tmp.list
+               numsed=0
+               rm -f $tmp.grep
+           fi
+           echo "^$t\$" >>$tmp.grep
+           numsed=`expr $numsed + 1`
+       done
+       grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
+       mv $tmp.tmp $tmp.list
+}
+
 
 _wallclock()
 {
     date "+%H %M %S" | $AWK_PROG '{ print $1*3600 + $2*60 + $3 }'
 }
 
+_timestamp()
+{
+    now=`date "+%T"`
+    echo -n " [$now]"
+}
+
+_prepare_test_list()
+{
+       unset list
+       # Tests specified on the command line
+       if [ -s $tmp.arglist ]; then
+               cat $tmp.arglist > $tmp.list
+       else
+               touch $tmp.list
+       fi
+
+       # Specified groups to include
+       for group in $GROUP_LIST; do
+               list=$(get_group_list $group)
+               if [ -z "$list" ]; then
+                       echo "Group \"$group\" is empty or not defined?"
+                       exit 1
+               fi
+
+               for t in $list; do
+                       grep -s "^$t\$" $tmp.list >/dev/null || \
+                                                       echo "$t" >>$tmp.list
+               done
+       done
+
+       if ! $have_test_arg && [ -z "$GROUP_LIST" ]; then
+               # no test numbers, do everything
+               get_all_tests
+       fi
+
+       # Specified groups to exclude
+       for xgroup in $XGROUP_LIST; do
+               list=$(get_group_list $xgroup)
+               if [ -z "$list" ]; then
+                       echo "Group \"$xgroup\" is empty or not defined?"
+                       exit 1
+               fi
+
+               trim_test_list $list
+       done
+
+       # sort the list of tests into numeric order
+       list=`sort -n $tmp.list | uniq`
+       rm -f $tmp.list $tmp.tmp $tmp.grep
+
+       if $randomize
+       then
+               list=`echo $list | awk -f randomize.awk`
+       fi
+}
+
+# Process command arguments first.
+while [ $# -gt 0 ]; do
+       case "$1" in
+       -\? | -h | --help) usage ;;
+
+       -nfs)   FSTYP=nfs ;;
+       -tmpfs) FSTYP=tmpfs ;;
+
+       -g)     group=$2 ; shift ;
+               GROUP_LIST="$GROUP_LIST $group"
+               ;;
+
+       -x)     xgroup=$2 ; shift ;
+               XGROUP_LIST="$XGROUP_LIST $xgroup"
+               ;;
+
+       -X)     xfile=$2; shift ;
+               for d in $SRC_GROUPS $FSTYP; do
+                       [ -f $SRC_DIR/$d/$xfile ] || continue
+                       for f in `cat $SRC_DIR/$d/$xfile`; do
+                               echo $d/$f >> $tmp.xlist
+                       done
+               done
+               ;;
+
+       -l)     diff="diff" ;;
+       -udiff) diff="$diff -u" ;;
+
+       -n)     showme=true ;;
+        -r)    randomize=true ;;
+
+       -T)     timestamp=true ;;
+
+       --large-fs) export LARGE_SCRATCH_DEV=yes ;;
+       --extra-space=*) export SCRATCH_DEV_EMPTY_SPACE=${r#*=} ;;
+
+       -*)     usage ;;
+       *)      # not an argument, we've got tests now.
+               have_test_arg=true ;;
+       esac
+
+       # if we've found a test specification, the break out of the processing
+       # loop before we shift the arguments so that this is the first argument
+       # that we process in the test arg loop below.
+       if $have_test_arg; then
+               break;
+       fi
+
+       shift
+done
+
+# Process tests from command line now.
+if $have_test_arg; then
+       while [ $# -gt 0 ]; do
+               case "$1" in
+               -*)     echo "Argments before tests, please!"
+                       status=1
+                       exit $status
+                       ;;
+               *)      test_dir=`dirname $1`
+                       test_dir=${test_dir#$SRC_DIR/*}
+                       test_name=`basename $1`
+                       group_file=$SRC_DIR/$test_dir/group
+
+                       if egrep "^$test_name" $group_file >/dev/null ; then
+                               # in group file ... OK
+                               echo $SRC_DIR/$test_dir/$test_name >>$tmp.arglist
+                       else
+                               # oops
+                               echo "$1 - unknown test, ignored"
+                       fi
+                       ;;
+               esac
+
+               shift
+       done
+fi
+
+_prepare_test_list
+
+# we need common/rc
+if ! . ./common/rc
+then
+    echo "check: failed to source common/rc"
+    exit 1
+fi
+
+if [ `id -u` -ne 0 ]
+then
+    echo "check: QA must be run as root"
+    exit 1
+fi
+
+# Ok, time to start running...
+
 _wrapup()
 {
-    # for hangcheck ...
-    # remove files that were used by hangcheck
-    #
-    [ -f /tmp/check.pid ] && rm -rf /tmp/check.pid
-    [ -f /tmp/check.sts ] && rm -rf /tmp/check.sts
+    seq="check"
+    check="$RESULT_BASE/check"
 
     if $showme
     then
        :
     elif $needwrap
     then
-       if [ -f check.time -a -f $tmp.time ]
+       if [ -f $check.time -a -f $tmp.time ]
        then
-           cat check.time $tmp.time \
+           cat $check.time $tmp.time \
            | $AWK_PROG '
        { t[$1] = $2 }
 END    { if (NR > 0) {
@@ -87,142 +318,148 @@ END      { if (NR > 0) {
          }
        }' \
            | sort -n >$tmp.out
-           mv $tmp.out check.time
+           mv $tmp.out $check.time
        fi
 
-       if [ -f $tmp.expunged ]
+       echo "" >>$check.log
+       date >>$check.log
+       echo $list | fmt | sed -e 's/^/    /' -e "s;$SRC_DIR/;;g" >>$check.log
+       $interrupt && echo "Interrupted!" >>$check.log
+        
+        if [ ! -z "$n_try" -a $n_try != 0 ]
        then
-           notrun=`wc -l <$tmp.expunged | sed -e 's/  *//g'`
-           try=`expr $try - $notrun`
-           list=`echo "$list" | sed -f $tmp.expunged`
+           echo "Ran:$try"
        fi
 
-       echo "" >>check.log
-       date >>check.log
-       echo $list | fmt | sed -e 's/^/    /' >>check.log
-       $interrupt && echo "Interrupted!" >>check.log
-        
        if [ ! -z "$notrun" ]
        then
            echo "Not run:$notrun"
-           echo "Not run:$notrun" >>check.log
+           echo "Not run:$notrun" >>$check.log
        fi
+
         if [ ! -z "$n_bad" -a $n_bad != 0 ]
        then
            echo "Failures:$bad"
-           echo "Failed $n_bad of $try tests"
-           echo "Failures:$bad" | fmt >>check.log
-           echo "Failed $n_bad of $try tests" >>check.log
+           echo "Failed $n_bad of $n_try tests"
+           echo "Failures:$bad" | fmt >>$check.log
+           echo "Failed $n_bad of $n_try tests" >>$check.log
        else
-           echo "Passed all $try tests"
-           echo "Passed all $try tests" >>check.log
+           echo "Passed all $n_try tests"
+           echo "Passed all $n_try tests" >>$check.log
        fi
        needwrap=false
     fi
 
+    rm -f /tmp/*.rawout /tmp/*.out /tmp/*.err /tmp/*.time
     rm -f $tmp.*
 }
 
 trap "_wrapup; exit \$status" 0 1 2 3 15
 
-# for hangcheck ...
-# Save pid of check in a well known place, so that hangcheck can be sure it
-# has the right pid (getting the pid from ps output is not reliable enough).
-#
-rm -rf /tmp/check.pid
-echo $$ >/tmp/check.pid
+mkdir -p $RESULT_BASE
+if [ ! -d $RESULT_BASE ]; then
+       echo "failed to create results directory $RESULTS_BASE"
+       exit 1;
+fi
 
-# for hangcheck ...
-# Save the status of check in a well known place, so that hangcheck can be
-# sure to know where check is up to (getting test number from ps output is
-# not reliable enough since the trace stuff has been introduced).
-#
-rm -rf /tmp/check.sts
-echo "preamble" >/tmp/check.sts
+seq="check"
+check="$RESULT_BASE/check"
 
 # don't leave old full output behind on a clean run
-rm -f check.full
+rm -f $check.full
 
-# by default don't output timestamps
-timestamp=${TIMESTAMP:=false}
+[ -f $check.time ] || touch $check.time
 
-. ./common
+# print out our test configuration
+echo "FSTYP         -- `_full_fstyp_details`"
+echo "PLATFORM      -- `_full_platform_details`"
+if [ ! -z "$SCRATCH_DEV" ]; then
+  echo "MKFS_OPTIONS  -- `_scratch_mkfs_options`"
+  echo "MOUNT_OPTIONS -- `_scratch_mount_options`"
+fi
+echo
 
-[ -f check.time ] || touch check.time
 
-if [ ! -z "$MKFS_OPTIONS" ]
-then
-    echo "check: \$MKFS_OPTIONS specified -- \"$MKFS_OPTIONS\""
-    umount $SCRATCH_DEV 2>/dev/null
-    # call the overridden mkfs.xfs - make sure the FS is built
-    # the same as we'll create it later.
-    if ! mkfs_xfs -f $SCRATCH_DEV >$tmp.err 2>&1
-    then
-       echo "our local mkfs_xfs routine ..."
-       cat $tmp.err
-        echo "check: failed to mkfs.xfs \$SCRATCH_DEV using specified options"
-        exit 1
-    fi
-fi
+if [ ! -z "$SCRATCH_DEV" ]; then
+  umount $SCRATCH_DEV 2>/dev/null
+  # call the overridden mkfs - make sure the FS is built
+  # the same as we'll create it later.
 
-if [ ! -z "$MOUNT_OPTIONS" ]
-then
-    echo "check: \$MOUNT_OPTIONS specified -- \"$MOUNT_OPTIONS\""
-    umount $TEST_DEV
-    # call the overridden mount - make sure the FS starts as
-    # the same as we'll set it later.
-    if ! mount -t xfs $TEST_DEV $TEST_DIR >$tmp.err 2>&1
-    then
-       echo "our local mount routine ..."
-       cat $tmp.err
-        # call the normal mount
-       echo "normal mount ..."
-        /bin/mount -t xfs $TEST_DEV $TEST_DIR
-        echo "check: failed to mount \$TEST_DEV using specified mount options"
-        exit 1
-    fi
+  if ! _scratch_mkfs $flag >$tmp.err 2>&1
+  then
+      echo "our local _scratch_mkfs routine ..."
+      cat $tmp.err
+      echo "check: failed to mkfs \$SCRATCH_DEV using specified options"
+      exit 1
+  fi
+
+  # call the overridden mount - make sure the FS mounts with
+  # the same options that we'll mount with later.
+  if ! _scratch_mount >$tmp.err 2>&1
+  then
+      echo "our local mount routine ..."
+      cat $tmp.err
+      echo "check: failed to mount \$SCRATCH_DEV using specified options"
+      exit 1
+  fi
 fi
 
-seq="check"
-_check_fs $TEST_DEV
+seqres="$check"
+_check_test_fs
 
 for seq in $list
 do
     err=false
-    echo -n "$seq"
+
+    # the filename for the test and the name output are different.
+    # we don't include the tests/ directory in the name output.
+    seqnum=`echo $seq | sed -e "s;$SRC_DIR/;;"`
+
+    # Similarly, the result directory needs to replace the tests/
+    # part of the test location.
+    group=`dirname $seq`
+    export RESULT_DIR=`echo $group | sed -e "s;$SRC_DIR;$RESULT_BASE;"`
+    mkdir -p $RESULT_DIR
+    seqres="$RESULT_BASE/$seqnum"
+
+    echo -n "$seqnum"
+
     if $showme
     then
        echo
        continue
-    elif [ -f expunged ] && $expunge && egrep "^$seq([         ]|\$)" expunged >/dev/null
-    then
-       echo " - expunged"
-       rm -f $seq.out.bad
-       echo "/^$seq\$/d" >>$tmp.expunged
     elif [ ! -f $seq ]
     then
        echo " - no such test?"
-       echo "/^$seq\$/d" >>$tmp.expunged
     else
        # really going to try and run this one
        #
-       rm -f $seq.out.bad
-       lasttime=`sed -n -e "/^$seq /s/.* //p" <check.time`
+       rm -f $seqres.out.bad
+
+       # check if we really should run it
+       if [ -s $tmp.xlist ]; then
+               if grep $seqnum $tmp.xlist > /dev/null 2>&1 ; then
+                       echo "       [expunged]"
+                       continue
+               fi
+       fi
+
+       # slashes now in names, sed barfs on them so use grep
+       lasttime=`grep -w ^$seqnum $check.time | awk '// {print $2}'`
        if [ "X$lasttime" != X ]; then
                echo -n " ${lasttime}s ..."
        else
                echo -n "       "       # prettier output with timestamps.
        fi
-       rm -f core $seq.notrun
-
-       # for hangcheck ...
-       echo "$seq" >/tmp/check.sts
+       rm -f core $seqres.notrun
 
        start=`_wallclock`
        $timestamp && echo -n " ["`date "+%T"`"]"
-       sh $seq >$tmp.rawout 2>&1
+       [ ! -x $seq ] && chmod u+x $seq # ensure we can run it
+       $LOGGER_PROG "run xfstest $seqnum"
+       ./$seq >$tmp.rawout 2>&1
        sts=$?
-       $timestamp && echo -n " ["`date "+%T"`"]"
+       $timestamp && _timestamp
        stop=`_wallclock`
 
        _fix_malloc <$tmp.rawout >$tmp.out
@@ -231,16 +468,16 @@ do
        if [ -f core ]
        then
            echo -n " [dumped core]"
-           mv core $seq.core
+           mv core $RESULT_BASE/$seqnum.core
            err=true
        fi
 
-       if [ -f $seq.notrun ]
+       if [ -f $seqres.notrun ]
        then
            $timestamp || echo -n " [not run] "
-           $timestamp && echo " [not run]" && echo -n "        $seq -- "
-           cat $seq.notrun
-           notrun="$notrun $seq"
+           $timestamp && echo " [not run]" && echo -n "        $seqnum -- "
+           cat $seqres.notrun
+           notrun="$notrun $seqnum"
        else
            if [ $sts -ne 0 ]
            then
@@ -252,19 +489,33 @@ do
                echo " - no qualified output"
                err=true
            else
+
+               # coreutils 8.16+ changed quote formats in error messages from
+               # `foo' to 'foo'. Filter old versions to match the new version.
+               sed -i "s/\`/\'/g" $tmp.out
                if diff $seq.out $tmp.out >/dev/null 2>&1
                then
-                   echo ""
                    if $err
                    then
                        :
                    else
-                       echo "$seq `expr $stop - $start`" >>$tmp.time
+                       echo "$seqnum `expr $stop - $start`" >>$tmp.time
+                       echo -n " `expr $stop - $start`s"
                    fi
+                   echo ""
                else
-                   echo " - output mismatch (see $seq.out.bad)"
-                   mv $tmp.out $seq.out.bad
-                   $diff $seq.out $seq.out.bad
+                   echo " - output mismatch (see $seqres.out.bad)"
+                   mv $tmp.out $seqres.out.bad
+                   $diff $seq.out $seqres.out.bad | {
+                       if test "$DIFF_LENGTH" -le 0; then
+                               cat
+                       else
+                               head -n "$DIFF_LENGTH"
+                               echo "..."
+                               echo "(Run '$diff $seq.out $seqres.out.bad'" \
+                                       " to see the entire diff)"
+                       fi; } | \
+                       sed -e 's/^\(.\)/    \1/'
                    err=true
                fi
            fi
@@ -276,15 +527,18 @@ do
     #
     if $err
     then
-       bad="$bad $seq"
+       bad="$bad $seqnum"
        n_bad=`expr $n_bad + 1`
        quick=false
     fi
-    [ -f $seq.notrun ] || try=`expr $try + 1`
-    
-    seq="after_$seq"
-    _check_fs $TEST_DEV
-    
+    if [ ! -f $seqres.notrun ]
+    then
+       try="$try $seqnum"
+       n_try=`expr $n_try + 1`
+        _check_test_fs
+    fi
+
+    seq="after_$seqnum"
 done
 
 interrupt=false