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