xfs: xfs_bioerror can die.

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>

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 0eee0f1f099e981330e63220de375ac32d9b4bd9..409a8a06642a9cafe03b253e3f8be76ddeac9319 100644 (file)
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1074,39 +1074,6 @@ xfs_buf_ioerror_alert(
                (__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
  * here ourselves, and avoiding the xfs_buf_ioend call.
@@ -1155,19 +1122,19 @@ xfs_bwrite(
        ASSERT(xfs_buf_islocked(bp));
 
        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)) {
                trace_xfs_bdstrat_shut(bp, _RET_IP_);
 
-               /*
-                * Metadata write that didn't get logged but written anyway.
-                * These aren't associated with a transaction, and can be
-                * ignored.
-                */
-               if (!bp->b_iodone)
-                       return xfs_bioerror_relse(bp);
-               return xfs_bioerror(bp);
+               xfs_buf_ioerror(bp, -EIO);
+               xfs_buf_stale(bp);
+
+               /* sync IO, xfs_buf_ioend is going to remove a ref here */
+               xfs_buf_hold(bp);
+               xfs_buf_ioend(bp);
+               return -EIO;
        }
 
        xfs_buf_iorequest(bp);
@@ -1857,10 +1824,9 @@ __xfs_buf_delwri_submit(
                if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
                        trace_xfs_bdstrat_shut(bp, _RET_IP_);
 
-                       if (!bp->b_iodone)
-                               xfs_bioerror_relse(bp);
-                       else
-                               xfs_bioerror(bp);
+                       xfs_buf_ioerror(bp, -EIO);
+                       xfs_buf_stale(bp);
+                       xfs_buf_ioend(bp);
                        continue;
                }
                xfs_buf_iorequest(bp);