Commit 2e38a84b authored by Christoph Hellwig's avatar Christoph Hellwig Committed by David Sterba
Browse files

btrfs: simplify extent map splitting and rename split_zoned_em 



split_zoned_em is only ever asked to split out the beginning of an extent
map.  Change it to only take a len to split out instead of a pre and post
region.

Also rename the function to split_extent_map as there is nothing zoned
device specific about it.

Reviewed-by: default avatarJosef Bacik <josef@toxicpanda.com>
Tested-by: default avatarJohannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent f0792b79

fs/btrfs/inode.c

+26 −51
Original line number Diff line number Diff line
@@ -2512,37 +2512,31 @@ void btrfs_clear_delalloc_extent(struct btrfs_inode *inode, 
}



/*

 * Split an extent_map at [start, start + len]

 * Split off the first pre bytes from the extent_map at [start, start + len]

 *

 * This function is intended to be used only for extract_ordered_extent().

 */

static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len,

			  u64 pre, u64 post)

static int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre)

{

	struct extent_map_tree *em_tree = &inode->extent_tree;

	struct extent_map *em;

	struct extent_map *split_pre = NULL;

	struct extent_map *split_mid = NULL;

	struct extent_map *split_post = NULL;

	int ret = 0;

	unsigned long flags;



	/* Sanity check */

	if (pre == 0 && post == 0)

		return 0;

	ASSERT(pre != 0);

	ASSERT(pre < len);



	split_pre = alloc_extent_map();

	if (pre)

	if (!split_pre)

		return -ENOMEM;

	split_mid = alloc_extent_map();

	if (post)

		split_post = alloc_extent_map();

	if (!split_pre || (pre && !split_mid) || (post && !split_post)) {

	if (!split_mid) {

		ret = -ENOMEM;

		goto out;

		goto out_free_pre;

	}



	ASSERT(pre + post < len);



	lock_extent(&inode->io_tree, start, start + len - 1, NULL);

	write_lock(&em_tree->lock);

	em = lookup_extent_mapping(em_tree, start, len);
@@ -2563,7 +2557,7 @@ static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len, 


	/* First, replace the em with a new extent_map starting from * em->start */

	split_pre->start = em->start;

	split_pre->len = (pre ? pre : em->len - post);

	split_pre->len = pre;

	split_pre->orig_start = split_pre->start;

	split_pre->block_start = em->block_start;

	split_pre->block_len = split_pre->len;
@@ -2577,14 +2571,12 @@ static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len, 


	/*

	 * Now we only have an extent_map at:

	 *     [em->start, em->start + pre] if pre != 0

	 *     [em->start, em->start + em->len - post] if pre == 0

	 *     [em->start, em->start + pre]

	 */



	if (pre) {

		/* Insert the middle extent_map */

	/* Insert the middle extent_map. */

	split_mid->start = em->start + pre;

		split_mid->len = em->len - pre - post;

	split_mid->len = em->len - pre;

	split_mid->orig_start = split_mid->start;

	split_mid->block_start = em->block_start + pre;

	split_mid->block_len = split_mid->len;
@@ -2594,21 +2586,6 @@ static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len, 
	split_mid->compress_type = em->compress_type;

	split_mid->generation = em->generation;

	add_extent_mapping(em_tree, split_mid, 1);

	}



	if (post) {

		split_post->start = em->start + em->len - post;

		split_post->len = post;

		split_post->orig_start = split_post->start;

		split_post->block_start = em->block_start + em->len - post;

		split_post->block_len = split_post->len;

		split_post->orig_block_len = split_post->block_len;

		split_post->ram_bytes = split_post->len;

		split_post->flags = flags;

		split_post->compress_type = em->compress_type;

		split_post->generation = em->generation;

		add_extent_mapping(em_tree, split_post, 1);

	}



	/* Once for us */

	free_extent_map(em);
@@ -2618,11 +2595,9 @@ static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len, 
out_unlock:

	write_unlock(&em_tree->lock);

	unlock_extent(&inode->io_tree, start, start + len - 1, NULL);

out:

	free_extent_map(split_pre);

	free_extent_map(split_mid);

	free_extent_map(split_post);



out_free_pre:

	free_extent_map(split_pre);

	return ret;

}
@@ -2653,7 +2628,7 @@ blk_status_t btrfs_extract_ordered_extent(struct btrfs_bio *bbio) 
	ret = btrfs_split_ordered_extent(ordered, len);

	if (ret)

		goto out;

	ret = split_zoned_em(inode, bbio->file_offset, ordered_len, len, 0);

	ret = split_extent_map(inode, bbio->file_offset, ordered_len, len);

out:

	btrfs_put_ordered_extent(ordered);

	return errno_to_blk_status(ret);