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                  ;;
 707     esac
 708
 709     # mounted?
 710     if _mount | grep -q $SCRATCH_DEV
 711     then
 712         # if it's mounted, make sure its on $SCRATCH_MNT
 713         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
 714         then
 715             echo "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
 716             exit 1
 717         fi
 718         # and then unmount it
 719         if ! $UMOUNT_PROG $SCRATCH_DEV
 720         then
 721             echo "failed to unmount $SCRATCH_DEV"
 722             exit 1
 723         fi
 724     fi
 725 }
 726
 727 # this test needs a logdev
 728 #
 729 _require_logdev()
 730 {
 731     [ -z "$SCRATCH_LOGDEV" -o ! -b "$SCRATCH_LOGDEV" ] && \
 732         _notrun "This test requires a valid \$SCRATCH_LOGDEV"
 733     [ "$USE_EXTERNAL" != yes ] && \
 734         _notrun "This test requires USE_EXTERNAL to be enabled"
 735
 736     # ensure its not mounted
 737     $UMOUNT_PROG $SCRATCH_LOGDEV 2>/dev/null
 738 }
 739
 740 # this test requires loopback device support
 741 #
 742 _require_loop()
 743 {
 744     if [ "$HOSTOS" != "Linux" ]
 745     then
 746         _notrun "This test requires linux for loopback device support"
 747     fi
 748
 749     modprobe loop >/dev/null 2>&1
 750     if grep loop /proc/devices >/dev/null 2>&1
 751     then
 752         :
 753     else
 754         _notrun "This test requires loopback device support"
 755     fi
 756 }
 757
 758 # this test requires that (large) loopback device files are not in use
 759 #
 760 _require_nobigloopfs()
 761 {
 762     [ "$USE_BIG_LOOPFS" = yes ] && \
 763         _notrun "Large filesystem testing in progress, skipped this test"
 764 }
 765
 766 # this test requires that a realtime subvolume is in use, and
 767 # that the kernel supports realtime as well.
 768 #
 769 _require_realtime()
 770 {
 771     [ "$USE_EXTERNAL" = yes ] || \
 772         _notrun "External volumes not in use, skipped this test"
 773     [ "$SCRATCH_RTDEV" = "" ] && \
 774         _notrun "Realtime device required, skipped this test"
 775 }
 776
 777 # this test requires that a specified command (executable) exists
 778 #
 779 _require_command()
 780 {
 781     [ -x "$1" ] || _notrun "$1 utility required, skipped this test"
 782 }
 783
 784 # this test requires that external log/realtime devices are not in use
 785 #
 786 _require_nonexternal()
 787 {
 788     [ "$USE_EXTERNAL" = yes ] && \
 789         _notrun "External device testing in progress, skipped this test"
 790 }
 791
 792 # check for the fsgqa user on the machine
 793 #
 794 _require_user()
 795 {
 796     qa_user=fsgqa
 797     cat /etc/passwd | grep -q $qa_user
 798     [ "$?" == "0" ] || _notrun "$qa_user user not defined."
 799 }
 800
 801 # check that xfs_io, glibc, kernel, and filesystem all (!) support
 802 # fallocate
 803 #
 804 _require_xfs_io_falloc()
 805 {
 806         testio=`$XFS_IO_PROG -F -f -c "falloc 0 1m" $TEST_DIR/$tmp.io 2>&1`
 807         rm -f $TEST_DIR/$tmp.io 2>&1 > /dev/null
 808         echo $testio | grep -q "not found" && \
 809                 _notrun "xfs_io fallocate support is missing"
 810         echo $testio | grep -q "Operation not supported" && \
 811                 _notrun "xfs_io fallocate command failed (old kernel/wrong fs?)"
 812 }
 813
 814 # Check that a fs has enough free space (in 1024b blocks)
 815 #
 816 _require_fs_space()
 817 {
 818         MNT=$1
 819         BLOCKS=$2       # in units of 1024
 820         let GB=$BLOCKS/1024/1024
 821
 822         FREE_BLOCKS=`df -klP $MNT | grep -v Filesystem | awk '{print $4}'`
 823         [ $FREE_BLOCKS -lt $BLOCKS ] && \
 824                 _notrun "This test requires at least ${GB}GB free on $MNT to run"
 825 }
 826
 827 # check that a FS on a device is mounted
 828 # if so, return mount point
 829 #
 830 _is_mounted()
 831 {
 832     if [ $# -ne 1 ]
 833     then
 834         echo "Usage: _is_mounted device" 1>&2
 835         exit 1
 836     fi
 837
 838     device=$1
 839
 840     if _mount | grep "$device " | $AWK_PROG -v pattern="type $FSTYP" '
 841         pattern        { print $3 ; exit 0 }
 842         END            { exit 1 }
 843     '
 844     then
 845         echo "_is_mounted: $device is not a mounted $FSTYP FS"
 846         exit 1
 847     fi
 848 }
 849
 850 # remount a FS to a new mode (ro or rw)
 851 #
 852 _remount()
 853 {
 854     if [ $# -ne 2 ]
 855     then
 856         echo "Usage: _remount device ro/rw" 1>&2
 857         exit 1
 858     fi
 859     device=$1
 860     mode=$2
 861
 862     if ! mount -o remount,$mode $device
 863     then
 864         echo "_remount: failed to remount filesystem on $device as $mode"
 865         exit 1
 866     fi
 867 }
 868
 869 # Run the appropriate repair/check on a filesystem
 870 #
 871 # if the filesystem is mounted, it's either remounted ro before being
 872 # checked or it's unmounted and then remounted
 873 #
 874
 875 # If set, we remount ro instead of unmounting for fsck
 876 USE_REMOUNT=0
 877
 878 _umount_or_remount_ro()
 879 {
 880     if [ $# -ne 1 ]
 881     then
 882         echo "Usage: _umount_or_remount_ro <device>" 1>&2
 883         exit 1
 884     fi
 885
 886     device=$1
 887     mountpoint=`_is_mounted $device`
 888
 889     if [ $USE_REMOUNT -eq 0 ]; then
 890         $UMOUNT_PROG $device
 891     else
 892         _remount $device ro
 893     fi
 894     echo "$mountpoint"
 895 }
 896
 897 _mount_or_remount_rw()
 898 {
 899     if [ $# -ne 3 ]
 900     then
 901         echo "Usage: _mount_or_remount_rw <opts> <device> <mountpoint>" 1>&2
 902         exit 1
 903     fi
 904     mount_opts=$1
 905     device=$2
 906     mountpoint=$3
 907
 908     if [ $USE_REMOUNT -eq 0 ]
 909     then
 910         if ! _mount -t $FSTYP $mount_opts $device $mountpoint
 911         then
 912             echo "!!! failed to remount $device on $mountpoint"
 913             return 0 # ok=0
 914         fi
 915     else
 916         _remount $device rw
 917     fi
 918
 919     return 1 # ok=1
 920 }
 921
 922 # Check a generic filesystem in no-op mode; this assumes that the
 923 # underlying fsck program accepts "-n" for a no-op (check-only) run,
 924 # and that it will still return an errno for corruption in this mode.
 925 #
 926 # Filesystems which don't support this will need to define their
 927 # own check routine.
 928 #
 929 _check_generic_filesystem()
 930 {
 931     device=$1
 932
 933     # If type is set, we're mounted
 934     type=`_fs_type $device`
 935     ok=1
 936
 937     if [ "$type" = "$FSTYP" ]
 938     then
 939         # mounted ...
 940         mountpoint=`_umount_or_remount_ro $device`
 941     fi
 942
 943     fsck -t $FSTYP $FSCK_OPTIONS $device >$tmp.fsck 2>&1
 944     if [ $? -ne 0 ]
 945     then
 946         echo "_check_generic_filesystem: filesystem on $device is inconsistent (see $seq.full)"
 947
 948         echo "_check_generic filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
 949         echo "*** fsck.$FSTYP output ***"                     >>$here/$seq.full
 950         cat $tmp.fsck                                         >>$here/$seq.full
 951         echo "*** end fsck.$FSTYP output"                     >>$here/$seq.full
 952
 953         ok=0
 954     fi
 955     rm -f $tmp.fsck
 956
 957     if [ $ok -eq 0 ]
 958     then
 959         echo "*** mount output ***"                             >>$here/$seq.full
 960         _mount                                                  >>$here/$seq.full
 961         echo "*** end mount output"                             >>$here/$seq.full
 962     elif [ "$type" = "$FSTYP" ]
 963     then
 964         # was mounted ...
 965         _mount_or_remount_rw "$MOUNT_OPTIONS" $device $mountpoint
 966         ok=$?
 967     fi
 968
 969     [ $ok -eq 0 ] && exit 1
 970     return 0
 971 }
 972
 973 # run xfs_check and friends on a FS.
 974
 975 _check_xfs_filesystem()
 976 {
 977     if [ $# -ne 3 ]
 978     then
 979         echo "Usage: _check_xfs_filesystem device <logdev>|none <rtdev>|none" 1>&2
 980         exit 1
 981     fi
 982
 983     extra_mount_options=""
 984     device=$1
 985     if [ "$2" != "none" ]; then
 986         extra_log_options="-l$2"
 987         extra_mount_options="-ologdev=$2"
 988     fi
 989
 990     if [ "$3" != "none" ]; then
 991         extra_rt_options="-r$3"
 992         extra_mount_options=$extra_mount_options" -ortdev=$3"
 993     fi
 994     extra_mount_options=$extra_mount_options" $MOUNT_OPTIONS"
 995
 996     [ "$FSTYP" != xfs ] && return 0
 997     testoption=""
 998     [ "$USE_BIG_LOOPFS" = yes ] && testoption=-t
 999
1000     type=`_fs_type $device`
1001     ok=1
1002
1003     if [ "$type" = "xfs" ]
1004     then
1005         # mounted ...
1006         mountpoint=`_umount_or_remount_ro $device`
1007     fi
1008
1009     $XFS_LOGPRINT_PROG -t $extra_log_options $device 2>&1 \
1010                 | tee $tmp.logprint | grep -q "<CLEAN>"
1011     if [ $? -ne 0 -a "$HOSTOS" = "Linux" ]
1012     then
1013         echo "_check_xfs_filesystem: filesystem on $device has dirty log (see $seq.full)"
1014
1015         echo "_check_xfs_filesystem: filesystem on $device has dirty log"   >>$here/$seq.full
1016         echo "*** xfs_logprint -t output ***"                   >>$here/$seq.full
1017         cat $tmp.logprint                                       >>$here/$seq.full
1018         echo "*** end xfs_logprint output"                      >>$here/$seq.full
1019
1020         ok=0
1021     fi
1022
1023     $XFS_CHECK_PROG $testoption $extra_log_options $device 2>&1 |\
1024          _fix_malloc >$tmp.fs_check
1025     if [ -s $tmp.fs_check ]
1026     then
1027         echo "_check_xfs_filesystem: filesystem on $device is inconsistent (c) (see $seq.full)"
1028
1029         echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1030         echo "*** xfs_check output ***"                         >>$here/$seq.full
1031         cat $tmp.fs_check                                       >>$here/$seq.full
1032         echo "*** end xfs_check output"                         >>$here/$seq.full
1033
1034         ok=0
1035     fi
1036     # repair doesn't scale massively at this stage, optionally skip it for now
1037     [ "$USE_BIG_LOOPFS" = yes ] || \
1038     $XFS_REPAIR_PROG -n $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
1039     if [ $? -ne 0 ]
1040     then
1041         echo "_check_xfs_filesystem: filesystem on $device is inconsistent (r) (see $seq.full)"
1042
1043         echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$here/$seq.full
1044         echo "*** xfs_repair -n output ***"                     >>$here/$seq.full
1045         cat $tmp.repair | _fix_malloc                           >>$here/$seq.full
1046         echo "*** end xfs_repair output"                        >>$here/$seq.full
1047
1048         ok=0
1049     fi
1050     rm -f $tmp.fs_check $tmp.logprint $tmp.repair
1051
1052     if [ $ok -eq 0 ]
1053     then
1054         echo "*** mount output ***"                             >>$here/$seq.full
1055         _mount                                                  >>$here/$seq.full
1056         echo "*** end mount output"                             >>$here/$seq.full
1057     elif [ "$type" = "xfs" ]
1058     then
1059         _mount_or_remount_rw "$extra_mount_options" $device $mountpoint
1060     fi
1061
1062     [ $ok -eq 0 ] && exit 1
1063     return 0
1064 }
1065
1066 # Filter the knowen errors the UDF Verifier reports.
1067 _udf_test_known_error_filter()
1068 {
1069         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."
1070
1071 }
1072
1073 _check_udf_filesystem()
1074 {
1075     [ "$DISABLE_UDF_TEST" == "1" ] && return
1076
1077     if [ $# -ne 1 -a $# -ne 2 ]
1078     then
1079         echo "Usage: _check_udf_filesystem device [last_block]" 1>&2
1080         exit 1
1081     fi
1082
1083     if [ ! -x $here/src/udf_test ]
1084     then
1085         echo "udf_test not installed, please download and build the Philips"
1086         echo "UDF Verification Software from http://www.extra.research.philips.com/udf/."
1087         echo "Then copy the udf_test binary to $here/src/."
1088         echo "If you do not wish to run udf_test then set environment variable DISABLE_UDF_TEST"
1089         echo "to 1."
1090         return
1091     fi
1092
1093     device=$1
1094     if [ $# -eq 2 ];
1095     then
1096         LAST_BLOCK=`expr \( $2 - 1 \)`
1097         OPT_ARG="-lastvalidblock $LAST_BLOCK"
1098     fi
1099
1100     rm -f $seq.checkfs
1101     sleep 1 # Due to a problem with time stamps in udf_test
1102     $here/src/udf_test $OPT_ARG $device | tee $here/$seq.checkfs | egrep "Error|Warning" | \
1103         _udf_test_known_error_filter | \
1104         egrep -iv "Error count:.*[0-9]+.*total occurrences:.*[0-9]+|Warning count:.*[0-9]+.*total occurrences:.*[0-9]+" | \
1105         sed "s/^.*$/Warning UDF Verifier reported errors see $seq.checkfs./g"
1106
1107 }
1108
1109 _check_xfs_test_fs()
1110 {
1111     TEST_LOG="none"
1112     TEST_RT="none"
1113     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
1114         TEST_LOG="$TEST_LOGDEV"
1115
1116     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
1117         TEST_RT="$TEST_RTDEV"
1118
1119     _check_xfs_filesystem $TEST_DEV $TEST_LOG $TEST_RT
1120
1121     # check for ipath consistency
1122     if $XFS_GROWFS_PROG -n $TEST_DIR | grep -q 'inode-paths=1'; then
1123         # errors go to stderr
1124         xfs_check_ipaths $TEST_DIR >/dev/null
1125         xfs_repair_ipaths -n $TEST_DIR >/dev/null
1126     fi
1127 }
1128
1129 _check_test_fs()
1130 {
1131     case $FSTYP in
1132     xfs)
1133         _check_xfs_test_fs
1134         ;;
1135     nfs)
1136         # no way to check consistency for nfs
1137         ;;
1138     udf)
1139         # do nothing for now
1140         ;;
1141     *)
1142         _check_generic_filesystem $TEST_DEV
1143         ;;
1144     esac
1145 }
1146
1147 _check_scratch_fs()
1148 {
1149     case $FSTYP in
1150     xfs)
1151         SCRATCH_LOG="none"
1152         SCRATCH_RT="none"
1153         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
1154             SCRATCH_LOG="$SCRATCH_LOGDEV"
1155
1156         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
1157             SCRATCH_RT="$SCRATCH_RTDEV"
1158
1159         _check_xfs_filesystem $SCRATCH_DEV $SCRATCH_LOG $SCRATCH_RT
1160         ;;
1161     udf)
1162         _check_udf_filesystem $SCRATCH_DEV $udf_fsize
1163         ;;
1164     nfs*)
1165         # Don't know how to check an NFS filesystem, yet.
1166         ;;
1167     *)
1168         _check_generic_filesystem $SCRATCH_DEV
1169         ;;
1170     esac
1171 }
1172
1173 _full_fstyp_details()
1174 {
1175      [ -z "$FSTYP" ] && FSTYP=xfs
1176      if [ $FSTYP = xfs ]; then
1177         if [ -d /proc/fs/xfs ]; then
1178             if grep -q 'debug 0' /proc/fs/xfs/stat; then
1179                 FSTYP="$FSTYP (non-debug)"
1180             elif grep -q 'debug 1' /proc/fs/xfs/stat; then
1181                 FSTYP="$FSTYP (debug)"
1182             fi
1183         else
1184             if uname -a | grep -qi 'debug'; then
1185                 FSTYP="$FSTYP (debug)"
1186             else
1187                 FSTYP="$FSTYP (non-debug)"
1188             fi
1189         fi
1190      fi
1191      echo $FSTYP
1192 }
1193
1194 _full_platform_details()
1195 {
1196      os=`uname -s`
1197      host=`hostname -s`
1198      kernel=`uname -r`
1199      platform=`uname -m`
1200      echo "$os/$platform $host $kernel"
1201 }
1202
1203 _setup_udf_scratchdir()
1204 {
1205     [ "$FSTYP" != "udf" ] \
1206         && _fail "setup_udf_testdir: \$FSTYP is not udf"
1207     [ -z "$SCRATCH_DEV" -o ! -b "$SCRATCH_DEV" ] \
1208         && _notrun "this test requires a valid \$SCRATCH_DEV"
1209     [ -z "$SCRATCH_MNT" ] \
1210         && _notrun "this test requires a valid \$SCRATCH_MNT"
1211
1212     # mounted?
1213     if _mount | grep -q $SCRATCH_DEV
1214     then
1215         # if it's mounted, make sure its on $TEST_RW_DIR
1216         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
1217         then
1218             _fail "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
1219         fi
1220         $UMOUNT_PROG $SCRATCH_DEV
1221     fi
1222
1223     _scratch_mkfs
1224     _scratch_mount
1225
1226     testdir=$SCRATCH_MNT
1227 }
1228
1229 _setup_nfs_scratchdir()
1230 {
1231     [ "$FSTYP" != "nfs" ] \
1232         && _fail "setup_nfs_testdir: \$FSTYP is not nfs"
1233     [ -z "$SCRATCH_DEV" ] \
1234         && _notrun "this test requires a valid host fs for \$SCRATCH_DEV"
1235     [ -z "$SCRATCH_MNT" ] \
1236         && _notrun "this test requires a valid \$SCRATCH_MNT"
1237
1238     # mounted?
1239     if _mount | grep -q $SCRATCH_DEV
1240     then
1241         # if it's mounted, make sure its on $SCRATCH_MNT
1242         if ! _mount | grep $SCRATCH_DEV | grep -q $SCRATCH_MNT
1243         then
1244             _fail "\$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT - aborting"
1245         fi
1246         $UMOUNT_PROG $SCRATCH_DEV
1247     fi
1248
1249     _scratch_mkfs
1250     _scratch_mount
1251
1252     testdir=$SCRATCH_MNT
1253 }
1254
1255 #
1256 # Warning for UDF and NFS:
1257 # this function calls _setup_udf_scratchdir and _setup_udf_scratchdir
1258 # which actually uses the scratch dir for the test dir.
1259 #
1260 # This was done because testdir was intended to be a persistent
1261 # XFS only partition.  This should eventually change, and treat
1262 # at least local filesystems all the same.
1263 #
1264 _setup_testdir()
1265 {
1266     case $FSTYP in
1267     udf)
1268         _setup_udf_scratchdir
1269         ;;
1270     nfs*)
1271         _setup_nfs_scratchdir
1272         ;;
1273     *)
1274         testdir=$TEST_DIR
1275         ;;
1276     esac
1277 }
1278
1279 _cleanup_testdir()
1280 {
1281     case $FSTYP in
1282     udf)
1283         # umount testdir as it is $SCRATCH_MNT which could be used by xfs next
1284         [ -n "$testdir" ] && $UMOUNT_PROG $testdir
1285         ;;
1286     nfs*)
1287         # umount testdir as it is $SCRATCH_MNT which could be used by xfs next
1288         [ -n "$testdir" ] && $UMOUNT_PROG $testdir
1289         ;;
1290     *)
1291         # do nothing, testdir is $TEST_DIR
1292         :
1293         ;;
1294     esac
1295 }
1296
1297 _link_out_file()
1298 {
1299    if [ -z "$1" ]; then
1300       echo Error must pass \$seq.
1301       exit
1302    fi
1303    rm -f $1
1304    if [ "`uname`" == "IRIX64" ] || [ "`uname`" == "IRIX" ]; then
1305       ln -s $1.irix $1
1306    elif [ "`uname`" == "Linux" ]; then
1307       ln -s $1.linux $1
1308    else
1309       echo Error test $seq does not run on the operating system: `uname`
1310       exit
1311    fi
1312 }
1313
1314 _die()
1315 {
1316         echo $@
1317         exit 1
1318 }
1319
1320 _nfiles()
1321 {
1322         f=0
1323         while [ $f -lt $1 ]
1324         do
1325                 file=f$f
1326                 echo > $file
1327                 if [ $size -gt 0 ]; then
1328                     dd if=/dev/zero of=$file bs=1024 count=$size
1329                 fi
1330                 let f=$f+1
1331         done
1332 }
1333
1334 # takes dirname, depth
1335 _descend()
1336 {
1337         dirname=$1; depth=$2
1338         mkdir $dirname  || die "mkdir $dirname failed"
1339         cd $dirname
1340
1341         _nfiles $files           # files for this dir
1342
1343         [ $depth -eq 0 ] && return
1344         let deep=$depth-1 # go 1 down
1345
1346         [ $verbose = true ] && echo "descending, depth from leaves = $deep"
1347
1348         d=0
1349         while [ $d -lt $dirs ]
1350         do
1351                 _descend d$d $deep &
1352                 let d=$d+1
1353                 wait
1354         done
1355 }
1356
1357 # Populate a filesystem with inodes for performance experiments
1358 #
1359 # usage: populate [-v] [-n ndirs] [-f nfiles] [-d depth] [-r root] [-s size]
1360 #
1361 _populate_fs()
1362 {
1363     here=`pwd`
1364     dirs=5          # ndirs in each subdir till leaves
1365     size=0          # sizeof files in K
1366     files=100       # num files in _each_ subdir
1367     depth=2         # depth of tree from root to leaves
1368     verbose=false
1369     root=root       # path of initial root of directory tree
1370
1371     while getopts "d:f:n:r:s:v" c
1372     do
1373         case $c in
1374         d)      depth=$OPTARG;;
1375         n)      dirs=$OPTARG;;
1376         f)      files=$OPTARG;;
1377         s)      size=$OPTARG;;
1378         v)      verbose=true;;
1379         r)      root=$OPTARG;;
1380         esac
1381     done
1382
1383     _descend $root $depth
1384     wait
1385
1386     cd $here
1387
1388     [ $verbose = true ] && echo done
1389 }
1390
1391 # query whether the given file has the given inode flag set
1392 #
1393 _test_inode_flag()
1394 {
1395     flag=$1
1396     file=$2
1397
1398     if which $XFS_IO_PROG >/dev/null; then
1399         if $XFS_IO_PROG -r -c 'lsattr -v' "$file" | grep -q "$flag" ; then
1400             return 0
1401         fi
1402     fi
1403     return 1
1404 }
1405
1406 # query the given files extsize allocator hint in bytes (if any)
1407 #
1408 _test_inode_extsz()
1409 {
1410     file=$1
1411     blocks=""
1412
1413     if which $XFS_IO_PROG >/dev/null; then
1414         blocks=`$XFS_IO_PROG -r -c 'stat' "$file" | \
1415                 awk '/^xattr.extsize =/ { print $3 }'`
1416     fi
1417     [ -z "$blocks" ] && blocks="0"
1418     echo $blocks
1419 }
1420
1421
1422 ################################################################################
1423
1424 if [ "$iam" != new -a "$iam" != bench ]
1425 then
1426     # make some further configuration checks here
1427
1428     if [ "$TEST_DEV" = ""  ]
1429     then
1430         echo "common.rc: Error: \$TEST_DEV is not set"
1431         exit 1
1432     fi
1433
1434     # if $TEST_DEV is not mounted, mount it now as XFS
1435     if [ -z "`_fs_type $TEST_DEV`" ]
1436     then
1437         # $TEST_DEV is not mounted
1438         if ! _test_mount
1439         then
1440             echo "common.rc: retrying test device mount with external set"
1441             [ "$USE_EXTERNAL" != "yes" ] && export USE_EXTERNAL=yes
1442             if ! _test_mount
1443             then
1444                 echo "common.rc: could not mount $TEST_DEV on $TEST_DIR"
1445                 exit 1
1446             fi
1447         fi
1448     fi
1449
1450     if [ "`_fs_type $TEST_DEV`" != "$FSTYP" ]
1451     then
1452         echo "common.rc: Error: \$TEST_DEV ($TEST_DEV) is not a MOUNTED $FSTYP filesystem"
1453         $DF_PROG $TEST_DEV
1454         exit 1
1455     fi
1456 fi
1457
1458 # make sure this script returns success
1459 /bin/true