check

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