lustre/tests/sanity-quota.sh

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