lustre/tests/quota_sanity.sh

   1 #!/bin/bash
   2
   3 set -e
   4 #set -vx
   5
   6 SRCDIR=`dirname $0`
   7 export PATH=$PWD/$SRCDIR:$SRCDIR:$SRCDIR/../utils:$PATH:/sbin
   8 . $SRCDIR/test-framework.sh
   9
  10 LFS=${LFS:-lfs}
  11 LCTL=${LCTL:-lctl}
  12 USER="quota_usr"
  13 TSTID=${TSTID:-60000}
  14 RUNAS=${RUNAS:-"runas -u $TSTID"}
  15 BLK_SZ=1024
  16 BUNIT_SZ=1000 # 1000 quota blocks
  17 BTUNE_SZ=500  # 500 quota blocks
  18 IUNIT_SZ=10 # 10 files
  19 ITUNE_SZ=5  # 5 files
  20 MAX_DQ_TIME=604800
  21 MAX_IQ_TIME=604800
  22
  23 MOUNT="`cat /proc/mounts | grep "lustre" | awk '{print $2}'`"
  24 if [ -z "$MOUNT" ]; then
  25         echo "ERROR: lustre not mounted, quit test!"
  26         exit 1;
  27 fi
  28 OSTCOUNT=`cat /proc/fs/lustre/lov/*/activeobd | head -n 1`
  29 TSTDIR="$MOUNT/quota_dir"
  30
  31 # set_blk_tunables(btune_sz)
  32 set_blk_tunesz() {
  33         # set btune size on all obdfilters
  34         for i in `ls /proc/fs/lustre/obdfilter/*/quota_btune_sz`; do
  35                 echo $(($1 * $BLK_SZ)) > $i
  36         done
  37         # set btune size on mds
  38         for i in `ls /proc/fs/lustre/mds/mds*/quota_btune_sz`; do
  39                 echo $(($1 * $BLK_SZ)) > $i
  40         done
  41 }
  42
  43 # se_blk_unitsz(bunit_sz)
  44 set_blk_unitsz() {
  45         for i in `ls /proc/fs/lustre/obdfilter/*/quota_bunit_sz`; do
  46                 echo $(($1 * $BLK_SZ)) > $i
  47         done
  48         for i in `ls /proc/fs/lustre/mds/mds*/quota_bunit_sz`; do
  49                 echo $(($1 * $BLK_SZ)) > $i
  50         done
  51 }
  52
  53 # set_file_tunesz(itune_sz)
  54 set_file_tunesz() {
  55         # set iunit and itune size on all obdfilters
  56         for i in `ls /proc/fs/lustre/obdfilter/*/quota_itune_sz`; do
  57                 echo $1 > $i
  58         done
  59         # set iunit and itune size on mds
  60         for i in `ls /proc/fs/lustre/mds/mds*/quota_itune_sz`; do
  61                 echo $1 > $i
  62         done
  63
  64
  65 }
  66 # set_file_unitsz(iunit_sz)
  67 set_file_unitsz() {
  68         for i in `ls /proc/fs/lustre/obdfilter/*/quota_iunit_sz`; do
  69                 echo $1 > $i
  70         done;
  71         for i in `ls /proc/fs/lustre/mds/mds*/quota_iunit_sz`; do
  72                 echo $1 > $i
  73         done
  74 }
  75
  76 prepare_test() {
  77         # create test group
  78         GRP="`cat /etc/group | grep "$USER" | awk -F: '{print $1}'`"
  79         if [ -z "$GRP" ]; then
  80                 groupadd -g $TSTID "$USER"
  81         fi
  82         TSTID="`cat /etc/group | grep "$USER" | awk -F: '{print $3}'`"
  83
  84         # create test user
  85         USR="`cat /etc/passwd | grep "$USER" | awk -F: '{print $1}'`"
  86         if [ -z "$USR" ]; then
  87                 useradd -u $TSTID -g $TSTID -d /tmp "$USER"
  88         fi
  89
  90         RUNAS="runas -u $TSTID"
  91
  92         # set block tunables
  93         set_blk_tunesz $BTUNE_SZ
  94         set_blk_unitsz $BUNIT_SZ
  95         # set file tunaables
  96         set_file_tunesz $ITUNE_SZ
  97         set_file_unitsz $IUNIT_SZ
  98
  99         [ -d $TSTDIR ] || mkdir $TSTDIR
 100         chmod 777 $TSTDIR
 101 }
 102
 103 cleanup_test() {
 104         # restore block tunables to default size
 105         set_blk_unitsz $((1024 * 100))
 106         set_blk_tunesz $((1024 * 50))
 107         # restore file tunables to default size
 108         set_file_unitsz 5000
 109         set_file_tunesz 2500
 110
 111         rm -fr $TSTDIR
 112         # delete test user and group
 113         userdel "$USER"
 114 }
 115
 116 # set quota
 117 test_1() {
 118         echo "== Enable quota"
 119         $LFS quotaoff -ug $MOUNT
 120         $LFS quotacheck -ug $MOUNT
 121
 122         $LFS setquota -u $USER 0 0 0 0 $MOUNT
 123         $LFS setquota -g $USER 0 0 0 0 $MOUNT
 124         return 0
 125 }
 126
 127 # block hard limit (normal use and out of quota)
 128 test_2() {
 129         echo "== Block hard limit"
 130         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits each sever
 131         TESTFILE="$TSTDIR/quota_tst20"
 132
 133         echo "  User quota (limit: $LIMIT bytes)"
 134         $LFS setquota -u $USER 0 $LIMIT 0 0 $MOUNT
 135
 136         $RUNAS touch $TESTFILE >/dev/null 2>&1
 137
 138         echo "    Write ..."
 139         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) > /dev/null 2>&1 || error "(usr) write failure, but expect success"
 140         echo "    Done"
 141         echo "    Write out of block quota ..."
 142         # this time maybe cache write,  ignore it's failure
 143         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) > /dev/null 2>&1 || echo " " > /dev/null
 144         # flush cache, ensure noquota flag is setted on client
 145         sync; sleep 1; sync;
 146         $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"
 147         echo "    EDQUOT"
 148
 149         rm -f $TESTFILE
 150
 151         echo "  Group quota (limit: $LIMIT bytes)"
 152         $LFS setquota -u $USER 0 0 0 0 $MOUNT           # clear user limit
 153         $LFS setquota -g $USER 0 $LIMIT 0 0 $MOUNT
 154         TESTFILE="$TSTDIR/quota_tst21"
 155
 156         $RUNAS touch $TESTFILE >/dev/null 2>&1
 157
 158         echo "    Write ..."
 159         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) > /dev/null 2>&1 || error "(grp) write failure, but expect success"
 160         echo "    Done"
 161         echo "    Write out of block quota ..."
 162         # this time maybe cache write, ignore it's failure
 163         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) > /dev/null 2>&1 || echo " " > /dev/null
 164         sync; sleep 1; sync;
 165         $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"
 166         echo "    EDQUOT"
 167
 168         # cleanup
 169         rm -f $TESTFILE
 170         $LFS setquota -g $USER 0 0 0 0 $MOUNT
 171         return 0
 172 }
 173
 174 # file hard limit (normal use and out of quota)
 175 test_3() {
 176         echo "== File hard limit"
 177         LIMIT=$(($IUNIT_SZ * 10)) # 10 iunits on mds
 178         TESTFILE="$TSTDIR/quota_tst30"
 179
 180         echo "  User quota (limit: $LIMIT files)"
 181         $LFS setquota -u $USER 0 0 0 $LIMIT $MOUNT
 182
 183         echo "    Create $LIMIT files ..."
 184         for i in `seq ${LIMIT}`; do
 185                 $RUNAS touch ${TESTFILE}_$i > /dev/null 2>&1 || error "(usr) touch failure, but except success"
 186         done
 187         echo "    Done"
 188         echo "    Create out of file quota ..."
 189         $RUNAS touch ${TESTFILE}_xxx > /dev/null 2>&1 && error "(usr) touch success, but expect EDQUOT"
 190         echo "    EDQUOT"
 191
 192         for i in `seq ${LIMIT}`; do
 193                 rm -f ${TESTFILE}_$i
 194         done
 195
 196         echo "  Group quota (limit: $LIMIT files)"
 197         $LFS setquota -u $USER 0 0 0 0 $MOUNT           # clear user limit
 198         $LFS setquota -g $USER 0 0 0 $LIMIT $MOUNT
 199         TESTFILE="$TSTDIR/quota_tst31"
 200
 201         echo "    Create $LIMIT files ..."
 202         for i in `seq ${LIMIT}`; do
 203                 $RUNAS touch ${TESTFILE}_$i > /dev/null 2>&1 || error "(grp) touch failure, but expect success"
 204         done
 205         echo "    Done"
 206         echo "    Create out of file quota ..."
 207         $RUNAS touch ${TESTFILE}_xxx > /dev/null 2>&1 && error "(grp) touch success, but expect EDQUOT"
 208         echo "    EDQUOT"
 209
 210         # cleanup
 211         for i in `seq ${LIMIT}`; do
 212                 rm -f ${TESTFILE}_$i
 213         done
 214         $LFS setquota -g $USER 0 0 0 0 $MOUNT
 215         return 0
 216 }
 217
 218 test_block_soft() {
 219         TESTFILE=$1
 220         GRACE=$2
 221         BS=$(($BUNIT_SZ * $BLK_SZ))
 222
 223         echo "    Write to exceed soft limit"
 224         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ >/dev/null 2>&1 || error "write failure, but expect success"
 225         sync; sleep 1; sync;
 226
 227         echo "    Write before timer goes off"
 228         $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"
 229         sync; sleep 1; sync;
 230         echo "    Done"
 231
 232         echo "    Sleep $GRACE seconds ..."
 233         sleep $GRACE
 234
 235         echo "    Write after timer goes off"
 236         # maybe cache write, ignore.
 237         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$(($BUNIT_SZ * 2)) >/dev/null 2>&1 || echo " " > /dev/null
 238         sync; sleep 1; sync;
 239         $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"
 240         echo "    EDQUOT"
 241
 242         echo "    Unlink file to stop timer"
 243         rm -f $TESTFILE
 244         echo "    Done"
 245
 246         echo "    Write ..."
 247         $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ >/dev/null 2>&1 || error "write failure, but expect success"
 248         echo "    Done"
 249
 250         # cleanup
 251         rm -f $TESTFILE
 252 }
 253
 254 # block soft limit (start timer, timer goes off, stop timer)
 255 test_4() {
 256         echo "== Block soft limit"
 257         LIMIT=$(( $BUNIT_SZ * $(($OSTCOUNT + 1)) )) # 1 bunits each sever
 258         TESTFILE="$TSTDIR/quota_tst40"
 259         GRACE=10
 260
 261         echo "  User quota (soft limit: $LIMIT bytes  grace: $GRACE seconds)"
 262         $LFS setquota -t -u $GRACE $MAX_IQ_TIME $MOUNT
 263         $LFS setquota -u $USER $LIMIT 0 0 0 $MOUNT
 264
 265         test_block_soft $TESTFILE $GRACE
 266         $LFS setquota -u $USER 0 0 0 0 $MOUNT
 267
 268         echo "  Group quota (soft limit: $LIMIT bytes  grace: $GRACE seconds)"
 269         $LFS setquota -t -g $GRACE $MAX_IQ_TIME $MOUNT
 270         $LFS setquota -g $USER $LIMIT 0 0 0 $MOUNT
 271         TESTFILE="$TSTDIR/quota_tst41"
 272
 273         test_block_soft $TESTFILE $GRACE
 274         $LFS setquota -g $USER 0 0 0 0 $MOUNT
 275
 276         return 0
 277 }
 278
 279 test_file_soft() {
 280         TESTFILE=$1
 281         LIMIT=$2
 282         GRACE=$3
 283
 284         echo "    Create files to exceed soft limit"
 285         for i in `seq $LIMIT`; do
 286                 $RUNAS touch ${TESTFILE}_$i >/dev/null 2>&1 || error "touch failure, but expect success"
 287         done
 288         echo "    Done"
 289
 290         echo "    Create file before timer goes off"
 291         $RUNAS touch ${TESTFILE}_before >/dev/null 2>&1 || error "touch before timer goes off failure, but expect success"
 292         echo "    Done"
 293
 294         echo "    Sleep $GRACE seconds ..."
 295         sleep $GRACE
 296
 297         echo "    Create file after timer goes off"
 298         for i in `seq $(($IUNIT_SZ - 1))`; do
 299                 $RUNAS touch ${TESTFILE}_after_$i >/dev/null 2>&1 || error "touch ${TESTFILE}_after_$i failure, but expect success"
 300         done
 301         $RUNAS touch ${TESTFILE}_after >/dev/null 2>&1 && error "touch after timer goes off success, but expect EDQUOT"
 302         echo "    EDQUOT"
 303
 304         echo "    Unlink files to stop timer"
 305         for i in `seq $LIMIT`; do
 306                 rm -f ${TESTFILE}_$i >/dev/null 2>&1 || error "rm ${TESTFILE}_$i failure"
 307         done
 308         rm -f ${TESTFILE}_before
 309         for i in `seq $(($IUNIT_SZ - 1))`; do
 310                 rm -f ${TESTFILE}_after_$i >/dev/null 2>&1 || error "rm ${TESTFILE}_after_$i failure"
 311         done
 312         echo "    Done"
 313
 314         echo "    Create file"
 315         $RUNAS touch ${TESTFILE}_xxx >/dev/null 2>&1 || error "touch after timer stop failure, but expect success"
 316         echo "    Done"
 317
 318         # cleanup
 319         rm -f ${TESTFILE}_xxx
 320 }
 321
 322 # file soft limit (start timer, timer goes off, stop timer)
 323 test_5() {
 324         echo "== File soft limit"
 325         LIMIT=$(($IUNIT_SZ * 10))       # 10 iunits on mds
 326         TESTFILE="$TSTDIR/quota_tst50"
 327         GRACE=5
 328
 329         echo "  User quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 330         $LFS setquota -t -u $MAX_DQ_TIME $GRACE $MOUNT
 331         $LFS setquota -u $USER 0 0 $LIMIT 0 $MOUNT
 332
 333         test_file_soft $TESTFILE $LIMIT $GRACE
 334         $LFS setquota -u $USER 0 0 0 0 $MOUNT
 335
 336         echo "  Group quota (soft limit: $LIMIT files  grace: $GRACE seconds)"
 337         $LFS setquota -t -g $MAX_DQ_TIME $GRACE $MOUNT
 338         $LFS setquota -g $USER 0 0 $LIMIT 0 $MOUNT
 339         TESTFILE="$TSTDIR/quota_tst51"
 340
 341         test_file_soft $TESTFILE $LIMIT $GRACE
 342         $LFS setquota -g $USER 0 0 0 0 $MOUNT
 343
 344         # cleanup
 345         $LFS setquota -t -u $MAX_DQ_TIME $MAX_IQ_TIME $MOUNT
 346         $LFS setquota -t -g $MAX_DQ_TIME $MAX_IQ_TIME $MOUNT
 347         return 0
 348 }
 349
 350 # chown & chgrp (chown & chgrp successfully even out of block/file quota)
 351 test_6() {
 352         echo "== Chown/Chgrp ignore quota"
 353         BLIMIT=$(( $BUNIT_SZ * $((OSTCOUNT + 1)) * 10)) # 10 bunits on each server
 354         ILIMIT=$(( $IUNIT_SZ * 10 )) # 10 iunits on mds
 355
 356         echo "  Set quota limit (0 $BLIMIT 0 $ILIMIT) for $USER.$USER"
 357         $LFS setquota -u $USER 0 $BLIMIT 0 $ILIMIT $MOUNT
 358         $LFS setquota -g $USER 0 $BLIMIT 0 $ILIMIT $MOUNT
 359
 360         echo "  Create more than $ILIMIT files and alloc more than $BLIMIT blocks ..."
 361         for i in `seq $(($ILIMIT + 1))`; do
 362                 touch $TSTDIR/quota_tst60_$i > /dev/null 2>&1 || error "touch failure, expect success"
 363         done
 364         dd if=/dev/zero of=$TSTDIR/quota_tst60_1 bs=$BLK_SZ count=$(($BLIMIT+1)) > /dev/null 2>&1 || error "write failure, expect success"
 365
 366         echo "  Chown files to $USER.$USER ..."
 367         for i in `seq $(($ILIMIT + 1))`; do
 368                 chown $USER.$USER $TSTDIR/quota_tst60_$i > /dev/null 2>&1 || error "chown failure, but expect success"
 369         done
 370
 371         # cleanup
 372         for i in `seq $(($ILIMIT + 1))`; do
 373                 rm -f $TSTDIR/quota_tst60_$i
 374         done
 375         $LFS setquota -u $USER 0 0 0 0 $MOUNT
 376         $LFS setquota -g $USER 0 0 0 0 $MOUNT
 377         return 0
 378 }
 379
 380 # block quota acquire & release
 381 test_7() {
 382         echo "== Block quota acqurie / release"
 383
 384         if [ $OSTCOUNT -lt 2 ]; then
 385                 echo "WARN: too few osts, skip this test."
 386                 return 0;
 387         fi
 388
 389         LIMIT=$(($BUNIT_SZ * $(($OSTCOUNT + 1)) * 10)) # 10 bunits per server
 390         FILEA="$TSTDIR/quota_tst70_a"
 391         FILEB="$TSTDIR/quota_tst70_b"
 392
 393         echo "  Set block limit $LIMIT bytes to $USER.$USER"
 394         $LFS setquota -u $USER 0 $LIMIT 0 0 $MOUNT
 395         $LFS setquota -g $USER 0 $LIMIT 0 0 $MOUNT
 396
 397         echo "  Create filea on OST0 and fileb on OST1"
 398         $LFS setstripe $FILEA 65536 0 1
 399         $LFS setstripe $FILEB 65536 1 1
 400         chown $USER.$USER $FILEA
 401         chown $USER.$USER $FILEB
 402
 403         echo "  Exceed quota limit ..."
 404         $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"
 405         sync; sleep 1; sync;
 406         $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"
 407         sync; sleep 1; sync;
 408         echo "  Write to OST0 return EDQUOT"
 409         # this write maybe cache write, ignore it's failure
 410         $RUNAS dd if=/dev/zero of=$FILEA bs=$BLK_SZ count=$(($BUNIT_SZ * 2)) >/dev/null 2>&1 || echo " " > /dev/null
 411         sync; sleep 1; sync;
 412         $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"
 413         echo "  EDQUOT"
 414
 415         echo "  Remove fileb to let OST1 release quota"
 416         rm -f $FILEB
 417
 418         echo "  Write to OST0"
 419         $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"
 420         echo "  Done"
 421
 422         # cleanup
 423         rm -f $FILEA
 424         $LFS setquota -u $USER 0 0 0 0 $MOUNT
 425         $LFS setquota -g $USER 0 0 0 0 $MOUNT
 426         return 0
 427 }
 428
 429 # turn off quota
 430 test_8()
 431 {
 432         echo "=== Turn off quota"
 433         $LFS quotaoff $MOUNT
 434         return 0
 435 }
 436
 437 prepare_test
 438
 439 # run all tests
 440 for j in `seq 8`; do
 441         test_$j
 442         echo "== Done"
 443         echo " "
 444 done
 445
 446 cleanup_test