btrfs: remove inode number cache feature (5297199a) · Commits · EulixOS / Software / Kernel

fs/btrfs/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -3,7 +3,7 @@
		obj-$(CONFIG_BTRFS_FS) := btrfs.o

		btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
		file-item.o inode-item.o inode-map.o disk-io.o \
		file-item.o inode-item.o disk-io.o \
		transaction.o inode.o file.o tree-defrag.o \
		extent_map.o sysfs.o struct-funcs.o xattr.o ordered-data.o \
		extent_io.o volumes.o async-thread.o ioctl.o locking.o orphan.o \

fs/btrfs/ctree.h

+2 −13

Original line number	Diff line number	Diff line
		@@ -1077,15 +1077,6 @@ struct btrfs_root {
		spinlock_t accounting_lock;
		struct btrfs_block_rsv *block_rsv;

		/* free ino cache stuff */
		struct btrfs_free_space_ctl *free_ino_ctl;
		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 ino_cache_progress;
		struct inode *ino_cache_inode;

		struct mutex log_mutex;
		wait_queue_head_t log_writer_wait;
		wait_queue_head_t log_commit_wait[2];
		@@ -1359,7 +1350,7 @@ static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
		#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
		#define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
		#define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
		#define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
		/* bit 17 is free */
		#define BTRFS_MOUNT_USEBACKUPROOT (1 << 18)
		#define BTRFS_MOUNT_SKIP_BALANCE (1 << 19)
		#define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20)
		@@ -1406,9 +1397,7 @@ do { \
		* transaction commit)
		*/

		#define BTRFS_PENDING_SET_INODE_MAP_CACHE (0)
		#define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE (1)
		#define BTRFS_PENDING_COMMIT (2)
		#define BTRFS_PENDING_COMMIT (0)

		#define btrfs_test_pending(info, opt) \
		test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)

fs/btrfs/disk-io.c

+0 −23

Original line number	Diff line number	Diff line
		@@ -29,7 +29,6 @@
		#include "tree-log.h"
		#include "free-space-cache.h"
		#include "free-space-tree.h"
		#include "inode-map.h"
		#include "check-integrity.h"
		#include "rcu-string.h"
		#include "dev-replace.h"
		@@ -1336,14 +1335,6 @@ static int btrfs_init_fs_root(struct btrfs_root *root, dev_t anon_dev)
		int ret;
		unsigned int nofs_flag;

		root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
		root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
		GFP_NOFS);
		if (!root->free_ino_pinned \|\| !root->free_ino_ctl) {
		ret = -ENOMEM;
		goto fail;
		}

		/*
		* We might be called under a transaction (e.g. indirect backref
		* resolution) which could deadlock if it triggers memory reclaim
		@@ -1360,10 +1351,6 @@ static int btrfs_init_fs_root(struct btrfs_root *root, dev_t anon_dev)
		btrfs_check_and_init_root_item(&root->root_item);
		}

		btrfs_init_free_ino_ctl(root);
		spin_lock_init(&root->ino_cache_lock);
		init_waitqueue_head(&root->ino_cache_wait);

		/*
		* Don't assign anonymous block device to roots that are not exposed to
		* userspace, the id pool is limited to 1M
		@@ -2033,8 +2020,6 @@ void btrfs_put_root(struct btrfs_root *root)
		free_anon_bdev(root->anon_dev);
		btrfs_drew_lock_destroy(&root->snapshot_lock);
		free_root_extent_buffers(root);
		kfree(root->free_ino_ctl);
		kfree(root->free_ino_pinned);
		#ifdef CONFIG_BTRFS_DEBUG
		spin_lock(&root->fs_info->fs_roots_radix_lock);
		list_del_init(&root->leak_list);
		@@ -3988,14 +3973,6 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
		}
		}

		if (root->free_ino_pinned)
		__btrfs_remove_free_space_cache(root->free_ino_pinned);
		if (root->free_ino_ctl)
		__btrfs_remove_free_space_cache(root->free_ino_ctl);
		if (root->ino_cache_inode) {
		iput(root->ino_cache_inode);
		root->ino_cache_inode = NULL;
		}
		if (drop_ref)
		btrfs_put_root(root);
		}

fs/btrfs/free-space-cache.c

+0 −177

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@
		#include "transaction.h"
		#include "disk-io.h"
		#include "extent_io.h"
		#include "inode-map.h"
		#include "volumes.h"
		#include "space-info.h"
		#include "delalloc-space.h"
		@@ -37,10 +36,6 @@ static int link_free_space(struct btrfs_free_space_ctl *ctl,
		struct btrfs_free_space *info);
		static void unlink_free_space(struct btrfs_free_space_ctl *ctl,
		struct btrfs_free_space *info);
		static int btrfs_wait_cache_io_root(struct btrfs_root *root,
		struct btrfs_trans_handle *trans,
		struct btrfs_io_ctl *io_ctl,
		struct btrfs_path *path);
		static int search_bitmap(struct btrfs_free_space_ctl *ctl,
		struct btrfs_free_space bitmap_info, u64 offset,
		u64 *bytes, bool for_alloc);
		@@ -1222,14 +1217,6 @@ static int __btrfs_wait_cache_io(struct btrfs_root *root,

		}

		static int btrfs_wait_cache_io_root(struct btrfs_root *root,
		struct btrfs_trans_handle *trans,
		struct btrfs_io_ctl *io_ctl,
		struct btrfs_path *path)
		{
		return __btrfs_wait_cache_io(root, trans, NULL, io_ctl, path, 0);
		}

		int btrfs_wait_cache_io(struct btrfs_trans_handle *trans,
		struct btrfs_block_group *block_group,
		struct btrfs_path *path)
		@@ -3807,170 +3794,6 @@ int btrfs_trim_block_group_bitmaps(struct btrfs_block_group *block_group,
		return ret;
		}

		/*
		* Find the left-most item in the cache tree, and then return the
		* smallest inode number in the item.
		*
		* Note: the returned inode number may not be the smallest one in
		* the tree, if the left-most item is a bitmap.
		*/
		u64 btrfs_find_ino_for_alloc(struct btrfs_root *fs_root)
		{
		struct btrfs_free_space_ctl *ctl = fs_root->free_ino_ctl;
		struct btrfs_free_space *entry = NULL;
		u64 ino = 0;

		spin_lock(&ctl->tree_lock);

		if (RB_EMPTY_ROOT(&ctl->free_space_offset))
		goto out;

		entry = rb_entry(rb_first(&ctl->free_space_offset),
		struct btrfs_free_space, offset_index);

		if (!entry->bitmap) {
		ino = entry->offset;

		unlink_free_space(ctl, entry);
		entry->offset++;
		entry->bytes--;
		if (!entry->bytes)
		kmem_cache_free(btrfs_free_space_cachep, entry);
		else
		link_free_space(ctl, entry);
		} else {
		u64 offset = 0;
		u64 count = 1;
		int ret;

		ret = search_bitmap(ctl, entry, &offset, &count, true);
		/* Logic error; Should be empty if it can't find anything */
		ASSERT(!ret);

		ino = offset;
		bitmap_clear_bits(ctl, entry, offset, 1);
		if (entry->bytes == 0)
		free_bitmap(ctl, entry);
		}
		out:
		spin_unlock(&ctl->tree_lock);

		return ino;
		}

		struct inode lookup_free_ino_inode(struct btrfs_root root,
		struct btrfs_path *path)
		{
		struct inode *inode = NULL;

		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;

		inode = __lookup_free_space_inode(root, path, 0);
		if (IS_ERR(inode))
		return inode;

		spin_lock(&root->ino_cache_lock);
		if (!btrfs_fs_closing(root->fs_info))
		root->ino_cache_inode = igrab(inode);
		spin_unlock(&root->ino_cache_lock);

		return inode;
		}

		int create_free_ino_inode(struct btrfs_root *root,
		struct btrfs_trans_handle *trans,
		struct btrfs_path *path)
		{
		return __create_free_space_inode(root, trans, path,
		BTRFS_FREE_INO_OBJECTID, 0);
		}

		int load_free_ino_cache(struct btrfs_fs_info fs_info, struct btrfs_root root)
		{
		struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
		struct btrfs_path *path;
		struct inode *inode;
		int ret = 0;
		u64 root_gen = btrfs_root_generation(&root->root_item);

		if (!btrfs_test_opt(fs_info, INODE_MAP_CACHE))
		return 0;

		/*
		* If we're unmounting then just return, since this does a search on the
		* normal root and not the commit root and we could deadlock.
		*/
		if (btrfs_fs_closing(fs_info))
		return 0;

		path = btrfs_alloc_path();
		if (!path)
		return 0;

		inode = lookup_free_ino_inode(root, path);
		if (IS_ERR(inode))
		goto out;

		if (root_gen != BTRFS_I(inode)->generation)
		goto out_put;

		ret = __load_free_space_cache(root, inode, ctl, path, 0);

		if (ret < 0)
		btrfs_err(fs_info,
		"failed to load free ino cache for root %llu",
		root->root_key.objectid);
		out_put:
		iput(inode);
		out:
		btrfs_free_path(path);
		return ret;
		}

		int btrfs_write_out_ino_cache(struct btrfs_root *root,
		struct btrfs_trans_handle *trans,
		struct btrfs_path *path,
		struct inode *inode)
		{
		struct btrfs_fs_info *fs_info = root->fs_info;
		struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
		int ret;
		struct btrfs_io_ctl io_ctl;
		bool release_metadata = true;

		if (!btrfs_test_opt(fs_info, INODE_MAP_CACHE))
		return 0;

		memset(&io_ctl, 0, sizeof(io_ctl));
		ret = __btrfs_write_out_cache(root, inode, ctl, NULL, &io_ctl, trans);
		if (!ret) {
		/*
		* At this point writepages() didn't error out, so our metadata
		* reservation is released when the writeback finishes, at
		* inode.c:btrfs_finish_ordered_io(), regardless of it finishing
		* with or without an error.
		*/
		release_metadata = false;
		ret = btrfs_wait_cache_io_root(root, trans, &io_ctl, path);
		}

		if (ret) {
		if (release_metadata)
		btrfs_delalloc_release_metadata(BTRFS_I(inode),
		inode->i_size, true);
		btrfs_debug(fs_info,
		"failed to write free ino cache for root %llu error %d",
		root->root_key.objectid, ret);
		}

		return ret;
		}

		#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
		/*
		* Use this if you need to make a bitmap or extent entry specifically, it

fs/btrfs/free-space-cache.h

+0 −12

Original line number	Diff line number	Diff line
		@@ -97,17 +97,6 @@ int btrfs_wait_cache_io(struct btrfs_trans_handle *trans,
		int btrfs_write_out_cache(struct btrfs_trans_handle *trans,
		struct btrfs_block_group *block_group,
		struct btrfs_path *path);
		struct inode lookup_free_ino_inode(struct btrfs_root root,
		struct btrfs_path *path);
		int create_free_ino_inode(struct btrfs_root *root,
		struct btrfs_trans_handle *trans,
		struct btrfs_path *path);
		int load_free_ino_cache(struct btrfs_fs_info *fs_info,
		struct btrfs_root *root);
		int btrfs_write_out_ino_cache(struct btrfs_root *root,
		struct btrfs_trans_handle *trans,
		struct btrfs_path *path,
		struct inode *inode);

		void btrfs_init_free_space_ctl(struct btrfs_block_group *block_group,
		struct btrfs_free_space_ctl *ctl);
		@@ -127,7 +116,6 @@ bool btrfs_is_free_space_trimmed(struct btrfs_block_group *block_group);
		u64 btrfs_find_space_for_alloc(struct btrfs_block_group *block_group,
		u64 offset, u64 bytes, u64 empty_size,
		u64 *max_extent_size);
		u64 btrfs_find_ino_for_alloc(struct btrfs_root *fs_root);
		void btrfs_dump_free_space(struct btrfs_block_group *block_group,
		u64 bytes);
		int btrfs_find_space_cluster(struct btrfs_block_group *block_group,