3 # Run select tests by setting ONLY, or as arguments to the script.
4 # Skip specific tests by setting EXCEPT.
6 # Run test by setting NOSETUP=true when ltest has setup env for us
9 #kernel 2.4.x doesn't support quota
10 K_VER=`uname --kernel-release | cut -b 1-3`
11 if [ $K_VER = "2.4" ]; then
12 echo "Kernel 2.4 doesn't support quota"
17 export PATH=$PWD/$SRCDIR:$SRCDIR:$PWD/$SRCDIR/../utils:$PATH:/sbin
20 ALWAYS_EXCEPT="10 $SANITY_QUOTA_EXCEPT"
21 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
24 2.6*) FSTYPE=${FSTYPE:-ldiskfs};;
25 *) error "unsupported kernel" ;;
28 [ "$ALWAYS_EXCEPT$EXCEPT" ] && \
29 echo "Skipping tests: `echo $ALWAYS_EXCEPT $EXCEPT`"
35 TSTID2=${TSTID2:-60001}
36 TSTUSR=${TSTUSR:-"quota_usr"}
37 TSTUSR2=${TSTUSR2:-"quota_2usr"}
39 BUNIT_SZ=${BUNIT_SZ:-1024} # min block quota unit(kB)
40 IUNIT_SZ=${IUNIT_SZ:-10} # min inode quota unit
47 LUSTRE=${LUSTRE:-`dirname $0`/..}
48 . $LUSTRE/tests/test-framework.sh
50 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
51 DIRECTIO=${DIRECTIO:-$LUSTRE/tests/directio}
53 [ $MDSCOUNT -gt 1 ] && skip "CMD case" && exit 0
54 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
55 remote_ost_nodsh && skip "remote OST with nodsh" && exit 0
57 [ "$SLOW" = "no" ] && EXCEPT_SLOW="9 10 11 18b 21"
59 QUOTALOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}
61 [ "$QUOTALOG" ] && rm -f $QUOTALOG || true
66 check_and_setup_lustre
68 LOVNAME=`lctl get_param -n llite.*.lov.common_name | tail -n 1`
69 OSTCOUNT=`lctl get_param -n lov.$LOVNAME.numobd`
71 SHOW_QUOTA_USER="$LFS quota -v -u $TSTUSR $DIR"
72 SHOW_QUOTA_USER2="$LFS quota -v -u $TSTUSR2 $DIR"
73 SHOW_QUOTA_GROUP="$LFS quota -v -g $TSTUSR $DIR"
74 SHOW_QUOTA_GROUP2="$LFS quota -v -g $TSTUSR2 $DIR"
75 SHOW_QUOTA_INFO="$LFS quota -t $DIR"
77 # control the time of tests
79 [ "$SLOW" = "no" ] && cycle=10
86 # set_blk_tunables(btune_sz)
88 local btune=$(($1 * BLK_SZ))
89 # set btune size on all obdfilters
90 do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_btune_sz=$btune"
91 # set btune size on mds
92 do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_btune_sz=$btune"
95 # set_blk_unitsz(bunit_sz)
97 local bunit=$(($1 * BLK_SZ))
98 # set bunit size on all obdfilters
99 do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_bunit_sz=$bunit"
100 # set bunit size on mds
101 do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_bunit_sz=$bunit"
104 # set_file_tunesz(itune_sz)
107 # set itune size on all obdfilters
108 do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_itune_sz=$itune"
109 # set itune size on mds
110 do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_itune_sz=$itune"
113 # set_file_unitsz(iunit_sz)
116 # set iunit size on all obdfilters
117 do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_iunit_sz=$iunit"
118 # set iunit size on mds
119 do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_iunit_sz=$iunit"
125 local fail_val=${3:-0}
127 if [ $fail_node == "mds" ] || [ $fail_node == "mds_ost" ]; then
128 if [ $((fail_loc & 0x10000000)) -ne 0 -a $fail_val -gt 0 ] || \
129 [ $((fail_loc)) -eq 0 ]; then
130 do_facet $SINGLEMDS "lctl set_param fail_val=$fail_val"
132 do_facet $SINGLEMDS "lctl set_param fail_loc=$fail_loc"
134 if [ $fail_node == "ost" ] || [ $fail_node == "mds_ost" ]; then
135 for num in `seq $OSTCOUNT`; do
136 if [ $((fail_loc & 0x10000000)) -ne 0 -a $fail_val -gt 0 ] || \
137 [ $((fail_loc)) -eq 0 ]; then
138 do_facet ost$num "lctl set_param fail_val=$fail_val"
140 do_facet ost$num "lctl set_param fail_loc=$fail_loc"
145 RUNAS="runas -u $TSTID -g $TSTID"
146 RUNAS2="runas -u $TSTID2 -g $TSTID2"
147 FAIL_ON_ERROR=true check_runas_id $TSTID $TSTID $RUNAS
148 FAIL_ON_ERROR=true check_runas_id $TSTID2 $TSTID2 $RUNAS2
152 run_test_with_stat() {
153 (($# != 2)) && error "the number of arguments is wrong"
155 do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.stats=0" > /dev/null
156 for j in `seq $OSTCOUNT`; do
157 do_facet ost$j "lctl set_param lquota.${FSNAME}-OST*.stats=0" > /dev/null
160 if [ ${STAT:-"yes"} != "no" -a -z "$LAST_SKIPPED" ]; then
161 echo "statistics info begin ***************************************"
162 do_facet $SINGLEMDS "lctl get_param lquota.mdd_obd-${FSNAME}-MDT*.stats"
163 for j in `seq $OSTCOUNT`; do
164 do_facet ost$j "lctl get_param lquota.${FSNAME}-OST*.stats"
166 echo "statistics info end ***************************************"
171 # clear quota limits for a user or a group
172 # usage: resetquota -u username
173 # resetquota -g groupname
176 [ "$#" != 2 ] && error "resetquota: wrong number of arguments: $#"
177 [ "$1" != "-u" -a "$1" != "-g" ] && error "resetquota: wrong specifier $1 passed"
178 $LFS setquota "$1" "$2" -b 0 -B 0 -i 0 -I 0 $MOUNT || error "resetquota failed"
185 if [ "$LOCAL_UG" == "a" -o "$LOCAL_UG" == "u" ]; then
186 log "Files for user ($LOCAL_ID):"
187 ($LFS find -user $LOCAL_ID $DIR | xargs stat 2>/dev/null)
190 if [ "$LOCAL_UG" == "a" -o "$LOCAL_UG" == "g" ]; then
191 log "Files for group ($LOCAL_ID):"
192 ($LFS find -group $LOCAL_ID $DIR | xargs stat 2>/dev/null)
212 PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
214 $LFS quota -v -$LOCAL_UG $LOCAL_ID $DIR
216 if [ "$LOCAL_BF" == "a" -o "$LOCAL_BF" == "b" ]; then
217 USAGE="`$LFS quota -$LOCAL_UG $LOCAL_ID $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $2 }'`"
218 [ $USAGE -ne 0 ] && quota_log $LOCAL_UG $LOCAL_ID "System is not clean for block ($LOCAL_UG:$LOCAL_ID:$USAGE)."
221 if [ "$LOCAL_BF" == "a" -o "$LOCAL_BF" == "f" ]; then
222 USAGE="`$LFS quota -$LOCAL_UG $LOCAL_ID $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $5 }'`"
223 [ $USAGE -ne 0 ] && quota_log $LOCAL_UG $LOCAL_ID "System is not clean for file ($LOCAL_UG:$LOCAL_ID:$USAGE)."
229 $LFS quotaoff -ug $DIR
230 $LFS quotacheck -ug $DIR
232 resetquota -u $TSTUSR
233 resetquota -g $TSTUSR
235 lctl set_param debug="+quota"
236 do_facet $SINGLEMDS "lctl set_param debug=+quota"
237 for num in `seq $OSTCOUNT`; do
238 do_facet ost$num "lctl set_param debug=+quota"
241 run_test_with_stat 0 "Set quota ============================="
243 # test for specific quota limitation, qunit, qtune $1=block_quota_limit
247 chmod 0777 $DIR/$tdir
248 TESTFILE="$DIR/$tdir/$tfile-0"
250 wait_delete_completed
253 log " User quota (limit: $LIMIT kbytes)"
254 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
256 quota_show_check b u $TSTUSR
258 $LFS setstripe $TESTFILE -c 1
259 chown $TSTUSR.$TSTUSR $TESTFILE
262 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || quota_error u $TSTUSR "(usr) write failure, but expect success"
264 log " Write out of block quota ..."
265 # this time maybe cache write, ignore it's failure
266 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
267 # flush cache, ensure noquota flag is setted on client
269 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && quota_error u $TSTUSR "(usr) write success, but expect EDQUOT"
273 OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
274 OST0_QUOTA_USED=`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
275 echo $OST0_QUOTA_USED
276 [ $OST0_QUOTA_USED -ne 0 ] && \
277 ($SHOW_QUOTA_USER; quota_error u $TSTUSR "(usr) quota deleted isn't released")
279 resetquota -u $TSTUSR
282 log "--------------------------------------"
283 log " Group quota (limit: $LIMIT kbytes)"
284 $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
286 quota_show_check b g $TSTUSR
287 TESTFILE="$DIR/$tdir/$tfile-1"
289 $LFS setstripe $TESTFILE -c 1
290 chown $TSTUSR.$TSTUSR $TESTFILE
293 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || quota_error g $TSTUSR "(grp) write failure, but expect success"
295 log " Write out of block quota ..."
296 # this time maybe cache write, ignore it's failure
297 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
299 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && quota_error g $TSTUSR "(grp) write success, but expect EDQUOT"
304 OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
305 OST0_QUOTA_USED=`$LFS quota -o $OST0_UUID -g $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
306 echo $OST0_QUOTA_USED
307 [ $OST0_QUOTA_USED -ne 0 ] && \
308 ($SHOW_QUOTA_GROUP; quota_error g $TSTUSR "(grp) quota deleted isn't released")
310 resetquota -g $TSTUSR
313 # block hard limit (normal use and out of quota)
315 for i in `seq 1 $cycle`; do
316 # define blk_qunit is between 1M and 4M
317 blk_qunit=$(( $RANDOM % 3072 + 1024 ))
318 blk_qtune=$(( $RANDOM % $blk_qunit ))
319 # other osts and mds will occupy at 1M blk quota
320 b_limit=$(( ($RANDOM - 16384) / 8 + $OSTCOUNT * $blk_qunit * 4 ))
321 set_blk_tunesz $blk_qtune
322 set_blk_unitsz $blk_qunit
323 echo "cycle: $i(total $cycle) bunit:$blk_qunit, btune:$blk_qtune, blimit:$b_limit"
325 echo "=================================================="
326 set_blk_unitsz $((128 * 1024))
327 set_blk_tunesz $((128 * 1024 / 2))
330 run_test_with_stat 1 "Block hard limit (normal use and out of quota) ==="
332 # test for specific quota limitation, qunit, qtune $1=block_quota_limit
336 chmod 0777 $DIR/$tdir
337 TESTFILE="$DIR/$tdir/$tfile-0"
339 wait_delete_completed
342 log " User quota (limit: $LIMIT files)"
343 $LFS setquota -u $TSTUSR -b 0 -B 0 -i 0 -I $LIMIT $DIR
345 quota_show_check f u $TSTUSR
347 log " Create $LIMIT files ..."
348 $RUNAS createmany -m ${TESTFILE} $LIMIT || \
349 quota_error u $TSTUSR "(usr) create failure, but expect success"
351 log " Create out of file quota ..."
352 $RUNAS touch ${TESTFILE}_xxx && \
353 quota_error u $TSTUSR "(usr) touch success, but expect EDQUOT"
355 unlinkmany ${TESTFILE} $LIMIT
356 rm -f ${TESTFILE}_xxx
359 MDS_UUID=`do_facet $SINGLEMDS $LCTL dl | grep -m1 " mdt " | awk '{print $((NF-1))}'`
360 MDS_QUOTA_USED=`$LFS quota -o $MDS_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
362 [ $MDS_QUOTA_USED -ne 0 ] && \
363 ($SHOW_QUOTA_USER; quota_error u $TSTUSR "(usr) quota deleted isn't released")
365 resetquota -u $TSTUSR
368 log "--------------------------------------"
369 log " Group quota (limit: $LIMIT FILE)"
370 $LFS setquota -g $TSTUSR -b 0 -B 0 -i 0 -I $LIMIT $DIR
372 quota_show_check f g $TSTUSR
373 TESTFILE=$DIR/$tdir/$tfile-1
375 log " Create $LIMIT files ..."
376 $RUNAS createmany -m ${TESTFILE} $LIMIT || \
377 quota_error g $TSTUSR "(grp) create failure, but expect success"
379 log " Create out of file quota ..."
380 $RUNAS touch ${TESTFILE}_xxx && \
381 quota_error g $TSTUSR "(grp) touch success, but expect EDQUOT"
383 unlinkmany ${TESTFILE} $LIMIT
384 rm -f ${TESTFILE}_xxx
387 MDS_UUID=`do_facet $SINGLEMDS $LCTL dl | grep -m1 " mdt " | awk '{print $((NF-1))}'`
388 MDS_QUOTA_USED=`$LFS quota -o $MDS_UUID -g $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
390 [ $MDS_QUOTA_USED -ne 0 ] && \
391 ($SHOW_QUOTA_GROUP; quota_error g $TSTUSR "(grp) quota deleted isn't released")
393 resetquota -g $TSTUSR
396 # file hard limit (normal use and out of quota)
398 for i in `seq 1 $cycle`; do
399 if [ $i -eq 1 ]; then
404 # define ino_qunit is between 10 and 100
405 ino_qunit=$(( $RANDOM % 90 + 10 ))
406 ino_qtune=$(( $RANDOM % $ino_qunit ))
407 # RANDOM's maxium is 32767
408 i_limit=$(( $RANDOM % 990 + 10 ))
411 set_file_tunesz $ino_qtune
412 set_file_unitsz $ino_qunit
413 echo "cycle: $i(total $cycle) iunit:$ino_qunit, itune:$ino_qtune, ilimit:$i_limit"
415 echo "=================================================="
420 run_test_with_stat 2 "File hard limit (normal use and out of quota) ==="
424 TIMER=$(($2 * 3 / 2))
427 wait_delete_completed
429 echo " Write to exceed soft limit"
430 RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
431 $RUNDD count=$((BUNIT_SZ+1)) || \
432 quota_error a $TSTUSR "write failure, but expect success"
433 OFFSET=$((OFFSET + BUNIT_SZ + 1))
440 echo " Write before timer goes off"
441 $RUNDD count=$BUNIT_SZ seek=$OFFSET || \
442 quota_error a $TSTUSR "write failure, but expect success"
443 OFFSET=$((OFFSET + BUNIT_SZ))
447 echo " Sleep $TIMER seconds ..."
454 echo " Write after timer goes off"
455 # maybe cache write, ignore.
456 $RUNDD count=$BUNIT_SZ seek=$OFFSET || true
457 OFFSET=$((OFFSET + BUNIT_SZ))
459 $RUNDD count=$BUNIT_SZ seek=$OFFSET && \
460 quota_error a $TSTUSR "write success, but expect EDQUOT"
466 echo " Unlink file to stop timer"
476 $RUNDD count=$BUNIT_SZ || quota_error a $TSTUSR "write failure, but expect success"
484 # block soft limit (start timer, timer goes off, stop timer)
487 chmod 0777 $DIR/$tdir
489 # 1 bunit on mds and 1 bunit on every ost
490 LIMIT=$(( $BUNIT_SZ * ($OSTCOUNT + 1) ))
493 echo " User quota (soft limit: $LIMIT kbytes grace: $GRACE seconds)"
494 TESTFILE=$DIR/$tdir/$tfile-0
496 $LFS setstripe $TESTFILE -c 1
497 chown $TSTUSR.$TSTUSR $TESTFILE
499 $LFS setquota -t -u --block-grace $GRACE --inode-grace $MAX_IQ_TIME $DIR
500 $LFS setquota -u $TSTUSR -b $LIMIT -B 0 -i 0 -I 0 $DIR
502 test_block_soft $TESTFILE $GRACE
503 resetquota -u $TSTUSR
505 echo " Group quota (soft limit: $LIMIT kbytes grace: $GRACE seconds)"
506 TESTFILE=$DIR/$tdir/$tfile-1
508 $LFS setstripe $TESTFILE -c 1
509 chown $TSTUSR.$TSTUSR $TESTFILE
511 $LFS setquota -t -g --block-grace $GRACE --inode-grace $MAX_IQ_TIME $DIR
512 $LFS setquota -g $TSTUSR -b $LIMIT -B 0 -i 0 -I 0 $DIR
514 test_block_soft $TESTFILE $GRACE
515 resetquota -g $TSTUSR
517 run_test_with_stat 3 "Block soft limit (start timer, timer goes off, stop timer) ==="
522 TIMER=$(($3 * 3 / 2))
524 wait_delete_completed
526 echo " Create files to exceed soft limit"
527 $RUNAS createmany -m ${TESTFILE}_ $((LIMIT + 1)) || \
528 quota_error a $TSTUSR "create failure, but expect success"
532 echo " Create file before timer goes off"
533 $RUNAS touch ${TESTFILE}_before || \
534 quota_error a $TSTUSR "failed create before timer expired, but expect success"
538 echo " Sleep $TIMER seconds ..."
545 echo " Create file after timer goes off"
546 # the least of inode qunit is 2, so there are at most 3(qunit:2+qtune:1)
547 # inode quota left here
548 $RUNAS touch ${TESTFILE}_after ${TESTFILE}_after1 ${TESTFILE}_after2 || true
550 $RUNAS touch ${TESTFILE}_after3 && \
551 quota_error a $TSTUSR "create after timer expired, but expect EDQUOT"
558 echo " Unlink files to stop timer"
559 find `dirname $TESTFILE` -name "`basename ${TESTFILE}`*" | xargs rm -f
563 $RUNAS touch ${TESTFILE}_xxx || \
564 quota_error a $TSTUSR "touch after timer stop failure, but expect success"
569 rm -f ${TESTFILE}_xxx
573 # file soft limit (start timer, timer goes off, stop timer)
574 test_4a() { # was test_4
576 chmod 0777 $DIR/$tdir
577 LIMIT=$(($IUNIT_SZ * 10)) # 10 iunits on mds
578 TESTFILE=$DIR/$tdir/$tfile-0
582 echo " User quota (soft limit: $LIMIT files grace: $GRACE seconds)"
583 $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $GRACE $DIR
584 $LFS setquota -u $TSTUSR -b 0 -B 0 -i $LIMIT -I 0 $DIR
585 quota_show_check f u $TSTUSR
587 test_file_soft $TESTFILE $LIMIT $GRACE
588 resetquota -u $TSTUSR
590 echo " Group quota (soft limit: $LIMIT files grace: $GRACE seconds)"
591 $LFS setquota -t -g --block-grace $MAX_DQ_TIME --inode-grace $GRACE $DIR
592 $LFS setquota -g $TSTUSR -b 0 -B 0 -i $LIMIT -I 0 $DIR
593 quota_show_check f g $TSTUSR
594 TESTFILE=$DIR/$tdir/$tfile-1
596 test_file_soft $TESTFILE $LIMIT $GRACE
597 resetquota -g $TSTUSR
600 $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
601 $LFS setquota -t -g --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
603 run_test_with_stat 4a "File soft limit (start timer, timer goes off, stop timer) ==="
605 test_4b() { # was test_4a
611 GR_STR6="1111111111111111"
613 wait_delete_completed
615 # test of valid grace strings handling
616 echo " Valid grace strings test"
617 $LFS setquota -t -u --block-grace $GR_STR1 --inode-grace $GR_STR2 $DIR
618 $LFS quota -u -t $DIR | grep "Block grace time: $GR_STR1"
619 $LFS setquota -t -g --block-grace $GR_STR3 --inode-grace $GR_STR4 $DIR
620 $LFS quota -g -t $DIR | grep "Inode grace time: $GR_STR4"
622 # test of invalid grace strings handling
623 echo " Invalid grace strings test"
624 ! $LFS setquota -t -u --block-grace $GR_STR4 --inode-grace $GR_STR5 $DIR
625 ! $LFS setquota -t -g --block-grace $GR_STR4 --inode-grace $GR_STR6 $DIR
628 $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
629 $LFS setquota -t -g --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
631 run_test_with_stat 4b "Grace time strings handling ==="
633 # chown & chgrp (chown & chgrp successfully even out of block/file quota)
636 BLIMIT=$(( $BUNIT_SZ * $((OSTCOUNT + 1)) * 10)) # 10 bunits on each server
637 ILIMIT=$(( $IUNIT_SZ * 10 )) # 10 iunits on mds
639 wait_delete_completed
641 echo " Set quota limit (0 $BLIMIT 0 $ILIMIT) for $TSTUSR.$TSTUSR"
642 $LFS setquota -u $TSTUSR -b 0 -B $BLIMIT -i 0 -I $ILIMIT $DIR
643 $LFS setquota -g $TSTUSR -b 0 -B $BLIMIT -i 0 -I $ILIMIT $DIR
644 quota_show_check a u $TSTUSR
645 quota_show_check a g $TSTUSR
647 echo " Create more than $ILIMIT files and more than $BLIMIT kbytes ..."
648 createmany -m $DIR/$tdir/$tfile-0_ $((ILIMIT + 1)) || \
649 error "touch failure, expect success"
650 dd if=/dev/zero of=$DIR/$tdir/$tfile-0_1 bs=$BLK_SZ count=$((BLIMIT+1)) || error "write failure, expect success"
652 echo " Chown files to $TSTUSR.$TSTUSR ..."
653 for i in `seq 0 $ILIMIT`; do
654 chown $TSTUSR.$TSTUSR $DIR/$tdir/$tfile-0_$i || \
655 quota_error a $TSTUSR "chown failure, but expect success"
659 unlinkmany $DIR/$tdir/$tfile-0_ $((ILIMIT + 1))
662 resetquota -u $TSTUSR
663 resetquota -g $TSTUSR
665 run_test_with_stat 5 "Chown & chgrp successfully even out of block/file quota ==="
667 # block quota acquire & release
669 if [ $OSTCOUNT -lt 2 ]; then
670 skip "$OSTCOUNT < 2, too few osts"
674 wait_delete_completed
677 chmod 0777 $DIR/$tdir
679 LIMIT=$((BUNIT_SZ * (OSTCOUNT + 1) * 5)) # 5 bunits per server
680 FILEA="$DIR/$tdir/$tfile-0_a"
681 FILEB="$DIR/$tdir/$tfile-0_b"
683 echo " Set block limit $LIMIT kbytes to $TSTUSR.$TSTUSR"
684 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
685 $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
686 quota_show_check b u $TSTUSR
687 quota_show_check b g $TSTUSR
689 echo " Create filea on OST0 and fileb on OST1"
690 $LFS setstripe $FILEA -i 0 -c 1
691 $LFS setstripe $FILEB -i 1 -c 1
692 chown $TSTUSR.$TSTUSR $FILEA
693 chown $TSTUSR.$TSTUSR $FILEB
695 echo " Exceed quota limit ..."
696 RUNDD="$RUNAS dd if=/dev/zero of=$FILEB bs=$BLK_SZ"
697 $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
698 quota_error a $TSTUSR "write fileb failure, but expect success"
703 $RUNDD seek=$LIMIT count=$((BUNIT_SZ * OSTCOUNT)) && \
704 quota_error a $TSTUSR "write fileb success, but expect EDQUOT"
706 echo " Write to OST0 return EDQUOT"
707 # this write maybe cache write, ignore it's failure
708 RUNDD="$RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ"
709 $RUNDD count=$(($BUNIT_SZ * 2)) || true
713 $RUNDD count=$((BUNIT_SZ * 2)) seek=$((BUNIT_SZ *2)) && \
714 quota_error a $TSTUSR "write filea success, but expect EDQUOT"
716 echo " Remove fileb to let OST1 release quota"
718 sync; sleep 10; sync; # need to allow journal commit for small fs
720 echo " Write to OST0"
721 $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
722 quota_error a $TSTUSR "write filea failure, expect success"
729 resetquota -u $TSTUSR
730 resetquota -g $TSTUSR
733 run_test_with_stat 6 "Block quota acquire & release ========="
735 # quota recovery (block quota only by now)
739 chmod 0777 $DIR/$tdir
741 wait_delete_completed
743 LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) ))
744 TESTFILE="$DIR/$tdir/$tfile-0"
746 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
748 $LFS setstripe $TESTFILE -c 1
749 chown $TSTUSR.$TSTUSR $TESTFILE
751 echo " Write to OST0..."
752 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ || \
753 quota_error u $TSTUSR "write failure, but expect success"
755 #define OBD_FAIL_OBD_DQACQ 0x604
756 lustre_fail mds 0x604
757 echo " Remove files on OST0"
761 echo " Trigger recovery..."
762 OSC0_UUID="`$LCTL dl | awk '$3 ~ /osc/ { print $1 }'`"
763 for i in $OSC0_UUID; do
764 $LCTL --device $i activate || error "activate osc failed!"
767 # sleep a while to wait for recovery done
771 PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
772 TOTAL_LIMIT="`$LFS quota -v -u $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
773 [ $TOTAL_LIMIT -eq $LIMIT ] || error "total limits not recovery!"
774 echo " total limits = $TOTAL_LIMIT"
776 OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
777 [ -z "$OST0_UUID" ] && OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
778 OST0_LIMIT="`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $3 }'`"
779 [ $OST0_LIMIT -eq $BUNIT_SZ ] || error "high limits not released!"
780 echo " limits on $OST0_UUID = $OST0_LIMIT"
783 resetquota -u $TSTUSR
785 run_test_with_stat 7 "Quota recovery (only block limit) ======"
787 # run dbench with quota enabled
790 BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
793 wait_delete_completed
795 echo " Set enough high limit for user: $TSTUSR"
796 $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
797 echo " Set enough high limit for group: $TSTUSR"
798 $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
800 chmod 0777 $DIR/$tdir
802 [ "$SLOW" = "no" ] && duration=" -t 120"
803 $RUNAS bash rundbench -D $DIR/$tdir 3 $duration || quota_error a $TSTUSR "dbench failed!"
810 run_test_with_stat 8 "Run dbench with quota enabled ==========="
812 # run for fixing bug10707, it needs a big room. test for 64bit
814 GB=$((KB * 1024 * 1024))
815 # Use this as dd bs to decrease time
816 # inode->i_blkbits = min(PTLRPC_MAX_BRW_BITS+1, LL_MAX_BLKSIZE_BITS);
817 blksize=$((1 << 21)) # 2Mb
818 size_file=$((GB * 9 / 2))
819 # this check is just for test9 and test10
820 OST0_MIN=4900000 #4.67G
821 check_whether_skip () {
822 OST0_SIZE=`$LFS df $DIR | awk '/\[OST:0\]/ {print $4}'`
823 log "OST0_SIZE: $OST0_SIZE required: $OST0_MIN"
824 if [ $OST0_SIZE -lt $OST0_MIN ]; then
825 echo "WARN: OST0 has less than $OST0_MIN free, skip this test."
833 check_whether_skip && return 0
835 wait_delete_completed
841 chmod 0777 $DIR/$tdir
842 TESTFILE="$DIR/$tdir/$tfile-0"
844 BLK_LIMIT=$((100 * KB * KB)) # 100G
846 echo " Set block limit $BLK_LIMIT kbytes to $TSTUSR.$TSTUSR"
848 log " Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
849 $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
850 log " Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
851 $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
853 quota_show_check a u $TSTUSR
854 quota_show_check a g $TSTUSR
857 $LFS setstripe $TESTFILE -c 1
859 chown $TSTUSR.$TSTUSR $TESTFILE
861 log " Write the big file of 4.5G ..."
862 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$blksize count=$((size_file / blksize)) || \
863 quota_error a $TSTUSR "(usr) write 4.5G file failure, but expect success"
868 log " delete the big file of 4.5G..."
869 $RUNAS rm -f $TESTFILE
877 set_blk_unitsz $((128 * 1024))
878 set_blk_tunesz $((128 * 1024 / 2))
882 run_test_with_stat 9 "run for fixing bug10707(64bit) ==========="
884 # run for fixing bug10707, it need a big room. test for 32bit
885 # 2.0 version does not support 32 bit qd_count, so such test is obsolete.
888 chmod 0777 $DIR/$tdir
889 check_whether_skip && return 0
891 wait_delete_completed
896 # make qd_count 32 bit
897 lustre_fail mds_ost 0xA00
899 TESTFILE="$DIR/$tdir/$tfile-0"
901 BLK_LIMIT=$((100 * KB * KB)) # 100G
904 log " Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
905 $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
906 log " Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
907 $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
909 quota_show_check a u $TSTUSR
910 quota_show_check a g $TSTUSR
913 $LFS setstripe $TESTFILE -c 1
915 chown $TSTUSR.$TSTUSR $TESTFILE
917 log " Write the big file of 4.5 G ..."
918 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$blksize count=$((size_file / blksize)) || \
919 quota_error a $TSTUSR "(usr) write 4.5 G file failure, but expect success"
924 log " delete the big file of 4.5 G..."
925 $RUNAS rm -f $TESTFILE
933 # make qd_count 64 bit
934 lustre_fail mds_ost 0
936 set_blk_unitsz $((128 * 1024))
937 set_blk_tunesz $((128 * 1024 / 2))
941 #run_test_with_stat 10 "run for fixing bug10707(32bit) ==========="
944 wait_delete_completed
947 block_limit=`(echo 0; df -t lustre -P | awk '{print $(NF - 4)}') | tail -n 1`
949 orig_dbr=`sysctl -n vm.dirty_background_ratio`
950 orig_dec=`sysctl -n vm.dirty_expire_centisecs`
951 orig_dr=`sysctl -n vm.dirty_ratio`
952 orig_dwc=`sysctl -n vm.dirty_writeback_centisecs`
953 sysctl -w vm.dirty_background_ratio=1
954 sysctl -w vm.dirty_expire_centisecs=30
955 sysctl -w vm.dirty_ratio=1
956 sysctl -w vm.dirty_writeback_centisecs=50
963 [ "$SLOW" = no ] && REPS=1
966 while [ $i -le $REPS ]; do
967 echo "test: cycle($i of $REPS) start at $(date)"
968 mkdir -p $TESTDIR && chmod 777 $TESTDIR
969 echo -n " create a file for uid "
970 for j in `seq 1 30`; do
972 # 30MB per dd for a total of 900MB (if space even permits)
973 runas -u $j dd if=/dev/zero of=$TESTDIR/$tfile bs=$blksize count=15 > /dev/null 2>&1 &
976 PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
978 while [ $PROCS -gt 0 ]; do
980 SECS=$((SECS + sleep))
981 PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
982 USED=$(du -s $TESTDIR | awk '{print $1}')
983 PCT=$(($USED * 100 / $block_limit))
984 echo "${i}/${REPS} ${PCT}% p${PROCS} t${SECS} "
985 if [ $USED -le $LAST_USED ]; then
986 kill -9 $(ps -ef | grep "dd if /dev/zero of $TESTDIR" | grep -v grep | awk '{ print $2 }')
993 echo " removing the test files..."
994 rm -f $TESTDIR/$tfile
995 echo "cycle $i done at $(date)"
998 echo "Test took $SECS sec"
1001 sysctl -w vm.dirty_background_ratio=$orig_dbr
1002 sysctl -w vm.dirty_expire_centisecs=$orig_dec
1003 sysctl -w vm.dirty_ratio=$orig_dr
1004 sysctl -w vm.dirty_writeback_centisecs=$orig_dwc
1005 if [ $RV -ne 0 ]; then
1006 error "Nothing was written for $SECS sec ... aborting"
1010 run_test_with_stat 11 "run for fixing bug10912 ==========="
1013 # test a deadlock between quota and journal b=11693
1016 chmod 0777 $DIR/$tdir
1018 [ "$(grep $DIR2 /proc/mounts)" ] || mount_client $DIR2 || \
1019 { skip "Need lustre mounted on $MOUNT2 " && retutn 0; }
1021 LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
1022 TESTFILE="$DIR/$tdir/$tfile-0"
1023 TESTFILE2="$DIR2/$tdir/$tfile-1"
1025 wait_delete_completed
1027 echo " User quota (limit: $LIMIT kbytes)"
1028 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1030 $LFS setstripe $TESTFILE -i 0 -c 1
1031 chown $TSTUSR.$TSTUSR $TESTFILE
1032 $LFS setstripe $TESTFILE2 -i 0 -c 1
1033 chown $TSTUSR2.$TSTUSR2 $TESTFILE2
1035 #define OBD_FAIL_OST_HOLD_WRITE_RPC 0x21f
1036 #define OBD_FAIL_SOME 0x10000000 /* fail N times */
1037 lustre_fail ost $((0x0000021f | 0x10000000)) 1
1039 echo " step1: write out of block quota ..."
1040 $RUNAS2 dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=102400 &
1042 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT*2)) &
1045 echo " step2: testing ......"
1048 if ! ps -p ${DDPID1} > /dev/null 2>&1; then break; fi
1050 if [ $count -gt 64 ]; then
1052 quota_error u $TSTUSR2 "dd should be finished!"
1056 echo "(dd_pid=$DDPID1, time=$count)successful"
1058 #Recover fail_loc and dd will finish soon
1061 echo " step3: testing ......"
1064 if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1066 if [ $count -gt 150 ]; then
1067 quota_error u $TSTUSR "dd should be finished!"
1071 echo "(dd_pid=$DDPID, time=$count)successful"
1073 rm -f $TESTFILE $TESTFILE2
1074 sync; sleep 3; sync;
1076 resetquota -u $TSTUSR
1078 run_test_with_stat 12 "test a deadlock between quota and journal ==="
1080 # test multiple clients write block quota b=11693
1083 wait_delete_completed
1085 # one OST * 10 + (mds + other OSTs)
1086 LIMIT=$((BUNIT_SZ * 10 + (BUNIT_SZ * OSTCOUNT)))
1087 TESTFILE="$DIR/$tdir/$tfile"
1089 echo " User quota (limit: $LIMIT kbytes)"
1090 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1091 quota_show_check b u $TSTUSR
1093 $LFS setstripe $TESTFILE -i 0 -c 1
1094 chown $TSTUSR.$TSTUSR $TESTFILE
1095 $LFS setstripe $TESTFILE.2 -i 0 -c 1
1096 chown $TSTUSR.$TSTUSR $TESTFILE.2
1098 echo " step1: write out of block quota ..."
1099 # one bunit will give mds
1100 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1102 $RUNAS dd if=/dev/zero of=$TESTFILE.2 bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1105 echo " step2: testing ......"
1108 if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1110 if [ $count -gt 64 ]; then
1111 quota_error u $TSTUSR "dd should be finished!"
1115 echo "(dd_pid=$DDPID, time=$count)successful"
1119 if ! ps -p ${DDPID1} > /dev/null 2>&1 ; then break; fi
1121 if [ $count -gt 64 ]; then
1122 quota_error u $TSTUSR "dd should be finished!"
1126 echo "(dd_pid=$DDPID1, time=$count)successful"
1128 sync; sleep 5; sync;
1130 echo " step3: checking ......"
1131 fz=`stat -c %s $TESTFILE`
1132 fz2=`stat -c %s $TESTFILE.2`
1134 [ $((fz + fz2)) -lt $((BUNIT_SZ * BLK_SZ * 10)) ] && \
1135 quota_error u $TSTUSR "files too small $fz + $fz2 < $((BUNIT_SZ * BLK_SZ * 10))"
1137 rm -f $TESTFILE $TESTFILE.2
1138 sync; sleep 3; sync;
1140 resetquota -u $TSTUSR
1142 run_test_with_stat 13 "test multiple clients write block quota ==="
1144 check_if_quota_zero(){
1145 line=`$LFS quota -v -$1 $2 $DIR | wc -l`
1146 for i in `seq 3 $line`; do
1147 if [ $i -eq 3 ]; then
1153 tmp=`$LFS quota -v -$1 $2 $DIR | sed -n ${i}p |
1154 awk '{print $'"$j"'}'`
1155 [ -n "$tmp" ] && [ $tmp -ne 0 ] && $LFS quota -v -$1 $2 $DIR && \
1156 error "quota on $2 isn't clean"
1159 echo "pass check_if_quota_zero"
1162 test_14a() { # was test_14 b=12223 -- setting quota on root
1163 TESTFILE="$DIR/$tdir/$tfile"
1167 cleanup_and_setup_lustre
1172 # out of root's file and block quota
1173 $LFS setquota -u root -b 10 -B 10 -i 10 -I 10 $DIR
1174 createmany -m ${TESTFILE} 20 || \
1175 quota_error u root "unexpected: user(root) create files failly!"
1176 dd if=/dev/zero of=$TESTFILE bs=4k count=4096 || \
1177 quota_error u root "unexpected: user(root) write files failly!"
1179 $RUNAS dd if=/dev/zero of=${TESTFILE} seek=4096 bs=4k count=4096 && \
1180 quota_error u root "unexpected: user(quota_usr) write a file successfully!"
1184 for i in `seq 1 10`; do $RUNAS touch ${TESTFILE}a_$i; done
1185 for i in `seq 1 10`; do $RUNAS rm -f ${TESTFILE}a_$i; done
1188 dmesg | tail | grep "\-122" |grep llog_obd_origin_add && error "err -122 not found in dmesg"
1190 #check_if_quota_zero u root
1193 unlinkmany ${TESTFILE} 15
1195 sync; sleep 3; sync;
1197 run_test_with_stat 14a "test setting quota on root ==="
1200 LIMIT=$((24 * 1024 * 1024 * 1024 * 1024)) # 24 TB
1201 PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
1203 wait_delete_completed
1206 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1207 TOTAL_LIMIT="`$LFS quota -v -u $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
1208 [ $TOTAL_LIMIT -eq $LIMIT ] || error " (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1209 echo " (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1210 resetquota -u $TSTUSR
1213 $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1214 TOTAL_LIMIT="`$LFS quota -v -g $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
1215 [ $TOTAL_LIMIT -eq $LIMIT ] || error " (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1216 echo " (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1217 resetquota -g $TSTUSR
1218 $LFS quotaoff -ug $DIR
1219 do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_type=ug" | grep "error writing" && \
1220 error "fail to set version for $SINGLEMDS"
1221 for j in `seq $OSTCOUNT`; do
1222 do_facet ost$j "lctl set_param lquota.${FSNAME}-OST*.quota_type=ug" | grep "error writing" && \
1223 error "fail to set version for ost$j"
1226 echo "invalidating quota files"
1227 $LFS quotainv -ug $DIR
1228 $LFS quotainv -ugf $DIR
1229 $LFS quotacheck -ug $DIR
1231 run_test_with_stat 15 "set block quota more than 4T ==="
1233 # $1=u/g $2=with qunit adjust or not
1235 LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 4))
1236 TESTFILE="$DIR/$tdir/$tfile"
1239 wait_delete_completed
1241 echo " User quota (limit: $LIMIT kbytes)"
1242 if [ $1 == "u" ]; then
1243 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1244 quota_show_check b u $TSTUSR
1246 $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1247 quota_show_check b g $TSTUSR
1250 $LFS setstripe $TESTFILE -c 1
1251 chown $TSTUSR.$TSTUSR $TESTFILE
1254 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((BUNIT_SZ * 4)) || \
1255 quota_error a $TSTUSR "(usr) write failure, but expect success"
1257 echo " Write out of block quota ..."
1258 # this time maybe cache write, ignore it's failure
1259 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || true
1260 # flush cache, ensure noquota flag is setted on client
1261 cancel_lru_locks osc
1262 if [ $2 -eq 1 ]; then
1263 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || \
1264 quota_error a $TSTUSR "(write failure, but expect success"
1266 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) && \
1267 quota_error a $TSTUSR "(write success, but expect EDQUOT"
1271 sync; sleep 3; sync;
1272 resetquota -$1 $TSTUSR
1275 # test without adjusting qunit
1276 # 2.0 version does not support WITHOUT_CHANGE_QS, so such test is obsolete
1278 set_blk_tunesz $((BUNIT_SZ * 2))
1279 set_blk_unitsz $((BUNIT_SZ * 4))
1282 # define OBD_FAIL_QUOTA_WITHOUT_CHANGE_QS 0xA01
1283 echo " grp/usr: $i, adjust qunit: $j"
1284 echo "-------------------------------"
1285 [ $j -eq 1 ] && lustre_fail mds_ost 0
1286 [ $j -eq 0 ] && lustre_fail mds_ost 0xA01
1290 set_blk_unitsz $((128 * 1024))
1291 set_blk_tunesz $((128 * 1024 / 2))
1293 #run_test_with_stat 16 "test without adjusting qunit"
1295 # run for fixing bug14526, failed returned quota reqs shouldn't ruin lustre.
1300 wait_delete_completed
1302 #define OBD_FAIL_QUOTA_RET_QDATA | OBD_FAIL_ONCE
1303 lustre_fail ost 0x80000A02
1305 TESTFILE="$DIR/$tdir/$tfile-a"
1306 TESTFILE2="$DIR/$tdir/$tfile-b"
1309 BLK_LIMIT=$((100 * 1024)) # 100M
1311 log " Set enough high limit(block:$BLK_LIMIT) for user: $TSTUSR"
1312 $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
1313 log " Set enough high limit(block:$BLK_LIMIT) for group: $TSTUSR"
1314 $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
1316 quota_show_check b u $TSTUSR
1317 quota_show_check b g $TSTUSR
1320 chown $TSTUSR.$TSTUSR $TESTFILE
1322 chown $TSTUSR.$TSTUSR $TESTFILE2
1324 log " Write the test file1 ..."
1325 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(( 10 * 1024 )) \
1326 || quota_error a $TSTUSR "write 10M file failure"
1331 log " write the test file2 ..."
1332 $RUNAS dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=$(( 10 * 1024 )) \
1333 || quota_error a $TSTUSR "write 10M file failure"
1338 rm -f $TESTFILE $TESTFILE2
1340 sync; sleep 3; sync;
1342 # make qd_count 64 bit
1345 set_blk_unitsz $((128 * 1024))
1346 set_blk_tunesz $((128 * 1024 / 2))
1348 resetquota -u $TSTUSR
1349 resetquota -g $TSTUSR
1353 run_test_with_stat 17 "run for fixing bug14526 ==========="
1355 # test when mds takes a long time to handle a quota req so that
1356 # the ost has dropped it, the ost still could work well b=14840
1358 LIMIT=$((100 * 1024 * 1024)) # 100G
1359 TESTFILE="$DIR/$tdir/$tfile"
1362 wait_delete_completed
1367 log " User quota (limit: $LIMIT kbytes)"
1368 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1369 quota_show_check b u $TSTUSR
1371 $LFS setstripe $TESTFILE -i 0 -c 1
1372 chown $TSTUSR.$TSTUSR $TESTFILE
1374 #define OBD_FAIL_MDS_BLOCK_QUOTA_REQ 0x13c
1375 lustre_fail mds 0x13c
1377 log " step1: write 100M block ..."
1378 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1384 echo " step2: testing ......"
1386 if at_is_valid && at_is_enabled; then
1387 timeout=$(at_max_get mds)
1389 timeout=$(lctl get_param -n timeout)
1392 if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1394 if [ $count -gt $((4 * $timeout)) ]; then
1395 quota_error u $TSTUSR "count=$count dd should be finished!"
1399 log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1401 testfile_size=$(stat -c %s $TESTFILE)
1402 [ $testfile_size -ne $((BLK_SZ * 1024 * 100)) ] && \
1403 quota_error u $TSTUSR "expect $((BLK_SZ * 1024 * 100)), got ${testfile_size}. Verifying file failed!"
1405 sync; sleep 3; sync;
1407 resetquota -u $TSTUSR
1409 set_blk_unitsz $((128 * 1024))
1410 set_blk_tunesz $((128 * 1024 / 2))
1412 run_test_with_stat 18 "run for fixing bug14840 ==========="
1414 # test when mds drops a quota req, the ost still could work well b=14840
1416 LIMIT=$((100 * 1024 * 1024)) # 100G
1417 TESTFILE="$DIR/$tdir/$tfile-a"
1420 wait_delete_completed
1425 log " User quota (limit: $LIMIT kbytes)"
1426 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1427 quota_show_check b u $TSTUSR
1429 $LFS setstripe $TESTFILE -i 0 -c 1
1430 chown $TSTUSR.$TSTUSR $TESTFILE
1432 #define OBD_FAIL_MDS_DROP_QUOTA_REQ | OBD_FAIL_ONCE 0x8000013d
1433 lustre_fail mds 0x8000013d
1435 log " step1: write 100M block ..."
1436 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1439 echo " step2: testing ......"
1441 if at_is_valid && at_is_enabled; then
1442 timeout=$(at_max_get mds)
1444 timeout=$(lctl get_param -n timeout)
1447 if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1449 if [ $count -gt $((6 * $timeout)) ]; then
1451 quota_error u $TSTUSR "count=$count dd should be finished!"
1455 log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1460 sync; sleep 3; sync;
1462 resetquota -u $TSTUSR
1464 set_blk_unitsz $((128 * 1024))
1465 set_blk_tunesz $((128 * 1024 / 2))
1467 run_test_with_stat 18a "run for fixing bug14840 ==========="
1469 # test when mds do failover, the ost still could work well without trigger
1474 LIMIT=$((110 * 1024 )) # 110M
1475 TESTFILE="$DIR/$tdir/$tfile"
1478 wait_delete_completed
1483 log " User quota (limit: $LIMIT kbytes)"
1484 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1485 quota_show_check b u $TSTUSR
1487 $LFS setstripe $TESTFILE -i 0 -c 1
1488 chown $TSTUSR.$TSTUSR $TESTFILE
1490 timeout=$(sysctl -n lustre.timeout)
1492 if [ $type = "directio" ]; then
1493 log " write 100M block(directio) ..."
1494 $RUNAS $DIRECTIO write $TESTFILE 0 100 $((BLK_SZ * 1024)) &
1496 log " write 100M block(normal) ..."
1497 $RUNAS dd if=/dev/zero of=$TESTFILE bs=$((BLK_SZ * 1024)) count=100 &
1501 do_facet $SINGLEMDS "$LCTL conf_param ${FSNAME}-MDT*.mdd.quota_type=ug"
1503 log "failing mds for $((2 * timeout)) seconds"
1504 fail $SINGLEMDS $((2 * timeout))
1506 # check if quotaon successful
1507 $LFS quota -u $TSTUSR $MOUNT 2>&1 | grep -q "quotas are not enabled"
1508 if [ $? -eq 0 ]; then
1509 error "quotaon failed!"
1515 if at_is_valid && at_is_enabled; then
1516 timeout=$(at_max_get mds)
1518 timeout=$(lctl get_param -n timeout)
1521 if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1522 if [ $((++count % (2 * timeout) )) -eq 0 ]; then
1523 log "it took $count second"
1527 log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1530 testfile_size=$(stat -c %s $TESTFILE)
1531 [ $testfile_size -ne $((BLK_SZ * 1024 * 100)) ] && \
1532 quota_error u $TSTUSR "expect $((BLK_SZ * 1024 * 100)), got ${testfile_size}. Verifying file failed!"
1534 resetquota -u $TSTUSR
1539 # test when mds does failover, the ost still could work well
1540 # this test shouldn't trigger watchdog b=14840
1542 test_18bc_sub normal
1543 test_18bc_sub directio
1544 # check if watchdog is triggered
1545 do_facet ost1 dmesg > $TMP/lustre-log-${TESTNAME}.log
1546 watchdog=`awk '/test 18b/ {start = 1;}
1547 /Watchdog triggered/ {
1551 }' $TMP/lustre-log-${TESTNAME}.log`
1552 [ `echo "$watchdog" | wc -l` -ge 3 ] && error "$watchdog"
1553 rm -f $TMP/lustre-log-${TESTNAME}.log
1555 run_test_with_stat 18b "run for fixing bug14840(mds failover, no watchdog) ==========="
1557 # test when mds does failover, the ost still could work well
1558 # this test will prevent OST_DISCONNET from happening b=14840
1560 # define OBD_FAIL_OST_DISCONNECT_NET 0x202(disable ost_disconnect for osts)
1561 lustre_fail ost 0x202
1562 test_18bc_sub normal
1563 test_18bc_sub directio
1566 run_test_with_stat 18c "run for fixing bug14840(mds failover, OST_DISCONNECT is disabled) ==========="
1568 run_to_block_limit() {
1569 local LIMIT=$((($OSTCOUNT + 1) * $BUNIT_SZ))
1571 wait_delete_completed
1573 # set 1 Mb quota unit size
1577 # bind file to a single OST
1578 $LFS setstripe -c 1 $TESTFILE
1579 chown $TSTUSR.$TSTUSR $TESTFILE
1581 echo " User quota (limit: $LIMIT kbytes)"
1582 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1583 quota_show_check b u $TSTUSR
1584 echo " Updating quota limits"
1585 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1586 quota_show_check b u $TSTUSR
1588 RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
1589 $RUNDD count=$BUNIT_SZ || quota_error u $TSTUSR "(usr) write failure, but expect success"
1590 # for now page cache of TESTFILE may still be dirty,
1591 # let's push it to the corresponding OST, this will also
1592 # cache NOQUOTA on the client from OST's reply
1593 cancel_lru_locks osc
1594 $RUNDD seek=$BUNIT_SZ && quota_error u $TSTUSR "(usr) write success, should be EDQUOT"
1598 # 1 Mb bunit per each MDS/OSS
1599 local TESTFILE="$DIR/$tdir/$tfile"
1602 run_to_block_limit $TESTFILE
1607 resetquota -u $TSTUSR
1609 set_blk_unitsz $((128 * 1024))
1610 set_blk_tunesz $((128 * 1024 / 2))
1613 run_test_with_stat 19 "test if administrative limits updates do not zero operational limits (14790) ==="
1617 LSTR=(1t 2g 3m 4k) # limits strings
1618 LVAL=($[1*1024*1024*1024] $[2*1024*1024] $[3*1024*1024] $[4*1024]) # limits values
1620 $LFS setquota -u $TSTUSR --block-softlimit ${LSTR[0]} \
1621 $MOUNT || error "could not set quota limits"
1623 $LFS setquota -u $TSTUSR --block-hardlimit ${LSTR[1]} \
1624 --inode-softlimit ${LSTR[2]} \
1625 --inode-hardlimit ${LSTR[3]} \
1626 $MOUNT || error "could not set quota limits"
1628 ($LFS quota -v -u $TSTUSR $MOUNT | \
1629 grep -E '^ *'$MOUNT' *[0-9]+\** *'${LVAL[0]}' *'${LVAL[1]}' *[0-9]+\** *'${LVAL[2]}' *'${LVAL[3]}) \
1630 || error "lfs quota output is unexpected"
1632 resetquota -u $TSTUSR
1634 run_test_with_stat 20 "test if setquota specifiers work properly (15754)"
1641 time=$(($(date +%s) + seconds))
1642 while [ $(date +%s) -lt $time ]; do
1643 $RUNAS dd if=/dev/zero of=$testfile bs=$BLK_SZ count=$blk_number > /dev/null 2>&1
1648 # run for fixing bug16053, setquota shouldn't fail when writing and
1649 # deleting are happening
1654 wait_delete_completed
1656 TESTFILE="$DIR/$tdir/$tfile"
1658 BLK_LIMIT=$((10 * 1024 * 1024)) # 10G
1661 log " Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
1662 $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $MOUNT
1663 log " Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
1664 $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $MOUNT
1666 # repeat writing on a 1M file
1667 test_21_sub ${TESTFILE}_1 1024 30 &
1669 # repeat writing on a 128M file
1670 test_21_sub ${TESTFILE}_2 $((1024 * 128)) 30 &
1673 time=$(($(date +%s) + 30))
1675 while [ $(date +%s) -lt $time ]; do
1676 log " Set quota for $i times"
1677 $LFS setquota -u $TSTUSR -b 0 -B $((BLK_LIMIT + 1024 * i)) -i 0 -I $((FILE_LIMIT + i)) $MOUNT
1678 $LFS setquota -g $TSTUSR -b 0 -B $((BLK_LIMIT + 1024 * i)) -i 0 -I $((FILE_LIMIT + i)) $MOUNT
1685 if ! ps -p ${DDPID1} > /dev/null 2>&1; then break; fi
1687 if [ $count -gt 60 ]; then
1688 quota_error a $TSTUSR "dd should be finished!"
1692 echo "(dd_pid=$DDPID1, time=$count)successful"
1696 if ! ps -p ${DDPID2} > /dev/null 2>&1; then break; fi
1698 if [ $count -gt 60 ]; then
1699 quota_error a $TSTUSR "dd should be finished!"
1703 echo "(dd_pid=$DDPID2, time=$count)successful"
1705 set_blk_unitsz $((128 * 1024))
1706 set_blk_tunesz $((128 * 1024 / 2))
1707 resetquota -u $TSTUSR
1708 resetquota -g $TSTUSR
1712 run_test_with_stat 21 "run for fixing bug16053 ==========="
1715 $LFS quotaoff -ug $DIR || error "could not turn quotas off"
1717 quota_save_version "ug"
1723 echo "checking parameters"
1725 do_facet $SINGLEMDS "lctl get_param mdd.${FSNAME}-MDT*.quota_type" | grep "ug" || error "admin failure"
1726 do_facet ost1 "lctl get_param obdfilter.*.quota_type" | grep "ug" || error "op failure"
1728 run_test 0 "reboot lustre"
1730 run_test_with_stat 22 "test if quota_type saved as permanent parameter ===="
1732 # It is triggered when test_23 failed, diagnostic for bug 18293
1736 DUMPPAGE=`find /proc/fs/${FSNAME}/llite/ -name dump_page_cache`
1738 cat $DUMPPAGE > $TMP/sanity-quota_test_23_${qtime}_${NUM}.log
1739 fsize=`stat -c%s $TMP/sanity-quota_test_23_${qtime}_${NUM}.log`
1740 if [ $fsize -eq 0 ]; then
1741 rm -f $TMP/sanity-quota_test_23_${qtime}_${NUM}.log
1743 error "some IO error was found during directIO"
1749 chmod 0777 $DIR/$tdir
1750 TESTFILE="$DIR/$tdir/$tfile-0"
1752 local bs_unit=$((1024*1024))
1755 wait_delete_completed
1758 log " User quota (limit: $LIMIT kbytes)"
1759 $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1761 quota_show_check b u $TSTUSR
1763 $LFS setstripe $TESTFILE -c 1
1764 chown $TSTUSR.$TSTUSR $TESTFILE
1766 log " Step1: trigger quota with 0_DIRECT"
1767 log " Write half of file"
1768 $RUNAS $DIRECTIO write $TESTFILE 0 $(($LIMIT/1024/2)) $bs_unit || \
1769 (quota_error u $TSTUSR "(1) write failure, but expect success: $LIMIT" && test_23_dumppage 1)
1770 log " Write out of block quota ..."
1771 $RUNAS $DIRECTIO write $TESTFILE $(($LIMIT/1024/2)) $(($LIMIT/1024/2)) $bs_unit && \
1772 quota_error u $TSTUSR "(2) write success, but expect EDQUOT: $LIMIT" && test_23_dumppage 2
1775 log " Step2: rewrite should succeed"
1776 $RUNAS $DIRECTIO write $TESTFILE $(($LIMIT/1024/2)) 1 $bs_unit || \
1777 (quota_error u $TSTUSR "(3) write failure, but expect success: $LIMIT" && test_23_dumppage 3)
1781 wait_delete_completed
1782 OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
1783 OST0_QUOTA_USED=`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
1784 echo $OST0_QUOTA_USED
1785 [ $OST0_QUOTA_USED -ne 0 ] && \
1786 ($SHOW_QUOTA_USER; quota_error u $TSTUSR "quota deleted isn't released")
1788 resetquota -u $TSTUSR
1792 log "run for $((OSTCOUNT * 4))MB test file"
1793 test_23_sub $((OSTCOUNT * 4 * 1024))
1796 check_whether_skip && return 0
1797 log "run for $((OSTCOUNT * 40))MB test file"
1798 test_23_sub $((OSTCOUNT * 40 * 1024))
1800 run_test_with_stat 23 "run for fixing bug16125 ==========="
1803 local TESTFILE="$DIR/$tdir/$tfile"
1806 run_to_block_limit $TESTFILE
1807 $SHOW_QUOTA_USER | grep '*' || error "no matching *"
1811 resetquota -u $TSTUSR
1813 set_blk_unitsz $((128 * 1024))
1814 set_blk_tunesz $((128 * 1024 / 2))
1817 run_test_with_stat 24 "test if lfs draws an asterix when limit is reached (16646) ==========="
1820 if [ $1 = "-u" ]; then
1821 if [ $2 = "$TSTUSR" ]; then
1827 if [ $2 = "$TSTUSR" ]; then
1837 chmod 0777 $DIR/$tdir
1838 TESTFILE="$DIR/$tdir/$tfile-0"
1840 LIMIT=$(( $BUNIT_SZ * ($OSTCOUNT + 1) + 4096 ))
1842 wait_delete_completed
1844 # set quota for $TSTUSR
1845 log "setquota for $TSTUSR"
1846 $LFS setquota $1 $TSTUSR -b $LIMIT -B $LIMIT -i 10 -I 10 $DIR
1848 if [ "$1" == "-u" ]; then
1849 quota_show_check a u $TSTUSR
1851 quota_show_check a g $TSTUSR
1854 # set quota for $TSTUSR2
1855 log "setquota for $TSTUSR2"
1856 $LFS setquota $1 $TSTUSR2 -b $LIMIT -B $LIMIT -i 10 -I 10 $DIR
1858 if [ "$1" == "-u" ]; then
1859 quota_show_check a u $TSTUSR2
1861 quota_show_check a g $TSTUSR2
1864 # set stripe index to 0
1865 log "setstripe for $DIR/$tdir to 0"
1866 $LFS setstripe $DIR/$tdir -c 1 -i 0
1867 MDS_UUID=`do_facet $SINGLEMDS $LCTL dl | grep -m1 " mdt " | awk '{print $((NF-1))}'`
1868 OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
1869 MDS_QUOTA_USED_OLD=`$LFS quota -o $MDS_UUID $1 $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
1870 OST0_QUOTA_USED_OLD=`$LFS quota -o $OST0_UUID $1 $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
1871 MDS_QUOTA_USED2_OLD=`$LFS quota -o $MDS_UUID $1 $TSTUSR2 $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
1872 OST0_QUOTA_USED2_OLD=`$LFS quota -o $OST0_UUID $1 $TSTUSR2 $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
1875 log "$TSTUSR write 4M to $TESTFILE"
1876 $RUNAS dd if=/dev/zero of=$TESTFILE bs=4K count=1K || quota_error a $TSTUSR "dd failed"
1878 show_quota $1 $TSTUSR
1879 show_quota $1 $TSTUSR2
1880 MDS_QUOTA_USED_NEW=`$LFS quota -o $MDS_UUID $1 $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
1881 [ $MDS_QUOTA_USED_NEW -ne $((MDS_QUOTA_USED_OLD + 1)) ] && \
1882 quota_error a $TSTUSR "$TSTUSR inode quota usage error: [$MDS_QUOTA_USED_OLD|$MDS_QUOTA_USED_NEW]"
1883 OST0_QUOTA_USED_NEW=`$LFS quota -o $OST0_UUID $1 $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
1884 OST0_QUOTA_USED_DELTA=$((OST0_QUOTA_USED_NEW - OST0_QUOTA_USED_OLD))
1885 [ $OST0_QUOTA_USED_DELTA -lt 4096 ] && \
1886 quota_error a $TSTUSR "$TSTUSR block quota usage error: [$OST0_QUOTA_USED_OLD|$OST0_QUOTA_USED_NEW]"
1888 # chown/chgrp from $TSTUSR to $TSTUSR2
1889 if [ $1 = "-u" ]; then
1890 log "chown from $TSTUSR to $TSTUSR2"
1891 chown $TSTUSR2 $TESTFILE || quota_error u $TSTUSR2 "chown failed"
1893 log "chgrp from $TSTUSR to $TSTUSR2"
1894 chgrp $TSTUSR2 $TESTFILE || quota_error g $TSTUSR2 "chgrp failed"
1897 show_quota $1 $TSTUSR
1898 show_quota $1 $TSTUSR2
1899 MDS_QUOTA_USED2_NEW=`$LFS quota -o $MDS_UUID $1 $TSTUSR2 $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
1900 [ $MDS_QUOTA_USED2_NEW -ne $((MDS_QUOTA_USED2_OLD + 1)) ] && \
1901 quota_error a $TSTUSR2 "$TSTUSR2 inode quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$MDS_QUOTA_USED2_OLD|$MDS_QUOTA_USED2_NEW]"
1902 OST0_QUOTA_USED2_NEW=`$LFS quota -o $OST0_UUID $1 $TSTUSR2 $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
1903 OST0_QUOTA_USED2_DELTA=$((OST0_QUOTA_USED2_NEW - OST0_QUOTA_USED2_OLD))
1904 [ $OST0_QUOTA_USED2_DELTA -ne $OST0_QUOTA_USED_DELTA ] && \
1905 quota_error a $TSTUSR2 "$TSTUSR2 block quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$OST0_QUOTA_USED2_OLD|$OST0_QUOTA_USED2_NEW]"
1906 MDS_QUOTA_USED_NEW=`$LFS quota -o $MDS_UUID $1 $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
1907 [ $MDS_QUOTA_USED_NEW -ne $MDS_QUOTA_USED_OLD ] && \
1908 quota_error a $TSTUSR "$TSTUSR inode quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$MDS_QUOTA_USED_OLD|$MDS_QUOTA_USED_NEW]"
1909 OST0_QUOTA_USED_NEW=`$LFS quota -o $OST0_UUID $1 $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
1910 [ $OST0_QUOTA_USED_NEW -ne $OST0_QUOTA_USED_OLD ] && \
1911 quota_error a $TSTUSR "$TSTUSR block quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$OST0_QUOTA_USED_OLD|$OST0_QUOTA_USED_NEW]"
1914 wait_delete_completed
1915 resetquota $1 $TSTUSR
1916 resetquota $1 $TSTUSR2
1920 log "run for chown case"
1923 log "run for chgrp case"
1926 run_test_with_stat 25 "test whether quota usage is transfered when chown/chgrp (18081) ==========="
1930 chmod 0777 $DIR/$tdir
1931 TESTFILE="$DIR/$tdir/$tfile-0"
1932 TESTFILE2="$DIR/$tdir/$tfile-1"
1936 wait_delete_completed
1938 # every quota slave gets 20MB
1939 b_limit=$((OSTCOUNT * 20 * 1024))
1940 log "limit: ${b_limit}KB"
1941 $LFS setquota -u $TSTUSR -b 0 -B $b_limit -i 0 -I 0 $DIR
1943 quota_show_check b u $TSTUSR
1945 $LFS setstripe $TESTFILE -c 1 -i 0
1946 $LFS setstripe $TESTFILE2 -c 1 -i 0
1947 chown $TSTUSR.$TSTUSR $TESTFILE
1948 chown $TSTUSR.$TSTUSR $TESTFILE2
1950 #define OBD_FAIL_QUOTA_DELAY_REL 0xA03
1951 lustre_fail ost 0xA03
1953 log " Write the first file..."
1954 $RUNAS $DIRECTIO write $TESTFILE 0 10 $((BLK_SZ * 1024)) || quota_error u $TSTUSR "write failure, but expect success"
1955 log " Delete the first file..."
1959 wait_delete_completed
1961 log " Write the second file..."
1962 $RUNAS $DIRECTIO write $TESTFILE2 0 10 $((BLK_SZ * 1024)) || quota_error u $TSTUSR "write failure, but expect success"
1963 log " Delete the second file..."
1967 set_blk_unitsz $((128 * 1024))
1968 set_blk_tunesz $((128 * 1024 / 2))
1969 resetquota -u $TSTUSR
1971 run_test_with_stat 26 "test for false quota error(bz18491) ======================================"
1977 lctl set_param debug="-quota"
1981 run_test_with_stat 99 "Quota off ==============================="
1984 log "cleanup: ======================================================"
1986 check_and_cleanup_lustre
1987 echo '=========================== finished ==============================='
1988 [ -f "$QUOTALOG" ] && cat $QUOTALOG && grep -q FAIL $QUOTALOG && exit 1 || true
1989 echo "$0: completed"