eCryptfs: Fix lockdep warning in miscdev operations
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / xfs / xfs_trans_buf.c
index 1302d1d95a5850d121af792719b04d2d5672af39..21c5a5e3700d066d05b19fa2ac1a47f19e952eb1 100644 (file)
@@ -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;