# Strip getstripe output to a space separated list of OSTs
local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
- awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
+ awk '{print $1}' | tr '\n' ' ' | sed -e 's/[[:space:]]*$//')
[ "$getstripe_osts" = "${osts//,/ }" ] ||
error "stripes not on specified OSTs"
# Strip getstripe output to a space separated list of OSTs
local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
- awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
+ awk '{print $1}' | tr '\n' ' ' | sed -e 's/[[:space:]]*$//')
[ "$getstripe_osts" = "${osts//,/ }" ] ||
error "stripes not on specified OSTs"
# Strip getstripe output to a space separated list of OSTs
local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
- awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
+ awk '{print $1}' | tr '\n' ' ' | sed -e 's/[[:space:]]*$//')
[ "$getstripe_osts" = "${osts//,/ }" ] ||
error "stripes not on specified OSTs"
# Strip getstripe output to a space separated list of OSTs
local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
- awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
+ awk '{print $1}' | tr '\n' ' ' | sed -e 's/[[:space:]]*$//')
[ "$getstripe_osts" = "${osts//,/ }" ] ||
error "stripes not on specified OSTs"
local write_bytes
local all_zeros
- all_zeros=:
- rm -fr $DIR/$tdir
+ all_zeros=true
test_mkdir $DIR/$tdir
# Read: 0, Write: 4, create/destroy: 2/0, stat: 1, punch: 0
- sync
- for ostnum in $(seq $OSTCOUNT); do
- # test-framework's OST numbering is one-based, while Lustre's
- # is zero-based
- ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
- # Parsing llobdstat's output sucks; we could grep the /proc
- # path, but that's likely to not be as portable as using the
- # llobdstat utility. So we parse lctl output instead.
- write_bytes=$(do_facet ost$ostnum lctl get_param -n \
- obdfilter/$ostname/stats |
- awk '/^write_bytes/ {print $7}' )
- echo "baseline_write_bytes@$OSTnum/$ostname=$write_bytes"
- if (( ${write_bytes:-0} > 0 ))
- then
- all_zeros=false
- break;
- fi
- done
+ sync
+ for ostnum in $(seq $OSTCOUNT); do
+ # test-framework's OST numbering is one-based, while Lustre's
+ # is zero-based
+ ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
+ # check if at least some write_bytes stats are counted
+ write_bytes=$(do_facet ost$ostnum lctl get_param -n \
+ obdfilter.$ostname.stats |
+ awk '/^write_bytes/ {print $7}' )
+ echo "baseline_write_bytes@ost$ostnum/$ostname=$write_bytes"
+ if (( ${write_bytes:-0} > 0 )); then
+ all_zeros=false
+ break
+ fi
+ done
- $all_zeros || return 0
+ $all_zeros || return 0
# Write four bytes
echo foo > $DIR/$tdir/bar
# Really write them
sync
- # Total up write_bytes after writing. We'd better find non-zeros.
- for ostnum in $(seq $OSTCOUNT); do
- ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
- write_bytes=$(do_facet ost$ostnum lctl get_param -n \
- obdfilter/$ostname/stats |
- awk '/^write_bytes/ {print $7}' )
- echo "write_bytes@$OSTnum/$ostname=$write_bytes"
- if (( ${write_bytes:-0} > 0 ))
- then
- all_zeros=false
- break;
- fi
- done
+ # Total up write_bytes after writing. We'd better find non-zeros.
+ for ostnum in $(seq $OSTCOUNT); do
+ ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
+ write_bytes=$(do_facet ost$ostnum lctl get_param -n \
+ obdfilter/$ostname/stats |
+ awk '/^write_bytes/ {print $7}' )
+ echo "write_bytes@ost$ostnum/$ostname=$write_bytes"
+ if (( ${write_bytes:-0} > 0 )); then
+ all_zeros=false
+ break
+ fi
+ done
- if $all_zeros
- then
- for ostnum in $(seq $OSTCOUNT); do
- ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
- echo "Check that write_bytes is present in obdfilter/*/stats:"
- do_facet ost$ostnum lctl get_param -n \
- obdfilter/$ostname/stats
- done
- error "OST not keeping write_bytes stats (b22312)"
- fi
+ if $all_zeros; then
+ for ostnum in $(seq $OSTCOUNT); do
+ ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
+ echo "Check write_bytes is in obdfilter.*.stats:"
+ do_facet ost$ostnum lctl get_param -n \
+ obdfilter.$ostname.stats
+ done
+ error "OST not keeping write_bytes stats (b=22312)"
+ fi
}
-run_test 33c "test llobdstat and write_bytes"
+run_test 33c "test write_bytes stats"
test_33d() {
[[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
if [ $y == "t" ]; then
if [ $x == "b" ]; then
- ref="\"$(do_facet mds1 date +"%Y-%m-%d\ %H:%M:%S")\""
+ ref=\"$(do_facet mds1 date +"%Y-%m-%d\ %H:%M:%S")\"
else
- ref="\"$(date +"%Y-%m-%d %H:%M:%S")\""
+ ref=\"$(date +"%Y-%m-%d %H:%M:%S")\"
fi
else
ref=$DIR/$tfile.newer.$x$y
sleep 2
if [ $y == "t" ]; then
if [ $x == "b" ]; then
- negref="\"$(do_facet mds1 date +"%Y-%m-%d\ %H:%M:%S")\""
+ negref=\"$(do_facet mds1 date +"%Y-%m-%d\ %H:%M:%S")\"
else
- negref="\"$(date +"%Y-%m-%d %H:%M:%S")\""
+ negref=\"$(date +"%Y-%m-%d %H:%M:%S")\"
fi
else
negref=$DIR/$tfile.negnewer.$x$y
}
run_test 60e "no space while new llog is being created"
+test_60f() {
+ local old_path=$($LCTL get_param -n debug_path)
+
+ stack_trap "$LCTL set_param debug_path=$old_path"
+ stack_trap "rm -f $TMP/$tfile*"
+ rm -f $TMP/$tfile* 2> /dev/null
+ #define OBD_FAIL_PTLRPC_DUMP_LOG 0x50e
+ $LCTL set_param debug_path=$TMP/$tfile fail_loc=0x8000050e
+ test_mkdir $DIR/$tdir
+ # retry in case the open is cached and not released
+ for (( i = 0; i < 100 && $(ls $TMP/$tfile* | wc -l) == 0; i++ )); do
+ echo $i > $DIR/$tdir/$tfile.$i && cat $DIR/$tdir/$tfile.$i
+ sleep 0.1
+ done
+ ls $TMP/$tfile*
+ (( $(ls $TMP/$tfile* | wc -l) > 0 )) || error "$TMP/$tfile not dumped"
+}
+run_test 60f "change debug_path works"
+
test_60g() {
local pid
local i
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
+ local tag=$1
+
+ grep -w "$tag" | sed "s/^$tag *\([0-9]*\) *.*/\1/"
}
export CACHE_MAX=$($LCTL get_param -n llite.*.max_cached_mb |
local nreads=10000
local cache_limit=32
- $LCTL set_param -n osc.*-osc*.rpc_stats 0
+ $LCTL set_param -n osc.*-osc*.rpc_stats=0
trap cleanup_101a EXIT
- $LCTL set_param -n llite.*.read_ahead_stats 0
- $LCTL set_param -n llite.*.max_cached_mb $cache_limit
+ $LCTL set_param -n llite.*.read_ahead_stats=0
+ $LCTL set_param -n llite.*.max_cached_mb=$cache_limit
#
# randomly read 10000 of 64K chunks from file 3x 32MB in size
discard=0
for s in $($LCTL get_param -n llite.*.read_ahead_stats |
- get_named_value 'read but discarded' | cut -d" " -f1); do
+ get_named_value 'read.but.discarded'); do
discard=$(($discard + $s))
done
cleanup_101a
local discard_limit=$((((STRIDE_LENGTH - 1)*3/(STRIDE_LENGTH*OSTCOUNT))* \
(STRIDE_LENGTH*OSTCOUNT - STRIDE_LENGTH)))
DISCARD=$($LCTL get_param -n llite.*.read_ahead_stats |
- get_named_value 'read but discarded' |
- cut -d" " -f1 | calc_total)
+ get_named_value 'read.but.discarded' | calc_total)
if [[ $DISCARD -gt $discard_limit ]]; then
$LCTL get_param llite.*.read_ahead_stats
error "Too many ($DISCARD) discarded pages with size (${READ_SIZE})"
local READ_COUNT=$((STRIPE_SIZE/BSIZE))
local STRIDE_LENGTH=$((STRIDE_SIZE/BSIZE))
local OFFSET=$((STRIPE_SIZE/BSIZE*(OSTCOUNT - 1)))
- $LCTL set_param -n llite.*.read_ahead_stats 0
+ $LCTL set_param -n llite.*.read_ahead_stats=0
$READS -f $DIR/$tfile -l $STRIDE_LENGTH -o $OFFSET \
-s $FILE_LENGTH -b $STRIPE_SIZE -a $READ_COUNT -n $ITERATION
cancel_lru_locks osc
setup_test101bc $STRIPE_SIZE $FILE_LENGTH
cancel_lru_locks osc
- $LCTL set_param osc.*.rpc_stats 0
+ $LCTL set_param osc.*.rpc_stats=0
$READS -f $DIR/$tfile -s$FILE_LENGTH -b$rsize -n$nreads -t 180
$LCTL get_param osc.*.rpc_stats
for osc_rpc_stats in $($LCTL get_param -N osc.*.rpc_stats); do
cleanup_test101bc
true
}
-run_test 101c "check stripe_size aligned read-ahead ================="
+run_test 101c "check stripe_size aligned read-ahead"
test_101d() {
[ $PARALLEL == "yes" ] && skip "skip parallel run"
echo Disable read-ahead
local old_RA=$($LCTL get_param -n llite.*.max_read_ahead_mb | head -n 1)
$LCTL set_param -n llite.*.max_read_ahead_mb=0
- stack_trap "$LCTL set_param -n llite.*.max_read_ahead_mb $old_RA" EXIT
+ stack_trap "$LCTL set_param -n llite.*.max_read_ahead_mb=$old_RA" EXIT
$LCTL get_param -n llite.*.max_read_ahead_mb
echo "Reading the test file $file with read-ahead disabled"
cancel_lru_locks $OSC
echo "Reset readahead stats"
- $LCTL set_param -n llite.*.read_ahead_stats 0
+ $LCTL set_param -n llite.*.read_ahead_stats=0
for ((i = 0; i < $count; i++)); do
dd if=$file.$i of=/dev/null bs=$bsize count=$size_KB 2>/dev/null
done
+ $LCTL get_param llite.*.max_cached_mb
+ $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)
+ get_named_value 'misses' | calc_total)
for ((i = 0; i < $count; i++)); do
rm -rf $file.$i 2>/dev/null
cancel_lru_locks osc
echo Reset readahead stats
- $LCTL set_param -n llite.*.read_ahead_stats 0
+ $LCTL set_param -n llite.*.read_ahead_stats=0
echo mmap read the file with small block size
iozone -i 1 -u 1 -l 1 -+n -r 32k -s 128m -B -f $DIR/$tfile \
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)
+ get_named_value 'misses' | calc_total)
$LCTL set_param debug="$old_debug"
[ $miss -lt 3 ] || error "misses too much pages ('$miss')!"
echo "Read 10M of data but cross 64M bundary"
dd if=$DIR/$tfile of=/dev/null bs=10M skip=6 count=1
local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
- get_named_value 'misses' | cut -d" " -f1 | calc_total)
+ get_named_value 'misses' | calc_total)
[ $miss -eq 1 ] || error "expected miss 1 but got $miss"
rm -f $p $DIR/$tfile
}
local count=$(($file_size / $blk))
dd if=$DIR/$tfile bs=$blk count=$count of=/dev/null
local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
- get_named_value 'failed to fast read' |
- cut -d" " -f1 | calc_total)
+ get_named_value 'failed.to.fast.read' | calc_total)
$LCTL get_param -n llite.*.read_ahead_stats
[ $miss -eq $count ] || error "expected $count got $miss"
done
run_test 103c "'cp -rp' won't set empty acl"
test_103e() {
- (( $MDS1_VERSION >= $(version_code 2.13.59) )) ||
- skip "MDS needs to be at least 2.13.59"
+ local numacl
+ local fileacl
+ local saved_debug=$($LCTL get_param -n debug)
+
+ (( $MDS1_VERSION >= $(version_code 2.14.0) )) ||
+ skip "MDS needs to be at least 2.14.0"
+
+ large_xattr_enabled || skip_env "ea_inode feature disabled"
mkdir -p $DIR/$tdir
- # one default ACL will be created for the file owner
- for U in {2..256}; do
- setfacl -m default:user:$U:rwx $DIR/$tdir
- numacl=$(getfacl $DIR/$tdir |& grep -c "default:user")
- touch $DIR/$tdir/$tfile.$U ||
- error "failed to create $tfile.$U with $numacl ACLs"
+ # add big LOV EA to cause reply buffer overflow earlier
+ $LFS setstripe -C 1000 $DIR/$tdir
+ lctl set_param mdc.*-mdc*.stats=clear
+
+ $LCTL set_param debug=0
+ stack_trap "$LCTL set_param debug=\"$saved_debug\"" EXIT
+ stack_trap "$LCTL get_param mdc.*-mdc*.stats" EXIT
+
+ # add a large number of default ACLs (expect 8000+ for 2.13+)
+ for U in {2..7000}; do
+ setfacl -d -m user:$U:rwx $DIR/$tdir ||
+ error "Able to add just $U default ACLs"
done
+ numacl=$(getfacl $DIR/$tdir |& grep -c "default:user")
+ echo "$numacl default ACLs created"
+
+ stat $DIR/$tdir || error "Cannot stat directory"
+ # check file creation
+ touch $DIR/$tdir/$tfile ||
+ error "failed to create $tfile with $numacl default ACLs"
+ stat $DIR/$tdir/$tfile || error "Cannot stat file"
+ fileacl=$(getfacl $DIR/$tdir/$tfile |& grep -c "user:")
+ echo "$fileacl ACLs were inherited"
+ (( $fileacl == $numacl )) ||
+ error "Not all default ACLs were inherited: $numacl != $fileacl"
+ # check that new ACLs creation adds new ACLs to inherited ACLs
+ setfacl -m user:19000:rwx $DIR/$tdir/$tfile ||
+ error "Cannot set new ACL"
+ numacl=$((numacl + 1))
+ fileacl=$(getfacl $DIR/$tdir/$tfile |& grep -c "user:")
+ (( $fileacl == $numacl )) ||
+ error "failed to add new ACL: $fileacl != $numacl as expected"
+ # adds more ACLs to a file to reach their maximum at 8000+
+ numacl=0
+ for U in {20000..25000}; do
+ setfacl -m user:$U:rwx $DIR/$tdir/$tfile || break
+ numacl=$((numacl + 1))
+ done
+ echo "Added $numacl more ACLs to the file"
+ fileacl=$(getfacl $DIR/$tdir/$tfile |& grep -c "user:")
+ echo "Total $fileacl ACLs in file"
+ stat $DIR/$tdir/$tfile > /dev/null || error "Cannot stat file"
+ rm -f $DIR/$tdir/$tfile || error "Cannot remove file"
+ rmdir $DIR/$tdir || error "Cannot remove directory"
}
run_test 103e "inheritance of big amount of default ACLs"
}
run_test 104b "$RUNAS lfs check servers test ===================="
+#
+# Verify $1 is within range of $2.
+# Success when $1 is within range. That is, when $1 is >= 2% of $2 and
+# $1 is <= 2% of $2. Else Fail.
+#
+value_in_range() {
+ # Strip all units (M, G, T)
+ actual=$(echo $1 | tr -d A-Z)
+ expect=$(echo $2 | tr -d A-Z)
+
+ expect_lo=$(($expect * 98 / 100)) # 2% below
+ expect_hi=$(($expect * 102 / 100)) # 2% above
+
+ # permit 2% drift above and below
+ (( $actual >= $expect_lo && $actual <= $expect_hi ))
+}
+
+test_104c() {
+ [ $PARALLEL == "yes" ] && skip "skip parallel run"
+ [ "$ost1_FSTYPE" == "zfs" ] || skip "zfs only test"
+
+ local ost_param="osd-zfs.$FSNAME-OST0000."
+ local mdt_param="osd-zfs.$FSNAME-MDT0000."
+ local ofacets=$(get_facets OST)
+ local mfacets=$(get_facets MDS)
+ local saved_ost_blocks=
+ local saved_mdt_blocks=
+
+ echo "Before recordsize change"
+ lfs_df=($($LFS df -h | grep "filesystem_summary:"))
+ df=($(df -h | grep "/mnt/lustre"$))
+
+ # For checking.
+ echo "lfs output : ${lfs_df[*]}"
+ echo "df output : ${df[*]}"
+
+ for facet in ${ofacets//,/ }; do
+ if [ -z $saved_ost_blocks ]; then
+ saved_ost_blocks=$(do_facet $facet \
+ lctl get_param -n $ost_param.blocksize)
+ echo "OST Blocksize: $saved_ost_blocks"
+ fi
+ ost=$(do_facet $facet lctl get_param -n $ost_param.mntdev)
+ do_facet $facet zfs set recordsize=32768 $ost
+ done
+
+ # BS too small. Sufficient for functional testing.
+ for facet in ${mfacets//,/ }; do
+ if [ -z $saved_mdt_blocks ]; then
+ saved_mdt_blocks=$(do_facet $facet \
+ lctl get_param -n $mdt_param.blocksize)
+ echo "MDT Blocksize: $saved_mdt_blocks"
+ fi
+ mdt=$(do_facet $facet lctl get_param -n $mdt_param.mntdev)
+ do_facet $facet zfs set recordsize=32768 $mdt
+ done
+
+ # Give new values chance to reflect change
+ sleep 2
+
+ echo "After recordsize change"
+ lfs_df_after=($($LFS df -h | grep "filesystem_summary:"))
+ df_after=($(df -h | grep "/mnt/lustre"$))
+
+ # For checking.
+ echo "lfs output : ${lfs_df_after[*]}"
+ echo "df output : ${df_after[*]}"
+
+ # Verify lfs df
+ value_in_range ${lfs_df_after[1]%.*} ${lfs_df[1]%.*} ||
+ error "lfs_df bytes: ${lfs_df_after[1]%.*} != ${lfs_df[1]%.*}"
+ value_in_range ${lfs_df_after[2]%.*} ${lfs_df[2]%.*} ||
+ error "lfs_df used: ${lfs_df_after[2]%.*} != ${lfs_df[2]%.*}"
+ value_in_range ${lfs_df_after[3]%.*} ${lfs_df[3]%.*} ||
+ error "lfs_df avail: ${lfs_df_after[3]%.*} != ${lfs_df[3]%.*}"
+
+ # Verify df
+ value_in_range ${df_after[1]%.*} ${df[1]%.*} ||
+ error "df bytes: ${df_after[1]%.*} != ${df[1]%.*}"
+ value_in_range ${df_after[2]%.*} ${df[2]%.*} ||
+ error "df used: ${df_after[2]%.*} != ${df[2]%.*}"
+ value_in_range ${df_after[3]%.*} ${df[3]%.*} ||
+ error "df avail: ${df_after[3]%.*} != ${df[3]%.*}"
+
+ # Restore MDT recordize back to original
+ for facet in ${mfacets//,/ }; do
+ mdt=$(do_facet $facet lctl get_param -n $mdt_param.mntdev)
+ do_facet $facet zfs set recordsize=$saved_mdt_blocks $mdt
+ done
+
+ # Restore OST recordize back to original
+ for facet in ${ofacets//,/ }; do
+ ost=$(do_facet $facet lctl get_param -n $ost_param.mntdev)
+ do_facet $facet zfs set recordsize=$saved_ost_blocks $ost
+ done
+
+ return 0
+}
+run_test 104c "Verify df vs lfs_df stays same after recordsize change"
+
test_105a() {
# doesn't work on 2.4 kernels
touch $DIR/$tfile
}
run_test 150e "Verify 60% of available OST space consumed by fallocate"
+test_150f() {
+ local size
+ local blocks
+ local want_size_before=20480 # in bytes
+ local want_blocks_before=40 # 512 sized blocks
+ local want_blocks_after=24 # 512 sized blocks
+ local length=$(((want_blocks_before - want_blocks_after) * 512))
+
+ [[ $OST1_VERSION -ge $(version_code 2.14.0) ]] ||
+ skip "need at least 2.14.0 for fallocate punch"
+
+ if [ "$ost1_FSTYPE" = "zfs" ] || [ "$mds1_FSTYPE" = "zfs" ]; then
+ skip "LU-14160: punch mode is not implemented on OSD ZFS"
+ fi
+
+ check_set_fallocate_or_skip
+ stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
+
+ echo "Verify fallocate punch: Range within the file range"
+ yes 'A' | dd of=$DIR/$tfile bs=4096 count=5 ||
+ error "dd failed for bs 4096 and count 5"
+
+ # Call fallocate with punch range which is within the file range
+ fallocate -p --offset 4096 -l $length $DIR/$tfile ||
+ error "fallocate failed: offset 4096 and length $length"
+ # client must see changes immediately after fallocate
+ size=$(stat -c '%s' $DIR/$tfile)
+ blocks=$(stat -c '%b' $DIR/$tfile)
+
+ # Verify punch worked.
+ (( blocks == want_blocks_after )) ||
+ error "punch failed: blocks $blocks != $want_blocks_after"
+
+ (( size == want_size_before )) ||
+ error "punch failed: size $size != $want_size_before"
+
+ # Verify there is hole in file
+ local data_off=$(lseek_test -d 4096 $DIR/$tfile)
+ # precomputed md5sum
+ local expect="4a9a834a2db02452929c0a348273b4aa"
+
+ cksum=($(md5sum $DIR/$tfile))
+ [[ "${cksum[0]}" == "$expect" ]] ||
+ error "unexpected MD5SUM after punch: ${cksum[0]}"
+
+ # Start second sub-case for fallocate punch.
+ echo "Verify fallocate punch: Range overlapping and less than blocksize"
+ yes 'A' | dd of=$DIR/$tfile bs=4096 count=5 ||
+ error "dd failed for bs 4096 and count 5"
+
+ # Punch range less than block size will have no change in block count
+ want_blocks_after=40 # 512 sized blocks
+
+ # Punch overlaps two blocks and less than blocksize
+ fallocate -p --offset 4000 -l 3000 $DIR/$tfile ||
+ error "fallocate failed: offset 4000 length 3000"
+ size=$(stat -c '%s' $DIR/$tfile)
+ blocks=$(stat -c '%b' $DIR/$tfile)
+
+ # Verify punch worked.
+ (( blocks == want_blocks_after )) ||
+ error "punch failed: blocks $blocks != $want_blocks_after"
+
+ (( size == want_size_before )) ||
+ error "punch failed: size $size != $want_size_before"
+
+ # Verify if range is really zero'ed out. We expect Zeros.
+ # precomputed md5sum
+ expect="c57ec5d769c3dbe3426edc3f7d7e11d3"
+ cksum=($(md5sum $DIR/$tfile))
+ [[ "${cksum[0]}" == "$expect" ]] ||
+ error "unexpected MD5SUM after punch: ${cksum[0]}"
+}
+run_test 150f "Verify fallocate punch functionality"
+
+test_150g() {
+ local space
+ local size
+ local blocks
+ local blocks_after
+ local size_after
+ local BS=4096 # Block size in bytes
+
+ [[ $OST1_VERSION -ge $(version_code 2.14.0) ]] ||
+ skip "need at least 2.14.0 for fallocate punch"
+
+ if [ "$ost1_FSTYPE" = "zfs" ] || [ "$mds1_FSTYPE" = "zfs" ]; then
+ skip "LU-14160: punch mode is not implemented on OSD ZFS"
+ fi
+
+ check_set_fallocate_or_skip
+ stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
+
+ $LFS setstripe -c${OSTCOUNT} $DIR/$tfile ||
+ error "$LFS setstripe -c${OSTCOUNT} $DIR/$tfile failed"
+
+ # Get 100MB per OST of the available space to reduce run time
+ # else 60% of the available space if we are running SLOW tests
+ if [ $SLOW == "no" ]; then
+ space=$((1024 * 100 * OSTCOUNT))
+ else
+ # Find OST with Minimum Size
+ space=$($LFS df | awk "/$FSNAME-OST/ { print \$4 }" |
+ sort -un | head -1)
+ echo "min size OST: $space"
+ space=$(((space * 60)/100 * OSTCOUNT))
+ fi
+ # space in 1k units, round to 4k blocks
+ local blkcount=$((space * 1024 / $BS))
+
+ echo "Verify fallocate punch: Very large Range"
+ fallocate -l${space}k $DIR/$tfile ||
+ error "fallocate ${space}k $DIR/$tfile failed"
+ # write 1M at the end, start and in the middle
+ yes 'A' | dd of=$DIR/$tfile bs=$BS count=256 ||
+ error "dd failed: bs $BS count 256"
+ yes 'A' | dd of=$DIR/$tfile bs=$BS seek=$((blkcount - 256)) count=256 ||
+ error "dd failed: bs $BS count 256 seek $((blkcount - 256))"
+ yes 'A' | dd of=$DIR/$tfile bs=$BS seek=$((blkcount / 2)) count=1024 ||
+ error "dd failed: bs $BS count 256 seek $((blkcount / 2))"
+
+ # Gather stats.
+ size=$(stat -c '%s' $DIR/$tfile)
+
+ # gather punch length.
+ local punch_size=$((size - (BS * 2)))
+
+ echo "punch_size = $punch_size"
+ echo "size - punch_size: $((size - punch_size))"
+ echo "size - punch_size in blocks: $(((size - punch_size)/BS))"
+
+ # Call fallocate to punch all except 2 blocks. We leave the
+ # first and the last block
+ echo "fallocate -p --offset $BS -l $punch_size $DIR/$tfile"
+ fallocate -p --offset $BS -l $punch_size $DIR/$tfile ||
+ error "fallocate failed: offset $BS length $punch_size"
+
+ size_after=$(stat -c '%s' $DIR/$tfile)
+ blocks_after=$(stat -c '%b' $DIR/$tfile)
+
+ # Verify punch worked.
+ # Size should be kept
+ (( size == size_after )) ||
+ error "punch failed: size $size != $size_after"
+
+ # two 4k data blocks to remain plus possible 1 extra extent block
+ (( blocks_after <= ((BS / 512) * 3) )) ||
+ error "too many blocks remains: $blocks_after"
+
+ # Verify that file has hole between the first and the last blocks
+ local hole_start=$(lseek_test -l 0 $DIR/$tfile)
+ local hole_end=$(lseek_test -d $BS $DIR/$tfile)
+
+ echo "Hole at [$hole_start, $hole_end)"
+ (( hole_start == BS )) ||
+ error "no hole at offset $BS after punch"
+
+ (( hole_end == BS + punch_size )) ||
+ error "data at offset $hole_end < $((BS + punch_size))"
+}
+run_test 150g "Verify fallocate punch on large range"
+
#LU-2902 roc_hit was not able to read all values from lproc
function roc_hit_init() {
local list=$(comma_list $(osts_nodes))
}
run_test 160l "Verify that MTIME changelog records contain the parent FID"
+test_160m() {
+ remote_mds_nodsh && skip "remote MDS with nodsh" && return
+ [[ $MDS1_VERSION -ge $(version_code 2.14.51) ]] ||
+ skip "Need MDS version at least 2.14.51"
+ local cl_users
+ local cl_user1
+ local cl_user2
+ local pid1
+
+ # Create a user
+ changelog_register || error "first changelog_register failed"
+ changelog_register || error "second changelog_register failed"
+
+ cl_users=(${CL_USERS[mds1]})
+ cl_user1="${cl_users[0]}"
+ cl_user2="${cl_users[1]}"
+ # generate some changelog records to accumulate on MDT0
+ test_mkdir -p -i0 -c1 $DIR/$tdir || error "test_mkdir $tdir failed"
+ createmany -m $DIR/$tdir/$tfile 50 ||
+ error "create $DIR/$tdir/$tfile failed"
+ unlinkmany $DIR/$tdir/$tfile 50 || error "unlinkmany failed"
+ rm -f $DIR/$tdir
+
+ # check changelogs have been generated
+ local nbcl=$(changelog_dump | wc -l)
+ [[ $nbcl -eq 0 ]] && error "no changelogs found"
+
+#define OBD_FAIL_MDS_CHANGELOG_RACE 0x15f
+ do_facet mds1 $LCTL set_param fail_loc=0x8000015f fail_val=0
+
+ __changelog_clear mds1 $cl_user1 +10
+ __changelog_clear mds1 $cl_user2 0 &
+ pid1=$!
+ sleep 2
+ __changelog_clear mds1 $cl_user1 0 ||
+ error "fail to cancel record for $cl_user1"
+ wait $pid1
+ [[ $? -eq 0 ]] || error "fail to cancel record for $cl_user2"
+}
+run_test 160m "Changelog clear race"
+
+
test_161a() {
[ $PARALLEL == "yes" ] && skip "skip parallel run"
}
run_test 230r "migrate with too many local locks"
+test_230s() {
+ [ $MDS1_VERSION -ge $(version_code 2.13.57) ] ||
+ skip "Need MDS version at least 2.13.57"
+
+ local mdts=$(comma_list $(mdts_nodes))
+ local restripe_status=$(do_facet mds1 $LCTL get_param -n \
+ mdt.*MDT0000.enable_dir_restripe)
+
+ stack_trap "do_nodes $mdts $LCTL set_param \
+ mdt.*.enable_dir_restripe=$restripe_status"
+
+ local st
+ for st in 0 1; do
+ do_nodes $mdts "$LCTL set_param mdt.*.enable_dir_restripe=$st"
+ test_mkdir $DIR/$tdir
+ $LFS mkdir $DIR/$tdir |& grep "File exists" ||
+ error "$LFS mkdir doesn't return -EEXIST if target exists"
+ rmdir $DIR/$tdir
+ done
+}
+run_test 230s "lfs mkdir should return -EEXIST if target exists"
+
+test_230t()
+{
+ [[ $MDSCOUNT -ge 2 ]] || skip_env "needs >= 2 MDTs"
+ [[ $MDS1_VERSION -ge $(version_code 2.14.50) ]] ||
+ skip "Need MDS version at least 2.14.50"
+
+ test_mkdir $DIR/$tdir || error "mkdir $tdir failed"
+ test_mkdir $DIR/$tdir/subdir || error "mkdir subdir failed"
+ $LFS project -p 1 -s $DIR/$tdir ||
+ error "set $tdir project id failed"
+ $LFS project -p 2 -s $DIR/$tdir/subdir ||
+ error "set subdir project id failed"
+ $LFS migrate -m 1 -c $MDSCOUNT $DIR/$tdir || error "migrate failed"
+}
+run_test 230t "migrate directory with project ID set"
+
test_231a()
{
# For simplicity this test assumes that max_pages_per_rpc
stop mgs || error "stop mgs failed"
#for a race mgs would crash
start mgs $(mgsdevname) $MGS_MOUNT_OPTS || error "start mgs failed"
+ # make sure we unmount client before remounting
+ wait
+ umount_client $MOUNT
mount_client $MOUNT || error "mount client failed"
}
run_test 280 "Race between MGS umount and client llog processing"
error "create dir0 under hash dir failed"
$LFS setdirstripe -i0 -c$MDSCOUNT -H fnv_1a_64 $DIR/$tdir/hashdir/d1 ||
error "create dir1 under hash dir failed"
+ $LFS setdirstripe -i0 -c$MDSCOUNT -H crush $DIR/$tdir/hashdir/d2 ||
+ error "create dir2 under hash dir failed"
# unfortunately, we need to umount to clear dir layout cache for now
# once we fully implement dir layout, we can drop this
umount_client $MOUNT || error "umount failed"
mount_client $MOUNT || error "mount failed"
- $LFS find -H fnv_1a_64 $DIR/$tdir/hashdir
- local dircnt=$($LFS find -H fnv_1a_64 $DIR/$tdir/hashdir | wc -l)
- [ $dircnt -eq 1 ] || error "lfs find striped dir got:$dircnt,except:1"
+ $LFS find -H fnv_1a_64,crush $DIR/$tdir/hashdir
+ local dircnt=$($LFS find -H fnv_1a_64,crush $DIR/$tdir/hashdir | wc -l)
+ [ $dircnt -eq 2 ] || error "lfs find striped dir got:$dircnt,except:1"
#set the stripe to be unknown hash type
#define OBD_FAIL_UNKNOWN_LMV_STRIPE 0x1901
skip "lustre < 2.8.54 does not contain LU-4825 fix"
remote_mds_nodsh && skip "remote MDS with nodsh"
- local old_iused=$($LFS df -i | grep OST0000 | awk '{ print $3 }')
+ local old_iused=$($LFS df -i | awk '/OST0000/ { print $3; exit; }')
local mdts=$(comma_list $(mdts_nodes))
mkdir -p $DIR/$tdir
local new_iused
for i in $(seq 120); do
- new_iused=$($LFS df -i | grep OST0000 | awk '{ print $3 }')
+ new_iused=$($LFS df -i | awk '/OST0000/ { print $3; exit; }')
# system may be too busy to destroy all objs in time, use
# a somewhat small value to not fail autotest
[ $((old_iused - new_iused)) -gt 400 ] && break
run_test 317 "Verify blocks get correctly update after truncate"
test_318() {
+ local llite_name="llite.$($LFS getname $MOUNT | awk '{print $1}')"
local old_max_active=$($LCTL get_param -n \
- llite.*.max_read_ahead_async_active 2>/dev/null)
+ ${llite_name}.max_read_ahead_async_active \
+ 2>/dev/null)
$LCTL set_param llite.*.max_read_ahead_async_active=256
local max_active=$($LCTL get_param -n \
- llite.*.max_read_ahead_async_active 2>/dev/null)
+ ${llite_name}.max_read_ahead_async_active \
+ 2>/dev/null)
[ $max_active -ne 256 ] && error "expected 256 but got $max_active"
$LCTL set_param llite.*.max_read_ahead_async_active=0 ||
$LCTL set_param llite.*.max_read_ahead_async_active=512
max_active=$($LCTL get_param -n \
- llite.*.max_read_ahead_async_active 2>/dev/null)
+ ${llite_name}.max_read_ahead_async_active 2>/dev/null)
[ $max_active -eq 512 ] || error "expected 512 but got $max_active"
# restore @max_active
llite.*.max_read_ahead_async_active=$old_max_active
local old_threshold=$($LCTL get_param -n \
- llite.*.read_ahead_async_file_threshold_mb 2>/dev/null)
+ ${llite_name}.read_ahead_async_file_threshold_mb 2>/dev/null)
local max_per_file_mb=$($LCTL get_param -n \
- llite.*.max_read_ahead_per_file_mb 2>/dev/null)
+ ${llite_name}.max_read_ahead_per_file_mb 2>/dev/null)
local invalid=$(($max_per_file_mb + 1))
$LCTL set_param \
llite.*.read_ahead_async_file_threshold_mb=$valid ||
error "set $valid should succeed"
local threshold=$($LCTL get_param -n \
- llite.*.read_ahead_async_file_threshold_mb 2>/dev/null)
+ ${llite_name}.read_ahead_async_file_threshold_mb 2>/dev/null)
[ $threshold -eq $valid ] || error \
"expect threshold $valid got $threshold"
$LCTL set_param \
error "Locks were requested while doing AIO"
# get the percentage of 1-page I/O
- pct=$($LCTL get_param osc.${FSNAME}-OST0000-osc-ffff*.rpc_stats |
+ pct=$($LCTL get_param osc.${imp_name}.rpc_stats |
grep -A 1 'pages per rpc' | grep -v 'pages per rpc' |
awk '{print $7}')
[ $pct -le 50 ] || error "$pct% of I/O are 1-page"
$LFS setstripe -c 1 -i 0 $DIR/$tfile
# get ost1 size - $FSNAME-OST0000
- local ost1_avail_size=$($LFS df | awk /${ost1_svc}/'{ print $4 }')
+ local ost1_avail_size=$($LFS df $DIR | 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
stack_trap "do_nodes $mdts $LCTL set_param \
lod.*.mdt_qos_maxage=$lod_qos_maxage > /dev/null" EXIT
- echo
- echo "Mkdir (stripe_count $stripe_count) roundrobin:"
-
$LCTL set_param lmv.*.qos_threshold_rr=100 > /dev/null
do_nodes $mdts $LCTL set_param lod.*.mdt_qos_threshold_rr=100 > /dev/null
testdir=$DIR/$tdir-s$stripe_count/rr
+ local stripe_index=$($LFS getstripe -m $testdir)
+ local test_mkdir_rr=true
+
+ getfattr -d -m dmv $testdir | grep dmv
+ if [ $? -eq 0 ] && [ $MDS1_VERSION -ge $(version_code 2.14.51) ]; then
+ local inherit_rr=$($LFS getdirstripe -D --max-inherit-rr $testdir)
+
+ (( $inherit_rr == 0 )) && test_mkdir_rr=false
+ fi
+
+ echo
+ $test_mkdir_rr &&
+ echo "Mkdir (stripe_count $stripe_count) roundrobin:" ||
+ echo "Mkdir (stripe_count $stripe_count) on stripe $stripe_index"
+
for i in $(seq $((100 * MDSCOUNT))); do
eval $mkdir_cmd $testdir/subdir$i ||
error "$mkdir_cmd subdir$i failed"
count=$($LFS getdirstripe -i $testdir/* |
grep ^$((i - 1))$ | wc -l)
echo "$count directories created on MDT$((i - 1))"
- [ $count -eq 100 ] || error "subdirs are not evenly distributed"
+ if $test_mkdir_rr; then
+ (( $count == 100 )) ||
+ error "subdirs are not evenly distributed"
+ elif [ $((i - 1)) -eq $stripe_index ]; then
+ (( $count == 100 * MDSCOUNT )) ||
+ error "$count subdirs created on MDT$((i - 1))"
+ else
+ (( $count == 0 )) ||
+ error "$count subdirs created on MDT$((i - 1))"
+ fi
- if [ $stripe_count -gt 1 ]; then
+ if $test_mkdir_rr && [ $stripe_count -gt 1 ]; then
count=$($LFS getdirstripe $testdir/* |
grep -P "^\s+$((i - 1))\t" | wc -l)
echo "$count stripes created on MDT$((i - 1))"
# deviation should < 5% of average
- [ $count -lt $((95 * stripe_count)) ] ||
- [ $count -gt $((105 * stripe_count)) ] &&
+ (( $count < 95 * stripe_count )) ||
+ (( $count > 105 * stripe_count)) &&
error "stripes are not evenly distributed"
fi
done
fi
done
- [ ${ffree[min_index]} -eq 0 ] &&
+ (( ${ffree[min_index]} == 0 )) &&
skip "no free files in MDT$min_index"
- [ ${ffree[min_index]} -gt 100000000 ] &&
- skip "too much free files in MDT$min_index"
+ (( ${ffree[min_index]} > 100000000 )) &&
+ skip "too many free files in MDT$min_index"
# Check if we need to generate uneven MDTs
local threshold=50
echo -n "weight diff=$diff% must be > $threshold% ..."
count=$((${ffree[min_index]} / 10))
# 50 sec per 10000 files in vm
- [ $count -gt 40000 ] && [ "$SLOW" = "no" ] &&
+ (( $count < 100000 )) || [ "$SLOW" != "no" ] ||
skip "$count files to create"
echo "Fill MDT$min_index with $count files"
[ -d $DIR/$tdir-MDT$min_index ] ||
$LFS mkdir -i $min_index $DIR/$tdir-MDT$min_index ||
error "mkdir $tdir-MDT$min_index failed"
- for i in $(seq $count); do
- $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE \
- $DIR/$tdir-MDT$min_index/f$j_$i > /dev/null ||
- error "create f$j_$i failed"
- setfattr -n user.413b -v $value \
- $DIR/$tdir-MDT$min_index/f$j_$i ||
- error "setfattr f$j_$i failed"
- done
+ createmany -d $DIR/$tdir-MDT$min_index/d $count ||
+ error "create d$count failed"
ffree=($(lctl get_param -n mdc.*[mM][dD][cC]-*.filesfree))
bavail=($(lctl get_param -n mdc.*[mM][dD][cC]-*.kbytesavail))
min=$($LFS getdirstripe -i $testdir/* | grep ^$min_index$ | wc -l)
# D-value should > 10% of averge
- [ $((max - min)) -lt 10 ] &&
+ (( $max - $min < 10 )) &&
error "subdirs shouldn't be evenly distributed"
# ditto
grep -P "^\s+$max_index\t" | wc -l)
min=$($LFS getdirstripe $testdir/* |
grep -P "^\s+$min_index\t" | wc -l)
- [ $((max - min)) -le $((10 * stripe_count)) ] &&
+ (( $max - $min < 10 * $stripe_count )) &&
error "stripes shouldn't be evenly distributed"|| true
fi
}
[ $MDS1_VERSION -lt $(version_code 2.12.52) ] &&
skip "Need server version at least 2.12.52"
+ local testdir
local stripe_count
for stripe_count in $(seq 1 $((MDSCOUNT - 1))); do
- mkdir $DIR/$tdir-s$stripe_count || error "mkdir failed"
- mkdir $DIR/$tdir-s$stripe_count/rr || error "mkdir failed"
- mkdir $DIR/$tdir-s$stripe_count/qos || error "mkdir failed"
- $LFS setdirstripe -D -c $stripe_count \
- $DIR/$tdir-s$stripe_count/rr ||
- error "setdirstripe failed"
- $LFS setdirstripe -D -c $stripe_count \
- $DIR/$tdir-s$stripe_count/qos ||
+ testdir=$DIR/$tdir-s$stripe_count
+ mkdir $testdir || error "mkdir $testdir failed"
+ mkdir $testdir/rr || error "mkdir rr failed"
+ mkdir $testdir/qos || error "mkdir qos failed"
+ $LFS setdirstripe -D -c $stripe_count --max-inherit-rr 2 \
+ $testdir/rr || error "setdirstripe rr failed"
+ $LFS setdirstripe -D -c $stripe_count $testdir/qos ||
error "setdirstripe failed"
test_qos_mkdir "mkdir" $stripe_count
done
}
run_test 413b "QoS mkdir under dir whose default LMV starting MDT offset is -1"
+test_413c() {
+ [ $MDSCOUNT -ge 2 ] ||
+ skip "We need at least 2 MDTs for this test"
+
+ [ $MDS1_VERSION -ge $(version_code 2.14.51) ] ||
+ skip "Need server version at least 2.14.50"
+
+ local testdir
+ local inherit
+ local inherit_rr
+
+ testdir=$DIR/${tdir}-s1
+ mkdir $testdir || error "mkdir $testdir failed"
+ mkdir $testdir/rr || error "mkdir rr failed"
+ mkdir $testdir/qos || error "mkdir qos failed"
+ # default max_inherit is -1, default max_inherit_rr is 0
+ $LFS setdirstripe -D -c 1 $testdir/rr ||
+ error "setdirstripe rr failed"
+ $LFS setdirstripe -D -c 1 -X 2 --max-inherit-rr 1 $testdir/qos ||
+ error "setdirstripe qos failed"
+ test_qos_mkdir "mkdir" 1
+
+ mkdir $testdir/rr/level1 || error "mkdir rr/level1 failed"
+ inherit=$($LFS getdirstripe -D -X $testdir/rr/level1)
+ (( $inherit == -1 )) || error "rr/level1 inherit $inherit != -1"
+ inherit_rr=$($LFS getdirstripe -D --max-inherit-rr $testdir/rr/level1)
+ (( $inherit_rr == 0 )) ||
+ error "rr/level1 inherit-rr $inherit_rr != 0"
+
+ mkdir $testdir/qos/level1 || error "mkdir qos/level1 failed"
+ inherit=$($LFS getdirstripe -D -X $testdir/qos/level1)
+ (( $inherit == 1 )) || error "qos/level1 inherit $inherit != 1"
+ inherit_rr=$($LFS getdirstripe -D --max-inherit-rr $testdir/qos/level1)
+ (( $inherit_rr == 0 )) ||
+ error "qos/level1 inherit-rr $inherit_rr !=0"
+ mkdir $testdir/qos/level1/level2 || error "mkdir level2 failed"
+ getfattr -d -m dmv $testdir/qos/level1/level2 | grep dmv &&
+ error "level2 shouldn't have default LMV" || true
+}
+run_test 413c "mkdir with default LMV max inherit rr"
+
test_414() {
#define OBD_FAIL_PTLRPC_BULK_ATTACH 0x521
$LCTL set_param fail_loc=0x80000521
cnt=$(ls -1 $DIR/$tdir | wc -l)
[ $cnt == 1 ] || error "unexpected #files after (5): $cnt"
- umount_client $MOUNT || error "failed to umount client"
- mount_client $MOUNT "$MOUNT_OPTS,user_fid2path" ||
+ tmpdir=$(mktemp -d /tmp/lustre-XXXXXX)
+ stack_trap "rmdir $tmpdir"
+ mount_client $tmpdir "$MOUNT_OPTS,user_fid2path" ||
error "failed to mount client'"
+ stack_trap "umount_client $tmpdir"
- $RUNAS $LFS rmfid $DIR $FID || error "rmfid failed"
+ $RUNAS $LFS rmfid $tmpdir $FID || error "rmfid failed"
# rmfid should succeed
- cnt=$(ls -1 $DIR/$tdir | wc -l)
+ cnt=$(ls -1 $tmpdir/$tdir | wc -l)
[ $cnt == 0 ] || error "unexpected #files after (6): $cnt"
# rmfid shouldn't allow to remove files due to dir's permission
- chmod a+rwx $DIR/$tdir
- touch $DIR/$tdir/f
- ls -la $DIR/$tdir
- FID=$(lfs path2fid $DIR/$tdir/f)
- $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail"
-
- umount_client $MOUNT || error "failed to umount client"
- mount_client $MOUNT "$MOUNT_OPTS" ||
- error "failed to mount client'"
-
+ chmod a+rwx $tmpdir/$tdir
+ touch $tmpdir/$tdir/f
+ ls -la $tmpdir/$tdir
+ FID=$(lfs path2fid $tmpdir/$tdir/f)
+ $RUNAS $LFS rmfid $tmpdir $FID && error "rmfid didn't fail"
+ return 0
}
run_test 421f "rmfid checks permissions"
}
run_test 427 "Failed DNE2 update request shouldn't corrupt updatelog"
+test_428() {
+ [ $PARALLEL == "yes" ] && skip "skip parallel run"
+ local cache_limit=$CACHE_MAX
+
+ stack_trap "$LCTL set_param -n llite.*.max_cached_mb=$cache_limit"
+ $LCTL set_param -n llite.*.max_cached_mb=64
+
+ mkdir $DIR/$tdir
+ $LFS setstripe -c 1 $DIR/$tdir
+ eval touch $DIR/$tdir/$tfile.{1..$OSTCOUNT}
+ stack_trap "rm -f $DIR/$tdir/$tfile.*"
+ #test write
+ for f in $(seq 4); do
+ dd if=/dev/zero of=$DIR/$tdir/$tfile.$f bs=128M count=1 &
+ done
+ wait
+
+ cancel_lru_locks osc
+ # Test read
+ for f in $(seq 4); do
+ dd if=$DIR/$tdir/$tfile.$f of=/dev/null bs=128M count=1 &
+ done
+ wait
+}
+run_test 428 "large block size IO should not hang"
+
+test_429() { # LU-7915 / LU-10948
+ local ll_opencache_threshold_count="llite.*.opencache_threshold_count"
+ local testfile=$DIR/$tfile
+ local mdc_rpcstats="mdc.$FSNAME-MDT0000-*.stats"
+ local new_flag=1
+ local first_rpc
+ local second_rpc
+ local third_rpc
+
+ $LCTL get_param $ll_opencache_threshold_count ||
+ skip "client does not have opencache parameter"
+
+ set_opencache $new_flag
+ stack_trap "restore_opencache"
+ [ $($LCTL get_param -n $ll_opencache_threshold_count) == $new_flag ] ||
+ error "enable opencache failed"
+ touch $testfile
+ # drop MDC DLM locks
+ cancel_lru_locks mdc
+ # clear MDC RPC stats counters
+ $LCTL set_param $mdc_rpcstats=clear
+
+ # According to the current implementation, we need to run 3 times
+ # open & close file to verify if opencache is enabled correctly.
+ # 1st, RPCs are sent for lookup/open and open handle is released on
+ # close finally.
+ # 2nd, RPC is sent for open, MDS_OPEN_LOCK is fetched automatically,
+ # so open handle won't be released thereafter.
+ # 3rd, No RPC is sent out.
+ $MULTIOP $testfile oc || error "multiop failed"
+ first_rpc=$(calc_stats $mdc_rpcstats ldlm_ibits_enqueue)
+ echo "1st: $first_rpc RPCs in flight"
+
+ $MULTIOP $testfile oc || error "multiop failed"
+ second_rpc=$(calc_stats $mdc_rpcstats ldlm_ibits_enqueue)
+ echo "2nd: $second_rpc RPCs in flight"
+
+ $MULTIOP $testfile oc || error "multiop failed"
+ third_rpc=$(calc_stats $mdc_rpcstats ldlm_ibits_enqueue)
+ echo "3rd: $third_rpc RPCs in flight"
+
+ #verify no MDC RPC is sent
+ [[ $second_rpc == $third_rpc ]] || error "MDC RPC is still sent"
+}
+run_test 429 "verify if opencache flag on client side does work"
+
lseek_test_430() {
local offset
local file=$1
check_lsom_data()
{
local file=$1
- local size=$($LFS getsom -s $file)
local expect=$(stat -c %s $file)
- [[ $size == $expect ]] ||
- error "$file expected size: $expect, got: $size"
+ check_lsom_size $1 $expect
local blocks=$($LFS getsom -b $file)
expect=$(stat -c %b $file)
check_lsom_size()
{
- local size=$($LFS getsom -s $1)
+ local size
local expect=$2
+ cancel_lru_locks mdc
+
+ size=$($LFS getsom -s $1)
[[ $size == $expect ]] ||
error "$file expected size: $expect, got: $size"
}
}
run_test 812b "do not drop no resend request for idle connect"
+test_812c() {
+ local old
+
+ old=$($LCTL get_param -n osc.*.idle_timeout | head -n 1)
+
+ $LFS setstripe -c 1 -o 0 $DIR/$tfile
+ $LFS getstripe $DIR/$tfile
+ $LCTL set_param osc.*.idle_timeout=10
+ stack_trap "$LCTL set_param osc.*.idle_timeout=$old" EXIT
+ # ensure ost1 is connected
+ stat $DIR/$tfile >/dev/null || error "can't stat"
+ wait_osc_import_state client ost1 FULL
+ # no locks, no reqs to let the connection idle
+ cancel_lru_locks osc
+
+#define OBD_FAIL_PTLRPC_IDLE_RACE 0x533
+ $LCTL set_param fail_loc=0x80000533
+ sleep 15
+ dd if=/dev/zero of=$DIR/$tfile count=1 conv=sync || error "dd failed"
+}
+run_test 812c "idle import vs lock enqueue race"
+
test_813() {
local file_heat_sav=$($LCTL get_param -n llite.*.file_heat 2>/dev/null)
[ -z "$file_heat_sav" ] && skip "no file heat support"
git://git.whamcloud.com / fs / lustre-release.git / blobdiff