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;} }'
 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 # run for fixing bug10707, it need a big room. test for 32bit
1028 # 2.0 version does not support 32 bit qd_count, so such test is obsolete.
1029 test_10() {
1030         mkdir -p $DIR/$tdir
1031         chmod 0777 $DIR/$tdir
1032         check_whether_skip && return 0
1033
1034         wait_delete_completed
1035
1036         set_blk_tunesz 512
1037         set_blk_unitsz 1024
1038
1039         # make qd_count 32 bit
1040         lustre_fail mds_ost 0xA00
1041
1042         TESTFILE="$DIR/$tdir/$tfile-0"
1043
1044         BLK_LIMIT=$((100 * KB * KB)) # 100G
1045         FILE_LIMIT=1000000
1046
1047         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
1048         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
1049         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
1050         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $DIR
1051
1052         quota_show_check a u $TSTUSR
1053         quota_show_check a g $TSTUSR
1054
1055         echo "  Set stripe"
1056         $LFS setstripe $TESTFILE -c 1
1057         touch $TESTFILE
1058         chown $TSTUSR.$TSTUSR $TESTFILE
1059
1060         log "    Write the big file of 4.5 G ..."
1061         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
1062                 quota_error a $TSTUSR "(usr) write 4.5 G file failure, but expect success"
1063
1064         $SHOW_QUOTA_USER
1065         $SHOW_QUOTA_GROUP
1066
1067         log "    delete the big file of 4.5 G..."
1068         $RUNAS rm -f $TESTFILE
1069         sync; sleep 3; sync;
1070
1071         $SHOW_QUOTA_USER
1072         $SHOW_QUOTA_GROUP
1073
1074         RC=$?
1075
1076         # make qd_count 64 bit
1077         lustre_fail mds_ost 0
1078
1079         set_blk_unitsz $((128 * 1024))
1080         set_blk_tunesz $((128 * 1024 / 2))
1081
1082         return $RC
1083 }
1084 #run_test_with_stat 10 "run for fixing bug10707(32bit) ==========="
1085
1086 # test a deadlock between quota and journal b=11693
1087 test_12() {
1088         mkdir -p $DIR/$tdir
1089         chmod 0777 $DIR/$tdir
1090
1091         [ "$(grep $DIR2 /proc/mounts)" ] || mount_client $DIR2 || \
1092                 { skip_env "Need lustre mounted on $MOUNT2 " && retutn 0; }
1093
1094         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
1095         TESTFILE="$DIR/$tdir/$tfile-0"
1096         TESTFILE2="$DIR2/$tdir/$tfile-1"
1097
1098         wait_delete_completed
1099
1100         echo "   User quota (limit: $LIMIT kbytes)"
1101         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1102
1103         $LFS setstripe $TESTFILE -i 0 -c 1
1104         chown $TSTUSR.$TSTUSR $TESTFILE
1105         $LFS setstripe $TESTFILE2 -i 0 -c 1
1106         chown $TSTUSR2.$TSTUSR2 $TESTFILE2
1107
1108         #define OBD_FAIL_OST_HOLD_WRITE_RPC      0x21f
1109         #define OBD_FAIL_SOME        0x10000000 /* fail N times */
1110         lustre_fail ost $((0x0000021f | 0x10000000)) 1
1111
1112         echo "   step1: write out of block quota ..."
1113         $RUNAS2 dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=102400 &
1114         DDPID1=$!
1115         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT*2)) &
1116         DDPID=$!
1117
1118         echo  "   step2: testing ......"
1119         local last_size=$(stat -c %s $TESTFILE2)
1120         local stall_secs=0
1121         local start_secs=$SECONDS
1122         while [ -d /proc/${DDPID1} ]; do
1123             local size=$(stat -c %s $TESTFILE2)
1124             if [ $size -eq $last_size ]; then
1125                 stall_secs=$[stall_secs+1]
1126             else
1127                 stall_secs=0
1128             fi
1129             if [ $stall_secs -gt 30 ]; then
1130                 lustre_fail ost 0
1131                 quota_error u $TSTUSR2 "giving up: dd stalled (i.e. made no progress) for 30 seconds!"
1132             fi
1133             last_size=$size
1134             sleep 1
1135         done
1136         echo "(dd_pid=$DDPID1, time=$((SECONDS-start_secs)))successful"
1137
1138         #Recover fail_loc and dd will finish soon
1139         lustre_fail ost 0
1140
1141         echo  "   step3: testing ......"
1142         count=0
1143         while [ true ]; do
1144             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1145             count=$[count+1]
1146             if [ $count -gt 150 ]; then
1147                 quota_error u $TSTUSR "dd should be finished!"
1148             fi
1149             sleep 1
1150         done
1151         echo "(dd_pid=$DDPID, time=$count)successful"
1152
1153         rm -f $TESTFILE $TESTFILE2
1154         sync; sleep 3; sync;
1155
1156         resetquota -u $TSTUSR
1157 }
1158 run_test_with_stat 12 "test a deadlock between quota and journal ==="
1159
1160 # test multiple clients write block quota b=11693
1161 test_13() {
1162         mkdir -p $DIR/$tdir
1163         wait_delete_completed
1164
1165         # one OST * 10 + (mds + other OSTs)
1166         LIMIT=$((BUNIT_SZ * 10 + (BUNIT_SZ * OSTCOUNT)))
1167         TESTFILE="$DIR/$tdir/$tfile"
1168
1169         echo "   User quota (limit: $LIMIT kbytes)"
1170         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1171         quota_show_check b u $TSTUSR
1172
1173         $LFS setstripe $TESTFILE -i 0 -c 1
1174         chown $TSTUSR.$TSTUSR $TESTFILE
1175         $LFS setstripe $TESTFILE.2 -i 0 -c 1
1176         chown $TSTUSR.$TSTUSR $TESTFILE.2
1177
1178         echo "   step1: write out of block quota ..."
1179         # one bunit will give mds
1180         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1181         DDPID=$!
1182         $RUNAS dd if=/dev/zero of=$TESTFILE.2 bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1183         DDPID1=$!
1184
1185         echo  "   step2: testing ......"
1186         count=0
1187         while [ true ]; do
1188             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1189             count=$[count+1]
1190             if [ $count -gt 64 ]; then
1191                 quota_error u $TSTUSR "dd should be finished!"
1192             fi
1193             sleep 1
1194         done
1195         echo "(dd_pid=$DDPID, time=$count)successful"
1196
1197         count=0
1198         while [ true ]; do
1199             if ! ps -p ${DDPID1} > /dev/null 2>&1 ; then break; fi
1200             count=$[count+1]
1201             if [ $count -gt 64 ]; then
1202                 quota_error u $TSTUSR "dd should be finished!"
1203             fi
1204             sleep 1
1205         done
1206         echo "(dd_pid=$DDPID1, time=$count)successful"
1207
1208         sync; sleep 5; sync;
1209
1210         echo  "   step3: checking ......"
1211         fz=`stat -c %s $TESTFILE`
1212         fz2=`stat -c %s $TESTFILE.2`
1213         $SHOW_QUOTA_USER
1214         [ $((fz + fz2)) -lt $((BUNIT_SZ * BLK_SZ * 10)) ] && \
1215                 quota_error u $TSTUSR "files too small $fz + $fz2 < $((BUNIT_SZ * BLK_SZ * 10))"
1216
1217         rm -f $TESTFILE $TESTFILE.2
1218         sync; sleep 3; sync;
1219
1220         resetquota -u $TSTUSR
1221 }
1222 run_test_with_stat 13 "test multiple clients write block quota ==="
1223
1224 check_if_quota_zero(){
1225         line=`$LFS quota -v -$1 $2 $DIR | wc -l`
1226         for i in `seq 3 $line`; do
1227             if [ $i -eq 3 ]; then
1228                 field="3 4 7 8"
1229             else
1230                 field="3 6"
1231             fi
1232             for j in $field; do
1233                 tmp=`$LFS quota -v -$1 $2 $DIR | sed -n ${i}p |
1234                      awk  '{print $'"$j"'}'`
1235                 [ -n "$tmp" ] && [ $tmp -ne 0 ] && $LFS quota -v -$1 $2 $DIR && \
1236                     error "quota on $2 isn't clean"
1237             done
1238         done
1239         echo "pass check_if_quota_zero"
1240 }
1241
1242 test_14a() {    # was test_14 b=12223 -- setting quota on root
1243         TESTFILE="$DIR/$tdir/$tfile"
1244
1245         # reboot the lustre
1246         sync; sleep 5; sync
1247         cleanup_and_setup_lustre
1248         quota_init
1249
1250         mkdir -p $DIR/$tdir
1251
1252         # out of root's file and block quota
1253         $LFS setquota -u root -b 10 -B 10 -i 10 -I 10 $DIR
1254         createmany -m ${TESTFILE} 20 || \
1255             quota_error u root "unexpected: user(root) create files failly!"
1256         dd if=/dev/zero of=$TESTFILE bs=4k count=4096 || \
1257             quota_error u root "unexpected: user(root) write files failly!"
1258         chmod 666 $TESTFILE
1259         $RUNAS dd if=/dev/zero of=${TESTFILE} seek=4096 bs=4k count=4096 && \
1260             quota_error u root "unexpected: user(quota_usr) write a file successfully!"
1261
1262         # trigger the llog
1263         chmod 777 $DIR
1264         for i in `seq 1 10`; do $RUNAS touch ${TESTFILE}a_$i; done
1265         for i in `seq 1 10`; do $RUNAS rm -f ${TESTFILE}a_$i; done
1266
1267         # do the check
1268         dmesg | tail | grep "\-122" |grep llog_obd_origin_add && error "err -122 not found in dmesg"
1269         resetquota -u root
1270         #check_if_quota_zero u root
1271
1272         # clean
1273         unlinkmany ${TESTFILE} 15
1274         rm -f $TESTFILE
1275         sync; sleep 3; sync;
1276 }
1277 run_test_with_stat 14a "test setting quota on root ==="
1278
1279 test_15(){
1280         LIMIT=$((24 * 1024 * 1024 * 1024 * 1024)) # 24 TB
1281         PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
1282
1283         wait_delete_completed
1284
1285         # test for user
1286         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1287         TOTAL_LIMIT=`getquota -u $TSTUSR global bhardlimit`
1288         [ $TOTAL_LIMIT -eq $LIMIT ] || error "  (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1289         echo "  (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1290         resetquota -u $TSTUSR
1291
1292         # test for group
1293         $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1294         TOTAL_LIMIT=`getquota -g $TSTUSR global bhardlimit`
1295         [ $TOTAL_LIMIT -eq $LIMIT ] || error "  (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1296         echo "  (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1297         resetquota -g $TSTUSR
1298         $LFS quotaoff -ug $DIR
1299         do_facet $SINGLEMDS "lctl set_param lquota.mdd_obd-${FSNAME}-MDT*.quota_type=ug" | grep "error writing" && \
1300                 error "fail to set version for $SINGLEMDS"
1301         for j in `seq $OSTCOUNT`; do
1302                 do_facet ost$j "lctl set_param lquota.${FSNAME}-OST*.quota_type=ug" | grep "error writing" && \
1303                         error "fail to set version for ost$j"
1304         done
1305
1306         echo "invalidating quota files"
1307         $LFS quotainv -ug $DIR
1308         $LFS quotainv -ugf $DIR
1309         $LFS quotacheck -ug $DIR
1310 }
1311 run_test_with_stat 15 "set block quota more than 4T ==="
1312
1313 # $1=u/g $2=with qunit adjust or not
1314 test_16_tub() {
1315         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 4))
1316         TESTFILE="$DIR/$tdir/$tfile"
1317         mkdir -p $DIR/$tdir
1318
1319         wait_delete_completed
1320
1321         echo "  User quota (limit: $LIMIT kbytes)"
1322         if [ $1 == "u" ]; then
1323             $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1324             quota_show_check b u $TSTUSR
1325         else
1326             $LFS setquota -g $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1327             quota_show_check b g $TSTUSR
1328         fi
1329
1330         $LFS setstripe $TESTFILE -c 1
1331         chown $TSTUSR.$TSTUSR $TESTFILE
1332
1333         echo "    Write ..."
1334         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((BUNIT_SZ * 4)) || \
1335             quota_error a $TSTUSR "(usr) write failure, but expect success"
1336         echo "    Done"
1337         echo "    Write out of block quota ..."
1338         # this time maybe cache write,  ignore it's failure
1339         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || true
1340         # flush cache, ensure noquota flag is setted on client
1341         cancel_lru_locks osc
1342         if [ $2 -eq 1 ]; then
1343             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || \
1344                 quota_error a $TSTUSR "(write failure, but expect success"
1345         else
1346             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) && \
1347                 quota_error a $TSTUSR "(write success, but expect EDQUOT"
1348         fi
1349
1350         rm -f $TESTFILE
1351         sync; sleep 3; sync;
1352         resetquota -$1 $TSTUSR
1353 }
1354
1355 # test without adjusting qunit
1356 # 2.0 version does not support WITHOUT_CHANGE_QS, so such test is obsolete
1357 test_16 () {
1358         set_blk_tunesz $((BUNIT_SZ * 2))
1359         set_blk_unitsz $((BUNIT_SZ * 4))
1360         for i in u g; do
1361             for j in 0 1; do
1362                 # define OBD_FAIL_QUOTA_WITHOUT_CHANGE_QS    0xA01
1363                 echo " grp/usr: $i, adjust qunit: $j"
1364                 echo "-------------------------------"
1365                 [ $j -eq 1 ] && lustre_fail mds_ost 0
1366                 [ $j -eq 0 ] && lustre_fail mds_ost 0xA01
1367                 test_16_tub $i $j
1368             done
1369         done
1370         set_blk_unitsz $((128 * 1024))
1371         set_blk_tunesz $((128 * 1024 / 2))
1372 }
1373 #run_test_with_stat 16 "test without adjusting qunit"
1374
1375 # run for fixing bug14526, failed returned quota reqs shouldn't ruin lustre.
1376 test_17() {
1377         set_blk_tunesz 512
1378         set_blk_unitsz 1024
1379
1380         wait_delete_completed
1381
1382         #define OBD_FAIL_QUOTA_RET_QDATA | OBD_FAIL_ONCE
1383         lustre_fail ost 0x80000A02
1384
1385         TESTFILE="$DIR/$tdir/$tfile-a"
1386         TESTFILE2="$DIR/$tdir/$tfile-b"
1387         mkdir -p $DIR/$tdir
1388
1389         BLK_LIMIT=$((100 * 1024)) # 100M
1390
1391         log "  Set enough high limit(block:$BLK_LIMIT) for user: $TSTUSR"
1392         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
1393         log "  Set enough high limit(block:$BLK_LIMIT) for group: $TSTUSR"
1394         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
1395
1396         quota_show_check b u $TSTUSR
1397         quota_show_check b g $TSTUSR
1398
1399         touch $TESTFILE
1400         chown $TSTUSR.$TSTUSR $TESTFILE
1401         touch $TESTFILE2
1402         chown $TSTUSR.$TSTUSR $TESTFILE2
1403
1404         log "    Write the test file1 ..."
1405         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$(( 10 * 1024 )) \
1406             || quota_error a $TSTUSR "write 10M file failure"
1407
1408         $SHOW_QUOTA_USER
1409         $SHOW_QUOTA_GROUP
1410
1411         log "    write the test file2 ..."
1412         $RUNAS dd if=/dev/zero of=$TESTFILE2  bs=$BLK_SZ count=$(( 10 * 1024 )) \
1413             || quota_error a $TSTUSR "write 10M file failure"
1414
1415         $SHOW_QUOTA_USER
1416         $SHOW_QUOTA_GROUP
1417
1418         rm -f $TESTFILE $TESTFILE2
1419         RC=$?
1420         sync; sleep 3; sync;
1421
1422         # make qd_count 64 bit
1423         lustre_fail ost 0
1424
1425         set_blk_unitsz $((128 * 1024))
1426         set_blk_tunesz $((128 * 1024 / 2))
1427
1428         resetquota -u $TSTUSR
1429         resetquota -g $TSTUSR
1430
1431         return $RC
1432 }
1433 run_test_with_stat 17 "run for fixing bug14526 ==========="
1434
1435 # test when mds takes a long time to handle a quota req so that
1436 # the ost has dropped it, the ost still could work well b=14840
1437 test_18() {
1438         LIMIT=$((100 * 1024 * 1024)) # 100G
1439         TESTFILE="$DIR/$tdir/$tfile"
1440         mkdir -p $DIR/$tdir
1441
1442         wait_delete_completed
1443
1444         set_blk_tunesz 512
1445         set_blk_unitsz 1024
1446
1447         log "   User quota (limit: $LIMIT kbytes)"
1448         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1449         quota_show_check b u $TSTUSR
1450
1451         $LFS setstripe $TESTFILE -i 0 -c 1
1452         chown $TSTUSR.$TSTUSR $TESTFILE
1453
1454         #define OBD_FAIL_MDS_BLOCK_QUOTA_REQ      0x13c
1455         lustre_fail mds 0x13c
1456
1457         log "   step1: write 100M block ..."
1458         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1459         DDPID=$!
1460
1461         sleep 5
1462         lustre_fail mds 0
1463
1464         echo  "   step2: testing ......"
1465         count=0
1466         if at_is_enabled; then
1467             timeout=$(at_max_get mds)
1468         else
1469             timeout=$(lctl get_param -n timeout)
1470         fi
1471         while [ true ]; do
1472             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1473             count=$[count+1]
1474             if [ $count -gt $((4 * $timeout)) ]; then
1475                 quota_error u $TSTUSR "count=$count dd should be finished!"
1476             fi
1477             sleep 1
1478         done
1479         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1480         sync
1481         cancel_lru_locks mdc
1482         cancel_lru_locks osc
1483
1484         testfile_size=$(stat -c %s $TESTFILE)
1485         [ $testfile_size -ne $((BLK_SZ * 1024 * 100)) ] && \
1486             quota_error u $TSTUSR "expect $((BLK_SZ * 1024 * 100)), got ${testfile_size}. Verifying file failed!"
1487         $SHOW_QUOTA_USER
1488         rm -f $TESTFILE
1489         sync
1490
1491         resetquota -u $TSTUSR
1492         set_blk_unitsz $((128 * 1024))
1493         set_blk_tunesz $((128 * 1024 / 2))
1494 }
1495 run_test_with_stat 18 "run for fixing bug14840 ==========="
1496
1497 # test when mds drops a quota req, the ost still could work well b=14840
1498 test_18a() {
1499         LIMIT=$((100 * 1024 * 1024)) # 100G
1500         TESTFILE="$DIR/$tdir/$tfile-a"
1501         mkdir -p $DIR/$tdir
1502
1503         wait_delete_completed
1504
1505         set_blk_tunesz 512
1506         set_blk_unitsz 1024
1507
1508         log "   User quota (limit: $LIMIT kbytes)"
1509         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1510         quota_show_check b u $TSTUSR
1511
1512         $LFS setstripe $TESTFILE -i 0 -c 1
1513         chown $TSTUSR.$TSTUSR $TESTFILE
1514
1515         #define OBD_FAIL_MDS_DROP_QUOTA_REQ | OBD_FAIL_ONCE   0x8000013d
1516         lustre_fail mds 0x8000013d
1517
1518         log "   step1: write 100M block ..."
1519         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1520         DDPID=$!
1521
1522         echo  "   step2: testing ......"
1523         count=0
1524         if at_is_enabled; then
1525             timeout=$(at_max_get mds)
1526         else
1527             timeout=$(lctl get_param -n timeout)
1528         fi
1529         while [ true ]; do
1530             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1531             count=$[count+1]
1532             if [ $count -gt $((6 * $timeout)) ]; then
1533                 lustre_fail mds 0
1534                 quota_error u $TSTUSR "count=$count dd should be finished!"
1535             fi
1536             sleep 1
1537         done
1538         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1539
1540         lustre_fail mds 0
1541         rm -f $TESTFILE
1542         sync
1543
1544         resetquota -u $TSTUSR
1545         set_blk_unitsz $((128 * 1024))
1546         set_blk_tunesz $((128 * 1024 / 2))
1547 }
1548 run_test_with_stat 18a "run for fixing bug14840 ==========="
1549
1550 # test when mds do failover, the ost still could work well without trigger
1551 # watchdog b=14840
1552 test_18bc_sub() {
1553         type=$1
1554
1555         LIMIT=$((110 * 1024 )) # 110M
1556         TESTFILE="$DIR/$tdir/$tfile"
1557         mkdir -p $DIR/$tdir
1558
1559         wait_delete_completed
1560
1561         set_blk_tunesz 512
1562         set_blk_unitsz 1024
1563
1564         log "   User quota (limit: $LIMIT kbytes)"
1565         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1566         quota_show_check b u $TSTUSR
1567
1568         $LFS setstripe $TESTFILE -i 0 -c 1
1569         chown $TSTUSR.$TSTUSR $TESTFILE
1570
1571         timeout=$(sysctl -n lustre.timeout)
1572
1573         if [ $type = "directio" ]; then
1574             log "   write 100M block(directio) ..."
1575             $RUNAS $DIRECTIO write $TESTFILE 0 100 $((BLK_SZ * 1024)) &
1576         else
1577             log "   write 100M block(normal) ..."
1578             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$((BLK_SZ * 1024)) count=100 &
1579         fi
1580
1581         DDPID=$!
1582         do_facet $SINGLEMDS "$LCTL conf_param ${FSNAME}-MDT*.mdd.quota_type=ug"
1583
1584         log "failing mds for $((2 * timeout)) seconds"
1585         fail $SINGLEMDS $((2 * timeout))
1586
1587         # check if quotaon successful
1588         $LFS quota -u $TSTUSR $MOUNT 2>&1 | grep -q "quotas are not enabled"
1589         if [ $? -eq 0 ]; then
1590             error "quotaon failed!"
1591             rm -rf $TESTFILE
1592             return
1593         fi
1594
1595         count=0
1596         if at_is_enabled; then
1597             timeout=$(at_max_get mds)
1598         else
1599             timeout=$(lctl get_param -n timeout)
1600         fi
1601         while [ true ]; do
1602             if ! ps -p ${DDPID} > /dev/null 2>&1; then break; fi
1603             if [ $((++count % (2 * timeout) )) -eq 0 ]; then
1604                 log "it took $count second"
1605             fi
1606             sleep 1
1607         done
1608         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1609         sync
1610         cancel_lru_locks mdc
1611         cancel_lru_locks osc
1612
1613         testfile_size=$(stat -c %s $TESTFILE)
1614         [ $testfile_size -ne $((BLK_SZ * 1024 * 100)) ] && \
1615             quota_error u $TSTUSR "expect $((BLK_SZ * 1024 * 100)), got ${testfile_size}. Verifying file failed!"
1616         $SHOW_QUOTA_USER
1617         rm -f $TESTFILE
1618         sync
1619
1620         resetquota -u $TSTUSR
1621         set_blk_unitsz $((128 * 1024))
1622         set_blk_tunesz $((128 * 1024 / 2))
1623 }
1624
1625 # test when mds does failover, the ost still could work well
1626 # this test shouldn't trigger watchdog b=14840
1627 test_18b() {
1628         test_18bc_sub normal
1629         test_18bc_sub directio
1630         # check if watchdog is triggered
1631         do_facet ost1 dmesg > $TMP/lustre-log-${TESTNAME}.log
1632         watchdog=`awk '/test 18b/ {start = 1;}
1633                        /Service thread pid/ && /was inactive/ {
1634                                if (start) {
1635                                        print;
1636                                }
1637                        }' $TMP/lustre-log-${TESTNAME}.log`
1638         [ `echo "$watchdog" | wc -l` -ge 3 ] && error "$watchdog"
1639         rm -f $TMP/lustre-log-${TESTNAME}.log
1640 }
1641 run_test_with_stat 18b "run for fixing bug14840(mds failover, no watchdog) ==========="
1642
1643 # test when mds does failover, the ost still could work well
1644 # this test will prevent OST_DISCONNET from happening b=14840
1645 test_18c() {
1646         # define OBD_FAIL_OST_DISCONNECT_NET 0x202(disable ost_disconnect for osts)
1647         lustre_fail ost  0x202
1648         test_18bc_sub normal
1649         test_18bc_sub directio
1650         lustre_fail ost  0
1651 }
1652 run_test_with_stat 18c "run for fixing bug14840(mds failover, OST_DISCONNECT is disabled) ==========="
1653
1654 run_to_block_limit() {
1655         local LIMIT=$((($OSTCOUNT + 1) * $BUNIT_SZ))
1656         local TESTFILE=$1
1657         wait_delete_completed
1658
1659         # set 1 Mb quota unit size
1660         set_blk_tunesz 512
1661         set_blk_unitsz 1024
1662
1663         # bind file to a single OST
1664         $LFS setstripe -c 1 $TESTFILE
1665         chown $TSTUSR.$TSTUSR $TESTFILE
1666
1667         echo "  User quota (limit: $LIMIT kbytes)"
1668         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1669         quota_show_check b u $TSTUSR
1670         echo "  Updating quota limits"
1671         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $MOUNT
1672         quota_show_check b u $TSTUSR
1673
1674         RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
1675         $RUNDD count=$BUNIT_SZ || quota_error u $TSTUSR "(usr) write failure, but expect success"
1676         # for now page cache of TESTFILE may still be dirty,
1677         # let's push it to the corresponding OST, this will also
1678         # cache NOQUOTA on the client from OST's reply
1679         cancel_lru_locks osc
1680         $RUNDD seek=$BUNIT_SZ && quota_error u $TSTUSR "(usr) write success, should be EDQUOT"
1681 }
1682
1683 test_19() {
1684         # 1 Mb bunit per each MDS/OSS
1685         local TESTFILE="$DIR/$tdir/$tfile"
1686         mkdir -p $DIR/$tdir
1687
1688         run_to_block_limit $TESTFILE
1689         $SHOW_QUOTA_USER
1690
1691         # cleanup
1692         rm -f $TESTFILE
1693         resetquota -u $TSTUSR
1694
1695         set_blk_unitsz $((128 * 1024))
1696         set_blk_tunesz $((128 * 1024 / 2))
1697
1698 }
1699 run_test_with_stat 19 "test if administrative limits updates do not zero operational limits (14790) ==="
1700
1701 test_20()
1702 {
1703         LSTR=(1t 2g 3m 4k) # limits strings
1704         LVAL=($[1*1024*1024*1024] $[2*1024*1024] $[3*1024*1024] $[4*1024]) # limits values
1705
1706         $LFS setquota -u $TSTUSR --block-softlimit ${LSTR[0]} \
1707                                  $MOUNT || error "could not set quota limits"
1708
1709         $LFS setquota -u $TSTUSR --block-hardlimit ${LSTR[1]} \
1710                                  --inode-softlimit ${LSTR[2]} \
1711                                  --inode-hardlimit ${LSTR[3]} \
1712                                  $MOUNT || error "could not set quota limits"
1713
1714         [ "`getquota -u $TSTUSR global bsoftlimit`" = "${LVAL[0]}" ] || error "bsoftlimit was not set properly"
1715         [ "`getquota -u $TSTUSR global bhardlimit`" = "${LVAL[1]}" ] || error "bhardlimit was not set properly"
1716         [ "`getquota -u $TSTUSR global isoftlimit`" = "${LVAL[2]}" ] || error "isoftlimit was not set properly"
1717         [ "`getquota -u $TSTUSR global ihardlimit`" = "${LVAL[3]}" ] || error "ihardlimit was not set properly"
1718
1719         resetquota -u $TSTUSR
1720 }
1721 run_test_with_stat 20 "test if setquota specifiers work properly (15754)"
1722
1723 test_21_sub() {
1724         local testfile=$1
1725         local blk_number=$2
1726         local seconds=$3
1727
1728         time=$(($(date +%s) + seconds))
1729         while [ $(date +%s) -lt $time ]; do
1730             $RUNAS dd if=/dev/zero of=$testfile  bs=$BLK_SZ count=$blk_number > /dev/null 2>&1
1731             rm -f $testfile
1732         done
1733 }
1734
1735 # run for fixing bug16053, setquota shouldn't fail when writing and
1736 # deleting are happening
1737 test_21() {
1738         set_blk_tunesz 512
1739         set_blk_unitsz 1024
1740
1741         wait_delete_completed
1742
1743         TESTFILE="$DIR/$tdir/$tfile"
1744
1745         BLK_LIMIT=$((10 * 1024 * 1024)) # 10G
1746         FILE_LIMIT=1000000
1747
1748         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
1749         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $MOUNT
1750         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
1751         $LFS setquota -g $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I $FILE_LIMIT $MOUNT
1752
1753         # repeat writing on a 1M file
1754         test_21_sub ${TESTFILE}_1 1024 30 &
1755         DDPID1=$!
1756         # repeat writing on a 128M file
1757         test_21_sub ${TESTFILE}_2 $((1024 * 128)) 30 &
1758         DDPID2=$!
1759
1760         time=$(($(date +%s) + 30))
1761         i=1
1762         while [ $(date +%s) -lt $time ]; do
1763             log "  Set quota for $i times"
1764             $LFS setquota -u $TSTUSR -b 0 -B $((BLK_LIMIT + 1024 * i)) -i 0 -I $((FILE_LIMIT + i)) $MOUNT
1765             $LFS setquota -g $TSTUSR -b 0 -B $((BLK_LIMIT + 1024 * i)) -i 0 -I $((FILE_LIMIT + i)) $MOUNT
1766             i=$((i+1))
1767             sleep 1
1768         done
1769
1770         count=0
1771         while [ true ]; do
1772             if ! ps -p ${DDPID1} > /dev/null 2>&1; then break; fi
1773             count=$[count+1]
1774             if [ $count -gt 60 ]; then
1775                 quota_error a $TSTUSR "dd should be finished!"
1776             fi
1777             sleep 1
1778         done
1779         echo "(dd_pid=$DDPID1, time=$count)successful"
1780
1781         count=0
1782         while [ true ]; do
1783             if ! ps -p ${DDPID2} > /dev/null 2>&1; then break; fi
1784             count=$[count+1]
1785             if [ $count -gt 60 ]; then
1786                 quota_error a $TSTUSR "dd should be finished!"
1787             fi
1788             sleep 1
1789         done
1790         echo "(dd_pid=$DDPID2, time=$count)successful"
1791
1792         set_blk_unitsz $((128 * 1024))
1793         set_blk_tunesz $((128 * 1024 / 2))
1794         resetquota -u $TSTUSR
1795         resetquota -g $TSTUSR
1796
1797         return $RC
1798 }
1799 run_test_with_stat 21 "run for fixing bug16053 ==========="
1800
1801 test_22() {
1802         quota_save_version "ug3"
1803
1804         stopall
1805         mount
1806         setupall
1807
1808         echo "checking parameters"
1809
1810         do_facet $SINGLEMDS "lctl get_param mdd.${FSNAME}-MDT*.quota_type" | grep "ug3" || error "admin failure"
1811         do_facet ost1 "lctl get_param obdfilter.*.quota_type" | grep "ug3" || error "op failure"
1812
1813         quota_init
1814 }
1815 run_test_with_stat 22 "test if quota_type saved as permanent parameter ===="
1816
1817 test_23_sub() {
1818         mkdir -p $DIR/$tdir
1819         chmod 0777 $DIR/$tdir
1820         TESTFILE="$DIR/$tdir/$tfile-0"
1821         rm -f $TESTFILE
1822         local bs_unit=$((1024*1024))
1823         LIMIT=$1
1824
1825         wait_delete_completed
1826
1827         # test for user
1828         log "  User quota (limit: $LIMIT kbytes)"
1829         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
1830         sleep 3
1831         quota_show_check b u $TSTUSR
1832
1833         $LFS setstripe $TESTFILE -c 1
1834         chown $TSTUSR.$TSTUSR $TESTFILE
1835
1836         log "    Step1: trigger quota with 0_DIRECT"
1837         log "      Write half of file"
1838         $RUNAS $DIRECTIO write $TESTFILE 0 $(($LIMIT/1024/2)) $bs_unit || \
1839                 quota_error u $TSTUSR "(1) write failure, but expect success: $LIMIT"
1840         log "      Write out of block quota ..."
1841         $RUNAS $DIRECTIO write $TESTFILE $(($LIMIT/1024/2)) $(($LIMIT/1024/2)) $bs_unit && \
1842                 quota_error u $TSTUSR "(2) write success, but expect EDQUOT: $LIMIT"
1843         log "    Step1: done"
1844
1845         log "    Step2: rewrite should succeed"
1846         $RUNAS $DIRECTIO write $TESTFILE 0 1 $bs_unit || \
1847                 quota_error u $TSTUSR "(3) write failure, but expect success: $LIMIT"
1848         log "    Step2: done"
1849
1850         rm -f $TESTFILE
1851         wait_delete_completed
1852         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
1853         OST0_QUOTA_USED=`getquota -u $TSTUSR $OST0_UUID curspace`
1854         echo $OST0_QUOTA_USED
1855         [ $OST0_QUOTA_USED -ne 0 ] && \
1856             ($SHOW_QUOTA_USER; quota_error u $TSTUSR "quota deleted isn't released")
1857         $SHOW_QUOTA_USER
1858         resetquota -u $TSTUSR
1859 }
1860
1861 test_23() {
1862         log "run for $((OSTCOUNT * 4))MB test file"
1863         test_23_sub $((OSTCOUNT * 4 * 1024))
1864
1865         OST0_MIN=120000
1866         check_whether_skip && return 0
1867         log "run for $((OSTCOUNT * 40))MB test file"
1868         test_23_sub $((OSTCOUNT * 40 * 1024))
1869 }
1870 run_test_with_stat 23 "run for fixing bug16125 ==========="
1871
1872 test_24() {
1873         local TESTFILE="$DIR/$tdir/$tfile"
1874         mkdir -p $DIR/$tdir
1875
1876         run_to_block_limit $TESTFILE
1877         $SHOW_QUOTA_USER | grep '*' || error "no matching *"
1878
1879         # cleanup
1880         rm -f $TESTFILE
1881         resetquota -u $TSTUSR
1882
1883         set_blk_unitsz $((128 * 1024))
1884         set_blk_tunesz $((128 * 1024 / 2))
1885
1886 }
1887 run_test_with_stat 24 "test if lfs draws an asterix when limit is reached (16646) ==========="
1888
1889 show_quota() {
1890         if [ $1 = "-u" ]; then
1891                 if [ $2 = "$TSTUSR" ]; then
1892                         $SHOW_QUOTA_USER
1893                 else
1894                         $SHOW_QUOTA_USER2
1895                 fi
1896         else
1897                 if [ $2 = "$TSTUSR" ]; then
1898                         $SHOW_QUOTA_GROUP
1899                 else
1900                         $SHOW_QUOTA_GROUP2
1901                 fi
1902         fi
1903 }
1904
1905 test_25_sub() {
1906         mkdir -p $DIR/$tdir
1907         chmod 0777 $DIR/$tdir
1908         TESTFILE="$DIR/$tdir/$tfile-0"
1909         rm -f $TESTFILE
1910         LIMIT=$(( $BUNIT_SZ * ($OSTCOUNT + 1) + 4096 ))
1911
1912         wait_delete_completed
1913
1914         # set quota for $TSTUSR
1915         log "setquota for $TSTUSR"
1916         $LFS setquota $1 $TSTUSR -b $LIMIT -B $LIMIT -i 10 -I 10 $DIR
1917         sleep 3
1918         if [ "$1" == "-u" ]; then
1919                 quota_show_check a u $TSTUSR
1920         else
1921                 quota_show_check a g $TSTUSR
1922         fi
1923
1924         # set quota for $TSTUSR2
1925         log "setquota for $TSTUSR2"
1926         $LFS setquota $1 $TSTUSR2 -b $LIMIT -B $LIMIT -i 10 -I 10 $DIR
1927         sleep 3
1928         if [ "$1" == "-u" ]; then
1929                 quota_show_check a u $TSTUSR2
1930         else
1931                 quota_show_check a g $TSTUSR2
1932         fi
1933
1934         # set stripe index to 0
1935         log "setstripe for $DIR/$tdir to 0"
1936         $LFS setstripe $DIR/$tdir -c 1 -i 0
1937         MDS_UUID=`do_facet $SINGLEMDS $LCTL dl | grep -m1 " mdt " | awk '{print $((NF-1))}'`
1938         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
1939         MDS_QUOTA_USED_OLD=`getquota $1 $TSTUSR $MDS_UUID curinodes`
1940         OST0_QUOTA_USED_OLD=`getquota $1 $TSTUSR $OST0_UUID curspace`
1941         MDS_QUOTA_USED2_OLD=`getquota $1 $TSTUSR2 $MDS_UUID curinodes`
1942         OST0_QUOTA_USED2_OLD=`getquota $1 $TSTUSR2 $OST0_UUID curspace`
1943
1944         # TSTUSR write 4M
1945         log "$TSTUSR write 4M to $TESTFILE"
1946         $RUNAS dd if=/dev/zero of=$TESTFILE bs=4K count=1K || quota_error a $TSTUSR "dd failed"
1947         sync
1948         show_quota $1 $TSTUSR
1949         show_quota $1 $TSTUSR2
1950         MDS_QUOTA_USED_NEW=`getquota  $1 $TSTUSR $MDS_UUID curinodes`
1951         [ $MDS_QUOTA_USED_NEW -ne $((MDS_QUOTA_USED_OLD + 1)) ] && \
1952                 quota_error a $TSTUSR "$TSTUSR inode quota usage error: [$MDS_QUOTA_USED_OLD|$MDS_QUOTA_USED_NEW]"
1953         OST0_QUOTA_USED_NEW=`getquota   $1 $TSTUSR $OST0_UUID curspace`
1954         OST0_QUOTA_USED_DELTA=$((OST0_QUOTA_USED_NEW - OST0_QUOTA_USED_OLD))
1955         [ $OST0_QUOTA_USED_DELTA -lt 4096 ] && \
1956                 quota_error a $TSTUSR "$TSTUSR block quota usage error: [$OST0_QUOTA_USED_OLD|$OST0_QUOTA_USED_NEW]"
1957
1958         # chown/chgrp from $TSTUSR to $TSTUSR2
1959         if [ $1 = "-u" ]; then
1960                 log "chown from $TSTUSR to $TSTUSR2"
1961                 chown $TSTUSR2 $TESTFILE || quota_error u $TSTUSR2 "chown failed"
1962         else
1963                 log "chgrp from $TSTUSR to $TSTUSR2"
1964                 chgrp $TSTUSR2 $TESTFILE || quota_error g $TSTUSR2 "chgrp failed"
1965         fi
1966         sync
1967         show_quota $1 $TSTUSR
1968         show_quota $1 $TSTUSR2
1969         MDS_QUOTA_USED2_NEW=`getquota $1 $TSTUSR2 $MDS_UUID curinodes`
1970         [ $MDS_QUOTA_USED2_NEW -ne $((MDS_QUOTA_USED2_OLD + 1)) ] && \
1971                 quota_error a $TSTUSR2 "$TSTUSR2 inode quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$MDS_QUOTA_USED2_OLD|$MDS_QUOTA_USED2_NEW]"
1972         OST0_QUOTA_USED2_NEW=`getquota  $1 $TSTUSR2 $OST0_UUID curspace`
1973         # when chown, the quota on ost could be displayed out of quota temporarily. Delete the '*' in this situation. b=20433
1974         OST0_QUOTA_USED2_NEW=${OST0_QUOTA_USED2_NEW%\*}
1975         OST0_QUOTA_USED2_DELTA=$((OST0_QUOTA_USED2_NEW - OST0_QUOTA_USED2_OLD))
1976         [ $OST0_QUOTA_USED2_DELTA -ne $OST0_QUOTA_USED_DELTA ] && \
1977                 quota_error a $TSTUSR2 "$TSTUSR2 block quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$OST0_QUOTA_USED2_OLD|$OST0_QUOTA_USED2_NEW]"
1978         MDS_QUOTA_USED_NEW=`getquota  $1 $TSTUSR $MDS_UUID curinodes`
1979         [ $MDS_QUOTA_USED_NEW -ne $MDS_QUOTA_USED_OLD ] && \
1980                 quota_error a $TSTUSR "$TSTUSR inode quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$MDS_QUOTA_USED_OLD|$MDS_QUOTA_USED_NEW]"
1981         OST0_QUOTA_USED_NEW=`getquota  $1 $TSTUSR $OST0_UUID curspace`
1982         [ $OST0_QUOTA_USED_NEW -ne $OST0_QUOTA_USED_OLD ] && \
1983                 quota_error a $TSTUSR "$TSTUSR block quota usage transfer from $TSTUSR to $TSTUSR2 failed: [$OST0_QUOTA_USED_OLD|$OST0_QUOTA_USED_NEW]"
1984
1985         rm -f $TESTFILE
1986         wait_delete_completed
1987         resetquota $1 $TSTUSR
1988         resetquota $1 $TSTUSR2
1989 }
1990
1991 test_25() {
1992         log "run for chown case"
1993         test_25_sub -u
1994
1995         log "run for chgrp case"
1996         test_25_sub -g
1997 }
1998 run_test_with_stat 25 "test whether quota usage is transfered when chown/chgrp (18081) ==========="
1999
2000 test_26() {
2001         mkdir -p $DIR/$tdir
2002         chmod 0777 $DIR/$tdir
2003         TESTFILE="$DIR/$tdir/$tfile-0"
2004         TESTFILE2="$DIR/$tdir/$tfile-1"
2005         set_blk_tunesz 512
2006         set_blk_unitsz 1024
2007
2008         wait_delete_completed
2009
2010         # every quota slave gets 20MB
2011         b_limit=$(((OSTCOUNT + 1) * 20 * 1024))
2012         log "limit: ${b_limit}KB"
2013         $LFS setquota -u $TSTUSR -b 0 -B $b_limit -i 0 -I 0 $DIR
2014         sleep 3
2015         quota_show_check b u $TSTUSR
2016
2017         $LFS setstripe $TESTFILE  -c 1 -i 0
2018         $LFS setstripe $TESTFILE2 -c 1 -i 0
2019         chown $TSTUSR.$TSTUSR $TESTFILE
2020         chown $TSTUSR.$TSTUSR $TESTFILE2
2021
2022         #define OBD_FAIL_QUOTA_DELAY_REL         0xA03
2023         lustre_fail ost 0xA03
2024
2025         log "    Write the first file..."
2026         $RUNAS $DIRECTIO write $TESTFILE 0 10 $((BLK_SZ * 1024)) || quota_error u $TSTUSR "write failure, but expect success"
2027         log "    Delete the first file..."
2028         rm -f $TESTFILE
2029
2030
2031         wait_delete_completed
2032
2033         log "    Write the second file..."
2034         $RUNAS $DIRECTIO write $TESTFILE2 0 10 $((BLK_SZ * 1024)) || quota_error u $TSTUSR "write failure, but expect success"
2035         log "    Delete the second file..."
2036         rm -f $TESTFILE2
2037
2038         lustre_fail ost 0
2039         set_blk_unitsz $((128 * 1024))
2040         set_blk_tunesz $((128 * 1024 / 2))
2041         resetquota -u $TSTUSR
2042 }
2043 run_test_with_stat 26 "test for false quota error(bz18491) ======================================"
2044
2045 test_27a() {
2046         $LFS quota $TSTUSR $DIR && error "lfs succeeded with no type, but should have failed"
2047         $LFS setquota $TSTUSR $DIR && error "lfs succeeded with no type, but should have failed"
2048         return 0
2049 }
2050 run_test_with_stat 27a "lfs quota/setquota should handle wrong arguments (19612) ================="
2051
2052 test_27b() {
2053         $LFS setquota -u $TSTID -b 1000 -B 1000 -i 1000 -I 1000 $DIR || \
2054                 error "lfs setquota failed with uid argument"
2055         $LFS setquota -g $TSTID -b 1000 -B 1000 -i 1000 -I 1000 $DIR || \
2056                 error "lfs stequota failed with gid argument"
2057         $SHOW_QUOTA_USERID || error "lfs quota failed with uid argument"
2058         $SHOW_QUOTA_GROUPID || error "lfs quota failed with gid argument"
2059         resetquota -u $TSTUSR
2060         resetquota -g $TSTUSR
2061         return 0
2062 }
2063 run_test 27b "lfs quota/setquota should handle user/group ID (20200) ================="
2064
2065 test_28() {
2066         BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
2067         echo "Step 1: set enough high limit for user [$TSTUSR:$BLK_LIMIT]"
2068         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
2069         $SHOW_QUOTA_USER
2070
2071         echo "Step 2: reset system ..."
2072         cleanup_and_setup_lustre
2073         quota_init
2074
2075         echo "Step 3: change qunit for user [$TSTUSR:512:1024]"
2076         set_blk_tunesz 512
2077         set_blk_unitsz 1024
2078
2079         wait_delete_completed
2080
2081         #define OBD_FAIL_QUOTA_RET_QDATA | OBD_FAIL_ONCE
2082         lustre_fail ost 0x80000A02
2083
2084         TESTFILE="$DIR/$tdir/$tfile"
2085         mkdir -p $DIR/$tdir
2086
2087         BLK_LIMIT=$((100 * 1024)) # 100M
2088         echo "Step 4: set enough high limit for user [$TSTUSR:$BLK_LIMIT]"
2089         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR
2090         $SHOW_QUOTA_USER
2091
2092         touch $TESTFILE
2093         chown $TSTUSR.$TSTUSR $TESTFILE
2094
2095         echo "Step 5: write the test file1 [10M] ..."
2096         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$(( 10 * 1024 )) \
2097             || quota_error a $TSTUSR "write 10M file failure"
2098         $SHOW_QUOTA_USER
2099
2100         rm -f $TESTFILE
2101         sync; sleep 3; sync;
2102
2103         # make qd_count 64 bit
2104         lustre_fail ost 0
2105
2106         set_blk_unitsz $((128 * 1024))
2107         set_blk_tunesz $((128 * 1024 / 2))
2108
2109         resetquota -u $TSTUSR
2110 }
2111 run_test_with_stat 28 "test for consistency for qunit when setquota (18574) ==========="
2112
2113 test_29()
2114 {
2115         local BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
2116         local timeout
2117         local pid
2118
2119         if at_is_enabled; then
2120                 timeout=$(at_max_get client)
2121                 at_max_set 10 client
2122         else
2123                 timeout=$(lctl get_param -n timeout)
2124                 lctl set_param timeout=10
2125         fi
2126
2127         #define OBD_FAIL_MDS_QUOTACTL_NET 0x12e
2128         lustre_fail mds 0x12e
2129
2130         $LFS setquota -u $TSTUSR -b 0 -B $BLK_LIMIT -i 0 -I 0 $DIR & pid=$!
2131
2132         echo "sleeping for $((10 * 2)) seconds"
2133         sleep $((10 * 2))
2134         ps -p $pid && error "lfs hadn't finished by timeout"
2135         wait $pid && error "succeeded, but should have failed"
2136
2137         lustre_fail mds 0
2138
2139         if at_is_enabled; then
2140                 at_max_set $timeout client
2141         else
2142                 lctl set_param timeout=$timeout
2143         fi
2144
2145         resetquota -u $TSTUSR
2146 }
2147 run_test_with_stat 29 "unhandled quotactls must not hang lustre client (19778) ========"
2148
2149 test_30()
2150 {
2151         local output
2152         local LIMIT=1024
2153         local TESTFILE="$DIR/$tdir/$tfile"
2154         local GRACE=10
2155
2156         set_blk_tunesz 512
2157         set_blk_unitsz 1024
2158
2159         mkdir -p $DIR/$tdir
2160         chmod 0777 $DIR/$tdir
2161
2162         $LFS setstripe $TESTFILE -i 0 -c 1
2163         chown $TSTUSR.$TSTUSR $TESTFILE
2164
2165         $LFS setquota -t -u --block-grace $GRACE --inode-grace $MAX_IQ_TIME $DIR
2166         $LFS setquota -u $TSTUSR -b $LIMIT -B 0 -i 0 -I 0 $DIR
2167         $RUNAS dd if=/dev/zero of=$TESTFILE bs=1024 count=$((LIMIT * 2)) || true
2168         cancel_lru_locks osc
2169         sleep $GRACE
2170         $LFS setquota -u $TSTUSR -B 0 $DIR
2171         # over-quota flag has not yet settled since we do not trigger async events
2172         # based on grace time period expiration
2173         $SHOW_QUOTA_USER
2174         $RUNAS dd if=/dev/zero of=$TESTFILE conv=notrunc oflag=append bs=1048576 count=1 || true
2175         cancel_lru_locks osc
2176         # now over-quota flag should be settled and further writes should fail
2177         $SHOW_QUOTA_USER
2178         $RUNAS dd if=/dev/zero of=$TESTFILE conv=notrunc oflag=append bs=1048576 count=1 && error "grace times were reset"
2179         rm -f $TESTFILE
2180         resetquota -u $TSTUSR
2181         $LFS setquota -t -u --block-grace $MAX_DQ_TIME --inode-grace $MAX_IQ_TIME $DIR
2182
2183         set_blk_unitsz $((128 * 1024))
2184         set_blk_tunesz $((128 * 1024 / 2))
2185 }
2186 run_test_with_stat 30 "hard limit updates should not reset grace times ================"
2187
2188 # test duplicate quota releases b=18630
2189 test_31() {
2190         mkdir -p $DIR/$tdir
2191         chmod 0777 $DIR/$tdir
2192
2193         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
2194         TESTFILE="$DIR/$tdir/$tfile-0"
2195         TESTFILE2="$DIR/$tdir/$tfile-1"
2196
2197         wait_delete_completed
2198
2199         log "   User quota (limit: $LIMIT kbytes)"
2200         $LFS setquota -u $TSTUSR -b 0 -B $LIMIT -i 0 -I 0 $DIR
2201
2202         $LFS setstripe $TESTFILE -i 0 -c 1
2203         chown $TSTUSR.$TSTUSR $TESTFILE
2204         $LFS setstripe $TESTFILE2 -i 0 -c 1
2205         chown $TSTUSR.$TSTUSR $TESTFILE2
2206
2207         log "   step1: write out of block quota ..."
2208         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=5120
2209         $RUNAS dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=5120
2210
2211         #define OBD_FAIL_QUOTA_DELAY_SD      0xA04
2212         #define OBD_FAIL_SOME        0x10000000 /* fail N times */
2213         lustre_fail ost $((0x00000A04 | 0x10000000)) 1
2214
2215         log "   step2: delete two files so that triggering duplicate quota release ..."
2216         rm -f $TESTFILE $TESTFILE2
2217         sync; sleep 5; sync      #  OBD_FAIL_QUOTA_DELAY_SD will delay for 5 seconds
2218         wait_delete_completed
2219
2220         log "   step3: verify if the ost failed"
2221         do_facet ost1 dmesg > $TMP/lustre-log-${TESTNAME}.log
2222         watchdog=`awk '/test 31/ {start = 1;}
2223                        /release quota error/ {
2224                                if (start) {
2225                                        print;
2226                                }
2227                        }' $TMP/lustre-log-${TESTNAME}.log`
2228         [ "$watchdog" ] && error "$watchdog"
2229         rm -f $TMP/lustre-log-${TESTNAME}.log
2230
2231         lustre_fail ost 0
2232         resetquota -u $TSTUSR
2233 }
2234 run_test_with_stat 31 "test duplicate quota releases ==="
2235
2236 # check hash_cur_bits
2237 check_quota_hash_cur_bits() {
2238         local bits=$1
2239
2240         # check quota_hash_cur_bits on all obdfilters
2241         for num in `seq $OSTCOUNT`; do
2242             cb=`do_facet ost$num "cat /sys/module/lquota/parameters/hash_lqs_cur_bits"`
2243             if [ $cb -gt $bits ]; then
2244                 echo "hash_lqs_cur_bits of ost$num is too large(cur_bits=$cb)"
2245                 return 1;
2246             fi
2247         done
2248         # check quota_hash_cur_bits on mds
2249         cb=`do_facet $SINGLEMDS "cat /sys/module/lquota/parameters/hash_lqs_cur_bits"`
2250         if [ $cb -gt $bits ]; then
2251             echo "hash_lqs_cur_bits of mds is too large(cur_bits=$cb)"
2252             return 1;
2253         fi
2254         return 0;
2255 }
2256
2257 # check lqs hash
2258 check_lqs_hash() {
2259         # check distribution of all obdfilters
2260         for num in `seq $OSTCOUNT`; do
2261             do_facet ost$num "lctl get_param obdfilter.${FSNAME}-OST*.hash_stats | grep LQS_HASH" | while read line; do
2262                 rehash_count=`echo $line | awk '{print $9}'`
2263                 if [ $rehash_count -eq 0 ]; then
2264                     echo -e "ost$num:\n $line"
2265                     error "Rehearsh didn't happen"
2266                 fi
2267             done
2268         done
2269         # check distribution of mds
2270         do_facet $SINGLEMDS "lctl get_param mdt.${FSNAME}-MDT*.hash_stats | grep LQS_HASH" | while read line; do
2271             rehash_count=`echo $line | awk '{print $9}'`
2272             if [ $rehash_count -eq 0 ]; then
2273                 echo -e "mdt:\n $line"
2274                 error "Rehearsh didn't happen"
2275             fi
2276         done
2277 }
2278
2279 test_32()
2280 {
2281         # reset system so that quota_hash_cur_bits==3
2282         echo "Reset system ..."
2283         local LMR_orig=$LOAD_MODULES_REMOTE
2284         LOAD_MODULES_REMOTE=true
2285         cleanup_and_setup_lustre
2286         LOAD_MODULES_REMOTE=$LMR_orig
2287
2288         for user in $SANITY_QUOTA_USERS; do
2289             check_runas_id_ret $user quota_usr "runas -u $user -g quota_usr" >/dev/null 2>/dev/null || \
2290                 missing_users="$missing_users $user"
2291         done
2292         [ -n "$missing_users" ] && { skip_env "the following users are missing: $missing_users" ; return 0 ; }
2293         check_quota_hash_cur_bits 3 || { skip_env "hash_lqs_cur_bits isn't set properly"; return 0;}
2294
2295         $LFS quotaoff -ug $DIR
2296         $LFS quotacheck -ug $DIR
2297
2298         for user in $SANITY_QUOTA_USERS; do
2299             $LFS setquota -u $user --block-hardlimit 1048576 $DIR
2300         done
2301
2302         check_lqs_hash
2303
2304         for user in $SANITY_QUOTA_USERS; do
2305             resetquota -u $user
2306         done
2307 }
2308 run_test 32 "check lqs hash(bug 21846) =========================================="
2309
2310 # turn off quota
2311 quota_fini()
2312 {
2313         $LFS quotaoff $DIR
2314         do_nodes $(comma_list $(nodes_list)) "lctl set_param debug=-quota"
2315 }
2316 quota_fini
2317
2318 log "cleanup: ======================================================"
2319 cd $ORIG_PWD
2320 check_and_cleanup_lustre
2321 echo '=========================== finished ==============================='
2322 export QUOTA_AUTO=$QUOTA_AUTO_OLD
2323 [ -f "$QUOTALOG" ] && cat $QUOTALOG && grep -q FAIL $QUOTALOG && exit 1 || true
2324 echo "$0: completed"