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 dd()
  24 {
  25    if [ "$HOSTOS" == "Linux" ]
  26    then
  27         command dd --help | grep noxfer > /dev/null 2>&1
  28
  29         if [ "$?" -eq 0 ]
  30             then
  31                 command dd status=noxfer $@
  32             else
  33                 command dd $@
  34         fi
  35    else
  36         command dd $@
  37    fi
  38 }
  39
  40 # ls -l w/ selinux sometimes puts a dot at the end:
  41 # -rwxrw-r--. id1 id2 file1
  42
  43 _ls_l()
  44 {
  45         ls -l $* | sed "s/\(^[-rwxdlbcpsStT]*\)\. /\1 /"
  46 }
  47
  48 _mount_opts()
  49 {
  50     # SELinux adds extra xattrs which can mess up our expected output.
  51     # So, mount with a context, and they won't be created
  52     # nfs_t is a "liberal" context so we can use it.
  53     if [ -x /usr/sbin/selinuxenabled ] && /usr/sbin/selinuxenabled; then
  54         SELINUX_MOUNT_OPTIONS="-o context=system_u:object_r:nfs_t:s0"
  55     fi
  56
  57     case $FSTYP in
  58     xfs)
  59         export SELINUX_MOUNT_OPTIONS
  60         export MOUNT_OPTIONS=$XFS_MOUNT_OPTIONS
  61         ;;
  62     udf)
  63         export MOUNT_OPTIONS=$UDF_MOUNT_OPTIONS
  64         ;;
  65     nfs)
  66         export MOUNT_OPTIONS=$NFS_MOUNT_OPTIONS
  67         ;;
  68     ext2|ext3|ext4)
  69         # acls & xattrs aren't turned on by default on ext$FOO
  70         export MOUNT_OPTIONS="-o acl,user_xattr $EXT_MOUNT_OPTIONS"
  71         ;;
  72     reiserfs)
  73         # acls & xattrs aren't turned on by default on reiserfs
  74         export MOUNT_OPTIONS="-o acl,user_xattr $REISERFS_MOUNT_OPTIONS"
  75         ;;
  76     gfs2)
  77         # acls aren't turned on by default on gfs2
  78         export MOUNT_OPTIONS="-o acl $GFS2_MOUNT_OPTIONS"
  79         ;;
  80     *)
  81         ;;
  82     esac
  83 }
  84
  85 _mkfs_opts()
  86 {
  87     case $FSTYP in
  88     xfs)
  89         export MKFS_OPTIONS=$XFS_MKFS_OPTIONS
  90         ;;
  91     udf)
  92         [ ! -z "$udf_fsize" ] && \
  93             UDF_MKFS_OPTIONS="$UDF_MKFS_OPTIONS -s $udf_fsize"
  94         export MKFS_OPTIONS=$UDF_MKFS_OPTIONS
  95         ;;
  96     nfs)
  97         export MKFS_OPTIONS=$NFS_MKFS_OPTIONS
  98         ;;
  99     reiserfs)
 100         export MKFS_OPTIONS="$REISERFS_MKFS_OPTIONS -q"
 101         ;;
 102     gfs2)
 103         export MKFS_OPTIONS="$GFS2_MKFS_OPTIONS -O -p lock_nolock"
 104         ;;
 105     *)
 106         ;;
 107     esac
 108 }
 109
 110 _fsck_opts()
 111 {
 112     case $FSTYP in
 113     ext2|ext3|ext4)
 114         export FSCK_OPTIONS="-nf"
 115         ;;
 116     reiserfs)
 117         export FSCK_OPTIONS="--yes"
 118         ;;
 119     *)
 120         export FSCK_OPTIONS="-n"
 121         ;;
 122     esac
 123 }
 124
 125 [ -z "$FSTYP" ] && FSTYP=xfs
 126 [ -z "$MOUNT_OPTIONS" ] && _mount_opts
 127 [ -z "$MKFS_OPTIONS" ] && _mkfs_opts
 128 [ -z "$FSCK_OPTIONS" ] && _fsck_opts
 129
 130
 131 # we need common.config
 132 if [ "$iam" != "check" ]
 133 then
 134     if ! . ./common.config
 135         then
 136         echo "$iam: failed to source common.config"
 137         exit 1
 138     fi
 139 fi
 140
 141 # make sure we have a standard umask
 142 umask 022
 143
 144 _mount()
 145 {
 146     $MOUNT_PROG `_mount_ops_filter $*`
 147 }
 148
 149 _scratch_options()
 150 {
 151     type=$1
 152     SCRATCH_OPTIONS=""
 153
 154     if [ "$FSTYP" != "xfs" ]; then
 155         return
 156     fi
 157
 158     case $type in
 159     mkfs)
 160         [ "$HOSTOS" != "IRIX" ] && SCRATCH_OPTIONS="$SCRATCH_OPTIONS -f"
 161         rt_opt="-r"
 162         log_opt="-l"
 163         ;;
 164     mount)
 165         rt_opt="-o"
 166         log_opt="-o"
 167         ;;
 168     esac
 169     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
 170         SCRATCH_OPTIONS="$SCRATCH_OPTIONS ${rt_opt}rtdev=$SCRATCH_RTDEV"
 171     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 172         SCRATCH_OPTIONS="$SCRATCH_OPTIONS ${log_opt}logdev=$SCRATCH_LOGDEV"
 173 }
 174
 175 _test_options()
 176 {
 177     type=$1
 178     TEST_OPTIONS=""
 179
 180     if [ "$FSTYP" != "xfs" ]; then
 181         return
 182     fi
 183
 184     case $type in
 185     mkfs)
 186         rt_opt="-r"
 187         log_opt="-l"
 188         ;;
 189     mount)
 190         rt_opt="-o"
 191         log_opt="-o"
 192         ;;
 193     esac
 194     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
 195         TEST_OPTIONS="$TEST_OPTIONS ${rt_opt}rtdev=$TEST_RTDEV"
 196     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
 197         TEST_OPTIONS="$TEST_OPTIONS ${log_opt}logdev=$TEST_LOGDEV"
 198 }
 199
 200 _mount_ops_filter()
 201 {
 202     params="$*"
 203
 204     #get mount point to handle dmapi mtpt option correctly
 205     let last_index=$#-1
 206     [ $last_index -gt 0 ] && shift $last_index
 207     FS_ESCAPED=$1
 208
 209     # irix is fussy about how it is fed its mount options
 210     # - multiple -o's are not allowed
 211     # - no spaces between comma delimitered options
 212     # the sed script replaces all -o's (except the first) with a comma
 213     # not required for linux, but won't hurt
 214
 215     echo $params | sed -e 's/[[:space:]]*-o[[:space:]]*/UnIqUe/1; s/[[:space:]]*-o[[:space:]]*/,/g; s/UnIqUe/ -o /1' \
 216         | sed -e 's/dmapi/dmi/' \
 217         | $PERL_PROG -ne "s#mtpt=[^,|^\n|^\s]*#mtpt=$FS_ESCAPED\1\2#; print;"
 218
 219 }
 220
 221 _scratch_mount_options()
 222 {
 223     _scratch_options mount
 224
 225     echo $SCRATCH_OPTIONS $MOUNT_OPTIONS $SELINUX_MOUNT_OPTIONS $* $SCRATCH_DEV $SCRATCH_MNT
 226 }
 227
 228 _scratch_mount()
 229 {
 230     _mount -t $FSTYP `_scratch_mount_options $*`
 231 }
 232
 233 _scratch_unmount()
 234 {
 235     $UMOUNT_PROG $SCRATCH_DEV
 236 }
 237
 238 _scratch_remount()
 239 {
 240     _scratch_unmount
 241     _scratch_mount
 242 }
 243
 244 _test_mount()
 245 {
 246     _test_options mount
 247     _mount -t $FSTYP $TEST_OPTIONS $TEST_FS_MOUNT_OPTS $SELINUX_MOUNT_OPTIONS $* $TEST_DEV $TEST_DIR
 248 }
 249
 250 _scratch_mkfs_options()
 251 {
 252     _scratch_options mkfs
 253     echo $SCRATCH_OPTIONS $MKFS_OPTIONS $* $SCRATCH_DEV
 254 }
 255
 256 _scratch_mkfs_xfs()
 257 {
 258     # extra mkfs options can be added by tests
 259     local extra_mkfs_options=$*
 260
 261     local tmp_dir=/tmp/
 262
 263     _scratch_options mkfs
 264
 265     # save mkfs output in case conflict means we need to run again.
 266     # only the output for the mkfs that applies should be shown
 267     $MKFS_XFS_PROG $SCRATCH_OPTIONS $MKFS_OPTIONS $extra_mkfs_options $SCRATCH_DEV \
 268         2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
 269     local mkfs_status=$?
 270
 271     # a mkfs failure may be caused by conflicts between
 272     # $MKFS_OPTIONS and $extra_mkfs_options
 273
 274     if [ $mkfs_status -ne 0 -a ! -z "$extra_mkfs_options" ]; then
 275         echo "** mkfs failed with extra mkfs options added to \"$MKFS_OPTIONS\" by test $seq **" \
 276             >>$here/$seq.full
 277         echo "** attempting to mkfs using only test $seq options: $extra_mkfs_options **" \
 278             >>$here/$seq.full
 279         # running mkfs again. overwrite previous mkfs output files
 280         $MKFS_XFS_PROG $SCRATCH_OPTIONS $extra_mkfs_options $SCRATCH_DEV \
 281             2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
 282         mkfs_status=$?
 283     fi
 284
 285     # output stored mkfs output
 286     cat $tmp_dir.mkfserr >&2
 287     cat $tmp_dir.mkfsstd
 288     rm -f $tmp_dir.mkfserr $tmp_dir.mkfsstd
 289
 290     if [ "$USE_BIG_LOOPFS" = yes ]; then
 291         [ -z "$RETAIN_AG_BYTES" ] && RETAIN_AG_BYTES=0
 292         ./tools/ag-wipe -q -r $RETAIN_AG_BYTES $SCRATCH_DEV
 293     fi
 294
 295     return $mkfs_status
 296 }
 297
 298 _scratch_mkfs()
 299 {
 300     case $FSTYP in
 301     xfs)
 302         _scratch_mkfs_xfs $*
 303         ;;
 304     nfs*)
 305         # do nothing for nfs
 306         ;;
 307     udf)
 308         $MKFS_UDF_PROG $MKFS_OPTIONS $* $SCRATCH_DEV > /dev/null
 309         ;;
 310     *)
 311         /sbin/mkfs -t $FSTYP -- $MKFS_OPTIONS $* $SCRATCH_DEV
 312         ;;
 313     esac
 314 }
 315
 316 # Create fs of certain size on scratch device
 317 # _scratch_mkfs_sized <size in bytes> [optional blocksize]
 318 _scratch_mkfs_sized()
 319 {
 320     fssize=$1
 321     blocksize=$2
 322     [ -z "$blocksize" ] && blocksize=4096
 323     blocks=`expr $fssize / $blocksize`
 324
 325     case $FSTYP in
 326     xfs)
 327         _scratch_mkfs_xfs -d size=$fssize -b size=$blocksize
 328         ;;
 329     ext2|ext3|ext4)
 330         /sbin/mkfs.$FSTYP -b $blocksize $SCRATCH_DEV $blocks
 331         ;;
 332     *)
 333         _notrun "Filesystem $FSTYP not supported in _scratch_mkfs_sized"
 334         ;;
 335     esac
 336 }
 337
 338 # Emulate an N-data-disk stripe w/ various stripe units
 339 # _scratch_mkfs_geom <sunit bytes> <swidth multiplier> [optional blocksize]
 340 _scratch_mkfs_geom()
 341 {
 342     sunit_bytes=$1
 343     swidth_mult=$2
 344     blocksize=$3
 345     [ -z "$blocksize" ] && blocksize=4096
 346
 347     let sunit_blocks=$sunit_bytes/$blocksize
 348     let swidth_blocks=$sunit_blocks*$swidth_mult
 349
 350     case $FSTYP in
 351     xfs)
 352         MKFS_OPTIONS="-b size=$blocksize, -d su=$sunit_bytes,sw=$swidth_mult"
 353         ;;
 354     ext4)
 355         MKFS_OPTIONS="-b $blocksize -E stride=$sunit_blocks,stripe_width=$swidth_blocks"
 356         ;;
 357     *)
 358         _notrun "can't mkfs $FSTYP with geometry"
 359         ;;
 360     esac
 361     _scratch_mkfs
 362 }
 363
 364 _scratch_resvblks()
 365 {
 366         case $FSTYP in
 367         xfs)
 368                 xfs_io -x -c "resblks $1" $SCRATCH_MNT
 369                 ;;
 370         *)
 371                 ;;
 372         esac
 373 }
 374
 375 _scratch_xfs_db_options()
 376 {
 377     SCRATCH_OPTIONS=""
 378     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 379         SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
 380     echo $SCRATCH_OPTIONS $* $SCRATCH_DEV
 381 }
 382
 383 _scratch_xfs_logprint()
 384 {
 385     SCRATCH_OPTIONS=""
 386     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 387         SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
 388     $XFS_LOGPRINT_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
 389 }
 390
 391 _scratch_xfs_check()
 392 {
 393     SCRATCH_OPTIONS=""
 394     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 395         SCRATCH_OPTIONS="-l $SCRATCH_LOGDEV"
 396     $XFS_CHECK_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
 397 }
 398
 399 _scratch_xfs_repair()
 400 {
 401     SCRATCH_OPTIONS=""
 402     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 403         SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
 404     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
 405         SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -r$SCRATCH_RTDEV"
 406     [ "$USE_BIG_LOOPFS" = yes ] && SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -t"
 407     $XFS_REPAIR_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
 408 }
 409
 410 _get_pids_by_name()
 411 {
 412     if [ $# -ne 1 ]
 413     then
 414         echo "Usage: _get_pids_by_name process-name" 1>&2
 415         exit 1
 416     fi
 417
 418     # Algorithm ... all ps(1) variants have a time of the form MM:SS or
 419     # HH:MM:SS before the psargs field, use this as the search anchor.
 420     #
 421     # Matches with $1 (process-name) occur if the first psarg is $1
 422     # or ends in /$1 ... the matching uses sed's regular expressions,
 423     # so passing a regex into $1 will work.
 424
 425     ps $PS_ALL_FLAGS \
 426     | sed -n \
 427         -e 's/$/ /' \
 428         -e 's/[         ][      ]*/ /g' \
 429         -e 's/^ //' \
 430         -e 's/^[^ ]* //' \
 431         -e "/[0-9]:[0-9][0-9]  *[^ ]*\/$1 /s/ .*//p" \
 432         -e "/[0-9]:[0-9][0-9]  *$1 /s/ .*//p"
 433 }
 434
 435 # fix malloc libs output
 436 #
 437 _fix_malloc()
 438 {
 439     # filter out the Electric Fence notice
 440     $PERL_PROG -e '
 441         while (<>) {
 442             if (defined $o && /^\s+Electric Fence/) {
 443                 chomp($o);
 444                 print "$o";
 445                 undef $o;
 446                 next;
 447             }
 448             print $o if (defined $o);
 449
 450             $o=$_;
 451         }
 452         print $o if (defined $o);
 453     '
 454 }
 455
 456 # check if run as root
 457 #
 458 _need_to_be_root()
 459 {
 460     id=`id | $SED_PROG -e 's/(.*//' -e 's/.*=//'`
 461     if [ "$id" -ne 0 ]
 462     then
 463         echo "Arrgh ... you need to be root (not uid=$id) to run this test"
 464         exit 1
 465     fi
 466 }
 467
 468
 469 #
 470 # _df_device : get an IRIX style df line for a given device
 471 #
 472 #       - returns "" if not mounted
 473 #       - returns fs type in field two (ala IRIX)
 474 #       - joins line together if split by fancy df formatting
 475 #       - strips header etc
 476 #
 477
 478 _df_device()
 479 {
 480     if [ $# -ne 1 ]
 481     then
 482         echo "Usage: _df_device device" 1>&2
 483         exit 1
 484     fi
 485
 486     $DF_PROG 2>/dev/null | $AWK_PROG -v what=$1 '
 487         match($1,what) && NF==1 {
 488             v=$1
 489             getline
 490             print v, $0
 491             exit
 492         }
 493         match($1,what) {
 494             print
 495             exit
 496         }
 497     '
 498 }
 499
 500 #
 501 # _df_dir : get an IRIX style df line for device where a directory resides
 502 #
 503 #       - returns fs type in field two (ala IRIX)
 504 #       - joins line together if split by fancy df formatting
 505 #       - strips header etc
 506 #
 507
 508 _df_dir()
 509 {
 510     if [ $# -ne 1 ]
 511     then
 512         echo "Usage: _df_dir device" 1>&2
 513         exit 1
 514     fi
 515
 516     $DF_PROG $1 2>/dev/null | $AWK_PROG -v what=$1 '
 517         NR == 2 && NF==1 {
 518             v=$1
 519             getline
 520             print v, $0;
 521             exit 0
 522         }
 523         NR == 2 {
 524             print;
 525             exit 0
 526         }
 527         {}
 528     '
 529     # otherwise, nada
 530 }
 531
 532 # return percentage used disk space for mounted device
 533
 534 _used()
 535 {
 536     if [ $# -ne 1 ]
 537     then
 538         echo "Usage: _used device" 1>&2
 539         exit 1
 540     fi
 541
 542     _df_device $1 | $AWK_PROG '{ sub("%", "") ; print $6 }'
 543 }
 544
 545 # return the FS type of a mounted device
 546 #
 547 _fs_type()
 548 {
 549     if [ $# -ne 1 ]
 550     then
 551         echo "Usage: _fs_type device" 1>&2
 552         exit 1
 553     fi
 554
 555     _df_device $1 | $AWK_PROG '{ print $2 }'
 556 }
 557
 558 # return the FS mount options of a mounted device
 559 #
 560 # should write a version which just parses the output of mount for IRIX
 561 # compatibility, but since this isn't used at all, at the moment I'll leave
 562 # this for now
 563 #
 564 _fs_options()
 565 {
 566     if [ $# -ne 1 ]
 567     then
 568         echo "Usage: _fs_options device" 1>&2
 569         exit 1
 570     fi
 571
 572     $AWK_PROG -v dev=$1 '
 573         match($1,dev) { print $4 }
 574     ' </proc/mounts
 575 }
 576
 577 # returns device number if a file is a block device
 578 #
 579 _is_block_dev()
 580 {
 581     if [ $# -ne 1 ]
 582     then
 583         echo "Usage: _is_block_dev dev" 1>&2
 584         exit 1
 585     fi
 586
 587     [ -b $1 ] && src/lstat64 $1 | $AWK_PROG '/Device type:/ { print $9 }'
 588 }
 589
 590 # Do a command, log it to $seq.full, optionally test return status
 591 # and die if command fails. If called with one argument _do executes the
 592 # command, logs it, and returns its exit status. With two arguments _do
 593 # first prints the message passed in the first argument, and then "done"
 594 # or "fail" depending on the return status of the command passed in the
 595 # second argument. If the command fails and the variable _do_die_on_error
 596 # is set to "always" or the two argument form is used and _do_die_on_error
 597 # is set to "message_only" _do will print an error message to
 598 # $seq.out and exit.
 599
 600 _do()
 601 {
 602     if [ $# -eq 1 ]; then
 603         _cmd=$1
 604     elif [ $# -eq 2 ]; then
 605         _note=$1
 606         _cmd=$2
 607         echo -n "$_note... "
 608     else
 609         echo "Usage: _do [note] cmd" 1>&2
 610         status=1; exit
 611     fi
 612
 613     (eval "echo '---' \"$_cmd\"") >>$here/$seq.full
 614     (eval "$_cmd") >$tmp._out 2>&1; ret=$?
 615     cat $tmp._out | _fix_malloc >>$here/$seq.full
 616     if [ $# -eq 2 ]; then
 617         if [ $ret -eq 0 ]; then
 618             echo "done"
 619         else
 620             echo "fail"
 621         fi
 622     fi
 623     if [ $ret -ne 0  ] \
 624         && [ "$_do_die_on_error" = "always" \
 625             -o \( $# -eq 2 -a "$_do_die_on_error" = "message_only" \) ]
 626     then
 627         [ $# -ne 2 ] && echo
 628         eval "echo \"$_cmd\" failed \(returned $ret\): see $seq.full"
 629         status=1; exit
 630     fi
 631
 632     return $ret
 633 }
 634
 635 # bail out, setting up .notrun file
 636 #
 637 _notrun()
 638 {
 639     echo "$*" >$seq.notrun
 640     echo "$seq not run: $*"
 641     status=0
 642     exit
 643 }
 644
 645 # just plain bail out
 646 #
 647 _fail()
 648 {
 649     echo "$*" | tee -a $here/$seq.full
 650     echo "(see $seq.full for details)"
 651     status=1
 652     exit 1
 653 }
 654
 655 # tests whether $FSTYP is one of the supported filesystems for a test
 656 #
 657 _supported_fs()
 658 {
 659     for f
 660     do
 661         if [ "$f" = "$FSTYP" -o "$f" = "generic" ]
 662         then
 663             return
 664         fi
 665     done
 666
 667     _notrun "not suitable for this filesystem type: $FSTYP"
 668 }
 669
 670 # tests whether $FSTYP is one of the supported OSes for a test
 671 #
 672 _supported_os()
 673 {
 674     for h
 675     do
 676         if [ "$h" = "$HOSTOS" ]
 677         then
 678             return
 679         fi
 680     done
 681
 682     _notrun "not suitable for this OS: $HOSTOS"
 683 }
 684
 685 # this test needs a scratch partition - check we're ok & unmount it
 686 #
 687 _require_scratch()
 688 {
 689     case "$FSTYP" in
 690         nfs*)
 691                  echo $SCRATCH_DEV | grep -q ":" > /dev/null 2>&1
 692                  if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]
 693                  then
 694                      _notrun "this test requires a valid \$SCRATCH_DEV"
 695                  fi
 696                  ;;
 697         *)
 698                  if [ -z "$SCRATCH_DEV" -o "`_is_block_dev $SCRATCH_DEV`" = "" ]
 699                  then
 700                      _notrun "this test requires a valid \$SCRATCH_DEV"
 701                  fi
 702                  if [ "`_is_block_dev $SCRATCH_DEV`" = "`_is_block_dev $TEST_DEV`" ]
 703                  then
 704                      _notrun "this test requires a valid \$SCRATCH_DEV"
 705                  fi
 706                 if [ ! -d "$SCRATCH_MNT" ]
 707                 then
 708                      _notrun "this test requires a valid \$SCRATCH_MNT"
 709                 fi
 710                  ;;
 711     esac
 712
 713     # mounted?
 714     if _mount | grep -q $SCRATCH_DEV
 715     then
 716         # if it's mounted, make sure its on $SCRATCH_MNT
 717         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
 718         then
 719             echo "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
 720             exit 1
 721         fi
 722         # and then unmount it
 723         if ! $UMOUNT_PROG $SCRATCH_DEV
 724         then
 725             echo "failed to unmount $SCRATCH_DEV"
 726             exit 1
 727         fi
 728     fi
 729 }
 730
 731 # this test needs a logdev
 732 #
 733 _require_logdev()
 734 {
 735     [ -z "$SCRATCH_LOGDEV" -o ! -b "$SCRATCH_LOGDEV" ] && \
 736         _notrun "This test requires a valid \$SCRATCH_LOGDEV"
 737     [ "$USE_EXTERNAL" != yes ] && \
 738         _notrun "This test requires USE_EXTERNAL to be enabled"
 739
 740     # ensure its not mounted
 741     $UMOUNT_PROG $SCRATCH_LOGDEV 2>/dev/null
 742 }
 743
 744 # this test requires loopback device support
 745 #
 746 _require_loop()
 747 {
 748     if [ "$HOSTOS" != "Linux" ]
 749     then
 750         _notrun "This test requires linux for loopback device support"
 751     fi
 752
 753     modprobe loop >/dev/null 2>&1
 754     if grep loop /proc/devices >/dev/null 2>&1
 755     then
 756         :
 757     else
 758         _notrun "This test requires loopback device support"
 759     fi
 760 }
 761
 762 # this test requires that (large) loopback device files are not in use
 763 #
 764 _require_nobigloopfs()
 765 {
 766     [ "$USE_BIG_LOOPFS" = yes ] && \
 767         _notrun "Large filesystem testing in progress, skipped this test"
 768 }
 769
 770 # this test requires that a realtime subvolume is in use, and
 771 # that the kernel supports realtime as well.
 772 #
 773 _require_realtime()
 774 {
 775     [ "$USE_EXTERNAL" = yes ] || \
 776         _notrun "External volumes not in use, skipped this test"
 777     [ "$SCRATCH_RTDEV" = "" ] && \
 778         _notrun "Realtime device required, skipped this test"
 779 }
 780
 781 # this test requires that a specified command (executable) exists
 782 #
 783 _require_command()
 784 {
 785     [ -x "$1" ] || _notrun "$1 utility required, skipped this test"
 786 }
 787
 788 # this test requires that external log/realtime devices are not in use
 789 #
 790 _require_nonexternal()
 791 {
 792     [ "$USE_EXTERNAL" = yes ] && \
 793         _notrun "External device testing in progress, skipped this test"
 794 }
 795
 796 # indicate whether YP/NIS is active or not
 797 #
 798 _yp_active()
 799 {
 800         local dn
 801         dn=$(domainname 2>/dev/null)
 802         test -n "${dn}" -a "${dn}" != "(none)"
 803         echo $?
 804 }
 805
 806 # cat the password file
 807 #
 808 _cat_passwd()
 809 {
 810         [ $(_yp_active) -eq 0 ] && ypcat passwd
 811         cat /etc/passwd
 812 }
 813
 814 # cat the group file
 815 #
 816 _cat_group()
 817 {
 818         [ $(_yp_active) -eq 0 ] && ypcat group
 819         cat /etc/group
 820 }
 821
 822 # check for the fsgqa user on the machine
 823 #
 824 _require_user()
 825 {
 826     qa_user=fsgqa
 827     _cat_passwd | grep -q $qa_user
 828     [ "$?" == "0" ] || _notrun "$qa_user user not defined."
 829 }
 830
 831 # check that xfs_io, glibc, kernel, and filesystem all (!) support
 832 # fallocate
 833 #
 834 _require_xfs_io_falloc()
 835 {
 836         testfile=$TEST_DIR/$$.falloc
 837         testio=`$XFS_IO_PROG -F -f -c "falloc 0 1m" $testfile 2>&1`
 838         rm -f $testfile 2>&1 > /dev/null
 839         echo $testio | grep -q "not found" && \
 840                 _notrun "xfs_io fallocate support is missing"
 841         echo $testio | grep -q "Operation not supported" && \
 842                 _notrun "xfs_io fallocate command failed (old kernel/wrong fs?)"
 843 }
 844
 845 # Check that a fs has enough free space (in 1024b blocks)
 846 #
 847 _require_fs_space()
 848 {
 849         MNT=$1
 850         BLOCKS=$2       # in units of 1024
 851         let GB=$BLOCKS/1024/1024
 852
 853         FREE_BLOCKS=`df -klP $MNT | grep -v Filesystem | awk '{print $4}'`
 854         [ $FREE_BLOCKS -lt $BLOCKS ] && \
 855                 _notrun "This test requires at least ${GB}GB free on $MNT to run"
 856 }
 857
 858 # check that a FS on a device is mounted
 859 # if so, return mount point
 860 #
 861 _is_mounted()
 862 {
 863     if [ $# -ne 1 ]
 864     then
 865         echo "Usage: _is_mounted device" 1>&2
 866         exit 1
 867     fi
 868
 869     device=$1
 870
 871     if _mount | grep "$device " | $AWK_PROG -v pattern="type $FSTYP" '
 872         pattern        { print $3 ; exit 0 }
 873         END            { exit 1 }
 874     '
 875     then
 876         echo "_is_mounted: $device is not a mounted $FSTYP FS"
 877         exit 1
 878     fi
 879 }
 880
 881 # remount a FS to a new mode (ro or rw)
 882 #
 883 _remount()
 884 {
 885     if [ $# -ne 2 ]
 886     then
 887         echo "Usage: _remount device ro/rw" 1>&2
 888         exit 1
 889     fi
 890     device=$1
 891     mode=$2
 892
 893     if ! mount -o remount,$mode $device
 894     then
 895         echo "_remount: failed to remount filesystem on $device as $mode"
 896         exit 1
 897     fi
 898 }
 899
 900 # Run the appropriate repair/check on a filesystem
 901 #
 902 # if the filesystem is mounted, it's either remounted ro before being
 903 # checked or it's unmounted and then remounted
 904 #
 905
 906 # If set, we remount ro instead of unmounting for fsck
 907 USE_REMOUNT=0
 908
 909 _umount_or_remount_ro()
 910 {
 911     if [ $# -ne 1 ]
 912     then
 913         echo "Usage: _umount_or_remount_ro <device>" 1>&2
 914         exit 1
 915     fi
 916
 917     device=$1
 918     mountpoint=`_is_mounted $device`
 919
 920     if [ $USE_REMOUNT -eq 0 ]; then
 921         $UMOUNT_PROG $device
 922     else
 923         _remount $device ro
 924     fi
 925     echo "$mountpoint"
 926 }
 927
 928 _mount_or_remount_rw()
 929 {
 930     if [ $# -ne 3 ]
 931     then
 932         echo "Usage: _mount_or_remount_rw <opts> <device> <mountpoint>" 1>&2
 933         exit 1
 934     fi
 935     mount_opts=$1
 936     device=$2
 937     mountpoint=$3
 938
 939     if [ $USE_REMOUNT -eq 0 ]
 940     then
 941         if ! _mount -t $FSTYP $mount_opts $device $mountpoint
 942         then
 943             echo "!!! failed to remount $device on $mountpoint"
 944             return 0 # ok=0
 945         fi
 946     else
 947         _remount $device rw
 948     fi
 949
 950     return 1 # ok=1
 951 }
 952
 953 # Check a generic filesystem in no-op mode; this assumes that the
 954 # underlying fsck program accepts "-n" for a no-op (check-only) run,
 955 # and that it will still return an errno for corruption in this mode.
 956 #
 957 # Filesystems which don't support this will need to define their
 958 # own check routine.
 959 #
 960 _check_generic_filesystem()
 961 {
 962     device=$1
 963
 964     # If type is set, we're mounted
 965     type=`_fs_type $device`
 966     ok=1
 967
 968     if [ "$type" = "$FSTYP" ]
 969     then
 970         # mounted ...
 971         mountpoint=`_umount_or_remount_ro $device`
 972     fi
 973
 974     fsck -t $FSTYP $FSCK_OPTIONS $device >$tmp.fsck 2>&1
 975     if [ $? -ne 0 ]
 976     then
 977         echo "_check_generic_filesystem: filesystem on $device is inconsistent (see $seq.full)"
 978
 979         echo "_check_generic filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
 980         echo "*** fsck.$FSTYP output ***"                     >>$here/$seq.full
 981         cat $tmp.fsck                                         >>$here/$seq.full
 982         echo "*** end fsck.$FSTYP output"                     >>$here/$seq.full
 983
 984         ok=0
 985     fi
 986     rm -f $tmp.fsck
 987
 988     if [ $ok -eq 0 ]
 989     then
 990         echo "*** mount output ***"                             >>$here/$seq.full
 991         _mount                                                  >>$here/$seq.full
 992         echo "*** end mount output"                             >>$here/$seq.full
 993     elif [ "$type" = "$FSTYP" ]
 994     then
 995         # was mounted ...
 996         _mount_or_remount_rw "$MOUNT_OPTIONS" $device $mountpoint
 997         ok=$?
 998     fi
 999
1000     if [ $ok -eq 0 ]; then
1001         status=1
1002         exit 1
1003     fi
1004
1005     return 0
1006 }
1007
1008 # run xfs_check and friends on a FS.
1009
1010 _check_xfs_filesystem()
1011 {
1012     if [ $# -ne 3 ]
1013     then
1014         echo "Usage: _check_xfs_filesystem device <logdev>|none <rtdev>|none" 1>&2
1015         exit 1
1016     fi
1017
1018     extra_mount_options=""
1019     device=$1
1020     if [ "$2" != "none" ]; then
1021         extra_log_options="-l$2"
1022         extra_mount_options="-ologdev=$2"
1023     fi
1024
1025     if [ "$3" != "none" ]; then
1026         extra_rt_options="-r$3"
1027         extra_mount_options=$extra_mount_options" -ortdev=$3"
1028     fi
1029     extra_mount_options=$extra_mount_options" $MOUNT_OPTIONS"
1030
1031     [ "$FSTYP" != xfs ] && return 0
1032     testoption=""
1033     [ "$USE_BIG_LOOPFS" = yes ] && testoption=-t
1034
1035     type=`_fs_type $device`
1036     ok=1
1037
1038     if [ "$type" = "xfs" ]
1039     then
1040         # mounted ...
1041         mountpoint=`_umount_or_remount_ro $device`
1042     fi
1043
1044     $XFS_LOGPRINT_PROG -t $extra_log_options $device 2>&1 \
1045                 | tee $tmp.logprint | grep -q "<CLEAN>"
1046     if [ $? -ne 0 -a "$HOSTOS" = "Linux" ]
1047     then
1048         echo "_check_xfs_filesystem: filesystem on $device has dirty log (see $seq.full)"
1049
1050         echo "_check_xfs_filesystem: filesystem on $device has dirty log"   >>$here/$seq.full
1051         echo "*** xfs_logprint -t output ***"                   >>$here/$seq.full
1052         cat $tmp.logprint                                       >>$here/$seq.full
1053         echo "*** end xfs_logprint output"                      >>$here/$seq.full
1054
1055         ok=0
1056     fi
1057
1058     $XFS_CHECK_PROG $testoption $extra_log_options $device 2>&1 |\
1059          _fix_malloc >$tmp.fs_check
1060     if [ -s $tmp.fs_check ]
1061     then
1062         echo "_check_xfs_filesystem: filesystem on $device is inconsistent (c) (see $seq.full)"
1063
1064         echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1065         echo "*** xfs_check output ***"                         >>$here/$seq.full
1066         cat $tmp.fs_check                                       >>$here/$seq.full
1067         echo "*** end xfs_check output"                         >>$here/$seq.full
1068
1069         ok=0
1070     fi
1071     # repair doesn't scale massively at this stage, optionally skip it for now
1072     [ "$USE_BIG_LOOPFS" = yes ] || \
1073     $XFS_REPAIR_PROG -n $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
1074     if [ $? -ne 0 ]
1075     then
1076         echo "_check_xfs_filesystem: filesystem on $device is inconsistent (r) (see $seq.full)"
1077
1078         echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1079         echo "*** xfs_repair -n output ***"                     >>$here/$seq.full
1080         cat $tmp.repair | _fix_malloc                           >>$here/$seq.full
1081         echo "*** end xfs_repair output"                        >>$here/$seq.full
1082
1083         ok=0
1084     fi
1085     rm -f $tmp.fs_check $tmp.logprint $tmp.repair
1086
1087     if [ $ok -eq 0 ]
1088     then
1089         echo "*** mount output ***"                             >>$here/$seq.full
1090         _mount                                                  >>$here/$seq.full
1091         echo "*** end mount output"                             >>$here/$seq.full
1092     elif [ "$type" = "xfs" ]
1093     then
1094         _mount_or_remount_rw "$extra_mount_options" $device $mountpoint
1095     fi
1096
1097     if [ $ok -eq 0 ]; then
1098         status=1
1099         exit 1
1100     fi
1101
1102     return 0
1103 }
1104
1105 # Filter the knowen errors the UDF Verifier reports.
1106 _udf_test_known_error_filter()
1107 {
1108         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."
1109
1110 }
1111
1112 _check_udf_filesystem()
1113 {
1114     [ "$DISABLE_UDF_TEST" == "1" ] && return
1115
1116     if [ $# -ne 1 -a $# -ne 2 ]
1117     then
1118         echo "Usage: _check_udf_filesystem device [last_block]" 1>&2
1119         exit 1
1120     fi
1121
1122     if [ ! -x $here/src/udf_test ]
1123     then
1124         echo "udf_test not installed, please download and build the Philips"
1125         echo "UDF Verification Software from http://www.extra.research.philips.com/udf/."
1126         echo "Then copy the udf_test binary to $here/src/."
1127         echo "If you do not wish to run udf_test then set environment variable DISABLE_UDF_TEST"
1128         echo "to 1."
1129         return
1130     fi
1131
1132     device=$1
1133     if [ $# -eq 2 ];
1134     then
1135         LAST_BLOCK=`expr \( $2 - 1 \)`
1136         OPT_ARG="-lastvalidblock $LAST_BLOCK"
1137     fi
1138
1139     rm -f $seq.checkfs
1140     sleep 1 # Due to a problem with time stamps in udf_test
1141     $here/src/udf_test $OPT_ARG $device | tee $here/$seq.checkfs | egrep "Error|Warning" | \
1142         _udf_test_known_error_filter | \
1143         egrep -iv "Error count:.*[0-9]+.*total occurrences:.*[0-9]+|Warning count:.*[0-9]+.*total occurrences:.*[0-9]+" | \
1144         sed "s/^.*$/Warning UDF Verifier reported errors see $seq.checkfs./g"
1145
1146 }
1147
1148 _check_xfs_test_fs()
1149 {
1150     TEST_LOG="none"
1151     TEST_RT="none"
1152     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
1153         TEST_LOG="$TEST_LOGDEV"
1154
1155     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
1156         TEST_RT="$TEST_RTDEV"
1157
1158     _check_xfs_filesystem $TEST_DEV $TEST_LOG $TEST_RT
1159
1160     # check for ipath consistency
1161     if $XFS_GROWFS_PROG -n $TEST_DIR | grep -q 'inode-paths=1'; then
1162         # errors go to stderr
1163         xfs_check_ipaths $TEST_DIR >/dev/null
1164         xfs_repair_ipaths -n $TEST_DIR >/dev/null
1165     fi
1166 }
1167
1168 _check_test_fs()
1169 {
1170     case $FSTYP in
1171     xfs)
1172         _check_xfs_test_fs
1173         ;;
1174     nfs)
1175         # no way to check consistency for nfs
1176         ;;
1177     udf)
1178         # do nothing for now
1179         ;;
1180     *)
1181         _check_generic_filesystem $TEST_DEV
1182         ;;
1183     esac
1184 }
1185
1186 _check_scratch_fs()
1187 {
1188     case $FSTYP in
1189     xfs)
1190         SCRATCH_LOG="none"
1191         SCRATCH_RT="none"
1192         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
1193             SCRATCH_LOG="$SCRATCH_LOGDEV"
1194
1195         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
1196             SCRATCH_RT="$SCRATCH_RTDEV"
1197
1198         _check_xfs_filesystem $SCRATCH_DEV $SCRATCH_LOG $SCRATCH_RT
1199         ;;
1200     udf)
1201         _check_udf_filesystem $SCRATCH_DEV $udf_fsize
1202         ;;
1203     nfs*)
1204         # Don't know how to check an NFS filesystem, yet.
1205         ;;
1206     *)
1207         _check_generic_filesystem $SCRATCH_DEV
1208         ;;
1209     esac
1210 }
1211
1212 _full_fstyp_details()
1213 {
1214      [ -z "$FSTYP" ] && FSTYP=xfs
1215      if [ $FSTYP = xfs ]; then
1216         if [ -d /proc/fs/xfs ]; then
1217             if grep -q 'debug 0' /proc/fs/xfs/stat; then
1218                 FSTYP="$FSTYP (non-debug)"
1219             elif grep -q 'debug 1' /proc/fs/xfs/stat; then
1220                 FSTYP="$FSTYP (debug)"
1221             fi
1222         else
1223             if uname -a | grep -qi 'debug'; then
1224                 FSTYP="$FSTYP (debug)"
1225             else
1226                 FSTYP="$FSTYP (non-debug)"
1227             fi
1228         fi
1229      fi
1230      echo $FSTYP
1231 }
1232
1233 _full_platform_details()
1234 {
1235      os=`uname -s`
1236      host=`hostname -s`
1237      kernel=`uname -r`
1238      platform=`uname -m`
1239      echo "$os/$platform $host $kernel"
1240 }
1241
1242 _setup_udf_scratchdir()
1243 {
1244     [ "$FSTYP" != "udf" ] \
1245         && _fail "setup_udf_testdir: \$FSTYP is not udf"
1246     [ -z "$SCRATCH_DEV" -o ! -b "$SCRATCH_DEV" ] \
1247         && _notrun "this test requires a valid \$SCRATCH_DEV"
1248     [ -z "$SCRATCH_MNT" ] \
1249         && _notrun "this test requires a valid \$SCRATCH_MNT"
1250
1251     # mounted?
1252     if _mount | grep -q $SCRATCH_DEV
1253     then
1254         # if it's mounted, make sure its on $TEST_RW_DIR
1255         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
1256         then
1257             _fail "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
1258         fi
1259         $UMOUNT_PROG $SCRATCH_DEV
1260     fi
1261
1262     _scratch_mkfs
1263     _scratch_mount
1264
1265     testdir=$SCRATCH_MNT
1266 }
1267
1268 _setup_nfs_scratchdir()
1269 {
1270     [ "$FSTYP" != "nfs" ] \
1271         && _fail "setup_nfs_testdir: \$FSTYP is not nfs"
1272     [ -z "$SCRATCH_DEV" ] \
1273         && _notrun "this test requires a valid host fs for \$SCRATCH_DEV"
1274     [ -z "$SCRATCH_MNT" ] \
1275         && _notrun "this test requires a valid \$SCRATCH_MNT"
1276
1277     # mounted?
1278     if _mount | grep -q $SCRATCH_DEV
1279     then
1280         # if it's mounted, make sure its on $SCRATCH_MNT
1281         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
1282         then
1283             _fail "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
1284         fi
1285         $UMOUNT_PROG $SCRATCH_DEV
1286     fi
1287
1288     _scratch_mkfs
1289     _scratch_mount
1290
1291     testdir=$SCRATCH_MNT
1292 }
1293
1294 #
1295 # Warning for UDF and NFS:
1296 # this function calls _setup_udf_scratchdir and _setup_udf_scratchdir
1297 # which actually uses the scratch dir for the test dir.
1298 #
1299 # This was done because testdir was intended to be a persistent
1300 # XFS only partition.  This should eventually change, and treat
1301 # at least local filesystems all the same.
1302 #
1303 _setup_testdir()
1304 {
1305     case $FSTYP in
1306     udf)
1307         _setup_udf_scratchdir
1308         ;;
1309     nfs*)
1310         _setup_nfs_scratchdir
1311         ;;
1312     *)
1313         testdir=$TEST_DIR
1314         ;;
1315     esac
1316 }
1317
1318 _cleanup_testdir()
1319 {
1320     case $FSTYP in
1321     udf)
1322         # umount testdir as it is $SCRATCH_MNT which could be used by xfs next
1323         [ -n "$testdir" ] && $UMOUNT_PROG $testdir
1324         ;;
1325     nfs*)
1326         # umount testdir as it is $SCRATCH_MNT which could be used by xfs next
1327         [ -n "$testdir" ] && $UMOUNT_PROG $testdir
1328         ;;
1329     *)
1330         # do nothing, testdir is $TEST_DIR
1331         :
1332         ;;
1333     esac
1334 }
1335
1336 _link_out_file()
1337 {
1338    if [ -z "$1" ]; then
1339       echo Error must pass \$seq.
1340       exit
1341    fi
1342    rm -f $1
1343    if [ "`uname`" == "IRIX64" ] || [ "`uname`" == "IRIX" ]; then
1344       ln -s $1.irix $1
1345    elif [ "`uname`" == "Linux" ]; then
1346       ln -s $1.linux $1
1347    else
1348       echo Error test $seq does not run on the operating system: `uname`
1349       exit
1350    fi
1351 }
1352
1353 _die()
1354 {
1355         echo $@
1356         exit 1
1357 }
1358
1359 _nfiles()
1360 {
1361         f=0
1362         while [ $f -lt $1 ]
1363         do
1364                 file=f$f
1365                 echo > $file
1366                 if [ $size -gt 0 ]; then
1367                     dd if=/dev/zero of=$file bs=1024 count=$size
1368                 fi
1369                 let f=$f+1
1370         done
1371 }
1372
1373 # takes dirname, depth
1374 _descend()
1375 {
1376         dirname=$1; depth=$2
1377         mkdir $dirname  || die "mkdir $dirname failed"
1378         cd $dirname
1379
1380         _nfiles $files           # files for this dir
1381
1382         [ $depth -eq 0 ] && return
1383         let deep=$depth-1 # go 1 down
1384
1385         [ $verbose = true ] && echo "descending, depth from leaves = $deep"
1386
1387         d=0
1388         while [ $d -lt $dirs ]
1389         do
1390                 _descend d$d $deep &
1391                 let d=$d+1
1392                 wait
1393         done
1394 }
1395
1396 # Populate a filesystem with inodes for performance experiments
1397 #
1398 # usage: populate [-v] [-n ndirs] [-f nfiles] [-d depth] [-r root] [-s size]
1399 #
1400 _populate_fs()
1401 {
1402     here=`pwd`
1403     dirs=5          # ndirs in each subdir till leaves
1404     size=0          # sizeof files in K
1405     files=100       # num files in _each_ subdir
1406     depth=2         # depth of tree from root to leaves
1407     verbose=false
1408     root=root       # path of initial root of directory tree
1409
1410     while getopts "d:f:n:r:s:v" c
1411     do
1412         case $c in
1413         d)      depth=$OPTARG;;
1414         n)      dirs=$OPTARG;;
1415         f)      files=$OPTARG;;
1416         s)      size=$OPTARG;;
1417         v)      verbose=true;;
1418         r)      root=$OPTARG;;
1419         esac
1420     done
1421
1422     _descend $root $depth
1423     wait
1424
1425     cd $here
1426
1427     [ $verbose = true ] && echo done
1428 }
1429
1430 # query whether the given file has the given inode flag set
1431 #
1432 _test_inode_flag()
1433 {
1434     flag=$1
1435     file=$2
1436
1437     if which $XFS_IO_PROG >/dev/null; then
1438         if $XFS_IO_PROG -r -c 'lsattr -v' "$file" | grep -q "$flag" ; then
1439             return 0
1440         fi
1441     fi
1442     return 1
1443 }
1444
1445 # query the given files extsize allocator hint in bytes (if any)
1446 #
1447 _test_inode_extsz()
1448 {
1449     file=$1
1450     blocks=""
1451
1452     if which $XFS_IO_PROG >/dev/null; then
1453         blocks=`$XFS_IO_PROG -r -c 'stat' "$file" | \
1454                 awk '/^xattr.extsize =/ { print $3 }'`
1455     fi
1456     [ -z "$blocks" ] && blocks="0"
1457     echo $blocks
1458 }
1459
1460
1461 ################################################################################
1462
1463 if [ "$iam" != new -a "$iam" != bench ]
1464 then
1465     # make some further configuration checks here
1466
1467     if [ "$TEST_DEV" = ""  ]
1468     then
1469         echo "common.rc: Error: \$TEST_DEV is not set"
1470         exit 1
1471     fi
1472
1473     # if $TEST_DEV is not mounted, mount it now as XFS
1474     if [ -z "`_fs_type $TEST_DEV`" ]
1475     then
1476         # $TEST_DEV is not mounted
1477         if ! _test_mount
1478         then
1479             echo "common.rc: retrying test device mount with external set"
1480             [ "$USE_EXTERNAL" != "yes" ] && export USE_EXTERNAL=yes
1481             if ! _test_mount
1482             then
1483                 echo "common.rc: could not mount $TEST_DEV on $TEST_DIR"
1484                 exit 1
1485             fi
1486         fi
1487     fi
1488
1489     if [ "`_fs_type $TEST_DEV`" != "$FSTYP" ]
1490     then
1491         echo "common.rc: Error: \$TEST_DEV ($TEST_DEV) is not a MOUNTED $FSTYP filesystem"
1492         $DF_PROG $TEST_DEV
1493         exit 1
1494     fi
1495 fi
1496
1497 # make sure this script returns success
1498 /bin/true