Skip to contentSkip to conversation

btrfs-progs: cleanup btrfs_item* accessors

PATCH In review Josef Bacik 3 participants 23 messages Feb 22, 2022 – Mar 9, 2022

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

cover btrfs-progs: cleanup btrfs_item* accessors

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(-)
Signature · 1 line
2.26.3
#1 lore raw

PATCH 1/13 btrfs-progs: turn on more compiler warnings and use -Wall

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.

---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)
Makefile +3 -0
index af4908f9..e0921ca3 100644
@@ -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) \
Signature · 1 line
2.26.3
#2 lore raw

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

Quoted 15 lines · 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.

---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)
Makefile +0 -0
index af4908f9..e0921ca3 100644

Makefile CFLAGS = $(SUBST_CFLAGS) \ · line 98

Quoted 6 lines
Makefile +3 -0
@@ -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.

#3 lore raw

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

Quoted 28 lines · David Sterba
Quoted 15 lines · 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.

---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)
Makefile +0 -0
index af4908f9..e0921ca3 100644

Makefile CFLAGS = $(SUBST_CFLAGS) \ · line 98

Quoted 6 lines
Makefile +3 -0
@@ -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.

Quoted 3 lines

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.

#4 lore raw

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

Quoted 33 lines · David Sterba
Quoted 28 lines · David Sterba
Quoted 15 lines · 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.

---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)
Makefile +0 -0
index af4908f9..e0921ca3 100644

Makefile CFLAGS = $(SUBST_CFLAGS) \ · line 98

Quoted 6 lines
Makefile +3 -0
@@ -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.

Quoted 3 lines

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.

Quoted 5 lines

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.

#5 lore raw

PATCH 2/13 btrfs-progs: store LEAF_DATA_SIZE in the mkfs_config

In reply to 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.

---
 mkfs/common.c | 9 ++++-----
 mkfs/common.h | 1 +
 mkfs/main.c   | 1 +
 3 files changed, 6 insertions(+), 5 deletions(-)
mkfs/common.c +4 -5
index 9608d27f..aee4b9fb 100644
@@ -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);
mkfs/common.h +1 -0
index 66c9d9d0..428cd366 100644
@@ -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_* */
mkfs/main.c +1 -0
index f9e8be74..3dd06979 100644
@@ -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
Signature · 1 line
2.26.3
#6 lore raw

PATCH 3/13 btrfs-progs: store BTRFS_LEAF_DATA_SIZE in the fs_info

In reply to 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.

---
 kernel-shared/ctree.h   | 4 ++--
 kernel-shared/disk-io.c | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)
kernel-shared/ctree.h +2 -2
index de5452f2..31169f33 100644
@@ -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;
 
kernel-shared/disk-io.c +1 -0
index f83ba884..0434ed7d 100644
@@ -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)
Signature · 1 line
2.26.3
#7 lore raw

PATCH 4/13 btrfs-progs: convert: use cfg->leaf_data_size

In reply to 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.

---
 convert/common.c | 8 ++++----
 convert/main.c   | 1 +
 2 files changed, 5 insertions(+), 4 deletions(-)
convert/common.c +4 -4
index 00a7e553..356c2b4c 100644
@@ -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;
 
convert/main.c +1 -0
index 333d5be1..b72d1e51 100644
@@ -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);
Signature · 1 line
2.26.3
#8 lore raw

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

Quoted 5 lines · 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.

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

#9 lore raw

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

Quoted 10 lines · Nikolay Borisov
Quoted 5 lines · 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.

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.

#10 lore raw

PATCH 5/13 btrfs-progs: reduce usage of __BTRFS_LEAF_DATA_SIZE

In reply to 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.

---
 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(-)
kernel-shared/ctree.c +3 -2
index 950923d0..10b22b2c 100644
@@ -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",
kernel-shared/ctree.h +3 -2
index 31169f33..d9677bce 100644
@@ -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		\
kernel-shared/print-tree.c +1 -1
index bd75ae51..7308599f 100644
@@ -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);
mkfs/common.c +1 -1
index aee4b9fb..f3e689cb 100644
@@ -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];
 
Signature · 1 line
2.26.3
#11 lore raw

PATCH 6/13 btrfs-progs: btrfs_item_size_nr/btrfs_item_offset_nr everywhere

In reply to 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.

---
 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(-)
check/main.c +4 -4
index e9ac94cc..76eb8d54 100644
@@ -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)
image/main.c +1 -1
index 3125163d..e953d981 100644
@@ -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);
 	}
 
kernel-shared/backref.c +1 -3
index f1a638ed..327599b7 100644
@@ -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 "
kernel-shared/ctree.c +12 -12
index 10b22b2c..fc661aeb 100644
@@ -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);
 		}
 
kernel-shared/dir-item.c +2 -4
index 590b79a9..729d4308 100644
@@ -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;
 }
 
kernel-shared/inode-item.c +1 -3
index 67173eb1..7ca75f6d 100644
@@ -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);
kernel-shared/print-tree.c +3 -3
index 7308599f..6e601779 100644
@@ -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);
Signature · 1 line
2.26.3
#12 lore raw

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

Quoted 86 lines · 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.

---
  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(-)
check/main.c +4 -4
index e9ac94cc..76eb8d54 100644
@@ -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)
image/main.c +1 -1
index 3125163d..e953d981 100644
@@ -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);
  	}
 
kernel-shared/backref.c +1 -3
index f1a638ed..327599b7 100644
@@ -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 "
kernel-shared/ctree.c +0 -0
index 10b22b2c..fc661aeb 100644

kernel-shared/ctree.c static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root · line 2042

Quoted 2 lines
kernel-shared/ctree.c +0 -0
@@ -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.

kernel-shared/ctree.c static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root · line 2094

Quoted 10 lines
kernel-shared/ctree.c +1 -1
-		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);

kernel-shared/ctree.c static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root · line 2096

Quoted 3 lines
kernel-shared/ctree.c +1 -1
-		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.

Quoted 21 lines
kernel-shared/ctree.c +2 -2
  	}
 
@@ -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));

kernel-shared/ctree.c static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root · line 2261

Quoted 7 lines
kernel-shared/ctree.c +1 -1
@@ -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

Quoted 1 line

<snip>

kernel-shared/ctree.c int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, · line 3031

Quoted 5 lines
kernel-shared/ctree.c +0 -0
@@ -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.

Quoted 5 lines
kernel-shared/ctree.c +1 -1
-			ioff = btrfs_item_offset(leaf, item);
+			ioff = btrfs_item_offset_nr(leaf, i);
  			btrfs_set_item_offset(leaf, item, ioff + dsize);
  		}
 

<snip>

#13 lore raw

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

Quoted 152 lines · Nikolay Borisov
Quoted 85 lines · 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.

---
  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(-)
check/main.c +4 -4
index e9ac94cc..76eb8d54 100644
@@ -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)
image/main.c +1 -1
index 3125163d..e953d981 100644
@@ -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);
       }
kernel-shared/backref.c +1 -3
index f1a638ed..327599b7 100644
@@ -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 "

kernel-shared/ctree.c +0 -0
index 10b22b2c..fc661aeb 100644
@@ -2041,7 +2041,7 @@ static int push_leaf_right(struct 
Quoted 3 lines

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.

Quoted 10 lines

-        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++;

kernel-shared/ctree.c +0 -0
@@ -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);

Quoted 3 lines

-        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.

Quoted 19 lines

      }

kernel-shared/ctree.c +0 -0
@@ -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;

kernel-shared/ctree.c +0 -0
@@ -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));

kernel-shared/ctree.c +0 -0
@@ -2256,7 +2256,7 @@ static int push_leaf_left(struct 
Quoted 8 lines

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>

kernel-shared/ctree.c int btrfs_del_items(struct btrfs_trans_handle · line 3031

Quoted 4 lines
kernel-shared/ctree.c +0 -0
@@ -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.

Quoted 7 lines
Quoted 4 lines
kernel-shared/ctree.c +1 -1
-            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 ;)

#14 lore raw

PATCH 7/13 btrfs-progs: add btrfs_set_item_*_nr() helpers

In reply to 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.

---
 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(-)
btrfs-corrupt-block.c +2 -3
index 866c863e..57a4e271 100644
@@ -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;
check/main.c +5 -9
index 76eb8d54..0bc42de7 100644
@@ -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);
 	}
 
convert/common.c +12 -13
index 356c2b4c..38112084 100644
@@ -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);
image/main.c +2 -5
index e953d981..09f60e63 100644
@@ -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,
kernel-shared/ctree.c +23 -49

225 lines not on this page · raw message

kernel-shared/ctree.h +12 -0
index d9677bce..cda05481 100644
@@ -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));
mkfs/common.c +18 -23

95 lines not on this page · raw message

Signature · 1 line
2.26.3
#15 lore raw

PATCH 8/13 btrfs-progs: change btrfs_file_extent_inline_item_len to take a slot

In reply to 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.

---
 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(-)
check/main.c +4 -7
index 0bc42de7..fb0ef8cb 100644
@@ -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);
check/mode-lowmem.c +2 -5
index 0cdf24cd..729c453a 100644
@@ -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]);
cmds/inspect-tree-stats.c +1 -2
index eeb57810..0731675c 100644
@@ -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;
cmds/restore.c +2 -3
index 48300ae5..bc88af70 100644
@@ -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);
image/main.c +1 -3
index 09f60e63..5d67d282 100644
@@ -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);
 	}
 }
kernel-shared/ctree.h +2 -4
index cda05481..7fb66049 100644
@@ -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 */
kernel-shared/print-tree.c +2 -5
index 6e601779..aff2ebc4 100644
@@ -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);
Signature · 1 line
2.26.3
#16 lore raw

PATCH 9/13 btrfs-progs: rename btrfs_item_end_nr to btrfs_item_end

In reply to 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.

---
 check/main.c          | 12 ++++++------
 kernel-shared/ctree.c | 20 ++++++++++----------
 kernel-shared/ctree.h | 16 +++++-----------
 3 files changed, 21 insertions(+), 27 deletions(-)
check/main.c +6 -6
index fb0ef8cb..92e1399f 100644
@@ -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;
kernel-shared/ctree.c +10 -10
index 81a438c8..d18c91d1 100644
@@ -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);
kernel-shared/ctree.h +5 -11
index 7fb66049..befa244f 100644
@@ -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)
 {
Signature · 1 line
2.26.3
#17 lore raw

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

In reply to 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.

---
 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(-)
btrfs-corrupt-block.c +8 -8
index 57a4e271..fb1f15f0 100644
@@ -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);
 	}
check/main.c +25 -25

145 lines not on this page · raw message

check/mode-common.c +6 -6
index c3d8bb45..f05960ac 100644
@@ -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),
check/mode-lowmem.c +15 -15
index 729c453a..99d04945 100644
@@ -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:
check/qgroup-verify.c +1 -1
index 0813b841..2c05f875 100644
@@ -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;
cmds/rescue-chunk-recover.c +2 -2
index da24df4c..ec5c206f 100644
@@ -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;
cmds/restore.c +1 -1
index bc88af70..81ca6cd5 100644
@@ -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);
 
convert/common.c +12 -12
index 38112084..0fb7b6c5 100644
@@ -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);
image/main.c +10 -10
index 5d67d282..ff121fca 100644
@@ -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,
image/sanitize.c +2 -2
index e3ac1b84..c6970403 100644
@@ -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) {
kernel-shared/backref.c +4 -4
index 327599b7..9c5a3895 100644
@@ -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;
 
kernel-shared/ctree.c +45 -45

268 lines not on this page · raw message

kernel-shared/ctree.h +17 -25

74 lines not on this page · raw message

kernel-shared/dir-item.c +4 -4
index 729d4308..27dfb362 100644
@@ -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;
 
kernel-shared/extent-tree.c +6 -6
index 3713452b..e36745ca 100644
@@ -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",
kernel-shared/file-item.c +6 -6
index 0d68ed52..b0fcd49d 100644
@@ -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;
 
kernel-shared/inode-item.c +6 -6
index 7ca75f6d..891ae40a 100644
@@ -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);
kernel-shared/print-tree.c +10 -10
index aff2ebc4..717be5d5 100644
@@ -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);
kernel-shared/root-tree.c +1 -1
index bc410963..0f83f915 100644
@@ -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
kernel-shared/uuid-tree.c +2 -2
index c0b3406a..6de9a178 100644
@@ -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;
kernel-shared/volumes.c +5 -5
index 4274c378..e24428db 100644
@@ -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;
 	}
mkfs/common.c +18 -18
index 0ea0d114..11d92c8b 100644
@@ -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);
Signature · 1 line
2.26.3
#18 lore raw

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

In reply to 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().

---
 kernel-shared/ctree.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)
kernel-shared/ctree.c +5 -5
index 04847cd5..e164492b 100644
@@ -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));
 
Signature · 1 line
2.26.3
#19 lore raw

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

Quoted 5 lines · 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().

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?

#20 lore raw

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

In reply to 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.

---
 kernel-shared/ctree.h | 49 +++++++++++++++++--------------------------
 1 file changed, 19 insertions(+), 30 deletions(-)
kernel-shared/ctree.h +19 -30
index 8b654dde..464a0f74 100644
@@ -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 */
Signature · 1 line
2.26.3
#21 lore raw

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

In reply to 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.

---
 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(-)
check/main.c +7 -6
index ed3fde60..39cb1ce5 100644
@@ -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);
image/main.c +2 -2
index ff121fca..c6af0cc2 100644
@@ -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) +
kernel-shared/ctree.c +27 -27

146 lines not on this page · raw message

kernel-shared/ctree.h +18 -18
index 464a0f74..addfafc7 100644
@@ -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);
 }
 
Signature · 1 line
2.26.3
Reviewed-by on the v1 series
#22 lore raw
In reply to Josef Bacik
Quoted 47 lines · 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 +--
Quoted 9 lines
  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 :