Commit 1c11b63e authored by Jeff Mahoney's avatar Jeff Mahoney Committed by David Sterba
Browse files

btrfs: replace pending/pinned chunks lists with io tree 



The pending chunks list contains chunks that are allocated in the
current transaction but haven't been created yet. The pinned chunks
list contains chunks that are being released in the current transaction.
Both describe chunks that are not reflected on disk as in use but are
unavailable just the same.

The pending chunks list is anchored by the transaction handle, which
means that we need to hold a reference to a transaction when working
with the list.

The way we use them is by iterating over both lists to perform
comparisons on the stripes they describe for each device. This is
backwards and requires that we keep a transaction handle open while
we're trimming.

This patchset adds an extent_io_tree to btrfs_device that maintains
the allocation state of the device.  Extents are set dirty when
chunks are first allocated -- when the extent maps are added to the
mapping tree. They're cleared when last removed -- when the extent
maps are removed from the mapping tree. This matches the lifespan
of the pending and pinned chunks list and allows us to do trims
on unallocated space safely without pinning the transaction for what
may be a lengthy operation. We can also use this io tree to mark
which chunks have already been trimmed so we don't repeat the operation.

Signed-off-by: default avatarJeff Mahoney <jeffm@suse.com>
Signed-off-by: default avatarNikolay Borisov <nborisov@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 68c94e55

fs/btrfs/ctree.h

+0 −6
Original line number Diff line number Diff line
@@ -1149,12 +1149,6 @@ struct btrfs_fs_info { 
	struct mutex unused_bg_unpin_mutex;

	struct mutex delete_unused_bgs_mutex;



	/*

	 * Chunks that can't be freed yet (under a trim/discard operation)

	 * and will be latter freed. Protected by fs_info->chunk_mutex.

	 */

	struct list_head pinned_chunks;



	/* Cached block sizes */

	u32 nodesize;

	u32 sectorsize;

fs/btrfs/disk-io.c

+0 −11
Original line number Diff line number Diff line
@@ -2774,8 +2774,6 @@ int open_ctree(struct super_block *sb, 
	init_waitqueue_head(&fs_info->async_submit_wait);

	init_waitqueue_head(&fs_info->delayed_iputs_wait);



	INIT_LIST_HEAD(&fs_info->pinned_chunks);



	/* Usable values until the real ones are cached from the superblock */

	fs_info->nodesize = 4096;

	fs_info->sectorsize = 4096;
@@ -4050,15 +4048,6 @@ void close_ctree(struct btrfs_fs_info *fs_info) 


	btrfs_free_stripe_hash_table(fs_info);

	btrfs_free_ref_cache(fs_info);



	while (!list_empty(&fs_info->pinned_chunks)) {

		struct extent_map *em;



		em = list_first_entry(&fs_info->pinned_chunks,

				      struct extent_map, list);

		list_del_init(&em->list);

		free_extent_map(em);

	}

}



int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,

fs/btrfs/extent-tree.c

+0 −28
Original line number Diff line number Diff line
@@ -10946,10 +10946,6 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	memcpy(&key, &block_group->key, sizeof(key));



	mutex_lock(&fs_info->chunk_mutex);

	if (!list_empty(&em->list)) {

		/* We're in the transaction->pending_chunks list. */

		free_extent_map(em);

	}

	spin_lock(&block_group->lock);

	block_group->removed = 1;

	/*
@@ -10976,25 +10972,6 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	 * the transaction commit has completed.

	 */

	remove_em = (atomic_read(&block_group->trimming) == 0);

	/*

	 * Make sure a trimmer task always sees the em in the pinned_chunks list

	 * if it sees block_group->removed == 1 (needs to lock block_group->lock

	 * before checking block_group->removed).

	 */

	if (!remove_em) {

		/*

		 * Our em might be in trans->transaction->pending_chunks which

		 * is protected by fs_info->chunk_mutex ([lock|unlock]_chunks),

		 * and so is the fs_info->pinned_chunks list.

		 *

		 * So at this point we must be holding the chunk_mutex to avoid

		 * any races with chunk allocation (more specifically at

		 * volumes.c:contains_pending_extent()), to ensure it always

		 * sees the em, either in the pending_chunks list or in the

		 * pinned_chunks list.

		 */

		list_move_tail(&em->list, &fs_info->pinned_chunks);

	}

	spin_unlock(&block_group->lock);



	if (remove_em) {
@@ -11002,11 +10979,6 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 


		em_tree = &fs_info->mapping_tree.map_tree;

		write_lock(&em_tree->lock);

		/*

		 * The em might be in the pending_chunks list, so make sure the

		 * chunk mutex is locked, since remove_extent_mapping() will

		 * delete us from that list.

		 */

		remove_extent_mapping(em_tree, em);

		write_unlock(&em_tree->lock);

		/* once for the tree */

fs/btrfs/extent_map.c

+36 −0
Original line number Diff line number Diff line
@@ -4,6 +4,7 @@ 
#include <linux/slab.h>

#include <linux/spinlock.h>

#include "ctree.h"

#include "volumes.h"

#include "extent_map.h"

#include "compression.h"
@@ -337,6 +338,37 @@ static inline void setup_extent_mapping(struct extent_map_tree *tree, 
		try_merge_map(tree, em);

}



static void extent_map_device_set_bits(struct extent_map *em, unsigned bits)

{

	struct map_lookup *map = em->map_lookup;

	u64 stripe_size = em->orig_block_len;

	int i;



	for (i = 0; i < map->num_stripes; i++) {

		struct btrfs_bio_stripe *stripe = &map->stripes[i];

		struct btrfs_device *device = stripe->dev;



		set_extent_bits_nowait(&device->alloc_state, stripe->physical,

				 stripe->physical + stripe_size - 1, bits);

	}

}



static void extent_map_device_clear_bits(struct extent_map *em, unsigned bits)

{

	struct map_lookup *map = em->map_lookup;

	u64 stripe_size = em->orig_block_len;

	int i;



	for (i = 0; i < map->num_stripes; i++) {

		struct btrfs_bio_stripe *stripe = &map->stripes[i];

		struct btrfs_device *device = stripe->dev;



		__clear_extent_bit(&device->alloc_state, stripe->physical,

				   stripe->physical + stripe_size - 1, bits,

				   0, 0, NULL, GFP_NOWAIT, NULL);

	}

}



/**

 * add_extent_mapping - add new extent map to the extent tree

 * @tree:	tree to insert new map in
@@ -357,6 +389,8 @@ int add_extent_mapping(struct extent_map_tree *tree, 
		goto out;



	setup_extent_mapping(tree, em, modified);

	if (test_bit(EXTENT_FLAG_FS_MAPPING, &em->flags))

		extent_map_device_set_bits(em, CHUNK_ALLOCATED);

out:

	return ret;

}
@@ -438,6 +472,8 @@ void remove_extent_mapping(struct extent_map_tree *tree, struct extent_map *em) 
	rb_erase_cached(&em->rb_node, &tree->map);

	if (!test_bit(EXTENT_FLAG_LOGGING, &em->flags))

		list_del_init(&em->list);

	if (test_bit(EXTENT_FLAG_FS_MAPPING, &em->flags))

		extent_map_device_clear_bits(em, CHUNK_ALLOCATED);

	RB_CLEAR_NODE(&em->rb_node);

}

fs/btrfs/free-space-cache.c

+0 −4
Original line number Diff line number Diff line
@@ -3366,10 +3366,6 @@ void btrfs_put_block_group_trimming(struct btrfs_block_group_cache *block_group) 
		em = lookup_extent_mapping(em_tree, block_group->key.objectid,

					   1);

		BUG_ON(!em); /* logic error, can't happen */

		/*

		 * remove_extent_mapping() will delete us from the pinned_chunks

		 * list, which is protected by the chunk mutex.

		 */

		remove_extent_mapping(em_tree, em);

		write_unlock(&em_tree->lock);

		mutex_unlock(&fs_info->chunk_mutex);

CRA Git | Maintained and supported by SUSTech CRA and CCSE