b3937b35310c7ac928b2f32795f23ff7dc1bb9b6
[xfstests-dev.git] / 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 notrun=""
32 interrupt=true
33 diff="diff -u"
34 showme=false
35 have_test_arg=false
36 randomize=false
37 export here=`pwd`
38 xfile=""
39
40 # start the initialisation work now
41 iam=check
42
43 export MSGVERB="text:action"
44 export QA_CHECK_FS=${QA_CHECK_FS:=true}
45
46 # number of diff lines from a failed test, 0 for whole output
47 export DIFF_LENGTH=${DIFF_LENGTH:=10}
48
49 # by default don't output timestamps
50 timestamp=${TIMESTAMP:=false}
51
52 rm -f $tmp.list $tmp.tmp $tmp.grep $here/$iam.out $tmp.xlist
53
54 # we need common/config
55 if ! . ./common/config
56 then
57     echo "$iam: failed to source common/config"
58     exit 1
59 fi
60
61 # Autodetect fs type based on what's on $TEST_DEV unless it's been set
62 # externally
63 if [ -z "$FSTYP" -a "$HOSTOS" == "Linux" ]; then
64     FSTYP=`blkid -c /dev/null -s TYPE -o value $TEST_DEV`
65 fi
66 FSTYP=${FSTYP:=xfs}
67 export FSTYP
68
69 SUPPORTED_TESTS="[0-9][0-9][0-9] [0-9][0-9][0-9][0-9]"
70 SRC_GROUPS="generic shared"
71 export SRC_DIR="tests"
72
73 usage()
74 {
75     echo "Usage: $0 [options] [testlist]"'
76
77 check options
78     -nfs                test NFS
79     -tmpfs              test TMPFS
80     -l                  line mode diff
81     -udiff              show unified diff (default)
82     -n                  show me, do not run tests
83     -T                  output timestamps
84     -r                  randomize test order
85     --large-fs          optimise scratch device for large filesystems
86
87 testlist options
88     -g group[,group...] include tests from these groups
89     -x group[,group...] exclude tests from these groups
90     -X file             exclude individual tests
91     [testlist]          include tests matching names in testlist
92 '
93             exit 0
94 }
95
96 get_group_list()
97 {
98         grp=$1
99
100         for d in $SRC_GROUPS $FSTYP; do
101                 l=$(sed -n < $SRC_DIR/$d/group \
102                         -e 's/#.*//' \
103                         -e 's/$/ /' \
104                         -e "s;\(^[0-9][0-9][0-9]\).* $grp .*;$SRC_DIR/$d/\1;p")
105                 grpl="$grpl $l"
106         done
107         echo $grpl
108 }
109
110 # find all tests, excluding files that are test metadata such as group files.
111 # This assumes that tests are defined purely by alphanumeric filenames with no
112 # ".xyz" extensions in the name.
113 get_all_tests()
114 {
115         touch $tmp.list
116         for d in $SRC_GROUPS $FSTYP; do
117                 ls $SRC_DIR/$d/* | \
118                         grep -v "\..*" | \
119                         grep -v "group\|Makefile" >> $tmp.list 2>/dev/null
120         done
121 }
122
123 # takes the list of tests to run in $tmp.list, and removes the tests passed to
124 # the function from that list.
125 trim_test_list()
126 {
127         test_list="$*"
128
129         rm -f $tmp.grep
130         numsed=0
131         for t in $test_list
132         do
133             if [ $numsed -gt 100 ]; then
134                 grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
135                 mv $tmp.tmp $tmp.list
136                 numsed=0
137                 rm -f $tmp.grep
138             fi
139             echo "^$t\$" >>$tmp.grep
140             numsed=`expr $numsed + 1`
141         done
142         grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
143         mv $tmp.tmp $tmp.list
144 }
145
146
147 _wallclock()
148 {
149     date "+%H %M %S" | $AWK_PROG '{ print $1*3600 + $2*60 + $3 }'
150 }
151
152 _timestamp()
153 {
154     now=`date "+%T"`
155     echo -n " [$now]"
156 }
157
158 _prepare_test_list()
159 {
160         unset list
161         # Tests specified on the command line
162         if [ -s $tmp.arglist ]; then
163                 cat $tmp.arglist > $tmp.list
164         else
165                 touch $tmp.list
166         fi
167
168         # Specified groups to include
169         for group in $GROUP_LIST; do
170                 list=$(get_group_list $group)
171                 if [ -z "$list" ]; then
172                         echo "Group \"$group\" is empty or not defined?"
173                         exit 1
174                 fi
175
176                 for t in $list; do
177                         grep -s "^$t\$" $tmp.list >/dev/null || \
178                                                         echo "$t" >>$tmp.list
179                 done
180         done
181
182         if ! $have_test_arg && [ -z "$GROUP_LIST" ]; then
183                 # no test numbers, do everything
184                 get_all_tests
185         fi
186
187         # Specified groups to exclude
188         for xgroup in $XGROUP_LIST; do
189                 list=$(get_group_list $xgroup)
190                 if [ -z "$list" ]; then
191                         echo "Group \"$xgroup\" is empty or not defined?"
192                         exit 1
193                 fi
194
195                 trim_test_list $list
196         done
197
198         # sort the list of tests into numeric order
199         list=`sort -n $tmp.list | uniq`
200         rm -f $tmp.list $tmp.tmp $tmp.grep
201
202         if $randomize
203         then
204                 list=`echo $list | awk -f randomize.awk`
205         fi
206 }
207
208 # Process command arguments first.
209 while [ $# -gt 0 ]; do
210         case "$1" in
211         -\? | -h | --help) usage ;;
212
213         -nfs)   FSTYP=nfs ;;
214         -tmpfs) FSTYP=tmpfs ;;
215
216         -g)     group=$2 ; shift ;
217                 GROUP_LIST="$GROUP_LIST $group"
218                 ;;
219
220         -x)     xgroup=$2 ; shift ;
221                 XGROUP_LIST="$XGROUP_LIST $xgroup"
222                 ;;
223
224         -X)     xfile=$2; shift ;
225                 for d in $SRC_GROUPS $FSTYP; do
226                         [ -f $SRC_DIR/$d/$xfile ] || continue
227                         for f in `cat $SRC_DIR/$d/$xfile`; do
228                                 echo $d/$f >> $tmp.xlist
229                         done
230                 done
231                 ;;
232
233         -l)     diff="diff" ;;
234         -udiff) diff="$diff -u" ;;
235
236         -n)     showme=true ;;
237         -r)     randomize=true ;;
238
239         -T)     timestamp=true ;;
240
241         --large-fs) export LARGE_SCRATCH_DEV=yes ;;
242         --extra-space=*) export SCRATCH_DEV_EMPTY_SPACE=${r#*=} ;;
243
244         -*)     usage ;;
245         *)      # not an argument, we've got tests now.
246                 have_test_arg=true ;;
247         esac
248
249         # if we've found a test specification, the break out of the processing
250         # loop before we shift the arguments so that this is the first argument
251         # that we process in the test arg loop below.
252         if $have_test_arg; then
253                 break;
254         fi
255
256         shift
257 done
258
259 # Process tests from command line now.
260 if $have_test_arg; then
261         while [ $# -gt 0 ]; do
262                 case "$1" in
263                 -*)     echo "Argments before tests, please!"
264                         status=1
265                         exit $status
266                         ;;
267                 *)      test_dir=`dirname $1`
268                         test_dir=${test_dir#$SRC_DIR/*}
269                         test_name=`basename $1`
270                         group_file=$SRC_DIR/$test_dir/group
271
272                         if egrep "^$test_name" $group_file >/dev/null ; then
273                                 # in group file ... OK
274                                 echo $SRC_DIR/$test_dir/$test_name >>$tmp.arglist
275                         else
276                                 # oops
277                                 echo "$1 - unknown test, ignored"
278                         fi
279                         ;;
280                 esac
281
282                 shift
283         done
284 fi
285
286 # we need common/rc
287 if ! . ./common/rc
288 then
289     echo "check: failed to source common/rc"
290     exit 1
291 fi
292
293 if [ `id -u` -ne 0 ]
294 then
295     echo "check: QA must be run as root"
296     exit 1
297 fi
298
299 _wipe_counters()
300 {
301         n_try="0"
302         n_bad="0"
303         unset try notrun bad
304 }
305
306 _wrapup()
307 {
308     seq="check"
309     check="$RESULT_BASE/check"
310
311     if $showme
312     then
313         :
314     elif $needwrap
315     then
316         if [ -f $check.time -a -f $tmp.time ]
317         then
318             cat $check.time $tmp.time \
319             | $AWK_PROG '
320         { t[$1] = $2 }
321 END     { if (NR > 0) {
322             for (i in t) print i " " t[i]
323           }
324         }' \
325             | sort -n >$tmp.out
326             mv $tmp.out $check.time
327         fi
328
329         echo "" >>$check.log
330         date >>$check.log
331         echo $list | fmt | sed -e 's/^/    /' -e "s;$SRC_DIR/;;g" >>$check.log
332         $interrupt && echo "Interrupted!" >>$check.log
333
334         echo "SECTION       -- $section" >>$tmp.summary
335         echo "=========================" >>$tmp.summary
336         if [ ! -z "$n_try" -a $n_try != 0 ]
337         then
338             echo "Ran:$try"
339             echo "Ran:$try" >>$tmp.summary
340         fi
341
342         if [ ! -z "$notrun" ]
343         then
344             echo "Not run:$notrun"
345             echo "Not run:$notrun" >>$check.log
346             echo "Not run:$notrun" >>$tmp.summary
347         fi
348
349         if [ ! -z "$n_bad" -a $n_bad != 0 ]
350         then
351             echo "Failures:$bad"
352             echo "Failed $n_bad of $n_try tests"
353             echo "Failures:$bad" | fmt >>$check.log
354             echo "Failed $n_bad of $n_try tests" >>$check.log
355             echo "Failures:$bad" >>$tmp.summary
356             echo "Failed $n_bad of $n_try tests" >>$tmp.summary
357         else
358             echo "Passed all $n_try tests"
359             echo "Passed all $n_try tests" >>$check.log
360             echo "Passed all $n_try tests" >>$tmp.summary
361         fi
362         echo "" >>$tmp.summary
363         needwrap=false
364     fi
365
366     sum_bad=`expr $sum_bad + $n_bad`
367     _wipe_counters
368     rm -f /tmp/*.rawout /tmp/*.out /tmp/*.err /tmp/*.time
369     if ! $OPTIONS_HAVE_SECTIONS; then
370         rm -f $tmp.*
371     fi
372 }
373
374 _summary()
375 {
376         _wrapup
377         if $showme; then
378                 :
379         elif $needsum; then
380                 count=`wc -L $tmp.summary | cut -f1 -d" "`
381                 cat $tmp.summary
382                 needsum=false
383         fi
384         rm -f $tmp.*
385 }
386
387 _prepare_test_list
388
389 if $OPTIONS_HAVE_SECTIONS; then
390         trap "_summary; exit \$status" 0 1 2 3 15
391 else
392         trap "_wrapup; exit \$status" 0 1 2 3 15
393 fi
394
395 for section in $HOST_OPTIONS_SECTIONS; do
396         OLD_FSTYP=$FSTYP
397         OLD_MOUNT_OPTIONS=$MOUNT_OPTIONS
398         get_next_config $section
399
400         mkdir -p $RESULT_BASE
401         if [ ! -d $RESULT_BASE ]; then
402                 echo "failed to create results directory $RESULTS_BASE"
403                 exit 1;
404         fi
405
406         if $OPTIONS_HAVE_SECTIONS; then
407                 echo "SECTION       -- $section"
408         fi
409
410         if $RECREATE_TEST_DEV || [ "$OLD_FSTYP" != "$FSTYP" ]; then
411                 echo "RECREATING    -- $FSTYP on $TEST_DEV"
412                 umount $TEST_DEV 2> /dev/null
413                 if ! _test_mkfs >$tmp.err 2>&1
414                 then
415                         echo "our local _test_mkfs routine ..."
416                         cat $tmp.err
417                         echo "check: failed to mkfs \$TEST_DEV using specified options"
418                         exit 1
419                 fi
420                 out=`_mount_or_remount_rw "$MOUNT_OPTIONS" $TEST_DEV $TEST_DIR`
421                 if [ $? -ne 1 ]; then
422                         echo $out
423                         exit 1
424                 fi
425                 _prepare_test_list
426         elif [ "$OLD_MOUNT_OPTIONS" != "$MOUNT_OPTIONS" ]; then
427                 umount $TEST_DEV 2> /dev/null
428                 out=`_mount_or_remount_rw "$MOUNT_OPTIONS" $TEST_DEV $TEST_DIR`
429                 if [ $? -ne 1 ]; then
430                         echo $out
431                         exit 1
432                 fi
433         fi
434
435         init_rc
436
437         seq="check"
438         check="$RESULT_BASE/check"
439
440         # don't leave old full output behind on a clean run
441         rm -f $check.full
442
443         [ -f $check.time ] || touch $check.time
444
445         # print out our test configuration
446         echo "FSTYP         -- `_full_fstyp_details`"
447         echo "PLATFORM      -- `_full_platform_details`"
448         if [ ! -z "$SCRATCH_DEV" ]; then
449           echo "MKFS_OPTIONS  -- `_scratch_mkfs_options`"
450           echo "MOUNT_OPTIONS -- `_scratch_mount_options`"
451         fi
452         echo
453         needwrap=true
454
455         if [ ! -z "$SCRATCH_DEV" ]; then
456           umount $SCRATCH_DEV 2>/dev/null
457           # call the overridden mkfs - make sure the FS is built
458           # the same as we'll create it later.
459
460           if ! _scratch_mkfs $flag >$tmp.err 2>&1
461           then
462               echo "our local _scratch_mkfs routine ..."
463               cat $tmp.err
464               echo "check: failed to mkfs \$SCRATCH_DEV using specified options"
465               exit 1
466           fi
467
468           # call the overridden mount - make sure the FS mounts with
469           # the same options that we'll mount with later.
470           if ! _scratch_mount >$tmp.err 2>&1
471           then
472               echo "our local mount routine ..."
473               cat $tmp.err
474               echo "check: failed to mount \$SCRATCH_DEV using specified options"
475               exit 1
476           fi
477         fi
478
479         seqres="$check"
480         _check_test_fs
481
482         for seq in $list
483         do
484             err=false
485
486             # the filename for the test and the name output are different.
487             # we don't include the tests/ directory in the name output.
488             seqnum=`echo $seq | sed -e "s;$SRC_DIR/;;"`
489
490             # Similarly, the result directory needs to replace the tests/
491             # part of the test location.
492             group=`dirname $seq`
493             if $OPTIONS_HAVE_SECTIONS; then
494                 export RESULT_DIR=`echo $group | sed -e "s;$SRC_DIR;${RESULT_BASE}/$section;"`
495                 seqres="$RESULT_BASE/$section/$seqnum"
496             else
497                 export RESULT_DIR=`echo $group | sed -e "s;$SRC_DIR;$RESULT_BASE;"`
498                 seqres="$RESULT_BASE/$seqnum"
499             fi
500
501             mkdir -p $RESULT_DIR
502
503             echo -n "$seqnum"
504
505             if $showme
506             then
507                 echo
508                 continue
509             elif [ ! -f $seq ]
510             then
511                 echo " - no such test?"
512             else
513                 # really going to try and run this one
514                 #
515                 rm -f $seqres.out.bad
516
517                 # check if we really should run it
518                 if [ -s $tmp.xlist ]; then
519                         if grep $seqnum $tmp.xlist > /dev/null 2>&1 ; then
520                                 echo "       [expunged]"
521                                 continue
522                         fi
523                 fi
524
525                 # slashes now in names, sed barfs on them so use grep
526                 lasttime=`grep -w ^$seqnum $check.time | awk '// {print $2}'`
527                 if [ "X$lasttime" != X ]; then
528                         echo -n " ${lasttime}s ..."
529                 else
530                         echo -n "       "       # prettier output with timestamps.
531                 fi
532                 rm -f core $seqres.notrun
533
534                 start=`_wallclock`
535                 $timestamp && echo -n " ["`date "+%T"`"]"
536                 [ ! -x $seq ] && chmod u+x $seq # ensure we can run it
537                 $LOGGER_PROG "run xfstest $seqnum"
538                 ./$seq >$tmp.rawout 2>&1
539                 sts=$?
540                 $timestamp && _timestamp
541                 stop=`_wallclock`
542
543                 _fix_malloc <$tmp.rawout >$tmp.out
544                 rm -f $tmp.rawout
545
546                 if [ -f core ]
547                 then
548                     echo -n " [dumped core]"
549                     mv core $RESULT_BASE/$seqnum.core
550                     err=true
551                 fi
552
553                 if [ -f $seqres.notrun ]
554                 then
555                     $timestamp || echo -n " [not run] "
556                     $timestamp && echo " [not run]" && echo -n "        $seqnum -- "
557                     cat $seqres.notrun
558                     notrun="$notrun $seqnum"
559                 else
560                     if [ $sts -ne 0 ]
561                     then
562                         echo -n " [failed, exit status $sts]"
563                         err=true
564                     fi
565                     if [ ! -f $seq.out ]
566                     then
567                         echo " - no qualified output"
568                         err=true
569                     else
570
571                         # coreutils 8.16+ changed quote formats in error messages from
572                         # `foo' to 'foo'. Filter old versions to match the new version.
573                         sed -i "s/\`/\'/g" $tmp.out
574                         if diff $seq.out $tmp.out >/dev/null 2>&1
575                         then
576                             if $err
577                             then
578                                 :
579                             else
580                                 echo "$seqnum `expr $stop - $start`" >>$tmp.time
581                                 echo -n " `expr $stop - $start`s"
582                             fi
583                             echo ""
584                         else
585                             echo " - output mismatch (see $seqres.out.bad)"
586                             mv $tmp.out $seqres.out.bad
587                             $diff $seq.out $seqres.out.bad | {
588                                 if test "$DIFF_LENGTH" -le 0; then
589                                         cat
590                                 else
591                                         head -n "$DIFF_LENGTH"
592                                         echo "..."
593                                         echo "(Run '$diff $seq.out $seqres.out.bad'" \
594                                                 " to see the entire diff)"
595                                 fi; } | \
596                                 sed -e 's/^\(.\)/    \1/'
597                             err=true
598                         fi
599                     fi
600                 fi
601
602             fi
603
604             # come here for each test, except when $showme is true
605             #
606             if $err
607             then
608                 bad="$bad $seqnum"
609                 n_bad=`expr $n_bad + 1`
610                 quick=false
611             fi
612             if [ ! -f $seqres.notrun ]
613             then
614                 try="$try $seqnum"
615                 n_try=`expr $n_try + 1`
616                 _check_test_fs
617             fi
618
619             seq="after_$seqnum"
620         done
621         _wrapup
622         echo
623 done
624
625 interrupt=false
626 status=`expr $sum_bad`
627 exit