X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Ftests%2Fsanity.sh;h=82d0f76e12de129bad2530928718461e74b23649;hp=34c8753c53e998851ce0e86915e39c67a6a05992;hb=f7392c7c4a16bc1127ee448f937ba81c50dcdfd5;hpb=94441071dbadbde56442e5e2560c642cc2793274

diff --git a/lustre/tests/sanity.sh b/lustre/tests/sanity.sh
index 34c8753..82d0f76 100755
--- a/lustre/tests/sanity.sh
+++ b/lustre/tests/sanity.sh
@@ -41,12 +41,12 @@ 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"
+# bug number:    LU-8411 LU-9054
+ALWAYS_EXCEPT+=" 407     312"
 
 if $SHARED_KEY; then
-	# bug number:    LU-9795 LU-9795 LU-9795 LU-9795
-	ALWAYS_EXCEPT+=" 17n     60a     133g    300f"
+	# bug number:    LU-14181 LU-14181
+	ALWAYS_EXCEPT+=" 64e      64f"
 fi
 
 selinux_status=$(getenforce)
@@ -61,10 +61,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
@@ -80,11 +82,16 @@ fi
 
 if [ "$mds1_FSTYPE" = "zfs" ]; then
 	# bug number for skipped test:
-	ALWAYS_EXCEPT="$ALWAYS_EXCEPT  "
+	ALWAYS_EXCEPT+="              "
 	#                                               13    (min)"
 	[ "$SLOW" = "no" ] && EXCEPT_SLOW="$EXCEPT_SLOW 51b"
 fi
 
+if [ "$ost1_FSTYPE" = "zfs" ]; then
+	# bug number for skipped test:	LU-1941  LU-1941  LU-1941  LU-1941
+	ALWAYS_EXCEPT+="                130a 130b 130c 130d 130e 130f 130g"
+fi
+
 # Get the SLES distro version
 #
 # Returns a version string that should only be used in comparing
@@ -144,6 +151,13 @@ check_swap_layouts_support()
 		skip "Does not support layout lock."
 }
 
+check_swap_layout_no_dom()
+{
+	local FOLDER=$1
+	local SUPP=$(lfs getstripe $FOLDER | grep "pattern:       mdt" | wc -l)
+	[ $SUPP -eq 0 ] || skip "layout swap does not support DOM files so far"
+}
+
 check_and_setup_lustre
 DIR=${DIR:-$MOUNT}
 assert_DIR
@@ -227,12 +241,13 @@ test_0d() { # LU-3397
 	[ "$exp_val" == "$imp_val" ] ||
 		error "export flags '$exp_val' != import flags '$imp_val'"
 
-	# Compare the value of client version
+	# Compare client versions.  Only compare top-3 fields for compatibility
 	exp_client_version=$(awk '/target_version:/ { print $2 }' $temp_exp)
-	exp_val=$(version_code $exp_client_version)
-	imp_val=$CLIENT_VERSION
+	exp_val=$(version_code $(cut -d. -f1,2,3 <<<$exp_client_version))
+	imp_val=$(version_code $(lustre_build_version client | cut -d. -f1,2,3))
 	[ "$exp_val" == "$imp_val" ] ||
-		error "export client version '$exp_val' != '$imp_val'"
+		error "exp version '$exp_client_version'($exp_val) != " \
+			"'$(lustre_build_version client)'($imp_val)"
 }
 run_test 0d "check export proc ============================="
 
@@ -1436,6 +1451,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 ============================================='
 
@@ -1609,7 +1641,7 @@ test_27ce() {
 	[[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
 		skip "server does not support overstriping"
 	# We do one more stripe than we have OSTs
-	[ $OSTCOUNT -ge 159 ] || large_xattr_enabled ||
+	[ $OSTCOUNT -lt 159 ] || large_xattr_enabled ||
 		skip_env "ea_inode feature disabled"
 
 	test_mkdir -p $DIR/$tdir
@@ -1876,6 +1908,57 @@ test_27o() {
 }
 run_test 27o "create file with all full OSTs (should error)"
 
+function create_and_checktime() {
+	local fname=$1
+	local loops=$2
+	local i
+
+	for ((i=0; i < $loops; i++)); do
+		local start=$SECONDS
+		multiop $fname-$i Oc
+		((SECONDS-start < TIMEOUT)) ||
+			error "creation took " $((SECONDS-$start)) && return 1
+	done
+}
+
+test_27oo() {
+	local mdts=$(comma_list $(mdts_nodes))
+
+	[ $MDS1_VERSION -lt $(version_code 2.13.57) ] &&
+		skip "Need MDS version at least 2.13.57"
+
+	local f0=$DIR/${tfile}-0
+	local f1=$DIR/${tfile}-1
+
+	wait_delete_completed
+
+	# refill precreated objects
+	$LFS setstripe -i0 -c1 $f0
+
+	saved=$(do_facet mds1 $LCTL get_param -n lov.*0000*.qos_threshold_rr)
+	# force QoS allocation policy
+	do_nodes $mdts $LCTL set_param lov.*.qos_threshold_rr=0%
+	stack_trap "do_nodes $mdts $LCTL set_param \
+		lov.*.qos_threshold_rr=$saved" EXIT
+	sleep_maxage
+
+	# one OST is unavailable, but still have few objects preallocated
+	stop ost1
+	stack_trap "start ost1 $(ostdevname 1) $OST_MOUNT_OPTS; \
+		rm -rf $f1 $DIR/$tdir*" EXIT
+
+	for ((i=0; i < 7; i++)); do
+		mkdir $DIR/$tdir$i || error "can't create dir"
+		$LFS setstripe -c$((OSTCOUNT-1)) $DIR/$tdir$i ||
+			error "can't set striping"
+	done
+	for ((i=0; i < 7; i++)); do
+		create_and_checktime $DIR/$tdir$i/$tfile 100 &
+	done
+	wait
+}
+run_test 27oo "don't let few threads to reserve too many objects"
+
 test_27p() {
 	[[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
@@ -2365,7 +2448,7 @@ test_27Cb() {
 
 	test_mkdir -p $DIR/$tdir
 	local setcount=$(($OSTCOUNT * 2))
-	[ $setcount -ge 160 ] || large_xattr_enabled ||
+	[ $setcount -lt 160 ] || large_xattr_enabled ||
 		skip_env "ea_inode feature disabled"
 
 	$LFS setstripe -C $setcount $DIR/$tdir/$tfile ||
@@ -2391,7 +2474,7 @@ test_27Cc() {
 	test_mkdir -p $DIR/$tdir
 	local setcount=$(($OSTCOUNT - 1))
 
-	[ $setcount -ge 160 ] || large_xattr_enabled ||
+	[ $setcount -lt 160 ] || large_xattr_enabled ||
 		skip_env "ea_inode feature disabled"
 
 	$LFS setstripe -C $setcount $DIR/$tdir/$tfile ||
@@ -2471,7 +2554,7 @@ test_27Cf() {
 	test_mkdir -p $DIR/$tdir
 
 	local setcount=$(($OSTCOUNT * 2))
-	[ $setcount -ge 160 ] || large_xattr_enabled ||
+	[ $setcount -lt 160 ] || large_xattr_enabled ||
 		skip_env "ea_inode feature disabled"
 
 	$LFS setstripe  -C $setcount $DIR/$tdir/ ||
@@ -2689,6 +2772,17 @@ test_27J() {
 	local uuid2=$(cat /proc/sys/kernel/random/uuid)
 
 	# create foreign file (raw way)
+	! $LFS setstripe --flags 0xda08 $DIR/$tdir/$tfile ||
+		error "creating $tfile w/ hex flags w/o --foreign should fail"
+
+	! $LFS setstripe --foreign --flags foo \
+		--xattr ${uuid1}@${uuid2} $DIR/$tdir/$tfile ||
+			error "creating $tfile with '--flags foo' should fail"
+
+	! $LFS setstripe --foreign --flags 0xffffffff \
+		--xattr ${uuid1}@${uuid2} $DIR/$tdir/$tfile ||
+			error "creating $tfile w/ 0xffffffff flags should fail"
+
 	create_foreign_file -f $DIR/$tdir/$tfile -x "${uuid1}@${uuid2}" \
 		-t 1 -F 0xda08 || error "create_foreign_file failed"
 
@@ -2715,7 +2809,7 @@ test_27J() {
 		error "$DIR/$tdir/$tfile: invalid LOV EA foreign value"
 
 	# create foreign file (lfs + API)
-	$LFS setstripe --foreign=daos --flags 0xda08 \
+	$LFS setstripe --foreign=none --flags 0xda08 \
 		-x "${uuid1}@${uuid2}" $DIR/$tdir/${tfile}2 ||
 		error "$DIR/$tdir/${tfile}2: create failed"
 
@@ -2725,7 +2819,7 @@ test_27J() {
 	# lfm_length is LOV EA size - sizeof(lfm_magic) - sizeof(lfm_length)
 	$LFS getstripe -v $DIR/$tdir/${tfile}2 | grep "lfm_length:.*73" ||
 		error "$DIR/$tdir/${tfile}2: invalid LOV EA foreign size"
-	$LFS getstripe -v $DIR/$tdir/${tfile}2 | grep "lfm_type:.*daos" ||
+	$LFS getstripe -v $DIR/$tdir/${tfile}2 | grep "lfm_type:.*none" ||
 		error "$DIR/$tdir/${tfile}2: invalid LOV EA foreign type"
 	$LFS getstripe -v $DIR/$tdir/${tfile}2 |
 		grep "lfm_flags:.*0x0000DA08" ||
@@ -2784,6 +2878,17 @@ test_27K() {
 	local uuid2=$(cat /proc/sys/kernel/random/uuid)
 
 	# create foreign dir (raw way)
+	! $LFS setdirstripe --flags 0xda08 $DIR/$tdir/$tdir ||
+		error "creating $tdir w/ hex flags w/o --foreign should fail"
+
+	! $LFS setdirstripe --foreign --flags foo \
+		--xattr ${uuid1}@${uuid2} $DIR/$tdir/$tdir ||
+			error "creating $tdir with '--flags foo' should fail"
+
+	! $LFS setdirstripe --foreign --flags 0xffffffff \
+		--xattr ${uuid1}@${uuid2} $DIR/$tdir/$tdir ||
+			error "creating $tdir w/ 0xffffffff flags should fail"
+
 	create_foreign_dir -d $DIR/$tdir/$tdir -x "${uuid1}@${uuid2}" -t 1 ||
 		error "create_foreign_dir FAILED"
 
@@ -2795,7 +2900,8 @@ test_27K() {
 		error "$DIR/$tdir/$tdir: invalid LMV EA size"
 	parse_foreign_dir -d $DIR/$tdir/$tdir | grep "lmv_foreign_type: 1$" ||
 		error "$DIR/$tdir/$tdir: invalid LMV EA type"
-	parse_foreign_dir -d $DIR/$tdir/$tdir | grep "lmv_foreign_flags: 0$" ||
+	parse_foreign_dir -d $DIR/$tdir/$tdir |
+		grep "lmv_foreign_flags: 55813$" ||
 		error "$DIR/$tdir/$tdir: invalid LMV EA flags"
 	local lmv=$(parse_foreign_dir -d $DIR/$tdir/$tdir |
 		grep "lmv_foreign_value: 0x" |
@@ -2805,7 +2911,7 @@ test_27K() {
 	[[ $lmv == $lmv2 ]] || error "$DIR/$tdir/$tdir: invalid LMV EA value"
 
 	# create foreign dir (lfs + API)
-	$LFS mkdir --foreign=daos --xattr="${uuid1}@${uuid2}" --flags=0xda05 \
+	$LFS mkdir --foreign=none --xattr="${uuid1}@${uuid2}" --flags=0xda05 \
 		$DIR/$tdir/${tdir}2 ||
 		error "$DIR/$tdir/${tdir}2: create failed"
 
@@ -2816,7 +2922,7 @@ test_27K() {
 	# - sizeof(lfm_type) - sizeof(lfm_flags)
 	$LFS getdirstripe -v $DIR/$tdir/${tdir}2 | grep "lfm_length:.*73" ||
 		error "$DIR/$tdir/${tdir}2: invalid LMV EA size"
-	$LFS getdirstripe -v $DIR/$tdir/${tdir}2 | grep "lfm_type:.*daos" ||
+	$LFS getdirstripe -v $DIR/$tdir/${tdir}2 | grep "lfm_type:.*none" ||
 		error "$DIR/$tdir/${tdir}2: invalid LMV EA type"
 	$LFS getdirstripe -v $DIR/$tdir/${tdir}2 |
 		grep "lfm_flags:.*0x0000DA05" ||
@@ -3015,6 +3121,204 @@ test_27N() {
 }
 run_test 27N "lctl pool_list on separate MGS gives correct pool name"
 
+clean_foreign_symlink() {
+	trap 0
+	lctl set_param llite/$FSNAME-*/foreign_symlink_enable=0
+	for i in $DIR/$tdir/* ; do
+		$LFS unlink_foreign $i || true
+	done
+}
+
+test_27O() {
+	[[ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.12.51) ]] &&
+		skip "Need MDS version newer than 2.12.51"
+
+	test_mkdir $DIR/$tdir
+	local uuid1=$(cat /proc/sys/kernel/random/uuid)
+	local uuid2=$(cat /proc/sys/kernel/random/uuid)
+
+	trap clean_foreign_symlink EXIT
+
+	# enable foreign_symlink behaviour
+	$LCTL set_param llite/$FSNAME-*/foreign_symlink_enable=1
+
+	# foreign symlink LOV format is a partial path by default
+
+	# create foreign file (lfs + API)
+	$LFS setstripe --foreign=symlink --flags 0xda05 \
+		-x "${uuid1}/${uuid2}" --mode 0600 $DIR/$tdir/${tfile} ||
+		error "$DIR/$tdir/${tfile}: create failed"
+
+	$LFS getstripe -v $DIR/$tdir/${tfile} |
+		grep "lfm_magic:.*0x0BD70BD0" ||
+		error "$DIR/$tdir/${tfile}: invalid LOV EA foreign magic"
+	$LFS getstripe -v $DIR/$tdir/${tfile} | grep "lfm_type:.*symlink" ||
+		error "$DIR/$tdir/${tfile}: invalid LOV EA foreign type"
+	$LFS getstripe -v $DIR/$tdir/${tfile} |
+		grep "lfm_flags:.*0x0000DA05" ||
+		error "$DIR/$tdir/${tfile}: invalid LOV EA foreign flags"
+	$LFS getstripe $DIR/$tdir/${tfile} |
+		grep "lfm_value:.*${uuid1}/${uuid2}" ||
+		error "$DIR/$tdir/${tfile}: invalid LOV EA foreign value"
+
+	# modify striping should fail
+	$LFS setstripe -c 2 $DIR/$tdir/$tfile &&
+		error "$DIR/$tdir/$tfile: setstripe should fail"
+
+	# R/W should fail ("/{foreign_symlink_prefix}/${uuid1}/" missing)
+	cat $DIR/$tdir/$tfile && error "$DIR/$tdir/$tfile: read should fail"
+	cat /etc/passwd > $DIR/$tdir/$tfile &&
+		error "$DIR/$tdir/$tfile: write should fail"
+
+	# rename should succeed
+	mv $DIR/$tdir/$tfile $DIR/$tdir/${tfile}.new ||
+		error "$DIR/$tdir/$tfile: rename has failed"
+
+	#remove foreign_symlink file should fail
+	rm $DIR/$tdir/${tfile}.new &&
+		error "$DIR/$tdir/${tfile}.new: remove of foreign_symlink file should fail"
+
+	#test fake symlink
+	mkdir /tmp/${uuid1} ||
+		error "/tmp/${uuid1}: mkdir has failed"
+	echo FOOFOO > /tmp/${uuid1}/${uuid2} ||
+		error "/tmp/${uuid1}/${uuid2}: echo has failed"
+	$LCTL set_param llite/$FSNAME-*/foreign_symlink_prefix=/tmp/
+	$CHECKSTAT -t link -l /tmp/${uuid1}/${uuid2} $DIR/$tdir/${tfile}.new ||
+		error "$DIR/$tdir/${tfile}.new: not seen as a symlink"
+	#read should succeed now
+	cat $DIR/$tdir/${tfile}.new | grep FOOFOO ||
+		error "$DIR/$tdir/${tfile}.new: symlink resolution has failed"
+	#write should succeed now
+	cat /etc/passwd > $DIR/$tdir/${tfile}.new ||
+		error "$DIR/$tdir/${tfile}.new: write should succeed"
+	diff /etc/passwd $DIR/$tdir/${tfile}.new ||
+		error "$DIR/$tdir/${tfile}.new: diff has failed"
+	diff /etc/passwd /tmp/${uuid1}/${uuid2} ||
+		error "/tmp/${uuid1}/${uuid2}: diff has failed"
+
+	#check that getstripe still works
+	$LFS getstripe $DIR/$tdir/${tfile}.new ||
+		error "$DIR/$tdir/${tfile}.new: getstripe should still work with foreign_symlink enabled"
+
+	# chmod should still succeed
+	chmod 644 $DIR/$tdir/${tfile}.new ||
+		error "$DIR/$tdir/${tfile}.new: chmod has failed"
+
+	# chown should still succeed
+	chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/${tfile}.new ||
+		error "$DIR/$tdir/${tfile}.new: chown has failed"
+
+	# rename should still succeed
+	mv $DIR/$tdir/${tfile}.new $DIR/$tdir/${tfile} ||
+		error "$DIR/$tdir/${tfile}.new: rename has failed"
+
+	#remove foreign_symlink file should still fail
+	rm $DIR/$tdir/${tfile} &&
+		error "$DIR/$tdir/${tfile}: remove of foreign_symlink file should fail"
+
+	#use special ioctl() to unlink foreign_symlink file
+	$LFS unlink_foreign $DIR/$tdir/${tfile} ||
+		error "$DIR/$tdir/$tfile: unlink/ioctl failed"
+
+}
+run_test 27O "basic ops on foreign file of symlink type"
+
+test_27P() {
+	[[ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.12.49) ]] &&
+		skip "Need MDS version newer than 2.12.49"
+
+	test_mkdir $DIR/$tdir
+	local uuid1=$(cat /proc/sys/kernel/random/uuid)
+	local uuid2=$(cat /proc/sys/kernel/random/uuid)
+
+	trap clean_foreign_symlink EXIT
+
+	# enable foreign_symlink behaviour
+	$LCTL set_param llite/$FSNAME-*/foreign_symlink_enable=1
+
+	# foreign symlink LMV format is a partial path by default
+
+	# create foreign dir (lfs + API)
+	$LFS mkdir --foreign=symlink --xattr="${uuid1}/${uuid2}" \
+		--flags=0xda05 --mode 0750 $DIR/$tdir/${tdir} ||
+		error "$DIR/$tdir/${tdir}: create failed"
+
+	$LFS getdirstripe -v $DIR/$tdir/${tdir} |
+		grep "lfm_magic:.*0x0CD50CD0" ||
+		error "$DIR/$tdir/${tdir}: invalid LMV EA magic"
+	$LFS getdirstripe -v $DIR/$tdir/${tdir} | grep "lfm_type:.*symlink" ||
+		error "$DIR/$tdir/${tdir}: invalid LMV EA type"
+	$LFS getdirstripe -v $DIR/$tdir/${tdir} |
+		grep "lfm_flags:.*0x0000DA05" ||
+		error "$DIR/$tdir/${tdir}: invalid LMV EA flags"
+	$LFS getdirstripe $DIR/$tdir/${tdir} |
+		grep "lfm_value.*${uuid1}/${uuid2}" ||
+		error "$DIR/$tdir/${tdir}: invalid LMV EA value"
+
+	# file create in dir should fail
+	# ("/{foreign_symlink_prefix}/${uuid1}/${uuid2}/" missing)
+	touch $DIR/$tdir/$tdir/$tfile && "$DIR/$tdir: file create should fail"
+
+	# rename should succeed
+	mv $DIR/$tdir/$tdir $DIR/$tdir/${tdir}.new ||
+		error "$DIR/$tdir/$tdir: rename of foreign_symlink dir has failed"
+
+	#remove foreign_symlink dir should fail
+	rmdir $DIR/$tdir/${tdir}.new &&
+		error "$DIR/$tdir/${tdir}.new: remove of foreign_symlink dir should fail"
+
+	#test fake symlink
+	mkdir -p /tmp/${uuid1}/${uuid2} ||
+		error "/tmp/${uuid1}/${uuid2}: mkdir has failed"
+	echo FOOFOO > /tmp/${uuid1}/${uuid2}/foo ||
+		error "/tmp/${uuid1}/${uuid2}/foo: echo has failed"
+	$LCTL set_param llite/$FSNAME-*/foreign_symlink_prefix=/tmp/
+	$CHECKSTAT -t link -l /tmp/${uuid1}/${uuid2} $DIR/$tdir/${tdir}.new ||
+		error "$DIR/$tdir/${tdir}.new: not seen as a symlink"
+	cat $DIR/$tdir/${tdir}.new/foo | grep FOOFOO ||
+		error "$DIR/$tdir/${tdir}.new: symlink resolution has failed"
+
+	#check that getstripe fails now that foreign_symlink enabled
+	$LFS getdirstripe $DIR/$tdir/${tdir}.new ||
+		error "$DIR/$tdir/${tdir}.new: getdirstripe should still work with foreign_symlink enabled"
+
+	# file create in dir should work now
+	cp /etc/passwd $DIR/$tdir/${tdir}.new/$tfile ||
+		error "$DIR/$tdir/${tdir}.new/$tfile: file create should fail"
+	diff /etc/passwd $DIR/$tdir/${tdir}.new/$tfile ||
+		error "$DIR/$tdir/${tdir}.new/$tfile: diff has failed"
+	diff /etc/passwd /tmp/${uuid1}/${uuid2}/$tfile ||
+		error "/tmp/${uuid1}/${uuid2}/$tfile: diff has failed"
+
+	# chmod should still succeed
+	chmod 755 $DIR/$tdir/${tdir}.new ||
+		error "$DIR/$tdir/${tdir}.new: chmod has failed"
+
+	# chown should still succeed
+	chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/${tdir}.new ||
+		error "$DIR/$tdir/${tdir}.new: chown has failed"
+
+	# rename should still succeed
+	mv $DIR/$tdir/${tdir}.new $DIR/$tdir/${tdir} ||
+		error "$DIR/$tdir/${tdir}.new: rename of foreign_symlink dir has failed"
+
+	#remove foreign_symlink dir should still fail
+	rmdir $DIR/$tdir/${tdir} &&
+		error "$DIR/$tdir/${tdir}: remove of foreign_symlink dir should fail"
+
+	#use special ioctl() to unlink foreign_symlink file
+	$LFS unlink_foreign $DIR/$tdir/${tdir} ||
+		error "$DIR/$tdir/$tdir: unlink/ioctl failed"
+
+	#created file should still exist
+	[[ -f /tmp/${uuid1}/${uuid2}/$tfile ]] ||
+		error "/tmp/${uuid1}/${uuid2}/$tfile has been removed"
+	diff /etc/passwd /tmp/${uuid1}/${uuid2}/$tfile ||
+		error "/tmp/${uuid1}/${uuid2}/$tfile: diff has failed"
+}
+run_test 27P "basic ops on foreign dir of foreign_symlink type"
+
 # createtest also checks that device nodes are created and
 # then visible correctly (#2091)
 test_28() { # bug 2091
@@ -3326,6 +3630,21 @@ test_31p() {
 }
 run_test 31p "remove of open striped directory"
 
+test_31q() {
+	[ $MDSCOUNT -lt 3 ] && skip_env "needs >= 3 MDTs"
+
+	$LFS mkdir -i 3,1 $DIR/$tdir || error "mkdir failed"
+	index=$($LFS getdirstripe -i $DIR/$tdir)
+	[ $index -eq 3 ] || error "first stripe index $index != 3"
+	index=$($LFS getdirstripe $DIR/$tdir | tail -1 | awk '{print $1}')
+	[ $index -eq 1 ] || error "second stripe index $index != 1"
+
+	# when "-c <stripe_count>" is set, the number of MDTs specified after
+	# "-i" should equal to the stripe count
+	$LFS mkdir -i 3,1 -c 3 $DIR/$tdir.2 && error "mkdir should fail" || true
+}
+run_test 31q "create striped directory on specific MDTs"
+
 cleanup_test32_mount() {
 	local rc=0
 	trap 0
@@ -3827,7 +4146,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"
@@ -3839,7 +4158,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"
@@ -4585,7 +4904,8 @@ test_39r() {
 
 	# exceed atime_diff and access file
 	sleep 6
-	dd if=$DIR/$tfile of=/dev/null || error "can't udpate atime"
+	dd if=$DIR/$tfile of=/dev/null bs=4k count=1 ||
+		error "can't udpate atime"
 
 	local atime_cli=$(stat -c %X $DIR/$tfile)
 	echo "client atime: $atime_cli"
@@ -4873,6 +5193,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"
 
@@ -4920,17 +5242,14 @@ test_44A() { # was test_44
 run_test 44A "zero length read from a sparse stripe"
 
 test_44a() {
-	local nstripe=$($LCTL lov_getconfig $DIR | grep default_stripe_count: |
-		awk '{ print $2 }')
+	local nstripe=$($LFS getstripe -c -d $DIR)
 	[ -z "$nstripe" ] && skip "can't get stripe info"
 	[[ $nstripe -gt $OSTCOUNT ]] &&
-		skip "Wrong default_stripe_count: $nstripe OSTCOUNT: $OSTCOUNT"
+		skip "Wrong default stripe_count: $nstripe OSTCOUNT: $OSTCOUNT"
 
-	local stride=$($LCTL lov_getconfig $DIR | grep default_stripe_size: |
-		awk '{ print $2 }')
+	local stride=$($LFS getstripe -S -d $DIR)
 	if [[ $nstripe -eq 0 || $nstripe -eq -1 ]]; then
-		nstripe=$($LCTL lov_getconfig $DIR | grep obd_count: |
-			awk '{ print $2 }')
+		nstripe=$($LFS df $DIR | grep OST: | wc -l)
 	fi
 
 	OFFSETS="0 $((stride/2)) $((stride-1))"
@@ -5122,6 +5441,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"
@@ -5912,7 +6252,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"
 
@@ -5933,6 +6273,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
@@ -5947,28 +6289,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"
@@ -5978,10 +6320,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"
@@ -6227,8 +6578,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
@@ -6268,14 +6624,15 @@ test_56rb() {
 	test_mkdir -p $dir || error "failed to mkdir $dir"
 	$LFS setstripe -c 1 -i 0 $dir/$tfile ||
 		error "failed to setstripe $dir/$tfile"
+	mdt_idx=$($LFS getdirstripe -i $dir)
 	dd if=/dev/zero of=$dir/$tfile bs=1M count=1
 
 	stack_trap "rm -f $tmp" EXIT
-	$LFS find --size +100K --ost 0 $dir 2>&1 | tee $tmp
-	[ -z "$(cat $tmp | grep "obd_uuid: ")" ] ||
+	$LFS find --size +100K --ost 0 $dir |& tee $tmp
+	! grep -q obd_uuid $tmp ||
 		error "failed to find --size +100K --ost 0 $dir"
-	$LFS find --size +100K --mdt $mdt_idx $dir 2>&1 | tee $tmp
-	[ -z "$(cat $tmp | grep "obd_uuid: ")" ] ||
+	$LFS find --size +100K --mdt $mdt_idx $dir |& tee $tmp
+	! grep -q obd_uuid $tmp ||
 		error "failed to find --size +100K --mdt $mdt_idx $dir"
 }
 run_test 56rb "check lfs find --size --ost/--mdt works"
@@ -6992,7 +7349,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" ||
@@ -7012,7 +7369,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
@@ -7399,6 +7756,38 @@ test_56ca() {
 }
 run_test 56ca "check lfs find --mirror-count|-N and --mirror-state"
 
+test_56da() { # LU-14179
+	local path=$DIR/$tdir
+
+	test_mkdir $path
+	cd $path
+
+	local longdir=$(str_repeat 'a' 255)
+
+	for i in {1..15}; do
+		path=$path/$longdir
+		test_mkdir $longdir
+		cd $longdir
+	done
+
+	local len=${#path}
+	local lastdir=$(str_repeat 'a' $((4096 - 1 - $len - 1)))
+
+	test_mkdir $lastdir
+	cd $lastdir
+	# PATH_MAX-1
+	(( ${#PWD} == 4095 )) || error "bad PWD length ${#PWD}, expect 4095"
+
+	# NAME_MAX
+	touch $(str_repeat 'f' 255)
+
+	$LFS find $DIR/$tdir --type d |& grep "lfs find: error" &&
+		error "lfs find reported an error"
+
+	rm -rf $DIR/$tdir
+}
+run_test 56da "test lfs find with long paths"
+
 test_57a() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 	# note test will not do anything if MDS is not local
@@ -7660,6 +8049,25 @@ test_60e() {
 }
 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*"
+	#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
+		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
@@ -7686,7 +8094,7 @@ test_60g() {
 
 		do_facet mds$index $LCTL set_param fail_loc=0x8000019a \
 			> /dev/null
-		usleep 100
+		sleep 0.01
 	done
 
 	kill -9 $pid
@@ -7839,18 +8247,25 @@ test_64c() {
 }
 run_test 64c "verify grant shrink"
 
+import_param() {
+	local tgt=$1
+	local param=$2
+
+	$LCTL get_param osc.$tgt.import | awk "/$param/ { print \$2 }"
+}
+
 # this does exactly what osc_request.c:osc_announce_cached() does in
 # order to calculate max amount of grants to ask from server
 want_grant() {
 	local tgt=$1
 
-	local nrpages=$($LCTL get_param -n osc.${tgt}.max_pages_per_rpc)
-	local rpc_in_flight=$($LCTL get_param -n osc.${tgt}.max_rpcs_in_flight)
+	local nrpages=$($LCTL get_param -n osc.$tgt.max_pages_per_rpc)
+	local rpc_in_flight=$($LCTL get_param -n osc.$tgt.max_rpcs_in_flight)
 
-	((rpc_in_flight ++));
+	((rpc_in_flight++));
 	nrpages=$((nrpages * rpc_in_flight))
 
-	local dirty_max_pages=$($LCTL get_param -n osc.${tgt}.max_dirty_mb)
+	local dirty_max_pages=$($LCTL get_param -n osc.$tgt.max_dirty_mb)
 
 	dirty_max_pages=$((dirty_max_pages * 1024 * 1024 / PAGE_SIZE))
 
@@ -7858,13 +8273,11 @@ want_grant() {
 	local undirty=$((nrpages * PAGE_SIZE))
 
 	local max_extent_pages
-	max_extent_pages=$($LCTL get_param osc.${tgt}.import |
-	    grep grant_max_extent_size | awk '{print $2}')
+	max_extent_pages=$(import_param $tgt grant_max_extent_size)
 	max_extent_pages=$((max_extent_pages / PAGE_SIZE))
 	local nrextents=$(((nrpages + max_extent_pages - 1) / max_extent_pages))
 	local grant_extent_tax
-	grant_extent_tax=$($LCTL get_param osc.${tgt}.import |
-	    grep grant_extent_tax | awk '{print $2}')
+	grant_extent_tax=$(import_param $tgt grant_extent_tax)
 
 	undirty=$((undirty + nrextents * grant_extent_tax))
 
@@ -7878,56 +8291,171 @@ grant_chunk() {
 	local max_brw_size
 	local grant_extent_tax
 
-	max_brw_size=$($LCTL get_param osc.${tgt}.import |
-	    grep max_brw_size | awk '{print $2}')
+	max_brw_size=$(import_param $tgt max_brw_size)
 
-	grant_extent_tax=$($LCTL get_param osc.${tgt}.import |
-	    grep grant_extent_tax | awk '{print $2}')
+	grant_extent_tax=$(import_param $tgt grant_extent_tax)
 
 	echo $(((max_brw_size + grant_extent_tax) * 2))
 }
 
 test_64d() {
-	[ $OST1_VERSION -lt $(version_code 2.10.56) ] &&
+	[ $OST1_VERSION -ge $(version_code 2.10.56) ] ||
 		skip "OST < 2.10.55 doesn't limit grants enough"
 
-	local tgt=$($LCTL dl | grep "0000-osc-[^mM]" | awk '{print $4}')
-	local file=$DIR/$tfile
+	local tgt=$($LCTL dl | awk '/OST0000-osc-[^mM]/ { print $4 }')
 
-	[[ $($LCTL get_param osc.${tgt}.import |
-	     grep "connect_flags:.*grant_param") ]] ||
+	[[ "$($LCTL get_param osc.${tgt}.import)" =~ "grant_param" ]] ||
 		skip "no grant_param connect flag"
 
-	local olddebug=$($LCTL get_param -n debug 2> /dev/null)
+	local olddebug="$($LCTL get_param -n debug 2> /dev/null)"
+
+	$LCTL set_param -n -n debug="$OLDDEBUG" || true
+	stack_trap "$LCTL set_param -n debug='$olddebug'" EXIT
 
-	$LCTL set_param debug="$OLDDEBUG" 2> /dev/null || true
 
 	local max_cur_granted=$(($(want_grant $tgt) + $(grant_chunk $tgt)))
-	stack_trap "rm -f $file" EXIT
+	stack_trap "rm -f $DIR/$tfile && wait_delete_completed" EXIT
 
-	$LFS setstripe $file -i 0 -c 1
-	dd if=/dev/zero of=$file bs=1M count=1000 &
+	$LFS setstripe $DIR/$tfile -i 0 -c 1
+	dd if=/dev/zero of=$DIR/$tfile bs=1M count=1000 &
 	ddpid=$!
 
-	while true
-	do
-		local cur_grant=$($LCTL get_param -n osc.${tgt}.cur_grant_bytes)
-		if [[ $cur_grant -gt $max_cur_granted ]]
-		then
+	while kill -0 $ddpid; do
+		local cur_grant=$($LCTL get_param -n osc.$tgt.cur_grant_bytes)
+
+		if [[ $cur_grant -gt $max_cur_granted ]]; then
 			kill $ddpid
 			error "cur_grant $cur_grant > $max_cur_granted"
 		fi
-		kill -0 $ddpid
-		[[ $? -ne 0 ]] && break;
-		sleep 2
-	done
 
-	rm -f $DIR/$tfile
-	wait_delete_completed
-	$LCTL set_param debug="$olddebug" 2> /dev/null || true
+		sleep 1
+	done
 }
 run_test 64d "check grant limit exceed"
 
+check_grants() {
+	local tgt=$1
+	local expected=$2
+	local msg=$3
+	local cur_grants=$($LCTL get_param -n osc.$tgt.cur_grant_bytes)
+
+	((cur_grants == expected)) ||
+		error "$msg: grants mismatch: $cur_grants, expected $expected"
+}
+
+round_up_p2() {
+	echo $((($1 + $2 - 1) & ~($2 - 1)))
+}
+
+test_64e() {
+	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+	[ $OST1_VERSION -ge $(version_code 2.11.56) ] ||
+		skip "Need OSS version at least 2.11.56"
+
+	# Remount client to reset grant
+	remount_client $MOUNT || error "failed to remount client"
+	local osc_tgt="$FSNAME-OST0000-osc-$($LFS getname -i $DIR)"
+
+	local init_grants=$(import_param $osc_tgt initial_grant)
+
+	check_grants $osc_tgt $init_grants "init grants"
+
+	local extent_tax=$(import_param $osc_tgt grant_extent_tax)
+	local max_brw_size=$(import_param $osc_tgt max_brw_size)
+	local gbs=$(import_param $osc_tgt grant_block_size)
+
+	# write random number of bytes from max_brw_size / 4 to max_brw_size
+	local write_bytes=$(shuf -i $((max_brw_size / 4))-$max_brw_size -n 1)
+	# align for direct io
+	write_bytes=$(round_up_p2 $write_bytes PAGE_SIZE)
+	# round to grant consumption unit
+	local wb_round_up=$(round_up_p2 $write_bytes gbs)
+
+	local grants=$((wb_round_up + extent_tax))
+
+	$LFS setstripe -c 1 -i 0 $DIR/$tfile  || error "lfs setstripe failed"
+
+	# define OBD_FAIL_TGT_NO_GRANT 0x725
+	# make the server not grant more back
+	do_facet ost1 $LCTL set_param fail_loc=0x725
+	dd if=/dev/zero of=$DIR/$tfile bs=$write_bytes count=1 oflag=direct
+
+	do_facet ost1 $LCTL set_param fail_loc=0
+
+	check_grants $osc_tgt $((init_grants - grants)) "dio w/o grant alloc"
+
+	rm -f $DIR/$tfile || error "rm failed"
+
+	# Remount client to reset grant
+	remount_client $MOUNT || error "failed to remount client"
+	osc_tgt="$FSNAME-OST0000-osc-$($LFS getname -i $DIR)"
+
+	$LFS setstripe -c 1 -i 0 $DIR/$tfile || error "lfs setstripe failed"
+
+	# define OBD_FAIL_TGT_NO_GRANT 0x725
+	# make the server not grant more back
+	do_facet ost1 $LCTL set_param fail_loc=0x725
+	$MULTIOP $DIR/$tfile "oO_WRONLY:w${write_bytes}yc"
+	do_facet ost1 $LCTL set_param fail_loc=0
+
+	check_grants $osc_tgt $((init_grants - grants)) "buf io w/o grant alloc"
+}
+run_test 64e "check grant consumption (no grant allocation)"
+
+test_64f() {
+	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+
+	# Remount client to reset grant
+	remount_client $MOUNT || error "failed to remount client"
+	local osc_tgt="$FSNAME-OST0000-osc-$($LFS getname -i $DIR)"
+
+	local init_grants=$(import_param $osc_tgt initial_grant)
+	local extent_tax=$(import_param $osc_tgt grant_extent_tax)
+	local max_brw_size=$(import_param $osc_tgt max_brw_size)
+	local gbs=$(import_param $osc_tgt grant_block_size)
+	local chunk=$(grant_chunk $osc_tgt)
+
+	# write random number of bytes from max_brw_size / 4 to max_brw_size
+	local write_bytes=$(shuf -i $((max_brw_size / 4))-$max_brw_size -n 1)
+	# align for direct io
+	write_bytes=$(round_up_p2 $write_bytes PAGE_SIZE)
+	# round to grant consumption unit
+	local wb_round_up=$(round_up_p2 $write_bytes gbs)
+
+	local grants=$((wb_round_up + extent_tax))
+
+	$LFS setstripe -c 1 -i 0 $DIR/$tfile || error "lfs setstripe failed"
+	dd if=/dev/zero of=$DIR/$tfile bs=$write_bytes count=1 oflag=direct ||
+		error "error writing to $DIR/$tfile"
+
+	check_grants $osc_tgt $((init_grants - grants + chunk)) \
+		"direct io with grant allocation"
+
+	rm -f $DIR/$tfile || error "rm failed"
+
+	# Remount client to reset grant
+	remount_client $MOUNT || error "failed to remount client"
+	osc_tgt="$FSNAME-OST0000-osc-$($LFS getname -i $DIR)"
+
+	$LFS setstripe -c 1 -i 0 $DIR/$tfile || error "lfs setstripe failed"
+
+	local cmd="oO_WRONLY:w${write_bytes}_yc"
+
+	$MULTIOP $DIR/$tfile $cmd &
+	MULTIPID=$!
+	sleep 1
+
+	check_grants $osc_tgt $((init_grants - grants)) \
+		"buffered io, not write rpc"
+
+	kill -USR1 $MULTIPID
+	wait
+
+	check_grants $osc_tgt $((init_grants - grants + chunk)) \
+		"buffered io, one RPC"
+}
+run_test 64f "check grant consumption (with grant allocation)"
+
 # bug 1414 - set/get directories' stripe info
 test_65a() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
@@ -8208,7 +8736,11 @@ test_65n() {
 
 	local file2_stripe_size=$($LFS getstripe -S $file2)
 	[[ $file2_stripe_size -eq $new_def_stripe_size ]] ||
+	{
+		echo "file2_stripe_size: '$file2_stripe_size'"
+		echo "new_def_stripe_size: '$new_def_stripe_size'"
 		error "$file2 didn't inherit stripe size $new_def_stripe_size"
+	}
 
 	local dir3=$MOUNT/$tdir-3
 	mkdir $dir3 || error "mkdir $dir3 failed"
@@ -8218,7 +8750,11 @@ test_65n() {
 	local dir3_layout=$(get_layout_param $dir3)
 	local root_dir_layout=$(get_layout_param $MOUNT)
 	[[ "$dir3_layout" = "$root_dir_layout" ]] ||
+	{
+		echo "dir3_layout: '$dir3_layout'"
+		echo "root_dir_layout: '$root_dir_layout'"
 		error "$dir3 should show the default layout from $MOUNT"
+	}
 
 	# set OST pool on root directory
 	local pool=$TESTNAME
@@ -8236,7 +8772,7 @@ test_65n() {
 
 	local file3_pool=$($LFS getstripe -p $file3)
 	[[ "$file3_pool" = "$pool" ]] ||
-		error "$file3 didn't inherit OST pool $pool"
+		error "$file3 ('$file3_pool') didn't inherit OST pool '$pool'"
 
 	local dir4=$MOUNT/$tdir-4
 	mkdir $dir4 || error "mkdir $dir4 failed"
@@ -8247,7 +8783,11 @@ test_65n() {
 	echo "$LFS getstripe -d $MOUNT"
 	$LFS getstripe -d $MOUNT
 	[[ "$dir4_layout" = "$root_dir_layout" ]] ||
+	{
+		echo "dir4_layout: '$dir4_layout'"
+		echo "root_dir_layout: '$root_dir_layout'"
 		error "$dir4 should show the default layout from $MOUNT"
+	}
 
 	# new file created in $dir4 should inherit the pool from
 	# the filesystem default
@@ -8256,7 +8796,7 @@ test_65n() {
 
 	local file4_pool=$($LFS getstripe -p $file4)
 	[[ "$file4_pool" = "$pool" ]] ||
-		error "$file4 didn't inherit OST pool $pool"
+		error "$file4 ('$file4_pool') didn't inherit OST pool $pool"
 
 	# new subdirectory under non-root directory should inherit
 	# the default layout from its parent directory
@@ -8269,7 +8809,11 @@ test_65n() {
 	dir4_layout=$(get_layout_param $dir4)
 	local dir5_layout=$(get_layout_param $dir5)
 	[[ "$dir4_layout" = "$dir5_layout" ]] ||
+	{
+		echo "dir4_layout: '$dir4_layout'"
+		echo "dir5_layout: '$dir5_layout'"
 		error "$dir5 should inherit the default layout from $dir4"
+	}
 
 	# though subdir under ROOT doesn't inherit default layout, but
 	# its sub dir/file should be created with default layout.
@@ -8479,39 +9023,78 @@ test_74c() {
 }
 run_test 74c "ldlm_lock_create error path, (shouldn't LBUG)"
 
-num_inodes() {
-	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()
@@ -8769,9 +9352,8 @@ test_77k() { # LU-10906
 	local i
 
 	[ "$ORIG_CSUM" ] || ORIG_CSUM=$(eval $get_checksum)
-	stack_trap "wait_update $HOSTNAME '$get_checksum' $ORIG_CSUM" EXIT
-	stack_trap "do_facet mgs $LCTL set_param -P $cksum_param=$ORIG_CSUM" \
-		EXIT
+	stack_trap "wait_update $HOSTNAME '$get_checksum' $ORIG_CSUM || true"
+	stack_trap "do_facet mgs $LCTL set_param -P $cksum_param=$ORIG_CSUM"
 
 	for i in 0 1; do
 		do_facet mgs $LCTL set_param -P $cksum_param=$i ||
@@ -8994,28 +9576,6 @@ test_81b() { # LU-456
 }
 run_test 81b "OST should return -ENOSPC when retry still fails ======="
 
-test_82() { # LU-1031
-	dd if=/dev/zero of=$DIR/$tfile bs=1M count=10
-	local gid1=14091995
-	local gid2=16022000
-
-	multiop_bg_pause $DIR/$tfile OG${gid1}_g${gid1}c || return 1
-	local MULTIPID1=$!
-	multiop_bg_pause $DIR/$tfile O_G${gid2}r10g${gid2}c || return 2
-	local MULTIPID2=$!
-	kill -USR1 $MULTIPID2
-	sleep 2
-	if [[ `ps h -o comm -p $MULTIPID2` == "" ]]; then
-		error "First grouplock does not block second one"
-	else
-		echo "Second grouplock blocks first one"
-	fi
-	kill -USR1 $MULTIPID1
-	wait $MULTIPID1
-	wait $MULTIPID2
-}
-run_test 82 "Basic grouplock test"
-
 test_99() {
 	[ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs"
 
@@ -9412,12 +9972,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() {
@@ -10262,6 +10821,21 @@ test_103c() {
 }
 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"
+
+	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"
+	done
+}
+run_test 103e "inheritance of big amount of default ACLs"
+
 test_104a() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 
@@ -11675,18 +12249,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
@@ -12421,38 +12995,30 @@ test_130e() {
 
 	local fm_file=$DIR/$tfile
 	$LFS setstripe -S 131072 -c 2 $fm_file || error "setstripe on $fm_file"
-	[ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
-		skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
 
 	NUM_BLKS=512
 	EXPECTED_LEN=$(( (NUM_BLKS / 2) * 64 ))
-	for ((i = 0; i < $NUM_BLKS; i++))
-	do
-		dd if=/dev/zero of=$fm_file count=1 bs=64k seek=$((2*$i)) conv=notrunc > /dev/null 2>&1
+	for ((i = 0; i < $NUM_BLKS; i++)); do
+		dd if=/dev/zero of=$fm_file count=1 bs=64k seek=$((2*$i)) \
+			conv=notrunc > /dev/null 2>&1
 	done
 
 	filefrag -ves $fm_file || error "filefrag $fm_file failed"
 	filefrag_op=$(filefrag -ve -k $fm_file |
 			sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
 
-	last_lun=$(echo $filefrag_op | cut -d: -f5 |
-		sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
+	last_lun=$(echo $filefrag_op | cut -d: -f5)
 
 	IFS=$'\n'
 	tot_len=0
 	num_luns=1
-	for line in $filefrag_op
-	do
-		frag_lun=$(echo $line | cut -d: -f5 |
-			sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
+	for line in $filefrag_op; do
+		frag_lun=$(echo $line | cut -d: -f5)
 		ext_len=$(echo $line | cut -d: -f4)
-		if (( $frag_lun != $last_lun )); then
+		if [[ "$frag_lun" != "$last_lun" ]]; then
 			if (( tot_len != $EXPECTED_LEN )); then
 				cleanup_130
-				error "FIEMAP on $fm_file failed; returned " \
-				"len $tot_len for OST $last_lun instead " \
-				"of $EXPECTED_LEN"
-				return
+				error "OST$last_lun $tot_len != $EXPECTED_LEN"
 			else
 				(( num_luns += 1 ))
 				tot_len=0
@@ -12463,13 +13029,9 @@ test_130e() {
 	done
 	if (( num_luns != 2 || tot_len != $EXPECTED_LEN )); then
 		cleanup_130
-		error "FIEMAP on $fm_file failed; returned wrong number " \
-			"of luns or wrong len for OST $last_lun"
-		return
+		error "OST$last_lun $num_luns != 2, $tot_len != $EXPECTED_LEN"
 	fi
 
-	cleanup_130
-
 	echo "FIEMAP with continuation calls succeeded"
 }
 run_test 130e "FIEMAP (test continuation FIEMAP calls)"
@@ -12486,14 +13048,38 @@ test_130f() {
 	filefrag_extents=$(filefrag -vek $fm_file |
 			   awk '/extents? found/ { print $2 }')
 	if [[ "$filefrag_extents" != "0" ]]; then
-		error "FIEMAP on $fm_file failed; " \
-		      "returned $filefrag_extents expected 0"
+		error "$fm_file: filefrag_extents=$filefrag_extents != 0"
 	fi
 
 	rm -f $fm_file
 }
 run_test 130f "FIEMAP (unstriped file)"
 
+test_130g() {
+	local file=$DIR/$tfile
+	local nr=$((OSTCOUNT * 100))
+
+	$LFS setstripe -C $nr $file ||
+		error "failed to setstripe -C $nr $file"
+
+	dd if=/dev/zero of=$file count=$nr bs=1M
+	sync
+	nr=$($LFS getstripe -c $file)
+
+	local extents=$(filefrag -v $file |
+			sed -n '/ext:/,/found/{/ext:/d; /found/d; p}' | wc -l)
+
+	echo "filefrag list $extents extents in file with stripecount $nr"
+	if (( extents < nr )); then
+		$LFS getstripe $file
+		filefrag -v $file
+		error "filefrag printed $extents < $nr extents"
+	fi
+
+	rm -f $file
+}
+run_test 130g "FIEMAP (overstripe file)"
+
 # Test for writev/readv
 test_131a() {
 	rwv -f $DIR/$tfile -w -n 3 524288 1048576 1572864 ||
@@ -13156,6 +13742,7 @@ test_150a() {
 
 	local TF="$TMP/$tfile"
 
+	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
 	dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
 	cp $TF $DIR/$tfile
 	cancel_lru_locks $OSC
@@ -13178,58 +13765,87 @@ test_150a() {
 	echo "12345" >>$DIR/$tfile
 	cancel_lru_locks $OSC
 	cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append2)"
-
-	rm -f $TF
-	true
 }
 run_test 150a "truncate/append tests"
 
 test_150b() {
-	[ "$ost1_FSTYPE" != ldiskfs ] && skip "non-ldiskfs backend"
-	[ $OST1_VERSION -lt $(version_code 2.13.50) ] &&
-		skip "Need OST version at least 2.13.53"
+	check_set_fallocate_or_skip
+
 	touch $DIR/$tfile
+	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
 	check_fallocate $DIR/$tfile || error "fallocate failed"
 }
 run_test 150b "Verify fallocate (prealloc) functionality"
 
-test_150c() {
-	local bytes
-	local want
+test_150bb() {
+	check_set_fallocate_or_skip
 
-	[ "$ost1_FSTYPE" != ldiskfs ] && skip "non-ldiskfs backend"
-	[ $OST1_VERSION -lt $(version_code 2.13.50) ] &&
-		skip "Need OST version at least 2.13.53"
+	touch $DIR/$tfile
+	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
+	dd if=/dev/urandom of=$DIR/$tfile bs=1M count=20 || error "dd failed"
+	> $DIR/$tfile
+	fallocate -l $((1048576 * 20)) $DIR/$tfile || error "fallocate failed"
+	# precomputed md5sum for 20MB of zeroes
+	local expect="8f4e33f3dc3e414ff94e5fb6905cba8c"
+	local sum=($(md5sum $DIR/$tfile))
 
-	$LFS setstripe -c $OSTCOUNT -S1M $DIR/$tdir || error "setstripe failed"
-	fallocate -l ${OSTCOUNT}m $DIR/$tdir || error "fallocate failed"
+	[[ "${sum[0]}" == "$expect" ]] || error "fallocate unwritten is not zero"
+
+	check_set_fallocate 1
+
+	> $DIR/$tfile
+	fallocate -l $((1048576 * 20)) $DIR/$tfile || error "fallocate failed"
+	sum=($(md5sum $DIR/$tfile))
+
+	[[ "${sum[0]}" == "$expect" ]] || error "fallocate zero is not zero"
+}
+run_test 150bb "Verify fallocate modes both zero space"
+
+test_150c() {
+	check_set_fallocate_or_skip
+
+	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
+	$LFS setstripe -c $OSTCOUNT -S1M $DIR/$tfile || error "setstripe failed"
+	fallocate -l ${OSTCOUNT}m $DIR/$tfile || error "fallocate failed"
 	sync; sync_all_data
 	cancel_lru_locks $OSC
 	sleep 5
-	bytes=$(($(stat -c '%b * %B' $DIR/$tdir)))
+	bytes=$(($(stat -c '%b * %B' $DIR/$tfile)))
 	want=$((OSTCOUNT * 1048576))
 
 	# Must allocate all requested space, not more than 5% extra
 	(( $bytes >= $want && $bytes < $want * 105 / 100 )) ||
 		error "bytes $bytes is not $want"
+
+	rm -f $DIR/$tfile
+	# verify fallocate on PFL file
+	$LFS setstripe -E1M -c1 -E16M -c3 -Eeof -c 4 $DIR/$tfile ||
+		error "Create $DIR/$tfile failed"
+	fallocate -l $((1048576 * 1024)) $DIR/$tfile ||
+			error "fallocate failed"
+	sync; sync_all_data
+	cancel_lru_locks $OSC
+	sleep 5
+	local bytes=$(($(stat -c '%b * %B' $DIR/$tfile)))
+	local want=$((1024 * 1048576))
+
+	# Must allocate all requested space, not more than 5% extra
+	(( $bytes >= $want && $bytes < $want * 105 / 100 )) ||
+		error "bytes $bytes is not $want"
 }
 run_test 150c "Verify fallocate Size and Blocks"
 
 test_150d() {
-	local bytes
-	local want
-
-	[ "$ost1_FSTYPE" != ldiskfs ] && skip "non-ldiskfs backend"
-	[ $OST1_VERSION -lt $(version_code 2.13.50) ] &&
-		skip "Need OST version at least 2.13.53"
+	check_set_fallocate_or_skip
 
+	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
 	$LFS setstripe -c $OSTCOUNT -S1M $DIR/$tdir || error "setstripe failed"
 	fallocate -o 1G -l ${OSTCOUNT}m $DIR/$tdir || error "fallocate failed"
 	sync; sync_all_data
 	cancel_lru_locks $OSC
 	sleep 5
-	bytes=$(($(stat -c '%b * %B' $DIR/$tdir)))
-	want=$((OSTCOUNT * 1048576))
+	local bytes=$(($(stat -c '%b * %B' $DIR/$tdir)))
+	local want=$((OSTCOUNT * 1048576))
 
 	# Must allocate all requested space, not more than 5% extra
 	(( $bytes >= $want && $bytes < $want * 105 / 100 )) ||
@@ -13237,6 +13853,55 @@ test_150d() {
 }
 run_test 150d "Verify fallocate Size and Blocks - Non zero start"
 
+test_150e() {
+	check_set_fallocate_or_skip
+
+	echo "df before:"
+	$LFS df
+	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
+	$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 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
+		local space=$((1024 * 100 * OSTCOUNT))
+	else
+		local space=$(((min_size_ost * 60)/100 * OSTCOUNT))
+	fi
+
+	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 60% 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))
@@ -13522,10 +14187,19 @@ test_154A() {
 	[ -z "$fid" ] && error "path2fid unable to get $tf FID"
 
 	# check that we get the same pathname back
-	local found=$($LFS fid2path $MOUNT "$fid")
-	[ -z "$found" ] && error "fid2path unable to get '$fid' path"
-	[ "$found" == "$tf" ] ||
-		error "fid2path($fid=path2fid($tf)) = $found != $tf"
+	local rootpath
+	local found
+	for rootpath in "$MOUNT" "$MOUNT///" "$MOUNT/$tfile"; do
+		echo "$rootpath $fid"
+		found=$($LFS fid2path $rootpath "$fid")
+		[ -z "$found" ] && error "fid2path unable to get '$fid' path"
+		[ "$found" == "$tf" ] || error "fid2path $found != $tf"
+	done
+
+	# check wrong root path format
+	rootpath=$MOUNT"_wrong"
+	found=$($LFS fid2path $rootpath "$fid")
+	[ -z "$found" ] || error "should fail ($rootpath != $MOUNT)"
 }
 run_test 154A "lfs path2fid and fid2path basic checks"
 
@@ -14347,12 +15021,14 @@ test_160f() {
 	local i
 
 	# generate some changelog records to accumulate on each MDT
-	# use fnv1a because created files should be evenly distributed
-	test_mkdir -c $MDSCOUNT -H fnv_1a_64 $DIR/$tdir ||
+	# use all_char because created files should be evenly distributed
+	test_mkdir -c $MDSCOUNT -H all_char $DIR/$tdir ||
 		error "test_mkdir $tdir failed"
 	log "$(date +%s): creating first files"
-	createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
-		error "create $DIR/$tdir/$tfile failed"
+	for ((i = 0; i < MDSCOUNT * 2; i++)); do
+		$LFS mkdir -i $((i%MDSCOUNT)) $DIR/$tdir/d$i.$((i/MDSCOUNT)) ||
+			error "create $DIR/$tdir/d$i.$((i/MDSCOUNT)) failed"
+	done
 
 	# check changelogs have been generated
 	local start=$SECONDS
@@ -14380,7 +15056,7 @@ test_160f() {
 
 	# simulate changelog catalog almost full
 	#define OBD_FAIL_CAT_FREE_RECORDS	0x1313
-	do_nodes $mdts $LCTL set_param fail_loc=0x1313 fail_val=3
+	do_nodes $mdts "$LCTL set_param fail_loc=0x1313 fail_val=3"
 
 	for i in $(seq $MDSCOUNT); do
 		cl_users=(${CL_USERS[mds$i]})
@@ -14420,18 +15096,19 @@ test_160f() {
 	# Generate one more changelog to trigger GC at fail_loc for cl_user2.
 	# cl_user1 should be OK because it recently processed records.
 	echo "$(date +%s): creating $((MDSCOUNT * 2)) files"
-	createmany -m $DIR/$tdir/${tfile}b $((MDSCOUNT * 2)) ||
-		error "create $DIR/$tdir/${tfile}b failed"
+	for ((i = 0; i < MDSCOUNT * 2; i++)); do
+		$LFS mkdir -i $((i%MDSCOUNT)) $DIR/$tdir/d$i.$((i/MDSCOUNT+2))||
+			error "create $DIR/$tdir/d$i.$((i/MDSCOUNT+2)) failed"
+	done
 
 	# ensure gc thread is done
 	for i in $(mdts_nodes); do
-		wait_update $i \
-			"ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
+		wait_update $i "ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
 			error "$i: GC-thread not done"
 	done
 
 	local first_rec
-	for i in $(seq $MDSCOUNT); do
+	for (( i = 1; i <= MDSCOUNT; i++ )); do
 		# check cl_user1 still registered
 		changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
 			error "mds$i: User ${cl_user1[mds$i]} not registered"
@@ -14446,10 +15123,9 @@ test_160f() {
 		first_rec=$($LFS changelog $(facet_svc mds$i) |
 			    awk '{ print $1; exit; }')
 
-		echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
+		echo "mds$i: $(date +%s) verify rec $user_rec1+1 == $first_rec"
 		[ $((user_rec1 + 1)) == $first_rec ] ||
-			error "mds$i: first index should be $user_rec1 + 1, " \
-			      "but is $first_rec"
+			error "mds$i: rec $first_rec != $user_rec1 + 1"
 	done
 }
 run_test 160f "changelog garbage collect (timestamped users)"
@@ -14475,20 +15151,20 @@ test_160g() {
 	local i
 
 	# generate some changelog records to accumulate on each MDT
-	# use fnv1a because created files should be evenly distributed
-	test_mkdir -c $MDSCOUNT -H fnv_1a_64 $DIR/$tdir ||
-		error "mkdir $tdir failed"
-	createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
-		error "create $DIR/$tdir/$tfile failed"
+	# use all_char because created files should be evenly distributed
+	test_mkdir -c $MDSCOUNT -H all_char $DIR/$tdir ||
+		error "test_mkdir $tdir failed"
+	for ((i = 0; i < MDSCOUNT; i++)); do
+		$LFS mkdir -i $i $DIR/$tdir/d$i.1 $DIR/$tdir/d$i.2 ||
+			error "create $DIR/$tdir/d$i.1 failed"
+	done
 
 	# check changelogs have been generated
 	local nbcl=$(changelog_dump | wc -l)
-	[[ $nbcl -eq 0 ]] && error "no changelogs found"
+	(( $nbcl > 0 )) || error "no changelogs found"
 
 	# reduce the max_idle_indexes value to make sure we exceed it
-	max_ndx=$((nbcl / 2 - 1))
-
-	for param in "changelog_max_idle_indexes=$max_ndx" \
+	for param in "changelog_max_idle_indexes=1" \
 		     "changelog_gc=1" \
 		     "changelog_min_gc_interval=2" \
 		     "changelog_min_free_cat_entries=3"; do
@@ -14503,8 +15179,9 @@ test_160g() {
 
 	# simulate changelog catalog almost full
 	#define OBD_FAIL_CAT_FREE_RECORDS	0x1313
-	do_nodes $mdts $LCTL set_param fail_loc=0x1313 fail_val=3
+	do_nodes $mdts "$LCTL set_param fail_loc=0x1313 fail_val=3"
 
+	local start=$SECONDS
 	for i in $(seq $MDSCOUNT); do
 		cl_users=(${CL_USERS[mds$i]})
 		cl_user1[mds$i]="${cl_users[0]}"
@@ -14536,21 +15213,24 @@ test_160g() {
 	done
 
 	# ensure we are past the previous changelog_min_gc_interval set above
-	sleep 2
+	local sleep2=$((start + 2 - SECONDS))
+	(( sleep2 > 0 )) && echo "sleep $sleep2 for interval" && sleep $sleep2
 
-	# generate one more changelog to trigger fail_loc
-	createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
-		error "create $DIR/$tdir/${tfile}bis failed"
+	# Generate one more changelog to trigger GC at fail_loc for cl_user2.
+	# cl_user1 should be OK because it recently processed records.
+	for ((i = 0; i < MDSCOUNT; i++)); do
+		$LFS mkdir -i $i $DIR/$tdir/d$i.3 $DIR/$tdir/d$i.4 ||
+			error "create $DIR/$tdir/d$i.3 failed"
+	done
 
 	# ensure gc thread is done
 	for i in $(mdts_nodes); do
-		wait_update $i \
-			"ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
+		wait_update $i "ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
 			error "$i: GC-thread not done"
 	done
 
 	local first_rec
-	for i in $(seq $MDSCOUNT); do
+	for (( i = 1; i <= MDSCOUNT; i++ )); do
 		# check cl_user1 still registered
 		changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
 			error "mds$i: User ${cl_user1[mds$i]} not registered"
@@ -14565,10 +15245,9 @@ test_160g() {
 		first_rec=$($LFS changelog $(facet_svc mds$i) |
 			    awk '{ print $1; exit; }')
 
-		echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
+		echo "mds$i: $(date +%s) verify rec $user_rec1+1 == $first_rec"
 		[ $((user_rec1 + 1)) == $first_rec ] ||
-			error "mds$i: first index should be $user_rec1 + 1, " \
-			      "but is $first_rec"
+			error "mds$i: rec $first_rec != $user_rec1 + 1"
 	done
 }
 run_test 160g "changelog garbage collect (old users)"
@@ -14591,11 +15270,13 @@ test_160h() {
 	local i
 
 	# generate some changelog records to accumulate on each MDT
-	# use fnv1a because created files should be evenly distributed
-	test_mkdir -c $MDSCOUNT -H fnv_1a_64 $DIR/$tdir ||
+	# use all_char because created files should be evenly distributed
+	test_mkdir -c $MDSCOUNT -H all_char $DIR/$tdir ||
 		error "test_mkdir $tdir failed"
-	createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
-		error "create $DIR/$tdir/$tfile failed"
+	for ((i = 0; i < MDSCOUNT; i++)); do
+		$LFS mkdir -i $i $DIR/$tdir/d$i.1 $DIR/$tdir/d$i.2 ||
+			error "create $DIR/$tdir/d$i.1 failed"
+	done
 
 	# check changelogs have been generated
 	local nbcl=$(changelog_dump | wc -l)
@@ -14742,11 +15423,13 @@ test_160i() {
 	changelog_register || error "first changelog_register failed"
 
 	# generate some changelog records to accumulate on each MDT
-	# use fnv1a because created files should be evenly distributed
-	test_mkdir -c $MDSCOUNT -H fnv_1a_64 $DIR/$tdir ||
-		error "mkdir $tdir failed"
-	createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
-		error "create $DIR/$tdir/$tfile failed"
+	# use all_char because created files should be evenly distributed
+	test_mkdir -c $MDSCOUNT -H all_char $DIR/$tdir ||
+		error "test_mkdir $tdir failed"
+	for ((i = 0; i < MDSCOUNT; i++)); do
+		$LFS mkdir -i $i $DIR/$tdir/d$i.1 $DIR/$tdir/d$i.2 ||
+			error "create $DIR/$tdir/d$i.1 failed"
+	done
 
 	# check changelogs have been generated
 	local nbcl=$(changelog_dump | wc -l)
@@ -14809,11 +15492,13 @@ test_160j() {
 	stack_trap "changelog_deregister" EXIT
 
 	# generate some changelog
-	# use fnv1a because created files should be evenly distributed
-	test_mkdir -c $MDSCOUNT -H fnv_1a_64 $DIR/$tdir ||
+	# use all_char because created files should be evenly distributed
+	test_mkdir -c $MDSCOUNT -H all_char $DIR/$tdir ||
 		error "mkdir $tdir failed"
-	createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
-		error "create $DIR/$tdir/${tfile}bis failed"
+	for ((i = 0; i < MDSCOUNT; i++)); do
+		$LFS mkdir -i $i $DIR/$tdir/d$i.1 $DIR/$tdir/d$i.2 ||
+			error "create $DIR/$tdir/d$i.1 failed"
+	done
 
 	# open the changelog device
 	exec 3>/dev/changelog-$FSNAME-MDT0000
@@ -14825,8 +15510,8 @@ test_160j() {
 	umount $MOUNT
 	stack_trap "mount_client $MOUNT" EXIT
 
-	# read changelog
-	cat <&4 >/dev/null || error "read changelog failed"
+	# read changelog, which may or may not fail, but should not crash
+	cat <&4 >/dev/null
 
 	# clear changelog
 	local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
@@ -14835,7 +15520,7 @@ test_160j() {
 
 	printf 'clear:'$cl_user':0' >&3
 }
-run_test 160j "client can be umounted  while its chanangelog is being used"
+run_test 160j "client can be umounted while its chanangelog is being used"
 
 test_160k() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
@@ -14859,12 +15544,73 @@ test_160k() {
 	sleep 4
 
 	changelog_dump | grep rmdir || error "rmdir not recorded"
-
-	rm -rf $DIR/$tdir
-	changelog_deregister
 }
 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
+	$MULTIOP $DIR/$tdir/${tfile}_2 O_2w4096c || error "multiop failed"
+	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"
 
@@ -15236,8 +15982,11 @@ test_165a() {
 	local rc
 	local count
 
-	do_facet ost1 ofd_access_log_reader --debug=- --trace=- > "${trace}" &
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
 	setup_165
+	do_facet ost1 ofd_access_log_reader --debug=- --trace=- > "${trace}" &
 	sleep 5
 
 	do_facet ost1 ofd_access_log_reader --list
@@ -15269,13 +16018,19 @@ test_165b() {
 	local size
 	local flags
 
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
 	setup_165
+	do_facet ost1 ofd_access_log_reader --debug=- --trace=- > "${trace}" &
+	sleep 5
 
-	lfs setstripe -c 1 -i 0 "${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}" &
+	lfs setstripe -c 1 -i 0 "${file}"
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
+
 	sleep 5
 	do_facet ost1 killall -TERM ofd_access_log_reader
 	wait
@@ -15311,8 +16066,12 @@ 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}'"
 	sleep 5
+
+	$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
 	rc=$?
@@ -15344,89 +16103,202 @@ test_165b() {
 run_test 165b "ofd access log entries are produced and consumed"
 
 test_165c() {
+	local trace="/tmp/${tfile}.trace"
 	local file="${DIR}/${tdir}/${tfile}"
+
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
 	test_mkdir "${DIR}/${tdir}"
 
 	setup_165
+	do_facet ost1 ofd_access_log_reader --debug=- --trace=- > "${trace}" &
+	sleep 5
 
 	lfs setstripe -c 1 -i 0 "${DIR}/${tdir}"
 
 	# 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
-	do_facet ost1 ofd_access_log_reader --list
+
+	do_facet ost1 killall -TERM ofd_access_log_reader
+	wait
+	rc=$?
+	if ((rc != 0)); then
+		error "ofd_access_log_reader exited with rc = '${rc}'"
+	fi
+
 	unlinkmany  "${file}-%d" 128
 }
 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; }'
+oal_get_read_count() {
+	local stats="$1"
+
+	# STATS lustre-OST0001 alr_read_count 1
+
+	do_facet ost1 cat "${stats}" |
+	awk '$1 == "STATS" && $3 == "alr_read_count" { count = $4; }
+	     END { print count; }'
 }
 
-oal_expect_entry_count() {
-	local entry_count=$(oal_peek_entry_count)
-	local expect="$1"
+oal_expect_read_count() {
+	local stats="$1"
+	local count
+	local expect="$2"
+
+	# Ask ofd_access_log_reader to write stats.
+	do_facet ost1 killall -USR1 ofd_access_log_reader
+
+	# Allow some time for things to happen.
+	sleep 1
 
-	if ((entry_count == expect)); then
+	count=$(oal_get_read_count "${stats}")
+	if ((count == expect)); then
 		return 0
 	fi
 
-	error_noexit "bad entry count, got ${entry_count}, expected ${expect}"
-	do_facet ost1 ofd_access_log_reader --list >&2
+	error_noexit "bad read count, got ${count}, expected ${expect}"
+	do_facet ost1 cat "${stats}" >&2
 	exit 1
 }
 
 test_165d() {
-	local trace="/tmp/${tfile}.trace"
+	local stats="/tmp/${tfile}.stats"
 	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
+	do_facet ost1 ofd_access_log_reader --stats="${stats}" &
+	sleep 5
+
 	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}'"
-	oal_expect_entry_count 1
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
+	oal_expect_read_count "${stats}" 1
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
-	oal_expect_entry_count 2
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
+	oal_expect_read_count "${stats}" 2
 
 	do_facet ost1 lctl set_param "${param}=r"
-	$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_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
+	oal_expect_read_count "${stats}" 2
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
-	oal_expect_entry_count 3
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
+	oal_expect_read_count "${stats}" 3
 
 	do_facet ost1 lctl set_param "${param}=w"
-	$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_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
+	oal_expect_read_count "${stats}" 4
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
-	oal_expect_entry_count 4
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
+	oal_expect_read_count "${stats}" 4
 
 	do_facet ost1 lctl set_param "${param}=0"
-	$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_WRONLY:w1048576c ||
+		error "cannot create '${file}'"
+	oal_expect_read_count "${stats}" 4
 
-	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c || error "cannot read '${file}'"
-	oal_expect_entry_count 4
+	$MULTIOP "${file}" oO_CREAT:O_DIRECT:O_RDONLY:r1048576c ||
+		error "cannot read '${file}'"
+	oal_expect_read_count "${stats}" 4
+
+	do_facet ost1 killall -TERM ofd_access_log_reader
+	wait
+	rc=$?
+	if ((rc != 0)); then
+		error "ofd_access_log_reader exited with rc = '${rc}'"
+	fi
 }
 run_test 165d "ofd_access_log mask works"
 
+test_165e() {
+	local stats="/tmp/${tfile}.stats"
+	local file0="${DIR}/${tdir}-0/${tfile}"
+	local file1="${DIR}/${tdir}-1/${tfile}"
+
+	(( $OST1_VERSION >= $(version_code 2.13.54) )) ||
+		skip "OFD access log unsupported"
+
+	[[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
+
+	test_mkdir -c 1 -i 0 "${DIR}/${tdir}-0"
+	test_mkdir -c 1 -i 1 "${DIR}/${tdir}-1"
+
+	lfs setstripe -c 1 -i 0 "${file0}"
+	lfs setstripe -c 1 -i 0 "${file1}"
+
+	setup_165
+	do_facet ost1 ofd_access_log_reader -I 1 --stats="${stats}" &
+	sleep 5
+
+	$MULTIOP "${file0}" oO_CREAT:O_WRONLY:w512c ||
+		error "cannot create '${file0}'"
+	sync
+	oal_expect_read_count "${stats}" 0
+
+	$MULTIOP "${file1}" oO_CREAT:O_WRONLY:w512c ||
+		error "cannot create '${file1}'"
+	sync
+	oal_expect_read_count "${stats}" 1
+
+	do_facet ost1 killall -TERM ofd_access_log_reader
+	wait
+	rc=$?
+	if ((rc != 0)); then
+		error "ofd_access_log_reader exited with rc = '${rc}'"
+	fi
+}
+run_test 165e "ofd_access_log MDT index filter works"
+
+test_165f() {
+	local trace="/tmp/${tfile}.trace"
+	local rc
+	local count
+
+	setup_165
+	do_facet ost1 timeout 60 ofd_access_log_reader \
+		--exit-on-close --debug=- --trace=- > "${trace}" &
+	sleep 5
+	stop ost1
+
+	wait
+	rc=$?
+
+	if ((rc != 0)); then
+		error_noexit "ofd_access_log_reader exited with rc = '${rc}'"
+		cat "${trace}"
+		exit 1
+	fi
+}
+run_test 165f "ofd_access_log_reader --exit-on-close 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"
@@ -15574,7 +16446,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"
@@ -15785,6 +16658,7 @@ test_184c() {
 	local cmpn_arg=$(cmp -n 2>&1 | grep "invalid option")
 	[ -n "$cmpn_arg" ] && skip_env "cmp does not support -n"
 	check_swap_layouts_support
+	check_swap_layout_no_dom $DIR
 
 	local dir0=$DIR/$tdir/$testnum
 	mkdir -p $dir0 || error "creating dir $dir0"
@@ -15803,8 +16677,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=$?
@@ -15832,6 +16707,7 @@ run_test 184c "Concurrent write and layout swap"
 
 test_184d() {
 	check_swap_layouts_support
+	check_swap_layout_no_dom $DIR
 	[ -z "$(which getfattr 2>/dev/null)" ] &&
 		skip_env "no getfattr command"
 
@@ -15868,6 +16744,7 @@ test_184e() {
 	[[ $MDS1_VERSION -ge $(version_code 2.6.94) ]] ||
 		skip "Need MDS version at least 2.6.94"
 	check_swap_layouts_support
+	check_swap_layout_no_dom $DIR
 	[ -z "$(which getfattr 2>/dev/null)" ] &&
 		skip_env "no getfattr command"
 
@@ -16350,11 +17227,32 @@ 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
 
-	verify_jobstats "touch $DIR/$tfile" $SINGLEMDS
+	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 -s).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
+	fi
 }
 run_test 205a "Verify job stats"
 
@@ -16362,7 +17260,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" &&
@@ -16373,6 +17273,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
@@ -16479,6 +17390,8 @@ test_209() {
 	sync; sleep 5; sync;
 
 	echo 3 > /proc/sys/vm/drop_caches
+	[ -f /sys/kernel/slab/ptlrpc_cache/shrink ] &&
+		echo 1 > /sys/kernel/slab/ptlrpc_cache/shrink
 	req_before=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
 
 	# open/close 500 times
@@ -16487,6 +17400,8 @@ test_209() {
 	done
 
 	echo 3 > /proc/sys/vm/drop_caches
+	[ -f /sys/kernel/slab/ptlrpc_cache/shrink ] &&
+		echo 1 > /sys/kernel/slab/ptlrpc_cache/shrink
 	req_after=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
 
 	echo "before: $req_before, after: $req_after"
@@ -17080,6 +17995,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() {
@@ -17930,11 +18873,12 @@ test_230o() {
 		skip "Need MDS version at least 2.13.52"
 
 	local mdts=$(comma_list $(mdts_nodes))
-
+	local timeout=100
 	local restripe_status
 	local delta
 	local i
-	local j
+
+	[[ $mds1_FSTYPE == zfs ]] && timeout=300
 
 	# in case "crush" hash type is not set
 	do_nodes $mdts "$LCTL set_param lod.*.mdt_hash=crush"
@@ -17952,18 +18896,18 @@ test_230o() {
 		error "create dirs under remote dir failed $i"
 
 	for i in $(seq 2 $MDSCOUNT); do
-		do_nodes $mdts "$LCTL set_param mdt.*.md_stats=clear > /dev/null"
+		do_nodes $mdts "$LCTL set_param mdt.*.md_stats=clear >/dev/null"
 		$LFS setdirstripe -c $i $DIR/$tdir ||
 			error "split -c $i $tdir failed"
 		wait_update $HOSTNAME \
-			"$LFS getdirstripe -H $DIR/$tdir" "crush" 100 ||
+			"$LFS getdirstripe -H $DIR/$tdir" "crush" $timeout ||
 			error "dir split not finished"
 		delta=$(do_nodes $mdts "lctl get_param -n mdt.*MDT*.md_stats" |
 			awk '/migrate/ {sum += $2} END { print sum }')
-		echo "$delta files migrated when dir split from $((i - 1)) to $i stripes"
+		echo "$delta migrated when dir split $((i - 1)) to $i stripes"
 		# delta is around total_files/stripe_count
-		[ $delta -lt $((200 /(i - 1))) ] ||
-			error "$delta files migrated"
+		(( $delta < 200 / (i - 1) + 4 )) ||
+			error "$delta files migrated >= $((200 / (i - 1) + 4))"
 	done
 }
 run_test 230o "dir split"
@@ -17974,11 +18918,12 @@ test_230p() {
 		skip "Need MDS version at least 2.13.52"
 
 	local mdts=$(comma_list $(mdts_nodes))
-
+	local timeout=100
 	local restripe_status
 	local delta
 	local i
-	local j
+
+	[[ $mds1_FSTYPE == zfs ]] && timeout=300
 
 	do_nodes $mdts "$LCTL set_param lod.*.mdt_hash=crush"
 
@@ -17997,19 +18942,19 @@ test_230p() {
 	for i in $(seq $((MDSCOUNT - 1)) -1 1); do
 		local mdt_hash="crush"
 
-		do_nodes $mdts "$LCTL set_param mdt.*.md_stats=clear > /dev/null"
+		do_nodes $mdts "$LCTL set_param mdt.*.md_stats=clear >/dev/null"
 		$LFS setdirstripe -c $i $DIR/$tdir ||
 			error "split -c $i $tdir failed"
 		[ $i -eq 1 ] && mdt_hash="none"
 		wait_update $HOSTNAME \
-			"$LFS getdirstripe -H $DIR/$tdir" $mdt_hash 100 ||
+			"$LFS getdirstripe -H $DIR/$tdir" $mdt_hash $timeout ||
 			error "dir merge not finished"
 		delta=$(do_nodes $mdts "lctl get_param -n mdt.*MDT*.md_stats" |
 			awk '/migrate/ {sum += $2} END { print sum }')
-		echo "$delta files migrated when dir merge from $((i + 1)) to $i stripes"
+		echo "$delta migrated when dir merge $((i + 1)) to $i stripes"
 		# delta is around total_files/stripe_count
-		[ $delta -lt $((200 / i)) ] ||
-			error "$delta files migrated"
+		(( $delta < 200 / i + 4 )) ||
+			error "$delta files migrated >= $((200 / i + 4))"
 	done
 }
 run_test 230p "dir merge"
@@ -18030,6 +18975,10 @@ test_230q() {
 	local stripe_count=0
 	local stripe_index
 	local nr_files
+	local create
+
+	# 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"
@@ -18045,11 +18994,12 @@ test_230q() {
 	$LFS mkdir -i -1 -c 1 $DIR/$tdir || error "mkdir $tdir failed"
 	stripe_index=$($LFS getdirstripe -i $DIR/$tdir)
 
+	create=$((threshold * 3 / 2))
 	while [ $stripe_count -lt $MDSCOUNT ]; do
-		createmany -m $DIR/$tdir/f $total $((threshold * 3 / 2)) ||
+		createmany -m $DIR/$tdir/f $total $create ||
 			error "create sub files failed"
 		stat $DIR/$tdir > /dev/null
-		total=$((total + threshold * 3 / 2))
+		total=$((total + create))
 		stripe_count=$((stripe_count + delta))
 		[ $stripe_count -gt $MDSCOUNT ] && stripe_count=$MDSCOUNT
 
@@ -18061,19 +19011,54 @@ test_230q() {
 			"$LFS getdirstripe -H $DIR/$tdir" "crush" 200 ||
 			error "stripe hash $($LFS getdirstripe -H $DIR/$tdir) != crush"
 
-		nr_files=$($LFS getstripe -m $DIR/$tdir/* |
-			   grep -w $stripe_index | wc -l)
-		echo "$nr_files files on MDT$stripe_index after split"
-		[ $nr_files -lt $((total / (stripe_count - 1))) ] ||
+		nr_files=$($LFS find -m 1 $DIR/$tdir | grep -c -w $stripe_index)
+		echo "$nr_files/$total files on MDT$stripe_index after split"
+		# allow 10% margin of imbalance with crush hash
+		(( $nr_files <= $total / $stripe_count + $create / 10)) ||
 			error "$nr_files files on MDT$stripe_index after split"
 
-		nr_files=$(ls $DIR/$tdir | wc -w)
+		nr_files=$($LFS find -type f $DIR/$tdir | wc -l)
 		[ $nr_files -eq $total ] ||
 			error "total sub files $nr_files != $total"
 	done
 }
 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
@@ -18535,7 +19520,7 @@ test_247c() {
 	$LFS fid2path $submount $fid && error "fid2path should fail"
 	cleanup_247 $submount
 }
-run_test 247c "running fid2path outside root"
+run_test 247c "running fid2path outside subdirectory root"
 
 test_247d() {
 	lctl get_param -n mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
@@ -18548,11 +19533,28 @@ test_247d() {
 	FILESET="$FILESET/$tdir" mount_client $submount ||
 		error "mount $submount failed"
 	trap "cleanup_247 $submount" EXIT
-	local fid=$($LFS path2fid $submount/dir1)
-	$LFS fid2path $submount $fid || error "fid2path should succeed"
+
+	local td=$submount/dir1
+	local fid=$($LFS path2fid $td)
+	[ -z "$fid" ] && error "path2fid unable to get $td FID"
+
+	# check that we get the same pathname back
+	local rootpath
+	local found
+	for rootpath in "$submount" "$submount///" "$submount/dir1"; do
+		echo "$rootpath $fid"
+		found=$($LFS fid2path $rootpath "$fid")
+		[ -n "found" ] || error "fid2path should succeed"
+		[ "$found" == "$td" ] || error "fid2path $found != $td"
+	done
+	# check wrong root path format
+	rootpath=$submount"_wrong"
+	found=$($LFS fid2path $rootpath "$fid")
+	[ -z "$found" ] || error "fid2path should fail ($rootpath != $submount)"
+
 	cleanup_247 $submount
 }
-run_test 247d "running fid2path inside root"
+run_test 247d "running fid2path inside subdirectory root"
 
 # LU-8037
 test_247e() {
@@ -18574,6 +19576,8 @@ test_247f() {
 	[ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
 	[ $MDS1_VERSION -lt $(version_code 2.13.52) ] &&
 		skip "Need at least version 2.13.52"
+	[ $CLIENT_VERSION -lt $(version_code 2.14.50) ] &&
+		skip "Need at least version 2.14.50"
 	lctl get_param -n mdc.$FSNAME-MDT0000*.import |
 		grep -q subtree ||
 		skip "Fileset feature is not supported"
@@ -18582,26 +19586,78 @@ test_247f() {
 	$LFS mkdir -i $((MDSCOUNT - 1)) $DIR/$tdir/remote ||
 		error "mkdir remote failed"
 	mkdir $DIR/$tdir/remote/subdir || error "mkdir remote/subdir failed"
-	$LFS mkdir -c $MDSCOUNT $DIR/$tdir/striped ||
+	$LFS mkdir -i 0 -c $MDSCOUNT $DIR/$tdir/striped ||
 		error "mkdir striped failed"
 	mkdir $DIR/$tdir/striped/subdir || error "mkdir striped/subdir failed"
 
 	local submount=${MOUNT}_$tdir
 
 	mkdir -p $submount || error "mkdir $submount failed"
+	stack_trap "rmdir $submount"
 
 	local dir
+	local stat
 	local fileset=$FILESET
+	local mdts=$(comma_list $(mdts_nodes))
 
-	for dir in $tdir/remote $tdir/remote/subdir \
-		   $tdir/striped $tdir/striped/subdir $tdir/striped/. ; do
+	stat=$(do_facet mds1 $LCTL get_param -n \
+		mdt.*MDT0000.enable_remote_subdir_mount)
+	stack_trap "do_nodes $mdts $LCTL set_param \
+		mdt.*.enable_remote_subdir_mount=$stat"
+
+	do_nodes $mdts "$LCTL set_param mdt.*.enable_remote_subdir_mount=0"
+	stack_trap "umount_client $submount"
+	FILESET="$fileset/$tdir/remote" mount_client $submount &&
+		error "mount remote dir $dir should fail"
+
+	for dir in $tdir/remote/subdir $tdir/striped $tdir/striped/subdir \
+		$tdir/striped/. ; do
 		FILESET="$fileset/$dir" mount_client $submount ||
 			error "mount $dir failed"
 		umount_client $submount
 	done
+
+	do_nodes $mdts "$LCTL set_param mdt.*.enable_remote_subdir_mount=1"
+	FILESET="$fileset/$tdir/remote" mount_client $submount ||
+		error "mount $tdir/remote failed"
 }
 run_test 247f "mount striped or remote directory as fileset"
 
+test_247g() {
+	[ $MDSCOUNT -lt 4 ] && skip_env "needs >= 4 MDTs"
+	[ $CLIENT_VERSION -lt $(version_code 2.14.50) ] &&
+		skip "Need at least version 2.14.50"
+
+	$LFS mkdir -i 0 -c 4 -H fnv_1a_64 $DIR/$tdir ||
+		error "mkdir $tdir failed"
+	touch $DIR/$tdir/$tfile || error "touch $tfile failed"
+
+	local submount=${MOUNT}_$tdir
+
+	mkdir -p $submount || error "mkdir $submount failed"
+	stack_trap "rmdir $submount"
+
+	FILESET="$fileset/$tdir" mount_client $submount ||
+		error "mount $dir failed"
+	stack_trap "umount $submount"
+
+	local mdts=$(comma_list $(mdts_nodes))
+
+	local nrpcs
+
+	stat $submount > /dev/null
+	cancel_lru_locks $MDC
+	stat $submount > /dev/null
+	stat $submount/$tfile > /dev/null
+	do_nodes $mdts "$LCTL set_param mdt.*.md_stats=clear > /dev/null"
+	stat $submount/$tfile > /dev/null
+	nrpcs=$(do_nodes $mdts "lctl get_param -n mdt.*.md_stats" |
+		awk '/getattr/ {sum += $2} END {print sum}')
+
+	[ -z "$nrpcs" ] || error "$nrpcs extra getattr sent"
+}
+run_test 247g "mount striped directory as fileset caches ROOT lookup lock"
+
 test_248a() {
 	local fast_read_sav=$($LCTL get_param -n llite.*.fast_read 2>/dev/null)
 	[ -z "$fast_read_sav" ] && skip "no fast read support"
@@ -19043,7 +20099,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%"
 }
@@ -19202,6 +20258,9 @@ test_255c() {
 	[ $OST1_VERSION -lt $(version_code 2.10.50) ] &&
 		skip "lustre < 2.10.50 does not support lockahead"
 
+	local ost1_imp=$(get_osc_import_name client ost1)
+	local imp_name=$($LCTL list_param osc.$ost1_imp | head -n1 |
+			 cut -d'.' -f2)
 	local count
 	local new_count
 	local difference
@@ -19249,7 +20308,7 @@ test_255c() {
 		cancel_lru_locks osc
 
 		count=$($LCTL get_param -n \
-		       ldlm.namespaces.$FSNAME-OST0000*osc-[-0-9a-f]*.lock_unused_count)
+		       ldlm.namespaces.$imp_name.lock_unused_count)
 
 		lockahead_test -d $DIR/$tdir -t $i -f $tfile
 		rc=$?
@@ -19258,7 +20317,7 @@ test_255c() {
 		fi
 
 		new_count=$($LCTL get_param -n \
-		       ldlm.namespaces.$FSNAME-OST0000*osc-[-0-9a-f]*.lock_unused_count)
+		       ldlm.namespaces.$imp_name.lock_unused_count)
 		difference="$((new_count - count))"
 
 		# Test 15 output is divided by 100 to map down to valid return
@@ -20342,6 +21401,17 @@ test_273a() {
 }
 run_test 273a "DoM: layout swapping should fail with DOM"
 
+test_273b() {
+	mkdir -p $DIR/$tdir
+	$LFS setstripe -E 1M -L mdt -E -1 -c -1 $DIR/$tdir
+
+#define OBD_FAIL_MDS_COMMITRW_DELAY      0x16b
+	do_facet mds1 $LCTL set_param fail_loc=0x8000016b fail_val=2
+
+	$MULTIOP $DIR/$tdir/$tfile Ouw2097152c
+}
+run_test 273b "DoM: race writeback and object destroy"
+
 test_275() {
 	remote_ost_nodsh && skip "remote OST with nodsh"
 	[ $OST1_VERSION -lt $(version_code 2.10.57) ] &&
@@ -20451,6 +21521,9 @@ test_280() {
 	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"
@@ -20737,7 +21810,7 @@ test_300_check_default_striped_dir()
 
 	echo "checking $dirname $default_count $default_index"
 	$LFS setdirstripe -D -c $default_count -i $default_index \
-				-t all_char $DIR/$tdir/$dirname ||
+				-H all_char $DIR/$tdir/$dirname ||
 		error "set default stripe on striped dir error"
 	stripe_count=$($LFS getdirstripe -D -c $DIR/$tdir/$dirname)
 	[ $stripe_count -eq $default_count ] ||
@@ -20754,8 +21827,9 @@ test_300_check_default_striped_dir()
 	unlinkmany $DIR/$tdir/$dirname/f- 10	|| error "unlink files failed"
 	for dir in $(find $DIR/$tdir/$dirname/*); do
 		stripe_count=$($LFS getdirstripe -c $dir)
-		[ $stripe_count -eq $default_count ] ||
-		[ $stripe_count -eq 0 ] || [ $default_count -eq 1 ] ||
+		(( $stripe_count == $default_count )) ||
+		(( $stripe_count == $MDSCOUNT && $default_count == -1 )) ||
+		(( $stripe_count == 0 )) || (( $default_count == 1 )) ||
 		error "stripe count $default_count != $stripe_count for $dir"
 
 		stripe_index=$($LFS getdirstripe -i $dir)
@@ -20807,7 +21881,7 @@ test_300g() {
 	#check default stripe count/stripe index
 	test_300_check_default_striped_dir normal_dir $MDSCOUNT 1
 	test_300_check_default_striped_dir normal_dir 1 0
-	test_300_check_default_striped_dir normal_dir 2 1
+	test_300_check_default_striped_dir normal_dir -1 1
 	test_300_check_default_striped_dir normal_dir 2 -1
 
 	#delete default stripe information
@@ -20841,7 +21915,7 @@ test_300h() {
 
 	test_300_check_default_striped_dir striped_dir $MDSCOUNT 1
 	test_300_check_default_striped_dir striped_dir 1 0
-	test_300_check_default_striped_dir striped_dir 2 1
+	test_300_check_default_striped_dir striped_dir -1 1
 	test_300_check_default_striped_dir striped_dir 2 -1
 
 	#delete default stripe information
@@ -20881,15 +21955,17 @@ test_300i() {
 		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
@@ -21181,6 +22257,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"
@@ -21268,7 +22394,7 @@ test_311() {
 		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
@@ -21300,7 +22426,7 @@ test_311() {
 
 	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
@@ -21546,12 +22672,15 @@ test_317() {
 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 ||
@@ -21559,7 +22688,7 @@ test_318() {
 
 	$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
@@ -21567,9 +22696,9 @@ test_318() {
 		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 \
@@ -21581,7 +22710,7 @@ test_318() {
 		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 \
@@ -21615,6 +22744,10 @@ test_319() {
 run_test 319 "lost lease lock on migrate error"
 
 test_398a() { # LU-4198
+	local ost1_imp=$(get_osc_import_name client ost1)
+	local imp_name=$($LCTL list_param osc.$ost1_imp | head -n1 |
+			 cut -d'.' -f2)
+
 	$LFS setstripe -c 1 -i 0 $DIR/$tfile
 	$LCTL set_param ldlm.namespaces.*.lru_size=clear
 
@@ -21623,7 +22756,7 @@ test_398a() { # LU-4198
 
 	dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 oflag=direct conv=notrunc
 	local lock_count=$($LCTL get_param -n \
-			   ldlm.namespaces.*-OST0000-osc-ffff*.lru_size)
+			   ldlm.namespaces.$imp_name.lru_size)
 	[[ $lock_count -eq 0 ]] || error "lock should be cancelled by direct IO"
 
 	$LCTL set_param ldlm.namespaces.*-OST0000-osc-ffff*.lru_size=clear
@@ -21631,7 +22764,7 @@ test_398a() { # LU-4198
 	# no lock cached, should use lockless IO and not enqueue new lock
 	dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 oflag=direct conv=notrunc
 	lock_count=$($LCTL get_param -n \
-		     ldlm.namespaces.*-OST0000-osc-ffff*.lru_size)
+		     ldlm.namespaces.$imp_name.lru_size)
 	[[ $lock_count -eq 0 ]] || error "no lock should be held by direct IO"
 }
 run_test 398a "direct IO should cancel lock otherwise lockless"
@@ -21663,6 +22796,10 @@ test_398b() { # LU-4198
 run_test 398b "DIO and buffer IO race"
 
 test_398c() { # LU-4198
+	local ost1_imp=$(get_osc_import_name client ost1)
+	local imp_name=$($LCTL list_param osc.$ost1_imp | head -n1 |
+			 cut -d'.' -f2)
+
 	which fio || skip_env "no fio installed"
 
 	saved_debug=$($LCTL get_param -n debug)
@@ -21691,12 +22828,11 @@ test_398c() { # LU-4198
 		--filename=$DIR/$tfile
 	[ $? -eq 0 ] || error "fio write error"
 
-	[ $($LCTL get_param -n \
-	 ldlm.namespaces.${FSNAME}-OST0000-osc-ffff*.lock_count) -eq 0 ] ||
+	[ $($LCTL get_param -n ldlm.namespaces.$imp_name.lock_count) -eq 0 ] ||
 		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"
@@ -21708,11 +22844,44 @@ test_398c() { # LU-4198
 		--filename=$DIR/$tfile
 	[ $? -eq 0 ] || error "fio mixed read write error"
 
+	echo "AIO with large block size ${size}M"
+	fio --name=rand-rw --rw=randrw --bs=${size}M --direct=1 \
+		--numjobs=1 --fallocate=none --ioengine=libaio \
+		--iodepth=16 --allow_file_create=0 --size=${size}M \
+		--filename=$DIR/$tfile
+	[ $? -eq 0 ] || error "fio large block size failed"
+
 	rm -rf $DIR/$tfile
 	$LCTL set_param debug="$saved_debug"
 }
 run_test 398c "run fio to test AIO"
 
+test_398d() { #  LU-13846
+	test -f aiocp || skip_env "no aiocp installed"
+	local aio_file=$DIR/aio_file
+
+	$LFS setstripe -c -1 -S 1M $DIR/$tfile $aio_file
+
+	dd if=/dev/urandom of=$DIR/$tfile bs=1M count=64
+	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"
+
+test_398e() {
+	dd if=/dev/zero of=$DIR/$tfile bs=1234 count=1
+	touch $DIR/$tfile.new
+	dd if=$DIR/$tfile of=$DIR/$tfile.new bs=1M count=1 oflag=direct
+}
+run_test 398e "O_Direct open cleared by fcntl doesn't cause hang"
+
 test_fake_rw() {
 	local read_write=$1
 	if [ "$read_write" = "write" ]; then
@@ -21730,12 +22899,12 @@ test_fake_rw() {
 	$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
 
 	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)
@@ -21877,70 +23046,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
 
-	$LCTL set_param foo=bar jobid_var=$tmp bar=baz &&
+	local save=$($LCTL get_param -n $testname)
+
+	$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 '='"
 
@@ -22027,6 +23218,7 @@ test_405() {
 			skip "Layout swap lock is not supported"
 
 	check_swap_layouts_support
+	check_swap_layout_no_dom $DIR
 
 	test_mkdir $DIR/$tdir
 	swap_lock_test -d $DIR/$tdir ||
@@ -22177,6 +23369,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
@@ -22896,26 +24090,24 @@ test_421f() {
 	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"
 
@@ -23024,6 +24216,354 @@ 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"
+
+test_427() {
+	[ $MDSCOUNT -ge 2 ] || skip "needs >= 2 MDTs"
+	(( $MDS1_VERSION >= $(version_code 2.12.4) )) ||
+		skip "Need MDS version at least 2.12.4"
+	local log
+
+	mkdir $DIR/$tdir
+	mkdir $DIR/$tdir/1
+	mkdir $DIR/$tdir/2
+	test_mkdir -c $MDSCOUNT -i 1 $DIR/$tdir/1/dir
+	test_mkdir -c $MDSCOUNT -i 1 $DIR/$tdir/2/dir2
+
+	$LFS getdirstripe $DIR/$tdir/1/dir
+
+	#first setfattr for creating updatelog
+	setfattr -n user.attr0 -v "some text" $DIR/$tdir/1/dir
+
+#define OBD_FAIL_OUT_OBJECT_MISS        0x1708
+	do_nodes $(comma_list $(mdts_nodes)) $LCTL set_param fail_loc=0x80001708
+	setfattr -n user.attr1 -v "some text" $DIR/$tdir/1/dir &
+	setfattr -n user.attr2 -v "another attr"  $DIR/$tdir/2/dir2 &
+
+	sleep 2
+	fail mds2
+	wait_recovery_complete mds2 $((2*TIMEOUT))
+
+	log=$(do_facet mds1 dmesg | tac | sed "/${TESTNAME//_/ }/,$ d")
+	echo $log | grep "get update log failed" &&
+		error "update log corruption is detected" || true
+}
+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"
+
+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"
+	rm $file
+
+	# full component followed by non-inited one
+	$LFS setstripe -E 1M -c2 -E eof $file
+	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
+	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"
+
+test_431() { # LU-14187
+	local file=$DIR/$tdir/$tfile
+
+	mkdir -p $DIR/$tdir
+	$LFS setstripe -c 1 -i 0 $file || error "lfs setstripe failed"
+	dd if=/dev/urandom of=$file bs=4k count=1
+	dd if=/dev/urandom of=$file bs=4k count=1 seek=10 conv=notrunc
+	dd if=/dev/urandom of=$file bs=4k count=1 seek=12 conv=notrunc
+	#define OBD_FAIL_OST_RESTART_IO	0x251
+	do_facet ost1 "$LCTL set_param fail_loc=0x251"
+	$LFS setstripe -c 1 -i 0 $file.0 || error "lfs setstripe failed"
+	cp $file $file.0
+	cancel_lru_locks
+	sync_all_data
+	echo 3 > /proc/sys/vm/drop_caches
+	diff  $file $file.0 || error "data diff"
+}
+run_test 431 "Restart transaction for IO"
+
 prep_801() {
 	[[ $MDS1_VERSION -lt $(version_code 2.9.55) ]] ||
 	[[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
@@ -23332,7 +24872,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"
@@ -23380,7 +24920,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"
@@ -23779,8 +25351,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
@@ -23802,8 +25372,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
@@ -24011,11 +25579,13 @@ 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"
+	local ost1_imp=$(get_osc_import_name client ost1)
+	local imp_name=$($LCTL list_param osc.$ost1_imp | head -n1 |
+			 cut -d'.' -f2)
 
 	$LFS setstripe -c 1 -i 0 $DIR/$tfile
 	# 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
@@ -24024,12 +25594,12 @@ test_816() {
 	local before
 	local now
 	before=$($LCTL get_param -n \
-		 ldlm.namespaces.$FSNAME-OST0000-osc-[^M]*.lru_size)
+		 ldlm.namespaces.$imp_name.lru_size)
 
 	wait_osc_import_state client ost1 IDLE
 	dd if=/dev/null of=$DIR/$tfile bs=1k count=1 conv=sync
 	now=$($LCTL get_param -n \
-	      ldlm.namespaces.$FSNAME-OST0000-osc-[^M]*.lru_size)
+	      ldlm.namespaces.$imp_name.lru_size)
 	[ $before == $now ] || error "lru_size changed $before != $now"
 }
 run_test 816 "do not reset lru_resize on idle reconnect"
@@ -24122,11 +25692,49 @@ test_820() {
 	# open intent should update default EA size
 	# see mdc_update_max_ea_from_body()
 	# notice this is the very first RPC to MDS2
-	cp /etc/services $DIR/$tdir/mds2 ||
-		error "Failed to copy files to mds$n"
+	out=$(cp /etc/services $DIR/$tdir/mds2 2>&1)
+	ret=$?
+	echo $out
+	# With SSK, this situation can lead to -EPERM being returned.
+	# In that case, simply retry.
+	if [ $ret -ne 0 ] && $SHARED_KEY; then
+		if echo "$out" | grep -q "not permitted"; then
+			cp /etc/services $DIR/$tdir/mds2
+			ret=$?
+		fi
+	fi
+	[ $ret -eq 0 ] || error "Failed to copy files to mds$n"
 }
 run_test 820 "update max EA from open intent"
 
+test_822() {
+	local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+
+	save_lustre_params mds1 \
+		"osp.$FSNAME-OST*-osc-MDT0000.max_create_count" > $p
+	do_facet $SINGLEMDS "$LCTL set_param -n \
+			osp.$FSNAME-OST*MDT0000.max_create_count=0"
+	do_facet $SINGLEMDS "$LCTL set_param -n \
+			osp.$FSNAME-OST0000*MDT0000.max_create_count=20000"
+
+	# wait for statfs update to clear OS_STATFS_NOPRECREATE
+	local maxage=$(do_facet mds1 $LCTL get_param -n \
+		       osp.$FSNAME-OST0000*MDT0000.maxage)
+	sleep $((maxage + 1))
+
+	#define OBD_FAIL_NET_ERROR_RPC          0x532
+	do_facet mds1 "$LCTL set_param fail_loc=0x80000532 fail_val=5"
+
+	stack_trap "restore_lustre_params < $p; rm $p"
+
+	local count=$(do_facet $SINGLEMDS "lctl get_param -n \
+		      osp.$FSNAME-OST0000*MDT0000.create_count")
+	for i in $(seq 1 $count); do
+		touch $DIR/$tfile.${i} || error "touch failed"
+	done
+}
+run_test 822 "test precreate failure"
+
 #
 # tests that do cleanup/setup should be run at the end
 #