xfs: add buffer types to directory and attribute buffers

Add buffer types to the buffer log items so that log recovery can
validate the buffers and calculate CRCs correctly after the buffers
are recovered.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

diff --git a/include/xfs_attr_remote.h b/include/xfs_attr_remote.h
index 9e71edfc39d6c421a7a8d8d2de9dcbf7002e9df8..28f6f10181152ae27b4abe025e5bf97e69aa641d 100644 (file)
--- a/include/xfs_attr_remote.h
+++ b/include/xfs_attr_remote.h
@@ -43,6 +43,8 @@ struct xfs_attr3_rmt_hdr {
        ((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
                        sizeof(struct xfs_attr3_rmt_hdr) : 0))
 
+extern const struct xfs_buf_ops xfs_attr3_rmt_buf_ops;
+
 int xfs_attr_rmtval_get(struct xfs_da_args *args);
 int xfs_attr_rmtval_set(struct xfs_da_args *args);
 int xfs_attr_rmtval_remove(struct xfs_da_args *args);

diff --git a/include/xfs_buf_item.h b/include/xfs_buf_item.h
index 09cab4ed1065474c7626c473ccccb3609dc22017..640adcfa4143eb0629c773b93294840b65e7361e 100644 (file)
--- a/include/xfs_buf_item.h
+++ b/include/xfs_buf_item.h
@@ -50,6 +50,14 @@ extern kmem_zone_t   *xfs_buf_item_zone;
 #define XFS_BLF_AGI_BUF                (1<<8)
 #define XFS_BLF_DINO_BUF       (1<<9)
 #define XFS_BLF_SYMLINK_BUF    (1<<10)
+#define XFS_BLF_DIR_BLOCK_BUF  (1<<11)
+#define XFS_BLF_DIR_DATA_BUF   (1<<12)
+#define XFS_BLF_DIR_FREE_BUF   (1<<13)
+#define XFS_BLF_DIR_LEAF1_BUF  (1<<14)
+#define XFS_BLF_DIR_LEAFN_BUF  (1<<15)
+#define XFS_BLF_DA_NODE_BUF    (1<<16)
+#define XFS_BLF_ATTR_LEAF_BUF  (1<<17)
+#define XFS_BLF_ATTR_RMT_BUF   (1<<18)
 
 #define XFS_BLF_TYPE_MASK      \
                (XFS_BLF_UDQUOT_BUF | \
@@ -60,7 +68,15 @@ extern kmem_zone_t   *xfs_buf_item_zone;
                 XFS_BLF_AGFL_BUF | \
                 XFS_BLF_AGI_BUF | \
                 XFS_BLF_DINO_BUF | \
-                XFS_BLF_SYMLINK_BUF)
+                XFS_BLF_SYMLINK_BUF | \
+                XFS_BLF_DIR_BLOCK_BUF | \
+                XFS_BLF_DIR_DATA_BUF | \
+                XFS_BLF_DIR_FREE_BUF | \
+                XFS_BLF_DIR_LEAF1_BUF | \
+                XFS_BLF_DIR_LEAFN_BUF | \
+                XFS_BLF_DA_NODE_BUF | \
+                XFS_BLF_ATTR_LEAF_BUF | \
+                XFS_BLF_ATTR_RMT_BUF)
 
 #define        XFS_BLF_CHUNK           128
 #define        XFS_BLF_SHIFT           7

diff --git a/include/xfs_da_btree.h b/include/xfs_da_btree.h
index 0e8182c5210b7a8c090d8d6f2218d51c36151441..6fb3371c63cf3db535ea84cd6d62c31445b8c4f2 100644 (file)
--- a/include/xfs_da_btree.h
+++ b/include/xfs_da_btree.h
@@ -301,6 +301,8 @@ int xfs_da3_node_read(struct xfs_trans *tp, struct xfs_inode *dp,
                         xfs_dablk_t bno, xfs_daddr_t mappedbno,
                         struct xfs_buf **bpp, int which_fork);
 
+extern const struct xfs_buf_ops xfs_da3_node_buf_ops;
+
 /*
  * Utility routines.
  */

diff --git a/include/xfs_trans.h b/include/xfs_trans.h
index a9bd8264e81b90feb10863635f0ad0dc6456b1f7..9e145e95ebcf3b16dfa94fdcc37ff15897564017 100644 (file)
--- a/include/xfs_trans.h
+++ b/include/xfs_trans.h
@@ -502,6 +502,8 @@ void                xfs_trans_dquot_buf(xfs_trans_t *, struct xfs_buf *, uint);
 void           xfs_trans_inode_alloc_buf(xfs_trans_t *, struct xfs_buf *);
 void           xfs_trans_buf_set_type(struct xfs_trans *, struct xfs_buf *,
                                       uint);
+void           xfs_trans_buf_copy_type(struct xfs_buf *dst_bp,
+                                       struct xfs_buf *src_bp);
 void           xfs_trans_ichgtime(struct xfs_trans *, struct xfs_inode *, int);
 void           xfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *, uint);
 void           xfs_trans_log_buf(xfs_trans_t *, struct xfs_buf *, uint, uint);

diff --git a/libxfs/xfs.h b/libxfs/xfs.h
index c69dc4a57778a60dbd9638246f02929c68cc4ea1..6bec18ec7514c4fefbfcf0dadd0158cd2a6cdda8 100644 (file)
--- a/libxfs/xfs.h
+++ b/libxfs/xfs.h
@@ -255,6 +255,7 @@ roundup_pow_of_two(uint v)
 #define        xfs_trans_agflist_delta(tp, d)
 #define        xfs_trans_agbtree_delta(tp, d)
 #define xfs_trans_buf_set_type(tp, bp, t)
+#define xfs_trans_buf_copy_type(dbp, sbp)
 
 #define xfs_buf_readahead(a,b,c,ops)           ((void) 0)      /* no readahead */
 #define xfs_buf_readahead_map(a,b,c,ops)       ((void) 0)      /* no readahead */

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index 9de224458241ecf49b0aeedfd75a65f6910568df..77247814dd99193ea76554841bcad9dca13a8300 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -236,8 +236,13 @@ xfs_attr3_leaf_read(
        xfs_daddr_t             mappedbno,
        struct xfs_buf          **bpp)
 {
-       return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
+       int                     err;
+
+       err = xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
                                XFS_ATTR_FORK, &xfs_attr3_leaf_buf_ops);
+       if (!err && tp)
+               xfs_trans_buf_set_type(tp, *bpp, XFS_BLF_ATTR_LEAF_BUF);
+       return err;
 }
 
 /*========================================================================
@@ -867,6 +872,7 @@ xfs_attr3_leaf_to_node(
                goto out;
 
        /* copy leaf to new buffer, update identifiers */
+       xfs_trans_buf_set_type(args->trans, bp2, XFS_BLF_ATTR_LEAF_BUF);
        bp2->b_ops = bp1->b_ops;
        memcpy(bp2->b_addr, bp1->b_addr, XFS_LBSIZE(mp));
        if (xfs_sb_version_hascrc(&mp->m_sb)) {
@@ -929,6 +935,7 @@ xfs_attr3_leaf_create(
        if (error)
                return error;
        bp->b_ops = &xfs_attr3_leaf_buf_ops;
+       xfs_trans_buf_set_type(args->trans, bp, XFS_BLF_ATTR_LEAF_BUF);
        leaf = bp->b_addr;
        memset(leaf, 0, XFS_LBSIZE(mp));
 

diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c
index 5db94dba783321bee1932410a2b6a2c9c8b10a83..ef443ae254d029c6dc3d7a7927b02d7753dd1968 100644 (file)
--- a/libxfs/xfs_da_btree.c
+++ b/libxfs/xfs_da_btree.c
@@ -270,7 +270,6 @@ const struct xfs_buf_ops xfs_da3_node_buf_ops = {
        .verify_write = xfs_da3_node_write_verify,
 };
 
-
 int
 xfs_da3_node_read(
        struct xfs_trans        *tp,
@@ -280,8 +279,35 @@ xfs_da3_node_read(
        struct xfs_buf          **bpp,
        int                     which_fork)
 {
-       return xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
+       int                     err;
+
+       err = xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
                                        which_fork, &xfs_da3_node_buf_ops);
+       if (!err && tp) {
+               struct xfs_da_blkinfo   *info = (*bpp)->b_addr;
+               int                     type;
+
+               switch (be16_to_cpu(info->magic)) {
+               case XFS_DA3_NODE_MAGIC:
+               case XFS_DA_NODE_MAGIC:
+                       type = XFS_BLF_DA_NODE_BUF;
+                       break;
+               case XFS_ATTR_LEAF_MAGIC:
+               case XFS_ATTR3_LEAF_MAGIC:
+                       type = XFS_BLF_ATTR_LEAF_BUF;
+                       break;
+               case XFS_DIR2_LEAFN_MAGIC:
+               case XFS_DIR3_LEAFN_MAGIC:
+                       type = XFS_BLF_DIR_LEAFN_BUF;
+                       break;
+               default:
+                       type = 0;
+                       ASSERT(0);
+                       break;
+               }
+               xfs_trans_buf_set_type(tp, *bpp, type);
+       }
+       return err;
 }
 
 /*========================================================================
@@ -312,6 +338,8 @@ xfs_da3_node_create(
        error = xfs_da_get_buf(tp, args->dp, blkno, -1, &bp, whichfork);
        if (error)
                return(error);
+       bp->b_ops = &xfs_da3_node_buf_ops;
+       xfs_trans_buf_set_type(tp, bp, XFS_BLF_DA_NODE_BUF);
        node = bp->b_addr;
 
        if (xfs_sb_version_hascrc(&mp->m_sb)) {
@@ -330,7 +358,6 @@ xfs_da3_node_create(
        xfs_trans_log_buf(tp, bp,
                XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
 
-       bp->b_ops = &xfs_da3_node_buf_ops;
        *bpp = bp;
        return(0);
 }
@@ -541,6 +568,12 @@ xfs_da3_root_split(
                btree = xfs_da3_node_tree_p(oldroot);
                size = (int)((char *)&btree[nodehdr.count] - (char *)oldroot);
                level = nodehdr.level;
+
+               /*
+                * we are about to copy oldroot to bp, so set up the type
+                * of bp while we know exactly what it will be.
+                */
+               xfs_trans_buf_set_type(tp, bp, XFS_BLF_DA_NODE_BUF);
        } else {
                struct xfs_dir3_icleaf_hdr leafhdr;
                struct xfs_dir2_leaf_entry *ents;
@@ -553,6 +586,12 @@ xfs_da3_root_split(
                       leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
                size = (int)((char *)&ents[leafhdr.count] - (char *)leaf);
                level = 0;
+
+               /*
+                * we are about to copy oldroot to bp, so set up the type
+                * of bp while we know exactly what it will be.
+                */
+               xfs_trans_buf_set_type(tp, bp, XFS_BLF_DIR_LEAFN_BUF);
        }
 
        /*
@@ -1068,6 +1107,7 @@ xfs_da3_root_join(
         */
        memcpy(root_blk->bp->b_addr, bp->b_addr, state->blocksize);
        root_blk->bp->b_ops = bp->b_ops;
+       xfs_trans_buf_copy_type(root_blk->bp, bp);
        if (oldroothdr.magic == XFS_DA3_NODE_MAGIC) {
                struct xfs_da3_blkinfo *da3 = root_blk->bp->b_addr;
                da3->blkno = cpu_to_be64(root_blk->bp->b_bn);

diff --git a/libxfs/xfs_dir2_block.c b/libxfs/xfs_dir2_block.c
index b98b7496d6d64c924d3e82b7652015dde539e54a..574e414707d22b9a8238a21c47f60994ea7cba7f 100644 (file)
--- a/libxfs/xfs_dir2_block.c
+++ b/libxfs/xfs_dir2_block.c
@@ -114,20 +114,26 @@ xfs_dir3_block_read(
        struct xfs_buf          **bpp)
 {
        struct xfs_mount        *mp = dp->i_mount;
+       int                     err;
 
-       return xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, bpp,
+       err = xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, bpp,
                                XFS_DATA_FORK, &xfs_dir3_block_buf_ops);
+       if (!err && tp)
+               xfs_trans_buf_set_type(tp, *bpp, XFS_BLF_DIR_BLOCK_BUF);
+       return err;
 }
 
 static void
 xfs_dir3_block_init(
        struct xfs_mount        *mp,
+       struct xfs_trans        *tp,
        struct xfs_buf          *bp,
        struct xfs_inode        *dp)
 {
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
        bp->b_ops = &xfs_dir3_block_buf_ops;
+       xfs_trans_buf_set_type(tp, bp, XFS_BLF_DIR_BLOCK_BUF);
 
        if (xfs_sb_version_hascrc(&mp->m_sb)) {
                memset(hdr3, 0, sizeof(*hdr3));
@@ -964,7 +970,7 @@ xfs_dir2_leaf_to_block(
        /*
         * Start converting it to block form.
         */
-       xfs_dir3_block_init(mp, dbp, dp);
+       xfs_dir3_block_init(mp, tp, dbp, dp);
 
        needlog = 1;
        needscan = 0;
@@ -1093,7 +1099,7 @@ xfs_dir2_sf_to_block(
                kmem_free(sfp);
                return error;
        }
-       xfs_dir3_block_init(mp, bp, dp);
+       xfs_dir3_block_init(mp, tp, bp, dp);
        hdr = bp->b_addr;
 
        /*

diff --git a/libxfs/xfs_dir2_data.c b/libxfs/xfs_dir2_data.c
index 69841dfd4287f4546c04478f41a8fb6f938843dd..9752ae3ff37fe5b627255768b7b530ddbf6635da 100644 (file)
--- a/libxfs/xfs_dir2_data.c
+++ b/libxfs/xfs_dir2_data.c
@@ -283,8 +283,13 @@ xfs_dir3_data_read(
        xfs_daddr_t             mapped_bno,
        struct xfs_buf          **bpp)
 {
-       return xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp,
+       int                     err;
+
+       err = xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp,
                                XFS_DATA_FORK, &xfs_dir3_data_buf_ops);
+       if (!err && tp)
+               xfs_trans_buf_set_type(tp, *bpp, XFS_BLF_DIR_DATA_BUF);
+       return err;
 }
 
 int
@@ -553,6 +558,7 @@ xfs_dir3_data_init(
        if (error)
                return error;
        bp->b_ops = &xfs_dir3_data_buf_ops;
+       xfs_trans_buf_set_type(tp, bp, XFS_BLF_DIR_DATA_BUF);
 
        /*
         * Initialize the header.

diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c
index f00b23cd8dba276e44c5dd08d58681a92b852789..3d1ec239c71109d9288422fb95d0b33066a086b8 100644 (file)
--- a/libxfs/xfs_dir2_leaf.c
+++ b/libxfs/xfs_dir2_leaf.c
@@ -279,8 +279,13 @@ xfs_dir3_leaf_read(
        xfs_daddr_t             mappedbno,
        struct xfs_buf          **bpp)
 {
-       return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
+       int                     err;
+
+       err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
                                XFS_DATA_FORK, &xfs_dir3_leaf1_buf_ops);
+       if (!err && tp)
+               xfs_trans_buf_set_type(tp, *bpp, XFS_BLF_DIR_LEAF1_BUF);
+       return err;
 }
 
 int
@@ -291,8 +296,13 @@ xfs_dir3_leafn_read(
        xfs_daddr_t             mappedbno,
        struct xfs_buf          **bpp)
 {
-       return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
+       int                     err;
+
+       err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
                                XFS_DATA_FORK, &xfs_dir3_leafn_buf_ops);
+       if (!err && tp)
+               xfs_trans_buf_set_type(tp, *bpp, XFS_BLF_DIR_LEAFN_BUF);
+       return err;
 }
 
 /*
@@ -301,6 +311,7 @@ xfs_dir3_leafn_read(
 static void
 xfs_dir3_leaf_init(
        struct xfs_mount        *mp,
+       struct xfs_trans        *tp,
        struct xfs_buf          *bp,
        xfs_ino_t               owner,
        __uint16_t              type)
@@ -335,8 +346,11 @@ xfs_dir3_leaf_init(
                ltp = xfs_dir2_leaf_tail_p(mp, leaf);
                ltp->bestcount = 0;
                bp->b_ops = &xfs_dir3_leaf1_buf_ops;
-       } else
+               xfs_trans_buf_set_type(tp, bp, XFS_BLF_DIR_LEAF1_BUF);
+       } else {
                bp->b_ops = &xfs_dir3_leafn_buf_ops;
+               xfs_trans_buf_set_type(tp, bp, XFS_BLF_DIR_LEAFN_BUF);
+       }
 }
 
 int
@@ -361,7 +375,7 @@ xfs_dir3_leaf_get_buf(
        if (error)
                return error;
 
-       xfs_dir3_leaf_init(mp, bp, dp->i_ino, magic);
+       xfs_dir3_leaf_init(mp, tp, bp, dp->i_ino, magic);
        xfs_dir3_leaf_log_header(tp, bp);
        if (magic == XFS_DIR2_LEAF1_MAGIC)
                xfs_dir3_leaf_log_tail(tp, bp);
@@ -456,6 +470,7 @@ xfs_dir2_block_to_leaf(
         * Fix up the block header, make it a data block.
         */
        dbp->b_ops = &xfs_dir3_data_buf_ops;
+       xfs_trans_buf_set_type(tp, dbp, XFS_BLF_DIR_DATA_BUF);
        if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))
                hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
        else
@@ -1776,6 +1791,7 @@ xfs_dir2_node_to_leaf(
                xfs_dir3_leaf_compact(args, &leafhdr, lbp);
 
        lbp->b_ops = &xfs_dir3_leaf1_buf_ops;
+       xfs_trans_buf_set_type(tp, lbp, XFS_BLF_DIR_LEAF1_BUF);
        leafhdr.magic = (leafhdr.magic == XFS_DIR2_LEAFN_MAGIC)
                                        ? XFS_DIR2_LEAF1_MAGIC
                                        : XFS_DIR3_LEAF1_MAGIC;

diff --git a/libxfs/xfs_dir2_node.c b/libxfs/xfs_dir2_node.c
index ee3a31046f5a49d3108534ae9b593793b5b9551b..7268eea08ce265dec145776d39016eabc10d16c7 100644 (file)
--- a/libxfs/xfs_dir2_node.c
+++ b/libxfs/xfs_dir2_node.c
@@ -130,7 +130,7 @@ xfs_dir3_free_write_verify(
        xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_FREE_CRC_OFF);
 }
 
-static const struct xfs_buf_ops xfs_dir3_free_buf_ops = {
+const struct xfs_buf_ops xfs_dir3_free_buf_ops = {
        .verify_read = xfs_dir3_free_read_verify,
        .verify_write = xfs_dir3_free_write_verify,
 };
@@ -144,8 +144,15 @@ __xfs_dir3_free_read(
        xfs_daddr_t             mappedbno,
        struct xfs_buf          **bpp)
 {
-       return xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
+       int                     err;
+
+       err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
                                XFS_DATA_FORK, &xfs_dir3_free_buf_ops);
+
+       /* try read returns without an error or *bpp if it lands in a hole */
+       if (!err && tp && *bpp)
+               xfs_trans_buf_set_type(tp, *bpp, XFS_BLF_DIR_FREE_BUF);
+       return err;
 }
 
 int
@@ -232,7 +239,8 @@ xfs_dir3_free_get_buf(
        if (error)
                return error;
 
-       bp->b_ops = &xfs_dir3_free_buf_ops;;
+       xfs_trans_buf_set_type(tp, bp, XFS_BLF_DIR_FREE_BUF);
+       bp->b_ops = &xfs_dir3_free_buf_ops;
 
        /*
         * Initialize the new block to be empty, and remember
@@ -380,6 +388,7 @@ xfs_dir2_leaf_to_node(
        else
                leaf->hdr.info.magic = cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
        lbp->b_ops = &xfs_dir3_leafn_buf_ops;
+       xfs_trans_buf_set_type(tp, lbp, XFS_BLF_DIR_LEAFN_BUF);
        xfs_dir3_leaf_log_header(tp, lbp);
        xfs_dir3_leaf_check(mp, lbp);
        return 0;
@@ -795,6 +804,7 @@ xfs_dir2_leafn_lookup_for_entry(
                                                        (char *)curbp->b_addr);
                        state->extrablk.magic = XFS_DIR2_DATA_MAGIC;
                        curbp->b_ops = &xfs_dir3_data_buf_ops;
+                       xfs_trans_buf_set_type(tp, curbp, XFS_BLF_DIR_DATA_BUF);
                        if (cmp == XFS_CMP_EXACT)
                                return XFS_ERROR(EEXIST);
                }
@@ -809,6 +819,7 @@ xfs_dir2_leafn_lookup_for_entry(
                        state->extrablk.blkno = curdb;
                        state->extrablk.magic = XFS_DIR2_DATA_MAGIC;
                        curbp->b_ops = &xfs_dir3_data_buf_ops;
+                       xfs_trans_buf_set_type(tp, curbp, XFS_BLF_DIR_DATA_BUF);
                } else {
                        /* If the curbp is not the CI match block, drop it */
                        if (state->extrablk.bp != curbp)

diff --git a/libxfs/xfs_dir2_priv.h b/libxfs/xfs_dir2_priv.h
index 932565d6ef2a85849a2547e9fbe5c956a3070923..7cf573c88aad5394f977b5b794026159f2248488 100644 (file)
--- a/libxfs/xfs_dir2_priv.h
+++ b/libxfs/xfs_dir2_priv.h
@@ -49,6 +49,7 @@ extern int xfs_dir2_leaf_to_block(struct xfs_da_args *args,
 #endif
 
 extern const struct xfs_buf_ops xfs_dir3_data_buf_ops;
+extern const struct xfs_buf_ops xfs_dir3_free_buf_ops;
 
 extern int __xfs_dir3_data_check(struct xfs_inode *dp, struct xfs_buf *bp);
 extern int xfs_dir3_data_read(struct xfs_trans *tp, struct xfs_inode *dp,
@@ -77,6 +78,7 @@ extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_buf *bp,
                xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);
 
 /* xfs_dir2_leaf.c */
+extern const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops;
 extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
 
 extern int xfs_dir3_leafn_read(struct xfs_trans *tp, struct xfs_inode *dp,