[PATCH v2 0/7] btrfs-progs: Do some clean up to be consistent

[PATCH v2 0/7] btrfs-progs: Do some clean up to be consistent

[Gu Jinxiang]

Patch 1~4 and 7: clean up use of btrfs_root.
Patch 5: remove redundancy value assignment.
Patch 6: remove no longer be used function define.

Changelog:
v2->v1:
Patch 2,4: To be consistent with kernel, change macro to inline function.
Patch 3:
	Change macro to inline function to be consistent with kernel.
	And change the function body to match kernel.

Gu Jinxiang (7):
  btrfs-progs: Use fs_info instead of root for BTRFS_LEAF_DATA_SIZE
  btrfs-progs: Use fs_info instead of root for BTRFS_NODEPTRS_PER_BLOCK
  btrfs-progs: Use fs_info instead of root for
    BTRFS_MAX_INLINE_DATA_SIZE
  btrfs-progs: Use fs_info instead of root for BTRFS_MAX_XATTR_SIZE
  btrfs-progs: do clean up for redundancy value assignment
  btrfs-progs: remove no longer be used btrfs_alloc_extent
  btrfs-progs: Cleanup use of root in leaf_data_end

 cmds-check.c              | 10 ++---
 convert/source-ext2.c     |  4 +-
 convert/source-reiserfs.c |  6 +--
 ctree.c                   | 96 +++++++++++++++++++++++++----------------------
 ctree.h                   | 45 +++++++++++++---------
 dir-item.c                |  3 +-
 extent-tree.c             |  1 -
 file-item.c               |  2 +-
 mkfs/main.c               |  4 +-
 print-tree.c              |  2 +-
 quick-test.c              |  2 +-
 volumes.c                 |  2 +-
 12 files changed, 97 insertions(+), 80 deletions(-)

-- 
2.14.3

[PATCH v2 1/7] btrfs-progs: Use fs_info instead of root for BTRFS_LEAF_DATA_SIZE

[Gu Jinxiang]

Do a cleanup. Also make it consistent with kernel.
Use fs_info instead of root for BTRFS_LEAF_DATA_SIZE, since
maybe in some situation we do not know root, but just know fs_info.

Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
---
 cmds-check.c              |  6 +++---
 convert/source-ext2.c     |  2 +-
 convert/source-reiserfs.c |  4 ++--
 ctree.c                   | 49 +++++++++++++++++++++++++++--------------------
 ctree.h                   | 10 ++++++----
 file-item.c               |  2 +-
 volumes.c                 |  2 +-
 7 files changed, 42 insertions(+), 33 deletions(-)

diff --git a/cmds-check.c b/cmds-check.c
index 7d6bbb07..b118ea71 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -7255,9 +7255,9 @@ again:
 		unsigned int shift = 0, offset;
 
 		if (i == 0 && btrfs_item_end_nr(buf, i) !=
-		    BTRFS_LEAF_DATA_SIZE(root)) {
+		    BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 			if (btrfs_item_end_nr(buf, i) >
-			    BTRFS_LEAF_DATA_SIZE(root)) {
+			    BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 				ret = delete_bogus_item(root, path, buf, i);
 				if (!ret)
 					goto again;
@@ -7266,7 +7266,7 @@ again:
 				ret = -EIO;
 				break;
 			}
-			shift = BTRFS_LEAF_DATA_SIZE(root) -
+			shift = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 				btrfs_item_end_nr(buf, i);
 		} else if (i > 0 && btrfs_item_end_nr(buf, i) !=
 			   btrfs_item_offset_nr(buf, i - 1)) {
diff --git a/convert/source-ext2.c b/convert/source-ext2.c
index e9277213..e5c2a943 100644
--- a/convert/source-ext2.c
+++ b/convert/source-ext2.c
@@ -520,7 +520,7 @@ static int ext2_copy_single_xattr(struct btrfs_trans_handle *trans,
 	}
 	strncpy(namebuf, xattr_prefix_table[name_index], XATTR_NAME_MAX);
 	strncat(namebuf, EXT2_EXT_ATTR_NAME(entry), entry->e_name_len);
-	if (name_len + datalen > BTRFS_LEAF_DATA_SIZE(root) -
+	if (name_len + datalen > BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 	    sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
 		fprintf(stderr, "skip large xattr on inode %Lu name %.*s\n",
 			objectid - INO_OFFSET, name_len, namebuf);
diff --git a/convert/source-reiserfs.c b/convert/source-reiserfs.c
index be79d8e2..e3582bda 100644
--- a/convert/source-reiserfs.c
+++ b/convert/source-reiserfs.c
@@ -676,7 +676,7 @@ static int reiserfs_xattr_indirect_fn(reiserfs_filsys_t fs, u64 position,
 	size_t alloc = min(position + num_blocks * fs->fs_blocksize, size);
 	char *body;
 
-	if (size > BTRFS_LEAF_DATA_SIZE(xa_data->root) -
+	if (size > BTRFS_LEAF_DATA_SIZE(xa_data->root->fs_info) -
 	    sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
 		fprintf(stderr, "skip large xattr on objectid %llu name %.*s\n",
 			xa_data->target_oid, (int)xa_data->namelen,
@@ -714,7 +714,7 @@ static int reiserfs_xattr_direct_fn(reiserfs_filsys_t fs, __u64 position,
 	struct reiserfs_xattr_data *xa_data = data;
 	char *newbody;
 
-	if (size > BTRFS_LEAF_DATA_SIZE(xa_data->root) -
+	if (size > BTRFS_LEAF_DATA_SIZE(xa_data->root->fs_info) -
 	    sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
 		fprintf(stderr, "skip large xattr on objectid %llu name %.*s\n",
 			xa_data->target_oid, (int)xa_data->namelen,
diff --git a/ctree.c b/ctree.c
index f4cf006b..cb16c42c 100644
--- a/ctree.c
+++ b/ctree.c
@@ -415,7 +415,7 @@ static inline unsigned int leaf_data_end(struct btrfs_root *root,
 {
 	u32 nr = btrfs_header_nritems(leaf);
 	if (nr == 0)
-		return BTRFS_LEAF_DATA_SIZE(root);
+		return BTRFS_LEAF_DATA_SIZE(root->fs_info);
 	return btrfs_item_offset_nr(leaf, nr - 1);
 }
 
@@ -517,24 +517,26 @@ btrfs_check_leaf(struct btrfs_root *root, struct btrfs_disk_key *parent_key,
 			goto fail;
 		}
 		if (i == 0 && btrfs_item_end_nr(buf, i) !=
-		    BTRFS_LEAF_DATA_SIZE(root)) {
+		    BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 			ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS;
 			fprintf(stderr, "bad item end %u wanted %u\n",
 				btrfs_item_end_nr(buf, i),
-				(unsigned)BTRFS_LEAF_DATA_SIZE(root));
+				(unsigned)BTRFS_LEAF_DATA_SIZE(root->fs_info));
 			goto fail;
 		}
 	}
 
 	for (i = 0; i < nritems; i++) {
-		if (btrfs_item_end_nr(buf, i) > BTRFS_LEAF_DATA_SIZE(root)) {
+		if (btrfs_item_end_nr(buf, i) >
+				BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 			btrfs_item_key(buf, &key, 0);
 			btrfs_print_key(&key);
 			fflush(stdout);
 			ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS;
 			fprintf(stderr, "slot end outside of leaf %llu > %llu\n",
 				(unsigned long long)btrfs_item_end_nr(buf, i),
-				(unsigned long long)BTRFS_LEAF_DATA_SIZE(root));
+				(unsigned long long)BTRFS_LEAF_DATA_SIZE(
+					root->fs_info));
 			goto fail;
 		}
 	}
@@ -1621,7 +1623,7 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr)
  */
 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf)
 {
-	u32 nodesize = (root ? BTRFS_LEAF_DATA_SIZE(root) : leaf->len);
+	u32 nodesize = (root ? BTRFS_LEAF_DATA_SIZE(root->fs_info) : leaf->len);
 	int nritems = btrfs_header_nritems(leaf);
 	int ret;
 	ret = nodesize - leaf_space_used(leaf, 0, nritems);
@@ -1742,11 +1744,11 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	memmove_extent_buffer(right,
 			      btrfs_leaf_data(right) + data_end - push_space,
 			      btrfs_leaf_data(right) + data_end,
-			      BTRFS_LEAF_DATA_SIZE(root) - data_end);
+			      BTRFS_LEAF_DATA_SIZE(root->fs_info) - data_end);
 
 	/* copy from the left data area */
 	copy_extent_buffer(right, left, btrfs_leaf_data(right) +
-		     BTRFS_LEAF_DATA_SIZE(root) - push_space,
+		     BTRFS_LEAF_DATA_SIZE(root->fs_info) - push_space,
 		     btrfs_leaf_data(left) + leaf_data_end(root, left),
 		     push_space);
 
@@ -1762,7 +1764,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	/* update the item pointers */
 	right_nritems += push_items;
 	btrfs_set_header_nritems(right, right_nritems);
-	push_space = BTRFS_LEAF_DATA_SIZE(root);
+	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info);
 	for (i = 0; i < right_nritems; i++) {
 		item = btrfs_item_nr(i);
 		push_space -= btrfs_item_size(right, item);
@@ -1881,7 +1883,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 			   btrfs_item_nr_offset(0),
 			   push_items * sizeof(struct btrfs_item));
 
-	push_space = BTRFS_LEAF_DATA_SIZE(root) -
+	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 		     btrfs_item_offset_nr(right, push_items -1);
 
 	copy_extent_buffer(left, right, btrfs_leaf_data(left) +
@@ -1899,7 +1901,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 		item = btrfs_item_nr(i);
 		ioff = btrfs_item_offset(left, item);
 		btrfs_set_item_offset(left, item,
-		      ioff - (BTRFS_LEAF_DATA_SIZE(root) - old_left_item_size));
+		      ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) -
+			      old_left_item_size));
 	}
 	btrfs_set_header_nritems(left, old_left_nritems + push_items);
 
@@ -1913,7 +1916,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 		push_space = btrfs_item_offset_nr(right, push_items - 1) -
 						  leaf_data_end(root, right);
 		memmove_extent_buffer(right, btrfs_leaf_data(right) +
-				      BTRFS_LEAF_DATA_SIZE(root) - push_space,
+				      BTRFS_LEAF_DATA_SIZE(root->fs_info) -
+				      push_space,
 				      btrfs_leaf_data(right) +
 				      leaf_data_end(root, right), push_space);
 
@@ -1924,7 +1928,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	}
 	right_nritems -= push_items;
 	btrfs_set_header_nritems(right, right_nritems);
-	push_space = BTRFS_LEAF_DATA_SIZE(root);
+	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info);
 	for (i = 0; i < right_nritems; i++) {
 		item = btrfs_item_nr(i);
 		push_space = push_space - btrfs_item_size(right, item);
@@ -1981,11 +1985,12 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 			   nritems * sizeof(struct btrfs_item));
 
 	copy_extent_buffer(right, l,
-		     btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) -
+		     btrfs_leaf_data(right) +
+		     BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 		     data_copy_size, btrfs_leaf_data(l) +
 		     leaf_data_end(root, l), data_copy_size);
 
-	rt_data_off = BTRFS_LEAF_DATA_SIZE(root) -
+	rt_data_off = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 		      btrfs_item_end_nr(l, mid);
 
 	for (i = 0; i < nritems; i++) {
@@ -2046,7 +2051,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
 	l = path->nodes[0];
 	slot = path->slots[0];
 	if (extend && data_size + btrfs_item_size_nr(l, slot) +
-	    sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root))
+	    sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root->fs_info))
 		return -EOVERFLOW;
 
 	/* first try to make some room by pushing left and right */
@@ -2081,21 +2086,22 @@ again:
 	if (mid <= slot) {
 		if (nritems == 1 ||
 		    leaf_space_used(l, mid, nritems - mid) + data_size >
-			BTRFS_LEAF_DATA_SIZE(root)) {
+			BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 			if (slot >= nritems) {
 				split = 0;
 			} else {
 				mid = slot;
 				if (mid != nritems &&
 				    leaf_space_used(l, mid, nritems - mid) +
-				    data_size > BTRFS_LEAF_DATA_SIZE(root)) {
+				    data_size >
+				    BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 					split = 2;
 				}
 			}
 		}
 	} else {
 		if (leaf_space_used(l, 0, mid) + data_size >
-			BTRFS_LEAF_DATA_SIZE(root)) {
+			BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 			if (!extend && data_size && slot == 0) {
 				split = 0;
 			} else if ((extend || !data_size) && slot == 0) {
@@ -2104,7 +2110,8 @@ again:
 				mid = slot;
 				if (mid != nritems &&
 				    leaf_space_used(l, mid, nritems - mid) +
-				    data_size > BTRFS_LEAF_DATA_SIZE(root)) {
+				    data_size >
+				    BTRFS_LEAF_DATA_SIZE(root->fs_info)) {
 					split = 2 ;
 				}
 			}
@@ -2729,7 +2736,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		}
 
 		/* delete the leaf if it is mostly empty */
-		if (used < BTRFS_LEAF_DATA_SIZE(root) / 4) {
+		if (used < BTRFS_LEAF_DATA_SIZE(root->fs_info) / 4) {
 			/* push_leaf_left fixes the path.
 			 * make sure the path still points to our leaf
 			 * for possible call to del_ptr below
diff --git a/ctree.h b/ctree.h
index ef422ea6..11913efa 100644
--- a/ctree.h
+++ b/ctree.h
@@ -360,11 +360,12 @@ struct btrfs_header {
 			        sizeof(struct btrfs_header)) / \
 			        sizeof(struct btrfs_key_ptr))
 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
-#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->fs_info->nodesize))
-#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
+#define BTRFS_LEAF_DATA_SIZE(fs_info) \
+				(__BTRFS_LEAF_DATA_SIZE(fs_info->nodesize))
+#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r->fs_info) - \
 					sizeof(struct btrfs_item) - \
 					sizeof(struct btrfs_file_extent_item))
-#define BTRFS_MAX_XATTR_SIZE(r)	(BTRFS_LEAF_DATA_SIZE(r) - \
+#define BTRFS_MAX_XATTR_SIZE(r)	(BTRFS_LEAF_DATA_SIZE(r->fs_info) - \
 				 sizeof(struct btrfs_item) -\
 				 sizeof(struct btrfs_dir_item))
 
@@ -599,7 +600,8 @@ struct btrfs_extent_item_v0 {
 	__le32 refs;
 } __attribute__ ((__packed__));
 
-#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
+#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) \
+			((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
 					sizeof(struct btrfs_item))
 #define BTRFS_MAX_EXTENT_SIZE		SZ_128M
 
diff --git a/file-item.c b/file-item.c
index 8e169e18..7b0ff358 100644
--- a/file-item.c
+++ b/file-item.c
@@ -27,7 +27,7 @@
 #include "crc32c.h"
 #include "internal.h"
 
-#define MAX_CSUM_ITEMS(r,size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
+#define MAX_CSUM_ITEMS(r, size) ((((BTRFS_LEAF_DATA_SIZE(r->fs_info) - \
 			       sizeof(struct btrfs_item) * 2) / \
 			       size) - 1))
 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
diff --git a/volumes.c b/volumes.c
index ce3a5405..034f5d45 100644
--- a/volumes.c
+++ b/volumes.c
@@ -837,7 +837,7 @@ error:
 	return ret;
 }
 
-#define BTRFS_MAX_DEVS(r) ((BTRFS_LEAF_DATA_SIZE(r)		\
+#define BTRFS_MAX_DEVS(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info)	\
 			- sizeof(struct btrfs_item)		\
 			- sizeof(struct btrfs_chunk))		\
 			/ sizeof(struct btrfs_stripe) + 1)
-- 
2.14.3

[PATCH v2 2/7] btrfs-progs: Use fs_info instead of root for BTRFS_NODEPTRS_PER_BLOCK

[Gu Jinxiang]

Do a cleanup. Also make it consistent with kernel.
Use fs_info instead of root for BTRFS_NODEPTRS_PER_BLOCK, since
maybe in some situation we do not know root, but just know fs_info.

Changelog:
v2->v1:
To be consistent with kernel, change macro to inline function.

Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
---
 cmds-check.c |  4 ++--
 ctree.c      | 18 +++++++++---------
 ctree.h      |  7 ++++---
 print-tree.c |  2 +-
 quick-test.c |  2 +-
 5 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/cmds-check.c b/cmds-check.c
index b118ea71..b94fab4f 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -2529,7 +2529,7 @@ static void account_bytes(struct btrfs_root *root, struct btrfs_path *path,
 	if (level == 0) {
 		btree_space_waste += btrfs_leaf_free_space(root, eb);
 	} else {
-		free_nrs = (BTRFS_NODEPTRS_PER_BLOCK(root) -
+		free_nrs = (BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) -
 			    btrfs_header_nritems(eb));
 		btree_space_waste += free_nrs * sizeof(struct btrfs_key_ptr);
 	}
@@ -9504,7 +9504,7 @@ static int run_next_block(struct btrfs_root *root,
 				add_pending(pending, seen, ptr, size);
 			}
 		}
-		btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
+		btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(fs_info) -
 				      nritems) * sizeof(struct btrfs_key_ptr);
 	}
 	total_btree_bytes += buf->len;
diff --git a/ctree.c b/ctree.c
index cb16c42c..11d207e7 100644
--- a/ctree.c
+++ b/ctree.c
@@ -429,7 +429,7 @@ btrfs_check_node(struct btrfs_root *root, struct btrfs_disk_key *parent_key,
 	u32 nritems = btrfs_header_nritems(buf);
 	enum btrfs_tree_block_status ret = BTRFS_TREE_BLOCK_INVALID_NRITEMS;
 
-	if (nritems == 0 || nritems > BTRFS_NODEPTRS_PER_BLOCK(root))
+	if (nritems == 0 || nritems > BTRFS_NODEPTRS_PER_BLOCK(root->fs_info))
 		goto fail;
 
 	ret = BTRFS_TREE_BLOCK_INVALID_PARENT_KEY;
@@ -716,7 +716,7 @@ static int balance_level(struct btrfs_trans_handle *trans,
 		return ret;
 	}
 	if (btrfs_header_nritems(mid) >
-	    BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
+	    BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 4)
 		return 0;
 
 	left = read_node_slot(fs_info, parent, pslot - 1);
@@ -884,7 +884,7 @@ static int noinline push_nodes_for_insert(struct btrfs_trans_handle *trans,
 	if (extent_buffer_uptodate(left)) {
 		u32 left_nr;
 		left_nr = btrfs_header_nritems(left);
-		if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
+		if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {
 			wret = 1;
 		} else {
 			ret = btrfs_cow_block(trans, root, left, parent,
@@ -927,7 +927,7 @@ static int noinline push_nodes_for_insert(struct btrfs_trans_handle *trans,
 	if (extent_buffer_uptodate(right)) {
 		u32 right_nr;
 		right_nr = btrfs_header_nritems(right);
-		if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
+		if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) - 1) {
 			wret = 1;
 		} else {
 			ret = btrfs_cow_block(trans, root, right,
@@ -1146,7 +1146,7 @@ again:
 			p->slots[level] = slot;
 			if ((p->search_for_split || ins_len > 0) &&
 			    btrfs_header_nritems(b) >=
-			    BTRFS_NODEPTRS_PER_BLOCK(root) - 3) {
+			    BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 3) {
 				int sret = split_node(trans, root, p, level);
 				BUG_ON(sret > 0);
 				if (sret)
@@ -1292,7 +1292,7 @@ static int push_node_left(struct btrfs_trans_handle *trans,
 
 	src_nritems = btrfs_header_nritems(src);
 	dst_nritems = btrfs_header_nritems(dst);
-	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
+	push_items = BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) - dst_nritems;
 	WARN_ON(btrfs_header_generation(src) != trans->transid);
 	WARN_ON(btrfs_header_generation(dst) != trans->transid);
 
@@ -1362,7 +1362,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
 
 	src_nritems = btrfs_header_nritems(src);
 	dst_nritems = btrfs_header_nritems(dst);
-	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
+	push_items = BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) - dst_nritems;
 	if (push_items <= 0) {
 		return 1;
 	}
@@ -1490,7 +1490,7 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
 	nritems = btrfs_header_nritems(lower);
 	if (slot > nritems)
 		BUG();
-	if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root))
+	if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root->fs_info))
 		BUG();
 	if (slot < nritems) {
 		/* shift the items */
@@ -1539,7 +1539,7 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
 		ret = push_nodes_for_insert(trans, root, path, level);
 		c = path->nodes[level];
 		if (!ret && btrfs_header_nritems(c) <
-		    BTRFS_NODEPTRS_PER_BLOCK(root) - 3)
+		    BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) - 3)
 			return 0;
 		if (ret < 0)
 			return ret;
diff --git a/ctree.h b/ctree.h
index 11913efa..f3964f18 100644
--- a/ctree.h
+++ b/ctree.h
@@ -356,9 +356,6 @@ struct btrfs_header {
 	u8 level;
 } __attribute__ ((__packed__));
 
-#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->fs_info->nodesize - \
-			        sizeof(struct btrfs_header)) / \
-			        sizeof(struct btrfs_key_ptr))
 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
 #define BTRFS_LEAF_DATA_SIZE(fs_info) \
 				(__BTRFS_LEAF_DATA_SIZE(fs_info->nodesize))
@@ -1191,6 +1188,10 @@ struct btrfs_root {
 	struct rb_node rb_node;
 };
 
+static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
+{
+	return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
+}
 /*
  * inode items have the data typically returned from stat and store other
  * info about object characteristics.  There is one for every file and dir in
diff --git a/print-tree.c b/print-tree.c
index d3fa8621..5f37ef3e 100644
--- a/print-tree.c
+++ b/print-tree.c
@@ -1359,7 +1359,7 @@ void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *eb, int fol
 	printf("node %llu level %d items %d free %u generation %llu owner %llu\n",
 	       (unsigned long long)eb->start,
 	        btrfs_header_level(eb), nr,
-		(u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr,
+		(u32)BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) - nr,
 		(unsigned long long)btrfs_header_generation(eb),
 		(unsigned long long)btrfs_header_owner(eb));
 	print_uuids(eb);
diff --git a/quick-test.c b/quick-test.c
index b1e7999d..5da47c32 100644
--- a/quick-test.c
+++ b/quick-test.c
@@ -110,7 +110,7 @@ int main(int ac, char **av) {
 	printf("node %p level %d total ptrs %d free spc %lu\n", root->node,
 	        btrfs_header_level(root->node),
 		btrfs_header_nritems(root->node),
-		(unsigned long)BTRFS_NODEPTRS_PER_BLOCK(root) -
+		(unsigned long)BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) -
 		btrfs_header_nritems(root->node));
 	printf("all searches good, deleting some items\n");
 	i = 0;
-- 
2.14.3

[PATCH v2 3/7] btrfs-progs: Use fs_info instead of root for BTRFS_MAX_INLINE_DATA_SIZE

[Gu Jinxiang]

Do a cleanup. Also make it consistent with kernel.
Use fs_info instead of root for BTRFS_MAX_INLINE_DATA_SIZE, since
maybe in some situation we do not know root, but just know fs_info.

Changelog:
v2->v1:
Change macro to inline function to be consistent with kernel.
And change the function body to match kernel.

Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
---
 convert/source-ext2.c     |  2 +-
 convert/source-reiserfs.c |  2 +-
 ctree.h                   | 17 ++++++++++++++---
 mkfs/main.c               |  4 ++--
 4 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/convert/source-ext2.c b/convert/source-ext2.c
index e5c2a943..f5ecd8cf 100644
--- a/convert/source-ext2.c
+++ b/convert/source-ext2.c
@@ -309,7 +309,7 @@ static int ext2_create_file_extents(struct btrfs_trans_handle *trans,
 		goto fail;
 	if ((convert_flags & CONVERT_FLAG_INLINE_DATA) && data.first_block == 0
 	    && data.num_blocks > 0
-	    && inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
+	    && inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root->fs_info)) {
 		u64 num_bytes = data.num_blocks * sectorsize;
 		u64 disk_bytenr = data.disk_block * sectorsize;
 		u64 nbytes;
diff --git a/convert/source-reiserfs.c b/convert/source-reiserfs.c
index e3582bda..39d6f072 100644
--- a/convert/source-reiserfs.c
+++ b/convert/source-reiserfs.c
@@ -376,7 +376,7 @@ static int reiserfs_convert_tail(struct btrfs_trans_handle *trans,
 	u64 isize;
 	int ret;
 
-	if (length >= BTRFS_MAX_INLINE_DATA_SIZE(root))
+	if (length >= BTRFS_MAX_INLINE_DATA_SIZE(root->fs_info))
 		return convert_direct(trans, root, objectid, inode, body,
 				      length, offset, convert_flags);
 
diff --git a/ctree.h b/ctree.h
index f3964f18..7be48e22 100644
--- a/ctree.h
+++ b/ctree.h
@@ -359,9 +359,6 @@ struct btrfs_header {
 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
 #define BTRFS_LEAF_DATA_SIZE(fs_info) \
 				(__BTRFS_LEAF_DATA_SIZE(fs_info->nodesize))
-#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r->fs_info) - \
-					sizeof(struct btrfs_item) - \
-					sizeof(struct btrfs_file_extent_item))
 #define BTRFS_MAX_XATTR_SIZE(r)	(BTRFS_LEAF_DATA_SIZE(r->fs_info) - \
 				 sizeof(struct btrfs_item) -\
 				 sizeof(struct btrfs_dir_item))
@@ -1188,10 +1185,24 @@ struct btrfs_root {
 	struct rb_node rb_node;
 };
 
+static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info)
+{
+	return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item);
+}
+
 static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
 {
 	return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
 }
+
+#define BTRFS_FILE_EXTENT_INLINE_DATA_START		\
+	(offsetof(struct btrfs_file_extent_item, disk_bytenr))
+static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
+{
+	return BTRFS_MAX_ITEM_SIZE(info) -
+		BTRFS_FILE_EXTENT_INLINE_DATA_START;
+}
+
 /*
  * inode items have the data typically returned from stat and store other
  * info about object characteristics.  There is one for every file and dir in
diff --git a/mkfs/main.c b/mkfs/main.c
index d817ad8d..a301efc3 100644
--- a/mkfs/main.c
+++ b/mkfs/main.c
@@ -498,7 +498,7 @@ static int fill_inode_item(struct btrfs_trans_handle *trans,
 	}
 	if (S_ISREG(src->st_mode)) {
 		btrfs_set_stack_inode_size(dst, (u64)src->st_size);
-		if (src->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root))
+		if (src->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root->fs_info))
 			btrfs_set_stack_inode_nbytes(dst, src->st_size);
 		else {
 			blocks = src->st_size / sectorsize;
@@ -686,7 +686,7 @@ static int add_file_items(struct btrfs_trans_handle *trans,
 	if (st->st_size % sectorsize)
 		blocks += 1;
 
-	if (st->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
+	if (st->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root->fs_info)) {
 		char *buffer = malloc(st->st_size);
 
 		if (!buffer) {
-- 
2.14.3

[PATCH v2 4/7] btrfs-progs: Use fs_info instead of root for BTRFS_MAX_XATTR_SIZE

[Gu Jinxiang]

Do a cleanup. Also make it consistent with kernel.
Use fs_info instead of root for BTRFS_MAX_XATTR_SIZE, since
maybe in some situation we do not know root, but just know fs_info.

Changelog:
v2->v1:
To be consistent with kernel, change macro to inline function.

Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
---
 ctree.h    | 9 +++++----
 dir-item.c | 3 ++-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/ctree.h b/ctree.h
index 7be48e22..679bbc91 100644
--- a/ctree.h
+++ b/ctree.h
@@ -359,10 +359,6 @@ struct btrfs_header {
 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
 #define BTRFS_LEAF_DATA_SIZE(fs_info) \
 				(__BTRFS_LEAF_DATA_SIZE(fs_info->nodesize))
-#define BTRFS_MAX_XATTR_SIZE(r)	(BTRFS_LEAF_DATA_SIZE(r->fs_info) - \
-				 sizeof(struct btrfs_item) -\
-				 sizeof(struct btrfs_dir_item))
-
 
 /*
  * this is a very generous portion of the super block, giving us
@@ -1203,6 +1199,11 @@ static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
 		BTRFS_FILE_EXTENT_INLINE_DATA_START;
 }
 
+static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
+{
+	return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item);
+}
+
 /*
  * inode items have the data typically returned from stat and store other
  * info about object characteristics.  There is one for every file and dir in
diff --git a/dir-item.c b/dir-item.c
index 462546c0..0b7250c9 100644
--- a/dir-item.c
+++ b/dir-item.c
@@ -311,7 +311,8 @@ static int verify_dir_item(struct btrfs_root *root,
 
 	/* BTRFS_MAX_XATTR_SIZE is the same for all dir items */
 	if ((btrfs_dir_data_len(leaf, dir_item) +
-	     btrfs_dir_name_len(leaf, dir_item)) > BTRFS_MAX_XATTR_SIZE(root)) {
+	     btrfs_dir_name_len(leaf, dir_item)) >
+			BTRFS_MAX_XATTR_SIZE(root->fs_info)) {
 		fprintf(stderr, "invalid dir item name + data len: %u + %u\n",
 		       (unsigned)btrfs_dir_name_len(leaf, dir_item),
 		       (unsigned)btrfs_dir_data_len(leaf, dir_item));
-- 
2.14.3

[PATCH v2 5/7] btrfs-progs: do clean up for redundancy value assignment

[Gu Jinxiang]

Although skinny_metadata's type is int, its value just can be 0/1.
And if condition be true only when skinny_metadata equals 1,
so in if's executive part, set skinny_metadata to 1 is redundancy.
Remove it.

Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
---
 extent-tree.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/extent-tree.c b/extent-tree.c
index 1ac312a6..53d31ab3 100644
--- a/extent-tree.c
+++ b/extent-tree.c
@@ -1005,7 +1005,6 @@ static int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
 		extra_size = -1;
 
 	if (owner < BTRFS_FIRST_FREE_OBJECTID && skinny_metadata) {
-		skinny_metadata = 1;
 		key.type = BTRFS_METADATA_ITEM_KEY;
 		key.offset = owner;
 	} else if (skinny_metadata) {
-- 
2.14.3

[PATCH v2 6/7] btrfs-progs: remove no longer be used btrfs_alloc_extent

[Gu Jinxiang]

Do a cleanup.
Function btrfs_alloc_extent is no longer be used.
So let's remove it.

Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
---
 ctree.h | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/ctree.h b/ctree.h
index 679bbc91..41b14b57 100644
--- a/ctree.h
+++ b/ctree.h
@@ -2501,12 +2501,6 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
 					u32 blocksize, u64 root_objectid,
 					struct btrfs_disk_key *key, int level,
 					u64 hint, u64 empty_size);
-int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
-		       struct btrfs_root *root,
-		       u64 num_bytes, u64 parent,
-		       u64 root_objectid, u64 ref_generation,
-		       u64 owner, u64 empty_size, u64 hint_byte,
-		       u64 search_end, struct btrfs_key *ins, int data);
 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
 			     struct btrfs_root *root, u64 bytenr,
 			     u64 offset, int metadata, u64 *refs, u64 *flags);
-- 
2.14.3

[PATCH v2 7/7] btrfs-progs: Cleanup use of root in leaf_data_end

[Gu Jinxiang]

In function leaf_data_end, root is just used to get fs_info,
so change the parameter of this function from btrfs_root to
btrfs_fs_info.
And also make it consistent with kernel.

Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
---
 ctree.c | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/ctree.c b/ctree.c
index 11d207e7..2417483d 100644
--- a/ctree.c
+++ b/ctree.c
@@ -410,12 +410,12 @@ static int btrfs_comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
  * this returns the address of the start of the last item,
  * which is the stop of the leaf data stack
  */
-static inline unsigned int leaf_data_end(struct btrfs_root *root,
-					 struct extent_buffer *leaf)
+static inline unsigned int leaf_data_end(const struct btrfs_fs_info *fs_info,
+					 const struct extent_buffer *leaf)
 {
 	u32 nr = btrfs_header_nritems(leaf);
 	if (nr == 0)
-		return BTRFS_LEAF_DATA_SIZE(root->fs_info);
+		return BTRFS_LEAF_DATA_SIZE(fs_info);
 	return btrfs_item_offset_nr(leaf, nr - 1);
 }
 
@@ -1737,10 +1737,10 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	right_nritems = btrfs_header_nritems(right);
 
 	push_space = btrfs_item_end_nr(left, left_nritems - push_items);
-	push_space -= leaf_data_end(root, left);
+	push_space -= leaf_data_end(fs_info, left);
 
 	/* make room in the right data area */
-	data_end = leaf_data_end(root, right);
+	data_end = leaf_data_end(fs_info, right);
 	memmove_extent_buffer(right,
 			      btrfs_leaf_data(right) + data_end - push_space,
 			      btrfs_leaf_data(right) + data_end,
@@ -1749,7 +1749,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	/* copy from the left data area */
 	copy_extent_buffer(right, left, btrfs_leaf_data(right) +
 		     BTRFS_LEAF_DATA_SIZE(root->fs_info) - push_space,
-		     btrfs_leaf_data(left) + leaf_data_end(root, left),
+		     btrfs_leaf_data(left) + leaf_data_end(fs_info, left),
 		     push_space);
 
 	memmove_extent_buffer(right, btrfs_item_nr_offset(push_items),
@@ -1887,7 +1887,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 		     btrfs_item_offset_nr(right, push_items -1);
 
 	copy_extent_buffer(left, right, btrfs_leaf_data(left) +
-		     leaf_data_end(root, left) - push_space,
+		     leaf_data_end(fs_info, left) - push_space,
 		     btrfs_leaf_data(right) +
 		     btrfs_item_offset_nr(right, push_items - 1),
 		     push_space);
@@ -1914,12 +1914,13 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 
 	if (push_items < right_nritems) {
 		push_space = btrfs_item_offset_nr(right, push_items - 1) -
-						  leaf_data_end(root, right);
+						  leaf_data_end(fs_info, right);
 		memmove_extent_buffer(right, btrfs_leaf_data(right) +
 				      BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 				      push_space,
 				      btrfs_leaf_data(right) +
-				      leaf_data_end(root, right), push_space);
+				      leaf_data_end(fs_info, right),
+				      push_space);
 
 		memmove_extent_buffer(right, btrfs_item_nr_offset(0),
 			      btrfs_item_nr_offset(push_items),
@@ -1978,7 +1979,8 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 
 	nritems = nritems - mid;
 	btrfs_set_header_nritems(right, nritems);
-	data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(root, l);
+	data_copy_size = btrfs_item_end_nr(l, mid) -
+		leaf_data_end(root->fs_info, l);
 
 	copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
 			   btrfs_item_nr_offset(mid),
@@ -1988,7 +1990,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 		     btrfs_leaf_data(right) +
 		     BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 		     data_copy_size, btrfs_leaf_data(l) +
-		     leaf_data_end(root, l), data_copy_size);
+		     leaf_data_end(root->fs_info, l), data_copy_size);
 
 	rt_data_off = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 		      btrfs_item_end_nr(l, mid);
@@ -2326,7 +2328,7 @@ int btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path,
 		return 0;
 
 	nritems = btrfs_header_nritems(leaf);
-	data_end = leaf_data_end(root, leaf);
+	data_end = leaf_data_end(root->fs_info, leaf);
 
 	old_data_start = btrfs_item_offset_nr(leaf, slot);
 
@@ -2415,7 +2417,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 	leaf = path->nodes[0];
 
 	nritems = btrfs_header_nritems(leaf);
-	data_end = leaf_data_end(root, leaf);
+	data_end = leaf_data_end(root->fs_info, leaf);
 
 	if (btrfs_leaf_free_space(root, leaf) < data_size) {
 		btrfs_print_leaf(root, leaf);
@@ -2501,7 +2503,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 	leaf = path->nodes[0];
 
 	nritems = btrfs_header_nritems(leaf);
-	data_end = leaf_data_end(root, leaf);
+	data_end = leaf_data_end(root->fs_info, leaf);
 
 	if (btrfs_leaf_free_space(root, leaf) < total_size) {
 		btrfs_print_leaf(root, leaf);
@@ -2692,7 +2694,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 	nritems = btrfs_header_nritems(leaf);
 
 	if (slot + nr != nritems) {
-		int data_end = leaf_data_end(root, leaf);
+		int data_end = leaf_data_end(root->fs_info, leaf);
 
 		memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
 			      data_end + dsize,
-- 
2.14.3

Re: [PATCH v2 0/7] btrfs-progs: Do some clean up to be consistent

[Qu Wenruo]

[-- Attachment #1.1: Type: text/plain, Size: 1870 bytes --]



On 2018年01月26日 15:25, Gu Jinxiang wrote:
> Patch 1~4 and 7: clean up use of btrfs_root.
> Patch 5: remove redundancy value assignment.
> Patch 6: remove no longer be used function define.

Overall it looks good, just one small nitpick, which should not need
another update.

> Changelog:
> v2->v1:
> Patch 2,4: To be consistent with kernel, change macro to inline function.
> Patch 3:
> 	Change macro to inline function to be consistent with kernel.
> 	And change the function body to match kernel.
> 
> Gu Jinxiang (7):
>   btrfs-progs: Use fs_info instead of root for BTRFS_LEAF_DATA_SIZE
>   btrfs-progs: Use fs_info instead of root for BTRFS_NODEPTRS_PER_BLOCK
>   btrfs-progs: Use fs_info instead of root for
>     BTRFS_MAX_INLINE_DATA_SIZE

Not only this patch modified the parameter but also sync the code with
kernel.
It would be better to mention it in commit message, but anyway, just a
small nitpick, nothing to worry about.

Reviewed-by: Qu Wenruo <wqu@suse.com>

Thanks,
Qu

>   btrfs-progs: Use fs_info instead of root for BTRFS_MAX_XATTR_SIZE
>   btrfs-progs: do clean up for redundancy value assignment
>   btrfs-progs: remove no longer be used btrfs_alloc_extent
>   btrfs-progs: Cleanup use of root in leaf_data_end
> 
>  cmds-check.c              | 10 ++---
>  convert/source-ext2.c     |  4 +-
>  convert/source-reiserfs.c |  6 +--
>  ctree.c                   | 96 +++++++++++++++++++++++++----------------------
>  ctree.h                   | 45 +++++++++++++---------
>  dir-item.c                |  3 +-
>  extent-tree.c             |  1 -
>  file-item.c               |  2 +-
>  mkfs/main.c               |  4 +-
>  print-tree.c              |  2 +-
>  quick-test.c              |  2 +-
>  volumes.c                 |  2 +-
>  12 files changed, 97 insertions(+), 80 deletions(-)
> 


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 520 bytes --]

Re: [PATCH v2 7/7] btrfs-progs: Cleanup use of root in leaf_data_end

[Qu Wenruo]

[-- Attachment #1.1: Type: text/plain, Size: 6138 bytes --]



On 2018年01月26日 15:26, Gu Jinxiang wrote:
> In function leaf_data_end, root is just used to get fs_info,
> so change the parameter of this function from btrfs_root to
> btrfs_fs_info.
> And also make it consistent with kernel.
> 
> Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
> ---
>  ctree.c | 32 +++++++++++++++++---------------
>  1 file changed, 17 insertions(+), 15 deletions(-)
> 
> diff --git a/ctree.c b/ctree.c
> index 11d207e7..2417483d 100644
> --- a/ctree.c
> +++ b/ctree.c
> @@ -410,12 +410,12 @@ static int btrfs_comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
>   * this returns the address of the start of the last item,
>   * which is the stop of the leaf data stack
>   */
> -static inline unsigned int leaf_data_end(struct btrfs_root *root,
> -					 struct extent_buffer *leaf)
> +static inline unsigned int leaf_data_end(const struct btrfs_fs_info *fs_info,
> +					 const struct extent_buffer *leaf)

Here leaf is const, which is fine.

>  {
>  	u32 nr = btrfs_header_nritems(leaf);
>  	if (nr == 0)
> -		return BTRFS_LEAF_DATA_SIZE(root->fs_info);
> +		return BTRFS_LEAF_DATA_SIZE(fs_info);
>  	return btrfs_item_offset_nr(leaf, nr - 1);

But btrfs_item_offset_nr() doesn't have const prefix for leaf.
Leaving the following warning:

passing argument 1 of ‘btrfs_item_offset_nr’ discards ‘const’ qualifier
from pointer target type [-Wdiscarded-qualifiers]
  return btrfs_item_offset_nr(leaf, nr - 1);
                              ^~~~

Thanks,
Qu
>  }
>  
> @@ -1737,10 +1737,10 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
>  	right_nritems = btrfs_header_nritems(right);
>  
>  	push_space = btrfs_item_end_nr(left, left_nritems - push_items);
> -	push_space -= leaf_data_end(root, left);
> +	push_space -= leaf_data_end(fs_info, left);
>  
>  	/* make room in the right data area */
> -	data_end = leaf_data_end(root, right);
> +	data_end = leaf_data_end(fs_info, right);
>  	memmove_extent_buffer(right,
>  			      btrfs_leaf_data(right) + data_end - push_space,
>  			      btrfs_leaf_data(right) + data_end,
> @@ -1749,7 +1749,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
>  	/* copy from the left data area */
>  	copy_extent_buffer(right, left, btrfs_leaf_data(right) +
>  		     BTRFS_LEAF_DATA_SIZE(root->fs_info) - push_space,
> -		     btrfs_leaf_data(left) + leaf_data_end(root, left),
> +		     btrfs_leaf_data(left) + leaf_data_end(fs_info, left),
>  		     push_space);
>  
>  	memmove_extent_buffer(right, btrfs_item_nr_offset(push_items),
> @@ -1887,7 +1887,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
>  		     btrfs_item_offset_nr(right, push_items -1);
>  
>  	copy_extent_buffer(left, right, btrfs_leaf_data(left) +
> -		     leaf_data_end(root, left) - push_space,
> +		     leaf_data_end(fs_info, left) - push_space,
>  		     btrfs_leaf_data(right) +
>  		     btrfs_item_offset_nr(right, push_items - 1),
>  		     push_space);
> @@ -1914,12 +1914,13 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
>  
>  	if (push_items < right_nritems) {
>  		push_space = btrfs_item_offset_nr(right, push_items - 1) -
> -						  leaf_data_end(root, right);
> +						  leaf_data_end(fs_info, right);
>  		memmove_extent_buffer(right, btrfs_leaf_data(right) +
>  				      BTRFS_LEAF_DATA_SIZE(root->fs_info) -
>  				      push_space,
>  				      btrfs_leaf_data(right) +
> -				      leaf_data_end(root, right), push_space);
> +				      leaf_data_end(fs_info, right),
> +				      push_space);
>  
>  		memmove_extent_buffer(right, btrfs_item_nr_offset(0),
>  			      btrfs_item_nr_offset(push_items),
> @@ -1978,7 +1979,8 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
>  
>  	nritems = nritems - mid;
>  	btrfs_set_header_nritems(right, nritems);
> -	data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(root, l);
> +	data_copy_size = btrfs_item_end_nr(l, mid) -
> +		leaf_data_end(root->fs_info, l);
>  
>  	copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
>  			   btrfs_item_nr_offset(mid),
> @@ -1988,7 +1990,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
>  		     btrfs_leaf_data(right) +
>  		     BTRFS_LEAF_DATA_SIZE(root->fs_info) -
>  		     data_copy_size, btrfs_leaf_data(l) +
> -		     leaf_data_end(root, l), data_copy_size);
> +		     leaf_data_end(root->fs_info, l), data_copy_size);
>  
>  	rt_data_off = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
>  		      btrfs_item_end_nr(l, mid);
> @@ -2326,7 +2328,7 @@ int btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path,
>  		return 0;
>  
>  	nritems = btrfs_header_nritems(leaf);
> -	data_end = leaf_data_end(root, leaf);
> +	data_end = leaf_data_end(root->fs_info, leaf);
>  
>  	old_data_start = btrfs_item_offset_nr(leaf, slot);
>  
> @@ -2415,7 +2417,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
>  	leaf = path->nodes[0];
>  
>  	nritems = btrfs_header_nritems(leaf);
> -	data_end = leaf_data_end(root, leaf);
> +	data_end = leaf_data_end(root->fs_info, leaf);
>  
>  	if (btrfs_leaf_free_space(root, leaf) < data_size) {
>  		btrfs_print_leaf(root, leaf);
> @@ -2501,7 +2503,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
>  	leaf = path->nodes[0];
>  
>  	nritems = btrfs_header_nritems(leaf);
> -	data_end = leaf_data_end(root, leaf);
> +	data_end = leaf_data_end(root->fs_info, leaf);
>  
>  	if (btrfs_leaf_free_space(root, leaf) < total_size) {
>  		btrfs_print_leaf(root, leaf);
> @@ -2692,7 +2694,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
>  	nritems = btrfs_header_nritems(leaf);
>  
>  	if (slot + nr != nritems) {
> -		int data_end = leaf_data_end(root, leaf);
> +		int data_end = leaf_data_end(root->fs_info, leaf);
>  
>  		memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
>  			      data_end + dsize,
> 


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 520 bytes --]

Re: [PATCH v2 7/7] btrfs-progs: Cleanup use of root in leaf_data_end

[David Sterba]

On Tue, Jan 30, 2018 at 03:36:28PM +0800, Qu Wenruo wrote:
> On 2018年01月26日 15:26, Gu Jinxiang wrote:
> > In function leaf_data_end, root is just used to get fs_info,
> > so change the parameter of this function from btrfs_root to
> > btrfs_fs_info.
> > And also make it consistent with kernel.
> > 
> > Signed-off-by: Gu Jinxiang <gujx@cn.fujitsu.com>
> > ---
> >  ctree.c | 32 +++++++++++++++++---------------
> >  1 file changed, 17 insertions(+), 15 deletions(-)
> > 
> > diff --git a/ctree.c b/ctree.c
> > index 11d207e7..2417483d 100644
> > --- a/ctree.c
> > +++ b/ctree.c
> > @@ -410,12 +410,12 @@ static int btrfs_comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
> >   * this returns the address of the start of the last item,
> >   * which is the stop of the leaf data stack
> >   */
> > -static inline unsigned int leaf_data_end(struct btrfs_root *root,
> > -					 struct extent_buffer *leaf)
> > +static inline unsigned int leaf_data_end(const struct btrfs_fs_info *fs_info,
> > +					 const struct extent_buffer *leaf)
> 
> Here leaf is const, which is fine.
> 
> >  {
> >  	u32 nr = btrfs_header_nritems(leaf);
> >  	if (nr == 0)
> > -		return BTRFS_LEAF_DATA_SIZE(root->fs_info);
> > +		return BTRFS_LEAF_DATA_SIZE(fs_info);
> >  	return btrfs_item_offset_nr(leaf, nr - 1);
> 
> But btrfs_item_offset_nr() doesn't have const prefix for leaf.
> Leaving the following warning:
> 
> passing argument 1 of ‘btrfs_item_offset_nr’ discards ‘const’ qualifier
> from pointer target type [-Wdiscarded-qualifiers]
>   return btrfs_item_offset_nr(leaf, nr - 1);
>                               ^~~~

I don't want to add the warning, so I'll skip this patch for now. The
constification of arguments will likely propagate to more helpers so
it's not a trivial fix to this patch.

Gu Jinxiang, please fix the warning and resend with possibly more
preparatory cleanups if necessary. Thanks.

Re: [PATCH v2 0/7] btrfs-progs: Do some clean up to be consistent

[David Sterba]

On Fri, Jan 26, 2018 at 04:18:55PM +0800, Qu Wenruo wrote:
> 
> 
> On 2018年01月26日 15:25, Gu Jinxiang wrote:
> > Patch 1~4 and 7: clean up use of btrfs_root.
> > Patch 5: remove redundancy value assignment.
> > Patch 6: remove no longer be used function define.
> 
> Overall it looks good, just one small nitpick, which should not need
> another update.
> 
> > Changelog:
> > v2->v1:
> > Patch 2,4: To be consistent with kernel, change macro to inline function.
> > Patch 3:
> > 	Change macro to inline function to be consistent with kernel.
> > 	And change the function body to match kernel.
> > 
> > Gu Jinxiang (7):
> >   btrfs-progs: Use fs_info instead of root for BTRFS_LEAF_DATA_SIZE
> >   btrfs-progs: Use fs_info instead of root for BTRFS_NODEPTRS_PER_BLOCK
> >   btrfs-progs: Use fs_info instead of root for
> >     BTRFS_MAX_INLINE_DATA_SIZE
> 
> Not only this patch modified the parameter but also sync the code with
> kernel.
> It would be better to mention it in commit message, but anyway, just a
> small nitpick, nothing to worry about.

I've updated the changelogs so it mentions the kernel code sync.

Patches 1-6 applied to devel as they're fairly independend of the other
patchsets waiting fo merge.