X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Ftests%2Fsanity.sh;h=8a6313ddd2c7d6578d4a7896e60185dd852c42fa;hp=217cf579e07c4c1f9a80d106f04ea6afe33ffe4c;hb=2c89cc6c25549cb6748c7c9f5a209c7e38387eb4;hpb=689714eb511d39e225da64d8bfae42a4b2554626

diff --git a/lustre/tests/sanity.sh b/lustre/tests/sanity.sh
index 217cf57..8a6313d 100755
--- a/lustre/tests/sanity.sh
+++ b/lustre/tests/sanity.sh
@@ -41,13 +41,8 @@ init_logging
 ALWAYS_EXCEPT="$SANITY_EXCEPT "
 # bug number for skipped test: LU-9693 LU-6493 LU-9693
 ALWAYS_EXCEPT+="               42a     42b     42c "
-# bug number:    LU-8411 LU-9054 LU-13314
-ALWAYS_EXCEPT+=" 407     312     56ob"
-
-if $SHARED_KEY; then
-	# bug number:    LU-9795 LU-9795 LU-9795 LU-9795
-	ALWAYS_EXCEPT+=" 17n     60a     133g    300f"
-fi
+# bug number:    LU-8411 LU-9054
+ALWAYS_EXCEPT+=" 407     312"
 
 selinux_status=$(getenforce)
 if [ "$selinux_status" != "Disabled" ]; then
@@ -61,10 +56,12 @@ if [[ $(uname -m) = aarch64 ]]; then
 	ALWAYS_EXCEPT+=" $GRANT_CHECK_LIST"
 	# bug number:	 LU-11671 LU-11667
 	ALWAYS_EXCEPT+=" 45	  317"
+	# bug number:	 LU-14067 LU-14067
+	ALWAYS_EXCEPT+=" 400a	  400b"
 fi
 
-# skip nfs tests on kernels >= 4.14.0 until they are fixed
-if [ $LINUX_VERSION_CODE -ge $(version_code 4.14.0) ]; then
+# skip nfs tests on kernels >= 4.12.0 until they are fixed
+if [ $LINUX_VERSION_CODE -ge $(version_code 4.12.0) ]; then
 	# bug number:	LU-12661
 	ALWAYS_EXCEPT+=" 817"
 fi
@@ -1443,6 +1440,23 @@ test_24F () {
 }
 run_test 24F "hash order vs readdir (LU-11330)"
 
+test_24G () {
+	[ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
+
+	local ino1
+	local ino2
+
+	$LFS mkdir -i 0 $DIR/$tdir-0 || error "mkdir $tdir-0"
+	$LFS mkdir -i 1 $DIR/$tdir-1 || error "mkdir $tdir-1"
+	touch $DIR/$tdir-0/f1 || error "touch f1"
+	ln -s $DIR/$tdir-0/f1 $DIR/$tdir-0/s1 || error "ln s1"
+	ino1=$(stat -c%i $DIR/$tdir-0/s1)
+	mv $DIR/$tdir-0/s1 $DIR/$tdir-1 || error "mv s1"
+	ino2=$(stat -c%i $DIR/$tdir-1/s1)
+	[ $ino1 -ne $ino2 ] || error "s1 should be migrated"
+}
+run_test 24G "migrate symlink in rename"
+
 test_25a() {
 	echo '== symlink sanity ============================================='
 
@@ -3834,7 +3848,7 @@ test_33h() {
 	done
 
 	local failed=0
-	for i in {1..50}; do
+	for i in {1..250}; do
 		for fname in $(mktemp -u $DIR/$tdir/.$tfile.XXXXXX) \
 			     $(mktemp $DIR/$tdir/$tfile.XXXXXXXX); do
 			touch $fname  || error "touch $fname failed"
@@ -3846,7 +3860,7 @@ test_33h() {
 		done
 	done
 	echo "$failed MDT index mismatches"
-	(( failed < 4 )) || error "MDT index mismatch $failed times"
+	(( failed < 20 )) || error "MDT index mismatch $failed times"
 
 }
 run_test 33h "temp file is located on the same MDT as target"
@@ -4880,6 +4894,8 @@ test_43A() { # was test_43
 
 	$DIR/$tdir/$tfile && error "execute $DIR/$tdir/$tfile succeeded" || true
 	kill -USR1 $pid
+	# Wait for multiop to exit
+	wait $pid
 }
 run_test 43A "execution of file opened for write should return -ETXTBSY"
 
@@ -5129,6 +5145,27 @@ test_48e() { # bug 4134
 }
 run_test 48e "Access to recreated parent subdir (should return errors)"
 
+test_48f() {
+	[[ $MDS1_VERSION -ge $(version_code 2.13.55) ]] ||
+		skip "need MDS >= 2.13.55"
+	[[ $MDSCOUNT -ge 2 ]] || skip "needs >= 2 MDTs"
+	[[ "$(facet_host mds1)" != "$(facet_host mds2)" ]] ||
+		skip "needs different host for mdt1 mdt2"
+	[[ $(facet_fstype mds1) == ldiskfs ]] || skip "ldiskfs only"
+
+	$LFS mkdir -i0 $DIR/$tdir
+	$LFS mkdir -i 1 $DIR/$tdir/sub1 $DIR/$tdir/sub2 $DIR/$tdir/sub3
+
+	for d in sub1 sub2 sub3; do
+		#define OBD_FAIL_OSD_REF_DEL	0x19c
+		do_facet mds1 $LCTL set_param fail_loc=0x8000019c
+		rm -rf $DIR/$tdir/$d && error "rm $d should fail"
+	done
+
+	rm -d --interactive=never $DIR/$tdir || error "rm $tdir fail"
+}
+run_test 48f "non-zero nlink dir unlink won't LBUG()"
+
 test_49() { # LU-1030
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 	remote_ost_nodsh && skip "remote OST with nodsh"
@@ -5919,7 +5956,7 @@ test_56ob() {
 	cmd="$LFS find $dir -ctime +1s -type f"
 	nums=$($cmd | wc -l)
 	(( $nums == $count * 2 + 1)) ||
-		error "'$cmd' wrong: found $nums, expected $((expected*2+1))"
+		error "'$cmd' wrong: found $nums, expected $((count * 2 + 1))"
 }
 run_test 56ob "check lfs find -atime -mtime -ctime with units"
 
@@ -5940,6 +5977,8 @@ test_newerXY_base() {
 		ref=$DIR/$tfile.newer.$x$y
 		touch $ref || error "touch $ref failed"
 	fi
+
+	echo "before = $ref"
 	sleep 2
 	setup_56 $dir $NUMFILES $NUMDIRS "-i0 -c1" "-i0 -c1"
 	sleep 2
@@ -5954,28 +5993,28 @@ test_newerXY_base() {
 		touch $negref || error "touch $negref failed"
 	fi
 
+	echo "after = $negref"
 	local cmd="$LFS find $dir -newer$x$y $ref"
 	local nums=$(eval $cmd | wc -l)
 	local expected=$(((NUMFILES + 2) * NUMDIRS + 1))
 
-	[ $nums -eq $expected ] ||
-		error "'$cmd' wrong: found $nums, expected $expected"
+	[ $nums -eq $expected ] || { ls -lauR --full-time $dir ;
+		error "'$cmd' wrong: found $nums newer, expected $expected"  ; }
 
 	cmd="$LFS find $dir ! -newer$x$y $negref"
 	nums=$(eval $cmd | wc -l)
-	[ $nums -eq $expected ] ||
-		error "'$cmd' wrong: found $nums, expected $expected"
+	[ $nums -eq $expected ] || { ls -lauR --full-time $dir ;
+		error "'$cmd' wrong: found $nums older, expected $expected"  ; }
 
 	cmd="$LFS find $dir -newer$x$y $ref ! -newer$x$y $negref"
 	nums=$(eval $cmd | wc -l)
-	[ $nums -eq $expected ] ||
-		error "'$cmd' wrong: found $nums, expected $expected"
+	[ $nums -eq $expected ] || { ls -lauR --full-time $dir ;
+		error "'$cmd' wrong: found $nums between, expected $expected"; }
 
 	rm -rf $DIR/*
 }
 
 test_56oc() {
-	test_newerXY_base "b" "t"
 	test_newerXY_base "a" "a"
 	test_newerXY_base "a" "m"
 	test_newerXY_base "a" "c"
@@ -5985,10 +6024,19 @@ test_56oc() {
 	test_newerXY_base "c" "a"
 	test_newerXY_base "c" "m"
 	test_newerXY_base "c" "c"
-	test_newerXY_base "b" "b"
+
+	[[ -n "$sles_version" ]] &&
+		echo "skip timestamp tests on SLES, LU-13665" && return 0
+
 	test_newerXY_base "a" "t"
 	test_newerXY_base "m" "t"
 	test_newerXY_base "c" "t"
+
+	[[ $MDS1_VERSION -lt $(version_code 2.13.54) ||
+	   $CLIENT_VERSION -lt $(version_code 2.13.54) ]] &&
+		! btime_supported && echo "btime unsupported" && return 0
+
+	test_newerXY_base "b" "b"
 	test_newerXY_base "b" "t"
 }
 run_test 56oc "check lfs find -newerXY work"
@@ -6234,8 +6282,13 @@ test_56ra() {
 	[[ $MDS1_VERSION -gt $(version_code 2.12.58) ]] ||
 		skip "MDS < 2.12.58 doesn't return LSOM data"
 	local dir=$DIR/$tdir
+	local old_agl=$($LCTL get_param -n llite.*.statahead_agl)
 
-	[[ $OSC == "mdc" ]] && skip "DoM files" && return
+	[[ $OSC == "mdc" ]] && skip "statahead not needed for DoM files"
+
+	# statahead_agl may cause extra glimpse which confuses results. LU-13017
+	$LCTL set_param -n llite.*.statahead_agl=0
+	stack_trap "$LCTL set_param -n llite.*.statahead_agl=$old_agl"
 
 	setup_56 $dir $NUMFILES $NUMDIRS "-c 1"
 	# open and close all files to ensure LSOM is updated
@@ -7000,7 +7053,7 @@ test_56xc() {
 		error "cannot setstripe 20MB file"
 	echo "done"
 	echo -n "Sizing 20MB test file..."
-	truncate "$dir/20mb" 20971520 || error "cannot create 20MB test file"
+	$TRUNCATE "$dir/20mb" 20971520 || error "cannot create 20MB test file"
 	echo "done"
 	echo -n "Verifying small file autostripe count is 1..."
 	$LFS_MIGRATE -y -A -C 1 "$dir/20mb" ||
@@ -7020,7 +7073,7 @@ test_56xc() {
 	echo "done"
 	echo -n "Sizing 1GB test file..."
 	# File size is 1GB + 3KB
-	truncate "$dir/1gb" 1073744896 || error "cannot create 1GB test file"
+	$TRUNCATE "$dir/1gb" 1073744896 || error "cannot create 1GB test file"
 	echo "done"
 
 	# need at least 512MB per OST for 1GB file to fit in 2 stripes
@@ -7694,7 +7747,7 @@ test_60g() {
 
 		do_facet mds$index $LCTL set_param fail_loc=0x8000019a \
 			> /dev/null
-		usleep 100
+		sleep 0.01
 	done
 
 	kill -9 $pid
@@ -8607,41 +8660,78 @@ test_74c() {
 }
 run_test 74c "ldlm_lock_create error path, (shouldn't LBUG)"
 
-num_inodes() {
-	[ -f /sys/kernel/slab/lustre_inode_cache/shrink ] &&
-		echo 1 > /sys/kernel/slab/lustre_inode_cache/shrink
-	awk '/lustre_inode_cache/ {print $2; exit}' /proc/slabinfo
+slab_lic=/sys/kernel/slab/lustre_inode_cache
+num_objects() {
+	[ -f $slab_lic/shrink ] && echo 1 > $slab_lic/shrink
+	[ -f $slab_lic/objects ] && awk '{ print $1 }' $slab_lic/objects ||
+		awk '/lustre_inode_cache/ { print $2; exit }' /proc/slabinfo
 }
 
-test_76() { # Now for bug 20433, added originally in bug 1443
+test_76a() { # Now for b=20433, added originally in b=1443
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 
 	cancel_lru_locks osc
+	# there may be some slab objects cached per core
 	local cpus=$(getconf _NPROCESSORS_ONLN 2>/dev/null)
-	local before=$(num_inodes)
+	local before=$(num_objects)
 	local count=$((512 * cpus))
-	[ "$SLOW" = "no" ] && count=$((64 * cpus))
+	[ "$SLOW" = "no" ] && count=$((128 * cpus))
+	local margin=$((count / 10))
+	if [[ -f $slab_lic/aliases ]]; then
+		local aliases=$(cat $slab_lic/aliases)
+		(( aliases > 0 )) && margin=$((margin * aliases))
+	fi
 
-	echo "before inodes: $before"
+	echo "before slab objects: $before"
 	for i in $(seq $count); do
 		touch $DIR/$tfile
 		rm -f $DIR/$tfile
 	done
 	cancel_lru_locks osc
-	local after=$(num_inodes)
-	echo "after inodes: $after"
-	while (( after > before + 8 * ${cpus:-1} )); do
+	local after=$(num_objects)
+	echo "created: $count, after slab objects: $after"
+	# shared slab counts are not very accurate, allow significant margin
+	# the main goal is that the cache growth is not permanently > $count
+	while (( after > before + margin )); do
 		sleep 1
-		after=$(num_inodes)
+		after=$(num_objects)
 		wait=$((wait + 1))
-		(( wait % 5 == 0 )) && echo "wait $wait seconds inodes: $after"
-		if (( wait > 30 )); then
-			error "inode slab grew from $before to $after"
+		(( wait % 5 == 0 )) && echo "wait $wait seconds objects: $after"
+		if (( wait > 60 )); then
+			error "inode slab grew from $before+$margin to $after"
 		fi
 	done
 }
-run_test 76 "confirm clients recycle inodes properly ===="
+run_test 76a "confirm clients recycle inodes properly ===="
 
+test_76b() {
+	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+	[ $CLIENT_VERSION -ge $(version_code 2.13.55) ] || skip "not supported"
+
+	local count=512
+	local before=$(num_objects)
+
+	for i in $(seq $count); do
+		mkdir $DIR/$tdir
+		rmdir $DIR/$tdir
+	done
+
+	local after=$(num_objects)
+	local wait=0
+
+	while (( after > before )); do
+		sleep 1
+		after=$(num_objects)
+		wait=$((wait + 1))
+		(( wait % 5 == 0 )) && echo "wait $wait seconds objects: $after"
+		if (( wait > 60 )); then
+			error "inode slab grew from $before to $after"
+		fi
+	done
+
+	echo "slab objects before: $before, after: $after"
+}
+run_test 76b "confirm clients recycle directory inodes properly ===="
 
 export ORIG_CSUM=""
 set_checksums()
@@ -9519,12 +9609,11 @@ test_101g_brw_size_test() {
 		sed -n '/pages per rpc/,/^$/p' |
 		awk '/'$pages':/ { reads += $2; writes += $6 }; \
 		END { print reads,writes }'))
-	[ ${rpcs[0]} -ne $count ] && error "${rpcs[0]} != $count read RPCs" &&
-		return 5
-	[ ${rpcs[1]} -ne $count ] && error "${rpcs[1]} != $count write RPCs" &&
-		return 6
-
-	return 0
+	# allow one extra full-sized read RPC for async readahead
+	[[ ${rpcs[0]} == $count || ${rpcs[0]} == $((count + 1)) ]] ||
+		{ error "${rpcs[0]} != $count read RPCs"; return 5; }
+	[[ ${rpcs[1]} == $count ]] ||
+		{ error "${rpcs[1]} != $count write RPCs"; return 6; }
 }
 
 test_101g() {
@@ -11782,18 +11871,18 @@ test_124a() {
 		skip "Limit is too small $LIMIT"
 	fi
 
-        # Make LVF so higher that sleeping for $SLEEP is enough to _start_
-        # killing locks. Some time was spent for creating locks. This means
-        # that up to the moment of sleep finish we must have killed some of
-        # them (10-100 locks). This depends on how fast ther were created.
-        # Many of them were touched in almost the same moment and thus will
-        # be killed in groups.
-        local LVF=$(($MAX_HRS * 60 * 60 / $SLEEP * $LIMIT / $LRU_SIZE))
-
-        # Use $LRU_SIZE_B here to take into account real number of locks
-        # created in the case of CMD, LRU_SIZE_B != $NR in most of cases
-        local LRU_SIZE_B=$LRU_SIZE
-        log "LVF=$LVF"
+	# Make LVF so higher that sleeping for $SLEEP is enough to _start_
+	# killing locks. Some time was spent for creating locks. This means
+	# that up to the moment of sleep finish we must have killed some of
+	# them (10-100 locks). This depends on how fast ther were created.
+	# Many of them were touched in almost the same moment and thus will
+	# be killed in groups.
+	local LVF=$(($MAX_HRS * 60 * 60 / $SLEEP * $LIMIT / $LRU_SIZE * 100))
+
+	# Use $LRU_SIZE_B here to take into account real number of locks
+	# created in the case of CMD, LRU_SIZE_B != $NR in most of cases
+	local LRU_SIZE_B=$LRU_SIZE
+	log "LVF=$LVF"
 	local OLD_LVF=$($LCTL get_param -n $NSDIR.pool.lock_volume_factor)
 	log "OLD_LVF=$OLD_LVF"
 	$LCTL set_param -n $NSDIR.pool.lock_volume_factor $LVF
@@ -13344,6 +13433,51 @@ test_150d() {
 }
 run_test 150d "Verify fallocate Size and Blocks - Non zero start"
 
+test_150e() {
+	[ "$ost1_FSTYPE" != ldiskfs ] && skip "non-ldiskfs backend"
+	[ $OST1_VERSION -ge $(version_code 2.13.55) ] ||
+		skip "Need OST version at least 2.13.55"
+
+	echo "df before:"
+	$LFS df
+	$LFS setstripe -c${OSTCOUNT} $DIR/$tfile ||
+		error "$LFS setstripe -c${OSTCOUNT} $DIR/$tfile failed"
+
+	# Find OST with Minimum Size
+	min_size_ost=$($LFS df | awk "/$FSNAME-OST/ { print \$4 }" |
+		       sort -un | head -1)
+
+	# Get 90% of the available space
+	local space=$(((min_size_ost * 90)/100 * OSTCOUNT))
+
+	fallocate -l${space}k $DIR/$tfile ||
+		error "fallocate ${space}k $DIR/$tfile failed"
+	echo "'fallocate -l ${space}k $DIR/$tfile' succeeded"
+
+	# get size immediately after fallocate. This should be correctly
+	# updated
+	local size=$(stat -c '%s' $DIR/$tfile)
+	local used=$(( $(stat -c '%b * %B' $DIR/$tfile) / 1024))
+
+	# Sleep for a while for statfs to get updated. And not pull from cache.
+	sleep 2
+
+	echo "df after fallocate:"
+	$LFS df
+
+	(( size / 1024 == space )) || error "size $size != requested $space"
+	[ "$ost1_FSTYPE" != ldiskfs ] || (( used >= space )) ||
+		error "used $used < space $space"
+
+	rm $DIR/$tfile || error "rm failed"
+	sync
+	wait_delete_completed
+
+	echo "df after unlink:"
+	$LFS df
+}
+run_test 150e "Verify 90% of available OST space consumed by fallocate"
+
 #LU-2902 roc_hit was not able to read all values from lproc
 function roc_hit_init() {
 	local list=$(comma_list $(osts_nodes))
@@ -14981,6 +15115,71 @@ test_160k() {
 }
 run_test 160k "Verify that changelog records are not lost"
 
+# Verifies that a file passed as a parameter has recently had an operation
+# performed on it that has generated an MTIME changelog which contains the
+# correct parent FID. As files might reside on a different MDT from the
+# parent directory in DNE configurations, the FIDs are translated to paths
+# before being compared, which should be identical
+compare_mtime_changelog() {
+	local file="${1}"
+	local mdtidx
+	local mtime
+	local cl_fid
+	local pdir
+	local dir
+
+	mdtidx=$($LFS getstripe --mdt-index $file)
+	mdtidx=$(printf "%04x" $mdtidx)
+
+	# Obtain the parent FID from the MTIME changelog
+	mtime=$($LFS changelog $FSNAME-MDT$mdtidx | tail -n 1 | grep MTIME)
+	[ -z "$mtime" ] && error "MTIME changelog not recorded"
+
+	cl_fid=$(sed -e 's/.* p=//' -e 's/ .*//' <<<$mtime)
+	[ -z "$cl_fid" ] && error "parent FID not present"
+
+	# Verify that the path for the parent FID is the same as the path for
+	# the test directory
+	pdir=$($LFS fid2path $MOUNT "$cl_fid")
+
+	dir=$(dirname $1)
+
+	[[ "${pdir%/}" == "$dir" ]] ||
+		error "MTIME changelog parent FID is wrong, expected $dir, got $pdir"
+}
+
+test_160l() {
+	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+
+	remote_mds_nodsh && skip "remote MDS with nodsh"
+	[[ $MDS1_VERSION -ge $(version_code 2.13.55) ]] ||
+		skip "Need MDS version at least 2.13.55"
+
+	local cl_user
+
+	changelog_register || error "changelog_register failed"
+	cl_user="${CL_USERS[$SINGLEMDS]%% *}"
+
+	changelog_users $SINGLEMDS | grep -q $cl_user ||
+		error "User '$cl_user' not found in changelog_users"
+
+	# Clear some types so that MTIME changelogs are generated
+	changelog_chmask "-CREAT"
+	changelog_chmask "-CLOSE"
+
+	test_mkdir $DIR/$tdir || error "failed to mkdir $DIR/$tdir"
+
+	# Test CL_MTIME during setattr
+	touch $DIR/$tdir/$tfile
+	compare_mtime_changelog $DIR/$tdir/$tfile
+
+	# Test CL_MTIME during close
+	dd if=/dev/urandom of=$DIR/$tdir/${tfile}_2 bs=1M count=64 ||
+		error "cannot create file $DIR/$tdir/${tfile}_2"
+	compare_mtime_changelog $DIR/$tdir/${tfile}_2
+}
+run_test 160l "Verify that MTIME changelog records contain the parent FID"
+
 test_161a() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 
@@ -15352,6 +15551,9 @@ test_165a() {
 	local rc
 	local count
 
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
 	do_facet ost1 ofd_access_log_reader --debug=- --trace=- > "${trace}" &
 	setup_165
 	sleep 5
@@ -15385,10 +15587,14 @@ test_165b() {
 	local size
 	local flags
 
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
 	setup_165
 
 	lfs setstripe -c 1 -i 0 "${file}"
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c || error "cannot create '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
 	do_facet ost1 ofd_access_log_reader --list
 
 	do_facet ost1 ofd_access_log_reader --debug=- --trace=- > "${trace}" &
@@ -15427,7 +15633,8 @@ test_165b() {
 	fi
 
 	do_facet ost1 ofd_access_log_reader --debug=- --trace=- > "${trace}" &
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r524288c || error "cannot read '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r524288c ||
+		error "cannot read '${file}'"
 	sleep 5
 	do_facet ost1 killall -TERM ofd_access_log_reader
 	wait
@@ -15461,6 +15668,10 @@ run_test 165b "ofd access log entries are produced and consumed"
 
 test_165c() {
 	local file="${DIR}/${tdir}/${tfile}"
+
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
 	test_mkdir "${DIR}/${tdir}"
 
 	setup_165
@@ -15469,7 +15680,8 @@ test_165c() {
 
 	# 4096 / 64 = 64. Create twice as many entries.
 	for ((i = 0; i < 128; i++)); do
-		$MULTIOP "${file}-${i}" oO_CREAT:O_WRONLY:w512c || error "cannot create file"
+		$MULTIOP "${file}-${i}" oO_CREAT:O_WRONLY:w512c ||
+			error "cannot create file"
 	done
 
 	sync
@@ -15479,7 +15691,8 @@ test_165c() {
 run_test 165c "full ofd access logs do not block IOs"
 
 oal_peek_entry_count() {
-	do_facet ost1 ofd_access_log_reader --list | awk '$1 == "_entry_count:" { print $2; }'
+	do_facet ost1 ofd_access_log_reader --list |
+		awk '$1 == "_entry_count:" { print $2; }'
 }
 
 oal_expect_entry_count() {
@@ -15500,37 +15713,49 @@ test_165d() {
 	local file="${DIR}/${tdir}/${tfile}"
 	local param="obdfilter.${FSNAME}-OST0000.access_log_mask"
 	local entry_count
+
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
 	test_mkdir "${DIR}/${tdir}"
 
 	setup_165
 	lfs setstripe -c 1 -i 0 "${file}"
 
 	do_facet ost1 lctl set_param "${param}=rw"
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c || error "cannot create '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
 	oal_expect_entry_count 1
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
 	oal_expect_entry_count 2
 
 	do_facet ost1 lctl set_param "${param}=r"
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c || error "cannot create '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
 	oal_expect_entry_count 2
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
 	oal_expect_entry_count 3
 
 	do_facet ost1 lctl set_param "${param}=w"
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c || error "cannot create '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
 	oal_expect_entry_count 4
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
 	oal_expect_entry_count 4
 
 	do_facet ost1 lctl set_param "${param}=0"
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c || error "cannot create '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
 	oal_expect_entry_count 4
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
 	oal_expect_entry_count 4
 }
 run_test 165d "ofd_access_log mask works"
@@ -15538,11 +15763,13 @@ run_test 165d "ofd_access_log mask works"
 test_169() {
 	# do directio so as not to populate the page cache
 	log "creating a 10 Mb file"
-	$MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
+	$MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c ||
+		error "multiop failed while creating a file"
 	log "starting reads"
 	dd if=$DIR/$tfile of=/dev/null bs=4096 &
 	log "truncating the file"
-	$MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
+	$MULTIOP $DIR/$tfile oO_TRUNC:c ||
+		error "multiop failed while truncating the file"
 	log "killing dd"
 	kill %+ || true # reads might have finished
 	echo "wait until dd is finished"
@@ -15690,7 +15917,8 @@ obdecho_test() {
 test_180a() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 
-	if ! module_loaded obdecho; then
+	if ! [ -d /sys/fs/lustre/echo_client ] &&
+	   ! module_loaded obdecho; then
 		load_module obdecho/obdecho &&
 			stack_trap "rmmod obdecho" EXIT ||
 			error "unable to load obdecho on client"
@@ -15920,8 +16148,9 @@ test_184c() {
 	dd if=$ref1 of=$file1 bs=16k &
 	local DD_PID=$!
 
-	# Make sure dd starts to copy file
-	while [ ! -f $file1 ]; do sleep 0.1; done
+	# Make sure dd starts to copy file, but wait at most 5 seconds
+	local loops=0
+	while [ ! -s $file1 -a $((loops++)) -lt 50 ]; do sleep 0.1; done
 
 	$LFS swap_layouts $file1 $file2
 	local rc=$?
@@ -16469,11 +16698,25 @@ test_205a() { # Job stats
 			error "Unexpected jobids when jobid_var=$JOBENV"
 	fi
 
-	lctl set_param jobid_var=USER jobid_name="S.%j.%e.%u.%h.E"
-	JOBENV="JOBCOMPLEX"
-	JOBCOMPLEX="S.$USER.touch.$(id -u).$(hostname).E"
+	# test '%j' access to environment variable - if supported
+	if lctl set_param jobid_var=USER jobid_name="S.%j.%e.%u.%h.E"; then
+		JOBENV="JOBCOMPLEX"
+		JOBCOMPLEX="S.$USER.touch.$(id -u).$(hostname).E"
+
+		verify_jobstats "touch $DIR/$tfile" $SINGLEMDS
+	fi
+
+	# test '%j' access to per-session jobid - if supported
+	if lctl list_param jobid_this_session > /dev/null 2>&1
+	then
+		lctl set_param jobid_var=session jobid_name="S.%j.%e.%u.%h.E"
+		lctl set_param jobid_this_session=$USER
+
+		JOBENV="JOBCOMPLEX"
+		JOBCOMPLEX="S.$USER.touch.$(id -u).$(hostname).E"
 
-	verify_jobstats "touch $DIR/$tfile" $SINGLEMDS
+		verify_jobstats "touch $DIR/$tfile" $SINGLEMDS
+	fi
 }
 run_test 205a "Verify job stats"
 
@@ -16481,7 +16724,9 @@ run_test 205a "Verify job stats"
 test_205b() {
 	job_stats="mdt.*.job_stats"
 	$LCTL set_param $job_stats=clear
-	$LCTL set_param jobid_var=USER jobid_name="%e.%u"
+	# Setting jobid_var to USER might not be supported
+	$LCTL set_param jobid_var=USER || true
+	$LCTL set_param jobid_name="%e.%u"
 	env -i USERTESTJOBSTATS=foolish touch $DIR/$tfile.1
 	do_facet $SINGLEMDS $LCTL get_param $job_stats |
 		grep "job_id:.*foolish" &&
@@ -16492,6 +16737,17 @@ test_205b() {
 }
 run_test 205b "Verify job stats jobid and output format"
 
+# LU-13733
+test_205c() {
+	$LCTL set_param llite.*.stats=0
+	dd if=/dev/zero of=$DIR/$tfile.1 bs=4k count=1
+	$LCTL get_param llite.*.stats
+	$LCTL get_param llite.*.stats | grep \
+		"write_bytes *1 samples \[bytes\] 4096 4096 4096 16777216" ||
+			error "wrong client stats format found"
+}
+run_test 205c "Verify client stats format"
+
 # LU-1480, LU-1773 and LU-1657
 test_206() {
 	mkdir -p $DIR/$tdir
@@ -17203,6 +17459,34 @@ test_226b () {
 }
 run_test 226b "call path2fid and fid2path on files of all type under remote dir"
 
+test_226c () {
+	[ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
+	[[ $MDS1_VERSION -ge $(version_code 2.13.55) ]] ||
+		skip "Need MDS version at least 2.13.55"
+
+	local submnt=/mnt/submnt
+	local srcfile=/etc/passwd
+	local dstfile=$submnt/passwd
+	local path
+	local fid
+
+	rm -rf $DIR/$tdir
+	rm -rf $submnt
+	$LFS setdirstripe -c -1 -i 1 $DIR/$tdir ||
+		error "create remote directory failed"
+	mkdir -p $submnt || error "create $submnt failed"
+	$MOUNT_CMD $MGSNID:/$FSNAME/$tdir $submnt ||
+		error "mount $submnt failed"
+	stack_trap "umount $submnt" EXIT
+
+	cp $srcfile $dstfile
+	fid=$($LFS path2fid $dstfile)
+	path=$($LFS fid2path $submnt "$fid")
+	[ "$path" = "$dstfile" ] ||
+		error "fid2path $submnt $fid failed ($path != $dstfile)"
+}
+run_test 226c "call path2fid and fid2path under remote dir with subdir mount"
+
 # LU-1299 Executing or running ldd on a truncated executable does not
 # cause an out-of-memory condition.
 test_227() {
@@ -18160,6 +18444,9 @@ test_230q() {
 	local stripe_index
 	local nr_files
 
+	# test with fewer files on ZFS
+	[ "$mds1_FSTYPE" == "zfs" ] && threshold=40
+
 	stack_trap "do_nodes $mdts $LCTL set_param \
 		    mdt.*.dir_split_count=$saved_threshold"
 	stack_trap "do_nodes $mdts $LCTL set_param \
@@ -18203,6 +18490,41 @@ test_230q() {
 }
 run_test 230q "dir auto split"
 
+test_230r() {
+	[[ $PARALLEL != "yes" ]] || skip "skip parallel run"
+	[[ $MDSCOUNT -ge 2 ]] || skip_env "needs >= 2 MDTs"
+	[[ $MDS1_VERSION -ge $(version_code 2.13.54) ]] ||
+		skip "Need MDS version at least 2.13.54"
+
+	# maximum amount of local locks:
+	# parent striped dir - 2 locks
+	# new stripe in parent to migrate to - 1 lock
+	# source and target - 2 locks
+	# Total 5 locks for regular file
+	mkdir -p $DIR/$tdir
+	$LFS mkdir -i1 -c2 $DIR/$tdir/dir1
+	touch $DIR/$tdir/dir1/eee
+
+	# create 4 hardlink for 4 more locks
+	# Total: 9 locks > RS_MAX_LOCKS (8)
+	$LFS mkdir -i1 -c1 $DIR/$tdir/dir2
+	$LFS mkdir -i1 -c1 $DIR/$tdir/dir3
+	$LFS mkdir -i1 -c1 $DIR/$tdir/dir4
+	$LFS mkdir -i1 -c1 $DIR/$tdir/dir5
+	ln $DIR/$tdir/dir1/eee $DIR/$tdir/dir2/eee
+	ln $DIR/$tdir/dir1/eee $DIR/$tdir/dir3/eee
+	ln $DIR/$tdir/dir1/eee $DIR/$tdir/dir4/eee
+	ln $DIR/$tdir/dir1/eee $DIR/$tdir/dir5/eee
+
+	cancel_lru_locks mdc
+
+	$LFS migrate -m1 -c1 $DIR/$tdir/dir1 ||
+		error "migrate dir fails"
+
+	rm -rf $DIR/$tdir || error "rm dir failed after migration"
+}
+run_test 230r "migrate with too many local locks"
+
 test_231a()
 {
 	# For simplicity this test assumes that max_pages_per_rpc
@@ -19189,7 +19511,7 @@ ladvise_willread_performance()
 		return 0
 
 	lowest_speedup=$(bc <<<"scale=2; $average_cache / 2")
-	[ ${average_ladvise%.*} -gt $lowest_speedup ] ||
+	[[ ${average_ladvise%.*} > $lowest_speedup ]] ||
 		error_not_in_vm "Speedup with willread is less than " \
 			"$lowest_speedup%, got $average_ladvise%"
 }
@@ -21327,6 +21649,56 @@ test_300r() {
 }
 run_test 300r "test -1 striped directory"
 
+test_300s_helper() {
+	local count=$1
+
+	local stripe_dir=$DIR/$tdir/striped_dir.$count
+
+	$LFS mkdir -c $count $stripe_dir ||
+		error "lfs mkdir -c error"
+
+	$LFS getdirstripe $stripe_dir ||
+		error "lfs getdirstripe fails"
+
+	local stripe_count
+	stripe_count=$($LFS getdirstripe $stripe_dir |
+		      awk '/lmv_stripe_count:/ { print $2 }')
+
+	[ $count -ne $stripe_count ] &&
+		error_noexit "bad stripe count $stripe_count expected $count"
+
+	local dupe_stripes
+	dupe_stripes=$($LFS getdirstripe $stripe_dir |
+		awk '/0x/ {count[$1] += 1}; END {
+			for (idx in count) {
+				if (count[idx]>1) {
+					print "index " idx " count " count[idx]
+				}
+			}
+		}')
+
+	if [[ -n "$dupe_stripes" ]] ; then
+		lfs getdirstripe $stripe_dir
+		error_noexit "Dupe MDT above: $dupe_stripes "
+	fi
+
+	rm -rf $stripe_dir ||
+		error_noexit "unlink $stripe_dir fails"
+}
+
+test_300s() {
+	[ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
+		skip "Need MDS version at least 2.7.55" && return
+	[ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
+
+	mkdir $DIR/$tdir
+	for count in $(seq 2 $MDSCOUNT); do
+		test_300s_helper $count
+	done
+}
+run_test 300s "test lfs mkdir -c without -i"
+
+
 prepare_remote_file() {
 	mkdir $DIR/$tdir/src_dir ||
 		error "create remote source failed"
@@ -21876,6 +22248,11 @@ test_398d() { #  LU-13846
 	aiocp -a $PAGE_SIZE -b 64M -s 64M -f O_DIRECT $DIR/$tfile $aio_file
 
 	diff $DIR/$tfile $aio_file || "file diff after aiocp"
+
+	# make sure we don't crash and fail properly
+	aiocp -a 512 -b 64M -s 64M -f O_DIRECT $DIR/$tfile $aio_file &&
+		error "aio not aligned with PAGE SIZE should fail"
+
 	rm -rf $DIR/$tfile $aio_file
 }
 run_test 398d "run aiocp to verify block size > stripe size"
@@ -21902,7 +22279,7 @@ test_fake_rw() {
 	[ $blocks -gt 1000 ] && blocks=1000 # 1G in maximum
 
 	if [ "$read_write" = "read" ]; then
-		truncate -s $(expr 1048576 \* $blocks) $DIR/$tfile
+		$TRUNCATE $DIR/$tfile $(expr 1048576 \* $blocks)
 	fi
 
 	local start_time=$(date +%s.%N)
@@ -22044,70 +22421,92 @@ test_401a() { #LU-7437
 run_test 401a "Verify if 'lctl list_param -R' can list parameters recursively"
 
 test_401b() {
-	local save=$($LCTL get_param -n jobid_var)
-	local tmp=testing
+	# jobid_var may not allow arbitrary values, so use jobid_name
+	# if available
+	if $LCTL list_param jobid_name > /dev/null 2>&1; then
+		local testname=jobid_name tmp='testing%p'
+	else
+		local testname=jobid_var tmp=testing
+	fi
+
+	local save=$($LCTL get_param -n $testname)
 
-	$LCTL set_param foo=bar jobid_var=$tmp bar=baz &&
+	$LCTL set_param foo=bar $testname=$tmp bar=baz &&
 		error "no error returned when setting bad parameters"
 
-	local jobid_new=$($LCTL get_param -n foe jobid_var baz)
+	local jobid_new=$($LCTL get_param -n foe $testname baz)
 	[[ "$jobid_new" == "$tmp" ]] || error "jobid tmp $jobid_new != $tmp"
 
-	$LCTL set_param -n fog=bam jobid_var=$save bat=fog
-	local jobid_old=$($LCTL get_param -n foe jobid_var bag)
+	$LCTL set_param -n fog=bam $testname=$save bat=fog
+	local jobid_old=$($LCTL get_param -n foe $testname bag)
 	[[ "$jobid_old" == "$save" ]] || error "jobid new $jobid_old != $save"
 }
 run_test 401b "Verify 'lctl {get,set}_param' continue after error"
 
 test_401c() {
-	local jobid_var_old=$($LCTL get_param -n jobid_var)
+	# jobid_var may not allow arbitrary values, so use jobid_name
+	# if available
+	if $LCTL list_param jobid_name > /dev/null 2>&1; then
+		local testname=jobid_name
+	else
+		local testname=jobid_var
+	fi
+
+	local jobid_var_old=$($LCTL get_param -n $testname)
 	local jobid_var_new
 
-	$LCTL set_param jobid_var= &&
+	$LCTL set_param $testname= &&
 		error "no error returned for 'set_param a='"
 
-	jobid_var_new=$($LCTL get_param -n jobid_var)
+	jobid_var_new=$($LCTL get_param -n $testname)
 	[[ "$jobid_var_old" == "$jobid_var_new" ]] ||
-		error "jobid_var was changed by setting without value"
+		error "$testname was changed by setting without value"
 
-	$LCTL set_param jobid_var &&
+	$LCTL set_param $testname &&
 		error "no error returned for 'set_param a'"
 
-	jobid_var_new=$($LCTL get_param -n jobid_var)
+	jobid_var_new=$($LCTL get_param -n $testname)
 	[[ "$jobid_var_old" == "$jobid_var_new" ]] ||
-		error "jobid_var was changed by setting without value"
+		error "$testname was changed by setting without value"
 }
 run_test 401c "Verify 'lctl set_param' without value fails in either format."
 
 test_401d() {
-	local jobid_var_old=$($LCTL get_param -n jobid_var)
+	# jobid_var may not allow arbitrary values, so use jobid_name
+	# if available
+	if $LCTL list_param jobid_name > /dev/null 2>&1; then
+		local testname=jobid_name new_value='foo=bar%p'
+	else
+		local testname=jobid_var new_valuie=foo=bar
+	fi
+
+	local jobid_var_old=$($LCTL get_param -n $testname)
 	local jobid_var_new
-	local new_value="foo=bar"
 
-	$LCTL set_param jobid_var=$new_value ||
+	$LCTL set_param $testname=$new_value ||
 		error "'set_param a=b' did not accept a value containing '='"
 
-	jobid_var_new=$($LCTL get_param -n jobid_var)
+	jobid_var_new=$($LCTL get_param -n $testname)
 	[[ "$jobid_var_new" == "$new_value" ]] ||
 		error "'set_param a=b' failed on a value containing '='"
 
-	# Reset the jobid_var to test the other format
-	$LCTL set_param jobid_var=$jobid_var_old
-	jobid_var_new=$($LCTL get_param -n jobid_var)
+	# Reset the $testname to test the other format
+	$LCTL set_param $testname=$jobid_var_old
+	jobid_var_new=$($LCTL get_param -n $testname)
 	[[ "$jobid_var_new" == "$jobid_var_old" ]] ||
-		error "failed to reset jobid_var"
+		error "failed to reset $testname"
 
-	$LCTL set_param jobid_var $new_value ||
+	$LCTL set_param $testname $new_value ||
 		error "'set_param a b' did not accept a value containing '='"
 
-	jobid_var_new=$($LCTL get_param -n jobid_var)
+	jobid_var_new=$($LCTL get_param -n $testname)
 	[[ "$jobid_var_new" == "$new_value" ]] ||
 		error "'set_param a b' failed on a value containing '='"
 
-	$LCTL set_param jobid_var $jobid_var_old
-	jobid_var_new=$($LCTL get_param -n jobid_var)
+	$LCTL set_param $testname $jobid_var_old
+	jobid_var_new=$($LCTL get_param -n $testname)
 	[[ "$jobid_var_new" == "$jobid_var_old" ]] ||
-		error "failed to reset jobid_var"
+		error "failed to reset $testname"
 }
 run_test 401d "Verify 'lctl set_param' accepts values containing '='"
 
@@ -22345,6 +22744,8 @@ test_410()
 {
 	[[ $CLIENT_VERSION -lt $(version_code 2.9.59) ]] &&
 		skip "Need client version at least 2.9.59"
+	[ -f $LUSTRE/tests/kernel/kinode.ko ] ||
+		skip "Need MODULES build"
 
 	# Create a file, and stat it from the kernel
 	local testfile=$DIR/$tfile
@@ -23192,6 +23593,275 @@ test_424() {
 }
 run_test 424 "simulate ENOMEM in ptl_send_rpc bulk reply ME attach"
 
+test_425() {
+	test_mkdir -c -1 $DIR/$tdir
+	$LFS setstripe -c -1 $DIR/$tdir
+
+	lru_resize_disable "" 100
+	stack_trap "lru_resize_enable" EXIT
+
+	sleep 5
+
+	for i in $(seq $((MDSCOUNT * 125))); do
+		local t=$DIR/$tdir/$tfile_$i
+
+		dd if=/dev/zero of=$t bs=4K count=1 > /dev/null 2>&1 ||
+			error_noexit "Create file $t"
+	done
+	stack_trap "rm -rf $DIR/$tdir" EXIT
+
+	for oscparam in $($LCTL list_param ldlm.namespaces.*osc-[-0-9a-f]*); do
+		local lru_size=$($LCTL get_param -n $oscparam.lru_size)
+		local lock_count=$($LCTL get_param -n $oscparam.lock_count)
+
+		[ $lock_count -le $lru_size ] ||
+			error "osc lock count $lock_count > lru size $lru_size"
+	done
+
+	for mdcparam in $($LCTL list_param ldlm.namespaces.*mdc-*); do
+		local lru_size=$($LCTL get_param -n $mdcparam.lru_size)
+		local lock_count=$($LCTL get_param -n $mdcparam.lock_count)
+
+		[ $lock_count -le $lru_size ] ||
+			error "mdc lock count $lock_count > lru size $lru_size"
+	done
+}
+run_test 425 "lock count should not exceed lru size"
+
+test_426() {
+	splice-test -r $DIR/$tfile
+	splice-test -rd $DIR/$tfile
+	splice-test $DIR/$tfile
+	splice-test -d $DIR/$tfile
+}
+run_test 426 "splice test on Lustre"
+
+lseek_test_430() {
+	local offset
+	local file=$1
+
+	# data at [200K, 400K)
+	dd if=/dev/urandom of=$file bs=256K count=1 seek=1 ||
+		error "256K->512K dd fails"
+	# data at [2M, 3M)
+	dd if=/dev/urandom of=$file bs=1M count=1 seek=2 ||
+		error "2M->3M dd fails"
+	# data at [4M, 5M)
+	dd if=/dev/urandom of=$file bs=1M count=1 seek=4 ||
+		error "4M->5M dd fails"
+	echo "Data at 256K...512K, 2M...3M and 4M...5M"
+	# start at first component hole #1
+	printf "Seeking hole from 1000 ... "
+	offset=$(lseek_test -l 1000 $file)
+	echo $offset
+	[[ $offset == 1000 ]] || error "offset $offset != 1000"
+	printf "Seeking data from 1000 ... "
+	offset=$(lseek_test -d 1000 $file)
+	echo $offset
+	[[ $offset == 262144 ]] || error "offset $offset != 262144"
+
+	# start at first component data block
+	printf "Seeking hole from 300000 ... "
+	offset=$(lseek_test -l 300000 $file)
+	echo $offset
+	[[ $offset == 524288 ]] || error "offset $offset != 524288"
+	printf "Seeking data from 300000 ... "
+	offset=$(lseek_test -d 300000 $file)
+	echo $offset
+	[[ $offset == 300000 ]] || error "offset $offset != 300000"
+
+	# start at the first component but beyond end of object size
+	printf "Seeking hole from 1000000 ... "
+	offset=$(lseek_test -l 1000000 $file)
+	echo $offset
+	[[ $offset == 1000000 ]] || error "offset $offset != 1000000"
+	printf "Seeking data from 1000000 ... "
+	offset=$(lseek_test -d 1000000 $file)
+	echo $offset
+	[[ $offset == 2097152 ]] || error "offset $offset != 2097152"
+
+	# start at second component stripe 2 (empty file)
+	printf "Seeking hole from 1500000 ... "
+	offset=$(lseek_test -l 1500000 $file)
+	echo $offset
+	[[ $offset == 1500000 ]] || error "offset $offset != 1500000"
+	printf "Seeking data from 1500000 ... "
+	offset=$(lseek_test -d 1500000 $file)
+	echo $offset
+	[[ $offset == 2097152 ]] || error "offset $offset != 2097152"
+
+	# start at second component stripe 1 (all data)
+	printf "Seeking hole from 3000000 ... "
+	offset=$(lseek_test -l 3000000 $file)
+	echo $offset
+	[[ $offset == 3145728 ]] || error "offset $offset != 3145728"
+	printf "Seeking data from 3000000 ... "
+	offset=$(lseek_test -d 3000000 $file)
+	echo $offset
+	[[ $offset == 3000000 ]] || error "offset $offset != 3000000"
+
+	dd if=/dev/urandom of=$file bs=640K count=1 seek=1 ||
+		error "2nd dd fails"
+	echo "Add data block at 640K...1280K"
+
+	# start at before new data block, in hole
+	printf "Seeking hole from 600000 ... "
+	offset=$(lseek_test -l 600000 $file)
+	echo $offset
+	[[ $offset == 600000 ]] || error "offset $offset != 600000"
+	printf "Seeking data from 600000 ... "
+	offset=$(lseek_test -d 600000 $file)
+	echo $offset
+	[[ $offset == 655360 ]] || error "offset $offset != 655360"
+
+	# start at the first component new data block
+	printf "Seeking hole from 1000000 ... "
+	offset=$(lseek_test -l 1000000 $file)
+	echo $offset
+	[[ $offset == 1310720 ]] || error "offset $offset != 1310720"
+	printf "Seeking data from 1000000 ... "
+	offset=$(lseek_test -d 1000000 $file)
+	echo $offset
+	[[ $offset == 1000000 ]] || error "offset $offset != 1000000"
+
+	# start at second component stripe 2, new data
+	printf "Seeking hole from 1200000 ... "
+	offset=$(lseek_test -l 1200000 $file)
+	echo $offset
+	[[ $offset == 1310720 ]] || error "offset $offset != 1310720"
+	printf "Seeking data from 1200000 ... "
+	offset=$(lseek_test -d 1200000 $file)
+	echo $offset
+	[[ $offset == 1200000 ]] || error "offset $offset != 1200000"
+
+	# start beyond file end
+	printf "Using offset > filesize ... "
+	lseek_test -l 4000000 $file && error "lseek should fail"
+	printf "Using offset > filesize ... "
+	lseek_test -d 4000000 $file && error "lseek should fail"
+
+	printf "Done\n\n"
+}
+
+test_430a() {
+	$LCTL get_param mdc.*.import | grep -q 'connect_flags:.*seek' ||
+		skip "MDT does not support SEEK_HOLE"
+
+	$LCTL get_param osc.*.import | grep -q 'connect_flags:.*seek' ||
+		skip "OST does not support SEEK_HOLE"
+
+	local file=$DIR/$tdir/$tfile
+
+	mkdir -p $DIR/$tdir
+
+	$LFS setstripe -E 1M -L mdt -E eof -c2 $file
+	# OST stripe #1 will have continuous data at [1M, 3M)
+	# OST stripe #2 is empty
+	echo "Component #1: 1M DoM, component #2: EOF, 2 stripes 1M"
+	lseek_test_430 $file
+	rm $file
+	$LFS setstripe -E 1M -c2 -S 64K -E 10M -c2 -S 1M $file
+	echo "Component #1: 1M, 2 stripes 64K, component #2: EOF, 2 stripes 1M"
+	lseek_test_430 $file
+	rm $file
+	$LFS setstripe -c2 -S 512K $file
+	echo "Two stripes, stripe size 512K"
+	lseek_test_430 $file
+	rm $file
+	# FLR with stale mirror
+	$LFS setstripe -N -E 512K -c1 -S 64K -E eof -c2 -S 512K \
+		       -N -c2 -S 1M $file
+	echo "Mirrored file:"
+	echo "Component #1: 512K, stripe 64K, component #2: EOF, 2 stripes 512K"
+	echo "Plain 2 stripes 1M"
+	lseek_test_430 $file
+	rm $file
+}
+run_test 430a "lseek: SEEK_DATA/SEEK_HOLE basic functionality"
+
+test_430b() {
+	$LCTL get_param osc.*.import | grep -q 'connect_flags:.*seek' ||
+		skip "OST does not support SEEK_HOLE"
+
+	local offset
+	local file=$DIR/$tdir/$tfile
+
+	mkdir -p $DIR/$tdir
+	# Empty layout lseek should fail
+	$MCREATE $file
+	# seek from 0
+	printf "Seeking hole from 0 ... "
+	lseek_test -l 0 $file && error "lseek should fail"
+	printf "Seeking data from 0 ... "
+	lseek_test -d 0 $file && error "lseek should fail"
+	rm $file
+
+	# 1M-hole file
+	$LFS setstripe -E 1M -c2 -E eof $file
+	$TRUNCATE $file 1048576
+	printf "Seeking hole from 1000000 ... "
+	offset=$(lseek_test -l 1000000 $file)
+	echo $offset
+	[[ $offset == 1000000 ]] || error "offset $offset != 1000000"
+	printf "Seeking data from 1000000 ... "
+	lseek_test -d 1000000 $file && error "lseek should fail"
+	# full first component, non-inited second one
+	dd if=/dev/urandom of=$file bs=1M count=1
+	printf "Seeking hole from 1000000 ... "
+	offset=$(lseek_test -l 1000000 $file)
+	echo $offset
+	[[ $offset == 1048576 ]] || error "offset $offset != 1048576"
+	printf "Seeking hole from 1048576 ... "
+	lseek_test -l 1048576 $file && error "lseek should fail"
+	# init second component and truncate back
+	echo "123" >> $file
+	$TRUNCATE $file 1048576
+	ls -lia $file
+	printf "Seeking hole from 1000000 ... "
+	offset=$(lseek_test -l 1000000 $file)
+	echo $offset
+	[[ $offset == 1048576 ]] || error "offset $offset != 1048576"
+	printf "Seeking hole from 1048576 ... "
+	lseek_test -l 1048576 $file && error "lseek should fail"
+	# boundary checks for big values
+	dd if=/dev/urandom of=$file.10g bs=1 count=1 seek=10G
+	offset=$(lseek_test -d 0 $file.10g)
+	[[ $offset == 10737418240 ]] || error "offset $offset != 10737418240"
+	dd if=/dev/urandom of=$file.100g bs=1 count=1 seek=100G
+	offset=$(lseek_test -d 0 $file.100g)
+	[[ $offset == 107374182400 ]] || error "offset $offset != 107374182400"
+	return 0
+}
+run_test 430b "lseek: SEEK_DATA/SEEK_HOLE special cases"
+
+test_430c() {
+	$LCTL get_param osc.*.import | grep -q 'connect_flags:.*seek' ||
+		skip "OST does not support SEEK_HOLE"
+
+	local file=$DIR/$tdir/$tfile
+	local start
+
+	mkdir -p $DIR/$tdir
+	dd if=/dev/urandom of=$file bs=1k count=1 seek=5M
+
+	# cp version 8.33+ prefers lseek over fiemap
+	if [[ $(cp --version | head -n1 | sed "s/[^0-9]//g") -ge 833 ]]; then
+		start=$SECONDS
+		time cp $file /dev/null
+		(( SECONDS - start < 5 )) ||
+			error "cp: too long runtime $((SECONDS - start))"
+
+	fi
+	# tar version 1.29+ supports SEEK_HOLE/DATA
+	if [[ $(tar --version | head -n1 | sed "s/[^0-9]//g") -ge 129 ]]; then
+		start=$SECONDS
+		time tar cS $file - | cat > /dev/null
+		(( SECONDS - start < 5 )) ||
+			error "tar: too long runtime $((SECONDS - start))"
+	fi
+}
+run_test 430c "lseek: external tools check"
+
 prep_801() {
 	[[ $MDS1_VERSION -lt $(version_code 2.9.55) ]] ||
 	[[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
@@ -23500,7 +24170,7 @@ test_802b() {
 }
 run_test 802b "be able to set MDTs to readonly"
 
-test_803() {
+test_803a() {
 	[[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
 	[ $MDS1_VERSION -lt $(version_code 2.10.54) ] &&
 		skip "MDS needs to be newer than 2.10.54"
@@ -23548,7 +24218,39 @@ test_803() {
 	[ $after_used -le $((before_used + 1)) ] ||
 		error "after ($after_used) > before ($before_used) + 1"
 }
-run_test 803 "verify agent object for remote object"
+run_test 803a "verify agent object for remote object"
+
+test_803b() {
+	[[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
+	[ $MDS1_VERSION -lt $(version_code 2.13.56) ] &&
+		skip "MDS needs to be newer than 2.13.56"
+	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+
+	for i in $(seq 0 $((MDSCOUNT - 1))); do
+		$LFS mkdir -i $i $DIR/$tdir.$i || error "mkdir $tdir.$i"
+	done
+
+	local before=0
+	local after=0
+
+	local tmp
+
+	stat $DIR/$tdir.* >/dev/null || error "stat $tdir.*"
+	for i in $(seq 0 $((MDSCOUNT - 1))); do
+		tmp=$(do_facet mds$i $LCTL get_param mdt.*-MDT000$i.md_stats |
+			awk '/getattr/ { print $2 }')
+		before=$((before + tmp))
+	done
+	stat $DIR/$tdir.* >/dev/null || error "stat $tdir.*"
+	for i in $(seq 0 $((MDSCOUNT - 1))); do
+		tmp=$(do_facet mds$i $LCTL get_param mdt.*-MDT000$i.md_stats |
+			awk '/getattr/ { print $2 }')
+		after=$((after + tmp))
+	done
+
+	[ $before -eq $after ] || error "getattr count $before != $after"
+}
+run_test 803b "remote object can getattr from cache"
 
 test_804() {
 	[[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
@@ -23947,8 +24649,6 @@ run_test 810 "partial page writes on ZFS (LU-11663)"
 test_812a() {
 	[ $OST1_VERSION -lt $(version_code 2.12.51) ] &&
 		skip "OST < 2.12.51 doesn't support this fail_loc"
-	[ "$SHARED_KEY" = true ] &&
-		skip "OSC connections never go IDLE with Shared-Keys enabled"
 
 	$LFS setstripe -c 1 -i 0 $DIR/$tfile
 	# ensure ost1 is connected
@@ -23970,8 +24670,6 @@ run_test 812a "do not drop reqs generated when imp is going to idle (LU-11951)"
 test_812b() { # LU-12378
 	[ $OST1_VERSION -lt $(version_code 2.12.51) ] &&
 		skip "OST < 2.12.51 doesn't support this fail_loc"
-	[ "$SHARED_KEY" = true ] &&
-		skip "OSC connections never go IDLE with Shared-Keys enabled"
 
 	$LFS setstripe -c 1 -i 0 $DIR/$tfile || error "setstripe failed"
 	# ensure ost1 is connected
@@ -24179,9 +24877,6 @@ test_815()
 run_test 815 "zero byte tiny write doesn't hang (LU-12382)"
 
 test_816() {
-	[ "$SHARED_KEY" = true ] &&
-		skip "OSC connections never go IDLE with Shared-Keys enabled"
-
 	$LFS setstripe -c 1 -i 0 $DIR/$tfile
 	# ensure ost1 is connected
 	stat $DIR/$tfile >/dev/null || error "can't stat"