ef41cbf68cd6b0987943a5da276a6409157fc81a
[xfstests-dev.git] / common.rc
1 ##/bin/bash
2 #-----------------------------------------------------------------------
3 #  Copyright (c) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.
4 #  This program is free software; you can redistribute it and/or modify
5 #  it under the terms of the GNU General Public License as published by
6 #  the Free Software Foundation; either version 2 of the License, or
7 #  (at your option) any later version.
8 #
9 #  This program is distributed in the hope that it will be useful,
10 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
11 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 #  GNU General Public License for more details.
13 #
14 #  You should have received a copy of the GNU General Public License
15 #  along with this program; if not, write to the Free Software
16 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
17 #  USA
18 #
19 #  Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
20 #  Mountain View, CA 94043, USA, or: http://www.sgi.com
21 #-----------------------------------------------------------------------
22
23 BC=$(which bc 2> /dev/null) || BC=
24
25 _require_math()
26 {
27         if [ -z "$BC" ]; then
28                 _notrun "this test requires 'bc' tool for doing math operations"
29         fi
30 }
31
32 _math()
33 {
34         [ $# -le 0 ] && return
35         if [ "$BC" ]; then
36                 result=$(LANG=C echo "scale=0; $@" | "$BC" -q 2> /dev/null)
37         else
38                 _notrun "this test requires 'bc' tool for doing math operations"
39         fi
40         echo "$result"
41 }
42
43 dd()
44 {
45    if [ "$HOSTOS" == "Linux" ]
46    then 
47         command dd --help | grep noxfer > /dev/null 2>&1
48         
49         if [ "$?" -eq 0 ]
50             then
51                 command dd status=noxfer $@
52             else
53                 command dd $@
54         fi
55    else
56         command dd $@
57    fi
58 }
59
60 # ls -l w/ selinux sometimes puts a dot at the end:
61 # -rwxrw-r--. id1 id2 file1
62
63 _ls_l()
64 {
65         ls -l $* | sed "s/\(^[-rwxdlbcpsStT]*\)\. /\1 /"
66 }
67
68 _mount_opts()
69 {
70     # SELinux adds extra xattrs which can mess up our expected output.
71     # So, mount with a context, and they won't be created
72     # nfs_t is a "liberal" context so we can use it.
73     if [ -x /usr/sbin/selinuxenabled ] && /usr/sbin/selinuxenabled; then
74         SELINUX_MOUNT_OPTIONS="-o context=system_u:object_r:nfs_t:s0"
75         export SELINUX_MOUNT_OPTIONS
76     fi
77
78     case $FSTYP in
79     xfs)
80         export MOUNT_OPTIONS=$XFS_MOUNT_OPTIONS
81         ;;
82     udf)
83         export MOUNT_OPTIONS=$UDF_MOUNT_OPTIONS
84         ;;
85     nfs)
86         export MOUNT_OPTIONS=$NFS_MOUNT_OPTIONS
87         ;;
88     ext2|ext3|ext4|ext4dev)
89         # acls & xattrs aren't turned on by default on ext$FOO
90         export MOUNT_OPTIONS="-o acl,user_xattr $EXT_MOUNT_OPTIONS"
91         ;;
92     reiserfs)
93         # acls & xattrs aren't turned on by default on reiserfs
94         export MOUNT_OPTIONS="-o acl,user_xattr $REISERFS_MOUNT_OPTIONS"
95         ;;
96     gfs2)
97         # acls aren't turned on by default on gfs2
98         export MOUNT_OPTIONS="-o acl $GFS2_MOUNT_OPTIONS"
99         ;;
100     *)
101         ;;
102     esac
103 }
104
105 _mkfs_opts()
106 {
107     case $FSTYP in
108     xfs)
109         export MKFS_OPTIONS=$XFS_MKFS_OPTIONS
110         ;;
111     udf)
112         [ ! -z "$udf_fsize" ] && \
113             UDF_MKFS_OPTIONS="$UDF_MKFS_OPTIONS -s $udf_fsize"
114         export MKFS_OPTIONS=$UDF_MKFS_OPTIONS
115         ;;
116     nfs)
117         export MKFS_OPTIONS=$NFS_MKFS_OPTIONS
118         ;;
119     reiserfs)
120         export MKFS_OPTIONS="$REISERFS_MKFS_OPTIONS -q"
121         ;;
122     gfs2)
123         export MKFS_OPTIONS="$GFS2_MKFS_OPTIONS -O -p lock_nolock"
124         ;;
125     jfs)
126         export MKFS_OPTIONS="$JFS_MKFS_OPTIONS -q"
127         ;;
128     *)
129         ;;
130     esac
131 }
132
133 _fsck_opts()
134 {
135     case $FSTYP in
136     ext2|ext3|ext4|ext4dev)
137         export FSCK_OPTIONS="-nf"
138         ;;
139     reiserfs)
140         export FSCK_OPTIONS="--yes"
141         ;;
142     *)
143         export FSCK_OPTIONS="-n"
144         ;;
145     esac
146 }
147
148 [ -z "$FSTYP" ] && FSTYP=xfs
149 [ -z "$MOUNT_OPTIONS" ] && _mount_opts
150 [ -z "$MKFS_OPTIONS" ] && _mkfs_opts
151 [ -z "$FSCK_OPTIONS" ] && _fsck_opts
152
153
154 # we need common.config
155 if [ "$iam" != "check" ]
156 then
157     if ! . ./common.config
158         then
159         echo "$iam: failed to source common.config"
160         exit 1
161     fi
162 fi
163
164 # make sure we have a standard umask
165 umask 022
166
167 _mount()
168 {
169     $MOUNT_PROG `_mount_ops_filter $*`
170 }
171
172 _scratch_options()
173 {
174     type=$1
175     SCRATCH_OPTIONS=""
176
177     if [ "$FSTYP" != "xfs" ]; then
178         return
179     fi
180
181     case $type in
182     mkfs)
183         [ "$HOSTOS" != "IRIX" ] && SCRATCH_OPTIONS="$SCRATCH_OPTIONS -f"
184         rt_opt="-r"
185         log_opt="-l"
186         ;;
187     mount)
188         rt_opt="-o"
189         log_opt="-o"
190         ;;
191     esac
192     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
193         SCRATCH_OPTIONS="$SCRATCH_OPTIONS ${rt_opt}rtdev=$SCRATCH_RTDEV"
194     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
195         SCRATCH_OPTIONS="$SCRATCH_OPTIONS ${log_opt}logdev=$SCRATCH_LOGDEV"
196 }
197
198 _test_options()
199 {
200     type=$1
201     TEST_OPTIONS=""
202
203     if [ "$FSTYP" != "xfs" ]; then
204         return
205     fi
206
207     case $type in
208     mkfs)
209         rt_opt="-r"
210         log_opt="-l"
211         ;;
212     mount)
213         rt_opt="-o"
214         log_opt="-o"
215         ;;
216     esac
217     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
218         TEST_OPTIONS="$TEST_OPTIONS ${rt_opt}rtdev=$TEST_RTDEV"
219     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
220         TEST_OPTIONS="$TEST_OPTIONS ${log_opt}logdev=$TEST_LOGDEV"
221 }
222
223 _mount_ops_filter()
224 {
225     params="$*"
226     
227     #get mount point to handle dmapi mtpt option correctly
228     let last_index=$#-1
229     [ $last_index -gt 0 ] && shift $last_index
230     FS_ESCAPED=$1
231     
232     # irix is fussy about how it is fed its mount options
233     # - multiple -o's are not allowed
234     # - no spaces between comma delimitered options
235     # the sed script replaces all -o's (except the first) with a comma
236     # not required for linux, but won't hurt
237     
238     echo $params | sed -e 's/[[:space:]]*-o[[:space:]]*/UnIqUe/1; s/[[:space:]]*-o[[:space:]]*/,/g; s/UnIqUe/ -o /1' \
239         | sed -e 's/dmapi/dmi/' \
240         | $PERL_PROG -ne "s#mtpt=[^,|^\n|^\s]*#mtpt=$FS_ESCAPED\1\2#; print;"
241
242 }
243
244 _scratch_mount_options()
245 {
246     _scratch_options mount
247
248     echo $SCRATCH_OPTIONS $MOUNT_OPTIONS $SELINUX_MOUNT_OPTIONS $* $SCRATCH_DEV $SCRATCH_MNT
249 }
250
251 _scratch_mount()
252 {
253     _mount -t $FSTYP `_scratch_mount_options $*`
254 }
255
256 _scratch_unmount()
257 {
258     $UMOUNT_PROG $SCRATCH_DEV
259 }
260
261 _scratch_remount()
262 {
263     _scratch_unmount
264     _scratch_mount
265 }
266
267 _test_mount()
268 {
269     _test_options mount
270     _mount -t $FSTYP $TEST_OPTIONS $TEST_FS_MOUNT_OPTS $SELINUX_MOUNT_OPTIONS $* $TEST_DEV $TEST_DIR
271 }
272
273 _scratch_mkfs_options()
274 {
275     _scratch_options mkfs
276     echo $SCRATCH_OPTIONS $MKFS_OPTIONS $* $SCRATCH_DEV
277 }
278
279 _scratch_mkfs_xfs()
280 {
281     # extra mkfs options can be added by tests
282     local extra_mkfs_options=$*
283
284     local tmp_dir=/tmp/
285
286     _scratch_options mkfs
287
288     # save mkfs output in case conflict means we need to run again.
289     # only the output for the mkfs that applies should be shown
290     $MKFS_XFS_PROG $SCRATCH_OPTIONS $MKFS_OPTIONS $extra_mkfs_options $SCRATCH_DEV \
291         2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
292     local mkfs_status=$?
293
294     # a mkfs failure may be caused by conflicts between
295     # $MKFS_OPTIONS and $extra_mkfs_options
296
297     if [ $mkfs_status -ne 0 -a ! -z "$extra_mkfs_options" ]; then
298         echo "** mkfs failed with extra mkfs options added to \"$MKFS_OPTIONS\" by test $seq **" \
299             >>$here/$seq.full
300         echo "** attempting to mkfs using only test $seq options: $extra_mkfs_options **" \
301             >>$here/$seq.full
302         # running mkfs again. overwrite previous mkfs output files
303         $MKFS_XFS_PROG $SCRATCH_OPTIONS $extra_mkfs_options $SCRATCH_DEV \
304             2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
305         mkfs_status=$?
306     fi
307
308     # output stored mkfs output
309     cat $tmp_dir.mkfserr >&2
310     cat $tmp_dir.mkfsstd
311     rm -f $tmp_dir.mkfserr $tmp_dir.mkfsstd
312
313     if [ "$USE_BIG_LOOPFS" = yes ]; then
314         [ -z "$RETAIN_AG_BYTES" ] && RETAIN_AG_BYTES=0
315         ./tools/ag-wipe -q -r $RETAIN_AG_BYTES $SCRATCH_DEV
316     fi
317
318     return $mkfs_status
319 }
320
321 _scratch_mkfs()
322 {
323     case $FSTYP in
324     xfs)
325         _scratch_mkfs_xfs $*
326         ;;
327     nfs*)
328         # do nothing for nfs
329         ;;
330     udf)
331         $MKFS_UDF_PROG $MKFS_OPTIONS $* $SCRATCH_DEV > /dev/null
332         ;;
333     btrfs)
334         $MKFS_BTRFS_PROG $MKFS_OPTIONS $* $SCRATCH_DEV > /dev/null
335         ;;
336     *)
337         yes | $MKFS_PROG -t $FSTYP -- $MKFS_OPTIONS $* $SCRATCH_DEV
338         ;;
339     esac
340 }
341
342 # Create fs of certain size on scratch device
343 # _scratch_mkfs_sized <size in bytes> [optional blocksize]
344 _scratch_mkfs_sized()
345 {
346     fssize=$1
347     blocksize=$2
348     [ -z "$blocksize" ] && blocksize=4096
349     blocks=`expr $fssize / $blocksize`
350
351     if [ "$HOSTOS" == "Linux" ]; then
352         devsize=`blockdev --getsize64 $SCRATCH_DEV`
353         [ "$fssize" -gt "$devsize" ] && _notrun "Scratch device too small"
354     fi
355
356     case $FSTYP in
357     xfs)
358         _scratch_mkfs_xfs -d size=$fssize -b size=$blocksize
359         ;;
360     ext2|ext3|ext4|ext4dev)
361         yes | ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
362         ;;
363     btrfs)
364         $MKFS_BTRFS_PROG $MKFS_OPTIONS -b $fssize $SCRATCH_DEV
365         ;;
366     *)
367         _notrun "Filesystem $FSTYP not supported in _scratch_mkfs_sized"
368         ;;
369     esac
370 }
371
372 # Emulate an N-data-disk stripe w/ various stripe units
373 # _scratch_mkfs_geom <sunit bytes> <swidth multiplier> [optional blocksize]
374 _scratch_mkfs_geom()
375 {
376     sunit_bytes=$1
377     swidth_mult=$2
378     blocksize=$3
379     [ -z "$blocksize" ] && blocksize=4096
380
381     let sunit_blocks=$sunit_bytes/$blocksize
382     let swidth_blocks=$sunit_blocks*$swidth_mult
383
384     case $FSTYP in
385     xfs)
386         MKFS_OPTIONS+=" -b size=$blocksize, -d su=$sunit_bytes,sw=$swidth_mult"
387         ;;
388     ext4|ext4dev)
389         MKFS_OPTIONS+=" -b $blocksize -E stride=$sunit_blocks,stripe_width=$swidth_blocks"
390         ;;
391     *)
392         _notrun "can't mkfs $FSTYP with geometry"
393         ;;
394     esac
395     _scratch_mkfs
396 }
397
398 _scratch_resvblks()
399 {
400         case $FSTYP in
401         xfs)
402                 xfs_io -x -c "resblks $1" $SCRATCH_MNT
403                 ;;
404         *)
405                 ;;
406         esac
407 }
408
409 _scratch_xfs_db_options()
410 {
411     SCRATCH_OPTIONS=""
412     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
413         SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
414     echo $SCRATCH_OPTIONS $* $SCRATCH_DEV
415 }
416
417 _scratch_xfs_logprint()
418 {
419     SCRATCH_OPTIONS=""
420     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
421         SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
422     $XFS_LOGPRINT_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
423 }
424
425 _scratch_xfs_check()
426 {
427     SCRATCH_OPTIONS=""
428     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
429         SCRATCH_OPTIONS="-l $SCRATCH_LOGDEV"
430     $XFS_CHECK_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
431 }
432
433 _scratch_xfs_repair()
434 {
435     SCRATCH_OPTIONS=""
436     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
437         SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
438     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
439         SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -r$SCRATCH_RTDEV"
440     [ "$USE_BIG_LOOPFS" = yes ] && SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -t"
441     $XFS_REPAIR_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
442 }
443
444 _get_pids_by_name()
445 {
446     if [ $# -ne 1 ]
447     then
448         echo "Usage: _get_pids_by_name process-name" 1>&2
449         exit 1
450     fi
451
452     # Algorithm ... all ps(1) variants have a time of the form MM:SS or
453     # HH:MM:SS before the psargs field, use this as the search anchor.
454     #
455     # Matches with $1 (process-name) occur if the first psarg is $1
456     # or ends in /$1 ... the matching uses sed's regular expressions,
457     # so passing a regex into $1 will work.
458
459     ps $PS_ALL_FLAGS \
460     | sed -n \
461         -e 's/$/ /' \
462         -e 's/[         ][      ]*/ /g' \
463         -e 's/^ //' \
464         -e 's/^[^ ]* //' \
465         -e "/[0-9]:[0-9][0-9]  *[^ ]*\/$1 /s/ .*//p" \
466         -e "/[0-9]:[0-9][0-9]  *$1 /s/ .*//p"
467 }
468
469 # fix malloc libs output
470 #
471 _fix_malloc()
472 {
473     # filter out the Electric Fence notice
474     $PERL_PROG -e '
475         while (<>) {
476             if (defined $o && /^\s+Electric Fence/) {
477                 chomp($o);
478                 print "$o";
479                 undef $o;
480                 next;
481             }
482             print $o if (defined $o);
483
484             $o=$_;
485         }
486         print $o if (defined $o);
487     '
488 }
489
490 # check if run as root
491 #
492 _need_to_be_root()
493 {
494     id=`id | $SED_PROG -e 's/(.*//' -e 's/.*=//'`
495     if [ "$id" -ne 0 ]
496     then
497         echo "Arrgh ... you need to be root (not uid=$id) to run this test"
498         exit 1
499     fi
500 }
501
502
503 #
504 # _df_device : get an IRIX style df line for a given device
505 #
506 #       - returns "" if not mounted
507 #       - returns fs type in field two (ala IRIX)
508 #       - joins line together if split by fancy df formatting
509 #       - strips header etc
510 #
511
512 _df_device()
513 {
514     if [ $# -ne 1 ]
515     then
516         echo "Usage: _df_device device" 1>&2
517         exit 1
518     fi
519
520     $DF_PROG 2>/dev/null | $AWK_PROG -v what=$1 '
521         match($1,what) && NF==1 {
522             v=$1
523             getline
524             print v, $0
525             exit
526         }
527         match($1,what) {
528             print
529             exit
530         }
531     '
532 }
533
534 #
535 # _df_dir : get an IRIX style df line for device where a directory resides
536 #
537 #       - returns fs type in field two (ala IRIX)
538 #       - joins line together if split by fancy df formatting
539 #       - strips header etc
540 #
541
542 _df_dir()
543 {
544     if [ $# -ne 1 ]
545     then
546         echo "Usage: _df_dir device" 1>&2
547         exit 1
548     fi
549
550     $DF_PROG $1 2>/dev/null | $AWK_PROG -v what=$1 '
551         NR == 2 && NF==1 {
552             v=$1
553             getline
554             print v, $0;
555             exit 0
556         }
557         NR == 2 {
558             print;
559             exit 0
560         }
561         {}
562     '
563     # otherwise, nada
564 }
565
566 # return percentage used disk space for mounted device
567
568 _used()
569 {
570     if [ $# -ne 1 ]
571     then
572         echo "Usage: _used device" 1>&2
573         exit 1
574     fi
575
576     _df_device $1 | $AWK_PROG '{ sub("%", "") ; print $6 }'
577 }
578
579 # return the FS type of a mounted device
580 #
581 _fs_type()
582 {
583     if [ $# -ne 1 ]
584     then
585         echo "Usage: _fs_type device" 1>&2
586         exit 1
587     fi
588
589     #
590     # The Linux kernel shows NFSv4 filesystems in df output as
591     # filesystem type nfs4, although we mounted it as nfs earlier.
592     # Fix the filesystem type up here so that the callers don't
593     # have to bother with this quirk.
594     #
595     _df_device $1 | $AWK_PROG '{ print $2 }' | sed -e 's/nfs4/nfs/'
596 }
597
598 # return the FS mount options of a mounted device
599 #
600 # should write a version which just parses the output of mount for IRIX
601 # compatibility, but since this isn't used at all, at the moment I'll leave
602 # this for now
603 #
604 _fs_options()
605 {
606     if [ $# -ne 1 ]
607     then
608         echo "Usage: _fs_options device" 1>&2
609         exit 1
610     fi
611
612     $AWK_PROG -v dev=$1 '
613         match($1,dev) { print $4 }
614     ' </proc/mounts
615 }
616
617 # returns device number if a file is a block device
618 #
619 _is_block_dev()
620 {
621     if [ $# -ne 1 ]
622     then
623         echo "Usage: _is_block_dev dev" 1>&2
624         exit 1
625     fi
626
627     _dev=$1
628     if [ -L "${_dev}" ]; then
629         _dev=`readlink -f ${_dev}`
630     fi
631
632     if [ -b "${_dev}" ]; then
633         src/lstat64 ${_dev} | $AWK_PROG '/Device type:/ { print $9 }'
634     fi
635 }
636
637 # Do a command, log it to $seq.full, optionally test return status
638 # and die if command fails. If called with one argument _do executes the
639 # command, logs it, and returns its exit status. With two arguments _do
640 # first prints the message passed in the first argument, and then "done"
641 # or "fail" depending on the return status of the command passed in the
642 # second argument. If the command fails and the variable _do_die_on_error
643 # is set to "always" or the two argument form is used and _do_die_on_error
644 # is set to "message_only" _do will print an error message to
645 # $seq.out and exit.
646
647 _do()
648 {
649     if [ $# -eq 1 ]; then
650         _cmd=$1
651     elif [ $# -eq 2 ]; then
652         _note=$1
653         _cmd=$2
654         echo -n "$_note... "
655     else
656         echo "Usage: _do [note] cmd" 1>&2
657         status=1; exit
658     fi
659
660     (eval "echo '---' \"$_cmd\"") >>$here/$seq.full
661     (eval "$_cmd") >$tmp._out 2>&1; ret=$?
662     cat $tmp._out | _fix_malloc >>$here/$seq.full
663     if [ $# -eq 2 ]; then
664         if [ $ret -eq 0 ]; then
665             echo "done"
666         else
667             echo "fail"
668         fi
669     fi
670     if [ $ret -ne 0  ] \
671         && [ "$_do_die_on_error" = "always" \
672             -o \( $# -eq 2 -a "$_do_die_on_error" = "message_only" \) ]
673     then
674         [ $# -ne 2 ] && echo
675         eval "echo \"$_cmd\" failed \(returned $ret\): see $seq.full"
676         status=1; exit
677     fi
678
679     return $ret
680 }
681
682 # bail out, setting up .notrun file
683 #
684 _notrun()
685 {
686     echo "$*" >$seq.notrun
687     echo "$seq not run: $*"
688     status=0
689     exit
690 }
691
692 # just plain bail out
693 #
694 _fail()
695 {
696     echo "$*" | tee -a $here/$seq.full
697     echo "(see $seq.full for details)"
698     status=1
699     exit 1
700 }
701
702 # tests whether $FSTYP is one of the supported filesystems for a test
703 #
704 _supported_fs()
705 {
706     for f
707     do
708         if [ "$f" = "$FSTYP" -o "$f" = "generic" ]
709         then
710             return
711         fi
712     done
713
714     _notrun "not suitable for this filesystem type: $FSTYP"
715 }
716
717 # tests whether $FSTYP is one of the supported OSes for a test
718 #
719 _supported_os()
720 {
721     for h
722     do
723         if [ "$h" = "$HOSTOS" ]
724         then
725             return
726         fi
727     done
728
729     _notrun "not suitable for this OS: $HOSTOS"
730 }
731
732 # this test needs a scratch partition - check we're ok & unmount it
733 #
734 _require_scratch()
735 {
736     case "$FSTYP" in
737         nfs*)
738                  echo $SCRATCH_DEV | grep -q ":" > /dev/null 2>&1
739                  if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]
740                  then
741                      _notrun "this test requires a valid \$SCRATCH_DEV"
742                  fi
743                  ;;
744         *)
745                  if [ -z "$SCRATCH_DEV" -o "`_is_block_dev $SCRATCH_DEV`" = "" ]
746                  then
747                      _notrun "this test requires a valid \$SCRATCH_DEV"
748                  fi
749                  if [ "`_is_block_dev $SCRATCH_DEV`" = "`_is_block_dev $TEST_DEV`" ]
750                  then
751                      _notrun "this test requires a valid \$SCRATCH_DEV"
752                  fi
753                 if [ ! -d "$SCRATCH_MNT" ]
754                 then
755                      _notrun "this test requires a valid \$SCRATCH_MNT"
756                 fi
757                  ;;
758     esac
759
760     # mounted?
761     if _mount | grep -q $SCRATCH_DEV
762     then
763         # if it's mounted, make sure its on $SCRATCH_MNT
764         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
765         then
766             echo "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
767             exit 1
768         fi
769         # and then unmount it
770         if ! $UMOUNT_PROG $SCRATCH_DEV
771         then
772             echo "failed to unmount $SCRATCH_DEV"
773             exit 1
774         fi
775     fi
776 }
777
778 # this test needs a logdev
779 #
780 _require_logdev()
781 {
782     [ -z "$SCRATCH_LOGDEV" -o ! -b "$SCRATCH_LOGDEV" ] && \
783         _notrun "This test requires a valid \$SCRATCH_LOGDEV"
784     [ "$USE_EXTERNAL" != yes ] && \
785         _notrun "This test requires USE_EXTERNAL to be enabled"
786
787     # ensure its not mounted
788     $UMOUNT_PROG $SCRATCH_LOGDEV 2>/dev/null
789 }
790
791 # this test requires loopback device support
792 #
793 _require_loop()
794 {
795     if [ "$HOSTOS" != "Linux" ]
796     then
797         _notrun "This test requires linux for loopback device support"
798     fi
799
800     modprobe loop >/dev/null 2>&1
801     if grep loop /proc/devices >/dev/null 2>&1
802     then
803         :
804     else
805         _notrun "This test requires loopback device support"
806     fi
807 }
808
809 # this test requires ext2 filesystem support
810 #
811 _require_ext2()
812 {
813     if [ "$HOSTOS" != "Linux" ]
814     then
815         _notrun "This test requires linux for ext2 filesystem support"
816     fi
817
818     modprobe ext2 >/dev/null 2>&1
819     if grep ext2 /proc/filesystems >/dev/null 2>&1
820     then
821         :
822     else
823         _notrun "This test requires ext2 filesystem support"
824     fi
825 }
826
827 # this test requires that (large) loopback device files are not in use
828 #
829 _require_nobigloopfs()
830 {
831     [ "$USE_BIG_LOOPFS" = yes ] && \
832         _notrun "Large filesystem testing in progress, skipped this test"
833 }
834
835 # this test requires that a realtime subvolume is in use, and
836 # that the kernel supports realtime as well.
837 #
838 _require_realtime()
839 {
840     [ "$USE_EXTERNAL" = yes ] || \
841         _notrun "External volumes not in use, skipped this test"
842     [ "$SCRATCH_RTDEV" = "" ] && \
843         _notrun "Realtime device required, skipped this test"
844 }
845
846 # this test requires that a specified command (executable) exists
847 # $1 - command, $2 - name for error message
848 #
849 _require_command()
850 {
851     [ -n "$1" ] && _cmd="$1" || _cmd="$2"
852     [ -n "$1" -a -x "$1" ] || _notrun "$_cmd utility required, skipped this test"
853 }
854
855 # this test requires the projid32bit feature to be available in
856 # mkfs.xfs
857 #
858 _require_projid32bit()
859 {
860         _scratch_mkfs_xfs -f -i projid32bit=0 2>&1 >/dev/null \
861            || _notrun "mkfs.xfs doesn't have projid32bit feature"
862 }
863
864 # this test requires that external log/realtime devices are not in use
865 #
866 _require_nonexternal()
867 {
868     [ "$USE_EXTERNAL" = yes ] && \
869         _notrun "External device testing in progress, skipped this test"
870 }
871
872 # this test requires that a (specified) aio-dio executable exists
873 # $1 - command (optional)
874 #
875 _require_aiodio()
876 {
877     if [ -z "$1" ]
878     then
879         AIO_TEST=src/aio-dio-regress/aiodio_sparse2
880         [ -x $AIO_TEST ] || _notrun "aio-dio utilities required"
881     else
882         AIO_TEST=src/aio-dio-regress/$1
883         [ -x $AIO_TEST ] || _notrun "$AIO_TEST not built"
884     fi
885 }
886
887 # run an aio-dio program
888 # $1 - command
889 _run_aiodio()
890 {
891     if [ -z "$1" ]
892     then
893         echo "usage: _run_aiodio command_name" 2>&1
894         status=1; exit 1
895     fi
896
897     _require_aiodio $1
898
899     local testtemp=$TEST_DIR/aio-testfile
900     rm -f $testtemp
901     $AIO_TEST $testtemp 2>&1
902     status=$?
903     rm -f $testtemp
904
905     return $status
906 }
907
908 # indicate whether YP/NIS is active or not
909 #
910 _yp_active()
911 {
912         local dn
913         dn=$(domainname 2>/dev/null)
914         test -n "${dn}" -a "${dn}" != "(none)"
915         echo $?
916 }
917
918 # cat the password file
919 #
920 _cat_passwd()
921 {
922         [ $(_yp_active) -eq 0 ] && ypcat passwd
923         cat /etc/passwd
924 }
925
926 # cat the group file
927 #
928 _cat_group()
929 {
930         [ $(_yp_active) -eq 0 ] && ypcat group
931         cat /etc/group
932 }
933
934 # check for the fsgqa user on the machine
935 #
936 _require_user()
937 {
938     qa_user=fsgqa
939     _cat_passwd | grep -q $qa_user
940     [ "$?" == "0" ] || _notrun "$qa_user user not defined."
941     echo /bin/true | su $qa_user
942     [ "$?" == "0" ] || _notrun "$qa_user cannot execute commands."
943 }
944
945 # check for the fsgqa group on the machine
946 #
947 _require_group()
948 {
949     qa_group=fsgqa
950     _cat_group | grep -q $qa_group
951     [ "$?" == "0" ] || _notrun "$qa_group user not defined."
952 }
953
954 _filter_user_do()
955 {
956         perl -ne "
957 s,.*Permission\sdenied.*,Permission denied,;
958 s,.*no\saccess\sto\stty.*,,;
959 s,.*no\sjob\scontrol\sin\sthis\sshell.*,,;
960 s,^\s*$,,;
961         print;"
962 }
963
964 _user_do()
965 {
966     if [ "$HOSTOS" == "IRIX" ]
967         then
968         echo $1 | /bin/bash "su $qa_user 2>&1" | _filter_user_do
969     else
970         echo $1 | su $qa_user 2>&1 | _filter_user_do
971     fi
972 }
973
974 # check that xfs_io, kernel, and filesystem all support zero
975 _require_xfs_io_zero()
976 {
977         testio=`$XFS_IO_PROG -c "zero help" 2>&1`
978         echo $testio | grep -q 'command "zero" not found' && \
979                 _notrun "zero command not supported"
980 }
981
982 # check that xfs_io, glibc, kernel, and filesystem all (!) support
983 # fallocate
984 #
985 _require_xfs_io_falloc()
986 {
987         testfile=$TEST_DIR/$$.falloc
988         testio=`$XFS_IO_PROG -F -f -c "falloc 0 1m" $testfile 2>&1`
989         rm -f $testfile 2>&1 > /dev/null
990         echo $testio | grep -q "not found" && \
991                 _notrun "xfs_io fallocate support is missing"
992         echo $testio | grep -q "Operation not supported" && \
993                 _notrun "xfs_io fallocate command failed (old kernel/wrong fs?)"
994 }
995
996 # check that xfs_io, kernel and filesystem all support fallocate with hole
997 # punching
998 _require_xfs_io_falloc_punch()
999 {
1000         testfile=$TEST_DIR/$$.falloc
1001         testio=`$XFS_IO_PROG -F -f -c "pwrite 0 20k" -c "fsync" \
1002                 -c "fpunch 4k 8k" $testfile 2>&1`
1003         rm -f $testfile 2>&1 > /dev/null
1004         echo $testio | grep -q "not found" && \
1005                 _notrun "xfs_io fallocate punch support is missing"
1006         echo $testio | grep -q "Operation not supported" && \
1007                 _notrun "xfs_io fallocate punch command failed (no fs support?)"
1008 }
1009
1010 # check that xfs_io, kernel and filesystem support fiemap
1011 _require_xfs_io_fiemap()
1012 {
1013         testfile=$TEST_DIR/$$.fiemap
1014         testio=`$XFS_IO_PROG -F -f -c "pwrite 0 20k" -c "fsync" \
1015                 -c "fiemap -v" $testfile 2>&1`
1016         rm -f $testfile 2>&1 > /dev/null
1017         echo $testio | grep -q "not found" && \
1018                 _notrun "xfs_io fiemap support is missing"
1019         echo $testio | grep -q "Operation not supported" && \
1020                 _notrun "xfs_io fiemap command failed (no fs support?)"
1021 }
1022
1023 # Check that a fs has enough free space (in 1024b blocks)
1024 #
1025 _require_fs_space()
1026 {
1027         MNT=$1
1028         BLOCKS=$2       # in units of 1024
1029         let GB=$BLOCKS/1024/1024
1030
1031         FREE_BLOCKS=`df -klP $MNT | grep -v Filesystem | awk '{print $4}'`
1032         [ $FREE_BLOCKS -lt $BLOCKS ] && \
1033                 _notrun "This test requires at least ${GB}GB free on $MNT to run"
1034 }
1035
1036 #
1037 # Check if the filesystem supports sparse files.
1038 #
1039 # Unfortunately there is no better way to do this than a manual black list.
1040 #
1041 _require_sparse_files()
1042 {
1043     case $FSTYP in
1044     hfsplus)
1045         _notrun "Sparse files not supported by this filesystem type: $FSTYP"
1046         ;;
1047     *)
1048         ;;
1049     esac
1050 }
1051
1052 _require_debugfs()
1053 {
1054     #boot_params always present in debugfs
1055     [ -d "$DEBUGFS_MNT/boot_params" ] || _notrun "Debugfs not mounted"
1056 }
1057
1058 _require_fail_make_request()
1059 {
1060     [ -f "$DEBUGFS_MNT/fail_make_request/probability" ] \
1061         || _notrun "$DEBUGFS_MNT/fail_make_request \
1062  not found. Seems that CONFIG_FAIL_MAKE_REQUEST kernel config option not enabled"
1063 }
1064
1065 # check that a FS on a device is mounted
1066 # if so, return mount point
1067 #
1068 _is_mounted()
1069 {
1070     if [ $# -ne 1 ]
1071     then
1072         echo "Usage: _is_mounted device" 1>&2
1073         exit 1
1074     fi
1075
1076     device=$1
1077
1078     if _mount | grep "$device " | $AWK_PROG -v pattern="type $FSTYP" '
1079         pattern        { print $3 ; exit 0 }
1080         END            { exit 1 }
1081     '
1082     then
1083         echo "_is_mounted: $device is not a mounted $FSTYP FS"
1084         exit 1
1085     fi
1086 }
1087
1088 # remount a FS to a new mode (ro or rw)
1089 #
1090 _remount()
1091 {
1092     if [ $# -ne 2 ]
1093     then
1094         echo "Usage: _remount device ro/rw" 1>&2
1095         exit 1
1096     fi
1097     device=$1
1098     mode=$2
1099
1100     if ! mount -o remount,$mode $device
1101     then
1102         echo "_remount: failed to remount filesystem on $device as $mode"
1103         exit 1
1104     fi
1105 }
1106
1107 # Run the appropriate repair/check on a filesystem
1108 #
1109 # if the filesystem is mounted, it's either remounted ro before being
1110 # checked or it's unmounted and then remounted
1111 #
1112
1113 # If set, we remount ro instead of unmounting for fsck
1114 USE_REMOUNT=0
1115
1116 _umount_or_remount_ro()
1117 {
1118     if [ $# -ne 1 ]
1119     then
1120         echo "Usage: _umount_or_remount_ro <device>" 1>&2
1121         exit 1
1122     fi
1123
1124     device=$1
1125     mountpoint=`_is_mounted $device`
1126
1127     if [ $USE_REMOUNT -eq 0 ]; then
1128         $UMOUNT_PROG $device
1129     else
1130         _remount $device ro
1131     fi
1132     echo "$mountpoint"
1133 }
1134
1135 _mount_or_remount_rw()
1136 {
1137     if [ $# -ne 3 ]
1138     then
1139         echo "Usage: _mount_or_remount_rw <opts> <device> <mountpoint>" 1>&2
1140         exit 1
1141     fi
1142     mount_opts=$1
1143     device=$2
1144     mountpoint=$3
1145
1146     if [ $USE_REMOUNT -eq 0 ]
1147     then
1148         if ! _mount -t $FSTYP $mount_opts $device $mountpoint
1149         then
1150             echo "!!! failed to remount $device on $mountpoint"
1151             return 0 # ok=0
1152         fi
1153     else
1154         _remount $device rw
1155     fi
1156
1157     return 1 # ok=1
1158 }
1159
1160 # Check a generic filesystem in no-op mode; this assumes that the
1161 # underlying fsck program accepts "-n" for a no-op (check-only) run,
1162 # and that it will still return an errno for corruption in this mode.
1163 #
1164 # Filesystems which don't support this will need to define their
1165 # own check routine.
1166 #
1167 _check_generic_filesystem()
1168 {
1169     device=$1
1170
1171     # If type is set, we're mounted
1172     type=`_fs_type $device`
1173     ok=1
1174
1175     if [ "$type" = "$FSTYP" ]
1176     then
1177         # mounted ...
1178         mountpoint=`_umount_or_remount_ro $device`
1179     fi
1180
1181     fsck -t $FSTYP $FSCK_OPTIONS $device >$tmp.fsck 2>&1
1182     if [ $? -ne 0 ]
1183     then
1184         echo "_check_generic_filesystem: filesystem on $device is inconsistent (see $seq.full)"
1185
1186         echo "_check_generic filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1187         echo "*** fsck.$FSTYP output ***"                     >>$here/$seq.full
1188         cat $tmp.fsck                                         >>$here/$seq.full
1189         echo "*** end fsck.$FSTYP output"                     >>$here/$seq.full
1190
1191         ok=0
1192     fi
1193     rm -f $tmp.fsck
1194
1195     if [ $ok -eq 0 ]
1196     then
1197         echo "*** mount output ***"                             >>$here/$seq.full
1198         _mount                                                  >>$here/$seq.full
1199         echo "*** end mount output"                             >>$here/$seq.full
1200     elif [ "$type" = "$FSTYP" ]
1201     then
1202         # was mounted ...
1203         _mount_or_remount_rw "$MOUNT_OPTIONS" $device $mountpoint
1204         ok=$?
1205     fi
1206
1207     if [ $ok -eq 0 ]; then
1208         status=1
1209         exit 1
1210     fi
1211
1212     return 0
1213 }
1214
1215 # run xfs_check and friends on a FS.
1216
1217 _check_xfs_filesystem()
1218 {
1219     if [ $# -ne 3 ]
1220     then
1221         echo "Usage: _check_xfs_filesystem device <logdev>|none <rtdev>|none" 1>&2
1222         exit 1
1223     fi
1224
1225     extra_mount_options=""
1226     device=$1
1227     if [ "$2" != "none" ]; then
1228         extra_log_options="-l$2"
1229         extra_mount_options="-ologdev=$2"
1230     fi
1231
1232     if [ "$3" != "none" ]; then
1233         extra_rt_options="-r$3"
1234         extra_mount_options=$extra_mount_options" -ortdev=$3"
1235     fi
1236     extra_mount_options=$extra_mount_options" $MOUNT_OPTIONS"
1237
1238     [ "$FSTYP" != xfs ] && return 0
1239     testoption=""
1240     [ "$USE_BIG_LOOPFS" = yes ] && testoption=-t
1241
1242     type=`_fs_type $device`
1243     ok=1
1244
1245     if [ "$type" = "xfs" ]
1246     then
1247         # mounted ...
1248         mountpoint=`_umount_or_remount_ro $device`
1249     fi
1250
1251     $XFS_LOGPRINT_PROG -t $extra_log_options $device 2>&1 \
1252                 | tee $tmp.logprint | grep -q "<CLEAN>"
1253     if [ $? -ne 0 -a "$HOSTOS" = "Linux" ]
1254     then
1255         echo "_check_xfs_filesystem: filesystem on $device has dirty log (see $seq.full)"
1256
1257         echo "_check_xfs_filesystem: filesystem on $device has dirty log"   >>$here/$seq.full
1258         echo "*** xfs_logprint -t output ***"                   >>$here/$seq.full
1259         cat $tmp.logprint                                       >>$here/$seq.full
1260         echo "*** end xfs_logprint output"                      >>$here/$seq.full
1261
1262         ok=0
1263     fi
1264
1265     $XFS_CHECK_PROG $testoption $extra_log_options $device 2>&1 |\
1266          _fix_malloc >$tmp.fs_check
1267     if [ -s $tmp.fs_check ]
1268     then
1269         echo "_check_xfs_filesystem: filesystem on $device is inconsistent (c) (see $seq.full)"
1270
1271         echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1272         echo "*** xfs_check output ***"                         >>$here/$seq.full
1273         cat $tmp.fs_check                                       >>$here/$seq.full
1274         echo "*** end xfs_check output"                         >>$here/$seq.full
1275
1276         ok=0
1277     fi
1278     # repair doesn't scale massively at this stage, optionally skip it for now
1279     [ "$USE_BIG_LOOPFS" = yes ] || \
1280     $XFS_REPAIR_PROG -n $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
1281     if [ $? -ne 0 ]
1282     then
1283         echo "_check_xfs_filesystem: filesystem on $device is inconsistent (r) (see $seq.full)"
1284
1285         echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1286         echo "*** xfs_repair -n output ***"                     >>$here/$seq.full
1287         cat $tmp.repair | _fix_malloc                           >>$here/$seq.full
1288         echo "*** end xfs_repair output"                        >>$here/$seq.full
1289
1290         ok=0
1291     fi
1292     rm -f $tmp.fs_check $tmp.logprint $tmp.repair
1293
1294     if [ $ok -eq 0 ]
1295     then
1296         echo "*** mount output ***"                             >>$here/$seq.full
1297         _mount                                                  >>$here/$seq.full
1298         echo "*** end mount output"                             >>$here/$seq.full
1299     elif [ "$type" = "xfs" ]
1300     then
1301         _mount_or_remount_rw "$extra_mount_options" $device $mountpoint
1302     fi
1303
1304     if [ $ok -eq 0 ]; then
1305         status=1
1306         exit 1
1307     fi
1308
1309     return 0
1310 }
1311
1312 # Filter the knowen errors the UDF Verifier reports.
1313 _udf_test_known_error_filter()
1314 {
1315         egrep -v "PVD  60  Error: Interchange Level: 1, Maximum Interchange Level: 0|FSD  28  Error: Interchange Level: 1, Maximum Interchange Level: 1,|PVD  72  Warning: Volume Set Identifier: \"\*IRIX UDF\",|Warning: [0-9]+ unused blocks NOT marked as unallocated."
1316
1317 }
1318
1319 _check_udf_filesystem()
1320 {
1321     [ "$DISABLE_UDF_TEST" == "1" ] && return
1322
1323     if [ $# -ne 1 -a $# -ne 2 ]
1324     then
1325         echo "Usage: _check_udf_filesystem device [last_block]" 1>&2
1326         exit 1
1327     fi
1328
1329     if [ ! -x $here/src/udf_test ]
1330     then
1331         echo "udf_test not installed, please download and build the Philips"
1332         echo "UDF Verification Software from http://www.extra.research.philips.com/udf/."
1333         echo "Then copy the udf_test binary to $here/src/."
1334         echo "If you do not wish to run udf_test then set environment variable DISABLE_UDF_TEST"
1335         echo "to 1."
1336         return
1337     fi
1338
1339     device=$1
1340     if [ $# -eq 2 ];
1341     then
1342         LAST_BLOCK=`expr \( $2 - 1 \)`
1343         OPT_ARG="-lastvalidblock $LAST_BLOCK"
1344     fi
1345
1346     rm -f $seq.checkfs
1347     sleep 1 # Due to a problem with time stamps in udf_test
1348     $here/src/udf_test $OPT_ARG $device | tee $here/$seq.checkfs | egrep "Error|Warning" | \
1349         _udf_test_known_error_filter | \
1350         egrep -iv "Error count:.*[0-9]+.*total occurrences:.*[0-9]+|Warning count:.*[0-9]+.*total occurrences:.*[0-9]+" | \
1351         sed "s/^.*$/Warning UDF Verifier reported errors see $seq.checkfs./g"
1352
1353 }
1354
1355 _check_xfs_test_fs()
1356 {
1357     TEST_LOG="none"
1358     TEST_RT="none"
1359     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
1360         TEST_LOG="$TEST_LOGDEV"
1361
1362     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
1363         TEST_RT="$TEST_RTDEV"
1364
1365     _check_xfs_filesystem $TEST_DEV $TEST_LOG $TEST_RT
1366
1367     # check for ipath consistency
1368     if $XFS_GROWFS_PROG -n $TEST_DIR | grep -q 'inode-paths=1'; then
1369         # errors go to stderr
1370         xfs_check_ipaths $TEST_DIR >/dev/null
1371         xfs_repair_ipaths -n $TEST_DIR >/dev/null
1372     fi
1373 }
1374
1375 _check_btrfs_filesystem()
1376 {
1377     device=$1
1378
1379     # If type is set, we're mounted
1380     type=`_fs_type $device`
1381     ok=1
1382
1383     if [ "$type" = "$FSTYP" ]
1384     then
1385         # mounted ...
1386         mountpoint=`_umount_or_remount_ro $device`
1387     fi
1388
1389     btrfsck $device >$tmp.fsck 2>&1
1390     if [ $? -ne 0 ]
1391     then
1392         echo "_check_btrfs_filesystem: filesystem on $device is inconsistent (see $seq.full)"
1393
1394         echo "_check_btrfs_filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1395         echo "*** fsck.$FSTYP output ***"                     >>$here/$seq.full
1396         cat $tmp.fsck                                         >>$here/$seq.full
1397         echo "*** end fsck.$FSTYP output"                     >>$here/$seq.full
1398
1399         ok=0
1400     fi
1401     rm -f $tmp.fsck
1402
1403     if [ $ok -eq 0 ]
1404     then
1405         echo "*** mount output ***"                             >>$here/$seq.full
1406         _mount                                                  >>$here/$seq.full
1407         echo "*** end mount output"                             >>$here/$seq.full
1408     elif [ "$type" = "$FSTYP" ]
1409     then
1410         # was mounted ...
1411         _mount_or_remount_rw "$MOUNT_OPTIONS" $device $mountpoint
1412         ok=$?
1413     fi
1414
1415     if [ $ok -eq 0 ]; then
1416         status=1
1417         exit 1
1418     fi
1419
1420     return 0
1421 }
1422
1423 _check_test_fs()
1424 {
1425     case $FSTYP in
1426     xfs)
1427         _check_xfs_test_fs
1428         ;;
1429     nfs)
1430         # no way to check consistency for nfs
1431         ;;
1432     udf)
1433         # do nothing for now
1434         ;;
1435     btrfs)
1436         _check_btrfs_filesystem $TEST_DEV
1437         ;;
1438     *)
1439         _check_generic_filesystem $TEST_DEV
1440         ;;
1441     esac
1442 }
1443
1444 _check_scratch_fs()
1445 {
1446     case $FSTYP in
1447     xfs)
1448         SCRATCH_LOG="none"
1449         SCRATCH_RT="none"
1450         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
1451             SCRATCH_LOG="$SCRATCH_LOGDEV"
1452
1453         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
1454             SCRATCH_RT="$SCRATCH_RTDEV"
1455
1456         _check_xfs_filesystem $SCRATCH_DEV $SCRATCH_LOG $SCRATCH_RT
1457         ;;
1458     udf)
1459         _check_udf_filesystem $SCRATCH_DEV $udf_fsize
1460         ;;
1461     nfs*)
1462         # Don't know how to check an NFS filesystem, yet.
1463         ;;
1464     btrfs)
1465         _check_btrfs_filesystem $SCRATCH_DEV
1466         ;;
1467     *)
1468         _check_generic_filesystem $SCRATCH_DEV
1469         ;;
1470     esac
1471 }
1472
1473 _full_fstyp_details()
1474 {
1475      [ -z "$FSTYP" ] && FSTYP=xfs
1476      if [ $FSTYP = xfs ]; then
1477         if [ -d /proc/fs/xfs ]; then
1478             if grep -q 'debug 0' /proc/fs/xfs/stat; then
1479                 FSTYP="$FSTYP (non-debug)"
1480             elif grep -q 'debug 1' /proc/fs/xfs/stat; then
1481                 FSTYP="$FSTYP (debug)"
1482             fi
1483         else
1484             if uname -a | grep -qi 'debug'; then
1485                 FSTYP="$FSTYP (debug)"
1486             else
1487                 FSTYP="$FSTYP (non-debug)"
1488             fi
1489         fi
1490      fi
1491      echo $FSTYP
1492 }
1493
1494 _full_platform_details()
1495 {
1496      os=`uname -s`
1497      host=`hostname -s`
1498      kernel=`uname -r`
1499      platform=`uname -m`
1500      echo "$os/$platform $host $kernel"
1501 }
1502
1503 _setup_udf_scratchdir()
1504 {
1505     [ "$FSTYP" != "udf" ] \
1506         && _fail "setup_udf_testdir: \$FSTYP is not udf"
1507     [ -z "$SCRATCH_DEV" -o ! -b "$SCRATCH_DEV" ] \
1508         && _notrun "this test requires a valid \$SCRATCH_DEV"
1509     [ -z "$SCRATCH_MNT" ] \
1510         && _notrun "this test requires a valid \$SCRATCH_MNT"
1511
1512     # mounted?
1513     if _mount | grep -q $SCRATCH_DEV
1514     then
1515         # if it's mounted, make sure its on $TEST_RW_DIR
1516         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
1517         then
1518             _fail "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
1519         fi
1520         $UMOUNT_PROG $SCRATCH_DEV
1521     fi
1522
1523     _scratch_mkfs
1524     _scratch_mount
1525
1526     testdir=$SCRATCH_MNT
1527 }
1528
1529 _setup_nfs_scratchdir()
1530 {
1531     [ "$FSTYP" != "nfs" ] \
1532         && _fail "setup_nfs_testdir: \$FSTYP is not nfs"
1533     [ -z "$SCRATCH_DEV" ] \
1534         && _notrun "this test requires a valid host fs for \$SCRATCH_DEV"
1535     [ -z "$SCRATCH_MNT" ] \
1536         && _notrun "this test requires a valid \$SCRATCH_MNT"
1537
1538     # mounted?
1539     if _mount | grep -q $SCRATCH_DEV
1540     then
1541         # if it's mounted, make sure its on $SCRATCH_MNT
1542         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
1543         then
1544             _fail "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
1545         fi
1546         $UMOUNT_PROG $SCRATCH_DEV
1547     fi
1548
1549     _scratch_mkfs
1550     _scratch_mount
1551
1552     testdir=$SCRATCH_MNT
1553 }
1554
1555 #
1556 # Warning for UDF and NFS:
1557 # this function calls _setup_udf_scratchdir and _setup_udf_scratchdir
1558 # which actually uses the scratch dir for the test dir.
1559 #
1560 # This was done because testdir was intended to be a persistent
1561 # XFS only partition.  This should eventually change, and treat
1562 # at least local filesystems all the same.
1563 #
1564 _setup_testdir()
1565 {
1566     case $FSTYP in
1567     udf)
1568         _setup_udf_scratchdir
1569         ;;
1570     nfs*)
1571         _setup_nfs_scratchdir
1572         ;;
1573     *)
1574         testdir=$TEST_DIR
1575         ;;
1576     esac
1577 }
1578
1579 _cleanup_testdir()
1580 {
1581     case $FSTYP in
1582     udf)
1583         # umount testdir as it is $SCRATCH_MNT which could be used by xfs next
1584         [ -n "$testdir" ] && $UMOUNT_PROG $testdir
1585         ;;
1586     nfs*)
1587         # umount testdir as it is $SCRATCH_MNT which could be used by xfs next
1588         [ -n "$testdir" ] && $UMOUNT_PROG $testdir
1589         ;;
1590     *)
1591         # do nothing, testdir is $TEST_DIR
1592         :
1593         ;;
1594     esac
1595 }
1596
1597 _link_out_file()
1598 {
1599    if [ -z "$1" ]; then
1600       echo Error must pass \$seq.
1601       exit
1602    fi
1603    rm -f $1
1604    if [ "`uname`" == "IRIX64" ] || [ "`uname`" == "IRIX" ]; then
1605       ln -s $1.irix $1
1606    elif [ "`uname`" == "Linux" ]; then
1607       ln -s $1.linux $1
1608    else
1609       echo Error test $seq does not run on the operating system: `uname`
1610       exit
1611    fi
1612 }
1613
1614 _die()
1615 {
1616         echo $@
1617         exit 1
1618 }
1619
1620 #takes files, randomdata
1621 _nfiles()
1622 {
1623         f=0
1624         while [ $f -lt $1 ]
1625         do
1626                 file=f$f
1627                 echo > $file
1628                 if [ $size -gt 0 ]; then
1629                     if [ "$2" == "false" ]; then
1630                         dd if=/dev/zero of=$file bs=1024 count=$size 2>&1 | _filter_dd
1631                     else
1632                         dd if=/dev/urandom of=$file bs=1024 count=$size 2>&1 | _filter_dd
1633                     fi
1634                 fi
1635                 let f=$f+1
1636         done
1637 }
1638
1639 # takes dirname, depth, randomdata
1640 _descend()
1641 {
1642         dirname=$1; depth=$2; randomdata=$3
1643         mkdir $dirname  || die "mkdir $dirname failed"
1644         cd $dirname
1645
1646         _nfiles $files $randomdata          # files for this dir and data type
1647
1648         [ $depth -eq 0 ] && return
1649         let deep=$depth-1 # go 1 down
1650
1651         [ $verbose = true ] && echo "descending, depth from leaves = $deep"
1652
1653         d=0
1654         while [ $d -lt $dirs ]
1655         do
1656                 _descend d$d $deep &
1657                 let d=$d+1
1658                 wait
1659         done
1660 }
1661
1662 # Populate a filesystem with inodes for performance experiments
1663 #
1664 # usage: populate [-v] [-n ndirs] [-f nfiles] [-d depth] [-r root] [-s size] [-x]
1665 #
1666 _populate_fs()
1667 {
1668     here=`pwd`
1669     dirs=5          # ndirs in each subdir till leaves
1670     size=0          # sizeof files in K
1671     files=100       # num files in _each_ subdir
1672     depth=2         # depth of tree from root to leaves
1673     verbose=false
1674     root=root       # path of initial root of directory tree
1675     randomdata=false # -x data type urandom or zero
1676
1677     OPTIND=1
1678     while getopts "d:f:n:r:s:v:x" c
1679     do
1680         case $c in
1681         d)      depth=$OPTARG;;
1682         n)      dirs=$OPTARG;;
1683         f)      files=$OPTARG;;
1684         s)      size=$OPTARG;;
1685         v)      verbose=true;;
1686         r)      root=$OPTARG;;
1687         x)      randomdata=true;;
1688         esac
1689     done
1690
1691     _descend $root $depth $randomdata
1692     wait
1693
1694     cd $here
1695
1696     [ $verbose = true ] && echo done
1697 }
1698
1699 # query whether the given file has the given inode flag set
1700 #
1701 _test_inode_flag()
1702 {
1703     flag=$1
1704     file=$2
1705
1706     if which $XFS_IO_PROG >/dev/null; then
1707         if $XFS_IO_PROG -r -c 'lsattr -v' "$file" | grep -q "$flag" ; then
1708             return 0
1709         fi
1710     fi
1711     return 1
1712 }
1713
1714 # query the given files extsize allocator hint in bytes (if any)
1715 #
1716 _test_inode_extsz()
1717 {
1718     file=$1
1719     blocks=""
1720
1721     if which $XFS_IO_PROG >/dev/null; then
1722         blocks=`$XFS_IO_PROG -r -c 'stat' "$file" | \
1723                 awk '/^xattr.extsize =/ { print $3 }'`
1724     fi
1725     [ -z "$blocks" ] && blocks="0"
1726     echo $blocks
1727 }
1728
1729 # scratch_dev_pool should contain the disks pool for the btrfs raid
1730 _require_scratch_dev_pool()
1731 {
1732         local i
1733         if [ -z "$SCRATCH_DEV_POOL" ]; then
1734                 _notrun "this test requires a valid \$SCRATCH_DEV_POOL"
1735         fi
1736
1737         # btrfs test case needs 2 or more scratch_dev_pool; other FS not sure
1738         # so fail it
1739         case $FSTYP in
1740         btrfs)
1741                 if [ "`echo $SCRATCH_DEV_POOL|wc -w`" -lt 2 ]; then
1742                         _notrun "btrfs and this test needs 2 or more disks in SCRATCH_DEV_POOL"
1743                 fi
1744         ;;
1745         *)
1746                 _notrun "dev_pool is not supported by fstype \"$FSTYP\""
1747         ;;
1748         esac
1749
1750         for i in $SCRATCH_DEV_POOL; do
1751                 if [ "`_is_block_dev $i`" = "" ]; then
1752                         _notrun "this test requires valid block disk $i"
1753                 fi
1754                 if [ "`_is_block_dev $i`" = "`_is_block_dev $TEST_DEV`" ]; then
1755                         _notrun "$i is part of TEST_DEV, this test requires unique disks"
1756                 fi
1757                 if _mount | grep -q $i; then
1758                         if ! $UMOUNT_PROG $i; then
1759                             echo "failed to unmount $i - aborting"
1760                             exit 1
1761                         fi
1762                 fi
1763                 # to help better debug when something fails, we remove
1764                 # traces of previous btrfs FS on the dev.
1765                 dd if=/dev/zero of=$i bs=4096 count=100 > /dev/null 2>&1
1766         done
1767 }
1768
1769 # We will check if the device is virtual (eg: loop device) since it does not
1770 # have the delete entry-point. Otherwise SCSI and USB devices are fine. 
1771 _require_deletable_scratch_dev_pool()
1772 {
1773         local i
1774         local x
1775         for i in $SCRATCH_DEV_POOL; do
1776                 x=`echo $i | cut -d"/" -f 3`
1777                 ls -l /sys/class/block/${x} | grep -q "virtual" 
1778                 if [ $? == "0" ]; then
1779                         _notrun "$i is a virtual device which is not deletable"
1780                 fi
1781         done
1782 }
1783
1784 # We check for btrfs and (optionally) features of the btrfs command
1785 _require_btrfs()
1786 {
1787         cmd=$1
1788         _require_command $BTRFS_UTIL_PROG btrfs
1789         if [ -z "$1" ]; then
1790                 return 1;
1791         fi
1792         $BTRFS_UTIL_PROG $cmd --help >/dev/null 2>&1
1793         [ $? -eq 0 ] || _notrun "$BTRFS_UTIL_PROG too old (must support $cmd)"
1794 }
1795
1796 # Check that fio is present, and it is able to execute given jobfile
1797 _require_fio()
1798 {
1799         job=$1
1800
1801         _require_command $FIO_PROG
1802         if [ -z "$1" ]; then
1803                 return 1;
1804         fi
1805
1806         $FIO_PROG --warnings-fatal --showcmd $job >/dev/null 2>&1
1807         [ $? -eq 0 ] || _notrun "$FIO_PROG too old"
1808 }
1809
1810 # Does freeze work on this fs?
1811 _require_freeze()
1812 {
1813         xfs_freeze -f "$TEST_DIR" >/dev/null 2>&1
1814         result=$? 
1815         xfs_freeze -u "$TEST_DIR" >/dev/null 2>&1
1816         [ $result -eq 0 ] || _notrun "$FSTYP does not support freezing"
1817 }
1818
1819 # arg 1 is dev to remove and is output of the below eg.
1820 # ls -l /sys/class/block/sdd | rev | cut -d "/" -f 3 | rev
1821 _devmgt_remove()
1822 {
1823         echo 1 > /sys/class/scsi_device/${1}/device/delete || _fail "Remove disk failed"
1824 }
1825
1826 # arg 1 is dev to add and is output of the below eg.
1827 # ls -l /sys/class/block/sdd | rev | cut -d "/" -f 3 | rev
1828 _devmgt_add()
1829 {
1830         local h
1831         local tdl
1832         # arg 1 will be in h:t:d:l format now in the h and "t d l" format
1833         h=`echo ${1} | cut -d":" -f 1`
1834         tdl=`echo ${1} | cut -d":" -f 2-|sed 's/:/ /g'`
1835
1836         echo ${tdl} >  /sys/class/scsi_host/host${h}/scan || _fail "Add disk failed"
1837 }
1838
1839 _require_fstrim()
1840 {
1841         if [ -z "$FSTRIM_PROG" ]; then
1842                 _notrun "This test requires fstrim utility."
1843         fi
1844 }
1845
1846 _test_batched_discard()
1847 {
1848         if [ $# -ne 1 ]; then
1849                 echo "Usage: _test_batched_discard mnt_point" 1>&2
1850                 exit 1
1851         fi
1852         _require_fstrim
1853         $FSTRIM_PROG ${1} &>/dev/null
1854 }
1855
1856 _require_dumpe2fs()
1857 {
1858         if [ -z "$DUMPE2FS_PROG" ]; then
1859                 _notrun "This test requires dumpe2fs utility."
1860         fi
1861 }
1862
1863 _create_loop_device()
1864 {
1865         file=$1
1866         dev=`losetup -f --show $file` || _fail "Cannot assign $file to a loop device"
1867         echo $dev
1868 }
1869
1870 _destroy_loop_device()
1871 {
1872         dev=$1
1873         losetup -d $dev || _fail "Cannot destroy loop device $dev"
1874 }
1875
1876 _scale_fsstress_args()
1877 {
1878     args=""
1879     while [ $# -gt 0 ]; do
1880         case "$1" in
1881             -n) args="$args $1 $(($2 * $TIME_FACTOR))"; shift ;;
1882             -p) args="$args $1 $(($2 * $LOAD_FACTOR))"; shift ;;
1883             *) args="$args $1" ;;
1884         esac
1885         shift
1886     done
1887     echo $args
1888 }
1889
1890 run_check()
1891 {
1892         echo "# $@" >> $seq.full 2>&1
1893         "$@" >> $seq.full 2>&1 || _fail "failed: '$@'"
1894 }
1895
1896 ################################################################################
1897
1898 if [ "$iam" != new -a "$iam" != bench ]
1899 then
1900     # make some further configuration checks here
1901
1902     if [ "$TEST_DEV" = ""  ]
1903     then
1904         echo "common.rc: Error: \$TEST_DEV is not set"
1905         exit 1
1906     fi
1907
1908     # if $TEST_DEV is not mounted, mount it now as XFS
1909     if [ -z "`_fs_type $TEST_DEV`" ]
1910     then
1911         # $TEST_DEV is not mounted
1912         if ! _test_mount
1913         then
1914             echo "common.rc: retrying test device mount with external set"
1915             [ "$USE_EXTERNAL" != "yes" ] && export USE_EXTERNAL=yes
1916             if ! _test_mount
1917             then
1918                 echo "common.rc: could not mount $TEST_DEV on $TEST_DIR"
1919                 exit 1
1920             fi
1921         fi
1922     fi
1923
1924     if [ "`_fs_type $TEST_DEV`" != "$FSTYP" ]
1925     then
1926         echo "common.rc: Error: \$TEST_DEV ($TEST_DEV) is not a MOUNTED $FSTYP filesystem"
1927         $DF_PROG $TEST_DEV
1928         exit 1
1929     fi
1930 fi
1931
1932 # make sure this script returns success
1933 /bin/true