lustre/tests/sanity-quota.sh

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