xfs: use unhashed buffers for size checks

When we are checking we can access the last block of each device, we
do not need to use cached buffers as they will be tossed away
immediately. Use uncached buffers for size checks so that all IO
prior to full in-memory structure initialisation does not use the
buffer cache.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Alex Elder <aelder@sgi.com>

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 43b1d56993350ba3af58c53757be99dfa936c017..6a1edb1348f6550b983c01a55d46c0ea34d01df8 100644 (file)
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -144,12 +144,11 @@ xfs_growfs_data_private(
        if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
                return error;
        dpct = pct - mp->m_sb.sb_imax_pct;
-       error = xfs_read_buf(mp, mp->m_ddev_targp,
-                       XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
-                       XFS_FSS_TO_BB(mp, 1), 0, &bp);
-       if (error)
-               return error;
-       ASSERT(bp);
+       bp = xfs_buf_read_uncached(mp, mp->m_ddev_targp,
+                               XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
+                               BBTOB(XFS_FSS_TO_BB(mp, 1)), 0);
+       if (!bp)
+               return EIO;
        xfs_buf_relse(bp);
 
        new = nb;       /* use new as a temporary here */

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index fbca293326e5e14b131055704f57fd804200efb8..912101d280bf910f5b868958377ab6588efaa2de 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -980,42 +980,35 @@ xfs_check_sizes(xfs_mount_t *mp)
 {
        xfs_buf_t       *bp;
        xfs_daddr_t     d;
-       int             error;
 
        d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
        if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
-               cmn_err(CE_WARN, "XFS: size check 1 failed");
+               cmn_err(CE_WARN, "XFS: filesystem size mismatch detected");
                return XFS_ERROR(EFBIG);
        }
-       error = xfs_read_buf(mp, mp->m_ddev_targp,
-                            d - XFS_FSS_TO_BB(mp, 1),
-                            XFS_FSS_TO_BB(mp, 1), 0, &bp);
-       if (!error) {
-               xfs_buf_relse(bp);
-       } else {
-               cmn_err(CE_WARN, "XFS: size check 2 failed");
-               if (error == ENOSPC)
-                       error = XFS_ERROR(EFBIG);
-               return error;
+       bp = xfs_buf_read_uncached(mp, mp->m_ddev_targp,
+                                       d - XFS_FSS_TO_BB(mp, 1),
+                                       BBTOB(XFS_FSS_TO_BB(mp, 1)), 0);
+       if (!bp) {
+               cmn_err(CE_WARN, "XFS: last sector read failed");
+               return EIO;
        }
+       xfs_buf_relse(bp);
 
        if (mp->m_logdev_targp != mp->m_ddev_targp) {
                d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
                if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
-                       cmn_err(CE_WARN, "XFS: size check 3 failed");
+                       cmn_err(CE_WARN, "XFS: log size mismatch detected");
                        return XFS_ERROR(EFBIG);
                }
-               error = xfs_read_buf(mp, mp->m_logdev_targp,
-                                    d - XFS_FSB_TO_BB(mp, 1),
-                                    XFS_FSB_TO_BB(mp, 1), 0, &bp);
-               if (!error) {
-                       xfs_buf_relse(bp);
-               } else {
-                       cmn_err(CE_WARN, "XFS: size check 3 failed");
-                       if (error == ENOSPC)
-                               error = XFS_ERROR(EFBIG);
-                       return error;
+               bp = xfs_buf_read_uncached(mp, mp->m_logdev_targp,
+                                       d - XFS_FSB_TO_BB(mp, 1),
+                                       XFS_FSB_TO_B(mp, 1), 0);
+               if (!bp) {
+                       cmn_err(CE_WARN, "XFS: log device read failed");
+                       return EIO;
                }
+               xfs_buf_relse(bp);
        }
        return 0;
 }

diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 891260fea11e3bc442f2de17349f16d532fad6a9..12a19138531048555651e28330ade938a1b2b36f 100644 (file)
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -39,6 +39,7 @@
 #include "xfs_trans_space.h"
 #include "xfs_utils.h"
 #include "xfs_trace.h"
+#include "xfs_buf.h"
 
 
 /*
@@ -1883,13 +1884,13 @@ xfs_growfs_rt(
        /*
         * Read in the last block of the device, make sure it exists.
         */
-       error = xfs_read_buf(mp, mp->m_rtdev_targp,
-                       XFS_FSB_TO_BB(mp, nrblocks - 1),
-                       XFS_FSB_TO_BB(mp, 1), 0, &bp);
-       if (error)
-               return error;
-       ASSERT(bp);
+       bp = xfs_buf_read_uncached(mp, mp->m_rtdev_targp,
+                               XFS_FSB_TO_BB(mp, nrblocks - 1),
+                               XFS_FSB_TO_B(mp, 1), 0);
+       if (!bp)
+               return EIO;
        xfs_buf_relse(bp);
+
        /*
         * Calculate new parameters.  These are the final values to be reached.
         */
@@ -2215,7 +2216,6 @@ xfs_rtmount_init(
 {
        xfs_buf_t       *bp;    /* buffer for last block of subvolume */
        xfs_daddr_t     d;      /* address of last block of subvolume */
-       int             error;  /* error return value */
        xfs_sb_t        *sbp;   /* filesystem superblock copy in mount */
 
        sbp = &mp->m_sb;
@@ -2242,15 +2242,12 @@ xfs_rtmount_init(
                        (unsigned long long) mp->m_sb.sb_rblocks);
                return XFS_ERROR(EFBIG);
        }
-       error = xfs_read_buf(mp, mp->m_rtdev_targp,
-                               d - XFS_FSB_TO_BB(mp, 1),
-                               XFS_FSB_TO_BB(mp, 1), 0, &bp);
-       if (error) {
-               cmn_err(CE_WARN,
-       "XFS: realtime mount -- xfs_read_buf failed, returned %d", error);
-               if (error == ENOSPC)
-                       return XFS_ERROR(EFBIG);
-               return error;
+       bp = xfs_buf_read_uncached(mp, mp->m_rtdev_targp,
+                                       d - XFS_FSB_TO_BB(mp, 1),
+                                       XFS_FSB_TO_B(mp, 1), 0);
+       if (!bp) {
+               cmn_err(CE_WARN, "XFS: realtime device size check failed");
+               return EIO;
        }
        xfs_buf_relse(bp);
        return 0;