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"
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
- rm -f $TMP/$tfile* 2> /dev/null
# 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
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
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 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 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_231a()
{
# For simplicity this test assumes that max_pages_per_rpc