Commit 0af3d00b authored by Josef Bacik's avatar Josef Bacik
Browse files

Btrfs: create special free space cache inode 



In order to save free space cache, we need an inode to hold the data, and we
need a special item to point at the right inode for the right block group.  So
first, create a special item that will point to the right inode, and the number
of extent entries we will have and the number of bitmaps we will have.  We
truncate and pre-allocate space everytime to make sure it's uptodate.

This feature will be turned on as soon as you mount with -o space_cache, however
it is safe to boot into old kernels, they will just generate the cache the old
fashion way.  When you boot back into a newer kernel we will notice that we
modified and not the cache and automatically discard the cache.

Signed-off-by: default avatarJosef Bacik <josef@redhat.com>
parent f6f94e2a

fs/btrfs/ctree.h

+68 −6
Original line number Diff line number Diff line
@@ -99,6 +99,9 @@ struct btrfs_ordered_sum; 
 */

#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL



/* For storing free space cache */

#define BTRFS_FREE_SPACE_OBJECTID -11ULL



/* dummy objectid represents multiple objectids */

#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
@@ -265,6 +268,22 @@ struct btrfs_chunk { 
	/* additional stripes go here */

} __attribute__ ((__packed__));



#define BTRFS_FREE_SPACE_EXTENT	1

#define BTRFS_FREE_SPACE_BITMAP	2



struct btrfs_free_space_entry {

	__le64 offset;

	__le64 bytes;

	u8 type;

} __attribute__ ((__packed__));



struct btrfs_free_space_header {

	struct btrfs_disk_key location;

	__le64 generation;

	__le64 num_entries;

	__le64 num_bitmaps;

} __attribute__ ((__packed__));



static inline unsigned long btrfs_chunk_item_size(int num_stripes)

{

	BUG_ON(num_stripes == 0);
@@ -365,8 +384,10 @@ struct btrfs_super_block { 


	char label[BTRFS_LABEL_SIZE];



	__le64 cache_generation;



	/* future expansion */

	__le64 reserved[32];

	__le64 reserved[31];

	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];

} __attribute__ ((__packed__));
@@ -375,7 +396,7 @@ struct btrfs_super_block { 
 * ones specified below then we will fail to mount

 */

#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF	(1ULL << 0)

#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL	(2ULL << 0)

#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL	(1ULL << 1)



#define BTRFS_FEATURE_COMPAT_SUPP		0ULL

#define BTRFS_FEATURE_COMPAT_RO_SUPP		0ULL
@@ -750,6 +771,14 @@ enum btrfs_caching_type { 
	BTRFS_CACHE_FINISHED	= 2,

};



enum btrfs_disk_cache_state {

	BTRFS_DC_WRITTEN	= 0,

	BTRFS_DC_ERROR		= 1,

	BTRFS_DC_CLEAR		= 2,

	BTRFS_DC_SETUP		= 3,

	BTRFS_DC_NEED_WRITE	= 4,

};



struct btrfs_caching_control {

	struct list_head list;

	struct mutex mutex;
@@ -763,6 +792,7 @@ struct btrfs_block_group_cache { 
	struct btrfs_key key;

	struct btrfs_block_group_item item;

	struct btrfs_fs_info *fs_info;

	struct inode *inode;

	spinlock_t lock;

	u64 pinned;

	u64 reserved;
@@ -773,8 +803,11 @@ struct btrfs_block_group_cache { 
	int extents_thresh;

	int free_extents;

	int total_bitmaps;

	int ro;

	int dirty;

	int ro:1;

	int dirty:1;

	int iref:1;



	int disk_cache_state;



	/* cache tracking stuff */

	int cached;
@@ -1192,6 +1225,7 @@ struct btrfs_root { 
#define BTRFS_MOUNT_NOSSD		(1 << 9)

#define BTRFS_MOUNT_DISCARD		(1 << 10)

#define BTRFS_MOUNT_FORCE_COMPRESS      (1 << 11)

#define BTRFS_MOUNT_SPACE_CACHE		(1 << 12)



#define btrfs_clear_opt(o, opt)		((o) &= ~BTRFS_MOUNT_##opt)

#define btrfs_set_opt(o, opt)		((o) |= BTRFS_MOUNT_##opt)
@@ -1665,6 +1699,27 @@ static inline void btrfs_set_dir_item_key(struct extent_buffer *eb, 
	write_eb_member(eb, item, struct btrfs_dir_item, location, key);

}



BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,

		   num_entries, 64);

BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,

		   num_bitmaps, 64);

BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,

		   generation, 64);



static inline void btrfs_free_space_key(struct extent_buffer *eb,

					struct btrfs_free_space_header *h,

					struct btrfs_disk_key *key)

{

	read_eb_member(eb, h, struct btrfs_free_space_header, location, key);

}



static inline void btrfs_set_free_space_key(struct extent_buffer *eb,

					    struct btrfs_free_space_header *h,

					    struct btrfs_disk_key *key)

{

	write_eb_member(eb, h, struct btrfs_free_space_header, location, key);

}



/* struct btrfs_disk_key */

BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,

			 objectid, 64);
@@ -1876,6 +1931,8 @@ BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block, 
			 incompat_flags, 64);

BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,

			 csum_type, 16);

BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,

			 cache_generation, 64);



static inline int btrfs_super_csum_size(struct btrfs_super_block *s)

{
@@ -2115,6 +2172,7 @@ int btrfs_set_block_group_ro(struct btrfs_root *root, 
			     struct btrfs_block_group_cache *cache);

int btrfs_set_block_group_rw(struct btrfs_root *root,

			     struct btrfs_block_group_cache *cache);

void btrfs_put_block_group_cache(struct btrfs_fs_info *info);

/* ctree.c */

int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,

		     int level, int *slot);
@@ -2426,6 +2484,10 @@ void btrfs_run_delayed_iputs(struct btrfs_root *root); 
int btrfs_prealloc_file_range(struct inode *inode, int mode,

			      u64 start, u64 num_bytes, u64 min_size,

			      loff_t actual_len, u64 *alloc_hint);

int btrfs_prealloc_file_range_trans(struct inode *inode,

				    struct btrfs_trans_handle *trans, int mode,

				    u64 start, u64 num_bytes, u64 min_size,

				    loff_t actual_len, u64 *alloc_hint);

extern const struct dentry_operations btrfs_dentry_operations;



/* ioctl.c */

fs/btrfs/disk-io.c

+2 −1
Original line number Diff line number Diff line
@@ -1685,7 +1685,6 @@ struct btrfs_root *open_ctree(struct super_block *sb, 
	__setup_root(4096, 4096, 4096, 4096, tree_root,

		     fs_info, BTRFS_ROOT_TREE_OBJECTID);





	bh = btrfs_read_dev_super(fs_devices->latest_bdev);

	if (!bh)

		goto fail_iput;
@@ -1993,6 +1992,7 @@ struct btrfs_root *open_ctree(struct super_block *sb, 
	if (!(sb->s_flags & MS_RDONLY)) {

		down_read(&fs_info->cleanup_work_sem);

		btrfs_orphan_cleanup(fs_info->fs_root);

		btrfs_orphan_cleanup(fs_info->tree_root);

		up_read(&fs_info->cleanup_work_sem);

	}
@@ -2421,6 +2421,7 @@ int close_ctree(struct btrfs_root *root) 
	fs_info->closing = 1;

	smp_mb();



	btrfs_put_block_group_cache(fs_info);

	if (!(fs_info->sb->s_flags & MS_RDONLY)) {

		ret =  btrfs_commit_super(root);

		if (ret)

fs/btrfs/extent-tree.c

+225 −6
Original line number Diff line number Diff line
@@ -2688,6 +2688,109 @@ next_block_group(struct btrfs_root *root, 
	return cache;

}



static int cache_save_setup(struct btrfs_block_group_cache *block_group,

			    struct btrfs_trans_handle *trans,

			    struct btrfs_path *path)

{

	struct btrfs_root *root = block_group->fs_info->tree_root;

	struct inode *inode = NULL;

	u64 alloc_hint = 0;

	int num_pages = 0;

	int retries = 0;

	int ret = 0;



	/*

	 * If this block group is smaller than 100 megs don't bother caching the

	 * block group.

	 */

	if (block_group->key.offset < (100 * 1024 * 1024)) {

		spin_lock(&block_group->lock);

		block_group->disk_cache_state = BTRFS_DC_WRITTEN;

		spin_unlock(&block_group->lock);

		return 0;

	}



again:

	inode = lookup_free_space_inode(root, block_group, path);

	if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) {

		ret = PTR_ERR(inode);

		btrfs_release_path(root, path);

		goto out;

	}



	if (IS_ERR(inode)) {

		BUG_ON(retries);

		retries++;



		if (block_group->ro)

			goto out_free;



		ret = create_free_space_inode(root, trans, block_group, path);

		if (ret)

			goto out_free;

		goto again;

	}



	/*

	 * We want to set the generation to 0, that way if anything goes wrong

	 * from here on out we know not to trust this cache when we load up next

	 * time.

	 */

	BTRFS_I(inode)->generation = 0;

	ret = btrfs_update_inode(trans, root, inode);

	WARN_ON(ret);



	if (i_size_read(inode) > 0) {

		ret = btrfs_truncate_free_space_cache(root, trans, path,

						      inode);

		if (ret)

			goto out_put;

	}



	spin_lock(&block_group->lock);

	if (block_group->cached != BTRFS_CACHE_FINISHED) {

		spin_unlock(&block_group->lock);

		goto out_put;

	}

	spin_unlock(&block_group->lock);



	num_pages = (int)div64_u64(block_group->key.offset, 1024 * 1024 * 1024);

	if (!num_pages)

		num_pages = 1;



	/*

	 * Just to make absolutely sure we have enough space, we're going to

	 * preallocate 12 pages worth of space for each block group.  In

	 * practice we ought to use at most 8, but we need extra space so we can

	 * add our header and have a terminator between the extents and the

	 * bitmaps.

	 */

	num_pages *= 16;

	num_pages *= PAGE_CACHE_SIZE;



	ret = btrfs_check_data_free_space(inode, num_pages);

	if (ret)

		goto out_put;



	ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, num_pages,

					      num_pages, num_pages,

					      &alloc_hint);

	btrfs_free_reserved_data_space(inode, num_pages);

out_put:

	iput(inode);

out_free:

	btrfs_release_path(root, path);

out:

	spin_lock(&block_group->lock);

	if (ret)

		block_group->disk_cache_state = BTRFS_DC_ERROR;

	else

		block_group->disk_cache_state = BTRFS_DC_SETUP;

	spin_unlock(&block_group->lock);



	return ret;

}



int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,

				   struct btrfs_root *root)

{
@@ -2700,6 +2803,25 @@ int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 
	if (!path)

		return -ENOMEM;



again:

	while (1) {

		cache = btrfs_lookup_first_block_group(root->fs_info, last);

		while (cache) {

			if (cache->disk_cache_state == BTRFS_DC_CLEAR)

				break;

			cache = next_block_group(root, cache);

		}

		if (!cache) {

			if (last == 0)

				break;

			last = 0;

			continue;

		}

		err = cache_save_setup(cache, trans, path);

		last = cache->key.objectid + cache->key.offset;

		btrfs_put_block_group(cache);

	}



	while (1) {

		if (last == 0) {

			err = btrfs_run_delayed_refs(trans, root,
@@ -2709,6 +2831,11 @@ int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 


		cache = btrfs_lookup_first_block_group(root->fs_info, last);

		while (cache) {

			if (cache->disk_cache_state == BTRFS_DC_CLEAR) {

				btrfs_put_block_group(cache);

				goto again;

			}



			if (cache->dirty)

				break;

			cache = next_block_group(root, cache);
@@ -2883,11 +3010,16 @@ int btrfs_check_data_free_space(struct inode *inode, u64 bytes) 
	struct btrfs_space_info *data_sinfo;

	struct btrfs_root *root = BTRFS_I(inode)->root;

	u64 used;

	int ret = 0, committed = 0;

	int ret = 0, committed = 0, alloc_chunk = 1;



	/* make sure bytes are sectorsize aligned */

	bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);



	if (root == root->fs_info->tree_root) {

		alloc_chunk = 0;

		committed = 1;

	}



	data_sinfo = BTRFS_I(inode)->space_info;

	if (!data_sinfo)

		goto alloc;
@@ -2906,7 +3038,7 @@ again: 
		 * if we don't have enough free bytes in this space then we need

		 * to alloc a new chunk.

		 */

		if (!data_sinfo->full) {

		if (!data_sinfo->full && alloc_chunk) {

			u64 alloc_target;



			data_sinfo->force_alloc = 1;
@@ -3777,12 +3909,12 @@ static int update_block_group(struct btrfs_trans_handle *trans, 
			      struct btrfs_root *root,

			      u64 bytenr, u64 num_bytes, int alloc)

{

	struct btrfs_block_group_cache *cache;

	struct btrfs_block_group_cache *cache = NULL;

	struct btrfs_fs_info *info = root->fs_info;

	int factor;

	u64 total = num_bytes;

	u64 old_val;

	u64 byte_in_group;

	int factor;



	/* block accounting for super block */

	spin_lock(&info->delalloc_lock);
@@ -3804,11 +3936,17 @@ static int update_block_group(struct btrfs_trans_handle *trans, 
			factor = 2;

		else

			factor = 1;



		byte_in_group = bytenr - cache->key.objectid;

		WARN_ON(byte_in_group > cache->key.offset);



		spin_lock(&cache->space_info->lock);

		spin_lock(&cache->lock);



		if (btrfs_super_cache_generation(&info->super_copy) != 0 &&

		    cache->disk_cache_state < BTRFS_DC_CLEAR)

			cache->disk_cache_state = BTRFS_DC_CLEAR;



		cache->dirty = 1;

		old_val = btrfs_block_group_used(&cache->item);

		num_bytes = min(total, cache->key.offset - byte_in_group);
@@ -7814,6 +7952,40 @@ out: 
	return ret;

}



void btrfs_put_block_group_cache(struct btrfs_fs_info *info)

{

	struct btrfs_block_group_cache *block_group;

	u64 last = 0;



	while (1) {

		struct inode *inode;



		block_group = btrfs_lookup_first_block_group(info, last);

		while (block_group) {

			spin_lock(&block_group->lock);

			if (block_group->iref)

				break;

			spin_unlock(&block_group->lock);

			block_group = next_block_group(info->tree_root,

						       block_group);

		}

		if (!block_group) {

			if (last == 0)

				break;

			last = 0;

			continue;

		}



		inode = block_group->inode;

		block_group->iref = 0;

		block_group->inode = NULL;

		spin_unlock(&block_group->lock);

		iput(inode);

		last = block_group->key.objectid + block_group->key.offset;

		btrfs_put_block_group(block_group);

	}

}



int btrfs_free_block_groups(struct btrfs_fs_info *info)

{

	struct btrfs_block_group_cache *block_group;
@@ -7897,6 +8069,8 @@ int btrfs_read_block_groups(struct btrfs_root *root) 
	struct btrfs_key key;

	struct btrfs_key found_key;

	struct extent_buffer *leaf;

	int need_clear = 0;

	u64 cache_gen;



	root = info->extent_root;

	key.objectid = 0;
@@ -7906,6 +8080,11 @@ int btrfs_read_block_groups(struct btrfs_root *root) 
	if (!path)

		return -ENOMEM;



	cache_gen = btrfs_super_cache_generation(&root->fs_info->super_copy);

	if (cache_gen != 0 &&

	    btrfs_super_generation(&root->fs_info->super_copy) != cache_gen)

		need_clear = 1;



	while (1) {

		ret = find_first_block_group(root, path, &key);

		if (ret > 0)
@@ -7928,6 +8107,9 @@ int btrfs_read_block_groups(struct btrfs_root *root) 
		INIT_LIST_HEAD(&cache->list);

		INIT_LIST_HEAD(&cache->cluster_list);



		if (need_clear)

			cache->disk_cache_state = BTRFS_DC_CLEAR;



		/*

		 * we only want to have 32k of ram per block group for keeping

		 * track of free space, and if we pass 1/2 of that we want to
@@ -8032,6 +8214,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, 
	cache->key.offset = size;

	cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;

	cache->sectorsize = root->sectorsize;

	cache->fs_info = root->fs_info;



	/*

	 * we only want to have 32k of ram per block group for keeping track
@@ -8088,7 +8271,9 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	struct btrfs_path *path;

	struct btrfs_block_group_cache *block_group;

	struct btrfs_free_cluster *cluster;

	struct btrfs_root *tree_root = root->fs_info->tree_root;

	struct btrfs_key key;

	struct inode *inode;

	int ret;



	root = root->fs_info->extent_root;
@@ -8097,8 +8282,6 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	BUG_ON(!block_group);

	BUG_ON(!block_group->ro);



	memcpy(&key, &block_group->key, sizeof(key));



	/* make sure this block group isn't part of an allocation cluster */

	cluster = &root->fs_info->data_alloc_cluster;

	spin_lock(&cluster->refill_lock);
@@ -8117,6 +8300,40 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	path = btrfs_alloc_path();

	BUG_ON(!path);



	inode = lookup_free_space_inode(root, block_group, path);

	if (!IS_ERR(inode)) {

		btrfs_orphan_add(trans, inode);

		clear_nlink(inode);

		/* One for the block groups ref */

		spin_lock(&block_group->lock);

		if (block_group->iref) {

			block_group->iref = 0;

			block_group->inode = NULL;

			spin_unlock(&block_group->lock);

			iput(inode);

		} else {

			spin_unlock(&block_group->lock);

		}

		/* One for our lookup ref */

		iput(inode);

	}



	key.objectid = BTRFS_FREE_SPACE_OBJECTID;

	key.offset = block_group->key.objectid;

	key.type = 0;



	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);

	if (ret < 0)

		goto out;

	if (ret > 0)

		btrfs_release_path(tree_root, path);

	if (ret == 0) {

		ret = btrfs_del_item(trans, tree_root, path);

		if (ret)

			goto out;

		btrfs_release_path(tree_root, path);

	}



	spin_lock(&root->fs_info->block_group_cache_lock);

	rb_erase(&block_group->cache_node,

		 &root->fs_info->block_group_cache_tree);
@@ -8140,6 +8357,8 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	block_group->space_info->bytes_readonly -= block_group->key.offset;

	spin_unlock(&block_group->space_info->lock);



	memcpy(&key, &block_group->key, sizeof(key));



	btrfs_clear_space_info_full(root->fs_info);



	btrfs_put_block_group(block_group);

fs/btrfs/free-space-cache.c

+155 −0
Original line number Diff line number Diff line
@@ -23,10 +23,165 @@ 
#include "ctree.h"

#include "free-space-cache.h"

#include "transaction.h"

#include "disk-io.h"



#define BITS_PER_BITMAP		(PAGE_CACHE_SIZE * 8)

#define MAX_CACHE_BYTES_PER_GIG	(32 * 1024)



struct inode *lookup_free_space_inode(struct btrfs_root *root,

				      struct btrfs_block_group_cache

				      *block_group, struct btrfs_path *path)

{

	struct btrfs_key key;

	struct btrfs_key location;

	struct btrfs_disk_key disk_key;

	struct btrfs_free_space_header *header;

	struct extent_buffer *leaf;

	struct inode *inode = NULL;

	int ret;



	spin_lock(&block_group->lock);

	if (block_group->inode)

		inode = igrab(block_group->inode);

	spin_unlock(&block_group->lock);

	if (inode)

		return inode;



	key.objectid = BTRFS_FREE_SPACE_OBJECTID;

	key.offset = block_group->key.objectid;

	key.type = 0;



	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);

	if (ret < 0)

		return ERR_PTR(ret);

	if (ret > 0) {

		btrfs_release_path(root, path);

		return ERR_PTR(-ENOENT);

	}



	leaf = path->nodes[0];

	header = btrfs_item_ptr(leaf, path->slots[0],

				struct btrfs_free_space_header);

	btrfs_free_space_key(leaf, header, &disk_key);

	btrfs_disk_key_to_cpu(&location, &disk_key);

	btrfs_release_path(root, path);



	inode = btrfs_iget(root->fs_info->sb, &location, root, NULL);

	if (!inode)

		return ERR_PTR(-ENOENT);

	if (IS_ERR(inode))

		return inode;

	if (is_bad_inode(inode)) {

		iput(inode);

		return ERR_PTR(-ENOENT);

	}



	spin_lock(&block_group->lock);

	if (!root->fs_info->closing) {

		block_group->inode = igrab(inode);

		block_group->iref = 1;

	}

	spin_unlock(&block_group->lock);



	return inode;

}



int create_free_space_inode(struct btrfs_root *root,

			    struct btrfs_trans_handle *trans,

			    struct btrfs_block_group_cache *block_group,

			    struct btrfs_path *path)

{

	struct btrfs_key key;

	struct btrfs_disk_key disk_key;

	struct btrfs_free_space_header *header;

	struct btrfs_inode_item *inode_item;

	struct extent_buffer *leaf;

	u64 objectid;

	int ret;



	ret = btrfs_find_free_objectid(trans, root, 0, &objectid);

	if (ret < 0)

		return ret;



	ret = btrfs_insert_empty_inode(trans, root, path, objectid);

	if (ret)

		return ret;



	leaf = path->nodes[0];

	inode_item = btrfs_item_ptr(leaf, path->slots[0],

				    struct btrfs_inode_item);

	btrfs_item_key(leaf, &disk_key, path->slots[0]);

	memset_extent_buffer(leaf, 0, (unsigned long)inode_item,

			     sizeof(*inode_item));

	btrfs_set_inode_generation(leaf, inode_item, trans->transid);

	btrfs_set_inode_size(leaf, inode_item, 0);

	btrfs_set_inode_nbytes(leaf, inode_item, 0);

	btrfs_set_inode_uid(leaf, inode_item, 0);

	btrfs_set_inode_gid(leaf, inode_item, 0);

	btrfs_set_inode_mode(leaf, inode_item, S_IFREG | 0600);

	btrfs_set_inode_flags(leaf, inode_item, BTRFS_INODE_NOCOMPRESS |

			      BTRFS_INODE_PREALLOC | BTRFS_INODE_NODATASUM);

	btrfs_set_inode_nlink(leaf, inode_item, 1);

	btrfs_set_inode_transid(leaf, inode_item, trans->transid);

	btrfs_set_inode_block_group(leaf, inode_item,

				    block_group->key.objectid);

	btrfs_mark_buffer_dirty(leaf);

	btrfs_release_path(root, path);



	key.objectid = BTRFS_FREE_SPACE_OBJECTID;

	key.offset = block_group->key.objectid;

	key.type = 0;



	ret = btrfs_insert_empty_item(trans, root, path, &key,

				      sizeof(struct btrfs_free_space_header));

	if (ret < 0) {

		btrfs_release_path(root, path);

		return ret;

	}

	leaf = path->nodes[0];

	header = btrfs_item_ptr(leaf, path->slots[0],

				struct btrfs_free_space_header);

	memset_extent_buffer(leaf, 0, (unsigned long)header, sizeof(*header));

	btrfs_set_free_space_key(leaf, header, &disk_key);

	btrfs_mark_buffer_dirty(leaf);

	btrfs_release_path(root, path);



	return 0;

}



int btrfs_truncate_free_space_cache(struct btrfs_root *root,

				    struct btrfs_trans_handle *trans,

				    struct btrfs_path *path,

				    struct inode *inode)

{

	loff_t oldsize;

	int ret = 0;



	trans->block_rsv = root->orphan_block_rsv;

	ret = btrfs_block_rsv_check(trans, root,

				    root->orphan_block_rsv,

				    0, 5);

	if (ret)

		return ret;



	oldsize = i_size_read(inode);

	btrfs_i_size_write(inode, 0);

	truncate_pagecache(inode, oldsize, 0);



	/*

	 * We don't need an orphan item because truncating the free space cache

	 * will never be split across transactions.

	 */

	ret = btrfs_truncate_inode_items(trans, root, inode,

					 0, BTRFS_EXTENT_DATA_KEY);

	if (ret) {

		WARN_ON(1);

		return ret;

	}



	return btrfs_update_inode(trans, root, inode);

}



static inline unsigned long offset_to_bit(u64 bitmap_start, u64 sectorsize,

					  u64 offset)

{

fs/btrfs/free-space-cache.h

+11 −0
Original line number Diff line number Diff line
@@ -27,6 +27,17 @@ struct btrfs_free_space { 
	struct list_head list;

};



struct inode *lookup_free_space_inode(struct btrfs_root *root,

				      struct btrfs_block_group_cache

				      *block_group, struct btrfs_path *path);

int create_free_space_inode(struct btrfs_root *root,

			    struct btrfs_trans_handle *trans,

			    struct btrfs_block_group_cache *block_group,

			    struct btrfs_path *path);

int btrfs_truncate_free_space_cache(struct btrfs_root *root,

				    struct btrfs_trans_handle *trans,

				    struct btrfs_path *path,

				    struct inode *inode);

int btrfs_add_free_space(struct btrfs_block_group_cache *block_group,

			 u64 bytenr, u64 size);

int btrfs_remove_free_space(struct btrfs_block_group_cache *block_group,

CRA Git | Maintained and supported by SUSTech CRA and CCSE