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

Btrfs: replace tree->mapping with tree->private_data 



For extent_io tree's we have carried the address_mapping of the inode
around in the io tree in order to pull the inode back out for calling
into various tree ops hooks.  This works fine when everything that has
an extent_io_tree has an inode.  But we are going to remove the
btree_inode, so we need to change this.  Instead just have a generic
void * for private data that we can initialize with, and have all the
tree ops use that instead.  This had a lot of cascading changes but
should be relatively straightforward.

Signed-off-by: default avatarJosef Bacik <jbacik@fb.com>
Reviewed-by: default avatarChandan Rajendra <chandan@linux.vnet.ibm.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
[ minor reordering of the callback prototypes ]
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 2723480a

fs/btrfs/ctree.h

+1 −0
Original line number Diff line number Diff line
@@ -3172,6 +3172,7 @@ int btrfs_create_subvol_root(struct btrfs_trans_handle *trans, 
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,

			 size_t size, struct bio *bio,

			 unsigned long bio_flags);

void btrfs_set_range_writeback(void *private_data, u64 start, u64 end);

int btrfs_page_mkwrite(struct vm_fault *vmf);

int btrfs_readpage(struct file *file, struct page *page);

void btrfs_evict_inode(struct inode *inode);

fs/btrfs/disk-io.c

+29 −21
Original line number Diff line number Diff line
@@ -118,7 +118,8 @@ void btrfs_end_io_wq_exit(void) 
 * just before they are sent down the IO stack.

 */

struct async_submit_bio {

	struct inode *inode;

	void *private_data;

	struct btrfs_fs_info *fs_info;

	struct bio *bio;

	struct list_head list;

	extent_submit_bio_hook_t *submit_bio_start;
@@ -871,7 +872,7 @@ static void run_one_async_start(struct btrfs_work *work) 
	int ret;



	async = container_of(work, struct  async_submit_bio, work);

	ret = async->submit_bio_start(async->inode, async->bio,

	ret = async->submit_bio_start(async->private_data, async->bio,

				      async->mirror_num, async->bio_flags,

				      async->bio_offset);

	if (ret)
@@ -885,7 +886,7 @@ static void run_one_async_done(struct btrfs_work *work) 
	int limit;



	async = container_of(work, struct  async_submit_bio, work);

	fs_info = BTRFS_I(async->inode)->root->fs_info;

	fs_info = async->fs_info;



	limit = btrfs_async_submit_limit(fs_info);

	limit = limit * 2 / 3;
@@ -904,7 +905,7 @@ static void run_one_async_done(struct btrfs_work *work) 
		return;

	}



	async->submit_bio_done(async->inode, async->bio, async->mirror_num,

	async->submit_bio_done(async->private_data, async->bio, async->mirror_num,

			       async->bio_flags, async->bio_offset);

}
@@ -916,10 +917,9 @@ static void run_one_async_free(struct btrfs_work *work) 
	kfree(async);

}



int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,

			struct bio *bio, int mirror_num,

			unsigned long bio_flags,

			u64 bio_offset,

int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio,

			int mirror_num, unsigned long bio_flags,

			u64 bio_offset, void *private_data,

			extent_submit_bio_hook_t *submit_bio_start,

			extent_submit_bio_hook_t *submit_bio_done)

{
@@ -929,7 +929,8 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode, 
	if (!async)

		return -ENOMEM;



	async->inode = inode;

	async->private_data = private_data;

	async->fs_info = fs_info;

	async->bio = bio;

	async->mirror_num = mirror_num;

	async->submit_bio_start = submit_bio_start;
@@ -975,7 +976,7 @@ static int btree_csum_one_bio(struct bio *bio) 
	return ret;

}



static int __btree_submit_bio_start(struct inode *inode, struct bio *bio,

static int __btree_submit_bio_start(void *private_data, struct bio *bio,

				    int mirror_num, unsigned long bio_flags,

				    u64 bio_offset)

{
@@ -986,10 +987,11 @@ static int __btree_submit_bio_start(struct inode *inode, struct bio *bio, 
	return btree_csum_one_bio(bio);

}



static int __btree_submit_bio_done(struct inode *inode, struct bio *bio,

static int __btree_submit_bio_done(void *private_data, struct bio *bio,

				 int mirror_num, unsigned long bio_flags,

				 u64 bio_offset)

{

	struct inode *inode = private_data;

	int ret;



	/*
@@ -1015,10 +1017,11 @@ static int check_async_write(unsigned long bio_flags) 
	return 1;

}



static int btree_submit_bio_hook(struct inode *inode, struct bio *bio,

static int btree_submit_bio_hook(void *private_data, struct bio *bio,

				 int mirror_num, unsigned long bio_flags,

				 u64 bio_offset)

{

	struct inode *inode = private_data;

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

	int async = check_async_write(bio_flags);

	int ret;
@@ -1043,8 +1046,8 @@ static int btree_submit_bio_hook(struct inode *inode, struct bio *bio, 
		 * kthread helpers are used to submit writes so that

		 * checksumming can happen in parallel across all CPUs

		 */

		ret = btrfs_wq_submit_bio(fs_info, inode, bio, mirror_num, 0,

					  bio_offset,

		ret = btrfs_wq_submit_bio(fs_info, bio, mirror_num, 0,

					  bio_offset, private_data,

					  __btree_submit_bio_start,

					  __btree_submit_bio_done);

	}
@@ -1347,8 +1350,7 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info, 
	root->log_transid_committed = -1;

	root->last_log_commit = 0;

	if (!dummy)

		extent_io_tree_init(&root->dirty_log_pages,

				     fs_info->btree_inode->i_mapping);

		extent_io_tree_init(&root->dirty_log_pages, NULL);



	memset(&root->root_key, 0, sizeof(root->root_key));

	memset(&root->root_item, 0, sizeof(root->root_item));
@@ -2309,7 +2311,7 @@ static void btrfs_init_btree_inode(struct btrfs_fs_info *fs_info) 
	inode->i_mapping->a_ops = &btree_aops;



	RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);

	extent_io_tree_init(&BTRFS_I(inode)->io_tree, inode->i_mapping);

	extent_io_tree_init(&BTRFS_I(inode)->io_tree, inode);

	BTRFS_I(inode)->io_tree.track_uptodate = 0;

	extent_map_tree_init(&BTRFS_I(inode)->extent_tree);
@@ -2703,10 +2705,8 @@ int open_ctree(struct super_block *sb, 
	fs_info->block_group_cache_tree = RB_ROOT;

	fs_info->first_logical_byte = (u64)-1;



	extent_io_tree_init(&fs_info->freed_extents[0],

			     fs_info->btree_inode->i_mapping);

	extent_io_tree_init(&fs_info->freed_extents[1],

			     fs_info->btree_inode->i_mapping);

	extent_io_tree_init(&fs_info->freed_extents[0], NULL);

	extent_io_tree_init(&fs_info->freed_extents[1], NULL);

	fs_info->pinned_extents = &fs_info->freed_extents[0];

	set_bit(BTRFS_FS_BARRIER, &fs_info->flags);
@@ -4686,6 +4686,12 @@ static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info) 
	return 0;

}



static struct btrfs_fs_info *btree_fs_info(void *private_data)

{

	struct inode *inode = private_data;

	return btrfs_sb(inode->i_sb);

}



static const struct extent_io_ops btree_extent_io_ops = {

	/* mandatory callbacks */

	.submit_bio_hook = btree_submit_bio_hook,
@@ -4693,6 +4699,8 @@ static const struct extent_io_ops btree_extent_io_ops = { 
	/* note we're sharing with inode.c for the merge bio hook */

	.merge_bio_hook = btrfs_merge_bio_hook,

	.readpage_io_failed_hook = btree_io_failed_hook,

	.set_range_writeback = btrfs_set_range_writeback,

	.tree_fs_info = btree_fs_info,



	/* optional callbacks */

};

fs/btrfs/disk-io.h

+3 −3
Original line number Diff line number Diff line
@@ -120,9 +120,9 @@ u32 btrfs_csum_data(const char *data, u32 seed, size_t len); 
void btrfs_csum_final(u32 crc, u8 *result);

int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,

			enum btrfs_wq_endio_type metadata);

int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,

			struct bio *bio, int mirror_num,

			unsigned long bio_flags, u64 bio_offset,

int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio,

			int mirror_num, unsigned long bio_flags,

			u64 bio_offset, void *private_data,

			extent_submit_bio_hook_t *submit_bio_start,

			extent_submit_bio_hook_t *submit_bio_done);

unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info);

fs/btrfs/extent_io.c

+15 −37
Original line number Diff line number Diff line
@@ -87,19 +87,9 @@ void btrfs_leak_debug_check(void) 
static inline void __btrfs_debug_check_extent_io_range(const char *caller,

		struct extent_io_tree *tree, u64 start, u64 end)

{

	struct inode *inode;

	u64 isize;



	if (!tree->mapping)

		return;



	inode = tree->mapping->host;

	isize = i_size_read(inode);

	if (end >= PAGE_SIZE && (end % 2) == 0 && end != isize - 1) {

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

		    "%s: ino %llu isize %llu odd range [%llu,%llu]",

			caller, btrfs_ino(BTRFS_I(inode)), isize, start, end);

	}

	if (tree->ops && tree->ops->check_extent_io_range)

		tree->ops->check_extent_io_range(tree->private_data, caller,

						 start, end);

}

#else

#define btrfs_leak_debug_add(new, head)	do {} while (0)
@@ -154,9 +144,9 @@ static noinline void flush_write_bio(void *data); 
static inline struct btrfs_fs_info *

tree_fs_info(struct extent_io_tree *tree)

{

	if (!tree->mapping)

	if (tree->ops)

		return tree->ops->tree_fs_info(tree->private_data);

	return NULL;

	return btrfs_sb(tree->mapping->host->i_sb);

}



int __init extent_io_init(void)
@@ -213,13 +203,13 @@ void extent_io_exit(void) 
}



void extent_io_tree_init(struct extent_io_tree *tree,

			 struct address_space *mapping)

			 void *private_data)

{

	tree->state = RB_ROOT;

	tree->ops = NULL;

	tree->dirty_bytes = 0;

	spin_lock_init(&tree->lock);

	tree->mapping = mapping;

	tree->private_data = private_data;

}



static struct extent_state *alloc_extent_state(gfp_t mask)
@@ -369,8 +359,7 @@ static void merge_cb(struct extent_io_tree *tree, struct extent_state *new, 
		     struct extent_state *other)

{

	if (tree->ops && tree->ops->merge_extent_hook)

		tree->ops->merge_extent_hook(tree->mapping->host, new,

					     other);

		tree->ops->merge_extent_hook(tree->private_data, new, other);

}



/*
@@ -421,15 +410,14 @@ static void set_state_cb(struct extent_io_tree *tree, 
			 struct extent_state *state, unsigned *bits)

{

	if (tree->ops && tree->ops->set_bit_hook)

		tree->ops->set_bit_hook(tree->mapping->host, state, bits);

		tree->ops->set_bit_hook(tree->private_data, state, bits);

}



static void clear_state_cb(struct extent_io_tree *tree,

			   struct extent_state *state, unsigned *bits)

{

	if (tree->ops && tree->ops->clear_bit_hook)

		tree->ops->clear_bit_hook(BTRFS_I(tree->mapping->host),

				state, bits);

		tree->ops->clear_bit_hook(tree->private_data, state, bits);

}



static void set_state_bits(struct extent_io_tree *tree,
@@ -478,7 +466,7 @@ static void split_cb(struct extent_io_tree *tree, struct extent_state *orig, 
		     u64 split)

{

	if (tree->ops && tree->ops->split_extent_hook)

		tree->ops->split_extent_hook(tree->mapping->host, orig, split);

		tree->ops->split_extent_hook(tree->private_data, orig, split);

}



/*
@@ -1402,17 +1390,7 @@ void extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end) 
 */

static void set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end)

{

	unsigned long index = start >> PAGE_SHIFT;

	unsigned long end_index = end >> PAGE_SHIFT;

	struct page *page;



	while (index <= end_index) {

		page = find_get_page(tree->mapping, index);

		BUG_ON(!page); /* Pages should be in the extent_io_tree */

		set_page_writeback(page);

		put_page(page);

		index++;

	}

	tree->ops->set_range_writeback(tree->private_data, start, end);

}



/* find the first state struct with 'bits' set after 'start', and
@@ -2431,7 +2409,7 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset, 
		"Repair Read Error: submitting new read[%#x] to this_mirror=%d, in_validation=%d",

		read_mode, failrec->this_mirror, failrec->in_validation);



	ret = tree->ops->submit_bio_hook(inode, bio, failrec->this_mirror,

	ret = tree->ops->submit_bio_hook(tree->private_data, bio, failrec->this_mirror,

					 failrec->bio_flags, 0);

	if (ret) {

		free_io_failure(BTRFS_I(inode), failrec);
@@ -2755,7 +2733,7 @@ static int __must_check submit_one_bio(struct bio *bio, int mirror_num, 
	bio_get(bio);



	if (tree->ops)

		ret = tree->ops->submit_bio_hook(page->mapping->host, bio,

		ret = tree->ops->submit_bio_hook(tree->private_data, bio,

					   mirror_num, bio_flags, start);

	else

		btrfsic_submit_bio(bio);

fs/btrfs/extent_io.h

+12 −9
Original line number Diff line number Diff line
@@ -92,7 +92,7 @@ struct btrfs_inode; 
struct btrfs_io_bio;

struct io_failure_record;



typedef	int (extent_submit_bio_hook_t)(struct inode *inode, struct bio *bio,

typedef	int (extent_submit_bio_hook_t)(void *private_data, struct bio *bio,

				       int mirror_num, unsigned long bio_flags,

				       u64 bio_offset);

struct extent_io_ops {
@@ -108,32 +108,36 @@ struct extent_io_ops { 
			      size_t size, struct bio *bio,

			      unsigned long bio_flags);

	int (*readpage_io_failed_hook)(struct page *page, int failed_mirror);

	struct btrfs_fs_info *(*tree_fs_info)(void *private_data);

	void (*set_range_writeback)(void *private_data, u64 start, u64 end);



	/*

	 * Optional hooks, called if the pointer is not NULL

	 */

	int (*fill_delalloc)(struct inode *inode, struct page *locked_page,

	int (*fill_delalloc)(void *private_data, struct page *locked_page,

			     u64 start, u64 end, int *page_started,

			     unsigned long *nr_written);



	int (*writepage_start_hook)(struct page *page, u64 start, u64 end);

	void (*writepage_end_io_hook)(struct page *page, u64 start, u64 end,

				      struct extent_state *state, int uptodate);

	void (*set_bit_hook)(struct inode *inode, struct extent_state *state,

	void (*set_bit_hook)(void *private_data, struct extent_state *state,

			     unsigned *bits);

	void (*clear_bit_hook)(struct btrfs_inode *inode,

	void (*clear_bit_hook)(void *private_data,

			struct extent_state *state,

			unsigned *bits);

	void (*merge_extent_hook)(struct inode *inode,

	void (*merge_extent_hook)(void *private_data,

				  struct extent_state *new,

				  struct extent_state *other);

	void (*split_extent_hook)(struct inode *inode,

	void (*split_extent_hook)(void *private_data,

				  struct extent_state *orig, u64 split);

	void (*check_extent_io_range)(void *private_data, const char *caller,

				      u64 start, u64 end);

};



struct extent_io_tree {

	struct rb_root state;

	struct address_space *mapping;

	void *private_data;

	u64 dirty_bytes;

	int track_uptodate;

	spinlock_t lock;
@@ -230,8 +234,7 @@ typedef struct extent_map *(get_extent_t)(struct btrfs_inode *inode, 
					  u64 start, u64 len,

					  int create);



void extent_io_tree_init(struct extent_io_tree *tree,

			 struct address_space *mapping);

void extent_io_tree_init(struct extent_io_tree *tree, void *private_data);

int try_release_extent_mapping(struct extent_map_tree *map,

			       struct extent_io_tree *tree, struct page *page,

			       gfp_t mask);

CRA Git | Maintained and supported by SUSTech CRA and CCSE