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

Commit 57cdc8db authored by David Sterba's avatar David Sterba Committed by Chris Mason
Browse files

btrfs: cleanup ino cache members of btrfs_root 



The naming is confusing, generic yet used for a specific cache. Add a
prefix 'ino_' or rename appropriately.

Signed-off-by: default avatarDavid Sterba <dsterba@suse.cz>
Signed-off-by: default avatarChris Mason <clm@fb.com>
parent c6f83c74

fs/btrfs/ctree.h

+5 −5
Original line number Diff line number Diff line
@@ -1776,12 +1776,12 @@ struct btrfs_root { 


	/* free ino cache stuff */

	struct btrfs_free_space_ctl *free_ino_ctl;

	enum btrfs_caching_type cached;

	spinlock_t cache_lock;

	wait_queue_head_t cache_wait;

	enum btrfs_caching_type ino_cache_state;

	spinlock_t ino_cache_lock;

	wait_queue_head_t ino_cache_wait;

	struct btrfs_free_space_ctl *free_ino_pinned;

	u64 cache_progress;

	struct inode *cache_inode;

	u64 ino_cache_progress;

	struct inode *ino_cache_inode;



	struct mutex log_mutex;

	wait_queue_head_t log_writer_wait;

fs/btrfs/disk-io.c

+3 −3
Original line number Diff line number Diff line
@@ -1573,8 +1573,8 @@ int btrfs_init_fs_root(struct btrfs_root *root) 
	root->subv_writers = writers;



	btrfs_init_free_ino_ctl(root);

	spin_lock_init(&root->cache_lock);

	init_waitqueue_head(&root->cache_wait);

	spin_lock_init(&root->ino_cache_lock);

	init_waitqueue_head(&root->ino_cache_wait);



	ret = get_anon_bdev(&root->anon_dev);

	if (ret)
@@ -3532,7 +3532,7 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info, 


static void free_fs_root(struct btrfs_root *root)

{

	iput(root->cache_inode);

	iput(root->ino_cache_inode);

	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));

	btrfs_free_block_rsv(root, root->orphan_block_rsv);

	root->orphan_block_rsv = NULL;

fs/btrfs/free-space-cache.c

+7 −7
Original line number Diff line number Diff line
@@ -3033,10 +3033,10 @@ struct inode *lookup_free_ino_inode(struct btrfs_root *root, 
{

	struct inode *inode = NULL;



	spin_lock(&root->cache_lock);

	if (root->cache_inode)

		inode = igrab(root->cache_inode);

	spin_unlock(&root->cache_lock);

	spin_lock(&root->ino_cache_lock);

	if (root->ino_cache_inode)

		inode = igrab(root->ino_cache_inode);

	spin_unlock(&root->ino_cache_lock);

	if (inode)

		return inode;
@@ -3044,10 +3044,10 @@ struct inode *lookup_free_ino_inode(struct btrfs_root *root, 
	if (IS_ERR(inode))

		return inode;



	spin_lock(&root->cache_lock);

	spin_lock(&root->ino_cache_lock);

	if (!btrfs_fs_closing(root->fs_info))

		root->cache_inode = igrab(inode);

	spin_unlock(&root->cache_lock);

		root->ino_cache_inode = igrab(inode);

	spin_unlock(&root->ino_cache_lock);



	return inode;

}

fs/btrfs/inode-map.c

+34 −34
Original line number Diff line number Diff line
@@ -87,7 +87,7 @@ static int caching_kthread(void *data) 
				 */

				btrfs_item_key_to_cpu(leaf, &key, 0);

				btrfs_release_path(path);

				root->cache_progress = last;

				root->ino_cache_progress = last;

				up_read(&fs_info->commit_root_sem);

				schedule_timeout(1);

				goto again;
@@ -106,7 +106,7 @@ static int caching_kthread(void *data) 
		if (last != (u64)-1 && last + 1 != key.objectid) {

			__btrfs_add_free_space(ctl, last + 1,

					       key.objectid - last - 1);

			wake_up(&root->cache_wait);

			wake_up(&root->ino_cache_wait);

		}



		last = key.objectid;
@@ -119,14 +119,14 @@ static int caching_kthread(void *data) 
				       root->highest_objectid - last - 1);

	}



	spin_lock(&root->cache_lock);

	root->cached = BTRFS_CACHE_FINISHED;

	spin_unlock(&root->cache_lock);

	spin_lock(&root->ino_cache_lock);

	root->ino_cache_state = BTRFS_CACHE_FINISHED;

	spin_unlock(&root->ino_cache_lock);



	root->cache_progress = (u64)-1;

	root->ino_cache_progress = (u64)-1;

	btrfs_unpin_free_ino(root);

out:

	wake_up(&root->cache_wait);

	wake_up(&root->ino_cache_wait);

	up_read(&fs_info->commit_root_sem);



	btrfs_free_path(path);
@@ -144,20 +144,20 @@ static void start_caching(struct btrfs_root *root) 
	if (!btrfs_test_opt(root, INODE_MAP_CACHE))

		return;



	spin_lock(&root->cache_lock);

	if (root->cached != BTRFS_CACHE_NO) {

		spin_unlock(&root->cache_lock);

	spin_lock(&root->ino_cache_lock);

	if (root->ino_cache_state != BTRFS_CACHE_NO) {

		spin_unlock(&root->ino_cache_lock);

		return;

	}



	root->cached = BTRFS_CACHE_STARTED;

	spin_unlock(&root->cache_lock);

	root->ino_cache_state = BTRFS_CACHE_STARTED;

	spin_unlock(&root->ino_cache_lock);



	ret = load_free_ino_cache(root->fs_info, root);

	if (ret == 1) {

		spin_lock(&root->cache_lock);

		root->cached = BTRFS_CACHE_FINISHED;

		spin_unlock(&root->cache_lock);

		spin_lock(&root->ino_cache_lock);

		root->ino_cache_state = BTRFS_CACHE_FINISHED;

		spin_unlock(&root->ino_cache_lock);

		return;

	}
@@ -196,11 +196,11 @@ int btrfs_find_free_ino(struct btrfs_root *root, u64 *objectid) 


	start_caching(root);



	wait_event(root->cache_wait,

		   root->cached == BTRFS_CACHE_FINISHED ||

	wait_event(root->ino_cache_wait,

		   root->ino_cache_state == BTRFS_CACHE_FINISHED ||

		   root->free_ino_ctl->free_space > 0);



	if (root->cached == BTRFS_CACHE_FINISHED &&

	if (root->ino_cache_state == BTRFS_CACHE_FINISHED &&

	    root->free_ino_ctl->free_space == 0)

		return -ENOSPC;

	else
@@ -214,17 +214,17 @@ void btrfs_return_ino(struct btrfs_root *root, u64 objectid) 
	if (!btrfs_test_opt(root, INODE_MAP_CACHE))

		return;

again:

	if (root->cached == BTRFS_CACHE_FINISHED) {

	if (root->ino_cache_state == BTRFS_CACHE_FINISHED) {

		__btrfs_add_free_space(pinned, objectid, 1);

	} else {

		down_write(&root->fs_info->commit_root_sem);

		spin_lock(&root->cache_lock);

		if (root->cached == BTRFS_CACHE_FINISHED) {

			spin_unlock(&root->cache_lock);

		spin_lock(&root->ino_cache_lock);

		if (root->ino_cache_state == BTRFS_CACHE_FINISHED) {

			spin_unlock(&root->ino_cache_lock);

			up_write(&root->fs_info->commit_root_sem);

			goto again;

		}

		spin_unlock(&root->cache_lock);

		spin_unlock(&root->ino_cache_lock);



		start_caching(root);
@@ -235,10 +235,10 @@ void btrfs_return_ino(struct btrfs_root *root, u64 objectid) 
}



/*

 * When a transaction is committed, we'll move those inode numbers which

 * are smaller than root->cache_progress from pinned tree to free_ino tree,

 * and others will just be dropped, because the commit root we were

 * searching has changed.

 * When a transaction is committed, we'll move those inode numbers which are

 * smaller than root->ino_cache_progress from pinned tree to free_ino tree, and

 * others will just be dropped, because the commit root we were searching has

 * changed.

 *

 * Must be called with root->fs_info->commit_root_sem held

 */
@@ -261,10 +261,10 @@ void btrfs_unpin_free_ino(struct btrfs_root *root) 
		info = rb_entry(n, struct btrfs_free_space, offset_index);

		BUG_ON(info->bitmap); /* Logic error */



		if (info->offset > root->cache_progress)

		if (info->offset > root->ino_cache_progress)

			goto free;

		else if (info->offset + info->bytes > root->cache_progress)

			count = root->cache_progress - info->offset + 1;

		else if (info->offset + info->bytes > root->ino_cache_progress)

			count = root->ino_cache_progress - info->offset + 1;

		else

			count = info->bytes;
@@ -462,13 +462,13 @@ int btrfs_save_ino_cache(struct btrfs_root *root, 
		}

	}



	spin_lock(&root->cache_lock);

	if (root->cached != BTRFS_CACHE_FINISHED) {

	spin_lock(&root->ino_cache_lock);

	if (root->ino_cache_state != BTRFS_CACHE_FINISHED) {

		ret = -1;

		spin_unlock(&root->cache_lock);

		spin_unlock(&root->ino_cache_lock);

		goto out_put;

	}

	spin_unlock(&root->cache_lock);

	spin_unlock(&root->ino_cache_lock);



	spin_lock(&ctl->tree_lock);

	prealloc = sizeof(struct btrfs_free_space) * ctl->free_extents;

fs/btrfs/ioctl.c

+3 −3
Original line number Diff line number Diff line
@@ -2526,9 +2526,9 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file, 
		ASSERT(dest->send_in_progress == 0);



		/* the last ref */

		if (dest->cache_inode) {

			iput(dest->cache_inode);

			dest->cache_inode = NULL;

		if (dest->ino_cache_inode) {

			iput(dest->ino_cache_inode);

			dest->ino_cache_inode = NULL;

		}

	}

out_dput: