[PATCH 00/13] btrfs-progs: cleanup btrfs_item* accessors

[PATCH 00/13] btrfs-progs: cleanup btrfs_item* accessors

[Josef Bacik]

Hello,

This is prep work for me adjusting the size of the btrfs_header.  This is a
mirror of the work that was already merged into the kernel.  The only extra work
that I've done here is add some compiler switches that I used to help me catch
all the different users of the helpers to make sure I didn't make any mistakes.
Thanks,

Josef

Josef Bacik (13):
  btrfs-progs: turn on more compiler warnings and use -Wall
  btrfs-progs: store LEAF_DATA_SIZE in the mkfs_config
  btrfs-progs: store BTRFS_LEAF_DATA_SIZE in the fs_info
  btrfs-progs: convert: use cfg->leaf_data_size
  btrfs-progs: reduce usage of __BTRFS_LEAF_DATA_SIZE
  btrfs-progs: btrfs_item_size_nr/btrfs_item_offset_nr everywhere
  btrfs-progs: add btrfs_set_item_*_nr() helpers
  btrfs-progs: change btrfs_file_extent_inline_item_len to take a slot
  btrfs-progs: rename btrfs_item_end_nr to btrfs_item_end
  btrfs-progs: remove the _nr from the item helpers
  btrfs-progs: replace btrfs_item_nr_offset(0)
  btrfs-progs: rework the btrfs_node accessors to match the item
    accessors
  btrfs-progs: make all of the item/key_ptr offset helpers take an eb

 Makefile                    |   3 +
 btrfs-corrupt-block.c       |  17 ++-
 check/main.c                |  90 +++++++--------
 check/mode-common.c         |  12 +-
 check/mode-lowmem.c         |  37 +++---
 check/qgroup-verify.c       |   2 +-
 cmds/inspect-tree-stats.c   |   3 +-
 cmds/rescue-chunk-recover.c |   4 +-
 cmds/restore.c              |   7 +-
 convert/common.c            |  33 +++---
 convert/main.c              |   1 +
 image/main.c                |  31 +++--
 image/sanitize.c            |   4 +-
 kernel-shared/backref.c     |  10 +-
 kernel-shared/ctree.c       | 219 ++++++++++++++++--------------------
 kernel-shared/ctree.h       | 110 ++++++++----------
 kernel-shared/dir-item.c    |  10 +-
 kernel-shared/disk-io.c     |   1 +
 kernel-shared/extent-tree.c |  12 +-
 kernel-shared/file-item.c   |  12 +-
 kernel-shared/inode-item.c  |  14 +--
 kernel-shared/print-tree.c  |  29 +++--
 kernel-shared/root-tree.c   |   2 +-
 kernel-shared/uuid-tree.c   |   4 +-
 kernel-shared/volumes.c     |  10 +-
 mkfs/common.c               |  52 ++++-----
 mkfs/common.h               |   1 +
 mkfs/main.c                 |   1 +
 28 files changed, 333 insertions(+), 398 deletions(-)

-- 
2.26.3

[PATCH 01/13] btrfs-progs: turn on more compiler warnings and use -Wall

[Josef Bacik]

In converting some of our helpers to take new args I would miss some
locations because we don't stop on any warning, and I would miss the
warning in the scrollback.  Fix this by stopping compiling on any error
and turn on the fancy compiler checks.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Makefile b/Makefile
index af4908f9..e0921ca3 100644
--- a/Makefile
+++ b/Makefile
@@ -93,6 +93,9 @@ CFLAGS = $(SUBST_CFLAGS) \
 	 -D_XOPEN_SOURCE=700  \
 	 -fno-strict-aliasing \
 	 -fPIC \
+	 -Wall \
+	 -Wunused-but-set-parameter \
+	 -Werror \
 	 -I$(TOPDIR) \
 	 -I$(TOPDIR)/libbtrfsutil \
 	 $(CRYPTO_CFLAGS) \
-- 
2.26.3

[PATCH 02/13] btrfs-progs: store LEAF_DATA_SIZE in the mkfs_config

[Josef Bacik]

We use __BTRFS_LEAF_DATA_SIZE() in a few places for mkfs.  With extent
tree v2 we'll be increasing the size of btrfs_header, so it'll be kind
of annoying to add flags to all callers of __BTRFS_LEAF_DATA_SIZE, so
simply calculate it once and put it in the mkfs_config and use that.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 mkfs/common.c | 9 ++++-----
 mkfs/common.h | 1 +
 mkfs/main.c   | 1 +
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/mkfs/common.c b/mkfs/common.c
index 9608d27f..aee4b9fb 100644
--- a/mkfs/common.c
+++ b/mkfs/common.c
@@ -93,7 +93,7 @@ static int btrfs_create_tree_root(int fd, struct btrfs_mkfs_config *cfg,
 
 	btrfs_set_disk_key_type(&disk_key, BTRFS_ROOT_ITEM_KEY);
 	btrfs_set_disk_key_offset(&disk_key, 0);
-	itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - sizeof(root_item);
+	itemoff = cfg->leaf_data_size - sizeof(root_item);
 
 	for (i = 0; i < blocks_nr; i++) {
 		blk = blocks[i];
@@ -148,7 +148,7 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg,
 {
 	struct btrfs_free_space_info *info;
 	struct btrfs_disk_key disk_key;
-	int itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
+	int itemoff = cfg->leaf_data_size;
 	int nritems = 0;
 	int ret;
 
@@ -427,7 +427,7 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 		cfg->nodesize - sizeof(struct btrfs_header));
 	nritems = 0;
 	item_size = sizeof(*dev_item);
-	itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - item_size;
+	itemoff = cfg->leaf_data_size - item_size;
 
 	/* first device 1 (there is no device 0) */
 	btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
@@ -515,8 +515,7 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	memset(buf->data + sizeof(struct btrfs_header), 0,
 		cfg->nodesize - sizeof(struct btrfs_header));
 	nritems = 0;
-	itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) -
-		sizeof(struct btrfs_dev_extent);
+	itemoff = cfg->leaf_data_size - sizeof(struct btrfs_dev_extent);
 
 	btrfs_set_disk_key_objectid(&disk_key, 1);
 	btrfs_set_disk_key_offset(&disk_key, system_group_offset);
diff --git a/mkfs/common.h b/mkfs/common.h
index 66c9d9d0..428cd366 100644
--- a/mkfs/common.h
+++ b/mkfs/common.h
@@ -76,6 +76,7 @@ struct btrfs_mkfs_config {
 	u32 nodesize;
 	u32 sectorsize;
 	u32 stripesize;
+	u32 leaf_data_size;
 	/* Bitfield of incompat features, BTRFS_FEATURE_INCOMPAT_* */
 	u64 features;
 	/* Bitfield of BTRFS_RUNTIME_FEATURE_* */
diff --git a/mkfs/main.c b/mkfs/main.c
index f9e8be74..3dd06979 100644
--- a/mkfs/main.c
+++ b/mkfs/main.c
@@ -1413,6 +1413,7 @@ int BOX_MAIN(mkfs)(int argc, char **argv)
 	mkfs_cfg.features = features;
 	mkfs_cfg.runtime_features = runtime_features;
 	mkfs_cfg.csum_type = csum_type;
+	mkfs_cfg.leaf_data_size = __BTRFS_LEAF_DATA_SIZE(nodesize);
 	if (zoned)
 		mkfs_cfg.zone_size = zone_size(file);
 	else
-- 
2.26.3

[PATCH 03/13] btrfs-progs: store BTRFS_LEAF_DATA_SIZE in the fs_info

[Josef Bacik]

This is going to be a different value based on the incompat settings of
the file system, just store this in the fs_info instead of calculating
it every time.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 kernel-shared/ctree.h   | 4 ++--
 kernel-shared/disk-io.c | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index de5452f2..31169f33 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -363,8 +363,7 @@ static inline u32 __BTRFS_LEAF_DATA_SIZE(u32 nodesize)
 	return nodesize - sizeof(struct btrfs_header);
 }
 
-#define BTRFS_LEAF_DATA_SIZE(fs_info) \
-				(__BTRFS_LEAF_DATA_SIZE(fs_info->nodesize))
+#define BTRFS_LEAF_DATA_SIZE(fs_info) (fs_info->leaf_data_size)
 
 /*
  * this is a very generous portion of the super block, giving us
@@ -1271,6 +1270,7 @@ struct btrfs_fs_info {
 	u32 nodesize;
 	u32 sectorsize;
 	u32 stripesize;
+	u32 leaf_data_size;
 	u16 csum_type;
 	u16 csum_size;
 
diff --git a/kernel-shared/disk-io.c b/kernel-shared/disk-io.c
index f83ba884..0434ed7d 100644
--- a/kernel-shared/disk-io.c
+++ b/kernel-shared/disk-io.c
@@ -1552,6 +1552,7 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, struct open_ctree_flags *oc
 	fs_info->stripesize = btrfs_super_stripesize(disk_super);
 	fs_info->csum_type = btrfs_super_csum_type(disk_super);
 	fs_info->csum_size = btrfs_super_csum_size(disk_super);
+	fs_info->leaf_data_size = __BTRFS_LEAF_DATA_SIZE(fs_info->nodesize);
 
 	ret = btrfs_check_fs_compatibility(fs_info->super_copy, flags);
 	if (ret)
-- 
2.26.3

[PATCH 04/13] btrfs-progs: convert: use cfg->leaf_data_size

[Josef Bacik]

The mkfs_config can hold the BTRFS_LEAF_DATA_SIZE, so calculate this at
config creation time and then use that value throughout convert instead
of calling __BTRFS_LEAF_DATA_SIZE.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 convert/common.c | 8 ++++----
 convert/main.c   | 1 +
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/convert/common.c b/convert/common.c
index 00a7e553..356c2b4c 100644
--- a/convert/common.c
+++ b/convert/common.c
@@ -238,7 +238,7 @@ static int setup_temp_root_tree(int fd, struct btrfs_mkfs_config *cfg,
 				u64 dev_bytenr, u64 fs_bytenr, u64 csum_bytenr)
 {
 	struct extent_buffer *buf = NULL;
-	u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
+	u32 itemoff = cfg->leaf_data_size;
 	int slot = 0;
 	int ret;
 
@@ -419,7 +419,7 @@ static int setup_temp_chunk_tree(int fd, struct btrfs_mkfs_config *cfg,
 				 u64 chunk_bytenr)
 {
 	struct extent_buffer *buf = NULL;
-	u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
+	u32 itemoff = cfg->leaf_data_size;
 	int slot = 0;
 	int ret;
 
@@ -490,7 +490,7 @@ static int setup_temp_dev_tree(int fd, struct btrfs_mkfs_config *cfg,
 			       u64 dev_bytenr)
 {
 	struct extent_buffer *buf = NULL;
-	u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
+	u32 itemoff = cfg->leaf_data_size;
 	int slot = 0;
 	int ret;
 
@@ -688,7 +688,7 @@ static int setup_temp_extent_tree(int fd, struct btrfs_mkfs_config *cfg,
 				  u64 fs_bytenr, u64 csum_bytenr)
 {
 	struct extent_buffer *buf = NULL;
-	u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
+	u32 itemoff = cfg->leaf_data_size;
 	int slot = 0;
 	int ret;
 
diff --git a/convert/main.c b/convert/main.c
index 333d5be1..b72d1e51 100644
--- a/convert/main.c
+++ b/convert/main.c
@@ -1228,6 +1228,7 @@ static int do_convert(const char *devname, u32 convert_flags, u32 nodesize,
 	mkfs_cfg.sectorsize = blocksize;
 	mkfs_cfg.stripesize = blocksize;
 	mkfs_cfg.features = features;
+	mkfs_cfg.leaf_data_size = __BTRFS_LEAF_DATA_SIZE(nodesize);
 
 	printf("Create initial btrfs filesystem\n");
 	ret = make_convert_btrfs(fd, &mkfs_cfg, &cctx);
-- 
2.26.3

[PATCH 05/13] btrfs-progs: reduce usage of __BTRFS_LEAF_DATA_SIZE

[Josef Bacik]

This helper only takes the nodesize, but in the future it'll take a bool
to indicate if we're extent tree v2.  The remaining users are all where
we only have extent_buffer, but we should always have a valid
eb->fs_info in these cases, so add BUG_ON()'s for the !eb->fs_info case
and then convert these callers to use BTRFS_LEAF_DATA_SIZE which takes
the fs_info.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 kernel-shared/ctree.c      | 5 +++--
 kernel-shared/ctree.h      | 5 +++--
 kernel-shared/print-tree.c | 2 +-
 mkfs/common.c              | 2 +-
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
index 950923d0..10b22b2c 100644
--- a/kernel-shared/ctree.c
+++ b/kernel-shared/ctree.c
@@ -1949,8 +1949,9 @@ int btrfs_leaf_free_space(struct extent_buffer *leaf)
 	u32 leaf_data_size;
 	int ret;
 
-	BUG_ON(leaf->fs_info && leaf->fs_info->nodesize != leaf->len);
-	leaf_data_size = __BTRFS_LEAF_DATA_SIZE(leaf->len);
+	BUG_ON(!leaf->fs_info);
+	BUG_ON(leaf->fs_info->nodesize != leaf->len);
+	leaf_data_size = BTRFS_LEAF_DATA_SIZE(leaf->fs_info);
 	ret = leaf_data_size - leaf_space_used(leaf, 0 ,nritems);
 	if (ret < 0) {
 		printk("leaf free space ret %d, leaf data size %u, used %d nritems %d\n",
diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index 31169f33..d9677bce 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -1328,8 +1328,9 @@ static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
 
 static inline u32 BTRFS_NODEPTRS_PER_EXTENT_BUFFER(const struct extent_buffer *eb)
 {
-	BUG_ON(eb->fs_info && eb->fs_info->nodesize != eb->len);
-	return __BTRFS_LEAF_DATA_SIZE(eb->len) / sizeof(struct btrfs_key_ptr);
+	BUG_ON(!eb->fs_info);
+	BUG_ON(eb->fs_info->nodesize != eb->len);
+	return BTRFS_LEAF_DATA_SIZE(eb->fs_info) / sizeof(struct btrfs_key_ptr);
 }
 
 #define BTRFS_FILE_EXTENT_INLINE_DATA_START		\
diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c
index bd75ae51..7308599f 100644
--- a/kernel-shared/print-tree.c
+++ b/kernel-shared/print-tree.c
@@ -1288,7 +1288,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 {
 	struct btrfs_item *item;
 	struct btrfs_disk_key disk_key;
-	u32 leaf_data_size = __BTRFS_LEAF_DATA_SIZE(eb->len);
+	u32 leaf_data_size = BTRFS_LEAF_DATA_SIZE(eb->fs_info);
 	u32 i;
 	u32 nr;
 	const bool print_csum_items = (mode & BTRFS_PRINT_TREE_CSUM_ITEMS);
diff --git a/mkfs/common.c b/mkfs/common.c
index aee4b9fb..f3e689cb 100644
--- a/mkfs/common.c
+++ b/mkfs/common.c
@@ -326,7 +326,7 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	memset(buf->data + sizeof(struct btrfs_header), 0,
 		cfg->nodesize - sizeof(struct btrfs_header));
 	nritems = 0;
-	itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
+	itemoff = cfg->leaf_data_size;
 	for (i = 0; i < blocks_nr; i++) {
 		blk = blocks[i];
 
-- 
2.26.3

[PATCH 06/13] btrfs-progs: btrfs_item_size_nr/btrfs_item_offset_nr everywhere

[Josef Bacik]

We have this pattern in a lot of places

	item = btrfs_item_nr(slot);
	btrfs_item_size(leaf, item);
	btrfs_item_offset(leaf, item);

when we could simply use

	btrfs_item_size_nr(leaf, slot);
	btrfs_item_offset_nr(leaf, slot);

Fix all callers of btrfs_item_size() and btrfs_item_offset() to use the
_nr variation of the helpers.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 check/main.c               |  8 ++++----
 image/main.c               |  2 +-
 kernel-shared/backref.c    |  4 +---
 kernel-shared/ctree.c      | 24 ++++++++++++------------
 kernel-shared/dir-item.c   |  6 ++----
 kernel-shared/inode-item.c |  4 +---
 kernel-shared/print-tree.c |  6 +++---
 7 files changed, 24 insertions(+), 30 deletions(-)

diff --git a/check/main.c b/check/main.c
index e9ac94cc..76eb8d54 100644
--- a/check/main.c
+++ b/check/main.c
@@ -4222,10 +4222,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
 		item2 = btrfs_item_nr(slot + 1);
 		btrfs_item_key_to_cpu(buf, &k1, slot);
 		btrfs_item_key_to_cpu(buf, &k2, slot + 1);
-		item1_offset = btrfs_item_offset(buf, item1);
-		item2_offset = btrfs_item_offset(buf, item2);
-		item1_size = btrfs_item_size(buf, item1);
-		item2_size = btrfs_item_size(buf, item2);
+		item1_offset = btrfs_item_offset_nr(buf, slot);
+		item2_offset = btrfs_item_offset_nr(buf, slot + 1);
+		item1_size = btrfs_item_size_nr(buf, slot);
+		item2_size = btrfs_item_size_nr(buf, slot + 1);
 
 		item1_data = malloc(item1_size);
 		if (!item1_data)
diff --git a/image/main.c b/image/main.c
index 3125163d..e953d981 100644
--- a/image/main.c
+++ b/image/main.c
@@ -1239,7 +1239,7 @@ static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
 		item = btrfs_item_nr(i);
-		ioff = btrfs_item_offset(eb, item);
+		ioff = btrfs_item_offset_nr(eb, i);
 		btrfs_set_item_offset(eb, item, ioff + size_diff);
 	}
 
diff --git a/kernel-shared/backref.c b/kernel-shared/backref.c
index f1a638ed..327599b7 100644
--- a/kernel-shared/backref.c
+++ b/kernel-shared/backref.c
@@ -1417,7 +1417,6 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
 	u64 parent = 0;
 	int found = 0;
 	struct extent_buffer *eb;
-	struct btrfs_item *item;
 	struct btrfs_inode_ref *iref;
 	struct btrfs_key found_key;
 
@@ -1442,10 +1441,9 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
 		extent_buffer_get(eb);
 		btrfs_release_path(path);
 
-		item = btrfs_item_nr(slot);
 		iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
 
-		for (cur = 0; cur < btrfs_item_size(eb, item); cur += len) {
+		for (cur = 0; cur < btrfs_item_size_nr(eb, slot); cur += len) {
 			name_len = btrfs_inode_ref_name_len(eb, iref);
 			/* path must be released before calling iterate()! */
 			pr_debug("following ref at offset %u for inode %llu in "
diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
index 10b22b2c..fc661aeb 100644
--- a/kernel-shared/ctree.c
+++ b/kernel-shared/ctree.c
@@ -2041,7 +2041,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(*item);
 
-		this_item_size = btrfs_item_size(left, item);
+		this_item_size = btrfs_item_size_nr(left, i);
 		if (this_item_size + sizeof(*item) + push_space > free_space)
 			break;
 		push_items++;
@@ -2092,7 +2092,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_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);
+		push_space -= btrfs_item_size_nr(right, i);
 		btrfs_set_item_offset(right, item, push_space);
 	}
 
@@ -2187,7 +2187,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(*item);
 
-		this_item_size = btrfs_item_size(right, item);
+		this_item_size = btrfs_item_size_nr(right, i);
 		if (this_item_size + sizeof(*item) + push_space > free_space)
 			break;
 
@@ -2224,7 +2224,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 		u32 ioff;
 
 		item = btrfs_item_nr(i);
-		ioff = btrfs_item_offset(left, item);
+		ioff = btrfs_item_offset_nr(left, i);
 		btrfs_set_item_offset(left, item,
 		      ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 			      old_left_item_size));
@@ -2256,7 +2256,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_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);
+		push_space = push_space - btrfs_item_size_nr(right, i);
 		btrfs_set_item_offset(right, item, push_space);
 	}
 
@@ -2319,7 +2319,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 
 	for (i = 0; i < nritems; i++) {
 		struct btrfs_item *item = btrfs_item_nr(i);
-		u32 ioff = btrfs_item_offset(right, item);
+		u32 ioff = btrfs_item_offset_nr(right, i);
 		btrfs_set_item_offset(right, item, ioff + rt_data_off);
 	}
 
@@ -2574,8 +2574,8 @@ int btrfs_split_item(struct btrfs_trans_handle *trans,
 
 split:
 	item = btrfs_item_nr(path->slots[0]);
-	orig_offset = btrfs_item_offset(leaf, item);
-	item_size = btrfs_item_size(leaf, item);
+	orig_offset = btrfs_item_offset_nr(leaf, path->slots[0]);
+	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
 
 
 	buf = kmalloc(item_size, GFP_NOFS);
@@ -2666,7 +2666,7 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
 		item = btrfs_item_nr(i);
-		ioff = btrfs_item_offset(leaf, item);
+		ioff = btrfs_item_offset_nr(leaf, i);
 		btrfs_set_item_offset(leaf, item, ioff + size_diff);
 	}
 
@@ -2762,7 +2762,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
 		item = btrfs_item_nr(i);
-		ioff = btrfs_item_offset(leaf, item);
+		ioff = btrfs_item_offset_nr(leaf, i);
 		btrfs_set_item_offset(leaf, item, ioff - data_size);
 	}
 
@@ -2854,7 +2854,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 			u32 ioff;
 
 			item = btrfs_item_nr(i);
-			ioff = btrfs_item_offset(leaf, item);
+			ioff = btrfs_item_offset_nr(leaf, i);
 			btrfs_set_item_offset(leaf, item, ioff - total_data);
 		}
 
@@ -3029,7 +3029,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 			u32 ioff;
 
 			item = btrfs_item_nr(i);
-			ioff = btrfs_item_offset(leaf, item);
+			ioff = btrfs_item_offset_nr(leaf, i);
 			btrfs_set_item_offset(leaf, item, ioff + dsize);
 		}
 
diff --git a/kernel-shared/dir-item.c b/kernel-shared/dir-item.c
index 590b79a9..729d4308 100644
--- a/kernel-shared/dir-item.c
+++ b/kernel-shared/dir-item.c
@@ -32,7 +32,6 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
 {
 	int ret;
 	char *ptr;
-	struct btrfs_item *item;
 	struct extent_buffer *leaf;
 
 	ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
@@ -48,10 +47,9 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
 		return ERR_PTR(ret);
 	WARN_ON(ret > 0);
 	leaf = path->nodes[0];
-	item = btrfs_item_nr(path->slots[0]);
 	ptr = btrfs_item_ptr(leaf, path->slots[0], char);
-	BUG_ON(data_size > btrfs_item_size(leaf, item));
-	ptr += btrfs_item_size(leaf, item) - data_size;
+	BUG_ON(data_size > btrfs_item_size_nr(leaf, path->slots[0]));
+	ptr += btrfs_item_size_nr(leaf, path->slots[0]) - data_size;
 	return (struct btrfs_dir_item *)ptr;
 }
 
diff --git a/kernel-shared/inode-item.c b/kernel-shared/inode-item.c
index 67173eb1..7ca75f6d 100644
--- a/kernel-shared/inode-item.c
+++ b/kernel-shared/inode-item.c
@@ -336,7 +336,6 @@ int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
 	struct btrfs_path *path;
 	struct btrfs_key key;
 	struct extent_buffer *leaf;
-	struct btrfs_item *item;
 
 	key.objectid = inode_objectid;
 	key.type = BTRFS_INODE_EXTREF_KEY;
@@ -361,9 +360,8 @@ int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
 		goto out;
 
 	leaf = path->nodes[0];
-	item = btrfs_item_nr(path->slots[0]);
 	ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);
-	ptr += btrfs_item_size(leaf, item) - ins_len;
+	ptr += btrfs_item_size_nr(leaf, path->slots[0]) - ins_len;
 	extref = (struct btrfs_inode_extref *)ptr;
 
 	btrfs_set_inode_extref_name_len(path->nodes[0], extref, name_len);
diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c
index 7308599f..6e601779 100644
--- a/kernel-shared/print-tree.c
+++ b/kernel-shared/print-tree.c
@@ -1320,7 +1320,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 			break;
 		}
 		item = btrfs_item_nr(i);
-		item_size = btrfs_item_size(eb, item);
+		item_size = btrfs_item_size_nr(eb, i);
 		/* Untyped extraction of slot from btrfs_item_ptr */
 		ptr = btrfs_item_ptr(eb, i, void*);
 
@@ -1332,8 +1332,8 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 		printf("\titem %u ", i);
 		btrfs_print_key(&disk_key);
 		printf(" itemoff %u itemsize %u\n",
-			btrfs_item_offset(eb, item),
-			btrfs_item_size(eb, item));
+			btrfs_item_offset_nr(eb, i),
+			btrfs_item_size_nr(eb, i));
 
 		if (type == 0 && objectid == BTRFS_FREE_SPACE_OBJECTID)
 			print_free_space_header(eb, i);
-- 
2.26.3

[PATCH 07/13] btrfs-progs: add btrfs_set_item_*_nr() helpers

[Josef Bacik]

We have a lot of the following patterns

	item = btrfs_item_nr(nr);
	btrfs_set_item_*(eb, item, val);

	btrfs_set_item_*(eb, btrfs_item_nr(nr), val);

in a lot of places in our code.  Instead add _nr variations of these
helpers and convert all of the users to this new helper.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 btrfs-corrupt-block.c |  5 ++-
 check/main.c          | 14 +++------
 convert/common.c      | 25 ++++++++-------
 image/main.c          |  7 ++---
 kernel-shared/ctree.c | 72 ++++++++++++++-----------------------------
 kernel-shared/ctree.h | 12 ++++++++
 mkfs/common.c         | 41 +++++++++++-------------
 7 files changed, 74 insertions(+), 102 deletions(-)

diff --git a/btrfs-corrupt-block.c b/btrfs-corrupt-block.c
index 866c863e..57a4e271 100644
--- a/btrfs-corrupt-block.c
+++ b/btrfs-corrupt-block.c
@@ -838,7 +838,7 @@ static void shift_items(struct btrfs_root *root, struct extent_buffer *eb)
 	for (i = nritems - 1; i >= slot; i--) {
 		u32 offset = btrfs_item_offset_nr(eb, i);
 		offset -= shift_space;
-		btrfs_set_item_offset(eb, btrfs_item_nr(i), offset);
+		btrfs_set_item_offset_nr(eb, i, offset);
 	}
 }
 
@@ -980,8 +980,7 @@ static int corrupt_btrfs_item(struct btrfs_root *root, struct btrfs_key *key,
 	case BTRFS_ITEM_OFFSET:
 		orig = btrfs_item_offset_nr(path->nodes[0], path->slots[0]);
 		bogus = generate_u32(orig);
-		btrfs_set_item_offset(path->nodes[0],
-				      btrfs_item_nr(path->slots[0]), bogus);
+		btrfs_set_item_offset_nr(path->nodes[0], path->slots[0], bogus);
 		break;
 	default:
 		ret = -EINVAL;
diff --git a/check/main.c b/check/main.c
index 76eb8d54..0bc42de7 100644
--- a/check/main.c
+++ b/check/main.c
@@ -4213,13 +4213,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
 			btrfs_fixup_low_keys(path, &key, btrfs_header_level(buf) + 1);
 		}
 	} else {
-		struct btrfs_item *item1, *item2;
 		struct btrfs_key k1, k2;
 		char *item1_data, *item2_data;
 		u32 item1_offset, item2_offset, item1_size, item2_size;
 
-		item1 = btrfs_item_nr(slot);
-		item2 = btrfs_item_nr(slot + 1);
 		btrfs_item_key_to_cpu(buf, &k1, slot);
 		btrfs_item_key_to_cpu(buf, &k2, slot + 1);
 		item1_offset = btrfs_item_offset_nr(buf, slot);
@@ -4244,10 +4241,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
 		free(item1_data);
 		free(item2_data);
 
-		btrfs_set_item_offset(buf, item1, item2_offset);
-		btrfs_set_item_offset(buf, item2, item1_offset);
-		btrfs_set_item_size(buf, item1, item2_size);
-		btrfs_set_item_size(buf, item2, item1_size);
+		btrfs_set_item_offset_nr(buf, slot, item2_offset);
+		btrfs_set_item_offset_nr(buf, slot + 1, item1_offset);
+		btrfs_set_item_size_nr(buf, slot, item2_size);
+		btrfs_set_item_size_nr(buf, slot + 1, item1_size);
 
 		path->slots[0] = slot;
 		btrfs_set_item_key_unsafe(root, path, &k2);
@@ -4371,8 +4368,7 @@ again:
 				      btrfs_leaf_data(buf) + offset + shift,
 				      btrfs_leaf_data(buf) + offset,
 				      btrfs_item_size_nr(buf, i));
-		btrfs_set_item_offset(buf, btrfs_item_nr(i),
-				      offset + shift);
+		btrfs_set_item_offset_nr(buf, i, offset + shift);
 		btrfs_mark_buffer_dirty(buf);
 	}
 
diff --git a/convert/common.c b/convert/common.c
index 356c2b4c..38112084 100644
--- a/convert/common.c
+++ b/convert/common.c
@@ -204,8 +204,8 @@ static void insert_temp_root_item(struct extent_buffer *buf,
 	btrfs_set_disk_key_offset(&disk_key, 0);
 
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(root_item));
+	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
+	btrfs_set_item_size_nr(buf, *slot, sizeof(root_item));
 	write_extent_buffer(buf, &root_item,
 			    btrfs_item_ptr_offset(buf, *slot),
 			    sizeof(root_item));
@@ -311,8 +311,8 @@ static int insert_temp_dev_item(int fd, struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
 	btrfs_set_disk_key_offset(&disk_key, 1);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(*dev_item));
+	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
+	btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_item));
 
 	dev_item = btrfs_item_ptr(buf, *slot, struct btrfs_dev_item);
 	/* Generate device uuid */
@@ -369,9 +369,8 @@ static int insert_temp_chunk_item(int fd, struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
 	btrfs_set_disk_key_offset(&disk_key, start);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(*slot),
-			    btrfs_chunk_item_size(1));
+	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
+	btrfs_set_item_size_nr(buf, *slot, btrfs_chunk_item_size(1));
 
 	chunk = btrfs_item_ptr(buf, *slot, struct btrfs_chunk);
 	btrfs_set_chunk_length(buf, chunk, len);
@@ -472,8 +471,8 @@ static void insert_temp_dev_extent(struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, 1);
 	btrfs_set_disk_key_offset(&disk_key, start);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(*dev_extent));
+	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
+	btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_extent));
 
 	dev_extent = btrfs_item_ptr(buf, *slot, struct btrfs_dev_extent);
 	btrfs_set_dev_extent_chunk_objectid(buf, dev_extent,
@@ -604,8 +603,8 @@ static int insert_temp_extent_item(int fd, struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, bytenr);
 
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(*slot), itemsize);
+	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
+	btrfs_set_item_size_nr(buf, *slot, itemsize);
 
 	ei = btrfs_item_ptr(buf, *slot, struct btrfs_extent_item);
 	btrfs_set_extent_refs(buf, ei, 1);
@@ -670,8 +669,8 @@ static void insert_temp_block_group(struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, bytenr);
 	btrfs_set_disk_key_offset(&disk_key, len);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(bgi));
+	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
+	btrfs_set_item_size_nr(buf, *slot, sizeof(bgi));
 
 	btrfs_set_stack_block_group_flags(&bgi, flag);
 	btrfs_set_stack_block_group_used(&bgi, used);
diff --git a/image/main.c b/image/main.c
index e953d981..09f60e63 100644
--- a/image/main.c
+++ b/image/main.c
@@ -1218,7 +1218,6 @@ static struct extent_buffer *alloc_dummy_eb(u64 bytenr, u32 size)
 
 static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
 {
-	struct btrfs_item *item;
 	u32 nritems;
 	u32 old_size;
 	u32 old_data_start;
@@ -1238,16 +1237,14 @@ static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
 
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
-		item = btrfs_item_nr(i);
 		ioff = btrfs_item_offset_nr(eb, i);
-		btrfs_set_item_offset(eb, item, ioff + size_diff);
+		btrfs_set_item_offset_nr(eb, i, ioff + size_diff);
 	}
 
 	memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end + size_diff,
 			      btrfs_leaf_data(eb) + data_end,
 			      old_data_start + new_size - data_end);
-	item = btrfs_item_nr(slot);
-	btrfs_set_item_size(eb, item, new_size);
+	btrfs_set_item_size_nr(eb, slot, new_size);
 }
 
 static int fixup_chunk_tree_block(struct mdrestore_struct *mdres,
diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
index fc661aeb..81a438c8 100644
--- a/kernel-shared/ctree.c
+++ b/kernel-shared/ctree.c
@@ -1982,7 +1982,6 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	int free_space;
 	int push_space = 0;
 	int push_items = 0;
-	struct btrfs_item *item;
 	u32 left_nritems;
 	u32 nr;
 	u32 right_nritems;
@@ -2036,16 +2035,14 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 
 	i = left_nritems - 1;
 	while (i >= nr) {
-		item = btrfs_item_nr(i);
-
 		if (path->slots[0] == i)
-			push_space += data_size + sizeof(*item);
+			push_space += data_size + sizeof(struct btrfs_item);
 
 		this_item_size = btrfs_item_size_nr(left, i);
-		if (this_item_size + sizeof(*item) + push_space > free_space)
+		if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space)
 			break;
 		push_items++;
-		push_space += this_item_size + sizeof(*item);
+		push_space += this_item_size + sizeof(struct btrfs_item);
 		if (i == 0)
 			break;
 		i--;
@@ -2091,9 +2088,8 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	btrfs_set_header_nritems(right, right_nritems);
 	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_nr(right, i);
-		btrfs_set_item_offset(right, item, push_space);
+		btrfs_set_item_offset_nr(right, i, push_space);
 	}
 
 	left_nritems -= push_items;
@@ -2135,7 +2131,6 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	int free_space;
 	int push_space = 0;
 	int push_items = 0;
-	struct btrfs_item *item;
 	u32 old_left_nritems;
 	u32 right_nritems;
 	u32 nr;
@@ -2182,17 +2177,15 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 		nr = right_nritems - 1;
 
 	for (i = 0; i < nr; i++) {
-		item = btrfs_item_nr(i);
-
 		if (path->slots[0] == i)
-			push_space += data_size + sizeof(*item);
+			push_space += data_size + sizeof(struct btrfs_item);
 
 		this_item_size = btrfs_item_size_nr(right, i);
-		if (this_item_size + sizeof(*item) + push_space > free_space)
+		if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space)
 			break;
 
 		push_items++;
-		push_space += this_item_size + sizeof(*item);
+		push_space += this_item_size + sizeof(struct btrfs_item);
 	}
 
 	if (push_items == 0) {
@@ -2223,9 +2216,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
 		u32 ioff;
 
-		item = btrfs_item_nr(i);
 		ioff = btrfs_item_offset_nr(left, i);
-		btrfs_set_item_offset(left, item,
+		btrfs_set_item_offset_nr(left, i,
 		      ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 			      old_left_item_size));
 	}
@@ -2255,9 +2247,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	btrfs_set_header_nritems(right, right_nritems);
 	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_nr(right, i);
-		btrfs_set_item_offset(right, item, push_space);
+		btrfs_set_item_offset_nr(right, i, push_space);
 	}
 
 	btrfs_mark_buffer_dirty(left);
@@ -2318,9 +2309,8 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 		      btrfs_item_end_nr(l, mid);
 
 	for (i = 0; i < nritems; i++) {
-		struct btrfs_item *item = btrfs_item_nr(i);
 		u32 ioff = btrfs_item_offset_nr(right, i);
-		btrfs_set_item_offset(right, item, ioff + rt_data_off);
+		btrfs_set_item_offset_nr(right, i, ioff + rt_data_off);
 	}
 
 	btrfs_set_header_nritems(l, mid);
@@ -2537,8 +2527,6 @@ int btrfs_split_item(struct btrfs_trans_handle *trans,
 	u32 item_size;
 	struct extent_buffer *leaf;
 	struct btrfs_key orig_key;
-	struct btrfs_item *item;
-	struct btrfs_item *new_item;
 	int ret = 0;
 	int slot;
 	u32 nritems;
@@ -2573,7 +2561,6 @@ int btrfs_split_item(struct btrfs_trans_handle *trans,
 	leaf = path->nodes[0];
 
 split:
-	item = btrfs_item_nr(path->slots[0]);
 	orig_offset = btrfs_item_offset_nr(leaf, path->slots[0]);
 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
 
@@ -2598,14 +2585,12 @@ split:
 	btrfs_cpu_key_to_disk(&disk_key, new_key);
 	btrfs_set_item_key(leaf, &disk_key, slot);
 
-	new_item = btrfs_item_nr(slot);
-
-	btrfs_set_item_offset(leaf, new_item, orig_offset);
-	btrfs_set_item_size(leaf, new_item, item_size - split_offset);
+	btrfs_set_item_offset_nr(leaf, slot, orig_offset);
+	btrfs_set_item_size_nr(leaf, slot, item_size - split_offset);
 
-	btrfs_set_item_offset(leaf, item,
-			      orig_offset + item_size - split_offset);
-	btrfs_set_item_size(leaf, item, split_offset);
+	btrfs_set_item_offset_nr(leaf, path->slots[0],
+				 orig_offset + item_size - split_offset);
+	btrfs_set_item_size_nr(leaf, path->slots[0], split_offset);
 
 	btrfs_set_header_nritems(leaf, nritems + 1);
 
@@ -2634,7 +2619,6 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 	int ret = 0;
 	int slot;
 	struct extent_buffer *leaf;
-	struct btrfs_item *item;
 	u32 nritems;
 	unsigned int data_end;
 	unsigned int old_data_start;
@@ -2665,9 +2649,8 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 	/* first correct the data pointers */
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
-		item = btrfs_item_nr(i);
 		ioff = btrfs_item_offset_nr(leaf, i);
-		btrfs_set_item_offset(leaf, item, ioff + size_diff);
+		btrfs_set_item_offset_nr(leaf, i, ioff + size_diff);
 	}
 
 	/* shift the data */
@@ -2711,8 +2694,7 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 			btrfs_fixup_low_keys(path, &disk_key, 1);
 	}
 
-	item = btrfs_item_nr(slot);
-	btrfs_set_item_size(leaf, item, new_size);
+	btrfs_set_item_size_nr(leaf, slot, new_size);
 	btrfs_mark_buffer_dirty(leaf);
 
 	ret = 0;
@@ -2729,7 +2711,6 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 	int ret = 0;
 	int slot;
 	struct extent_buffer *leaf;
-	struct btrfs_item *item;
 	u32 nritems;
 	unsigned int data_end;
 	unsigned int old_data;
@@ -2761,9 +2742,8 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 	/* first correct the data pointers */
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
-		item = btrfs_item_nr(i);
 		ioff = btrfs_item_offset_nr(leaf, i);
-		btrfs_set_item_offset(leaf, item, ioff - data_size);
+		btrfs_set_item_offset_nr(leaf, i, ioff - data_size);
 	}
 
 	/* shift the data */
@@ -2773,8 +2753,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 
 	data_end = old_data;
 	old_size = btrfs_item_size_nr(leaf, slot);
-	item = btrfs_item_nr(slot);
-	btrfs_set_item_size(leaf, item, old_size + data_size);
+	btrfs_set_item_size_nr(leaf, slot, old_size + data_size);
 	btrfs_mark_buffer_dirty(leaf);
 
 	ret = 0;
@@ -2796,7 +2775,6 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 			    int nr)
 {
 	struct extent_buffer *leaf;
-	struct btrfs_item *item;
 	int ret = 0;
 	int slot;
 	int i;
@@ -2853,9 +2831,8 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 		for (i = slot; i < nritems; i++) {
 			u32 ioff;
 
-			item = btrfs_item_nr(i);
 			ioff = btrfs_item_offset_nr(leaf, i);
-			btrfs_set_item_offset(leaf, item, ioff - total_data);
+			btrfs_set_item_offset_nr(leaf, i, ioff - total_data);
 		}
 
 		/* shift the items */
@@ -2874,10 +2851,9 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 	for (i = 0; i < nr; i++) {
 		btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
 		btrfs_set_item_key(leaf, &disk_key, slot + i);
-		item = btrfs_item_nr(slot + i);
-		btrfs_set_item_offset(leaf, item, data_end - data_size[i]);
+		btrfs_set_item_offset_nr(leaf, slot + i, data_end - data_size[i]);
 		data_end -= data_size[i];
-		btrfs_set_item_size(leaf, item, data_size[i]);
+		btrfs_set_item_size_nr(leaf, slot + i, data_size[i]);
 	}
 	btrfs_set_header_nritems(leaf, nritems + nr);
 	btrfs_mark_buffer_dirty(leaf);
@@ -3001,7 +2977,6 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		    struct btrfs_path *path, int slot, int nr)
 {
 	struct extent_buffer *leaf;
-	struct btrfs_item *item;
 	int last_off;
 	int dsize = 0;
 	int ret = 0;
@@ -3028,9 +3003,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		for (i = slot + nr; i < nritems; i++) {
 			u32 ioff;
 
-			item = btrfs_item_nr(i);
 			ioff = btrfs_item_offset_nr(leaf, i);
-			btrfs_set_item_offset(leaf, item, ioff + dsize);
+			btrfs_set_item_offset_nr(leaf, i, ioff + dsize);
 		}
 
 		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index d9677bce..cda05481 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -2005,6 +2005,18 @@ static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
 	return btrfs_item_end(eb, btrfs_item_nr(nr));
 }
 
+static inline void btrfs_set_item_size_nr(struct extent_buffer *eb, int nr,
+					  u32 size)
+{
+	btrfs_set_item_size(eb, btrfs_item_nr(nr), size);
+}
+
+static inline void btrfs_set_item_offset_nr(struct extent_buffer *eb, int nr,
+					    u32 offset)
+{
+	btrfs_set_item_offset(eb, btrfs_item_nr(nr), offset);
+}
+
 static inline u32 btrfs_item_offset_nr(const struct extent_buffer *eb, int nr)
 {
 	return btrfs_item_offset(eb, btrfs_item_nr(nr));
diff --git a/mkfs/common.c b/mkfs/common.c
index f3e689cb..0ea0d114 100644
--- a/mkfs/common.c
+++ b/mkfs/common.c
@@ -104,9 +104,8 @@ static int btrfs_create_tree_root(int fd, struct btrfs_mkfs_config *cfg,
 		btrfs_set_disk_key_objectid(&disk_key,
 			reference_root_table[blk]);
 		btrfs_set_item_key(buf, &disk_key, nritems);
-		btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
-		btrfs_set_item_size(buf, btrfs_item_nr(nritems),
-				sizeof(root_item));
+		btrfs_set_item_offset_nr(buf, nritems, itemoff);
+		btrfs_set_item_size_nr(buf, nritems, sizeof(root_item));
 		if (blk == MKFS_FS_TREE) {
 			time_t now = time(NULL);
 
@@ -160,8 +159,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg,
 	btrfs_set_disk_key_offset(&disk_key, group_size);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_INFO_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(nritems), sizeof(*info));
+	btrfs_set_item_offset_nr(buf, nritems, itemoff);
+	btrfs_set_item_size_nr(buf, nritems, sizeof(*info));
 
 	info = btrfs_item_ptr(buf, nritems, struct btrfs_free_space_info);
 	btrfs_set_free_space_extent_count(buf, info, 1);
@@ -172,8 +171,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg,
 	btrfs_set_disk_key_offset(&disk_key, group_start + group_size - free_start);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_EXTENT_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0);
+	btrfs_set_item_offset_nr(buf, nritems, itemoff);
+	btrfs_set_item_size_nr(buf, nritems, 0);
 
 	nritems++;
 	btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_FREE_SPACE_TREE]);
@@ -341,8 +340,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 			btrfs_set_disk_key_offset(&disk_key, system_group_size);
 			btrfs_set_disk_key_type(&disk_key, BTRFS_BLOCK_GROUP_ITEM_KEY);
 			btrfs_set_item_key(buf, &disk_key, nritems);
-			btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
-			btrfs_set_item_size(buf, btrfs_item_nr(nritems), sizeof(*bg_item));
+			btrfs_set_item_offset_nr(buf, nritems, itemoff);
+			btrfs_set_item_size_nr(buf, nritems, sizeof(*bg_item));
 
 			bg_item = btrfs_item_ptr(buf, nritems,
 						 struct btrfs_block_group_item);
@@ -387,10 +386,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 			btrfs_set_disk_key_offset(&disk_key, cfg->nodesize);
 		}
 		btrfs_set_item_key(buf, &disk_key, nritems);
-		btrfs_set_item_offset(buf, btrfs_item_nr(nritems),
-				      itemoff);
-		btrfs_set_item_size(buf, btrfs_item_nr(nritems),
-				    item_size);
+		btrfs_set_item_offset_nr(buf, nritems, itemoff);
+		btrfs_set_item_size_nr(buf, nritems, item_size);
 		extent_item = btrfs_item_ptr(buf, nritems,
 					     struct btrfs_extent_item);
 		btrfs_set_extent_refs(buf, extent_item, 1);
@@ -405,9 +402,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 		btrfs_set_disk_key_offset(&disk_key, ref_root);
 		btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY);
 		btrfs_set_item_key(buf, &disk_key, nritems);
-		btrfs_set_item_offset(buf, btrfs_item_nr(nritems),
-				      itemoff);
-		btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0);
+		btrfs_set_item_offset_nr(buf, nritems, itemoff);
+		btrfs_set_item_size_nr(buf, nritems, 0);
 		nritems++;
 	}
 	btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_EXTENT_TREE]);
@@ -434,8 +430,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	btrfs_set_disk_key_offset(&disk_key, 1);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(nritems), item_size);
+	btrfs_set_item_offset_nr(buf, nritems, itemoff);
+	btrfs_set_item_size_nr(buf, nritems, item_size);
 
 	dev_item = btrfs_item_ptr(buf, nritems, struct btrfs_dev_item);
 	btrfs_set_device_id(buf, dev_item, 1);
@@ -465,8 +461,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	btrfs_set_disk_key_offset(&disk_key, system_group_offset);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(nritems), item_size);
+	btrfs_set_item_offset_nr(buf, nritems, itemoff);
+	btrfs_set_item_size_nr(buf, nritems, item_size);
 
 	chunk = btrfs_item_ptr(buf, nritems, struct btrfs_chunk);
 	btrfs_set_chunk_length(buf, chunk, system_group_size);
@@ -521,9 +517,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	btrfs_set_disk_key_offset(&disk_key, system_group_offset);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
-	btrfs_set_item_size(buf, btrfs_item_nr(nritems),
-			    sizeof(struct btrfs_dev_extent));
+	btrfs_set_item_offset_nr(buf, nritems, itemoff);
+	btrfs_set_item_size_nr(buf, nritems, sizeof(struct btrfs_dev_extent));
 	dev_extent = btrfs_item_ptr(buf, nritems, struct btrfs_dev_extent);
 	btrfs_set_dev_extent_chunk_tree(buf, dev_extent,
 					BTRFS_CHUNK_TREE_OBJECTID);
-- 
2.26.3

[PATCH 08/13] btrfs-progs: change btrfs_file_extent_inline_item_len to take a slot

[Josef Bacik]

This matches how the kernel does it, simply pass in the slot and fix up
btrfs_file_extent_inline_item_len to use the btrfs_item_nr() helper and
the correct define.  Fixup all the callers to use the slot now instead
of passing in the btrfs_item.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 check/main.c               | 11 ++++-------
 check/mode-lowmem.c        |  7 ++-----
 cmds/inspect-tree-stats.c  |  3 +--
 cmds/restore.c             |  5 ++---
 image/main.c               |  4 +---
 kernel-shared/ctree.h      |  6 ++----
 kernel-shared/print-tree.c |  7 ++-----
 7 files changed, 14 insertions(+), 29 deletions(-)

diff --git a/check/main.c b/check/main.c
index 0bc42de7..fb0ef8cb 100644
--- a/check/main.c
+++ b/check/main.c
@@ -1604,20 +1604,18 @@ static int process_file_extent(struct btrfs_root *root,
 	compression = btrfs_file_extent_compression(eb, fi);
 
 	if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
-		struct btrfs_item *item = btrfs_item_nr(slot);
-
 		num_bytes = btrfs_file_extent_ram_bytes(eb, fi);
 		if (num_bytes == 0)
 			rec->errors |= I_ERR_BAD_FILE_EXTENT;
 		if (compression) {
-			if (btrfs_file_extent_inline_item_len(eb, item) >
+			if (btrfs_file_extent_inline_item_len(eb, slot) >
 			    max_inline_size ||
 			    num_bytes > gfs_info->sectorsize)
 				rec->errors |= I_ERR_FILE_EXTENT_TOO_LARGE;
 		} else {
 			if (num_bytes > max_inline_size)
 				rec->errors |= I_ERR_FILE_EXTENT_TOO_LARGE;
-			if (btrfs_file_extent_inline_item_len(eb, item) !=
+			if (btrfs_file_extent_inline_item_len(eb, slot) !=
 			    num_bytes)
 				rec->errors |= I_ERR_INLINE_RAM_BYTES_WRONG;
 		}
@@ -2625,7 +2623,6 @@ static int repair_inline_ram_bytes(struct btrfs_trans_handle *trans,
 {
 	struct btrfs_key key;
 	struct btrfs_file_extent_item *fi;
-	struct btrfs_item *i;
 	u64 on_disk_item_len;
 	int ret;
 
@@ -2639,8 +2636,8 @@ static int repair_inline_ram_bytes(struct btrfs_trans_handle *trans,
 	if (ret < 0)
 		goto out;
 
-	i = btrfs_item_nr(path->slots[0]);
-	on_disk_item_len = btrfs_file_extent_inline_item_len(path->nodes[0], i);
+	on_disk_item_len = btrfs_file_extent_inline_item_len(path->nodes[0],
+							     path->slots[0]);
 	fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
 			    struct btrfs_file_extent_item);
 	btrfs_set_file_extent_ram_bytes(path->nodes[0], fi, on_disk_item_len);
diff --git a/check/mode-lowmem.c b/check/mode-lowmem.c
index 0cdf24cd..729c453a 100644
--- a/check/mode-lowmem.c
+++ b/check/mode-lowmem.c
@@ -1877,7 +1877,6 @@ static int repair_inline_ram_bytes(struct btrfs_root *root,
 	struct btrfs_trans_handle *trans;
 	struct btrfs_key key;
 	struct btrfs_file_extent_item *fi;
-	struct btrfs_item *item;
 	u32 on_disk_data_len;
 	int ret;
 	int recover_ret;
@@ -1899,9 +1898,8 @@ static int repair_inline_ram_bytes(struct btrfs_root *root,
 	if (ret < 0)
 		goto recover;
 
-	item = btrfs_item_nr(path->slots[0]);
 	on_disk_data_len = btrfs_file_extent_inline_item_len(path->nodes[0],
-			item);
+							     path->slots[0]);
 
 	fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
 			    struct btrfs_file_extent_item);
@@ -1943,7 +1941,6 @@ static int check_file_extent_inline(struct btrfs_root *root,
 	u32 max_inline_extent_size = min_t(u32, gfs_info->sectorsize - 1,
 				BTRFS_MAX_INLINE_DATA_SIZE(gfs_info));
 	struct extent_buffer *node = path->nodes[0];
-	struct btrfs_item *e = btrfs_item_nr(path->slots[0]);
 	struct btrfs_file_extent_item *fi;
 	struct btrfs_key fkey;
 	u64 extent_num_bytes;
@@ -1953,7 +1950,7 @@ static int check_file_extent_inline(struct btrfs_root *root,
 	int err = 0;
 
 	fi = btrfs_item_ptr(node, path->slots[0], struct btrfs_file_extent_item);
-	item_inline_len = btrfs_file_extent_inline_item_len(node, e);
+	item_inline_len = btrfs_file_extent_inline_item_len(node, path->slots[0]);
 	extent_num_bytes = btrfs_file_extent_ram_bytes(node, fi);
 	compressed = btrfs_file_extent_compression(node, fi);
 	btrfs_item_key_to_cpu(node, &fkey, path->slots[0]);
diff --git a/cmds/inspect-tree-stats.c b/cmds/inspect-tree-stats.c
index eeb57810..0731675c 100644
--- a/cmds/inspect-tree-stats.c
+++ b/cmds/inspect-tree-stats.c
@@ -121,8 +121,7 @@ static int walk_leaf(struct btrfs_root *root, struct btrfs_path *path,
 		fi = btrfs_item_ptr(b, i, struct btrfs_file_extent_item);
 		if (btrfs_file_extent_type(b, fi) == BTRFS_FILE_EXTENT_INLINE)
 			stat->total_inline +=
-				btrfs_file_extent_inline_item_len(b,
-							btrfs_item_nr(i));
+				btrfs_file_extent_inline_item_len(b, i);
 	}
 
 	return 0;
diff --git a/cmds/restore.c b/cmds/restore.c
index 48300ae5..bc88af70 100644
--- a/cmds/restore.c
+++ b/cmds/restore.c
@@ -302,7 +302,7 @@ static int copy_one_inline(struct btrfs_root *root, int fd,
 			    struct btrfs_file_extent_item);
 	ptr = btrfs_file_extent_inline_start(fi);
 	len = btrfs_file_extent_ram_bytes(leaf, fi);
-	inline_item_len = btrfs_file_extent_inline_item_len(leaf, btrfs_item_nr(path->slots[0]));
+	inline_item_len = btrfs_file_extent_inline_item_len(leaf, path->slots[0]);
 	read_extent_buffer(leaf, buf, ptr, inline_item_len);
 
 	compress = btrfs_file_extent_compression(leaf, fi);
@@ -834,8 +834,7 @@ static int copy_symlink(struct btrfs_root *root, struct btrfs_key *key,
 	extent_item = btrfs_item_ptr(leaf, path.slots[0],
 			struct btrfs_file_extent_item);
 
-	len = btrfs_file_extent_inline_item_len(leaf,
-			btrfs_item_nr(path.slots[0]));
+	len = btrfs_file_extent_inline_item_len(leaf, path.slots[0]);
 	if (len >= PATH_MAX) {
 		error("symlink '%s' target length %d is longer than PATH_MAX",
 				fs_name, len);
diff --git a/image/main.c b/image/main.c
index 09f60e63..5d67d282 100644
--- a/image/main.c
+++ b/image/main.c
@@ -302,7 +302,6 @@ static void zero_items(struct metadump_struct *md, u8 *dst,
 		       struct extent_buffer *src)
 {
 	struct btrfs_file_extent_item *fi;
-	struct btrfs_item *item;
 	struct btrfs_key key;
 	u32 nritems = btrfs_header_nritems(src);
 	size_t size;
@@ -310,7 +309,6 @@ static void zero_items(struct metadump_struct *md, u8 *dst,
 	int i, extent_type;
 
 	for (i = 0; i < nritems; i++) {
-		item = btrfs_item_nr(i);
 		btrfs_item_key_to_cpu(src, &key, i);
 		if (key.type == BTRFS_CSUM_ITEM_KEY) {
 			size = btrfs_item_size_nr(src, i);
@@ -334,7 +332,7 @@ static void zero_items(struct metadump_struct *md, u8 *dst,
 			continue;
 
 		ptr = btrfs_file_extent_inline_start(fi);
-		size = btrfs_file_extent_inline_item_len(src, item);
+		size = btrfs_file_extent_inline_item_len(src, i);
 		memset(dst + ptr, 0, size);
 	}
 }
diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index cda05481..7fb66049 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -2564,11 +2564,9 @@ static inline u64 btrfs_dev_stats_value(const struct extent_buffer *eb,
  * the compressed size
  */
 static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
-						    struct btrfs_item *e)
+						    int nr)
 {
-       unsigned long offset;
-       offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
-       return btrfs_item_size(eb, e) - offset;
+	return btrfs_item_size_nr(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
 }
 
 /* struct btrfs_ioctl_search_header */
diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c
index 6e601779..aff2ebc4 100644
--- a/kernel-shared/print-tree.c
+++ b/kernel-shared/print-tree.c
@@ -365,7 +365,6 @@ static const char* file_extent_type_to_str(u8 type)
 }
 
 static void print_file_extent_item(struct extent_buffer *eb,
-				   struct btrfs_item *item,
 				   int slot,
 				   struct btrfs_file_extent_item *fi)
 {
@@ -381,7 +380,7 @@ static void print_file_extent_item(struct extent_buffer *eb,
 
 	if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
 		printf("\t\tinline extent data size %u ram_bytes %llu compression %hhu (%s)\n",
-				btrfs_file_extent_inline_item_len(eb, item),
+				btrfs_file_extent_inline_item_len(eb, slot),
 				btrfs_file_extent_ram_bytes(eb, fi),
 				btrfs_file_extent_compression(eb, fi),
 				compress_str);
@@ -1286,7 +1285,6 @@ static void print_header_info(struct extent_buffer *eb, unsigned int mode)
 
 void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 {
-	struct btrfs_item *item;
 	struct btrfs_disk_key disk_key;
 	u32 leaf_data_size = BTRFS_LEAF_DATA_SIZE(eb->fs_info);
 	u32 i;
@@ -1319,7 +1317,6 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 			error("skip remaining slots");
 			break;
 		}
-		item = btrfs_item_nr(i);
 		item_size = btrfs_item_size_nr(eb, i);
 		/* Untyped extraction of slot from btrfs_item_ptr */
 		ptr = btrfs_item_ptr(eb, i, void*);
@@ -1402,7 +1399,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 			print_extent_csum(eb, item_size, offset, ptr, print_csum_items);
 			break;
 		case BTRFS_EXTENT_DATA_KEY:
-			print_file_extent_item(eb, item, i, ptr);
+			print_file_extent_item(eb, i, ptr);
 			break;
 		case BTRFS_BLOCK_GROUP_ITEM_KEY:
 			print_block_group_item(eb, ptr);
-- 
2.26.3

[PATCH 09/13] btrfs-progs: rename btrfs_item_end_nr to btrfs_item_end

[Josef Bacik]

All callers use the btrfs_item_end_nr() variation, simply drop
btrfs_item_end() and make btrfs_item_end_nr() use the _nr() variations
of the item get helpers.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 check/main.c          | 12 ++++++------
 kernel-shared/ctree.c | 20 ++++++++++----------
 kernel-shared/ctree.h | 16 +++++-----------
 3 files changed, 21 insertions(+), 27 deletions(-)

diff --git a/check/main.c b/check/main.c
index fb0ef8cb..92e1399f 100644
--- a/check/main.c
+++ b/check/main.c
@@ -4327,9 +4327,9 @@ again:
 	for (i = 0; i < btrfs_header_nritems(buf); i++) {
 		unsigned int shift = 0, offset;
 
-		if (i == 0 && btrfs_item_end_nr(buf, i) !=
+		if (i == 0 && btrfs_item_end(buf, i) !=
 		    BTRFS_LEAF_DATA_SIZE(gfs_info)) {
-			if (btrfs_item_end_nr(buf, i) >
+			if (btrfs_item_end(buf, i) >
 			    BTRFS_LEAF_DATA_SIZE(gfs_info)) {
 				ret = delete_bogus_item(root, path, buf, i);
 				if (!ret)
@@ -4340,10 +4340,10 @@ again:
 				break;
 			}
 			shift = BTRFS_LEAF_DATA_SIZE(gfs_info) -
-				btrfs_item_end_nr(buf, i);
-		} else if (i > 0 && btrfs_item_end_nr(buf, i) !=
+				btrfs_item_end(buf, i);
+		} else if (i > 0 && btrfs_item_end(buf, i) !=
 			   btrfs_item_offset_nr(buf, i - 1)) {
-			if (btrfs_item_end_nr(buf, i) >
+			if (btrfs_item_end(buf, i) >
 			    btrfs_item_offset_nr(buf, i - 1)) {
 				ret = delete_bogus_item(root, path, buf, i);
 				if (!ret)
@@ -4353,7 +4353,7 @@ again:
 				break;
 			}
 			shift = btrfs_item_offset_nr(buf, i - 1) -
-				btrfs_item_end_nr(buf, i);
+				btrfs_item_end(buf, i);
 		}
 		if (!shift)
 			continue;
diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
index 81a438c8..d18c91d1 100644
--- a/kernel-shared/ctree.c
+++ b/kernel-shared/ctree.c
@@ -730,10 +730,10 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info,
 		else
 			item_end_expected = btrfs_item_offset_nr(leaf,
 								 slot - 1);
-		if (btrfs_item_end_nr(leaf, slot) != item_end_expected) {
+		if (btrfs_item_end(leaf, slot) != item_end_expected) {
 			generic_err(leaf, slot,
 				"unexpected item end, have %u expect %u",
-				btrfs_item_end_nr(leaf, slot),
+				btrfs_item_end(leaf, slot),
 				item_end_expected);
 			ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS;
 			goto fail;
@@ -744,11 +744,11 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info,
 		 * just in case all the items are consistent to each other, but
 		 * all point outside of the leaf.
 		 */
-		if (btrfs_item_end_nr(leaf, slot) >
+		if (btrfs_item_end(leaf, slot) >
 		    BTRFS_LEAF_DATA_SIZE(fs_info)) {
 			generic_err(leaf, slot,
 			"slot end outside of leaf, have %u expect range [0, %u]",
-				btrfs_item_end_nr(leaf, slot),
+				btrfs_item_end(leaf, slot),
 				BTRFS_LEAF_DATA_SIZE(fs_info));
 			ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS;
 			goto fail;
@@ -1931,7 +1931,7 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr)
 
 	if (!nr)
 		return 0;
-	data_len = btrfs_item_end_nr(l, start);
+	data_len = btrfs_item_end(l, start);
 	data_len = data_len - btrfs_item_offset_nr(l, end);
 	data_len += sizeof(struct btrfs_item) * nr;
 	WARN_ON(data_len < 0);
@@ -2059,7 +2059,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	/* push left to right */
 	right_nritems = btrfs_header_nritems(right);
 
-	push_space = btrfs_item_end_nr(left, left_nritems - push_items);
+	push_space = btrfs_item_end(left, left_nritems - push_items);
 	push_space -= leaf_data_end(left);
 
 	/* make room in the right data area */
@@ -2294,7 +2294,7 @@ 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(l);
+	data_copy_size = btrfs_item_end(l, mid) - leaf_data_end(l);
 
 	copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
 			   btrfs_item_nr_offset(mid),
@@ -2306,7 +2306,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 			 btrfs_leaf_data(l) + leaf_data_end(l), data_copy_size);
 
 	rt_data_off = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
-		      btrfs_item_end_nr(l, mid);
+		      btrfs_item_end(l, mid);
 
 	for (i = 0; i < nritems; i++) {
 		u32 ioff = btrfs_item_offset_nr(right, i);
@@ -2727,7 +2727,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 		BUG();
 	}
 	slot = path->slots[0];
-	old_data = btrfs_item_end_nr(leaf, slot);
+	old_data = btrfs_item_end(leaf, slot);
 
 	BUG_ON(slot < 0);
 	if (slot >= nritems) {
@@ -2816,7 +2816,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 	BUG_ON(slot < 0);
 
 	if (slot < nritems) {
-		unsigned int old_data = btrfs_item_end_nr(leaf, slot);
+		unsigned int old_data = btrfs_item_end(leaf, slot);
 
 		if (old_data < data_end) {
 			btrfs_print_leaf(leaf, BTRFS_PRINT_TREE_DEFAULT);
diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index 7fb66049..befa244f 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -1994,17 +1994,6 @@ static inline struct btrfs_item *btrfs_item_nr(int nr)
 	return (struct btrfs_item *)btrfs_item_nr_offset(nr);
 }
 
-static inline u32 btrfs_item_end(struct extent_buffer *eb,
-				 struct btrfs_item *item)
-{
-	return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
-}
-
-static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
-{
-	return btrfs_item_end(eb, btrfs_item_nr(nr));
-}
-
 static inline void btrfs_set_item_size_nr(struct extent_buffer *eb, int nr,
 					  u32 size)
 {
@@ -2027,6 +2016,11 @@ static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
 	return btrfs_item_size(eb, btrfs_item_nr(nr));
 }
 
+static inline u32 btrfs_item_end(struct extent_buffer *eb, int nr)
+{
+	return btrfs_item_offset_nr(eb, nr) + btrfs_item_size_nr(eb, nr);
+}
+
 static inline void btrfs_item_key(struct extent_buffer *eb,
 			   struct btrfs_disk_key *disk_key, int nr)
 {
-- 
2.26.3

[PATCH 10/13] btrfs-progs: remove the _nr from the item helpers

[Josef Bacik]

Now that all callers are using the _nr variations we can simply rename
these helpers to btrfs_item_##member/btrfs_set_item_##member and change
the actual item SETGET funcs to raw_item_##member/set_raw_item_##member
and then change all callers to drop the _nr part.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 btrfs-corrupt-block.c       | 16 +++----
 check/main.c                | 50 ++++++++++-----------
 check/mode-common.c         | 12 ++---
 check/mode-lowmem.c         | 30 ++++++-------
 check/qgroup-verify.c       |  2 +-
 cmds/rescue-chunk-recover.c |  4 +-
 cmds/restore.c              |  2 +-
 convert/common.c            | 24 +++++-----
 image/main.c                | 20 ++++-----
 image/sanitize.c            |  4 +-
 kernel-shared/backref.c     |  8 ++--
 kernel-shared/ctree.c       | 90 ++++++++++++++++++-------------------
 kernel-shared/ctree.h       | 42 +++++++----------
 kernel-shared/dir-item.c    |  8 ++--
 kernel-shared/extent-tree.c | 12 ++---
 kernel-shared/file-item.c   | 12 ++---
 kernel-shared/inode-item.c  | 12 ++---
 kernel-shared/print-tree.c  | 20 ++++-----
 kernel-shared/root-tree.c   |  2 +-
 kernel-shared/uuid-tree.c   |  4 +-
 kernel-shared/volumes.c     | 10 ++---
 mkfs/common.c               | 36 +++++++--------
 22 files changed, 206 insertions(+), 214 deletions(-)

diff --git a/btrfs-corrupt-block.c b/btrfs-corrupt-block.c
index 57a4e271..fb1f15f0 100644
--- a/btrfs-corrupt-block.c
+++ b/btrfs-corrupt-block.c
@@ -246,7 +246,7 @@ static int corrupt_extent(struct btrfs_trans_handle *trans,
 				"corrupting extent record: key %llu %u %llu\n",
 				key.objectid, key.type, key.offset);
 			ptr = btrfs_item_ptr_offset(leaf, slot);
-			item_size = btrfs_item_size_nr(leaf, slot);
+			item_size = btrfs_item_size(leaf, slot);
 			memset_extent_buffer(leaf, 0, ptr, item_size);
 			btrfs_mark_buffer_dirty(leaf);
 		}
@@ -827,18 +827,18 @@ static void shift_items(struct btrfs_root *root, struct extent_buffer *eb)
 	int shift_space = btrfs_leaf_free_space(eb) / 2;
 	int slot = nritems / 2;
 	int i = 0;
-	unsigned int data_end = btrfs_item_offset_nr(eb, nritems - 1);
+	unsigned int data_end = btrfs_item_offset(eb, nritems - 1);
 
 	/* Shift the item data up to and including slot back by shift space */
 	memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end - shift_space,
 			      btrfs_leaf_data(eb) + data_end,
-			      btrfs_item_offset_nr(eb, slot - 1) - data_end);
+			      btrfs_item_offset(eb, slot - 1) - data_end);
 
 	/* Now update the item pointers. */
 	for (i = nritems - 1; i >= slot; i--) {
-		u32 offset = btrfs_item_offset_nr(eb, i);
+		u32 offset = btrfs_item_offset(eb, i);
 		offset -= shift_space;
-		btrfs_set_item_offset_nr(eb, i, offset);
+		btrfs_set_item_offset(eb, i, offset);
 	}
 }
 
@@ -978,9 +978,9 @@ static int corrupt_btrfs_item(struct btrfs_root *root, struct btrfs_key *key,
 	ret = 0;
 	switch (corrupt_field) {
 	case BTRFS_ITEM_OFFSET:
-		orig = btrfs_item_offset_nr(path->nodes[0], path->slots[0]);
+		orig = btrfs_item_offset(path->nodes[0], path->slots[0]);
 		bogus = generate_u32(orig);
-		btrfs_set_item_offset_nr(path->nodes[0], path->slots[0], bogus);
+		btrfs_set_item_offset(path->nodes[0], path->slots[0], bogus);
 		break;
 	default:
 		ret = -EINVAL;
@@ -1082,7 +1082,7 @@ static int corrupt_item_nocow(struct btrfs_trans_handle *trans,
 		fprintf(stdout, "Corrupting key and data [%llu, %u, %llu].\n",
 			key.objectid, key.type, key.offset);
 		ptr = btrfs_item_ptr_offset(leaf, slot);
-		item_size = btrfs_item_size_nr(leaf, slot);
+		item_size = btrfs_item_size(leaf, slot);
 		memset_extent_buffer(leaf, 0, ptr, item_size);
 		btrfs_mark_buffer_dirty(leaf);
 	}
diff --git a/check/main.c b/check/main.c
index 92e1399f..ed3fde60 100644
--- a/check/main.c
+++ b/check/main.c
@@ -1408,7 +1408,7 @@ static int process_dir_item(struct extent_buffer *eb,
 		return 0;
 
 	di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
-	total = btrfs_item_size_nr(eb, slot);
+	total = btrfs_item_size(eb, slot);
 	while (cur < total) {
 		int ret;
 
@@ -1490,7 +1490,7 @@ static int process_inode_ref(struct extent_buffer *eb,
 	inode_cache = &active_node->inode_cache;
 
 	ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
-	total = btrfs_item_size_nr(eb, slot);
+	total = btrfs_item_size(eb, slot);
 	while (cur < total) {
 		name_len = btrfs_inode_ref_name_len(eb, ref);
 		index = btrfs_inode_ref_index(eb, ref);
@@ -1539,7 +1539,7 @@ static int process_inode_extref(struct extent_buffer *eb,
 	inode_cache = &active_node->inode_cache;
 
 	extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
-	total = btrfs_item_size_nr(eb, slot);
+	total = btrfs_item_size(eb, slot);
 	while (cur < total) {
 		name_len = btrfs_inode_extref_name_len(eb, extref);
 		index = btrfs_inode_extref_index(eb, extref);
@@ -4216,10 +4216,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
 
 		btrfs_item_key_to_cpu(buf, &k1, slot);
 		btrfs_item_key_to_cpu(buf, &k2, slot + 1);
-		item1_offset = btrfs_item_offset_nr(buf, slot);
-		item2_offset = btrfs_item_offset_nr(buf, slot + 1);
-		item1_size = btrfs_item_size_nr(buf, slot);
-		item2_size = btrfs_item_size_nr(buf, slot + 1);
+		item1_offset = btrfs_item_offset(buf, slot);
+		item2_offset = btrfs_item_offset(buf, slot + 1);
+		item1_size = btrfs_item_size(buf, slot);
+		item2_size = btrfs_item_size(buf, slot + 1);
 
 		item1_data = malloc(item1_size);
 		if (!item1_data)
@@ -4238,10 +4238,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
 		free(item1_data);
 		free(item2_data);
 
-		btrfs_set_item_offset_nr(buf, slot, item2_offset);
-		btrfs_set_item_offset_nr(buf, slot + 1, item1_offset);
-		btrfs_set_item_size_nr(buf, slot, item2_size);
-		btrfs_set_item_size_nr(buf, slot + 1, item1_size);
+		btrfs_set_item_offset(buf, slot, item2_offset);
+		btrfs_set_item_offset(buf, slot + 1, item1_offset);
+		btrfs_set_item_size(buf, slot, item2_size);
+		btrfs_set_item_size(buf, slot + 1, item1_size);
 
 		path->slots[0] = slot;
 		btrfs_set_item_key_unsafe(root, path, &k2);
@@ -4342,9 +4342,9 @@ again:
 			shift = BTRFS_LEAF_DATA_SIZE(gfs_info) -
 				btrfs_item_end(buf, i);
 		} else if (i > 0 && btrfs_item_end(buf, i) !=
-			   btrfs_item_offset_nr(buf, i - 1)) {
+			   btrfs_item_offset(buf, i - 1)) {
 			if (btrfs_item_end(buf, i) >
-			    btrfs_item_offset_nr(buf, i - 1)) {
+			    btrfs_item_offset(buf, i - 1)) {
 				ret = delete_bogus_item(root, path, buf, i);
 				if (!ret)
 					goto again;
@@ -4352,7 +4352,7 @@ again:
 				ret = -EIO;
 				break;
 			}
-			shift = btrfs_item_offset_nr(buf, i - 1) -
+			shift = btrfs_item_offset(buf, i - 1) -
 				btrfs_item_end(buf, i);
 		}
 		if (!shift)
@@ -4360,12 +4360,12 @@ again:
 
 		printf("Shifting item nr %d by %u bytes in block %llu\n",
 		       i, shift, (unsigned long long)buf->start);
-		offset = btrfs_item_offset_nr(buf, i);
+		offset = btrfs_item_offset(buf, i);
 		memmove_extent_buffer(buf,
 				      btrfs_leaf_data(buf) + offset + shift,
 				      btrfs_leaf_data(buf) + offset,
-				      btrfs_item_size_nr(buf, i));
-		btrfs_set_item_offset_nr(buf, i, offset + shift);
+				      btrfs_item_size(buf, i));
+		btrfs_set_item_offset(buf, i, offset + shift);
 		btrfs_mark_buffer_dirty(buf);
 	}
 
@@ -5403,7 +5403,7 @@ static int process_extent_item(struct btrfs_root *root,
 	unsigned long ptr;
 	int ret;
 	int type;
-	u32 item_size = btrfs_item_size_nr(eb, slot);
+	u32 item_size = btrfs_item_size(eb, slot);
 	u64 refs = 0;
 	u64 offset;
 	u64 num_bytes;
@@ -6077,7 +6077,7 @@ static int check_csum_root(struct btrfs_root *root)
 				path.slots[0]);
 			errors++;
 		}
-		num_entries = btrfs_item_size_nr(leaf, path.slots[0]) / csum_size;
+		num_entries = btrfs_item_size(leaf, path.slots[0]) / csum_size;
 		data_len = num_entries * gfs_info->sectorsize;
 
 		if (num_entries > max_entries) {
@@ -6459,7 +6459,7 @@ static int run_next_block(struct btrfs_root *root,
 			}
 			if (key.type == BTRFS_EXTENT_CSUM_KEY) {
 				total_csum_bytes +=
-					btrfs_item_size_nr(buf, i);
+					btrfs_item_size(buf, i);
 				continue;
 			}
 			if (key.type == BTRFS_CHUNK_ITEM_KEY) {
@@ -6552,11 +6552,11 @@ static int run_next_block(struct btrfs_root *root,
 			if (key.type != BTRFS_EXTENT_DATA_KEY)
 				continue;
 			/* Check itemsize before we continue */
-			if (btrfs_item_size_nr(buf, i) < inline_offset) {
+			if (btrfs_item_size(buf, i) < inline_offset) {
 				ret = -EUCLEAN;
 				error(
 		"invalid file extent item size, have %u expect (%lu, %u]",
-					btrfs_item_size_nr(buf, i),
+					btrfs_item_size(buf, i),
 					inline_offset,
 					BTRFS_LEAF_DATA_SIZE(gfs_info));
 				continue;
@@ -6568,12 +6568,12 @@ static int run_next_block(struct btrfs_root *root,
 				continue;
 
 			/* Prealloc/regular extent must have fixed item size */
-			if (btrfs_item_size_nr(buf, i) !=
+			if (btrfs_item_size(buf, i) !=
 			    sizeof(struct btrfs_file_extent_item)) {
 				ret = -EUCLEAN;
 				error(
 			"invalid file extent item size, have %u expect %zu",
-					btrfs_item_size_nr(buf, i),
+					btrfs_item_size(buf, i),
 					sizeof(struct btrfs_file_extent_item));
 				continue;
 			}
@@ -9661,7 +9661,7 @@ static int build_roots_info_cache(void)
 
 		ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
 		flags = btrfs_extent_flags(leaf, ei);
-		item_end = (unsigned long)ei + btrfs_item_size_nr(leaf, slot);
+		item_end = (unsigned long)ei + btrfs_item_size(leaf, slot);
 
 		if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
 		    !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
diff --git a/check/mode-common.c b/check/mode-common.c
index c3d8bb45..f05960ac 100644
--- a/check/mode-common.c
+++ b/check/mode-common.c
@@ -205,7 +205,7 @@ int check_prealloc_extent_written(u64 disk_bytenr, u64 num_bytes)
 	/* First check all inline refs. */
 	ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
 			    struct btrfs_extent_item);
-	item_size = btrfs_item_size_nr(path.nodes[0], path.slots[0]);
+	item_size = btrfs_item_size(path.nodes[0], path.slots[0]);
 	ptr = (unsigned long)(ei + 1);
 	end = (unsigned long)ei + item_size;
 	while (ptr < end) {
@@ -340,7 +340,7 @@ int count_csum_range(u64 start, u64 len, u64 *found)
 		if (key.offset > start)
 			start = key.offset;
 
-		size = btrfs_item_size_nr(leaf, path.slots[0]);
+		size = btrfs_item_size(leaf, path.slots[0]);
 		csum_end = key.offset + (size / csum_size) *
 			   gfs_info->sectorsize;
 		if (csum_end > start) {
@@ -758,7 +758,7 @@ static int find_file_type_dir_index(struct btrfs_root *root, u64 ino, u64 dirid,
 	if (filetype >= BTRFS_FT_MAX || filetype == BTRFS_FT_UNKNOWN)
 		goto out;
 	len = min_t(u32, BTRFS_NAME_LEN,
-		btrfs_item_size_nr(path.nodes[0], path.slots[0]) - sizeof(*di));
+		btrfs_item_size(path.nodes[0], path.slots[0]) - sizeof(*di));
 	len = min_t(u32, len, btrfs_dir_name_len(path.nodes[0], di));
 	read_extent_buffer(path.nodes[0], namebuf, (unsigned long)(di + 1), len);
 	if (name_len != len || memcmp(namebuf, name, len))
@@ -802,7 +802,7 @@ static int find_file_type_dir_item(struct btrfs_root *root, u64 ino, u64 dirid,
 		goto out;
 
 	cur = btrfs_item_ptr_offset(path.nodes[0], path.slots[0]);
-	end = cur + btrfs_item_size_nr(path.nodes[0], path.slots[0]);
+	end = cur + btrfs_item_size(path.nodes[0], path.slots[0]);
 	while (cur < end) {
 		di = (struct btrfs_dir_item *)cur;
 		cur += btrfs_dir_name_len(path.nodes[0], di) + sizeof(*di);
@@ -817,7 +817,7 @@ static int find_file_type_dir_item(struct btrfs_root *root, u64 ino, u64 dirid,
 		if (filetype >= BTRFS_FT_MAX || filetype == BTRFS_FT_UNKNOWN)
 			continue;
 		len = min_t(u32, BTRFS_NAME_LEN,
-			    btrfs_item_size_nr(path.nodes[0], path.slots[0]) -
+			    btrfs_item_size(path.nodes[0], path.slots[0]) -
 			    sizeof(*di));
 		len = min_t(u32, len, btrfs_dir_name_len(path.nodes[0], di));
 		read_extent_buffer(path.nodes[0], namebuf,
@@ -903,7 +903,7 @@ int detect_imode(struct btrfs_root *root, struct btrfs_path *path,
 		case BTRFS_INODE_REF_KEY:
 			/* The most accurate way to determine filetype */
 			cur = btrfs_item_ptr_offset(leaf, slot);
-			end = cur + btrfs_item_size_nr(leaf, slot);
+			end = cur + btrfs_item_size(leaf, slot);
 			while (cur < end) {
 				iref = (struct btrfs_inode_ref *)cur;
 				namelen = min_t(u32, end - cur - sizeof(&iref),
diff --git a/check/mode-lowmem.c b/check/mode-lowmem.c
index 729c453a..99d04945 100644
--- a/check/mode-lowmem.c
+++ b/check/mode-lowmem.c
@@ -98,7 +98,7 @@ static int calc_extent_flag(struct btrfs_root *root, struct extent_buffer *eb,
 		goto full_backref;
 
 	ptr = (unsigned long)(ei + 1);
-	end = (unsigned long)ei + btrfs_item_size_nr(eb, slot);
+	end = (unsigned long)ei + btrfs_item_size(eb, slot);
 
 	if (key.type == BTRFS_EXTENT_ITEM_KEY)
 		ptr += sizeof(struct btrfs_tree_block_info);
@@ -844,7 +844,7 @@ loop:
 	node = path.nodes[0];
 	slot = path.slots[0];
 	di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
-	total = btrfs_item_size_nr(node, slot);
+	total = btrfs_item_size(node, slot);
 	while (cur < total) {
 		ret = -ENOENT;
 		len = btrfs_dir_name_len(node, di);
@@ -940,7 +940,7 @@ static int find_dir_item(struct btrfs_root *root, struct btrfs_key *key,
 	node = path.nodes[0];
 	slot = path.slots[0];
 	di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
-	total = btrfs_item_size_nr(node, slot);
+	total = btrfs_item_size(node, slot);
 	while (cur < total) {
 		ret = key->type == BTRFS_DIR_ITEM_KEY ?
 			DIR_ITEM_MISMATCH : DIR_INDEX_MISMATCH;
@@ -1147,7 +1147,7 @@ begin:
 
 	memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf));
 	ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
-	total = btrfs_item_size_nr(node, slot);
+	total = btrfs_item_size(node, slot);
 
 next:
 	/* Update inode ref count */
@@ -1256,7 +1256,7 @@ static int check_inode_extref(struct btrfs_root *root,
 	location.offset = 0;
 
 	extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
-	total = btrfs_item_size_nr(node, slot);
+	total = btrfs_item_size(node, slot);
 
 next:
 	/* update inode ref count */
@@ -1352,7 +1352,7 @@ static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
 	slot = path.slots[0];
 
 	ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
-	total = btrfs_item_size_nr(node, slot);
+	total = btrfs_item_size(node, slot);
 
 	/* Iterate all entry of INODE_REF */
 	while (cur < total) {
@@ -1418,7 +1418,7 @@ extref:
 
 	extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
 	cur = 0;
-	total = btrfs_item_size_nr(node, slot);
+	total = btrfs_item_size(node, slot);
 
 	/* Iterate all entry of INODE_EXTREF */
 	while (cur < total) {
@@ -1710,7 +1710,7 @@ begin:
 	slot = path->slots[0];
 
 	di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
-	total = btrfs_item_size_nr(node, slot);
+	total = btrfs_item_size(node, slot);
 	memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf));
 
 	while (cur < total) {
@@ -2206,7 +2206,7 @@ loop:
 special_case:
 	di = btrfs_item_ptr(path.nodes[0], path.slots[0], struct btrfs_dir_item);
 	cur = 0;
-	total = btrfs_item_size_nr(path.nodes[0], path.slots[0]);
+	total = btrfs_item_size(path.nodes[0], path.slots[0]);
 
 	while (cur < total) {
 		len = btrfs_dir_name_len(path.nodes[0], di);
@@ -3106,7 +3106,7 @@ static int check_tree_block_ref(struct btrfs_root *root,
 	/*
 	 * Iterate the extent/metadata item to find the exact backref
 	 */
-	item_size = btrfs_item_size_nr(leaf, slot);
+	item_size = btrfs_item_size(leaf, slot);
 	ptr = (unsigned long)iref;
 	end = (unsigned long)ei + item_size;
 
@@ -3448,7 +3448,7 @@ static int check_extent_data_item(struct btrfs_root *root,
 	}
 
 	/* Check data backref inside that extent item */
-	item_size = btrfs_item_size_nr(leaf, path.slots[0]);
+	item_size = btrfs_item_size(leaf, path.slots[0]);
 	iref = (struct btrfs_extent_inline_ref *)(ei + 1);
 	ptr = (unsigned long)iref;
 	end = (unsigned long)ei + item_size;
@@ -4230,7 +4230,7 @@ static int check_extent_item(struct btrfs_path *path)
 	int slot = path->slots[0];
 	int type;
 	u32 nodesize = btrfs_super_nodesize(gfs_info->super_copy);
-	u32 item_size = btrfs_item_size_nr(eb, slot);
+	u32 item_size = btrfs_item_size(eb, slot);
 	u64 flags;
 	u64 offset;
 	u64 parent;
@@ -4391,7 +4391,7 @@ next:
 			eb = path->nodes[0];
 			slot = path->slots[0];
 			ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
-			item_size = btrfs_item_size_nr(eb, slot);
+			item_size = btrfs_item_size(eb, slot);
 			goto next;
 		}
 	}
@@ -4408,7 +4408,7 @@ next:
 		eb = path->nodes[0];
 		slot = path->slots[0];
 		ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
-		item_size = btrfs_item_size_nr(eb, slot);
+		item_size = btrfs_item_size(eb, slot);
 		ptr_offset += btrfs_extent_inline_ref_size(type);
 		goto next;
 	}
@@ -4846,7 +4846,7 @@ again:
 		err |= ret;
 		break;
 	case BTRFS_EXTENT_CSUM_KEY:
-		total_csum_bytes += btrfs_item_size_nr(eb, slot);
+		total_csum_bytes += btrfs_item_size(eb, slot);
 		err |= ret;
 		break;
 	case BTRFS_TREE_BLOCK_REF_KEY:
diff --git a/check/qgroup-verify.c b/check/qgroup-verify.c
index 0813b841..2c05f875 100644
--- a/check/qgroup-verify.c
+++ b/check/qgroup-verify.c
@@ -1041,7 +1041,7 @@ static int add_inline_refs(struct btrfs_fs_info *info,
 	struct btrfs_extent_inline_ref *iref;
 	struct btrfs_extent_data_ref *dref;
 	u64 flags, root_obj, offset, parent;
-	u32 item_size = btrfs_item_size_nr(ei_leaf, slot);
+	u32 item_size = btrfs_item_size(ei_leaf, slot);
 	int type;
 	unsigned long end;
 	unsigned long ptr;
diff --git a/cmds/rescue-chunk-recover.c b/cmds/rescue-chunk-recover.c
index da24df4c..ec5c206f 100644
--- a/cmds/rescue-chunk-recover.c
+++ b/cmds/rescue-chunk-recover.c
@@ -1812,7 +1812,7 @@ static int next_csum(struct btrfs_root *csum_root,
 	struct btrfs_csum_item *csum_item;
 	u32 blocksize = csum_root->fs_info->sectorsize;
 	u16 csum_size = csum_root->fs_info->csum_size;
-	int csums_in_item = btrfs_item_size_nr(*leaf, *slot) / csum_size;
+	int csums_in_item = btrfs_item_size(*leaf, *slot) / csum_size;
 
 	if (*csum_offset >= csums_in_item) {
 		++(*slot);
@@ -1897,7 +1897,7 @@ static u64 item_end_offset(struct btrfs_root *root, struct btrfs_key *key,
 	u32 blocksize = root->fs_info->sectorsize;
 	u16 csum_size = root->fs_info->csum_size;
 
-	u64 offset = btrfs_item_size_nr(leaf, slot);
+	u64 offset = btrfs_item_size(leaf, slot);
 	offset /= csum_size;
 	offset *= blocksize;
 	offset += key->offset;
diff --git a/cmds/restore.c b/cmds/restore.c
index bc88af70..81ca6cd5 100644
--- a/cmds/restore.c
+++ b/cmds/restore.c
@@ -512,7 +512,7 @@ static int set_file_xattrs(struct btrfs_root *root, u64 inode,
 		if (key.type != BTRFS_XATTR_ITEM_KEY || key.objectid != inode)
 			break;
 		cur = 0;
-		total_len = btrfs_item_size_nr(leaf, path.slots[0]);
+		total_len = btrfs_item_size(leaf, path.slots[0]);
 		di = btrfs_item_ptr(leaf, path.slots[0],
 				    struct btrfs_dir_item);
 
diff --git a/convert/common.c b/convert/common.c
index 38112084..0fb7b6c5 100644
--- a/convert/common.c
+++ b/convert/common.c
@@ -204,8 +204,8 @@ static void insert_temp_root_item(struct extent_buffer *buf,
 	btrfs_set_disk_key_offset(&disk_key, 0);
 
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
-	btrfs_set_item_size_nr(buf, *slot, sizeof(root_item));
+	btrfs_set_item_offset(buf, *slot, *itemoff);
+	btrfs_set_item_size(buf, *slot, sizeof(root_item));
 	write_extent_buffer(buf, &root_item,
 			    btrfs_item_ptr_offset(buf, *slot),
 			    sizeof(root_item));
@@ -311,8 +311,8 @@ static int insert_temp_dev_item(int fd, struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
 	btrfs_set_disk_key_offset(&disk_key, 1);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
-	btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_item));
+	btrfs_set_item_offset(buf, *slot, *itemoff);
+	btrfs_set_item_size(buf, *slot, sizeof(*dev_item));
 
 	dev_item = btrfs_item_ptr(buf, *slot, struct btrfs_dev_item);
 	/* Generate device uuid */
@@ -369,8 +369,8 @@ static int insert_temp_chunk_item(int fd, struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
 	btrfs_set_disk_key_offset(&disk_key, start);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
-	btrfs_set_item_size_nr(buf, *slot, btrfs_chunk_item_size(1));
+	btrfs_set_item_offset(buf, *slot, *itemoff);
+	btrfs_set_item_size(buf, *slot, btrfs_chunk_item_size(1));
 
 	chunk = btrfs_item_ptr(buf, *slot, struct btrfs_chunk);
 	btrfs_set_chunk_length(buf, chunk, len);
@@ -471,8 +471,8 @@ static void insert_temp_dev_extent(struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, 1);
 	btrfs_set_disk_key_offset(&disk_key, start);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
-	btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_extent));
+	btrfs_set_item_offset(buf, *slot, *itemoff);
+	btrfs_set_item_size(buf, *slot, sizeof(*dev_extent));
 
 	dev_extent = btrfs_item_ptr(buf, *slot, struct btrfs_dev_extent);
 	btrfs_set_dev_extent_chunk_objectid(buf, dev_extent,
@@ -603,8 +603,8 @@ static int insert_temp_extent_item(int fd, struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, bytenr);
 
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
-	btrfs_set_item_size_nr(buf, *slot, itemsize);
+	btrfs_set_item_offset(buf, *slot, *itemoff);
+	btrfs_set_item_size(buf, *slot, itemsize);
 
 	ei = btrfs_item_ptr(buf, *slot, struct btrfs_extent_item);
 	btrfs_set_extent_refs(buf, ei, 1);
@@ -669,8 +669,8 @@ static void insert_temp_block_group(struct extent_buffer *buf,
 	btrfs_set_disk_key_objectid(&disk_key, bytenr);
 	btrfs_set_disk_key_offset(&disk_key, len);
 	btrfs_set_item_key(buf, &disk_key, *slot);
-	btrfs_set_item_offset_nr(buf, *slot, *itemoff);
-	btrfs_set_item_size_nr(buf, *slot, sizeof(bgi));
+	btrfs_set_item_offset(buf, *slot, *itemoff);
+	btrfs_set_item_size(buf, *slot, sizeof(bgi));
 
 	btrfs_set_stack_block_group_flags(&bgi, flag);
 	btrfs_set_stack_block_group_used(&bgi, used);
diff --git a/image/main.c b/image/main.c
index 5d67d282..ff121fca 100644
--- a/image/main.c
+++ b/image/main.c
@@ -311,9 +311,9 @@ static void zero_items(struct metadump_struct *md, u8 *dst,
 	for (i = 0; i < nritems; i++) {
 		btrfs_item_key_to_cpu(src, &key, i);
 		if (key.type == BTRFS_CSUM_ITEM_KEY) {
-			size = btrfs_item_size_nr(src, i);
+			size = btrfs_item_size(src, i);
 			memset(dst + btrfs_leaf_data(src) +
-			       btrfs_item_offset_nr(src, i), 0, size);
+			       btrfs_item_offset(src, i), 0, size);
 			continue;
 		}
 
@@ -359,7 +359,7 @@ static void copy_buffer(struct metadump_struct *md, u8 *dst,
 		memset(dst + size, 0, src->len - size);
 	} else if (level == 0) {
 		size = btrfs_leaf_data(src) +
-			btrfs_item_offset_nr(src, nritems - 1) -
+			btrfs_item_offset(src, nritems - 1) -
 			btrfs_item_nr_offset(nritems);
 		memset(dst + btrfs_item_nr_offset(nritems), 0, size);
 		zero_items(md, dst, src);
@@ -971,7 +971,7 @@ static int copy_from_extent_tree(struct metadump_struct *metadump,
 			break;
 		}
 
-		if (btrfs_item_size_nr(leaf, path->slots[0]) >= sizeof(*ei)) {
+		if (btrfs_item_size(leaf, path->slots[0]) >= sizeof(*ei)) {
 			ei = btrfs_item_ptr(leaf, path->slots[0],
 					    struct btrfs_extent_item);
 			if (btrfs_extent_flags(leaf, ei) &
@@ -1223,26 +1223,26 @@ static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
 	u32 data_end;
 	int i;
 
-	old_size = btrfs_item_size_nr(eb, slot);
+	old_size = btrfs_item_size(eb, slot);
 	if (old_size == new_size)
 		return;
 
 	nritems = btrfs_header_nritems(eb);
-	data_end = btrfs_item_offset_nr(eb, nritems - 1);
+	data_end = btrfs_item_offset(eb, nritems - 1);
 
-	old_data_start = btrfs_item_offset_nr(eb, slot);
+	old_data_start = btrfs_item_offset(eb, slot);
 	size_diff = old_size - new_size;
 
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
-		ioff = btrfs_item_offset_nr(eb, i);
-		btrfs_set_item_offset_nr(eb, i, ioff + size_diff);
+		ioff = btrfs_item_offset(eb, i);
+		btrfs_set_item_offset(eb, i, ioff + size_diff);
 	}
 
 	memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end + size_diff,
 			      btrfs_leaf_data(eb) + data_end,
 			      old_data_start + new_size - data_end);
-	btrfs_set_item_size_nr(eb, slot, new_size);
+	btrfs_set_item_size(eb, slot, new_size);
 }
 
 static int fixup_chunk_tree_block(struct mdrestore_struct *mdres,
diff --git a/image/sanitize.c b/image/sanitize.c
index e3ac1b84..c6970403 100644
--- a/image/sanitize.c
+++ b/image/sanitize.c
@@ -325,7 +325,7 @@ static void sanitize_dir_item(enum sanitize_mode sanitize,
 	int free_garbage = (sanitize == SANITIZE_NAMES);
 
 	dir_item = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
-	total_len = btrfs_item_size_nr(eb, slot);
+	total_len = btrfs_item_size(eb, slot);
 	while (cur < total_len) {
 		this_len = sizeof(*dir_item) +
 			btrfs_dir_name_len(eb, dir_item) +
@@ -371,7 +371,7 @@ static void sanitize_inode_ref(enum sanitize_mode sanitize,
 	int len;
 	int free_garbage = (sanitize == SANITIZE_NAMES);
 
-	item_size = btrfs_item_size_nr(eb, slot);
+	item_size = btrfs_item_size(eb, slot);
 	ptr = btrfs_item_ptr_offset(eb, slot);
 	while (cur_offset < item_size) {
 		if (ext) {
diff --git a/kernel-shared/backref.c b/kernel-shared/backref.c
index 327599b7..9c5a3895 100644
--- a/kernel-shared/backref.c
+++ b/kernel-shared/backref.c
@@ -561,7 +561,7 @@ static int __add_inline_refs(struct btrfs_fs_info *fs_info,
 	leaf = path->nodes[0];
 	slot = path->slots[0];
 
-	item_size = btrfs_item_size_nr(leaf, slot);
+	item_size = btrfs_item_size(leaf, slot);
 	BUG_ON(item_size < sizeof(*ei));
 
 	ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
@@ -1182,7 +1182,7 @@ int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
 	}
 
 	eb = path->nodes[0];
-	item_size = btrfs_item_size_nr(eb, path->slots[0]);
+	item_size = btrfs_item_size(eb, path->slots[0]);
 	BUG_ON(item_size < sizeof(*ei));
 
 	ei = btrfs_item_ptr(eb, path->slots[0], struct btrfs_extent_item);
@@ -1443,7 +1443,7 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
 
 		iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
 
-		for (cur = 0; cur < btrfs_item_size_nr(eb, slot); cur += len) {
+		for (cur = 0; cur < btrfs_item_size(eb, slot); cur += len) {
 			name_len = btrfs_inode_ref_name_len(eb, iref);
 			/* path must be released before calling iterate()! */
 			pr_debug("following ref at offset %u for inode %llu in "
@@ -1502,7 +1502,7 @@ static int iterate_inode_extrefs(u64 inum, struct btrfs_root *fs_root,
 		btrfs_release_path(path);
 
 		leaf = path->nodes[0];
-		item_size = btrfs_item_size_nr(leaf, slot);
+		item_size = btrfs_item_size(leaf, slot);
 		ptr = btrfs_item_ptr_offset(leaf, slot);
 		cur_offset = 0;
 
diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
index d18c91d1..04847cd5 100644
--- a/kernel-shared/ctree.c
+++ b/kernel-shared/ctree.c
@@ -582,7 +582,7 @@ static inline unsigned int leaf_data_end(const struct extent_buffer *leaf)
 	u32 nr = btrfs_header_nritems(leaf);
 	if (nr == 0)
 		return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);
-	return btrfs_item_offset_nr(leaf, nr - 1);
+	return btrfs_item_offset(leaf, nr - 1);
 }
 
 static void generic_err(const struct extent_buffer *buf, int slot,
@@ -728,7 +728,7 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info,
 		if (slot == 0)
 			item_end_expected = BTRFS_LEAF_DATA_SIZE(fs_info);
 		else
-			item_end_expected = btrfs_item_offset_nr(leaf,
+			item_end_expected = btrfs_item_offset(leaf,
 								 slot - 1);
 		if (btrfs_item_end(leaf, slot) != item_end_expected) {
 			generic_err(leaf, slot,
@@ -1932,7 +1932,7 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr)
 	if (!nr)
 		return 0;
 	data_len = btrfs_item_end(l, start);
-	data_len = data_len - btrfs_item_offset_nr(l, end);
+	data_len = data_len - btrfs_item_offset(l, end);
 	data_len += sizeof(struct btrfs_item) * nr;
 	WARN_ON(data_len < 0);
 	return data_len;
@@ -2038,7 +2038,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(struct btrfs_item);
 
-		this_item_size = btrfs_item_size_nr(left, i);
+		this_item_size = btrfs_item_size(left, i);
 		if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space)
 			break;
 		push_items++;
@@ -2088,8 +2088,8 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 	btrfs_set_header_nritems(right, right_nritems);
 	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info);
 	for (i = 0; i < right_nritems; i++) {
-		push_space -= btrfs_item_size_nr(right, i);
-		btrfs_set_item_offset_nr(right, i, push_space);
+		push_space -= btrfs_item_size(right, i);
+		btrfs_set_item_offset(right, i, push_space);
 	}
 
 	left_nritems -= push_items;
@@ -2180,7 +2180,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 		if (path->slots[0] == i)
 			push_space += data_size + sizeof(struct btrfs_item);
 
-		this_item_size = btrfs_item_size_nr(right, i);
+		this_item_size = btrfs_item_size(right, i);
 		if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space)
 			break;
 
@@ -2202,22 +2202,22 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 			   push_items * sizeof(struct btrfs_item));
 
 	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
-		     btrfs_item_offset_nr(right, push_items -1);
+		     btrfs_item_offset(right, push_items -1);
 
 	copy_extent_buffer(left, right, btrfs_leaf_data(left) +
 		     leaf_data_end(left) - push_space,
 		     btrfs_leaf_data(right) +
-		     btrfs_item_offset_nr(right, push_items - 1),
+		     btrfs_item_offset(right, push_items - 1),
 		     push_space);
 	old_left_nritems = btrfs_header_nritems(left);
 	BUG_ON(old_left_nritems == 0);
 
-	old_left_item_size = btrfs_item_offset_nr(left, old_left_nritems - 1);
+	old_left_item_size = btrfs_item_offset(left, old_left_nritems - 1);
 	for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
 		u32 ioff;
 
-		ioff = btrfs_item_offset_nr(left, i);
-		btrfs_set_item_offset_nr(left, i,
+		ioff = btrfs_item_offset(left, i);
+		btrfs_set_item_offset(left, i,
 		      ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) -
 			      old_left_item_size));
 	}
@@ -2230,7 +2230,7 @@ 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) -
+		push_space = btrfs_item_offset(right, push_items - 1) -
 						  leaf_data_end(right);
 		memmove_extent_buffer(right, btrfs_leaf_data(right) +
 				      BTRFS_LEAF_DATA_SIZE(root->fs_info) -
@@ -2247,8 +2247,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	btrfs_set_header_nritems(right, right_nritems);
 	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info);
 	for (i = 0; i < right_nritems; i++) {
-		push_space = push_space - btrfs_item_size_nr(right, i);
-		btrfs_set_item_offset_nr(right, i, push_space);
+		push_space = push_space - btrfs_item_size(right, i);
+		btrfs_set_item_offset(right, i, push_space);
 	}
 
 	btrfs_mark_buffer_dirty(left);
@@ -2309,8 +2309,8 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 		      btrfs_item_end(l, mid);
 
 	for (i = 0; i < nritems; i++) {
-		u32 ioff = btrfs_item_offset_nr(right, i);
-		btrfs_set_item_offset_nr(right, i, ioff + rt_data_off);
+		u32 ioff = btrfs_item_offset(right, i);
+		btrfs_set_item_offset(right, i, ioff + rt_data_off);
 	}
 
 	btrfs_set_header_nritems(l, mid);
@@ -2364,7 +2364,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) +
+	if (extend && data_size + btrfs_item_size(l, slot) +
 	    sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root->fs_info))
 		return -EOVERFLOW;
 
@@ -2540,7 +2540,7 @@ int btrfs_split_item(struct btrfs_trans_handle *trans,
 	    sizeof(struct btrfs_item))
 		goto split;
 
-	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+	item_size = btrfs_item_size(leaf, path->slots[0]);
 	btrfs_release_path(path);
 
 	path->search_for_split = 1;
@@ -2549,7 +2549,7 @@ int btrfs_split_item(struct btrfs_trans_handle *trans,
 	path->search_for_split = 0;
 
 	/* if our item isn't there or got smaller, return now */
-	if (ret != 0 || item_size != btrfs_item_size_nr(path->nodes[0],
+	if (ret != 0 || item_size != btrfs_item_size(path->nodes[0],
 							path->slots[0])) {
 		return -EAGAIN;
 	}
@@ -2561,8 +2561,8 @@ int btrfs_split_item(struct btrfs_trans_handle *trans,
 	leaf = path->nodes[0];
 
 split:
-	orig_offset = btrfs_item_offset_nr(leaf, path->slots[0]);
-	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+	orig_offset = btrfs_item_offset(leaf, path->slots[0]);
+	item_size = btrfs_item_size(leaf, path->slots[0]);
 
 
 	buf = kmalloc(item_size, GFP_NOFS);
@@ -2585,12 +2585,12 @@ split:
 	btrfs_cpu_key_to_disk(&disk_key, new_key);
 	btrfs_set_item_key(leaf, &disk_key, slot);
 
-	btrfs_set_item_offset_nr(leaf, slot, orig_offset);
-	btrfs_set_item_size_nr(leaf, slot, item_size - split_offset);
+	btrfs_set_item_offset(leaf, slot, orig_offset);
+	btrfs_set_item_size(leaf, slot, item_size - split_offset);
 
-	btrfs_set_item_offset_nr(leaf, path->slots[0],
+	btrfs_set_item_offset(leaf, path->slots[0],
 				 orig_offset + item_size - split_offset);
-	btrfs_set_item_size_nr(leaf, path->slots[0], split_offset);
+	btrfs_set_item_size(leaf, path->slots[0], split_offset);
 
 	btrfs_set_header_nritems(leaf, nritems + 1);
 
@@ -2629,14 +2629,14 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 	leaf = path->nodes[0];
 	slot = path->slots[0];
 
-	old_size = btrfs_item_size_nr(leaf, slot);
+	old_size = btrfs_item_size(leaf, slot);
 	if (old_size == new_size)
 		return 0;
 
 	nritems = btrfs_header_nritems(leaf);
 	data_end = leaf_data_end(leaf);
 
-	old_data_start = btrfs_item_offset_nr(leaf, slot);
+	old_data_start = btrfs_item_offset(leaf, slot);
 
 	size_diff = old_size - new_size;
 
@@ -2649,8 +2649,8 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 	/* first correct the data pointers */
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
-		ioff = btrfs_item_offset_nr(leaf, i);
-		btrfs_set_item_offset_nr(leaf, i, ioff + size_diff);
+		ioff = btrfs_item_offset(leaf, i);
+		btrfs_set_item_offset(leaf, i, ioff + size_diff);
 	}
 
 	/* shift the data */
@@ -2694,7 +2694,7 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 			btrfs_fixup_low_keys(path, &disk_key, 1);
 	}
 
-	btrfs_set_item_size_nr(leaf, slot, new_size);
+	btrfs_set_item_size(leaf, slot, new_size);
 	btrfs_mark_buffer_dirty(leaf);
 
 	ret = 0;
@@ -2742,8 +2742,8 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 	/* first correct the data pointers */
 	for (i = slot; i < nritems; i++) {
 		u32 ioff;
-		ioff = btrfs_item_offset_nr(leaf, i);
-		btrfs_set_item_offset_nr(leaf, i, ioff - data_size);
+		ioff = btrfs_item_offset(leaf, i);
+		btrfs_set_item_offset(leaf, i, ioff - data_size);
 	}
 
 	/* shift the data */
@@ -2752,8 +2752,8 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
 		      data_end, old_data - data_end);
 
 	data_end = old_data;
-	old_size = btrfs_item_size_nr(leaf, slot);
-	btrfs_set_item_size_nr(leaf, slot, old_size + data_size);
+	old_size = btrfs_item_size(leaf, slot);
+	btrfs_set_item_size(leaf, slot, old_size + data_size);
 	btrfs_mark_buffer_dirty(leaf);
 
 	ret = 0;
@@ -2831,8 +2831,8 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 		for (i = slot; i < nritems; i++) {
 			u32 ioff;
 
-			ioff = btrfs_item_offset_nr(leaf, i);
-			btrfs_set_item_offset_nr(leaf, i, ioff - total_data);
+			ioff = btrfs_item_offset(leaf, i);
+			btrfs_set_item_offset(leaf, i, ioff - total_data);
 		}
 
 		/* shift the items */
@@ -2851,9 +2851,9 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 	for (i = 0; i < nr; i++) {
 		btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
 		btrfs_set_item_key(leaf, &disk_key, slot + i);
-		btrfs_set_item_offset_nr(leaf, slot + i, data_end - data_size[i]);
+		btrfs_set_item_offset(leaf, slot + i, data_end - data_size[i]);
 		data_end -= data_size[i];
-		btrfs_set_item_size_nr(leaf, slot + i, data_size[i]);
+		btrfs_set_item_size(leaf, slot + i, data_size[i]);
 	}
 	btrfs_set_header_nritems(leaf, nritems + nr);
 	btrfs_mark_buffer_dirty(leaf);
@@ -2985,10 +2985,10 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 	u32 nritems;
 
 	leaf = path->nodes[0];
-	last_off = btrfs_item_offset_nr(leaf, slot + nr - 1);
+	last_off = btrfs_item_offset(leaf, slot + nr - 1);
 
 	for (i = 0; i < nr; i++)
-		dsize += btrfs_item_size_nr(leaf, slot + i);
+		dsize += btrfs_item_size(leaf, slot + i);
 
 	nritems = btrfs_header_nritems(leaf);
 
@@ -3003,8 +3003,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		for (i = slot + nr; i < nritems; i++) {
 			u32 ioff;
 
-			ioff = btrfs_item_offset_nr(leaf, i);
-			btrfs_set_item_offset_nr(leaf, i, ioff + dsize);
+			ioff = btrfs_item_offset(leaf, i);
+			btrfs_set_item_offset(leaf, i, ioff + dsize);
 		}
 
 		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
@@ -3334,7 +3334,7 @@ static int btrfs_uuid_tree_lookup(struct btrfs_root *uuid_root, u8 *uuid,
 
 	eb = path->nodes[0];
 	slot = path->slots[0];
-	item_size = btrfs_item_size_nr(eb, slot);
+	item_size = btrfs_item_size(eb, slot);
 	offset = btrfs_item_ptr_offset(eb, slot);
 	ret = -ENOENT;
 
@@ -3407,7 +3407,7 @@ int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
 		eb = path->nodes[0];
 		slot = path->slots[0];
 		offset = btrfs_item_ptr_offset(eb, slot);
-		offset += btrfs_item_size_nr(eb, slot) - sizeof(subvol_id_le);
+		offset += btrfs_item_size(eb, slot) - sizeof(subvol_id_le);
 	} else if (ret < 0) {
 		warning(
 		"inserting uuid item failed (0x%016llx, 0x%016llx) type %u: %d",
diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index befa244f..8b654dde 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -1980,8 +1980,8 @@ static inline void btrfs_set_node_key(struct extent_buffer *eb,
 }
 
 /* struct btrfs_item */
-BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
-BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
+BTRFS_SETGET_FUNCS(raw_item_offset, struct btrfs_item, offset, 32);
+BTRFS_SETGET_FUNCS(raw_item_size, struct btrfs_item, size, 32);
 
 static inline unsigned long btrfs_item_nr_offset(int nr)
 {
@@ -1994,31 +1994,23 @@ static inline struct btrfs_item *btrfs_item_nr(int nr)
 	return (struct btrfs_item *)btrfs_item_nr_offset(nr);
 }
 
-static inline void btrfs_set_item_size_nr(struct extent_buffer *eb, int nr,
-					  u32 size)
-{
-	btrfs_set_item_size(eb, btrfs_item_nr(nr), size);
+#define BTRFS_ITEM_SETGET_FUNCS(member)						\
+static inline u32 btrfs_item_##member(const struct extent_buffer *eb, int slot)	\
+{										\
+	return btrfs_raw_item_##member(eb, btrfs_item_nr(slot));		\
+}										\
+static inline void btrfs_set_item_##member(struct extent_buffer *eb,		\
+					   int slot, u32 val)			\
+{										\
+	btrfs_set_raw_item_##member(eb, btrfs_item_nr(slot), val);		\
 }
 
-static inline void btrfs_set_item_offset_nr(struct extent_buffer *eb, int nr,
-					    u32 offset)
-{
-	btrfs_set_item_offset(eb, btrfs_item_nr(nr), offset);
-}
-
-static inline u32 btrfs_item_offset_nr(const struct extent_buffer *eb, int nr)
-{
-	return btrfs_item_offset(eb, btrfs_item_nr(nr));
-}
-
-static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
-{
-	return btrfs_item_size(eb, btrfs_item_nr(nr));
-}
+BTRFS_ITEM_SETGET_FUNCS(size)
+BTRFS_ITEM_SETGET_FUNCS(offset)
 
 static inline u32 btrfs_item_end(struct extent_buffer *eb, int nr)
 {
-	return btrfs_item_offset_nr(eb, nr) + btrfs_item_size_nr(eb, nr);
+	return btrfs_item_offset(eb, nr) + btrfs_item_size(eb, nr);
 }
 
 static inline void btrfs_item_key(struct extent_buffer *eb,
@@ -2560,7 +2552,7 @@ static inline u64 btrfs_dev_stats_value(const struct extent_buffer *eb,
 static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
 						    int nr)
 {
-	return btrfs_item_size_nr(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
+	return btrfs_item_size(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
 }
 
 /* struct btrfs_ioctl_search_header */
@@ -2612,11 +2604,11 @@ static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
 /* helper function to cast into the data area of the leaf. */
 #define btrfs_item_ptr(leaf, slot, type) \
 	((type *)(btrfs_leaf_data(leaf) + \
-	btrfs_item_offset_nr(leaf, slot)))
+	btrfs_item_offset(leaf, slot)))
 
 #define btrfs_item_ptr_offset(leaf, slot) \
 	((unsigned long)(btrfs_leaf_data(leaf) + \
-	btrfs_item_offset_nr(leaf, slot)))
+	btrfs_item_offset(leaf, slot)))
 
 u64 btrfs_name_hash(const char *name, int len);
 u64 btrfs_extref_hash(u64 parent_objectid, const char *name, int len);
diff --git a/kernel-shared/dir-item.c b/kernel-shared/dir-item.c
index 729d4308..27dfb362 100644
--- a/kernel-shared/dir-item.c
+++ b/kernel-shared/dir-item.c
@@ -48,8 +48,8 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
 	WARN_ON(ret > 0);
 	leaf = path->nodes[0];
 	ptr = btrfs_item_ptr(leaf, path->slots[0], char);
-	BUG_ON(data_size > btrfs_item_size_nr(leaf, path->slots[0]));
-	ptr += btrfs_item_size_nr(leaf, path->slots[0]) - data_size;
+	BUG_ON(data_size > btrfs_item_size(leaf, path->slots[0]));
+	ptr += btrfs_item_size(leaf, path->slots[0]) - data_size;
 	return (struct btrfs_dir_item *)ptr;
 }
 
@@ -264,7 +264,7 @@ int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
 	leaf = path->nodes[0];
 	sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di) +
 		btrfs_dir_data_len(leaf, di);
-	item_len = btrfs_item_size_nr(leaf, path->slots[0]);
+	item_len = btrfs_item_size(leaf, path->slots[0]);
 
 	/*
 	 * If @sub_item_len is longer than @item_len, then it means the
@@ -329,7 +329,7 @@ struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
 
 	leaf = path->nodes[0];
 	dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
-	total_len = btrfs_item_size_nr(leaf, path->slots[0]);
+	total_len = btrfs_item_size(leaf, path->slots[0]);
 	if (verify_dir_item(root, leaf, dir_item))
 		return NULL;
 
diff --git a/kernel-shared/extent-tree.c b/kernel-shared/extent-tree.c
index 3713452b..e36745ca 100644
--- a/kernel-shared/extent-tree.c
+++ b/kernel-shared/extent-tree.c
@@ -929,7 +929,7 @@ again:
 	BUG_ON(ret);
 
 	leaf = path->nodes[0];
-	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+	item_size = btrfs_item_size(leaf, path->slots[0]);
 	if (item_size < sizeof(*ei)) {
 		printf("Size is %u, needs to be %u, slot %d\n",
 		       (unsigned)item_size,
@@ -1055,7 +1055,7 @@ static int setup_inline_extent_backref(struct btrfs_root *root,
 	btrfs_set_extent_refs(leaf, ei, refs);
 
 	ptr = (unsigned long)ei + item_offset;
-	end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
+	end = (unsigned long)ei + btrfs_item_size(leaf, path->slots[0]);
 	if (ptr < end - size)
 		memmove_extent_buffer(leaf, ptr + size, ptr,
 				      end - size - ptr);
@@ -1159,7 +1159,7 @@ static int update_inline_extent_backref(struct btrfs_trans_handle *trans,
 			btrfs_set_shared_data_ref_count(leaf, sref, refs);
 	} else {
 		size =  btrfs_extent_inline_ref_size(type);
-		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+		item_size = btrfs_item_size(leaf, path->slots[0]);
 		ptr = (unsigned long)iref;
 		end = (unsigned long)ei + item_size;
 		if (ptr + size < end)
@@ -1353,7 +1353,7 @@ again:
 	}
 
 	l = path->nodes[0];
-	item_size = btrfs_item_size_nr(l, path->slots[0]);
+	item_size = btrfs_item_size(l, path->slots[0]);
 	if (item_size >= sizeof(*item)) {
 		item = btrfs_item_ptr(l, path->slots[0],
 				      struct btrfs_extent_item);
@@ -1429,7 +1429,7 @@ again:
 		BUG();
 	}
 	l = path->nodes[0];
-	item_size = btrfs_item_size_nr(l, path->slots[0]);
+	item_size = btrfs_item_size(l, path->slots[0]);
 	if (item_size < sizeof(*item)) {
 		error(
 "unsupported or corrupted extent item, item size=%u expect minimal size=%zu",
@@ -2035,7 +2035,7 @@ static int __free_extent(struct btrfs_trans_handle *trans,
 	}
 
 	leaf = path->nodes[0];
-	item_size = btrfs_item_size_nr(leaf, extent_slot);
+	item_size = btrfs_item_size(leaf, extent_slot);
 	if (item_size < sizeof(*ei)) {
 		error(
 "unsupported or corrupted extent item, item size=%u expect minimal size=%zu",
diff --git a/kernel-shared/file-item.c b/kernel-shared/file-item.c
index 0d68ed52..b0fcd49d 100644
--- a/kernel-shared/file-item.c
+++ b/kernel-shared/file-item.c
@@ -170,7 +170,7 @@ btrfs_lookup_csum(struct btrfs_trans_handle *trans,
 
 		csum_offset = (bytenr - found_key.offset) /
 				root->fs_info->sectorsize;
-		csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
+		csums_in_item = btrfs_item_size(leaf, path->slots[0]);
 		csums_in_item /= csum_size;
 
 		if (csum_offset >= csums_in_item) {
@@ -235,7 +235,7 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
 		/* printf("item not big enough for bytenr %llu\n", bytenr); */
 		/* we found one, but it isn't big enough yet */
 		leaf = path->nodes[0];
-		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+		item_size = btrfs_item_size(leaf, path->slots[0]);
 		if ((item_size / csum_size) >= MAX_CSUM_ITEMS(root, csum_size)) {
 			/* already at max size, make a new one */
 			goto insert;
@@ -287,10 +287,10 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
 	    csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) {
 		goto insert;
 	}
-	if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
+	if (csum_offset >= btrfs_item_size(leaf, path->slots[0]) /
 	    csum_size) {
 		u32 diff = (csum_offset + 1) * csum_size;
-		diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
+		diff = diff - btrfs_item_size(leaf, path->slots[0]);
 		if (diff != csum_size)
 			goto insert;
 		ret = btrfs_extend_item(root, path, diff);
@@ -359,7 +359,7 @@ static noinline int truncate_one_csum(struct btrfs_root *root,
 	int ret;
 
 	leaf = path->nodes[0];
-	csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
+	csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
 	csum_end *= root->fs_info->sectorsize;
 	csum_end += key->offset;
 
@@ -439,7 +439,7 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans, u64 bytenr, u64 len)
 		if (key.offset >= end_byte)
 			break;
 
-		csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
+		csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
 		csum_end *= blocksize;
 		csum_end += key.offset;
 
diff --git a/kernel-shared/inode-item.c b/kernel-shared/inode-item.c
index 7ca75f6d..891ae40a 100644
--- a/kernel-shared/inode-item.c
+++ b/kernel-shared/inode-item.c
@@ -32,7 +32,7 @@ static int find_name_in_backref(struct btrfs_path *path, const char * name,
 	int len;
 
 	leaf = path->nodes[0];
-	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+	item_size = btrfs_item_size(leaf, path->slots[0]);
 	ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
 	while (cur_offset < item_size) {
 		ref = (struct btrfs_inode_ref *)(ptr + cur_offset);
@@ -77,7 +77,7 @@ int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
 		if (find_name_in_backref(path, name, name_len, &ref))
 			goto out;
 
-		old_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
+		old_size = btrfs_item_size(path->nodes[0], path->slots[0]);
 		ret = btrfs_extend_item(root, path, ins_len);
 		BUG_ON(ret);
 		ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
@@ -197,7 +197,7 @@ static int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
 
 	node = path->nodes[0];
 	slot = path->slots[0];
-	item_size = btrfs_item_size_nr(node, slot);
+	item_size = btrfs_item_size(node, slot);
 	ptr = btrfs_item_ptr_offset(node, slot);
 
 	/*
@@ -293,7 +293,7 @@ int btrfs_del_inode_extref(struct btrfs_trans_handle *trans,
 	}
 
 	leaf = path->nodes[0];
-	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+	item_size = btrfs_item_size(leaf, path->slots[0]);
 	if (index)
 		*index = btrfs_inode_extref_index(leaf, extref);
 
@@ -361,7 +361,7 @@ int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
 
 	leaf = path->nodes[0];
 	ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);
-	ptr += btrfs_item_size_nr(leaf, path->slots[0]) - ins_len;
+	ptr += btrfs_item_size(leaf, path->slots[0]) - ins_len;
 	extref = (struct btrfs_inode_extref *)ptr;
 
 	btrfs_set_inode_extref_name_len(path->nodes[0], extref, name_len);
@@ -416,7 +416,7 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
 		goto out;
 	}
 	leaf = path->nodes[0];
-	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+	item_size = btrfs_item_size(leaf, path->slots[0]);
 
 	if (index)
 		*index = btrfs_inode_ref_index(leaf, ref);
diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c
index aff2ebc4..717be5d5 100644
--- a/kernel-shared/print-tree.c
+++ b/kernel-shared/print-tree.c
@@ -440,7 +440,7 @@ void print_extent_item(struct extent_buffer *eb, int slot, int metadata)
 	unsigned long end;
 	unsigned long ptr;
 	int type;
-	u32 item_size = btrfs_item_size_nr(eb, slot);
+	u32 item_size = btrfs_item_size(eb, slot);
 	u64 flags;
 	u64 offset;
 	char flags_str[32] = {0};
@@ -571,7 +571,7 @@ static void print_root_item(struct extent_buffer *leaf, int slot)
 	struct btrfs_key drop_key;
 
 	ri = btrfs_item_ptr(leaf, slot, struct btrfs_root_item);
-	len = btrfs_item_size_nr(leaf, slot);
+	len = btrfs_item_size(leaf, slot);
 
 	memset(&root_item, 0, sizeof(root_item));
 	read_extent_buffer(leaf, &root_item, (unsigned long)ri, len);
@@ -1306,18 +1306,18 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 		 * Only need to ensure all pointers are pointing range inside
 		 * the leaf, thus no segfault.
 		 */
-		if (btrfs_item_offset_nr(eb, i) > leaf_data_size ||
-		    btrfs_item_size_nr(eb, i) + btrfs_item_offset_nr(eb, i) >
+		if (btrfs_item_offset(eb, i) > leaf_data_size ||
+		    btrfs_item_size(eb, i) + btrfs_item_offset(eb, i) >
 		    leaf_data_size) {
 			error(
 "leaf %llu slot %u pointer invalid, offset %u size %u leaf data limit %u",
 			      btrfs_header_bytenr(eb), i,
-			      btrfs_item_offset_nr(eb, i),
-			      btrfs_item_size_nr(eb, i), leaf_data_size);
+			      btrfs_item_offset(eb, i),
+			      btrfs_item_size(eb, i), leaf_data_size);
 			error("skip remaining slots");
 			break;
 		}
-		item_size = btrfs_item_size_nr(eb, i);
+		item_size = btrfs_item_size(eb, i);
 		/* Untyped extraction of slot from btrfs_item_ptr */
 		ptr = btrfs_item_ptr(eb, i, void*);
 
@@ -1329,8 +1329,8 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 		printf("\titem %u ", i);
 		btrfs_print_key(&disk_key);
 		printf(" itemoff %u itemsize %u\n",
-			btrfs_item_offset_nr(eb, i),
-			btrfs_item_size_nr(eb, i));
+			btrfs_item_offset(eb, i),
+			btrfs_item_size(eb, i));
 
 		if (type == 0 && objectid == BTRFS_FREE_SPACE_OBJECTID)
 			print_free_space_header(eb, i);
@@ -1436,7 +1436,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode)
 		case BTRFS_UUID_KEY_SUBVOL:
 		case BTRFS_UUID_KEY_RECEIVED_SUBVOL:
 			print_uuid_item(eb, btrfs_item_ptr_offset(eb, i),
-					btrfs_item_size_nr(eb, i));
+					btrfs_item_size(eb, i));
 			break;
 		case BTRFS_STRING_ITEM_KEY: {
 			const char *str = eb->data + btrfs_item_ptr_offset(eb, i);
diff --git a/kernel-shared/root-tree.c b/kernel-shared/root-tree.c
index bc410963..0f83f915 100644
--- a/kernel-shared/root-tree.c
+++ b/kernel-shared/root-tree.c
@@ -87,7 +87,7 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
 	l = path->nodes[0];
 	slot = path->slots[0];
 	ptr = btrfs_item_ptr_offset(l, slot);
-	old_len = btrfs_item_size_nr(l, slot);
+	old_len = btrfs_item_size(l, slot);
 
 	/*
 	 * If this is the first time we update the root item which originated
diff --git a/kernel-shared/uuid-tree.c b/kernel-shared/uuid-tree.c
index c0b3406a..6de9a178 100644
--- a/kernel-shared/uuid-tree.c
+++ b/kernel-shared/uuid-tree.c
@@ -154,7 +154,7 @@ int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
 	eb = path->nodes[0];
 	slot = path->slots[0];
 	offset = btrfs_item_ptr_offset(eb, slot);
-	item_size = btrfs_item_size_nr(eb, slot);
+	item_size = btrfs_item_size(eb, slot);
 	if (!IS_ALIGNED(item_size, sizeof(u64))) {
 		warning("uuid item with illegal size %u!", item_size);
 		ret = -ENOENT;
@@ -175,7 +175,7 @@ int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
 		goto out;
 	}
 
-	item_size = btrfs_item_size_nr(eb, slot);
+	item_size = btrfs_item_size(eb, slot);
 	if (item_size == sizeof(subid)) {
 		ret = btrfs_del_item(trans, uuid_root, path);
 		goto out;
diff --git a/kernel-shared/volumes.c b/kernel-shared/volumes.c
index 4274c378..e24428db 100644
--- a/kernel-shared/volumes.c
+++ b/kernel-shared/volumes.c
@@ -2103,9 +2103,9 @@ int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
 	 * one stripe, so no "==" check.
 	 */
 	if (slot >= 0 &&
-	    btrfs_item_size_nr(leaf, slot) < sizeof(struct btrfs_chunk)) {
+	    btrfs_item_size(leaf, slot) < sizeof(struct btrfs_chunk)) {
 		error("invalid chunk item size, have %u expect [%zu, %u)",
-			btrfs_item_size_nr(leaf, slot),
+			btrfs_item_size(leaf, slot),
 			sizeof(struct btrfs_chunk),
 			BTRFS_LEAF_DATA_SIZE(fs_info));
 		return -EUCLEAN;
@@ -2122,9 +2122,9 @@ int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
 		return -EUCLEAN;
 	}
 	if (slot >= 0 && btrfs_chunk_item_size(num_stripes) !=
-	    btrfs_item_size_nr(leaf, slot)) {
+	    btrfs_item_size(leaf, slot)) {
 		error("invalid chunk item size, have %u expect %lu",
-			btrfs_item_size_nr(leaf, slot),
+			btrfs_item_size(leaf, slot),
 			btrfs_chunk_item_size(num_stripes));
 		return -EUCLEAN;
 	}
@@ -2184,7 +2184,7 @@ int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
 	 */
 	if (num_stripes < 1 ||
 	    (slot == -1 && chunk_ondisk_size > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) ||
-	    (slot >= 0 && chunk_ondisk_size > btrfs_item_size_nr(leaf, slot))) {
+	    (slot >= 0 && chunk_ondisk_size > btrfs_item_size(leaf, slot))) {
 		error("invalid num_stripes: %u", num_stripes);
 		return -EIO;
 	}
diff --git a/mkfs/common.c b/mkfs/common.c
index 0ea0d114..11d92c8b 100644
--- a/mkfs/common.c
+++ b/mkfs/common.c
@@ -104,8 +104,8 @@ static int btrfs_create_tree_root(int fd, struct btrfs_mkfs_config *cfg,
 		btrfs_set_disk_key_objectid(&disk_key,
 			reference_root_table[blk]);
 		btrfs_set_item_key(buf, &disk_key, nritems);
-		btrfs_set_item_offset_nr(buf, nritems, itemoff);
-		btrfs_set_item_size_nr(buf, nritems, sizeof(root_item));
+		btrfs_set_item_offset(buf, nritems, itemoff);
+		btrfs_set_item_size(buf, nritems, sizeof(root_item));
 		if (blk == MKFS_FS_TREE) {
 			time_t now = time(NULL);
 
@@ -159,8 +159,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg,
 	btrfs_set_disk_key_offset(&disk_key, group_size);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_INFO_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset_nr(buf, nritems, itemoff);
-	btrfs_set_item_size_nr(buf, nritems, sizeof(*info));
+	btrfs_set_item_offset(buf, nritems, itemoff);
+	btrfs_set_item_size(buf, nritems, sizeof(*info));
 
 	info = btrfs_item_ptr(buf, nritems, struct btrfs_free_space_info);
 	btrfs_set_free_space_extent_count(buf, info, 1);
@@ -171,8 +171,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg,
 	btrfs_set_disk_key_offset(&disk_key, group_start + group_size - free_start);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_EXTENT_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset_nr(buf, nritems, itemoff);
-	btrfs_set_item_size_nr(buf, nritems, 0);
+	btrfs_set_item_offset(buf, nritems, itemoff);
+	btrfs_set_item_size(buf, nritems, 0);
 
 	nritems++;
 	btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_FREE_SPACE_TREE]);
@@ -340,8 +340,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 			btrfs_set_disk_key_offset(&disk_key, system_group_size);
 			btrfs_set_disk_key_type(&disk_key, BTRFS_BLOCK_GROUP_ITEM_KEY);
 			btrfs_set_item_key(buf, &disk_key, nritems);
-			btrfs_set_item_offset_nr(buf, nritems, itemoff);
-			btrfs_set_item_size_nr(buf, nritems, sizeof(*bg_item));
+			btrfs_set_item_offset(buf, nritems, itemoff);
+			btrfs_set_item_size(buf, nritems, sizeof(*bg_item));
 
 			bg_item = btrfs_item_ptr(buf, nritems,
 						 struct btrfs_block_group_item);
@@ -386,8 +386,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 			btrfs_set_disk_key_offset(&disk_key, cfg->nodesize);
 		}
 		btrfs_set_item_key(buf, &disk_key, nritems);
-		btrfs_set_item_offset_nr(buf, nritems, itemoff);
-		btrfs_set_item_size_nr(buf, nritems, item_size);
+		btrfs_set_item_offset(buf, nritems, itemoff);
+		btrfs_set_item_size(buf, nritems, item_size);
 		extent_item = btrfs_item_ptr(buf, nritems,
 					     struct btrfs_extent_item);
 		btrfs_set_extent_refs(buf, extent_item, 1);
@@ -402,8 +402,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 		btrfs_set_disk_key_offset(&disk_key, ref_root);
 		btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY);
 		btrfs_set_item_key(buf, &disk_key, nritems);
-		btrfs_set_item_offset_nr(buf, nritems, itemoff);
-		btrfs_set_item_size_nr(buf, nritems, 0);
+		btrfs_set_item_offset(buf, nritems, itemoff);
+		btrfs_set_item_size(buf, nritems, 0);
 		nritems++;
 	}
 	btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_EXTENT_TREE]);
@@ -430,8 +430,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	btrfs_set_disk_key_offset(&disk_key, 1);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset_nr(buf, nritems, itemoff);
-	btrfs_set_item_size_nr(buf, nritems, item_size);
+	btrfs_set_item_offset(buf, nritems, itemoff);
+	btrfs_set_item_size(buf, nritems, item_size);
 
 	dev_item = btrfs_item_ptr(buf, nritems, struct btrfs_dev_item);
 	btrfs_set_device_id(buf, dev_item, 1);
@@ -461,8 +461,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	btrfs_set_disk_key_offset(&disk_key, system_group_offset);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset_nr(buf, nritems, itemoff);
-	btrfs_set_item_size_nr(buf, nritems, item_size);
+	btrfs_set_item_offset(buf, nritems, itemoff);
+	btrfs_set_item_size(buf, nritems, item_size);
 
 	chunk = btrfs_item_ptr(buf, nritems, struct btrfs_chunk);
 	btrfs_set_chunk_length(buf, chunk, system_group_size);
@@ -517,8 +517,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
 	btrfs_set_disk_key_offset(&disk_key, system_group_offset);
 	btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY);
 	btrfs_set_item_key(buf, &disk_key, nritems);
-	btrfs_set_item_offset_nr(buf, nritems, itemoff);
-	btrfs_set_item_size_nr(buf, nritems, sizeof(struct btrfs_dev_extent));
+	btrfs_set_item_offset(buf, nritems, itemoff);
+	btrfs_set_item_size(buf, nritems, sizeof(struct btrfs_dev_extent));
 	dev_extent = btrfs_item_ptr(buf, nritems, struct btrfs_dev_extent);
 	btrfs_set_dev_extent_chunk_tree(buf, dev_extent,
 					BTRFS_CHUNK_TREE_OBJECTID);
-- 
2.26.3

[PATCH 11/13] btrfs-progs: replace btrfs_item_nr_offset(0)

[Josef Bacik]

btrfs_item_nr_offset(0) is simply offsetof(struct btrfs_leaf, items),
which is the same thing as btrfs_leaf_data(), so replace all calls of
btrfs_item_nr_offset(0) with btrfs_leaf_data().

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 kernel-shared/ctree.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
index 04847cd5..e164492b 100644
--- a/kernel-shared/ctree.c
+++ b/kernel-shared/ctree.c
@@ -2075,11 +2075,11 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 		     btrfs_leaf_data(left) + leaf_data_end(left), push_space);
 
 	memmove_extent_buffer(right, btrfs_item_nr_offset(push_items),
-			      btrfs_item_nr_offset(0),
+			      btrfs_leaf_data(right),
 			      right_nritems * sizeof(struct btrfs_item));
 
 	/* copy the items from left to right */
-	copy_extent_buffer(right, left, btrfs_item_nr_offset(0),
+	copy_extent_buffer(right, left, btrfs_leaf_data(right),
 		   btrfs_item_nr_offset(left_nritems - push_items),
 		   push_items * sizeof(struct btrfs_item));
 
@@ -2198,7 +2198,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 	/* push data from right to left */
 	copy_extent_buffer(left, right,
 			   btrfs_item_nr_offset(btrfs_header_nritems(left)),
-			   btrfs_item_nr_offset(0),
+			   btrfs_leaf_data(right),
 			   push_items * sizeof(struct btrfs_item));
 
 	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info) -
@@ -2238,7 +2238,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 				      btrfs_leaf_data(right) +
 				      leaf_data_end(right), push_space);
 
-		memmove_extent_buffer(right, btrfs_item_nr_offset(0),
+		memmove_extent_buffer(right, btrfs_leaf_data(right),
 			      btrfs_item_nr_offset(push_items),
 			     (btrfs_header_nritems(right) - push_items) *
 			     sizeof(struct btrfs_item));
@@ -2296,7 +2296,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 	btrfs_set_header_nritems(right, nritems);
 	data_copy_size = btrfs_item_end(l, mid) - leaf_data_end(l);
 
-	copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
+	copy_extent_buffer(right, l, btrfs_leaf_data(right),
 			   btrfs_item_nr_offset(mid),
 			   nritems * sizeof(struct btrfs_item));
 
-- 
2.26.3

[PATCH 12/13] btrfs-progs: rework the btrfs_node accessors to match the item accessors

[Josef Bacik]

We are duplicating the offsetof(btrfs_node, key_ptr) logic everywhere,
instead use the helper to do this work for us, and make all the node
accessors use the helper.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 kernel-shared/ctree.h | 49 +++++++++++++++++--------------------------
 1 file changed, 19 insertions(+), 30 deletions(-)

diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index 8b654dde..464a0f74 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -1921,62 +1921,51 @@ BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
 
-static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
+static inline unsigned long btrfs_node_key_ptr_offset(int nr)
 {
-	unsigned long ptr;
-	ptr = offsetof(struct btrfs_node, ptrs) +
+	return offsetof(struct btrfs_node, ptrs) +
 		sizeof(struct btrfs_key_ptr) * nr;
-	return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
+}
+
+static inline struct btrfs_key_ptr *btrfs_node_key_ptr(int nr)
+{
+	return (struct btrfs_key_ptr *)btrfs_node_key_ptr_offset(nr);
+}
+
+static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
+{
+	return btrfs_key_blockptr(eb, btrfs_node_key_ptr(nr));
 }
 
 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
 					   int nr, u64 val)
 {
-	unsigned long ptr;
-	ptr = offsetof(struct btrfs_node, ptrs) +
-		sizeof(struct btrfs_key_ptr) * nr;
-	btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
+	btrfs_set_key_blockptr(eb, btrfs_node_key_ptr(nr), val);
 }
 
 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
 {
-	unsigned long ptr;
-	ptr = offsetof(struct btrfs_node, ptrs) +
-		sizeof(struct btrfs_key_ptr) * nr;
-	return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
+	return btrfs_key_generation(eb, btrfs_node_key_ptr(nr));
 }
 
 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
 						 int nr, u64 val)
 {
-	unsigned long ptr;
-	ptr = offsetof(struct btrfs_node, ptrs) +
-		sizeof(struct btrfs_key_ptr) * nr;
-	btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
-}
-
-static inline unsigned long btrfs_node_key_ptr_offset(int nr)
-{
-	return offsetof(struct btrfs_node, ptrs) +
-		sizeof(struct btrfs_key_ptr) * nr;
+	btrfs_set_key_generation(eb, btrfs_node_key_ptr(nr), val);
 }
 
 static inline void btrfs_node_key(struct extent_buffer *eb,
 				  struct btrfs_disk_key *disk_key, int nr)
 {
-	unsigned long ptr;
-	ptr = btrfs_node_key_ptr_offset(nr);
-	read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
-		       struct btrfs_key_ptr, key, disk_key);
+	read_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key,
+		       disk_key);
 }
 
 static inline void btrfs_set_node_key(struct extent_buffer *eb,
 				      struct btrfs_disk_key *disk_key, int nr)
 {
-	unsigned long ptr;
-	ptr = btrfs_node_key_ptr_offset(nr);
-	write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
-		       struct btrfs_key_ptr, key, disk_key);
+	write_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key,
+			disk_key);
 }
 
 /* struct btrfs_item */
-- 
2.26.3

[PATCH 13/13] btrfs-progs: make all of the item/key_ptr offset helpers take an eb

[Josef Bacik]

When we change the size of the btrfs_header we're going to need to
change how these helpers calculate where to find the start of items or
block ptrs.  To prepare for that make these helpers take the
extent_buffer as an argument so we can do the appropriate math based on
the version type.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
---
 check/main.c          | 13 ++++++-----
 image/main.c          |  4 ++--
 kernel-shared/ctree.c | 54 +++++++++++++++++++++----------------------
 kernel-shared/ctree.h | 36 ++++++++++++++---------------
 4 files changed, 54 insertions(+), 53 deletions(-)

diff --git a/check/main.c b/check/main.c
index ed3fde60..39cb1ce5 100644
--- a/check/main.c
+++ b/check/main.c
@@ -4192,16 +4192,17 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
 	if (btrfs_header_level(buf)) {
 		struct btrfs_key_ptr ptr1, ptr2;
 
-		read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
+		read_extent_buffer(buf, &ptr1,
+				   btrfs_node_key_ptr_offset(buf, slot),
 				   sizeof(struct btrfs_key_ptr));
 		read_extent_buffer(buf, &ptr2,
-				   btrfs_node_key_ptr_offset(slot + 1),
+				   btrfs_node_key_ptr_offset(buf, slot + 1),
 				   sizeof(struct btrfs_key_ptr));
 		write_extent_buffer(buf, &ptr1,
-				    btrfs_node_key_ptr_offset(slot + 1),
+				    btrfs_node_key_ptr_offset(buf, slot + 1),
 				    sizeof(struct btrfs_key_ptr));
 		write_extent_buffer(buf, &ptr2,
-				    btrfs_node_key_ptr_offset(slot),
+				    btrfs_node_key_ptr_offset(buf, slot),
 				    sizeof(struct btrfs_key_ptr));
 		if (slot == 0) {
 			struct btrfs_disk_key key;
@@ -4299,8 +4300,8 @@ static int delete_bogus_item(struct btrfs_root *root,
 	printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
 	       (unsigned long long)key.objectid, key.type,
 	       (unsigned long long)key.offset, slot, buf->start);
-	memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
-			      btrfs_item_nr_offset(slot + 1),
+	memmove_extent_buffer(buf, btrfs_item_nr_offset(buf, slot),
+			      btrfs_item_nr_offset(buf, slot + 1),
 			      sizeof(struct btrfs_item) *
 			      (nritems - slot - 1));
 	btrfs_set_header_nritems(buf, nritems - 1);
diff --git a/image/main.c b/image/main.c
index ff121fca..c6af0cc2 100644
--- a/image/main.c
+++ b/image/main.c
@@ -360,8 +360,8 @@ static void copy_buffer(struct metadump_struct *md, u8 *dst,
 	} else if (level == 0) {
 		size = btrfs_leaf_data(src) +
 			btrfs_item_offset(src, nritems - 1) -
-			btrfs_item_nr_offset(nritems);
-		memset(dst + btrfs_item_nr_offset(nritems), 0, size);
+			btrfs_item_nr_offset(src, nritems);
+		memset(dst + btrfs_item_nr_offset(src, nritems), 0, size);
 		zero_items(md, dst, src);
 	} else {
 		size = offsetof(struct btrfs_node, ptrs) +
diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
index e164492b..758a3882 100644
--- a/kernel-shared/ctree.c
+++ b/kernel-shared/ctree.c
@@ -756,10 +756,10 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info,
 
 		/* Also check if the item pointer overlaps with btrfs item. */
 		if (btrfs_item_ptr_offset(leaf, slot) <
-		    btrfs_item_nr_offset(slot) + sizeof(struct btrfs_item)) {
+		    btrfs_item_nr_offset(leaf, slot) + sizeof(struct btrfs_item)) {
 			generic_err(leaf, slot,
 		"slot overlaps with its data, item end %lu data start %lu",
-				btrfs_item_nr_offset(slot) +
+				btrfs_item_nr_offset(leaf, slot) +
 				sizeof(struct btrfs_item),
 				btrfs_item_ptr_offset(leaf, slot));
 			ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS;
@@ -1638,13 +1638,13 @@ static int push_node_left(struct btrfs_trans_handle *trans,
 		push_items = min(src_nritems - 8, push_items);
 
 	copy_extent_buffer(dst, src,
-			   btrfs_node_key_ptr_offset(dst_nritems),
-			   btrfs_node_key_ptr_offset(0),
+			   btrfs_node_key_ptr_offset(dst, dst_nritems),
+			   btrfs_node_key_ptr_offset(src, 0),
 		           push_items * sizeof(struct btrfs_key_ptr));
 
 	if (push_items < src_nritems) {
-		memmove_extent_buffer(src, btrfs_node_key_ptr_offset(0),
-				      btrfs_node_key_ptr_offset(push_items),
+		memmove_extent_buffer(src, btrfs_node_key_ptr_offset(src, 0),
+				      btrfs_node_key_ptr_offset(src, push_items),
 				      (src_nritems - push_items) *
 				      sizeof(struct btrfs_key_ptr));
 	}
@@ -1699,14 +1699,14 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
 	if (max_push < push_items)
 		push_items = max_push;
 
-	memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(push_items),
-				      btrfs_node_key_ptr_offset(0),
+	memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(dst, push_items),
+				      btrfs_node_key_ptr_offset(dst, 0),
 				      (dst_nritems) *
 				      sizeof(struct btrfs_key_ptr));
 
 	copy_extent_buffer(dst, src,
-			   btrfs_node_key_ptr_offset(0),
-			   btrfs_node_key_ptr_offset(src_nritems - push_items),
+			   btrfs_node_key_ptr_offset(dst, 0),
+			   btrfs_node_key_ptr_offset(src, src_nritems - push_items),
 		           push_items * sizeof(struct btrfs_key_ptr));
 
 	btrfs_set_header_nritems(src, src_nritems - push_items);
@@ -1816,8 +1816,8 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
 	if (slot < nritems) {
 		/* shift the items */
 		memmove_extent_buffer(lower,
-			      btrfs_node_key_ptr_offset(slot + 1),
-			      btrfs_node_key_ptr_offset(slot),
+			      btrfs_node_key_ptr_offset(lower, slot + 1),
+			      btrfs_node_key_ptr_offset(lower, slot),
 			      (nritems - slot) * sizeof(struct btrfs_key_ptr));
 	}
 	btrfs_set_node_key(lower, key, slot);
@@ -1891,8 +1891,8 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
 	root_add_used(root, root->fs_info->nodesize);
 
 	copy_extent_buffer(split, c,
-			   btrfs_node_key_ptr_offset(0),
-			   btrfs_node_key_ptr_offset(mid),
+			   btrfs_node_key_ptr_offset(split, 0),
+			   btrfs_node_key_ptr_offset(c, mid),
 			   (c_nritems - mid) * sizeof(struct btrfs_key_ptr));
 	btrfs_set_header_nritems(split, c_nritems - mid);
 	btrfs_set_header_nritems(c, mid);
@@ -2074,13 +2074,13 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
 		     BTRFS_LEAF_DATA_SIZE(root->fs_info) - push_space,
 		     btrfs_leaf_data(left) + leaf_data_end(left), push_space);
 
-	memmove_extent_buffer(right, btrfs_item_nr_offset(push_items),
+	memmove_extent_buffer(right, btrfs_item_nr_offset(right, push_items),
 			      btrfs_leaf_data(right),
 			      right_nritems * sizeof(struct btrfs_item));
 
 	/* copy the items from left to right */
 	copy_extent_buffer(right, left, btrfs_leaf_data(right),
-		   btrfs_item_nr_offset(left_nritems - push_items),
+		   btrfs_item_nr_offset(left, left_nritems - push_items),
 		   push_items * sizeof(struct btrfs_item));
 
 	/* update the item pointers */
@@ -2197,7 +2197,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 
 	/* push data from right to left */
 	copy_extent_buffer(left, right,
-			   btrfs_item_nr_offset(btrfs_header_nritems(left)),
+			   btrfs_item_nr_offset(left, btrfs_header_nritems(left)),
 			   btrfs_leaf_data(right),
 			   push_items * sizeof(struct btrfs_item));
 
@@ -2239,7 +2239,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
 				      leaf_data_end(right), push_space);
 
 		memmove_extent_buffer(right, btrfs_leaf_data(right),
-			      btrfs_item_nr_offset(push_items),
+			      btrfs_item_nr_offset(right, push_items),
 			     (btrfs_header_nritems(right) - push_items) *
 			     sizeof(struct btrfs_item));
 	}
@@ -2297,7 +2297,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
 	data_copy_size = btrfs_item_end(l, mid) - leaf_data_end(l);
 
 	copy_extent_buffer(right, l, btrfs_leaf_data(right),
-			   btrfs_item_nr_offset(mid),
+			   btrfs_item_nr_offset(l, mid),
 			   nritems * sizeof(struct btrfs_item));
 
 	copy_extent_buffer(right, l,
@@ -2576,8 +2576,8 @@ split:
 
 	if (slot < nritems) {
 		/* shift the items */
-		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + 1),
-			      btrfs_item_nr_offset(slot),
+		memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, slot + 1),
+			      btrfs_item_nr_offset(leaf, slot),
 			      (nritems - slot) * sizeof(struct btrfs_item));
 
 	}
@@ -2836,8 +2836,8 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 		}
 
 		/* shift the items */
-		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
-			      btrfs_item_nr_offset(slot),
+		memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, slot + nr),
+			      btrfs_item_nr_offset(leaf, slot),
 			      (nritems - slot) * sizeof(struct btrfs_item));
 
 		/* shift the data */
@@ -2919,8 +2919,8 @@ int btrfs_del_ptr(struct btrfs_root *root, struct btrfs_path *path,
 	if (slot < nritems - 1) {
 		/* shift the items */
 		memmove_extent_buffer(parent,
-			      btrfs_node_key_ptr_offset(slot),
-			      btrfs_node_key_ptr_offset(slot + 1),
+			      btrfs_node_key_ptr_offset(parent, slot),
+			      btrfs_node_key_ptr_offset(parent, slot + 1),
 			      sizeof(struct btrfs_key_ptr) *
 			      (nritems - slot - 1));
 	}
@@ -3007,8 +3007,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 			btrfs_set_item_offset(leaf, i, ioff + dsize);
 		}
 
-		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
-			      btrfs_item_nr_offset(slot + nr),
+		memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, slot),
+			      btrfs_item_nr_offset(leaf, slot + nr),
 			      sizeof(struct btrfs_item) *
 			      (nritems - slot - nr));
 	}
diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h
index 464a0f74..addfafc7 100644
--- a/kernel-shared/ctree.h
+++ b/kernel-shared/ctree.h
@@ -1921,77 +1921,77 @@ BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
 
-static inline unsigned long btrfs_node_key_ptr_offset(int nr)
+static inline unsigned long btrfs_node_key_ptr_offset(const struct extent_buffer *eb, int nr)
 {
 	return offsetof(struct btrfs_node, ptrs) +
 		sizeof(struct btrfs_key_ptr) * nr;
 }
 
-static inline struct btrfs_key_ptr *btrfs_node_key_ptr(int nr)
+static inline struct btrfs_key_ptr *btrfs_node_key_ptr(const struct extent_buffer *eb, int nr)
 {
-	return (struct btrfs_key_ptr *)btrfs_node_key_ptr_offset(nr);
+	return (struct btrfs_key_ptr *)btrfs_node_key_ptr_offset(eb, nr);
 }
 
 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
 {
-	return btrfs_key_blockptr(eb, btrfs_node_key_ptr(nr));
+	return btrfs_key_blockptr(eb, btrfs_node_key_ptr(eb, nr));
 }
 
 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
 					   int nr, u64 val)
 {
-	btrfs_set_key_blockptr(eb, btrfs_node_key_ptr(nr), val);
+	btrfs_set_key_blockptr(eb, btrfs_node_key_ptr(eb, nr), val);
 }
 
 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
 {
-	return btrfs_key_generation(eb, btrfs_node_key_ptr(nr));
+	return btrfs_key_generation(eb, btrfs_node_key_ptr(eb, nr));
 }
 
 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
 						 int nr, u64 val)
 {
-	btrfs_set_key_generation(eb, btrfs_node_key_ptr(nr), val);
+	btrfs_set_key_generation(eb, btrfs_node_key_ptr(eb, nr), val);
 }
 
 static inline void btrfs_node_key(struct extent_buffer *eb,
 				  struct btrfs_disk_key *disk_key, int nr)
 {
-	read_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key,
-		       disk_key);
+	read_eb_member(eb, btrfs_node_key_ptr(eb, nr), struct btrfs_key_ptr,
+		       key, disk_key);
 }
 
 static inline void btrfs_set_node_key(struct extent_buffer *eb,
 				      struct btrfs_disk_key *disk_key, int nr)
 {
-	write_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key,
-			disk_key);
+	write_eb_member(eb, btrfs_node_key_ptr(eb, nr), struct btrfs_key_ptr,
+			key, disk_key);
 }
 
 /* struct btrfs_item */
 BTRFS_SETGET_FUNCS(raw_item_offset, struct btrfs_item, offset, 32);
 BTRFS_SETGET_FUNCS(raw_item_size, struct btrfs_item, size, 32);
 
-static inline unsigned long btrfs_item_nr_offset(int nr)
+static inline unsigned long btrfs_item_nr_offset(const struct extent_buffer *eb, int nr)
 {
 	return offsetof(struct btrfs_leaf, items) +
 		sizeof(struct btrfs_item) * nr;
 }
 
-static inline struct btrfs_item *btrfs_item_nr(int nr)
+static inline struct btrfs_item *btrfs_item_nr(const struct extent_buffer *eb, int nr)
 {
-	return (struct btrfs_item *)btrfs_item_nr_offset(nr);
+	return (struct btrfs_item *)btrfs_item_nr_offset(eb, nr);
 }
 
 #define BTRFS_ITEM_SETGET_FUNCS(member)						\
 static inline u32 btrfs_item_##member(const struct extent_buffer *eb, int slot)	\
 {										\
-	return btrfs_raw_item_##member(eb, btrfs_item_nr(slot));		\
+	return btrfs_raw_item_##member(eb, btrfs_item_nr(eb, slot));		\
 }										\
 static inline void btrfs_set_item_##member(struct extent_buffer *eb,		\
 					   int slot, u32 val)			\
 {										\
-	btrfs_set_raw_item_##member(eb, btrfs_item_nr(slot), val);		\
+	btrfs_set_raw_item_##member(eb, btrfs_item_nr(eb, slot), val);		\
 }
 
 BTRFS_ITEM_SETGET_FUNCS(size)
@@ -2005,14 +2005,14 @@ static inline u32 btrfs_item_end(struct extent_buffer *eb, int nr)
 static inline void btrfs_item_key(struct extent_buffer *eb,
 			   struct btrfs_disk_key *disk_key, int nr)
 {
-	struct btrfs_item *item = btrfs_item_nr(nr);
+	struct btrfs_item *item = btrfs_item_nr(eb, nr);
 	read_eb_member(eb, item, struct btrfs_item, key, disk_key);
 }
 
 static inline void btrfs_set_item_key(struct extent_buffer *eb,
 			       struct btrfs_disk_key *disk_key, int nr)
 {
-	struct btrfs_item *item = btrfs_item_nr(nr);
+	struct btrfs_item *item = btrfs_item_nr(eb, nr);
 	write_eb_member(eb, item, struct btrfs_item, key, disk_key);
 }
 
-- 
2.26.3

Re: [PATCH 01/13] btrfs-progs: turn on more compiler warnings and use -Wall

[David Sterba]

On Tue, Feb 22, 2022 at 05:26:11PM -0500, Josef Bacik wrote:
> In converting some of our helpers to take new args I would miss some
> locations because we don't stop on any warning, and I would miss the
> warning in the scrollback.  Fix this by stopping compiling on any error
> and turn on the fancy compiler checks.
> 
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> ---
>  Makefile | 3 +++
>  1 file changed, 3 insertions(+)
> 
> diff --git a/Makefile b/Makefile
> index af4908f9..e0921ca3 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -93,6 +93,9 @@ CFLAGS = $(SUBST_CFLAGS) \
>  	 -D_XOPEN_SOURCE=700  \
>  	 -fno-strict-aliasing \
>  	 -fPIC \
> +	 -Wall \
> +	 -Wunused-but-set-parameter \
> +	 -Werror \

That's in the default flags and based on the recent experience in kernel
defaulting to Werror it creates more problems than not. The build is
clean enough that new warnings are quite obvious and get fixed right
away.

You can always use the EXTRA_CFLAG=-Werror when developing or you can
also set CFLAGS=-Werror at configure time, as they get stored in the
generated Makefile.inc into SUBST_CFLAGS.

Re: [PATCH 01/13] btrfs-progs: turn on more compiler warnings and use -Wall

[David Sterba]

On Tue, Mar 08, 2022 at 05:51:26PM +0100, David Sterba wrote:
> On Tue, Feb 22, 2022 at 05:26:11PM -0500, Josef Bacik wrote:
> > In converting some of our helpers to take new args I would miss some
> > locations because we don't stop on any warning, and I would miss the
> > warning in the scrollback.  Fix this by stopping compiling on any error
> > and turn on the fancy compiler checks.
> > 
> > Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> > ---
> >  Makefile | 3 +++
> >  1 file changed, 3 insertions(+)
> > 
> > diff --git a/Makefile b/Makefile
> > index af4908f9..e0921ca3 100644
> > --- a/Makefile
> > +++ b/Makefile
> > @@ -93,6 +93,9 @@ CFLAGS = $(SUBST_CFLAGS) \
> >  	 -D_XOPEN_SOURCE=700  \
> >  	 -fno-strict-aliasing \
> >  	 -fPIC \
> > +	 -Wall \
> > +	 -Wunused-but-set-parameter \
> > +	 -Werror \
> 
> That's in the default flags and based on the recent experience in kernel
> defaulting to Werror it creates more problems than not. The build is
> clean enough that new warnings are quite obvious and get fixed right
> away.
> 
> You can always use the EXTRA_CFLAG=-Werror when developing or you can
> also set CFLAGS=-Werror at configure time, as they get stored in the
> generated Makefile.inc into SUBST_CFLAGS.

And actually there's make parameter W=1 like in kernel, that enables
more warnings though the W=1 build is not clean. I'd rather not clutter
the default flags by random warnings at all as the build is supposed to
work on various LTS distros and compilers so that would probably fail
build.

Re: [PATCH 01/13] btrfs-progs: turn on more compiler warnings and use -Wall

[David Sterba]

On Tue, Mar 08, 2022 at 07:15:03PM +0100, David Sterba wrote:
> On Tue, Mar 08, 2022 at 05:51:26PM +0100, David Sterba wrote:
> > On Tue, Feb 22, 2022 at 05:26:11PM -0500, Josef Bacik wrote:
> > > In converting some of our helpers to take new args I would miss some
> > > locations because we don't stop on any warning, and I would miss the
> > > warning in the scrollback.  Fix this by stopping compiling on any error
> > > and turn on the fancy compiler checks.
> > > 
> > > Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> > > ---
> > >  Makefile | 3 +++
> > >  1 file changed, 3 insertions(+)
> > > 
> > > diff --git a/Makefile b/Makefile
> > > index af4908f9..e0921ca3 100644
> > > --- a/Makefile
> > > +++ b/Makefile
> > > @@ -93,6 +93,9 @@ CFLAGS = $(SUBST_CFLAGS) \
> > >  	 -D_XOPEN_SOURCE=700  \
> > >  	 -fno-strict-aliasing \
> > >  	 -fPIC \
> > > +	 -Wall \
> > > +	 -Wunused-but-set-parameter \
> > > +	 -Werror \
> > 
> > That's in the default flags and based on the recent experience in kernel
> > defaulting to Werror it creates more problems than not. The build is
> > clean enough that new warnings are quite obvious and get fixed right
> > away.
> > 
> > You can always use the EXTRA_CFLAG=-Werror when developing or you can
> > also set CFLAGS=-Werror at configure time, as they get stored in the
> > generated Makefile.inc into SUBST_CFLAGS.
> 
> And actually there's make parameter W=1 like in kernel, that enables
> more warnings though the W=1 build is not clean. I'd rather not clutter
> the default flags by random warnings at all as the build is supposed to
> work on various LTS distros and compilers so that would probably fail
> build.

Ok, so not theoretical, the musl and centos7 builds fail, so I'm
dropping the patch.

Re: [PATCH 06/13] btrfs-progs: btrfs_item_size_nr/btrfs_item_offset_nr everywhere

[Nikolay Borisov]

On 23.02.22 г. 0:26 ч., Josef Bacik wrote:
> We have this pattern in a lot of places
> 
> 	item = btrfs_item_nr(slot);
> 	btrfs_item_size(leaf, item);
> 	btrfs_item_offset(leaf, item);
> 
> when we could simply use
> 
> 	btrfs_item_size_nr(leaf, slot);
> 	btrfs_item_offset_nr(leaf, slot);
> 
> Fix all callers of btrfs_item_size() and btrfs_item_offset() to use the
> _nr variation of the helpers.
> 
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> ---
>   check/main.c               |  8 ++++----
>   image/main.c               |  2 +-
>   kernel-shared/backref.c    |  4 +---
>   kernel-shared/ctree.c      | 24 ++++++++++++------------
>   kernel-shared/dir-item.c   |  6 ++----
>   kernel-shared/inode-item.c |  4 +---
>   kernel-shared/print-tree.c |  6 +++---
>   7 files changed, 24 insertions(+), 30 deletions(-)
> 
> diff --git a/check/main.c b/check/main.c
> index e9ac94cc..76eb8d54 100644
> --- a/check/main.c
> +++ b/check/main.c
> @@ -4222,10 +4222,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
>   		item2 = btrfs_item_nr(slot + 1);
>   		btrfs_item_key_to_cpu(buf, &k1, slot);
>   		btrfs_item_key_to_cpu(buf, &k2, slot + 1);
> -		item1_offset = btrfs_item_offset(buf, item1);
> -		item2_offset = btrfs_item_offset(buf, item2);
> -		item1_size = btrfs_item_size(buf, item1);
> -		item2_size = btrfs_item_size(buf, item2);
> +		item1_offset = btrfs_item_offset_nr(buf, slot);
> +		item2_offset = btrfs_item_offset_nr(buf, slot + 1);
> +		item1_size = btrfs_item_size_nr(buf, slot);
> +		item2_size = btrfs_item_size_nr(buf, slot + 1);
>   
>   		item1_data = malloc(item1_size);
>   		if (!item1_data)
> diff --git a/image/main.c b/image/main.c
> index 3125163d..e953d981 100644
> --- a/image/main.c
> +++ b/image/main.c
> @@ -1239,7 +1239,7 @@ static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size)
>   	for (i = slot; i < nritems; i++) {
>   		u32 ioff;
>   		item = btrfs_item_nr(i);
> -		ioff = btrfs_item_offset(eb, item);
> +		ioff = btrfs_item_offset_nr(eb, i);
>   		btrfs_set_item_offset(eb, item, ioff + size_diff);
>   	}
>   
> diff --git a/kernel-shared/backref.c b/kernel-shared/backref.c
> index f1a638ed..327599b7 100644
> --- a/kernel-shared/backref.c
> +++ b/kernel-shared/backref.c
> @@ -1417,7 +1417,6 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
>   	u64 parent = 0;
>   	int found = 0;
>   	struct extent_buffer *eb;
> -	struct btrfs_item *item;
>   	struct btrfs_inode_ref *iref;
>   	struct btrfs_key found_key;
>   
> @@ -1442,10 +1441,9 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
>   		extent_buffer_get(eb);
>   		btrfs_release_path(path);
>   
> -		item = btrfs_item_nr(slot);
>   		iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
>   
> -		for (cur = 0; cur < btrfs_item_size(eb, item); cur += len) {
> +		for (cur = 0; cur < btrfs_item_size_nr(eb, slot); cur += len) {
>   			name_len = btrfs_inode_ref_name_len(eb, iref);
>   			/* path must be released before calling iterate()! */
>   			pr_debug("following ref at offset %u for inode %llu in "
> diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
> index 10b22b2c..fc661aeb 100644
> --- a/kernel-shared/ctree.c
> +++ b/kernel-shared/ctree.c
> @@ -2041,7 +2041,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
>   		if (path->slots[0] == i)
>   			push_space += data_size + sizeof(*item);

item is no longer used in this while so the assignment done above this 
if can also be removed. Heck, I'd even go as far as moving the variable 
declaration inside the for() loop further down and convert all the 
sizeof(*item) calls to either sizeof(struct btrfs_item) or make a const 
size_t item_size = sizeof(struct btrfs_item) atop the function and use 
that.
>   
> -		this_item_size = btrfs_item_size(left, item);
> +		this_item_size = btrfs_item_size_nr(left, i);
>   		if (this_item_size + sizeof(*item) + push_space > free_space)
>   			break;
>   		push_items++;
> @@ -2092,7 +2092,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
>   	push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info);
>   	for (i = 0; i < right_nritems; i++) {
>   		item = btrfs_item_nr(i);

Then this line could be turned into:
struct btrfs_item item = btrfs_item_nr(i);

> -		push_space -= btrfs_item_size(right, item);
> +		push_space -= btrfs_item_size_nr(right, i);
>   		btrfs_set_item_offset(right, item, push_space);

And item would be confined to the single site here.

>   	}
>   
> @@ -2187,7 +2187,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
>   		if (path->slots[0] == i)
>   			push_space += data_size + sizeof(*item);
>   
> -		this_item_size = btrfs_item_size(right, item);
> +		this_item_size = btrfs_item_size_nr(right, i);
>   		if (this_item_size + sizeof(*item) + push_space > free_space)
>   			break;
>   
> @@ -2224,7 +2224,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
>   		u32 ioff;
>   
>   		item = btrfs_item_nr(i);
> -		ioff = btrfs_item_offset(left, item);
> +		ioff = btrfs_item_offset_nr(left, i);
>   		btrfs_set_item_offset(left, item,
>   		      ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) -
>   			      old_left_item_size));
> @@ -2256,7 +2256,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_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);
> +		push_space = push_space - btrfs_item_size_nr(right, i);
>   		btrfs_set_item_offset(right, item, push_space);
>   	}

nit: Same strategy can be applied to push_leaf_left as the one in 
pusth_leaf_right

>   
<snip>

>   
> @@ -3029,7 +3029,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
>   			u32 ioff;
>   
>   			item = btrfs_item_nr(i);

nit: btrfs_item is used only in this loop so why not move it to reduce 
the variable's scope.

> -			ioff = btrfs_item_offset(leaf, item);
> +			ioff = btrfs_item_offset_nr(leaf, i);
>   			btrfs_set_item_offset(leaf, item, ioff + dsize);
>   		}
>   

<snip>

Re: [PATCH 04/13] btrfs-progs: convert: use cfg->leaf_data_size

[Nikolay Borisov]

On 23.02.22 г. 0:26 ч., Josef Bacik wrote:
> The mkfs_config can hold the BTRFS_LEAF_DATA_SIZE, so calculate this at
> config creation time and then use that value throughout convert instead
> of calling __BTRFS_LEAF_DATA_SIZE.
> 
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>

nit: IMO this patch should be squashed into the patch 02.

Re: [PATCH 06/13] btrfs-progs: btrfs_item_size_nr/btrfs_item_offset_nr everywhere

[Nikolay Borisov]

On 9.03.22 г. 13:45 ч., Nikolay Borisov wrote:
> 
> 
> On 23.02.22 г. 0:26 ч., Josef Bacik wrote:
>> We have this pattern in a lot of places
>>
>>     item = btrfs_item_nr(slot);
>>     btrfs_item_size(leaf, item);
>>     btrfs_item_offset(leaf, item);
>>
>> when we could simply use
>>
>>     btrfs_item_size_nr(leaf, slot);
>>     btrfs_item_offset_nr(leaf, slot);
>>
>> Fix all callers of btrfs_item_size() and btrfs_item_offset() to use the
>> _nr variation of the helpers.
>>
>> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
>> ---
>>   check/main.c               |  8 ++++----
>>   image/main.c               |  2 +-
>>   kernel-shared/backref.c    |  4 +---
>>   kernel-shared/ctree.c      | 24 ++++++++++++------------
>>   kernel-shared/dir-item.c   |  6 ++----
>>   kernel-shared/inode-item.c |  4 +---
>>   kernel-shared/print-tree.c |  6 +++---
>>   7 files changed, 24 insertions(+), 30 deletions(-)
>>
>> diff --git a/check/main.c b/check/main.c
>> index e9ac94cc..76eb8d54 100644
>> --- a/check/main.c
>> +++ b/check/main.c
>> @@ -4222,10 +4222,10 @@ static int swap_values(struct btrfs_root 
>> *root, struct btrfs_path *path,
>>           item2 = btrfs_item_nr(slot + 1);
>>           btrfs_item_key_to_cpu(buf, &k1, slot);
>>           btrfs_item_key_to_cpu(buf, &k2, slot + 1);
>> -        item1_offset = btrfs_item_offset(buf, item1);
>> -        item2_offset = btrfs_item_offset(buf, item2);
>> -        item1_size = btrfs_item_size(buf, item1);
>> -        item2_size = btrfs_item_size(buf, item2);
>> +        item1_offset = btrfs_item_offset_nr(buf, slot);
>> +        item2_offset = btrfs_item_offset_nr(buf, slot + 1);
>> +        item1_size = btrfs_item_size_nr(buf, slot);
>> +        item2_size = btrfs_item_size_nr(buf, slot + 1);
>>           item1_data = malloc(item1_size);
>>           if (!item1_data)
>> diff --git a/image/main.c b/image/main.c
>> index 3125163d..e953d981 100644
>> --- a/image/main.c
>> +++ b/image/main.c
>> @@ -1239,7 +1239,7 @@ static void truncate_item(struct extent_buffer 
>> *eb, int slot, u32 new_size)
>>       for (i = slot; i < nritems; i++) {
>>           u32 ioff;
>>           item = btrfs_item_nr(i);
>> -        ioff = btrfs_item_offset(eb, item);
>> +        ioff = btrfs_item_offset_nr(eb, i);
>>           btrfs_set_item_offset(eb, item, ioff + size_diff);
>>       }
>> diff --git a/kernel-shared/backref.c b/kernel-shared/backref.c
>> index f1a638ed..327599b7 100644
>> --- a/kernel-shared/backref.c
>> +++ b/kernel-shared/backref.c
>> @@ -1417,7 +1417,6 @@ static int iterate_inode_refs(u64 inum, struct 
>> btrfs_root *fs_root,
>>       u64 parent = 0;
>>       int found = 0;
>>       struct extent_buffer *eb;
>> -    struct btrfs_item *item;
>>       struct btrfs_inode_ref *iref;
>>       struct btrfs_key found_key;
>> @@ -1442,10 +1441,9 @@ static int iterate_inode_refs(u64 inum, struct 
>> btrfs_root *fs_root,
>>           extent_buffer_get(eb);
>>           btrfs_release_path(path);
>> -        item = btrfs_item_nr(slot);
>>           iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
>> -        for (cur = 0; cur < btrfs_item_size(eb, item); cur += len) {
>> +        for (cur = 0; cur < btrfs_item_size_nr(eb, slot); cur += len) {
>>               name_len = btrfs_inode_ref_name_len(eb, iref);
>>               /* path must be released before calling iterate()! */
>>               pr_debug("following ref at offset %u for inode %llu in "
>> diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c
>> index 10b22b2c..fc661aeb 100644
>> --- a/kernel-shared/ctree.c
>> +++ b/kernel-shared/ctree.c
>> @@ -2041,7 +2041,7 @@ static int push_leaf_right(struct 
>> btrfs_trans_handle *trans, struct btrfs_root
>>           if (path->slots[0] == i)
>>               push_space += data_size + sizeof(*item);
> 
> item is no longer used in this while so the assignment done above this 
> if can also be removed. Heck, I'd even go as far as moving the variable 
> declaration inside the for() loop further down and convert all the 
> sizeof(*item) calls to either sizeof(struct btrfs_item) or make a const 
> size_t item_size = sizeof(struct btrfs_item) atop the function and use 
> that.
>> -        this_item_size = btrfs_item_size(left, item);
>> +        this_item_size = btrfs_item_size_nr(left, i);
>>           if (this_item_size + sizeof(*item) + push_space > free_space)
>>               break;
>>           push_items++;
>> @@ -2092,7 +2092,7 @@ static int push_leaf_right(struct 
>> btrfs_trans_handle *trans, struct btrfs_root
>>       push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info);
>>       for (i = 0; i < right_nritems; i++) {
>>           item = btrfs_item_nr(i);
> 
> Then this line could be turned into:
> struct btrfs_item item = btrfs_item_nr(i);
> 
>> -        push_space -= btrfs_item_size(right, item);
>> +        push_space -= btrfs_item_size_nr(right, i);
>>           btrfs_set_item_offset(right, item, push_space);
> 
> And item would be confined to the single site here.
> 
>>       }
>> @@ -2187,7 +2187,7 @@ static int push_leaf_left(struct 
>> btrfs_trans_handle *trans, struct btrfs_root
>>           if (path->slots[0] == i)
>>               push_space += data_size + sizeof(*item);
>> -        this_item_size = btrfs_item_size(right, item);
>> +        this_item_size = btrfs_item_size_nr(right, i);
>>           if (this_item_size + sizeof(*item) + push_space > free_space)
>>               break;
>> @@ -2224,7 +2224,7 @@ static int push_leaf_left(struct 
>> btrfs_trans_handle *trans, struct btrfs_root
>>           u32 ioff;
>>           item = btrfs_item_nr(i);
>> -        ioff = btrfs_item_offset(left, item);
>> +        ioff = btrfs_item_offset_nr(left, i);
>>           btrfs_set_item_offset(left, item,
>>                 ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) -
>>                     old_left_item_size));
>> @@ -2256,7 +2256,7 @@ static int push_leaf_left(struct 
>> btrfs_trans_handle *trans, struct btrfs_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);
>> +        push_space = push_space - btrfs_item_size_nr(right, i);
>>           btrfs_set_item_offset(right, item, push_space);
>>       }
> 
> nit: Same strategy can be applied to push_leaf_left as the one in 
> pusth_leaf_right
> 
> <snip>
> 
>> @@ -3029,7 +3029,7 @@ int btrfs_del_items(struct btrfs_trans_handle 
>> *trans, struct btrfs_root *root,
>>               u32 ioff;
>>               item = btrfs_item_nr(i);
> 
> nit: btrfs_item is used only in this loop so why not move it to reduce 
> the variable's scope.
> 
>> -            ioff = btrfs_item_offset(leaf, item);
>> +            ioff = btrfs_item_offset_nr(leaf, i);
>>               btrfs_set_item_offset(leaf, item, ioff + dsize);
>>           }
> 
> <snip>
> 

Oh right that's effectively implemented by the following patch so 
disregard this one ;)

Re: [PATCH 11/13] btrfs-progs: replace btrfs_item_nr_offset(0)

[Nikolay Borisov]

On 23.02.22 г. 0:26 ч., Josef Bacik wrote:
> btrfs_item_nr_offset(0) is simply offsetof(struct btrfs_leaf, items),
> which is the same thing as btrfs_leaf_data(), so replace all calls of
> btrfs_item_nr_offset(0) with btrfs_leaf_data().
> 
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>


nit: The patch itself is fine, however in the kernel we don't have 
btrfs_leaf_data() func, instead we have BTRFS_LEAF_DATA_OFFSET macro 
which is used in a lot of places in the kernel. So why not make the 
btrfs-progs follow the kernel style to reduce future clashes when we 
start factoring out common code between user/kernel?

Re: [PATCH 00/13] btrfs-progs: cleanup btrfs_item* accessors

[Nikolay Borisov]

On 23.02.22 г. 0:26 ч., Josef Bacik wrote:
> Hello,
> 
> This is prep work for me adjusting the size of the btrfs_header.  This is a
> mirror of the work that was already merged into the kernel.  The only extra work
> that I've done here is add some compiler switches that I used to help me catch
> all the different users of the helpers to make sure I didn't make any mistakes.
> Thanks,
> 
> Josef
> 
> Josef Bacik (13):
>    btrfs-progs: turn on more compiler warnings and use -Wall
>    btrfs-progs: store LEAF_DATA_SIZE in the mkfs_config
>    btrfs-progs: store BTRFS_LEAF_DATA_SIZE in the fs_info
>    btrfs-progs: convert: use cfg->leaf_data_size
>    btrfs-progs: reduce usage of __BTRFS_LEAF_DATA_SIZE
>    btrfs-progs: btrfs_item_size_nr/btrfs_item_offset_nr everywhere
>    btrfs-progs: add btrfs_set_item_*_nr() helpers
>    btrfs-progs: change btrfs_file_extent_inline_item_len to take a slot
>    btrfs-progs: rename btrfs_item_end_nr to btrfs_item_end
>    btrfs-progs: remove the _nr from the item helpers
>    btrfs-progs: replace btrfs_item_nr_offset(0)
>    btrfs-progs: rework the btrfs_node accessors to match the item
>      accessors
>    btrfs-progs: make all of the item/key_ptr offset helpers take an eb
> 
>   Makefile                    |   3 +
>   btrfs-corrupt-block.c       |  17 ++-
>   check/main.c                |  90 +++++++--------
>   check/mode-common.c         |  12 +-
>   check/mode-lowmem.c         |  37 +++---
>   check/qgroup-verify.c       |   2 +-
>   cmds/inspect-tree-stats.c   |   3 +-
>   cmds/rescue-chunk-recover.c |   4 +-
>   cmds/restore.c              |   7 +-
>   convert/common.c            |  33 +++---
>   convert/main.c              |   1 +
>   image/main.c                |  31 +++--
>   image/sanitize.c            |   4 +-
>   kernel-shared/backref.c     |  10 +-
>   kernel-shared/ctree.c       | 219 ++++++++++++++++--------------------
>   kernel-shared/ctree.h       | 110 ++++++++----------
>   kernel-shared/dir-item.c    |  10 +-
>   kernel-shared/disk-io.c     |   1 +
>   kernel-shared/extent-tree.c |  12 +-
>   kernel-shared/file-item.c   |  12 +-
>   kernel-shared/inode-item.c  |  14 +--
>   kernel-shared/print-tree.c  |  29 +++--
>   kernel-shared/root-tree.c   |   2 +-
>   kernel-shared/uuid-tree.c   |   4 +-
>   kernel-shared/volumes.c     |  10 +-
>   mkfs/common.c               |  52 ++++-----
>   mkfs/common.h               |   1 +
>   mkfs/main.c                 |   1 +
>   28 files changed, 333 insertions(+), 398 deletions(-)
> 

For the whole series :

Reviewed-by: Nikolay Borisov <nborisov@suse.com>

Re: [PATCH 04/13] btrfs-progs: convert: use cfg->leaf_data_size

[David Sterba]

On Wed, Mar 09, 2022 at 01:48:08PM +0200, Nikolay Borisov wrote:
> 
> 
> On 23.02.22 г. 0:26 ч., Josef Bacik wrote:
> > The mkfs_config can hold the BTRFS_LEAF_DATA_SIZE, so calculate this at
> > config creation time and then use that value throughout convert instead
> > of calling __BTRFS_LEAF_DATA_SIZE.
> > 
> > Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> 
> nit: IMO this patch should be squashed into the patch 02.

I don't mind the patch granularity, both ways it's reviewable and clear.