Whamcloud - gitweb
6d9f8aabd82f3be1ce63d399bd005d83cb474ba0
[fs/lustre-release.git] / lustre / tests / sanity-quota.sh
1 #!/bin/bash
2 #
3 # Run select tests by setting ONLY, or as arguments to the script.
4 # Skip specific tests by setting EXCEPT.
5 #
6 # Run test by setting NOSETUP=true when ltest has setup env for us
7 set -e
8
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"
13     exit 0
14 fi
15
16 SRCDIR=`dirname $0`
17 export PATH=$PWD/$SRCDIR:$SRCDIR:$PWD/$SRCDIR/../utils:$PATH:/sbin
18
19 ONLY=${ONLY:-"$*"}
20 # test_11 has been used to protect a kernel bug(bz10912), now it isn't
21 # useful any more. Then add it to ALWAYS_EXCEPT. b=19835
22 ALWAYS_EXCEPT="10 $SANITY_QUOTA_EXCEPT"
23 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
24
25 case `uname -r` in
26 2.6*) FSTYPE=${FSTYPE:-ldiskfs};;
27 *) error "unsupported kernel" ;;
28 esac
29
30 [ "$ALWAYS_EXCEPT$EXCEPT" ] && \
31         echo "Skipping tests: `echo $ALWAYS_EXCEPT $EXCEPT`"
32
33 TMP=${TMP:-/tmp}
34
35 ORIG_PWD=${PWD}
36 TSTID=${TSTID:-60000}
37 TSTID2=${TSTID2:-60001}
38 TSTUSR=${TSTUSR:-"quota_usr"}
39 TSTUSR2=${TSTUSR2:-"quota_2usr"}
40 BLK_SZ=1024
41 BUNIT_SZ=${BUNIT_SZ:-1024}      # min block quota unit(kB)
42 IUNIT_SZ=${IUNIT_SZ:-10}        # min inode quota unit
43 MAX_DQ_TIME=604800
44 MAX_IQ_TIME=604800
45
46 TRACE=${TRACE:-""}
47 LUSTRE=${LUSTRE:-`dirname $0`/..}
48 . $LUSTRE/tests/test-framework.sh
49 init_test_env $@
50 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
51 init_logging
52 DIRECTIO=${DIRECTIO:-$LUSTRE/tests/directio}
53
54 [ $MDSCOUNT -gt 1 ] && skip "CMD case" && exit 0
55
56 require_dsh_mds || exit 0
57 require_dsh_ost || exit 0
58
59 [ "$SLOW" = "no" ] && EXCEPT_SLOW="9 10 11 18b 21"
60
61 QUOTALOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}
62
63 [ "$QUOTALOG" ] && rm -f $QUOTALOG || true
64
65 DIR=${DIR:-$MOUNT}
66 DIR2=${DIR2:-$MOUNT2}
67
68 QUOTA_AUTO_OLD=$QUOTA_AUTO
69 export QUOTA_AUTO=0
70
71 check_and_setup_lustre
72
73 LOVNAME=`lctl get_param -n llite.*.lov.common_name | tail -n 1`
74 OSTCOUNT=`lctl get_param -n lov.$LOVNAME.numobd`
75
76 SHOW_QUOTA_USER="$LFS quota -v -u $TSTUSR $DIR"
77 SHOW_QUOTA_USERID="$LFS quota -v -u $TSTID $DIR"
78 SHOW_QUOTA_USER2="$LFS quota -v -u $TSTUSR2 $DIR"
79 SHOW_QUOTA_GROUP="$LFS quota -v -g $TSTUSR $DIR"
80 SHOW_QUOTA_GROUPID="$LFS quota -v -g $TSTID $DIR"
81 SHOW_QUOTA_GROUP2="$LFS quota -v -g $TSTUSR2 $DIR"
82 SHOW_QUOTA_INFO_USER="$LFS quota -t -u $DIR"
83 SHOW_QUOTA_INFO_GROUP="$LFS quota -t -g $DIR"
84
85 # control the time of tests
86 cycle=30
87 [ "$SLOW" = "no" ] && cycle=10
88
89 build_test_filter
90
91 # set_blk_tunables(btune_sz)
92 set_blk_tunesz() {
93         local btune=$(($1 * BLK_SZ))
94         # set btune size on all obdfilters
95         do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_btune_sz=$btune"
96         # set btune size on mds
97         do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_btune_sz=$btune"
98 }
99
100 # set_blk_unitsz(bunit_sz)
101 set_blk_unitsz() {
102         local bunit=$(($1 * BLK_SZ))
103         # set bunit size on all obdfilters
104         do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_bunit_sz=$bunit"
105         # set bunit size on mds
106         do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_bunit_sz=$bunit"
107 }
108
109 # set_file_tunesz(itune_sz)
110 set_file_tunesz() {
111         local itune=$1
112         # set itune size on all obdfilters
113         do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_itune_sz=$itune"
114         # set itune size on mds
115         do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_itune_sz=$itune"
116 }
117
118 # set_file_unitsz(iunit_sz)
119 set_file_unitsz() {
120         local iunit=$1
121         # set iunit size on all obdfilters
122         do_facet ost1 "lctl set_param lquota.${FSNAME}-OST*.quota_iunit_sz=$iunit"
123         # set iunit size on mds
124         do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_iunit_sz=$iunit"
125 }
126
127 lustre_fail() {
128         local fail_node=$1
129         local fail_loc=$2
130         local fail_val=${3:-0}
131
132         if [ $fail_node == "mds" ] || [ $fail_node == "mds_ost" ]; then
133             if [ $((fail_loc & 0x10000000)) -ne 0  -a $fail_val -gt 0 ] || \
134                 [ $((fail_loc)) -eq 0 ]; then
135                 do_facet $SINGLEMDS "lctl set_param fail_val=$fail_val"
136             fi
137             do_facet $SINGLEMDS "lctl set_param fail_loc=$fail_loc"
138         fi
139         if [ $fail_node == "ost" ] || [ $fail_node == "mds_ost" ]; then
140             for num in `seq $OSTCOUNT`; do
141                 if [ $((fail_loc & 0x10000000)) -ne 0 -a $fail_val -gt 0 ] || \
142                     [ $((fail_loc)) -eq 0 ]; then
143                     do_facet ost$num "lctl set_param fail_val=$fail_val"
144                 fi
145                 do_facet ost$num "lctl set_param fail_loc=$fail_loc"
146             done
147         fi
148 }
149
150 RUNAS="runas -u $TSTID -g $TSTID"
151 RUNAS2="runas -u $TSTID2 -g $TSTID2"
152 FAIL_ON_ERROR=true check_runas_id $TSTID $TSTID $RUNAS
153 FAIL_ON_ERROR=true check_runas_id $TSTID2 $TSTID2 $RUNAS2
154
155 FAIL_ON_ERROR=false
156
157 run_test_with_stat() {
158         (($# != 2)) && error "the number of arguments is wrong"
159
160         do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.stats=0" > /dev/null
161         for j in `seq $OSTCOUNT`; do
162             do_facet ost$j "lctl set_param lquota.${FSNAME}-OST*.stats=0" > /dev/null
163         done
164         run_test "$@"
165         if [ ${STAT:-"yes"} != "no" -a -z "$LAST_SKIPPED" ]; then
166             echo "statistics info begin ***************************************"
167             do_facet $SINGLEMDS "lctl get_param lquota.mdd_obd-${FSNAME}-MDT*.stats"
168             for j in `seq $OSTCOUNT`; do
169                 do_facet ost$j "lctl get_param lquota.${FSNAME}-OST*.stats"
170             done
171             echo "statistics info end   ***************************************"
172         fi
173 }
174
175 #
176 # clear quota limits for a user or a group
177 # usage: resetquota -u username
178 #        resetquota -g groupname
179
180 resetquota() {
181         [ "$#" != 2 ] && error "resetquota: wrong number of arguments: $#"
182         [ "$1" != "-u" -a "$1" != "-g" ] && error "resetquota: wrong specifier $1 passed"
183
184         count=0
185         if at_is_enabled; then
186             timeout=$(at_max_get mds)
187         else
188             timeout=$(lctl get_param -n timeout)
189         fi
190
191         while [ $((count++)) -lt $timeout ]; do
192                 local RC=0
193                 OUTPUT=`$LFS setquota "$1" "$2" -b 0 -B 0 -i 0 -I 0 $MOUNT 2>&1` || RC=${PIPESTATUS[0]}
194                 if [ $RC -ne 0 ]; then
195                         if echo "$OUTPUT" | grep -q busy; then
196                                 log "resetquota is blocked for quota master recovery, retry after $((count * 3)) sec"
197                                 sleep 3
198                                 continue
199                         else
200                                 error "resetquota failed"
201                         fi
202                 fi
203                 break
204         done
205
206         [ $count -lt $timeout ] || error "resetquota timeout: $timeout"
207 }
208
209 quota_scan() {
210         LOCAL_UG=$1
211         LOCAL_ID=$2
212
213         if [ "$LOCAL_UG" == "a" -o "$LOCAL_UG" == "u" ]; then
214                 log "Files for user ($LOCAL_ID):"
215                 ($LFS find -user $LOCAL_ID $DIR | xargs stat 2>/dev/null)
216         fi
217
218         if [ "$LOCAL_UG" == "a" -o "$LOCAL_UG" == "g" ]; then
219                 log "Files for group ($LOCAL_ID):"
220                 ($LFS find -group $LOCAL_ID $DIR | xargs stat 2>/dev/null)
221         fi
222 }
223
224 quota_error() {
225         quota_scan $1 $2
226         shift 2
227         error "$*"
228 }
229
230 quota_log() {
231         quota_scan $1 $2
232         shift 2
233         log "$*"
234 }
235
236 #
237 # get quota info for a user or a group
238 # usage: getquota -u|-g <username>|<groupname> global|<obd_uuid> bhardlimit|bsoftlimit|bgrace|ihardlimit|isoftlimit|igrace
239 #
240 getquota() {
241         local spec
242         local uuid
243
244         [ "$#" != 4 ] && error "getquota: wrong number of arguments: $#"
245         [ "$1" != "-u" -a "$1" != "-g" ] && error "getquota: wrong u/g specifier $1 passed"
246
247         uuid="$3"
248
249         case "$4" in
250                 curspace)   spec=1;;
251                 bsoftlimit) spec=2;;
252                 bhardlimit) spec=3;;
253                 bgrace)     spec=4;;
254                 curinodes)  spec=5;;
255                 isoftlimit) spec=6;;
256                 ihardlimit) spec=7;;
257                 igrace)     spec=8;;
258                 *)          error "unknown quota parameter $4";;
259         esac
260
261         [ "$uuid" = "global" ] && uuid=$DIR
262
263         $LFS quota -v "$1" "$2" $DIR | awk 'BEGIN { num='$spec' } { if ($1 == "'$uuid'") { if (NF == 1) { getline } else { num++ } ; print $num;} }'
264 }
265
266 quota_show_check() {
267         LOCAL_BF=$1
268         LOCAL_UG=$2
269         LOCAL_ID=$3
270         PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
271
272         $LFS quota -v -$LOCAL_UG $LOCAL_ID $DIR
273
274         if [ "$LOCAL_BF" == "a" -o "$LOCAL_BF" == "b" ]; then
275                 USAGE=`getquota -$LOCAL_UG $LOCAL_ID global curspace`
276                 if [ -z $USAGE ]; then
277                         quota_error $LOCAL_UG $LOCAL_ID "System is error when query quota for block ($LOCAL_UG:$LOCAL_ID)."
278                 else
279                         [ $USAGE -ne 0 ] && quota_log $LOCAL_UG $LOCAL_ID "System is not clean for block ($LOCAL_UG:$LOCAL_ID:$USAGE)."
280                 fi
281         fi
282
283         if [ "$LOCAL_BF" == "a" -o "$LOCAL_BF" == "f" ]; then
284                 USAGE=`getquota -$LOCAL_UG $LOCAL_ID global curinodes`
285                 if [ -z $USAGE ]; then
286                         quota_error $LOCAL_UG $LOCAL_ID "System is error when query quota for file ($LOCAL_UG:$LOCAL_ID)."
287                 else
288                         [ $USAGE -ne 0 ] && quota_log $LOCAL_UG $LOCAL_ID "System is not clean for file ($LOCAL_UG:$LOCAL_ID:$USAGE)."
289                 fi
290         fi
291 }
292
293 # set quota
294 quota_init() {
295         $LFS quotacheck -ug $DIR
296
297         resetquota -u $TSTUSR
298         resetquota -g $TSTUSR
299
300         do_nodes $(comma_list $(nodes_list)) "lctl set_param debug=+quota"
301 }
302 quota_init
303
304 # test for specific quota limitation, qunit, qtune $1=block_quota_limit
305 test_1_sub() {
306         LIMIT=$1
307         mkdir -p $DIR/$tdir
308         chmod 0777 $DIR/$tdir
309         TESTFILE="$DIR/$tdir/$tfile-0"
310
311         wait_delete_completed
312
313         # test for user
314         log "  User quota (limit: $LIMIT kbytes)"
315         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
316         sleep 3
317         quota_show_check b u $TSTUSR
318
319         $LFS setstripe $TESTFILE -c 1
320         chown $TSTUSR.$TSTUSR $TESTFILE
321
322         log "    Write ..."
323         stime=`date +%s`
324         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || quota_error u $TSTUSR "(usr) write failure, but expect success"
325         etime=`date +%s`
326         delta=$((etime - stime))
327         if [ $delta -gt 0 ]; then
328                 rate=$((BLK_SZ * LIMIT / 2 / delta / 1024))
329                 [ $rate -gt 1024 ] || error "SLOW IO for $TSTUSR (user): $rate KB/sec"
330         fi
331         log "    Done"
332         log "    Write out of block quota ..."
333         # this time maybe cache write,  ignore it's failure
334         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
335         # flush cache, ensure noquota flag is setted on client
336         cancel_lru_locks osc
337         $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"
338
339         rm -f $TESTFILE
340         sync; sleep 1; sync;
341         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
342         OST0_QUOTA_USED=`getquota -u $TSTUSR $OST0_UUID curspace`
343         echo $OST0_QUOTA_USED
344         [ $OST0_QUOTA_USED -ne 0 ] && \
345             ($SHOW_QUOTA_USER; quota_error u $TSTUSR "(usr) quota deleted isn't released")
346         $SHOW_QUOTA_USER
347         resetquota -u $TSTUSR
348
349         # test for group
350         log "--------------------------------------"
351         log "  Group quota (limit: $LIMIT kbytes)"
352         $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
353         sleep 3
354         quota_show_check b g $TSTUSR
355         TESTFILE="$DIR/$tdir/$tfile-1"
356
357         $LFS setstripe $TESTFILE -c 1
358         chown $TSTUSR.$TSTUSR $TESTFILE
359
360         log "    Write ..."
361         stime=`date +%s`
362         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || quota_error g $TSTUSR "(grp) write failure, but expect success"
363         etime=`date +%s`
364         delta=$((etime - stime))
365         if [ $delta -gt 0 ]; then
366                 rate=$((BLK_SZ * LIMIT / 2 / delta / 1024))
367                 [ $rate -gt 1024 ] || error "SLOW IO for $TSTUSR (group): $rate KB/sec"
368         fi
369         log "    Done"
370         log "    Write out of block quota ..."
371         # this time maybe cache write, ignore it's failure
372         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
373         cancel_lru_locks osc
374         $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"
375
376         # cleanup
377         rm -f $TESTFILE
378         sync; sleep 1; sync;
379         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
380         OST0_QUOTA_USED=`getquota -g $TSTUSR $OST0_UUID curspace`
381         echo $OST0_QUOTA_USED
382         [ $OST0_QUOTA_USED -ne 0 ] && \
383             ($SHOW_QUOTA_GROUP; quota_error g $TSTUSR "(grp) quota deleted isn't released")
384         $SHOW_QUOTA_GROUP
385         resetquota -g $TSTUSR
386 }
387
388 # block hard limit (normal use and out of quota)
389 test_1() {
390         for i in `seq 1 $cycle`; do
391             # define blk_qunit is between 1M and 4M
392             blk_qunit=$(( $RANDOM % 3072 + 1024 ))
393             blk_qtune=$(( $RANDOM % $blk_qunit ))
394             # other osts and mds will occupy at 1M blk quota
395             b_limit=$(( ($RANDOM - 16384) / 8 +  ($OSTCOUNT + 1) * $blk_qunit * 4 ))
396             set_blk_tunesz $blk_qtune
397             set_blk_unitsz $blk_qunit
398             echo "cycle: $i(total $cycle) bunit:$blk_qunit, btune:$blk_qtune, blimit:$b_limit"
399             test_1_sub $b_limit
400             echo "=================================================="
401             set_blk_unitsz $((128 * 1024))
402             set_blk_tunesz $((128 * 1024 / 2))
403         done
404 }
405 run_test_with_stat 1 "Block hard limit (normal use and out of quota) ==="
406
407 # test for specific quota limitation, qunit, qtune $1=block_quota_limit
408 test_2_sub() {
409         LIMIT=$1
410         mkdir -p $DIR/$tdir
411         chmod 0777 $DIR/$tdir
412         TESTFILE="$DIR/$tdir/$tfile-0"
413
414         wait_delete_completed
415
416         # test for user
417         log "  User quota (limit: $LIMIT files)"
418         $LFS setquota -u $TSTUSR -b 0 -B 0 -i 0 -I $LIMIT $DIR
419         sleep 3
420         quota_show_check f u $TSTUSR
421
422         log "    Create $LIMIT files ..."
423         $RUNAS createmany -m ${TESTFILE} $LIMIT || \
424                 quota_error u $TSTUSR "(usr) create failure, but expect success"
425         log "    Done"
426         log "    Create out of file quota ..."
427         $RUNAS touch ${TESTFILE}_xxx && \
428                 quota_error u $TSTUSR "(usr) touch success, but expect EDQUOT"
429
430         unlinkmany ${TESTFILE} $LIMIT
431         rm -f ${TESTFILE}_xxx
432         sync; sleep 1; sync;
433
434         MDS_UUID=`do_facet $SINGLEMDS $LCTL dl | grep -m1 " mdt " | awk '{print $((NF-1))}'`
435         MDS_QUOTA_USED=`getquota -u $TSTUSR $MDS_UUID curinodes`
436         echo $MDS_QUOTA_USED
437         [ $MDS_QUOTA_USED -ne 0 ] && \
438             ($SHOW_QUOTA_USER; quota_error u $TSTUSR "(usr) quota deleted isn't released")
439         $SHOW_QUOTA_USER
440         resetquota -u $TSTUSR
441
442         # test for group
443         log "--------------------------------------"
444         log "  Group quota (limit: $LIMIT FILE)"
445         $LFS setquota -g $TSTUSR -b 0 -B 0 -i 0 -I $LIMIT $DIR
446         sleep 3
447         quota_show_check f g $TSTUSR
448         TESTFILE=$DIR/$tdir/$tfile-1
449
450         log "    Create $LIMIT files ..."
451         $RUNAS createmany -m ${TESTFILE} $LIMIT || \
452                 quota_error g $TSTUSR "(grp) create failure, but expect success"
453         log "    Done"
454         log "    Create out of file quota ..."
455         $RUNAS touch ${TESTFILE}_xxx && \
456                 quota_error g $TSTUSR "(grp) touch success, but expect EDQUOT"
457
458         unlinkmany ${TESTFILE} $LIMIT
459         rm -f ${TESTFILE}_xxx
460         sync; sleep 1; sync;
461
462         MDS_UUID=`do_facet $SINGLEMDS $LCTL dl | grep -m1 " mdt " | awk '{print $((NF-1))}'`
463         MDS_QUOTA_USED=`getquota -g $TSTUSR $MDS_UUID curinodes`
464         echo $MDS_QUOTA_USED
465         [ $MDS_QUOTA_USED -ne 0 ] && \
466             ($SHOW_QUOTA_GROUP; quota_error g $TSTUSR "(grp) quota deleted isn't released")
467         $SHOW_QUOTA_GROUP
468         resetquota -g $TSTUSR
469 }
470
471 # file hard limit (normal use and out of quota)
472 test_2() {
473         for i in `seq 1 $cycle`; do
474             if [ $i -eq 1 ]; then
475                 ino_qunit=52
476                 ino_qtune=41
477                 i_limit=11
478             else
479                 # define ino_qunit is between 10 and 100
480                 ino_qunit=$(( $RANDOM % 90 + 10 ))
481                 ino_qtune=$(( $RANDOM % $ino_qunit ))
482                 # RANDOM's maxium is 32767
483                 i_limit=$(( $RANDOM % 990 + 10 ))
484             fi
485
486             set_file_tunesz $ino_qtune
487             set_file_unitsz $ino_qunit
488             echo "cycle: $i(total $cycle) iunit:$ino_qunit, itune:$ino_qtune, ilimit:$i_limit"
489             test_2_sub $i_limit
490             echo "=================================================="
491             set_file_unitsz 5120
492             set_file_tunesz 2560
493         done
494 }
495 run_test_with_stat 2 "File hard limit (normal use and out of quota) ==="
496
497 test_block_soft() {
498         TESTFILE=$1
499         TIMER=$(($2 * 3 / 2))
500         OFFSET=0
501
502         wait_delete_completed
503
504         echo "    Write to exceed soft limit"
505         RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
506         $RUNDD count=$((BUNIT_SZ+1)) || \
507                 quota_error a $TSTUSR "write failure, but expect success"
508         OFFSET=$((OFFSET + BUNIT_SZ + 1))
509         cancel_lru_locks osc
510
511         $SHOW_QUOTA_USER
512         $SHOW_QUOTA_GROUP
513         $SHOW_QUOTA_INFO_USER
514         $SHOW_QUOTA_INFO_GROUP
515
516         echo "    Write before timer goes off"
517         $RUNDD count=$BUNIT_SZ seek=$OFFSET || \
518                 quota_error a $TSTUSR "write failure, but expect success"
519         OFFSET=$((OFFSET + BUNIT_SZ))
520         cancel_lru_locks osc
521         echo "    Done"
522
523         echo "    Sleep $TIMER seconds ..."
524         sleep $TIMER
525
526         $SHOW_QUOTA_USER
527         $SHOW_QUOTA_GROUP
528         $SHOW_QUOTA_INFO_USER
529         $SHOW_QUOTA_INFO_GROUP
530
531         echo "    Write after timer goes off"
532         # maybe cache write, ignore.
533         $RUNDD count=$BUNIT_SZ seek=$OFFSET || true
534         OFFSET=$((OFFSET + BUNIT_SZ))
535         cancel_lru_locks osc
536         $RUNDD count=$BUNIT_SZ seek=$OFFSET && \
537                 quota_error a $TSTUSR "write success, but expect EDQUOT"
538
539         $SHOW_QUOTA_USER
540         $SHOW_QUOTA_GROUP
541         $SHOW_QUOTA_INFO_USER
542         $SHOW_QUOTA_INFO_GROUP
543
544         echo "    Unlink file to stop timer"
545         rm -f $TESTFILE
546         sync; sleep 1; sync
547         echo "    Done"
548
549         $SHOW_QUOTA_USER
550         $SHOW_QUOTA_GROUP
551         $SHOW_QUOTA_INFO_USER
552         $SHOW_QUOTA_INFO_GROUP
553
554         echo "    Write ..."
555         $RUNDD count=$BUNIT_SZ || quota_error a $TSTUSR "write failure, but expect success"
556         echo "    Done"
557
558         # cleanup
559         rm -f $TESTFILE
560         sync; sleep 3; sync;
561 }
562
563 # block soft limit (start timer, timer goes off, stop timer)
564 test_3() {
565         mkdir -p $DIR/$tdir
566         chmod 0777 $DIR/$tdir
567
568         # 1 bunit on mds and 1 bunit on every ost
569         LIMIT=$(( $BUNIT_SZ * ($OSTCOUNT + 1) ))
570         GRACE=10
571
572         echo "  User quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
573         TESTFILE=$DIR/$tdir/$tfile-0
574
575         $LFS setstripe $TESTFILE -c 1
576         chown $TSTUSR.$TSTUSR $TESTFILE
577
578         $LFS setquota -t -u --block-grace $GRACE --inode-grace $MAX_IQ_TIME $DIR
579         $LFS setquota -u $TSTUSR -b $LIMIT -B 0 -i 0 -I 0 $DIR
580
581         test_block_soft $TESTFILE $GRACE
582         resetquota -u $TSTUSR
583
584         echo "  Group quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
585         TESTFILE=$DIR/$tdir/$tfile-1
586
587         $LFS setstripe $TESTFILE -c 1
588         chown $TSTUSR.$TSTUSR $TESTFILE
589
590         $LFS setquota -t -g --block-grace $GRACE --inode-grace $MAX_IQ_TIME $DIR
591         $LFS setquota -g $TSTUSR -b $LIMIT -B 0 -i 0 -I 0 $DIR
592
593         test_block_soft $TESTFILE $GRACE
594         resetquota -g $TSTUSR
595 }
596 run_test_with_stat 3 "Block soft limit (start timer, timer goes off, stop timer) ==="
597
598 test_file_soft() {
599         TESTFILE=$1
600         LIMIT=$2
601         TIMER=$(($3 * 3 / 2))
602
603         wait_delete_completed
604
605         echo "    Create files to exceed soft limit"
606         $RUNAS createmany -m ${TESTFILE}_ $((LIMIT + 1)) || \
607                 quota_error a $TSTUSR "create failure, but expect success"
608         sync; sleep 1; sync
609         echo "    Done"
610
611         echo "    Create file before timer goes off"
612         $RUNAS touch ${TESTFILE}_before || \
613                 quota_error a $TSTUSR "failed create before timer expired, but expect success"
614         sync; sleep 1; sync
615         echo "    Done"
616
617         echo "    Sleep $TIMER seconds ..."
618         sleep $TIMER
619
620         $SHOW_QUOTA_USER
621         $SHOW_QUOTA_GROUP
622         $SHOW_QUOTA_INFO_USER
623         $SHOW_QUOTA_INFO_GROUP
624
625         echo "    Create file after timer goes off"
626         # the least of inode qunit is 2, so there are at most 3(qunit:2+qtune:1)
627         # inode quota left here
628         $RUNAS touch ${TESTFILE}_after ${TESTFILE}_after1 ${TESTFILE}_after2 || true
629         sync; sleep 1; sync
630         $RUNAS touch ${TESTFILE}_after3 && \
631                 quota_error a $TSTUSR "create after timer expired, but expect EDQUOT"
632         sync; sleep 1; sync
633
634         $SHOW_QUOTA_USER
635         $SHOW_QUOTA_GROUP
636         $SHOW_QUOTA_INFO_USER
637         $SHOW_QUOTA_INFO_GROUP
638
639         echo "    Unlink files to stop timer"
640         find `dirname $TESTFILE` -name "`basename ${TESTFILE}`*" | xargs rm -f
641         echo "    Done"
642
643         echo "    Create file"
644         $RUNAS touch ${TESTFILE}_xxx || \
645                 quota_error a $TSTUSR "touch after timer stop failure, but expect success"
646         sync; sleep 1; sync
647         echo "    Done"
648
649         # cleanup
650         rm -f ${TESTFILE}_xxx
651         sync; sleep 3; sync;
652 }
653
654 # file soft limit (start timer, timer goes off, stop timer)
655 test_4a() {     # was test_4
656         mkdir -p $DIR/$tdir
657         chmod 0777 $DIR/$tdir
658         LIMIT=$(($IUNIT_SZ * 10))       # 10 iunits on mds
659         TESTFILE=$DIR/$tdir/$tfile-0
660
661         GRACE=5
662
663         echo "  User quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
664         $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $GRACE $DIR
665         $LFS setquota -u $TSTUSR -b 0 -B 0 -i $LIMIT -I 0 $DIR
666         quota_show_check f u $TSTUSR
667
668         test_file_soft $TESTFILE $LIMIT $GRACE
669         resetquota -u $TSTUSR
670
671         echo "  Group quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
672         $LFS setquota -t -g --block-grace $MAX_DQ_TIME --inode-grace $GRACE $DIR
673         $LFS setquota -g $TSTUSR -b 0 -B 0 -i $LIMIT -I 0 $DIR
674         quota_show_check f g $TSTUSR
675         TESTFILE=$DIR/$tdir/$tfile-1
676
677         test_file_soft $TESTFILE $LIMIT $GRACE
678         resetquota -g $TSTUSR
679
680         # cleanup
681         $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
682         $LFS setquota -t -g --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
683 }
684 run_test_with_stat 4a "File soft limit (start timer, timer goes off, stop timer) ==="
685
686 test_4b() {     # was test_4a
687         GR_STR1="1w3d"
688         GR_STR2="1000s"
689         GR_STR3="5s"
690         GR_STR4="1w2d3h4m5s"
691         GR_STR5="5c"
692         GR_STR6="1111111111111111"
693
694         wait_delete_completed
695
696         # test of valid grace strings handling
697         echo "  Valid grace strings test"
698         $LFS setquota -t -u --block-grace $GR_STR1 --inode-grace $GR_STR2 $DIR
699         $LFS quota -u -t $DIR | grep "Block grace time: $GR_STR1"
700         $LFS setquota -t -g --block-grace $GR_STR3 --inode-grace $GR_STR4 $DIR
701         $LFS quota -g -t $DIR | grep "Inode grace time: $GR_STR4"
702
703         # test of invalid grace strings handling
704         echo "  Invalid grace strings test"
705         ! $LFS setquota -t -u --block-grace $GR_STR4 --inode-grace $GR_STR5 $DIR
706         ! $LFS setquota -t -g --block-grace $GR_STR4 --inode-grace $GR_STR6 $DIR
707
708         # cleanup
709         $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
710         $LFS setquota -t -g --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
711 }
712 run_test_with_stat 4b "Grace time strings handling ==="
713
714 # chown & chgrp (chown & chgrp successfully even out of block/file quota)
715 test_5() {
716         mkdir -p $DIR/$tdir
717         BLIMIT=$(( $BUNIT_SZ * $((OSTCOUNT + 1)) * 10)) # 10 bunits on each server
718         ILIMIT=$(( $IUNIT_SZ * 10 )) # 10 iunits on mds
719
720         wait_delete_completed
721
722         echo "  Set quota limit (0 $BLIMIT 0 $ILIMIT) for $TSTUSR.$TSTUSR"
723         $LFS setquota -u $TSTUSR -b 0 -B $BLIMIT -i 0 -I $ILIMIT $DIR
724         $LFS setquota -g $TSTUSR -b 0 -B $BLIMIT -i 0 -I $ILIMIT $DIR
725         quota_show_check a u $TSTUSR
726         quota_show_check a g $TSTUSR
727
728         echo "  Create more than $ILIMIT files and more than $BLIMIT kbytes ..."
729         createmany -m $DIR/$tdir/$tfile-0_ $((ILIMIT + 1)) || \
730                 error "touch failure, expect success"
731         dd if=/dev/zero of=$DIR/$tdir/$tfile-0_1 bs=$BLK_SZ count=$((BLIMIT+1)) || error "write failure, expect success"
732
733         echo "  Chown files to $TSTUSR.$TSTUSR ..."
734         for i in `seq 0 $ILIMIT`; do
735         chown $TSTUSR.$TSTUSR $DIR/$tdir/$tfile-0_$i || \
736                         quota_error a $TSTUSR "chown failure, but expect success"
737         done
738
739         # cleanup
740         unlinkmany $DIR/$tdir/$tfile-0_ $((ILIMIT + 1))
741         sync; sleep 3; sync;
742
743         resetquota -u $TSTUSR
744         resetquota -g $TSTUSR
745 }
746 run_test_with_stat 5 "Chown & chgrp successfully even out of block/file quota ==="
747
748 # block quota acquire & release
749 test_6() {
750         if [ $OSTCOUNT -lt 2 ]; then
751                 skip_env "$OSTCOUNT < 2, too few osts"
752                 return 0;
753         fi
754
755         wait_delete_completed
756
757         mkdir -p $DIR/$tdir
758         chmod 0777 $DIR/$tdir
759
760         LIMIT=$((BUNIT_SZ * (OSTCOUNT + 1) * 5)) # 5 bunits per server
761         FILEA="$DIR/$tdir/$tfile-0_a"
762         FILEB="$DIR/$tdir/$tfile-0_b"
763
764         echo "  Set block limit $LIMIT kbytes to $TSTUSR.$TSTUSR"
765         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
766         $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
767         quota_show_check b u $TSTUSR
768         quota_show_check b g $TSTUSR
769
770         echo "  Create filea on OST0 and fileb on OST1"
771         $LFS setstripe $FILEA -i 0 -c 1
772         $LFS setstripe $FILEB -i 1 -c 1
773         chown $TSTUSR.$TSTUSR $FILEA
774         chown $TSTUSR.$TSTUSR $FILEB
775
776         echo "  Exceed quota limit ..."
777         RUNDD="$RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ"
778         $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
779                 quota_error a $TSTUSR "write filea failure, but expect success"
780
781         cancel_lru_locks osc
782         $SHOW_QUOTA_USER
783         $SHOW_QUOTA_GROUP
784         $RUNDD seek=$LIMIT count=$((BUNIT_SZ * OSTCOUNT)) && \
785                 quota_error a $TSTUSR "write filea success, but expect EDQUOT"
786         cancel_lru_locks osc
787         echo "  Write to OST1 return EDQUOT"
788         # this write maybe cache write, ignore it's failure
789         RUNDD="$RUNAS dd if=/dev/zero of=$FILEB bs=$BLK_SZ"
790         $RUNDD count=$(($BUNIT_SZ * 2)) || true
791         cancel_lru_locks osc
792         $SHOW_QUOTA_USER
793         $SHOW_QUOTA_GROUP
794         $RUNDD count=$((BUNIT_SZ * 2)) seek=$((BUNIT_SZ *2)) && \
795                 quota_error a $TSTUSR "write fileb success, but expect EDQUOT"
796
797         echo "  Remove filea to let OST0 release quota"
798         rm -f $FILEA
799
800         if at_is_enabled; then
801             timeout=$(at_max_get mds)
802         else
803             timeout=$(lctl get_param -n timeout)
804         fi
805         count=$((timeout / 5))
806         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
807
808         while [ $((count--)) -gt 0 ]; do
809                 sync && sleep 5
810
811                 OST0_QUOTA_HOLD=`getquota -u $TSTUSR $OST0_UUID bhardlimit`
812                 if [ -z $OST0_QUOTA_HOLD ]; then
813                         error "System is error when query quota for block (U:$TSTUSR)."
814                 else
815                         [ $OST0_QUOTA_HOLD -gt $BUNIT_SZ ] && continue
816                 fi
817
818                 break
819         done
820
821         [ ! $count -gt 0 ] && error "Release quota for block timeout (U:$TSTUSR)."
822         $SHOW_QUOTA_USER
823
824         while [ $((count--)) -gt 0 ]; do
825                 sync && sleep 5
826
827                 OST0_QUOTA_HOLD=`getquota -g $TSTUSR $OST0_UUID bhardlimit`
828                 if [ -z $OST0_QUOTA_HOLD ]; then
829                         error "System is error when query quota for block (G:$TSTUSR)."
830                 else
831                         [ $OST0_QUOTA_HOLD -gt $BUNIT_SZ ] && continue
832                 fi
833
834                 break
835         done
836
837         [ ! $count -gt 0 ] && error "Release quota for block timeout (G:$TSTUSR)."
838         $SHOW_QUOTA_GROUP
839
840         echo "  Write to OST1"
841         $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
842                 quota_error a $TSTUSR "write fileb failure, expect success"
843         echo "  Done"
844
845         # cleanup
846         rm -f $FILEB
847         sync; sleep 3; sync;
848
849         resetquota -u $TSTUSR
850         resetquota -g $TSTUSR
851         return 0
852 }
853 run_test_with_stat 6 "Block quota acquire & release ========="
854
855 # quota recovery (block quota only by now)
856 test_7()
857 {
858         mkdir -p $DIR/$tdir
859         chmod 0777 $DIR/$tdir
860
861         wait_delete_completed
862
863         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) ))
864         TESTFILE="$DIR/$tdir/$tfile-0"
865
866         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
867
868         $LFS setstripe $TESTFILE -c 1
869         chown $TSTUSR.$TSTUSR $TESTFILE
870
871         echo "  Write to OST0..."
872         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ || \
873                 quota_error u $TSTUSR "write failure, but expect success"
874
875         #define OBD_FAIL_OBD_DQACQ               0x604
876         lustre_fail mds  0x604
877         echo "  Remove files on OST0"
878         rm -f $TESTFILE
879         lustre_fail mds  0
880
881         echo "  Trigger recovery..."
882         OSC0_UUID="`$LCTL dl | awk '$3 ~ /osc/ { print $1 }'`"
883         for i in $OSC0_UUID; do
884                 $LCTL --device $i activate || error "activate osc failed!"
885         done
886
887         # sleep a while to wait for recovery done
888         sleep 20
889
890         # check limits
891         PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
892         TOTAL_LIMIT=`getquota -u $TSTUSR global bhardlimit`
893         [ $TOTAL_LIMIT -eq $LIMIT ] || error "total limits not recovery!"
894         echo "  total limits = $TOTAL_LIMIT"
895
896         OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
897         [ -z "$OST0_UUID" ] && OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
898         OST0_LIMIT=`getquota  -u $TSTUSR $OST0_UUID bhardlimit`
899         [ $OST0_LIMIT -eq $BUNIT_SZ ] || error "high limits not released!"
900         echo "  limits on $OST0_UUID = $OST0_LIMIT"
901
902         # cleanup
903         resetquota -u $TSTUSR
904 }
905 run_test_with_stat 7 "Quota recovery (only block limit) ======"
906
907 # run dbench with quota enabled
908 test_8() {
909         mkdir -p $DIR/$tdir
910         BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
911         FILE_LIMIT=1000000
912
913         wait_delete_completed
914
915         echo "  Set enough high limit for user: $TSTUSR"
916         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
917         echo "  Set enough high limit for group: $TSTUSR"
918         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
919
920         chmod 0777 $DIR/$tdir
921         local duration=""
922         [ "$SLOW" = "no" ] && duration=" -t 120"
923         $RUNAS bash rundbench -D $DIR/$tdir 3 $duration || quota_error a $TSTUSR "dbench failed!"
924
925         rm -rf $DIR/$tdir
926         sync; sleep 3; sync;
927
928         return 0
929 }
930 run_test_with_stat 8 "Run dbench with quota enabled ==========="
931
932 # run for fixing bug10707, it needs a big room. test for 64bit
933 KB=1024
934 GB=$((KB * 1024 * 1024))
935 # Use this as dd bs to decrease time
936 # inode->i_blkbits = min(PTLRPC_MAX_BRW_BITS+1, LL_MAX_BLKSIZE_BITS);
937 blksize=$((1 << 21)) # 2Mb
938 size_file=$((GB * 9 / 2))
939 # this check is just for test9 and test10
940 OST0_MIN=4900000 #4.67G
941 check_whether_skip () {
942     OST0_SIZE=`$LFS df $DIR | awk '/\[OST:0\]/ {print $4}'`
943     log "OST0_SIZE: $OST0_SIZE  required: $OST0_MIN"
944     if [ $OST0_SIZE -lt $OST0_MIN ]; then
945         echo "WARN: OST0 has less than $OST0_MIN free, skip this test."
946         return 0
947     else
948         return 1
949     fi
950 }
951
952 test_9() {
953         check_whether_skip && return 0
954
955         wait_delete_completed
956
957         set_blk_tunesz 512
958         set_blk_unitsz 1024
959
960         mkdir -p $DIR/$tdir
961         chmod 0777 $DIR/$tdir
962         TESTFILE="$DIR/$tdir/$tfile-0"
963
964         BLK_LIMIT=$((100 * KB * KB)) # 100G
965         FILE_LIMIT=1000000
966         echo "  Set block limit $BLK_LIMIT kbytes to $TSTUSR.$TSTUSR"
967
968         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
969         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
970         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
971         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
972
973         quota_show_check a u $TSTUSR
974         quota_show_check a g $TSTUSR
975
976         echo "  Set stripe"
977         $LFS setstripe $TESTFILE -c 1
978         touch $TESTFILE
979         chown $TSTUSR.$TSTUSR $TESTFILE
980
981         log "    Write the big file of 4.5G ..."
982         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
983                quota_error a $TSTUSR "(usr) write 4.5G file failure, but expect success"
984
985         $SHOW_QUOTA_USER
986         $SHOW_QUOTA_GROUP
987
988         log "    delete the big file of 4.5G..."
989         $RUNAS rm -f $TESTFILE
990         sync; sleep 3; sync;
991
992         $SHOW_QUOTA_USER
993         $SHOW_QUOTA_GROUP
994
995         RC=$?
996
997         set_blk_unitsz $((128 * 1024))
998         set_blk_tunesz $((128 * 1024 / 2))
999
1000         return $RC
1001 }
1002 run_test_with_stat 9 "run for fixing bug10707(64bit) ==========="
1003
1004 # run for fixing bug10707, it need a big room. test for 32bit
1005 # 2.0 version does not support 32 bit qd_count, so such test is obsolete.
1006 test_10() {
1007         mkdir -p $DIR/$tdir
1008         chmod 0777 $DIR/$tdir
1009         check_whether_skip && return 0
1010
1011         wait_delete_completed
1012
1013         set_blk_tunesz 512
1014         set_blk_unitsz 1024
1015
1016         # make qd_count 32 bit
1017         lustre_fail mds_ost 0xA00
1018
1019         TESTFILE="$DIR/$tdir/$tfile-0"
1020
1021         BLK_LIMIT=$((100 * KB * KB)) # 100G
1022         FILE_LIMIT=1000000
1023
1024         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
1025         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
1026         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
1027         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
1028
1029         quota_show_check a u $TSTUSR
1030         quota_show_check a g $TSTUSR
1031
1032         echo "  Set stripe"
1033         $LFS setstripe $TESTFILE -c 1
1034         touch $TESTFILE
1035         chown $TSTUSR.$TSTUSR $TESTFILE
1036
1037         log "    Write the big file of 4.5 G ..."
1038         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
1039                 quota_error a $TSTUSR "(usr) write 4.5 G file failure, but expect success"
1040
1041         $SHOW_QUOTA_USER
1042         $SHOW_QUOTA_GROUP
1043
1044         log "    delete the big file of 4.5 G..."
1045         $RUNAS rm -f $TESTFILE
1046         sync; sleep 3; sync;
1047
1048         $SHOW_QUOTA_USER
1049         $SHOW_QUOTA_GROUP
1050
1051         RC=$?
1052
1053         # make qd_count 64 bit
1054         lustre_fail mds_ost 0
1055
1056         set_blk_unitsz $((128 * 1024))
1057         set_blk_tunesz $((128 * 1024 / 2))
1058
1059         return $RC
1060 }
1061 #run_test_with_stat 10 "run for fixing bug10707(32bit) ==========="
1062
1063 # test a deadlock between quota and journal b=11693
1064 test_12() {
1065         mkdir -p $DIR/$tdir
1066         chmod 0777 $DIR/$tdir
1067
1068         [ "$(grep $DIR2 /proc/mounts)" ] || mount_client $DIR2 || \
1069                 { skip_env "Need lustre mounted on $MOUNT2 " && retutn 0; }
1070
1071         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
1072         TESTFILE="$DIR/$tdir/$tfile-0"
1073         TESTFILE2="$DIR2/$tdir/$tfile-1"
1074
1075         wait_delete_completed
1076
1077         echo "   User quota (limit: $LIMIT kbytes)"
1078         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1079
1080         $LFS setstripe $TESTFILE -i 0 -c 1
1081         chown $TSTUSR.$TSTUSR $TESTFILE
1082         $LFS setstripe $TESTFILE2 -i 0 -c 1
1083         chown $TSTUSR2.$TSTUSR2 $TESTFILE2
1084
1085         #define OBD_FAIL_OST_HOLD_WRITE_RPC      0x21f
1086         #define OBD_FAIL_SOME        0x10000000 /* fail N times */
1087         lustre_fail ost $((0x0000021f | 0x10000000)) 1
1088
1089         echo "   step1: write out of block quota ..."
1090         $RUNAS2 dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=102400 &
1091         DDPID1=$!
1092         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT*2)) &
1093         DDPID=$!
1094
1095         echo  "   step2: testing ......"
1096         local last_size=$(stat -c %s $TESTFILE2) 
1097         local stall_secs=0
1098         local start_secs=$SECONDS
1099         while [ -d /proc/${DDPID1} ]; do
1100             local size=$(stat -c %s $TESTFILE2) 
1101             if [ $size -eq $last_size ]; then
1102                 stall_secs=$[stall_secs+1]
1103             else
1104                 stall_secs=0
1105             fi
1106             if [ $stall_secs -gt 30 ]; then
1107                 lustre_fail ost 0
1108                 quota_error u $TSTUSR2 "giving up: dd stalled (i.e. made no progress) for 30 seconds!"
1109             fi
1110             last_size=$size
1111             sleep 1
1112         done
1113         echo "(dd_pid=$DDPID1, time=$((SECONDS-start_secs)))successful"
1114
1115         #Recover fail_loc and dd will finish soon
1116         lustre_fail ost 0
1117
1118         echo  "   step3: testing ......"
1119         count=0
1120         while [ true ]; do
1121             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1122             count=$[count+1]
1123             if [ $count -gt 150 ]; then
1124                 quota_error u $TSTUSR "dd should be finished!"
1125             fi
1126             sleep 1
1127         done
1128         echo "(dd_pid=$DDPID, time=$count)successful"
1129
1130         rm -f $TESTFILE $TESTFILE2
1131         sync; sleep 3; sync;
1132
1133         resetquota -u $TSTUSR
1134 }
1135 run_test_with_stat 12 "test a deadlock between quota and journal ==="
1136
1137 # test multiple clients write block quota b=11693
1138 test_13() {
1139         mkdir -p $DIR/$tdir
1140         wait_delete_completed
1141
1142         # one OST * 10 + (mds + other OSTs)
1143         LIMIT=$((BUNIT_SZ * 10 + (BUNIT_SZ * OSTCOUNT)))
1144         TESTFILE="$DIR/$tdir/$tfile"
1145
1146         echo "   User quota (limit: $LIMIT kbytes)"
1147         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1148         quota_show_check b u $TSTUSR
1149
1150         $LFS setstripe $TESTFILE -i 0 -c 1
1151         chown $TSTUSR.$TSTUSR $TESTFILE
1152         $LFS setstripe $TESTFILE.2 -i 0 -c 1
1153         chown $TSTUSR.$TSTUSR $TESTFILE.2
1154
1155         echo "   step1: write out of block quota ..."
1156         # one bunit will give mds
1157         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1158         DDPID=$!
1159         $RUNAS dd if=/dev/zero of=$TESTFILE.2 bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1160         DDPID1=$!
1161
1162         echo  "   step2: testing ......"
1163         count=0
1164         while [ true ]; do
1165             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1166             count=$[count+1]
1167             if [ $count -gt 64 ]; then
1168                 quota_error u $TSTUSR "dd should be finished!"
1169             fi
1170             sleep 1
1171         done
1172         echo "(dd_pid=$DDPID, time=$count)successful"
1173
1174         count=0
1175         while [ true ]; do
1176             if ! ps -p ${DDPID1} > /dev/null 2>&1 ; then break; fi
1177             count=$[count+1]
1178             if [ $count -gt 64 ]; then
1179                 quota_error u $TSTUSR "dd should be finished!"
1180             fi
1181             sleep 1
1182         done
1183         echo "(dd_pid=$DDPID1, time=$count)successful"
1184
1185         sync; sleep 5; sync;
1186
1187         echo  "   step3: checking ......"
1188         fz=`stat -c %s $TESTFILE`
1189         fz2=`stat -c %s $TESTFILE.2`
1190         $SHOW_QUOTA_USER
1191         [ $((fz + fz2)) -lt $((BUNIT_SZ * BLK_SZ * 10)) ] && \
1192                 quota_error u $TSTUSR "files too small $fz + $fz2 < $((BUNIT_SZ * BLK_SZ * 10))"
1193
1194         rm -f $TESTFILE $TESTFILE.2
1195         sync; sleep 3; sync;
1196
1197         resetquota -u $TSTUSR
1198 }
1199 run_test_with_stat 13 "test multiple clients write block quota ==="
1200
1201 check_if_quota_zero(){
1202         line=`$LFS quota -v -$1 $2 $DIR | wc -l`
1203         for i in `seq 3 $line`; do
1204             if [ $i -eq 3 ]; then
1205                 field="3 4 7 8"
1206             else
1207                 field="3 6"
1208             fi
1209             for j in $field; do
1210                 tmp=`$LFS quota -v -$1 $2 $DIR | sed -n ${i}p |
1211                      awk  '{print $'"$j"'}'`
1212                 [ -n "$tmp" ] && [ $tmp -ne 0 ] && $LFS quota -v -$1 $2 $DIR && \
1213                     error "quota on $2 isn't clean"
1214             done
1215         done
1216         echo "pass check_if_quota_zero"
1217 }
1218
1219 test_14a() {    # was test_14 b=12223 -- setting quota on root
1220         TESTFILE="$DIR/$tdir/$tfile"
1221
1222         # reboot the lustre
1223         sync; sleep 5; sync
1224         cleanup_and_setup_lustre
1225         quota_init
1226
1227         mkdir -p $DIR/$tdir
1228
1229         # out of root's file and block quota
1230         $LFS setquota -u root -b 10 -B 10 -i 10 -I 10 $DIR
1231         createmany -m ${TESTFILE} 20 || \
1232             quota_error u root "unexpected: user(root) create files failly!"
1233         dd if=/dev/zero of=$TESTFILE bs=4k count=4096 || \
1234             quota_error u root "unexpected: user(root) write files failly!"
1235         chmod 666 $TESTFILE
1236         $RUNAS dd if=/dev/zero of=${TESTFILE} seek=4096 bs=4k count=4096 && \
1237             quota_error u root "unexpected: user(quota_usr) write a file successfully!"
1238
1239         # trigger the llog
1240         chmod 777 $DIR
1241         for i in `seq 1 10`; do $RUNAS touch ${TESTFILE}a_$i; done
1242         for i in `seq 1 10`; do $RUNAS rm -f ${TESTFILE}a_$i; done
1243
1244         # do the check
1245         dmesg | tail | grep "\-122" |grep llog_obd_origin_add && error "err -122 not found in dmesg"
1246         resetquota -u root
1247         #check_if_quota_zero u root
1248
1249         # clean
1250         unlinkmany ${TESTFILE} 15
1251         rm -f $TESTFILE
1252         sync; sleep 3; sync;
1253 }
1254 run_test_with_stat 14a "test setting quota on root ==="
1255
1256 test_15(){
1257         LIMIT=$((24 * 1024 * 1024 * 1024 * 1024)) # 24 TB
1258         PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
1259
1260         wait_delete_completed
1261
1262         # test for user
1263         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1264         TOTAL_LIMIT=`getquota -u $TSTUSR global bhardlimit`
1265         [ $TOTAL_LIMIT -eq $LIMIT ] || error "  (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1266         echo "  (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1267         resetquota -u $TSTUSR
1268
1269         # test for group
1270         $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1271         TOTAL_LIMIT=`getquota -g $TSTUSR global bhardlimit`
1272         [ $TOTAL_LIMIT -eq $LIMIT ] || error "  (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1273         echo "  (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1274         resetquota -g $TSTUSR
1275         $LFS quotaoff -ug $DIR
1276         do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_type=ug" | grep "error writing" && \
1277                 error "fail to set version for $SINGLEMDS"
1278         for j in `seq $OSTCOUNT`; do
1279                 do_facet ost$j "lctl set_param lquota.${FSNAME}-OST*.quota_type=ug" | grep "error writing" && \
1280                         error "fail to set version for ost$j"
1281         done
1282
1283         echo "invalidating quota files"
1284         $LFS quotainv -ug $DIR
1285         $LFS quotainv -ugf $DIR
1286         $LFS quotacheck -ug $DIR
1287 }
1288 run_test_with_stat 15 "set block quota more than 4T ==="
1289
1290 # $1=u/g $2=with qunit adjust or not
1291 test_16_tub() {
1292         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 4))
1293         TESTFILE="$DIR/$tdir/$tfile"
1294         mkdir -p $DIR/$tdir
1295
1296         wait_delete_completed
1297
1298         echo "  User quota (limit: $LIMIT kbytes)"
1299         if [ $1 == "u" ]; then
1300             $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1301             quota_show_check b u $TSTUSR
1302         else
1303             $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1304             quota_show_check b g $TSTUSR
1305         fi
1306
1307         $LFS setstripe $TESTFILE -c 1
1308         chown $TSTUSR.$TSTUSR $TESTFILE
1309
1310         echo "    Write ..."
1311         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((BUNIT_SZ * 4)) || \
1312             quota_error a $TSTUSR "(usr) write failure, but expect success"
1313         echo "    Done"
1314         echo "    Write out of block quota ..."
1315         # this time maybe cache write,  ignore it's failure
1316         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || true
1317         # flush cache, ensure noquota flag is setted on client
1318         cancel_lru_locks osc
1319         if [ $2 -eq 1 ]; then
1320             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || \
1321                 quota_error a $TSTUSR "(write failure, but expect success"
1322         else
1323             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) && \
1324                 quota_error a $TSTUSR "(write success, but expect EDQUOT"
1325         fi
1326
1327         rm -f $TESTFILE
1328         sync; sleep 3; sync;
1329         resetquota -$1 $TSTUSR
1330 }
1331
1332 # test without adjusting qunit
1333 # 2.0 version does not support WITHOUT_CHANGE_QS, so such test is obsolete
1334 test_16 () {
1335         set_blk_tunesz $((BUNIT_SZ * 2))
1336         set_blk_unitsz $((BUNIT_SZ * 4))
1337         for i in u g; do
1338             for j in 0 1; do
1339                 # define OBD_FAIL_QUOTA_WITHOUT_CHANGE_QS    0xA01
1340                 echo " grp/usr: $i, adjust qunit: $j"
1341                 echo "-------------------------------"
1342                 [ $j -eq 1 ] && lustre_fail mds_ost 0
1343                 [ $j -eq 0 ] && lustre_fail mds_ost 0xA01
1344                 test_16_tub $i $j
1345             done
1346         done
1347         set_blk_unitsz $((128 * 1024))
1348         set_blk_tunesz $((128 * 1024 / 2))
1349 }
1350 #run_test_with_stat 16 "test without adjusting qunit"
1351
1352 # run for fixing bug14526, failed returned quota reqs shouldn't ruin lustre.
1353 test_17() {
1354         set_blk_tunesz 512
1355         set_blk_unitsz 1024
1356
1357         wait_delete_completed
1358
1359         #define OBD_FAIL_QUOTA_RET_QDATA | OBD_FAIL_ONCE
1360         lustre_fail ost 0x80000A02
1361
1362         TESTFILE="$DIR/$tdir/$tfile-a"
1363         TESTFILE2="$DIR/$tdir/$tfile-b"
1364         mkdir -p $DIR/$tdir
1365
1366         BLK_LIMIT=$((100 * 1024)) # 100M
1367
1368         log "  Set enough high limit(block:$BLK_LIMIT) for user: $TSTUSR"
1369         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
1370         log "  Set enough high limit(block:$BLK_LIMIT) for group: $TSTUSR"
1371         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
1372
1373         quota_show_check b u $TSTUSR
1374         quota_show_check b g $TSTUSR
1375
1376         touch $TESTFILE
1377         chown $TSTUSR.$TSTUSR $TESTFILE
1378         touch $TESTFILE2
1379         chown $TSTUSR.$TSTUSR $TESTFILE2
1380
1381         log "    Write the test file1 ..."
1382         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$(( 10 * 1024 )) \
1383             || quota_error a $TSTUSR "write 10M file failure"
1384
1385         $SHOW_QUOTA_USER
1386         $SHOW_QUOTA_GROUP
1387
1388         log "    write the test file2 ..."
1389         $RUNAS dd if=/dev/zero of=$TESTFILE2  bs=$BLK_SZ count=$(( 10 * 1024 )) \
1390             || quota_error a $TSTUSR "write 10M file failure"
1391
1392         $SHOW_QUOTA_USER
1393         $SHOW_QUOTA_GROUP
1394
1395         rm -f $TESTFILE $TESTFILE2
1396         RC=$?
1397         sync; sleep 3; sync;
1398
1399         # make qd_count 64 bit
1400         lustre_fail ost 0
1401
1402         set_blk_unitsz $((128 * 1024))
1403         set_blk_tunesz $((128 * 1024 / 2))
1404
1405         resetquota -u $TSTUSR
1406         resetquota -g $TSTUSR
1407
1408         return $RC
1409 }
1410 run_test_with_stat 17 "run for fixing bug14526 ==========="
1411
1412 # test when mds takes a long time to handle a quota req so that
1413 # the ost has dropped it, the ost still could work well b=14840
1414 test_18() {
1415         LIMIT=$((100 * 1024 * 1024)) # 100G
1416         TESTFILE="$DIR/$tdir/$tfile"
1417         mkdir -p $DIR/$tdir
1418
1419         wait_delete_completed
1420
1421         set_blk_tunesz 512
1422         set_blk_unitsz 1024
1423
1424         log "   User quota (limit: $LIMIT kbytes)"
1425         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1426         quota_show_check b u $TSTUSR
1427
1428         $LFS setstripe $TESTFILE -i 0 -c 1
1429         chown $TSTUSR.$TSTUSR $TESTFILE
1430
1431         #define OBD_FAIL_MDS_BLOCK_QUOTA_REQ      0x13c
1432         lustre_fail mds 0x13c
1433
1434         log "   step1: write 100M block ..."
1435         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1436         DDPID=$!
1437
1438         sleep 5
1439         lustre_fail mds 0
1440
1441         echo  "   step2: testing ......"
1442         count=0
1443         if at_is_enabled; then
1444             timeout=$(at_max_get mds)
1445         else
1446             timeout=$(lctl get_param -n timeout)
1447         fi
1448         while [ true ]; do
1449             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1450             count=$[count+1]
1451             if [ $count -gt $((4 * $timeout)) ]; then
1452                 quota_error u $TSTUSR "count=$count dd should be finished!"
1453             fi
1454             sleep 1
1455         done
1456         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1457         sync
1458         cancel_lru_locks mdc
1459         cancel_lru_locks osc
1460
1461         testfile_size=$(stat -c %s $TESTFILE)
1462         [ $testfile_size -ne $((BLK_SZ * 1024 * 100)) ] && \
1463             quota_error u $TSTUSR "expect $((BLK_SZ * 1024 * 100)), got ${testfile_size}. Verifying file failed!"
1464         $SHOW_QUOTA_USER
1465         rm -f $TESTFILE
1466         sync
1467
1468         resetquota -u $TSTUSR
1469         set_blk_unitsz $((128 * 1024))
1470         set_blk_tunesz $((128 * 1024 / 2))
1471 }
1472 run_test_with_stat 18 "run for fixing bug14840 ==========="
1473
1474 # test when mds drops a quota req, the ost still could work well b=14840
1475 test_18a() {
1476         LIMIT=$((100 * 1024 * 1024)) # 100G
1477         TESTFILE="$DIR/$tdir/$tfile-a"
1478         mkdir -p $DIR/$tdir
1479
1480         wait_delete_completed
1481
1482         set_blk_tunesz 512
1483         set_blk_unitsz 1024
1484
1485         log "   User quota (limit: $LIMIT kbytes)"
1486         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1487         quota_show_check b u $TSTUSR
1488
1489         $LFS setstripe $TESTFILE -i 0 -c 1
1490         chown $TSTUSR.$TSTUSR $TESTFILE
1491
1492         #define OBD_FAIL_MDS_DROP_QUOTA_REQ | OBD_FAIL_ONCE   0x8000013d
1493         lustre_fail mds 0x8000013d
1494
1495         log "   step1: write 100M block ..."
1496         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1497         DDPID=$!
1498
1499         echo  "   step2: testing ......"
1500         count=0
1501         if at_is_enabled; then
1502             timeout=$(at_max_get mds)
1503         else
1504             timeout=$(lctl get_param -n timeout)
1505         fi
1506         while [ true ]; do
1507             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1508             count=$[count+1]
1509             if [ $count -gt $((6 * $timeout)) ]; then
1510                 lustre_fail mds 0
1511                 quota_error u $TSTUSR "count=$count dd should be finished!"
1512             fi
1513             sleep 1
1514         done
1515         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1516
1517         lustre_fail mds 0
1518         rm -f $TESTFILE
1519         sync
1520
1521         resetquota -u $TSTUSR
1522         set_blk_unitsz $((128 * 1024))
1523         set_blk_tunesz $((128 * 1024 / 2))
1524 }
1525 run_test_with_stat 18a "run for fixing bug14840 ==========="
1526
1527 # test when mds do failover, the ost still could work well without trigger
1528 # watchdog b=14840
1529 test_18bc_sub() {
1530         type=$1
1531
1532         LIMIT=$((110 * 1024 )) # 110M
1533         TESTFILE="$DIR/$tdir/$tfile"
1534         mkdir -p $DIR/$tdir
1535
1536         wait_delete_completed
1537
1538         set_blk_tunesz 512
1539         set_blk_unitsz 1024
1540
1541         log "   User quota (limit: $LIMIT kbytes)"
1542         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1543         quota_show_check b u $TSTUSR
1544
1545         $LFS setstripe $TESTFILE -i 0 -c 1
1546         chown $TSTUSR.$TSTUSR $TESTFILE
1547
1548         timeout=$(sysctl -n lustre.timeout)
1549
1550         if [ $type = "directio" ]; then
1551             log "   write 100M block(directio) ..."
1552             $RUNAS $DIRECTIO write $TESTFILE 0 100 $((BLK_SZ * 1024)) &
1553         else
1554             log "   write 100M block(normal) ..."
1555             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$((BLK_SZ * 1024)) count=100 &
1556         fi
1557
1558         DDPID=$!
1559         do_facet $SINGLEMDS "$LCTL conf_param ${FSNAME}-MDT*.mdd.quota_type=ug"
1560
1561         log "failing mds for $((2 * timeout)) seconds"
1562         fail $SINGLEMDS $((2 * timeout))
1563
1564         # check if quotaon successful
1565         $LFS quota -u $TSTUSR $MOUNT 2>&1 | grep -q "quotas are not enabled"
1566         if [ $? -eq 0 ]; then
1567             error "quotaon failed!"
1568             rm -rf $TESTFILE
1569             return
1570         fi
1571
1572         count=0
1573         if at_is_enabled; then
1574             timeout=$(at_max_get mds)
1575         else
1576             timeout=$(lctl get_param -n timeout)
1577         fi
1578         while [ true ]; do
1579             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1580             if [ $((++count % (2 * timeout) )) -eq 0 ]; then
1581                 log "it took $count second"
1582             fi
1583             sleep 1
1584         done
1585         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1586         sync
1587         cancel_lru_locks mdc
1588         cancel_lru_locks osc
1589
1590         testfile_size=$(stat -c %s $TESTFILE)
1591         [ $testfile_size -ne $((BLK_SZ * 1024 * 100)) ] && \
1592             quota_error u $TSTUSR "expect $((BLK_SZ * 1024 * 100)), got ${testfile_size}. Verifying file failed!"
1593         $SHOW_QUOTA_USER
1594         rm -f $TESTFILE
1595         sync
1596
1597         resetquota -u $TSTUSR
1598         set_blk_unitsz $((128 * 1024))
1599         set_blk_tunesz $((128 * 1024 / 2))
1600 }
1601
1602 # test when mds does failover, the ost still could work well
1603 # this test shouldn't trigger watchdog b=14840
1604 test_18b() {
1605         test_18bc_sub normal
1606         test_18bc_sub directio
1607         # check if watchdog is triggered
1608         do_facet ost1 dmesg > $TMP/lustre-log-${TESTNAME}.log
1609         watchdog=`awk '/test 18b/ {start = 1;}
1610                        /Service thread pid/ && /was inactive/ {
1611                                if (start) {
1612                                        print;
1613                                }
1614                        }' $TMP/lustre-log-${TESTNAME}.log`
1615         [ `echo "$watchdog" | wc -l` -ge 3 ] && error "$watchdog"
1616         rm -f $TMP/lustre-log-${TESTNAME}.log
1617 }
1618 run_test_with_stat 18b "run for fixing bug14840(mds failover, no watchdog) ==========="
1619
1620 # test when mds does failover, the ost still could work well
1621 # this test will prevent OST_DISCONNET from happening b=14840
1622 test_18c() {
1623         # define OBD_FAIL_OST_DISCONNECT_NET 0x202(disable ost_disconnect for osts)
1624         lustre_fail ost  0x202
1625         test_18bc_sub normal
1626         test_18bc_sub directio
1627         lustre_fail ost  0
1628 }
1629 run_test_with_stat 18c "run for fixing bug14840(mds failover, OST_DISCONNECT is disabled) ==========="
1630
1631 run_to_block_limit() {
1632         local LIMIT=$((($OSTCOUNT + 1) * $BUNIT_SZ))
1633         local TESTFILE=$1
1634         wait_delete_completed
1635
1636         # set 1 Mb quota unit size
1637         set_blk_tunesz 512
1638         set_blk_unitsz 1024
1639
1640         # bind file to a single OST
1641         $LFS setstripe -c 1 $TESTFILE
1642         chown $TSTUSR.$TSTUSR $TESTFILE
1643
1644         echo "  User quota (limit: $LIMIT kbytes)"
1645         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1646         quota_show_check b u $TSTUSR
1647         echo "  Updating quota limits"
1648         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1649         quota_show_check b u $TSTUSR
1650
1651         RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
1652         $RUNDD count=$BUNIT_SZ || quota_error u $TSTUSR "(usr) write failure, but expect success"
1653         # for now page cache of TESTFILE may still be dirty,
1654         # let's push it to the corresponding OST, this will also
1655         # cache NOQUOTA on the client from OST's reply
1656         cancel_lru_locks osc
1657         $RUNDD seek=$BUNIT_SZ && quota_error u $TSTUSR "(usr) write success, should be EDQUOT"
1658 }
1659
1660 test_19() {
1661         # 1 Mb bunit per each MDS/OSS
1662         local TESTFILE="$DIR/$tdir/$tfile"
1663         mkdir -p $DIR/$tdir
1664
1665         run_to_block_limit $TESTFILE
1666         $SHOW_QUOTA_USER
1667
1668         # cleanup
1669         rm -f $TESTFILE
1670         resetquota -u $TSTUSR
1671
1672         set_blk_unitsz $((128 * 1024))
1673         set_blk_tunesz $((128 * 1024 / 2))
1674
1675 }
1676 run_test_with_stat 19 "test if administrative limits updates do not zero operational limits (14790) ==="
1677
1678 test_20()
1679 {
1680         LSTR=(1t 2g 3m 4k) # limits strings
1681         LVAL=($[1*1024*1024*1024] $[2*1024*1024] $[3*1024*1024] $[4*1024]) # limits values
1682
1683         $LFS setquota -u $TSTUSR --block-softlimit ${LSTR[0]} \
1684                                  $MOUNT || error "could not set quota limits"
1685
1686         $LFS setquota -u $TSTUSR --block-hardlimit ${LSTR[1]} \
1687                                  --inode-softlimit ${LSTR[2]} \
1688                                  --inode-hardlimit ${LSTR[3]} \
1689                                  $MOUNT || error "could not set quota limits"
1690
1691         [ "`getquota -u $TSTUSR global bsoftlimit`" = "${LVAL[0]}" ] || error "bsoftlimit was not set properly"
1692         [ "`getquota -u $TSTUSR global bhardlimit`" = "${LVAL[1]}" ] || error "bhardlimit was not set properly"
1693         [ "`getquota -u $TSTUSR global isoftlimit`" = "${LVAL[2]}" ] || error "isoftlimit was not set properly"
1694         [ "`getquota -u $TSTUSR global ihardlimit`" = "${LVAL[3]}" ] || error "ihardlimit was not set properly"
1695
1696         resetquota -u $TSTUSR
1697 }
1698 run_test_with_stat 20 "test if setquota specifiers work properly (15754)"
1699
1700 test_21_sub() {
1701         local testfile=$1
1702         local blk_number=$2
1703         local seconds=$3
1704
1705         time=$(($(date +%s) + seconds))
1706         while [ $(date +%s) -lt $time ]; do
1707             $RUNAS dd if=/dev/zero of=$testfile  bs=$BLK_SZ count=$blk_number > /dev/null 2>&1
1708             rm -f $testfile
1709         done
1710 }
1711
1712 # run for fixing bug16053, setquota shouldn't fail when writing and
1713 # deleting are happening
1714 test_21() {
1715         set_blk_tunesz 512
1716         set_blk_unitsz 1024
1717
1718         wait_delete_completed
1719
1720         TESTFILE="$DIR/$tdir/$tfile"
1721
1722         BLK_LIMIT=$((10 * 1024 * 1024)) # 10G
1723         FILE_LIMIT=1000000
1724
1725         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
1726         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $MOUNT
1727         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
1728         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $MOUNT
1729
1730         # repeat writing on a 1M file
1731         test_21_sub ${TESTFILE}_1 1024 30 &
1732         DDPID1=$!
1733         # repeat writing on a 128M file
1734         test_21_sub ${TESTFILE}_2 $((1024 * 128)) 30 &
1735         DDPID2=$!
1736
1737         time=$(($(date +%s) + 30))
1738         i=1
1739         while [ $(date +%s) -lt $time ]; do
1740             log "  Set quota for $i times"
1741             $LFS setquota -u $TSTUSR -b 0 -B $((BLK_LIMIT + 1024 * i)) -i 0 -I $((FILE_LIMIT + i)) $MOUNT
1742             $LFS setquota -g $TSTUSR -b 0 -B $((BLK_LIMIT + 1024 * i)) -i 0 -I $((FILE_LIMIT + i)) $MOUNT
1743             i=$((i+1))
1744             sleep 1
1745         done
1746
1747         count=0
1748         while [ true ]; do
1749             if ! ps -p ${DDPID1} > /dev/null 2>&1; then break; fi
1750             count=$[count+1]
1751             if [ $count -gt 60 ]; then
1752                 quota_error a $TSTUSR "dd should be finished!"
1753             fi
1754             sleep 1
1755         done
1756         echo "(dd_pid=$DDPID1, time=$count)successful"
1757
1758         count=0
1759         while [ true ]; do
1760             if ! ps -p ${DDPID2} > /dev/null 2>&1; then break; fi
1761             count=$[count+1]
1762             if [ $count -gt 60 ]; then
1763                 quota_error a $TSTUSR "dd should be finished!"
1764             fi
1765             sleep 1
1766         done
1767         echo "(dd_pid=$DDPID2, time=$count)successful"
1768
1769         set_blk_unitsz $((128 * 1024))
1770         set_blk_tunesz $((128 * 1024 / 2))
1771         resetquota -u $TSTUSR
1772         resetquota -g $TSTUSR
1773
1774         return $RC
1775 }
1776 run_test_with_stat 21 "run for fixing bug16053 ==========="
1777
1778 test_22() {
1779         quota_save_version "ug3"
1780
1781         stopall
1782         mount
1783         setupall
1784
1785         echo "checking parameters"
1786
1787         do_facet $SINGLEMDS "lctl get_param mdd.${FSNAME}-MDT*.quota_type" | grep "ug3" || error "admin failure"
1788         do_facet ost1 "lctl get_param obdfilter.*.quota_type" | grep "ug3" || error "op failure"
1789
1790         quota_init
1791 }
1792 run_test_with_stat 22 "test if quota_type saved as permanent parameter ===="
1793
1794 test_23_sub() {
1795         mkdir -p $DIR/$tdir
1796         chmod 0777 $DIR/$tdir
1797         TESTFILE="$DIR/$tdir/$tfile-0"
1798         rm -f $TESTFILE
1799         local bs_unit=$((1024*1024))
1800         LIMIT=$1
1801
1802         wait_delete_completed
1803
1804         # test for user
1805         log "  User quota (limit: $LIMIT kbytes)"
1806         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1807         sleep 3
1808         quota_show_check b u $TSTUSR
1809
1810         $LFS setstripe $TESTFILE -c 1
1811         chown $TSTUSR.$TSTUSR $TESTFILE
1812
1813         log "    Step1: trigger quota with 0_DIRECT"
1814         log "      Write half of file"
1815         $RUNAS $DIRECTIO write $TESTFILE 0 $(($LIMIT/1024/2)) $bs_unit || \
1816                 quota_error u $TSTUSR "(1) write failure, but expect success: $LIMIT"
1817         log "      Write out of block quota ..."
1818         $RUNAS $DIRECTIO write $TESTFILE $(($LIMIT/1024/2)) $(($LIMIT/1024/2)) $bs_unit && \
1819                 quota_error u $TSTUSR "(2) write success, but expect EDQUOT: $LIMIT"
1820         log "    Step1: done"
1821
1822         log "    Step2: rewrite should succeed"
1823         $RUNAS $DIRECTIO write $TESTFILE 0 1 $bs_unit || \
1824                 quota_error u $TSTUSR "(3) write failure, but expect success: $LIMIT"
1825         log "    Step2: done"
1826
1827         rm -f $TESTFILE
1828         wait_delete_completed
1829         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
1830         OST0_QUOTA_USED=`getquota -u $TSTUSR $OST0_UUID curspace`
1831         echo $OST0_QUOTA_USED
1832         [ $OST0_QUOTA_USED -ne 0 ] && \
1833             ($SHOW_QUOTA_USER; quota_error u $TSTUSR "quota deleted isn't released")
1834         $SHOW_QUOTA_USER
1835         resetquota -u $TSTUSR
1836 }
1837
1838 test_23() {
1839         log "run for $((OSTCOUNT * 4))MB test file"
1840         test_23_sub $((OSTCOUNT * 4 * 1024))
1841
1842         OST0_MIN=120000
1843         check_whether_skip && return 0
1844         log "run for $((OSTCOUNT * 40))MB test file"
1845         test_23_sub $((OSTCOUNT * 40 * 1024))
1846 }
1847 run_test_with_stat 23 "run for fixing bug16125 ==========="
1848
1849 test_24() {
1850         local TESTFILE="$DIR/$tdir/$tfile"
1851         mkdir -p $DIR/$tdir
1852
1853         run_to_block_limit $TESTFILE
1854         $SHOW_QUOTA_USER | grep '*' || error "no matching *"
1855
1856         # cleanup
1857         rm -f $TESTFILE
1858         resetquota -u $TSTUSR
1859
1860         set_blk_unitsz $((128 * 1024))
1861         set_blk_tunesz $((128 * 1024 / 2))
1862         
1863 }
1864 run_test_with_stat 24 "test if lfs draws an asterix when limit is reached (16646) ==========="
1865
1866 show_quota() {
1867         if [ $1 = "-u" ]; then
1868                 if [ $2 = "$TSTUSR" ]; then
1869                         $SHOW_QUOTA_USER
1870                 else
1871                         $SHOW_QUOTA_USER2
1872                 fi
1873         else
1874                 if [ $2 = "$TSTUSR" ]; then
1875                         $SHOW_QUOTA_GROUP
1876                 else
1877                         $SHOW_QUOTA_GROUP2
1878                 fi
1879         fi
1880 }
1881
1882 test_25_sub() {
1883         mkdir -p $DIR/$tdir
1884         chmod 0777 $DIR/$tdir
1885         TESTFILE="$DIR/$tdir/$tfile-0"
1886         rm -f $TESTFILE
1887         LIMIT=$(( $BUNIT_SZ * ($OSTCOUNT + 1) + 4096 ))
1888
1889         wait_delete_completed
1890
1891         # set quota for $TSTUSR
1892         log "setquota for $TSTUSR"
1893         $LFS setquota $1 $TSTUSR -b $LIMIT -B $LIMIT -i 10 -I 10 $DIR
1894         sleep 3
1895         if [ "$1" == "-u" ]; then
1896                 quota_show_check a u $TSTUSR
1897         else
1898                 quota_show_check a g $TSTUSR
1899         fi
1900
1901         # set quota for $TSTUSR2
1902         log "setquota for $TSTUSR2"
1903         $LFS setquota $1 $TSTUSR2 -b $LIMIT -B $LIMIT -i 10 -I 10 $DIR
1904         sleep 3
1905         if [ "$1" == "-u" ]; then
1906                 quota_show_check a u $TSTUSR2
1907         else
1908                 quota_show_check a g $TSTUSR2
1909         fi
1910
1911         # set stripe index to 0
1912         log "setstripe for $DIR/$tdir to 0"
1913         $LFS setstripe $DIR/$tdir -c 1 -i 0
1914         MDS_UUID=`do_facet $SINGLEMDS $LCTL dl | grep -m1 " mdt " | awk '{print $((NF-1))}'`
1915         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
1916         MDS_QUOTA_USED_OLD=`getquota $1 $TSTUSR $MDS_UUID curinodes`
1917         OST0_QUOTA_USED_OLD=`getquota $1 $TSTUSR $OST0_UUID curspace`
1918         MDS_QUOTA_USED2_OLD=`getquota $1 $TSTUSR2 $MDS_UUID curinodes`
1919         OST0_QUOTA_USED2_OLD=`getquota $1 $TSTUSR2 $OST0_UUID curspace`
1920
1921         # TSTUSR write 4M
1922         log "$TSTUSR write 4M to $TESTFILE"
1923         $RUNAS dd if=/dev/zero of=$TESTFILE bs=4K count=1K || quota_error a $TSTUSR "dd failed"
1924         sync
1925         show_quota $1 $TSTUSR
1926         show_quota $1 $TSTUSR2
1927         MDS_QUOTA_USED_NEW=`getquota  $1 $TSTUSR $MDS_UUID curinodes`
1928         [ $MDS_QUOTA_USED_NEW -ne $((MDS_QUOTA_USED_OLD + 1)) ] && \
1929                 quota_error a $TSTUSR "$TSTUSR inode quota usage error: [$MDS_QUOTA_USED_OLD|$MDS_QUOTA_USED_NEW]"
1930         OST0_QUOTA_USED_NEW=`getquota   $1 $TSTUSR $OST0_UUID curspace`
1931         OST0_QUOTA_USED_DELTA=$((OST0_QUOTA_USED_NEW - OST0_QUOTA_USED_OLD))
1932         [ $OST0_QUOTA_USED_DELTA -lt 4096 ] && \
1933                 quota_error a $TSTUSR "$TSTUSR block quota usage error: [$OST0_QUOTA_USED_OLD|$OST0_QUOTA_USED_NEW]"
1934
1935         # chown/chgrp from $TSTUSR to $TSTUSR2
1936         if [ $1 = "-u" ]; then
1937                 log "chown from $TSTUSR to $TSTUSR2"
1938                 chown $TSTUSR2 $TESTFILE || quota_error u $TSTUSR2 "chown failed"
1939         else
1940                 log "chgrp from $TSTUSR to $TSTUSR2"
1941                 chgrp $TSTUSR2 $TESTFILE || quota_error g $TSTUSR2 "chgrp failed"
1942         fi
1943         sync
1944         show_quota $1 $TSTUSR
1945         show_quota $1 $TSTUSR2
1946         MDS_QUOTA_USED2_NEW=`getquota $1 $TSTUSR2 $MDS_UUID curinodes`
1947         [ $MDS_QUOTA_USED2_NEW -ne $((MDS_QUOTA_USED2_OLD + 1)) ] && \
1948                 quota_error a $TSTUSR2 "$TSTUSR2 inode quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$MDS_QUOTA_USED2_OLD|$MDS_QUOTA_USED2_NEW]"
1949         OST0_QUOTA_USED2_NEW=`getquota  $1 $TSTUSR2 $OST0_UUID curspace`
1950         # when chown, the quota on ost could be displayed out of quota temporarily. Delete the '*' in this situation. b=20433
1951         OST0_QUOTA_USED2_NEW=${OST0_QUOTA_USED2_NEW%\*}
1952         OST0_QUOTA_USED2_DELTA=$((OST0_QUOTA_USED2_NEW - OST0_QUOTA_USED2_OLD))
1953         [ $OST0_QUOTA_USED2_DELTA -ne $OST0_QUOTA_USED_DELTA ] && \
1954                 quota_error a $TSTUSR2 "$TSTUSR2 block quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$OST0_QUOTA_USED2_OLD|$OST0_QUOTA_USED2_NEW]"
1955         MDS_QUOTA_USED_NEW=`getquota  $1 $TSTUSR $MDS_UUID curinodes`
1956         [ $MDS_QUOTA_USED_NEW -ne $MDS_QUOTA_USED_OLD ] && \
1957                 quota_error a $TSTUSR "$TSTUSR inode quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$MDS_QUOTA_USED_OLD|$MDS_QUOTA_USED_NEW]"
1958         OST0_QUOTA_USED_NEW=`getquota  $1 $TSTUSR $OST0_UUID curspace`
1959         [ $OST0_QUOTA_USED_NEW -ne $OST0_QUOTA_USED_OLD ] && \
1960                 quota_error a $TSTUSR "$TSTUSR block quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$OST0_QUOTA_USED_OLD|$OST0_QUOTA_USED_NEW]"
1961
1962         rm -f $TESTFILE
1963         wait_delete_completed
1964         resetquota $1 $TSTUSR
1965         resetquota $1 $TSTUSR2
1966 }
1967
1968 test_25() {
1969         log "run for chown case"
1970         test_25_sub -u
1971
1972         log "run for chgrp case"
1973         test_25_sub -g
1974 }
1975 run_test_with_stat 25 "test whether quota usage is transfered when chown/chgrp (18081) ==========="
1976
1977 test_26() {
1978         mkdir -p $DIR/$tdir
1979         chmod 0777 $DIR/$tdir
1980         TESTFILE="$DIR/$tdir/$tfile-0"
1981         TESTFILE2="$DIR/$tdir/$tfile-1"
1982         set_blk_tunesz 512
1983         set_blk_unitsz 1024
1984
1985         wait_delete_completed
1986
1987         # every quota slave gets 20MB
1988         b_limit=$(((OSTCOUNT + 1) * 20 * 1024))
1989         log "limit: ${b_limit}KB"
1990         $LFS setquota -u $TSTUSR -b 0 -B $b_limit -i 0 -I 0 $DIR
1991         sleep 3
1992         quota_show_check b u $TSTUSR
1993
1994         $LFS setstripe $TESTFILE  -c 1 -i 0
1995         $LFS setstripe $TESTFILE2 -c 1 -i 0
1996         chown $TSTUSR.$TSTUSR $TESTFILE
1997         chown $TSTUSR.$TSTUSR $TESTFILE2
1998
1999         #define OBD_FAIL_QUOTA_DELAY_REL         0xA03
2000         lustre_fail ost 0xA03
2001
2002         log "    Write the first file..."
2003         $RUNAS $DIRECTIO write $TESTFILE 0 10 $((BLK_SZ * 1024)) || quota_error u $TSTUSR "write failure, but expect success"
2004         log "    Delete the first file..."
2005         rm -f $TESTFILE
2006
2007
2008         wait_delete_completed
2009
2010         log "    Write the second file..."
2011         $RUNAS $DIRECTIO write $TESTFILE2 0 10 $((BLK_SZ * 1024)) || quota_error u $TSTUSR "write failure, but expect success"
2012         log "    Delete the second file..."
2013         rm -f $TESTFILE2
2014
2015         lustre_fail ost 0
2016         set_blk_unitsz $((128 * 1024))
2017         set_blk_tunesz $((128 * 1024 / 2))
2018         resetquota -u $TSTUSR
2019 }
2020 run_test_with_stat 26 "test for false quota error(bz18491) ======================================"
2021
2022 test_27a() {
2023         $LFS quota $TSTUSR $DIR && error "lfs succeeded with no type, but should have failed"
2024         $LFS setquota $TSTUSR $DIR && error "lfs succeeded with no type, but should have failed"
2025         return 0
2026 }
2027 run_test_with_stat 27a "lfs quota/setquota should handle wrong arguments (19612) ================="
2028
2029 test_27b() {
2030         $LFS setquota -u $TSTID -b 1000 -B 1000 -i 1000 -I 1000 $DIR || \
2031                 error "lfs setquota failed with uid argument"
2032         $LFS setquota -g $TSTID -b 1000 -B 1000 -i 1000 -I 1000 $DIR || \
2033                 error "lfs stequota failed with gid argument"
2034         $SHOW_QUOTA_USERID || error "lfs quota failed with uid argument"
2035         $SHOW_QUOTA_GROUPID || error "lfs quota failed with gid argument"
2036         resetquota -u $TSTUSR
2037         resetquota -g $TSTUSR
2038         return 0
2039 }
2040 run_test 27b "lfs quota/setquota should handle user/group ID (20200) ================="
2041
2042 test_28() {
2043         BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
2044         echo "Step 1: set enough high limit for user [$TSTUSR:$BLK_LIMIT]"
2045         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
2046         $SHOW_QUOTA_USER
2047
2048         echo "Step 2: reset system ..."
2049         cleanup_and_setup_lustre
2050         quota_init
2051
2052         echo "Step 3: change qunit for user [$TSTUSR:512:1024]"
2053         set_blk_tunesz 512
2054         set_blk_unitsz 1024
2055
2056         wait_delete_completed
2057
2058         #define OBD_FAIL_QUOTA_RET_QDATA | OBD_FAIL_ONCE
2059         lustre_fail ost 0x80000A02
2060
2061         TESTFILE="$DIR/$tdir/$tfile"
2062         mkdir -p $DIR/$tdir
2063
2064         BLK_LIMIT=$((100 * 1024)) # 100M
2065         echo "Step 4: set enough high limit for user [$TSTUSR:$BLK_LIMIT]"
2066         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
2067         $SHOW_QUOTA_USER
2068
2069         touch $TESTFILE
2070         chown $TSTUSR.$TSTUSR $TESTFILE
2071
2072         echo "Step 5: write the test file1 [10M] ..."
2073         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$(( 10 * 1024 )) \
2074             || quota_error a $TSTUSR "write 10M file failure"
2075         $SHOW_QUOTA_USER
2076
2077         rm -f $TESTFILE
2078         sync; sleep 3; sync;
2079
2080         # make qd_count 64 bit
2081         lustre_fail ost 0
2082
2083         set_blk_unitsz $((128 * 1024))
2084         set_blk_tunesz $((128 * 1024 / 2))
2085
2086         resetquota -u $TSTUSR
2087 }
2088 run_test_with_stat 28 "test for consistency for qunit when setquota (18574) ==========="
2089
2090 test_29()
2091 {
2092         local BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
2093         local timeout
2094         local pid
2095
2096         if at_is_enabled; then
2097                 timeout=$(at_max_get client)
2098                 at_max_set 10 client
2099         else
2100                 timeout=$(lctl get_param -n timeout)
2101                 lctl set_param timeout=10
2102         fi
2103
2104         #define OBD_FAIL_MDS_QUOTACTL_NET 0x12e
2105         lustre_fail mds 0x12e
2106
2107         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR & pid=$!
2108
2109         echo "sleeping for $((10 * 2)) seconds"
2110         sleep $((10 * 2))
2111         ps -p $pid && error "lfs hadn't finished by timeout"
2112         wait $pid && error "succeeded, but should have failed"
2113
2114         lustre_fail mds 0
2115
2116         if at_is_enabled; then
2117                 at_max_set $timeout client
2118         else
2119                 lctl set_param timeout=$timeout
2120         fi
2121
2122         resetquota -u $TSTUSR
2123 }
2124 run_test_with_stat 29 "unhandled quotactls must not hang lustre client (19778) ========"
2125
2126 test_30()
2127 {
2128         local output
2129         local LIMIT=1024
2130         local TESTFILE="$DIR/$tdir/$tfile"
2131         local GRACE=10
2132
2133         set_blk_tunesz 512
2134         set_blk_unitsz 1024
2135
2136         mkdir -p $DIR/$tdir
2137         chmod 0777 $DIR/$tdir
2138
2139         $LFS setstripe $TESTFILE -i 0 -c 1
2140         chown $TSTUSR.$TSTUSR $TESTFILE
2141
2142         $LFS setquota -t -u --block-grace $GRACE --inode-grace $MAX_IQ_TIME $DIR
2143         $LFS setquota -u $TSTUSR -b $LIMIT -B 0 -i 0 -I 0 $DIR
2144         $RUNAS dd if=/dev/zero of=$TESTFILE bs=1024 count=$((LIMIT * 2)) || true
2145         cancel_lru_locks osc
2146         sleep $GRACE
2147         $LFS setquota -u $TSTUSR -B 0 $DIR
2148         # over-quota flag has not yet settled since we do not trigger async events
2149         # based on grace time period expiration
2150         $SHOW_QUOTA_USER
2151         $RUNAS dd if=/dev/zero of=$TESTFILE conv=notrunc oflag=append bs=1048576 count=1 || true
2152         cancel_lru_locks osc
2153         # now over-quota flag should be settled and further writes should fail
2154         $SHOW_QUOTA_USER
2155         $RUNAS dd if=/dev/zero of=$TESTFILE conv=notrunc oflag=append bs=1048576 count=1 && error "grace times were reset"
2156         rm -f $TESTFILE
2157         resetquota -u $TSTUSR
2158         $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
2159
2160         set_blk_unitsz $((128 * 1024))
2161         set_blk_tunesz $((128 * 1024 / 2))
2162 }
2163 run_test_with_stat 30 "hard limit updates should not reset grace times ================"
2164
2165 # test duplicate quota releases b=18630
2166 test_31() {
2167         mkdir -p $DIR/$tdir
2168         chmod 0777 $DIR/$tdir
2169
2170         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
2171         TESTFILE="$DIR/$tdir/$tfile-0"
2172         TESTFILE2="$DIR/$tdir/$tfile-1"
2173
2174         wait_delete_completed
2175
2176         log "   User quota (limit: $LIMIT kbytes)"
2177         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
2178
2179         $LFS setstripe $TESTFILE -i 0 -c 1
2180         chown $TSTUSR.$TSTUSR $TESTFILE
2181         $LFS setstripe $TESTFILE2 -i 0 -c 1
2182         chown $TSTUSR.$TSTUSR $TESTFILE2
2183
2184         log "   step1: write out of block quota ..."
2185         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=5120
2186         $RUNAS dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=5120
2187
2188         #define OBD_FAIL_QUOTA_DELAY_SD      0xA04
2189         #define OBD_FAIL_SOME        0x10000000 /* fail N times */
2190         lustre_fail ost $((0x00000A04 | 0x10000000)) 1
2191
2192         log "   step2: delete two files so that triggering duplicate quota release ..."
2193         rm -f $TESTFILE $TESTFILE2
2194         sync; sleep 5; sync      #  OBD_FAIL_QUOTA_DELAY_SD will delay for 5 seconds
2195         wait_delete_completed
2196
2197         log "   step3: verify if the ost failed"
2198         do_facet ost1 dmesg > $TMP/lustre-log-${TESTNAME}.log
2199         watchdog=`awk '/test 31/ {start = 1;}
2200                        /release quota error/ {
2201                                if (start) {
2202                                        print;
2203                                }
2204                        }' $TMP/lustre-log-${TESTNAME}.log`
2205         [ "$watchdog" ] && error "$watchdog"
2206         rm -f $TMP/lustre-log-${TESTNAME}.log
2207
2208         lustre_fail ost 0
2209         resetquota -u $TSTUSR
2210 }
2211 run_test_with_stat 31 "test duplicate quota releases ==="
2212
2213 # turn off quota
2214 quota_fini()
2215 {
2216         $LFS quotaoff $DIR
2217         do_nodes $(comma_list $(nodes_list)) "lctl set_param debug=-quota"
2218 }
2219 quota_fini
2220
2221 log "cleanup: ======================================================"
2222 cd $ORIG_PWD
2223 check_and_cleanup_lustre
2224 echo '=========================== finished ==============================='
2225 export QUOTA_AUTO=$QUOTA_AUTO_OLD
2226 [ -f "$QUOTALOG" ] && cat $QUOTALOG && grep -q FAIL $QUOTALOG && exit 1 || true
2227 echo "$0: completed"