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 ALWAYS_EXCEPT="$SANITY_QUOTA_EXCEPT"
  21 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  22
  23 case `uname -r` in
  24 2.6*) FSTYPE=${FSTYPE:-ldiskfs};;
  25 *) error "unsupported kernel" ;;
  26 esac
  27
  28 [ "$ALWAYS_EXCEPT$EXCEPT" ] && \
  29         echo "Skipping tests: `echo $ALWAYS_EXCEPT $EXCEPT`"
  30
  31 TMP=${TMP:-/tmp}
  32
  33 ORIG_PWD=${PWD}
  34 TSTID=${TSTID:-60000}
  35 TSTID2=${TSTID2:-60001}
  36 TSTUSR=${TSTUSR:-"quota_usr"}
  37 TSTUSR2=${TSTUSR2:-"quota_2usr"}
  38 BLK_SZ=1024
  39 BUNIT_SZ=${BUNIT_SZ:-1024}      # min block quota unit(kB)
  40 IUNIT_SZ=${IUNIT_SZ:-10}        # min inode quota unit
  41 MAX_DQ_TIME=604800
  42 MAX_IQ_TIME=604800
  43
  44 TRACE=${TRACE:-""}
  45 LUSTRE=${LUSTRE:-`dirname $0`/..}
  46 . $LUSTRE/tests/test-framework.sh
  47 init_test_env $@
  48 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  49
  50 [ "$SLOW" = "no" ] && EXCEPT_SLOW="9 10 11"
  51
  52 QUOTALOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}
  53
  54 [ "$QUOTALOG" ] && rm -f $QUOTALOG || true
  55
  56 DIR=${DIR:-$MOUNT}
  57 DIR2=${DIR2:-$MOUNT2}
  58
  59 cleanup_and_setup_lustre
  60
  61 LOVNAME=`cat $LPROC/llite/*/lov/common_name | tail -n 1`
  62 OSTCOUNT=`cat $LPROC/lov/$LOVNAME/numobd`
  63
  64 SHOW_QUOTA_USER="$LFS quota -u $TSTUSR $DIR"
  65 SHOW_QUOTA_GROUP="$LFS quota -g $TSTUSR $DIR"
  66 SHOW_QUOTA_INFO="$LFS quota -t $DIR"
  67
  68 # control the time of tests
  69 cycle=30
  70 [ "$SLOW" = "no" ] && cycle=10
  71
  72 build_test_filter
  73
  74 eval ONLY_0=true
  75 eval ONLY_99=true
  76
  77 # set_blk_tunables(btune_sz)
  78 set_blk_tunesz() {
  79         local i
  80         # set btune size on all obdfilters
  81         do_facet ost1 "set -x; for i in /proc/fs/lustre/obdfilter/*/quota_btune_sz; do
  82                 echo $(($1 * BLK_SZ)) >> \\\$i;
  83         done"
  84         # set btune size on mds
  85         do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_btune_sz; do
  86                 echo $(($1 * BLK_SZ)) >> \\\$i;
  87         done"
  88 }
  89
  90 # set_blk_unitsz(bunit_sz)
  91 set_blk_unitsz() {
  92         local i
  93         do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_bunit_sz; do
  94                 echo $(($1 * BLK_SZ)) >> \\\$i;
  95         done"
  96         do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_bunit_sz; do
  97                 echo $(($1 * BLK_SZ)) >> \\\$i;
  98         done"
  99 }
 100
 101 # set_file_tunesz(itune_sz)
 102 set_file_tunesz() {
 103         local i
 104         # set iunit and itune size on all obdfilters
 105         do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_itune_sz; do
 106                 echo $1 >> \\\$i;
 107         done"
 108         # set iunit and itune size on mds
 109         do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_itune_sz; do
 110                 echo $1 >> \\\$i;
 111         done"
 112 }
 113
 114 # set_file_unitsz(iunit_sz)
 115 set_file_unitsz() {
 116         local i
 117         do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_iunit_sz; do
 118                 echo $1 >> \\\$i;
 119         done"
 120         do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_iunit_sz; do
 121                 echo $1 >> \\\$i;
 122         done"
 123 }
 124
 125 lustre_fail() {
 126         local fail_node=$1
 127         local fail_loc=$2
 128
 129         case $fail_node in
 130             "mds" )
 131                 do_facet mds "sysctl -w lustre.fail_loc=$fail_loc" ;;
 132             "ost" )
 133                 for num in `seq $OSTCOUNT`; do
 134                     do_facet ost$num "sysctl -w lustre.fail_loc=$fail_loc"
 135                 done ;;
 136             "mds_ost" )
 137                 do_facet mds "sysctl -w lustre.fail_loc=$fail_loc" ;
 138                 for num in `seq $OSTCOUNT`; do
 139                     do_facet ost$num "sysctl -w lustre.fail_loc=$fail_loc"
 140                 done ;;
 141             * ) echo "usage: lustre_fail fail_node fail_loc" ;
 142                 return 1 ;;
 143         esac
 144 }
 145
 146 RUNAS="runas -u $TSTID"
 147 RUNAS2="runas -u $TSTID2"
 148 FAIL_ON_ERROR=true check_runas_id $TSTID $RUNAS
 149 FAIL_ON_ERROR=true check_runas_id $TSTID2 $RUNAS2
 150
 151 FAIL_ON_ERROR=false
 152
 153 # set quota
 154 test_0() {
 155         $LFS quotaoff -ug $DIR
 156         $LFS quotacheck -ug $DIR
 157
 158         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 159         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 160         sysctl -w lnet.debug="+quota"
 161 }
 162 run_test 0 "Set quota ============================="
 163
 164 # test for specific quota limitation, qunit, qtune $1=block_quota_limit
 165 test_1_sub() {
 166         LIMIT=$1
 167         chmod 0777 $DIR/$tdir
 168         TESTFILE="$DIR/$tdir/$tfile-0"
 169
 170         wait_delete_completed
 171
 172         # test for user
 173         log "  User quota (limit: $LIMIT kbytes)"
 174         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 175         sleep 3
 176         $SHOW_QUOTA_USER
 177
 178         $LFS setstripe $TESTFILE -c 1
 179         chown $TSTUSR.$TSTUSR $TESTFILE
 180
 181         log "    Write ..."
 182         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || error "(usr) write failure, but expect success"
 183         log "    Done"
 184         log "    Write out of block quota ..."
 185         # this time maybe cache write,  ignore it's failure
 186         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
 187         # flush cache, ensure noquota flag is setted on client
 188         sync; sleep 1; sync;
 189         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && error "(usr) write success, but expect EDQUOT"
 190
 191         rm -f $TESTFILE
 192         sync; sleep 1; sync;
 193         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
 194         OST0_QUOTA_USED=`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
 195         echo $OST0_QUOTA_USED
 196         [ $OST0_QUOTA_USED -ne 0 ] && \
 197             ($SHOW_QUOTA_USER; error "quota deleted isn't released")
 198         $SHOW_QUOTA_USER
 199         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
 200
 201         # test for group
 202         log "--------------------------------------"
 203         log "  Group quota (limit: $LIMIT kbytes)"
 204         $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
 205         sleep 3
 206         $SHOW_QUOTA_GROUP
 207         TESTFILE="$DIR/$tdir/$tfile-1"
 208
 209         $LFS setstripe $TESTFILE -c 1
 210         chown $TSTUSR.$TSTUSR $TESTFILE
 211
 212         log "    Write ..."
 213         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || error "(grp) write failure, but expect success"
 214         log "    Done"
 215         log "    Write out of block quota ..."
 216         # this time maybe cache write, ignore it's failure
 217         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
 218         sync; sleep 1; sync;
 219         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && error "(grp) write success, but expect EDQUOT"
 220
 221         # cleanup
 222         rm -f $TESTFILE
 223         sync; sleep 1; sync;
 224         OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
 225         OST0_QUOTA_USED=`$LFS quota -o $OST0_UUID -g $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
 226         echo $OST0_QUOTA_USED
 227         [ $OST0_QUOTA_USED -ne 0 ] && \
 228             ($SHOW_QUOTA_USER; error "quota deleted isn't released")
 229         $SHOW_QUOTA_GROUP
 230         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR           # clear group limit
 231 }
 232
 233 # block hard limit (normal use and out of quota)
 234 test_1() {
 235         for i in `seq 1 $cycle`; do
 236             # define blk_qunit is between 1M and 4M
 237             blk_qunit=$(( $RANDOM % 3072 + 1024 ))
 238             blk_qtune=$(( $RANDOM % $blk_qunit ))
 239             # other osts and mds will occupy at 1M blk quota
 240             b_limit=$(( ($RANDOM - 16384) / 8 +  $OSTCOUNT  * $blk_qunit * 4 ))
 241             set_blk_tunesz $blk_qtune
 242             set_blk_unitsz $blk_qunit
 243             echo "cycle: $i(total $cycle) bunit:$blk_qunit, btune:$blk_qtune, blimit:$b_limit"
 244             test_1_sub $b_limit
 245             echo "=================================================="
 246             set_blk_unitsz $((128 * 1024))
 247             set_blk_tunesz $((128 * 1024 / 2))
 248         done
 249 }
 250 run_test 1 "Block hard limit (normal use and out of quota) ==="
 251
 252 # test for specific quota limitation, qunit, qtune $1=block_quota_limit
 253 test_2_sub() {
 254         LIMIT=$1
 255         chmod 0777 $DIR/$tdir
 256         TESTFILE="$DIR/$tdir/$tfile-0"
 257
 258         wait_delete_completed
 259
 260         # test for user
 261         log "  User quota (limit: $LIMIT files)"
 262         $LFS setquota -u $TSTUSR 0 0 0 $LIMIT $DIR
 263         sleep 3
 264         $SHOW_QUOTA_USER
 265
 266         log "    Create $LIMIT files ..."
 267         $RUNAS createmany -m ${TESTFILE} $LIMIT || \
 268                 error "(usr) create failure, but except success"
 269         log "    Done"
 270         log "    Create out of file quota ..."
 271         $RUNAS touch ${TESTFILE}_xxx && \
 272                 error "(usr) touch success, but expect EDQUOT"
 273
 274         unlinkmany ${TESTFILE} $LIMIT
 275         rm -f ${TESTFILE}_xxx
 276         sync; sleep 1; sync;
 277
 278         MDS_UUID=`do_facet mds $LCTL dl | grep -m1 mds | awk '{print $((NF-1))}'`
 279         MDS_QUOTA_USED=`$LFS quota -o $MDS_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
 280         echo $MDS_QUOTA_USED
 281         [ $MDS_QUOTA_USED -ne 0 ] && \
 282             ($SHOW_QUOTA_USER; error "quota deleted isn't released")
 283         $SHOW_QUOTA_USER
 284         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
 285
 286         # test for group
 287         log "--------------------------------------"
 288         log "  Group quota (limit: $LIMIT FILE)"
 289         $LFS setquota -g $TSTUSR 0 0 0 $LIMIT $DIR
 290         sleep 3
 291         $SHOW_QUOTA_GROUP
 292         TESTFILE=$DIR/$tdir/$tfile-1
 293
 294         log "    Create $LIMIT files ..."
 295         $RUNAS createmany -m ${TESTFILE} $LIMIT || \
 296                 error "(usr) create failure, but except success"
 297         log "    Done"
 298         log "    Create out of file quota ..."
 299         $RUNAS touch ${TESTFILE}_xxx && \
 300                 error "(usr) touch success, but expect EDQUOT"
 301
 302         unlinkmany ${TESTFILE} $LIMIT
 303         rm -f ${TESTFILE}_xxx
 304         sync; sleep 1; sync;
 305
 306         MDS_UUID=`do_facet mds $LCTL dl | grep -m1 mds | awk '{print $((NF-1))}'`
 307         MDS_QUOTA_USED=`$LFS quota -o $MDS_UUID -g $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
 308         echo $MDS_QUOTA_USED
 309         [ $MDS_QUOTA_USED -ne 0 ] && \
 310             ($SHOW_QUOTA_USER; error "quota deleted isn't released")
 311         $SHOW_QUOTA_GROUP
 312         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR           # clear user limit
 313 }
 314
 315 # file hard limit (normal use and out of quota)
 316 test_2() {
 317         for i in `seq 1 $cycle`; do
 318             # define ino_qunit is between 10 and 100
 319             ino_qunit=$(( $RANDOM % 90 + 10 ))
 320             ino_qtune=$(( $RANDOM % $ino_qunit ))
 321             # RANDOM's maxium is 32767
 322             i_limit=$(( $RANDOM % 990 + 10 ))
 323             set_file_tunesz $ino_qtune
 324             set_file_unitsz $ino_qunit
 325             echo "cycle: $i(total $cycle) iunit:$ino_qunit, itune:$ino_qtune, ilimit:$i_limit"
 326             test_2_sub $i_limit
 327             echo "=================================================="
 328             set_file_unitsz 5120
 329             set_file_tunesz 2560
 330         done
 331 }
 332 run_test 2 "File hard limit (normal use and out of quota) ==="
 333
 334 test_block_soft() {
 335         TESTFILE=$1
 336         TIMER=$(($2 * 3 / 2))
 337         OFFSET=0
 338
 339         wait_delete_completed
 340
 341         echo "    Write to exceed soft limit"
 342         RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
 343         $RUNDD count=$((BUNIT_SZ+1)) || \
 344                 error "write failure, but expect success"
 345         OFFSET=$((OFFSET + BUNIT_SZ + 1))
 346         sync; sleep 1; sync;
 347
 348         $SHOW_QUOTA_USER
 349         $SHOW_QUOTA_GROUP
 350         $SHOW_QUOTA_INFO
 351
 352         echo "    Write before timer goes off"
 353         $RUNDD count=$BUNIT_SZ seek=$OFFSET || \
 354                 error "write failure, but expect success"
 355         OFFSET=$((OFFSET + BUNIT_SZ))
 356         sync; sleep 1; sync;
 357         echo "    Done"
 358
 359         echo "    Sleep $TIMER seconds ..."
 360         sleep $TIMER
 361
 362         $SHOW_QUOTA_USER
 363         $SHOW_QUOTA_GROUP
 364         $SHOW_QUOTA_INFO
 365
 366         echo "    Write after timer goes off"
 367         # maybe cache write, ignore.
 368         sync; sleep 1; sync;
 369         $RUNDD count=$BUNIT_SZ seek=$OFFSET || true
 370         OFFSET=$((OFFSET + BUNIT_SZ))
 371         sync; sleep 1; sync;
 372         $RUNDD count=$BUNIT_SZ seek=$OFFSET && \
 373                 error "write success, but expect EDQUOT"
 374
 375         $SHOW_QUOTA_USER
 376         $SHOW_QUOTA_GROUP
 377         $SHOW_QUOTA_INFO
 378
 379         echo "    Unlink file to stop timer"
 380         rm -f $TESTFILE
 381         sync; sleep 1; sync
 382         echo "    Done"
 383
 384         $SHOW_QUOTA_USER
 385         $SHOW_QUOTA_GROUP
 386         $SHOW_QUOTA_INFO
 387
 388         echo "    Write ..."
 389         $RUNDD count=$BUNIT_SZ || error "write failure, but expect success"
 390         echo "    Done"
 391
 392         # cleanup
 393         rm -f $TESTFILE
 394         sync; sleep 3; sync;
 395 }
 396
 397 # block soft limit (start timer, timer goes off, stop timer)
 398 test_3() {
 399         chmod 0777 $DIR/$tdir
 400
 401         # 1 bunit on mds and 1 bunit on every ost
 402         LIMIT=$(( $BUNIT_SZ * ($OSTCOUNT + 1) ))
 403         GRACE=10
 404
 405         echo "  User quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
 406         TESTFILE=$DIR/$tdir/$tfile-0
 407
 408         $LFS setstripe $TESTFILE -c 1
 409         chown $TSTUSR.$TSTUSR $TESTFILE
 410
 411         $LFS setquota -t -u $GRACE $MAX_IQ_TIME $DIR
 412         $LFS setquota -u $TSTUSR $LIMIT 0 0 0 $DIR
 413
 414         test_block_soft $TESTFILE $GRACE
 415         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 416
 417         echo "  Group quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
 418         TESTFILE=$DIR/$tdir/$tfile-1
 419
 420         $LFS setstripe $TESTFILE -c 1
 421         chown $TSTUSR.$TSTUSR $TESTFILE
 422
 423         $LFS setquota -t -g $GRACE $MAX_IQ_TIME $DIR
 424         $LFS setquota -g $TSTUSR $LIMIT 0 0 0 $DIR
 425
 426         test_block_soft $TESTFILE $GRACE
 427         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 428 }
 429 run_test 3 "Block soft limit (start timer, timer goes off, stop timer) ==="
 430
 431 test_file_soft() {
 432         TESTFILE=$1
 433         LIMIT=$2
 434         TIMER=$(($3 * 3 / 2))
 435
 436         wait_delete_completed
 437
 438         echo "    Create files to exceed soft limit"
 439         $RUNAS createmany -m ${TESTFILE}_ $((LIMIT + 1)) || \
 440                 error "create failure, but expect success"
 441         sync; sleep 1; sync
 442         echo "    Done"
 443
 444         echo "    Create file before timer goes off"
 445         $RUNAS touch ${TESTFILE}_before || \
 446                 error "failed create before timer expired, but expect success"
 447         sync; sleep 1; sync
 448         echo "    Done"
 449
 450         echo "    Sleep $TIMER seconds ..."
 451         sleep $TIMER
 452
 453         $SHOW_QUOTA_USER
 454         $SHOW_QUOTA_GROUP
 455         $SHOW_QUOTA_INFO
 456
 457         echo "    Create file after timer goes off"
 458         $RUNAS touch ${TESTFILE}_after ${TESTFILE}_after1 && \
 459                 error "create after timer expired, but expect EDQUOT"
 460         sync; sleep 1; sync
 461
 462         $SHOW_QUOTA_USER
 463         $SHOW_QUOTA_GROUP
 464         $SHOW_QUOTA_INFO
 465
 466         echo "    Unlink files to stop timer"
 467         find `dirname $TESTFILE` -name "`basename ${TESTFILE}`*" | xargs rm -f
 468         echo "    Done"
 469
 470         echo "    Create file"
 471         $RUNAS touch ${TESTFILE}_xxx || \
 472                 error "touch after timer stop failure, but expect success"
 473         sync; sleep 1; sync
 474         echo "    Done"
 475
 476         # cleanup
 477         rm -f ${TESTFILE}_xxx
 478         sync; sleep 3; sync;
 479 }
 480
 481 # file soft limit (start timer, timer goes off, stop timer)
 482 test_4() {
 483         chmod 0777 $DIR/$tdir
 484         LIMIT=$(($IUNIT_SZ * 10))       # 10 iunits on mds
 485         TESTFILE=$DIR/$tdir/$tfile-0
 486
 487         GRACE=5
 488
 489         echo "  User quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 490         $LFS setquota -t -u $MAX_DQ_TIME $GRACE $DIR
 491         $LFS setquota -u $TSTUSR 0 0 $LIMIT 0 $DIR
 492         $SHOW_QUOTA_USER
 493
 494         test_file_soft $TESTFILE $LIMIT $GRACE
 495         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 496
 497         echo "  Group quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 498         $LFS setquota -t -g $MAX_DQ_TIME $GRACE $DIR
 499         $LFS setquota -g $TSTUSR 0 0 $LIMIT 0 $DIR
 500         $SHOW_QUOTA_GROUP
 501         TESTFILE=$DIR/$tdir/$tfile-1
 502
 503         test_file_soft $TESTFILE $LIMIT $GRACE
 504         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 505
 506         # cleanup
 507         $LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 508         $LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 509 }
 510 run_test 4 "File soft limit (start timer, timer goes off, stop timer) ==="
 511
 512 test_4a() {
 513         GR_STR1="1w3d"
 514         GR_STR2="1000s"
 515         GR_STR3="5s"
 516         GR_STR4="1w2d3h4m5s"
 517         GR_STR5="5c"
 518         GR_STR6="1111111111111111"
 519
 520         wait_delete_completed
 521
 522         # test of valid grace strings handling
 523         echo "  Valid grace strings test"
 524         $LFS setquota -t -u $GR_STR1 $GR_STR2 $DIR
 525         $LFS quota -u -t $DIR | grep "Block grace time: $GR_STR1"
 526         $LFS setquota -t -g $GR_STR3 $GR_STR4 $DIR
 527         $LFS quota -g -t $DIR | grep "Inode grace time: $GR_STR4"
 528
 529         # test of invalid grace strings handling
 530         echo "  Invalid grace strings test"
 531         ! $LFS setquota -t -u $GR_STR4 $GR_STR5 $DIR
 532         ! $LFS setquota -t -g $GR_STR4 $GR_STR6 $DIR
 533
 534         # cleanup
 535         $LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 536         $LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 537 }
 538 run_test 4a "Grace time strings handling ==="
 539
 540 # chown & chgrp (chown & chgrp successfully even out of block/file quota)
 541 test_5() {
 542         BLIMIT=$(( $BUNIT_SZ * $((OSTCOUNT + 1)) * 10)) # 10 bunits on each server
 543         ILIMIT=$(( $IUNIT_SZ * 10 )) # 10 iunits on mds
 544
 545         wait_delete_completed
 546
 547         echo "  Set quota limit (0 $BLIMIT 0 $ILIMIT) for $TSTUSR.$TSTUSR"
 548         $LFS setquota -u $TSTUSR 0 $BLIMIT 0 $ILIMIT $DIR
 549         $LFS setquota -g $TSTUSR 0 $BLIMIT 0 $ILIMIT $DIR
 550         $SHOW_QUOTA_USER
 551         $SHOW_QUOTA_GROUP
 552
 553         echo "  Create more than $ILIMIT files and more than $BLIMIT kbytes ..."
 554         createmany -m $DIR/$tdir/$tfile-0_ $((ILIMIT + 1)) || \
 555                 error "touch failure, expect success"
 556         dd if=/dev/zero of=$DIR/$tdir/$tfile-0_1 bs=$BLK_SZ count=$((BLIMIT+1)) || error "write failure, expect success"
 557
 558         echo "  Chown files to $TSTUSR.$TSTUSR ..."
 559         for i in `seq 0 $ILIMIT`; do
 560         chown $TSTUSR.$TSTUSR $DIR/$tdir/$tfile-0_$i || \
 561                         error "chown failure, but expect success"
 562         done
 563
 564         # cleanup
 565         unlinkmany $DIR/$tdir/$tfile-0_ $((ILIMIT + 1))
 566         sync; sleep 3; sync;
 567
 568         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 569         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 570 }
 571 run_test 5 "Chown & chgrp successfully even out of block/file quota ==="
 572
 573 # block quota acquire & release
 574 test_6() {
 575         if [ $OSTCOUNT -lt 2 ]; then
 576                 skip "$OSTCOUNT < 2, too few osts"
 577                 return 0;
 578         fi
 579
 580         wait_delete_completed
 581
 582         chmod 0777 $DIR/$tdir
 583
 584         LIMIT=$((BUNIT_SZ * (OSTCOUNT + 1) * 5)) # 5 bunits per server
 585         FILEA="$DIR/$tdir/$tfile-0_a"
 586         FILEB="$DIR/$tdir/$tfile-0_b"
 587
 588         echo "  Set block limit $LIMIT kbytes to $TSTUSR.$TSTUSR"
 589         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 590         $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
 591         $SHOW_QUOTA_USER
 592         $SHOW_QUOTA_GROUP
 593
 594         echo "  Create filea on OST0 and fileb on OST1"
 595         $LFS setstripe $FILEA -i 0 -c 1
 596         $LFS setstripe $FILEB -i 1 -c 1
 597         chown $TSTUSR.$TSTUSR $FILEA
 598         chown $TSTUSR.$TSTUSR $FILEB
 599
 600         echo "  Exceed quota limit ..."
 601         RUNDD="$RUNAS dd if=/dev/zero of=$FILEB bs=$BLK_SZ"
 602         $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
 603                 error "write fileb failure, but expect success"
 604
 605         sync; sleep 1; sync;
 606         $SHOW_QUOTA_USER
 607         $SHOW_QUOTA_GROUP
 608         $RUNDD seek=$LIMIT count=$((BUNIT_SZ * OSTCOUNT)) && \
 609                 error "write fileb success, but expect EDQUOT"
 610         sync; sleep 1; sync;
 611         echo "  Write to OST0 return EDQUOT"
 612         # this write maybe cache write, ignore it's failure
 613         RUNDD="$RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ"
 614         $RUNDD count=$(($BUNIT_SZ * 2)) || true
 615         sync; sleep 1; sync;
 616         $SHOW_QUOTA_USER
 617         $SHOW_QUOTA_GROUP
 618         $RUNDD count=$((BUNIT_SZ * 2)) seek=$((BUNIT_SZ *2)) && \
 619                 error "write filea success, but expect EDQUOT"
 620
 621         echo "  Remove fileb to let OST1 release quota"
 622         rm -f $FILEB
 623         sync; sleep 10; sync; # need to allow journal commit for small fs
 624
 625         echo "  Write to OST0"
 626         $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
 627                 error "write filea failure, expect success"
 628         echo "  Done"
 629
 630         # cleanup
 631         rm -f $FILEA
 632         sync; sleep 3; sync;
 633
 634         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 635         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 636         return 0
 637 }
 638 run_test 6 "Block quota acquire & release ========="
 639
 640 # quota recovery (block quota only by now)
 641 test_7()
 642 {
 643         chmod 0777 $DIR/$tdir
 644         remote_mds && skip "remote mds" && return 0
 645
 646         wait_delete_completed
 647
 648         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) ))
 649         TESTFILE="$DIR/$tdir/$tfile-0"
 650
 651         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 652
 653         $LFS setstripe $TESTFILE -c 1
 654         chown $TSTUSR.$TSTUSR $TESTFILE
 655
 656         echo "  Write to OST0..."
 657         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ || \
 658                 error "write failure, but expect success"
 659
 660         #define OBD_FAIL_OBD_DQACQ               0x604
 661         lustre_fail mds  0x604
 662         echo "  Remove files on OST0"
 663         rm -f $TESTFILE
 664         lustre_fail mds  0
 665
 666         echo "  Trigger recovery..."
 667         OSC0_UUID="`$LCTL dl | awk '$3 ~ /osc/ { print $1 }'`"
 668         for i in $OSC0_UUID; do
 669                 $LCTL --device $i activate || error "activate osc failed!"
 670         done
 671
 672         # sleep a while to wait for recovery done
 673         sleep 20
 674
 675         # check limits
 676         PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
 677         TOTAL_LIMIT="`$LFS quota -u $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
 678         [ $TOTAL_LIMIT -eq $LIMIT ] || error "total limits not recovery!"
 679         echo "  total limits = $TOTAL_LIMIT"
 680
 681         OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
 682         [ -z "$OST0_UUID" ] && OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
 683         OST0_LIMIT="`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $3 }'`"
 684         [ $OST0_LIMIT -eq $BUNIT_SZ ] || error "high limits not released!"
 685         echo "  limits on $OST0_UUID = $OST0_LIMIT"
 686
 687         # cleanup
 688         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 689 }
 690 run_test 7 "Quota recovery (only block limit) ======"
 691
 692 # run dbench with quota enabled
 693 test_8() {
 694         BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
 695         FILE_LIMIT=1000000
 696         DBENCH_LIB=${DBENCH_LIB:-/usr/lib/dbench}
 697
 698         [ ! -d $DBENCH_LIB ] && skip "dbench not installed" && return 0
 699
 700         wait_delete_completed
 701
 702         echo "  Set enough high limit for user: $TSTUSR"
 703         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 704         echo "  Set enough high limit for group: $TSTUSR"
 705         $LFS setquota -g $USER 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 706
 707         TGT=$DIR/$tdir/client.txt
 708         SRC=${SRC:-$DBENCH_LIB/client.txt}
 709         [ ! -e $TGT -a -e $SRC ] && echo "copying $SRC to $TGT" && cp $SRC $TGT
 710         SRC=$DBENCH_LIB/client_plain.txt
 711         [ ! -e $TGT -a -e $SRC ] && echo "copying $SRC to $TGT" && cp $SRC $TGT
 712
 713         chmod 0777 $DIR/$tdir
 714         SAVE_PWD=$PWD
 715         cd $DIR/$tdir
 716         local duration=""
 717         [ "$SLOW" = "no" ] && duration=" -t 120"
 718         $RUNAS dbench -c client.txt 3 $duration
 719         RC=$?
 720         [ $RC -ne 0 ] && killall -9 dbench
 721
 722         rm -f client.txt
 723         sync; sleep 3; sync;
 724
 725         cd $SAVE_PWD
 726         return $RC
 727 }
 728 run_test 8 "Run dbench with quota enabled ==========="
 729
 730 # run for fixing bug10707, it needs a big room. test for 64bit
 731 KB=1024
 732 GB=$((KB * 1024 * 1024))
 733 # Use this as dd bs to decrease time
 734 # inode->i_blkbits = min(PTLRPC_MAX_BRW_BITS+1, LL_MAX_BLKSIZE_BITS);
 735 blksize=$((1 << 21)) # 2Mb
 736 size_file=$((GB * 9 / 2))
 737 # this check is just for test9 and test10
 738 OST0_MIN=4900000 #4.67G
 739 check_whether_skip () {
 740     OST0_SIZE=`$LFS df $DIR | awk '/\[OST:0\]/ {print $4}'`
 741     log "OST0_SIZE: $OST0_SIZE  required: $OST0_MIN"
 742     if [ $OST0_SIZE -lt $OST0_MIN ]; then
 743         echo "WARN: OST0 has less than $OST0_MIN free, skip this test."
 744         return 0
 745     else
 746         return 1
 747     fi
 748 }
 749
 750 test_9() {
 751         check_whether_skip && return 0
 752
 753         wait_delete_completed
 754
 755         set_blk_tunesz 512
 756         set_blk_unitsz 1024
 757
 758         chmod 0777 $DIR/$tdir
 759         TESTFILE="$DIR/$tdir/$tfile-0"
 760
 761         BLK_LIMIT=$((100 * KB * KB)) # 100G
 762         FILE_LIMIT=1000000
 763
 764         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
 765         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 766         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
 767         $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 768
 769         echo "  Set stripe"
 770         $LFS setstripe $TESTFILE -c 1
 771         touch $TESTFILE
 772         chown $TSTUSR.$TSTUSR $TESTFILE
 773
 774         $SHOW_QUOTA_USER
 775         $SHOW_QUOTA_GROUP
 776
 777         log "    Write the big file of 4.5G ..."
 778         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
 779                error "(usr) write 4.5G file failure, but expect success"
 780
 781         $SHOW_QUOTA_USER
 782         $SHOW_QUOTA_GROUP
 783
 784         log "    delete the big file of 4.5G..."
 785         $RUNAS rm -f $TESTFILE
 786         sync; sleep 3; sync;
 787
 788         $SHOW_QUOTA_USER
 789         $SHOW_QUOTA_GROUP
 790
 791         RC=$?
 792
 793         set_blk_unitsz $((128 * 1024))
 794         set_blk_tunesz $((128 * 1024 / 2))
 795
 796         return $RC
 797 }
 798 run_test 9 "run for fixing bug10707(64bit) ==========="
 799
 800 # run for fixing bug10707, it need a big room. test for 32bit
 801 test_10() {
 802         chmod 0777 $DIR/$tdir
 803         check_whether_skip && return 0
 804
 805         wait_delete_completed
 806
 807         set_blk_tunesz 512
 808         set_blk_unitsz 1024
 809
 810         # make qd_count 32 bit
 811         lustre_fail mds_ost 0xA00
 812
 813         TESTFILE="$DIR/$tdir/$tfile-0"
 814
 815         BLK_LIMIT=$((100 * KB * KB)) # 100G
 816         FILE_LIMIT=1000000
 817
 818         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
 819         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 820         log "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
 821         $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 822
 823         echo "  Set stripe"
 824         $LFS setstripe $TESTFILE -c 1
 825         touch $TESTFILE
 826         chown $TSTUSR.$TSTUSR $TESTFILE
 827
 828         $SHOW_QUOTA_USER
 829         $SHOW_QUOTA_GROUP
 830
 831         log "    Write the big file of 4.5 G ..."
 832         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
 833                 error "(usr) write 4.5 G file failure, but expect success"
 834
 835         $SHOW_QUOTA_USER
 836         $SHOW_QUOTA_GROUP
 837
 838         log "    delete the big file of 4.5 G..."
 839         $RUNAS rm -f $TESTFILE
 840         sync; sleep 3; sync;
 841
 842         $SHOW_QUOTA_USER
 843         $SHOW_QUOTA_GROUP
 844
 845         RC=$?
 846
 847         # make qd_count 64 bit
 848         lustre_fail mds_ost 0
 849
 850         set_blk_unitsz $((128 * 1024))
 851         set_blk_tunesz $((128 * 1024 / 2))
 852
 853         return $RC
 854 }
 855 run_test 10 "run for fixing bug10707(32bit) ==========="
 856
 857 test_11() {
 858        wait_delete_completed
 859
 860        #prepare the test
 861        block_limit=`(echo 0; df -t lustre -P | awk '{print $(NF - 4)}') | tail -n 1`
 862        echo $block_limit
 863        orig_dbr=`cat /proc/sys/vm/dirty_background_ratio`
 864        orig_dec=`cat /proc/sys/vm/dirty_expire_centisecs`
 865        orig_dr=`cat /proc/sys/vm/dirty_ratio`
 866        orig_dwc=`cat /proc/sys/vm/dirty_writeback_centisecs`
 867        echo 1  > /proc/sys/vm/dirty_background_ratio
 868        echo 30 > /proc/sys/vm/dirty_expire_centisecs
 869        echo 1  > /proc/sys/vm/dirty_ratio
 870        echo 50 > /proc/sys/vm/dirty_writeback_centisecs
 871        TESTDIR="$DIR/$tdir"
 872        local RV=0
 873
 874        #do the test
 875        local SECS=0
 876        local REPS=3
 877        [ "$SLOW" = no ] && REPS=1
 878        local sleep=20
 879        local i=1
 880        while [ $i -le $REPS ]; do
 881            echo "test: cycle($i of $REPS) start at $(date)"
 882            mkdir -p $DIR/$tdir && chmod 777 $DIR/$tdir
 883            echo -n "    create a file for uid "
 884            for j in `seq 1 30`; do
 885                echo -n "$j "
 886                # 30MB per dd for a total of 900MB (if space even permits)
 887                runas -u $j dd if=/dev/zero of=$DIR/$tdir/$tfile  bs=$blksize count=15 > /dev/null 2>&1 &
 888            done
 889            echo ""
 890            PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
 891            LAST_USED=0
 892            while [ $PROCS -gt 0 ]; do
 893              sleep 20
 894              SECS=$((SECS + sleep))
 895              PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
 896              USED=$(du -s $DIR/$tdir | awk '{print $1}')
 897              PCT=$(($USED * 100 / $block_limit))
 898              echo "${i}/${REPS} ${PCT}% p${PROCS} t${SECS}  "
 899              if [ $USED -le $LAST_USED ]; then
 900                  kill -9 $(ps -ef | grep "dd if /dev/zero of $DIR/$tdir" | grep -v grep | awk '{ print $2 }')
 901                  i=$REPS
 902                  RV=2
 903                  break
 904              fi
 905              LAST_USED=$USED
 906            done
 907            echo "    removing the test files..."
 908            rm -f $DIR/$tdir/$tfile
 909            echo "cycle $i done at $(date)"
 910            i=$[$i+1]
 911        done
 912        echo "Test took $SECS sec"
 913
 914        #clean
 915        echo $orig_dbr > /proc/sys/vm/dirty_background_ratio
 916        echo $orig_dec > /proc/sys/vm/dirty_expire_centisecs
 917        echo $orig_dr  > /proc/sys/vm/dirty_ratio
 918        echo $orig_dwc > /proc/sys/vm/dirty_writeback_centisecs
 919        if [ $RV -ne 0 ]; then
 920            error "Nothing was written for $SECS sec ... aborting"
 921        fi
 922        return $RV
 923 }
 924 run_test 11 "run for fixing bug10912 ==========="
 925
 926
 927 # test a deadlock between quota and journal b=11693
 928 test_12() {
 929         chmod 0777 $DIR/$tdir
 930
 931         [ "$(grep $DIR2 /proc/mounts)" ] || mount_client $DIR2 || \
 932                 { skip "Need lustre mounted on $MOUNT2 " && retutn 0; }
 933
 934         if [ $OSTCOUNT -lt 2 ]; then
 935                 skip "$OSTCOUNT < 2, too few osts"
 936                 return 0;
 937         fi
 938
 939         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
 940         TESTFILE="$DIR/$tdir/$tfile-0"
 941         TESTFILE2="$DIR2/$tdir/$tfile-1"
 942
 943         wait_delete_completed
 944
 945         echo "   User quota (limit: $LIMIT kbytes)"
 946         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 947
 948         $LFS setstripe $TESTFILE -i 0 -c 1
 949         chown $TSTUSR.$TSTUSR $TESTFILE
 950         $LFS setstripe $TESTFILE2 -i 1 -c 1
 951         chown $TSTUSR2.$TSTUSR2 $TESTFILE2
 952
 953         #define OBD_FAIL_OST_HOLD_WRITE_RPC      0x21f
 954         lustre_fail ost 0x0000021f
 955
 956         echo "   step1: write out of block quota ..."
 957         $RUNAS2 dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=102400 &
 958         DDPID1=$!
 959         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT*2)) &
 960         DDPID=$!
 961
 962         echo  "   step2: testing ......"
 963         count=0
 964         while [ true ]; do
 965             if [ -z `ps -ef | awk '$2 == '${DDPID1}' { print $8 }'` ]; then break; fi
 966             count=$[count+1]
 967             if [ $count -gt 64 ]; then
 968                 lustre_fail ost 0
 969                 error "dd should be finished!"
 970             fi
 971             sleep 1
 972         done
 973         echo "(dd_pid=$DDPID1, time=$count)successful"
 974
 975         #Recover fail_loc and dd will finish soon
 976         lustre_fail ost 0
 977
 978         echo  "   step3: testing ......"
 979         count=0
 980         while [ true ]; do
 981             if [ -z `ps -ef | awk '$2 == '${DDPID}' { print $8 }'` ]; then break; fi
 982             count=$[count+1]
 983             if [ $count -gt 100 ]; then
 984                 error "dd should be finished!"
 985             fi
 986             sleep 1
 987         done
 988         echo "(dd_pid=$DDPID, time=$count)successful"
 989
 990         rm -f $TESTFILE $TESTFILE2
 991         sync; sleep 3; sync;
 992
 993         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
 994 }
 995 run_test 12 "test a deadlock between quota and journal ==="
 996
 997 # test multiple clients write block quota b=11693
 998 test_13() {
 999         wait_delete_completed
1000
1001         # one OST * 10 + (mds + other OSTs)
1002         LIMIT=$((BUNIT_SZ * 10 + (BUNIT_SZ * OSTCOUNT)))
1003         TESTFILE="$DIR/$tdir/$tfile"
1004
1005         echo "   User quota (limit: $LIMIT kbytes)"
1006         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
1007         $SHOW_QUOTA_USER
1008
1009         $LFS setstripe $TESTFILE -i 0 -c 1
1010         chown $TSTUSR.$TSTUSR $TESTFILE
1011         $LFS setstripe $TESTFILE.2 -i 0 -c 1
1012         chown $TSTUSR.$TSTUSR $TESTFILE.2
1013
1014         echo "   step1: write out of block quota ..."
1015         # one bunit will give mds
1016         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1017         DDPID=$!
1018         $RUNAS dd if=/dev/zero of=$TESTFILE.2 bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
1019         DDPID1=$!
1020
1021         echo  "   step2: testing ......"
1022         count=0
1023         while [ true ]; do
1024             if [ -z `ps -ef | awk '$2 == '${DDPID}' { print $8 }'` ]; then break; fi
1025             count=$[count+1]
1026             if [ $count -gt 64 ]; then
1027                 error "dd should be finished!"
1028             fi
1029             sleep 1
1030         done
1031         echo "(dd_pid=$DDPID, time=$count)successful"
1032
1033         count=0
1034         while [ true ]; do
1035             if [ -z `ps -ef | awk '$2 == '${DDPID1}' { print $8 }'` ]; then break; fi
1036             count=$[count+1]
1037             if [ $count -gt 64 ]; then
1038                 error "dd should be finished!"
1039             fi
1040             sleep 1
1041         done
1042         echo "(dd_pid=$DDPID1, time=$count)successful"
1043
1044         sync; sleep 5; sync;
1045
1046         echo  "   step3: checking ......"
1047         fz=`stat -c %s $TESTFILE`
1048         fz2=`stat -c %s $TESTFILE.2`
1049         $SHOW_QUOTA_USER
1050         [ $((fz + fz2)) -lt $((BUNIT_SZ * BLK_SZ * 10)) ] && \
1051                 error "files too small $fz + $fz2 < $((BUNIT_SZ * BLK_SZ * 10))"
1052
1053         rm -f $TESTFILE $TESTFILE.2
1054         sync; sleep 3; sync;
1055
1056         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
1057 }
1058 run_test 13 "test multiple clients write block quota ==="
1059
1060 check_if_quota_zero(){
1061         line=`$LFS quota -$1 $2 $DIR | wc -l`
1062         for i in `seq 3 $line`; do
1063             if [ $i -eq 3 ]; then
1064                 field="3 4 6 7"
1065             else
1066                 field="3 5"
1067             fi
1068             for j in $field; do
1069                 tmp=`$LFS quota -$1 $2 $DIR | sed -n ${i}p |
1070                      awk  '{print $'"$j"'}'`
1071                 [ -n "$tmp" ] && [ $tmp -ne 0 ] && $LFS quota -$1 $2 $DIR && \
1072                     error "quota on $2 isn't clean"
1073             done
1074         done
1075         echo "pass check_if_quota_zero"
1076 }
1077
1078 pre_test_14 () {
1079         # reboot the lustre
1080         sync; sleep 5; sync
1081         cd $T_PWD; sh llmountcleanup.sh || error "llmountcleanup failed"
1082         sh llmount.sh
1083         run_test 0 "reboot lustre"
1084 }
1085 pre_test_14
1086
1087 test_14(){ # b=12223 -- setting quota on root
1088         TESTFILE="$DIR/$tdir/$tfile"
1089
1090         # out of root's file and block quota
1091         $LFS setquota -u root 10 10 10 10 $DIR
1092         createmany -m ${TESTFILE} 20 || \
1093             error "unexpected: user(root) create files failly!"
1094         dd if=/dev/zero of=$TESTFILE bs=4k count=4096 || \
1095             error "unexpected: user(root) write files failly!"
1096         chmod 666 $TESTFILE
1097         $RUNAS dd if=/dev/zero of=${TESTFILE} seek=4096 bs=4k count=4096 && \
1098             error "unexpected: user(quota_usr) write a file successfully!"
1099
1100         # trigger the llog
1101         chmod 777 $DIR
1102         for i in `seq 1 10`; do $RUNAS touch ${TESTFILE}a_$i; done
1103         for i in `seq 1 10`; do $RUNAS rm -f ${TESTFILE}a_$i; done
1104
1105         # do the check
1106         dmesg | tail | grep "\-122" |grep llog_obd_origin_add && error "err -122 not found in dmesg"
1107         $LFS setquota -u root 0 0 0 0 $DIR
1108         #check_if_quota_zero u root
1109
1110         # clean
1111         unlinkmany ${TESTFILE} 15
1112         rm -f $TESTFILE
1113         sync; sleep 3; sync;
1114 }
1115 run_test 14 "test setting quota on root ==="
1116
1117 quota_set_version() {
1118         do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_type; do
1119                 echo $1 >> \\\$i;
1120         done"
1121 }
1122
1123 test_14a(){
1124         # 1. check that required users exist
1125         # 2. ensure that switch to new mode will start conversion
1126         # 3. start quota in old mode and put some entries
1127         # 4. restart quota in new mode forcing conversion and check the entries
1128
1129         wait_delete_completed
1130
1131         MISSING_USERS=""
1132         for i in `seq 1 30`; do
1133                 check_runas_id_ret quota15_$i "runas -u quota15_$i"
1134                 if [ "$?" != "0" ]; then
1135                        MISSING_USERS="$MISSING_USERS quota15_$i"
1136                 fi
1137         done
1138
1139         if [ -n "$MISSING_USERS" ]; then
1140                 skip "following users are missing: $MISSING_USERS"
1141                 return 0
1142         fi
1143
1144         $LFS quotaoff -ug $DIR
1145         quota_set_version 1
1146         $LFS quotacheck -ug $DIR
1147
1148         for i in `seq 1 30`; do
1149                 $LFS setquota -u quota15_$i $i $i $i $i $DIR || error "lfs setquota failed"
1150         done
1151
1152         $LFS quotaoff -ug $DIR
1153         quota_set_version 2
1154         $LFS quotainv -ug $DIR
1155         $LFS quotacheck -ug $DIR
1156
1157         for i in `seq 1 30`; do
1158                 # the format is "mntpnt   curspace[*]   bsoftlimit   bhardlimit   [time]   curinodes[*]    isoftlimit  ihardlimit"
1159                 ($LFS quota -u quota15_$i $DIR | grep -E '^ *'$DIR' *[0-9]+\** *'$i' *'$i' *[0-9]+\** *'$i' *'$i) \
1160                  || error "lfs quota output is unexpected"
1161                 $LFS setquota -u quota15_$i 0 0 0 0 $DIR || error "ifs setquota clear failed"
1162         done
1163 }
1164 run_test 14a "setting 30 quota entries in quota v1 file before conversion ==="
1165
1166 test_15(){
1167         LIMIT=$((24 * 1024 * 1024 * 1024 * 1024)) # 24 TB
1168         PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
1169
1170         wait_delete_completed
1171
1172         # test for user
1173         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR || error "failed setting user quota limit $LIMIT"
1174         TOTAL_LIMIT="`$LFS quota -u $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
1175         [ $TOTAL_LIMIT -eq $LIMIT ] || error "  (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1176         echo "  (user)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1177         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR || error "failed removing user quota limit"
1178
1179         # test for group
1180         $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR || error "failed setting group quota limit $LIMIT"
1181         TOTAL_LIMIT="`$LFS quota -g $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
1182         [ $TOTAL_LIMIT -eq $LIMIT ] || error "  (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, failed!"
1183         echo "  (group)total limits = $TOTAL_LIMIT; limit = $LIMIT, successful!"
1184         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR || error "failed removing group quota limit"
1185         $LFS quotaoff -ug $DIR
1186         quota_set_version 1
1187         $LFS quotacheck -ug $DIR || error "quotacheck failed"
1188
1189         echo "Testing that >4GB quota limits fail on volume with quota v1"
1190         ! $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
1191 }
1192 run_test 15 "set block quota more than 4T ==="
1193
1194 # $1=u/g $2=with qunit adjust or not
1195 test_16_tub() {
1196         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 4))
1197         TESTFILE="$DIR/$tdir/$tfile"
1198
1199         wait_delete_completed
1200
1201         echo "  User quota (limit: $LIMIT kbytes)"
1202         if [ $1 == "u" ]; then
1203             $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
1204             $SHOW_QUOTA_USER
1205         else
1206             $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
1207             $SHOW_QUOTA_GROUP
1208         fi
1209
1210         $LFS setstripe $TESTFILE -c 1
1211         chown $TSTUSR.$TSTUSR $TESTFILE
1212
1213         echo "    Write ..."
1214         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((BUNIT_SZ * 4)) || \
1215             error "(usr) write failure, but expect success"
1216         echo "    Done"
1217         echo "    Write out of block quota ..."
1218         # this time maybe cache write,  ignore it's failure
1219         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || true
1220         # flush cache, ensure noquota flag is setted on client
1221         sync; sleep 1; sync;
1222         if [ $2 -eq 1 ]; then
1223             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) || \
1224                 error "(write failure, but expect success"
1225         else
1226             $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$((BUNIT_SZ * 4)) && \
1227                 error "(write success, but expect EDQUOT"
1228         fi
1229
1230         rm -f $TESTFILE
1231         sync; sleep 3; sync;
1232         $LFS setquota -$1 $TSTUSR 0 0 0 0 $DIR
1233 }
1234
1235 # test without adjusting qunit
1236 test_16 () {
1237         set_blk_tunesz $((BUNIT_SZ * 2))
1238         set_blk_unitsz $((BUNIT_SZ * 4))
1239         for i in u g; do
1240             for j in 0 1; do
1241                 # define OBD_FAIL_QUOTA_WITHOUT_CHANGE_QS    0xA01
1242                 echo " grp/usr: $i, adjust qunit: $j"
1243                 echo "-------------------------------"
1244                 [ $j -eq 1 ] && lustre_fail mds_ost 0
1245                 [ $j -eq 0 ] && lustre_fail mds_ost 0xA01
1246                 test_16_tub $i $j
1247             done
1248         done
1249         set_blk_unitsz $((128 * 1024))
1250         set_blk_tunesz $((128 * 1024 / 2))
1251 }
1252 run_test 16 "test without adjusting qunit"
1253
1254 # run for fixing bug14526, failed returned quota reqs shouldn't ruin lustre.
1255 test_17() {
1256         set_blk_tunesz 512
1257         set_blk_unitsz 1024
1258
1259         wait_delete_completed
1260
1261         #define OBD_FAIL_QUOTA_RET_QDATA | OBD_FAIL_ONCE
1262         lustre_fail ost 0x80000A02
1263
1264         TESTFILE="$DIR/$tdir/$tfile-a"
1265         TESTFILE2="$DIR/$tdir/$tfile-b"
1266
1267         BLK_LIMIT=$((100 * 1024)) # 100M
1268
1269         log "  Set enough high limit(block:$BLK_LIMIT) for user: $TSTUSR"
1270         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 0 $DIR
1271         log "  Set enough high limit(block:$BLK_LIMIT) for group: $TSTUSR"
1272         $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 0 $DIR
1273
1274         touch $TESTFILE
1275         chown $TSTUSR.$TSTUSR $TESTFILE
1276         touch $TESTFILE2
1277         chown $TSTUSR.$TSTUSR $TESTFILE2
1278
1279         $SHOW_QUOTA_USER
1280         $SHOW_QUOTA_GROUP
1281
1282         log "    Write the test file1 ..."
1283         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$(( 10 * 1024 )) \
1284             || echo "write 10M file failure"
1285
1286         $SHOW_QUOTA_USER
1287         $SHOW_QUOTA_GROUP
1288
1289         log "    write the test file2 ..."
1290         $RUNAS dd if=/dev/zero of=$TESTFILE2  bs=$BLK_SZ count=$(( 10 * 1024 )) \
1291             || error "write 10M file failure"
1292
1293         $SHOW_QUOTA_USER
1294         $SHOW_QUOTA_GROUP
1295
1296         rm -f $TESTFILE $TESTFILE2
1297         RC=$?
1298         sync; sleep 3; sync;
1299
1300         # make qd_count 64 bit
1301         lustre_fail ost 0
1302
1303         set_blk_unitsz $((128 * 1024))
1304         set_blk_tunesz $((128 * 1024 / 2))
1305
1306         return $RC
1307 }
1308 run_test 17 "run for fixing bug14526 ==========="
1309
1310 # test when mds takes a long time to handle a quota req so that
1311 # the ost has dropped it, the ost still could work well b=14840
1312 test_18() {
1313         LIMIT=$((100 * 1024 * 1024)) # 100G
1314         TESTFILE="$DIR/$tdir/$tfile"
1315
1316         wait_delete_completed
1317
1318         set_blk_tunesz 512
1319         set_blk_unitsz 1024
1320
1321         log "   User quota (limit: $LIMIT kbytes)"
1322         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
1323         $SHOW_QUOTA_USER
1324
1325         $LFS setstripe $TESTFILE -i 0 -c 1
1326         chown $TSTUSR.$TSTUSR $TESTFILE
1327
1328         #define OBD_FAIL_MDS_BLOCK_QUOTA_REQ      0x13c
1329         lustre_fail mds 0x13c
1330
1331         log "   step1: write 100M block ..."
1332         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1333         DDPID=$!
1334
1335         sleep 5
1336         lustre_fail mds 0
1337
1338         echo  "   step2: testing ......"
1339         count=0
1340         timeout=$(sysctl -n lustre.timeout)
1341         while [ true ]; do
1342             if [ -z `ps -ef | awk '$2 == '${DDPID}' { print $8 }'` ]; then break; fi
1343             count=$[count+1]
1344             if [ $count -gt $((2 * $timeout)) ]; then
1345                 error "count=$count dd should be finished!"
1346             fi
1347             sleep 1
1348         done
1349         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1350         if [ $count -lt $(($timeout - 10)) ]; then
1351             error " should take longer!"
1352         else
1353             echo " successful"
1354         fi
1355
1356         rm -f $TESTFILE
1357         sync; sleep 3; sync;
1358
1359         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT         # clear user limit
1360
1361         set_blk_unitsz $((128 * 1024))
1362         set_blk_tunesz $((128 * 1024 / 2))
1363 }
1364 run_test 18 "run for fixing bug14840 ==========="
1365
1366 # test when mds drops a quota req, the ost still could work well b=14840
1367 test_18a() {
1368         LIMIT=$((100 * 1024 * 1024)) # 100G
1369         TESTFILE="$DIR/$tdir/$tfile-a"
1370
1371         wait_delete_completed
1372
1373         set_blk_tunesz 512
1374         set_blk_unitsz 1024
1375
1376         log "   User quota (limit: $LIMIT kbytes)"
1377         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
1378         $SHOW_QUOTA_USER
1379
1380         $LFS setstripe $TESTFILE -i 0 -c 1
1381         chown $TSTUSR.$TSTUSR $TESTFILE
1382
1383         #define OBD_FAIL_MDS_DROP_QUOTA_REQ | OBD_FAIL_ONCE   0x8000013d
1384         lustre_fail mds 0x8000013d
1385
1386         log "   step1: write 100M block ..."
1387         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$((1024 * 100)) &
1388         DDPID=$!
1389
1390         echo  "   step2: testing ......"
1391         count=0
1392         timeout=$(sysctl -n lustre.timeout)
1393         while [ true ]; do
1394             if [ -z `ps -ef | awk '$2 == '${DDPID}' { print $8 }'` ]; then break; fi
1395             count=$[count+1]
1396             if [ $count -gt $((3 * $timeout)) ]; then
1397                 lustre_fail mds 0
1398                 error "count=$count dd should be finished!"
1399             fi
1400             sleep 1
1401         done
1402         log "(dd_pid=$DDPID, time=$count, timeout=$timeout)"
1403         if [ $count -lt $(($timeout - 10)) ]; then
1404             lustre_fail mds 0
1405             error " should take longer!"
1406         else
1407             echo " successful"
1408         fi
1409
1410         lustre_fail mds 0
1411
1412         rm -f $TESTFILE
1413         sync; sleep 3; sync;
1414
1415         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT         # clear user limit
1416
1417         set_blk_unitsz $((128 * 1024))
1418         set_blk_tunesz $((128 * 1024 / 2))
1419 }
1420 run_test 18a "run for fixing bug14840 ==========="
1421
1422 # turn off quota
1423 test_99()
1424 {
1425         $LFS quotaoff $DIR
1426         sysctl -w lnet.debug="-quota"
1427
1428         return 0
1429 }
1430 run_test 99 "Quota off ==============================="
1431
1432
1433 log "cleanup: ======================================================"
1434 cd $ORIG_PWD
1435 check_and_cleanup_lustre
1436 echo '=========================== finished ==============================='
1437 [ -f "$QUOTALOG" ] && cat $QUOTALOG && grep -q FAIL $QUOTALOG && exit 1 || true
1438 echo "$0: completed"