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=${ALWAYS_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 LFS=${LFS:-lfs}
  35 LCTL=${LCTL:-lctl}
  36 SETSTRIPE=${SETSTRIPE:-"$LFS setstripe"}
  37 TSTID=${TSTID:-60000}
  38 RUNAS=${RUNAS:-"runas -u $TSTID"}
  39 TSTUSR=${TSTUSR:-"quota_usr"}
  40 BLK_SZ=1024
  41 BUNIT_SZ=${BUNIT_SZ:-1000}      # default 1000 quota blocks
  42 BTUNE_SZ=${BTUNE_SZ:-500}       # default 50% of BUNIT_SZ
  43 IUNIT_SZ=${IUNIT_SZ:-10}        # default 10 files
  44 ITUNE_SZ=${ITUNE_SZ:-5}         # default 50% of IUNIT_SZ
  45 MAX_DQ_TIME=604800
  46 MAX_IQ_TIME=604800
  47
  48 log() {
  49         echo "$*"
  50         $LCTL mark "$*" 2> /dev/null || true
  51 }
  52
  53 trace() {
  54         log "STARTING: $*"
  55         strace -o $TMP/$1.strace -ttt $*
  56         RC=$?
  57         log "FINISHED: $*: rc $RC"
  58         return 1
  59 }
  60 TRACE=${TRACE:-""}
  61
  62 run_one() {
  63         BEFORE=`date +%s`
  64         log "== test $1: $2= `date +%H:%M:%S` ($BEFORE)"
  65         export TESTNAME=test_$1
  66         test_$1 || error "exit with rc=$?"
  67         unset TESTNAME
  68         pass "($((`date +%s` - $BEFORE))s)"
  69         cd $SAVE_PWD
  70 }
  71
  72 build_test_filter() {
  73         for O in $ONLY; do
  74             eval ONLY_${O}=true
  75         done
  76         for E in $EXCEPT $ALWAYS_EXCEPT; do
  77             eval EXCEPT_${E}=true
  78         done
  79         # turn on/off quota tests must be included
  80         eval ONLY_0=true
  81         eval ONLY_99=true
  82 }
  83
  84 _basetest() {
  85         echo $*
  86 }
  87
  88 basetest() {
  89         IFS=abcdefghijklmnopqrstuvwxyz _basetest $1
  90 }
  91
  92 run_test() {
  93          base=`basetest $1`
  94          if [ "$ONLY" ]; then
  95                  testname=ONLY_$1
  96                  if [ ${!testname}x != x ]; then
  97                         run_one $1 "$2"
  98                         return $?
  99                  fi
 100                  testname=ONLY_$base
 101                  if [ ${!testname}x != x ]; then
 102                          run_one $1 "$2"
 103                          return $?
 104                  fi
 105                  echo -n "."
 106                  return 0
 107         fi
 108         testname=EXCEPT_$1
 109         if [ ${!testname}x != x ]; then
 110                  echo "skipping excluded test $1"
 111                  return 0
 112         fi
 113         testname=EXCEPT_$base
 114         if [ ${!testname}x != x ]; then
 115                  echo "skipping excluded test $1 (base $base)"
 116                  return 0
 117         fi
 118         run_one $1 "$2"
 119         return $?
 120 }
 121
 122 [ "$QUOTALOG" ] && rm -f $QUOTALOG || true
 123
 124 error() {
 125         sysctl -w lustre.fail_loc=0
 126         log "FAIL: $TESTNAME $@"
 127         if [ "$QUOTALOG" ]; then
 128                 echo "FAIL: $TESTNAME $@" >> $QUOTALOG
 129         else
 130                 exit 1
 131         fi
 132 }
 133
 134 pass() {
 135         echo PASS $@
 136 }
 137
 138 mounted_lustre_filesystems() {
 139         awk '($3 ~ "lustre" && $1 ~ ":") { print $2 }' /proc/mounts
 140 }
 141 MOUNT="`mounted_lustre_filesystems`"
 142 if [ -z "$MOUNT" ]; then
 143         export QUOTA_OPTS="quotaon=ug"
 144         sh llmount.sh
 145         MOUNT="`mounted_lustre_filesystems`"
 146         [ -z "$MOUNT" ] && error "NAME=$NAME not mounted"
 147         I_MOUNTED=yes
 148 fi
 149
 150 [ `echo $MOUNT | wc -w` -gt 1 ] && error "NAME=$NAME mounted more than once"
 151
 152 DIR=${DIR:-$MOUNT}
 153 [ -z "`echo $DIR | grep $MOUNT`" ] && echo "$DIR not in $MOUNT" && exit 99
 154
 155 LPROC=/proc/fs/lustre
 156 LOVNAME=`cat $LPROC/llite/*/lov/common_name | tail -n 1`
 157 OSTCOUNT=`cat $LPROC/lov/$LOVNAME/numobd`
 158 STRIPECOUNT=`cat $LPROC/lov/$LOVNAME/stripecount`
 159 STRIPESIZE=`cat $LPROC/lov/$LOVNAME/stripesize`
 160 ORIGFREE=`cat $LPROC/lov/$LOVNAME/kbytesavail`
 161 MAXFREE=${MAXFREE:-$((200000 * $OSTCOUNT))}
 162 MDS=$(\ls $LPROC/mds 2> /dev/null | grep -v num_refs | tail -n 1)
 163 TSTDIR="$MOUNT/quota_dir"
 164
 165 build_test_filter
 166
 167
 168 # set_blk_tunables(btune_sz)
 169 set_blk_tunesz() {
 170         # set btune size on all obdfilters
 171         for i in `ls /proc/fs/lustre/obdfilter/*/quota_btune_sz`; do
 172                 echo $(($1 * $BLK_SZ)) > $i
 173         done
 174         # set btune size on mds
 175         for i in `ls /proc/fs/lustre/mds/lustre-MDT*/quota_btune_sz`; do
 176                 echo $(($1 * $BLK_SZ)) > $i
 177         done
 178 }
 179 # se_blk_unitsz(bunit_sz)
 180 set_blk_unitsz() {
 181         for i in `ls /proc/fs/lustre/obdfilter/*/quota_bunit_sz`; do
 182                 echo $(($1 * $BLK_SZ)) > $i
 183         done
 184         for i in `ls /proc/fs/lustre/mds/lustre-MDT*/quota_bunit_sz`; do
 185                 echo $(($1 * $BLK_SZ)) > $i
 186         done
 187 }
 188 # set_file_tunesz(itune_sz)
 189 set_file_tunesz() {
 190         # set iunit and itune size on all obdfilters
 191         for i in `ls /proc/fs/lustre/obdfilter/*/quota_itune_sz`; do
 192                 echo $1 > $i
 193         done
 194         # set iunit and itune size on mds
 195         for i in `ls /proc/fs/lustre/mds/lustre-MDT*/quota_itune_sz`; do
 196                 echo $1 > $i
 197         done
 198
 199
 200 }
 201 # set_file_unitsz(iunit_sz)
 202 set_file_unitsz() {
 203         for i in `ls /proc/fs/lustre/obdfilter/*/quota_iunit_sz`; do
 204                 echo $1 > $i
 205         done;
 206         for i in `ls /proc/fs/lustre/mds/lustre-MDT*/quota_iunit_sz`; do
 207                 echo $1 > $i
 208         done
 209 }
 210
 211 # These are for test on local machine,if run sanity-quota.sh on
 212 # real cluster, ltest should have setup the test environment:
 213 #
 214 # - create test user/group on all servers with same id.
 215 # - set unit size/tune on all servers size to reasonable value.
 216 pre_test() {
 217         if [ -z "$NOSETUP" ]; then
 218                 # set block tunables
 219                 set_blk_tunesz $BTUNE_SZ
 220                 set_blk_unitsz $BUNIT_SZ
 221                 # set file tunables
 222                 set_file_tunesz $ITUNE_SZ
 223                 set_file_unitsz $IUNIT_SZ
 224         fi
 225 }
 226 pre_test
 227
 228 post_test() {
 229         if [ -z "$NOSETUP" ]; then
 230                 # restore block tunables to default size
 231                 set_blk_unitsz $((1024 * 100))
 232                 set_blk_tunesz $((1024 * 50))
 233                 # restore file tunables to default size
 234                 set_file_unitsz 5000
 235                 set_file_tunesz 2500
 236         fi
 237 }
 238
 239 setup() {
 240         # create local test group
 241         GRP="`cat /etc/group | grep "$TSTUSR" | awk -F: '{print $1}'`"
 242         if [ -z "$GRP" ]; then
 243                 groupadd -g $TSTID "$TSTUSR"
 244         fi
 245         TSTID="`cat /etc/group | grep "$TSTUSR" | awk -F: '{print $3}'`"
 246
 247         # create test user
 248         USR="`cat /etc/passwd | grep "$TSTUSR" | awk -F: '{print $1}'`"
 249         if [ -z "$USR" ]; then
 250                 useradd -u $TSTID -g $TSTID -d /tmp "$TSTUSR"
 251         fi
 252
 253         RUNAS="runas -u $TSTID"
 254
 255         # create test directory
 256         [ -d $TSTDIR ] || mkdir $TSTDIR
 257         chmod 777 $TSTDIR
 258 }
 259 setup
 260
 261 # set quota
 262 test_0() {
 263         $LFS quotaoff -ug $MOUNT
 264         $LFS quotacheck -ug $MOUNT
 265
 266         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
 267         $LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
 268 }
 269 run_test 0 "Set quota ============================="
 270
 271 # block hard limit (normal use and out of quota)
 272 test_1() {
 273         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
 274         TESTFILE="$TSTDIR/quota_tst10"
 275
 276         echo "  User quota (limit: $LIMIT bytes)"
 277         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
 278
 279         $LFS setstripe $TESTFILE 65536 0 1
 280         chown $TSTUSR.$TSTUSR $TESTFILE
 281
 282         echo "    Write ..."
 283         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) > /dev/null 2>&1 || error "(usr) write failure, but expect success"
 284         echo "    Done"
 285         echo "    Write out of block quota ..."
 286         # this time maybe cache write,  ignore it's failure
 287         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) > /dev/null 2>&1 || echo " " > /dev/null
 288         # flush cache, ensure noquota flag is setted on client
 289         sync; sleep 1; sync;
 290         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT > /dev/null 2>&1 && error "(usr) write success, but expect EDQUOT"
 291         echo "    EDQUOT"
 292
 293         rm -f $TESTFILE
 294
 295         echo "  Group quota (limit: $LIMIT bytes)"
 296         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT         # clear user limit
 297         $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $MOUNT
 298         TESTFILE="$TSTDIR/quota_tst11"
 299
 300         $LFS setstripe $TESTFILE 65536 0 1
 301         chown $TSTUSR.$TSTUSR $TESTFILE
 302
 303         echo "    Write ..."
 304         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) > /dev/null 2>&1 || error "(grp) write failure, but expect success"
 305         echo "    Done"
 306         echo "    Write out of block quota ..."
 307         # this time maybe cache write, ignore it's failure
 308         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) > /dev/null 2>&1 || echo " " > /dev/null
 309         sync; sleep 1; sync;
 310         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT > /dev/null 2>&1 && error "(grp) write success, but expect EDQUOT"
 311         echo "    EDQUOT"
 312
 313         # cleanup
 314         rm -f $TESTFILE
 315         $LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
 316 }
 317 run_test 1 "Block hard limit (normal use and out of quota) ==="
 318
 319 # file hard limit (normal use and out of quota)
 320 test_2() {
 321         LIMIT=$(($IUNIT_SZ * 10)) # 10 iunits on mds
 322         TESTFILE="$TSTDIR/quota_tstr20"
 323
 324         echo "  User quota (limit: $LIMIT files)"
 325         $LFS setquota -u $TSTUSR 0 0 0 $LIMIT $MOUNT
 326
 327         echo "    Create $LIMIT files ..."
 328         for i in `seq ${LIMIT}`; do
 329                 $RUNAS touch ${TESTFILE}_$i > /dev/null 2>&1 || error "(usr) touch failure, but except success"
 330         done
 331         echo "    Done"
 332         echo "    Create out of file quota ..."
 333         $RUNAS touch ${TESTFILE}_xxx > /dev/null 2>&1 && error "(usr) touch success, but expect EDQUOT"
 334         echo "    EDQUOT"
 335
 336         for i in `seq ${LIMIT}`; do
 337                 rm -f ${TESTFILE}_$i
 338         done
 339
 340         echo "  Group quota (limit: $LIMIT files)"
 341         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT         # clear user limit
 342         $LFS setquota -g $TSTUSR 0 0 0 $LIMIT $MOUNT
 343         TESTFILE="$TSTDIR/quota_tst21"
 344
 345         echo "    Create $LIMIT files ..."
 346         for i in `seq ${LIMIT}`; do
 347                 $RUNAS touch ${TESTFILE}_$i > /dev/null 2>&1 || error "(grp) touch failure, but expect success"
 348         done
 349         echo "    Done"
 350         echo "    Create out of file quota ..."
 351         $RUNAS touch ${TESTFILE}_xxx > /dev/null 2>&1 && error "(grp) touch success, but expect EDQUOT"
 352         echo "    EDQUOT"
 353
 354         # cleanup
 355         for i in `seq ${LIMIT}`; do
 356                 rm -f ${TESTFILE}_$i
 357         done
 358         $LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
 359 }
 360 run_test 2 "File hard limit (normal use and out of quota) ==="
 361
 362 test_block_soft() {
 363         TESTFILE=$1
 364         GRACE=$2
 365
 366         echo "    Write to exceed soft limit"
 367         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ >/dev/null 2>&1 || error "write failure, but expect success"
 368         sync; sleep 1; sync;
 369
 370         echo "    Write before timer goes off"
 371         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$BUNIT_SZ >/dev/null 2>&1 || error "write failure, but expect success"
 372         echo "    Done"
 373
 374         echo "    Sleep $GRACE seconds ..."
 375         sleep $GRACE
 376
 377         echo "    Write after timer goes off"
 378         # maybe cache write, ignore.
 379         sync; sleep 1; sync;
 380         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$(($BUNIT_SZ * 2)) >/dev/null 2>&1 || echo " " > /dev/null
 381         sync; sleep 1; sync;
 382         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=1 seek=$(($BUNIT_SZ * 3)) >/dev/null 2>&1 && error "write success, but expect EDQUOT"
 383         echo "    EDQUOT"
 384
 385         echo "    Unlink file to stop timer"
 386         rm -f $TESTFILE
 387         echo "    Done"
 388
 389         echo "    Write ..."
 390         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ >/dev/null 2>&1 || error "write failure, but expect success"
 391         echo "    Done"
 392
 393         # cleanup
 394         rm -f $TESTFILE
 395 }
 396
 397 # block soft limit (start timer, timer goes off, stop timer)
 398 test_3() {
 399         LIMIT=$(( $BUNIT_SZ * 2 )) # 1 bunit on mds and 1 bunit on the ost
 400         GRACE=10
 401
 402         echo "  User quota (soft limit: $LIMIT bytes  grace: $GRACE seconds)"
 403         TESTFILE="$TSTDIR/quota_tst30"
 404         $LFS setstripe $TESTFILE 65536 0 1
 405         chown $TSTUSR.$TSTUSR $TESTFILE
 406
 407         $LFS setquota -t -u $GRACE $MAX_IQ_TIME $MOUNT
 408         $LFS setquota -u $TSTUSR $LIMIT 0 0 0 $MOUNT
 409
 410         test_block_soft $TESTFILE $GRACE
 411         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
 412
 413         echo "  Group quota (soft limit: $LIMIT bytes  grace: $GRACE seconds)"
 414         TESTFILE="$TSTDIR/quota_tst31"
 415         $LFS setstripe $TESTFILE 65536 0 1
 416         chown $TSTUSR.$TSTUSR $TESTFILE
 417
 418         $LFS setquota -t -g $GRACE $MAX_IQ_TIME $MOUNT
 419         $LFS setquota -g $TSTUSR $LIMIT 0 0 0 $MOUNT
 420         TESTFILE="$TSTDIR/quota_tst31"
 421
 422         test_block_soft $TESTFILE $GRACE
 423         $LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
 424 }
 425 run_test 3 "Block soft limit (start timer, timer goes off, stop timer) ==="
 426
 427 test_file_soft() {
 428         TESTFILE=$1
 429         LIMIT=$2
 430         GRACE=$3
 431
 432         echo "    Create files to exceed soft limit"
 433         for i in `seq $LIMIT`; do
 434                 $RUNAS touch ${TESTFILE}_$i >/dev/null 2>&1 || error "touch failure, but expect success"
 435         done
 436         echo "    Done"
 437
 438         echo "    Create file before timer goes off"
 439         $RUNAS touch ${TESTFILE}_before >/dev/null 2>&1 || error "touch before timer goes off failure, but expect success"
 440         echo "    Done"
 441
 442         echo "    Sleep $GRACE seconds ..."
 443         sleep $GRACE
 444
 445         echo "    Create file after timer goes off"
 446         for i in `seq $(($IUNIT_SZ - 1))`; do
 447                 $RUNAS touch ${TESTFILE}_after_$i >/dev/null 2>&1 || error "touch ${TESTFILE}_after_$i failure, but expect success"
 448         done
 449         $RUNAS touch ${TESTFILE}_after >/dev/null 2>&1 && error "touch after timer goes off success, but expect EDQUOT"
 450         echo "    EDQUOT"
 451
 452         echo "    Unlink files to stop timer"
 453         for i in `seq $LIMIT`; do
 454                 rm -f ${TESTFILE}_$i >/dev/null 2>&1 || error "rm ${TESTFILE}_$i failure"
 455         done
 456         rm -f ${TESTFILE}_before
 457         for i in `seq $(($IUNIT_SZ - 1))`; do
 458                 rm -f ${TESTFILE}_after_$i >/dev/null 2>&1 || error "rm ${TESTFILE}_after_$i failure"
 459         done
 460         echo "    Done"
 461
 462         echo "    Create file"
 463         $RUNAS touch ${TESTFILE}_xxx >/dev/null 2>&1 || error "touch after timer stop failure, but expect success"
 464         echo "    Done"
 465
 466         # cleanup
 467         rm -f ${TESTFILE}_xxx
 468 }
 469
 470 # file soft limit (start timer, timer goes off, stop timer)
 471 test_4() {
 472         LIMIT=$(($IUNIT_SZ * 10))       # 10 iunits on mds
 473         TESTFILE="$TSTDIR/quota_tst40"
 474         GRACE=5
 475
 476         echo "  User quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 477         $LFS setquota -t -u $MAX_DQ_TIME $GRACE $MOUNT
 478         $LFS setquota -u $TSTUSR 0 0 $LIMIT 0 $MOUNT
 479
 480         test_file_soft $TESTFILE $LIMIT $GRACE
 481         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
 482
 483         echo "  Group quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 484         $LFS setquota -t -g $MAX_DQ_TIME $GRACE $MOUNT
 485         $LFS setquota -g $TSTUSR 0 0 $LIMIT 0 $MOUNT
 486         TESTFILE="$TSTDIR/quota_tst41"
 487
 488         test_file_soft $TESTFILE $LIMIT $GRACE
 489         $LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
 490
 491         # cleanup
 492         $LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $MOUNT
 493         $LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $MOUNT
 494 }
 495 run_test 4 "File soft limit (start timer, timer goes off, stop timer) ==="
 496
 497 # chown & chgrp (chown & chgrp successfully even out of block/file quota)
 498 test_5() {
 499         BLIMIT=$(( $BUNIT_SZ * $((OSTCOUNT + 1)) * 10)) # 10 bunits on each server
 500         ILIMIT=$(( $IUNIT_SZ * 10 )) # 10 iunits on mds
 501
 502         echo "  Set quota limit (0 $BLIMIT 0 $ILIMIT) for $TSTUSR.$TSTUSR"
 503         $LFS setquota -u $TSTUSR 0 $BLIMIT 0 $ILIMIT $MOUNT
 504         $LFS setquota -g $TSTUSR 0 $BLIMIT 0 $ILIMIT $MOUNT
 505
 506         echo "  Create more than $ILIMIT files and alloc more than $BLIMIT blocks ..."
 507         for i in `seq $(($ILIMIT + 1))`; do
 508                 touch $TSTDIR/quota_tst50_$i > /dev/null 2>&1 || error "touch failure, expect success"
 509         done
 510         dd if=/dev/zero of=$TSTDIR/quota_tst50_1 bs=$BLK_SZ count=$(($BLIMIT+1)) > /dev/null 2>&1 || error "write failure, expect success"
 511
 512         echo "  Chown files to $TSTUSR.$TSTUSR ..."
 513         for i in `seq $(($ILIMIT + 1))`; do
 514                 chown $TSTUSR.$TSTUSR $TSTDIR/quota_tst50_$i > /dev/null 2>&1 || error "chown failure, but expect success"
 515         done
 516
 517         # cleanup
 518         for i in `seq $(($ILIMIT + 1))`; do
 519                 rm -f $TSTDIR/quota_tst50_$i
 520         done
 521         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
 522         $LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
 523 }
 524 run_test 5 "Chown & chgrp (chown & chgrp successfully even out of block/file quota) ==="
 525
 526 # block quota acquire & release
 527 test_6() {
 528         if [ $OSTCOUNT -lt 2 ]; then
 529                 echo "WARN: too few osts, skip this test."
 530                 return 0;
 531         fi
 532
 533         LIMIT=$(($BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits per server
 534         FILEA="$TSTDIR/quota_tst60_a"
 535         FILEB="$TSTDIR/quota_tst60_b"
 536
 537         echo "  Set block limit $LIMIT bytes to $TSTUSR.$TSTUSR"
 538         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
 539         $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $MOUNT
 540
 541         echo "  Create filea on OST0 and fileb on OST1"
 542         $LFS setstripe $FILEA 65536 0 1
 543         $LFS setstripe $FILEB 65536 1 1
 544         chown $TSTUSR.$TSTUSR $FILEA
 545         chown $TSTUSR.$TSTUSR $FILEB
 546
 547         echo "  Exceed quota limit ..."
 548         $RUNAS dd if=/dev/zero of=$FILEB bs=$BLK_SZ count=$(($LIMIT - $BUNIT_SZ * $OSTCOUNT)) >/dev/null 2>&1 || error "write fileb failure, but expect success"
 549         #sync; sleep 1; sync;
 550         $RUNAS dd if=/dev/zero of=$FILEB bs=$BLK_SZ seek=$LIMIT count=$BUNIT_SZ >/dev/null 2>&1 && error "write fileb success, but expect EDQUOT"
 551         #sync; sleep 1; sync;
 552         echo "  Write to OST0 return EDQUOT"
 553         # this write maybe cache write, ignore it's failure
 554         $RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ count=$(($BUNIT_SZ * 2)) >/dev/null 2>&1 || echo " " > /dev/null
 555         sync; sleep 1; sync;
 556         $RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ count=$(($BUNIT_SZ * 2)) seek=$(($BUNIT_SZ *2)) >/dev/null 2>&1 && error "write filea success, but expect EDQUOT"
 557         echo "  EDQUOT"
 558
 559         echo "  Remove fileb to let OST1 release quota"
 560         rm -f $FILEB
 561
 562         echo "  Write to OST0"
 563         $RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ count=$(($LIMIT - $BUNIT_SZ * $OSTCOUNT)) >/dev/null 2>&1 || error "write filea failure, expect success"
 564         echo "  Done"
 565
 566         # cleanup
 567         rm -f $FILEA
 568         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
 569         $LFS setquota -g $TSTUSR 0 0 0 0 $MOUNT
 570         return 0
 571 }
 572 run_test 6 "Block quota acquire & release ========="
 573
 574 # quota recovery (block quota only by now)
 575 test_7()
 576 {
 577         if [ -z "`lsmod|grep mds`" ]; then
 578                 echo "WARN: no local mds, skip this test"
 579                 return 0
 580         fi
 581
 582         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
 583         TESTFILE="$TSTDIR/quota_tst70"
 584
 585         $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $MOUNT
 586
 587         $LFS setstripe $TESTFILE 65536 0 1
 588         chown $TSTUSR.$TSTUSR $TESTFILE
 589
 590         echo "  Write to OST0..."
 591         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ >/dev/null 2>&1 || error "write failure, but expect success"
 592
 593         #define OBD_FAIL_OBD_DQACQ               0x604
 594         echo 0x604 > /proc/sys/lustre/fail_loc
 595         echo "  Remove files on OST0"
 596         rm -f $TESTFILE
 597         echo 0 > /proc/sys/lustre/fail_loc
 598
 599         echo "  Trigger recovery..."
 600         OSC0_UUID="`$LCTL dl | awk '$3 ~ /osc/ { print $1 }'`"
 601         for i in $OSC0_UUID; do
 602                 $LCTL --device $i activate > /dev/null 2>&1 || error "activate osc failed!"
 603         done
 604
 605         # sleep a while to wait for recovery done
 606         sleep 20
 607
 608         # check limits
 609         PATTERN="`echo $MOUNT | sed 's/\//\\\\\//g'`"
 610         TOTAL_LIMIT="`$LFS quota -u $TSTUSR $MOUNT | awk '/^.*'$PATTERN'.*[[:digit:]+][[:space:]+]/ { print $4 }'`"
 611         [ $TOTAL_LIMIT -eq $LIMIT ] || error "total limits not recovery!"
 612         echo "  total limits = $TOTAL_LIMIT"
 613
 614         OST0_UUID=`$LCTL dl | awk '$3 ~ /obdfilter/ { print $5 }'| head -n1`
 615         [ -z "$OST0_UUID" ] && OST0_UUID=`$LCTL dl | awk '$3 ~ /obdfilter/ { print $5 }'|head -n1`
 616         OST0_LIMIT="`$LFS quota -o $OST0_UUID -u $TSTUSR $MOUNT | awk '/^.*[[:digit:]+][[:space:]+]/ { print $3 }'`"
 617         [ $OST0_LIMIT -eq $BUNIT_SZ ] || error "high limits not released!"
 618         echo "  limits on $OST0_UUID = $OST0_LIMIT"
 619
 620         # cleanup
 621         $LFS setquota -u $TSTUSR 0 0 0 0 $MOUNT
 622 }
 623 run_test 7 "Quota recovery (only block limit) ======"
 624
 625 # run dbench with quota enabled
 626 test_8() {
 627         BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
 628         FILE_LIMIT=1000000
 629         DBENCH_LIB=${DBENCH_LIB:-/usr/lib/dbench}
 630
 631         [ ! -d $DBENCH_LIB ] && echo "dbench not installed, skip this test" && return 0
 632
 633         echo "  Set enough high limit for user: $TSTUSR"
 634         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
 635         echo "  Set enough high limit for group: $TSTUSR"
 636         $LFS setquota -g $USER 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
 637
 638
 639         TGT=$TSTDIR/client.txt
 640         SRC=${SRC:-$DBENCH_LIB/client.txt}
 641         [ ! -e $TGT -a -e $SRC ] && echo "copying $SRC to $TGT" && cp $SRC $TGT
 642         SRC=$DBENCH_LIB/client_plain.txt
 643         [ ! -e $TGT -a -e $SRC ] && echo "copying $SRC to $TGT" && cp $SRC $TGT
 644
 645         SAVE_PWD=$PWD
 646         cd $TSTDIR
 647         $RUNAS dbench -c client.txt 3
 648         RC=$?
 649
 650         cd $SAVE_PWD
 651         return $RC
 652 }
 653 run_test 8 "Run dbench with quota enabled ==========="
 654
 655 # run for fixing bug10707, it needs a big room. test for 64bit
 656 test_9() {
 657         lustrefs_size=`df | grep $MOUNT | awk '{print $(NF - 2)}'`
 658         size_file=$((1024 * 1024 * 9 / 2 * $OSTCOUNT))
 659         echo "lustrefs_size:$lustrefs_size  size_file:$size_file"
 660         if [ $lustrefs_size -lt $size_file ]; then
 661             echo "WARN: too few capacity, skip this test."
 662             return 0;
 663         fi
 664
 665         # set the D_QUOTA flag
 666         DBG_SAVE="`sysctl -n lnet.debug`"
 667         sysctl -w lnet.debug="$DBG_SAVE quota"
 668
 669         TESTFILE="$TSTDIR/quota_tst90"
 670
 671         echo "  Set block limit $LIMIT bytes to $TSTUSR.$TSTUSR"
 672         BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
 673         FILE_LIMIT=1000000
 674
 675         echo "  Set enough high limit for user: $TSTUSR"
 676         $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
 677         echo "  Set enough high limit for group: $TSTUSR"
 678         $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
 679
 680         echo "  Set stripe"
 681         [ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE 65536 0 $OSTCOUNT
 682         touch $TESTFILE
 683         chown $TSTUSR.$TSTUSR $TESTFILE
 684
 685         echo "    Write the big file of $(($OSTCOUNT * 9 / 2 ))G ..."
 686         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$size_file >/dev/null 2>&1 || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect success"
 687
 688         echo "    delete the big file of $(($OSTCOUNT * 9 / 2))G..."
 689         $RUNAS rm -f $TESTFILE >/dev/null 2>&1
 690
 691         echo "    write the big file of 2G..."
 692         $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$((1024 * 1024 * 2)) >/dev/null 2>&1 || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect seccess"
 693
 694         echo "    delete the big file of 2G..."
 695         $RUNAS rm -f $TESTFILE >/dev/null 2>&1
 696         RC=$?
 697
 698         sysctl -w lnet.debug="$DBG_SAVE"
 699         return $RC
 700 }
 701 run_test 9 "run for fixing bug10707(64bit) ==========="
 702
 703 # run for fixing bug10707, it need a big room. test for 32bit
 704 test_10() {
 705        lustrefs_size=`df | grep $MOUNT | awk '{print $(NF - 2)}'`
 706        size_file=$((1024 * 1024 * 9 / 2 * $OSTCOUNT))
 707        echo "lustrefs_size:$lustrefs_size  size_file:$size_file"
 708        if [ $lustrefs_size -lt $size_file ]; then
 709                echo "WARN: too few capacity, skip this test."
 710                return 0;
 711        fi
 712
 713        if [ ! -d /proc/fs/lustre/ost/ -o ! -d /proc/fs/lustre/mds ]; then
 714            echo "WARN: mds or ost isn't on the local machine, skip this test."
 715            return 0;
 716        fi
 717
 718        sync; sleep 10; sync;
 719
 720        # set the D_QUOTA flag
 721        DBG_SAVE="`sysctl -n lnet.debug`"
 722        sysctl -w lnet.debug="$DBG_SAVE quota"
 723
 724        # make qd_count 32 bit
 725        sysctl -w lustre.fail_loc=2560
 726
 727        TESTFILE="$TSTDIR/quota_tst100"
 728
 729        echo "  Set block limit $LIMIT bytes to $TSTUSR.$TSTUSR"
 730        BLK_LIMIT=$((100 * 1024 * 1024)) # 100G
 731        FILE_LIMIT=1000000
 732
 733        echo "  Set enough high limit for user: $TSTUSR"
 734        $LFS setquota -u $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
 735        echo "  Set enough high limit for group: $TSTUSR"
 736        $LFS setquota -g $TSTUSR 0 $BLK_LIMIT 0 $FILE_LIMIT $MOUNT
 737
 738        echo "  Set stripe"
 739        [ $OSTCOUNT -ge 2 ] && $LFS setstripe $TESTFILE 65536 0 $OSTCOUNT
 740        touch $TESTFILE
 741        chown $TSTUSR.$TSTUSR $TESTFILE
 742
 743        echo "    Write the big file of $(($OSTCOUNT * 9 / 2 ))G ..."
 744        $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$size_file >/dev/null 2>&1 || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect success"
 745
 746        echo "    delete the big file of $(($OSTCOUNT * 9 / 2))G..."
 747        $RUNAS rm -f $TESTFILE >/dev/null 2>&1
 748
 749        echo "    write the big file of 2G..."
 750        $RUNAS dd if=/dev/zero of=$TESTFILE  bs=$BLK_SZ count=$((1024 * 1024 * 2)) >/dev/null 2>&1 || error "(usr) write $((9 / 2 * $OSTCOUNT))G file failure, but expect success"
 751
 752        echo "    delete the big file of 2G..."
 753        $RUNAS rm -f $TESTFILE >/dev/null 2>&1
 754        RC=$?
 755
 756        sysctl -w lnet.debug="$DBG_SAVE"
 757
 758        # make qd_count 64 bit
 759        sysctl -w lustre.fail_loc=0
 760
 761        return $RC
 762 }
 763 run_test 10 "run for fixing bug10707(32bit) ==========="
 764
 765 test_11() {
 766        #prepare the test
 767        block_limit=`df | grep $MOUNT | awk '{print $(NF - 4)}'`
 768        echo $block_limit
 769        orig_dbr=`cat /proc/sys/vm/dirty_background_ratio`
 770        orig_dec=`cat /proc/sys/vm/dirty_expire_centisecs`
 771        orig_dr=`cat /proc/sys/vm/dirty_ratio`
 772        orig_dwc=`cat /proc/sys/vm/dirty_writeback_centisecs`
 773        echo 1  > /proc/sys/vm/dirty_background_ratio
 774        echo 30 > /proc/sys/vm/dirty_expire_centisecs
 775        echo 1  > /proc/sys/vm/dirty_ratio
 776        echo 50 > /proc/sys/vm/dirty_writeback_centisecs
 777        TESTDIR="$TSTDIR/quota_tst110"
 778        local RV=0
 779
 780        #do the test
 781        MINS=0
 782        REPS=3
 783        i=1
 784        while [ $i -le $REPS ]; do
 785            echo "test: cycle($i of $REPS) start at $(date)"
 786            mkdir -p $TESTDIR && chmod 777 $TESTDIR
 787            echo -n "    create a file for uid "
 788            for j in `seq 1 30`; do
 789                echo -n "$j "
 790                runas -u $j dd if=/dev/zero of=$TESTDIR/$j  bs=$BLK_SZ > /dev/null 2>&1 &
 791            done
 792            echo ""
 793            PROCS=$(ps -e | grep dd | wc -l)
 794            while [ $PROCS -gt 0 ]; do
 795              sleep 60
 796              MINS=$(($MINS+1))
 797              PROCS=$(ps -e | grep dd | wc -l)
 798              USED=$(du -s $TESTDIR | awk '{print $1}')
 799              PCT=$(($USED * 100 / $block_limit))
 800              echo "${i}/${REPS} ${PCT}% p${PROCS} t${MINS}  "
 801              if [ $MINS -gt 30 ]; then
 802                  error "Aborting after $MINS minutes"
 803                  kill -9 $(ps -ef | grep $TESTDIR | grep -v grep | awk '{ print $2 }')
 804                  i=$REPS
 805                  RV=2
 806                  break
 807              fi
 808            done
 809            echo "    removing the test files..."
 810            rm -rf $TESTDIR
 811            echo "cycle $i done at $(date)"
 812            i=$[$i+1]
 813        done
 814        echo "Test took $MINS minutes"
 815
 816        #clean
 817        echo $orig_dbr > /proc/sys/vm/dirty_background_ratio
 818        echo $orig_dec > /proc/sys/vm/dirty_expire_centisecs
 819        echo $orig_dr  > /proc/sys/vm/dirty_ratio
 820        echo $orig_dwc > /proc/sys/vm/dirty_writeback_centisecs
 821        return $RV
 822 }
 823 run_test 11 "run for fixing bug10912 ==========="
 824
 825 # turn off quota
 826 test_99()
 827 {
 828         $LFS quotaoff $MOUNT
 829         return 0
 830 }
 831 run_test 99 "Quota off ==============================="
 832
 833
 834 log "cleanup: ======================================================"
 835 if [ "`mount | grep ^$NAME`" ]; then
 836         rm -fr $TSTDIR
 837         post_test
 838         # delete test user and group
 839         userdel "$TSTUSR"
 840         if [ "$I_MOUNTED" = "yes" ]; then
 841                 cd $ORIG_PWD && (sh llmountcleanup.sh || error "llmountcleanup failed")
 842         fi
 843 fi
 844
 845 echo '=========================== finished ==============================='
 846 [ -f "$QUOTALOG" ] && cat $QUOTALOG && exit 1
 847 echo "$0: completed"