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