1 files changed, 36 insertions, 90 deletions

diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 1302d1d95a58..21c5a5e3700d 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -18,9 +18,7 @@
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_bit.h"
 #include "xfs_log.h"
-#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -33,7 +31,6 @@
 #include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
 #include "xfs_error.h"
-#include "xfs_rw.h"
 #include "xfs_trace.h"
 
 /*
@@ -56,7 +53,7 @@ xfs_trans_buf_item_match(
                 if (blip->bli_item.li_type == XFS_LI_BUF &&
                     blip->bli_buf->b_target == target &&
                     XFS_BUF_ADDR(blip->bli_buf) == blkno &&
-                    XFS_BUF_COUNT(blip->bli_buf) == len)
+                    BBTOB(blip->bli_buf->b_length) == len)
                         return blip->bli_buf;
         }
 
@@ -141,15 +138,11 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
         xfs_buf_t               *bp;
         xfs_buf_log_item_t      *bip;
 
-        if (flags == 0)
-                flags = XBF_LOCK | XBF_MAPPED;
-
         /*
          * Default to a normal get_buf() call if the tp is NULL.
          */
         if (tp == NULL)
-                return xfs_buf_get(target_dev, blkno, len,
-                                   flags | XBF_DONT_BLOCK);
+                return xfs_buf_get(target_dev, blkno, len, flags);
 
         /*
          * If we find the buffer in the cache with this transaction
@@ -165,14 +158,6 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
                         XFS_BUF_DONE(bp);
                 }
 
-                /*
-                 * If the buffer is stale then it was binval'ed
-                 * since last read.  This doesn't matter since the
-                 * caller isn't allowed to use the data anyway.
-                 */
-                else if (XFS_BUF_ISSTALE(bp))
-                        ASSERT(!XFS_BUF_ISDELAYWRITE(bp));
-
                 ASSERT(bp->b_transp == tp);
                 bip = bp->b_fspriv;
                 ASSERT(bip != NULL);
@@ -182,15 +167,7 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
                 return (bp);
         }
 
-        /*
-         * We always specify the XBF_DONT_BLOCK flag within a transaction
-         * so that get_buf does not try to push out a delayed write buffer
-         * which might cause another transaction to take place (if the
-         * buffer was delayed alloc).  Such recursive transactions can
-         * easily deadlock with our current transaction as well as cause
-         * us to run out of stack space.
-         */
-        bp = xfs_buf_get(target_dev, blkno, len, flags | XBF_DONT_BLOCK);
+        bp = xfs_buf_get(target_dev, blkno, len, flags);
         if (bp == NULL) {
                 return NULL;
         }
@@ -282,14 +259,13 @@ xfs_trans_read_buf(
         xfs_buf_log_item_t      *bip;
         int                     error;
 
-        if (flags == 0)
-                flags = XBF_LOCK | XBF_MAPPED;
+        *bpp = NULL;
 
         /*
          * Default to a normal get_buf() call if the tp is NULL.
          */
         if (tp == NULL) {
-                bp = xfs_buf_read(target, blkno, len, flags | XBF_DONT_BLOCK);
+                bp = xfs_buf_read(target, blkno, len, flags);
                 if (!bp)
                         return (flags & XBF_TRYLOCK) ?
                                         EAGAIN : XFS_ERROR(ENOMEM);
@@ -297,6 +273,8 @@ xfs_trans_read_buf(
                 if (bp->b_error) {
                         error = bp->b_error;
                         xfs_buf_ioerror_alert(bp, __func__);
+                        XFS_BUF_UNDONE(bp);
+                        xfs_buf_stale(bp);
                         xfs_buf_relse(bp);
                         return error;
                 }
@@ -371,15 +349,7 @@ xfs_trans_read_buf(
                 return 0;
         }
 
-        /*
-         * We always specify the XBF_DONT_BLOCK flag within a transaction
-         * so that get_buf does not try to push out a delayed write buffer
-         * which might cause another transaction to take place (if the
-         * buffer was delayed alloc).  Such recursive transactions can
-         * easily deadlock with our current transaction as well as cause
-         * us to run out of stack space.
-         */
-        bp = xfs_buf_read(target, blkno, len, flags | XBF_DONT_BLOCK);
+        bp = xfs_buf_read(target, blkno, len, flags);
         if (bp == NULL) {
                 *bpp = NULL;
                 return (flags & XBF_TRYLOCK) ?
@@ -418,19 +388,6 @@ xfs_trans_read_buf(
         return 0;
 
 shutdown_abort:
-        /*
-         * the theory here is that buffer is good but we're
-         * bailing out because the filesystem is being forcibly
-         * shut down.  So we should leave the b_flags alone since
-         * the buffer's not staled and just get out.
-         */
-#if defined(DEBUG)
-        if (XFS_BUF_ISSTALE(bp) && XFS_BUF_ISDELAYWRITE(bp))
-                xfs_notice(mp, "about to pop assert, bp == 0x%p", bp);
-#endif
-        ASSERT((bp->b_flags & (XBF_STALE|XBF_DELWRI)) !=
-                                     (XBF_STALE|XBF_DELWRI));
-
         trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
         xfs_buf_relse(bp);
         *bpp = NULL;
@@ -606,7 +563,7 @@ xfs_trans_log_buf(xfs_trans_t	*tp,
 
         ASSERT(bp->b_transp == tp);
         ASSERT(bip != NULL);
-        ASSERT((first <= last) && (last < XFS_BUF_COUNT(bp)));
+        ASSERT(first <= last && last < BBTOB(bp->b_length));
         ASSERT(bp->b_iodone == NULL ||
                bp->b_iodone == xfs_buf_iodone_callbacks);
 
@@ -626,8 +583,6 @@ xfs_trans_log_buf(xfs_trans_t	*tp,
         bp->b_iodone = xfs_buf_iodone_callbacks;
         bip->bli_item.li_cb = xfs_buf_iodone;
 
-        xfs_buf_delwri_queue(bp);
-
         trace_xfs_trans_log_buf(bip);
 
         /*
@@ -651,22 +606,33 @@ xfs_trans_log_buf(xfs_trans_t	*tp,
 
 
 /*
- * This called to invalidate a buffer that is being used within
- * a transaction.  Typically this is because the blocks in the
- * buffer are being freed, so we need to prevent it from being
- * written out when we're done.  Allowing it to be written again
- * might overwrite data in the free blocks if they are reallocated
- * to a file.
+ * Invalidate a buffer that is being used within a transaction.
+ *
+ * Typically this is because the blocks in the buffer are being freed, so we
+ * need to prevent it from being written out when we're done.  Allowing it
+ * to be written again might overwrite data in the free blocks if they are
+ * reallocated to a file.
+ *
+ * We prevent the buffer from being written out by marking it stale.  We can't
+ * get rid of the buf log item at this point because the buffer may still be
+ * pinned by another transaction.  If that is the case, then we'll wait until
+ * the buffer is committed to disk for the last time (we can tell by the ref
+ * count) and free it in xfs_buf_item_unpin().  Until that happens we will
+ * keep the buffer locked so that the buffer and buf log item are not reused.
+ *
+ * We also set the XFS_BLF_CANCEL flag in the buf log format structure and log
+ * the buf item.  This will be used at recovery time to determine that copies
+ * of the buffer in the log before this should not be replayed.
  *
- * We prevent the buffer from being written out by clearing the
- * B_DELWRI flag.  We can't always
- * get rid of the buf log item at this point, though, because
- * the buffer may still be pinned by another transaction.  If that
- * is the case, then we'll wait until the buffer is committed to
- * disk for the last time (we can tell by the ref count) and
- * free it in xfs_buf_item_unpin().  Until it is cleaned up we
- * will keep the buffer locked so that the buffer and buf log item
- * are not reused.
+ * We mark the item descriptor and the transaction dirty so that we'll hold
+ * the buffer until after the commit.
+ *
+ * Since we're invalidating the buffer, we also clear the state about which
+ * parts of the buffer have been logged.  We also clear the flag indicating
+ * that this is an inode buffer since the data in the buffer will no longer
+ * be valid.
+ *
+ * We set the stale bit in the buffer as well since we're getting rid of it.
  */
 void
 xfs_trans_binval(
@@ -686,7 +652,6 @@ xfs_trans_binval(
                  * If the buffer is already invalidated, then
                  * just return.
                  */
-                ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
                 ASSERT(XFS_BUF_ISSTALE(bp));
                 ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
                 ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_INODE_BUF));
@@ -696,27 +661,8 @@ xfs_trans_binval(
                 return;
         }
 
-        /*
-         * Clear the dirty bit in the buffer and set the STALE flag
-         * in the buf log item.  The STALE flag will be used in
-         * xfs_buf_item_unpin() to determine if it should clean up
-         * when the last reference to the buf item is given up.
-         * We set the XFS_BLF_CANCEL flag in the buf log format structure
-         * and log the buf item.  This will be used at recovery time
-         * to determine that copies of the buffer in the log before
-         * this should not be replayed.
-         * We mark the item descriptor and the transaction dirty so
-         * that we'll hold the buffer until after the commit.
-         *
-         * Since we're invalidating the buffer, we also clear the state
-         * about which parts of the buffer have been logged.  We also
-         * clear the flag indicating that this is an inode buffer since
-         * the data in the buffer will no longer be valid.
-         *
-         * We set the stale bit in the buffer as well since we're getting
-         * rid of it.
-         */
         xfs_buf_stale(bp);
+
         bip->bli_flags |= XFS_BLI_STALE;
         bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
         bip->bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;