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

Commit 6324fbf3 authored by Chris Mason's avatar Chris Mason
Browse files

Btrfs: Dynamic chunk and block group allocation 



Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parent 0b86a832

fs/btrfs/ctree.h

+11 −1
Original line number Diff line number Diff line
@@ -431,9 +431,19 @@ struct btrfs_block_group_item { 
	__le64 flags;

} __attribute__ ((__packed__));



struct btrfs_space_info {

	u64 flags;

	u64 total_bytes;

	u64 bytes_used;

	u64 bytes_pinned;

	int full;

	struct list_head list;

};



struct btrfs_block_group_cache {

	struct btrfs_key key;

	struct btrfs_block_group_item item;

	struct btrfs_space_info *space_info;

	u64 pinned;

	u64 flags;

	int cached;
@@ -490,7 +500,7 @@ struct btrfs_fs_info { 
	struct list_head dirty_cowonly_roots;



	struct list_head devices;

	struct list_head *last_device;

	struct list_head space_info;

	spinlock_t delalloc_lock;

	spinlock_t new_trans_lock;

	u64 delalloc_bytes;

fs/btrfs/disk-io.c

+1 −1
Original line number Diff line number Diff line
@@ -700,8 +700,8 @@ struct btrfs_root *open_ctree(struct super_block *sb) 
	fs_info->dev_root = dev_root;

	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);

	INIT_LIST_HEAD(&fs_info->devices);

	INIT_LIST_HEAD(&fs_info->space_info);

	btrfs_mapping_init(&fs_info->mapping_tree);

	fs_info->last_device = &fs_info->devices;

	fs_info->sb = sb;

	fs_info->throttles = 0;

	fs_info->mount_opt = 0;

fs/btrfs/extent-tree.c

+190 −18
Original line number Diff line number Diff line
@@ -36,6 +36,10 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, struct 
				 btrfs_root *extent_root);

static int del_pending_extents(struct btrfs_trans_handle *trans, struct

			       btrfs_root *extent_root);

int btrfs_make_block_group(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, u64 bytes_used,

			   u64 type, u64 chunk_tree, u64 chunk_objectid,

			   u64 size);





static int cache_block_group(struct btrfs_root *root,
@@ -168,16 +172,7 @@ struct btrfs_block_group_cache *btrfs_lookup_block_group(struct 


static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)

{

	if ((bits & BLOCK_GROUP_DATA) &&

	    (cache->flags & BTRFS_BLOCK_GROUP_DATA))

		return 1;

	if ((bits & BLOCK_GROUP_METADATA) &&

	     (cache->flags & BTRFS_BLOCK_GROUP_METADATA))

		return 1;

	if ((bits & BLOCK_GROUP_SYSTEM) &&

	     (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM))

		return 1;

	return 0;

	return (cache->flags & bits);

}



static int noinline find_search_start(struct btrfs_root *root,
@@ -276,6 +271,18 @@ static u64 div_factor(u64 num, int factor) 
	return num;

}



static int block_group_state_bits(u64 flags)

{

	int bits = 0;

	if (flags & BTRFS_BLOCK_GROUP_DATA)

		bits |= BLOCK_GROUP_DATA;

	if (flags & BTRFS_BLOCK_GROUP_METADATA)

		bits |= BLOCK_GROUP_METADATA;

	if (flags & BTRFS_BLOCK_GROUP_SYSTEM)

		bits |= BLOCK_GROUP_SYSTEM;

	return bits;

}



struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root,

						 struct btrfs_block_group_cache

						 *hint, u64 search_start,
@@ -304,7 +311,7 @@ struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root, 
	if (!owner)

		factor = 8;



	bit = data;

	bit = block_group_state_bits(data);



	if (search_start && search_start < total_fs_bytes) {

		struct btrfs_block_group_cache *shint;
@@ -358,10 +365,15 @@ struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root, 
			free_check = cache->key.offset;

		else

			free_check = div_factor(cache->key.offset, factor);



		if (used + cache->pinned < free_check) {

			found_group = cache;

			goto found;

		}

		if (full_search) {

			printk("failed on cache %Lu used %Lu total %Lu\n",

			       cache->key.objectid, used, cache->key.offset);

		}

		cond_resched();

	}

	if (!full_search) {
@@ -983,6 +995,58 @@ int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 
	return werr;

}



static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,

						  u64 flags)

{

	struct list_head *head = &info->space_info;

	struct list_head *cur;

	struct btrfs_space_info *found;

	list_for_each(cur, head) {

		found = list_entry(cur, struct btrfs_space_info, list);

		if (found->flags == flags)

			return found;

	}

	return NULL;



}



static int do_chunk_alloc(struct btrfs_trans_handle *trans,

			  struct btrfs_root *extent_root, u64 alloc_bytes,

			  u64 flags)

{

	struct btrfs_space_info *space_info;

	u64 thresh;

	u64 start;

	u64 num_bytes;

	int ret;



	space_info = __find_space_info(extent_root->fs_info, flags);

	BUG_ON(!space_info);



	if (space_info->full)

		return 0;



	thresh = div_factor(space_info->total_bytes, 7);

	if ((space_info->bytes_used + space_info->bytes_pinned + alloc_bytes) <

	    thresh)

		return 0;



	ret = btrfs_alloc_chunk(trans, extent_root, &start, &num_bytes, flags);

	if (ret == -ENOSPC) {

printk("space info full %Lu\n", flags);

		space_info->full = 1;

		return 0;

	}



	BUG_ON(ret);



	ret = btrfs_make_block_group(trans, extent_root, 0, flags,

		     extent_root->fs_info->chunk_root->root_key.objectid,

		     start, num_bytes);

	BUG_ON(ret);

	return 0;

}



static int update_block_group(struct btrfs_trans_handle *trans,

			      struct btrfs_root *root,

			      u64 bytenr, u64 num_bytes, int alloc,
@@ -1012,8 +1076,10 @@ static int update_block_group(struct btrfs_trans_handle *trans, 
		num_bytes = min(total, cache->key.offset - byte_in_group);

		if (alloc) {

			old_val += num_bytes;

			cache->space_info->bytes_used += num_bytes;

		} else {

			old_val -= num_bytes;

			cache->space_info->bytes_used -= num_bytes;

			if (mark_free) {

				set_extent_dirty(&info->free_space_cache,

						 bytenr, bytenr + num_bytes - 1,
@@ -1026,6 +1092,7 @@ static int update_block_group(struct btrfs_trans_handle *trans, 
	}

	return 0;

}



static int update_pinned_extents(struct btrfs_root *root,

				u64 bytenr, u64 num, int pin)

{
@@ -1047,9 +1114,11 @@ static int update_pinned_extents(struct btrfs_root *root, 
			  (bytenr - cache->key.objectid));

		if (pin) {

			cache->pinned += len;

			cache->space_info->bytes_pinned += len;

			fs_info->total_pinned += len;

		} else {

			cache->pinned -= len;

			cache->space_info->bytes_pinned -= len;

			fs_info->total_pinned -= len;

		}

		bytenr += len;
@@ -1472,7 +1541,7 @@ static int noinline find_free_extent(struct btrfs_trans_handle *trans, 
		goto new_group;

	}



	if (!(data & BLOCK_GROUP_DATA)) {

	if (!(data & BTRFS_BLOCK_GROUP_DATA)) {

		block_group = btrfs_lookup_block_group(info, ins->objectid);

		if (block_group)

			trans->block_group = block_group;
@@ -1532,12 +1601,25 @@ int btrfs_alloc_extent(struct btrfs_trans_handle *trans, 
	struct btrfs_path *path;

	struct btrfs_key keys[2];



	if (data)

		data = BLOCK_GROUP_DATA;

	else if (root == root->fs_info->chunk_root)

		data = BLOCK_GROUP_SYSTEM;

	else

		data = BLOCK_GROUP_METADATA;

	if (data) {

		data = BTRFS_BLOCK_GROUP_DATA;

	} else if (root == root->fs_info->chunk_root) {

		data = BTRFS_BLOCK_GROUP_SYSTEM;

	} else {

		data = BTRFS_BLOCK_GROUP_METADATA;

	}



	if (root->ref_cows) {

		if (data != BTRFS_BLOCK_GROUP_METADATA) {

			ret = do_chunk_alloc(trans, root->fs_info->extent_root,

					     num_bytes,

					     BTRFS_BLOCK_GROUP_METADATA);

			BUG_ON(ret);

		}

		ret = do_chunk_alloc(trans, root->fs_info->extent_root,

				     num_bytes, data);

		BUG_ON(ret);

	}



	new_hint = max(hint_byte, root->fs_info->alloc_start);

	if (new_hint < btrfs_super_total_bytes(&info->super_copy))
@@ -2490,6 +2572,34 @@ int find_first_block_group(struct btrfs_root *root, struct btrfs_path *path, 
	return ret;

}



static int update_space_info(struct btrfs_fs_info *info, u64 flags,

			     u64 total_bytes, u64 bytes_used,

			     struct btrfs_space_info **space_info)

{

	struct btrfs_space_info *found;



	found = __find_space_info(info, flags);

	if (found) {

		found->total_bytes += total_bytes;

		found->bytes_used += bytes_used;

		WARN_ON(found->total_bytes < found->bytes_used);

		*space_info = found;

		return 0;

	}

	found = kmalloc(sizeof(*found), GFP_NOFS);

	if (!found)

		return -ENOMEM;



	list_add(&found->list, &info->space_info);

	found->flags = flags;

	found->total_bytes = total_bytes;

	found->bytes_used = bytes_used;

	found->bytes_pinned = 0;

	found->full = 0;

	*space_info = found;

	return 0;

}



int btrfs_read_block_groups(struct btrfs_root *root)

{

	struct btrfs_path *path;
@@ -2497,6 +2607,7 @@ int btrfs_read_block_groups(struct btrfs_root *root) 
	int bit;

	struct btrfs_block_group_cache *cache;

	struct btrfs_fs_info *info = root->fs_info;

	struct btrfs_space_info *space_info;

	struct extent_io_tree *block_group_cache;

	struct btrfs_key key;

	struct btrfs_key found_key;
@@ -2547,6 +2658,12 @@ int btrfs_read_block_groups(struct btrfs_root *root) 
			bit = BLOCK_GROUP_METADATA;

		}



		ret = update_space_info(info, cache->flags, found_key.offset,

					btrfs_block_group_used(&cache->item),

					&space_info);

		BUG_ON(ret);

		cache->space_info = space_info;



		/* use EXTENT_LOCKED to prevent merging */

		set_extent_bits(block_group_cache, found_key.objectid,

				found_key.objectid + found_key.offset - 1,
@@ -2563,3 +2680,58 @@ int btrfs_read_block_groups(struct btrfs_root *root) 
	btrfs_free_path(path);

	return ret;

}



int btrfs_make_block_group(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, u64 bytes_used,

			   u64 type, u64 chunk_tree, u64 chunk_objectid,

			   u64 size)

{

	int ret;

	int bit = 0;

	struct btrfs_root *extent_root;

	struct btrfs_block_group_cache *cache;

	struct extent_io_tree *block_group_cache;



	extent_root = root->fs_info->extent_root;

	block_group_cache = &root->fs_info->block_group_cache;



	cache = kmalloc(sizeof(*cache), GFP_NOFS);

	BUG_ON(!cache);

	cache->key.objectid = chunk_objectid;

	cache->key.offset = size;

	cache->cached = 0;

	cache->pinned = 0;

	btrfs_set_key_type(&cache->key, BTRFS_BLOCK_GROUP_ITEM_KEY);

	memset(&cache->item, 0, sizeof(cache->item));

	btrfs_set_block_group_used(&cache->item, bytes_used);

	btrfs_set_block_group_chunk_tree(&cache->item, chunk_tree);

	btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);

	cache->flags = type;

	btrfs_set_block_group_flags(&cache->item, type);



	ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,

				&cache->space_info);

	BUG_ON(ret);



	if (type & BTRFS_BLOCK_GROUP_DATA) {

		bit = BLOCK_GROUP_DATA;

	} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {

		bit = BLOCK_GROUP_SYSTEM;

	} else if (type & BTRFS_BLOCK_GROUP_METADATA) {

		bit = BLOCK_GROUP_METADATA;

	}

	set_extent_bits(block_group_cache, chunk_objectid,

			chunk_objectid + size - 1,

			bit | EXTENT_LOCKED, GFP_NOFS);

	set_state_private(block_group_cache, chunk_objectid,

			  (unsigned long)cache);



	ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,

				sizeof(cache->item));

	BUG_ON(ret);



	finish_current_insert(trans, extent_root);

	ret = del_pending_extents(trans, extent_root);

	BUG_ON(ret);

	return 0;

}

fs/btrfs/inode.c

+7 −2
Original line number Diff line number Diff line
@@ -1527,6 +1527,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans, 
{

	struct inode *inode;

	struct btrfs_inode_item *inode_item;

	struct btrfs_block_group_cache *new_inode_group;

	struct btrfs_key *location;

	struct btrfs_path *path;

	struct btrfs_inode_ref *ref;
@@ -1553,9 +1554,13 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans, 
		owner = 0;

	else

		owner = 1;

	group = btrfs_find_block_group(root, group, 0,

	new_inode_group = btrfs_find_block_group(root, group, 0,

				       BTRFS_BLOCK_GROUP_METADATA, owner);

	BTRFS_I(inode)->block_group = group;

	if (!new_inode_group) {

		printk("find_block group failed\n");

		new_inode_group = group;

	}

	BTRFS_I(inode)->block_group = new_inode_group;

	BTRFS_I(inode)->flags = 0;



	key[0].objectid = objectid;

fs/btrfs/volumes.c

+53 −34
Original line number Diff line number Diff line
@@ -131,7 +131,7 @@ static int find_free_dev_extent(struct btrfs_trans_handle *trans, 
	btrfs_release_path(root, path);

	BUG_ON(*start < search_start);



	if (*start + num_bytes >= search_end) {

	if (*start + num_bytes > search_end) {

		ret = -ENOSPC;

		goto error;

	}
@@ -159,8 +159,9 @@ int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans, 
		return -ENOMEM;



	ret = find_free_dev_extent(trans, device, path, num_bytes, start);

	if (ret)

	if (ret) {

		goto err;

	}



	key.objectid = device->devid;

	key.offset = *start;
@@ -214,22 +215,6 @@ static int find_next_chunk(struct btrfs_root *root, u64 *objectid) 
	return ret;

}



static struct btrfs_device *next_device(struct list_head *head,

					struct list_head *last)

{

	struct list_head *next = last->next;

	struct btrfs_device *dev;



	if (list_empty(head))

		return NULL;



	if (next == head)

		next = next->next;



	dev = list_entry(next, struct btrfs_device, dev_list);

	return dev;

}



static int find_next_devid(struct btrfs_root *root, struct btrfs_path *path,

			   u64 *objectid)

{
@@ -397,31 +382,63 @@ int btrfs_add_system_chunk(struct btrfs_trans_handle *trans, 


int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,

		      struct btrfs_root *extent_root, u64 *start,

		      u64 *num_bytes, u32 type)

		      u64 *num_bytes, u64 type)

{

	u64 dev_offset;

	struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;

	struct btrfs_stripe *stripes;

	struct btrfs_device *device = NULL;

	struct btrfs_chunk *chunk;

	struct list_head private_devs;

	struct list_head *dev_list = &extent_root->fs_info->devices;

	struct list_head *last_dev = extent_root->fs_info->last_device;

	struct list_head *cur;

	struct extent_map_tree *em_tree;

	struct map_lookup *map;

	struct extent_map *em;

	u64 physical;

	u64 calc_size = 1024 * 1024 * 1024;

	int num_stripes;

	u64 avail;

	u64 max_avail = 0;

	int num_stripes = 1;

	int looped = 0;

	int ret;

	int index = 0;

	int index;

	struct btrfs_key key;



	if (list_empty(dev_list))

		return -ENOSPC;

again:

	INIT_LIST_HEAD(&private_devs);

	cur = dev_list->next;

	index = 0;

	/* build a private list of devices we will allocate from */

	while(index < num_stripes) {

		device = list_entry(cur, struct btrfs_device, dev_list);

		avail = device->total_bytes - device->bytes_used;

		cur = cur->next;

		if (avail > max_avail)

			max_avail = avail;

		if (avail >= calc_size) {

			list_move_tail(&device->dev_list, &private_devs);

			index++;

		}

		if (cur == dev_list)

			break;

	}

	if (index < num_stripes) {

		list_splice(&private_devs, dev_list);

		if (!looped && max_avail > 0) {

			looped = 1;

			calc_size = max_avail;

			goto again;

		}

		return -ENOSPC;

	}



	ret = find_next_chunk(chunk_root, &key.objectid);

	if (ret)

		return ret;



	num_stripes = 1;

	chunk = kmalloc(btrfs_chunk_item_size(num_stripes), GFP_NOFS);

	if (!chunk)

		return -ENOMEM;
@@ -429,11 +446,12 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, 
	stripes = &chunk->stripe;



	*num_bytes = calc_size;

	index = 0;

	while(index < num_stripes) {

		device = next_device(dev_list, last_dev);

		BUG_ON(!device);

		last_dev = &device->dev_list;

		extent_root->fs_info->last_device = last_dev;

		BUG_ON(list_empty(&private_devs));

		cur = private_devs.next;

		device = list_entry(cur, struct btrfs_device, dev_list);

		list_move_tail(&device->dev_list, dev_list);



		ret = btrfs_alloc_dev_extent(trans, device,

					     key.objectid,
@@ -449,6 +467,7 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, 
		physical = dev_offset;

		index++;

	}

	BUG_ON(!list_empty(&private_devs));



	/* key.objectid was set above */

	key.offset = *num_bytes;
@@ -692,17 +711,17 @@ static int read_one_dev(struct btrfs_root *root, struct btrfs_key *key, 
	int ret;



	devid = btrfs_device_id(leaf, dev_item);

	if (btrfs_find_device(root, devid))

		return 0;



	device = btrfs_find_device(root, devid);

	if (!device) {

		device = kmalloc(sizeof(*device), GFP_NOFS);

		if (!device)

			return -ENOMEM;

		list_add(&device->dev_list, &root->fs_info->devices);

	}



	fill_device_from_item(leaf, dev_item, device);

	device->dev_root = root->fs_info->dev_root;

	device->bdev = root->fs_info->sb->s_bdev;

	list_add(&device->dev_list, &root->fs_info->devices);

	memcpy(&device->dev_key, key, sizeof(*key));

	ret = 0;

#if 0