Commit 438769e3 authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: refactor default quota limits by resource 



Now that we've split up the dquot resource fields into separate structs,
do the same for the default limits to enable further refactoring.

Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarChandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
parent 51dbb1be

fs/xfs/xfs_dquot.c

+15 −15
Original line number Diff line number Diff line
@@ -77,22 +77,22 @@ xfs_qm_adjust_dqlimits( 
	ASSERT(dq->q_id);

	defq = xfs_get_defquota(q, xfs_dquot_type(dq));



	if (defq->bsoftlimit && !dq->q_blk.softlimit) {

		dq->q_blk.softlimit = defq->bsoftlimit;

	if (defq->blk.soft && !dq->q_blk.softlimit) {

		dq->q_blk.softlimit = defq->blk.soft;

		prealloc = 1;

	}

	if (defq->bhardlimit && !dq->q_blk.hardlimit) {

		dq->q_blk.hardlimit = defq->bhardlimit;

	if (defq->blk.hard && !dq->q_blk.hardlimit) {

		dq->q_blk.hardlimit = defq->blk.hard;

		prealloc = 1;

	}

	if (defq->isoftlimit && !dq->q_ino.softlimit)

		dq->q_ino.softlimit = defq->isoftlimit;

	if (defq->ihardlimit && !dq->q_ino.hardlimit)

		dq->q_ino.hardlimit = defq->ihardlimit;

	if (defq->rtbsoftlimit && !dq->q_rtb.softlimit)

		dq->q_rtb.softlimit = defq->rtbsoftlimit;

	if (defq->rtbhardlimit && !dq->q_rtb.hardlimit)

		dq->q_rtb.hardlimit = defq->rtbhardlimit;

	if (defq->ino.soft && !dq->q_ino.softlimit)

		dq->q_ino.softlimit = defq->ino.soft;

	if (defq->ino.hard && !dq->q_ino.hardlimit)

		dq->q_ino.hardlimit = defq->ino.hard;

	if (defq->rtb.soft && !dq->q_rtb.softlimit)

		dq->q_rtb.softlimit = defq->rtb.soft;

	if (defq->rtb.hard && !dq->q_rtb.hardlimit)

		dq->q_rtb.hardlimit = defq->rtb.hard;



	if (prealloc)

		xfs_dquot_set_prealloc_limits(dq);
@@ -137,7 +137,7 @@ xfs_qm_adjust_dqtimers( 
		    (dq->q_blk.hardlimit &&

		     (dq->q_blk.count > dq->q_blk.hardlimit))) {

			dq->q_blk.timer = ktime_get_real_seconds() +

					defq->btimelimit;

					defq->blk.time;

		} else {

			dq->q_blk.warnings = 0;

		}
@@ -156,7 +156,7 @@ xfs_qm_adjust_dqtimers( 
		    (dq->q_ino.hardlimit &&

		     (dq->q_ino.count > dq->q_ino.hardlimit))) {

			dq->q_ino.timer = ktime_get_real_seconds() +

					defq->itimelimit;

					defq->ino.time;

		} else {

			dq->q_ino.warnings = 0;

		}
@@ -175,7 +175,7 @@ xfs_qm_adjust_dqtimers( 
		    (dq->q_rtb.hardlimit &&

		     (dq->q_rtb.count > dq->q_rtb.hardlimit))) {

			dq->q_rtb.timer = ktime_get_real_seconds() +

					defq->rtbtimelimit;

					defq->rtb.time;

		} else {

			dq->q_rtb.warnings = 0;

		}

fs/xfs/xfs_qm.c

+18 −18
Original line number Diff line number Diff line
@@ -562,12 +562,12 @@ xfs_qm_set_defquota( 
	 * Timers and warnings have been already set, let's just set the

	 * default limits for this quota type

	 */

	defq->bhardlimit = dqp->q_blk.hardlimit;

	defq->bsoftlimit = dqp->q_blk.softlimit;

	defq->ihardlimit = dqp->q_ino.hardlimit;

	defq->isoftlimit = dqp->q_ino.softlimit;

	defq->rtbhardlimit = dqp->q_rtb.hardlimit;

	defq->rtbsoftlimit = dqp->q_rtb.softlimit;

	defq->blk.hard = dqp->q_blk.hardlimit;

	defq->blk.soft = dqp->q_blk.softlimit;

	defq->ino.hard = dqp->q_ino.hardlimit;

	defq->ino.soft = dqp->q_ino.softlimit;

	defq->rtb.hard = dqp->q_rtb.hardlimit;

	defq->rtb.soft = dqp->q_rtb.softlimit;

	xfs_qm_dqdestroy(dqp);

}
@@ -584,12 +584,12 @@ xfs_qm_init_timelimits( 


	defq = xfs_get_defquota(qinf, type);



	defq->btimelimit = XFS_QM_BTIMELIMIT;

	defq->itimelimit = XFS_QM_ITIMELIMIT;

	defq->rtbtimelimit = XFS_QM_RTBTIMELIMIT;

	defq->bwarnlimit = XFS_QM_BWARNLIMIT;

	defq->iwarnlimit = XFS_QM_IWARNLIMIT;

	defq->rtbwarnlimit = XFS_QM_RTBWARNLIMIT;

	defq->blk.time = XFS_QM_BTIMELIMIT;

	defq->ino.time = XFS_QM_ITIMELIMIT;

	defq->rtb.time = XFS_QM_RTBTIMELIMIT;

	defq->blk.warn = XFS_QM_BWARNLIMIT;

	defq->ino.warn = XFS_QM_IWARNLIMIT;

	defq->rtb.warn = XFS_QM_RTBWARNLIMIT;



	/*

	 * We try to get the limits from the superuser's limits fields.
@@ -608,17 +608,17 @@ xfs_qm_init_timelimits( 
	 * more writing. If it is zero, a default is used.

	 */

	if (dqp->q_blk.timer)

		defq->btimelimit = dqp->q_blk.timer;

		defq->blk.time = dqp->q_blk.timer;

	if (dqp->q_ino.timer)

		defq->itimelimit = dqp->q_ino.timer;

		defq->ino.time = dqp->q_ino.timer;

	if (dqp->q_rtb.timer)

		defq->rtbtimelimit = dqp->q_rtb.timer;

		defq->rtb.time = dqp->q_rtb.timer;

	if (dqp->q_blk.warnings)

		defq->bwarnlimit = dqp->q_blk.warnings;

		defq->blk.warn = dqp->q_blk.warnings;

	if (dqp->q_ino.warnings)

		defq->iwarnlimit = dqp->q_ino.warnings;

		defq->ino.warn = dqp->q_ino.warnings;

	if (dqp->q_rtb.warnings)

		defq->rtbwarnlimit = dqp->q_rtb.warnings;

		defq->rtb.warn = dqp->q_rtb.warnings;



	xfs_qm_dqdestroy(dqp);

}

fs/xfs/xfs_qm.h

+10 −12
Original line number Diff line number Diff line
@@ -30,20 +30,18 @@ extern struct kmem_zone *xfs_qm_dqtrxzone; 
	!dqp->q_rtb.count && \

	!dqp->q_ino.count)



struct xfs_quota_limits {

	xfs_qcnt_t		hard;	/* default hard limit */

	xfs_qcnt_t		soft;	/* default soft limit */

	time64_t		time;	/* limit for timers */

	xfs_qwarncnt_t		warn;	/* limit for warnings */

};



/* Defaults for each quota type: time limits, warn limits, usage limits */

struct xfs_def_quota {

	time64_t	btimelimit;	/* limit for blks timer */

	time64_t	itimelimit;	/* limit for inodes timer */

	time64_t	rtbtimelimit;	/* limit for rt blks timer */

	xfs_qwarncnt_t	bwarnlimit;	/* limit for blks warnings */

	xfs_qwarncnt_t	iwarnlimit;	/* limit for inodes warnings */

	xfs_qwarncnt_t	rtbwarnlimit;	/* limit for rt blks warnings */

	xfs_qcnt_t	bhardlimit;	/* default data blk hard limit */

	xfs_qcnt_t	bsoftlimit;	/* default data blk soft limit */

	xfs_qcnt_t	ihardlimit;	/* default inode count hard limit */

	xfs_qcnt_t	isoftlimit;	/* default inode count soft limit */

	xfs_qcnt_t	rtbhardlimit;	/* default realtime blk hard limit */

	xfs_qcnt_t	rtbsoftlimit;	/* default realtime blk soft limit */

	struct xfs_quota_limits	blk;

	struct xfs_quota_limits	ino;

	struct xfs_quota_limits	rtb;

};



/*

fs/xfs/xfs_qm_syscalls.c

+12 −12
Original line number Diff line number Diff line
@@ -502,8 +502,8 @@ xfs_qm_scall_setqlim( 
		dqp->q_blk.softlimit = soft;

		xfs_dquot_set_prealloc_limits(dqp);

		if (id == 0) {

			defq->bhardlimit = hard;

			defq->bsoftlimit = soft;

			defq->blk.hard = hard;

			defq->blk.soft = soft;

		}

	} else {

		xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);
@@ -518,8 +518,8 @@ xfs_qm_scall_setqlim( 
		dqp->q_rtb.hardlimit = hard;

		dqp->q_rtb.softlimit = soft;

		if (id == 0) {

			defq->rtbhardlimit = hard;

			defq->rtbsoftlimit = soft;

			defq->rtb.hard = hard;

			defq->rtb.soft = soft;

		}

	} else {

		xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);
@@ -535,8 +535,8 @@ xfs_qm_scall_setqlim( 
		dqp->q_ino.hardlimit = hard;

		dqp->q_ino.softlimit = soft;

		if (id == 0) {

			defq->ihardlimit = hard;

			defq->isoftlimit = soft;

			defq->ino.hard = hard;

			defq->ino.soft = soft;

		}

	} else {

		xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);
@@ -554,11 +554,11 @@ xfs_qm_scall_setqlim( 


	if (id == 0) {

		if (newlim->d_fieldmask & QC_SPC_WARNS)

			defq->bwarnlimit = newlim->d_spc_warns;

			defq->blk.warn = newlim->d_spc_warns;

		if (newlim->d_fieldmask & QC_INO_WARNS)

			defq->iwarnlimit = newlim->d_ino_warns;

			defq->ino.warn = newlim->d_ino_warns;

		if (newlim->d_fieldmask & QC_RT_SPC_WARNS)

			defq->rtbwarnlimit = newlim->d_rt_spc_warns;

			defq->rtb.warn = newlim->d_rt_spc_warns;

	}



	/*
@@ -579,11 +579,11 @@ xfs_qm_scall_setqlim( 


	if (id == 0) {

		if (newlim->d_fieldmask & QC_SPC_TIMER)

			defq->btimelimit = newlim->d_spc_timer;

			defq->blk.time = newlim->d_spc_timer;

		if (newlim->d_fieldmask & QC_INO_TIMER)

			defq->itimelimit = newlim->d_ino_timer;

			defq->ino.time = newlim->d_ino_timer;

		if (newlim->d_fieldmask & QC_RT_SPC_TIMER)

			defq->rtbtimelimit = newlim->d_rt_spc_timer;

			defq->rtb.time = newlim->d_rt_spc_timer;

	}



	if (id != 0) {

fs/xfs/xfs_quotaops.c

+6 −6
Original line number Diff line number Diff line
@@ -37,12 +37,12 @@ xfs_qm_fill_state( 
	tstate->flags |= QCI_SYSFILE;

	tstate->blocks = ip->i_d.di_nblocks;

	tstate->nextents = ip->i_df.if_nextents;

	tstate->spc_timelimit = (u32)defq->btimelimit;

	tstate->ino_timelimit = (u32)defq->itimelimit;

	tstate->rt_spc_timelimit = (u32)defq->rtbtimelimit;

	tstate->spc_warnlimit = defq->bwarnlimit;

	tstate->ino_warnlimit = defq->iwarnlimit;

	tstate->rt_spc_warnlimit = defq->rtbwarnlimit;

	tstate->spc_timelimit = (u32)defq->blk.time;

	tstate->ino_timelimit = (u32)defq->ino.time;

	tstate->rt_spc_timelimit = (u32)defq->rtb.time;

	tstate->spc_warnlimit = defq->blk.warn;

	tstate->ino_warnlimit = defq->ino.warn;

	tstate->rt_spc_warnlimit = defq->rtb.warn;

	if (tempqip)

		xfs_irele(ip);

}