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