Commit 19dce7ea authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: stop using q_core timers in the quota code 



Add timers fields to the incore dquot, and use that instead of the ones
in qcore.  This eliminates a bunch of endian conversions and will
eventually allow us to remove qcore entirely.

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>
Reviewed-by: default avatarAllison Collins <allison.henderson@oracle.com>
parent c8c45fb2

fs/xfs/xfs_dquot.c

+23 −17
Original line number Diff line number Diff line
@@ -117,7 +117,6 @@ xfs_qm_adjust_dqtimers( 
	struct xfs_dquot	*dq)

{

	struct xfs_quotainfo	*qi = mp->m_quotainfo;

	struct xfs_disk_dquot	*d = &dq->q_core;

	struct xfs_def_quota	*defq;



	ASSERT(dq->q_id);
@@ -132,13 +131,13 @@ xfs_qm_adjust_dqtimers( 
		ASSERT(dq->q_rtb.softlimit <= dq->q_rtb.hardlimit);

#endif



	if (!d->d_btimer) {

	if (!dq->q_blk.timer) {

		if ((dq->q_blk.softlimit &&

		     (dq->q_blk.count > dq->q_blk.softlimit)) ||

		    (dq->q_blk.hardlimit &&

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

			d->d_btimer = cpu_to_be32(ktime_get_real_seconds() +

					defq->btimelimit);

			dq->q_blk.timer = ktime_get_real_seconds() +

					defq->btimelimit;

		} else {

			dq->q_blk.warnings = 0;

		}
@@ -147,17 +146,17 @@ xfs_qm_adjust_dqtimers( 
		     (dq->q_blk.count <= dq->q_blk.softlimit)) &&

		    (!dq->q_blk.hardlimit ||

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

			d->d_btimer = 0;

			dq->q_blk.timer = 0;

		}

	}



	if (!d->d_itimer) {

	if (!dq->q_ino.timer) {

		if ((dq->q_ino.softlimit &&

		     (dq->q_ino.count > dq->q_ino.softlimit)) ||

		    (dq->q_ino.hardlimit &&

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

			d->d_itimer = cpu_to_be32(ktime_get_real_seconds() +

					defq->itimelimit);

			dq->q_ino.timer = ktime_get_real_seconds() +

					defq->itimelimit;

		} else {

			dq->q_ino.warnings = 0;

		}
@@ -166,17 +165,17 @@ xfs_qm_adjust_dqtimers( 
		     (dq->q_ino.count <= dq->q_ino.softlimit))  &&

		    (!dq->q_ino.hardlimit ||

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

			d->d_itimer = 0;

			dq->q_ino.timer = 0;

		}

	}



	if (!d->d_rtbtimer) {

	if (!dq->q_rtb.timer) {

		if ((dq->q_rtb.softlimit &&

		     (dq->q_rtb.count > dq->q_rtb.softlimit)) ||

		    (dq->q_rtb.hardlimit &&

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

			d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() +

					defq->rtbtimelimit);

			dq->q_rtb.timer = ktime_get_real_seconds() +

					defq->rtbtimelimit;

		} else {

			dq->q_rtb.warnings = 0;

		}
@@ -185,7 +184,7 @@ xfs_qm_adjust_dqtimers( 
		     (dq->q_rtb.count <= dq->q_rtb.softlimit)) &&

		    (!dq->q_rtb.hardlimit ||

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

			d->d_rtbtimer = 0;

			dq->q_rtb.timer = 0;

		}

	}

}
@@ -546,6 +545,10 @@ xfs_dquot_from_disk( 
	dqp->q_ino.warnings = be16_to_cpu(ddqp->d_iwarns);

	dqp->q_rtb.warnings = be16_to_cpu(ddqp->d_rtbwarns);



	dqp->q_blk.timer = be32_to_cpu(ddqp->d_btimer);

	dqp->q_ino.timer = be32_to_cpu(ddqp->d_itimer);

	dqp->q_rtb.timer = be32_to_cpu(ddqp->d_rtbtimer);



	/*

	 * Reservation counters are defined as reservation plus current usage

	 * to avoid having to add every time.
@@ -580,6 +583,10 @@ xfs_dquot_to_disk( 
	ddqp->d_bwarns = cpu_to_be16(dqp->q_blk.warnings);

	ddqp->d_iwarns = cpu_to_be16(dqp->q_ino.warnings);

	ddqp->d_rtbwarns = cpu_to_be16(dqp->q_rtb.warnings);



	ddqp->d_btimer = cpu_to_be32(dqp->q_blk.timer);

	ddqp->d_itimer = cpu_to_be32(dqp->q_ino.timer);

	ddqp->d_rtbtimer = cpu_to_be32(dqp->q_rtb.timer);

}



/* Allocate and initialize the dquot buffer for this in-core dquot. */
@@ -1141,7 +1148,6 @@ static xfs_failaddr_t 
xfs_qm_dqflush_check(

	struct xfs_dquot	*dqp)

{

	struct xfs_disk_dquot	*ddq = &dqp->q_core;

	__u8			type = dqp->dq_flags & XFS_DQ_ALLTYPES;



	if (type != XFS_DQ_USER &&
@@ -1153,15 +1159,15 @@ xfs_qm_dqflush_check( 
		return NULL;



	if (dqp->q_blk.softlimit && dqp->q_blk.count > dqp->q_blk.softlimit &&

	    !ddq->d_btimer)

	    !dqp->q_blk.timer)

		return __this_address;



	if (dqp->q_ino.softlimit && dqp->q_ino.count > dqp->q_ino.softlimit &&

	    !ddq->d_itimer)

	    !dqp->q_ino.timer)

		return __this_address;



	if (dqp->q_rtb.softlimit && dqp->q_rtb.count > dqp->q_rtb.softlimit &&

	    !ddq->d_rtbtimer)

	    !dqp->q_rtb.timer)

		return __this_address;



	return NULL;

fs/xfs/xfs_dquot.h

+7 −0
Original line number Diff line number Diff line
@@ -38,6 +38,13 @@ struct xfs_dquot_res { 
	xfs_qcnt_t		hardlimit;

	xfs_qcnt_t		softlimit;



	/*

	 * For root dquots, this is the default grace period, in seconds.

	 * Otherwise, this is when the quota grace period expires,

	 * in seconds since the Unix epoch.

	 */

	time64_t		timer;



	/*

	 * For root dquots, this is the maximum number of warnings that will

	 * be issued for this quota type.  Otherwise, this is the number of

fs/xfs/xfs_qm.c

+6 −9
Original line number Diff line number Diff line
@@ -579,7 +579,6 @@ xfs_qm_init_timelimits( 
{

	struct xfs_quotainfo	*qinf = mp->m_quotainfo;

	struct xfs_def_quota	*defq;

	struct xfs_disk_dquot	*ddqp;

	struct xfs_dquot	*dqp;

	int			error;
@@ -603,19 +602,17 @@ xfs_qm_init_timelimits( 
	if (error)

		return;



	ddqp = &dqp->q_core;



	/*

	 * The warnings and timers set the grace period given to

	 * a user or group before he or she can not perform any

	 * more writing. If it is zero, a default is used.

	 */

	if (ddqp->d_btimer)

		defq->btimelimit = be32_to_cpu(ddqp->d_btimer);

	if (ddqp->d_itimer)

		defq->itimelimit = be32_to_cpu(ddqp->d_itimer);

	if (ddqp->d_rtbtimer)

		defq->rtbtimelimit = be32_to_cpu(ddqp->d_rtbtimer);

	if (dqp->q_blk.timer)

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

	if (dqp->q_ino.timer)

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

	if (dqp->q_rtb.timer)

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

	if (dqp->q_blk.warnings)

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

	if (dqp->q_ino.warnings)

fs/xfs/xfs_qm_syscalls.c

+8 −10
Original line number Diff line number Diff line
@@ -447,7 +447,6 @@ xfs_qm_scall_setqlim( 
	struct qc_dqblk		*newlim)

{

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	struct xfs_disk_dquot	*ddq;

	struct xfs_dquot	*dqp;

	struct xfs_trans	*tp;

	struct xfs_def_quota	*defq;
@@ -488,7 +487,6 @@ xfs_qm_scall_setqlim( 


	xfs_dqlock(dqp);

	xfs_trans_dqjoin(tp, dqp);

	ddq = &dqp->q_core;



	/*

	 * Make sure that hardlimits are >= soft limits before changing.
@@ -573,11 +571,11 @@ xfs_qm_scall_setqlim( 
	 * the soft limit.

	 */

	if (newlim->d_fieldmask & QC_SPC_TIMER)

		ddq->d_btimer = cpu_to_be32(newlim->d_spc_timer);

		dqp->q_blk.timer = newlim->d_spc_timer;

	if (newlim->d_fieldmask & QC_INO_TIMER)

		ddq->d_itimer = cpu_to_be32(newlim->d_ino_timer);

		dqp->q_ino.timer = newlim->d_ino_timer;

	if (newlim->d_fieldmask & QC_RT_SPC_TIMER)

		ddq->d_rtbtimer = cpu_to_be32(newlim->d_rt_spc_timer);

		dqp->q_rtb.timer = newlim->d_rt_spc_timer;



	if (id == 0) {

		if (newlim->d_fieldmask & QC_SPC_TIMER)
@@ -621,18 +619,18 @@ xfs_qm_scall_getquota_fill_qc( 
	memset(dst, 0, sizeof(*dst));

	dst->d_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_blk.hardlimit);

	dst->d_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_blk.softlimit);

	dst->d_ino_hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);

	dst->d_ino_softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);

	dst->d_ino_hardlimit = dqp->q_ino.hardlimit;

	dst->d_ino_softlimit = dqp->q_ino.softlimit;

	dst->d_space = XFS_FSB_TO_B(mp, dqp->q_blk.reserved);

	dst->d_ino_count = dqp->q_ino.reserved;

	dst->d_spc_timer = be32_to_cpu(dqp->q_core.d_btimer);

	dst->d_ino_timer = be32_to_cpu(dqp->q_core.d_itimer);

	dst->d_spc_timer = dqp->q_blk.timer;

	dst->d_ino_timer = dqp->q_ino.timer;

	dst->d_ino_warns = dqp->q_ino.warnings;

	dst->d_spc_warns = dqp->q_blk.warnings;

	dst->d_rt_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.hardlimit);

	dst->d_rt_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.softlimit);

	dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_rtb.reserved);

	dst->d_rt_spc_timer = be32_to_cpu(dqp->q_core.d_rtbtimer);

	dst->d_rt_spc_timer = dqp->q_rtb.timer;

	dst->d_rt_spc_warns = dqp->q_rtb.warnings;



	/*

fs/xfs/xfs_trans_dquot.c

+3 −3
Original line number Diff line number Diff line
@@ -591,7 +591,7 @@ xfs_trans_dqresv( 
		softlimit = dqp->q_blk.softlimit;

		if (!softlimit)

			softlimit = defq->bsoftlimit;

		timer = be32_to_cpu(dqp->q_core.d_btimer);

		timer = dqp->q_blk.timer;

		warns = dqp->q_blk.warnings;

		warnlimit = defq->bwarnlimit;

		resbcountp = &dqp->q_blk.reserved;
@@ -603,7 +603,7 @@ xfs_trans_dqresv( 
		softlimit = dqp->q_rtb.softlimit;

		if (!softlimit)

			softlimit = defq->rtbsoftlimit;

		timer = be32_to_cpu(dqp->q_core.d_rtbtimer);

		timer = dqp->q_rtb.timer;

		warns = dqp->q_rtb.warnings;

		warnlimit = defq->rtbwarnlimit;

		resbcountp = &dqp->q_rtb.reserved;
@@ -638,7 +638,7 @@ xfs_trans_dqresv( 
		}

		if (ninos > 0) {

			total_count = dqp->q_ino.reserved + ninos;

			timer = be32_to_cpu(dqp->q_core.d_itimer);

			timer = dqp->q_ino.timer;

			warns = dqp->q_ino.warnings;

			warnlimit = defq->iwarnlimit;

			hardlimit = dqp->q_ino.hardlimit;