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"