Merge tag 'xfs-5.15-merge-6' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux

[linux-2.6-microblaze.git] / fs / xfs / xfs_buf.c

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 3ab7356..5fa6cd9 100644 (file)
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -251,7 +251,7 @@ _xfs_buf_alloc(
                return error;
        }
 
-       bp->b_bn = map[0].bm_bn;
+       bp->b_rhash_key = map[0].bm_bn;
        bp->b_length = 0;
        for (i = 0; i < nmaps; i++) {
                bp->b_maps[i].bm_bn = map[i].bm_bn;
@@ -315,7 +315,6 @@ xfs_buf_alloc_kmem(
        struct xfs_buf  *bp,
        xfs_buf_flags_t flags)
 {
-       int             align_mask = xfs_buftarg_dma_alignment(bp->b_target);
        xfs_km_flags_t  kmflag_mask = KM_NOFS;
        size_t          size = BBTOB(bp->b_length);
 
@@ -323,7 +322,7 @@ xfs_buf_alloc_kmem(
        if (!(flags & XBF_READ))
                kmflag_mask |= KM_ZERO;
 
-       bp->b_addr = kmem_alloc_io(size, align_mask, kmflag_mask);
+       bp->b_addr = kmem_alloc(size, kmflag_mask);
        if (!bp->b_addr)
                return -ENOMEM;
 
@@ -460,7 +459,7 @@ _xfs_buf_obj_cmp(
         */
        BUILD_BUG_ON(offsetof(struct xfs_buf_map, bm_bn) != 0);
 
-       if (bp->b_bn != map->bm_bn)
+       if (bp->b_rhash_key != map->bm_bn)
                return 1;
 
        if (unlikely(bp->b_length != map->bm_len)) {
@@ -482,7 +481,7 @@ static const struct rhashtable_params xfs_buf_hash_params = {
        .min_size               = 32,   /* empty AGs have minimal footprint */
        .nelem_hint             = 16,
        .key_len                = sizeof(xfs_daddr_t),
-       .key_offset             = offsetof(struct xfs_buf, b_bn),
+       .key_offset             = offsetof(struct xfs_buf, b_rhash_key),
        .head_offset            = offsetof(struct xfs_buf, b_rhash_head),
        .automatic_shrinking    = true,
        .obj_cmpfn              = _xfs_buf_obj_cmp,
@@ -814,7 +813,7 @@ xfs_buf_read_map(
         * buffer.
         */
        if (error) {
-               if (!XFS_FORCED_SHUTDOWN(target->bt_mount))
+               if (!xfs_is_shutdown(target->bt_mount))
                        xfs_buf_ioerror_alert(bp, fa);
 
                bp->b_flags &= ~XBF_DONE;
@@ -854,7 +853,9 @@ xfs_buf_readahead_map(
 
 /*
  * Read an uncached buffer from disk. Allocates and returns a locked
- * buffer containing the disk contents or nothing.
+ * buffer containing the disk contents or nothing. Uncached buffers always have
+ * a cache index of XFS_BUF_DADDR_NULL so we can easily determine if the buffer
+ * is cached or uncached during fault diagnosis.
  */
 int
 xfs_buf_read_uncached(
@@ -876,7 +877,7 @@ xfs_buf_read_uncached(
 
        /* set up the buffer for a read IO */
        ASSERT(bp->b_map_count == 1);
-       bp->b_bn = XFS_BUF_DADDR_NULL;  /* always null for uncached buffers */
+       bp->b_rhash_key = XFS_BUF_DADDR_NULL;
        bp->b_maps[0].bm_bn = daddr;
        bp->b_flags |= XBF_READ;
        bp->b_ops = ops;
@@ -1145,7 +1146,7 @@ xfs_buf_ioerror_permanent(
                return true;
 
        /* At unmount we may treat errors differently */
-       if ((mp->m_flags & XFS_MOUNT_UNMOUNTING) && mp->m_fail_unmount)
+       if (xfs_is_unmounting(mp) && mp->m_fail_unmount)
                return true;
 
        return false;
@@ -1179,7 +1180,7 @@ xfs_buf_ioend_handle_error(
         * If we've already decided to shutdown the filesystem because of I/O
         * errors, there's no point in giving this a retry.
         */
-       if (XFS_FORCED_SHUTDOWN(mp))
+       if (xfs_is_shutdown(mp))
                goto out_stale;
 
        xfs_buf_ioerror_alert_ratelimited(bp);
@@ -1336,7 +1337,7 @@ xfs_buf_ioerror_alert(
 {
        xfs_buf_alert_ratelimited(bp, "XFS: metadata IO error",
                "metadata I/O error in \"%pS\" at daddr 0x%llx len %d error %d",
-                                 func, (uint64_t)XFS_BUF_ADDR(bp),
+                                 func, (uint64_t)xfs_buf_daddr(bp),
                                  bp->b_length, -bp->b_error);
 }
 
@@ -1514,17 +1515,18 @@ _xfs_buf_ioapply(
                                                   SHUTDOWN_CORRUPT_INCORE);
                                return;
                        }
-               } else if (bp->b_bn != XFS_BUF_DADDR_NULL) {
+               } else if (bp->b_rhash_key != XFS_BUF_DADDR_NULL) {
                        struct xfs_mount *mp = bp->b_mount;
 
                        /*
                         * non-crc filesystems don't attach verifiers during
                         * log recovery, so don't warn for such filesystems.
                         */
-                       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+                       if (xfs_has_crc(mp)) {
                                xfs_warn(mp,
                                        "%s: no buf ops on daddr 0x%llx len %d",
-                                       __func__, bp->b_bn, bp->b_length);
+                                       __func__, xfs_buf_daddr(bp),
+                                       bp->b_length);
                                xfs_hex_dump(bp->b_addr,
                                                XFS_CORRUPTION_DUMP_LEN);
                                dump_stack();
@@ -1592,7 +1594,7 @@ __xfs_buf_submit(
        ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
 
        /* on shutdown we stale and complete the buffer immediately */
-       if (XFS_FORCED_SHUTDOWN(bp->b_mount)) {
+       if (xfs_is_shutdown(bp->b_mount)) {
                xfs_buf_ioend_fail(bp);
                return -EIO;
        }
@@ -1794,7 +1796,7 @@ xfs_buftarg_drain(
                                xfs_buf_alert_ratelimited(bp,
                                        "XFS: Corruption Alert",
 "Corruption Alert: Buffer at daddr 0x%llx had permanent write failures!",
-                                       (long long)bp->b_bn);
+                                       (long long)xfs_buf_daddr(bp));
                        }
                        xfs_buf_rele(bp);
                }
@@ -1809,7 +1811,7 @@ xfs_buftarg_drain(
         * down the fs.
         */
        if (write_fail) {
-               ASSERT(XFS_FORCED_SHUTDOWN(btp->bt_mount));
+               ASSERT(xfs_is_shutdown(btp->bt_mount));
                xfs_alert(btp->bt_mount,
              "Please run xfs_repair to determine the extent of the problem.");
        }
@@ -2302,7 +2304,7 @@ xfs_verify_magic(
        struct xfs_mount        *mp = bp->b_mount;
        int                     idx;
 
-       idx = xfs_sb_version_hascrc(&mp->m_sb);
+       idx = xfs_has_crc(mp);
        if (WARN_ON(!bp->b_ops || !bp->b_ops->magic[idx]))
                return false;
        return dmagic == bp->b_ops->magic[idx];
@@ -2320,7 +2322,7 @@ xfs_verify_magic16(
        struct xfs_mount        *mp = bp->b_mount;
        int                     idx;
 
-       idx = xfs_sb_version_hascrc(&mp->m_sb);
+       idx = xfs_has_crc(mp);
        if (WARN_ON(!bp->b_ops || !bp->b_ops->magic16[idx]))
                return false;
        return dmagic == bp->b_ops->magic16[idx];