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

xfs: stop using q_core counters in the quota code 



Add counter 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 d3537cf9

fs/xfs/scrub/quota.c

+6 −12
Original line number Diff line number Diff line
@@ -82,9 +82,6 @@ xchk_quota_item( 
	struct xfs_disk_dquot	*d = &dq->q_core;

	struct xfs_quotainfo	*qi = mp->m_quotainfo;

	xfs_fileoff_t		offset;

	unsigned long long	bcount;

	unsigned long long	icount;

	unsigned long long	rcount;

	xfs_ino_t		fs_icount;

	int			error = 0;
@@ -132,9 +129,6 @@ xchk_quota_item( 
		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);



	/* Check the resource counts. */

	bcount = be64_to_cpu(d->d_bcount);

	icount = be64_to_cpu(d->d_icount);

	rcount = be64_to_cpu(d->d_rtbcount);

	fs_icount = percpu_counter_sum(&mp->m_icount);



	/*
@@ -143,15 +137,15 @@ xchk_quota_item( 
	 * if there are no quota limits.

	 */

	if (xfs_sb_version_hasreflink(&mp->m_sb)) {

		if (mp->m_sb.sb_dblocks < bcount)

		if (mp->m_sb.sb_dblocks < dq->q_blk.count)

			xchk_fblock_set_warning(sc, XFS_DATA_FORK,

					offset);

	} else {

		if (mp->m_sb.sb_dblocks < bcount)

		if (mp->m_sb.sb_dblocks < dq->q_blk.count)

			xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,

					offset);

	}

	if (icount > fs_icount || rcount > mp->m_sb.sb_rblocks)

	if (dq->q_ino.count > fs_icount || dq->q_rtb.count > mp->m_sb.sb_rblocks)

		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);



	/*
@@ -163,15 +157,15 @@ xchk_quota_item( 
		goto out;



	if (dq->q_blk.hardlimit != 0 &&

	    bcount > dq->q_blk.hardlimit)

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

		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);



	if (dq->q_ino.hardlimit != 0 &&

	    icount > dq->q_ino.hardlimit)

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

		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);



	if (dq->q_rtb.hardlimit != 0 &&

	    rcount > dq->q_rtb.hardlimit)

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

		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);



out:

fs/xfs/xfs_dquot.c

+26 −21
Original line number Diff line number Diff line
@@ -134,9 +134,9 @@ xfs_qm_adjust_dqtimers( 


	if (!d->d_btimer) {

		if ((dq->q_blk.softlimit &&

		     (be64_to_cpu(d->d_bcount) > dq->q_blk.softlimit)) ||

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

		    (dq->q_blk.hardlimit &&

		     (be64_to_cpu(d->d_bcount) > dq->q_blk.hardlimit))) {

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

			d->d_btimer = cpu_to_be32(ktime_get_real_seconds() +

					defq->btimelimit);

		} else {
@@ -144,18 +144,18 @@ xfs_qm_adjust_dqtimers( 
		}

	} else {

		if ((!dq->q_blk.softlimit ||

		     (be64_to_cpu(d->d_bcount) <= dq->q_blk.softlimit)) &&

		     (dq->q_blk.count <= dq->q_blk.softlimit)) &&

		    (!dq->q_blk.hardlimit ||

		    (be64_to_cpu(d->d_bcount) <= dq->q_blk.hardlimit))) {

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

			d->d_btimer = 0;

		}

	}



	if (!d->d_itimer) {

		if ((dq->q_ino.softlimit &&

		     (be64_to_cpu(d->d_icount) > dq->q_ino.softlimit)) ||

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

		    (dq->q_ino.hardlimit &&

		     (be64_to_cpu(d->d_icount) > dq->q_ino.hardlimit))) {

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

			d->d_itimer = cpu_to_be32(ktime_get_real_seconds() +

					defq->itimelimit);

		} else {
@@ -163,18 +163,18 @@ xfs_qm_adjust_dqtimers( 
		}

	} else {

		if ((!dq->q_ino.softlimit ||

		     (be64_to_cpu(d->d_icount) <= dq->q_ino.softlimit))  &&

		     (dq->q_ino.count <= dq->q_ino.softlimit))  &&

		    (!dq->q_ino.hardlimit ||

		     (be64_to_cpu(d->d_icount) <= dq->q_ino.hardlimit))) {

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

			d->d_itimer = 0;

		}

	}



	if (!d->d_rtbtimer) {

		if ((dq->q_rtb.softlimit &&

		     (be64_to_cpu(d->d_rtbcount) > dq->q_rtb.softlimit)) ||

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

		    (dq->q_rtb.hardlimit &&

		     (be64_to_cpu(d->d_rtbcount) > dq->q_rtb.hardlimit))) {

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

			d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() +

					defq->rtbtimelimit);

		} else {
@@ -182,9 +182,9 @@ xfs_qm_adjust_dqtimers( 
		}

	} else {

		if ((!dq->q_rtb.softlimit ||

		     (be64_to_cpu(d->d_rtbcount) <= dq->q_rtb.softlimit)) &&

		     (dq->q_rtb.count <= dq->q_rtb.softlimit)) &&

		    (!dq->q_rtb.hardlimit ||

		     (be64_to_cpu(d->d_rtbcount) <= dq->q_rtb.hardlimit))) {

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

			d->d_rtbtimer = 0;

		}

	}
@@ -538,13 +538,17 @@ xfs_dquot_from_disk( 
	dqp->q_rtb.hardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);

	dqp->q_rtb.softlimit = be64_to_cpu(ddqp->d_rtb_softlimit);



	dqp->q_blk.count = be64_to_cpu(ddqp->d_bcount);

	dqp->q_ino.count = be64_to_cpu(ddqp->d_icount);

	dqp->q_rtb.count = be64_to_cpu(ddqp->d_rtbcount);



	/*

	 * Reservation counters are defined as reservation plus current usage

	 * to avoid having to add every time.

	 */

	dqp->q_blk.reserved = be64_to_cpu(ddqp->d_bcount);

	dqp->q_ino.reserved = be64_to_cpu(ddqp->d_icount);

	dqp->q_rtb.reserved = be64_to_cpu(ddqp->d_rtbcount);

	dqp->q_blk.reserved = dqp->q_blk.count;

	dqp->q_ino.reserved = dqp->q_ino.count;

	dqp->q_rtb.reserved = dqp->q_rtb.count;



	/* initialize the dquot speculative prealloc thresholds */

	xfs_dquot_set_prealloc_limits(dqp);
@@ -564,6 +568,10 @@ xfs_dquot_to_disk( 
	ddqp->d_ino_softlimit = cpu_to_be64(dqp->q_ino.softlimit);

	ddqp->d_rtb_hardlimit = cpu_to_be64(dqp->q_rtb.hardlimit);

	ddqp->d_rtb_softlimit = cpu_to_be64(dqp->q_rtb.softlimit);



	ddqp->d_bcount = cpu_to_be64(dqp->q_blk.count);

	ddqp->d_icount = cpu_to_be64(dqp->q_ino.count);

	ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count);

}



/* Allocate and initialize the dquot buffer for this in-core dquot. */
@@ -1136,18 +1144,15 @@ xfs_qm_dqflush_check( 
	if (dqp->q_id == 0)

		return NULL;



	if (dqp->q_blk.softlimit &&

	    be64_to_cpu(ddq->d_bcount) > dqp->q_blk.softlimit &&

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

	    !ddq->d_btimer)

		return __this_address;



	if (dqp->q_ino.softlimit &&

	    be64_to_cpu(ddq->d_icount) > dqp->q_ino.softlimit &&

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

	    !ddq->d_itimer)

		return __this_address;



	if (dqp->q_rtb.softlimit &&

	    be64_to_cpu(ddq->d_rtbcount) > dqp->q_rtb.softlimit &&

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

	    !ddq->d_rtbtimer)

		return __this_address;

fs/xfs/xfs_dquot.h

+3 −0
Original line number Diff line number Diff line
@@ -31,6 +31,9 @@ struct xfs_dquot_res { 
	/* Total resources allocated and reserved. */

	xfs_qcnt_t		reserved;



	/* Total resources allocated. */

	xfs_qcnt_t		count;



	/* Absolute and preferred limits. */

	xfs_qcnt_t		hardlimit;

	xfs_qcnt_t		softlimit;

fs/xfs/xfs_qm.c

+3 −3
Original line number Diff line number Diff line
@@ -1089,14 +1089,14 @@ xfs_qm_quotacheck_dqadjust( 
	 * Adjust the inode count and the block count to reflect this inode's

	 * resource usage.

	 */

	be64_add_cpu(&dqp->q_core.d_icount, 1);

	dqp->q_ino.count++;

	dqp->q_ino.reserved++;

	if (nblks) {

		be64_add_cpu(&dqp->q_core.d_bcount, nblks);

		dqp->q_blk.count += nblks;

		dqp->q_blk.reserved += nblks;

	}

	if (rtblks) {

		be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);

		dqp->q_rtb.count += rtblks;

		dqp->q_rtb.reserved += rtblks;

	}

fs/xfs/xfs_qm.h

+3 −3
Original line number Diff line number Diff line
@@ -26,9 +26,9 @@ extern struct kmem_zone *xfs_qm_dqtrxzone; 
	!dqp->q_rtb.softlimit && \

	!dqp->q_ino.hardlimit && \

	!dqp->q_ino.softlimit && \

	!dqp->q_core.d_bcount && \

	!dqp->q_core.d_rtbcount && \

	!dqp->q_core.d_icount)

	!dqp->q_blk.count && \

	!dqp->q_rtb.count && \

	!dqp->q_ino.count)



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

struct xfs_def_quota {