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