Commit 2e871330 authored by Filipe Manana's avatar Filipe Manana Committed by David Sterba
Browse files

btrfs: rename extent map functions to get block start, end and check if in tree 



These functions are exported and don't have a 'btrfs_' prefix in their
names, which goes against coding style conventions. Rename them to have
such prefix, making it clear they are from btrfs and avoiding potential
collisions in the future with functions defined elsewhere outside btrfs.

Signed-off-by: default avatarFilipe Manana <fdmanana@suse.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 962162ff

fs/btrfs/compression.c

+2 −2
Original line number Diff line number Diff line
@@ -510,8 +510,8 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
		 * to this compressed extent on disk.

		 */

		if (!em || cur < em->start ||

		    (cur + fs_info->sectorsize > extent_map_end(em)) ||

		    (extent_map_block_start(em) >> SECTOR_SHIFT) !=

		    (cur + fs_info->sectorsize > btrfs_extent_map_end(em)) ||

		    (btrfs_extent_map_block_start(em) >> SECTOR_SHIFT) !=

		    orig_bio->bi_iter.bi_sector) {

			free_extent_map(em);

			btrfs_unlock_extent(tree, cur, page_end, NULL);

fs/btrfs/defrag.c

+2 −2
Original line number Diff line number Diff line
@@ -1074,7 +1074,7 @@ static int defrag_collect_targets(struct btrfs_inode *inode, 


add:

		last_is_target = true;

		range_len = min(extent_map_end(em), start + len) - cur;

		range_len = min(btrfs_extent_map_end(em), start + len) - cur;

		/*

		 * This one is a good target, check if it can be merged into

		 * last range of the target list.
@@ -1105,7 +1105,7 @@ static int defrag_collect_targets(struct btrfs_inode *inode, 
		list_add_tail(&new->list, target_list);



next:

		cur = extent_map_end(em);

		cur = btrfs_extent_map_end(em);

		free_extent_map(em);

	}

	if (ret < 0) {

fs/btrfs/direct-io.c

+2 −2
Original line number Diff line number Diff line
@@ -246,7 +246,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, 
		else

			type = BTRFS_ORDERED_NOCOW;

		len = min(len, em->len - (start - em->start));

		block_start = extent_map_block_start(em) + (start - em->start);

		block_start = btrfs_extent_map_block_start(em) + (start - em->start);



		if (can_nocow_extent(BTRFS_I(inode), start, &len, &file_extent,

				     false) == 1) {
@@ -558,7 +558,7 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start, 
		iomap->addr = IOMAP_NULL_ADDR;

		iomap->type = IOMAP_HOLE;

	} else {

		iomap->addr = extent_map_block_start(em) + (start - em->start);

		iomap->addr = btrfs_extent_map_block_start(em) + (start - em->start);

		iomap->type = IOMAP_MAPPED;

	}

	iomap->offset = start;

fs/btrfs/extent_io.c

+11 −10
Original line number Diff line number Diff line
@@ -892,8 +892,8 @@ static struct extent_map *get_extent_map(struct btrfs_inode *inode, 


	if (*em_cached) {

		em = *em_cached;

		if (extent_map_in_tree(em) && start >= em->start &&

		    start < extent_map_end(em)) {

		if (btrfs_extent_map_in_tree(em) && start >= em->start &&

		    start < btrfs_extent_map_end(em)) {

			refcount_inc(&em->refs);

			return em;

		}
@@ -969,7 +969,7 @@ static int btrfs_do_readpage(struct folio *folio, struct extent_map **em_cached, 
			return PTR_ERR(em);

		}

		extent_offset = cur - em->start;

		BUG_ON(extent_map_end(em) <= cur);

		BUG_ON(btrfs_extent_map_end(em) <= cur);

		BUG_ON(end < cur);



		compress_type = btrfs_extent_map_compression(em);
@@ -977,12 +977,12 @@ static int btrfs_do_readpage(struct folio *folio, struct extent_map **em_cached, 
		if (compress_type != BTRFS_COMPRESS_NONE)

			disk_bytenr = em->disk_bytenr;

		else

			disk_bytenr = extent_map_block_start(em) + extent_offset;

			disk_bytenr = btrfs_extent_map_block_start(em) + extent_offset;



		if (em->flags & EXTENT_FLAG_PREALLOC)

			block_start = EXTENT_MAP_HOLE;

		else

			block_start = extent_map_block_start(em);

			block_start = btrfs_extent_map_block_start(em);



		/*

		 * If we have a file range that points to a compressed extent
@@ -1539,13 +1539,13 @@ static int submit_one_sector(struct btrfs_inode *inode, 
		return PTR_ERR(em);



	extent_offset = filepos - em->start;

	em_end = extent_map_end(em);

	em_end = btrfs_extent_map_end(em);

	ASSERT(filepos <= em_end);

	ASSERT(IS_ALIGNED(em->start, sectorsize));

	ASSERT(IS_ALIGNED(em->len, sectorsize));



	block_start = extent_map_block_start(em);

	disk_bytenr = extent_map_block_start(em) + extent_offset;

	block_start = btrfs_extent_map_block_start(em);

	disk_bytenr = btrfs_extent_map_block_start(em) + extent_offset;



	ASSERT(!btrfs_extent_map_is_compressed(em));

	ASSERT(block_start != EXTENT_MAP_HOLE);
@@ -2679,7 +2679,8 @@ bool try_release_extent_mapping(struct folio *folio, gfp_t mask) 
			break;

		}

		if (btrfs_test_range_bit_exists(io_tree, em->start,

						extent_map_end(em) - 1, EXTENT_LOCKED))

						btrfs_extent_map_end(em) - 1,

						EXTENT_LOCKED))

			goto next;

		/*

		 * If it's not in the list of modified extents, used by a fast
@@ -2710,7 +2711,7 @@ bool try_release_extent_mapping(struct folio *folio, gfp_t mask) 
		/* Once for the inode's extent map tree. */

		free_extent_map(em);

next:

		start = extent_map_end(em);

		start = btrfs_extent_map_end(em);

		write_unlock(&extent_tree->lock);



		/* Once for us, for the lookup_extent_mapping() reference. */

fs/btrfs/extent_map.c

+24 −24
Original line number Diff line number Diff line
@@ -63,7 +63,7 @@ void free_extent_map(struct extent_map *em) 
	if (!em)

		return;

	if (refcount_dec_and_test(&em->refs)) {

		WARN_ON(extent_map_in_tree(em));

		WARN_ON(btrfs_extent_map_in_tree(em));

		WARN_ON(!list_empty(&em->list));

		kmem_cache_free(extent_map_cache, em);

	}
@@ -102,19 +102,19 @@ static int tree_insert(struct rb_root *root, struct extent_map *em) 


		if (em->start < entry->start)

			p = &(*p)->rb_left;

		else if (em->start >= extent_map_end(entry))

		else if (em->start >= btrfs_extent_map_end(entry))

			p = &(*p)->rb_right;

		else

			return -EEXIST;

	}



	orig_parent = parent;

	while (parent && em->start >= extent_map_end(entry)) {

	while (parent && em->start >= btrfs_extent_map_end(entry)) {

		parent = rb_next(parent);

		entry = rb_entry(parent, struct extent_map, rb_node);

	}

	if (parent)

		if (end > entry->start && em->start < extent_map_end(entry))

		if (end > entry->start && em->start < btrfs_extent_map_end(entry))

			return -EEXIST;



	parent = orig_parent;
@@ -124,7 +124,7 @@ static int tree_insert(struct rb_root *root, struct extent_map *em) 
		entry = rb_entry(parent, struct extent_map, rb_node);

	}

	if (parent)

		if (end > entry->start && em->start < extent_map_end(entry))

		if (end > entry->start && em->start < btrfs_extent_map_end(entry))

			return -EEXIST;



	rb_link_node(&em->rb_node, orig_parent, p);
@@ -154,14 +154,14 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 offset, 


		if (offset < entry->start)

			n = n->rb_left;

		else if (offset >= extent_map_end(entry))

		else if (offset >= btrfs_extent_map_end(entry))

			n = n->rb_right;

		else

			return n;

	}



	orig_prev = prev;

	while (prev && offset >= extent_map_end(prev_entry)) {

	while (prev && offset >= btrfs_extent_map_end(prev_entry)) {

		prev = rb_next(prev);

		prev_entry = rb_entry(prev, struct extent_map, rb_node);

	}
@@ -195,7 +195,7 @@ static inline u64 extent_map_block_len(const struct extent_map *em) 


static inline u64 extent_map_block_end(const struct extent_map *em)

{

	const u64 block_start = extent_map_block_start(em);

	const u64 block_start = btrfs_extent_map_block_start(em);

	const u64 block_end = block_start + extent_map_block_len(em);



	if (block_end < block_start)
@@ -230,7 +230,7 @@ static bool can_merge_extent_map(const struct extent_map *em) 
/* Check to see if two extent_map structs are adjacent and safe to merge. */

static bool mergeable_maps(const struct extent_map *prev, const struct extent_map *next)

{

	if (extent_map_end(prev) != next->start)

	if (btrfs_extent_map_end(prev) != next->start)

		return false;



	/*
@@ -242,7 +242,7 @@ static bool mergeable_maps(const struct extent_map *prev, const struct extent_ma 
		return false;



	if (next->disk_bytenr < EXTENT_MAP_LAST_BYTE - 1)

		return extent_map_block_start(next) == extent_map_block_end(prev);

		return btrfs_extent_map_block_start(next) == extent_map_block_end(prev);



	/* HOLES and INLINE extents. */

	return next->disk_bytenr == prev->disk_bytenr;
@@ -454,7 +454,7 @@ void clear_em_logging(struct btrfs_inode *inode, struct extent_map *em) 
	lockdep_assert_held_write(&inode->extent_tree.lock);



	em->flags &= ~EXTENT_FLAG_LOGGING;

	if (extent_map_in_tree(em))

	if (btrfs_extent_map_in_tree(em))

		try_merge_map(inode, em);

}
@@ -527,7 +527,7 @@ __lookup_extent_mapping(struct extent_map_tree *tree, 


	em = rb_entry(rb_node, struct extent_map, rb_node);



	if (strict && !(end > em->start && start < extent_map_end(em)))

	if (strict && !(end > em->start && start < btrfs_extent_map_end(em)))

		return NULL;



	refcount_inc(&em->refs);
@@ -605,7 +605,7 @@ static void replace_extent_mapping(struct btrfs_inode *inode, 
	validate_extent_map(fs_info, new);



	WARN_ON(cur->flags & EXTENT_FLAG_PINNED);

	ASSERT(extent_map_in_tree(cur));

	ASSERT(btrfs_extent_map_in_tree(cur));

	if (!(cur->flags & EXTENT_FLAG_LOGGING))

		list_del_init(&cur->list);

	rb_replace_node(&cur->rb_node, &new->rb_node, &tree->root);
@@ -651,7 +651,7 @@ static noinline int merge_extent_mapping(struct btrfs_inode *inode, 
	u64 end;

	u64 start_diff;



	if (map_start < em->start || map_start >= extent_map_end(em))

	if (map_start < em->start || map_start >= btrfs_extent_map_end(em))

		return -EINVAL;



	if (existing->start > map_start) {
@@ -662,10 +662,10 @@ static noinline int merge_extent_mapping(struct btrfs_inode *inode, 
		next = next_extent_map(prev);

	}



	start = prev ? extent_map_end(prev) : em->start;

	start = prev ? btrfs_extent_map_end(prev) : em->start;

	start = max_t(u64, start, em->start);

	end = next ? next->start : extent_map_end(em);

	end = min_t(u64, end, extent_map_end(em));

	end = next ? next->start : btrfs_extent_map_end(em);

	end = min_t(u64, end, btrfs_extent_map_end(em));

	start_diff = start - em->start;

	em->start = start;

	em->len = end - start;
@@ -725,7 +725,7 @@ int btrfs_add_extent_mapping(struct btrfs_inode *inode, 
		 * extent causing the -EEXIST.

		 */

		if (start >= existing->start &&

		    start < extent_map_end(existing)) {

		    start < btrfs_extent_map_end(existing)) {

			free_extent_map(em);

			*em_in = existing;

			ret = 0;
@@ -743,7 +743,7 @@ int btrfs_add_extent_mapping(struct btrfs_inode *inode, 
				*em_in = NULL;

				btrfs_warn(fs_info,

"extent map merge error existing [%llu, %llu) with em [%llu, %llu) start %llu",

					   existing->start, extent_map_end(existing),

					   existing->start, btrfs_extent_map_end(existing),

					   orig_start, orig_start + orig_len, start);

			}

			free_extent_map(existing);
@@ -834,7 +834,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, 


	while (em) {

		/* extent_map_end() returns exclusive value (last byte + 1). */

		const u64 em_end = extent_map_end(em);

		const u64 em_end = btrfs_extent_map_end(em);

		struct extent_map *next_em = NULL;

		u64 gen;

		unsigned long flags;
@@ -925,7 +925,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, 
				split->ram_bytes = split->len;

			}



			if (extent_map_in_tree(em)) {

			if (btrfs_extent_map_in_tree(em)) {

				replace_extent_mapping(inode, em, split, modified);

			} else {

				int ret;
@@ -940,7 +940,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, 
			split = NULL;

		}

remove_em:

		if (extent_map_in_tree(em)) {

		if (btrfs_extent_map_in_tree(em)) {

			/*

			 * If the extent map is still in the tree it means that

			 * either of the following is true:
@@ -1007,7 +1007,7 @@ int btrfs_replace_extent_map_range(struct btrfs_inode *inode, 
	struct extent_map_tree *tree = &inode->extent_tree;

	int ret;



	ASSERT(!extent_map_in_tree(new_em));

	ASSERT(!btrfs_extent_map_in_tree(new_em));



	/*

	 * The caller has locked an appropriate file range in the inode's io
@@ -1093,7 +1093,7 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, 
	/* Insert the middle extent_map. */

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

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

	split_mid->disk_bytenr = extent_map_block_start(em) + pre;

	split_mid->disk_bytenr = btrfs_extent_map_block_start(em) + pre;

	split_mid->disk_num_bytes = split_mid->len;

	split_mid->offset = 0;

	split_mid->ram_bytes = split_mid->len;