Re: [LTP] Lustre basic tests script

[Subrata M. <tos...@gm...>]

Hi Andreas,

On Sat, May 23, 2009 at 3:06 AM, Andreas Dilger <ad...@su...> wrote:

> Below are included some of the tests from the Lustre "sanity.sh" script,
> which tests filesystem behaviour in a variety of ways.  Some of them are
> very simple and might concievably be removed, but are not necessarily bad.
> I've removed the tests that depend on Lustre-specific behaviour.
>
> It probably isn't useful to use this test script directly, since it
> depends on a number of helper functions, but it is definitely useful
> as a starting point for adding new tests to xfstests.
>
> Unfortunately, a bunch of tests had to be removed since they depend on
> Lustre's fault-injection code, but they would be useful for testing
> generic filesystem behaviour (e.g. ENOMEM or ENOSPC handling).  There
> is also a helper program we use "multiop" which is a toolbox program
> that I could supply separately, if you want.


How about understanding these and find out if they can be made part of LTP
as well  ? Any objection(s) ?

Regards--
Subrata


>
>
> Cheers, Andreas
> --
> Andreas Dilger
> Sr. Staff Engineer, Lustre Group
> Sun Microsystems of Canada, Inc.
>
>
> ============================================================================
>
> TMP=${TMP:-/tmp}
>
> [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
> [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
> rm -rf $DIR/[Rdfs][0-9]*
>
> # $RUNAS_ID may get set incorrectly somewhere else
> [ $UID -eq 0 -a $RUNAS_ID -eq 0 ] && error "\$RUNAS_ID set to 0, but \$UID
> is also 0!"
>
>
> echo "preparing for tests involving mounts"
> EXT2_DEV=${EXT2_DEV:-$TMP/SANITY.LOOP}
> touch $EXT2_DEV
> mke2fs -j -F $EXT2_DEV 8000 > /dev/null
> echo # add a newline after mke2fs.
>
> umask 077
>
> test_0() {
>        touch $DIR/$tfile
>        $CHECKSTAT -t file $DIR/$tfile || error
>        rm $DIR/$tfile
>        $CHECKSTAT -a $DIR/$tfile || error
> }
> run_test 0 "touch .../$tfile ; rm .../$tfile"
>
> test_0b() {
>        chmod 0755 $DIR || error
>        $CHECKSTAT -p 0755 $DIR || error
> }
> run_test 0b "chmod 0755 $DIR"
>
> test_1a() {
>        mkdir $DIR/d1
>        mkdir $DIR/d1/d2
>        mkdir $DIR/d1/d2 && error "we expect EEXIST, but not returned"
>        $CHECKSTAT -t dir $DIR/d1/d2 || error
> }
> run_test 1a "mkdir .../d1; mkdir .../d1/d2"
>
> test_1b() {
>        rmdir $DIR/d1/d2
>        rmdir $DIR/d1
>        $CHECKSTAT -a $DIR/d1 || error
> }
> run_test 1b "rmdir .../d1/d2; rmdir .../d1"
>
> test_2a() {
>        mkdir $DIR/d2
>        touch $DIR/d2/f
>        $CHECKSTAT -t file $DIR/d2/f || error
> }
> run_test 2a "mkdir .../d2; touch .../d2/f"
>
> test_2b() {
>        rm -r $DIR/d2
>        $CHECKSTAT -a $DIR/d2 || error
> }
> run_test 2b "rm -r .../d2; checkstat .../d2/f"
>
> test_3a() {
>        mkdir $DIR/d3
>        $CHECKSTAT -t dir $DIR/d3 || error
> }
> run_test 3a "mkdir .../d3"
>
> test_3b() {
>        if [ ! -d $DIR/d3 ]; then
>                mkdir $DIR/d3
>        fi
>        touch $DIR/d3/f
>        $CHECKSTAT -t file $DIR/d3/f || error
> }
> run_test 3b "touch .../d3/f"
>
> test_3c() {
>        rm -r $DIR/d3
>        $CHECKSTAT -a $DIR/d3 || error
> }
> run_test 3c "rm -r .../d3"
>
> test_4a() {
>        mkdir $DIR/d4
>        $CHECKSTAT -t dir $DIR/d4 || error
> }
> run_test 4a "mkdir .../d4"
>
> test_4b() {
>        if [ ! -d $DIR/d4 ]; then
>                mkdir $DIR/d4
>        fi
>        mkdir $DIR/d4/d2
>        $CHECKSTAT -t dir $DIR/d4/d2 || error
> }
> run_test 4b "mkdir .../d4/d2"
>
> test_5() {
>        mkdir $DIR/d5
>        mkdir $DIR/d5/d2
>        chmod 0707 $DIR/d5/d2
>        $CHECKSTAT -t dir -p 0707 $DIR/d5/d2 || error
> }
> run_test 5 "mkdir .../d5 .../d5/d2; chmod .../d5/d2"
>
> test_6a() {
>        touch $DIR/f6a
>        chmod 0666 $DIR/f6a || error
>        $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/f6a || error
> }
> run_test 6a "touch .../f6a; chmod .../f6a"
>
> test_6b() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        if [ ! -f $DIR/f6a ]; then
>                touch $DIR/f6a
>                chmod 0666 $DIR/f6a
>        fi
>        $RUNAS chmod 0444 $DIR/f6a && error
>        $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/f6a || error
> }
> run_test 6b "$RUNAS chmod .../f6a (should return error)""
>
> test_6c() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        touch $DIR/f6c
>        chown $RUNAS_ID $DIR/f6c || error
>        $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/f6c || error
> }
> run_test 6c "touch .../f6c; chown .../f6c"
>
> test_6d() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        if [ ! -f $DIR/f6c ]; then
>                touch $DIR/f6c
>                chown $RUNAS_ID $DIR/f6c
>        fi
>        $RUNAS chown $UID $DIR/f6c && error
>        $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/f6c || error
> }
> run_test 6d "$RUNAS chown .../f6c (should return error)""
>
> test_6e() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        touch $DIR/f6e
>        chgrp $RUNAS_ID $DIR/f6e || error
>        $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/f6e || error
> }
> run_test 6e "touch .../f6e; chgrp .../f6e"
>
> test_6f() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        if [ ! -f $DIR/f6e ]; then
>                touch $DIR/f6e
>                chgrp $RUNAS_ID $DIR/f6e
>        fi
>        $RUNAS chgrp $UID $DIR/f6e && error
>        $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/f6e || error
> }
> run_test 6f "$RUNAS chgrp .../f6e (should return error)""
>
> test_6g() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        mkdir $DIR/d6g || error
>        chmod 777 $DIR/d6g || error
>        $RUNAS mkdir $DIR/d6g/d || error
>        chmod g+s $DIR/d6g/d || error
>        mkdir $DIR/d6g/d/subdir
>        $CHECKSTAT -g \#$RUNAS_ID $DIR/d6g/d/subdir || error
> }
> run_test 6g "Is new dir in sgid dir inheriting group?"
>
> test_6h() { # bug 7331
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        touch $DIR/f6h || error "touch failed"
>        chown $RUNAS_ID:$RUNAS_ID $DIR/f6h || error "initial chown failed"
>        $RUNAS -G$RUNAS_ID chown $RUNAS_ID:0 $DIR/f6h && error "chown
> worked"
>        $CHECKSTAT -t file -u \#$RUNAS_ID -g \#$RUNAS_ID $DIR/f6h || error
> }
> run_test 6h "$RUNAS chown RUNAS_ID.0 .../f6h (should return error)"
>
> test_7a() {
>        mkdir $DIR/d7
>        $MCREATE $DIR/d7/f
>        chmod 0666 $DIR/d7/f
>        $CHECKSTAT -t file -p 0666 $DIR/d7/f || error
> }
> run_test 7a "mkdir .../d7; mcreate .../d7/f; chmod .../d7/f""
>
> test_7b() {
>        if [ ! -d $DIR/d7 ]; then
>                mkdir $DIR/d7
>        fi
>        $MCREATE $DIR/d7/f2
>        echo -n foo > $DIR/d7/f2
>        [ "`cat $DIR/d7/f2`"" "foo" ] || error
>        $CHECKSTAT -t file -s 3 $DIR/d7/f2 || error
> }
> run_test 7b "mkdir .../d7; mcreate d7/f2; echo foo > d7/f2"
>
> test_8() {
>        mkdir $DIR/d8
>        touch $DIR/d8/f
>        chmod 0666 $DIR/d8/f
>        $CHECKSTAT -t file -p 0666 $DIR/d8/f || error
> }
> run_test 8 "mkdir .../d8; touch .../d8/f; chmod .../d8/f"
>
> test_9() {
>        mkdir $DIR/d9
>        mkdir $DIR/d9/d2
>        mkdir $DIR/d9/d2/d3
>        $CHECKSTAT -t dir $DIR/d9/d2/d3 || error
> }
> run_test 9 "mkdir .../d9 .../d9/d2 .../d9/d2/d3"
>
> test_10() {
>        mkdir $DIR/d10
>        mkdir $DIR/d10/d2
>        touch $DIR/d10/d2/f
>        $CHECKSTAT -t file $DIR/d10/d2/f || error
> }
> run_test 10 "mkdir .../d10 .../d10/d2; touch .../d10/d2/f"
>
> test_11() {
>        mkdir $DIR/d11
>        mkdir $DIR/d11/d2
>        chmod 0666 $DIR/d11/d2
>        chmod 0705 $DIR/d11/d2
>        $CHECKSTAT -t dir -p 0705 $DIR/d11/d2 || error
> }
> run_test 11 "mkdir .../d11 d11/d2; chmod .../d11/d2"
>
> test_12() {
>        mkdir $DIR/d12
>        touch $DIR/d12/f
>        chmod 0666 $DIR/d12/f
>        chmod 0654 $DIR/d12/f
>        $CHECKSTAT -t file -p 0654 $DIR/d12/f || error
> }
> run_test 12 "touch .../d12/f; chmod .../d12/f .../d12/f"
>
> test_13() {
>        mkdir $DIR/d13
>        dd if=/dev/zero of=$DIR/d13/f count=10
>        >  $DIR/d13/f
>        $CHECKSTAT -t file -s 0 $DIR/d13/f || error
> }
> run_test 13 "creat .../d13/f; dd .../d13/f; > .../d13/f"
>
> test_14() {
>        mkdir $DIR/d14
>        touch $DIR/d14/f
>        rm $DIR/d14/f
>        $CHECKSTAT -a $DIR/d14/f || error
> }
> run_test 14 "touch .../d14/f; rm .../d14/f; rm .../d14/f"
>
> test_15() {
>        mkdir $DIR/d15
>        touch $DIR/d15/f
>        mv $DIR/d15/f $DIR/d15/f2
>        $CHECKSTAT -t file $DIR/d15/f2 || error
> }
> run_test 15 "touch .../d15/f; mv .../d15/f .../d15/f2"
>
> test_16() {
>        mkdir $DIR/d16
>        touch $DIR/d16/f
>        rm -rf $DIR/d16/f
>        $CHECKSTAT -a $DIR/d16/f || error
> }
> run_test 16 "touch .../d16/f; rm -rf .../d16/f"
>
> test_17a() {
>        mkdir -p $DIR/d17
>        touch $DIR/d17/f
>        ln -s $DIR/d17/f $DIR/d17/l-exist
>        ls -l $DIR/d17
>        $CHECKSTAT -l $DIR/d17/f $DIR/d17/l-exist || error
>        $CHECKSTAT -f -t f $DIR/d17/l-exist || error
>        rm -f $DIR/d17/l-exist
>        $CHECKSTAT -a $DIR/d17/l-exist || error
> }
> run_test 17a "symlinks: create, remove (real)"
>
> test_17b() {
>        mkdir -p $DIR/d17
>        ln -s no-such-file $DIR/d17/l-dangle
>        ls -l $DIR/d17
>        $CHECKSTAT -l no-such-file $DIR/d17/l-dangle || error
>        $CHECKSTAT -fa $DIR/d17/l-dangle || error
>        rm -f $DIR/d17/l-dangle
>        $CHECKSTAT -a $DIR/d17/l-dangle || error
> }
> run_test 17b "symlinks: create, remove (dangling)"
>
> test_17c() { # bug 3440 - don't save failed open RPC for replay
>        mkdir -p $DIR/d17
>        ln -s foo $DIR/d17/f17c
>        cat $DIR/d17/f17c && error "opened non-existent symlink" || true
> }
> run_test 17c "symlinks: open dangling (should return error)""
>
> test_17d() {
>        mkdir -p $DIR/d17
>        ln -s foo $DIR/d17/f17d
>        touch $DIR/d17/f17d || error "creating to new symlink"
> }
> run_test 17d "symlinks: create dangling"
>
> test_17e() {
>        mkdir -p $DIR/$tdir
>        local foo=$DIR/$tdir/$tfile
>        ln -s $foo $foo || error "create symlink failed"
>        ls -l $foo || error "ls -l failed"
>        ls $foo && error "ls not failed" || true
> }
> run_test 17e "symlinks: create recursive symlink (should return error)""
>
> test_17f() {
>        mkdir -p $DIR/d17f
>        ln -s 1234567890/2234567890/3234567890/4234567890 $DIR/d17f/111
>        ln -s
> 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890
> $DIR/d17f/222
>        ln -s
> 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890
> $DIR/d17f/333
>        ln -s
> 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890
> $DIR/d17f/444
>        ln -s
> 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890
> $DIR/d17f/555
>        ln -s
> 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890/aaaaaaaaaa/bbbbbbbbbb/cccccccccc/dddddddddd/eeeeeeeeee/ffffffffff/
> $DIR/d17f/666
>        ls -l  $DIR/d17f
> }
> run_test 17f "symlinks: long and very long symlink name"
>
> test_17g() {
>        mkdir -p $DIR/$tdir
>        LONGSYMLINK="$(dd if=/dev/zero bs=4095 count=1 | tr '\0' 'x')"
>        ln -s $LONGSYMLINK $DIR/$tdir/$tfile
>        ls -l $DIR/$tdir
> }
> run_test 17g "symlinks: really long symlink name"
>
> test_17h() { #bug 17378
>        mkdir -p $DIR/$tdir
>        $SETSTRIPE $DIR/$tdir -c -1
> #define OBD_FAIL_MDS_LOV_PREP_CREATE 0x141
>        do_facet mds lctl set_param fail_loc=0x80000141
>        touch $DIR/$tdir/$tfile || true
> }
> run_test 17h "create objects: lov_free_memmd() doesn't lbug"
>
> test_18() {
>        touch $DIR/f
>        ls $DIR || error
> }
> run_test 18 "touch .../f ; ls ..."
>
> test_19a() {
>        touch $DIR/f19
>        ls -l $DIR
>        rm $DIR/f19
>        $CHECKSTAT -a $DIR/f19 || error
> }
> run_test 19a "touch .../f19 ; ls -l ... ; rm .../f19"
>
> test_19b() {
>        ls -l $DIR/f19 && error || true
> }
> run_test 19b "ls -l .../f19 (should return error)"
>
> test_19c() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        $RUNAS touch $DIR/f19 && error || true
> }
> run_test 19c "$RUNAS touch .../f19 (should return error)""
>
> test_19d() {
>        cat $DIR/f19 && error || true
> }
> run_test 19d "cat .../f19 (should return error)"
>
> test_20() {
>        touch $DIR/f
>        rm $DIR/f
>        log "1 done"
>        touch $DIR/f
>        rm $DIR/f
>        log "2 done"
>        touch $DIR/f
>        rm $DIR/f
>        log "3 done"
>        $CHECKSTAT -a $DIR/f || error
> }
> run_test 20 "touch .../f ; ls -l ..."
>
> test_21() {
>        mkdir $DIR/d21
>        [ -f $DIR/d21/dangle ] && rm -f $DIR/d21/dangle
>        ln -s dangle $DIR/d21/link
>        echo foo >> $DIR/d21/link
>        cat $DIR/d21/dangle
>        $CHECKSTAT -t link $DIR/d21/link || error
>        $CHECKSTAT -f -t file $DIR/d21/link || error
> }
> run_test 21 "write to dangling link"
>
> test_22() {
>        WDIR=$DIR/$tdir
>        mkdir -p $WDIR
>        chown $RUNAS_ID $WDIR
>        (cd $WDIR || error "cd $WDIR failed";
>        $RUNAS tar cf - /etc/hosts /etc/sysconfig/network | \
>        $RUNAS tar xf -)
>        ls -lR $WDIR/etc || error "ls -lR $WDIR/etc failed"
>        $CHECKSTAT -t dir $WDIR/etc || error "checkstat -t dir failed"
>        $CHECKSTAT -u \#$RUNAS_ID $WDIR/etc || error "checkstat -u failed"
> }
> run_test 22 "unpack tar archive as non-root user"
>
> test_23() {
>        mkdir -p $DIR/$tdir
>        local file=$DIR/$tdir/$tfile
>
>        openfile -f O_CREAT:O_EXCL $file || error "$file create failed"
>        openfile -f O_CREAT:O_EXCL $file &&
>                error "$file recreate succeeded" || true
> }
> run_test 23 "O_CREAT|O_EXCL in subdir"
>
> test_24a() {
>        echo '== rename sanity"
>        echo '-- same directory rename'
>        mkdir $DIR/R1
>        touch $DIR/R1/f
>        mv $DIR/R1/f $DIR/R1/g
>        $CHECKSTAT -t file $DIR/R1/g || error
> }
> run_test 24a "touch .../R1/f; rename .../R1/f .../R1/g"
>
> test_24b() {
>        mkdir $DIR/R2
>        touch $DIR/R2/{f,g}
>        mv $DIR/R2/f $DIR/R2/g
>        $CHECKSTAT -a $DIR/R2/f || error
>        $CHECKSTAT -t file $DIR/R2/g || error
> }
> run_test 24b "touch .../R2/{f,g}; rename .../R2/f .../R2/g"
>
> test_24c() {
>        mkdir $DIR/R3
>        mkdir $DIR/R3/f
>        mv $DIR/R3/f $DIR/R3/g
>        $CHECKSTAT -a $DIR/R3/f || error
>        $CHECKSTAT -t dir $DIR/R3/g || error
> }
> run_test 24c "mkdir .../R3/f; rename .../R3/f .../R3/g"
>
> test_24d() {
>        mkdir $DIR/R4
>        mkdir $DIR/R4/{f,g}
>        mrename $DIR/R4/f $DIR/R4/g
>        $CHECKSTAT -a $DIR/R4/f || error
>        $CHECKSTAT -t dir $DIR/R4/g || error
> }
> run_test 24d "mkdir .../R4/{f,g}; rename .../R4/f .../R4/g"
>
> test_24e() {
>        echo '-- cross directory renames --'
>        mkdir $DIR/R5{a,b}
>        touch $DIR/R5a/f
>        mv $DIR/R5a/f $DIR/R5b/g
>        $CHECKSTAT -a $DIR/R5a/f || error
>        $CHECKSTAT -t file $DIR/R5b/g || error
> }
> run_test 24e "touch .../R5a/f; rename .../R5a/f .../R5b/g"
>
> test_24f() {
>        mkdir $DIR/R6{a,b}
>        touch $DIR/R6a/f $DIR/R6b/g
>        mv $DIR/R6a/f $DIR/R6b/g
>        $CHECKSTAT -a $DIR/R6a/f || error
>        $CHECKSTAT -t file $DIR/R6b/g || error
> }
> run_test 24f "touch .../R6a/f R6b/g; mv .../R6a/f .../R6b/g""
>
> test_24g() {
>        mkdir $DIR/R7{a,b}
>        mkdir $DIR/R7a/d
>        mv $DIR/R7a/d $DIR/R7b/e
>        $CHECKSTAT -a $DIR/R7a/d || error
>        $CHECKSTAT -t dir $DIR/R7b/e || error
> }
> run_test 24g "mkdir .../R7{a,b}/d; mv .../R7a/d .../R7b/e"
>
> test_24h() {
>        mkdir $DIR/R8{a,b}
>        mkdir $DIR/R8a/d $DIR/R8b/e
>        mrename $DIR/R8a/d $DIR/R8b/e
>        $CHECKSTAT -a $DIR/R8a/d || error
>        $CHECKSTAT -t dir $DIR/R8b/e || error
> }
> run_test 24h "mkdir .../R8{a,b}/{d,e}; rename .../R8a/d .../R8b/e"
>
> test_24i() {
>        echo "-- rename error cases"
>        mkdir $DIR/R9
>        mkdir $DIR/R9/a
>        touch $DIR/R9/f
>        mrename $DIR/R9/f $DIR/R9/a
>        $CHECKSTAT -t file $DIR/R9/f || error
>        $CHECKSTAT -t dir  $DIR/R9/a || error
>        $CHECKSTAT -a $DIR/R9/a/f || error
> }
> run_test 24i "rename file to dir error: touch f ; mkdir a ; rename f a"
>
> test_24j() {
>        mkdir $DIR/R10
>        mrename $DIR/R10/f $DIR/R10/g
>        $CHECKSTAT -t dir $DIR/R10 || error
>        $CHECKSTAT -a $DIR/R10/f || error
>        $CHECKSTAT -a $DIR/R10/g || error
> }
> run_test 24j "source does not exist"
>
> test_24k() {
>        mkdir $DIR/R11a $DIR/R11a/d
>        touch $DIR/R11a/f
>        mv $DIR/R11a/f $DIR/R11a/d
>        $CHECKSTAT -a $DIR/R11a/f || error
>        $CHECKSTAT -t file $DIR/R11a/d/f || error
> }
> run_test 24k "touch .../R11a/f; mv .../R11a/f .../R11a/d"
>
> # bug 2429 - rename foo foo foo creates invalid file
> test_24l() {
>        f="$DIR/f24l"
>        multiop $f OcNs || error
> }
> run_test 24l "Renaming a file to itself"
>
> test_24m() {
>        f="$DIR/f24m"
>        multiop $f OcLN ${f}2 ${f}2 || error "link ${f}2 ${f}2 failed"
>        # on ext3 this does not remove either the source or target files
>        # though the "expected" operation would be to remove the source
>        $CHECKSTAT -t file ${f} || error "${f} missing"
>        $CHECKSTAT -t file ${f}2 || error "${f}2 missing"
> }
> run_test 24m "Renaming a file to a hard link to itself"
>
> test_24n() {
>    f="$DIR/f24n"
>    # this stats the old file after it was renamed, so it should fail
>    touch ${f}
>    $CHECKSTAT ${f}
>    mv ${f} ${f}.rename
>    $CHECKSTAT ${f}.rename
>    $CHECKSTAT -a ${f}
> }
> run_test 24n "Statting the old file after renaming (Posix rename 2)"
>
> test_24o() {
>        check_kernel_version 37 || return 0
>        mkdir -p $DIR/d24o
>        rename_many -s random -v -n 10 $DIR/d24o
> }
> run_test 24o "rename of files during htree split"
>
> test_24p() {
>        mkdir $DIR/R12{a,b}
>        DIRINO=`ls -lid $DIR/R12a | awk '{ print $1 }'`
>        mrename $DIR/R12a $DIR/R12b
>        $CHECKSTAT -a $DIR/R12a || error
>        $CHECKSTAT -t dir $DIR/R12b || error
>        DIRINO2=`ls -lid $DIR/R12b | awk '{ print $1 }'`
>        [ "$DIRINO"" "$DIRINO2" ] || error "R12a $DIRINO != R12b $DIRINO2"
> }
> run_test 24p "mkdir .../R12{a,b}; rename .../R12a .../R12b"
>
> test_24q() {
>        mkdir $DIR/R13{a,b}
>        DIRINO=`ls -lid $DIR/R13a | awk '{ print $1 }'`
>        multiop_bg_pause $DIR/R13b D_c || return 1
>        MULTIPID=$!
>
>        mrename $DIR/R13a $DIR/R13b
>        $CHECKSTAT -a $DIR/R13a || error
>        $CHECKSTAT -t dir $DIR/R13b || error
>        DIRINO2=`ls -lid $DIR/R13b | awk '{ print $1 }'`
>        [ "$DIRINO"" "$DIRINO2" ] || error "R13a $DIRINO != R13b $DIRINO2"
>        kill -USR1 $MULTIPID
>        wait $MULTIPID || error "multiop close failed"
> }
> run_test 24q "mkdir .../R13{a,b}; open R13b rename R13a R13b""
>
> test_24r() { #bug 3789
>        mkdir $DIR/R14a $DIR/R14a/b
>        mrename $DIR/R14a $DIR/R14a/b && error "rename to subdir worked!"
>        $CHECKSTAT -t dir $DIR/R14a || error "$DIR/R14a missing"
>        $CHECKSTAT -t dir $DIR/R14a/b || error "$DIR/R14a/b missing"
> }
> run_test 24r "mkdir .../R14a/b; rename .../R14a .../R14a/b"
>
> test_24s() {
>        mkdir $DIR/R15a $DIR/R15a/b $DIR/R15a/b/c
>        mrename $DIR/R15a $DIR/R15a/b/c && error "rename to sub-subdir
> worked!"
>        $CHECKSTAT -t dir $DIR/R15a || error "$DIR/R15a missing"
>        $CHECKSTAT -t dir $DIR/R15a/b/c || error "$DIR/R15a/b/c missing"
> }
> run_test 24s "mkdir .../R15a/b/c; rename .../R15a .../R15a/b/c""
> test_24t() {
>        mkdir $DIR/R16a $DIR/R16a/b $DIR/R16a/b/c
>        mrename $DIR/R16a/b/c $DIR/R16a && error "rename to sub-subdir
> worked!"
>        $CHECKSTAT -t dir $DIR/R16a || error "$DIR/R16a missing"
>        $CHECKSTAT -t dir $DIR/R16a/b/c || error "$DIR/R16a/b/c missing"
> }
> run_test 24t "mkdir .../R16a/b/c; rename .../R16a/b/c .../R16a""
>
> test_24u() { # bug12192
>        multiop $DIR/$tfile C2w$((2048 * 1024))c || error
>        $CHECKSTAT -s $((2048 * 1024)) $DIR/$tfile || error "wrong file
> size"
> }
> run_test 24u "create stripe file"
>
> test_25a() {
>        echo '== symlink sanity"
>
>        mkdir $DIR/d25
>        ln -s d25 $DIR/s25
>        touch $DIR/s25/foo || error
> }
> run_test 25a "create file in symlinked directory"
>
> test_25b() {
>        [ ! -d $DIR/d25 ] && test_25a
>        $CHECKSTAT -t file $DIR/s25/foo || error
> }
> run_test 25b "lookup file in symlinked directory""
>
> test_26a() {
>        mkdir $DIR/d26
>        mkdir $DIR/d26/d26-2
>        ln -s d26/d26-2 $DIR/s26
>        touch $DIR/s26/foo || error
> }
> run_test 26a "multiple component symlink""
>
> test_26b() {
>        mkdir -p $DIR/d26b/d26-2
>        ln -s d26b/d26-2/foo $DIR/s26-2
>        touch $DIR/s26-2 || error
> }
> run_test 26b "multiple component symlink at end of lookup""
>
> test_26c() {
>        mkdir $DIR/d26.2
>        touch $DIR/d26.2/foo
>        ln -s d26.2 $DIR/s26.2-1
>        ln -s s26.2-1 $DIR/s26.2-2
>        ln -s s26.2-2 $DIR/s26.2-3
>        chmod 0666 $DIR/s26.2-3/foo
> }
> run_test 26c "chain of symlinks""
>
> # recursive symlinks (bug 439)
> test_26d() {
>        ln -s d26-3/foo $DIR/d26-3
> }
> run_test 26d "create multiple component recursive symlink""
>
> test_26e() {
>        [ ! -h $DIR/d26-3 ] && test_26d
>        rm $DIR/d26-3
> }
> run_test 26e "unlink multiple component recursive symlink""
>
> # recursive symlinks (bug 7022)
> test_26f() {
>        mkdir -p $DIR/$tdir
>        mkdir $DIR/$tdir/$tfile        || error "mkdir $DIR/$tdir/$tfile
> failed"
>        cd $DIR/$tdir/$tfile           || error "cd $DIR/$tdir/$tfile
> failed"
>        mkdir -p lndir/bar1      || error "mkdir lndir/bar1 failed"
>        mkdir $tfile             || error "mkdir $tfile failed"
>        cd $tfile                || error "cd $tfile failed"
>        ln -s .. dotdot          || error "ln dotdot failed"
>        ln -s dotdot/lndir lndir || error "ln lndir failed"
>        cd $DIR/$tdir                 || error "cd $DIR/$tdir failed"
>        output=`ls $tfile/$tfile/lndir/bar1`
>        [ "$output"" bar1 ] && error "unexpected output"
>        rm -r $tfile             || error "rm $tfile failed"
>        $CHECKSTAT -a $DIR/$tfile || error "$tfile not gone"
> }
> run_test 26f "rm -r of a directory which has recursive symlink""
>
> # createtest also checks that device nodes are created and
> # then visible correctly (#2091)
> test_28() { # bug 2091
>        mkdir $DIR/d28
>        $CREATETEST $DIR/d28/ct || error
> }
> run_test 28 "create/mknod/mkdir with bad file types""
>
> test_30() {
>        cp `which ls` $DIR || cp /bin/ls $DIR
>        $DIR/ls /
>        rm $DIR/ls
> }
> run_test 30 "run binary from Lustre (execve)""
>
> test_31a() {
>        $OPENUNLINK $DIR/f31 $DIR/f31 || error
>        $CHECKSTAT -a $DIR/f31 || error
> }
> run_test 31a "open-unlink file""
>
> test_31b() {
>        touch $DIR/f31 || error
>        ln $DIR/f31 $DIR/f31b || error
>        multiop $DIR/f31b Ouc || error
>        $CHECKSTAT -t file $DIR/f31 || error
> }
> run_test 31b "unlink file with multiple links while open""
>
> test_31c() {
>        touch $DIR/f31 || error
>        ln $DIR/f31 $DIR/f31c || error
>        multiop_bg_pause $DIR/f31 O_uc || return 1
>        MULTIPID=$!
>        multiop $DIR/f31c Ouc
>        kill -USR1 $MULTIPID
>        wait $MULTIPID
> }
> run_test 31c "open-unlink file with multiple links""
>
> test_31d() {
>        opendirunlink $DIR/d31d $DIR/d31d || error
>        $CHECKSTAT -a $DIR/d31d || error
> }
> run_test 31d "remove of open directory""
>
> test_31e() { # bug 2904
>        check_kernel_version 34 || return 0
>        openfilleddirunlink $DIR/d31e || error
> }
> run_test 31e "remove of open non-empty directory""
>
> test_31f() { # bug 4554
>        set -vx
>        mkdir $DIR/d31f
>        $SETSTRIPE $DIR/d31f -s 1048576 -c 1
>        cp /etc/hosts $DIR/d31f
>        ls -l $DIR/d31f
>        multiop_bg_pause $DIR/d31f D_c || return 1
>        MULTIPID=$!
>
>        rm -rv $DIR/d31f || error "first of $DIR/d31f"
>        mkdir $DIR/d31f
>        $SETSTRIPE $DIR/d31f -s 1048576 -c 1
>        cp /etc/hosts $DIR/d31f
>        ls -l $DIR/d31f
>        $DIR/d31f/hosts
>        multiop_bg_pause $DIR/d31f D_c || return 1
>        MULTIPID2=$!
>
>        kill -USR1 $MULTIPID || error "first opendir $MULTIPID not running"
>        wait $MULTIPID || error "first opendir $MULTIPID failed"
>
>        sleep 6
>
>        kill -USR1 $MULTIPID2 || error "second opendir $MULTIPID not
> running"
>        wait $MULTIPID2 || error "second opendir $MULTIPID2 failed"
>        set +vx
> }
> run_test 31f "remove of open directory with open-unlink file""
>
> test_31g() {
>        echo "-- cross directory link --"
>        mkdir $DIR/d31g{a,b}
>        touch $DIR/d31ga/f
>        ln $DIR/d31ga/f $DIR/d31gb/g
>        $CHECKSTAT -t file $DIR/d31ga/f || error "source"
>        [ `stat -c%h $DIR/d31ga/f`" '2' ] || error "source nlink"
>        $CHECKSTAT -t file $DIR/d31gb/g || error "target"
>        [ `stat -c%h $DIR/d31gb/g`" '2' ] || error "target nlink"
> }
> run_test 31g "cross directory link==============="
>
> test_31h() {
>        echo "-- cross directory link --"
>        mkdir $DIR/d31h
>        mkdir $DIR/d31h/dir
>        touch $DIR/d31h/f
>        ln $DIR/d31h/f $DIR/d31h/dir/g
>        $CHECKSTAT -t file $DIR/d31h/f || error "source"
>        [ `stat -c%h $DIR/d31h/f`" '2' ] || error "source nlink"
>        $CHECKSTAT -t file $DIR/d31h/dir/g || error "target"
>        [ `stat -c%h $DIR/d31h/dir/g`" '2' ] || error "target nlink"
> }
> run_test 31h "cross directory link under child==============="
>
> test_31i() {
>        echo "-- cross directory link --"
>        mkdir $DIR/d31i
>        mkdir $DIR/d31i/dir
>        touch $DIR/d31i/dir/f
>        ln $DIR/d31i/dir/f $DIR/d31i/g
>        $CHECKSTAT -t file $DIR/d31i/dir/f || error "source"
>        [ `stat -c%h $DIR/d31i/dir/f`" '2' ] || error "source nlink"
>        $CHECKSTAT -t file $DIR/d31i/g || error "target"
>        [ `stat -c%h $DIR/d31i/g`" '2' ] || error "target nlink"
> }
> run_test 31i "cross directory link under parent==============="
>
>
> test_31j() {
>        mkdir $DIR/d31j
>        mkdir $DIR/d31j/dir1
>        ln $DIR/d31j/dir1 $DIR/d31j/dir2 && error "ln for dir"
>        link $DIR/d31j/dir1 $DIR/d31j/dir3 && error "link for dir"
>        mlink $DIR/d31j/dir1 $DIR/d31j/dir4 && error "mlink for dir"
>        mlink $DIR/d31j/dir1 $DIR/d31j/dir1 && error "mlink to the same dir"
>        return 0
> }
> run_test 31j "link for directory==============="
>
>
> test_31k() {
>        mkdir $DIR/d31k
>        touch $DIR/d31k/s
>        touch $DIR/d31k/exist
>        mlink $DIR/d31k/s $DIR/d31k/t || error "mlink"
>        mlink $DIR/d31k/s $DIR/d31k/exist && error "mlink to exist file"
>        mlink $DIR/d31k/s $DIR/d31k/s && error "mlink to the same file"
>        mlink $DIR/d31k/s $DIR/d31k && error "mlink to parent dir"
>        mlink $DIR/d31k $DIR/d31k/s && error "mlink parent dir to target"
>        mlink $DIR/d31k/not-exist $DIR/d31k/foo && error "mlink non-existing
> to new"
>        mlink $DIR/d31k/not-exist $DIR/d31k/s && error "mlink non-existing
> to exist"
>        return 0
> }
> run_test 31k "link to file: the same, non-existing, dir==============="
>
> test_31m() {
>        mkdir $DIR/d31m
>        touch $DIR/d31m/s
>        mkdir $DIR/d31m2
>        touch $DIR/d31m2/exist
>        mlink $DIR/d31m/s $DIR/d31m2/t || error "mlink"
>        mlink $DIR/d31m/s $DIR/d31m2/exist && error "mlink to exist file"
>        mlink $DIR/d31m/s $DIR/d31m2 && error "mlink to parent dir"
>        mlink $DIR/d31m2 $DIR/d31m/s && error "mlink parent dir to target"
>        mlink $DIR/d31m/not-exist $DIR/d31m2/foo && error "mlink
> non-existing to new"
>        mlink $DIR/d31m/not-exist $DIR/d31m2/s && error "mlink non-existing
> to exist"
>        return 0
> }
> run_test 31m "link to file: the same, non-existing, dir==============="
>
> test_32a() {
>        echo "== more mountpoints and symlinks""
>        [ -e $DIR/d32a ] && rm -fr $DIR/d32a
>        mkdir -p $DIR/d32a/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32a/ext2-mountpoint || error
>        $CHECKSTAT -t dir $DIR/d32a/ext2-mountpoint/.. || error
>        $UMOUNT $DIR/d32a/ext2-mountpoint || error
> }
> run_test 32a "stat d32a/ext2-mountpoint/..""
>
> test_32b() {
>        [ -e $DIR/d32b ] && rm -fr $DIR/d32b
>        mkdir -p $DIR/d32b/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32b/ext2-mountpoint || error
>        ls -al $DIR/d32b/ext2-mountpoint/.. || error
>        $UMOUNT $DIR/d32b/ext2-mountpoint || error
> }
> run_test 32b "open d32b/ext2-mountpoint/..""
>
> test_32c() {
>        [ -e $DIR/d32c ] && rm -fr $DIR/d32c
>        mkdir -p $DIR/d32c/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32c/ext2-mountpoint || error
>        mkdir -p $DIR/d32c/d2/test_dir
>        $CHECKSTAT -t dir $DIR/d32c/ext2-mountpoint/../d2/test_dir || error
>        $UMOUNT $DIR/d32c/ext2-mountpoint || error
> }
> run_test 32c "stat d32c/ext2-mountpoint/../d2/test_dir""
>
> test_32d() {
>        [ -e $DIR/d32d ] && rm -fr $DIR/d32d
>        mkdir -p $DIR/d32d/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32d/ext2-mountpoint || error
>        mkdir -p $DIR/d32d/d2/test_dir
>        ls -al $DIR/d32d/ext2-mountpoint/../d2/test_dir || error
>        $UMOUNT $DIR/d32d/ext2-mountpoint || error
> }
> run_test 32d "open d32d/ext2-mountpoint/../d2/test_dir""
>
> test_32e() {
>        [ -e $DIR/d32e ] && rm -fr $DIR/d32e
>        mkdir -p $DIR/d32e/tmp
>        TMP_DIR=$DIR/d32e/tmp
>        ln -s $DIR/d32e $TMP_DIR/symlink11
>        ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
>        $CHECKSTAT -t link $DIR/d32e/tmp/symlink11 || error
>        $CHECKSTAT -t link $DIR/d32e/symlink01 || error
> }
> run_test 32e "stat d32e/symlink->tmp/symlink->lustre-subdir""
>
> test_32f() {
>        [ -e $DIR/d32f ] && rm -fr $DIR/d32f
>        mkdir -p $DIR/d32f/tmp
>        TMP_DIR=$DIR/d32f/tmp
>        ln -s $DIR/d32f $TMP_DIR/symlink11
>        ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
>        ls $DIR/d32f/tmp/symlink11  || error
>        ls $DIR/d32f/symlink01 || error
> }
> run_test 32f "open d32f/symlink->tmp/symlink->lustre-subdir""
>
> test_32g() {
>        TMP_DIR=$DIR/$tdir/tmp
>        mkdir -p $TMP_DIR $DIR/${tdir}2
>        ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
>        ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
>        $CHECKSTAT -t link $TMP_DIR/symlink12 || error
>        $CHECKSTAT -t link $DIR/$tdir/symlink02 || error
>        $CHECKSTAT -t dir -f $TMP_DIR/symlink12 || error
>        $CHECKSTAT -t dir -f $DIR/$tdir/symlink02 || error
> }
> run_test 32g "stat d32g/symlink->tmp/symlink->lustre-subdir/${tdir}2"
>
> test_32h() {
>        rm -fr $DIR/$tdir $DIR/${tdir}2
>        TMP_DIR=$DIR/$tdir/tmp
>        mkdir -p $TMP_DIR $DIR/${tdir}2
>        ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
>        ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
>        ls $TMP_DIR/symlink12 || error
>        ls $DIR/$tdir/symlink02  || error
> }
> run_test 32h "open d32h/symlink->tmp/symlink->lustre-subdir/${tdir}2"
>
> test_32i() {
>        [ -e $DIR/d32i ] && rm -fr $DIR/d32i
>        mkdir -p $DIR/d32i/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32i/ext2-mountpoint || error
>        touch $DIR/d32i/test_file
>        $CHECKSTAT -t file $DIR/d32i/ext2-mountpoint/../test_file || error
>        $UMOUNT $DIR/d32i/ext2-mountpoint || error
> }
> run_test 32i "stat d32i/ext2-mountpoint/../test_file""
>
> test_32j() {
>        [ -e $DIR/d32j ] && rm -fr $DIR/d32j
>        mkdir -p $DIR/d32j/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32j/ext2-mountpoint || error
>        touch $DIR/d32j/test_file
>        cat $DIR/d32j/ext2-mountpoint/../test_file || error
>        $UMOUNT $DIR/d32j/ext2-mountpoint || error
> }
> run_test 32j "open d32j/ext2-mountpoint/../test_file""
>
> test_32k() {
>        rm -fr $DIR/d32k
>        mkdir -p $DIR/d32k/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32k/ext2-mountpoint
>        mkdir -p $DIR/d32k/d2
>        touch $DIR/d32k/d2/test_file || error
>        $CHECKSTAT -t file $DIR/d32k/ext2-mountpoint/../d2/test_file ||
> error
>        $UMOUNT $DIR/d32k/ext2-mountpoint || error
> }
> run_test 32k "stat d32k/ext2-mountpoint/../d2/test_file""
>
> test_32l() {
>        rm -fr $DIR/d32l
>        mkdir -p $DIR/d32l/ext2-mountpoint
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32l/ext2-mountpoint || error
>        mkdir -p $DIR/d32l/d2
>        touch $DIR/d32l/d2/test_file
>        cat  $DIR/d32l/ext2-mountpoint/../d2/test_file || error
>        $UMOUNT $DIR/d32l/ext2-mountpoint || error
> }
> run_test 32l "open d32l/ext2-mountpoint/../d2/test_file""
>
> test_32m() {
>        rm -fr $DIR/d32m
>        mkdir -p $DIR/d32m/tmp
>        TMP_DIR=$DIR/d32m/tmp
>        ln -s $DIR $TMP_DIR/symlink11
>        ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
>        $CHECKSTAT -t link $DIR/d32m/tmp/symlink11 || error
>        $CHECKSTAT -t link $DIR/d32m/symlink01 || error
> }
> run_test 32m "stat d32m/symlink->tmp/symlink->lustre-root""
>
> test_32n() {
>        rm -fr $DIR/d32n
>        mkdir -p $DIR/d32n/tmp
>        TMP_DIR=$DIR/d32n/tmp
>        ln -s $DIR $TMP_DIR/symlink11
>        ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
>        ls -l $DIR/d32n/tmp/symlink11  || error
>        ls -l $DIR/d32n/symlink01 || error
> }
> run_test 32n "open d32n/symlink->tmp/symlink->lustre-root""
>
> test_32o() {
>        rm -fr $DIR/d32o $DIR/$tfile
>        touch $DIR/$tfile
>        mkdir -p $DIR/d32o/tmp
>        TMP_DIR=$DIR/d32o/tmp
>        ln -s $DIR/$tfile $TMP_DIR/symlink12
>        ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
>        $CHECKSTAT -t link $DIR/d32o/tmp/symlink12 || error
>        $CHECKSTAT -t link $DIR/d32o/symlink02 || error
>        $CHECKSTAT -t file -f $DIR/d32o/tmp/symlink12 || error
>        $CHECKSTAT -t file -f $DIR/d32o/symlink02 || error
> }
> run_test 32o "stat d32o/symlink->tmp/symlink->lustre-root/$tfile"
>
> test_32p() {
>    log 32p_1
>        rm -fr $DIR/d32p
>    log 32p_2
>        rm -f $DIR/$tfile
>    log 32p_3
>        touch $DIR/$tfile
>    log 32p_4
>        mkdir -p $DIR/d32p/tmp
>    log 32p_5
>        TMP_DIR=$DIR/d32p/tmp
>    log 32p_6
>        ln -s $DIR/$tfile $TMP_DIR/symlink12
>    log 32p_7
>        ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
>    log 32p_8
>        cat $DIR/d32p/tmp/symlink12 || error
>    log 32p_9
>        cat $DIR/d32p/symlink02 || error
>    log 32p_10
> }
> run_test 32p "open d32p/symlink->tmp/symlink->lustre-root/$tfile"
>
> test_32q() {
>        [ -e $DIR/d32q ] && rm -fr $DIR/d32q
>        mkdir -p $DIR/d32q
>        touch $DIR/d32q/under_the_mount
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32q
>        ls $DIR/d32q/under_the_mount && error || true
>        $UMOUNT $DIR/d32q || error
> }
> run_test 32q "stat follows mountpoints in Lustre (should return error)"
>
> test_32r() {
>        [ -e $DIR/d32r ] && rm -fr $DIR/d32r
>        mkdir -p $DIR/d32r
>        touch $DIR/d32r/under_the_mount
>        mount -t ext2 -o loop $EXT2_DEV $DIR/d32r
>        ls $DIR/d32r | grep -q under_the_mount && error || true
>        $UMOUNT $DIR/d32r || error
> }
> run_test 32r "opendir follows mountpoints in Lustre (should return error)"
>
> test_33() {
>        rm -f $DIR/$tfile
>        touch $DIR/$tfile
>        chmod 444 $DIR/$tfile
>        chown $RUNAS_ID $DIR/$tfile
>        log 33_1
>        $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
>        log 33_2
> }
> run_test 33 "write file with mode 444 (should return error)""
>
> test_33a() {
>        rm -fr $DIR/d33
>        mkdir -p $DIR/d33
>        chown $RUNAS_ID $DIR/d33
>        $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33|| error
> "create"
>        $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33 && \
>                error "open RDWR" || true
> }
> run_test 33a "test open file(mode=0444) with O_RDWR (should return error)"
>
> test_33b() {
>        rm -fr $DIR/d33
>        mkdir -p $DIR/d33
>        chown $RUNAS_ID $DIR/d33
>        $RUNAS $OPENFILE -f 1286739555 $DIR/d33/f33 && error "create" ||
> true
> }
> run_test 33b "test open file with malformed flags (No panic and return
> error)"
>
> TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
> test_34a() {
>        rm -f $DIR/f34
>        $MCREATE $DIR/f34 || error
>        $TRUNCATE $DIR/f34 $TEST_34_SIZE || error
>        $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
> }
> run_test 34a "truncate file that has not been opened""
>
> test_34b() {
>        [ ! -f $DIR/f34 ] && test_34a
>        $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
>        $OPENFILE -f O_RDONLY $DIR/f34
>        $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
> }
> run_test 34b "O_RDONLY opening file doesn't create objects""
>
> test_34c() {
>        [ ! -f $DIR/f34 ] && test_34a
>        $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
>        $OPENFILE -f O_RDWR $DIR/f34
>        $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
> }
> run_test 34c "O_RDWR opening file-with-size works""
>
> test_34d() {
>        [ ! -f $DIR/f34 ] && test_34a
>        dd if=/dev/zero of=$DIR/f34 conv=notrunc bs=4k count=1 || error
>        $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
>        rm $DIR/f34
> }
> run_test 34d "write to sparse file""
>
> test_34e() {
>        rm -f $DIR/f34e
>        $MCREATE $DIR/f34e || error
>        $TRUNCATE $DIR/f34e 1000 || error
>        $CHECKSTAT -s 1000 $DIR/f34e || error
>        $OPENFILE -f O_RDWR $DIR/f34e
>        $CHECKSTAT -s 1000 $DIR/f34e || error
> }
> run_test 34e "create objects, some with size and some without""
>
> test_34f() { # bug 6242, 6243
>        SIZE34F=48000
>        rm -f $DIR/f34f
>        $MCREATE $DIR/f34f || error
>        $TRUNCATE $DIR/f34f $SIZE34F || error "truncating $DIR/f3f to
> $SIZE34F"
>        dd if=$DIR/f34f of=$TMP/f34f
>        $CHECKSTAT -s $SIZE34F $TMP/f34f || error "$TMP/f34f not $SIZE34F
> bytes"
>        dd if=/dev/zero of=$TMP/f34fzero bs=$SIZE34F count=1
>        cmp $DIR/f34f $TMP/f34fzero || error "$DIR/f34f not all zero"
>        cmp $TMP/f34f $TMP/f34fzero || error "$TMP/f34f not all zero"
>        rm $TMP/f34f $TMP/f34fzero $DIR/f34f
> }
> run_test 34f "read from a file with no objects until EOF""
>
> test_35a() {
>        cp /bin/sh $DIR/f35a
>        chmod 444 $DIR/f35a
>        chown $RUNAS_ID $DIR/f35a
>        $RUNAS $DIR/f35a && error || true
>        rm $DIR/f35a
> }
> run_test 35a "exec file with mode 444 (should return and not leak)""
>
> test_36a() {
>        rm -f $DIR/f36
>        utime $DIR/f36 || error
> }
> run_test 36a "MDS utime check (mknod, utime)""
>
> test_36b() {
>        echo "" > $DIR/f36
>        utime $DIR/f36 || error
> }
> run_test 36b "OST utime check (open, utime)""
>
> test_36c() {
>        rm -f $DIR/d36/f36
>        mkdir $DIR/d36
>        chown $RUNAS_ID $DIR/d36
>        $RUNAS utime $DIR/d36/f36 || error
> }
> run_test 36c "non-root MDS utime check (mknod, utime)""
>
> test_36d() {
>        [ ! -d $DIR/d36 ] && test_36c
>        echo "" > $DIR/d36/f36
>        $RUNAS utime $DIR/d36/f36 || error
> }
> run_test 36d "non-root OST utime check (open, utime)""
>
> test_36e() {
>        [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID" UID = $UID -- skipping" &&
> return
>        mkdir -p $DIR/$tdir
>        touch $DIR/$tdir/$tfile
>        $RUNAS utime $DIR/$tdir/$tfile && \
>                error "utime worked, expected failure" || true
> }
> run_test 36e "utime on non-owned file (should return error)""
>
> test_37() {
>        mkdir -p $DIR/$tdir
>        echo f > $DIR/$tdir/fbugfile
>        mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir
>        ls $DIR/$tdir | grep "\<fbugfile\>" && error
>        $UMOUNT $DIR/$tdir || error
>        rm -f $DIR/$tdir/fbugfile || error
> }
> run_test 37 "ls a mounted file system to check old content""
>
> test_38() {
>        local file=$DIR/$tfile
>        touch $file
>        openfile -f O_DIRECTORY $file
>        local RC=$?
>        local ENOTDIR=20
>        [ $RC -eq 0 ] && error "opened file $file with O_DIRECTORY" || true
>        [ $RC -eq $ENOTDIR ] || error "error $RC should be ENOTDIR
> ($ENOTDIR)"
> }
> run_test 38 "open a regular file with O_DIRECTORY should return -ENOTDIR""
>
> test_39() {
>        touch $DIR/$tfile
>        touch $DIR/${tfile}2
> #       ls -l  $DIR/$tfile $DIR/${tfile}2
> #       ls -lu  $DIR/$tfile $DIR/${tfile}2
> #       ls -lc  $DIR/$tfile $DIR/${tfile}2
>        sleep 2
>        $OPENFILE -f O_CREAT:O_TRUNC:O_WRONLY $DIR/${tfile}2
>        if [ ! $DIR/${tfile}2 -nt $DIR/$tfile ]; then
>                echo "mtime"
>                ls -l  $DIR/$tfile $DIR/${tfile}2
>                echo "atime"
>                ls -lu  $DIR/$tfile $DIR/${tfile}2
>                echo "ctime"
>                ls -lc  $DIR/$tfile $DIR/${tfile}2
>                error "O_TRUNC didn't change timestamps"
>        fi
> }
> run_test 39 "mtime changed on create""
>
> test_40() {
>        dd if=/dev/zero of=$DIR/f40 bs=4096 count=1
>        $RUNAS $OPENFILE -f O_WRONLY:O_TRUNC $DIR/f40 && error
>        $CHECKSTAT -t file -s 4096 $DIR/f40 || error
> }
> run_test 40 "failed open(O_TRUNC) doesn't truncate""
>
> test_43() {
>        mkdir -p $DIR/$tdir
>        cp -p /bin/ls $DIR/$tdir/$tfile
>        multiop $DIR/$tdir/$tfile Ow_c &
>        pid=$!
>        # give multiop a chance to open
>        sleep 1
>
>        $DIR/$tdir/$tfile && error || true
>        kill -USR1 $pid
> }
> run_test 43 "execution of file opened for write should return -ETXTBSY"
>
> test_43a() {
>        mkdir -p $DIR/d43
>        cp -p `which multiop` $DIR/d43/multiop || cp -p multiop
> $DIR/d43/multiop
>        MULTIOP_PROG=$DIR/d43/multiop multiop_bg_pause $TMP/test43.junk O_c
> || return 1
>        MULTIOP_PID=$!
>        multiop $DIR/d43/multiop Oc && error "expected error, got success"
>        kill -USR1 $MULTIOP_PID || return 2
>        wait $MULTIOP_PID || return 3
>        rm $TMP/test43.junk
> }
> run_test 43a "open(RDWR) of file being executed should return -ETXTBSY"
>
> test_43b() {
>        mkdir -p $DIR/d43
>        cp -p `which multiop` $DIR/d43/multiop || cp -p multiop
> $DIR/d43/multiop
>        MULTIOP_PROG=$DIR/d43/multiop multiop_bg_pause $TMP/test43.junk O_c
> || return 1
>        MULTIOP_PID=$!
>        truncate $DIR/d43/multiop 0 && error "expected error, got success"
>        kill -USR1 $MULTIOP_PID || return 2
>        wait $MULTIOP_PID || return 3
>        rm $TMP/test43.junk
> }
> run_test 43b "truncate of file being executed should return -ETXTBSY"
>
> page_size() {
>        getconf PAGE_SIZE
> }
>
> test_48a() { # bug 2399
>        mkdir -p $DIR/d48a
>        cd $DIR/d48a
>        mv $DIR/d48a $DIR/d48.new || error "move directory failed"
>        mkdir $DIR/d48a || error "recreate directory failed"
>        touch foo || error "'touch foo' failed after recreating cwd"
>        mkdir bar || error "'mkdir foo' failed after recreating cwd"
>        touch .foo || error "'touch .foo' failed after recreating cwd"
>        mkdir .bar || error "'mkdir .foo' failed after recreating cwd"
>        ls . > /dev/null || error "'ls .' failed after recreating cwd"
>        ls .. > /dev/null || error "'ls ..' failed after removing cwd"
>        cd . || error "'cd .' failed after recreating cwd"
>        mkdir . && error "'mkdir .' worked after recreating cwd"
>        rmdir . && error "'rmdir .' worked after recreating cwd"
>        ln -s . baz || error "'ln -s .' failed after recreating cwd"
>        cd .. || error "'cd ..' failed after recreating cwd"
> }
> run_test 48a "Access renamed working dir (should return errors)="
>
> test_48b() { # bug 2399
>        mkdir -p $DIR/d48b
>        cd $DIR/d48b
>        rmdir $DIR/d48b || error "remove cwd $DIR/d48b failed"
>        touch foo && error "'touch foo' worked after removing cwd"
>        mkdir foo && error "'mkdir foo' worked after removing cwd"
>        touch .foo && error "'touch .foo' worked after removing cwd"
>        mkdir .foo && error "'mkdir .foo' worked after removing cwd"
>        ls . > /dev/null && error "'ls .' worked after removing cwd"
>        ls .. > /dev/null || error "'ls ..' failed after removing cwd"
>        mkdir . && error "'mkdir .' worked after removing cwd"
>        rmdir . && error "'rmdir .' worked after removing cwd"
>        ln -s . foo && error "'ln -s .' worked after removing cwd"
>        cd .. || echo "'cd ..' failed after removing cwd `pwd`"  #bug 3517
> }
> run_test 48b "Access removed working dir (should return errors)="
>
> test_48c() { # bug 2350
>        mkdir -p $DIR/d48c/dir
>        cd $DIR/d48c/dir
>        rmdir $DIR/d48c/dir || error "remove cwd $DIR/d48c/dir failed"
>        touch foo && error "'touch foo' worked after removing cwd"
>        mkdir foo && error "'mkdir foo' worked after removing cwd"
>        touch .foo && error "'touch .foo' worked after removing cwd"
>        mkdir .foo && error "'mkdir .foo' worked after removing cwd"
>        ls . && error "'ls .' worked after removing cwd"
>        ls .. || error "'ls ..' failed after removing cwd"
>        mkdir . && error "'mkdir .' worked after removing cwd"
>        rmdir . && error "'rmdir .' worked after removing cwd"
>        ln -s . foo && error "'ln -s .' worked after removing cwd"
>        cd .. || echo "'cd ..' failed after removing cwd `pwd`" #bug 3415
> }
> run_test 48c "Access removed working subdir (should return errors)"
>
> test_48d() { # bug 2350
>        mkdir -p $DIR/d48d/dir
>        cd $DIR/d48d/dir
>        rmdir $DIR/d48d/dir || error "remove cwd $DIR/d48d/dir failed"
>        rmdir $DIR/d48d || error "remove parent $DIR/d48d failed"
>        touch foo && error "'touch foo' worked after removing parent"
>        mkdir foo && error "'mkdir foo' worked after removing parent"
>        touch .foo && error "'touch .foo' worked after removing parent"
>        mkdir .foo && error "'mkdir .foo' worked after removing parent"
>        ls . && error "'ls .' worked after removing parent"
>        ls .. && error "'ls ..' worked after removing parent"
>        mkdir . && error "'mkdir .' worked after removing parent"
>        rmdir . && error "'rmdir .' worked after removing parent"
>        ln -s . foo && error "'ln -s .' worked after removing parent"
> }
> run_test 48d "Access removed parent subdir (should return errors)"
>
> test_48e() { # bug 4134
>        mkdir -p $DIR/d48e/dir
>        cd $DIR/d48e/dir
>        rmdir $DIR/d48e/dir || error "remove cwd $DIR/d48e/dir failed"
>        rmdir $DIR/d48e || error "remove parent $DIR/d48e failed"
>        touch $DIR/d48e || error "'touch $DIR/d48e' failed"
>        chmod +x $DIR/d48e || error "'chmod +x $DIR/d48e' failed"
>        # On a buggy kernel addition of "touch foo" after cd .. will
>        # produce kernel oops in lookup_hash_it
>        touch ../foo && error "'cd ..' worked after recreate parent"
>        cd $DIR
>        rm $DIR/d48e || error "rm '$DIR/d48e' failed"
> }
> run_test 48e "Access to recreated parent subdir (should return errors)"
>
> test_50() {
>        # bug 1485
>        mkdir $DIR/d50
>        cd $DIR/d50
>        ls /proc/$$/cwd || error
> }
> run_test 50 "special situations: /proc symlinks ""
>
> test_51a() {    # was test_51
>        # bug 1516 - create an empty entry right after ".." then split dir
>        mkdir $DIR/d51
>        touch $DIR/d51/foo
>        $MCREATE $DIR/d51/bar
>        rm $DIR/d51/foo
>        createmany -m $DIR/d51/longfile 201
>        FNUM=202
>        while [ `ls -sd $DIR/d51 | awk '{ print $1 }'` -eq 4 ]; do
>                $MCREATE $DIR/d51/longfile$FNUM
>                FNUM=$(($FNUM + 1))
>                echo -n "+"
>        done
>        echo
>        ls -l $DIR/d51 > /dev/null || error
> }
> run_test 51a "special situations: split htree with empty entry""
>
> export NUMTEST=70000
> test_51b() {
>        NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
>        [ $NUMFREE -lt 21000 ] && \
>                skip "not enough free inodes ($NUMFREE)" && \
>                return
>
>        check_kernel_version 40 || NUMTEST=31000
>        [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 50))
>
>        mkdir -p $DIR/d51b
>        createmany -d $DIR/d51b/t- $NUMTEST
> }
> run_test 51b "mkdir .../t-0 --- .../t-$NUMTEST""
>
> test_51c() {
>        [ ! -d $DIR/d51b ] && skip "$DIR/51b missing" && \
>                return
>
>        unlinkmany -d $DIR/d51b/t- $NUMTEST
> }
> run_test 51c "rmdir .../t-0 --- .../t-$NUMTEST""
>
> test_52a() {
>        [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
>        mkdir -p $DIR/d52a
>        touch $DIR/d52a/foo
>        chattr"a $DIR/d52a/foo || error "chattr =a failed"
>        echo bar >> $DIR/d52a/foo || error "append bar failed"
>        cp /etc/hosts $DIR/d52a/foo && error "cp worked"
>        rm -f $DIR/d52a/foo 2>/dev/null && error "rm worked"
>        link $DIR/d52a/foo $DIR/d52a/foo_link 2>/dev/null && error "link
> worked"
>        echo foo >> $DIR/d52a/foo || error "append foo failed"
>        mrename $DIR/d52a/foo $DIR/d52a/foo_ren && error "rename worked"
>        lsattr $DIR/d52a/foo | egrep -q "^-+a-+ $DIR/d52a/foo" || error
> "lsattr"
>        chattr -a $DIR/d52a/foo || error "chattr -a failed"
>
>        rm -fr $DIR/d52a || error "cleanup rm failed"
> }
> run_test 52a "append-only flag test (should return errors)""
>
> test_52b() {
>        [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
>        mkdir -p $DIR/d52b
>        touch $DIR/d52b/foo
>        chattr"i $DIR/d52b/foo || error
>        cat test > $DIR/d52b/foo && error
>        cp /etc/hosts $DIR/d52b/foo && error
>        rm -f $DIR/d52b/foo 2>/dev/null && error
>        link $DIR/d52b/foo $DIR/d52b/foo_link 2>/dev/null && error
>        echo foo >> $DIR/d52b/foo && error
>        mrename $DIR/d52b/foo $DIR/d52b/foo_ren && error
>        [ -f $DIR/d52b/foo ] || error
>        [ -f $DIR/d52b/foo_ren ] && error
>        lsattr $DIR/d52b/foo | egrep -q "^-+i-+ $DIR/d52b/foo" || error
>        chattr -i $DIR/d52b/foo || error
>
>        rm -fr $DIR/d52b || error
> }
> run_test 52b "immutable flag test (should return errors)""
>
> test_54b() {
>        f="$DIR/f54b"
>        mknod $f c 1 3
>        chmod 0666 $f
>        dd if=/dev/zero of=$f bs=`page_size` count=1
> }
> run_test 54b "char device works in lustre""
>
> find_loop_dev() {
>        [ -b /dev/loop/0 ] && LOOPBASE=/dev/loop/
>        [ -b /dev/loop0 ] && LOOPBASE=/dev/loop
>        [ -z "$LOOPBASE" ] && echo "/dev/loop/0 and /dev/loop0 gone?" &&
> return
>
>        for i in `seq 3 7`; do
>                losetup $LOOPBASE$i > /dev/null 2>&1 && continue
>                LOOPDEV=$LOOPBASE$i
>                LOOPNUM=$i
>                break
>        done
> }
>
> test_54c() {
>        tfile="$DIR/f54c"
>        tdir="$DIR/d54c"
>        loopdev="$DIR/loop54c"
>
>        find_loop_dev
>        [ -z "$LOOPNUM" ] && echo "couldn't find empty loop device" &&
> return
>        mknod $loopdev b 7 $LOOPNUM
>        echo "make a loop file system with $tfile on $loopdev ($LOOPNUM)..."
>        dd if=/dev/zero of=$tfile bs=`page_size` seek=1024 count=1 >
> /dev/null
>        losetup $loopdev $tfile || error "can't set up $loopdev for $tfile"
>        mkfs.ext2 $loopdev || error "mke2fs on $loopdev"
>        mkdir -p $tdir
>        mount -t ext2 $loopdev $tdir || error "error mounting $loopdev on
> $tdir"
>        dd if=/dev/zero of=$tdir/tmp bs=`page_size` count=30 || error "dd
> write"
>        df $tdir
>        dd if=$tdir/tmp of=/dev/zero bs=`page_size` count=30 || error "dd
> read"
>        $UMOUNT $tdir
>        losetup -d $loopdev
>        rm $loopdev
> }
> run_test 54c "block device works in lustre""
>
> test_54d() {
>        f="$DIR/f54d"
>        string="aaaaaa"
>        mknod $f p
>        [ "$string"" `echo $string > $f | cat $f` ] || error
> }
> run_test 54d "fifo device works in lustre""
>
> test_54e() {
>        check_kernel_version 46 || return 0
>        f="$DIR/f54e"
>        string="aaaaaa"
>        cp -aL /dev/console $f
>        echo $string > $f || error
> }
> run_test 54e "console/tty device works in lustre""
>
> test_61() {
>        f="$DIR/f61"
>        dd if=/dev/zero of=$f bs=`page_size` count=1
>        multiop $f OSMWUc || error
>        sync
> }
> run_test 61 "mmap() writes don't make sync hang""
>
> # bug 2543 - update blocks count on client
> test_66() {
>        COUNT=${COUNT:-8}
>        dd if=/dev/zero of=$DIR/f66 bs=1k count=$COUNT
>        sync; sleep 1; sync
>        BLOCKS=`ls -s $DIR/f66 | awk '{ print $1 }'`
>        [ $BLOCKS -ge $COUNT ] || error "$DIR/f66 blocks $BLOCKS < $COUNT"
> }
> run_test 66 "update inode blocks count on client""
>
> LLOOP=
> cleanup_68() {
>        trap 0
>        if [ ! -z "$LLOOP" ]; then
>                if swapon -s | grep -q $LLOOP; then
>                        swapoff $LLOOP || error "swapoff failed"
>                fi
>
>                losetup -d $LOOPDEV || error "detach failed"
>                unset LOOPDEV
>                unset LLOOP
>        fi
>        rm -f $DIR/f68*
> }
>
> meminfo() {
>        awk '($1" "'$1':") { print $2 }' /proc/meminfo
> }
>
> swap_used() {
>        swapon -s | awk '($1" "'$1'") { print $4 }'
> }
>
> # excercise swapping to lustre by adding a high priority swapfile entry
> # and then consuming memory until it is used.
> test_68b() {  # was test_68
>        [ "$UID" != 0 ] && skip "must run as root" && return
>
>        MEMTOTAL=`meminfo MemTotal`
>        NR_BLOCKS=$((MEMTOTAL>>8))
>        [[ $NR_BLOCKS -le 2048 ]] && NR_BLOCKS=2048
>
>        dd if=/dev/zero of=$DIR/f68b bs=64k seek=$NR_BLOCKS count=1
>        mkswap $DIR/f68b
>
>        trap cleanup_68 EXIT
>
>        swapon -p 32767 $LLOOP || error "swapon $LLOOP failed"
>
>        echo "before: `swapon -s | grep $LLOOP`"
>        $MEMHOG $MEMTOTAL || error "error allocating $MEMTOTAL kB"
>        echo "after: `swapon -s | grep $LLOOP`"
>        SWAPUSED=`swap_used $LLOOP`
>
>        cleanup_68
>
>        [ $SWAPUSED -eq 0 ] && echo "no swap used???" || true
> }
> run_test 68b "support swapping to Lustre""
>
> test_72() { # bug 5695 - Test that on 2.6 remove_suid works properly
>        [ "$RUNAS_ID"" "$UID" ] && skip "RUNAS_ID = UID = $UID -- skipping"
> && return
>
>        # Check that testing environment is properly set up. Skip if not
>        FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_ID $RUNAS ||
> {
>                skip "User $RUNAS_ID does not exist - skipping"
>                return 0
>        }
>        touch $DIR/f72
>        chmod 777 $DIR/f72
>        chmod ug+s $DIR/f72
>        $RUNAS dd if=/dev/zero of=$DIR/f72 bs=512 count=1 || error
>        # See if we are still setuid/sgid
>        test -u $DIR/f72 -o -g $DIR/f72 && error "S/gid is not dropped on
> write"
> }
> run_test 72 "Test that remove suid works properly (bug5695)""
>
> test_78() { # bug 10901
>        NSEQ=5
>        F78SIZE=$(($(awk '/MemFree:/ { print $2 }' /proc/meminfo) / 1024))
>        echo "MemFree: $F78SIZE, Max file size: $MAXFREE"
>        MEMTOTAL=$(($(awk '/MemTotal:/ { print $2 }' /proc/meminfo) / 1024))
>        echo "MemTotal: $MEMTOTAL"
> # reserve 256MB of memory for the kernel and other running processes,
> # and then take 1/2 of the remaining memory for the read/write buffers.
>        if [ $MEMTOTAL -gt 512 ] ;then
>                MEMTOTAL=$(((MEMTOTAL - 256 ) / 2))
>        else
>                # for those poor memory-starved high-end clusters...
>                MEMTOTAL=$((MEMTOTAL / 2))
>        fi
>        echo "Mem to use for directio: $MEMTOTAL"
>        [ $F78SIZE -gt $MEMTOTAL ] && F78SIZE=$MEMTOTAL
>        [ $F78SIZE -gt 512 ] && F78SIZE=512
>        [ $F78SIZE -gt $((MAXFREE / 1024)) ] && F78SIZE=$((MAXFREE / 1024))
>        SMALLEST=`df $DIR | awk '{print $4}' | tail -1`
>        [ $SMALLEST -lt 10240 ] && \
>                skip "too small OSTSIZE, useless to run large O_DIRECT test"
> && return 0
>
>        [ $F78SIZE -gt $((SMALLEST * $OSTCOUNT / 1024 - 80)) ] && \
>                F78SIZE=$((SMALLEST * $OSTCOUNT / 1024 - 80))
>
>        [ "$SLOW"" "no" ] && NSEQ=1 && [ $F78SIZE -gt 32 ] && F78SIZE=32
>        echo "File size: $F78SIZE"
>        $SETSTRIPE $DIR/$tfile -c $OSTCOUNT || error "setstripe failed"
>        for i in `seq 1 $NSEQ`
>        do
>                FSIZE=$(($F78SIZE / ($NSEQ - $i + 1)))
>                echo directIO rdwr round $i of $NSEQ
>                $DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr
> failed"
>        done
>
>        rm -f $DIR/$tfile
> }
> run_test 78 "handle large O_DIRECT writes correctly""
>
> test_80() { # bug 10718
>        dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1M
>        sync; sleep 1; sync
>        local BEFORE=`date +%s`
>        cancel_lru_locks osc
>        local AFTER=`date +%s`
>        local DIFF=$((AFTER-BEFORE))
>        if [ $DIFF -gt 1 ] ; then
>                error "elapsed for 1M@1T" $DIFF"
>        fi
>        true
>        rm -f $DIR/$tfile
> }
> run_test 80 "Page eviction is equally fast at high offsets too ""
>
> test_99a() {
>        [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" && \
>            return
>        mkdir -p $DIR/d99cvsroot
>        chown $RUNAS_ID $DIR/d99cvsroot
>        local oldPWD=$PWD       # bug 13584, use $TMP as working dir
>        cd $TMP
>
>        $RUNAS cvs -d $DIR/d99cvsroot init || error
>        cd $oldPWD
> }
> run_test 99a "cvs init""
>
> test_99b() {
>        [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" &&
> return
>        [ ! -d $DIR/d99cvsroot ] && test_99a
>        cd /etc/init.d
>        # some versions of cvs import exit(1) when asked to import links or
>        # files they can't read.  ignore those files.
>        TOIGNORE=$(find . -type l -printf '-I %f\n' -o \
>                        ! -perm +4 -printf '-I %f\n')
>        $RUNAS cvs -d $DIR/d99cvsroot import -m "nomesg" $TOIGNORE \
>                d99reposname vtag rtag
> }
> run_test 99b "cvs import""
>
> test_99c() {
>        [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" &&
> return
>        [ ! -d $DIR/d99cvsroot ] && test_99b
>        cd $DIR
>        mkdir -p $DIR/d99reposname
>        chown $RUNAS_ID $DIR/d99reposname
>        $RUNAS cvs -d $DIR/d99cvsroot co d99reposname
> }
> run_test 99c "cvs checkout""
>
> test_99d() {
>        [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" &&
> return
>        [ ! -d $DIR/d99cvsroot ] && test_99c
>        cd $DIR/d99reposname
>        $RUNAS touch foo99
>        $RUNAS cvs add -m 'addmsg' foo99
> }
> run_test 99d "cvs add""
>
> test_99e() {
>        [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" &&
> return
>        [ ! -d $DIR/d99cvsroot ] && test_99c
>        cd $DIR/d99reposname
>        $RUNAS cvs update
> }
> run_test 99e "cvs update""
>
> test_99f() {
>        [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" &&
> return
>        [ ! -d $DIR/d99cvsroot ] && test_99d
>        cd $DIR/d99reposname
>        $RUNAS cvs commit -m 'nomsg' foo99
>    rm -fr $DIR/d99cvsroot
> }
> run_test 99f "cvs commit""
>
> function get_named_value()
> {
>    local tag
>
>    tag=$1
>    while read ;do
>        line=$REPLY
>        case $line in
>        $tag*)
>            echo $line | sed "s/^$tag//"
>            break
>            ;;
>        esac
>    done
> }
>
> export SETUP_TEST102=no
> setup_test102() {
>        [ "$SETUP_TEST102"" "yes" ] && return
>        mkdir -p $DIR/$tdir
>        chown $RUNAS_ID $DIR/$tdir
>        STRIPE_SIZE=65536
>        STRIPE_OFFSET=1
>        STRIPE_COUNT=$OSTCOUNT
>        [ $OSTCOUNT -gt 4 ] && STRIPE_COUNT=4
>
>        trap cleanup_test102 EXIT
>        cd $DIR
>        $1 $SETSTRIPE $tdir -s $STRIPE_SIZE -i $STRIPE_...
 
[truncated message content]