sanity-quota.sh

lustre 1.6.5 source code

#!/bin/bash
#
# Run select tests by setting ONLY, or as arguments to the script.
# Skip specific tests by setting EXCEPT.
#
# Run test by setting NOSETUP=true when ltest has setup env for us
set -e

#kernel 2.4.x doesn't support quota
K_VER=`uname --kernel-release | cut -b 1-3`
if [ $K_VER = "2.4" ]; then
    echo "Kernel 2.4 doesn't support quota"
    exit 0
fi

SRCDIR=`dirname $0`
export PATH=$PWD/$SRCDIR:$SRCDIR:$PWD/$SRCDIR/../utils:$PATH:/sbin

ONLY=${ONLY:-"$*"}
ALWAYS_EXCEPT="$SANITY_QUOTA_EXCEPT"
# UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!

case `uname -r` in
2.6*) FSTYPE=${FSTYPE:-ldiskfs};;
*) error "unsupported kernel" ;;
esac

[ "$ALWAYS_EXCEPT$EXCEPT" ] && \
	echo "Skipping tests: `echo $ALWAYS_EXCEPT $EXCEPT`"

TMP=${TMP:-/tmp}

ORIG_PWD=${PWD}
TSTID=${TSTID:-60000}
TSTID2=${TSTID2:-60001}
TSTUSR=${TSTUSR:-"quota_usr"}
TSTUSR2=${TSTUSR2:-"quota_2usr"}
BLK_SZ=1024
BUNIT_SZ=${BUNIT_SZ:-1024}	# min block quota unit(kB)
IUNIT_SZ=${IUNIT_SZ:-10}	# min inode quota unit
MAX_DQ_TIME=604800
MAX_IQ_TIME=604800

TRACE=${TRACE:-""}
LUSTRE=${LUSTRE:-`dirname $0`/..}
. $LUSTRE/tests/test-framework.sh
init_test_env $@
. ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}

[ "$SLOW" = "no" ] && EXCEPT_SLOW="9 10 11"

QUOTALOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}

[ "$QUOTALOG" ] && rm -f $QUOTALOG || true

DIR=${DIR:-$MOUNT}
DIR2=${DIR2:-$MOUNT2}

cleanup_and_setup_lustre

LOVNAME=`cat $LPROC/llite/*/lov/common_name | tail -n 1`
OSTCOUNT=`cat $LPROC/lov/$LOVNAME/numobd`

SHOW_QUOTA_USER="$LFS quota -u $TSTUSR $DIR"
SHOW_QUOTA_GROUP="$LFS quota -g $TSTUSR $DIR"
SHOW_QUOTA_INFO="$LFS quota -t $DIR"

# control the time of tests
cycle=30
[ "$SLOW" = "no" ] && cycle=10

build_test_filter

eval ONLY_0=true
eval ONLY_99=true

# set_blk_tunables(btune_sz)
set_blk_tunesz() {
        local i
	# set btune size on all obdfilters
	do_facet ost1 "set -x; for i in /proc/fs/lustre/obdfilter/*/quota_btune_sz; do
		echo $(($1 * BLK_SZ)) >> \\\$i;
	done"
	# set btune size on mds
	do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_btune_sz; do
		echo $(($1 * BLK_SZ)) >> \\\$i;
	done"
}

# set_blk_unitsz(bunit_sz)
set_blk_unitsz() {
        local i
	do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_bunit_sz; do
		echo $(($1 * BLK_SZ)) >> \\\$i;
	done"
	do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_bunit_sz; do
		echo $(($1 * BLK_SZ)) >> \\\$i;
	done"
}

# set_file_tunesz(itune_sz)
set_file_tunesz() {
        local i
	# set iunit and itune size on all obdfilters
	do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_itune_sz; do
		echo $1 >> \\\$i;
	done"
	# set iunit and itune size on mds
	do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_itune_sz; do
		echo $1 >> \\\$i;
	done"
}

# set_file_unitsz(iunit_sz)
set_file_unitsz() {
        local i
	do_facet ost1 "for i in /proc/fs/lustre/obdfilter/*/quota_iunit_sz; do
		echo $1 >> \\\$i;
	done"
	do_facet mds "for i in /proc/fs/lustre/mds/${FSNAME}-MDT*/quota_iunit_sz; do
		echo $1 >> \\\$i;
	done"
}

lustre_fail() {
        local fail_node=$1
	local fail_loc=$2

	case $fail_node in
	    "mds" )
		do_facet mds "sysctl -w lustre.fail_loc=$fail_loc" ;;
	    "ost" )
		for num in `seq $OSTCOUNT`; do
		    do_facet ost$num "sysctl -w lustre.fail_loc=$fail_loc"
		done ;;
	    "mds_ost" )
		do_facet mds "sysctl -w lustre.fail_loc=$fail_loc" ;
		for num in `seq $OSTCOUNT`; do
		    do_facet ost$num "sysctl -w lustre.fail_loc=$fail_loc"
		done ;;
	    * ) echo "usage: lustre_fail fail_node fail_loc" ;
		return 1 ;;
	esac
}

RUNAS="runas -u $TSTID"
RUNAS2="runas -u $TSTID2"
FAIL_ON_ERROR=true check_runas_id $TSTID $RUNAS
FAIL_ON_ERROR=true check_runas_id $TSTID2 $RUNAS2

FAIL_ON_ERROR=false

# set quota
test_0() {
	$LFS quotaoff -ug $DIR
	$LFS quotacheck -ug $DIR

	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR
	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
	sysctl -w lnet.debug="+quota"
}
run_test 0 "Set quota ============================="

# test for specific quota limitation, qunit, qtune $1=block_quota_limit
test_1_sub() {
        LIMIT=$1
	chmod 0777 $DIR/$tdir
        TESTFILE="$DIR/$tdir/$tfile-0"

	wait_delete_completed

        # test for user
        log "  User quota (limit: $LIMIT kbytes)"
        $LFS setquota -u $TSTUSR 0 $LIMIT 0 0 $DIR
	sleep 3
        $SHOW_QUOTA_USER

        $LFS setstripe $TESTFILE -c 1
        chown $TSTUSR.$TSTUSR $TESTFILE

        log "    Write ..."
        $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || error "(usr) write failure, but expect success"
        log "    Done"
        log "    Write out of block quota ..."
	# this time maybe cache write,  ignore it's failure
        $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
	# flush cache, ensure noquota flag is setted on client
        cancel_lru_locks osc
        $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && error "(usr) write success, but expect EDQUOT"

        rm -f $TESTFILE
	sync; sleep 1; sync;
	OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
	OST0_QUOTA_USED=`$LFS quota -o $OST0_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
	echo $OST0_QUOTA_USED
	[ $OST0_QUOTA_USED -ne 0 ] && \
	    ($SHOW_QUOTA_USER; error "quota deleted isn't released")
	$SHOW_QUOTA_USER
        $LFS setquota -u $TSTUSR 0 0 0 0 $DIR		# clear user limit

        # test for group
	log "--------------------------------------"
        log "  Group quota (limit: $LIMIT kbytes)"
        $LFS setquota -g $TSTUSR 0 $LIMIT 0 0 $DIR
	sleep 3
        $SHOW_QUOTA_GROUP
        TESTFILE="$DIR/$tdir/$tfile-1"

        $LFS setstripe $TESTFILE -c 1
        chown $TSTUSR.$TSTUSR $TESTFILE

        log "    Write ..."
        $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) || error "(grp) write failure, but expect success"
        log "    Done"
        log "    Write out of block quota ..."
	# this time maybe cache write, ignore it's failure
        $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$(($LIMIT/2)) seek=$(($LIMIT/2)) || true
        cancel_lru_locks osc
        $RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ count=$BUNIT_SZ seek=$LIMIT && error "(grp) write success, but expect EDQUOT"

	# cleanup
        rm -f $TESTFILE
	sync; sleep 1; sync;
	OST0_UUID=`do_facet ost1 $LCTL dl | grep -m1 obdfilter | awk '{print $((NF-1))}'`
	OST0_QUOTA_USED=`$LFS quota -o $OST0_UUID -g $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $1 }'`
	echo $OST0_QUOTA_USED
	[ $OST0_QUOTA_USED -ne 0 ] && \
	    ($SHOW_QUOTA_USER; error "quota deleted isn't released")
	$SHOW_QUOTA_GROUP
        $LFS setquota -g $TSTUSR 0 0 0 0 $DIR		# clear group limit
}

# block hard limit (normal use and out of quota)
test_1() {
	for i in `seq 1 $cycle`; do
	    # define blk_qunit is between 1M and 4M
	    blk_qunit=$(( $RANDOM % 3072 + 1024 ))
	    blk_qtune=$(( $RANDOM % $blk_qunit ))
	    # other osts and mds will occupy at 1M blk quota
	    b_limit=$(( ($RANDOM - 16384) / 8 +  $OSTCOUNT  * $blk_qunit * 4 ))
	    set_blk_tunesz $blk_qtune
	    set_blk_unitsz $blk_qunit
	    echo "cycle: $i(total $cycle) bunit:$blk_qunit, btune:$blk_qtune, blimit:$b_limit"
	    test_1_sub $b_limit
	    echo "=================================================="
	    set_blk_unitsz $((128 * 1024))
	    set_blk_tunesz $((128 * 1024 / 2))
        done
}
run_test 1 "Block hard limit (normal use and out of quota) ==="

# test for specific quota limitation, qunit, qtune $1=block_quota_limit
test_2_sub() {
        LIMIT=$1
	chmod 0777 $DIR/$tdir
        TESTFILE="$DIR/$tdir/$tfile-0"

	wait_delete_completed

        # test for user
        log "  User quota (limit: $LIMIT files)"
        $LFS setquota -u $TSTUSR 0 0 0 $LIMIT $DIR
	sleep 3
        $SHOW_QUOTA_USER

	log "    Create $LIMIT files ..."
	$RUNAS createmany -m ${TESTFILE} $LIMIT || \
		error "(usr) create failure, but except success"
	log "    Done"
	log "    Create out of file quota ..."
	$RUNAS touch ${TESTFILE}_xxx && \
		error "(usr) touch success, but expect EDQUOT"

	unlinkmany ${TESTFILE} $LIMIT
	rm -f ${TESTFILE}_xxx
	sync; sleep 1; sync;

	MDS_UUID=`do_facet mds $LCTL dl | grep -m1 mds | awk '{print $((NF-1))}'`
	MDS_QUOTA_USED=`$LFS quota -o $MDS_UUID -u $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
	echo $MDS_QUOTA_USED
	[ $MDS_QUOTA_USED -ne 0 ] && \
	    ($SHOW_QUOTA_USER; error "quota deleted isn't released")
	$SHOW_QUOTA_USER
        $LFS setquota -u $TSTUSR 0 0 0 0 $DIR		# clear user limit

        # test for group
	log "--------------------------------------"
        log "  Group quota (limit: $LIMIT FILE)"
        $LFS setquota -g $TSTUSR 0 0 0 $LIMIT $DIR
	sleep 3
        $SHOW_QUOTA_GROUP
        TESTFILE=$DIR/$tdir/$tfile-1

	log "    Create $LIMIT files ..."
	$RUNAS createmany -m ${TESTFILE} $LIMIT || \
		error "(usr) create failure, but except success"
	log "    Done"
	log "    Create out of file quota ..."
	$RUNAS touch ${TESTFILE}_xxx && \
		error "(usr) touch success, but expect EDQUOT"

	unlinkmany ${TESTFILE} $LIMIT
	rm -f ${TESTFILE}_xxx
	sync; sleep 1; sync;

	MDS_UUID=`do_facet mds $LCTL dl | grep -m1 mds | awk '{print $((NF-1))}'`
	MDS_QUOTA_USED=`$LFS quota -o $MDS_UUID -g $TSTUSR $DIR | awk '/^.*[[:digit:]+][[:space:]+]/ { print $4 }'`
	echo $MDS_QUOTA_USED
	[ $MDS_QUOTA_USED -ne 0 ] && \
	    ($SHOW_QUOTA_USER; error "quota deleted isn't released")
	$SHOW_QUOTA_GROUP
        $LFS setquota -g $TSTUSR 0 0 0 0 $DIR		# clear user limit
}

# file hard limit (normal use and out of quota)
test_2() {
	for i in `seq 1 $cycle`; do
	    # define ino_qunit is between 10 and 100
	    ino_qunit=$(( $RANDOM % 90 + 10 ))
	    ino_qtune=$(( $RANDOM % $ino_qunit ))
	    # RANDOM's maxium is 32767
	    i_limit=$(( $RANDOM % 990 + 10 ))
            set_file_tunesz $ino_qtune
	    set_file_unitsz $ino_qunit
	    echo "cycle: $i(total $cycle) iunit:$ino_qunit, itune:$ino_qtune, ilimit:$i_limit"
	    test_2_sub $i_limit
	    echo "=================================================="
	    set_file_unitsz 5120
	    set_file_tunesz 2560
        done
}
run_test 2 "File hard limit (normal use and out of quota) ==="

test_block_soft() {
	TESTFILE=$1
	TIMER=$(($2 * 3 / 2))
	OFFSET=0

	wait_delete_completed

	echo "    Write to exceed soft limit"
	RUNDD="$RUNAS dd if=/dev/zero of=$TESTFILE bs=$BLK_SZ"
	$RUNDD count=$((BUNIT_SZ+1)) || \
	        error "write failure, but expect success"
	OFFSET=$((OFFSET + BUNIT_SZ + 1))
        cancel_lru_locks osc

	$SHOW_QUOTA_USER
	$SHOW_QUOTA_GROUP
	$SHOW_QUOTA_INFO

	echo "    Write before timer goes off"
	$RUNDD count=$BUNIT_SZ seek=$OFFSET || \
	        error "write failure, but expect success"
	OFFSET=$((OFFSET + BUNIT_SZ))
        cancel_lru_locks osc
	echo "    Done"

        echo "    Sleep $TIMER seconds ..."
        sleep $TIMER

        $SHOW_QUOTA_USER
        $SHOW_QUOTA_GROUP
        $SHOW_QUOTA_INFO

	echo "    Write after timer goes off"
	# maybe cache write, ignore.
	$RUNDD count=$BUNIT_SZ seek=$OFFSET || true
	OFFSET=$((OFFSET + BUNIT_SZ))
        cancel_lru_locks osc
	$RUNDD count=$BUNIT_SZ seek=$OFFSET && \
	        error "write success, but expect EDQUOT"

        $SHOW_QUOTA_USER
        $SHOW_QUOTA_GROUP
        $SHOW_QUOTA_INFO

	echo "    Unlink file to stop timer"
	rm -f $TESTFILE
	sync; sleep 1; sync
	echo "    Done"

        $SHOW_QUOTA_USER
        $SHOW_QUOTA_GROUP
        $SHOW_QUOTA_INFO

	echo "    Write ..."
	$RUNDD count=$BUNIT_SZ || error "write failure, but expect success"
	echo "    Done"

	# cleanup
	rm -f $TESTFILE
	sync; sleep 3; sync;
}

# block soft limit (start timer, timer goes off, stop timer)
test_3() {
	chmod 0777 $DIR/$tdir

        # 1 bunit on mds and 1 bunit on every ost
	LIMIT=$(( $BUNIT_SZ * ($OSTCOUNT + 1) ))
	GRACE=10

	echo "  User quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
	TESTFILE=$DIR/$tdir/$tfile-0

	$LFS setstripe $TESTFILE -c 1
	chown $TSTUSR.$TSTUSR $TESTFILE

	$LFS setquota -t -u $GRACE $MAX_IQ_TIME $DIR
	$LFS setquota -u $TSTUSR $LIMIT 0 0 0 $DIR

	test_block_soft $TESTFILE $GRACE
	$LFS setquota -u $TSTUSR 0 0 0 0 $DIR

	echo "  Group quota (soft limit: $LIMIT kbytes  grace: $GRACE seconds)"
	TESTFILE=$DIR/$tdir/$tfile-1

	$LFS setstripe $TESTFILE -c 1
	chown $TSTUSR.$TSTUSR $TESTFILE

	$LFS setquota -t -g $GRACE $MAX_IQ_TIME $DIR
	$LFS setquota -g $TSTUSR $LIMIT 0 0 0 $DIR

	test_block_soft $TESTFILE $GRACE
	$LFS setquota -g $TSTUSR 0 0 0 0 $DIR
}
run_test 3 "Block soft limit (start timer, timer goes off, stop timer) ==="

test_file_soft() {
	TESTFILE=$1
	LIMIT=$2
	TIMER=$(($3 * 3 / 2))

	wait_delete_completed

	echo "    Create files to exceed soft limit"
	$RUNAS createmany -m ${TESTFILE}_ $((LIMIT + 1)) || \
		error "create failure, but expect success"
	sync; sleep 1; sync
	echo "    Done"

	echo "    Create file before timer goes off"
	$RUNAS touch ${TESTFILE}_before || \
		error "failed create before timer expired, but expect success"
	sync; sleep 1; sync
	echo "    Done"

	echo "    Sleep $TIMER seconds ..."
	sleep $TIMER

	$SHOW_QUOTA_USER
	$SHOW_QUOTA_GROUP
	$SHOW_QUOTA_INFO

	echo "    Create file after timer goes off"
	$RUNAS touch ${TESTFILE}_after ${TESTFILE}_after1 && \
		error "create after timer expired, but expect EDQUOT"
	sync; sleep 1; sync

	$SHOW_QUOTA_USER
	$SHOW_QUOTA_GROUP
	$SHOW_QUOTA_INFO

	echo "    Unlink files to stop timer"
	find `dirname $TESTFILE` -name "`basename ${TESTFILE}`*" | xargs rm -f
	echo "    Done"

	echo "    Create file"
	$RUNAS touch ${TESTFILE}_xxx || \
		error "touch after timer stop failure, but expect success"
	sync; sleep 1; sync
	echo "    Done"

	# cleanup
	rm -f ${TESTFILE}_xxx
	sync; sleep 3; sync;
}

# file soft limit (start timer, timer goes off, stop timer)