xfs: kill XBF_DONTBLOCK

Just about all callers of xfs_buf_read() and xfs_buf_get() use XBF_DONTBLOCK.
This is used to make memory allocation use GFP_NOFS rather than GFP_KERNEL to
avoid recursion through memory reclaim back into the filesystem.

All the blocking get calls in growfs occur inside a transaction, even though
they are no part of the transaction, so all allocation will be GFP_NOFS due to
the task flag PF_TRANS being set. The blocking read calls occur during log
recovery, so they will probably be unaffected by converting to GFP_NOFS
allocations.

Hence make XBF_DONTBLOCK behaviour always occur for buffers and kill the flag.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

1 files changed, 4 insertions, 21 deletions

diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 5e4cf617e56c..ccc6da1de98d 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -148,8 +148,7 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
          * 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
@@ -174,15 +173,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;
         }
@@ -283,7 +274,7 @@ xfs_trans_read_buf(
          * 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);
@@ -367,15 +358,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) ?