diff mbox series

[10/11] xfs: refactor xfs_icache_free_{eof,cow}blocks call sites

Message ID 161142797509.2171939.4924852652653930954.stgit@magnolia (mailing list archive)
State Superseded
Headers show
Series xfs: try harder to reclaim space when we run out | expand

Commit Message

Darrick J. Wong Jan. 23, 2021, 6:52 p.m. UTC 
From: Darrick J. Wong <djwong@kernel.org>

In anticipation of more restructuring of the eof/cowblocks gc code,
refactor calling of those two functions into a single internal helper
function, then present a new standard interface to purge speculative
block preallocations and start shifting higher level code to use that.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/xfs/xfs_file.c   |    3 +--
 fs/xfs/xfs_icache.c |   39 +++++++++++++++++++++++++++++++++------
 fs/xfs/xfs_icache.h |    1 +
 fs/xfs/xfs_trace.h  |    1 +
 4 files changed, 36 insertions(+), 8 deletions(-)

Comments

Christoph Hellwig Jan. 24, 2021, 9:41 a.m. UTC | #1 
On Sat, Jan 23, 2021 at 10:52:55AM -0800, Darrick J. Wong wrote:
> From: Darrick J. Wong <djwong@kernel.org>
> 
> In anticipation of more restructuring of the eof/cowblocks gc code,
> refactor calling of those two functions into a single internal helper
> function, then present a new standard interface to purge speculative
> block preallocations and start shifting higher level code to use that.
> 
> Signed-off-by: Darrick J. Wong <djwong@kernel.org>

Looks good,

Reviewed-by: Christoph Hellwig <hch@lst.de>
Brian Foster Jan. 25, 2021, 6:46 p.m. UTC | #2 
On Sat, Jan 23, 2021 at 10:52:55AM -0800, Darrick J. Wong wrote:
> From: Darrick J. Wong <djwong@kernel.org>
> 
> In anticipation of more restructuring of the eof/cowblocks gc code,
> refactor calling of those two functions into a single internal helper
> function, then present a new standard interface to purge speculative
> block preallocations and start shifting higher level code to use that.
> 
> Signed-off-by: Darrick J. Wong <djwong@kernel.org>
> ---
>  fs/xfs/xfs_file.c   |    3 +--
>  fs/xfs/xfs_icache.c |   39 +++++++++++++++++++++++++++++++++------
>  fs/xfs/xfs_icache.h |    1 +
>  fs/xfs/xfs_trace.h  |    1 +
>  4 files changed, 36 insertions(+), 8 deletions(-)
> 
> 
...
> diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> index 7f999f9dd80a..0d228a5e879f 100644
> --- a/fs/xfs/xfs_icache.c
> +++ b/fs/xfs/xfs_icache.c
> @@ -1645,6 +1645,38 @@ xfs_start_block_reaping(
>  	xfs_queue_cowblocks(mp);
>  }
>  
> +/* Scan all incore inodes for block preallocations that we can remove. */
> +static inline int
> +xfs_blockgc_scan(
> +	struct xfs_mount	*mp,
> +	struct xfs_eofblocks	*eofb)
> +{
> +	int			error;
> +
> +	error = xfs_icache_free_eofblocks(mp, eofb);
> +	if (error)
> +		return error;
> +
> +	error = xfs_icache_free_cowblocks(mp, eofb);
> +	if (error)
> +		return error;
> +
> +	return 0;
> +}
> +
> +/*
> + * Try to free space in the filesystem by purging eofblocks and cowblocks.
> + */
> +int
> +xfs_blockgc_free_space(
> +	struct xfs_mount	*mp,
> +	struct xfs_eofblocks	*eofb)
> +{
> +	trace_xfs_blockgc_free_space(mp, eofb, _RET_IP_);
> +
> +	return xfs_blockgc_scan(mp, eofb);
> +}
> +

What's the need for two helpers instead of just
xfs_blockgc_free_space()? Otherwise seems fine.

Brian

>  /*
>   * Run cow/eofblocks scans on the supplied dquots.  We don't know exactly which
>   * quota caused an allocation failure, so we make a best effort by including
> @@ -1661,7 +1693,6 @@ xfs_blockgc_free_dquots(
>  	struct xfs_eofblocks	eofb = {0};
>  	struct xfs_mount	*mp = NULL;
>  	bool			do_work = false;
> -	int			error;
>  
>  	if (!udqp && !gdqp && !pdqp)
>  		return 0;
> @@ -1699,11 +1730,7 @@ xfs_blockgc_free_dquots(
>  	if (!do_work)
>  		return 0;
>  
> -	error = xfs_icache_free_eofblocks(mp, &eofb);
> -	if (error)
> -		return error;
> -
> -	return xfs_icache_free_cowblocks(mp, &eofb);
> +	return xfs_blockgc_free_space(mp, &eofb);
>  }
>  
>  /*
> diff --git a/fs/xfs/xfs_icache.h b/fs/xfs/xfs_icache.h
> index 5f520de637f6..583c132ae0fb 100644
> --- a/fs/xfs/xfs_icache.h
> +++ b/fs/xfs/xfs_icache.h
> @@ -57,6 +57,7 @@ void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
>  int xfs_blockgc_free_dquots(struct xfs_dquot *udqp, struct xfs_dquot *gdqp,
>  		struct xfs_dquot *pdqp, unsigned int eof_flags);
>  int xfs_blockgc_free_quota(struct xfs_inode *ip, unsigned int eof_flags);
> +int xfs_blockgc_free_space(struct xfs_mount *mp, struct xfs_eofblocks *eofb);
>  
>  void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip);
>  void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip);
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index 4cbf446bae9a..c3fd344aaf5b 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -3926,6 +3926,7 @@ DEFINE_EVENT(xfs_eofblocks_class, name,	\
>  		 unsigned long caller_ip), \
>  	TP_ARGS(mp, eofb, caller_ip))
>  DEFINE_EOFBLOCKS_EVENT(xfs_ioc_free_eofblocks);
> +DEFINE_EOFBLOCKS_EVENT(xfs_blockgc_free_space);
>  
>  #endif /* _TRACE_XFS_H */
>  
>
Darrick J. Wong Jan. 26, 2021, 2:33 a.m. UTC | #3 
On Mon, Jan 25, 2021 at 01:46:01PM -0500, Brian Foster wrote:
> On Sat, Jan 23, 2021 at 10:52:55AM -0800, Darrick J. Wong wrote:
> > From: Darrick J. Wong <djwong@kernel.org>
> > 
> > In anticipation of more restructuring of the eof/cowblocks gc code,
> > refactor calling of those two functions into a single internal helper
> > function, then present a new standard interface to purge speculative
> > block preallocations and start shifting higher level code to use that.
> > 
> > Signed-off-by: Darrick J. Wong <djwong@kernel.org>
> > ---
> >  fs/xfs/xfs_file.c   |    3 +--
> >  fs/xfs/xfs_icache.c |   39 +++++++++++++++++++++++++++++++++------
> >  fs/xfs/xfs_icache.h |    1 +
> >  fs/xfs/xfs_trace.h  |    1 +
> >  4 files changed, 36 insertions(+), 8 deletions(-)
> > 
> > 
> ...
> > diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> > index 7f999f9dd80a..0d228a5e879f 100644
> > --- a/fs/xfs/xfs_icache.c
> > +++ b/fs/xfs/xfs_icache.c
> > @@ -1645,6 +1645,38 @@ xfs_start_block_reaping(
> >  	xfs_queue_cowblocks(mp);
> >  }
> >  
> > +/* Scan all incore inodes for block preallocations that we can remove. */
> > +static inline int
> > +xfs_blockgc_scan(
> > +	struct xfs_mount	*mp,
> > +	struct xfs_eofblocks	*eofb)
> > +{
> > +	int			error;
> > +
> > +	error = xfs_icache_free_eofblocks(mp, eofb);
> > +	if (error)
> > +		return error;
> > +
> > +	error = xfs_icache_free_cowblocks(mp, eofb);
> > +	if (error)
> > +		return error;
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * Try to free space in the filesystem by purging eofblocks and cowblocks.
> > + */
> > +int
> > +xfs_blockgc_free_space(
> > +	struct xfs_mount	*mp,
> > +	struct xfs_eofblocks	*eofb)
> > +{
> > +	trace_xfs_blockgc_free_space(mp, eofb, _RET_IP_);
> > +
> > +	return xfs_blockgc_scan(mp, eofb);
> > +}
> > +
> 
> What's the need for two helpers instead of just
> xfs_blockgc_free_space()? Otherwise seems fine.

The whole mess of helpers are combined in interesting ways in the "xfs:
consolidate posteof and cowblocks cleanup" patchset that follows this
one.  The xfs_iwalk_ag loops under xfs_icache_free_{eof,cow}blocks get
hoisted to xfs_blockgc_free_space so we only do the iteration once.

Hm, I guess an additional optimization would be to combine them in the
final product as a patch 10/9.

--D

> Brian
> 
> >  /*
> >   * Run cow/eofblocks scans on the supplied dquots.  We don't know exactly which
> >   * quota caused an allocation failure, so we make a best effort by including
> > @@ -1661,7 +1693,6 @@ xfs_blockgc_free_dquots(
> >  	struct xfs_eofblocks	eofb = {0};
> >  	struct xfs_mount	*mp = NULL;
> >  	bool			do_work = false;
> > -	int			error;
> >  
> >  	if (!udqp && !gdqp && !pdqp)
> >  		return 0;
> > @@ -1699,11 +1730,7 @@ xfs_blockgc_free_dquots(
> >  	if (!do_work)
> >  		return 0;
> >  
> > -	error = xfs_icache_free_eofblocks(mp, &eofb);
> > -	if (error)
> > -		return error;
> > -
> > -	return xfs_icache_free_cowblocks(mp, &eofb);
> > +	return xfs_blockgc_free_space(mp, &eofb);
> >  }
> >  
> >  /*
> > diff --git a/fs/xfs/xfs_icache.h b/fs/xfs/xfs_icache.h
> > index 5f520de637f6..583c132ae0fb 100644
> > --- a/fs/xfs/xfs_icache.h
> > +++ b/fs/xfs/xfs_icache.h
> > @@ -57,6 +57,7 @@ void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
> >  int xfs_blockgc_free_dquots(struct xfs_dquot *udqp, struct xfs_dquot *gdqp,
> >  		struct xfs_dquot *pdqp, unsigned int eof_flags);
> >  int xfs_blockgc_free_quota(struct xfs_inode *ip, unsigned int eof_flags);
> > +int xfs_blockgc_free_space(struct xfs_mount *mp, struct xfs_eofblocks *eofb);
> >  
> >  void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip);
> >  void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip);
> > diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> > index 4cbf446bae9a..c3fd344aaf5b 100644
> > --- a/fs/xfs/xfs_trace.h
> > +++ b/fs/xfs/xfs_trace.h
> > @@ -3926,6 +3926,7 @@ DEFINE_EVENT(xfs_eofblocks_class, name,	\
> >  		 unsigned long caller_ip), \
> >  	TP_ARGS(mp, eofb, caller_ip))
> >  DEFINE_EOFBLOCKS_EVENT(xfs_ioc_free_eofblocks);
> > +DEFINE_EOFBLOCKS_EVENT(xfs_blockgc_free_space);
> >  
> >  #endif /* _TRACE_XFS_H */
> >  
> > 
>
diff mbox series

Patch

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 57086838a676..a766ad4477c5 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -758,8 +758,7 @@  xfs_file_buffered_write(
 
 		xfs_iunlock(ip, iolock);
 		eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
-		xfs_icache_free_eofblocks(ip->i_mount, &eofb);
-		xfs_icache_free_cowblocks(ip->i_mount, &eofb);
+		xfs_blockgc_free_space(ip->i_mount, &eofb);
 		goto write_retry;
 	}
 
diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 7f999f9dd80a..0d228a5e879f 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -1645,6 +1645,38 @@  xfs_start_block_reaping(
 	xfs_queue_cowblocks(mp);
 }
 
+/* Scan all incore inodes for block preallocations that we can remove. */
+static inline int
+xfs_blockgc_scan(
+	struct xfs_mount	*mp,
+	struct xfs_eofblocks	*eofb)
+{
+	int			error;
+
+	error = xfs_icache_free_eofblocks(mp, eofb);
+	if (error)
+		return error;
+
+	error = xfs_icache_free_cowblocks(mp, eofb);
+	if (error)
+		return error;
+
+	return 0;
+}
+
+/*
+ * Try to free space in the filesystem by purging eofblocks and cowblocks.
+ */
+int
+xfs_blockgc_free_space(
+	struct xfs_mount	*mp,
+	struct xfs_eofblocks	*eofb)
+{
+	trace_xfs_blockgc_free_space(mp, eofb, _RET_IP_);
+
+	return xfs_blockgc_scan(mp, eofb);
+}
+
 /*
  * Run cow/eofblocks scans on the supplied dquots.  We don't know exactly which
  * quota caused an allocation failure, so we make a best effort by including
@@ -1661,7 +1693,6 @@  xfs_blockgc_free_dquots(
 	struct xfs_eofblocks	eofb = {0};
 	struct xfs_mount	*mp = NULL;
 	bool			do_work = false;
-	int			error;
 
 	if (!udqp && !gdqp && !pdqp)
 		return 0;
@@ -1699,11 +1730,7 @@  xfs_blockgc_free_dquots(
 	if (!do_work)
 		return 0;
 
-	error = xfs_icache_free_eofblocks(mp, &eofb);
-	if (error)
-		return error;
-
-	return xfs_icache_free_cowblocks(mp, &eofb);
+	return xfs_blockgc_free_space(mp, &eofb);
 }
 
 /*
diff --git a/fs/xfs/xfs_icache.h b/fs/xfs/xfs_icache.h
index 5f520de637f6..583c132ae0fb 100644
--- a/fs/xfs/xfs_icache.h
+++ b/fs/xfs/xfs_icache.h
@@ -57,6 +57,7 @@  void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
 int xfs_blockgc_free_dquots(struct xfs_dquot *udqp, struct xfs_dquot *gdqp,
 		struct xfs_dquot *pdqp, unsigned int eof_flags);
 int xfs_blockgc_free_quota(struct xfs_inode *ip, unsigned int eof_flags);
+int xfs_blockgc_free_space(struct xfs_mount *mp, struct xfs_eofblocks *eofb);
 
 void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip);
 void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip);
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 4cbf446bae9a..c3fd344aaf5b 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -3926,6 +3926,7 @@  DEFINE_EVENT(xfs_eofblocks_class, name,	\
 		 unsigned long caller_ip), \
 	TP_ARGS(mp, eofb, caller_ip))
 DEFINE_EOFBLOCKS_EVENT(xfs_ioc_free_eofblocks);
+DEFINE_EOFBLOCKS_EVENT(xfs_blockgc_free_space);
 
 #endif /* _TRACE_XFS_H */