Kernel/linux-next
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git synced 2025-01-15 11:57:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

xfs: xfs_bioerror can die.

Browse Source 
Internal buffer write error handling is a mess due to the unnatural
split between xfs_bioerror and xfs_bioerror_relse().

xfs_bwrite() only does sync IO and determines the handler to
call based on b_iodone, so for this caller the only difference
between xfs_bioerror() and xfs_bioerror_release() is the XBF_DONE
flag. We don't care what the XBF_DONE flag state is because we stale
the buffer in both paths - the next buffer lookup will clear
XBF_DONE because XBF_STALE is set. Hence we can use common
error handling for xfs_bwrite().

__xfs_buf_delwri_submit() is a similar - it's only ever called
on writes - all sync or async - and again there's no reason to
handle them any differently at all.

Clean up the nasty error handling and remove xfs_bioerror().

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <david@fromorbit.com>
This commit is contained in:
Dave Chinner 2014-10-02 09:04:56 +10:00 committed by Dave Chinner
parent 8dac392198
commit 2718775469
1 changed files with 12 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
fs/xfs/xfs_buf.c
View File

@ -1074,39 +1074,6 @@ xfs_buf_ioerror_alert(
(__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length); (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
} }
/*
* Called when we want to stop a buffer from getting written or read.
* We attach the EIO error, muck with its flags, and call xfs_buf_ioend
* so that the proper iodone callbacks get called.
*/
STATIC int
xfs_bioerror(
xfs_buf_t *bp)
{
#ifdef XFSERRORDEBUG
ASSERT(XFS_BUF_ISREAD(bp) || bp->b_iodone);
#endif
/*
* No need to wait until the buffer is unpinned, we aren't flushing it.
*/
xfs_buf_ioerror(bp, -EIO);
/*
* We're calling xfs_buf_ioend, so delete XBF_DONE flag. For
* sync IO, xfs_buf_ioend is going to remove a ref here.
*/
if (!(bp->b_flags & XBF_ASYNC))
xfs_buf_hold(bp);
XFS_BUF_UNREAD(bp);
XFS_BUF_UNDONE(bp);
xfs_buf_stale(bp);
xfs_buf_ioend(bp);
return -EIO;
}
/* /*
* Same as xfs_bioerror, except that we are releasing the buffer * Same as xfs_bioerror, except that we are releasing the buffer
* here ourselves, and avoiding the xfs_buf_ioend call. * here ourselves, and avoiding the xfs_buf_ioend call.
@ -1155,19 +1122,19 @@ xfs_bwrite(
ASSERT(xfs_buf_islocked(bp)); ASSERT(xfs_buf_islocked(bp));
bp->b_flags |= XBF_WRITE; bp->b_flags |= XBF_WRITE;
bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q | XBF_WRITE_FAIL); bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q |
XBF_WRITE_FAIL | XBF_DONE);
if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) { if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
trace_xfs_bdstrat_shut(bp, _RET_IP_); trace_xfs_bdstrat_shut(bp, _RET_IP_);
/* xfs_buf_ioerror(bp, -EIO);
* Metadata write that didn't get logged but written anyway. xfs_buf_stale(bp);
* These aren't associated with a transaction, and can be
* ignored. /* sync IO, xfs_buf_ioend is going to remove a ref here */
*/ xfs_buf_hold(bp);
if (!bp->b_iodone) xfs_buf_ioend(bp);
return xfs_bioerror_relse(bp); return -EIO;
return xfs_bioerror(bp);
} }
xfs_buf_iorequest(bp); xfs_buf_iorequest(bp);
@ -1857,10 +1824,9 @@ __xfs_buf_delwri_submit(
if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) { if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
trace_xfs_bdstrat_shut(bp, _RET_IP_); trace_xfs_bdstrat_shut(bp, _RET_IP_);
if (!bp->b_iodone) xfs_buf_ioerror(bp, -EIO);
xfs_bioerror_relse(bp); xfs_buf_stale(bp);
else xfs_buf_ioend(bp);
xfs_bioerror(bp);
continue; continue;
} }
xfs_buf_iorequest(bp); xfs_buf_iorequest(bp);