btrfs/048: add validation of compression options
[xfstests-dev.git] / check
1 #!/bin/bash
2 # SPDX-License-Identifier: GPL-2.0
3 # Copyright (c) 2000-2002,2006 Silicon Graphics, Inc.  All Rights Reserved.
4 #
5 # Control script for QA
6 #
7 tmp=/tmp/$$
8 status=0
9 needwrap=true
10 needsum=true
11 n_try=0
12 try=""
13 n_bad=0
14 sum_bad=0
15 bad=""
16 n_notrun=0
17 notrun=""
18 interrupt=true
19 diff="diff -u"
20 showme=false
21 have_test_arg=false
22 randomize=false
23 export here=`pwd`
24 xfile=""
25 subdir_xfile=""
26 brief_test_summary=false
27 do_report=false
28 DUMP_OUTPUT=false
29
30 # This is a global variable used to pass test failure text to reporting gunk
31 _err_msg=""
32
33 # start the initialisation work now
34 iam=check
35
36 export MSGVERB="text:action"
37 export QA_CHECK_FS=${QA_CHECK_FS:=true}
38
39 # number of diff lines from a failed test, 0 for whole output
40 export DIFF_LENGTH=${DIFF_LENGTH:=10}
41
42 # by default don't output timestamps
43 timestamp=${TIMESTAMP:=false}
44
45 rm -f $tmp.list $tmp.tmp $tmp.grep $here/$iam.out $tmp.xlist $tmp.report.*
46
47 SRC_GROUPS="generic shared"
48 export SRC_DIR="tests"
49
50 usage()
51 {
52     echo "Usage: $0 [options] [testlist]"'
53
54 check options
55     -nfs                test NFS
56     -glusterfs                test GlusterFS
57     -cifs               test CIFS
58     -9p                 test 9p
59     -overlay            test overlay
60     -pvfs2          test PVFS2
61     -tmpfs              test TMPFS
62     -ubifs              test ubifs
63     -l                  line mode diff
64     -udiff              show unified diff (default)
65     -n                  show me, do not run tests
66     -T                  output timestamps
67     -r                  randomize test order
68     -d                  dump test output to stdout
69     -b                  brief test summary
70     -R fmt[,fmt]        generate report in formats specified. Supported format: [xunit]
71     --large-fs          optimise scratch device for large filesystems
72     -s section          run only specified section from config file
73     -S section          exclude the specified section from the config file
74
75 testlist options
76     -g group[,group...] include tests from these groups
77     -x group[,group...] exclude tests from these groups
78     -X exclude_file     exclude individual tests
79     -E external_file    exclude individual tests
80     [testlist]          include tests matching names in testlist
81
82 testlist argument is a list of tests in the form of <test dir>/<test name>.
83
84 <test dir> is a directory under tests that contains a group file,
85 with a list of the names of the tests in that directory.
86
87 <test name> may be either a specific test file name (e.g. xfs/001) or
88 a test file name match pattern (e.g. xfs/*).
89
90 group argument is either a name of a tests group to collect from all
91 the test dirs (e.g. quick) or a name of a tests group to collect from
92 a specific tests dir in the form of <test dir>/<group name> (e.g. xfs/quick).
93 If you want to run all the tests in the test suite, use "-g all" to specify all
94 groups.
95
96 exclude_file argument refers to a name of a file inside each test directory.
97 for every test dir where this file is found, the listed test names are
98 excluded from the list of tests to run from that test dir.
99
100 external_file argument is a path to a single file containing a list of tests
101 to exclude in the form of <test dir>/<test name>.
102
103 examples:
104  check xfs/001
105  check -g quick
106  check -g xfs/quick
107  check -x stress xfs/*
108  check -X .exclude -g auto
109  check -E ~/.xfstests.exclude
110 '
111             exit 0
112 }
113
114 get_sub_group_list()
115 {
116         local d=$1
117         local grp=$2
118
119         test -s "$SRC_DIR/$d/group" || return 1
120
121         local grpl=$(sed -n < $SRC_DIR/$d/group \
122                 -e 's/#.*//' \
123                 -e 's/$/ /' \
124                 -e "s;^\($VALID_TEST_NAME\).* $grp .*;$SRC_DIR/$d/\1;p")
125         echo $grpl
126 }
127
128 get_group_list()
129 {
130         local grp=$1
131         local grpl=""
132         local sub=$(dirname $grp)
133
134         if [ -n "$sub" -a "$sub" != "." -a -d "$SRC_DIR/$sub" ]; then
135                 # group is given as <subdir>/<group> (e.g. xfs/quick)
136                 grp=$(basename $grp)
137                 get_sub_group_list $sub $grp
138                 return
139         fi
140
141         for d in $SRC_GROUPS $FSTYP; do
142                 if ! test -d "$SRC_DIR/$d" ; then
143                         continue
144                 fi
145                 grpl="$grpl $(get_sub_group_list $d $grp)"
146         done
147         echo $grpl
148 }
149
150 # Find all tests, excluding files that are test metadata such as group files.
151 # It matches test names against $VALID_TEST_NAME defined in common/rc
152 get_all_tests()
153 {
154         touch $tmp.list
155         for d in $SRC_GROUPS $FSTYP; do
156                 if ! test -d "$SRC_DIR/$d" ; then
157                         continue
158                 fi
159                 ls $SRC_DIR/$d/* | \
160                         grep -v "\..*" | \
161                         grep "^$SRC_DIR/$d/$VALID_TEST_NAME"| \
162                         grep -v "group\|Makefile" >> $tmp.list 2>/dev/null
163         done
164 }
165
166 # takes the list of tests to run in $tmp.list, and removes the tests passed to
167 # the function from that list.
168 trim_test_list()
169 {
170         test_list="$*"
171
172         rm -f $tmp.grep
173         numsed=0
174         for t in $test_list
175         do
176             if [ $numsed -gt 100 ]; then
177                 grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
178                 mv $tmp.tmp $tmp.list
179                 numsed=0
180                 rm -f $tmp.grep
181             fi
182             echo "^$t\$" >>$tmp.grep
183             numsed=`expr $numsed + 1`
184         done
185         grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
186         mv $tmp.tmp $tmp.list
187         rm -f $tmp.grep
188 }
189
190
191 _wallclock()
192 {
193     date "+%s"
194 }
195
196 _timestamp()
197 {
198     now=`date "+%T"`
199     echo -n " [$now]"
200 }
201
202 _prepare_test_list()
203 {
204         unset list
205         # Tests specified on the command line
206         if [ -s $tmp.arglist ]; then
207                 cat $tmp.arglist > $tmp.list
208         else
209                 touch $tmp.list
210         fi
211
212         # Specified groups to include
213         # Note that the CLI processing adds a leading space to the first group
214         # parameter, so we have to catch that here checking for "all"
215         if ! $have_test_arg && [ "$GROUP_LIST" == " all" ]; then
216                 # no test numbers, do everything
217                 get_all_tests
218         else
219                 for group in $GROUP_LIST; do
220                         list=$(get_group_list $group)
221                         if [ -z "$list" ]; then
222                                 echo "Group \"$group\" is empty or not defined?"
223                                 exit 1
224                         fi
225
226                         for t in $list; do
227                                 grep -s "^$t\$" $tmp.list >/dev/null || \
228                                                         echo "$t" >>$tmp.list
229                         done
230                 done
231         fi
232
233         # Specified groups to exclude
234         for xgroup in $XGROUP_LIST; do
235                 list=$(get_group_list $xgroup)
236                 if [ -z "$list" ]; then
237                         echo "Group \"$xgroup\" is empty or not defined?"
238                         exit 1
239                 fi
240
241                 trim_test_list $list
242         done
243
244         # sort the list of tests into numeric order
245         if $randomize; then
246                 if type shuf >& /dev/null; then
247                         sorter="shuf"
248                 else
249                         sorter="awk -v seed=$RANDOM -f randomize.awk"
250                 fi
251         else
252                 sorter="cat"
253         fi
254         list=`sort -n $tmp.list | uniq | $sorter`
255         rm -f $tmp.list
256 }
257
258 # Process command arguments first.
259 while [ $# -gt 0 ]; do
260         case "$1" in
261         -\? | -h | --help) usage ;;
262
263         -nfs)           FSTYP=nfs ;;
264         -glusterfs)     FSTYP=glusterfs ;;
265         -cifs)          FSTYP=cifs ;;
266         -9p)            FSTYP=9p ;;
267         -overlay)       FSTYP=overlay; export OVERLAY=true ;;
268         -pvfs2)         FSTYP=pvfs2 ;;
269         -tmpfs)         FSTYP=tmpfs ;;
270         -ubifs)         FSTYP=ubifs ;;
271
272         -g)     group=$2 ; shift ;
273                 GROUP_LIST="$GROUP_LIST ${group//,/ }"
274                 ;;
275
276         -x)     xgroup=$2 ; shift ;
277                 XGROUP_LIST="$XGROUP_LIST ${xgroup//,/ }"
278                 ;;
279
280         -X)     subdir_xfile=$2; shift ;
281                 ;;
282         -E)     xfile=$2; shift ;
283                 if [ -f $xfile ]; then
284                         sed "s/#.*$//" "$xfile" >> $tmp.xlist
285                 fi
286                 ;;
287         -s)     RUN_SECTION="$RUN_SECTION $2"; shift ;;
288         -S)     EXCLUDE_SECTION="$EXCLUDE_SECTION $2"; shift ;;
289         -l)     diff="diff" ;;
290         -udiff) diff="$diff -u" ;;
291
292         -n)     showme=true ;;
293         -r)     randomize=true ;;
294
295         -T)     timestamp=true ;;
296         -d)     DUMP_OUTPUT=true ;;
297         -b)     brief_test_summary=true;;
298         -R)     report_fmt=$2 ; shift ;
299                 REPORT_LIST="$REPORT_LIST ${report_fmt//,/ }"
300                 do_report=true
301                 ;;
302         --large-fs) export LARGE_SCRATCH_DEV=yes ;;
303         --extra-space=*) export SCRATCH_DEV_EMPTY_SPACE=${r#*=} ;;
304
305         -*)     usage ;;
306         *)      # not an argument, we've got tests now.
307                 have_test_arg=true ;;
308         esac
309
310         # if we've found a test specification, the break out of the processing
311         # loop before we shift the arguments so that this is the first argument
312         # that we process in the test arg loop below.
313         if $have_test_arg; then
314                 break;
315         fi
316
317         shift
318 done
319
320 # we need common/rc, that also sources common/config. We need to source it
321 # after processing args, overlay needs FSTYP set before sourcing common/config
322 if ! . ./common/rc; then
323         echo "check: failed to source common/rc"
324         exit 1
325 fi
326
327 if [ -n "$subdir_xfile" ]; then
328         for d in $SRC_GROUPS $FSTYP; do
329                 [ -f $SRC_DIR/$d/$subdir_xfile ] || continue
330                 for f in `sed "s/#.*$//" $SRC_DIR/$d/$subdir_xfile`; do
331                         echo $d/$f >> $tmp.xlist
332                 done
333         done
334 fi
335
336 # Process tests from command line now.
337 if $have_test_arg; then
338         while [ $# -gt 0 ]; do
339                 case "$1" in
340                 -*)     echo "Arguments before tests, please!"
341                         status=1
342                         exit $status
343                         ;;
344                 *)      # Expand test pattern (e.g. xfs/???, *fs/001)
345                         list=$(cd $SRC_DIR; echo $1)
346                         for t in $list; do
347                                 test_dir=`dirname $t`
348                                 test_dir=${test_dir#$SRC_DIR/*}
349                                 test_name=`basename $t`
350                                 group_file=$SRC_DIR/$test_dir/group
351
352                                 if egrep -q "^$test_name" $group_file; then
353                                         # in group file ... OK
354                                         echo $SRC_DIR/$test_dir/$test_name \
355                                                 >>$tmp.arglist
356                                 else
357                                         # oops
358                                         echo "$t - unknown test, ignored"
359                                 fi
360                         done
361                         ;;
362                 esac
363
364                 shift
365         done
366 elif [ -z "$GROUP_LIST" ]; then
367         # default group list is the auto group. If any other group or test is
368         # specified, we use that instead.
369         GROUP_LIST="auto"
370 fi
371
372 if [ `id -u` -ne 0 ]
373 then
374     echo "check: QA must be run as root"
375     exit 1
376 fi
377
378 _wipe_counters()
379 {
380         n_try="0"
381         n_bad="0"
382         n_notrun="0"
383         unset try notrun bad
384 }
385
386 _wrapup()
387 {
388         seq="check"
389         check="$RESULT_BASE/check"
390
391         if $showme; then
392                 if $needwrap; then
393                         if $do_report; then
394                                 _make_section_report
395                         fi
396                         needwrap=false
397                 fi
398         elif $needwrap; then
399                 if [ -f $check.time -a -f $tmp.time ]; then
400                         cat $check.time $tmp.time  \
401                                 | $AWK_PROG '
402                                 { t[$1] = $2 }
403                                 END {
404                                         if (NR > 0) {
405                                                 for (i in t) print i " " t[i]
406                                         }
407                                 }' \
408                                 | sort -n >$tmp.out
409                         mv $tmp.out $check.time
410                 fi
411
412                 echo "" >>$check.log
413                 date >>$check.log
414
415                 echo "SECTION       -- $section" >>$tmp.summary
416                 echo "=========================" >>$tmp.summary
417                 if [ ! -z "$n_try" -a $n_try != 0 ]; then
418                         if [ $brief_test_summary == "false" ]; then
419                                 echo "Ran:$try"
420                                 echo "Ran:$try" >>$tmp.summary
421                         fi
422                         echo "Ran:$try" >>$check.log
423                 fi
424
425                 $interrupt && echo "Interrupted!" | tee -a $check.log
426
427                 if [ ! -z "$notrun" ]; then
428                         if [ $brief_test_summary == "false" ]; then
429                                 echo "Not run:$notrun"
430                                 echo "Not run:$notrun" >>$tmp.summary
431                         fi
432                         echo "Not run:$notrun" >>$check.log
433                 fi
434
435                 if [ ! -z "$n_bad" -a $n_bad != 0 ]; then
436                         echo "Failures:$bad"
437                         echo "Failed $n_bad of $n_try tests"
438                         echo "Failures:$bad" >>$check.log
439                         echo "Failed $n_bad of $n_try tests" >>$check.log
440                         echo "Failures:$bad" >>$tmp.summary
441                         echo "Failed $n_bad of $n_try tests" >>$tmp.summary
442                 else
443                         echo "Passed all $n_try tests"
444                         echo "Passed all $n_try tests" >>$check.log
445                         echo "Passed all $n_try tests" >>$tmp.summary
446                 fi
447                 echo "" >>$tmp.summary
448                 if $do_report; then
449                         _make_section_report
450                 fi
451                 needwrap=false
452         fi
453
454         sum_bad=`expr $sum_bad + $n_bad`
455         _wipe_counters
456         rm -f /tmp/*.rawout /tmp/*.out /tmp/*.err /tmp/*.time
457         if ! $OPTIONS_HAVE_SECTIONS; then
458                 rm -f $tmp.*
459         fi
460 }
461
462 _summary()
463 {
464         _wrapup
465         if $showme; then
466                 :
467         elif $needsum; then
468                 count=`wc -L $tmp.summary | cut -f1 -d" "`
469                 cat $tmp.summary
470                 needsum=false
471         fi
472         rm -f $tmp.*
473 }
474
475 _check_filesystems()
476 {
477         if [ -f ${RESULT_DIR}/require_test ]; then
478                 _check_test_fs || err=true
479                 rm -f ${RESULT_DIR}/require_test*
480         else
481                 _test_unmount 2> /dev/null
482         fi
483         if [ -f ${RESULT_DIR}/require_scratch ]; then
484                 _check_scratch_fs || err=true
485                 rm -f ${RESULT_DIR}/require_scratch*
486         fi
487         _scratch_unmount 2> /dev/null
488 }
489
490 _expunge_test()
491 {
492         local TEST_ID="$1"
493         if [ -s $tmp.xlist ]; then
494                 if grep -q $TEST_ID $tmp.xlist; then
495                         echo "       [expunged]"
496                         return 1
497                 fi
498         fi
499         return 0
500 }
501
502 _detect_kmemleak
503 _prepare_test_list
504
505 if $OPTIONS_HAVE_SECTIONS; then
506         trap "_summary; exit \$status" 0 1 2 3 15
507 else
508         trap "_wrapup; exit \$status" 0 1 2 3 15
509 fi
510
511 for section in $HOST_OPTIONS_SECTIONS; do
512         OLD_FSTYP=$FSTYP
513         OLD_TEST_FS_MOUNT_OPTS=$TEST_FS_MOUNT_OPTS
514         get_next_config $section
515
516         # Do we need to run only some sections ?
517         if [ ! -z "$RUN_SECTION" ]; then
518                 skip=true
519                 for s in $RUN_SECTION; do
520                         if [ $section == $s ]; then
521                                 skip=false
522                                 break;
523                         fi
524                 done
525                 if $skip; then
526                         continue
527                 fi
528         fi
529
530         # Did this section get excluded?
531         if [ ! -z "$EXCLUDE_SECTION" ]; then
532                 skip=false
533                 for s in $EXCLUDE_SECTION; do
534                         if [ $section == $s ]; then
535                                 skip=true
536                                 break;
537                         fi
538                 done
539                 if $skip; then
540                         continue
541                 fi
542         fi
543
544         mkdir -p $RESULT_BASE
545         if [ ! -d $RESULT_BASE ]; then
546                 echo "failed to create results directory $RESULT_BASE"
547                 status=1
548                 exit
549         fi
550
551         if $OPTIONS_HAVE_SECTIONS; then
552                 echo "SECTION       -- $section"
553         fi
554
555         sect_start=`_wallclock`
556         if $RECREATE_TEST_DEV || [ "$OLD_FSTYP" != "$FSTYP" ]; then
557                 echo "RECREATING    -- $FSTYP on $TEST_DEV"
558                 _test_unmount 2> /dev/null
559                 if ! _test_mkfs >$tmp.err 2>&1
560                 then
561                         echo "our local _test_mkfs routine ..."
562                         cat $tmp.err
563                         echo "check: failed to mkfs \$TEST_DEV using specified options"
564                         status=1
565                         exit
566                 fi
567                 if ! _test_mount
568                 then
569                         echo "check: failed to mount $TEST_DEV on $TEST_DIR"
570                         status=1
571                         exit
572                 fi
573                 _prepare_test_list
574         elif [ "$OLD_TEST_FS_MOUNT_OPTS" != "$TEST_FS_MOUNT_OPTS" ]; then
575                 _test_unmount 2> /dev/null
576                 if ! _test_mount
577                 then
578                         echo "check: failed to mount $TEST_DEV on $TEST_DIR"
579                         status=1
580                         exit
581                 fi
582         fi
583
584         init_rc
585
586         seq="check"
587         check="$RESULT_BASE/check"
588
589         # don't leave old full output behind on a clean run
590         rm -f $check.full
591
592         [ -f $check.time ] || touch $check.time
593
594         # print out our test configuration
595         echo "FSTYP         -- `_full_fstyp_details`"
596         echo "PLATFORM      -- `_full_platform_details`"
597         if [ ! -z "$SCRATCH_DEV" ]; then
598           echo "MKFS_OPTIONS  -- `_scratch_mkfs_options`"
599           echo "MOUNT_OPTIONS -- `_scratch_mount_options`"
600         fi
601         echo
602         needwrap=true
603
604         if [ ! -z "$SCRATCH_DEV" ]; then
605           _scratch_unmount 2> /dev/null
606           # call the overridden mkfs - make sure the FS is built
607           # the same as we'll create it later.
608
609           if ! _scratch_mkfs >$tmp.err 2>&1
610           then
611               echo "our local _scratch_mkfs routine ..."
612               cat $tmp.err
613               echo "check: failed to mkfs \$SCRATCH_DEV using specified options"
614               status=1
615               exit
616           fi
617
618           # call the overridden mount - make sure the FS mounts with
619           # the same options that we'll mount with later.
620           if ! _try_scratch_mount >$tmp.err 2>&1
621           then
622               echo "our local mount routine ..."
623               cat $tmp.err
624               echo "check: failed to mount \$SCRATCH_DEV using specified options"
625               status=1
626               exit
627           else
628               _scratch_unmount
629           fi
630         fi
631
632         seqres="$check"
633         _check_test_fs
634
635         err=false
636         first_test=true
637         prev_seq=""
638         for seq in $list ; do
639                 # Run report for previous test!
640                 if $err ; then
641                         bad="$bad $seqnum"
642                         n_bad=`expr $n_bad + 1`
643                         tc_status="fail"
644                 fi
645                 if $do_report && ! $first_test ; then
646                         if [ $tc_status != "expunge" ] ; then
647                                 _make_testcase_report "$prev_seq" "$tc_status"
648                         fi
649                 fi
650                 first_test=false
651
652                 err=false
653                 prev_seq="$seq"
654                 if [ ! -f $seq ]; then
655                         # Try to get full name in case the user supplied only
656                         # seq id and the test has a name. A bit of hassle to
657                         # find really the test and not its sample output or
658                         # helping files.
659                         bname=$(basename $seq)
660                         full_seq=$(find $(dirname $seq) -name $bname* -executable |
661                                 awk '(NR == 1 || length < length(shortest)) { shortest = $0 }\
662                                      END { print shortest }')
663                         if [ -f $full_seq ] && \
664                            [ x$(echo $bname | grep -o "^$VALID_TEST_ID") != x ]; then
665                                 seq=$full_seq
666                         fi
667                 fi
668
669                 # the filename for the test and the name output are different.
670                 # we don't include the tests/ directory in the name output.
671                 export seqnum=`echo $seq | sed -e "s;$SRC_DIR/;;"`
672
673                 # Similarly, the result directory needs to replace the tests/
674                 # part of the test location.
675                 group=`dirname $seq`
676                 if $OPTIONS_HAVE_SECTIONS; then
677                         export RESULT_DIR=`echo $group | sed -e "s;$SRC_DIR;${RESULT_BASE}/$section;"`
678                         REPORT_DIR="$RESULT_BASE/$section"
679                 else
680                         export RESULT_DIR=`echo $group | sed -e "s;$SRC_DIR;$RESULT_BASE;"`
681                         REPORT_DIR="$RESULT_BASE"
682                 fi
683                 seqres="$REPORT_DIR/$seqnum"
684
685                 mkdir -p $RESULT_DIR
686                 echo -n "$seqnum"
687
688                 if $showme; then
689                         _expunge_test $seqnum
690                         if [ $? -eq 1 ]; then
691                             tc_status="expunge"
692                             continue
693                         fi
694                         echo
695                         start=0
696                         stop=0
697                         tc_status="list"
698                         n_notrun=`expr $n_notrun + 1`
699                         continue
700                 fi
701
702                 tc_status="pass"
703                 if [ ! -f $seq ]; then
704                         echo " - no such test?"
705                         continue
706                 fi
707
708                 # really going to try and run this one
709                 rm -f $seqres.out.bad
710
711                 # check if we really should run it
712                 _expunge_test $seqnum
713                 if [ $? -eq 1 ]; then
714                         tc_status="expunge"
715                         continue
716                 fi
717
718                 # record that we really tried to run this test.
719                 try="$try $seqnum"
720                 n_try=`expr $n_try + 1`
721
722                 # slashes now in names, sed barfs on them so use grep
723                 lasttime=`grep -w ^$seqnum $check.time | awk '// {print $2}'`
724                 if [ "X$lasttime" != X ]; then
725                         echo -n " ${lasttime}s ... "
726                 else
727                         echo -n "       " # prettier output with timestamps.
728                 fi
729                 rm -f core $seqres.notrun
730
731                 start=`_wallclock`
732                 $timestamp && echo -n " ["`date "+%T"`"]"
733                 [ ! -x $seq ] && chmod u+x $seq # ensure we can run it
734                 $LOGGER_PROG "run xfstest $seqnum"
735                 if [ -w /dev/kmsg ]; then
736                         export date_time=`date +"%F %T"`
737                         echo "run fstests $seqnum at $date_time" > /dev/kmsg
738                         # _check_dmesg depends on this log in dmesg
739                         touch ${RESULT_DIR}/check_dmesg
740                 fi
741                 _try_wipe_scratch_devs > /dev/null 2>&1
742                 if [ "$DUMP_OUTPUT" = true ]; then
743                         ./$seq 2>&1 | tee $tmp.out
744                         # Because $? would get tee's return code
745                         sts=${PIPESTATUS[0]}
746                 else
747                         ./$seq >$tmp.out 2>&1
748                         sts=$?
749                 fi
750
751                 if [ -f core ]; then
752                         _dump_err_cont "[dumped core]"
753                         mv core $RESULT_BASE/$seqnum.core
754                         err=true
755                 fi
756
757                 if [ -f $seqres.notrun ]; then
758                         $timestamp && _timestamp
759                         stop=`_wallclock`
760                         $timestamp || echo -n "[not run] "
761                         $timestamp && echo " [not run]" && \
762                                       echo -n " $seqnum -- "
763                         cat $seqres.notrun
764                         notrun="$notrun $seqnum"
765                         n_notrun=`expr $n_notrun + 1`
766                         tc_status="notrun"
767                         continue;
768                 fi
769
770                 if [ $sts -ne 0 ]; then
771                         _dump_err_cont "[failed, exit status $sts]"
772                         _test_unmount 2> /dev/null
773                         _scratch_unmount 2> /dev/null
774                         rm -f ${RESULT_DIR}/require_test*
775                         rm -f ${RESULT_DIR}/require_scratch*
776                         err=true
777                 else
778                         # the test apparently passed, so check for corruption
779                         # and log messages that shouldn't be there.
780                         _check_filesystems
781                         _check_dmesg || err=true
782                 fi
783
784                 # Scan for memory leaks after every test so that associating
785                 # a leak to a particular test will be as accurate as possible.
786                 _check_kmemleak || err=true
787
788                 # test ends after all checks are done.
789                 $timestamp && _timestamp
790                 stop=`_wallclock`
791
792                 if [ ! -f $seq.out ]; then
793                         _dump_err "no qualified output"
794                         err=true
795                         continue;
796                 fi
797
798                 # coreutils 8.16+ changed quote formats in error messages
799                 # from `foo' to 'foo'. Filter old versions to match the new
800                 # version.
801                 sed -i "s/\`/\'/g" $tmp.out
802                 if diff $seq.out $tmp.out >/dev/null 2>&1 ; then
803                         if ! $err ; then
804                                 echo "$seqnum `expr $stop - $start`" >>$tmp.time
805                                 echo -n " `expr $stop - $start`s"
806                         fi
807                         echo ""
808                 else
809                         _dump_err "- output mismatch (see $seqres.out.bad)"
810                         mv $tmp.out $seqres.out.bad
811                         $diff $seq.out $seqres.out.bad | {
812                         if test "$DIFF_LENGTH" -le 0; then
813                                 cat
814                         else
815                                 head -n "$DIFF_LENGTH"
816                                 echo "..."
817                                 echo "(Run '$diff $here/$seq.out $seqres.out.bad'" \
818                                         " to see the entire diff)"
819                         fi; } | sed -e 's/^\(.\)/    \1/'
820                         err=true
821                 fi
822         done
823
824         # make sure we record the status of the last test we ran.
825         if $err ; then
826                 bad="$bad $seqnum"
827                 n_bad=`expr $n_bad + 1`
828                 tc_status="fail"
829         fi
830         if $do_report && ! $first_test ; then
831                 if [ $tc_status != "expunge" ] ; then
832                         _make_testcase_report "$prev_seq" "$tc_status"
833                 fi
834         fi
835
836         sect_stop=`_wallclock`
837         interrupt=false
838         _wrapup
839         interrupt=true
840         echo
841
842         _test_unmount 2> /dev/null
843         _scratch_unmount 2> /dev/null
844 done
845
846 interrupt=false
847 status=`expr $sum_bad != 0`
848 exit