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