X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Ftests%2Fsanity-quota.sh;h=b81a2417f27ca1339845e0e1cd784e3faec9e10e;hb=33b82aa398e5ecd3c29d0a9eb5f5eba73611c6f6;hp=ab43295586c955af61869bab9e74f1c481340c88;hpb=d81556d5d57f2880f4571b46c1639bab154e60f4;p=fs%2Flustre-release.git

diff --git a/lustre/tests/sanity-quota.sh b/lustre/tests/sanity-quota.sh
index ab43295..b81a241 100644
--- a/lustre/tests/sanity-quota.sh
+++ b/lustre/tests/sanity-quota.sh
@@ -17,7 +17,7 @@ SRCDIR=`dirname $0`
 export PATH=$PWD/$SRCDIR:$SRCDIR:$PWD/$SRCDIR/../utils:$PATH:/sbin
 
 ONLY=${ONLY:-"$*"}
-ALWAYS_EXCEPT=${ALWAYS_EXCEPT:-""}
+ALWAYS_EXCEPT="$SANITY_QUOTA_EXCEPT"
 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
 
 case `uname -r` in
@@ -31,13 +31,8 @@ esac
 TMP=${TMP:-/tmp}
 
 ORIG_PWD=${PWD}
-LFS=${LFS:-lfs}
-LCTL=${LCTL:-lctl}
-SETSTRIPE=${SETSTRIPE:-"$LFS setstripe"}
 TSTID=${TSTID:-60000}
 TSTID2=${TSTID2:-60001}
-RUNAS=${RUNAS:-"runas -u $TSTID"}
-RUNAS2=${RUNAS2:-"runas -u $TSTID2"}
 TSTUSR=${TSTUSR:-"quota_usr"}
 TSTUSR2=${TSTUSR2:-"quota_2usr"}
 BLK_SZ=1024
@@ -54,55 +49,27 @@ LUSTRE=${LUSTRE:-`dirname $0`/..}
 init_test_env $@
 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
 
+[ "$SLOW" = "no" ] && EXCEPT_SLOW="9 10 11"
+
 QUOTALOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}
-FAIL_ON_ERROR=false
 
 [ "$QUOTALOG" ] && rm -f $QUOTALOG || true
 
-mounted_lustre_filesystems() {
-	awk '($3 ~ "lustre" && $1 ~ ":") { print $2 }' /proc/mounts | sed -n ${1}p
-}
-
-# Remember where our caller has hinted that we should mount lustre
-MOUNT_HINT=$MOUNT
-MOUNT_HINT2=$MOUNT_2
-MOUNT="`mounted_lustre_filesystems 1`"
-MOUNT_2="`mounted_lustre_filesystems 2`"
-if [ "$MOUNT" -a "$MOUNT_2" ]; then
-	echo "testing on $MOUNT and $MOUNT_2"
-elif [ "$MOUNT" -o "$MOUNT_2" ]; then
-        error "test needs two mounts, only found $MOUNT $MOUNT_2!"
-else
-	export QUOTA_OPTS="quotaon=ug"
-	export MOUNT=$MOUNT_HINT 
-	export MOUNT_2=$MOUNT_HINT2
-	MOUNT_2=${MOUNT_2:-/mnt/lustre_2}
-	sh llmount.sh 
-	MOUNT="`mounted_lustre_filesystems 1`"
-	MOUNT_2="`mounted_lustre_filesystems 2`"
-	[ -z "$MOUNT" ] && error "NAME=$MOUNT not mounted"
-	[ -z "$MOUNT_2" ] && error "NAME=$MOUNT_2 not mounted"
-	I_MOUNTED=yes
-fi
-
-[ `echo $MOUNT | wc -w` -gt 1 ] && error "NAME=$NAME mounted more than once"
-
 DIR=${DIR:-$MOUNT}
-[ -z "`echo $DIR | grep $MOUNT`" ] && echo "$DIR not in $MOUNT" && exit 99
-DIR2=${DIR2:-$MOUNT_2}
+DIR2=${DIR2:-$MOUNT2}
+
+cleanup_and_setup_lustre
 
 LOVNAME=`cat $LPROC/llite/*/lov/common_name | tail -n 1`
 OSTCOUNT=`cat $LPROC/lov/$LOVNAME/numobd`
-STRIPECOUNT=`cat $LPROC/lov/$LOVNAME/stripecount`
-STRIPESIZE=`cat $LPROC/lov/$LOVNAME/stripesize`
-ORIGFREE=`cat $LPROC/lov/$LOVNAME/kbytesavail`
-MAXFREE=${MAXFREE:-$((200000 * $OSTCOUNT))}
-MDS=$(\ls $LPROC/mdt 2> /dev/null | grep -v num_refs | tail -n 1)
-TSTDIR=$DIR/quota_test_dir
-TSTDIR2=$DIR2/quota_test_dir
-SHOW_QUOTA_USER="$LFS quota -u $TSTUSR $MOUNT"
-SHOW_QUOTA_GROUP="$LFS quota -g $TSTUSR $MOUNT"
-SHOW_QUOTA_INFO="$LFS quota -t $MOUNT"
+
+SHOW_QUOTA_USER="$LFS quota -u $TSTUSR $DIR"
+SHOW_QUOTA_GROUP="$LFS quota -g $TSTUSR $DIR"
+SHOW_QUOTA_INFO="$LFS quota -t $DIR"
+
+# control the time of tests
+cycle=30
+[ "$SLOW" = "no" ] && cycle=10
 
 build_test_filter
 
@@ -112,45 +79,45 @@ eval ONLY_99=true
 # set_blk_tunables(btune_sz)
 set_blk_tunesz() {
 	# set btune size on all obdfilters
-	for i in /proc/fs/lustre/obdfilter/*/quota_btune_sz; do
-		echo $(($1 * $BLK_SZ)) > $i
-	done
+	do_facet ost1 "set -x; for i in /proc/fs/lustre/obdfilter/*/quota_btune_sz; do
+		echo $(($1 * BLK_SZ)) >> \\\$i;
+	done"
 	# set btune size on mds
-	for i in /proc/fs/lustre/mds/lustre-MDT*/quota_btune_sz; do
-		echo $(($1 * $BLK_SZ)) > $i
-	done
+	do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_btune_sz; do
+		echo $(($1 * BLK_SZ)) >> \\\$i;
+	done"
 }
 
 # set_blk_unitsz(bunit_sz)
 set_blk_unitsz() {
-	for i in /proc/fs/lustre/obdfilter/*/quota_bunit_sz; do
-		echo $(($1 * $BLK_SZ)) > $i
-	done
-	for i in /proc/fs/lustre/mds/lustre-MDT*/quota_bunit_sz; do
-		echo $(($1 * $BLK_SZ)) > $i
-	done
+	do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_bunit_sz; do
+		echo $(($1 * BLK_SZ)) >> \\\$i;
+	done"
+	do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_bunit_sz; do
+		echo $(($1 * BLK_SZ)) >> \\\$i;
+	done"
 }
 
 # set_file_tunesz(itune_sz)
 set_file_tunesz() {
 	# set iunit and itune size on all obdfilters
-	for i in /proc/fs/lustre/obdfilter/*/quota_itune_sz; do
-		echo $1 > $i
-	done
+	do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_itune_sz; do
+		echo $1 >> \\\$i;
+	done"
 	# set iunit and itune size on mds
-	for i in /proc/fs/lustre/mds/lustre-MDT*/quota_itune_sz; do
-		echo $1 > $i
-	done
+	do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_itune_sz; do
+		echo $1 >> \\\$i;
+	done"
 }
 
 # set_file_unitsz(iunit_sz)
 set_file_unitsz() {
-	for i in `ls /proc/fs/lustre/obdfilter/*/quota_iunit_sz`; do
-		echo $1 > $i
-	done;
-	for i in `ls /proc/fs/lustre/mds/lustre-MDT*/quota_iunit_sz`; do
-		echo $1 > $i
-	done
+	do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_iunit_sz; do
+		echo $1 >> \\\$i;
+	done"
+	do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_iunit_sz; do
+		echo $1 >> \\\$i;
+	done"
 }
 
 # These are for test on local machine,if run sanity-quota.sh on 
@@ -181,63 +148,36 @@ post_test() {
 	fi
 }
 
-setup() {
-	# create local test group
-	GRP="`cat /etc/group | grep "^${TSTUSR}:" | awk -F: '{print $1}'`"
-	if [ -z "$GRP" ]; then
-		groupadd -g $TSTID "$TSTUSR"
-	fi
-	TSTID="`cat /etc/group | grep "^${TSTUSR}:" | awk -F: '{print $3}'`"
-
-        GRP2="`cat /etc/group | grep "^${TSTUSR2}:" | awk -F: '{print $1}'`"
-        if [ -z "$GRP2" ]; then
-                groupadd -g $TSTID2 "$TSTUSR2"
-        fi
-        TSTID2="`cat /etc/group | grep "^${TSTUSR2}:" | awk -F: '{print $3}'`"
-
-	# create test user
-	USR="`cat /etc/passwd | grep "^${TSTUSR}:" | awk -F: '{print $1}'`"
-	if [ -z "$USR" ]; then
-		useradd -u $TSTID -g $TSTID -d /tmp "$TSTUSR"
-	fi
-	
-	RUNAS="runas -u $TSTID"
-
-	USR2="`cat /etc/passwd | grep "^${TSTUSR2}:" | awk -F: '{print $1}'`"
-        if [ -z "$USR2" ]; then
-                useradd -u $TSTID2 -g $TSTID2 -d /tmp "$TSTUSR2"
-        fi
-
-        RUNAS2="runas -u $TSTID2"
-	
-	# create test directory
-	rm -fr $TSTDIR
+RUNAS="runas -u $TSTID"
+RUNAS2="runas -u $TSTID2"
+FAIL_ON_ERROR=true check_runas_id $TSTID $RUNAS
+FAIL_ON_ERROR=true check_runas_id $TSTID2 $RUNAS2
 
-	mkdir -p $TSTDIR 
-	chmod 777 $TSTDIR
-}
-setup
+FAIL_ON_ERROR=false
 
 # set quota
 test_0() {
-	$LFS quotaoff -ug $MOUNT
-	$LFS quotacheck -ug $MOUNT
+	$LFS quotaoff -ug $DIR
+	$LFS quotacheck -ug $DIR
 
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
-	$LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR
+	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 }
 run_test 0 "Set quota ============================="
 
 # block hard limit (normal use and out of quota)
 test_1() {
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
+
 	LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 5)) # 5 bunits each sever
-	TESTFILE="$TSTDIR/quota_tst10"
+	TESTFILE=$DIR/$tdir/$tfile-0	
 	
 	echo "  User quota (limit: $LIMIT kbytes)"
-	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 	$SHOW_QUOTA_USER
 	
-	$LFS setstripe $TESTFILE 65536 0 1
+	$LFS setstripe $TESTFILE -c 1
 	chown $TSTUSR.$TSTUSR $TESTFILE
 
 	echo "    Write ..."
@@ -253,12 +193,12 @@ test_1() {
 	rm -f $TESTFILE
 	
 	echo "  Group quota (limit: $LIMIT kbytes)"
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT		# clear user limit
-	$LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR		# clear user limit
+	$LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
 	$SHOW_QUOTA_GROUP
-	TESTFILE="$TSTDIR/quota_tst11"
+	TESTFILE=$DIR/$tdir/$tfile-1	
 
-	$LFS setstripe $TESTFILE 65536 0 1
+	$LFS setstripe $TESTFILE -c 1
 	chown $TSTUSR.$TSTUSR $TESTFILE
 
 	echo "    Write ..."
@@ -272,22 +212,25 @@ test_1() {
 
 	# cleanup
 	rm -f $TESTFILE
-	$LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 }
 run_test 1 "Block hard limit (normal use and out of quota) ==="
 
 # file hard limit (normal use and out of quota)
 test_2() {
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
+
 	LIMIT=$(($IUNIT_SZ * 10)) # 10 iunits on mds
-	TESTFILE="$TSTDIR/quota_tstr20"
+	TESTFILE=$DIR/$tdir/$tfile-0	
 
 	echo "  User quota (limit: $LIMIT files)"
-	$LFS setquota -u $TSTUSR 0 0 0 $LIMIT $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 $LIMIT $DIR
 	$SHOW_QUOTA_USER
 
 	echo "    Create $LIMIT files ..."
 	$RUNAS createmany -m ${TESTFILE} $LIMIT || \
-	    error "(usr) create failure, but except success"
+	    error "(usr) create failure, but expect success"
 	echo "    Done"
 	echo "    Create out of file quota ..."
 	$RUNAS touch ${TESTFILE}_xxx && \
@@ -297,10 +240,10 @@ test_2() {
 	rm ${TESTFILE}_xxx
 
 	echo "  Group quota (limit: $LIMIT files)"
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT		# clear user limit
-	$LFS setquota -g $TSTUSR 0 0 0 $LIMIT $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR		# clear user limit
+	$LFS setquota -g $TSTUSR 0 0 0 $LIMIT $DIR
 	$SHOW_QUOTA_GROUP
-	TESTFILE="$TSTDIR/quota_tst21"
+	TESTFILE=$DIR/$tdir/$tfile-1
 
 	echo "    Create $LIMIT files ..."
 	$RUNAS createmany -m ${TESTFILE} $LIMIT || \
@@ -317,7 +260,7 @@ test_2() {
 	unlinkmany ${TESTFILE} $LIMIT
 	rm ${TESTFILE}_xxx
 
-	$LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 }
 run_test 2 "File hard limit (normal use and out of quota) ==="
 
@@ -382,30 +325,35 @@ test_block_soft() {
 
 # block soft limit (start timer, timer goes off, stop timer)
 test_3() {
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
+
 	LIMIT=$(( $BUNIT_SZ * 2 )) # 1 bunit on mds and 1 bunit on the ost
 	GRACE=10
 
 	echo "  User quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
-	TESTFILE="$TSTDIR/quota_tst30"
-	$LFS setstripe $TESTFILE 65536 0 1
+	TESTFILE=$DIR/$tdir/$tfile-0
+
+	$LFS setstripe $TESTFILE -c 1
 	chown $TSTUSR.$TSTUSR $TESTFILE
 
-	$LFS setquota -t -u $GRACE $MAX_IQ_TIME $MOUNT
-	$LFS setquota -u $TSTUSR $LIMIT 0 0 0 $MOUNT
+	$LFS setquota -t -u $GRACE $MAX_IQ_TIME $DIR
+	$LFS setquota -u $TSTUSR $LIMIT 0 0 0 $DIR
 
 	test_block_soft $TESTFILE $GRACE
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 
 	echo "  Group quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
-	TESTFILE="$TSTDIR/quota_tst31"
-	$LFS setstripe $TESTFILE 65536 0 1
+	TESTFILE=$DIR/$tdir/$tfile-1
+
+	$LFS setstripe $TESTFILE -c 1
 	chown $TSTUSR.$TSTUSR $TESTFILE
 
-	$LFS setquota -t -g $GRACE $MAX_IQ_TIME $MOUNT
-	$LFS setquota -g $TSTUSR $LIMIT 0 0 0 $MOUNT
+	$LFS setquota -t -g $GRACE $MAX_IQ_TIME $DIR
+	$LFS setquota -g $TSTUSR $LIMIT 0 0 0 $DIR
 
 	test_block_soft $TESTFILE $GRACE
-	$LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 }
 run_test 3 "Block soft limit (start timer, timer goes off, stop timer) ==="
 
@@ -417,11 +365,13 @@ test_file_soft() {
 	echo "    Create files to exceed soft limit"
 	$RUNAS createmany -m ${TESTFILE}_ $((LIMIT + 1)) || \
 		error "create failure, but expect success"
+	sync; sleep 1; sync
 	echo "    Done"
 
 	echo "    Create file before timer goes off"
 	$RUNAS touch ${TESTFILE}_before || \
 		error "failed create before timer expired, but expect success"
+	sync; sleep 1; sync
 	echo "    Done"
 
 	echo "    Sleep $TIMER seconds ..."
@@ -434,8 +384,10 @@ test_file_soft() {
 	echo "    Create file after timer goes off"
 	$RUNAS createmany -m ${TESTFILE}_after_ $((IUNIT_SZ - 2)) || \
 		error "create ${TESTFILE}_after failure, but expect success"
+	sync; sleep 1; sync
 	$RUNAS touch ${TESTFILE}_after && \
 		error "create after timer expired, but expect EDQUOT"
+	sync; sleep 1; sync
 
 	$SHOW_QUOTA_USER
 	$SHOW_QUOTA_GROUP
@@ -448,6 +400,7 @@ test_file_soft() {
 	echo "    Create file"
 	$RUNAS touch ${TESTFILE}_xxx || \
 		error "touch after timer stop failure, but expect success"
+	sync; sleep 1; sync
 	echo "    Done"
 
 	# cleanup
@@ -455,61 +408,91 @@ test_file_soft() {
 }
 
 # file soft limit (start timer, timer goes off, stop timer)
-test_4() {
+test_4a() {	# was test_4
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
 	LIMIT=$(($IUNIT_SZ * 10))	# 10 iunits on mds
-	TESTFILE="$TSTDIR/quota_tst40"
+	TESTFILE=$DIR/$tdir/$tfile-0
+
 	GRACE=5
 
 	echo "  User quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
-	$LFS setquota -t -u $MAX_DQ_TIME $GRACE $MOUNT
-	$LFS setquota -u $TSTUSR 0 0 $LIMIT 0 $MOUNT
+	$LFS setquota -t -u $MAX_DQ_TIME $GRACE $DIR
+	$LFS setquota -u $TSTUSR 0 0 $LIMIT 0 $DIR
 	$SHOW_QUOTA_USER
 
 	test_file_soft $TESTFILE $LIMIT $GRACE
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 
 	echo "  Group quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
-	$LFS setquota -t -g $MAX_DQ_TIME $GRACE $MOUNT
-	$LFS setquota -g $TSTUSR 0 0 $LIMIT 0 $MOUNT
+	$LFS setquota -t -g $MAX_DQ_TIME $GRACE $DIR
+	$LFS setquota -g $TSTUSR 0 0 $LIMIT 0 $DIR
 	$SHOW_QUOTA_GROUP
-	TESTFILE="$TSTDIR/quota_tst41"
+	TESTFILE=$DIR/$tdir/$tfile-1
 
 	test_file_soft $TESTFILE $LIMIT $GRACE
-	$LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
-	
+	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
+
 	# cleanup
-	$LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $MOUNT
-	$LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $MOUNT
+	$LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $DIR
+	$LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $DIR
+}
+run_test 4a "File soft limit (start timer, timer goes off, stop timer) ==="
+
+test_4b() {	# was test_4a
+        GR_STR1="1w3d"
+        GR_STR2="1000s"
+        GR_STR3="5s"
+        GR_STR4="1w2d3h4m5s"
+        GR_STR5="5c"
+        GR_STR6="1111111111111111"
+
+        # test of valid grace strings handling
+        echo "  Valid grace strings test"
+        $LFS setquota -t -u $GR_STR1 $GR_STR2 $DIR
+        $LFS quota -u -t $DIR | grep "Block grace time: $GR_STR1"
+        $LFS setquota -t -g $GR_STR3 $GR_STR4 $DIR
+        $LFS quota -g -t $DIR | grep "Inode grace time: $GR_STR4"
+
+        # test of invalid grace strings handling
+        echo "  Invalid grace strings test"
+        ! $LFS setquota -t -u $GR_STR4 $GR_STR5 $DIR
+        ! $LFS setquota -t -g $GR_STR4 $GR_STR6 $DIR
+
+        # cleanup
+        $LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $DIR
+        $LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 }
-run_test 4 "File soft limit (start timer, timer goes off, stop timer) ==="
+run_test 4b "Grace time strings handling ==="
 
 # chown & chgrp (chown & chgrp successfully even out of block/file quota)
 test_5() {
+	mkdir -p $DIR/$tdir
 	BLIMIT=$(( $BUNIT_SZ * $((OSTCOUNT + 1)) * 10)) # 10 bunits on each server
 	ILIMIT=$(( $IUNIT_SZ * 10 )) # 10 iunits on mds
 	
 	echo "  Set quota limit (0 $BLIMIT 0 $ILIMIT) for $TSTUSR.$TSTUSR"
-	$LFS setquota -u $TSTUSR 0 $BLIMIT 0 $ILIMIT $MOUNT
-	$LFS setquota -g $TSTUSR 0 $BLIMIT 0 $ILIMIT $MOUNT
+	$LFS setquota -u $TSTUSR 0 $BLIMIT 0 $ILIMIT $DIR
+	$LFS setquota -g $TSTUSR 0 $BLIMIT 0 $ILIMIT $DIR
 	$SHOW_QUOTA_USER
 	$SHOW_QUOTA_GROUP
 	
 	echo "  Create more than $ILIMIT files and more than $BLIMIT kbytes ..."
-	createmany -m $TSTDIR/quota_tst50_ $((ILIMIT + 1)) || \
+	createmany -m $DIR/$tdir/$tfile-0_ $((ILIMIT + 1)) || \
 		error "touch failure, expect success"
-	dd if=/dev/zero of=$TSTDIR/quota_tst50_1 bs=$BLK_SZ count=$((BLIMIT+1)) || error "write failure, expect success"
+	dd if=/dev/zero of=$DIR/$tdir/$tfile-0_1 bs=$BLK_SZ count=$((BLIMIT+1)) || error "write failure, expect success"
 
 	echo "  Chown files to $TSTUSR.$TSTUSR ..."
-	for i in `seq 0 ILIMIT`; do
-		chown $TSTUSR.$TSTUSR $TSTDIR/quota_tst50_$i || \
+	for i in `seq 0 $ILIMIT`; do
+	chown $TSTUSR.$TSTUSR $DIR/$tdir/$tfile-0_$i || \
 			error "chown failure, but expect success"
 	done
 
 	# cleanup
-	unlinkmany $TSTDIR/quota_tst50_ $((ILIMIT + 1))
+	unlinkmany $DIR/$tdir/$tfile-0_ $((ILIMIT + 1))
 
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
-	$LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR
+	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 }
 run_test 5 "Chown & chgrp successfully even out of block/file quota ==="
 
@@ -520,19 +503,22 @@ test_6() {
 		return 0;
 	fi
 
-	LIMIT=$(($BUNIT_SZ * $(($OSTCOUNT + 1)) * 5)) # 5 bunits per server
-	FILEA="$TSTDIR/quota_tst60_a"
-	FILEB="$TSTDIR/quota_tst60_b"
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
+
+	LIMIT=$((BUNIT_SZ * (OSTCOUNT + 1) * 5)) # 5 bunits per server
+	FILEA="$DIR/$tdir/$tfile-0_a"
+	FILEB="$DIR/$tdir/$tfile-0_b"
 	
 	echo "  Set block limit $LIMIT kbytes to $TSTUSR.$TSTUSR"
-	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
-	$LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
+	$LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
 	$SHOW_QUOTA_USER
 	$SHOW_QUOTA_GROUP
 
 	echo "  Create filea on OST0 and fileb on OST1"
-	$LFS setstripe $FILEA 65536 0 1
-	$LFS setstripe $FILEB 65536 1 1
+	$LFS setstripe $FILEA -i 0 -c 1
+	$LFS setstripe $FILEB -i 1 -c 1
 	chown $TSTUSR.$TSTUSR $FILEA
 	chown $TSTUSR.$TSTUSR $FILEB
 
@@ -568,8 +554,8 @@ test_6() {
 
 	# cleanup
 	rm -f $FILEA
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
-	$LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR
+	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 	return 0
 }
 run_test 6 "Block quota acquire & release ========="
@@ -577,14 +563,15 @@ run_test 6 "Block quota acquire & release ========="
 # quota recovery (block quota only by now)
 test_7()
 {
-	remote_mds && skip "remote mds"
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
 
 	LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
-	TESTFILE="$TSTDIR/quota_tst70"
+	TESTFILE="$DIR/$tdir/$tfile-0"
 	
-	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 	
-	$LFS setstripe $TESTFILE 65536 0 1
+	$LFS setstripe $TESTFILE -c 1
 	chown $TSTUSR.$TSTUSR $TESTFILE
 
 	echo "  Write to OST0..."
@@ -607,127 +594,129 @@ test_7()
 	sleep 20
 
 	# check limits
-	PATTERN="`echo $MOUNT | sed 's/\//\\\\\//g'`"
-	TOTAL_LIMIT="`$LFS quota -u $TSTUSR $MOUNT | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
+	PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
+	TOTAL_LIMIT="`$LFS quota -u $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
 	[ $TOTAL_LIMIT -eq $LIMIT ] || error "total limits not recovery!"
 	echo "  total limits = $TOTAL_LIMIT"
 	
         OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
         [ -z "$OST0_UUID" ] && OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
-	OST0_LIMIT="`$LFS quota -o $OST0_UUID -u $TSTUSR $MOUNT | awk '/^.*[[:digit:]+][[:space:]+]/ { print $3 }'`"
+	OST0_LIMIT="`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $3 }'`"
 	[ $OST0_LIMIT -eq $BUNIT_SZ ] || error "high limits not released!"
 	echo "  limits on $OST0_UUID = $OST0_LIMIT"
 
 	# cleanup
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 }
 run_test 7 "Quota recovery (only block limit) ======"
 
 # run dbench with quota enabled
 test_8() {
+	mkdir -p $DIR/$tdir
 	BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
 	FILE_LIMIT=1000000
-	DBENCH_LIB=${DBENCH_LIB:-/usr/lib/dbench}
-	
-	[ ! -d $DBENCH_LIB ] && skip "dbench not installed" && return 0
-	
+
+	wait_delete_completed
+
 	echo "  Set enough high limit for user: $TSTUSR"
-	$LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
+	$LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 	echo "  Set enough high limit for group: $TSTUSR"
-	$LFS setquota -g $USER 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
-	
+	$LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 
-	TGT=$TSTDIR/client.txt
-	SRC=${SRC:-$DBENCH_LIB/client.txt}
-	[ ! -e $TGT -a -e $SRC ] && echo "copying $SRC to $TGT" && cp $SRC $TGT
-	SRC=$DBENCH_LIB/client_plain.txt
-	[ ! -e $TGT -a -e $SRC ] && echo "copying $SRC to $TGT" && cp $SRC $TGT
+	chmod 0777 $DIR/$tdir
+	local duration=""
+	[ "$SLOW" = "no" ] && duration=" -t 120"
+	$RUNAS bash rundbench -D $DIR/$tdir 3 $duration || error "dbench failed!"
 
-	SAVE_PWD=$PWD
-	cd $TSTDIR
-	$RUNAS dbench -c client.txt 3
-	RC=$?
-	
-	rm -f client.txt
-	cd $SAVE_PWD
-	return $RC
+	sync; sleep 3; sync;
+
+	return 0 
 }
 run_test 8 "Run dbench with quota enabled ==========="
 
 # run for fixing bug10707, it needs a big room. test for 64bit
+KB=1024
+GB=$((KB * 1024 * 1024))
+FSIZE=$((OSTCOUNT * 9 / 2))
+# Use this as dd bs to decrease time
+# inode->i_blkbits = min(PTLRPC_MAX_BRW_BITS+1, LL_MAX_BLKSIZE_BITS);
+blksize=$((1 << 21)) # 2Mb
+
 test_9() {
+	chmod 0777 $DIR/$tdir
         lustrefs_size=`(echo 0; df -t lustre -P | awk '{print $4}') | tail -n 1`
-        size_file=$((1024 * 1024 * 9 / 2 * $OSTCOUNT))
-        echo "lustrefs_size:$lustrefs_size  size_file:$size_file"
-        if [ $lustrefs_size -lt $size_file ]; then
-	    skip "less than $size_file free"
-	    return 0;
+        size_file=$((FSIZE * GB))
+        echo "lustrefs_size:$lustrefs_size  size_file:$((size_file / KB))"
+        if [ $((lustrefs_size * KB)) -lt $size_file ]; then
+		skip "less than $size_file bytes free"
+	    	return 0;
         fi
 
         set_blk_unitsz $((1024 * 100))
         set_blk_tunesz $((1024 * 50))
 
         # set the D_QUOTA flag
-	DBG_SAVE="`sysctl -n lnet.debug`"
-	sysctl -w lnet.debug="$DBG_SAVE quota"
+	debugsave
+	sysctl -w lnet.debug="+quota"
 
-        TESTFILE="$TSTDIR/quota_tst90"
+        TESTFILE="$DIR/$tdir/$tfile-0"
 
-        BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
+        BLK_LIMIT=$((100 * KB * KB)) # 100G
         FILE_LIMIT=1000000
 
-	echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
-        $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
-	echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
-        $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
+        echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
+        $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
+        echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
+        $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 
         echo "  Set stripe"
-        [ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE 65536 0 $OSTCOUNT
+        [ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE -c $OSTCOUNT
         touch $TESTFILE
         chown $TSTUSR.$TSTUSR $TESTFILE
 
         $SHOW_QUOTA_USER
         $SHOW_QUOTA_GROUP
 
-        echo "    Write the big file of $(($OSTCOUNT * 9 / 2 ))G ..."
-        $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$size_file || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect success"
-	
+        echo "    Write the big file of $FSIZE G ..."
+        $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
+               error "(usr) write $FSIZE G file failure, but expect success"
+
         $SHOW_QUOTA_USER
         $SHOW_QUOTA_GROUP
 
-	echo "    delete the big file of $(($OSTCOUNT * 9 / 2))G..." 
+        echo "    delete the big file of $FSIZE G..." 
         $RUNAS rm -f $TESTFILE
 
         $SHOW_QUOTA_USER
         $SHOW_QUOTA_GROUP
 
-        echo "    write the big file of 2G..."
-        $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$((1024 * 1024 * 2)) || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect seccess"
+        echo "    write the big file of 2 G..."
+        $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((2 * GB / blksize)) || \
+               error "(usr) write 2 G file failure, but expect seccess"
 
-        echo "    delete the big file of 2G..."
+        echo "    delete the big file of 2 G..."
         $RUNAS rm -f $TESTFILE 
         RC=$?
 
         set_blk_tunesz $BTUNE_SZ
         set_blk_unitsz $BUNIT_SZ
 
-	sysctl -w lnet.debug="$DBG_SAVE"
+	debugrestore
+	wait_delete_completed
+
         return $RC
 }
 run_test 9 "run for fixing bug10707(64bit) ==========="
 
 # run for fixing bug10707, it need a big room. test for 32bit
 test_10() {
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
 	lustrefs_size=`(echo 0; df -t lustre -P | awk '{print $4}') | tail -n 1`
-	size_file=$((1024 * 1024 * 9 / 2 * $OSTCOUNT))
-	echo "lustrefs_size:$lustrefs_size  size_file:$size_file"
-	if [ $lustrefs_size -lt $size_file ]; then
-		skip "less than $size_file free"
-		return 0;
-	fi
-
-	if [ ! -d /proc/fs/lustre/ost/ -o ! -d /proc/fs/lustre/mds ]; then
-		skip "mds or ost isn't local"
+	size_file=$((FSIZE * GB))
+	echo "lustrefs_size:$lustrefs_size  size_file:$((size_file / KB))"
+	if [ $((lustrefs_size * KB)) -lt $size_file ]; then
+		skip "less than $size_file bytes free"
 		return 0;
 	fi
 
@@ -737,57 +726,54 @@ test_10() {
 	set_blk_tunesz $((1024 * 50))
 
 	# set the D_QUOTA flag
-	set_flag=0
-	if [ -z "`sysctl lnet.debug | grep quota`" ]; then
-		sysctl -w lnet.debug="+quota"
-		set_flag=1
-	fi
-
+	debugsave
+	sysctl -w lnet.debug="+quota"
+	
 	# make qd_count 32 bit
 	sysctl -w lustre.fail_loc=0xA00
 
-	TESTFILE="$TSTDIR/quota_tst100"
+	TESTFILE="$DIR/$tdir/$tfile-0"
 
-	BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
+	BLK_LIMIT=$((100 * KB * KB)) # 100G
 	FILE_LIMIT=1000000
 
 	echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
-	$LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
+	$LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 	echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
-	$LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
+	$LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
        
 	echo "  Set stripe"
-	[ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE 65536 0 $OSTCOUNT
+	[ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE -c $OSTCOUNT
 	touch $TESTFILE
 	chown $TSTUSR.$TSTUSR $TESTFILE
 
         $SHOW_QUOTA_USER
         $SHOW_QUOTA_GROUP
 
-	echo "    Write the big file of $(($OSTCOUNT * 9 / 2 ))G ..."
-	$RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$size_file || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect success"
-
+        echo "    Write the big file of $FSIZE G ..."
+        $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
+		error "(usr) write $FSIZE G file failure, but expect success"
+ 
         $SHOW_QUOTA_USER
         $SHOW_QUOTA_GROUP
 
-	echo "    delete the big file of $(($OSTCOUNT * 9 / 2))G..."
-	$RUNAS rm -f $TESTFILE 
+        echo "    delete the big file of $FSIZE G..."
+        $RUNAS rm -f $TESTFILE 
 
         $SHOW_QUOTA_USER
         $SHOW_QUOTA_GROUP
 
-	echo "    write the big file of 2G..."
-	$RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$((1024 * 1024 * 2)) || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect success" 
+	echo "    write the big file of 2 G..."
+	$RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((2 * GB / blkzise)) || \
+		error "(usr) write 2 G file failure, but expect success" 
 
-	echo "    delete the big file of 2G..."
+	echo "    delete the big file of 2 G..."
 	$RUNAS rm -f $TESTFILE 
 
 	RC=$?
 
 	# clear the flage
-	if [ $set_flag -eq 1 ]; then
-		sysctl -w lnet.debug="-quota"
-	fi
+	debugrestore
 
 	# make qd_count 64 bit
 	sysctl -w lustre.fail_loc=0
@@ -795,11 +781,15 @@ test_10() {
 	set_blk_tunesz $BTUNE_SZ
 	set_blk_unitsz $BUNIT_SZ
 
+	wait_delete_completed
+
 	return $RC
 }
 run_test 10 "run for fixing bug10707(32bit) ==========="
 
 test_11() {
+       wait_delete_completed
+
        #prepare the test
        block_limit=`(echo 0; df -t lustre -P | awk '{print $(NF - 4)}') | tail -n 1`
        echo $block_limit
@@ -811,50 +801,57 @@ test_11() {
        echo 30 > /proc/sys/vm/dirty_expire_centisecs
        echo 1  > /proc/sys/vm/dirty_ratio
        echo 50 > /proc/sys/vm/dirty_writeback_centisecs
-       TESTDIR="$TSTDIR/quota_tst110"
+       TESTDIR="$DIR/$tdir"
        local RV=0
 
        #do the test
-       MINS=0
-       REPS=3
-       i=1
+       local SECS=0
+       local REPS=3
+       [ "$SLOW" = no ] && REPS=1
+       local sleep=20
+       local i=1
        while [ $i -le $REPS ]; do
 	   echo "test: cycle($i of $REPS) start at $(date)"
 	   mkdir -p $TESTDIR && chmod 777 $TESTDIR
 	   echo -n "    create a file for uid "
 	   for j in `seq 1 30`; do
 	       echo -n "$j "
-	       runas -u $j dd if=/dev/zero of=$TESTDIR/$j  bs=$BLK_SZ > /dev/null 2>&1 &
+               # 30MB per dd for a total of 900MB (if space even permits)
+	       runas -u $j dd if=/dev/zero of=$TESTDIR/$tfile  bs=$blksize count=15 > /dev/null 2>&1 &
 	   done
 	   echo ""
-	   PROCS=$(ps -e | grep dd | wc -l)
+	   PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
+	   LAST_USED=0
 	   while [ $PROCS -gt 0 ]; do 
-	     sleep 60
-	     MINS=$(($MINS+1))
-	     PROCS=$(ps -e | grep dd | wc -l)
+	     sleep 20
+	     SECS=$((SECS + sleep))
+	     PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
 	     USED=$(du -s $TESTDIR | awk '{print $1}')
 	     PCT=$(($USED * 100 / $block_limit))
-	     echo "${i}/${REPS} ${PCT}% p${PROCS} t${MINS}  "
-	     if [ $MINS -gt 30 ]; then
-		 error "Aborting after $MINS minutes"
-		 kill -9 $(ps -ef | grep $TESTDIR | grep -v grep | awk '{ print $2 }')
+	     echo "${i}/${REPS} ${PCT}% p${PROCS} t${SECS}  "
+	     if [ $USED -le $LAST_USED ]; then
+		 kill -9 $(ps -ef | grep "dd if /dev/zero of $TESTDIR" | grep -v grep | awk '{ print $2 }')
 		 i=$REPS
 		 RV=2
 		 break
 	     fi
+             LAST_USED=$USED
 	   done
 	   echo "    removing the test files..."
-	   rm -rf $TESTDIR
+	   rm -f $TESTDIR/$tfile
 	   echo "cycle $i done at $(date)"
 	   i=$[$i+1]
        done
-       echo "Test took $MINS minutes"
+       echo "Test took $SECS sec"
 
        #clean
        echo $orig_dbr > /proc/sys/vm/dirty_background_ratio
        echo $orig_dec > /proc/sys/vm/dirty_expire_centisecs
        echo $orig_dr  > /proc/sys/vm/dirty_ratio
        echo $orig_dwc > /proc/sys/vm/dirty_writeback_centisecs
+       if [ $RV -ne 0 ]; then
+           error "Nothing was written for $SECS sec ... aborting"
+       fi
        return $RV
 }
 run_test 11 "run for fixing bug10912 ==========="
@@ -862,16 +859,22 @@ run_test 11 "run for fixing bug10912 ==========="
 
 # test a deadlock between quota and journal b=11693
 test_12() {
+	mkdir -p $DIR/$tdir
+	chmod 0777 $DIR/$tdir
+
+	[ "$(grep $DIR2 /proc/mounts)" ] || mount_client $DIR2 || \
+		{ skip "Need lustre mounted on $MOUNT2 " && retutn 0; }
+
 	LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
-	TESTFILE="$TSTDIR/quota_tst120"
-	TESTFILE2="$TSTDIR2/quota_tst121"
+	TESTFILE="$DIR/$tdir/$tfile-0"
+	TESTFILE2="$DIR2/$tdir/$tfile-1"
 	
 	echo "   User quota (limit: $LIMIT kbytes)"
-	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
-	
-	$LFS setstripe $TESTFILE 65536 0 1
+	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
+
+	$LFS setstripe $TESTFILE -i 0 -c 1 
 	chown $TSTUSR.$TSTUSR $TESTFILE
-	$LFS setstripe $TESTFILE2 65536 0 1
+	$LFS setstripe $TESTFILE2 -i 0 -c 1
         chown $TSTUSR2.$TSTUSR2 $TESTFILE2
 
 	#define OBD_FAIL_OST_HOLD_WRITE_RPC      0x21f
@@ -914,7 +917,7 @@ test_12() {
 
 	rm -f $TESTFILE $TESTFILE2
 	
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT		# clear user limit
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR		# clear user limit
 }
 run_test 12 "test a deadlock between quota and journal ==="
 
@@ -922,15 +925,16 @@ run_test 12 "test a deadlock between quota and journal ==="
 test_13() {
 	# one OST * 10 + (mds + other OSTs)
 	LIMIT=$((BUNIT_SZ * 10 + (BUNIT_SZ * OSTCOUNT)))
-	TESTFILE="$TSTDIR/quota_tst13"
-	
+	TESTFILE="$DIR/$tdir/$tfile"
+	mkdir -p $DIR/$tdir
+
 	echo "   User quota (limit: $LIMIT kbytes)"
-	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
+	$LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 	$SHOW_QUOTA_USER
 	
-	$LFS setstripe $TESTFILE 65536 0 1
+	$LFS setstripe $TESTFILE -i 0 -c 1
 	chown $TSTUSR.$TSTUSR $TESTFILE
-	$LFS setstripe $TESTFILE.2 65536 0 1
+	$LFS setstripe $TESTFILE.2 -i 0 -c 1
         chown $TSTUSR.$TSTUSR $TESTFILE.2
 
 	echo "   step1: write out of block quota ..."
@@ -970,40 +974,48 @@ test_13() {
 	fz2=`stat -c %s $TESTFILE.2`
 	$SHOW_QUOTA_USER
 	[ $((fz + fz2)) -lt $((BUNIT_SZ * BLK_SZ * 10)) ] && \
-		error "files too small $fz + $fz < $((BUNIT_SZ * BLK_SZ * 10))"
+		error "files too small $fz + $fz2 < $((BUNIT_SZ * BLK_SZ * 10))"
 
 	rm -f $TESTFILE $TESTFILE.2
 	
-	$LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT		# clear user limit
+	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR		# clear user limit
 }
 run_test 13 "test multiple clients write block quota ==="
 
 check_if_quota_zero(){
-        line=`$LFS quota -$1 $2 $MOUNT | wc -l`
+        line=`$LFS quota -$1 $2 $DIR | wc -l`
 	for i in `seq 3 $line`; do
-	    for j in 3 4 6 7; do
-		tmp=`$LFS quota -$1 $2 $MOUNT | sed -n ${i}p | 
+	    if [ $i -eq 3 ]; then
+		field="3 4 6 7"
+	    else
+		field="3 5"
+	    fi
+	    for j in $field; do
+		tmp=`$LFS quota -$1 $2 $DIR | sed -n ${i}p | 
                      awk  '{print $'"$j"'}'`
-		[ -n "$tmp" ] && [ $tmp -ne 0 ] && $LFS quota -$1 $2 $MOUNT && \
-		    error "quota on $1 isn't clean"
+		[ -n "$tmp" ] && [ $tmp -ne 0 ] && $LFS quota -$1 $2 $DIR && \
+		    error "quota on $2 isn't clean"
 	    done
 	done
 	echo "pass check_if_quota_zero"
 }
 
-# test setting quota on root, b=12223
-test_13(){
-        TESTFILE="$TSTDIR/quota_tst13"
+pre_test_14 () {
+        # reboot the lustre
+        cd $T_PWD; sh llmountcleanup.sh || error "llmountcleanup failed"
+        sh llmount.sh
+        pre_test
+        run_test 0 "reboot lustre"
+}
 
-	# reboot the lustre
-	cd $T_PWD; sh llmountcleanup.sh || error "llmountcleanup failed"
-	sh llmount.sh 
-	pre_test
-	setup
-	run_test 0 "reboot lustre"
+pre_test_14 
+
+test_14a() {	# was test_14 b=12223 -- setting quota on root
+	TESTFILE="$DIR/$tdir/$tfile"
+	mkdir -p $DIR/$tdir
 
 	# out of root's file and block quota
-        $LFS setquota -u root 10 10 10 10 $MOUNT
+        $LFS setquota -u root 10 10 10 10 $DIR
 	createmany -m ${TESTFILE} 20 || \
 	    error "unexpected: user(root) create files failly!"
 	dd if=/dev/zero of=$TESTFILE bs=4k count=4096 || \
@@ -1013,42 +1025,34 @@ test_13(){
 	    error "unexpected: user(quota_usr) write a file successfully!"	
 
 	# trigger the llog
-	chmod 777 $MOUNT
+	chmod 777 $DIR
 	for i in `seq 1 10`; do $RUNAS touch ${TESTFILE}a_$i; done 
 	for i in `seq 1 10`; do $RUNAS rm -f ${TESTFILE}a_$i; done 
 
 	# do the check
-	dmesg | tail | grep "\-122" |grep llog_obd_origin_add && error "test_13 failed."
-	$LFS setquota -u root 0 0 0 0 $MOUNT
+	dmesg | tail | grep "\-122" |grep llog_obd_origin_add && error "err -122 not found in dmesg" 
+	$LFS setquota -u root 0 0 0 0 $DIR
 	#check_if_quota_zero u root
 
 	# clean 
 	unlinkmany ${TESTFILE} 15
 	rm -f $TESTFILE
 }
-run_test 13 "test setting quota on root ==="
+run_test 14a "test setting quota on root ==="
 
 # turn off quota
 test_99()
 {
-	$LFS quotaoff $MOUNT
+	$LFS quotaoff $DIR
 	return 0
 }
 run_test 99 "Quota off ==============================="
 
 
 log "cleanup: ======================================================"
-if [ "`mount | grep ^$NAME`" ]; then
-	rm -fr $TSTDIR
-	    post_test
-	# delete test user and group
-	userdel "$TSTUSR"
-	userdel "$TSTUSR2"
-	if [ "$I_MOUNTED" = "yes" ]; then
-		cd $ORIG_PWD && (sh llmountcleanup.sh || error "llmountcleanup failed")
-	fi
-fi
-
+cd $ORIG_PWD
+post_test
+check_and_cleanup_lustre
 echo '=========================== finished ==============================='
 [ -f "$QUOTALOG" ] && cat $QUOTALOG && grep -q FAIL $QUOTALOG && exit 1 || true
 echo "$0: completed"