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