[05/11] xfs: make xfs_buf_read_map return an error code
diff mbox series

Message ID 157924224846.3029431.3421957295562306193.stgit@magnolia
State Superseded
Headers show
Series
  • xfs: make buffer functions return error codes
Related show

Commit Message

Darrick J. Wong Jan. 17, 2020, 6:24 a.m. UTC
From: Darrick J. Wong <darrick.wong@oracle.com>

Convert xfs_buf_read_map() to return numeric error codes like most
everywhere else in xfs.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/libxfs/xfs_alloc.c |    4 ++--
 fs/xfs/xfs_buf.c          |   37 +++++++++++++++++++++----------------
 fs/xfs/xfs_buf.h          |   12 +++++-------
 fs/xfs/xfs_trans_buf.c    |    9 +++------
 4 files changed, 31 insertions(+), 31 deletions(-)

Comments

Christoph Hellwig Jan. 17, 2020, 6:50 a.m. UTC | #1
> @@ -842,13 +845,15 @@ xfs_buf_read_map(
>  		 * drop the buffer
>  		 */
>  		xfs_buf_relse(bp);
> -		return NULL;
> +		*bpp = NULL;

We already set *bpp to NULL at the very beginning, so this line is
redundant.

> @@ -860,19 +865,18 @@ xfs_buf_read(
>  	struct xfs_buf		**bpp,
>  	const struct xfs_buf_ops *ops)
>  {
>  	int			error;
>  	DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
>  
> -	*bpp = NULL;
> -	bp = xfs_buf_read_map(target, &map, 1, flags, ops);
> -	if (!bp)
> -		return -ENOMEM;
> -	error = bp->b_error;
> +	error = xfs_buf_read_map(target, &map, 1, flags, bpp, ops);
> +	if (error)
> +		return error;
> +	error = (*bpp)->b_error;
>  	if (error) {
> +		xfs_buf_ioerror_alert(*bpp, __func__);
> +		xfs_buf_stale(*bpp);
> +		xfs_buf_relse(*bpp);
> +		*bpp = NULL;
>  
>  		/* bad CRC means corrupted metadata */
>  		if (error == -EFSBADCRC)

I still think we have a problem here.  We should not have to check
->b_error, and the xfs_buf_ioerror_alert should be either in the callers
or in xfs_buf_read_map, as xfs_buf_read is just supposed to be a trivial
wrapper for the single map case, not add functionality of its own.
Darrick J. Wong Jan. 17, 2020, 10:58 p.m. UTC | #2
On Thu, Jan 16, 2020 at 10:50:20PM -0800, Christoph Hellwig wrote:
> > @@ -842,13 +845,15 @@ xfs_buf_read_map(
> >  		 * drop the buffer
> >  		 */
> >  		xfs_buf_relse(bp);
> > -		return NULL;
> > +		*bpp = NULL;
> 
> We already set *bpp to NULL at the very beginning, so this line is
> redundant.

Will fix.

> > @@ -860,19 +865,18 @@ xfs_buf_read(
> >  	struct xfs_buf		**bpp,
> >  	const struct xfs_buf_ops *ops)
> >  {
> >  	int			error;
> >  	DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
> >  
> > -	*bpp = NULL;
> > -	bp = xfs_buf_read_map(target, &map, 1, flags, ops);
> > -	if (!bp)
> > -		return -ENOMEM;
> > -	error = bp->b_error;
> > +	error = xfs_buf_read_map(target, &map, 1, flags, bpp, ops);
> > +	if (error)
> > +		return error;
> > +	error = (*bpp)->b_error;
> >  	if (error) {
> > +		xfs_buf_ioerror_alert(*bpp, __func__);
> > +		xfs_buf_stale(*bpp);
> > +		xfs_buf_relse(*bpp);
> > +		*bpp = NULL;
> >  
> >  		/* bad CRC means corrupted metadata */
> >  		if (error == -EFSBADCRC)
> 
> I still think we have a problem here.  We should not have to check
> ->b_error, and the xfs_buf_ioerror_alert should be either in the callers
> or in xfs_buf_read_map, as xfs_buf_read is just supposed to be a trivial
> wrapper for the single map case, not add functionality of its own.

Yeah.  I've redone the patchset to keep xfs_buf_read() as a static
inline function, then refactored the ioerror/stale/relse bits as a
separate patch on the end.

--D

Patch
diff mbox series

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index fc93fd88ec89..51818245eae2 100644
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -2960,10 +2960,10 @@  xfs_read_agf(
 			mp, tp, mp->m_ddev_targp,
 			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
 			XFS_FSS_TO_BB(mp, 1), flags, bpp, &xfs_agf_buf_ops);
+	if (error == -EAGAIN)
+		return 0;
 	if (error)
 		return error;
-	if (!*bpp)
-		return 0;
 
 	ASSERT(!(*bpp)->b_error);
 	xfs_buf_set_ref(*bpp, XFS_AGF_REF);
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 8778c4b38af7..f95c999b3343 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -809,21 +809,23 @@  xfs_buf_reverify(
 	return bp->b_error;
 }
 
-xfs_buf_t *
+int
 xfs_buf_read_map(
 	struct xfs_buftarg	*target,
 	struct xfs_buf_map	*map,
 	int			nmaps,
 	xfs_buf_flags_t		flags,
+	struct xfs_buf		**bpp,
 	const struct xfs_buf_ops *ops)
 {
 	struct xfs_buf		*bp;
 
 	flags |= XBF_READ;
+	*bpp = NULL;
 
 	bp = xfs_buf_get_map(target, map, nmaps, flags);
 	if (!bp)
-		return NULL;
+		return -ENOMEM;
 
 	trace_xfs_buf_read(bp, flags, _RET_IP_);
 
@@ -831,7 +833,8 @@  xfs_buf_read_map(
 		XFS_STATS_INC(target->bt_mount, xb_get_read);
 		bp->b_ops = ops;
 		_xfs_buf_read(bp, flags);
-		return bp;
+		*bpp = bp;
+		return 0;
 	}
 
 	xfs_buf_reverify(bp, ops);
@@ -842,13 +845,15 @@  xfs_buf_read_map(
 		 * drop the buffer
 		 */
 		xfs_buf_relse(bp);
-		return NULL;
+		*bpp = NULL;
+		return 0;
 	}
 
 	/* We do not want read in the flags */
 	bp->b_flags &= ~XBF_READ;
 	ASSERT(bp->b_ops != NULL || ops == NULL);
-	return bp;
+	*bpp = bp;
+	return 0;
 }
 
 int
@@ -860,19 +865,18 @@  xfs_buf_read(
 	struct xfs_buf		**bpp,
 	const struct xfs_buf_ops *ops)
 {
-	struct xfs_buf		*bp;
 	int			error;
 	DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
 
-	*bpp = NULL;
-	bp = xfs_buf_read_map(target, &map, 1, flags, ops);
-	if (!bp)
-		return -ENOMEM;
-	error = bp->b_error;
+	error = xfs_buf_read_map(target, &map, 1, flags, bpp, ops);
+	if (error)
+		return error;
+	error = (*bpp)->b_error;
 	if (error) {
-		xfs_buf_ioerror_alert(bp, __func__);
-		xfs_buf_stale(bp);
-		xfs_buf_relse(bp);
+		xfs_buf_ioerror_alert(*bpp, __func__);
+		xfs_buf_stale(*bpp);
+		xfs_buf_relse(*bpp);
+		*bpp = NULL;
 
 		/* bad CRC means corrupted metadata */
 		if (error == -EFSBADCRC)
@@ -880,7 +884,6 @@  xfs_buf_read(
 		return error;
 	}
 
-	*bpp = bp;
 	return 0;
 }
 
@@ -895,11 +898,13 @@  xfs_buf_readahead_map(
 	int			nmaps,
 	const struct xfs_buf_ops *ops)
 {
+	struct xfs_buf		*bp;
+
 	if (bdi_read_congested(target->bt_bdev->bd_bdi))
 		return;
 
 	xfs_buf_read_map(target, map, nmaps,
-		     XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops);
+		     XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD, &bp, ops);
 }
 
 /*
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 1ee516ef2c66..36d43bead158 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -195,13 +195,11 @@  struct xfs_buf *xfs_buf_incore(struct xfs_buftarg *target,
 struct xfs_buf *xfs_buf_get_map(struct xfs_buftarg *target,
 			       struct xfs_buf_map *map, int nmaps,
 			       xfs_buf_flags_t flags);
-struct xfs_buf *xfs_buf_read_map(struct xfs_buftarg *target,
-			       struct xfs_buf_map *map, int nmaps,
-			       xfs_buf_flags_t flags,
-			       const struct xfs_buf_ops *ops);
-void xfs_buf_readahead_map(struct xfs_buftarg *target,
-			       struct xfs_buf_map *map, int nmaps,
-			       const struct xfs_buf_ops *ops);
+int xfs_buf_read_map(struct xfs_buftarg *target, struct xfs_buf_map *map,
+		int nmaps, xfs_buf_flags_t flags, struct xfs_buf **bpp,
+		const struct xfs_buf_ops *ops);
+void xfs_buf_readahead_map(struct xfs_buftarg *target, struct xfs_buf_map *map,
+		int nmaps, const struct xfs_buf_ops *ops);
 
 static inline int
 xfs_buf_get(
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index b5b3a78ef31c..a2af6dec310d 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -298,12 +298,9 @@  xfs_trans_read_buf_map(
 		return 0;
 	}
 
-	bp = xfs_buf_read_map(target, map, nmaps, flags, ops);
-	if (!bp) {
-		if (!(flags & XBF_TRYLOCK))
-			return -ENOMEM;
-		return tp ? 0 : -EAGAIN;
-	}
+	error = xfs_buf_read_map(target, map, nmaps, flags, &bp, ops);
+	if (error)
+		return error;
 
 	/*
 	 * If we've had a read error, then the contents of the buffer are