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:-1000}      # default 1000 quota blocks
  40 BTUNE_SZ=${BTUNE_SZ:-500}       # default 50% of BUNIT_SZ
  41 IUNIT_SZ=${IUNIT_SZ:-10}        # default 10 files
  42 ITUNE_SZ=${ITUNE_SZ:-5}         # default 50% of IUNIT_SZ
  43 MAX_DQ_TIME=604800
  44 MAX_IQ_TIME=604800
  45
  46 TRACE=${TRACE:-""}
  47 LUSTRE=${LUSTRE:-`dirname $0`/..}
  48 . $LUSTRE/tests/test-framework.sh
  49 init_test_env $@
  50 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  51
  52 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
  53 remote_ost_nodsh && skip "remote OST with nodsh" && exit 0
  54
  55 [ "$SLOW" = "no" ] && EXCEPT_SLOW="9 10 11"
  56
  57 QUOTALOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}
  58
  59 [ "$QUOTALOG" ] && rm -f $QUOTALOG || true
  60
  61 DIR=${DIR:-$MOUNT}
  62 DIR2=${DIR2:-$MOUNT2}
  63
  64 check_and_setup_lustre
  65
  66 LOVNAME=`cat $LPROC/llite/*/lov/common_name | tail -n 1`
  67 OSTCOUNT=`cat $LPROC/lov/$LOVNAME/numobd`
  68
  69 SHOW_QUOTA_USER="$LFS quota -u $TSTUSR $DIR"
  70 SHOW_QUOTA_GROUP="$LFS quota -g $TSTUSR $DIR"
  71 SHOW_QUOTA_INFO="$LFS quota -t $DIR"
  72
  73 # control the time of tests
  74 cycle=30
  75 [ "$SLOW" = "no" ] && cycle=10
  76
  77 build_test_filter
  78
  79 eval ONLY_0=true
  80 eval ONLY_99=true
  81
  82 # set_blk_tunables(btune_sz)
  83 set_blk_tunesz() {
  84         # set btune size on all obdfilters
  85         do_facet ost1 "set -x; for i in /proc/fs/lustre/obdfilter/*/quota_btune_sz; do
  86                 echo $(($1 * BLK_SZ)) >> \\\$i;
  87         done"
  88         # set btune size on mds
  89         do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_btune_sz; do
  90                 echo $(($1 * BLK_SZ)) >> \\\$i;
  91         done"
  92 }
  93
  94 # set_blk_unitsz(bunit_sz)
  95 set_blk_unitsz() {
  96         do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_bunit_sz; do
  97                 echo $(($1 * BLK_SZ)) >> \\\$i;
  98         done"
  99         do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_bunit_sz; do
 100                 echo $(($1 * BLK_SZ)) >> \\\$i;
 101         done"
 102 }
 103
 104 # set_file_tunesz(itune_sz)
 105 set_file_tunesz() {
 106         # set iunit and itune size on all obdfilters
 107         do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_itune_sz; do
 108                 echo $1 >> \\\$i;
 109         done"
 110         # set iunit and itune size on mds
 111         do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_itune_sz; do
 112                 echo $1 >> \\\$i;
 113         done"
 114 }
 115
 116 # set_file_unitsz(iunit_sz)
 117 set_file_unitsz() {
 118         do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_iunit_sz; do
 119                 echo $1 >> \\\$i;
 120         done"
 121         do_facet $SINGLEMDS "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_iunit_sz; do
 122                 echo $1 >> \\\$i;
 123         done"
 124 }
 125
 126 # These are for test on local machine,if run sanity-quota.sh on
 127 # real cluster, ltest should have setup the test environment:
 128 #
 129 # - create test user/group on all servers with same id.
 130 # - set unit size/tune on all servers size to reasonable value.
 131 pre_test() {
 132         if [ -z "$NOSETUP" ]; then
 133                 # set block tunables
 134                 set_blk_tunesz $BTUNE_SZ
 135                 set_blk_unitsz $BUNIT_SZ
 136                 # set file tunables
 137                 set_file_tunesz $ITUNE_SZ
 138                 set_file_unitsz $IUNIT_SZ
 139         fi
 140 }
 141 pre_test
 142
 143 post_test() {
 144         if [ -z "$NOSETUP" ]; then
 145                 # restore block tunables to default size
 146                 set_blk_unitsz $((1024 * 100))
 147                 set_blk_tunesz $((1024 * 50))
 148                 # restore file tunables to default size
 149                 set_file_unitsz 5000
 150                 set_file_tunesz 2500
 151         fi
 152 }
 153
 154 RUNAS="runas -u $TSTID"
 155 RUNAS2="runas -u $TSTID2"
 156 FAIL_ON_ERROR=true check_runas_id $TSTID $RUNAS
 157 FAIL_ON_ERROR=true check_runas_id $TSTID2 $RUNAS2
 158
 159 FAIL_ON_ERROR=false
 160
 161 # set quota
 162 test_0() {
 163         $LFS quotaoff -ug $DIR
 164         $LFS quotacheck -ug $DIR
 165
 166         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 167         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 168 }
 169 run_test 0 "Set quota ============================="
 170
 171 # block hard limit (normal use and out of quota)
 172 test_1() {
 173         mkdir -p $DIR/$tdir
 174         chmod 0777 $DIR/$tdir
 175
 176         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 5)) # 5 bunits each sever
 177         TESTFILE=$DIR/$tdir/$tfile-0
 178
 179         echo "  User quota (limit: $LIMIT kbytes)"
 180         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 181         $SHOW_QUOTA_USER
 182
 183         $LFS setstripe $TESTFILE -c 1
 184         chown $TSTUSR.$TSTUSR $TESTFILE
 185
 186         echo "    Write ..."
 187         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || error "(usr) write failure, but expect success"
 188         echo "    Done"
 189         echo "    Write out of block quota ..."
 190         # this time maybe cache write,  ignore it's failure
 191         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
 192         # flush cache, ensure noquota flag is setted on client
 193         sync; sleep 1; sync;
 194         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && error "(usr) write success, but expect EDQUOT"
 195
 196         rm -f $TESTFILE
 197
 198         echo "  Group quota (limit: $LIMIT kbytes)"
 199         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
 200         $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
 201         $SHOW_QUOTA_GROUP
 202         TESTFILE=$DIR/$tdir/$tfile-1
 203
 204         $LFS setstripe $TESTFILE -c 1
 205         chown $TSTUSR.$TSTUSR $TESTFILE
 206
 207         echo "    Write ..."
 208         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || error "(grp) write failure, but expect success"
 209         echo "    Done"
 210         echo "    Write out of block quota ..."
 211         # this time maybe cache write, ignore it's failure
 212         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
 213         sync; sleep 1; sync;
 214         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && error "(grp) write success, but expect EDQUOT"
 215
 216         # cleanup
 217         rm -f $TESTFILE
 218         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 219 }
 220 run_test 1 "Block hard limit (normal use and out of quota) ==="
 221
 222 # file hard limit (normal use and out of quota)
 223 test_2() {
 224         mkdir -p $DIR/$tdir
 225         chmod 0777 $DIR/$tdir
 226
 227         LIMIT=$(($IUNIT_SZ * 10)) # 10 iunits on mds
 228         TESTFILE=$DIR/$tdir/$tfile-0
 229
 230         echo "  User quota (limit: $LIMIT files)"
 231         $LFS setquota -u $TSTUSR 0 0 0 $LIMIT $DIR
 232         $SHOW_QUOTA_USER
 233
 234         echo "    Create $LIMIT files ..."
 235         $RUNAS createmany -m ${TESTFILE} $LIMIT || \
 236             error "(usr) create failure, but expect success"
 237         echo "    Done"
 238         echo "    Create out of file quota ..."
 239         $RUNAS touch ${TESTFILE}_xxx && \
 240                 error "(usr) touch success, but expect EDQUOT"
 241
 242         unlinkmany ${TESTFILE} $LIMIT
 243         rm ${TESTFILE}_xxx
 244
 245         echo "  Group quota (limit: $LIMIT files)"
 246         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
 247         $LFS setquota -g $TSTUSR 0 0 0 $LIMIT $DIR
 248         $SHOW_QUOTA_GROUP
 249         TESTFILE=$DIR/$tdir/$tfile-1
 250
 251         echo "    Create $LIMIT files ..."
 252         $RUNAS createmany -m ${TESTFILE} $LIMIT || \
 253                 error "(grp) create failure, but expect success"
 254
 255         echo "    Done"
 256         echo "    Create out of file quota ..."
 257         $RUNAS touch ${TESTFILE}_xxx && \
 258                 error "(grp) touch success, but expect EDQUOT"
 259
 260         $RUNAS touch ${TESTFILE}_xxx > /dev/null 2>&1 && error "(grp) touch success, but expect EDQUOT"
 261
 262         # cleanup
 263         unlinkmany ${TESTFILE} $LIMIT
 264         rm ${TESTFILE}_xxx
 265
 266         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 267 }
 268 run_test 2 "File hard limit (normal use and out of quota) ==="
 269
 270 test_block_soft() {
 271         TESTFILE=$1
 272         TIMER=$(($2 * 3 / 2))
 273         OFFSET=0
 274
 275         echo "    Write to exceed soft limit"
 276         RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
 277         $RUNDD count=$((BUNIT_SZ+1)) || \
 278                 error "write failure, but expect success"
 279         OFFSET=$((OFFSET + BUNIT_SZ + 1))
 280         sync; sleep 1; sync;
 281
 282         $SHOW_QUOTA_USER
 283         $SHOW_QUOTA_GROUP
 284         $SHOW_QUOTA_INFO
 285
 286         echo "    Write before timer goes off"
 287         $RUNDD count=$BUNIT_SZ seek=$OFFSET || \
 288                 error "write failure, but expect success"
 289         OFFSET=$((OFFSET + BUNIT_SZ))
 290         sync; sleep 1; sync;
 291         echo "    Done"
 292
 293         echo "    Sleep $TIMER seconds ..."
 294         sleep $TIMER
 295
 296         $SHOW_QUOTA_USER
 297         $SHOW_QUOTA_GROUP
 298         $SHOW_QUOTA_INFO
 299
 300         echo "    Write after timer goes off"
 301         # maybe cache write, ignore.
 302         sync; sleep 1; sync;
 303         $RUNDD count=$BUNIT_SZ seek=$OFFSET || true
 304         OFFSET=$((OFFSET + BUNIT_SZ))
 305         sync; sleep 1; sync;
 306         $RUNDD count=$BUNIT_SZ seek=$OFFSET && \
 307                 error "write success, but expect EDQUOT"
 308
 309         $SHOW_QUOTA_USER
 310         $SHOW_QUOTA_GROUP
 311         $SHOW_QUOTA_INFO
 312
 313         echo "    Unlink file to stop timer"
 314         rm -f $TESTFILE
 315         echo "    Done"
 316
 317         $SHOW_QUOTA_USER
 318         $SHOW_QUOTA_GROUP
 319         $SHOW_QUOTA_INFO
 320
 321         echo "    Write ..."
 322         $RUNDD count=$BUNIT_SZ || error "write failure, but expect success"
 323         echo "    Done"
 324
 325         # cleanup
 326         rm -f $TESTFILE
 327 }
 328
 329 # block soft limit (start timer, timer goes off, stop timer)
 330 test_3() {
 331         mkdir -p $DIR/$tdir
 332         chmod 0777 $DIR/$tdir
 333
 334         LIMIT=$(( $BUNIT_SZ * 2 )) # 1 bunit on mds and 1 bunit on the ost
 335         GRACE=10
 336
 337         echo "  User quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
 338         TESTFILE=$DIR/$tdir/$tfile-0
 339
 340         $LFS setstripe $TESTFILE -c 1
 341         chown $TSTUSR.$TSTUSR $TESTFILE
 342
 343         $LFS setquota -t -u $GRACE $MAX_IQ_TIME $DIR
 344         $LFS setquota -u $TSTUSR $LIMIT 0 0 0 $DIR
 345
 346         test_block_soft $TESTFILE $GRACE
 347         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 348
 349         echo "  Group quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
 350         TESTFILE=$DIR/$tdir/$tfile-1
 351
 352         $LFS setstripe $TESTFILE -c 1
 353         chown $TSTUSR.$TSTUSR $TESTFILE
 354
 355         $LFS setquota -t -g $GRACE $MAX_IQ_TIME $DIR
 356         $LFS setquota -g $TSTUSR $LIMIT 0 0 0 $DIR
 357
 358         test_block_soft $TESTFILE $GRACE
 359         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 360 }
 361 run_test 3 "Block soft limit (start timer, timer goes off, stop timer) ==="
 362
 363 test_file_soft() {
 364         TESTFILE=$1
 365         LIMIT=$2
 366         TIMER=$(($3 * 3 / 2))
 367
 368         echo "    Create files to exceed soft limit"
 369         $RUNAS createmany -m ${TESTFILE}_ $((LIMIT + 1)) || \
 370                 error "create failure, but expect success"
 371         sync; sleep 1; sync
 372         echo "    Done"
 373
 374         echo "    Create file before timer goes off"
 375         $RUNAS touch ${TESTFILE}_before || \
 376                 error "failed create before timer expired, but expect success"
 377         sync; sleep 1; sync
 378         echo "    Done"
 379
 380         echo "    Sleep $TIMER seconds ..."
 381         sleep $TIMER
 382
 383         $SHOW_QUOTA_USER
 384         $SHOW_QUOTA_GROUP
 385         $SHOW_QUOTA_INFO
 386
 387         echo "    Create file after timer goes off"
 388         $RUNAS createmany -m ${TESTFILE}_after_ $((IUNIT_SZ - 2)) || \
 389                 error "create ${TESTFILE}_after failure, but expect success"
 390         sync; sleep 1; sync
 391         $RUNAS touch ${TESTFILE}_after && \
 392                 error "create after timer expired, but expect EDQUOT"
 393         sync; sleep 1; sync
 394
 395         $SHOW_QUOTA_USER
 396         $SHOW_QUOTA_GROUP
 397         $SHOW_QUOTA_INFO
 398
 399         echo "    Unlink files to stop timer"
 400         find `dirname $TESTFILE` -name "`basename ${TESTFILE}`*" | xargs rm -f
 401         echo "    Done"
 402
 403         echo "    Create file"
 404         $RUNAS touch ${TESTFILE}_xxx || \
 405                 error "touch after timer stop failure, but expect success"
 406         sync; sleep 1; sync
 407         echo "    Done"
 408
 409         # cleanup
 410         rm -f ${TESTFILE}_xxx
 411 }
 412
 413 # file soft limit (start timer, timer goes off, stop timer)
 414 test_4a() {     # was test_4
 415         mkdir -p $DIR/$tdir
 416         chmod 0777 $DIR/$tdir
 417         LIMIT=$(($IUNIT_SZ * 10))       # 10 iunits on mds
 418         TESTFILE=$DIR/$tdir/$tfile-0
 419
 420         GRACE=5
 421
 422         echo "  User quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 423         $LFS setquota -t -u $MAX_DQ_TIME $GRACE $DIR
 424         $LFS setquota -u $TSTUSR 0 0 $LIMIT 0 $DIR
 425         $SHOW_QUOTA_USER
 426
 427         test_file_soft $TESTFILE $LIMIT $GRACE
 428         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 429
 430         echo "  Group quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 431         $LFS setquota -t -g $MAX_DQ_TIME $GRACE $DIR
 432         $LFS setquota -g $TSTUSR 0 0 $LIMIT 0 $DIR
 433         $SHOW_QUOTA_GROUP
 434         TESTFILE=$DIR/$tdir/$tfile-1
 435
 436         test_file_soft $TESTFILE $LIMIT $GRACE
 437         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 438
 439         # cleanup
 440         $LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 441         $LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 442 }
 443 run_test 4a "File soft limit (start timer, timer goes off, stop timer) ==="
 444
 445 test_4b() {     # was test_4a
 446         GR_STR1="1w3d"
 447         GR_STR2="1000s"
 448         GR_STR3="5s"
 449         GR_STR4="1w2d3h4m5s"
 450         GR_STR5="5c"
 451         GR_STR6="1111111111111111"
 452
 453         # test of valid grace strings handling
 454         echo "  Valid grace strings test"
 455         $LFS setquota -t -u $GR_STR1 $GR_STR2 $DIR
 456         $LFS quota -u -t $DIR | grep "Block grace time: $GR_STR1"
 457         $LFS setquota -t -g $GR_STR3 $GR_STR4 $DIR
 458         $LFS quota -g -t $DIR | grep "Inode grace time: $GR_STR4"
 459
 460         # test of invalid grace strings handling
 461         echo "  Invalid grace strings test"
 462         ! $LFS setquota -t -u $GR_STR4 $GR_STR5 $DIR
 463         ! $LFS setquota -t -g $GR_STR4 $GR_STR6 $DIR
 464
 465         # cleanup
 466         $LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 467         $LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $DIR
 468 }
 469 run_test 4b "Grace time strings handling ==="
 470
 471 # chown & chgrp (chown & chgrp successfully even out of block/file quota)
 472 test_5() {
 473         mkdir -p $DIR/$tdir
 474         BLIMIT=$(( $BUNIT_SZ * $((OSTCOUNT + 1)) * 10)) # 10 bunits on each server
 475         ILIMIT=$(( $IUNIT_SZ * 10 )) # 10 iunits on mds
 476
 477         echo "  Set quota limit (0 $BLIMIT 0 $ILIMIT) for $TSTUSR.$TSTUSR"
 478         $LFS setquota -u $TSTUSR 0 $BLIMIT 0 $ILIMIT $DIR
 479         $LFS setquota -g $TSTUSR 0 $BLIMIT 0 $ILIMIT $DIR
 480         $SHOW_QUOTA_USER
 481         $SHOW_QUOTA_GROUP
 482
 483         echo "  Create more than $ILIMIT files and more than $BLIMIT kbytes ..."
 484         createmany -m $DIR/$tdir/$tfile-0_ $((ILIMIT + 1)) || \
 485                 error "touch failure, expect success"
 486         dd if=/dev/zero of=$DIR/$tdir/$tfile-0_1 bs=$BLK_SZ count=$((BLIMIT+1)) || error "write failure, expect success"
 487
 488         echo "  Chown files to $TSTUSR.$TSTUSR ..."
 489         for i in `seq 0 $ILIMIT`; do
 490         chown $TSTUSR.$TSTUSR $DIR/$tdir/$tfile-0_$i || \
 491                         error "chown failure, but expect success"
 492         done
 493
 494         # cleanup
 495         unlinkmany $DIR/$tdir/$tfile-0_ $((ILIMIT + 1))
 496
 497         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 498         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 499 }
 500 run_test 5 "Chown & chgrp successfully even out of block/file quota ==="
 501
 502 # block quota acquire & release
 503 test_6() {
 504         if [ $OSTCOUNT -lt 2 ]; then
 505                 skip "$OSTCOUNT < 2, too few osts"
 506                 return 0;
 507         fi
 508
 509         mkdir -p $DIR/$tdir
 510         chmod 0777 $DIR/$tdir
 511
 512         LIMIT=$((BUNIT_SZ * (OSTCOUNT + 1) * 5)) # 5 bunits per server
 513         FILEA="$DIR/$tdir/$tfile-0_a"
 514         FILEB="$DIR/$tdir/$tfile-0_b"
 515
 516         echo "  Set block limit $LIMIT kbytes to $TSTUSR.$TSTUSR"
 517         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 518         $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
 519         $SHOW_QUOTA_USER
 520         $SHOW_QUOTA_GROUP
 521
 522         echo "  Create filea on OST0 and fileb on OST1"
 523         $LFS setstripe $FILEA -i 0 -c 1
 524         $LFS setstripe $FILEB -i 1 -c 1
 525         chown $TSTUSR.$TSTUSR $FILEA
 526         chown $TSTUSR.$TSTUSR $FILEB
 527
 528         echo "  Exceed quota limit ..."
 529         RUNDD="$RUNAS dd if=/dev/zero of=$FILEB bs=$BLK_SZ"
 530         $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
 531                 error "write fileb failure, but expect success"
 532
 533         sync; sleep 1; sync;
 534         $SHOW_QUOTA_USER
 535         $SHOW_QUOTA_GROUP
 536         $RUNDD seek=$LIMIT count=$((BUNIT_SZ * OSTCOUNT)) && \
 537                 error "write fileb success, but expect EDQUOT"
 538         sync; sleep 1; sync;
 539         echo "  Write to OST0 return EDQUOT"
 540         # this write maybe cache write, ignore it's failure
 541         RUNDD="$RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ"
 542         $RUNDD count=$(($BUNIT_SZ * 2)) || true
 543         sync; sleep 1; sync;
 544         $SHOW_QUOTA_USER
 545         $SHOW_QUOTA_GROUP
 546         $RUNDD count=$((BUNIT_SZ * 2)) seek=$((BUNIT_SZ *2)) && \
 547                 error "write filea success, but expect EDQUOT"
 548
 549         echo "  Remove fileb to let OST1 release quota"
 550         rm -f $FILEB
 551         sync; sleep 10; sync; # need to allow journal commit for small fs
 552
 553         echo "  Write to OST0"
 554         $RUNDD count=$((LIMIT - BUNIT_SZ * OSTCOUNT)) || \
 555                 error "write filea failure, expect success"
 556         echo "  Done"
 557
 558         # cleanup
 559         rm -f $FILEA
 560         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 561         $LFS setquota -g $TSTUSR 0 0 0 0 $DIR
 562         return 0
 563 }
 564 run_test 6 "Block quota acquire & release ========="
 565
 566 # quota recovery (block quota only by now)
 567 test_7()
 568 {
 569         mkdir -p $DIR/$tdir
 570         chmod 0777 $DIR/$tdir
 571
 572         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
 573         TESTFILE="$DIR/$tdir/$tfile-0"
 574
 575         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 576
 577         $LFS setstripe $TESTFILE -c 1
 578         chown $TSTUSR.$TSTUSR $TESTFILE
 579
 580         echo "  Write to OST0..."
 581         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ || \
 582                 error "write failure, but expect success"
 583
 584         #define OBD_FAIL_OBD_DQACQ               0x604
 585         echo 0x604 > /proc/sys/lustre/fail_loc
 586         echo "  Remove files on OST0"
 587         rm -f $TESTFILE
 588         echo 0 > /proc/sys/lustre/fail_loc
 589
 590         echo "  Trigger recovery..."
 591         OSC0_UUID="`$LCTL dl | awk '$3 ~ /osc/ { print $1 }'`"
 592         for i in $OSC0_UUID; do
 593                 $LCTL --device $i activate || error "activate osc failed!"
 594         done
 595
 596         # sleep a while to wait for recovery done
 597         sleep 20
 598
 599         # check limits
 600         PATTERN="`echo $DIR | sed 's/\//\\\\\//g'`"
 601         TOTAL_LIMIT="`$LFS quota -u $TSTUSR $DIR | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
 602         [ $TOTAL_LIMIT -eq $LIMIT ] || error "total limits not recovery!"
 603         echo "  total limits = $TOTAL_LIMIT"
 604
 605         OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
 606         [ -z "$OST0_UUID" ] && OST0_UUID=`do_facet ost1 "$LCTL dl | grep -m1 obdfilter" | awk '{print $((NF-1))}'`
 607         OST0_LIMIT="`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $3 }'`"
 608         [ $OST0_LIMIT -eq $BUNIT_SZ ] || error "high limits not released!"
 609         echo "  limits on $OST0_UUID = $OST0_LIMIT"
 610
 611         # cleanup
 612         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR
 613 }
 614 run_test 7 "Quota recovery (only block limit) ======"
 615
 616 # run dbench with quota enabled
 617 test_8() {
 618         mkdir -p $DIR/$tdir
 619         BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
 620         FILE_LIMIT=1000000
 621
 622         wait_delete_completed
 623
 624         echo "  Set enough high limit for user: $TSTUSR"
 625         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 626         echo "  Set enough high limit for group: $TSTUSR"
 627         $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 628
 629         chmod 0777 $DIR/$tdir
 630         local duration=""
 631         [ "$SLOW" = "no" ] && duration=" -t 120"
 632         $RUNAS bash rundbench -D $DIR/$tdir 3 $duration || error "dbench failed!"
 633
 634         sync; sleep 3; sync;
 635
 636         return 0
 637 }
 638 run_test 8 "Run dbench with quota enabled ==========="
 639
 640 # run for fixing bug10707, it needs a big room. test for 64bit
 641 KB=1024
 642 GB=$((KB * 1024 * 1024))
 643 FSIZE=$((OSTCOUNT * 9 / 2))
 644 # Use this as dd bs to decrease time
 645 # inode->i_blkbits = min(PTLRPC_MAX_BRW_BITS+1, LL_MAX_BLKSIZE_BITS);
 646 blksize=$((1 << 21)) # 2Mb
 647
 648 test_9() {
 649         chmod 0777 $DIR/$tdir
 650         lustrefs_size=`(echo 0; df -t lustre -P | awk '{print $4}') | tail -n 1`
 651         size_file=$((FSIZE * GB))
 652         echo "lustrefs_size:$lustrefs_size  size_file:$((size_file / KB))"
 653         if [ $((lustrefs_size * KB)) -lt $size_file ]; then
 654                 skip "less than $size_file bytes free"
 655                 return 0;
 656         fi
 657
 658         set_blk_unitsz $((1024 * 100))
 659         set_blk_tunesz $((1024 * 50))
 660
 661         # set the D_QUOTA flag
 662         debugsave
 663         sysctl -w lnet.debug="+quota"
 664
 665         TESTFILE="$DIR/$tdir/$tfile-0"
 666
 667         BLK_LIMIT=$((100 * KB * KB)) # 100G
 668         FILE_LIMIT=1000000
 669
 670         echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
 671         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 672         echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
 673         $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 674
 675         echo "  Set stripe"
 676         [ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE -c $OSTCOUNT
 677         touch $TESTFILE
 678         chown $TSTUSR.$TSTUSR $TESTFILE
 679
 680         $SHOW_QUOTA_USER
 681         $SHOW_QUOTA_GROUP
 682
 683         echo "    Write the big file of $FSIZE G ..."
 684         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
 685                error "(usr) write $FSIZE G file failure, but expect success"
 686
 687         $SHOW_QUOTA_USER
 688         $SHOW_QUOTA_GROUP
 689
 690         echo "    delete the big file of $FSIZE G..."
 691         $RUNAS rm -f $TESTFILE
 692
 693         $SHOW_QUOTA_USER
 694         $SHOW_QUOTA_GROUP
 695
 696         echo "    write the big file of 2 G..."
 697         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((2 * GB / blksize)) || \
 698                error "(usr) write 2 G file failure, but expect seccess"
 699
 700         echo "    delete the big file of 2 G..."
 701         $RUNAS rm -f $TESTFILE
 702         RC=$?
 703
 704         set_blk_tunesz $BTUNE_SZ
 705         set_blk_unitsz $BUNIT_SZ
 706
 707         debugrestore
 708         wait_delete_completed
 709
 710         return $RC
 711 }
 712 run_test 9 "run for fixing bug10707(64bit) ==========="
 713
 714 # run for fixing bug10707, it need a big room. test for 32bit
 715 test_10() {
 716         mkdir -p $DIR/$tdir
 717         chmod 0777 $DIR/$tdir
 718         lustrefs_size=`(echo 0; df -t lustre -P | awk '{print $4}') | tail -n 1`
 719         size_file=$((FSIZE * GB))
 720         echo "lustrefs_size:$lustrefs_size  size_file:$((size_file / KB))"
 721         if [ $((lustrefs_size * KB)) -lt $size_file ]; then
 722                 skip "less than $size_file bytes free"
 723                 return 0;
 724         fi
 725
 726         sync; sleep 10; sync;
 727
 728         set_blk_unitsz $((1024 * 100))
 729         set_blk_tunesz $((1024 * 50))
 730
 731         # set the D_QUOTA flag
 732         debugsave
 733         sysctl -w lnet.debug="+quota"
 734
 735         # make qd_count 32 bit
 736         sysctl -w lustre.fail_loc=0xA00
 737
 738         TESTFILE="$DIR/$tdir/$tfile-0"
 739
 740         BLK_LIMIT=$((100 * KB * KB)) # 100G
 741         FILE_LIMIT=1000000
 742
 743         echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for user: $TSTUSR"
 744         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 745         echo "  Set enough high limit(block:$BLK_LIMIT; file: $FILE_LIMIT) for group: $TSTUSR"
 746         $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $DIR
 747
 748         echo "  Set stripe"
 749         [ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE -c $OSTCOUNT
 750         touch $TESTFILE
 751         chown $TSTUSR.$TSTUSR $TESTFILE
 752
 753         $SHOW_QUOTA_USER
 754         $SHOW_QUOTA_GROUP
 755
 756         echo "    Write the big file of $FSIZE G ..."
 757         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((size_file / blksize)) || \
 758                 error "(usr) write $FSIZE G file failure, but expect success"
 759
 760         $SHOW_QUOTA_USER
 761         $SHOW_QUOTA_GROUP
 762
 763         echo "    delete the big file of $FSIZE G..."
 764         $RUNAS rm -f $TESTFILE
 765
 766         $SHOW_QUOTA_USER
 767         $SHOW_QUOTA_GROUP
 768
 769         echo "    write the big file of 2 G..."
 770         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$blksize count=$((2 * GB / blkzise)) || \
 771                 error "(usr) write 2 G file failure, but expect success"
 772
 773         echo "    delete the big file of 2 G..."
 774         $RUNAS rm -f $TESTFILE
 775
 776         RC=$?
 777
 778         # clear the flage
 779         debugrestore
 780
 781         # make qd_count 64 bit
 782         sysctl -w lustre.fail_loc=0
 783
 784         set_blk_tunesz $BTUNE_SZ
 785         set_blk_unitsz $BUNIT_SZ
 786
 787         wait_delete_completed
 788
 789         return $RC
 790 }
 791 run_test 10 "run for fixing bug10707(32bit) ==========="
 792
 793 test_11() {
 794        wait_delete_completed
 795
 796        #prepare the test
 797        block_limit=`(echo 0; df -t lustre -P | awk '{print $(NF - 4)}') | tail -n 1`
 798        echo $block_limit
 799        orig_dbr=`cat /proc/sys/vm/dirty_background_ratio`
 800        orig_dec=`cat /proc/sys/vm/dirty_expire_centisecs`
 801        orig_dr=`cat /proc/sys/vm/dirty_ratio`
 802        orig_dwc=`cat /proc/sys/vm/dirty_writeback_centisecs`
 803        echo 1  > /proc/sys/vm/dirty_background_ratio
 804        echo 30 > /proc/sys/vm/dirty_expire_centisecs
 805        echo 1  > /proc/sys/vm/dirty_ratio
 806        echo 50 > /proc/sys/vm/dirty_writeback_centisecs
 807        TESTDIR="$DIR/$tdir"
 808        local RV=0
 809
 810        #do the test
 811        local SECS=0
 812        local REPS=3
 813        [ "$SLOW" = no ] && REPS=1
 814        local sleep=20
 815        local i=1
 816        while [ $i -le $REPS ]; do
 817            echo "test: cycle($i of $REPS) start at $(date)"
 818            mkdir -p $TESTDIR && chmod 777 $TESTDIR
 819            echo -n "    create a file for uid "
 820            for j in `seq 1 30`; do
 821                echo -n "$j "
 822                # 30MB per dd for a total of 900MB (if space even permits)
 823                runas -u $j dd if=/dev/zero of=$TESTDIR/$tfile  bs=$blksize count=15 > /dev/null 2>&1 &
 824            done
 825            echo ""
 826            PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
 827            LAST_USED=0
 828            while [ $PROCS -gt 0 ]; do
 829              sleep 20
 830              SECS=$((SECS + sleep))
 831              PROCS=$(ps -ef | grep -v grep | grep "dd if /dev/zero of $TESTDIR" | wc -l)
 832              USED=$(du -s $TESTDIR | awk '{print $1}')
 833              PCT=$(($USED * 100 / $block_limit))
 834              echo "${i}/${REPS} ${PCT}% p${PROCS} t${SECS}  "
 835              if [ $USED -le $LAST_USED ]; then
 836                  kill -9 $(ps -ef | grep "dd if /dev/zero of $TESTDIR" | grep -v grep | awk '{ print $2 }')
 837                  i=$REPS
 838                  RV=2
 839                  break
 840              fi
 841              LAST_USED=$USED
 842            done
 843            echo "    removing the test files..."
 844            rm -f $TESTDIR/$tfile
 845            echo "cycle $i done at $(date)"
 846            i=$[$i+1]
 847        done
 848        echo "Test took $SECS sec"
 849
 850        #clean
 851        echo $orig_dbr > /proc/sys/vm/dirty_background_ratio
 852        echo $orig_dec > /proc/sys/vm/dirty_expire_centisecs
 853        echo $orig_dr  > /proc/sys/vm/dirty_ratio
 854        echo $orig_dwc > /proc/sys/vm/dirty_writeback_centisecs
 855        if [ $RV -ne 0 ]; then
 856            error "Nothing was written for $SECS sec ... aborting"
 857        fi
 858        return $RV
 859 }
 860 run_test 11 "run for fixing bug10912 ==========="
 861
 862
 863 # test a deadlock between quota and journal b=11693
 864 test_12() {
 865         mkdir -p $DIR/$tdir
 866         chmod 0777 $DIR/$tdir
 867
 868         [ "$(grep $DIR2 /proc/mounts)" ] || mount_client $DIR2 || \
 869                 { skip "Need lustre mounted on $MOUNT2 " && retutn 0; }
 870
 871         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
 872         TESTFILE="$DIR/$tdir/$tfile-0"
 873         TESTFILE2="$DIR2/$tdir/$tfile-1"
 874
 875         echo "   User quota (limit: $LIMIT kbytes)"
 876         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 877
 878         $LFS setstripe $TESTFILE -i 0 -c 1
 879         chown $TSTUSR.$TSTUSR $TESTFILE
 880         $LFS setstripe $TESTFILE2 -i 0 -c 1
 881         chown $TSTUSR2.$TSTUSR2 $TESTFILE2
 882
 883         #define OBD_FAIL_OST_HOLD_WRITE_RPC      0x21f
 884         sysctl -w lustre.fail_loc=0x0000021f
 885
 886         echo "   step1: write out of block quota ..."
 887         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT*2)) &
 888         DDPID=$!
 889         sleep 5
 890         $RUNAS2 dd if=/dev/zero of=$TESTFILE2 bs=$BLK_SZ count=102400 &
 891         DDPID1=$!
 892
 893         echo  "   step2: testing ......"
 894         count=0
 895         while [ true ]; do
 896             if [ -z `ps -ef | awk '$2 == '${DDPID1}' { print $8 }'` ]; then break; fi
 897             count=$[count+1]
 898             if [ $count -gt 64 ]; then
 899                 sysctl -w lustre.fail_loc=0
 900                 error "dd should be finished!"
 901             fi
 902             sleep 1
 903         done
 904         echo "(dd_pid=$DDPID1, time=$count)successful"
 905
 906         #Recover fail_loc and dd will finish soon
 907         sysctl -w lustre.fail_loc=0
 908
 909         echo  "   step3: testing ......"
 910         count=0
 911         while [ true ]; do
 912             if [ -z `ps -ef | awk '$2 == '${DDPID}' { print $8 }'` ]; then break; fi
 913             count=$[count+1]
 914             if [ $count -gt 100 ]; then
 915                 error "dd should be finished!"
 916             fi
 917             sleep 1
 918         done
 919         echo "(dd_pid=$DDPID, time=$count)successful"
 920
 921         rm -f $TESTFILE $TESTFILE2
 922
 923         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
 924 }
 925 run_test 12 "test a deadlock between quota and journal ==="
 926
 927 # test multiple clients write block quota b=11693
 928 test_13() {
 929         # one OST * 10 + (mds + other OSTs)
 930         LIMIT=$((BUNIT_SZ * 10 + (BUNIT_SZ * OSTCOUNT)))
 931         TESTFILE="$DIR/$tdir/$tfile"
 932         mkdir -p $DIR/$tdir
 933
 934         echo "   User quota (limit: $LIMIT kbytes)"
 935         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
 936         $SHOW_QUOTA_USER
 937
 938         $LFS setstripe $TESTFILE -i 0 -c 1
 939         chown $TSTUSR.$TSTUSR $TESTFILE
 940         $LFS setstripe $TESTFILE.2 -i 0 -c 1
 941         chown $TSTUSR.$TSTUSR $TESTFILE.2
 942
 943         echo "   step1: write out of block quota ..."
 944         # one bunit will give mds
 945         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
 946         DDPID=$!
 947         $RUNAS dd if=/dev/zero of=$TESTFILE.2 bs=$BLK_SZ count=$[($LIMIT - $BUNIT_SZ) / 2] &
 948         DDPID1=$!
 949
 950         echo  "   step2: testing ......"
 951         count=0
 952         while [ true ]; do
 953             if [ -z `ps -ef | awk '$2 == '${DDPID}' { print $8 }'` ]; then break; fi
 954             count=$[count+1]
 955             if [ $count -gt 64 ]; then
 956                 error "dd should be finished!"
 957             fi
 958             sleep 1
 959         done
 960         echo "(dd_pid=$DDPID, time=$count)successful"
 961
 962         count=0
 963         while [ true ]; do
 964             if [ -z `ps -ef | awk '$2 == '${DDPID1}' { print $8 }'` ]; then break; fi
 965             count=$[count+1]
 966             if [ $count -gt 64 ]; then
 967                 error "dd should be finished!"
 968             fi
 969             sleep 1
 970         done
 971         echo "(dd_pid=$DDPID1, time=$count)successful"
 972
 973         sync; sleep 5; sync;
 974
 975         echo  "   step3: checking ......"
 976         fz=`stat -c %s $TESTFILE`
 977         fz2=`stat -c %s $TESTFILE.2`
 978         $SHOW_QUOTA_USER
 979         [ $((fz + fz2)) -lt $((BUNIT_SZ * BLK_SZ * 10)) ] && \
 980                 error "files too small $fz + $fz2 < $((BUNIT_SZ * BLK_SZ * 10))"
 981
 982         rm -f $TESTFILE $TESTFILE.2
 983
 984         $LFS setquota -u $TSTUSR 0 0 0 0 $DIR           # clear user limit
 985 }
 986 run_test 13 "test multiple clients write block quota ==="
 987
 988 check_if_quota_zero(){
 989         line=`$LFS quota -$1 $2 $DIR | wc -l`
 990         for i in `seq 3 $line`; do
 991             if [ $i -eq 3 ]; then
 992                 field="3 4 6 7"
 993             else
 994                 field="3 5"
 995             fi
 996             for j in $field; do
 997                 tmp=`$LFS quota -$1 $2 $DIR | sed -n ${i}p |
 998                      awk  '{print $'"$j"'}'`
 999                 [ -n "$tmp" ] && [ $tmp -ne 0 ] && $LFS quota -$1 $2 $DIR && \
1000                     error "quota on $2 isn't clean"
1001             done
1002         done
1003         echo "pass check_if_quota_zero"
1004 }
1005
1006 pre_test_14 () {
1007         # reboot the lustre
1008         cd $T_PWD; sh llmountcleanup.sh || error "llmountcleanup failed"
1009         sh llmount.sh
1010         pre_test
1011         run_test 0 "reboot lustre"
1012 }
1013
1014 pre_test_14
1015
1016 test_14a() {    # was test_14 b=12223 -- setting quota on root
1017         TESTFILE="$DIR/$tdir/$tfile"
1018         mkdir -p $DIR/$tdir
1019
1020         # out of root's file and block quota
1021         $LFS setquota -u root 10 10 10 10 $DIR
1022         createmany -m ${TESTFILE} 20 || \
1023             error "unexpected: user(root) create files failly!"
1024         dd if=/dev/zero of=$TESTFILE bs=4k count=4096 || \
1025             error "unexpected: user(root) write files failly!"
1026         chmod 666 $TESTFILE
1027         $RUNAS dd if=/dev/zero of=${TESTFILE} seek=4096 bs=4k count=4096 && \
1028             error "unexpected: user(quota_usr) write a file successfully!"
1029
1030         # trigger the llog
1031         chmod 777 $DIR
1032         for i in `seq 1 10`; do $RUNAS touch ${TESTFILE}a_$i; done
1033         for i in `seq 1 10`; do $RUNAS rm -f ${TESTFILE}a_$i; done
1034
1035         # do the check
1036         dmesg | tail | grep "\-122" |grep llog_obd_origin_add && error "err -122 not found in dmesg"
1037         $LFS setquota -u root 0 0 0 0 $DIR
1038         #check_if_quota_zero u root
1039
1040         # clean
1041         unlinkmany ${TESTFILE} 15
1042         rm -f $TESTFILE
1043 }
1044 run_test 14a "test setting quota on root ==="
1045
1046 # turn off quota
1047 test_99()
1048 {
1049         $LFS quotaoff $DIR
1050         return 0
1051 }
1052 run_test 99 "Quota off ==============================="
1053
1054
1055 log "cleanup: ======================================================"
1056 cd $ORIG_PWD
1057 post_test
1058 check_and_cleanup_lustre
1059 echo '=========================== finished ==============================='
1060 [ -f "$QUOTALOG" ] && cat $QUOTALOG && grep -q FAIL $QUOTALOG && exit 1 || true
1061 echo "$0: completed"