Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0b246afa authored by Jeff Mahoney's avatar Jeff Mahoney Committed by David Sterba
Browse files

btrfs: root->fs_info cleanup, add fs_info convenience variables 



In routines where someptr->fs_info is referenced multiple times, we
introduce a convenience variable.  This makes the code considerably
more readable.

Signed-off-by: default avatarJeff Mahoney <jeffm@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 6202df69

fs/btrfs/check-integrity.c

+33 −30
Original line number Diff line number Diff line
@@ -646,11 +646,12 @@ static struct btrfsic_dev_state *btrfsic_dev_state_hashtable_lookup( 
static int btrfsic_process_superblock(struct btrfsic_state *state,

				      struct btrfs_fs_devices *fs_devices)

{

	int ret = 0;

	struct btrfs_fs_info *fs_info = state->fs_info;

	struct btrfs_super_block *selected_super;

	struct list_head *dev_head = &fs_devices->devices;

	struct btrfs_device *device;

	struct btrfsic_dev_state *selected_dev_state = NULL;

	int ret = 0;

	int pass;



	BUG_ON(NULL == state);
@@ -716,9 +717,8 @@ static int btrfsic_process_superblock(struct btrfsic_state *state, 
			break;

		}



		num_copies =

		    btrfs_num_copies(state->fs_info,

				     next_bytenr, state->metablock_size);

		num_copies = btrfs_num_copies(fs_info, next_bytenr,

					      state->metablock_size);

		if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)

			pr_info("num_copies(log_bytenr=%llu) = %d\n",

			       next_bytenr, num_copies);
@@ -783,6 +783,7 @@ static int btrfsic_process_superblock_dev_mirror( 
		struct btrfsic_dev_state **selected_dev_state,

		struct btrfs_super_block *selected_super)

{

	struct btrfs_fs_info *fs_info = state->fs_info;

	struct btrfs_super_block *super_tmp;

	u64 dev_bytenr;

	struct buffer_head *bh;
@@ -832,7 +833,7 @@ static int btrfsic_process_superblock_dev_mirror( 
		superblock_tmp->never_written = 0;

		superblock_tmp->mirror_num = 1 + superblock_mirror_num;

		if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE)

			btrfs_info_in_rcu(device->fs_info,

			btrfs_info_in_rcu(fs_info,

				"new initial S-block (bdev %p, %s) @%llu (%s/%llu/%d)",

				     superblock_bdev,

				     rcu_str_deref(device->name), dev_bytenr,
@@ -887,9 +888,8 @@ static int btrfsic_process_superblock_dev_mirror( 
			break;

		}



		num_copies =

		    btrfs_num_copies(state->fs_info,

				     next_bytenr, state->metablock_size);

		num_copies = btrfs_num_copies(fs_info, next_bytenr,

					      state->metablock_size);

		if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)

			pr_info("num_copies(log_bytenr=%llu) = %d\n",

			       next_bytenr, num_copies);
@@ -1254,6 +1254,7 @@ static int btrfsic_create_link_to_next_block( 
		struct btrfs_disk_key *disk_key,

		u64 parent_generation)

{

	struct btrfs_fs_info *fs_info = state->fs_info;

	struct btrfsic_block *next_block = NULL;

	int ret;

	struct btrfsic_block_link *l;
@@ -1262,9 +1263,8 @@ static int btrfsic_create_link_to_next_block( 


	*next_blockp = NULL;

	if (0 == *num_copiesp) {

		*num_copiesp =

		    btrfs_num_copies(state->fs_info,

				     next_bytenr, state->metablock_size);

		*num_copiesp = btrfs_num_copies(fs_info, next_bytenr,

						state->metablock_size);

		if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)

			pr_info("num_copies(log_bytenr=%llu) = %d\n",

			       next_bytenr, *num_copiesp);
@@ -1390,13 +1390,14 @@ static int btrfsic_handle_extent_data( 
		struct btrfsic_block_data_ctx *block_ctx,

		u32 item_offset, int force_iodone_flag)

{

	int ret;

	struct btrfs_fs_info *fs_info = state->fs_info;

	struct btrfs_file_extent_item file_extent_item;

	u64 file_extent_item_offset;

	u64 next_bytenr;

	u64 num_bytes;

	u64 generation;

	struct btrfsic_block_link *l;

	int ret;



	file_extent_item_offset = offsetof(struct btrfs_leaf, items) +

				  item_offset;
@@ -1456,9 +1457,8 @@ static int btrfsic_handle_extent_data( 
		else

			chunk_len = num_bytes;



		num_copies =

		    btrfs_num_copies(state->fs_info,

				     next_bytenr, state->datablock_size);

		num_copies = btrfs_num_copies(fs_info, next_bytenr,

					      state->datablock_size);

		if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)

			pr_info("num_copies(log_bytenr=%llu) = %d\n",

			       next_bytenr, num_copies);
@@ -1533,13 +1533,14 @@ static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len, 
			     struct btrfsic_block_data_ctx *block_ctx_out,

			     int mirror_num)

{

	struct btrfs_fs_info *fs_info = state->fs_info;

	int ret;

	u64 length;

	struct btrfs_bio *multi = NULL;

	struct btrfs_device *device;



	length = len;

	ret = btrfs_map_block(state->fs_info, BTRFS_MAP_READ,

	ret = btrfs_map_block(fs_info, BTRFS_MAP_READ,

			      bytenr, &length, &multi, mirror_num);



	if (ret) {
@@ -1731,6 +1732,7 @@ static void btrfsic_dump_database(struct btrfsic_state *state) 
static int btrfsic_test_for_metadata(struct btrfsic_state *state,

				     char **datav, unsigned int num_pages)

{

	struct btrfs_fs_info *fs_info = state->fs_info;

	struct btrfs_header *h;

	u8 csum[BTRFS_CSUM_SIZE];

	u32 crc = ~(u32)0;
@@ -1741,7 +1743,7 @@ static int btrfsic_test_for_metadata(struct btrfsic_state *state, 
	num_pages = state->metablock_size >> PAGE_SHIFT;

	h = (struct btrfs_header *)datav[0];



	if (memcmp(h->fsid, state->fs_info->fsid, BTRFS_UUID_SIZE))

	if (memcmp(h->fsid, fs_info->fsid, BTRFS_UUID_SIZE))

		return 1;



	for (i = 0; i < num_pages; i++) {
@@ -2202,6 +2204,7 @@ static int btrfsic_process_written_superblock( 
		struct btrfsic_block *const superblock,

		struct btrfs_super_block *const super_hdr)

{

	struct btrfs_fs_info *fs_info = state->fs_info;

	int pass;



	superblock->generation = btrfs_super_generation(super_hdr);
@@ -2275,9 +2278,8 @@ static int btrfsic_process_written_superblock( 
			break;

		}



		num_copies =

		    btrfs_num_copies(state->fs_info,

				     next_bytenr, BTRFS_SUPER_INFO_SIZE);

		num_copies = btrfs_num_copies(fs_info, next_bytenr,

					      BTRFS_SUPER_INFO_SIZE);

		if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)

			pr_info("num_copies(log_bytenr=%llu) = %d\n",

			       next_bytenr, num_copies);
@@ -2699,14 +2701,14 @@ static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state, 
					   struct btrfsic_dev_state *dev_state,

					   u64 dev_bytenr)

{

	struct btrfs_fs_info *fs_info = state->fs_info;

	struct btrfsic_block_data_ctx block_ctx;

	int num_copies;

	int mirror_num;

	int ret;

	struct btrfsic_block_data_ctx block_ctx;

	int match = 0;

	int ret;



	num_copies = btrfs_num_copies(state->fs_info,

				      bytenr, state->metablock_size);

	num_copies = btrfs_num_copies(fs_info, bytenr, state->metablock_size);



	for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {

		ret = btrfsic_map_block(state, bytenr, state->metablock_size,
@@ -2909,16 +2911,17 @@ int btrfsic_mount(struct btrfs_root *root, 
	int ret;

	struct btrfsic_state *state;

	struct list_head *dev_head = &fs_devices->devices;

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_device *device;



	if (root->fs_info->nodesize & ((u64)PAGE_SIZE - 1)) {

	if (fs_info->nodesize & ((u64)PAGE_SIZE - 1)) {

		pr_info("btrfsic: cannot handle nodesize %d not being a multiple of PAGE_SIZE %ld!\n",

		       root->fs_info->nodesize, PAGE_SIZE);

		       fs_info->nodesize, PAGE_SIZE);

		return -1;

	}

	if (root->fs_info->sectorsize & ((u64)PAGE_SIZE - 1)) {

	if (fs_info->sectorsize & ((u64)PAGE_SIZE - 1)) {

		pr_info("btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_SIZE %ld!\n",

		       root->fs_info->sectorsize, PAGE_SIZE);

		       fs_info->sectorsize, PAGE_SIZE);

		return -1;

	}

	state = kzalloc(sizeof(*state), GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT);
@@ -2940,8 +2943,8 @@ int btrfsic_mount(struct btrfs_root *root, 
	state->print_mask = print_mask;

	state->include_extent_data = including_extent_data;

	state->csum_size = 0;

	state->metablock_size = root->fs_info->nodesize;

	state->datablock_size = root->fs_info->sectorsize;

	state->metablock_size = fs_info->nodesize;

	state->datablock_size = fs_info->sectorsize;

	INIT_LIST_HEAD(&state->all_blocks_list);

	btrfsic_block_hashtable_init(&state->block_hashtable);

	btrfsic_block_link_hashtable_init(&state->block_link_hashtable);

fs/btrfs/compression.c

+15 −13
Original line number Diff line number Diff line
@@ -88,10 +88,11 @@ static int btrfs_decompress_bio(int type, struct page **pages_in, 
static inline int compressed_bio_size(struct btrfs_root *root,

				      unsigned long disk_size)

{

	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);

	struct btrfs_fs_info *fs_info = root->fs_info;

	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);



	return sizeof(struct compressed_bio) +

		(DIV_ROUND_UP(disk_size, root->fs_info->sectorsize)) * csum_size;

		(DIV_ROUND_UP(disk_size, fs_info->sectorsize)) * csum_size;

}



static struct bio *compressed_bio_alloc(struct block_device *bdev,
@@ -328,6 +329,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, 
				 struct page **compressed_pages,

				 unsigned long nr_pages)

{

	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);

	struct bio *bio = NULL;

	struct btrfs_root *root = BTRFS_I(inode)->root;

	struct compressed_bio *cb;
@@ -355,7 +357,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, 
	cb->orig_bio = NULL;

	cb->nr_pages = nr_pages;



	bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;

	bdev = fs_info->fs_devices->latest_bdev;



	bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);

	if (!bio) {
@@ -391,7 +393,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, 
			 * freed before we're done setting it up

			 */

			atomic_inc(&cb->pending_bios);

			ret = btrfs_bio_wq_end_io(root->fs_info, bio,

			ret = btrfs_bio_wq_end_io(fs_info, bio,

						  BTRFS_WQ_ENDIO_DATA);

			BUG_ON(ret); /* -ENOMEM */
@@ -417,7 +419,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, 
			bio_add_page(bio, page, PAGE_SIZE, 0);

		}

		if (bytes_left < PAGE_SIZE) {

			btrfs_info(BTRFS_I(inode)->root->fs_info,

			btrfs_info(fs_info,

					"bytes left %lu compress len %lu nr %lu",

			       bytes_left, cb->compressed_len, cb->nr_pages);

		}
@@ -427,7 +429,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, 
	}

	bio_get(bio);



	ret = btrfs_bio_wq_end_io(root->fs_info, bio, BTRFS_WQ_ENDIO_DATA);

	ret = btrfs_bio_wq_end_io(fs_info, bio, BTRFS_WQ_ENDIO_DATA);

	BUG_ON(ret); /* -ENOMEM */



	if (!skip_sum) {
@@ -575,6 +577,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,

				 int mirror_num, unsigned long bio_flags)

{

	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);

	struct extent_io_tree *tree;

	struct extent_map_tree *em_tree;

	struct compressed_bio *cb;
@@ -634,7 +637,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
	if (!cb->compressed_pages)

		goto fail1;



	bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;

	bdev = fs_info->fs_devices->latest_bdev;



	for (pg_index = 0; pg_index < nr_pages; pg_index++) {

		cb->compressed_pages[pg_index] = alloc_page(GFP_NOFS |
@@ -678,7 +681,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
		    PAGE_SIZE) {

			bio_get(comp_bio);



			ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio,

			ret = btrfs_bio_wq_end_io(fs_info, comp_bio,

						  BTRFS_WQ_ENDIO_DATA);

			BUG_ON(ret); /* -ENOMEM */
@@ -696,7 +699,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
				BUG_ON(ret); /* -ENOMEM */

			}

			sums += DIV_ROUND_UP(comp_bio->bi_iter.bi_size,

					     root->fs_info->sectorsize);

					     fs_info->sectorsize);



			ret = btrfs_map_bio(root, comp_bio, mirror_num, 0);

			if (ret) {
@@ -719,8 +722,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
	}

	bio_get(comp_bio);



	ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio,

			BTRFS_WQ_ENDIO_DATA);

	ret = btrfs_bio_wq_end_io(fs_info, comp_bio, BTRFS_WQ_ENDIO_DATA);

	BUG_ON(ret); /* -ENOMEM */



	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {

fs/btrfs/ctree.c

+140 −115

File changed.

Preview size limit exceeded, changes collapsed.

fs/btrfs/ctree.h

+9 −5
Original line number Diff line number Diff line
@@ -1352,9 +1352,11 @@ static inline int 
btrfs_should_fragment_free_space(struct btrfs_root *root,

				 struct btrfs_block_group_cache *block_group)

{

	return (btrfs_test_opt(root->fs_info, FRAGMENT_METADATA) &&

	struct btrfs_fs_info *fs_info = root->fs_info;



	return (btrfs_test_opt(fs_info, FRAGMENT_METADATA) &&

		block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||

	       (btrfs_test_opt(root->fs_info, FRAGMENT_DATA) &&

	       (btrfs_test_opt(fs_info, FRAGMENT_DATA) &&

		block_group->flags &  BTRFS_BLOCK_GROUP_DATA);

}

#endif
@@ -2312,10 +2314,11 @@ static inline unsigned long btrfs_leaf_data(struct extent_buffer *l) 
static inline unsigned int leaf_data_end(struct btrfs_root *root,

					 struct extent_buffer *leaf)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	u32 nr = btrfs_header_nritems(leaf);



	if (nr == 0)

		return BTRFS_LEAF_DATA_SIZE(root->fs_info);

		return BTRFS_LEAF_DATA_SIZE(fs_info);

	return btrfs_item_offset_nr(leaf, nr - 1);

}
@@ -2905,8 +2908,9 @@ static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info) 
 */

static inline int btrfs_need_cleaner_sleep(struct btrfs_root *root)

{

	return (root->fs_info->sb->s_flags & MS_RDONLY ||

		btrfs_fs_closing(root->fs_info));

	struct btrfs_fs_info *fs_info = root->fs_info;



	return (fs_info->sb->s_flags & MS_RDONLY || btrfs_fs_closing(fs_info));

}



static inline void free_fs_info(struct btrfs_fs_info *fs_info)

fs/btrfs/delayed-inode.c

+21 −16
Original line number Diff line number Diff line
@@ -538,6 +538,7 @@ static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans, 
					       struct btrfs_root *root,

					       struct btrfs_delayed_item *item)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_block_rsv *src_rsv;

	struct btrfs_block_rsv *dst_rsv;

	u64 num_bytes;
@@ -547,12 +548,12 @@ static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans, 
		return 0;



	src_rsv = trans->block_rsv;

	dst_rsv = &root->fs_info->delayed_block_rsv;

	dst_rsv = &fs_info->delayed_block_rsv;



	num_bytes = btrfs_calc_trans_metadata_size(root->fs_info, 1);

	num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);

	ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, 1);

	if (!ret) {

		trace_btrfs_space_reservation(root->fs_info, "delayed_item",

		trace_btrfs_space_reservation(fs_info, "delayed_item",

					      item->key.objectid,

					      num_bytes, 1);

		item->bytes_reserved = num_bytes;
@@ -564,13 +565,14 @@ static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans, 
static void btrfs_delayed_item_release_metadata(struct btrfs_root *root,

						struct btrfs_delayed_item *item)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_block_rsv *rsv;



	if (!item->bytes_reserved)

		return;



	rsv = &root->fs_info->delayed_block_rsv;

	trace_btrfs_space_reservation(root->fs_info, "delayed_item",

	rsv = &fs_info->delayed_block_rsv;

	trace_btrfs_space_reservation(fs_info, "delayed_item",

				      item->key.objectid, item->bytes_reserved,

				      0);

	btrfs_block_rsv_release(root, rsv,
@@ -583,6 +585,7 @@ static int btrfs_delayed_inode_reserve_metadata( 
					struct inode *inode,

					struct btrfs_delayed_node *node)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_block_rsv *src_rsv;

	struct btrfs_block_rsv *dst_rsv;

	u64 num_bytes;
@@ -590,9 +593,9 @@ static int btrfs_delayed_inode_reserve_metadata( 
	bool release = false;



	src_rsv = trans->block_rsv;

	dst_rsv = &root->fs_info->delayed_block_rsv;

	dst_rsv = &fs_info->delayed_block_rsv;



	num_bytes = btrfs_calc_trans_metadata_size(root->fs_info, 1);

	num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);



	/*

	 * If our block_rsv is the delalloc block reserve then check and see if
@@ -640,7 +643,7 @@ static int btrfs_delayed_inode_reserve_metadata( 
			ret = -ENOSPC;

		if (!ret) {

			node->bytes_reserved = num_bytes;

			trace_btrfs_space_reservation(root->fs_info,

			trace_btrfs_space_reservation(fs_info,

						      "delayed_inode",

						      btrfs_ino(inode),

						      num_bytes, 1);
@@ -664,13 +667,13 @@ static int btrfs_delayed_inode_reserve_metadata( 
	 * how block rsvs. work.

	 */

	if (!ret) {

		trace_btrfs_space_reservation(root->fs_info, "delayed_inode",

		trace_btrfs_space_reservation(fs_info, "delayed_inode",

					      btrfs_ino(inode), num_bytes, 1);

		node->bytes_reserved = num_bytes;

	}



	if (release) {

		trace_btrfs_space_reservation(root->fs_info, "delalloc",

		trace_btrfs_space_reservation(fs_info, "delalloc",

					      btrfs_ino(inode), num_bytes, 0);

		btrfs_block_rsv_release(root, src_rsv, num_bytes);

	}
@@ -681,13 +684,14 @@ static int btrfs_delayed_inode_reserve_metadata( 
static void btrfs_delayed_inode_release_metadata(struct btrfs_root *root,

						struct btrfs_delayed_node *node)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_block_rsv *rsv;



	if (!node->bytes_reserved)

		return;



	rsv = &root->fs_info->delayed_block_rsv;

	trace_btrfs_space_reservation(root->fs_info, "delayed_inode",

	rsv = &fs_info->delayed_block_rsv;

	trace_btrfs_space_reservation(fs_info, "delayed_inode",

				      node->inode_id, node->bytes_reserved, 0);

	btrfs_block_rsv_release(root, rsv,

				node->bytes_reserved);
@@ -1140,6 +1144,7 @@ __btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 
static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans,

				     struct btrfs_root *root, int nr)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct btrfs_delayed_root *delayed_root;

	struct btrfs_delayed_node *curr_node, *prev_node;

	struct btrfs_path *path;
@@ -1156,7 +1161,7 @@ static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, 
	path->leave_spinning = 1;



	block_rsv = trans->block_rsv;

	trans->block_rsv = &root->fs_info->delayed_block_rsv;

	trans->block_rsv = &fs_info->delayed_block_rsv;



	delayed_root = btrfs_get_delayed_root(root);
@@ -1860,6 +1865,7 @@ int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans, 


int btrfs_delayed_delete_inode_ref(struct inode *inode)

{

	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);

	struct btrfs_delayed_node *delayed_node;



	/*
@@ -1867,8 +1873,7 @@ int btrfs_delayed_delete_inode_ref(struct inode *inode) 
	 * leads to enospc problems.  This means we also can't do

	 * delayed inode refs

	 */

	if (test_bit(BTRFS_FS_LOG_RECOVERING,

		     &BTRFS_I(inode)->root->fs_info->flags))

	if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))

		return -EAGAIN;



	delayed_node = btrfs_get_or_create_delayed_node(inode);
@@ -1895,7 +1900,7 @@ int btrfs_delayed_delete_inode_ref(struct inode *inode) 


	set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags);

	delayed_node->count++;

	atomic_inc(&BTRFS_I(inode)->root->fs_info->delayed_root->items);

	atomic_inc(&fs_info->delayed_root->items);

release_node:

	mutex_unlock(&delayed_node->mutex);

	btrfs_release_delayed_node(delayed_node);