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