All of lore.kernel.org
 help / color / mirror / Atom feed
From: Chandan Babu R <chandanrlinux@gmail.com>
To: "Darrick J. Wong" <darrick.wong@oracle.com>
Cc: linux-xfs@vger.kernel.org
Subject: Re: [PATCH 08/18] xfs: stop using q_core counters in the quota code
Date: Wed, 01 Jul 2020 14:03:45 +0530	[thread overview]
Message-ID: <2275486.PBonfk0Qrk@garuda> (raw)
In-Reply-To: <159353176230.2864738.15493398497982706092.stgit@magnolia>

On Tuesday 30 June 2020 9:12:42 PM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> 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.
>

The changes are logically correct.

Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>

> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> ---
>  fs/xfs/scrub/quota.c     |   18 ++++++------------
>  fs/xfs/xfs_dquot.c       |   47 +++++++++++++++++++++++++---------------------
>  fs/xfs/xfs_dquot.h       |    3 +++
>  fs/xfs/xfs_qm.c          |    6 +++---
>  fs/xfs/xfs_qm.h          |    6 +++---
>  fs/xfs/xfs_trace.h       |    4 ++--
>  fs/xfs/xfs_trans_dquot.c |   36 ++++++++++++++---------------------
>  7 files changed, 57 insertions(+), 63 deletions(-)
> 
> 
> diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
> index 1a1c6996fc69..2fc2625feca0 100644
> --- a/fs/xfs/scrub/quota.c
> +++ b/fs/xfs/scrub/quota.c
> @@ -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;
>  
> @@ -128,9 +125,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);
>  
>  	/*
> @@ -139,15 +133,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);
>  
>  	/*
> @@ -159,15 +153,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:
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 63f744bcbc90..02eae8c2ba1b 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -133,9 +133,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 {
> @@ -143,18 +143,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 {
> @@ -162,18 +162,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 {
> @@ -181,9 +181,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);
> @@ -565,6 +569,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. */
> @@ -1127,18 +1135,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;
>  
> diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
> index edb49788c476..23e05b0d7567 100644
> --- a/fs/xfs/xfs_dquot.h
> +++ b/fs/xfs/xfs_dquot.h
> @@ -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;
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index 54fc3aac1a68..b47bba204240 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -1093,14 +1093,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;
>  	}
>  
> diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
> index 84cb8af468b7..6ed4ae942603 100644
> --- a/fs/xfs/xfs_qm.h
> +++ b/fs/xfs/xfs_qm.h
> @@ -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)
>  
>  /*
>   * This defines the unit of allocation of dquots.
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index 7f744a37dc0e..851f97dfe9e3 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -880,8 +880,8 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
>  		__entry->flags = dqp->dq_flags;
>  		__entry->nrefs = dqp->q_nrefs;
>  		__entry->res_bcount = dqp->q_blk.reserved;
> -		__entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
> -		__entry->icount = be64_to_cpu(dqp->q_core.d_icount);
> +		__entry->bcount = dqp->q_blk.count;
> +		__entry->icount = dqp->q_ino.count;
>  		__entry->blk_hardlimit = dqp->q_blk.hardlimit;
>  		__entry->blk_softlimit = dqp->q_blk.softlimit;
>  		__entry->ino_hardlimit = dqp->q_ino.hardlimit;
> diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
> index 7a3d64eb9fbf..b36d747989a7 100644
> --- a/fs/xfs/xfs_trans_dquot.c
> +++ b/fs/xfs/xfs_trans_dquot.c
> @@ -309,7 +309,6 @@ xfs_trans_apply_dquot_deltas(
>  	int			i, j;
>  	struct xfs_dquot	*dqp;
>  	struct xfs_dqtrx	*qtrx, *qa;
> -	struct xfs_disk_dquot	*d;
>  	int64_t			totalbdelta;
>  	int64_t			totalrtbdelta;
>  
> @@ -341,7 +340,6 @@ xfs_trans_apply_dquot_deltas(
>  			/*
>  			 * adjust the actual number of blocks used
>  			 */
> -			d = &dqp->q_core;
>  
>  			/*
>  			 * The issue here is - sometimes we don't make a blkquota
> @@ -362,25 +360,22 @@ xfs_trans_apply_dquot_deltas(
>  				qtrx->qt_delrtb_delta;
>  #ifdef DEBUG
>  			if (totalbdelta < 0)
> -				ASSERT(be64_to_cpu(d->d_bcount) >=
> -				       -totalbdelta);
> +				ASSERT(dqp->q_blk.count >= -totalbdelta);
>  
>  			if (totalrtbdelta < 0)
> -				ASSERT(be64_to_cpu(d->d_rtbcount) >=
> -				       -totalrtbdelta);
> +				ASSERT(dqp->q_rtb.count >= -totalrtbdelta);
>  
>  			if (qtrx->qt_icount_delta < 0)
> -				ASSERT(be64_to_cpu(d->d_icount) >=
> -				       -qtrx->qt_icount_delta);
> +				ASSERT(dqp->q_ino.count >= -qtrx->qt_icount_delta);
>  #endif
>  			if (totalbdelta)
> -				be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta);
> +				dqp->q_blk.count += totalbdelta;
>  
>  			if (qtrx->qt_icount_delta)
> -				be64_add_cpu(&d->d_icount, (xfs_qcnt_t)qtrx->qt_icount_delta);
> +				dqp->q_ino.count += qtrx->qt_icount_delta;
>  
>  			if (totalrtbdelta)
> -				be64_add_cpu(&d->d_rtbcount, (xfs_qcnt_t)totalrtbdelta);
> +				dqp->q_rtb.count += totalrtbdelta;
>  
>  			/*
>  			 * Get any default limits in use.
> @@ -467,12 +462,9 @@ xfs_trans_apply_dquot_deltas(
>  					    (xfs_qcnt_t)qtrx->qt_icount_delta;
>  			}
>  
> -			ASSERT(dqp->q_blk.reserved >=
> -				be64_to_cpu(dqp->q_core.d_bcount));
> -			ASSERT(dqp->q_ino.reserved >=
> -				be64_to_cpu(dqp->q_core.d_icount));
> -			ASSERT(dqp->q_rtb.reserved >=
> -				be64_to_cpu(dqp->q_core.d_rtbcount));
> +			ASSERT(dqp->q_blk.reserved >= dqp->q_blk.count);
> +			ASSERT(dqp->q_ino.reserved >= dqp->q_ino.count);
> +			ASSERT(dqp->q_rtb.reserved >= dqp->q_rtb.count);
>  		}
>  	}
>  }
> @@ -645,7 +637,7 @@ xfs_trans_dqresv(
>  			}
>  		}
>  		if (ninos > 0) {
> -			total_count = dqp->q_res_icount + ninos;
> +			total_count = dqp->q_ino.reserved + ninos;
>  			timer = be32_to_cpu(dqp->q_core.d_itimer);
>  			warns = be16_to_cpu(dqp->q_core.d_iwarns);
>  			warnlimit = defq->iwarnlimit;
> @@ -675,7 +667,7 @@ xfs_trans_dqresv(
>  
>  	/*
>  	 * Change the reservation, but not the actual usage.
> -	 * Note that q_blk.reserved = q_core.d_bcount + resv
> +	 * Note that q_blk.reserved = q_blk.count + resv
>  	 */
>  	(*resbcountp) += (xfs_qcnt_t)nblks;
>  	if (ninos != 0)
> @@ -700,9 +692,9 @@ xfs_trans_dqresv(
>  					    XFS_TRANS_DQ_RES_INOS,
>  					    ninos);
>  	}
> -	ASSERT(dqp->q_blk.reserved >= be64_to_cpu(dqp->q_core.d_bcount));
> -	ASSERT(dqp->q_rtb.reserved >= be64_to_cpu(dqp->q_core.d_rtbcount));
> -	ASSERT(dqp->q_ino.reserved >= be64_to_cpu(dqp->q_core.d_icount));
> +	ASSERT(dqp->q_blk.reserved >= dqp->q_blk.count);
> +	ASSERT(dqp->q_rtb.reserved >= dqp->q_rtb.count);
> +	ASSERT(dqp->q_ino.reserved >= dqp->q_ino.count);
>  
>  	xfs_dqunlock(dqp);
>  	return 0;
> 
> 


-- 
chandan




  reply	other threads:[~2020-07-01  8:34 UTC|newest]

Thread overview: 94+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-06-30 15:41 [PATCH 00/18] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
2020-06-30 15:41 ` [PATCH 01/18] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush Darrick J. Wong
2020-06-30 21:35   ` Allison Collins
2020-07-01  8:32   ` Chandan Babu R
2020-07-01  8:33   ` Christoph Hellwig
2020-07-01 22:42     ` Dave Chinner
2020-06-30 15:42 ` [PATCH 02/18] xfs: fix inode quota reservation checks Darrick J. Wong
2020-06-30 21:35   ` Allison Collins
2020-07-01  8:33   ` Chandan Babu R
2020-07-01  8:34   ` Christoph Hellwig
2020-06-30 15:42 ` [PATCH 03/18] xfs: validate ondisk/incore dquot flags Darrick J. Wong
2020-06-30 21:35   ` Allison Collins
2020-07-01  8:33   ` Chandan Babu R
2020-07-01  8:42   ` Christoph Hellwig
2020-07-01 18:25     ` Darrick J. Wong
2020-07-02  6:30       ` Christoph Hellwig
2020-07-02 15:13         ` Darrick J. Wong
2020-07-01 22:41   ` Dave Chinner
2020-07-01 23:16     ` Darrick J. Wong
2020-06-30 15:42 ` [PATCH 04/18] xfs: stop using q_core.d_flags in the quota code Darrick J. Wong
2020-07-01  8:34   ` Chandan Babu R
2020-07-01  8:47   ` Christoph Hellwig
2020-07-01 19:02     ` Darrick J. Wong
2020-07-01 20:15   ` Allison Collins
2020-07-01 22:50   ` Dave Chinner
2020-07-01 23:19     ` Darrick J. Wong
2020-07-01 23:44       ` Dave Chinner
2020-07-01 23:50         ` Darrick J. Wong
2020-07-03  0:58           ` Dave Chinner
2020-07-03 18:01             ` Darrick J. Wong
2020-06-30 15:42 ` [PATCH 05/18] xfs: stop using q_core.d_id " Darrick J. Wong
2020-07-01  8:33   ` Chandan Babu R
2020-07-01  8:48   ` Christoph Hellwig
2020-07-01 20:16   ` Allison Collins
2020-06-30 15:42 ` [PATCH 06/18] xfs: use a per-resource struct for incore dquot data Darrick J. Wong
2020-07-01  8:33   ` Chandan Babu R
2020-07-01  8:49   ` Christoph Hellwig
2020-07-01 20:16   ` Allison Collins
2020-06-30 15:42 ` [PATCH 07/18] xfs: stop using q_core limits in the quota code Darrick J. Wong
2020-07-01  8:33   ` Chandan Babu R
2020-07-01  8:50   ` Christoph Hellwig
2020-07-01 20:16   ` Allison Collins
2020-07-01 23:01   ` Dave Chinner
2020-07-01 23:13     ` Darrick J. Wong
2020-07-01 23:33       ` Darrick J. Wong
2020-07-01 23:45         ` Dave Chinner
2020-06-30 15:42 ` [PATCH 08/18] xfs: stop using q_core counters " Darrick J. Wong
2020-07-01  8:33   ` Chandan Babu R [this message]
2020-07-01  8:51   ` Christoph Hellwig
2020-07-01 23:20   ` Allison Collins
2020-06-30 15:42 ` [PATCH 09/18] xfs: stop using q_core warning " Darrick J. Wong
2020-07-01  8:33   ` Chandan Babu R
2020-07-01  8:51   ` Christoph Hellwig
2020-07-01 23:20   ` Allison Collins
2020-06-30 15:42 ` [PATCH 10/18] xfs: stop using q_core timers " Darrick J. Wong
2020-07-01  8:34   ` Chandan Babu R
2020-07-01  8:51   ` Christoph Hellwig
2020-07-01 23:20   ` Allison Collins
2020-06-30 15:43 ` [PATCH 11/18] xfs: remove qcore from incore dquots Darrick J. Wong
2020-07-01  8:34   ` Chandan Babu R
2020-07-01  8:52   ` Christoph Hellwig
2020-07-01 23:07   ` Dave Chinner
2020-07-01 23:14     ` Darrick J. Wong
2020-07-02  2:06   ` Allison Collins
2020-06-30 15:43 ` [PATCH 12/18] xfs: refactor default quota limits by resource Darrick J. Wong
2020-07-01  8:52   ` Chandan Babu R
2020-07-01  8:53   ` Christoph Hellwig
2020-07-01 23:30   ` Dave Chinner
2020-07-02  0:07     ` Darrick J. Wong
2020-07-02  2:06   ` Allison Collins
2020-06-30 15:43 ` [PATCH 13/18] xfs: remove unnecessary arguments from quota adjust functions Darrick J. Wong
2020-07-01  8:53   ` Christoph Hellwig
2020-07-01  8:58   ` Chandan Babu R
2020-07-02  2:06   ` Allison Collins
2020-06-30 15:43 ` [PATCH 14/18] xfs: refactor quota exceeded test Darrick J. Wong
2020-07-01  8:56   ` Christoph Hellwig
2020-07-01 17:51     ` Darrick J. Wong
2020-07-01 18:48       ` Eric Sandeen
2020-07-01 23:34       ` Dave Chinner
2020-07-01 10:19   ` Chandan Babu R
2020-07-02 18:57   ` Allison Collins
2020-06-30 15:43 ` [PATCH 15/18] xfs: refactor xfs_qm_scall_setqlim Darrick J. Wong
2020-07-01  8:56   ` Christoph Hellwig
2020-07-03  4:11   ` Allison Collins
2020-07-03 12:39   ` Chandan Babu R
2020-06-30 15:43 ` [PATCH 16/18] xfs: refactor xfs_trans_dqresv Darrick J. Wong
2020-07-03  4:11   ` Allison Collins
2020-07-03 13:00   ` Chandan Babu R
2020-06-30 15:43 ` [PATCH 17/18] xfs: refactor xfs_trans_apply_dquot_deltas Darrick J. Wong
2020-07-04 20:41   ` Allison Collins
2020-07-06 13:40   ` Chandan Babu R
2020-06-30 15:43 ` [PATCH 18/18] xfs: add more dquot tracepoints Darrick J. Wong
2020-07-04 20:41   ` Allison Collins
2020-07-06 13:42   ` Chandan Babu R

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=2275486.PBonfk0Qrk@garuda \
    --to=chandanrlinux@gmail.com \
    --cc=darrick.wong@oracle.com \
    --cc=linux-xfs@vger.kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.