[ "$SLOW" = "no" ] && EXCEPT_SLOW="24D 27m 64b 68 71 115 300o"
if [ $(facet_fstype $SINGLEMDS) = "zfs" ]; then
- # bug number for skipped test: LU-4536 LU-1957 LU-2805
- ALWAYS_EXCEPT="$ALWAYS_EXCEPT 65ic 180 184c"
- # 4 13 (min)"
- [ "$SLOW" = "no" ] && EXCEPT_SLOW="$EXCEPT_SLOW 51b 51ba"
+ # bug number for skipped test: LU-4536 LU-1957
+ ALWAYS_EXCEPT="$ALWAYS_EXCEPT 65ic 180"
+ # 13 (min)"
+ [ "$SLOW" = "no" ] && EXCEPT_SLOW="$EXCEPT_SLOW 51b"
fi
FAIL_ON_ERROR=false
test_mkdir $DIR/$tdir/d/subdir || error "mkdir $tdir/d/subdir failed"
$CHECKSTAT -g \#$RUNAS_GID $DIR/$tdir/d/subdir ||
error "$tdir/d/subdir should be GID $RUNAS_GID"
+ if [[ $MDSCOUNT -gt 1 ]]; then
+ # check remote dir sgid inherite
+ $LFS mkdir -i 0 $DIR/$tdir.local ||
+ error "mkdir $tdir.local failed"
+ chmod g+s $DIR/$tdir.local ||
+ error "chmod $tdir.local failed"
+ chgrp $RUNAS_GID $DIR/$tdir.local ||
+ error "chgrp $tdir.local failed"
+ $LFS mkdir -i 1 $DIR/$tdir.local/$tdir.remote ||
+ error "mkdir $tdir.remote failed"
+ $CHECKSTAT -g \#$RUNAS_GID $DIR/$tdir.local/$tdir.remote ||
+ error "$tdir.remote should be owned by $UID.$RUNAS_ID"
+ $CHECKSTAT -p 02755 $DIR/$tdir.local/$tdir.remote ||
+ error "$tdir.remote should be mode 02755"
+ fi
}
run_test 6g "Is new dir in sgid dir inheriting group?"
createmany -o $DIR/$tdir/t- 1000
do_nodes $list $LCTL set_param fail_loc=0
- TLOG=$DIR/$tfile.getstripe
+ TLOG=$TMP/$tfile.getstripe
$GETSTRIPE $DIR/$tdir > $TLOG
OBJS=$(awk -vobj=0 '($1 == 0) { obj += 1 } END { print obj; }' $TLOG)
unlinkmany $DIR/$tdir/t- 1000
}
run_test 33f "nonroot user can create, access, and remove a striped directory"
+test_33g() {
+ mkdir -p $DIR/$tdir/dir2
+
+ local err=$($RUNAS mkdir $DIR/$tdir/dir2 2>&1)
+ echo $err
+ [[ $err =~ "exists" ]] || error "Not exists error"
+}
+run_test 33g "nonroot user create already existing root created file"
+
TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
test_34a() {
rm -f $DIR/f34
}
run_test 38 "open a regular file with O_DIRECTORY should return -ENOTDIR ==="
-test_39() {
+test_39a() { # was test_39
touch $DIR/$tfile
touch $DIR/${tfile}2
# ls -l $DIR/$tfile $DIR/${tfile}2
error "O_TRUNC didn't change timestamps"
fi
}
-run_test 39 "mtime changed on create ==========================="
+run_test 39a "mtime changed on create ==========================="
test_39b() {
test_mkdir -p -c1 $DIR/$tdir
run_test 39p "remote directory cached attributes updated after create ========"
-test_39p() { # LU-8041
+test_39q() { # LU-8041
local testdir=$DIR/$tdir
mkdir -p $testdir
multiop_bg_pause $testdir D_c || error "multiop failed"
local atime=$(stat -c %X $testdir)
[ "$atime" -ne 0 ] || error "atime is zero"
}
-run_test 39p "close won't zero out atime"
+run_test 39q "close won't zero out atime"
test_40() {
dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
}
run_test 42e "verify sub-RPC writes are not done synchronously"
-test_43() {
+test_43A() { # was test_43
test_mkdir -p $DIR/$tdir
cp -p /bin/ls $DIR/$tdir/$tfile
$MULTIOP $DIR/$tdir/$tfile Ow_c &
$DIR/$tdir/$tfile && error || true
kill -USR1 $pid
}
-run_test 43 "execution of file opened for write should return -ETXTBSY"
+run_test 43A "execution of file opened for write should return -ETXTBSY"
test_43a() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
}
run_test 43c "md5sum of copy into lustre========================"
-test_44() {
+test_44A() { # was test_44
[[ $OSTCOUNT -lt 2 ]] && skip_env "skipping 2-stripe test" && return
dd if=/dev/zero of=$DIR/f1 bs=4k count=1 seek=1023
dd if=$DIR/f1 bs=4k count=1 > /dev/null
}
-run_test 44 "zero length read from a sparse stripe ============="
+run_test 44A "zero length read from a sparse stripe ============="
test_44a() {
local nstripe=$($LCTL lov_getconfig $DIR | grep default_stripe_count: |
}
run_test 51a "special situations: split htree with empty entry =="
+cleanup_print_lfs_df () {
+ trap 0
+ $LFS df
+ $LFS df -i
+}
+
test_51b() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
local dir=$DIR/$tdir
# need to check free space for the directories as well
local blkfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.kbytesavail)
- numfree=$((blkfree / 4))
+ numfree=$(( blkfree / $(fs_inode_ksize) ))
[[ $numfree -lt $nrdirs ]] && skip "not enough blocks ($numfree)" &&
return
+ trap cleanup_print_lfsdf EXIT
+
# create files
createmany -d $dir/d $nrdirs ||
error "failed to create $nrdirs subdirs in MDT$mdtidx:$dir"
local left=100
local delete=$((nrdirs - left))
+ $LFS df
+ $LFS df -i
+
# for ldiskfs the nlink count should be 1, but this is OSD specific
# and so this is listed for informational purposes only
echo "nlink before: $(stat -c %h $dir), created before: $nrdirs"
local after=$(stat -c %h $dir)
[[ $after -gt 2 ]] && error "nlink after: $after > 2" ||
echo "nlink after: $after"
+
+ cleanup_print_lfs_df
}
run_test 51b "exceed 64k subdirectory nlink limit on create, verify unlink"
error "$GETSTRIPE $DIR/$tdir: found $FILENUM, not $NUMFILES"
echo "$GETSTRIPE --recursive passed."
- # test lfs getstripe with file instead of dir
+ # test lfs getstripe with file instead of dir
FILENUM=$($GETSTRIPE $DIR/$tdir/file1 | grep -c obdidx)
[[ $FILENUM -eq 1 ]] ||
error "$GETSTRIPE $DIR/$tdir/file1: found $FILENUM, not 1"
echo "$GETSTRIPE file1 passed."
- #test lfs getstripe with --verbose
+ #test lfs getstripe with --verbose
[[ $($GETSTRIPE --verbose $DIR/$tdir |
grep -c lmm_magic) -eq $NUMFILES ]] ||
error "$GETSTRIPE --verbose $DIR/$tdir: want $NUMFILES"
[[ $($GETSTRIPE $DIR/$tdir | grep -c lmm_magic) -eq 0 ]] ||
- rror "$GETSTRIPE $DIR/$tdir: showed lmm_magic"
+ error "$GETSTRIPE $DIR/$tdir: showed lmm_magic"
+
+ #test lfs getstripe with -v prints lmm_fid
+ [[ $($GETSTRIPE -v $DIR/$tdir | grep -c lmm_fid) -eq $NUMFILES ]] ||
+ error "$GETSTRIPE -v $DIR/$tdir: want $NUMFILES lmm_fid: lines"
+ [[ $($GETSTRIPE $DIR/$tdir | grep -c lmm_fid) -eq 0 ]] ||
+ error "$GETSTRIPE $DIR/$tdir: showed lmm_fid"
echo "$GETSTRIPE --verbose passed."
- #test lfs getstripe with --obd
- $GETSTRIPE --obd wrong_uuid $DIR/$tdir 2>&1 |
+ #check for FID information
+ local fid1=$($GETSTRIPE --fid $DIR/$tdir/file1)
+ local fid2=$($GETSTRIPE --verbose $DIR/$tdir/file1 |
+ awk '/lmm_fid: / { print $2 }')
+ local fid3=$($LFS path2fid $DIR/$tdir/file1)
+ [ "$fid1" != "$fid2" ] &&
+ error "getstripe --fid $fid1 != getstripe --verbose $fid2"
+ [ "$fid1" != "$fid3" ] &&
+ error "getstripe --fid $fid1 != lfs path2fid $fid3"
+ echo "$GETSTRIPE --fid passed."
+
+ #test lfs getstripe with --obd
+ $GETSTRIPE --obd wrong_uuid $DIR/$tdir 2>&1 |
grep -q "unknown obduuid" ||
error "$GETSTRIPE --obd wrong_uuid should return error message"
[[ $OSTCOUNT -lt 2 ]] &&
- skip_env "skipping other $GETSTRIPE --obd test" && return
+ skip_env "skipping other $GETSTRIPE --obd test" && return
- OSTIDX=1
- OBDUUID=$(ostuuid_from_index $OSTIDX)
+ OSTIDX=1
+ OBDUUID=$(ostuuid_from_index $OSTIDX)
FILENUM=$($GETSTRIPE -ir $DIR/$tdir | grep "^$OSTIDX\$" | wc -l)
FOUND=$($GETSTRIPE -r --obd $OBDUUID $DIR/$tdir | grep obdidx | wc -l)
[[ $FOUND -eq $FILENUM ]] ||
}
run_test 56a "check $GETSTRIPE"
+test_56b() {
+ test_mkdir $DIR/$tdir
+ NUMDIRS=3
+ for i in $(seq 1 $NUMDIRS); do
+ test_mkdir $DIR/$tdir/dir$i
+ done
+
+ # test lfs getdirstripe default mode is non-recursion, which is
+ # different from lfs getstripe
+ dircnt=$($LFS getdirstripe $DIR/$tdir | grep -c lmv_stripe_count)
+ [[ $dircnt -eq 1 ]] ||
+ error "$LFS getdirstripe: found $dircnt, not 1"
+ dircnt=$($LFS getdirstripe --recursive $DIR/$tdir |
+ grep -c lmv_stripe_count)
+ [[ $dircnt -eq $((NUMDIRS + 1)) ]] ||
+ error "$LFS getdirstripe --recursive: found $dircnt, \
+ not $((NUMDIRS + 1))"
+}
+run_test 56b "check $LFS getdirstripe"
+
NUMFILES=3
NUMDIRS=3
setup_56() {
test_56t() { # LU-611
TDIR=$DIR/${tdir}t
- setup_56 $NUMFILES $NUMDIRS "-s 512k"
+ setup_56 $NUMFILES $NUMDIRS "--stripe-size 512k"
$SETSTRIPE -S 256k $TDIR/$tfile.{0,1,2,3}
}
run_test 65l "lfs find on -1 stripe dir ========================"
+test_65m() {
+ $RUNAS $SETSTRIPE -c 2 $MOUNT && error "setstripe should fail"
+ true
+}
+run_test 65m "normal user can't set filesystem default stripe"
+
# bug 2543 - update blocks count on client
test_66() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
rm -f $LLOOP
unset LLOOP
fi
- if [ ! -z "$LLITELOOPLOAD" ]; then
- rmmod llite_lloop
- unset LLITELOOPLOAD
- fi
rm -f $DIR/f68*
}
swapon -s | awk '($1 == "'$1'") { print $4 }'
}
-# test case for lloop driver, basic function
-test_68a() {
- [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
- [ "$UID" != 0 ] && skip_env "must run as root" && return
- llite_lloop_enabled || \
- { skip_env "llite_lloop module disabled" && return; }
-
- trap cleanup_68 EXIT
-
- if ! module_loaded llite_lloop; then
- if load_module llite/llite_lloop; then
- LLITELOOPLOAD=yes
- else
- skip_env "can't find module llite_lloop"
- return
- fi
- fi
-
- LLOOP=$TMP/lloop.`date +%s`.`date +%N`
- dd if=/dev/zero of=$DIR/f68a bs=4k count=1024
- $LCTL blockdev_attach $DIR/f68a $LLOOP || error "attach failed"
-
- directio rdwr $LLOOP 0 1024 4096 || error "direct write failed"
- directio rdwr $LLOOP 0 1025 4096 && error "direct write should fail"
-
- cleanup_68
-}
-run_test 68a "lloop driver - basic test ========================"
-
-# excercise swapping to lustre by adding a high priority swapfile entry
-# and then consuming memory until it is used.
-test_68b() { # was test_68
- [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
- [ "$UID" != 0 ] && skip_env "must run as root" && return
- lctl get_param -n devices | grep -q obdfilter && \
- skip "local OST" && return
-
- grep -q llite_lloop /proc/modules
- [ $? -ne 0 ] && skip "can't find module llite_lloop" && return
-
- [ -z "`$LCTL list_nids | grep -v tcp`" ] && \
- skip "can't reliably test swap with TCP" && return
-
- MEMTOTAL=`meminfo MemTotal`
- NR_BLOCKS=$((MEMTOTAL>>8))
- [[ $NR_BLOCKS -le 2048 ]] && NR_BLOCKS=2048
-
- LLOOP=$TMP/lloop.`date +%s`.`date +%N`
- dd if=/dev/zero of=$DIR/f68b bs=64k seek=$NR_BLOCKS count=1
- mkswap $DIR/f68b
-
- $LCTL blockdev_attach $DIR/f68b $LLOOP || error "attach failed"
-
- 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 ========================"
-
# bug5265, obdfilter oa2dentry return -ENOENT
# #define OBD_FAIL_SRV_ENOENT 0x217
test_69() {
rm -f $F77_TMP
unset F77_TMP
+cleanup_test_78() {
+ trap 0
+ rm -f $DIR/$tfile
+}
+
test_78() { # bug 10901
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
remote_ost || { skip_env "local OST" && return; }
[[ $SMALLESTOST -lt 10240 ]] &&
skip "too small OSTSIZE, useless to run large O_DIRECT test" && return 0
+ trap cleanup_test_78 EXIT
+
[[ $F78SIZE -gt $((SMALLESTOST * $OSTCOUNT / 1024 - 80)) ]] &&
F78SIZE=$((SMALLESTOST * $OSTCOUNT / 1024 - 80))
$DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr failed"
done
- rm -f $DIR/$tfile
+ cleanup_test_78
}
run_test 78 "handle large O_DIRECT writes correctly ============"
test_101f() {
which iozone || { skip "no iozone installed" && return; }
+ local old_debug=$($LCTL get_param debug)
+ old_debug=${old_debug#*=}
+ $LCTL set_param debug="reada mmap"
+
# create a test file
iozone -i 0 -+n -r 1m -s 128m -w -f $DIR/$tfile > /dev/null 2>&1
$LCTL set_param -n llite.*.read_ahead_stats 0
echo mmap read the file with small block size
- iozone -i 1 -+n -r 32k -s 128m -B -f $DIR/$tfile > /dev/null 2>&1
+ iozone -i 1 -u 1 -l 1 -+n -r 32k -s 128m -B -f $DIR/$tfile \
+ > /dev/null 2>&1
echo checking missing pages
+ $LCTL get_param llite.*.read_ahead_stats
local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
get_named_value 'misses' | cut -d" " -f1 | calc_total)
- [ $miss -lt 3 ] || error "misses too much pages!"
+ $LCTL set_param debug="$old_debug"
+ [ $miss -lt 3 ] || error "misses too much pages ('$miss')!"
rm -f $DIR/$tfile
}
run_test 101f "check mmap read performance"
}
test_102n() { # LU-4101 mdt: protect internal xattrs
- local file0=$DIR/$tfile.0
- local file1=$DIR/$tfile.1
- local xattr0=$TMP/$tfile.0
- local xattr1=$TMP/$tfile.1
- local name
- local value
-
[ -z "$(which setfattr 2>/dev/null)" ] &&
skip "could not find setfattr" && return
-
if [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.5.50) ]
then
skip "MDT < 2.5.50 allows setxattr on internal trusted xattrs"
return
fi
+ local file0=$DIR/$tfile.0
+ local file1=$DIR/$tfile.1
+ local xattr0=$TMP/$tfile.0
+ local xattr1=$TMP/$tfile.1
+ local namelist="lov lma lmv link fid version som hsm"
+ local name
+ local value
+
rm -rf $file0 $file1 $xattr0 $xattr1
touch $file0 $file1
# Get 'before' xattrs of $file1.
getfattr --absolute-names --dump --match=- $file1 > $xattr0
- for name in lov lma lmv link fid version som hsm; do
+ [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.8.53) ] &&
+ namelist+=" lfsck_namespace"
+ for name in $namelist; do
# Try to copy xattr from $file0 to $file1.
value=$(getxattr $file0 trusted.$name 2> /dev/null)
SAVE_UMASK=$(umask)
umask 0022
- cd $DIR
+ mkdir -p $DIR/$tdir
+ cd $DIR/$tdir
echo "performing cp ..."
run_acl_subtest cp || error "run_acl_subtest cp failed"
run_acl_subtest misc || error "misc test failed"
echo "performing permissions..."
run_acl_subtest permissions || error "permissions failed"
+ # LU-1482 mdd: Setting xattr are properly checked with and without ACLs
+ if [ $(lustre_version_code $SINGLEMDS) -gt $(version_code 2.8.55) -o \
+ \( $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.6) -a \
+ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.5.29) \) ]
+ then
+ echo "performing permissions xattr..."
+ run_acl_subtest permissions_xattr ||
+ error "permissions_xattr failed"
+ fi
echo "performing setfacl..."
run_acl_subtest setfacl || error "setfacl test failed"
stat $DIR/$tdir $DIR/$tdir/f1 > /dev/null
# XXX client can not do early lock cancel of OST lock
# during unlink (LU-4206), so cancel osc lock now.
+ sleep 2
cancel_lru_locks osc
can1=$(do_facet $SINGLEMDS \
"$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2 > /dev/null
# XXX client can not do early lock cancel of OST lock
# during rename (LU-4206), so cancel osc lock now.
+ sleep 2
cancel_lru_locks osc
can1=$(do_facet $SINGLEMDS \
"$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
NR=$(($(default_lru_size)*20))
if [[ $NR -gt $LIMIT ]]; then
- log "Limit lock number by $LIMIT locks"
- NR=$LIMIT
- fi
- lru_resize_disable mdc
- test_mkdir -p $DIR/$tdir/disable_lru_resize ||
+ log "Limit lock number by $LIMIT locks"
+ NR=$LIMIT
+ fi
+
+ IFree=$(mdsrate_inodes_available)
+ if [ $IFree -lt $NR ]; then
+ log "Limit lock number by $IFree inodes"
+ NR=$IFree
+ fi
+
+ lru_resize_disable mdc
+ test_mkdir -p $DIR/$tdir/disable_lru_resize ||
error "failed to create $DIR/$tdir/disable_lru_resize"
createmany -o $DIR/$tdir/disable_lru_resize/f $NR
return
fi
remote_mds_nodsh && skip "remote MDS with nodsh" && return
- ENOSPC=28
- EFBIG=27
- has_warning=0
+ local ENOSPC=28
+ local EFBIG=27
+ local has_warning=0
rm -rf $DIR/$tdir
mkdir -p $DIR/$tdir
check_mds_dmesg '"has reached"' ||
error_exit "has reached message should be output"
- [ $has_warning ] ||
+ [ $has_warning -eq 0 ] &&
error_exit "warning message should be output"
I=$(stat -c%s "$DIR/$tdir")
[[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.1) ]] &&
skip "Need MDS version at least 2.4.1" && return
- touch $DIR/$tfile
- local FID=$($LFS path2fid $DIR/$tfile)
- [ -z "$FID" ] && error "path2fid unable to get $DIR/$tfile FID"
+ local tf=$DIR/$tfile
+ touch $tf
- # check that we get the same pathname back
- local FOUND=$($LFS fid2path $MOUNT "$FID")
- [ -z "$FOUND" ] && error "fid2path unable to get $FID path"
- [ "$FOUND" != "$DIR/$tfile" ] &&
- error "fid2path(path2fid($DIR/$tfile)) = $FOUND != $DIR/$tfile"
+ local fid=$($LFS path2fid $tf)
+ [ -z "$fid" ] && error "path2fid unable to get $tf FID"
- rm -rf $DIR/$tfile
+ # check that we get the same pathname back
+ local found=$($LFS fid2path $MOUNT "$fid")
+ [ -z "$found" ] && error "fid2path unable to get '$fid' path"
+ [ "$found" == "$tf" ] ||
+ error "fid2path($fid=path2fid($tf)) = $found != $tf"
}
run_test 154A "lfs path2fid and fid2path basic checks"
+test_154B() {
+ [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.1) ]] &&
+ skip "Need MDS version at least 2.4.1" && return
+
+ mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
+ touch $DIR/$tdir/$tfile || error "touch $DIR/$tdir/$tfile failed"
+ local linkea=$($LL_DECODE_LINKEA $DIR/$tdir/$tfile | grep 'pfid')
+ [ -z "$linkea" ] && error "decode linkea $DIR/$tdir/$tfile failed"
+
+ local name=$(echo $linkea | awk '/pfid/ {print $5}' | sed -e "s/'//g")
+ local PFID=$(echo $linkea | awk '/pfid/ {print $3}' | sed -e "s/,//g")
+
+ # check that we get the same pathname
+ echo "PFID: $PFID, name: $name"
+ local FOUND=$($LFS fid2path $MOUNT "$PFID")
+ [ -z "$FOUND" ] && error "fid2path unable to get $PFID path"
+ [ "$FOUND/$name" != "$DIR/$tdir/$tfile" ] &&
+ error "ll_decode_linkea has $FOUND/$name != $DIR/$tdir/$tfile"
+
+ rm -rf $DIR/$tdir || error "Can not delete directory $DIR/$tdir"
+}
+run_test 154B "verify the ll_decode_linkea tool"
+
test_154a() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
[[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ]] ||
true
}
+save_writethrough() {
+ local facets=$(get_facets OST)
+
+ save_lustre_params $facets "obdfilter.*.writethrough_cache_enable" > $1
+ save_lustre_params $facets "osd-*.*.writethrough_cache_enable" >> $1
+}
+
test_155a() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read on
set_cache writethrough on
test_155_small_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155a "Verify small file correctness: read cache:on write_cache:on"
test_155b() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read on
set_cache writethrough off
test_155_small_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155b "Verify small file correctness: read cache:on write_cache:off"
test_155c() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read off
set_cache writethrough on
test_155_small_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155c "Verify small file correctness: read cache:off write_cache:on"
test_155d() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read off
set_cache writethrough off
test_155_small_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155d "Verify small file correctness: read cache:off write_cache:off"
test_155e() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read on
set_cache writethrough on
test_155_big_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155e "Verify big file correctness: read cache:on write_cache:on"
test_155f() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read on
set_cache writethrough off
test_155_big_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155f "Verify big file correctness: read cache:on write_cache:off"
test_155g() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read off
set_cache writethrough on
test_155_big_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155g "Verify big file correctness: read cache:off write_cache:on"
test_155h() {
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+
set_cache read off
set_cache writethrough off
test_155_big_load
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 155h "Verify big file correctness: read cache:off write_cache:off"
local BEFORE
local AFTER
local file="$DIR/$tfile"
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
[ "$(facet_fstype ost1)" = "zfs" -a \
$(lustre_version_code ost1 -lt $(version_code 2.6.93)) ] &&
skip "LU-1956/LU-2261: stats not implemented on OSD ZFS" &&
return
+ save_writethrough $p
roc_hit_init
log "Turn on read and write cache"
fi
rm -f $file
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 156 "Verification of tunables"
#Changelogs
+cleanup_changelog () {
+ trap 0
+ echo "Deregistering changelog client $CL_USER"
+ do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $CL_USER
+}
+
err17935 () {
if [[ $MDSCOUNT -gt 1 ]]; then
error_ignore bz17935 $*
local CL_USERS="mdd.$MDT0.changelog_users"
local GET_CL_USERS="do_facet $SINGLEMDS $LCTL get_param -n $CL_USERS"
- USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_register -n)
- echo "Registered as changelog user $USER"
- $GET_CL_USERS | grep -q $USER ||
- error "User $USER not found in changelog_users"
+ CL_USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 \
+ changelog_register -n)
+ echo "Registered as changelog user $CL_USER"
+ trap cleanup_changelog EXIT
+ $GET_CL_USERS | grep -q $CL_USER ||
+ error "User $CL_USER not found in changelog_users"
# change something
test_mkdir -p $DIR/$tdir/pics/2008/zachy
[ "$fidc" == "$fidf" ] ||
err17935 "pfid in changelog $fidc != dir fid $fidf"
- USER_REC1=$($GET_CL_USERS | awk "\$1 == \"$USER\" {print \$2}")
- $LFS changelog_clear $MDT0 $USER $(($USER_REC1 + 5))
- USER_REC2=$($GET_CL_USERS | awk "\$1 == \"$USER\" {print \$2}")
+ USER_REC1=$($GET_CL_USERS | awk "\$1 == \"$CL_USER\" {print \$2}")
+ $LFS changelog_clear $MDT0 $CL_USER $(($USER_REC1 + 5))
+ USER_REC2=$($GET_CL_USERS | awk "\$1 == \"$CL_USER\" {print \$2}")
echo "verifying user clear: $(( $USER_REC1 + 5 )) == $USER_REC2"
[ $USER_REC2 == $(($USER_REC1 + 5)) ] ||
err17935 "user index expected $(($USER_REC1 + 5)) is $USER_REC2"
# LU-3446 changelog index reset on MDT restart
local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
CUR_REC1=$($GET_CL_USERS | head -n1 | cut -f3 -d' ')
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
stop $SINGLEMDS || error "Fail to stop MDT."
start $SINGLEMDS $MDT_DEV $MDS_MOUNT_OPTS || error "Fail to start MDT."
CUR_REC2=$($GET_CL_USERS | head -n1 | cut -f3 -d' ')
err17935 "current index should be $CUR_REC1 is $CUR_REC2"
echo "verifying user deregister"
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
- $GET_CL_USERS | grep -q $USER &&
- error "User $USER still in changelog_users"
+ cleanup_changelog
+ $GET_CL_USERS | grep -q $CL_USER &&
+ error "User $CL_USER still in changelog_users"
USERS=$(( $($GET_CL_USERS | wc -l) - 2 ))
- if [ $USERS -eq 0 ]; then
+ if [ $CL_USER -eq 0 ]; then
LAST_REC1=$($GET_CL_USERS | head -n1 | cut -f3 -d' ')
touch $DIR/$tdir/chloe
LAST_REC2=$($GET_CL_USERS | head -n1 | cut -f3 -d' ')
echo "verify changelogs are off: $LAST_REC1 == $LAST_REC2"
[ $LAST_REC1 == $LAST_REC2 ] || error "changelogs not off"
else
- echo "$USERS other changelog users; can't verify off"
+ echo "$CL_USER other changelog users; can't verify off"
fi
}
run_test 160a "changelog sanity"
local CL_USERS="mdd.$MDT0.changelog_users"
local GET_CL_USERS="do_facet $SINGLEMDS $LCTL get_param -n $CL_USERS"
- USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_register -n)
- echo "Registered as changelog user $USER"
- $GET_CL_USERS | grep -q $USER ||
- error "User $USER not found in changelog_users"
+ CL_USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 \
+ changelog_register -n)
+ echo "Registered as changelog user $CL_USER"
+ trap cleanup_changelog EXIT
+ $GET_CL_USERS | grep -q $CL_USER ||
+ error "User $CL_USER not found in changelog_users"
local LONGNAME1=$(str_repeat a 255)
local LONGNAME2=$(str_repeat b 255)
mv $LONGNAME1 $LONGNAME2
$LFS changelog $MDT0 | grep RENME
-
- echo "deregistering $USER"
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
-
rm -f $LONGNAME2
+ cleanup_changelog
}
run_test 160b "Verify that very long rename doesn't crash in changelog"
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
# Registration step
- local USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 \
+ CL_USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 \
changelog_register -n)
+ trap cleanup_changelog EXIT
rm -rf $DIR/$tdir
mkdir -p $DIR/$tdir
$LFS changelog $MDT0
TRUNCS=$($LFS changelog $MDT0 | tail -5 | grep -c "TRUNC")
[ $TRUNCS -eq 1 ] || err17935 "TRUNC changelog mask count $TRUNCS != 1"
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
# Deregistration step
- echo "deregistering $USER"
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
+ cleanup_changelog
}
run_test 160c "verify that changelog log catch the truncate event"
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
# Registration step
- local USER=$(do_facet mds1 $LCTL --device $MDT0 \
+ CL_USER=$(do_facet mds1 $LCTL --device $MDT0 \
changelog_register -n)
+ trap cleanup_changelog EXIT
mkdir -p $DIR/$tdir/migrate_dir
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
$LFS migrate -m 1 $DIR/$tdir/migrate_dir || error "migrate fails"
$LFS changelog $MDT0
MIGRATES=$($LFS changelog $MDT0 | tail -5 | grep -c "MIGRT")
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
[ $MIGRATES -eq 1 ] ||
error "MIGRATE changelog mask count $MIGRATES != 1"
# Deregistration step
- do_facet mds1 $LCTL --device $MDT0 changelog_deregister $USER
+ cleanup_changelog
}
run_test 160d "verify that changelog log catch the migrate event"
# define CLF_RENAME_LAST 0x0001
# rename overwrite a target having nlink = 1 (changelog flag 0x1)
- local USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 \
+ CL_USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 \
changelog_register -n)
+
+ trap cleanup_changelog EXIT
rm -rf $DIR/$tdir
mkdir -p $DIR/$tdir
touch $DIR/$tdir/foo_161c
$LFS changelog $MDT0 | grep RENME
local flags=$($LFS changelog $MDT0 | grep RENME | tail -1 | \
cut -f5 -d' ')
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
if [ x$flags != "x0x1" ]; then
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
- $USER
error "flag $flags is not 0x1"
fi
echo "rename overwrite a target having nlink = 1," \
mv -f $DIR/$tdir/foo_161c $DIR/$tdir/bar_161c
$LFS changelog $MDT0 | grep RENME
flags=$($LFS changelog $MDT0 | grep RENME | tail -1 | cut -f5 -d' ')
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
if [ x$flags != "x0x0" ]; then
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
- $USER
error "flag $flags is not 0x0"
fi
echo "rename overwrite a target having nlink > 1," \
mv -f $DIR/$tdir/foo_161c $DIR/$tdir/foo2_161c
$LFS changelog $MDT0 | grep RENME
flags=$($LFS changelog $MDT0 | grep RENME | tail -1 | cut -f5 -d' ')
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
if [ x$flags != "x0x0" ]; then
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
- $USER
error "flag $flags is not 0x0"
fi
echo "rename doesn't overwrite a target," \
rm -f $DIR/$tdir/foo2_161c
$LFS changelog $MDT0 | grep UNLNK
flags=$($LFS changelog $MDT0 | grep UNLNK | tail -1 | cut -f5 -d' ')
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
if [ x$flags != "x0x1" ]; then
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
- $USER
error "flag $flags is not 0x1"
fi
echo "unlink a file having nlink = 1," \
rm -f $DIR/$tdir/foobar_161c
$LFS changelog $MDT0 | grep UNLNK
flags=$($LFS changelog $MDT0 | grep UNLNK | tail -1 | cut -f5 -d' ')
- $LFS changelog_clear $MDT0 $USER 0
+ $LFS changelog_clear $MDT0 $CL_USER 0
if [ x$flags != "x0x0" ]; then
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
- $USER
error "flag $flags is not 0x0"
fi
echo "unlink a file having nlink > 1," \
"changelog record has flags of $flags"
- do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
+ cleanup_changelog
}
run_test 161c "check CL_RENME[UNLINK] changelog record flags"
}
cleanup_205() {
+ trap 0
do_facet $SINGLEMDS \
$LCTL set_param mdt.*.job_cleanup_interval=$OLD_INTERVAL
[ $OLD_JOBENV != $JOBENV ] && jobstats_set $OLD_JOBENV
- do_facet $SINGLEMDS lctl --device $MDT0 changelog_deregister $CL_USER
+ cleanup_changelog
}
test_205() { # Job stats
cmd="mv -f $DIR/$tfile $DIR/$tdir.rename"
verify_jobstats "$cmd" "$SINGLEMDS"
# jobstats expiry - sleep until old stats should be expired
- local left=$((interval_new + 2 - (SECONDS - start)))
- [ $left -ge 0 ] && echo "sleep $left for expiry" && sleep $((left + 1))
+ local left=$((interval_new + 5 - (SECONDS - start)))
+ [ $left -ge 0 ] && wait_update_facet $SINGLEMDS \
+ "lctl get_param *.*.job_stats | grep -c 'job_id.*mkdir'" \
+ "0" $left
cmd="mkdir $DIR/$tdir.expire"
verify_jobstats "$cmd" "$SINGLEMDS"
[ $(do_facet $SINGLEMDS lctl get_param *.*.job_stats |
test_224c() { # LU-6441
[ $PARALLEL == "yes" ] && skip "skip parallel run" && return
remote_mds_nodsh && skip "remote MDS with nodsh" && return
+
+ local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+ save_writethrough $p
+ set_cache writethrough on
+
local pages_per_rpc=$($LCTL get_param \
osc.*.max_pages_per_rpc)
local at_max=$($LCTL get_param -n at_max)
error "conf_param timeout=5 failed"
#define OBD_FAIL_PTLRPC_CLIENT_BULK_CB3 0x520
- $LCTL set_param fail_loc=0x520
+ do_facet ost1 $LCTL set_param fail_loc=0x520
+ $LFS setstripe -c 1 -i 0 $DIR/$tfile
dd if=/dev/zero of=$DIR/$tfile bs=8MB count=1
sync
- $LCTL set_param fail_loc=0
+ do_facet ost1 $LCTL set_param fail_loc=0
set_conf_param_and_check client "$test_at" "$param_at" $at_max ||
error "conf_param at_max=$at_max failed"
$timeout || error "conf_param timeout=$timeout failed"
$LCTL set_param -n $pages_per_rpc
+ restore_lustre_params < $p
+ rm -f $p
}
run_test 224c "Don't hang if one of md lost during large bulk RPC"
done
}
-test_241() {
+test_241a() { # was test_241
dd if=/dev/zero of=$DIR/$tfile count=1 bs=40960
ls -la $DIR/$tfile
cancel_lru_locks osc
test_241_dio 1000
wait $PID
}
-run_test 241 "bio vs dio"
+run_test 241a "bio vs dio"
test_241b() {
dd if=/dev/zero of=$DIR/$tfile count=1 bs=40960
run_test 247e "mount .. as fileset"
test_248() {
- local my_error=error
-
- # This test case is time sensitive and maloo uses kvm to run auto test.
- # Therefore the complete time of I/O task is unreliable and depends on
- # the work load on the host machine when the task is running.
- which virt-what 2> /dev/null && [ "$(virt-what)" != "kvm" ] ||
- { echo "no virt-what installed or running in kvm; ignore error";
- my_error="error_ignore env=kvm"; }
+ local fast_read_sav=$($LCTL get_param -n llite.*.fast_read 2>/dev/null)
+ [ -z "$fast_read_sav" ] && skip "no fast read support" && return
# create a large file for fast read verification
- dd if=/dev/zero of=$DIR/$tfile bs=128M count=1 > /dev/null 2>&1
+ dd if=/dev/zero of=$DIR/$tfile bs=1M count=128 > /dev/null 2>&1
# make sure the file is created correctly
$CHECKSTAT -s $((128*1024*1024)) $DIR/$tfile ||
{ rm -f $DIR/$tfile; skip "file creation error" && return; }
- local saved_fast_read=$($LCTL get_param -n llite.*.fast_read)
-
echo "Test 1: verify that fast read is 4 times faster on cache read"
# small read with fast read enabled
$LCTL set_param -n llite.*.fast_read=1
- local t_fast=$(eval time -p dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
- awk '/real/ { print $2 }')
+ local t_fast=$(dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
+ awk '/copied/ { print $6 }')
# small read with fast read disabled
$LCTL set_param -n llite.*.fast_read=0
- local t_slow=$(eval time -p dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
- awk '/real/ { print $2 }')
+ local t_slow=$(dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
+ awk '/copied/ { print $6 }')
# verify that fast read is 4 times faster for cache read
[ $(bc <<< "4 * $t_fast < $t_slow") -eq 1 ] ||
- $my_error "fast read was not 4 times faster: $t_fast vs $t_slow"
+ error_not_in_vm "fast read was not 4 times faster: " \
+ "$t_fast vs $t_slow"
echo "Test 2: verify the performance between big and small read"
$LCTL set_param -n llite.*.fast_read=1
# 1k non-cache read
cancel_lru_locks osc
- local t_1k=$(eval time -p dd if=$DIR/$tfile of=/dev/null bs=1k 2>&1 |
- awk '/real/ { print $2 }')
+ local t_1k=$(dd if=$DIR/$tfile of=/dev/null bs=1k 2>&1 |
+ awk '/copied/ { print $6 }')
# 1M non-cache read
cancel_lru_locks osc
- local t_1m=$(eval time -p dd if=$DIR/$tfile of=/dev/null bs=1M 2>&1 |
- awk '/real/ { print $2 }')
+ local t_1m=$(dd if=$DIR/$tfile of=/dev/null bs=1k 2>&1 |
+ awk '/copied/ { print $6 }')
# verify that big IO is not 4 times faster than small IO
[ $(bc <<< "4 * $t_1k >= $t_1m") -eq 1 ] ||
- $my_error "bigger IO is way too fast: $t_1k vs $t_1m"
+ error_not_in_vm "bigger IO is way too fast: $t_1k vs $t_1m"
- $LCTL set_param -n llite.*.fast_read=$saved_fast_read
+ $LCTL set_param -n llite.*.fast_read=$fast_read_sav
rm -f $DIR/$tfile
}
run_test 248 "fast read verification"
}
run_test 252 "check lr_reader tool"
+test_253_fill_ost() {
+ local size_mb #how many MB should we write to pass watermark
+ local lwm=$3 #low watermark
+ local free_10mb #10% of free space
+
+ free_kb=$($LFS df $MOUNT | grep $1 | awk '{ print $4 }')
+ size_mb=$((free_kb / 1024 - lwm))
+ free_10mb=$((free_kb / 10240))
+ #If 10% of free space cross low watermark use it
+ if (( free_10mb > size_mb )); then
+ size_mb=$free_10mb
+ else
+ #At least we need to store 1.1 of difference between
+ #free space and low watermark
+ size_mb=$((size_mb + size_mb / 10))
+ fi
+ if (( lwm <= $((free_kb / 1024)) )) || [ ! -f $DIR/$tdir/1 ]; then
+ dd if=/dev/zero of=$DIR/$tdir/1 bs=1M count=$size_mb \
+ oflag=append conv=notrunc
+ fi
+
+ sleep_maxage
+
+ free_kb=$($LFS df $MOUNT | grep $1 | awk '{ print $4 }')
+ echo "OST still has $((free_kb / 1024)) mbytes free"
+}
+
+test_253() {
+ local ostidx=0
+ local rc=0
+
+ [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
+ remote_mds_nodsh && skip "remote MDS with nodsh" && return
+ remote_mgs_nodsh && skip "remote MGS with nodsh" && return
+
+ local ost_name=$($LFS osts | grep ${ostidx}": " | \
+ awk '{print $2}' | sed -e 's/_UUID$//')
+ # on the mdt's osc
+ local mdtosc_proc1=$(get_mdtosc_proc_path $SINGLEMDS $ost_name)
+ do_facet $SINGLEMDS $LCTL get_param -n \
+ osp.$mdtosc_proc1.reserved_mb_high ||
+ { skip "remote MDS does not support reserved_mb_high" &&
+ return; }
+
+ rm -rf $DIR/$tdir
+ wait_mds_ost_sync
+ wait_delete_completed
+ mkdir $DIR/$tdir
+
+ local last_wm_h=$(do_facet $SINGLEMDS $LCTL get_param -n \
+ osp.$mdtosc_proc1.reserved_mb_high)
+ local last_wm_l=$(do_facet $SINGLEMDS $LCTL get_param -n \
+ osp.$mdtosc_proc1.reserved_mb_low)
+ echo "prev high watermark $last_wm_h, prev low watermark $last_wm_l"
+
+ do_facet mgs $LCTL pool_new $FSNAME.$TESTNAME ||
+ error "Pool creation failed"
+ do_facet mgs $LCTL pool_add $FSNAME.$TESTNAME $ost_name ||
+ error "Adding $ost_name to pool failed"
+
+ # Wait for client to see a OST at pool
+ wait_update $HOSTNAME "$LCTL get_param -n
+ lov.$FSNAME-*.pools.$TESTNAME | sort -u |
+ grep $ost_name" "$ost_name""_UUID" $((TIMEOUT/2)) ||
+ error "Client can not see the pool"
+ $SETSTRIPE $DIR/$tdir -i $ostidx -c 1 -p $FSNAME.$TESTNAME ||
+ error "Setstripe failed"
+
+ dd if=/dev/zero of=$DIR/$tdir/0 bs=1M count=10
+ local blocks=$($LFS df $MOUNT | grep $ost_name | awk '{ print $4 }')
+ echo "OST still has $((blocks/1024)) mbytes free"
+
+ local new_lwm=$((blocks/1024-10))
+ do_facet $SINGLEMDS $LCTL set_param \
+ osp.$mdtosc_proc1.reserved_mb_high=$((new_lwm+5))
+ do_facet $SINGLEMDS $LCTL set_param \
+ osp.$mdtosc_proc1.reserved_mb_low=$new_lwm
+
+ test_253_fill_ost $ost_name $mdtosc_proc1 $new_lwm
+
+ #First enospc could execute orphan deletion so repeat.
+ test_253_fill_ost $ost_name $mdtosc_proc1 $new_lwm
+
+ local oa_status=$(do_facet $SINGLEMDS $LCTL get_param -n \
+ osp.$mdtosc_proc1.prealloc_status)
+ echo "prealloc_status $oa_status"
+
+ dd if=/dev/zero of=$DIR/$tdir/2 bs=1M count=1 &&
+ error "File creation should fail"
+ #object allocation was stopped, but we still able to append files
+ dd if=/dev/zero of=$DIR/$tdir/1 bs=1M seek=6 count=5 oflag=append ||
+ error "Append failed"
+ rm -f $DIR/$tdir/1 $DIR/$tdir/0 $DIR/$tdir/r*
+
+ wait_delete_completed
+
+ sleep_maxage
+
+ for i in $(seq 10 12); do
+ dd if=/dev/zero of=$DIR/$tdir/$i bs=1M count=1 2>/dev/null ||
+ error "File creation failed after rm";
+ done
+
+ oa_status=$(do_facet $SINGLEMDS $LCTL get_param -n \
+ osp.$mdtosc_proc1.prealloc_status)
+ echo "prealloc_status $oa_status"
+
+ if (( oa_status != 0 )); then
+ error "Object allocation still disable after rm"
+ fi
+ do_facet $SINGLEMDS $LCTL set_param \
+ osp.$mdtosc_proc1.reserved_mb_high=$last_wm_h
+ do_facet $SINGLEMDS $LCTL set_param \
+ osp.$mdtosc_proc1.reserved_mb_low=$last_wm_l
+
+
+ do_facet mgs $LCTL pool_remove $FSNAME.$TESTNAME $ost_name ||
+ error "Remove $ost_name from pool failed"
+ do_facet mgs $LCTL pool_destroy $FSNAME.$TESTNAME ||
+ error "Pool destroy fialed"
+}
+run_test 253 "Check object allocation limit"
+
test_254() {
local cl_user
}
run_test 254 "Check changelog size"
+ladvise_no_type()
+{
+ local type=$1
+ local file=$2
+
+ lfs ladvise -a invalid $file 2>&1 | grep "Valid types" |
+ awk -F: '{print $2}' | grep $type > /dev/null
+ if [ $? -ne 0 ]; then
+ return 0
+ fi
+ return 1
+}
+
+ladvise_no_ioctl()
+{
+ local file=$1
+
+ lfs ladvise -a willread $file > /dev/null 2>&1
+ if [ $? -eq 0 ]; then
+ return 1
+ fi
+
+ lfs ladvise -a willread $file 2>&1 |
+ grep "Inappropriate ioctl for device" > /dev/null
+ if [ $? -eq 0 ]; then
+ return 0
+ fi
+ return 1
+}
+
+ladvise_willread_performance()
+{
+ local repeat=10
+ local average_cache=0
+ local average_ladvise=0
+
+ for ((i = 1; i <= $repeat; i++)); do
+ echo "Iter $i/$repeat: reading without willread hint"
+ cancel_lru_locks osc
+ do_nodes $(comma_list $(osts_nodes)) \
+ "echo 3 > /proc/sys/vm/drop_caches"
+ local speed_origin=$($READS -f $DIR/$tfile -s $size \
+ -b 4096 -n $((size / 4096)) -t 60 |
+ sed -e '/^$/d' -e 's#.*s, ##' -e 's#MB/s##')
+
+ echo "Iter $i/$repeat: Reading again without willread hint"
+ cancel_lru_locks osc
+ local speed_cache=$($READS -f $DIR/$tfile -s $size \
+ -b 4096 -n $((size / 4096)) -t 60 |
+ sed -e '/^$/d' -e 's#.*s, ##' -e 's#MB/s##')
+
+ echo "Iter $i/$repeat: reading with willread hint"
+ cancel_lru_locks osc
+ do_nodes $(comma_list $(osts_nodes)) \
+ "echo 3 > /proc/sys/vm/drop_caches"
+ lfs ladvise -a willread $DIR/$tfile ||
+ error "Ladvise failed"
+ local speed_ladvise=$($READS -f $DIR/$tfile -s $size \
+ -b 4096 -n $((size / 4096)) -t 60 |
+ sed -e '/^$/d' -e 's#.*s, ##' -e 's#MB/s##')
+
+ local cache_speedup=$(echo "scale=2; \
+ ($speed_cache-$speed_origin)/$speed_origin*100" | bc)
+ cache_speedup=$(echo ${cache_speedup%.*})
+ echo "Iter $i/$repeat: cache speedup: $cache_speedup%"
+ average_cache=$((average_cache + cache_speedup))
+
+ local ladvise_speedup=$(echo "scale=2; \
+ ($speed_ladvise-$speed_origin)/$speed_origin*100" | bc)
+ ladvise_speedup=$(echo ${ladvise_speedup%.*})
+ echo "Iter $i/$repeat: ladvise speedup: $ladvise_speedup%"
+ average_ladvise=$((average_ladvise + ladvise_speedup))
+ done
+ average_cache=$((average_cache / repeat))
+ average_ladvise=$((average_ladvise / repeat))
+
+ if [ $average_cache -lt 20 ]; then
+ echo "Speedup with cache is less than 20% ($average_cache%),"\
+ "skipping check of speedup with willread:"\
+ "$average_ladvise%"
+ return 0
+ fi
+
+ local lowest_speedup=$((average_cache / 2))
+ [ $average_ladvise -gt $lowest_speedup ] ||
+ error_not_in_vm "Speedup with willread is less than " \
+ "$lowest_speedup%, got $average_ladvise%"
+ echo "Speedup with willread ladvise: $average_ladvise%"
+ echo "Speedup with cache: $average_cache%"
+}
+
+test_255a() {
+ lfs setstripe -c -1 -i 0 $DIR/$tfile || error "$tfile failed"
+
+ ladvise_no_type willread $DIR/$tfile &&
+ skip "willread ladvise is not supported" && return
+
+ ladvise_no_ioctl $DIR/$tfile &&
+ skip "ladvise ioctl is not supported" && return
+
+ [ $(lustre_version_code ost1) -lt $(version_code 2.8.54) ] &&
+ skip "lustre < 2.8.54 does not support ladvise " && return
+
+ local size_mb=100
+ local size=$((size_mb * 1048576))
+ dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=$size_mb ||
+ error "dd to $DIR/$tfile failed"
+
+ lfs ladvise -a willread $DIR/$tfile ||
+ error "Ladvise failed with no range argument"
+
+ lfs ladvise -a willread -s 0 $DIR/$tfile ||
+ error "Ladvise failed with no -l or -e argument"
+
+ lfs ladvise -a willread -e 1 $DIR/$tfile ||
+ error "Ladvise failed with only -e argument"
+
+ lfs ladvise -a willread -l 1 $DIR/$tfile ||
+ error "Ladvise failed with only -l argument"
+
+ lfs ladvise -a willread -s 2 -e 1 $DIR/$tfile &&
+ error "End offset should not be smaller than start offset"
+
+ lfs ladvise -a willread -s 2 -e 2 $DIR/$tfile &&
+ error "End offset should not be equal to start offset"
+
+ lfs ladvise -a willread -s $size -l 1 $DIR/$tfile ||
+ error "Ladvise failed with overflowing -s argument"
+
+ lfs ladvise -a willread -s 1 -e $((size + 1)) $DIR/$tfile ||
+ error "Ladvise failed with overflowing -e argument"
+
+ lfs ladvise -a willread -s 1 -l $size $DIR/$tfile ||
+ error "Ladvise failed with overflowing -l argument"
+
+ lfs ladvise -a willread -l 1 -e 2 $DIR/$tfile &&
+ error "Ladvise succeeded with conflicting -l and -e arguments"
+
+ echo "Synchronous ladvise should wait"
+ local delay=4
+#define OBD_FAIL_OST_LADVISE_PAUSE 0x237
+ do_nodes $(comma_list $(osts_nodes)) \
+ $LCTL set_param fail_val=$delay fail_loc=0x237
+
+ local start_ts=$SECONDS
+ lfs ladvise -a willread $DIR/$tfile ||
+ error "Ladvise failed with no range argument"
+ local end_ts=$SECONDS
+ local inteval_ts=$((end_ts - start_ts))
+
+ if [ $inteval_ts -lt $(($delay - 1)) ]; then
+ error "Synchronous advice didn't wait reply"
+ fi
+
+ echo "Asynchronous ladvise shouldn't wait"
+ local start_ts=$SECONDS
+ lfs ladvise -a willread -b $DIR/$tfile ||
+ error "Ladvise failed with no range argument"
+ local end_ts=$SECONDS
+ local inteval_ts=$((end_ts - start_ts))
+
+ if [ $inteval_ts -gt $(($delay / 2)) ]; then
+ error "Asynchronous advice blocked"
+ fi
+
+ do_nodes $(comma_list $(osts_nodes)) $LCTL set_param fail_loc=0
+ ladvise_willread_performance
+}
+run_test 255a "check 'lfs ladvise -a willread'"
+
+facet_meminfo() {
+ local facet=$1
+ local info=$2
+
+ do_facet $facet "cat /proc/meminfo | grep ^${info}:" | awk '{print $2}'
+}
+
+test_255b() {
+ ladvise_no_type dontneed $DIR/$tfile &&
+ skip "dontneed ladvise is not supported" && return
+
+ ladvise_no_ioctl $DIR/$tfile &&
+ skip "ladvise ioctl is not supported" && return
+
+ [ $(lustre_version_code ost1) -lt $(version_code 2.8.54) ] &&
+ skip "lustre < 2.8.54 does not support ladvise" && return
+
+ [ "$(facet_fstype ost1)" = "zfs" ] &&
+ skip "zfs-osd does not support dontneed advice" && return
+
+ lfs setstripe -c 1 -i 0 $DIR/$tfile
+
+ local size_mb=100
+ local size=$((size_mb * 1048576))
+ # In order to prevent disturbance of other processes, only check 3/4
+ # of the memory usage
+ local kibibytes=$((size_mb * 1024 * 3 / 4))
+
+ dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=$size_mb ||
+ error "dd to $DIR/$tfile failed"
+
+ local total=$(facet_meminfo ost1 MemTotal)
+ echo "Total memory: $total KiB"
+
+ do_facet ost1 "sync && echo 3 > /proc/sys/vm/drop_caches"
+ local before_read=$(facet_meminfo ost1 Cached)
+ echo "Cache used before read: $before_read KiB"
+
+ lfs ladvise -a willread $DIR/$tfile ||
+ error "Ladvise willread failed"
+ local after_read=$(facet_meminfo ost1 Cached)
+ echo "Cache used after read: $after_read KiB"
+
+ lfs ladvise -a dontneed $DIR/$tfile ||
+ error "Ladvise dontneed again failed"
+ local no_read=$(facet_meminfo ost1 Cached)
+ echo "Cache used after dontneed ladvise: $no_read KiB"
+
+ if [ $total -lt $((before_read + kibibytes)) ]; then
+ echo "Memory is too small, abort checking"
+ return 0
+ fi
+
+ if [ $((before_read + kibibytes)) -gt $after_read ]; then
+ error "Ladvise willread should use more memory" \
+ "than $kibibytes KiB"
+ fi
+
+ if [ $((no_read + kibibytes)) -gt $after_read ]; then
+ error "Ladvise dontneed should release more memory" \
+ "than $kibibytes KiB"
+ fi
+}
+run_test 255b "check 'lfs ladvise -a dontneed'"
+
test_256() {
local cl_user
local cat_sl
}
run_test 256 "Check llog delete for empty and not full state"
+test_257() {
+ remote_mds_nodsh && skip "remote MDS with nodsh" && return
+ [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.8.55) ]] &&
+ skip "Need MDS version at least 2.8.55" && return
+
+ test_mkdir -p $DIR/$tdir
+
+ setfattr -n trusted.name1 -v value1 $DIR/$tdir ||
+ error "setfattr -n trusted.name1=value1 $DIR/$tdir failed"
+ stat $DIR/$tdir
+
+#define OBD_FAIL_MDS_XATTR_REP 0x161
+ local mdtidx=$($LFS getstripe -M $DIR/$tdir)
+ local facet=mds$((mdtidx + 1))
+ set_nodes_failloc $(facet_active_host $facet) 0x80000161
+ getfattr -n trusted.name1 $DIR/$tdir 2> /dev/null
+
+ stop $facet || error "stop MDS failed"
+ start $facet $(mdsdevname $((mdtidx + 1))) $MDS_MOUNT_OPTS ||
+ error "start MDS fail"
+}
+run_test 257 "xattr locks are not lost"
+
test_260() {
#define OBD_FAIL_MDC_CLOSE 0x806
$LCTL set_param fail_loc=0x80000806
local new_iused
for i in $(seq 120); do
new_iused=$($LFS df -i | grep OST0000 | awk '{ print $3 }')
- [ $new_iused -lt $((old_iused - 900)) ] && break
+ [ $((old_iused - new_iused)) -gt 800 ] && break
sleep 1
done
echo "waited $i sec, old Iused $old_iused, new Iused $new_iused"
- [ $new_iused -lt $((old_iused - 900)) ] ||
+ [ $((old_iused - new_iused)) -gt 800 ] ||
error "objs not destroyed after unlink"
}
run_test 311 "disable OSP precreate, and unlink should destroy objs"
+zfs_oid_to_objid()
+{
+ local ost=$1
+ local objid=$2
+
+ local vdevdir=$(dirname $(facet_vdevice $ost))
+ local cmd="$ZDB -e -p $vdevdir -dddd $(facet_device $ost)"
+ local zfs_zapid=$(do_facet $ost $cmd |
+ grep -w "/O/0/d$((objid%32))" -C 5 |
+ awk '/Object/{getline; print $1}')
+ local zfs_objid=$(do_facet $ost $cmd $zfs_zapid |
+ awk "/$objid = /"'{printf $3}')
+
+ echo $zfs_objid
+}
+
+zfs_object_blksz() {
+ local ost=$1
+ local objid=$2
+
+ local vdevdir=$(dirname $(facet_vdevice $ost))
+ local cmd="$ZDB -e -p $vdevdir -dddd $(facet_device $ost)"
+ local blksz=$(do_facet $ost $cmd $objid |
+ awk '/dblk/{getline; printf $4}')
+
+ case "${blksz: -1}" in
+ k|K) blksz=$((${blksz:0:$((${#blksz} - 1))}*1024)) ;;
+ m|M) blksz=$((${blksz:0:$((${#blksz} - 1))}*1024*1024)) ;;
+ *) ;;
+ esac
+
+ echo $blksz
+}
+
+test_312() { # LU-4856
+ [ $(facet_fstype ost1) = "zfs" ] ||
+ { skip "the test only applies to zfs" && return; }
+
+ local max_blksz=$(do_facet ost1 \
+ $ZFS get -p recordsize $(facet_device ost1) |
+ awk '!/VALUE/{print $3}')
+
+ # to make life a little bit easier
+ $LFS mkdir -c 1 -i 0 $DIR/$tdir
+ $LFS setstripe -c 1 -i 0 $DIR/$tdir
+
+ local tf=$DIR/$tdir/$tfile
+ touch $tf
+ local oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
+
+ # Get ZFS object id
+ local zfs_objid=$(zfs_oid_to_objid ost1 $oid)
+
+ # block size change by sequential over write
+ local blksz
+ for ((bs=4096; bs <= max_blksz; bs <<= 2)); do
+ dd if=/dev/zero of=$tf bs=$bs count=1 oflag=sync conv=notrunc
+
+ blksz=$(zfs_object_blksz ost1 $zfs_objid)
+ [ $blksz -eq $bs ] || error "blksz error: $blksz, expected: $bs"
+ done
+ rm -f $tf
+
+ # block size change by sequential append write
+ dd if=/dev/zero of=$tf bs=4K count=1 oflag=sync conv=notrunc
+ oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
+ zfs_objid=$(zfs_oid_to_objid ost1 $oid)
+
+ for ((count = 1; count < $((max_blksz / 4096)); count *= 2)); do
+ dd if=/dev/zero of=$tf bs=4K count=$count seek=$count \
+ oflag=sync conv=notrunc
+
+ blksz=$(zfs_object_blksz ost1 $zfs_objid)
+ blksz=$((blksz / 8192)) # in 2*4K unit
+ [ $blksz -eq $count ] ||
+ error "blksz error(in 8k): $blksz, expected: $count"
+ done
+ rm -f $tf
+
+ # random write
+ touch $tf
+ oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
+ zfs_objid=$(zfs_oid_to_objid ost1 $oid)
+
+ dd if=/dev/zero of=$tf bs=8K count=1 oflag=sync conv=notrunc
+ blksz=$(zfs_object_blksz ost1 $zfs_objid)
+ [ $blksz -eq 8192 ] || error "blksz error: $blksz, expected: 8k"
+
+ dd if=/dev/zero of=$tf bs=64K count=1 oflag=sync conv=notrunc seek=128
+ blksz=$(zfs_object_blksz ost1 $zfs_objid)
+ [ $blksz -eq 65536 ] || error "blksz error: $blksz, expected: 64k"
+
+ dd if=/dev/zero of=$tf bs=1M count=1 oflag=sync conv=notrunc
+ blksz=$(zfs_object_blksz ost1 $zfs_objid)
+ [ $blksz -eq 65536 ] || error "rewrite error: $blksz, expected: 64k"
+}
+run_test 312 "make sure ZFS adjusts its block size by write pattern"
+
+test_399() { # LU-7655 for OST fake write
+ # turn off debug for performance testing
+ local saved_debug=$($LCTL get_param -n debug)
+ $LCTL set_param debug=0
+
+ $SETSTRIPE -c 1 -i 0 $DIR/$tfile
+
+ # get ost1 size - lustre-OST0000
+ local ost1_avail_size=$($LFS df | awk /${ost1_svc}/'{ print $4 }')
+ local blocks=$((ost1_avail_size/2/1024)) # half avail space by megabytes
+ [ $blocks -gt 1000 ] && blocks=1000 # 1G in maximum
+
+ local start_time=$(date +%s.%N)
+ dd if=/dev/zero of=$DIR/$tfile bs=1M count=$blocks oflag=sync ||
+ error "real dd writing error"
+ local duration=$(bc <<< "$(date +%s.%N) - $start_time")
+ rm -f $DIR/$tfile
+
+ # define OBD_FAIL_OST_FAKE_WRITE 0x238
+ do_facet ost1 $LCTL set_param fail_loc=0x238
+
+ local start_time=$(date +%s.%N)
+ dd if=/dev/zero of=$DIR/$tfile bs=1M count=$blocks oflag=sync ||
+ error "fake dd writing error"
+ local duration_fake=$(bc <<< "$(date +%s.%N) - $start_time")
+
+ # verify file size
+ cancel_lru_locks osc
+ $CHECKSTAT -t file -s $((blocks * 1024 * 1024)) $DIR/$tfile ||
+ error "$tfile size not $blocks MB"
+
+ do_facet ost1 $LCTL set_param fail_loc=0
+
+ echo "fake write $duration_fake vs. normal write $duration in seconds"
+ [ $(bc <<< "$duration_fake < $duration") -eq 1 ] ||
+ error_not_in_vm "fake write is slower"
+
+ $LCTL set_param -n debug="$saved_debug"
+ rm -f $DIR/$tfile
+}
+run_test 399 "fake write should not be slower than normal write"
+
test_400a() { # LU-1606, was conf-sanity test_74
local extra_flags=''
local out=$TMP/$tfile
}
run_test 406 "DNE support fs default striping"
+test_407() {
+ [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
+
+ [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.8.55) ]] &&
+ skip "Need MDS version at least 2.8.55" && return
+
+ $LFS mkdir -i 0 -c 1 $DIR/$tdir.0 ||
+ error "$LFS mkdir -i 0 -c 1 $tdir.0 failed"
+ $LFS mkdir -i 1 -c 1 $DIR/$tdir.1 ||
+ error "$LFS mkdir -i 1 -c 1 $tdir.1 failed"
+ touch $DIR/$tdir.0/$tfile.0 || error "touch $tdir.0/$tfile.0 failed"
+
+ #define OBD_FAIL_DT_TXN_STOP 0x2019
+ for idx in $(seq $MDSCOUNT); do
+ do_facet mds$idx "lctl set_param fail_loc=0x2019"
+ done
+ $LFS mkdir -c 2 $DIR/$tdir && error "$LFS mkdir -c 2 $tdir should fail"
+ mv $DIR/$tdir.0/$tfile.0 $DIR/$tdir.1/$tfile.1 &&
+ error "mv $tdir.0/$tfile.0 $tdir.1/$tfile.1 should fail"
+ true
+}
+run_test 407 "transaction fail should cause operation fail"
+
+test_408() {
+ dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 oflag=direct
+
+ #define OBD_FAIL_OSC_BRW_PREP_REQ2 0x40a
+ lctl set_param fail_loc=0x8000040a
+ # let ll_prepare_partial_page() fail
+ dd if=/dev/zero of=$DIR/$tfile bs=2048 count=1 conv=notrunc || true
+
+ rm -f $DIR/$tfile
+
+ # create at least 100 unused inodes so that
+ # shrink_icache_memory(0) should not return 0
+ touch $DIR/$tfile-{0..100}
+ rm -f $DIR/$tfile-{0..100}
+ sync
+
+ echo 2 > /proc/sys/vm/drop_caches
+}
+run_test 408 "drop_caches should not hang due to page leaks"
+
#
# tests that do cleanup/setup should be run at the end
#
git://git.whamcloud.com / fs / lustre-release.git / blobdiff