Linux-XFS Archive on lore.kernel.org
 help / color / 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 06/18] xfs: use a per-resource struct for incore dquot data
Date: Wed, 01 Jul 2020 14:03:28 +0530
Message-ID: <3751802.jQPj3mRFqf@garuda> (raw)
In-Reply-To: <159353174945.2864738.16786596402939892293.stgit@magnolia>

On Tuesday 30 June 2020 9:12:29 PM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
> 
> Introduce a new struct xfs_dquot_res that we'll use to track all the
> incore data for a particular resource type (block, inode, rt block).
> This will help us (once we've eliminated q_core) to declutter quota
> functions that currently open-code field access or pass around fields
> around explicitly.
>

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/xfs_dquot.c       |    6 +++---
>  fs/xfs/xfs_dquot.h       |   18 +++++++++++-------
>  fs/xfs/xfs_iomap.c       |    6 +++---
>  fs/xfs/xfs_qm.c          |    6 +++---
>  fs/xfs/xfs_qm_bhv.c      |    8 ++++----
>  fs/xfs/xfs_qm_syscalls.c |    6 +++---
>  fs/xfs/xfs_trace.h       |    2 +-
>  fs/xfs/xfs_trans_dquot.c |   42 +++++++++++++++++++++---------------------
>  8 files changed, 49 insertions(+), 45 deletions(-)
> 
> 
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 76b35888e726..03624a8f0566 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -552,9 +552,9 @@ xfs_dquot_from_disk(
>  	 * Reservation counters are defined as reservation plus current usage
>  	 * to avoid having to add every time.
>  	 */
> -	dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
> -	dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
> -	dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
> +	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);
>  
>  	/* initialize the dquot speculative prealloc thresholds */
>  	xfs_dquot_set_prealloc_limits(dqp);
> diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
> index 5ea1f1515979..cb20df1e774f 100644
> --- a/fs/xfs/xfs_dquot.h
> +++ b/fs/xfs/xfs_dquot.h
> @@ -27,6 +27,11 @@ enum {
>  	XFS_QLOWSP_MAX
>  };
>  
> +struct xfs_dquot_res {
> +	/* Total resources allocated and reserved. */
> +	xfs_qcnt_t		reserved;
> +};
> +
>  /*
>   * The incore dquot structure
>   */
> @@ -40,14 +45,13 @@ struct xfs_dquot {
>  	xfs_daddr_t		q_blkno;
>  	xfs_fileoff_t		q_fileoffset;
>  
> +	struct xfs_dquot_res	q_blk;	/* regular blocks */
> +	struct xfs_dquot_res	q_ino;	/* inodes */
> +	struct xfs_dquot_res	q_rtb;	/* realtime blocks */
> +
>  	struct xfs_disk_dquot	q_core;
>  	struct xfs_dq_logitem	q_logitem;
> -	/* total regular nblks used+reserved */
> -	xfs_qcnt_t		q_res_bcount;
> -	/* total inos allocd+reserved */
> -	xfs_qcnt_t		q_res_icount;
> -	/* total realtime blks used+reserved */
> -	xfs_qcnt_t		q_res_rtbcount;
> +
>  	xfs_qcnt_t		q_prealloc_lo_wmark;
>  	xfs_qcnt_t		q_prealloc_hi_wmark;
>  	int64_t			q_low_space[XFS_QLOWSP_MAX];
> @@ -138,7 +142,7 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
>  {
>  	int64_t freesp;
>  
> -	freesp = be64_to_cpu(dqp->q_core.d_blk_hardlimit) - dqp->q_res_bcount;
> +	freesp = be64_to_cpu(dqp->q_core.d_blk_hardlimit) - dqp->q_blk.reserved;
>  	if (freesp < dqp->q_low_space[XFS_QLOWSP_1_PCNT])
>  		return true;
>  
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index b9a8c3798e08..f60a6e44363b 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -307,7 +307,7 @@ xfs_quota_need_throttle(
>  		return false;
>  
>  	/* under the lo watermark, no throttle */
> -	if (dq->q_res_bcount + alloc_blocks < dq->q_prealloc_lo_wmark)
> +	if (dq->q_blk.reserved + alloc_blocks < dq->q_prealloc_lo_wmark)
>  		return false;
>  
>  	return true;
> @@ -326,13 +326,13 @@ xfs_quota_calc_throttle(
>  	struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
>  
>  	/* no dq, or over hi wmark, squash the prealloc completely */
> -	if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
> +	if (!dq || dq->q_blk.reserved >= dq->q_prealloc_hi_wmark) {
>  		*qblocks = 0;
>  		*qfreesp = 0;
>  		return;
>  	}
>  
> -	freesp = dq->q_prealloc_hi_wmark - dq->q_res_bcount;
> +	freesp = dq->q_prealloc_hi_wmark - dq->q_blk.reserved;
>  	if (freesp < dq->q_low_space[XFS_QLOWSP_5_PCNT]) {
>  		shift = 2;
>  		if (freesp < dq->q_low_space[XFS_QLOWSP_3_PCNT])
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index 95e51186bd57..6ce3a4402041 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -1096,14 +1096,14 @@ xfs_qm_quotacheck_dqadjust(
>  	 * resource usage.
>  	 */
>  	be64_add_cpu(&dqp->q_core.d_icount, 1);
> -	dqp->q_res_icount++;
> +	dqp->q_ino.reserved++;
>  	if (nblks) {
>  		be64_add_cpu(&dqp->q_core.d_bcount, nblks);
> -		dqp->q_res_bcount += nblks;
> +		dqp->q_blk.reserved += nblks;
>  	}
>  	if (rtblks) {
>  		be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
> -		dqp->q_res_rtbcount += rtblks;
> +		dqp->q_rtb.reserved += rtblks;
>  	}
>  
>  	/*
> diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
> index fc2fa418919f..94b2b4b0fc17 100644
> --- a/fs/xfs/xfs_qm_bhv.c
> +++ b/fs/xfs/xfs_qm_bhv.c
> @@ -29,8 +29,8 @@ xfs_fill_statvfs_from_dquot(
>  	if (limit && statp->f_blocks > limit) {
>  		statp->f_blocks = limit;
>  		statp->f_bfree = statp->f_bavail =
> -			(statp->f_blocks > dqp->q_res_bcount) ?
> -			 (statp->f_blocks - dqp->q_res_bcount) : 0;
> +			(statp->f_blocks > dqp->q_blk.reserved) ?
> +			 (statp->f_blocks - dqp->q_blk.reserved) : 0;
>  	}
>  
>  	limit = dqp->q_core.d_ino_softlimit ?
> @@ -39,8 +39,8 @@ xfs_fill_statvfs_from_dquot(
>  	if (limit && statp->f_files > limit) {
>  		statp->f_files = limit;
>  		statp->f_ffree =
> -			(statp->f_files > dqp->q_res_icount) ?
> -			 (statp->f_files - dqp->q_res_icount) : 0;
> +			(statp->f_files > dqp->q_ino.reserved) ?
> +			 (statp->f_files - dqp->q_ino.reserved) : 0;
>  	}
>  }
>  
> diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
> index 90a11e7daf92..56fe80395679 100644
> --- a/fs/xfs/xfs_qm_syscalls.c
> +++ b/fs/xfs/xfs_qm_syscalls.c
> @@ -625,8 +625,8 @@ xfs_qm_scall_getquota_fill_qc(
>  		XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_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_space = XFS_FSB_TO_B(mp, dqp->q_res_bcount);
> -	dst->d_ino_count = dqp->q_res_icount;
> +	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_ino_warns = be16_to_cpu(dqp->q_core.d_iwarns);
> @@ -635,7 +635,7 @@ xfs_qm_scall_getquota_fill_qc(
>  		XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_hardlimit));
>  	dst->d_rt_spc_softlimit =
>  		XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_softlimit));
> -	dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_res_rtbcount);
> +	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_warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
>  
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index 78d9dbc7614d..71567ed367f2 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -879,7 +879,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
>  		__entry->id = dqp->q_id;
>  		__entry->flags = dqp->dq_flags;
>  		__entry->nrefs = dqp->q_nrefs;
> -		__entry->res_bcount = dqp->q_res_bcount;
> +		__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->blk_hardlimit =
> diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
> index a2656ec6ea76..469bf7946d3d 100644
> --- a/fs/xfs/xfs_trans_dquot.c
> +++ b/fs/xfs/xfs_trans_dquot.c
> @@ -409,11 +409,11 @@ xfs_trans_apply_dquot_deltas(
>  
>  				if (qtrx->qt_blk_res != blk_res_used) {
>  					if (qtrx->qt_blk_res > blk_res_used)
> -						dqp->q_res_bcount -= (xfs_qcnt_t)
> +						dqp->q_blk.reserved -= (xfs_qcnt_t)
>  							(qtrx->qt_blk_res -
>  							 blk_res_used);
>  					else
> -						dqp->q_res_bcount -= (xfs_qcnt_t)
> +						dqp->q_blk.reserved -= (xfs_qcnt_t)
>  							(blk_res_used -
>  							 qtrx->qt_blk_res);
>  				}
> @@ -426,7 +426,7 @@ xfs_trans_apply_dquot_deltas(
>  				 * deliberately skip quota reservations.
>  				 */
>  				if (qtrx->qt_bcount_delta) {
> -					dqp->q_res_bcount +=
> +					dqp->q_blk.reserved +=
>  					      (xfs_qcnt_t)qtrx->qt_bcount_delta;
>  				}
>  			}
> @@ -437,17 +437,17 @@ xfs_trans_apply_dquot_deltas(
>  				if (qtrx->qt_rtblk_res != qtrx->qt_rtblk_res_used) {
>  					if (qtrx->qt_rtblk_res >
>  					    qtrx->qt_rtblk_res_used)
> -					       dqp->q_res_rtbcount -= (xfs_qcnt_t)
> +					       dqp->q_rtb.reserved -= (xfs_qcnt_t)
>  						       (qtrx->qt_rtblk_res -
>  							qtrx->qt_rtblk_res_used);
>  					else
> -					       dqp->q_res_rtbcount -= (xfs_qcnt_t)
> +					       dqp->q_rtb.reserved -= (xfs_qcnt_t)
>  						       (qtrx->qt_rtblk_res_used -
>  							qtrx->qt_rtblk_res);
>  				}
>  			} else {
>  				if (qtrx->qt_rtbcount_delta)
> -					dqp->q_res_rtbcount +=
> +					dqp->q_rtb.reserved +=
>  					    (xfs_qcnt_t)qtrx->qt_rtbcount_delta;
>  			}
>  
> @@ -458,20 +458,20 @@ xfs_trans_apply_dquot_deltas(
>  				ASSERT(qtrx->qt_ino_res >=
>  				       qtrx->qt_ino_res_used);
>  				if (qtrx->qt_ino_res > qtrx->qt_ino_res_used)
> -					dqp->q_res_icount -= (xfs_qcnt_t)
> +					dqp->q_ino.reserved -= (xfs_qcnt_t)
>  						(qtrx->qt_ino_res -
>  						 qtrx->qt_ino_res_used);
>  			} else {
>  				if (qtrx->qt_icount_delta)
> -					dqp->q_res_icount +=
> +					dqp->q_ino.reserved +=
>  					    (xfs_qcnt_t)qtrx->qt_icount_delta;
>  			}
>  
> -			ASSERT(dqp->q_res_bcount >=
> +			ASSERT(dqp->q_blk.reserved >=
>  				be64_to_cpu(dqp->q_core.d_bcount));
> -			ASSERT(dqp->q_res_icount >=
> +			ASSERT(dqp->q_ino.reserved >=
>  				be64_to_cpu(dqp->q_core.d_icount));
> -			ASSERT(dqp->q_res_rtbcount >=
> +			ASSERT(dqp->q_rtb.reserved >=
>  				be64_to_cpu(dqp->q_core.d_rtbcount));
>  		}
>  	}
> @@ -516,7 +516,7 @@ xfs_trans_unreserve_and_mod_dquots(
>  			if (qtrx->qt_blk_res) {
>  				xfs_dqlock(dqp);
>  				locked = true;
> -				dqp->q_res_bcount -=
> +				dqp->q_blk.reserved -=
>  					(xfs_qcnt_t)qtrx->qt_blk_res;
>  			}
>  			if (qtrx->qt_ino_res) {
> @@ -524,7 +524,7 @@ xfs_trans_unreserve_and_mod_dquots(
>  					xfs_dqlock(dqp);
>  					locked = true;
>  				}
> -				dqp->q_res_icount -=
> +				dqp->q_ino.reserved -=
>  					(xfs_qcnt_t)qtrx->qt_ino_res;
>  			}
>  
> @@ -533,7 +533,7 @@ xfs_trans_unreserve_and_mod_dquots(
>  					xfs_dqlock(dqp);
>  					locked = true;
>  				}
> -				dqp->q_res_rtbcount -=
> +				dqp->q_rtb.reserved -=
>  					(xfs_qcnt_t)qtrx->qt_rtblk_res;
>  			}
>  			if (locked)
> @@ -602,7 +602,7 @@ xfs_trans_dqresv(
>  		timer = be32_to_cpu(dqp->q_core.d_btimer);
>  		warns = be16_to_cpu(dqp->q_core.d_bwarns);
>  		warnlimit = defq->bwarnlimit;
> -		resbcountp = &dqp->q_res_bcount;
> +		resbcountp = &dqp->q_blk.reserved;
>  	} else {
>  		ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
>  		hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
> @@ -614,7 +614,7 @@ xfs_trans_dqresv(
>  		timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
>  		warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
>  		warnlimit = defq->rtbwarnlimit;
> -		resbcountp = &dqp->q_res_rtbcount;
> +		resbcountp = &dqp->q_rtb.reserved;
>  	}
>  
>  	if ((flags & XFS_QMOPT_FORCE_RES) == 0 && dqp->q_id &&
> @@ -675,11 +675,11 @@ xfs_trans_dqresv(
>  
>  	/*
>  	 * Change the reservation, but not the actual usage.
> -	 * Note that q_res_bcount = q_core.d_bcount + resv
> +	 * Note that q_blk.reserved = q_core.d_bcount + resv
>  	 */
>  	(*resbcountp) += (xfs_qcnt_t)nblks;
>  	if (ninos != 0)
> -		dqp->q_res_icount += (xfs_qcnt_t)ninos;
> +		dqp->q_ino.reserved += (xfs_qcnt_t)ninos;
>  
>  	/*
>  	 * note the reservation amt in the trans struct too,
> @@ -700,9 +700,9 @@ xfs_trans_dqresv(
>  					    XFS_TRANS_DQ_RES_INOS,
>  					    ninos);
>  	}
> -	ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount));
> -	ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount));
> -	ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount));
> +	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));
>  
>  	xfs_dqunlock(dqp);
>  	return 0;
> 
> 


-- 
chandan




  reply index

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 [this message]
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
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=3751802.jQPj3mRFqf@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

Linux-XFS Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/linux-xfs/0 linux-xfs/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 linux-xfs linux-xfs/ https://lore.kernel.org/linux-xfs \
		linux-xfs@vger.kernel.org
	public-inbox-index linux-xfs

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.linux-xfs


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git