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