Commit 4ed8e27b authored by Darrick J. Wong's avatar Darrick J. Wong

xfs: make xfs_buf_read_map return an error code

Convert xfs_buf_read_map() to return numeric error codes like most
everywhere else in xfs.  This involves moving the open-coded logic that
reports metadata IO read / corruption errors and stales the buffer into
xfs_buf_read_map so that the logic is all in one place.
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDave Chinner <dchinner@redhat.com>
parent 3848b5f6
...@@ -2956,14 +2956,17 @@ xfs_read_agf( ...@@ -2956,14 +2956,17 @@ xfs_read_agf(
trace_xfs_read_agf(mp, agno); trace_xfs_read_agf(mp, agno);
ASSERT(agno != NULLAGNUMBER); ASSERT(agno != NULLAGNUMBER);
error = xfs_trans_read_buf( error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
mp, tp, mp->m_ddev_targp,
XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)), XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
XFS_FSS_TO_BB(mp, 1), flags, bpp, &xfs_agf_buf_ops); XFS_FSS_TO_BB(mp, 1), flags, bpp, &xfs_agf_buf_ops);
/*
* Callers of xfs_read_agf() currently interpret a NULL bpp as EAGAIN
* and need to be converted to check for EAGAIN specifically.
*/
if (error == -EAGAIN)
return 0;
if (error) if (error)
return error; return error;
if (!*bpp)
return 0;
ASSERT(!(*bpp)->b_error); ASSERT(!(*bpp)->b_error);
xfs_buf_set_ref(*bpp, XFS_AGF_REF); xfs_buf_set_ref(*bpp, XFS_AGF_REF);
......
...@@ -422,16 +422,6 @@ xfs_attr_rmtval_get( ...@@ -422,16 +422,6 @@ xfs_attr_rmtval_get(
&xfs_attr3_rmt_buf_ops); &xfs_attr3_rmt_buf_ops);
if (!bp) if (!bp)
return -ENOMEM; return -ENOMEM;
error = bp->b_error;
if (error) {
xfs_buf_ioerror_alert(bp, __func__);
xfs_buf_relse(bp);
/* bad CRC means corrupted metadata */
if (error == -EFSBADCRC)
error = -EFSCORRUPTED;
return error;
}
error = xfs_attr_rmtval_copyout(mp, bp, args->dp->i_ino, error = xfs_attr_rmtval_copyout(mp, bp, args->dp->i_ino,
&offset, &valuelen, &offset, &valuelen,
......
...@@ -796,47 +796,76 @@ xfs_buf_reverify( ...@@ -796,47 +796,76 @@ xfs_buf_reverify(
return bp->b_error; return bp->b_error;
} }
xfs_buf_t * int
xfs_buf_read_map( xfs_buf_read_map(
struct xfs_buftarg *target, struct xfs_buftarg *target,
struct xfs_buf_map *map, struct xfs_buf_map *map,
int nmaps, int nmaps,
xfs_buf_flags_t flags, xfs_buf_flags_t flags,
struct xfs_buf **bpp,
const struct xfs_buf_ops *ops) const struct xfs_buf_ops *ops)
{ {
struct xfs_buf *bp; struct xfs_buf *bp;
int error; int error;
flags |= XBF_READ; flags |= XBF_READ;
*bpp = NULL;
error = xfs_buf_get_map(target, map, nmaps, flags, &bp); error = xfs_buf_get_map(target, map, nmaps, flags, &bp);
if (error) if (error)
return NULL; return error;
trace_xfs_buf_read(bp, flags, _RET_IP_); trace_xfs_buf_read(bp, flags, _RET_IP_);
if (!(bp->b_flags & XBF_DONE)) { if (!(bp->b_flags & XBF_DONE)) {
/* Initiate the buffer read and wait. */
XFS_STATS_INC(target->bt_mount, xb_get_read); XFS_STATS_INC(target->bt_mount, xb_get_read);
bp->b_ops = ops; bp->b_ops = ops;
_xfs_buf_read(bp, flags); error = _xfs_buf_read(bp, flags);
return bp;
/* Readahead iodone already dropped the buffer, so exit. */
if (flags & XBF_ASYNC)
return 0;
} else {
/* Buffer already read; all we need to do is check it. */
error = xfs_buf_reverify(bp, ops);
/* Readahead already finished; drop the buffer and exit. */
if (flags & XBF_ASYNC) {
xfs_buf_relse(bp);
return 0;
}
/* We do not want read in the flags */
bp->b_flags &= ~XBF_READ;
ASSERT(bp->b_ops != NULL || ops == NULL);
} }
xfs_buf_reverify(bp, ops); /*
* If we've had a read error, then the contents of the buffer are
* invalid and should not be used. To ensure that a followup read tries
* to pull the buffer from disk again, we clear the XBF_DONE flag and
* mark the buffer stale. This ensures that anyone who has a current
* reference to the buffer will interpret it's contents correctly and
* future cache lookups will also treat it as an empty, uninitialised
* buffer.
*/
if (error) {
if (!XFS_FORCED_SHUTDOWN(target->bt_mount))
xfs_buf_ioerror_alert(bp, __func__);
if (flags & XBF_ASYNC) { bp->b_flags &= ~XBF_DONE;
/* xfs_buf_stale(bp);
* Read ahead call which is already satisfied,
* drop the buffer
*/
xfs_buf_relse(bp); xfs_buf_relse(bp);
return NULL;
/* bad CRC means corrupted metadata */
if (error == -EFSBADCRC)
error = -EFSCORRUPTED;
return error;
} }
/* We do not want read in the flags */ *bpp = bp;
bp->b_flags &= ~XBF_READ; return 0;
ASSERT(bp->b_ops != NULL || ops == NULL);
return bp;
} }
/* /*
...@@ -850,11 +879,13 @@ xfs_buf_readahead_map( ...@@ -850,11 +879,13 @@ xfs_buf_readahead_map(
int nmaps, int nmaps,
const struct xfs_buf_ops *ops) const struct xfs_buf_ops *ops)
{ {
struct xfs_buf *bp;
if (bdi_read_congested(target->bt_bdev->bd_bdi)) if (bdi_read_congested(target->bt_bdev->bd_bdi))
return; return;
xfs_buf_read_map(target, map, nmaps, xfs_buf_read_map(target, map, nmaps,
XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops); XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD, &bp, ops);
} }
/* /*
......
...@@ -194,10 +194,9 @@ struct xfs_buf *xfs_buf_incore(struct xfs_buftarg *target, ...@@ -194,10 +194,9 @@ struct xfs_buf *xfs_buf_incore(struct xfs_buftarg *target,
int xfs_buf_get_map(struct xfs_buftarg *target, struct xfs_buf_map *map, int xfs_buf_get_map(struct xfs_buftarg *target, struct xfs_buf_map *map,
int nmaps, xfs_buf_flags_t flags, struct xfs_buf **bpp); int nmaps, xfs_buf_flags_t flags, struct xfs_buf **bpp);
struct xfs_buf *xfs_buf_read_map(struct xfs_buftarg *target, int xfs_buf_read_map(struct xfs_buftarg *target, struct xfs_buf_map *map,
struct xfs_buf_map *map, int nmaps, int nmaps, xfs_buf_flags_t flags, struct xfs_buf **bpp,
xfs_buf_flags_t flags, const struct xfs_buf_ops *ops);
const struct xfs_buf_ops *ops);
void xfs_buf_readahead_map(struct xfs_buftarg *target, void xfs_buf_readahead_map(struct xfs_buftarg *target,
struct xfs_buf_map *map, int nmaps, struct xfs_buf_map *map, int nmaps,
const struct xfs_buf_ops *ops); const struct xfs_buf_ops *ops);
...@@ -226,8 +225,14 @@ xfs_buf_read( ...@@ -226,8 +225,14 @@ xfs_buf_read(
xfs_buf_flags_t flags, xfs_buf_flags_t flags,
const struct xfs_buf_ops *ops) const struct xfs_buf_ops *ops)
{ {
struct xfs_buf *bp;
int error;
DEFINE_SINGLE_BUF_MAP(map, blkno, numblks); DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
return xfs_buf_read_map(target, &map, 1, flags, ops);
error = xfs_buf_read_map(target, &map, 1, flags, &bp, ops);
if (error)
return NULL;
return bp;
} }
static inline void static inline void
......
...@@ -2749,11 +2749,6 @@ xlog_recover_buffer_pass2( ...@@ -2749,11 +2749,6 @@ xlog_recover_buffer_pass2(
buf_flags, NULL); buf_flags, NULL);
if (!bp) if (!bp)
return -ENOMEM; return -ENOMEM;
error = bp->b_error;
if (error) {
xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
goto out_release;
}
/* /*
* Recover the buffer only if we get an LSN from it and it's less than * Recover the buffer only if we get an LSN from it and it's less than
...@@ -2956,11 +2951,6 @@ xlog_recover_inode_pass2( ...@@ -2956,11 +2951,6 @@ xlog_recover_inode_pass2(
error = -ENOMEM; error = -ENOMEM;
goto error; goto error;
} }
error = bp->b_error;
if (error) {
xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
goto out_release;
}
ASSERT(in_f->ilf_fields & XFS_ILOG_CORE); ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
dip = xfs_buf_offset(bp, in_f->ilf_boffset); dip = xfs_buf_offset(bp, in_f->ilf_boffset);
......
...@@ -57,16 +57,6 @@ xfs_readlink_bmap_ilocked( ...@@ -57,16 +57,6 @@ xfs_readlink_bmap_ilocked(
&xfs_symlink_buf_ops); &xfs_symlink_buf_ops);
if (!bp) if (!bp)
return -ENOMEM; return -ENOMEM;
error = bp->b_error;
if (error) {
xfs_buf_ioerror_alert(bp, __func__);
xfs_buf_relse(bp);
/* bad CRC means corrupted metadata */
if (error == -EFSBADCRC)
error = -EFSCORRUPTED;
goto out;
}
byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt); byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
if (pathlen < byte_cnt) if (pathlen < byte_cnt)
byte_cnt = pathlen; byte_cnt = pathlen;
......
...@@ -302,36 +302,16 @@ xfs_trans_read_buf_map( ...@@ -302,36 +302,16 @@ xfs_trans_read_buf_map(
return 0; return 0;
} }
bp = xfs_buf_read_map(target, map, nmaps, flags, ops); error = xfs_buf_read_map(target, map, nmaps, flags, &bp, ops);
if (!bp) { switch (error) {
if (!(flags & XBF_TRYLOCK)) case 0:
return -ENOMEM; break;
return tp ? 0 : -EAGAIN; default:
}
/*
* If we've had a read error, then the contents of the buffer are
* invalid and should not be used. To ensure that a followup read tries
* to pull the buffer from disk again, we clear the XBF_DONE flag and
* mark the buffer stale. This ensures that anyone who has a current
* reference to the buffer will interpret it's contents correctly and
* future cache lookups will also treat it as an empty, uninitialised
* buffer.
*/
if (bp->b_error) {
error = bp->b_error;
if (!XFS_FORCED_SHUTDOWN(mp))
xfs_buf_ioerror_alert(bp, __func__);
bp->b_flags &= ~XBF_DONE;
xfs_buf_stale(bp);
if (tp && (tp->t_flags & XFS_TRANS_DIRTY)) if (tp && (tp->t_flags & XFS_TRANS_DIRTY))
xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR); xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
xfs_buf_relse(bp); /* fall through */
case -ENOMEM:
/* bad CRC means corrupted metadata */ case -EAGAIN:
if (error == -EFSBADCRC)
error = -EFSCORRUPTED;
return error; return error;
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment