xfs: extract xfs_da_buf_copy() helper function

This patch does not modify logic.

xfs_da_buf_copy() will copy one block from src xfs_buf to
dst xfs_buf, and update the block metadata in dst directly.

Signed-off-by: Zhang Tianci <zhangtianci.1997@bytedance.com>
Suggested-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Chandan Babu R <chandanbabu@kernel.org>

diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 2580ae47209a6bf5a3fe52e7df51789f81de26aa..654e17e6610d6b827aecd0f8eccdf67bc8f7c6ec 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -1244,14 +1244,10 @@ xfs_attr3_leaf_to_node(
        if (error)
                goto out;
 
-       /* copy leaf to new buffer, update identifiers */
-       xfs_trans_buf_set_type(args->trans, bp2, XFS_BLFT_ATTR_LEAF_BUF);
-       bp2->b_ops = bp1->b_ops;
-       memcpy(bp2->b_addr, bp1->b_addr, args->geo->blksize);
-       if (xfs_has_crc(mp)) {
-               struct xfs_da3_blkinfo *hdr3 = bp2->b_addr;
-               hdr3->blkno = cpu_to_be64(xfs_buf_daddr(bp2));
-       }
+       /*
+        * Copy leaf to new buffer and log it.
+        */
+       xfs_da_buf_copy(bp2, bp1, args->geo->blksize);
        xfs_trans_log_buf(args->trans, bp2, 0, args->geo->blksize - 1);
 
        /*

diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index 282c7cf032f406b038f62fcce7a17d4f135e8fb1..5457188bb4deb29c8a607e19f82f1fdf5b116b71 100644 (file)
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -421,6 +421,25 @@ xfs_da3_node_read_mapped(
        return xfs_da3_node_set_type(tp, *bpp);
 }
 
+/*
+ * Copy src directory/attr leaf/node buffer to the dst.
+ * For v5 file systems make sure the right blkno is stamped in.
+ */
+void
+xfs_da_buf_copy(
+       struct xfs_buf *dst,
+       struct xfs_buf *src,
+       size_t size)
+{
+       struct xfs_da3_blkinfo *da3 = dst->b_addr;
+
+       memcpy(dst->b_addr, src->b_addr, size);
+       dst->b_ops = src->b_ops;
+       xfs_trans_buf_copy_type(dst, src);
+       if (xfs_has_crc(dst->b_mount))
+               da3->blkno = cpu_to_be64(xfs_buf_daddr(dst));
+}
+
 /*========================================================================
  * Routines used for growing the Btree.
  *========================================================================*/
@@ -690,12 +709,6 @@ xfs_da3_root_split(
                btree = icnodehdr.btree;
                size = (int)((char *)&btree[icnodehdr.count] - (char *)oldroot);
                level = icnodehdr.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_BLFT_DA_NODE_BUF);
        } else {
                struct xfs_dir3_icleaf_hdr leafhdr;
 
@@ -707,31 +720,17 @@ xfs_da3_root_split(
                size = (int)((char *)&leafhdr.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_BLFT_DIR_LEAFN_BUF);
        }
 
        /*
-        * we can copy most of the information in the node from one block to
-        * another, but for CRC enabled headers we have to make sure that the
-        * block specific identifiers are kept intact. We update the buffer
-        * directly for this.
+        * Copy old root to new buffer and log it.
         */
-       memcpy(node, oldroot, size);
-       if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) ||
-           oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
-               struct xfs_da3_intnode *node3 = (struct xfs_da3_intnode *)node;
-
-               node3->hdr.info.blkno = cpu_to_be64(xfs_buf_daddr(bp));
-       }
+       xfs_da_buf_copy(bp, blk1->bp, size);
        xfs_trans_log_buf(tp, bp, 0, size - 1);
 
-       bp->b_ops = blk1->bp->b_ops;
-       xfs_trans_buf_copy_type(bp, blk1->bp);
+       /*
+        * Update blk1 to point to new buffer.
+        */
        blk1->bp = bp;
        blk1->blkno = blkno;
 
@@ -1220,21 +1219,14 @@ xfs_da3_root_join(
        xfs_da_blkinfo_onlychild_validate(bp->b_addr, oldroothdr.level);
 
        /*
-        * This could be copying a leaf back into the root block in the case of
-        * there only being a single leaf block left in the tree. Hence we have
-        * to update the b_ops pointer as well to match the buffer type change
-        * that could occur. For dir3 blocks we also need to update the block
-        * number in the buffer header.
+        * Copy child to root buffer and log it.
         */
-       memcpy(root_blk->bp->b_addr, bp->b_addr, args->geo->blksize);
-       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(xfs_buf_daddr(root_blk->bp));
-       }
+       xfs_da_buf_copy(root_blk->bp, bp, args->geo->blksize);
        xfs_trans_log_buf(args->trans, root_blk->bp, 0,
                          args->geo->blksize - 1);
+       /*
+        * Now we can drop the child buffer.
+        */
        error = xfs_da_shrink_inode(args, child, bp);
        return error;
 }
@@ -2316,14 +2308,8 @@ xfs_da3_swap_lastblock(
                return error;
        /*
         * Copy the last block into the dead buffer and log it.
-        * On CRC-enabled file systems, also update the stamped in blkno.
         */
-       memcpy(dead_buf->b_addr, last_buf->b_addr, args->geo->blksize);
-       if (xfs_has_crc(mp)) {
-               struct xfs_da3_blkinfo *da3 = dead_buf->b_addr;
-
-               da3->blkno = cpu_to_be64(xfs_buf_daddr(dead_buf));
-       }
+       xfs_da_buf_copy(dead_buf, last_buf, args->geo->blksize);
        xfs_trans_log_buf(tp, dead_buf, 0, args->geo->blksize - 1);
        dead_info = dead_buf->b_addr;
 

diff --git a/fs/xfs/libxfs/xfs_da_btree.h b/fs/xfs/libxfs/xfs_da_btree.h
index ffa3df5b2893f71cf864113d3a2704d7ff9d5dc2..706baf36e1751146ede959bd8eaf3becbf62a27d 100644 (file)
--- a/fs/xfs/libxfs/xfs_da_btree.h
+++ b/fs/xfs/libxfs/xfs_da_btree.h
@@ -219,6 +219,8 @@ int xfs_da_reada_buf(struct xfs_inode *dp, xfs_dablk_t bno,
                const struct xfs_buf_ops *ops);
 int    xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
                                          struct xfs_buf *dead_buf);
+void   xfs_da_buf_copy(struct xfs_buf *dst, struct xfs_buf *src,
+                       size_t size);
 
 uint xfs_da_hashname(const uint8_t *name_string, int name_length);
 enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args,