Commit 3212fa14 authored by Josef Bacik's avatar Josef Bacik Committed by David Sterba
Browse files

btrfs: drop the _nr from the item helpers 



Now that all call sites are using the slot number to modify item values,
rename the SETGET helpers to raw_item_*(), and then rework the _nr()
helpers to be the btrfs_item_*() btrfs_set_item_*() helpers, and then
rename all of the callers to the new helpers.

Signed-off-by: default avatarJosef Bacik <josef@toxicpanda.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 74794207

fs/btrfs/backref.c

+7 −7
Original line number Diff line number Diff line
@@ -950,7 +950,7 @@ static int add_inline_refs(const 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);
@@ -1779,7 +1779,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);
@@ -2085,7 +2085,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()! */

			btrfs_debug(fs_root->fs_info,
@@ -2141,7 +2141,7 @@ static int iterate_inode_extrefs(u64 inum, struct btrfs_root *fs_root, 
		}

		btrfs_release_path(path);



		item_size = btrfs_item_size_nr(eb, slot);

		item_size = btrfs_item_size(eb, slot);

		ptr = btrfs_item_ptr_offset(eb, slot);

		cur_offset = 0;
@@ -2362,7 +2362,7 @@ int btrfs_backref_iter_start(struct btrfs_backref_iter *iter, u64 bytenr) 
	iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],

						    path->slots[0]);

	iter->end_ptr = (u32)(iter->item_ptr +

			btrfs_item_size_nr(path->nodes[0], path->slots[0]));

			btrfs_item_size(path->nodes[0], path->slots[0]));

	ei = btrfs_item_ptr(path->nodes[0], path->slots[0],

			    struct btrfs_extent_item);
@@ -2402,7 +2402,7 @@ int btrfs_backref_iter_start(struct btrfs_backref_iter *iter, u64 bytenr) 
		iter->cur_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],

							   path->slots[0]);

		iter->item_ptr = iter->cur_ptr;

		iter->end_ptr = (u32)(iter->item_ptr + btrfs_item_size_nr(

		iter->end_ptr = (u32)(iter->item_ptr + btrfs_item_size(

				      path->nodes[0], path->slots[0]));

	}
@@ -2467,7 +2467,7 @@ int btrfs_backref_iter_next(struct btrfs_backref_iter *iter) 
	iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],

					path->slots[0]);

	iter->cur_ptr = iter->item_ptr;

	iter->end_ptr = iter->item_ptr + (u32)btrfs_item_size_nr(path->nodes[0],

	iter->end_ptr = iter->item_ptr + (u32)btrfs_item_size(path->nodes[0],

						path->slots[0]);

	return 0;

}

fs/btrfs/ctree.c

+43 −43
Original line number Diff line number Diff line
@@ -2622,8 +2622,8 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr) 


	if (!nr)

		return 0;

	data_len = btrfs_item_offset_nr(l, start) + btrfs_item_size_nr(l, start);

	data_len = data_len - btrfs_item_offset_nr(l, end);

	data_len = btrfs_item_offset(l, start) + btrfs_item_size(l, start);

	data_len = data_len - btrfs_item_offset(l, end);

	data_len += sizeof(struct btrfs_item) * nr;

	WARN_ON(data_len < 0);

	return data_len;
@@ -2700,7 +2700,7 @@ static noinline int __push_leaf_right(struct btrfs_path *path, 
		if (path->slots[0] == i)

			push_space += data_size;



		this_item_size = btrfs_item_size_nr(left, i);

		this_item_size = btrfs_item_size(left, i);

		if (this_item_size + sizeof(struct btrfs_item) +

		    push_space > free_space)

			break;
@@ -2751,8 +2751,8 @@ static noinline int __push_leaf_right(struct btrfs_path *path, 
	btrfs_set_header_nritems(right, right_nritems);

	push_space = BTRFS_LEAF_DATA_SIZE(fs_info);

	for (i = 0; i < right_nritems; i++) {

		push_space -= btrfs_token_item_size_nr(&token, i);

		btrfs_set_token_item_offset_nr(&token, i, push_space);

		push_space -= btrfs_token_item_size(&token, i);

		btrfs_set_token_item_offset(&token, i, push_space);

	}



	left_nritems -= push_items;
@@ -2924,7 +2924,7 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size, 
		if (path->slots[0] == i)

			push_space += data_size;



		this_item_size = btrfs_item_size_nr(right, i);

		this_item_size = btrfs_item_size(right, i);

		if (this_item_size + sizeof(struct btrfs_item) + push_space >

		    free_space)

			break;
@@ -2946,23 +2946,23 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size, 
			   push_items * sizeof(struct btrfs_item));



	push_space = BTRFS_LEAF_DATA_SIZE(fs_info) -

		     btrfs_item_offset_nr(right, push_items - 1);

		     btrfs_item_offset(right, push_items - 1);



	copy_extent_buffer(left, right, BTRFS_LEAF_DATA_OFFSET +

		     leaf_data_end(left) - push_space,

		     BTRFS_LEAF_DATA_OFFSET +

		     btrfs_item_offset_nr(right, push_items - 1),

		     btrfs_item_offset(right, push_items - 1),

		     push_space);

	old_left_nritems = btrfs_header_nritems(left);

	BUG_ON(old_left_nritems <= 0);



	btrfs_init_map_token(&token, left);

	old_left_item_size = btrfs_item_offset_nr(left, old_left_nritems - 1);

	old_left_item_size = btrfs_item_offset(left, old_left_nritems - 1);

	for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {

		u32 ioff;



		ioff = btrfs_token_item_offset_nr(&token, i);

		btrfs_set_token_item_offset_nr(&token, i,

		ioff = btrfs_token_item_offset(&token, i);

		btrfs_set_token_item_offset(&token, i,

		      ioff - (BTRFS_LEAF_DATA_SIZE(fs_info) - old_left_item_size));

	}

	btrfs_set_header_nritems(left, old_left_nritems + push_items);
@@ -2973,7 +2973,7 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size, 
		       right_nritems);



	if (push_items < right_nritems) {

		push_space = btrfs_item_offset_nr(right, push_items - 1) -

		push_space = btrfs_item_offset(right, push_items - 1) -

						  leaf_data_end(right);

		memmove_extent_buffer(right, BTRFS_LEAF_DATA_OFFSET +

				      BTRFS_LEAF_DATA_SIZE(fs_info) - push_space,
@@ -2991,8 +2991,8 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size, 
	btrfs_set_header_nritems(right, right_nritems);

	push_space = BTRFS_LEAF_DATA_SIZE(fs_info);

	for (i = 0; i < right_nritems; i++) {

		push_space = push_space - btrfs_token_item_size_nr(&token, i);

		btrfs_set_token_item_offset_nr(&token, i, push_space);

		push_space = push_space - btrfs_token_item_size(&token, i);

		btrfs_set_token_item_offset(&token, i, push_space);

	}



	btrfs_mark_buffer_dirty(left);
@@ -3137,8 +3137,8 @@ static noinline void copy_for_split(struct btrfs_trans_handle *trans, 
	for (i = 0; i < nritems; i++) {

		u32 ioff;



		ioff = btrfs_token_item_offset_nr(&token, i);

		btrfs_set_token_item_offset_nr(&token, i, ioff + rt_data_off);

		ioff = btrfs_token_item_offset(&token, i);

		btrfs_set_token_item_offset(&token, i, ioff + rt_data_off);

	}



	btrfs_set_header_nritems(l, mid);
@@ -3254,7 +3254,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans, 


	l = path->nodes[0];

	slot = path->slots[0];

	if (extend && data_size + btrfs_item_size_nr(l, slot) +

	if (extend && data_size + btrfs_item_size(l, slot) +

	    sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(fs_info))

		return -EOVERFLOW;
@@ -3423,7 +3423,7 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans, 
	if (btrfs_leaf_free_space(leaf) >= ins_len)

		return 0;



	item_size = btrfs_item_size_nr(leaf, path->slots[0]);

	item_size = btrfs_item_size(leaf, path->slots[0]);

	if (key.type == BTRFS_EXTENT_DATA_KEY) {

		fi = btrfs_item_ptr(leaf, path->slots[0],

				    struct btrfs_file_extent_item);
@@ -3443,7 +3443,7 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans, 
	ret = -EAGAIN;

	leaf = path->nodes[0];

	/* if our item isn't there, return now */

	if (item_size != btrfs_item_size_nr(leaf, path->slots[0]))

	if (item_size != btrfs_item_size(leaf, path->slots[0]))

		goto err;



	/* the leaf has  changed, it now has room.  return now */
@@ -3485,8 +3485,8 @@ static noinline int split_item(struct btrfs_path *path, 
	BUG_ON(btrfs_leaf_free_space(leaf) < sizeof(struct btrfs_item));



	orig_slot = path->slots[0];

	orig_offset = btrfs_item_offset_nr(leaf, path->slots[0]);

	item_size = btrfs_item_size_nr(leaf, path->slots[0]);

	orig_offset = btrfs_item_offset(leaf, path->slots[0]);

	item_size = btrfs_item_size(leaf, path->slots[0]);



	buf = kmalloc(item_size, GFP_NOFS);

	if (!buf)
@@ -3507,12 +3507,12 @@ static noinline int split_item(struct btrfs_path *path, 
	btrfs_cpu_key_to_disk(&disk_key, new_key);

	btrfs_set_item_key(leaf, &disk_key, slot);



	btrfs_set_item_offset_nr(leaf, slot, orig_offset);

	btrfs_set_item_size_nr(leaf, slot, item_size - split_offset);

	btrfs_set_item_offset(leaf, slot, orig_offset);

	btrfs_set_item_size(leaf, slot, item_size - split_offset);



	btrfs_set_item_offset_nr(leaf, orig_slot,

	btrfs_set_item_offset(leaf, orig_slot,

				 orig_offset + item_size - split_offset);

	btrfs_set_item_size_nr(leaf, orig_slot, split_offset);

	btrfs_set_item_size(leaf, orig_slot, split_offset);



	btrfs_set_header_nritems(leaf, nritems + 1);
@@ -3584,14 +3584,14 @@ void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) 
	leaf = path->nodes[0];

	slot = path->slots[0];



	old_size = btrfs_item_size_nr(leaf, slot);

	old_size = btrfs_item_size(leaf, slot);

	if (old_size == new_size)

		return;



	nritems = btrfs_header_nritems(leaf);

	data_end = leaf_data_end(leaf);



	old_data_start = btrfs_item_offset_nr(leaf, slot);

	old_data_start = btrfs_item_offset(leaf, slot);



	size_diff = old_size - new_size;
@@ -3606,8 +3606,8 @@ void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) 
	for (i = slot; i < nritems; i++) {

		u32 ioff;



		ioff = btrfs_token_item_offset_nr(&token, i);

		btrfs_set_token_item_offset_nr(&token, i, ioff + size_diff);

		ioff = btrfs_token_item_offset(&token, i);

		btrfs_set_token_item_offset(&token, i, ioff + size_diff);

	}



	/* shift the data */
@@ -3650,7 +3650,7 @@ void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) 
			fixup_low_keys(path, &disk_key, 1);

	}



	btrfs_set_item_size_nr(leaf, slot, new_size);

	btrfs_set_item_size(leaf, slot, new_size);

	btrfs_mark_buffer_dirty(leaf);



	if (btrfs_leaf_free_space(leaf) < 0) {
@@ -3701,8 +3701,8 @@ void btrfs_extend_item(struct btrfs_path *path, u32 data_size) 
	for (i = slot; i < nritems; i++) {

		u32 ioff;



		ioff = btrfs_token_item_offset_nr(&token, i);

		btrfs_set_token_item_offset_nr(&token, i, ioff - data_size);

		ioff = btrfs_token_item_offset(&token, i);

		btrfs_set_token_item_offset(&token, i, ioff - data_size);

	}



	/* shift the data */
@@ -3711,8 +3711,8 @@ void btrfs_extend_item(struct btrfs_path *path, u32 data_size) 
		      data_end, old_data - data_end);



	data_end = old_data;

	old_size = btrfs_item_size_nr(leaf, slot);

	btrfs_set_item_size_nr(leaf, slot, old_size + data_size);

	old_size = btrfs_item_size(leaf, slot);

	btrfs_set_item_size(leaf, slot, old_size + data_size);

	btrfs_mark_buffer_dirty(leaf);



	if (btrfs_leaf_free_space(leaf) < 0) {
@@ -3786,8 +3786,8 @@ static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *p 
		for (i = slot; i < nritems; i++) {

			u32 ioff;



			ioff = btrfs_token_item_offset_nr(&token, i);

			btrfs_set_token_item_offset_nr(&token, i,

			ioff = btrfs_token_item_offset(&token, i);

			btrfs_set_token_item_offset(&token, i,

						       ioff - batch->total_data_size);

		}

		/* shift the items */
@@ -3808,8 +3808,8 @@ static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *p 
		btrfs_cpu_key_to_disk(&disk_key, &batch->keys[i]);

		btrfs_set_item_key(leaf, &disk_key, slot + i);

		data_end -= batch->data_sizes[i];

		btrfs_set_token_item_offset_nr(&token, slot + i, data_end);

		btrfs_set_token_item_size_nr(&token, slot + i, batch->data_sizes[i]);

		btrfs_set_token_item_offset(&token, slot + i, data_end);

		btrfs_set_token_item_size(&token, slot + i, batch->data_sizes[i]);

	}



	btrfs_set_header_nritems(leaf, nritems + batch->nr);
@@ -3916,7 +3916,7 @@ int btrfs_duplicate_item(struct btrfs_trans_handle *trans, 
	u32 item_size;



	leaf = path->nodes[0];

	item_size = btrfs_item_size_nr(leaf, path->slots[0]);

	item_size = btrfs_item_size(leaf, path->slots[0]);

	ret = setup_leaf_for_split(trans, root, path,

				   item_size + sizeof(struct btrfs_item));

	if (ret)
@@ -4025,10 +4025,10 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
	u32 nritems;



	leaf = path->nodes[0];

	last_off = btrfs_item_offset_nr(leaf, slot + nr - 1);

	last_off = btrfs_item_offset(leaf, slot + nr - 1);



	for (i = 0; i < nr; i++)

		dsize += btrfs_item_size_nr(leaf, slot + i);

		dsize += btrfs_item_size(leaf, slot + i);



	nritems = btrfs_header_nritems(leaf);
@@ -4045,8 +4045,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
		for (i = slot + nr; i < nritems; i++) {

			u32 ioff;



			ioff = btrfs_token_item_offset_nr(&token, i);

			btrfs_set_token_item_offset_nr(&token, i, ioff + dsize);

			ioff = btrfs_token_item_offset(&token, i);

			btrfs_set_token_item_offset(&token, i, ioff + dsize);

		}



		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),

fs/btrfs/ctree.h

+33 −60
Original line number Diff line number Diff line
@@ -1960,8 +1960,8 @@ static inline void btrfs_set_node_key(const struct extent_buffer *eb, 
}



/* struct btrfs_item */

BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);

BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);

BTRFS_SETGET_FUNCS(raw_item_offset, struct btrfs_item, offset, 32);

BTRFS_SETGET_FUNCS(raw_item_size, struct btrfs_item, size, 32);

BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);

BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
@@ -1979,7 +1979,7 @@ static inline struct btrfs_item *btrfs_item_nr(int nr) 
static inline u32 btrfs_item_end(const struct extent_buffer *eb,

				 struct btrfs_item *item)

{

	return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);

	return btrfs_raw_item_offset(eb, item) + btrfs_raw_item_size(eb, item);

}



static inline u32 btrfs_item_end_nr(const struct extent_buffer *eb, int nr)
@@ -1987,59 +1987,32 @@ static inline u32 btrfs_item_end_nr(const struct extent_buffer *eb, int nr) 
	return btrfs_item_end(eb, btrfs_item_nr(nr));

}



static inline u32 btrfs_item_offset_nr(const struct extent_buffer *eb, int nr)

{

	return btrfs_item_offset(eb, btrfs_item_nr(nr));

}



static inline u32 btrfs_item_size_nr(const struct extent_buffer *eb, int nr)

{

	return btrfs_item_size(eb, btrfs_item_nr(nr));

}



static inline void btrfs_set_item_size_nr(struct extent_buffer *eb, int nr,

					  u32 val)

{

	btrfs_set_item_size(eb, btrfs_item_nr(nr), val);

}



static inline void btrfs_set_item_offset_nr(struct extent_buffer *eb, int nr,

					    u32 val)

{

	btrfs_set_item_offset(eb, btrfs_item_nr(nr), val);

}



static inline u32 btrfs_token_item_offset_nr(struct btrfs_map_token *token,

					     int slot)

{

	struct btrfs_item *item = btrfs_item_nr(slot);



	return btrfs_token_item_offset(token, item);

}



static inline u32 btrfs_token_item_size_nr(struct btrfs_map_token *token,

					   int slot)

{

	struct btrfs_item *item = btrfs_item_nr(slot);



	return btrfs_token_item_size(token, item);

}



static inline void btrfs_set_token_item_offset_nr(struct btrfs_map_token *token,

						  int slot, u32 val)

{

	struct btrfs_item *item = btrfs_item_nr(slot);



	btrfs_set_token_item_offset(token, item, val);

#define BTRFS_ITEM_SETGET_FUNCS(member)						\

static inline u32 btrfs_item_##member(const struct extent_buffer *eb,		\

				      int slot)					\

{										\

	return btrfs_raw_item_##member(eb, btrfs_item_nr(slot));		\

}										\

static inline void btrfs_set_item_##member(const struct extent_buffer *eb,	\

					   int slot, u32 val)			\

{										\

	btrfs_set_raw_item_##member(eb, btrfs_item_nr(slot), val);		\

}										\

static inline u32 btrfs_token_item_##member(struct btrfs_map_token *token,	\

					    int slot)				\

{										\

	struct btrfs_item *item = btrfs_item_nr(slot);				\

	return btrfs_token_raw_item_##member(token, item);			\

}										\

static inline void btrfs_set_token_item_##member(struct btrfs_map_token *token,	\

						 int slot, u32 val)		\

{										\

	struct btrfs_item *item = btrfs_item_nr(slot);				\

	btrfs_set_token_raw_item_##member(token, item, val);			\

}



static inline void btrfs_set_token_item_size_nr(struct btrfs_map_token *token,

						int slot, u32 val)

{

	struct btrfs_item *item = btrfs_item_nr(slot);



	btrfs_set_token_item_size(token, item, val);

}

BTRFS_ITEM_SETGET_FUNCS(offset)

BTRFS_ITEM_SETGET_FUNCS(size);



static inline void btrfs_item_key(const struct extent_buffer *eb,

			   struct btrfs_disk_key *disk_key, int nr)
@@ -2507,7 +2480,7 @@ static inline unsigned int leaf_data_end(const struct extent_buffer *leaf) 


	if (nr == 0)

		return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);

	return btrfs_item_offset_nr(leaf, nr - 1);

	return btrfs_item_offset(leaf, nr - 1);

}



/* struct btrfs_file_extent_item */
@@ -2568,7 +2541,7 @@ static inline u32 btrfs_file_extent_inline_item_len( 
						const struct extent_buffer *eb,

						int nr)

{

	return btrfs_item_size_nr(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START;

	return btrfs_item_size(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START;

}



/* btrfs_qgroup_status_item */
@@ -2660,11 +2633,11 @@ BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right, 
/* helper function to cast into the data area of the leaf. */

#define btrfs_item_ptr(leaf, slot, type) \

	((type *)(BTRFS_LEAF_DATA_OFFSET + \

	btrfs_item_offset_nr(leaf, slot)))

	btrfs_item_offset(leaf, slot)))



#define btrfs_item_ptr_offset(leaf, slot) \

	((unsigned long)(BTRFS_LEAF_DATA_OFFSET + \

	btrfs_item_offset_nr(leaf, slot)))

	btrfs_item_offset(leaf, slot)))



static inline u32 btrfs_crc32c(u32 crc, const void *address, unsigned length)

{

fs/btrfs/dev-replace.c

+2 −2
Original line number Diff line number Diff line
@@ -128,7 +128,7 @@ int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info) 
	}

	slot = path->slots[0];

	eb = path->nodes[0];

	item_size = btrfs_item_size_nr(eb, slot);

	item_size = btrfs_item_size(eb, slot);

	ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_replace_item);



	if (item_size != sizeof(struct btrfs_dev_replace_item)) {
@@ -381,7 +381,7 @@ int btrfs_run_dev_replace(struct btrfs_trans_handle *trans) 
	}



	if (ret == 0 &&

	    btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {

	    btrfs_item_size(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {

		/*

		 * need to delete old one and insert a new one.

		 * Since no attempt is made to recover any old state, if the

fs/btrfs/dir-item.c

+5 −5
Original line number Diff line number Diff line
@@ -41,8 +41,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);

	ASSERT(data_size <= btrfs_item_size_nr(leaf, path->slots[0]));

	ptr += btrfs_item_size_nr(leaf, path->slots[0]) - data_size;

	ASSERT(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;

}
@@ -269,7 +269,7 @@ int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir, 
	data_size = sizeof(*di) + name_len;

	leaf = path->nodes[0];

	slot = path->slots[0];

	if (data_size + btrfs_item_size_nr(leaf, slot) +

	if (data_size + btrfs_item_size(leaf, slot) +

	    sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root->fs_info)) {

		ret = -EOVERFLOW;

	} else {
@@ -407,7 +407,7 @@ struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info, 
	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]);

	while (cur < total_len) {

		this_len = sizeof(*dir_item) +

			btrfs_dir_name_len(leaf, dir_item) +
@@ -443,7 +443,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 == item_len) {

		ret = btrfs_del_item(trans, root, path);

	} else {