X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Ftests%2Fsanity.sh;h=3039059c0a0b4f5c558321af278a679e8f3d3d2b;hp=0f3c56aa47acd40e2468d0bf97b47c47d5636c0d;hb=2f50e9a386f2765a41572965c4bf5d40e2a7f3c9;hpb=d775f9ae37975c853984b67f6d1a21e6ec8a8c3d

diff --git a/lustre/tests/sanity.sh b/lustre/tests/sanity.sh
index 0f3c56a..3039059 100755
--- a/lustre/tests/sanity.sh
+++ b/lustre/tests/sanity.sh
@@ -59,8 +59,8 @@ fi
 if [[ $(uname -m) = aarch64 ]]; then
 	# bug number:	 LU-11596
 	ALWAYS_EXCEPT+=" $GRANT_CHECK_LIST"
-	# bug number:	 LU-11671 LU-11667
-	ALWAYS_EXCEPT+=" 45	  317"
+	# bug number:	 LU-11671
+	ALWAYS_EXCEPT+=" 45"
 	# bug number:	 LU-14067 LU-14067
 	ALWAYS_EXCEPT+=" 400a	  400b"
 fi
@@ -77,8 +77,8 @@ if (( $LINUX_VERSION_CODE >= $(version_code 4.18.0) &&
 	ALWAYS_EXCEPT+=" 411"
 fi
 
-#                                  5              12     8   12  (min)"
-[ "$SLOW" = "no" ] && EXCEPT_SLOW="27m 60i 64b 68 71 115 135 136 300o"
+#                                  5              12     8   12  15   (min)"
+[ "$SLOW" = "no" ] && EXCEPT_SLOW="27m 60i 64b 68 71 115 135 136 230d 300o"
 
 if [ "$mds1_FSTYPE" = "zfs" ]; then
 	# bug number for skipped test:
@@ -92,6 +92,8 @@ if [ "$ost1_FSTYPE" = "zfs" ]; then
 	ALWAYS_EXCEPT+="                130a 130b 130c 130d 130e 130f 130g"
 fi
 
+proc_regexp="/{proc,sys}/{fs,sys,kernel/debug}/{lustre,lnet}/"
+
 # Get the SLES distro version
 #
 # Returns a version string that should only be used in comparing
@@ -251,6 +253,35 @@ test_0d() { # LU-3397
 }
 run_test 0d "check export proc ============================="
 
+test_0e() { # LU-13417
+	(( $MDSCOUNT > 1 )) ||
+		skip "We need at least 2 MDTs for this test"
+
+	(( $MDS1_VERSION >= $(version_code 2.14.51) )) ||
+		skip "Need server version at least 2.14.51"
+
+	local default_lmv_count=$($LFS getdirstripe -D -c $MOUNT)
+	local default_lmv_index=$($LFS getdirstripe -D -i $MOUNT)
+
+	[ $default_lmv_count -eq 1 ] ||
+		error "$MOUNT default stripe count $default_lmv_count"
+
+	[ $default_lmv_index -eq -1 ] ||
+		error "$MOUNT default stripe index $default_lmv_index"
+
+	mkdir $MOUNT/$tdir.1 || error "mkdir $MOUNT/$tdir.1 failed"
+	mkdir $MOUNT/$tdir.2 || error "mkdir $MOUNT/$tdir.2 failed"
+
+	local mdt_index1=$($LFS getdirstripe -i $MOUNT/$tdir.1)
+	local mdt_index2=$($LFS getdirstripe -i $MOUNT/$tdir.2)
+
+	[ $mdt_index1 -eq $mdt_index2 ] &&
+		error "directories are on the same MDT $mdt_index1=$mdt_index2"
+
+	rmdir $MOUNT/$tdir.1 $MOUNT/$tdir.2
+}
+run_test 0e "Enable DNE MDT balancing for mkdir in the ROOT"
+
 test_1() {
 	test_mkdir $DIR/$tdir
 	test_mkdir $DIR/$tdir/d2
@@ -1829,52 +1860,6 @@ reset_enospc() {
 	wait_update_facet $SINGLEMDS "$get_prealloc" "" $delay
 }
 
-__exhaust_precreations() {
-	local OSTIDX=$1
-	local FAILLOC=$2
-	local FAILIDX=${3:-$OSTIDX}
-	local ofacet=ost$((OSTIDX + 1))
-
-	mkdir_on_mdt0 $DIR/$tdir
-	local mdtidx=$($LFS getstripe -m $DIR/$tdir)
-	local mfacet=mds$((mdtidx + 1))
-	echo OSTIDX=$OSTIDX MDTIDX=$mdtidx
-
-	local OST=$(ostname_from_index $OSTIDX)
-
-	# on the mdt's osc
-	local mdtosc_proc1=$(get_mdtosc_proc_path $mfacet $OST)
-	local last_id=$(do_facet $mfacet lctl get_param -n \
-			osp.$mdtosc_proc1.prealloc_last_id)
-	local next_id=$(do_facet $mfacet lctl get_param -n \
-			osp.$mdtosc_proc1.prealloc_next_id)
-
-	local mdtosc_proc2=$(get_mdtosc_proc_path $mfacet)
-	do_facet $mfacet lctl get_param osp.$mdtosc_proc2.prealloc*
-
-	test_mkdir -p $DIR/$tdir/${OST}
-	$LFS setstripe -i $OSTIDX -c 1 $DIR/$tdir/${OST}
-#define OBD_FAIL_OST_ENOSPC              0x215
-	do_facet $ofacet lctl set_param fail_val=$FAILIDX fail_loc=0x215
-	echo "Creating to objid $last_id on ost $OST..."
-	createmany -o $DIR/$tdir/${OST}/f $next_id $((last_id - next_id + 2))
-	do_facet $mfacet lctl get_param osp.$mdtosc_proc2.prealloc*
-	do_facet $ofacet lctl set_param fail_loc=$FAILLOC
-}
-
-exhaust_precreations() {
-	__exhaust_precreations $1 $2 $3
-	sleep_maxage
-}
-
-exhaust_all_precreations() {
-	local i
-	for (( i=0; i < OSTCOUNT; i++ )) ; do
-		__exhaust_precreations $i $1 -1
-	done
-	sleep_maxage
-}
-
 test_27n() {
 	[[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
@@ -2985,11 +2970,23 @@ test_27M() {
 	test_mkdir $DIR/$tdir
 
 	# Set default striping on directory
-	$LFS setstripe -C 4 $DIR/$tdir
+	local setcount=4
+	local stripe_opt
+
+	# if we run against a 2.12 server which lacks overstring support
+	# then the connect_flag will not report overstriping, even if client
+	# is 2.14+
+	if [[ $($LCTL get_param mdc.*.connect_flags) =~ overstriping ]]; then
+		stripe_opt="-C $setcount"
+	elif (( $OSTCOUNT >= $setcount )); then
+		stripe_opt="-c $setcount"
+	else
+		skip "server does not support overstriping"
+	fi
+	$LFS setstripe $stripe_opt $DIR/$tdir
 
 	echo 1 > $DIR/$tdir/${tfile}.1
 	local count=$($LFS getstripe -c $DIR/$tdir/${tfile}.1)
-	local setcount=4
 	[ $count -eq $setcount ] ||
 		error "(1) stripe count $count, should be $setcount"
 
@@ -3055,11 +3052,11 @@ test_27M() {
 	# Clean up DOM layout
 	$LFS setstripe -d $DIR/$tdir
 
+	save_layout_restore_at_exit $MOUNT
 	# Now test that append striping works when layout is from root
 	$LFS setstripe -c 2 $MOUNT
 	# Make a special directory for this
 	mkdir $DIR/${tdir}/${tdir}.2
-	stack_trap "$LFS setstripe -d $MOUNT" EXIT
 
 	# Verify for normal file
 	setcount=2
@@ -3352,6 +3349,36 @@ test_27Q() {
 }
 run_test 27Q "llapi_file_get_stripe() works on symlinks"
 
+test_27R() {
+	(( $MDS1_VERSION >= $(version_code 2.14.55) )) ||
+		skip "need MDS 2.14.55 or later"
+	(( $OSTCOUNT >= 2 )) || skip_env "needs at least 2 OSTs"
+
+	local testdir="$DIR/$tdir"
+	test_mkdir -p $testdir
+	stack_trap "rm -rf $testdir"
+	$LFS setstripe -c -1 $testdir || error "setstripe failed"
+
+	local f1="$testdir/f1"
+	touch $f1 || error "failed to touch $f1"
+	local count=$($LFS getstripe -c $f1)
+	(( $count == $OSTCOUNT )) || error "wrong stripe count"
+
+	do_facet $SINGLEMDS $LCTL set_param lod.*.max_stripecount=-1
+	(( $? == 34 )) || error "setting max_stripecount to -1 should fail and return ERANGE"
+
+	local maxcount=$(($OSTCOUNT - 1))
+	local mdts=$(comma_list $(mdts_nodes))
+	do_nodes $mdts $LCTL set_param lod.*.max_stripecount=$maxcount
+	stack_trap "do_nodes $mdts $LCTL set_param lod.*.max_stripecount=0"
+
+	local f2="$testdir/f2"
+	touch $f2 || error "failed to touch $f2"
+	local count=$($LFS getstripe -c $f2)
+	(( $count == $maxcount )) || error "wrong stripe count"
+}
+run_test 27R "test max_stripecount limitation when stripe count is set to -1"
+
 # createtest also checks that device nodes are created and
 # then visible correctly (#2091)
 test_28() { # bug 2091
@@ -3363,6 +3390,11 @@ run_test 28 "create/mknod/mkdir with bad file types ============"
 test_29() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 
+	[ $MDS1_VERSION -ge $(version_code 2.14.51) ] && {
+		disable_opencache
+		stack_trap "restore_opencache"
+	}
+
 	sync; sleep 1; sync # flush out any dirty pages from previous tests
 	cancel_lru_locks
 	test_mkdir $DIR/d29
@@ -3678,6 +3710,28 @@ test_31q() {
 }
 run_test 31q "create striped directory on specific MDTs"
 
+#LU-14949
+test_31r() {
+	touch $DIR/$tfile.target
+	touch $DIR/$tfile.source
+
+	#OBD_FAIL_LLITE_OPEN_DELAY 0x1419
+	$LCTL set_param fail_loc=0x1419 fail_val=3
+	cat $DIR/$tfile.target &
+	CATPID=$!
+
+	# Guarantee open is waiting before we get here
+	sleep 1
+	mv $DIR/$tfile.source $DIR/$tfile.target
+
+	wait $CATPID
+	RC=$?
+	if [[ $RC -ne 0 ]]; then
+		error "open with cat failed, rc=$RC"
+	fi
+}
+run_test 31r "open-rename(replace) race"
+
 cleanup_test32_mount() {
 	local rc=0
 	trap 0
@@ -5559,7 +5613,7 @@ test_51b() {
 	# cleanup the directory
 	rm -fr $dir
 
-	test_mkdir -c1 $dir
+	mkdir_on_mdt -i $((RANDOM % MDSCOUNT)) $dir
 
 	$LFS df
 	$LFS df -i
@@ -5617,38 +5671,51 @@ run_test 51b "exceed 64k subdirectory nlink limit on create, verify unlink"
 test_51d() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 	[[ $OSTCOUNT -lt 3 ]] && skip_env "needs >= 3 OSTs"
+	local qos_old
 
 	test_mkdir $DIR/$tdir
+	$LFS setstripe -c $OSTCOUNT $DIR/$tdir
+
+	qos_old=$(do_facet mds1 \
+		"$LCTL get_param -n lod.$FSNAME-*.qos_threshold_rr" | head -n 1)
+	do_nodes $(comma_list $(mdts_nodes)) \
+		"$LCTL set_param lod.$FSNAME-*.qos_threshold_rr=100"
+	stack_trap "do_nodes $(comma_list $(mdts_nodes)) \
+		'$LCTL set_param lod.$FSNAME-*.qos_threshold_rr=${qos_old%%%}'"
+
 	createmany -o $DIR/$tdir/t- 1000
 	$LFS getstripe $DIR/$tdir > $TMP/$tfile
-	for N in $(seq 0 $((OSTCOUNT - 1))); do
-		OBJS[$N]=$(awk -vobjs=0 '($1 == '$N') { objs += 1 } \
-			END { printf("%0.0f", objs) }' $TMP/$tfile)
-		OBJS0[$N]=$(grep -A 1 idx $TMP/$tfile | awk -vobjs=0 \
-			'($1 == '$N') { objs += 1 } \
-			END { printf("%0.0f", objs) }')
-		log "OST$N has ${OBJS[$N]} objects, ${OBJS0[$N]} are index 0"
+	for ((n = 0; n < $OSTCOUNT; n++)); do
+		objs[$n]=$(awk -vobjs=0 '($1 == '$n') { objs += 1 } \
+			   END { printf("%0.0f", objs) }' $TMP/$tfile)
+		objs0[$n]=$(grep -A 1 idx $TMP/$tfile | awk -vobjs=0 \
+			    '($1 == '$n') { objs += 1 } \
+			    END { printf("%0.0f", objs) }')
+		log "OST$n has ${objs[$n]} objects, ${objs0[$n]} are index 0"
 	done
 	unlinkmany $DIR/$tdir/t- 1000
 
-	NLAST=0
-	for N in $(seq 1 $((OSTCOUNT - 1))); do
-		[[ ${OBJS[$N]} -lt $((${OBJS[$NLAST]} - 20)) ]] &&
-			error "OST $N has less objects vs OST $NLAST" \
-			      " (${OBJS[$N]} < ${OBJS[$NLAST]}"
-		[[ ${OBJS[$N]} -gt $((${OBJS[$NLAST]} + 20)) ]] &&
-			error "OST $N has less objects vs OST $NLAST" \
-			      " (${OBJS[$N]} < ${OBJS[$NLAST]}"
-
-		[[ ${OBJS0[$N]} -lt $((${OBJS0[$NLAST]} - 20)) ]] &&
-			error "OST $N has less #0 objects vs OST $NLAST" \
-			      " (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
-		[[ ${OBJS0[$N]} -gt $((${OBJS0[$NLAST]} + 20)) ]] &&
-			error "OST $N has less #0 objects vs OST $NLAST" \
-			      " (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
-		NLAST=$N
+	nlast=0
+	for ((n = 0; n < $OSTCOUNT; n++)); do
+		(( ${objs[$n]} > ${objs[$nlast]} * 4 / 5 )) ||
+			{ $LFS df && $LFS df -i &&
+			error "OST $n has fewer objects vs. OST $nlast" \
+			      " (${objs[$n]} < ${objs[$nlast]}"; }
+		(( ${objs[$n]} < ${objs[$nlast]} * 5 / 4 )) ||
+			{ $LFS df && $LFS df -i &&
+			error "OST $n has fewer objects vs. OST $nlast" \
+			      " (${objs[$n]} < ${objs[$nlast]}"; }
+
+		(( ${objs0[$n]} > ${objs0[$nlast]} * 4 / 5 )) ||
+			{ $LFS df && $LFS df -i &&
+			error "OST $n has fewer #0 objects vs. OST $nlast" \
+			      " (${objs0[$n]} < ${objs0[$nlast]}"; }
+		(( ${objs0[$n]} < ${objs0[$nlast]} * 5 / 4 )) ||
+			{ $LFS df && $LFS df -i &&
+			error "OST $n has fewer #0 objects vs. OST $nlast" \
+			      " (${objs0[$n]} < ${objs0[$nlast]}"; }
+		nlast=$n
 	done
-	rm -f $TMP/$tfile
 }
 run_test 51d "check object distribution"
 
@@ -6066,6 +6133,47 @@ test_56d() {
 }
 run_test 56d "'lfs df -v' prints only configured devices"
 
+test_56e() {
+	err_enoent=2 # No such file or directory
+	err_eopnotsupp=95 # Operation not supported
+
+	enoent_mnt=/pmt1 # Invalid dentry. Path not present
+	notsup_mnt=/tmp  # Valid dentry, but Not a lustreFS
+
+	# Check for handling of path not exists
+	output=$($LFS df $enoent_mnt 2>&1)
+	ret=$?
+
+	fs=$(echo $output | awk -F: '{print $2}' | awk '{print $3}' | tr -d \')
+	[[ $fs = $enoent_mnt && $ret -eq $err_enoent ]] ||
+		error "expect failure $err_enoent, not $ret"
+
+	# Check for handling of non-Lustre FS
+	output=$($LFS df $notsup_mnt)
+	ret=$?
+
+	fs=$(echo $output | awk '{print $1}' | awk -F: '{print $2}')
+	[[ $fs = $notsup_mnt && $ret -eq $err_eopnotsupp ]] ||
+		error "expect success $err_eopnotsupp, not $ret"
+
+	# Check for multiple LustreFS argument
+	output=$($LFS df $MOUNT $MOUNT $MOUNT | grep -c "filesystem_summary:")
+	ret=$?
+
+	[[ $output -eq 3 && $ret -eq 0 ]] ||
+		error "expect success 3, not $output, rc = $ret"
+
+	# Check for correct non-Lustre FS handling among multiple
+	# LustreFS argument
+	output=$($LFS df $MOUNT $notsup_mnt $MOUNT |
+		grep -c "filesystem_summary:"; exit ${PIPESTATUS[0]})
+	ret=$?
+
+	[[ $output -eq 2 && $ret -eq $err_eopnotsupp ]] ||
+		error "expect success 2, not $output, rc = $ret"
+}
+run_test 56e "'lfs df' Handle non LustreFS & multiple LustreFS"
+
 NUMFILES=3
 NUMDIRS=3
 setup_56() {
@@ -7579,6 +7687,85 @@ test_56xf() {
 }
 run_test 56xf "FID is not lost during migration of a composite layout file"
 
+check_file_ost_range() {
+	local file="$1"
+	shift
+	local range="$*"
+	local -a file_range
+	local idx
+
+	file_range=($($LFS getstripe -y "$file" |
+		awk '/l_ost_idx:/ { print $NF }'))
+
+	if [[ "${#file_range[@]}" = 0 ]]; then
+		echo "No osts found for $file"
+		return 1
+	fi
+
+	for idx in "${file_range[@]}"; do
+		[[ " $range " =~ " $idx " ]] ||
+			return 1
+	done
+
+	return 0
+}
+
+sub_test_56xg() {
+	local stripe_opt="$1"
+	local pool="$2"
+	shift 2
+	local pool_ostidx="$(seq $* | tr '\n' ' ')"
+
+	$LFS migrate $stripe_opt -p $pool $DIR/$tfile ||
+		error "Fail to migrate $tfile on $pool"
+	[[ "$($LFS getstripe -p $DIR/$tfile)" = "$pool" ]] ||
+		error "$tfile is not in pool $pool"
+	check_file_ost_range "$DIR/$tfile" $pool_ostidx ||
+		error "$tfile osts mismatch with pool $pool (osts $pool_ostidx)"
+}
+
+test_56xg() {
+	[[ $PARALLEL != "yes" ]] || skip "skip parallel run"
+	[[ $OSTCOUNT -ge 2 ]] || skip "needs >= 2 OSTs"
+	[[ $MDS1_VERSION -gt $(version_code 2.14.52) ]] ||
+		skip "Need MDS version newer than 2.14.52"
+
+	local -a pool_names=("${TESTNAME}_0" "${TESTNAME}_1" "${TESTNAME}_2")
+	local -a pool_ranges=("0 0" "1 1" "0 1")
+
+	# init pools
+	for i in "${!pool_names[@]}"; do
+		pool_add ${pool_names[$i]} ||
+			error "pool_add failed (pool: ${pool_names[$i]})"
+		pool_add_targets ${pool_names[$i]} ${pool_ranges[$i]} ||
+			error "pool_add_targets failed (pool: ${pool_names[$i]})"
+	done
+
+	# init the file to migrate
+	$LFS setstripe -c1 -i1 $DIR/$tfile ||
+		error "Unable to create $tfile on OST1"
+	dd if=/dev/urandom of=$DIR/$tfile bs=1M count=4 status=none ||
+		error "Unable to write on $tfile"
+
+	echo "1. migrate $tfile on pool ${pool_names[0]}"
+	sub_test_56xg "-c-1" "${pool_names[0]}" ${pool_ranges[0]}
+
+	echo "2. migrate $tfile on pool ${pool_names[2]}"
+	sub_test_56xg "-c-1 -S2M" "${pool_names[2]}" ${pool_ranges[2]}
+
+	echo "3. migrate $tfile on pool ${pool_names[1]}"
+	sub_test_56xg "-n -c-1" "${pool_names[1]}" ${pool_ranges[1]}
+
+	echo "4. migrate $tfile on pool ${pool_names[2]} with default stripe parameters"
+	sub_test_56xg "" "${pool_names[2]}" ${pool_ranges[2]}
+	echo
+
+	# Clean pools
+	destroy_test_pools ||
+		error "pool_destroy failed"
+}
+run_test 56xg "lfs migrate pool support"
+
 test_56y() {
 	[ $MDS1_VERSION -lt $(version_code 2.4.53) ] &&
 		skip "No HSM $(lustre_build_version $SINGLEMDS) MDS < 2.4.53"
@@ -8631,6 +8818,138 @@ test_64f() {
 }
 run_test 64f "check grant consumption (with grant allocation)"
 
+test_64g() {
+	#[ $MDS1_VERSION -lt $(version_code 2.14.54) ] &&
+	#	skip "Need MDS version at least 2.14.54"
+
+	local mdts=$(comma_list $(mdts_nodes))
+
+	local old=$($LCTL get_param mdc.$FSNAME-*.grant_shrink_interval |
+			tr '\n' ' ')
+	stack_trap "$LCTL set_param $old"
+
+	# generate dirty pages and increase dirty granted on MDT
+	stack_trap "rm -f $DIR/$tfile-*"
+	for (( i = 0; i < 10; i++)); do
+		$LFS setstripe -E 1M -L mdt $DIR/$tfile-$i ||
+			error "can't set stripe"
+		dd if=/dev/zero of=$DIR/$tfile-$i bs=128k count=1 ||
+			error "can't dd"
+		$LFS getstripe $DIR/$tfile-$i | grep -q pattern.*mdt || {
+			$LFS getstripe $DIR/$tfile-$i
+			error "not DoM file"
+		}
+	done
+
+	# flush dirty pages
+	sync
+
+	# wait until grant shrink reset grant dirty on MDTs
+	for ((i = 0; i < 120; i++)); do
+		grant_dirty=$(do_nodes $mdts $LCTL get_param -n  mdt.*.tot_dirty |
+			awk '{sum=sum+$1} END {print sum}')
+		vm_dirty=$(awk '/Dirty:/{print $2}' /proc/meminfo)
+		echo "$grant_dirty grants, $vm_dirty pages"
+		(( grant_dirty + vm_dirty == 0 )) && break
+		(( i == 3 )) && sync &&
+			$LCTL set_param mdc.$FSNAME-*.grant_shrink_interval=5
+		sleep 1
+	done
+
+	grant_dirty=$(do_nodes $mdts $LCTL get_param -n  mdt.*.tot_dirty |
+		awk '{sum=sum+$1} END {print sum}')
+	(( grant_dirty == 0 )) || error "$grant_dirty on MDT"
+}
+run_test 64g "grant shrink on MDT"
+
+test_64h() {
+	local instance=$($LFS getname -i $DIR)
+	local osc_tgt="$FSNAME-OST0000-osc-$instance"
+	local num_exps=$(do_facet ost1 \
+	    $LCTL get_param -n obdfilter.*OST0000*.num_exports)
+	local max_brw_size=$(import_param $osc_tgt max_brw_size)
+	local avail=$($LCTL get_param -n osc.*OST0000-osc-$instance.kbytesavail)
+	local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+
+	# 10MiB is for file to be written, max_brw_size * 16 *
+	# num_exps is space reserve so that tgt_grant_shrink() decided
+	# to not shrink
+	local expect=$((max_brw_size * 16 * num_exps + 10 * 1048576))
+	(( avail * 1024 < expect )) &&
+		skip "need $expect bytes on ost1, have $(( avail * 1024 )) only"
+
+	save_lustre_params client "osc.*OST0000*.grant_shrink" > $p
+	save_lustre_params client "osc.*OST0000*.grant_shrink_interval" >> $p
+	stack_trap "restore_lustre_params < $p; rm -f $save" EXIT
+	$LCTL set_param osc.*OST0000*.grant_shrink=1
+	$LCTL set_param osc.*OST0000*.grant_shrink_interval=10
+
+	$LFS setstripe -c 1 -i 0 $DIR/$tfile
+	dd if=/dev/zero of=$DIR/$tfile bs=1M count=10 oflag=sync
+
+	# drop cache so that coming read would do rpc
+	cancel_lru_locks osc
+
+	# shrink interval is set to 10, pause for 7 seconds so that
+	# grant thread did not wake up yet but coming read entered
+	# shrink mode for rpc (osc_should_shrink_grant())
+	sleep 7
+
+	declare -a cur_grant_bytes
+	declare -a tot_granted
+	cur_grant_bytes[0]=$($LCTL get_param -n osc.*OST0000*.cur_grant_bytes)
+	tot_granted[0]=$(do_facet ost1 \
+	    $LCTL get_param -n obdfilter.*OST0000*.tot_granted)
+
+	dd if=$DIR/$tfile bs=4K count=1 of=/dev/null
+
+	cur_grant_bytes[1]=$($LCTL get_param -n osc.*OST0000*.cur_grant_bytes)
+	tot_granted[1]=$(do_facet ost1 \
+	    $LCTL get_param -n obdfilter.*OST0000*.tot_granted)
+
+	# grant change should be equal on both sides
+	(( cur_grant_bytes[0] - cur_grant_bytes[1] ==
+		tot_granted[0] - tot_granted[1])) ||
+		error "grant change mismatch, "				       \
+			"server: ${tot_granted[0]} to ${tot_granted[1]}, "     \
+			"client: ${cur_grant_bytes[0]} to ${cur_grant_bytes[1]}"
+}
+run_test 64h "grant shrink on read"
+
+test_64i() {
+	(( $OST1_VERSION >= $(version_code 2.14.55) )) ||
+		skip "need OST at least 2.14.55 to avoid grant shrink on replay"
+
+	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+	remote_ost_nodsh && skip "remote OSTs with nodsh"
+
+	$LFS setstripe -c 1 -i 0 $DIR/$tfile
+
+	dd if=/dev/zero of=$DIR/$tfile bs=1M count=64
+
+	# lustre-ffff9fc75e850800 /mnt/lustre -> ffff9fc75e850800
+	local instance=$($LFS getname -i $DIR)
+
+	local osc_tgt="$FSNAME-OST0000-osc-$instance"
+	local cgb=$($LCTL get_param -n osc.$osc_tgt.cur_grant_bytes)
+
+	# shrink grants and simulate rpc loss
+	#define OBD_FAIL_PTLRPC_DROP_REQ_OPC	 0x513
+	do_facet ost1 "$LCTL set_param fail_loc=0x80000513 fail_val=17"
+	$LCTL set_param osc.$osc_tgt.cur_grant_bytes=$((cgb/2))B
+
+	fail ost1
+
+	dd if=/dev/zero of=$DIR/$tfile oflag=append bs=1M count=8 conv=notrunc
+
+	local testid=$(echo $TESTNAME | tr '_' ' ')
+
+	do_facet ost1 dmesg | tac | sed "/$testid/,$ d" |
+		grep "GRANT, real grant" &&
+		error "client has more grants then it owns" || true
+}
+run_test 64i "shrink on reconnect"
+
 # bug 1414 - set/get directories' stripe info
 test_65a() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
@@ -9610,6 +9929,81 @@ test_77m() {
 }
 run_test 77m "Verify checksum_speed is correctly read"
 
+check_filefrag_77n() {
+	local nr_ext=0
+	local starts=()
+	local ends=()
+
+	while read extidx a b start end rest; do
+		if [[ "${extidx}" =~ ^[0-9]+: ]]; then
+			nr_ext=$(( $nr_ext + 1 ))
+			starts+=( ${start%..} )
+			ends+=( ${end%:} )
+		fi
+	done < <( filefrag -sv $1 )
+
+	[[ $nr_ext -eq 2 ]] && [[ "${starts[-1]}" == $(( ${ends[0]} + 1 )) ]] && return 0
+	return 1
+}
+
+test_77n() {
+	[[ "$CKSUM_TYPES" =~ t10 ]] || skip "no T10 checksum support on osc"
+
+	touch $DIR/$tfile
+	$TRUNCATE $DIR/$tfile 0
+	dd if=/dev/urandom of=$DIR/$tfile bs=4k conv=notrunc count=1 seek=0
+	dd if=/dev/urandom of=$DIR/$tfile bs=4k conv=notrunc count=1 seek=2
+	check_filefrag_77n $DIR/$tfile ||
+		skip "$tfile blocks not contiguous around hole"
+
+	set_checksums 1
+	stack_trap "set_checksums $ORIG_CSUM" EXIT
+	stack_trap "set_checksum_type $ORIG_CSUM_TYPE" EXIT
+	stack_trap "rm -f $DIR/$tfile"
+
+	for algo in $CKSUM_TYPES; do
+		if [[ "$algo" =~ ^t10 ]]; then
+			set_checksum_type $algo ||
+				error "fail to set checksum type $algo"
+			dd if=$DIR/$tfile of=/dev/null bs=12k count=1 iflag=direct ||
+				error "fail to read $tfile with $algo"
+		fi
+	done
+	rm -f $DIR/$tfile
+	return 0
+}
+run_test 77n "Verify read from a hole inside contiguous blocks with T10PI"
+
+test_77o() {
+	(( $CLIENT_VERSION >= $(version_code 2.14.54) )) ||
+		skip "Need at least version 2.14.54"
+	local ofd=obdfilter
+	local mdt=mdt
+
+	# print OST checksum_type
+	echo "$ofd.$FSNAME-*.checksum_type:"
+	do_nodes $(comma_list $(osts_nodes)) \
+		$LCTL get_param -n $ofd.$FSNAME-*.checksum_type
+
+	# print MDT checksum_type
+	echo "$mdt.$FSNAME-*.checksum_type:"
+	do_nodes $(comma_list $(mdts_nodes)) \
+		$LCTL get_param -n $mdt.$FSNAME-*.checksum_type
+
+	local o_count=$(do_nodes $(comma_list $(osts_nodes)) \
+		   $LCTL get_param -n $ofd.$FSNAME-*.checksum_type | wc -l)
+
+	(( $o_count == $OSTCOUNT )) ||
+		error "found $o_count checksums, not \$MDSCOUNT=$OSTCOUNT"
+
+	local m_count=$(do_nodes $(comma_list $(mdts_nodes)) \
+		   $LCTL get_param -n $mdt.$FSNAME-*.checksum_type | wc -l)
+
+	(( $m_count == $MDSCOUNT )) ||
+		error "found $m_count checksums, not \$MDSCOUNT=$MDSCOUNT"
+}
+run_test 77o "Verify checksum_type for server (mdt and ofd(obdfilter))"
+
 cleanup_test_78() {
 	trap 0
 	rm -f $DIR/$tfile
@@ -13832,8 +14226,12 @@ test_133f() {
 	$LCTL get_param -R '*' &> /dev/null
 
 	# Verifing writability with badarea_io.
+	local proc_dirs=$(eval \ls -d $proc_regexp 2>/dev/null)
+	local skipped_params='force_lbug|changelog_mask|daemon_file'
 	$LCTL list_param -FR '*' | grep '=' | tr -d = |
-		egrep -v 'force_lbug|changelog_mask' | xargs badarea_io ||
+		egrep -v "$skipped_params" |
+		xargs -n 1 find $proc_dirs -name |
+		xargs -n 1 badarea_io ||
 		error "client badarea_io failed"
 
 	# remount the FS in case writes/reads /proc break the FS
@@ -13846,6 +14244,8 @@ test_133g() {
 	remote_mds_nodsh && skip "remote MDS with nodsh"
 	remote_ost_nodsh && skip "remote OST with nodsh"
 
+	local proc_dirs=$(eval \ls -d $proc_regexp 2>/dev/null)
+	local skipped_params="'force_lbug|changelog_mask|daemon_file'"
 	local facet
 	for facet in mds1 ost1; do
 		local facet_ver=$(lustre_version_code $facet)
@@ -13856,8 +14256,9 @@ test_133g() {
 		fi
 		if [ $facet_ver -ge $(version_code 2.5.54) ]; then
 			do_facet $facet "$LCTL list_param -FR '*' | grep '=' |
-				tr -d = | egrep -v 'force_lbug|changelog_mask' |
-				xargs badarea_io" ||
+				tr -d = | egrep -v $skipped_params |
+				xargs -n 1 find $proc_dirs -name |
+				xargs -n 1 badarea_io" ||
 					error "$facet badarea_io failed"
 		else
 			skip_noexit "$facet: too old lustre for get_param -R"
@@ -14146,31 +14547,30 @@ run_test 150bb "Verify fallocate modes both zero space"
 
 test_150c() {
 	check_set_fallocate_or_skip
+	local striping="-c2"
 
 	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/$tfile)))
-	want=$((OSTCOUNT * 1048576))
+	local bytes=$(($(stat -c '%b * %B' $DIR/$tfile)))
+	local 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 ||
+
+	echo "verify fallocate on PFL file"
+
+	[[ "x$DOM" == "xyes" ]] && striping="-L mdt"
+
+	$LFS setstripe -E1M $striping -E16M -c3 -Eeof -c 4 $DIR/$tfile ||
 		error "Create $DIR/$tfile failed"
-	fallocate -l $((1048576 * 1024)) $DIR/$tfile ||
+	fallocate -l $((1048576 * 512)) $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))
+	bytes=$(($(stat -c '%b * %B' $DIR/$tfile)))
+	want=$((512 * 1048576))
 
 	# Must allocate all requested space, not more than 5% extra
 	(( $bytes >= $want && $bytes < $want * 105 / 100 )) ||
@@ -14180,13 +14580,14 @@ run_test 150c "Verify fallocate Size and Blocks"
 
 test_150d() {
 	check_set_fallocate_or_skip
+	local striping="-c2"
+
+	[[ "x$DOM" == "xyes" ]] && striping="-L mdt"
 
 	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
-	$LFS setstripe -c $OSTCOUNT -S1M $DIR/$tdir || error "setstripe failed"
+	$LFS setstripe -E1M $striping -E eof -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
 	local bytes=$(($(stat -c '%b * %B' $DIR/$tdir)))
 	local want=$((OSTCOUNT * 1048576))
 
@@ -14263,6 +14664,9 @@ test_150f() {
 	check_set_fallocate_or_skip
 	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
 
+	[[ "x$DOM" == "xyes" ]] &&
+		$LFS setstripe -E1M -L mdt -E eof $DIR/$tfile
+
 	echo "Verify fallocate punch: Range within the file range"
 	yes 'A' | dd of=$DIR/$tfile bs=4096 count=5 ||
 		error "dd failed for bs 4096 and count 5"
@@ -14338,8 +14742,13 @@ test_150g() {
 	check_set_fallocate_or_skip
 	stack_trap "rm -f $DIR/$tfile; wait_delete_completed"
 
-	$LFS setstripe -c${OSTCOUNT} $DIR/$tfile ||
-		error "$LFS setstripe -c${OSTCOUNT} $DIR/$tfile failed"
+	if [[ "x$DOM" == "xyes" ]]; then
+		$LFS setstripe -E2M -L mdt -E eof -c${OSTCOUNT} $DIR/$tfile ||
+			error "$LFS setstripe DoM + ${OSTCOUNT} OST failed"
+	else
+		$LFS setstripe -c${OSTCOUNT} $DIR/$tfile ||
+			error "$LFS setstripe -c${OSTCOUNT} $DIR/$tfile failed"
+	fi
 
 	# Get 100MB per OST of the available space to reduce run time
 	# else 60% of the available space if we are running SLOW tests
@@ -14865,35 +15274,35 @@ test_154f() {
 	[ -n "$FILESET" ] && skip "SKIP due to FILESET set"
 
 	# create parent directory on a single MDT to avoid cross-MDT hardlinks
-	test_mkdir -p -c1 $DIR/$tdir/d
+	mkdir_on_mdt0 $DIR/$tdir
 	# test dirs inherit from its stripe
-	mkdir -p $DIR/$tdir/d/foo1 || error "mkdir error"
-	mkdir -p $DIR/$tdir/d/foo2 || error "mkdir error"
-	cp /etc/hosts $DIR/$tdir/d/foo1/$tfile
-	ln $DIR/$tdir/d/foo1/$tfile $DIR/$tdir/d/foo2/link
+	mkdir -p $DIR/$tdir/foo1 || error "mkdir error"
+	mkdir -p $DIR/$tdir/foo2 || error "mkdir error"
+	cp /etc/hosts $DIR/$tdir/foo1/$tfile
+	ln $DIR/$tdir/foo1/$tfile $DIR/$tdir/foo2/link
 	touch $DIR/f
 
 	# get fid of parents
-	local FID0=$($LFS path2fid $DIR/$tdir/d)
-	local FID1=$($LFS path2fid $DIR/$tdir/d/foo1)
-	local FID2=$($LFS path2fid $DIR/$tdir/d/foo2)
+	local FID0=$($LFS path2fid $DIR/$tdir)
+	local FID1=$($LFS path2fid $DIR/$tdir/foo1)
+	local FID2=$($LFS path2fid $DIR/$tdir/foo2)
 	local FID3=$($LFS path2fid $DIR)
 
 	# check that path2fid --parents returns expected <parent_fid>/name
 	# 1) test for a directory (single parent)
-	local parent=$($LFS path2fid --parents $DIR/$tdir/d/foo1)
+	local parent=$($LFS path2fid --parents $DIR/$tdir/foo1)
 	[ "$parent" == "$FID0/foo1" ] ||
 		error "expected parent: $FID0/foo1, got: $parent"
 
 	# 2) test for a file with nlink > 1 (multiple parents)
-	parent=$($LFS path2fid --parents $DIR/$tdir/d/foo1/$tfile)
+	parent=$($LFS path2fid --parents $DIR/$tdir/foo1/$tfile)
 	echo "$parent" | grep -F "$FID1/$tfile" ||
 		error "$FID1/$tfile not returned in parent list"
 	echo "$parent" | grep -F "$FID2/link" ||
 		error "$FID2/link not returned in parent list"
 
 	# 3) get parent by fid
-	local file_fid=$($LFS path2fid $DIR/$tdir/d/foo1/$tfile)
+	local file_fid=$($LFS path2fid $DIR/$tdir/foo1/$tfile)
 	parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
 	echo "$parent" | grep -F "$FID1/$tfile" ||
 		error "$FID1/$tfile not returned in parent list (by fid)"
@@ -14915,7 +15324,7 @@ test_154f() {
 	lctl set_param llite.*.xattr_cache 1
 
 	# 6.1) linkea update on rename
-	mv $DIR/$tdir/d/foo1/$tfile $DIR/$tdir/d/foo2/$tfile.moved
+	mv $DIR/$tdir/foo1/$tfile $DIR/$tdir/foo2/$tfile.moved
 
 	# get parents by fid
 	parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
@@ -14927,7 +15336,7 @@ test_154f() {
 		error "$FID2/$tfile.moved is not in parent list"
 
 	# 6.2) linkea update on unlink
-	rm -f $DIR/$tdir/d/foo2/link
+	rm -f $DIR/$tdir/foo2/link
 	parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
 	# foo2/link should no longer be returned in parent list
 	echo "$parent" | grep -F "$FID2/link" &&
@@ -14947,7 +15356,7 @@ test_154g()
 	   $CLIENT_VERSION -gt $(version_code 2.6.99) ]] ||
 		skip "Need MDS version at least 2.6.92"
 
-	mkdir -p $DIR/$tdir
+	mkdir_on_mdt0 $DIR/$tdir
 	llapi_fid_test -d $DIR/$tdir
 }
 run_test 154g "various llapi FID tests"
@@ -15484,11 +15893,21 @@ test_160e() {
 	# Create a user
 	changelog_register || error "changelog_register failed"
 
-	# Delete a future user (expect fail)
 	local MDT0=$(facet_svc $SINGLEMDS)
-	do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister "cl77"
-	local rc=$?
+	local rc
+
+	# No user (expect fail)
+	do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister
+	rc=$?
+	if [ $rc -eq 0 ]; then
+		error "Should fail without user"
+	elif [ $rc -ne 4 ]; then
+		error "changelog_deregister failed with $rc, expect 4(CMD_HELP)"
+	fi
 
+	# Delete a future user (expect fail)
+	do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister "cl77"
+	rc=$?
 	if [ $rc -eq 0 ]; then
 		error "Deleted non-existant user cl77"
 	elif [ $rc -ne 2 ]; then
@@ -15636,14 +16055,11 @@ run_test 160f "changelog garbage collect (timestamped users)"
 
 test_160g() {
 	remote_mds_nodsh && skip "remote MDS with nodsh"
-	[[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
-		skip "Need MDS version at least 2.10.56"
+	[[ $MDS1_VERSION -ge $(version_code 2.14.55) ]] ||
+		skip "Need MDS version at least 2.14.55"
 
 	local mdts=$(comma_list $(mdts_nodes))
 
-	#define OBD_FAIL_TIME_IN_CHLOG_USER	0x1314
-	do_nodes $mdts $LCTL set_param fail_loc=0x1314
-
 	# Create a user
 	changelog_register || error "first changelog_register failed"
 	changelog_register || error "second changelog_register failed"
@@ -15668,10 +16084,9 @@ test_160g() {
 	(( $nbcl > 0 )) || error "no changelogs found"
 
 	# reduce the max_idle_indexes value to make sure we exceed it
-	for param in "changelog_max_idle_indexes=1" \
+	for param in "changelog_max_idle_indexes=2" \
 		     "changelog_gc=1" \
-		     "changelog_min_gc_interval=2" \
-		     "changelog_min_free_cat_entries=3"; do
+		     "changelog_min_gc_interval=2"; do
 		local MDT0=$(facet_svc $SINGLEMDS)
 		local var="${param%=*}"
 		local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
@@ -15681,10 +16096,6 @@ test_160g() {
 			error "unable to set mdd.*.$param"
 	done
 
-	# simulate changelog catalog almost full
-	#define OBD_FAIL_CAT_FREE_RECORDS	0x1313
-	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]})
@@ -15692,38 +16103,37 @@ test_160g() {
 		cl_user2[mds$i]="${cl_users[1]}"
 
 		[ -n "${cl_user1[mds$i]}" ] ||
-			error "mds$i: no user registered"
+			error "mds$i: user1 is not registered"
 		[ -n "${cl_user2[mds$i]}" ] ||
 			error "mds$i: only ${cl_user1[mds$i]} is registered"
 
 		user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
 		[ -n "$user_rec1" ] ||
-			error "mds$i: User ${cl_user1[mds$i]} not registered"
+			error "mds$i: user1 ${cl_user1[mds$i]} not found"
 		__changelog_clear mds$i ${cl_user1[mds$i]} +2
 		user_rec2=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
 		[ -n "$user_rec2" ] ||
-			error "mds$i: User ${cl_user1[mds$i]} not registered"
-		echo "mds$i: verifying user ${cl_user1[mds$i]} clear: " \
+			error "mds$i: user1 ${cl_user1[mds$i]} not found (2)"
+		echo "mds$i: verifying user1 ${cl_user1[mds$i]} clear: " \
 		     "$user_rec1 + 2 == $user_rec2"
 		[ $((user_rec1 + 2)) == $user_rec2 ] ||
-			error "mds$i: user ${cl_user1[mds$i]} index expected " \
-			      "$user_rec1 + 2, but is $user_rec2"
+			error "mds$i: user1 ${cl_user1[mds$i]} index " \
+			      "expected $user_rec1 + 2, but is $user_rec2"
 		user_rec2=$(changelog_user_rec mds$i ${cl_user2[mds$i]})
 		[ -n "$user_rec2" ] ||
-			error "mds$i: User ${cl_user2[mds$i]} not registered"
+			error "mds$i: user2 ${cl_user2[mds$i]} not found"
 		[ $user_rec1 == $user_rec2 ] ||
-			error "mds$i: user ${cl_user2[mds$i]} index expected " \
-			      "$user_rec1, but is $user_rec2"
+			error "mds$i: user2 ${cl_user2[mds$i]} index " \
+			      "expected $user_rec1, but is $user_rec2"
 	done
 
 	# ensure we are past the previous changelog_min_gc_interval set above
 	local sleep2=$((start + 2 - SECONDS))
 	(( sleep2 > 0 )) && echo "sleep $sleep2 for interval" && sleep $sleep2
-
 	# 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 ||
+		$LFS mkdir -i $i $DIR/$tdir/d$i.3 ||
 			error "create $DIR/$tdir/d$i.3 failed"
 	done
 
@@ -15737,15 +16147,15 @@ test_160g() {
 	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"
+			error "mds$i: user1 ${cl_user1[mds$i]} not found (3)"
 		# check cl_user2 unregistered
 		changelog_users mds$i | grep -q "${cl_user2[mds$i]}" &&
-			error "mds$i: User ${cl_user2[mds$i]} still registered"
+			error "mds$i: user2 ${cl_user2[mds$i]} is registered"
 
 		# check changelogs are present and starting at $user_rec1 + 1
 		user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
 		[ -n "$user_rec1" ] ||
-			error "mds$i: User ${cl_user1[mds$i]} not registered"
+			error "mds$i: user1 ${cl_user1[mds$i]} not found (4)"
 		first_rec=$($LFS changelog $(facet_svc mds$i) |
 			    awk '{ print $1; exit; }')
 
@@ -15754,7 +16164,7 @@ test_160g() {
 			error "mds$i: rec $first_rec != $user_rec1 + 1"
 	done
 }
-run_test 160g "changelog garbage collect (old users)"
+run_test 160g "changelog garbage collect on idle records"
 
 test_160h() {
 	remote_mds_nodsh && skip "remote MDS with nodsh" && return
@@ -16217,7 +16627,7 @@ test_160o() {
 
 	changelog_register --user test_160o -m unlnk+close+open ||
 		error "changelog_register failed"
-	# drop server mask so it doesn't interfere
+
 	do_facet $SINGLEMDS $LCTL --device $mdt \
 				changelog_register -u "Tt3_-#" &&
 		error "bad symbols in name should fail"
@@ -16308,12 +16718,117 @@ test_160p() {
 }
 run_test 160p "Changelog orphan cleanup with no users"
 
-test_161a() {
-	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+test_160q() {
+	local mdt="$(facet_svc $SINGLEMDS)"
+	local clu
 
-	test_mkdir -c1 $DIR/$tdir
-	cp /etc/hosts $DIR/$tdir/$tfile
-	test_mkdir -c1 $DIR/$tdir/foo1
+	[[ $PARALLEL != "yes" ]] || skip "skip parallel run"
+	remote_mds_nodsh && skip "remote MDS with nodsh"
+	[ $MDS1_VERSION -ge $(version_code 2.14.54) ] ||
+		skip "Need MDS version at least 2.14.54"
+
+	# set server mask to minimal value like server init does
+	changelog_chmask "MARK"
+	clu=$(do_facet $SINGLEMDS $LCTL --device $mdt changelog_register -n) ||
+		error "changelog_register failed"
+	# check effective mask again, should be treated as DEFMASK now
+	mask=$(do_facet $SINGLEMDS $LCTL get_param \
+				mdd.$mdt.changelog_current_mask -n)
+	do_facet $SINGLEMDS $LCTL --device $mdt changelog_deregister $clu ||
+		error "changelog_deregister failed"
+	[[ $mask == *"HLINK"* ]] || error "mask is not DEFMASK as expected"
+}
+run_test 160q "changelog effective mask is DEFMASK if not set"
+
+test_160s() {
+	remote_mds_nodsh && skip "remote MDS with nodsh"
+	(( $MDS1_VERSION >= $(version_code 2.14.55) )) ||
+		skip "Need MDS version at least 2.14.55"
+
+	local mdts=$(comma_list $(mdts_nodes))
+
+	#define OBD_FAIL_TIME_IN_CHLOG_USER     0x1314
+	do_nodes $mdts $LCTL set_param fail_loc=0x1314 \
+				       fail_val=$((24 * 3600 * 10))
+
+	# Create a user which is 10 days old
+	changelog_register || error "first changelog_register failed"
+	local cl_users
+	declare -A cl_user1
+	local i
+
+	# generate some changelog records to accumulate on each MDT
+	# 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 > 0 )) || error "no changelogs found"
+
+	# reduce the max_idle_indexes value to make sure we exceed it
+	for param in "changelog_max_idle_indexes=2097446912" \
+		     "changelog_max_idle_time=2592000" \
+		     "changelog_gc=1" \
+		     "changelog_min_gc_interval=2"; do
+		local MDT0=$(facet_svc $SINGLEMDS)
+		local var="${param%=*}"
+		local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
+
+		stack_trap "do_nodes $mdts $LCTL set_param mdd.*.$var=$old" EXIT
+		do_nodes $mdts $LCTL set_param mdd.*.$param ||
+			error "unable to set mdd.*.$param"
+	done
+
+	local start=$SECONDS
+	for i in $(seq $MDSCOUNT); do
+		cl_users=(${CL_USERS[mds$i]})
+		cl_user1[mds$i]="${cl_users[0]}"
+
+		[[ -n "${cl_user1[mds$i]}" ]] ||
+			error "mds$i: no user registered"
+	done
+
+	#define OBD_FAIL_MDS_CHANGELOG_IDX_PUMP   0x16d
+	do_nodes $mdts $LCTL set_param fail_loc=0x16d fail_val=500000000
+
+	# ensure we are past the previous changelog_min_gc_interval set above
+	local sleep2=$((start + 2 - SECONDS))
+	(( sleep2 > 0 )) && echo "sleep $sleep2 for interval" && sleep $sleep2
+
+	# Generate one more changelog to trigger GC
+	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 node in $(mdts_nodes); do
+		wait_update $node "pgrep chlg_gc_thread" "" 20 ||
+			error "$node: GC-thread not done"
+	done
+
+	do_nodes $mdts $LCTL set_param fail_loc=0
+
+	for (( i = 1; i <= MDSCOUNT; i++ )); do
+		# check cl_user1 is purged
+		changelog_users mds$i | grep -q "${cl_user1[mds$i]}" &&
+			error "mds$i: User ${cl_user1[mds$i]} is registered"
+	done
+	return 0
+}
+run_test 160s "changelog garbage collect on idle records * time"
+
+test_161a() {
+	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+
+	test_mkdir -c1 $DIR/$tdir
+	cp /etc/hosts $DIR/$tdir/$tfile
+	test_mkdir -c1 $DIR/$tdir/foo1
 	test_mkdir -c1 $DIR/$tdir/foo2
 	ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/sofia
 	ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/zachary
@@ -18043,23 +18558,23 @@ test_208() {
 	$MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:eRE+eU || error "get lease error"
 
 	echo "==== test 2: verify lease can be broken by upcoming open"
-	$MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
+	$MULTIOP $DIR/$tfile oO_RDWR:eR_E-eUc &
 	local PID=$!
 	sleep 1
 
-	$MULTIOP $DIR/$tfile oO_RDONLY:c
+	$MULTIOP $DIR/$tfile oO_RDWR:c
 	kill -USR1 $PID && wait $PID || error "break lease error"
 
 	echo "==== test 3: verify lease can't be granted if an open already exists"
-	$MULTIOP $DIR/$tfile oO_RDONLY:_c &
+	$MULTIOP $DIR/$tfile oO_RDWR:_c &
 	local PID=$!
 	sleep 1
 
-	$MULTIOP $DIR/$tfile oO_RDONLY:eReUc && error "apply lease should fail"
+	$MULTIOP $DIR/$tfile oO_RDWR:eReUc && error "apply lease should fail"
 	kill -USR1 $PID && wait $PID || error "open file error"
 
 	echo "==== test 4: lease can sustain over recovery"
-	$MULTIOP $DIR/$tfile oO_RDONLY:eR_E+eUc &
+	$MULTIOP $DIR/$tfile oO_RDWR:eR_E+eUc &
 	PID=$!
 	sleep 1
 
@@ -18068,7 +18583,7 @@ test_208() {
 	kill -USR1 $PID && wait $PID || error "lease broken over recovery"
 
 	echo "==== test 5: lease broken can't be regained by replay"
-	$MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
+	$MULTIOP $DIR/$tfile oO_RDWR:eR_E-eUc &
 	PID=$!
 	sleep 1
 
@@ -18514,26 +19029,48 @@ run_test 223 "osc reenqueue if without AGL lock granted ======================="
 
 test_224a() { # LU-1039, MRP-303
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
-
 	#define OBD_FAIL_PTLRPC_CLIENT_BULK_CB   0x508
 	$LCTL set_param fail_loc=0x508
-	dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 conv=fsync
+	dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 conv=fsync
 	$LCTL set_param fail_loc=0
 	df $DIR
 }
 run_test 224a "Don't panic on bulk IO failure"
 
-test_224b() { # LU-1039, MRP-303
+test_224bd_sub() { # LU-1039, MRP-303
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
+	local timeout=$1
 
-	dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
+	shift
+	dd if=/dev/urandom of=$TMP/$tfile bs=1M count=1
+
+	$LFS setstripe -c 1 -i 0 $DIR/$tfile
+
+	dd if=$TMP/$tfile of=$DIR/$tfile bs=1M count=1
 	cancel_lru_locks osc
+	set_checksums 0
+	stack_trap "set_checksums $ORIG_CSUM" EXIT
+	local at_max_saved=0
+
+	# adaptive timeouts may prevent seeing the issue
+	if at_is_enabled; then
+		at_max_saved=$(at_max_get mds)
+		at_max_set 0 mds client
+		stack_trap "at_max_set $at_max_saved mds client" EXIT
+	fi
+
 	#define OBD_FAIL_PTLRPC_CLIENT_BULK_CB2   0x515
-	$LCTL set_param fail_loc=0x515
-	dd of=/dev/null if=$DIR/$tfile bs=4096 count=1
-	$LCTL set_param fail_loc=0
+	do_facet ost1 $LCTL set_param fail_val=$timeout fail_loc=0x80000515
+	dd of=$TMP/$tfile.new if=$DIR/$tfile bs=1M count=1 || "$@"
+
+	do_facet ost1 $LCTL set_param fail_loc=0
+	cmp $TMP/$tfile $TMP/$tfile.new || error "file contents wrong"
 	df $DIR
 }
+
+test_224b() {
+	test_224bd_sub 3 error "dd failed"
+}
 run_test 224b "Don't panic on bulk IO failure"
 
 test_224c() { # LU-6441
@@ -18574,6 +19111,11 @@ test_224c() { # LU-6441
 }
 run_test 224c "Don't hang if one of md lost during large bulk RPC"
 
+test_224d() { # LU-11169
+	test_224bd_sub $((TIMEOUT + 2)) error "dd failed"
+}
+run_test 224d "Don't corrupt data on bulk IO timeout"
+
 MDSSURVEY=${MDSSURVEY:-$(which mds-survey 2>/dev/null || true)}
 test_225a () {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
@@ -19253,7 +19795,7 @@ test_230d() {
 		error "migrate remote dir error"
 
 	echo "Finish migration, then checking.."
-	for file in $(find $migrate_dir); do
+	for file in $(find $migrate_dir -maxdepth 1); do
 		mdt_index=$($LFS getstripe -m $file)
 		if [ $mdt_index -lt $new_index ] ||
 		   [ $mdt_index -gt $((new_index + new_count - 1)) ]; then
@@ -19613,15 +20155,15 @@ test_230o() {
 run_test 230o "dir split"
 
 test_230p() {
-	[ $MDSCOUNT -ge 2 ] || skip "needs >= 2 MDTs"
-	[ $MDS1_VERSION -ge $(version_code 2.13.52) ] ||
+	(( MDSCOUNT > 1 )) || skip "needs >= 2 MDTs"
+	(( MDS1_VERSION >= $(version_code 2.13.52) )) ||
 		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 c
 
 	[[ $mds1_FSTYPE == zfs ]] && timeout=300
 
@@ -19635,33 +20177,37 @@ test_230p() {
 
 	test_mkdir -c $MDSCOUNT -H crush $DIR/$tdir
 	createmany -m $DIR/$tdir/f 100 ||
-		error "create files under remote dir failed $i"
+		error "create files under remote dir failed"
 	createmany -d $DIR/$tdir/d 100 ||
-		error "create dirs under remote dir failed $i"
+		error "create dirs under remote dir failed"
 
-	for i in $(seq $((MDSCOUNT - 1)) -1 1); do
+	for c in $(seq $((MDSCOUNT - 1)) -1 1); do
 		local mdt_hash="crush"
 
 		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"
+		$LFS setdirstripe -c $c $DIR/$tdir ||
+			error "split -c $c $tdir failed"
+		if (( MDS1_VERSION >= $(version_code 2.14.51) )); then
+			mdt_hash="$mdt_hash,fixed"
+		elif [ $c -eq 1 ]; then
+			mdt_hash="none"
+		fi
 		wait_update $HOSTNAME \
 			"$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 migrated when dir merge $((i + 1)) to $i stripes"
+		echo "$delta migrated when dir merge $((c + 1)) to $c stripes"
 		# delta is around total_files/stripe_count
-		(( $delta < 200 / i + 4 )) ||
-			error "$delta files migrated >= $((200 / i + 4))"
+		(( delta < 200 / c + 4 )) ||
+			error "$delta files migrated >= $((200 / c + 4))"
 	done
 }
 run_test 230p "dir merge"
 
 test_230q() {
-	[ $MDSCOUNT -ge 2 ] || skip "needs >= 2 MDTs"
-	[ $MDS1_VERSION -ge $(version_code 2.13.52) ] ||
+	(( MDSCOUNT > 1)) || skip "needs >= 2 MDTs"
+	(( MDS1_VERSION >= $(version_code 2.13.52) )) ||
 		skip "Need MDS version at least 2.13.52"
 
 	local mdts=$(comma_list $(mdts_nodes))
@@ -19721,6 +20267,15 @@ test_230q() {
 		[ $nr_files -eq $total ] ||
 			error "total sub files $nr_files != $total"
 	done
+
+	(( MDS1_VERSION >= $(version_code 2.14.51) )) || return 0
+
+	echo "fixed layout directory won't auto split"
+	$LFS migrate -m 0 $DIR/$tdir || error "migrate $tdir failed"
+	wait_update $HOSTNAME "$LFS getdirstripe -H $DIR/$tdir" "crush,fixed" \
+		10 || error "stripe hash $($LFS getdirstripe -H $DIR/$tdir)"
+	wait_update $HOSTNAME "$LFS getdirstripe -c $DIR/$tdir" 1 10 ||
+		error "stripe count $($LFS getdirstripe -c $DIR/$tdir)"
 }
 run_test 230q "dir auto split"
 
@@ -19797,6 +20352,66 @@ test_230t()
 }
 run_test 230t "migrate directory with project ID set"
 
+test_230u()
+{
+	(( MDSCOUNT > 3 )) || skip_env "needs >= 4 MDTs"
+	(( MDS1_VERSION >= $(version_code 2.14.53) )) ||
+		skip "Need MDS version at least 2.14.53"
+
+	local count
+
+	mkdir_on_mdt0 $DIR/$tdir || error "mkdir $tdir failed"
+	mkdir $DIR/$tdir/sub{0..99} || error "mkdir sub failed"
+	$LFS migrate -m -1 $DIR/$tdir/sub{0..99} || error "migrate sub failed"
+	for i in $(seq 0 $((MDSCOUNT - 1))); do
+		count=$($LFS getstripe -m $DIR/$tdir/sub* | grep -c ^$i)
+		echo "$count dirs migrated to MDT$i"
+	done
+	count=$($LFS getstripe -m $DIR/$tdir/sub* | sort -u | wc -l)
+	(( count >= MDSCOUNT - 1 )) || error "dirs migrated to $count MDTs"
+}
+run_test 230u "migrate directory by QOS"
+
+test_230v()
+{
+	(( MDSCOUNT > 3 )) || skip_env "needs >= 4 MDTs"
+	(( MDS1_VERSION >= $(version_code 2.14.53) )) ||
+		skip "Need MDS version at least 2.14.53"
+
+	local count
+
+	mkdir $DIR/$tdir || error "mkdir $tdir failed"
+	mkdir $DIR/$tdir/sub{0..99} || error "mkdir sub failed"
+	$LFS migrate -m 0,2,1 $DIR/$tdir || error "migrate $tdir failed"
+	for i in $(seq 0 $((MDSCOUNT - 1))); do
+		count=$($LFS getstripe -m $DIR/$tdir/sub* | grep -c ^$i)
+		echo "$count subdirs migrated to MDT$i"
+		(( i == 3 )) && (( count > 0 )) &&
+			error "subdir shouldn't be migrated to MDT3"
+	done
+	count=$($LFS getstripe -m $DIR/$tdir/sub* | sort -u | wc -l)
+	(( count == 3 )) || error "dirs migrated to $count MDTs"
+}
+run_test 230v "subdir migrated to the MDT where its parent is located"
+
+test_230w() {
+	(( MDSCOUNT > 1 )) || skip "needs >= 2 MDTs"
+	(( MDS1_VERSION >= $(version_code 2.14.53) )) ||
+		skip "Need MDS version at least 2.14.53"
+
+	mkdir -p $DIR/$tdir/sub || error "mkdir failed"
+
+	$LFS migrate -m 1 -c $MDSCOUNT -d $DIR/$tdir ||
+		error "migrate failed"
+
+	(( $($LFS getdirstripe -c $DIR/$tdir) == MDSCOUNT )) ||
+		error "$tdir stripe count mismatch"
+
+	(( $($LFS getdirstripe -c $DIR/$tdir/sub) == 0 )) ||
+		error "$tdir/sub is striped"
+}
+run_test 230w "non-recursive mode dir migration"
+
 test_231a()
 {
 	# For simplicity this test assumes that max_pages_per_rpc
@@ -20323,7 +20938,8 @@ test_247f() {
 	mkdir_on_mdt0 $DIR/$tdir || error "mkdir $tdir failed"
 	$LFS mkdir -i $((MDSCOUNT - 1)) $DIR/$tdir/remote ||
 		error "mkdir remote failed"
-	mkdir $DIR/$tdir/remote/subdir || error "mkdir remote/subdir failed"
+	$LFS mkdir -i $((MDSCOUNT - 1)) $DIR/$tdir/remote/subdir ||
+		error "mkdir remote/subdir failed"
 	$LFS mkdir -i 0 -c $MDSCOUNT $DIR/$tdir/striped ||
 		error "mkdir striped failed"
 	mkdir $DIR/$tdir/striped/subdir || error "mkdir striped/subdir failed"
@@ -20695,18 +21311,20 @@ run_test 253 "Check object allocation limit"
 test_254() {
 	[ $PARALLEL == "yes" ] && skip "skip parallel run"
 	remote_mds_nodsh && skip "remote MDS with nodsh"
-	do_facet $SINGLEMDS $LCTL get_param -n mdd.$MDT0.changelog_size ||
+
+	local mdt=$(facet_svc $SINGLEMDS)
+
+	do_facet $SINGLEMDS $LCTL get_param -n mdd.$mdt.changelog_size ||
 		skip "MDS does not support changelog_size"
 
 	local cl_user
-	local MDT0=$(facet_svc $SINGLEMDS)
 
 	changelog_register || error "changelog_register failed"
 
 	changelog_clear 0 || error "changelog_clear failed"
 
 	local size1=$(do_facet $SINGLEMDS \
-		      $LCTL get_param -n mdd.$MDT0.changelog_size)
+		      $LCTL get_param -n mdd.$mdt.changelog_size)
 	echo "Changelog size $size1"
 
 	rm -rf $DIR/$tdir
@@ -20721,7 +21339,7 @@ test_254() {
 	rm $DIR/$tdir/pics/desktop.jpg
 
 	local size2=$(do_facet $SINGLEMDS \
-		      $LCTL get_param -n mdd.$MDT0.changelog_size)
+		      $LCTL get_param -n mdd.$mdt.changelog_size)
 	echo "Changelog size after work $size2"
 
 	(( $size2 > $size1 )) ||
@@ -21650,6 +22268,16 @@ test_270h() {
 }
 run_test 270h "DoM: DoM stripe removal when disabled on server"
 
+test_270i() {
+	(( $MDS1_VERSION >= $(version_code 2.14.54) )) ||
+		skip "Need MDS version at least 2.14.54"
+
+	mkdir $DIR/$tdir
+	$LFS setstripe -L mdt -S 128k -c -1 $DIR/$tdir &&
+		error "setstripe should fail" || true
+}
+run_test 270i "DoM: setting invalid DoM striping should fail"
+
 test_271a() {
 	[ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
 		skip "Need MDS version at least 2.10.55"
@@ -22634,9 +23262,6 @@ test_300g() {
 		stripe_count=$($LFS getdirstripe -c $dir)
 		[ $stripe_count -eq 0 ] ||
 			error "expect 1 get $stripe_count for $dir"
-		stripe_index=$($LFS getdirstripe -i $dir)
-		[ $stripe_index -eq 0 ] ||
-			error "expect 0 get $stripe_index for $dir"
 	done
 }
 run_test 300g "check default striped directory for normal directory"
@@ -23381,19 +24006,19 @@ test_317() {
 
 	#
 	# sparse file test
-	# Create file with a hole and write actual two blocks. Block count
-	# must be 16.
+	# Create file with a hole and write actual 65536 bytes which aligned
+	# with 4K and 64K PAGE_SIZE. Block count must be 128.
 	#
-	dd if=/dev/zero of=$DIR/$tfile bs=$grant_blk_size count=2 seek=5 \
-		conv=fsync || error "Create file : $DIR/$tfile"
-
-	# Calculate the final truncate size.
-	trunc_sz=$(($(stat --format=%s $DIR/$tfile) - (grant_blk_size + 1)))
+	local bs=65536
+	dd if=/dev/zero of=$DIR/$tfile bs=$bs count=1 seek=5 conv=fsync ||
+		error "Create file : $DIR/$tfile"
 
 	#
-	# truncate to size $trunc_sz bytes. Strip the last block
-	# The block count must drop to 8
+	# Truncate to size $trunc_sz bytes. Strip tail blocks and leave only 8
+	# blocks. The block count must drop to 8.
 	#
+	trunc_sz=$(($(stat --format=%s $DIR/$tfile) - \
+		((bs - grant_blk_size) + 1)))
 	$TRUNCATE $DIR/$tfile $trunc_sz ||
 		error "truncate $tfile to $trunc_sz failed"
 
@@ -23844,8 +24469,6 @@ run_test 398l "test enospc on intermediate stripe/RPC"
 test_398m() { #  LU-13798
 	$LFS setstripe -o 0,1,0,1 -S 1M $DIR/$tfile
 
-	lctl set_param *debug=-1 debug_mb=10000
-
 	# Set up failure on OST0, the first stripe:
 	#define OBD_FAIL_OST_BRW_WRITE_BULK     0x20e
 	#NB: Fail val is ost # + 1, because we cannot use cfs_fail_val = 0
@@ -24056,7 +24679,6 @@ test_401a() { #LU-7437
 	#count the number of parameters by "list_param -R"
 	local params=$($LCTL list_param -R '*' 2>/dev/null | wc -l)
 	#count the number of parameters by listing proc files
-	local proc_regexp="/{proc,sys}/{fs,sys,kernel/debug}/{lustre,lnet}/"
 	local proc_dirs=$(eval \ls -d $proc_regexp 2>/dev/null)
 	echo "proc_dirs='$proc_dirs'"
 	[ -n "$proc_dirs" ] || error "no proc_dirs on $HOSTNAME"
@@ -24167,6 +24789,15 @@ test_401d() {
 }
 run_test 401d "Verify 'lctl set_param' accepts values containing '='"
 
+test_401e() { # LU-14779
+	$LCTL list_param -R "ldlm.namespaces.MGC*" ||
+		error "lctl list_param MGC* failed"
+	$LCTL get_param "ldlm.namespaces.MGC*" || error "lctl get_param failed"
+	$LCTL get_param "ldlm.namespaces.MGC*.lru_size" ||
+		error "lctl get_param lru_size failed"
+}
+run_test 401e "verify 'lctl get_param' works with NID in parameter"
+
 test_402() {
 	[[ $MDS1_VERSION -ge $(version_code 2.7.66) ]] ||
 	[[ $MDS1_VERSION -ge $(version_code 2.7.18.4) &&
@@ -24473,6 +25104,99 @@ test_412() {
 }
 run_test 412 "mkdir on specific MDTs"
 
+generate_uneven_mdts() {
+	local threshold=$1
+	local lmv_qos_maxage
+	local lod_qos_maxage
+	local ffree
+	local bavail
+	local max
+	local min
+	local max_index
+	local min_index
+	local tmp
+	local i
+
+	lmv_qos_maxage=$($LCTL get_param -n lmv.*.qos_maxage)
+	$LCTL set_param lmv.*.qos_maxage=1
+	stack_trap "$LCTL set_param \
+		lmv.*.qos_maxage=$lmv_qos_maxage > /dev/null" RETURN
+	lod_qos_maxage=$(do_facet mds1 $LCTL get_param -n \
+		lod.$FSNAME-MDT0000-mdtlov.qos_maxage | awk '{ print $1 }')
+	do_nodes $(comma_list $(mdts_nodes)) $LCTL set_param \
+		lod.*.mdt_qos_maxage=1
+	stack_trap "do_nodes $(comma_list $(mdts_nodes)) $LCTL set_param \
+		lod.*.mdt_qos_maxage=$lod_qos_maxage > /dev/null" RETURN
+
+	echo
+	echo "Check for uneven MDTs: "
+
+	ffree=($(lctl get_param -n mdc.*[mM][dD][cC]-[^M]*.filesfree))
+	bavail=($(lctl get_param -n mdc.*[mM][dD][cC]-[^M]*.kbytesavail))
+	bsize=$(lctl get_param -n mdc.*MDT0000*.blocksize)
+
+	max=$(((${ffree[0]} >> 8) * (${bavail[0]} * bsize >> 16)))
+	min=$(((${ffree[0]} >> 8) * (${bavail[0]} * bsize >> 16)))
+	max_index=0
+	min_index=0
+	for ((i = 1; i < ${#ffree[@]}; i++)); do
+		tmp=$(((${ffree[i]} >> 8) * (${bavail[i]} * bsize >> 16)))
+		if [ $tmp -gt $max ]; then
+			max=$tmp
+			max_index=$i
+		fi
+		if [ $tmp -lt $min ]; then
+			min=$tmp
+			min_index=$i
+		fi
+	done
+
+	(( ${ffree[min_index]} > 0 )) ||
+		skip "no free files in MDT$min_index"
+	(( ${ffree[min_index]} < 10000000 )) ||
+		skip "too many free files in MDT$min_index"
+
+	# Check if we need to generate uneven MDTs
+	local diff=$(((max - min) * 100 / min))
+	local testdir=$DIR/$tdir-fillmdt
+	local start
+
+	mkdir -p $testdir
+
+	i=0
+	while (( diff < threshold )); do
+		# generate uneven MDTs, create till $threshold% diff
+		echo -n "weight diff=$diff% must be > $threshold% ..."
+		echo "Fill MDT$min_index with 1000 files: loop $i"
+		testdir=$DIR/$tdir-fillmdt/$i
+		[ -d $testdir ] || $LFS mkdir -i $min_index $testdir ||
+			error "mkdir $testdir failed"
+		$LFS setstripe -E 1M -L mdt $testdir ||
+			error "setstripe $testdir failed"
+		start=$SECONDS
+		for F in f.{0..999}; do
+			dd if=/dev/zero of=$testdir/$F bs=64K count=1 > \
+				/dev/null 2>&1 || error "dd $F failed"
+		done
+
+		# wait for QOS to update
+		(( SECONDS < start + 1 )) && sleep $((start + 1 - SECONDS))
+
+		ffree=($(lctl get_param -n mdc.*[mM][dD][cC]-*.filesfree))
+		bavail=($(lctl get_param -n mdc.*[mM][dD][cC]-*.kbytesavail))
+		max=$(((${ffree[max_index]} >> 8) * \
+			(${bavail[max_index]} * bsize >> 16)))
+		min=$(((${ffree[min_index]} >> 8) * \
+			(${bavail[min_index]} * bsize >> 16)))
+		diff=$(((max - min) * 100 / min))
+		i=$((i + 1))
+	done
+
+	echo "MDT filesfree available: ${ffree[@]}"
+	echo "MDT blocks available: ${bavail[@]}"
+	echo "weight diff=$diff%"
+}
+
 test_qos_mkdir() {
 	local mkdir_cmd=$1
 	local stripe_count=$2
@@ -24495,11 +25219,11 @@ test_qos_mkdir() {
 	lmv_qos_threshold_rr=${lmv_qos_threshold_rr%%%}
 	lmv_qos_maxage=$($LCTL get_param -n lmv.*.qos_maxage)
 	stack_trap "$LCTL set_param \
-		lmv.*.qos_prio_free=$lmv_qos_prio_free > /dev/null" EXIT
+		lmv.*.qos_prio_free=$lmv_qos_prio_free > /dev/null"
 	stack_trap "$LCTL set_param \
-		lmv.*.qos_threshold_rr=$lmv_qos_threshold_rr > /dev/null" EXIT
+		lmv.*.qos_threshold_rr=$lmv_qos_threshold_rr > /dev/null"
 	stack_trap "$LCTL set_param \
-		lmv.*.qos_maxage=$lmv_qos_maxage > /dev/null" EXIT
+		lmv.*.qos_maxage=$lmv_qos_maxage > /dev/null"
 
 	lod_qos_prio_free=$(do_facet mds1 $LCTL get_param -n \
 		lod.$FSNAME-MDT0000-mdtlov.mdt_qos_prio_free | head -n1)
@@ -24510,12 +25234,11 @@ test_qos_mkdir() {
 	lod_qos_maxage=$(do_facet mds1 $LCTL get_param -n \
 		lod.$FSNAME-MDT0000-mdtlov.qos_maxage | awk '{ print $1 }')
 	stack_trap "do_nodes $mdts $LCTL set_param \
-		lod.*.mdt_qos_prio_free=$lod_qos_prio_free > /dev/null" EXIT
+		lod.*.mdt_qos_prio_free=$lod_qos_prio_free > /dev/null"
 	stack_trap "do_nodes $mdts $LCTL set_param \
-		lod.*.mdt_qos_threshold_rr=$lod_qos_threshold_rr > /dev/null" \
-		EXIT
+		lod.*.mdt_qos_threshold_rr=$lod_qos_threshold_rr > /dev/null"
 	stack_trap "do_nodes $mdts $LCTL set_param \
-		lod.*.mdt_qos_maxage=$lod_qos_maxage > /dev/null" EXIT
+		lod.*.mdt_qos_maxage=$lod_qos_maxage > /dev/null"
 
 	$LCTL set_param lmv.*.qos_threshold_rr=100 > /dev/null
 	do_nodes $mdts $LCTL set_param lod.*.mdt_qos_threshold_rr=100 > /dev/null
@@ -24525,11 +25248,11 @@ test_qos_mkdir() {
 	local stripe_index=$($LFS getstripe -m $testdir)
 	local test_mkdir_rr=true
 
-	getfattr -d -m dmv $testdir | grep dmv
-	if [ $? -eq 0 ] && [ $MDS1_VERSION -ge $(version_code 2.14.51) ]; then
-		local inherit_rr=$($LFS getdirstripe -D --max-inherit-rr $testdir)
-
-		(( $inherit_rr == 0 )) && test_mkdir_rr=false
+	getfattr -d -m dmv -e hex $testdir | grep dmv
+	if (( $? == 0 && $MDS1_VERSION >= $(version_code 2.14.51) )); then
+		echo "defstripe: '$($LFS getdirstripe -D $testdir)'"
+		(( $($LFS getdirstripe -D --max-inherit-rr $testdir) == 0 )) &&
+			test_mkdir_rr=false
 	fi
 
 	echo
@@ -24537,41 +25260,37 @@ test_qos_mkdir() {
 		echo "Mkdir (stripe_count $stripe_count) roundrobin:" ||
 		echo "Mkdir (stripe_count $stripe_count) on stripe $stripe_index"
 
-	for i in $(seq $((100 * MDSCOUNT))); do
+	stack_trap "unlinkmany -d $testdir/subdir $((100 * MDSCOUNT))"
+	for (( i = 0; i < 100 * MDSCOUNT; i++ )); do
 		eval $mkdir_cmd $testdir/subdir$i ||
 			error "$mkdir_cmd subdir$i failed"
 	done
 
-	for i in $(seq $MDSCOUNT); do
-		count=$($LFS getdirstripe -i $testdir/* |
-				grep ^$((i - 1))$ | wc -l)
-		echo "$count directories created on MDT$((i - 1))"
+	for (( i = 0; i < $MDSCOUNT; i++ )); do
+		count=$($LFS getdirstripe -i $testdir/* | grep -c "^$i$")
+		echo "$count directories created on MDT$i"
 		if $test_mkdir_rr; then
 			(( $count == 100 )) ||
 				error "subdirs are not evenly distributed"
-		elif [ $((i - 1)) -eq $stripe_index ]; then
+		elif (( $i == $stripe_index )); then
 			(( $count == 100 * MDSCOUNT )) ||
-				error "$count subdirs created on MDT$((i - 1))"
+				error "$count subdirs created on MDT$i"
 		else
 			(( $count == 0 )) ||
-				error "$count subdirs created on MDT$((i - 1))"
+				error "$count subdirs created on MDT$i"
 		fi
 
 		if $test_mkdir_rr && [ $stripe_count -gt 1 ]; then
 			count=$($LFS getdirstripe $testdir/* |
-				grep -P "^\s+$((i - 1))\t" | wc -l)
-			echo "$count stripes created on MDT$((i - 1))"
+				grep -c -P "^\s+$i\t")
+			echo "$count stripes created on MDT$i"
 			# deviation should < 5% of average
-			(( $count < 95 * stripe_count )) ||
-			(( $count > 105 * stripe_count)) &&
+			(( $count >= 95 * stripe_count &&
+			   $count <= 105 * stripe_count)) ||
 				error "stripes are not evenly distributed"
 		fi
 	done
 
-	$LCTL set_param lmv.*.qos_threshold_rr=$lmv_qos_threshold_rr > /dev/null
-	do_nodes $mdts $LCTL set_param \
-		lod.*.mdt_qos_threshold_rr=$lod_qos_threshold_rr > /dev/null
-
 	echo
 	echo "Check for uneven MDTs: "
 
@@ -24603,47 +25322,20 @@ test_qos_mkdir() {
 		fi
 	done
 
-	(( ${ffree[min_index]} == 0 )) &&
+	(( ${ffree[min_index]} > 0 )) ||
 		skip "no free files in MDT$min_index"
-	(( ${ffree[min_index]} > 100000000 )) &&
+	(( ${ffree[min_index]} < 10000000 )) ||
 		skip "too many free files in MDT$min_index"
 
-	# Check if we need to generate uneven MDTs
-	local threshold=50
-	local diff=$(((max - min) * 100 / min))
-	local value="$(generate_string 1024)"
-
-	while [ $diff -lt $threshold ]; do
-		# generate uneven MDTs, create till $threshold% diff
-		echo -n "weight diff=$diff% must be > $threshold% ..."
-		count=$((${ffree[min_index]} / 10))
-		# 50 sec per 10000 files in vm
-		(( $count < 100000 )) || [ "$SLOW" != "no" ] ||
-			skip "$count files to create"
-		echo "Fill MDT$min_index with $count files"
-		[ -d $DIR/$tdir-MDT$min_index ] ||
-			$LFS mkdir -i $min_index $DIR/$tdir-MDT$min_index ||
-			error "mkdir $tdir-MDT$min_index failed"
-		createmany -d $DIR/$tdir-MDT$min_index/d $count ||
-			error "create d$count failed"
-
-		ffree=($(lctl get_param -n mdc.*[mM][dD][cC]-*.filesfree))
-		bavail=($(lctl get_param -n mdc.*[mM][dD][cC]-*.kbytesavail))
-		max=$(((${ffree[max_index]} >> 8) * \
-			(${bavail[max_index]} * bsize >> 16)))
-		min=$(((${ffree[min_index]} >> 8) * \
-			(${bavail[min_index]} * bsize >> 16)))
-		diff=$(((max - min) * 100 / min))
-	done
-
 	echo "MDT filesfree available: ${ffree[@]}"
 	echo "MDT blocks available: ${bavail[@]}"
-	echo "weight diff=$diff%"
-
+	echo "weight diff=$(((max - min) * 100 / min))%"
 	echo
 	echo "Mkdir (stripe_count $stripe_count) with balanced space usage:"
 
+	$LCTL set_param lmv.*.qos_threshold_rr=0 > /dev/null
 	$LCTL set_param lmv.*.qos_prio_free=100 > /dev/null
+	do_nodes $mdts $LCTL set_param lod.*.mdt_qos_threshold_rr=0 > /dev/null
 	do_nodes $mdts $LCTL set_param lod.*.mdt_qos_prio_free=100 > /dev/null
 	# decrease statfs age, so that it can be updated in time
 	$LCTL set_param lmv.*.qos_maxage=1 > /dev/null
@@ -24652,42 +25344,66 @@ test_qos_mkdir() {
 	sleep 1
 
 	testdir=$DIR/$tdir-s$stripe_count/qos
+	local num=200
 
-	for i in $(seq $((100 * MDSCOUNT))); do
+	stack_trap "unlinkmany -d $testdir/subdir $((num * MDSCOUNT))"
+	for (( i = 0; i < num * MDSCOUNT; i++ )); do
 		eval $mkdir_cmd $testdir/subdir$i ||
 			error "$mkdir_cmd subdir$i failed"
 	done
 
-	for i in $(seq $MDSCOUNT); do
-		count=$($LFS getdirstripe -i $testdir/* | grep ^$((i - 1))$ |
-			wc -l)
-		echo "$count directories created on MDT$((i - 1))"
-
-		if [ $stripe_count -gt 1 ]; then
-			count=$($LFS getdirstripe $testdir/* |
-				grep -P "^\s+$((i - 1))\t" | wc -l)
-			echo "$count stripes created on MDT$((i - 1))"
-		fi
+	max=0
+	for (( i = 0; i < $MDSCOUNT; i++ )); do
+		count=$($LFS getdirstripe -i $testdir/* | grep -c "^$i$")
+		(( count > max )) && max=$count
+		echo "$count directories created on MDT$i"
 	done
 
-	max=$($LFS getdirstripe -i $testdir/* | grep ^$max_index$ | wc -l)
-	min=$($LFS getdirstripe -i $testdir/* | grep ^$min_index$ | wc -l)
+	min=$($LFS getdirstripe -i $testdir/* | grep -c "^$min_index$")
 
 	# D-value should > 10% of averge
-	(( $max - $min < 10 )) &&
-		error "subdirs shouldn't be evenly distributed"
+	(( max - min > num / 10 )) ||
+		error "subdirs shouldn't be evenly distributed: $max - $min < $((num / 10))"
+
+	# ditto for stripes
+	if (( stripe_count > 1 )); then
+		max=0
+		for (( i = 0; i < $MDSCOUNT; i++ )); do
+			count=$($LFS getdirstripe $testdir/* |
+				grep -c -P "^\s+$i\t")
+			(( count > max )) && max=$count
+			echo "$count stripes created on MDT$i"
+		done
 
-	# ditto
-	if [ $stripe_count -gt 1 ]; then
-		max=$($LFS getdirstripe $testdir/* |
-			grep -P "^\s+$max_index\t" | wc -l)
 		min=$($LFS getdirstripe $testdir/* |
-			grep -P "^\s+$min_index\t" | wc -l)
-		(( $max - $min < 10 * $stripe_count )) &&
-			error "stripes shouldn't be evenly distributed"|| true
+			grep -c -P "^\s+$min_index\t")
+		(( max - min > num * stripe_count / 10 )) ||
+			error "stripes shouldn't be evenly distributed: $max - $min < $((num / 10)) * $stripe_count"
 	fi
 }
 
+most_full_mdt() {
+	local ffree
+	local bavail
+	local bsize
+	local min
+	local min_index
+	local tmp
+
+	ffree=($(lctl get_param -n mdc.*[mM][dD][cC]-[^M]*.filesfree))
+	bavail=($(lctl get_param -n mdc.*[mM][dD][cC]-[^M]*.kbytesavail))
+	bsize=$(lctl get_param -n mdc.*MDT0000*.blocksize)
+
+	min=$(((${ffree[0]} >> 8) * (${bavail[0]} * bsize >> 16)))
+	min_index=0
+	for ((i = 1; i < ${#ffree[@]}; i++)); do
+		tmp=$(((${ffree[i]} >> 8) * (${bavail[i]} * bsize >> 16)))
+		(( tmp < min )) && min=$tmp && min_index=$i
+	done
+
+	echo -n $min_index
+}
+
 test_413a() {
 	[ $MDSCOUNT -lt 2 ] &&
 		skip "We need at least 2 MDTs for this test"
@@ -24697,11 +25413,13 @@ test_413a() {
 
 	local stripe_count
 
+	generate_uneven_mdts 100
 	for stripe_count in $(seq 1 $((MDSCOUNT - 1))); do
 		mkdir $DIR/$tdir-s$stripe_count || error "mkdir failed"
 		mkdir $DIR/$tdir-s$stripe_count/rr || error "mkdir failed"
-		mkdir $DIR/$tdir-s$stripe_count/qos || error "mkdir failed"
-		test_qos_mkdir "$LFS mkdir -c $stripe_count" $stripe_count
+		$LFS mkdir -i $(most_full_mdt) $DIR/$tdir-s$stripe_count/qos ||
+			error "mkdir failed"
+		test_qos_mkdir "$LFS mkdir -i -1 -c $stripe_count" $stripe_count
 	done
 }
 run_test 413a "QoS mkdir with 'lfs mkdir -i -1'"
@@ -24716,11 +25434,13 @@ test_413b() {
 	local testdir
 	local stripe_count
 
+	generate_uneven_mdts 100
 	for stripe_count in $(seq 1 $((MDSCOUNT - 1))); do
 		testdir=$DIR/$tdir-s$stripe_count
 		mkdir $testdir || error "mkdir $testdir failed"
 		mkdir $testdir/rr || error "mkdir rr failed"
-		mkdir $testdir/qos || error "mkdir qos failed"
+		$LFS mkdir -i $(most_full_mdt) $testdir/qos ||
+			error "mkdir qos failed"
 		$LFS setdirstripe -D -c $stripe_count --max-inherit-rr 2 \
 			$testdir/rr || error "setdirstripe rr failed"
 		$LFS setdirstripe -D -c $stripe_count $testdir/qos ||
@@ -24731,11 +25451,11 @@ test_413b() {
 run_test 413b "QoS mkdir under dir whose default LMV starting MDT offset is -1"
 
 test_413c() {
-	[ $MDSCOUNT -ge 2 ] ||
+	(( $MDSCOUNT >= 2 )) ||
 		skip "We need at least 2 MDTs for this test"
 
-	[ $MDS1_VERSION -ge $(version_code 2.14.51) ] ||
-		skip "Need server version at least 2.14.50"
+	(( $MDS1_VERSION >= $(version_code 2.14.51) )) ||
+		skip "Need server version at least 2.14.51"
 
 	local testdir
 	local inherit
@@ -24744,11 +25464,11 @@ test_413c() {
 	testdir=$DIR/${tdir}-s1
 	mkdir $testdir || error "mkdir $testdir failed"
 	mkdir $testdir/rr || error "mkdir rr failed"
-	mkdir $testdir/qos || error "mkdir qos failed"
+	$LFS mkdir -i $(most_full_mdt) $testdir/qos || error "mkdir qos failed"
 	# default max_inherit is -1, default max_inherit_rr is 0
 	$LFS setdirstripe -D -c 1 $testdir/rr ||
 		error "setdirstripe rr failed"
-	$LFS setdirstripe -D -c 1 -X 2 --max-inherit-rr 1 $testdir/qos ||
+	$LFS setdirstripe -D -c 1 -i -1 -X 2 --max-inherit-rr 1 $testdir/qos ||
 		error "setdirstripe qos failed"
 	test_qos_mkdir "mkdir" 1
 
@@ -24756,21 +25476,62 @@ test_413c() {
 	inherit=$($LFS getdirstripe -D -X $testdir/rr/level1)
 	(( $inherit == -1 )) || error "rr/level1 inherit $inherit != -1"
 	inherit_rr=$($LFS getdirstripe -D --max-inherit-rr $testdir/rr/level1)
-	(( $inherit_rr == 0 )) ||
-		error "rr/level1 inherit-rr $inherit_rr != 0"
+	(( $inherit_rr == 0 )) || error "rr/level1 inherit-rr $inherit_rr != 0"
 
 	mkdir $testdir/qos/level1 || error "mkdir qos/level1 failed"
 	inherit=$($LFS getdirstripe -D -X $testdir/qos/level1)
 	(( $inherit == 1 )) || error "qos/level1 inherit $inherit != 1"
 	inherit_rr=$($LFS getdirstripe -D --max-inherit-rr $testdir/qos/level1)
-	(( $inherit_rr == 0 )) ||
-		error "qos/level1 inherit-rr $inherit_rr !=0"
+	(( $inherit_rr == 0 )) || error "qos/level1 inherit-rr $inherit_rr != 0"
 	mkdir $testdir/qos/level1/level2 || error "mkdir level2 failed"
-	getfattr -d -m dmv $testdir/qos/level1/level2 | grep dmv &&
+	getfattr -d -m dmv -e hex $testdir/qos/level1/level2 | grep dmv &&
 		error "level2 shouldn't have default LMV" || true
 }
 run_test 413c "mkdir with default LMV max inherit rr"
 
+test_413d() {
+	(( MDSCOUNT >= 2 )) ||
+		skip "We need at least 2 MDTs for this test"
+
+	(( MDS1_VERSION >= $(version_code 2.14.51) )) ||
+		skip "Need server version at least 2.14.51"
+
+	local lmv_qos_threshold_rr
+
+	lmv_qos_threshold_rr=$($LCTL get_param -n lmv.*.qos_threshold_rr |
+		head -n1)
+	stack_trap "$LCTL set_param \
+		lmv.*.qos_threshold_rr=$lmv_qos_threshold_rr > /dev/null" EXIT
+
+	$LCTL set_param lmv.*.qos_threshold_rr=100 > /dev/null
+	mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
+	getfattr -d -m dmv -e hex $DIR/$tdir | grep dmv &&
+		error "$tdir shouldn't have default LMV"
+	createmany -d $DIR/$tdir/sub $((100 * MDSCOUNT)) ||
+		error "mkdir sub failed"
+
+	local count=$($LFS getstripe -m $DIR/$tdir/* | grep -c ^0)
+
+	(( count == 100 )) || error "$count subdirs on MDT0"
+}
+run_test 413d "inherit ROOT default LMV"
+
+test_413z() {
+	local pids=""
+	local subdir
+	local pid
+
+	for subdir in $(\ls -1 -d $DIR/d413*-fillmdt/*); do
+		unlinkmany $subdir/f. 1000 &
+		pids="$pids $!"
+	done
+
+	for pid in $pids; do
+		wait $pid
+	done
+}
+run_test 413z "413 test cleanup"
+
 test_414() {
 #define OBD_FAIL_PTLRPC_BULK_ATTACH      0x521
 	$LCTL set_param fail_loc=0x80000521
@@ -24886,7 +25647,8 @@ check_lfs_df() {
 	[ "$1" == "blocks" ] && inodes= || inodes="-i"
 
 	for count in {1..100}; do
-		cancel_lru_locks
+		do_nodes "$CLIENTS" \
+			$LCTL set_param ldlm.namespaces.*.lru_size=clear
 		sync; sleep 0.2
 
 		# read the lines of interest
@@ -24899,7 +25661,9 @@ check_lfs_df() {
 		# "<NID>:/<fsname>" for df, "filesystem_summary:" for lfs df
 		# compare the two outputs
 		passed=true
-		for i in {1..5}; do
+		#  skip "available" on MDT until LU-13997 is fixed.
+		#for i in {1..5}; do
+		for i in 1 2 4 5; do
 			[ "${df_out[i]}" != "${lfs_df_out[i]}" ] && passed=false
 		done
 		$passed && break
@@ -25698,6 +26462,38 @@ test_431() { # LU-14187
 }
 run_test 431 "Restart transaction for IO"
 
+cleanup_test_432() {
+	do_facet mgs $LCTL nodemap_activate 0
+	wait_nm_sync active
+}
+
+test_432() {
+	local tmpdir=$TMP/dir432
+
+	(( $MDS1_VERSION >= $(version_code 2.14.52) )) ||
+		skip "Need MDS version at least 2.14.52"
+
+	stack_trap cleanup_test_432 EXIT
+	mkdir $DIR/$tdir
+	mkdir $tmpdir
+
+	do_facet mgs $LCTL nodemap_activate 1
+	wait_nm_sync active
+	do_facet mgs $LCTL nodemap_modify --name default \
+		--property admin --value 1
+	do_facet mgs $LCTL nodemap_modify --name default \
+		--property trusted --value 1
+	cancel_lru_locks mdc
+	wait_nm_sync default admin_nodemap
+	wait_nm_sync default trusted_nodemap
+
+	if [ $(mv $tmpdir $DIR/$tdir/ 2>&1 |
+	       grep -ci "Operation not permitted") -ne 0 ]; then
+		error "mv $tmpdir $DIR/$tdir/ hits 'Operation not permitted'"
+	fi
+}
+run_test 432 "mv dir from outside Lustre"
+
 prep_801() {
 	[[ $MDS1_VERSION -lt $(version_code 2.9.55) ]] ||
 	[[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
@@ -26786,15 +27582,24 @@ test_817() {
 run_test 817 "nfsd won't cache write lock for exec file"
 
 test_818() {
-	mkdir $DIR/$tdir
-	$LFS setstripe -c1 -i0 $DIR/$tfile
-	$LFS setstripe -c1 -i1 $DIR/$tfile
+	test_mkdir -i0 -c1 $DIR/$tdir
+	$LFS setstripe -c1 -i0 $DIR/$tdir/$tfile
+	$LFS setstripe -c1 -i1 $DIR/$tdir/$tfile
 	stop $SINGLEMDS
+
+	# restore osp-syn threads
+	stack_trap "fail $SINGLEMDS"
+
 	#define OBD_FAIL_OSP_CANT_PROCESS_LLOG		0x2105
 	do_facet $SINGLEMDS lctl set_param fail_loc=0x80002105
 	start $SINGLEMDS $(mdsdevname ${SINGLEMDS//mds/}) $MDS_MOUNT_OPTS ||
 		error "start $SINGLEMDS failed"
 	rm -rf $DIR/$tdir
+
+	local testid=$(echo $TESTNAME | tr '_' ' ')
+
+	do_facet mds1 dmesg | tac | sed "/$testid/,$ d" |
+		grep "run LFSCK" || error "run LFSCK is not suggested"
 }
 run_test 818 "unlink with failed llog"
 
@@ -26892,6 +27697,78 @@ test_822() {
 }
 run_test 822 "test precreate failure"
 
+test_823() {
+	local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+	local OST_MAX_PRECREATE=20000
+
+	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=$OST_MAX_PRECREATE"
+
+	stack_trap "restore_lustre_params < $p; rm $p"
+
+	do_facet $SINGLEMDS "$LCTL set_param -n \
+		osp.$FSNAME-OST*-osc-MDT*.create_count=100200"
+
+	local count=$(do_facet $SINGLEMDS "$LCTL get_param -n \
+		      osp.$FSNAME-OST0000*MDT0000.create_count")
+	local max=$(do_facet $SINGLEMDS "$LCTL get_param -n \
+		    osp.$FSNAME-OST0000*MDT0000.max_create_count")
+	local expect_count=$(((($max/2)/256) * 256))
+
+	log "setting create_count to 100200:"
+	log " -result- count: $count with max: $max, expecting: $expect_count"
+
+	[[ $count -eq expect_count ]] ||
+		error "Create count not set to max precreate."
+}
+run_test 823 "Setting create_count > OST_MAX_PRECREATE is lowered to maximum"
+
+test_831() {
+	local sync_changes=$(do_facet $SINGLEMDS \
+		$LCTL get_param -n osp.$FSNAME-OST0000-osc-MDT0000.sync_changes)
+
+	[ "$sync_changes" -gt 100 ] &&
+		skip "Sync changes $sync_changes > 100 already"
+
+	local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
+
+	$LFS mkdir -i 0 $DIR/$tdir
+	$LFS setstripe -c 1 -i 0 $DIR/$tdir
+
+	save_lustre_params mds1 \
+		"osp.$FSNAME-OST*-osc-MDT0000.max_sync_changes" > $p
+	save_lustre_params mds1	\
+		"osp.$FSNAME-OST*-osc-MDT0000.max_rpcs_in_progress" >> $p
+
+	do_facet mds1 "$LCTL set_param -n \
+		osp.$FSNAME-OST*-osc-MDT0000.max_sync_changes=100 \
+		osp.$FSNAME-OST*-osc-MDT0000.max_rpcs_in_progress=128"
+	stack_trap "restore_lustre_params < $p" EXIT
+
+	createmany -o $DIR/$tdir/f- 1000
+	unlinkmany $DIR/$tdir/f- 1000 &
+	local UNLINK_PID=$!
+
+	while sleep 1; do
+		sync_changes=$(do_facet mds1 \
+		$LCTL get_param -n osp.$FSNAME-OST0000-osc-MDT0000.sync_changes)
+		# the check in the code is racy, fail the test
+		# if the value above the limit by 10.
+		[ $sync_changes -gt 110 ] && {
+			kill -2 $UNLINK_PID
+			wait
+			error "osp changes throttling failed, $sync_changes>110"
+		}
+		kill -0 $UNLINK_PID 2> /dev/null || break
+	done
+	wait
+}
+run_test 831 "throttling unlink/setattr queuing on OSP"
+
 #
 # tests that do cleanup/setup should be run at the end
 #
@@ -26947,6 +27824,21 @@ test_902() {
 }
 run_test 902 "test short write doesn't hang lustre"
 
+# LU-14711
+test_903() {
+	$LFS setstripe -i 0 -c 1 $DIR/$tfile $DIR/${tfile}-2
+	echo "blah" > $DIR/${tfile}-2
+	dd if=/dev/zero of=$DIR/$tfile bs=1M count=6 conv=fsync
+	#define OBD_FAIL_OSC_SLOW_PAGE_EVICT 0x417
+	$LCTL set_param fail_loc=0x417 fail_val=20
+
+	mv $DIR/${tfile}-2 $DIR/$tfile # Destroys the big object
+	sleep 1 # To start the destroy
+	wait_destroy_complete 150 || error "Destroy taking too long"
+	cat $DIR/$tfile > /dev/null || error "Evicted"
+}
+run_test 903 "Test long page discard does not cause evictions"
+
 complete $SECONDS
 [ -f $EXT2_DEV ] && rm $EXT2_DEV || true
 check_and_cleanup_lustre