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