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. 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_OFFSET -c $STRIPE_COUNT cd $DIR/$tdir for num in 1 2 3 4 do for count in `seq 1 $STRIPE_COUNT` do for offset in `seq 0 $[$STRIPE_COUNT - 1]` do local stripe_size=`expr $STRIPE_SIZE \* $num` local file=file"$num-$offset-$count" $1 $SETSTRIPE $file -s $stripe_size -i $offset -c $count done done done cd $DIR $1 $TAR cf $TMP/f102.tar $tdir --xattrs SETUP_TEST102=yes } cleanup_test102() { trap 0 [ "$SETUP_TEST102"" "yes" ] || return 0 rm -f $TMP/f102.tar SETUP_TEST102=no } test_102a() { local testfile=$DIR/xattr_testfile rm -f $testfile touch $testfile [ "$UID" != 0 ] && skip "must run as root" && return [ -z "`lctl get_param -n mdc.*-mdc-*.connect_flags | grep xattr`" ] && skip "must have user_xattr" && return [ -z "$(which setfattr 2>/dev/null)" ] && skip "could not find setfattr" && return echo "set/get xattr..." setfattr -n trusted.name1 -v value1 $testfile || error [ "`getfattr -n trusted.name1 $testfile 2> /dev/null | \ grep "trusted.name1"`"" "trusted.name1=\"value1\"" ] || error setfattr -n user.author1 -v author1 $testfile || error [ "`getfattr -n user.author1 $testfile 2> /dev/null | \ grep "user.author1"`"" "user.author1=\"author1\"" ] || error echo "listxattr..." setfattr -n trusted.name2 -v value2 $testfile || error setfattr -n trusted.name3 -v value3 $testfile || error [ `getfattr -d -m "^trusted" $testfile 2> /dev/null | \ grep "trusted.name" | wc -l` -eq 3 ] || error setfattr -n user.author2 -v author2 $testfile || error setfattr -n user.author3 -v author3 $testfile || error [ `getfattr -d -m "^user" $testfile 2> /dev/null | \ grep "user" | wc -l` -eq 3 ] || error echo "remove xattr..." setfattr -x trusted.name1 $testfile || error getfattr -d -m trusted $testfile 2> /dev/null | \ grep "trusted.name1" && error || true setfattr -x user.author1 $testfile || error getfattr -d -m user $testfile 2> /dev/null | \ grep "user.author1" && error || true # b10667: setting lustre special xattr be silently discarded echo "set lustre special xattr ..." setfattr -n "trusted.lov" -v "invalid value" $testfile || error rm -f $testfile } run_test 102a "user xattr test"" test_106() { #bug 10921 mkdir -p $DIR/$tdir $DIR/$tdir && error "exec $DIR/$tdir succeeded" chmod 777 $DIR/$tdir || error "chmod $DIR/$tdir failed" } run_test 106 "attempt exec of dir followed by chown of that dir" test_107() { CDIR=`pwd` cd $DIR local file=core rm -f $file local save_pattern=$(sysctl -n kernel.core_pattern) local save_uses_pid=$(sysctl -n kernel.core_uses_pid) sysctl -w kernel.core_pattern=$file sysctl -w kernel.core_uses_pid=0 ulimit -c unlimited sleep 60 & SLEEPPID=$! sleep 1 kill -s 11 $SLEEPPID wait $SLEEPPID if [ -e $file ]; then size=`stat -c%s $file` [ $size -eq 0 ] && error "Fail to create core file $file" else error "Fail to create core file $file" fi rm -f $file sysctl -w kernel.core_pattern=$save_pattern sysctl -w kernel.core_uses_pid=$save_uses_pid cd $CDIR } run_test 107 "Coredump on SIG" test_110() { mkdir -p $DIR/d110 mkdir $DIR/d110/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || error "mkdir with 255 char fail" mkdir $DIR/d110/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && error "mkdir with 256 char should fail, but not" touch $DIR/d110/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx || error "create with 255 char fail" touch $DIR/d110/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy && error ""create with 256 char should fail, but not ls -l $DIR/d110 rm -fr $DIR/d110 } run_test 110 "filename length checking" test_119a() # bug 11737 { BSIZE=$((512 * 1024)) directio write $DIR/$tfile 0 1 $BSIZE # We ask to read two blocks, which is more than a file size. # directio will indicate an error when requested and actual # sizes aren't equal (a normal situation in this case) and # print actual read amount. NOB=`directio read $DIR/$tfile 0 2 $BSIZE | awk '/error/ {print $6}'` if [ "$NOB" != "$BSIZE" ]; then error "read $NOB bytes instead of $BSIZE" fi rm -f $DIR/$tfile } run_test 119a "Short directIO read must return actual read amount" test_119b() # bug 11737 { dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1 || error "dd failed" sync multiop $DIR/$tfile oO_RDONLY:O_DIRECT:r$((2048 * 1024)) || \ error "direct read failed" rm -f $DIR/$tfile } run_test 119b "Sparse directIO read must return actual read amount" test_119c() # bug 13099 { BSIZE=1048576 directio write $DIR/$tfile 3 1 $BSIZE || error "direct write failed" directio readhole $DIR/$tfile 0 2 $BSIZE || error "reading hole failed" rm -f $DIR/$tfile } run_test 119c "Testing for direct read hitting hole" test_126() { # bug 12829/13455 [ "$UID" != 0 ] && echo "skipping $TESTNAME (must run as root)" && return $RUNAS -u 0 -g 1 touch $DIR/$tfile || error "touch failed" gid=`ls -n $DIR/$tfile | awk '{print $4}'` rm -f $DIR/$tfile [ $gid -eq "1" ] || error "gid is set to" $gid "instead of 1" } run_test 126 "check that the fsgid provided by the client is taken into account" OLDIFS="$IFS" cleanup_130() { trap 0 IFS="$OLDIFS" } test_130a() { filefrag_op=$(filefrag -e 2>&1 | grep "invalid option") [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return trap cleanup_130 EXIT RETURN local fm_file=$DIR/$tfile dd if=/dev/zero of=$fm_file bs=65536 count=1 || error "dd failed for $fm_file" filefrag -ves $fm_file || error "filefrag $fm_file failed" filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"` start_blk=`echo $filefrag_op | cut -d: -f2 | cut -d. -f1` IFS=$'\n' tot_len=0 for line in $filefrag_op; do ext_len=`echo $line | cut -d: -f4` (( tot_len += ext_len )) done if (( start_blk != 0 || tot_len != 64 )); then cleanup_130 error "FIEMAP on 1-stripe file($fm_file) failed;" return fi cleanup_130 echo "FIEMAP on single striped file succeeded" } run_test 130a "FIEMAP (1-stripe file)" test_130e() { skip "this test needs cleanup for non-lustre" filefrag_op=$(filefrag -e 2>&1 | grep "invalid option") [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return trap cleanup_130 EXIT RETURN local fm_file=$DIR/$tfile NUM_BLKS=512 EXPECTED_LEN=$(( (NUM_BLKS / 2) * 4 )) for ((i" 0; i < $NUM_BLKS; i++)) do dd if=/dev/zero of=$fm_file count=1 bs=4096 seek=$((2*$i)) conv=notrunc > /dev/null 2>&1 done filefrag -ves $fm_file || error "filefrag $fm_file failed" filefrag_op=`filefrag -ve $fm_file | grep -A 750 "ext:" | grep -v "ext:" | grep -v "found"` IFS=$'\n' tot_len=0 for line in $filefrag_op; do ext_len=`echo $line | cut -d: -f4` (( tot_len += ext_len )) done if (( tot_len != $EXPECTED_LEN )); then cleanup_130 error "FIEMAP on $fm_file failed; len $tot_len != $EXPECTED_LEN" return fi cleanup_130 echo "FIEMAP with continuation calls succeeded" } run_test 130e "FIEMAP (test continuation FIEMAP calls)" # Test for writev/readv test_131a() { rwv -f $DIR/$tfile -w -n 3 524288 1048576 1572864 || \ error "writev test failed" rwv -f $DIR/$tfile -r -v -n 2 1572864 1048576 || \ error "readv failed" rm -f $DIR/$tfile } run_test 131a "test iov's crossing stripe boundary for writev/readv" test_131b() { rwv -f $DIR/$tfile -w -a -n 3 524288 1048576 1572864 || \ error "append writev test failed" rwv -f $DIR/$tfile -w -a -n 2 1572864 1048576 || \ error "append writev test failed" rm -f $DIR/$tfile } run_test 131b "test append writev" test_131c() { rwv -f $DIR/$tfile -w -d -n 1 1048576 || return 0 error "NOT PASS" } run_test 131c "test read/write on file w/o objects" test_131d() { rwv -f $DIR/$tfile -w -n 1 1572864 NOB=`rwv -f $DIR/$tfile -r -n 3 524288 524288 1048576 | awk '/error/ {print $6}'` if [ "$NOB" != 1572864 ]; then error "Short read filed: read $NOB bytes instead of 1572864" fi rm -f $DIR/$tfile } run_test 131d "test short read" test_131e() { rwv -f $DIR/$tfile -w -s 1048576 -n 1 1048576 rwv -f $DIR/$tfile -r -z -s 0 -n 1 524288 || \ error "read hitting hole failed" rm -f $DIR/$tfile } run_test 131e "test read hitting hole" test_140() { #bug-17379 mkdir -p $DIR/$tdir || error "Creating dir $DIR/$tdir" cd $DIR/$tdir || error "Changing to $DIR/$tdir" cp /usr/bin/stat . || error "Copying stat to $DIR/$tdir" # VFS limits max symlink depth to 8 local i=0 while i=`expr $i + 1`; do mkdir -p $i || error "Creating dir $i" cd $i || error "Changing to $i" ln -s ../stat stat || error "Creating stat symlink" # Read the symlink until ELOOP present, # not LBUGing the system is considered success, # we didn't overrun the stack. $OPENFILE -f O_RDONLY stat >/dev/null 2>&1; ret=$? [ $ret -ne 0 ] && { if [ $ret -eq 40 ]; then break # -ELOOP else error "Open stat symlink" return fi } done i=`expr $i - 1` echo "The symlink depth" $i" [ $i -eq 8 ] || error "Invalid symlink depth" } run_test 140 "Check reasonable stack depth (shouldn't LBUG)"" test_154() { # do directio so as not to populate the page cache log "creating a 10 Mb file" multiop $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file" log "starting reads" dd if=$DIR/$tfile of=/dev/null bs=4096 & log "truncating the file" multiop $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file" log "killing dd" kill %+ || true # reads might have finished echo "wait until dd is finished" wait log "removing the temporary file" rm -rf $DIR/$tfile || error "tmp file removal failed" } run_test 154 "parallel read and truncate should not deadlock"" echo "$0: completed" -- To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html