Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs (e3a0dd98) · Commits · 戴 / test

fs/btrfs/backref.c

+41 −31

Original line number	Diff line number	Diff line
		@@ -255,13 +255,11 @@ static int add_all_parents(struct btrfs_root root, struct btrfs_path path,
		* to a logical address
		*/
		static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
		int search_commit_root,
		u64 time_seq,
		struct btrfs_path *path, u64 time_seq,
		struct __prelim_ref *ref,
		struct ulist *parents,
		const u64 *extent_item_pos)
		{
		struct btrfs_path *path;
		struct btrfs_root *root;
		struct btrfs_key root_key;
		struct extent_buffer *eb;
		@@ -269,11 +267,6 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
		int root_level;
		int level = ref->level;

		path = btrfs_alloc_path();
		if (!path)
		return -ENOMEM;
		path->search_commit_root = !!search_commit_root;

		root_key.objectid = ref->root_id;
		root_key.type = BTRFS_ROOT_ITEM_KEY;
		root_key.offset = (u64)-1;
		@@ -314,7 +307,8 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
		time_seq, ref->wanted_disk_byte,
		extent_item_pos);
		out:
		btrfs_free_path(path);
		path->lowest_level = 0;
		btrfs_release_path(path);
		return ret;
		}

		@@ -322,7 +316,7 @@ out:
		* resolve all indirect backrefs from the list
		*/
		static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info,
		int search_commit_root, u64 time_seq,
		struct btrfs_path *path, u64 time_seq,
		struct list_head *head,
		const u64 *extent_item_pos)
		{
		@@ -349,9 +343,8 @@ static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info,
		continue;
		if (ref->count == 0)
		continue;
		err = __resolve_indirect_ref(fs_info, search_commit_root,
		time_seq, ref, parents,
		extent_item_pos);
		err = __resolve_indirect_ref(fs_info, path, time_seq, ref,
		parents, extent_item_pos);
		if (err == -ENOMEM)
		goto out;
		if (err)
		@@ -604,6 +597,7 @@ static int __add_inline_refs(struct btrfs_fs_info *fs_info,
		int slot;
		struct extent_buffer *leaf;
		struct btrfs_key key;
		struct btrfs_key found_key;
		unsigned long ptr;
		unsigned long end;
		struct btrfs_extent_item *ei;
		@@ -621,17 +615,21 @@ static int __add_inline_refs(struct btrfs_fs_info *fs_info,

		ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
		flags = btrfs_extent_flags(leaf, ei);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		ptr = (unsigned long)(ei + 1);
		end = (unsigned long)ei + item_size;

		if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
		if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
		flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
		struct btrfs_tree_block_info *info;

		info = (struct btrfs_tree_block_info *)ptr;
		*info_level = btrfs_tree_block_level(leaf, info);
		ptr += sizeof(struct btrfs_tree_block_info);
		BUG_ON(ptr > end);
		} else if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
		*info_level = found_key.offset;
		} else {
		BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
		}
		@@ -795,7 +793,6 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans,
		struct btrfs_delayed_ref_head *head;
		int info_level = 0;
		int ret;
		int search_commit_root = (trans == BTRFS_BACKREF_SEARCH_COMMIT_ROOT);
		struct list_head prefs_delayed;
		struct list_head prefs;
		struct __prelim_ref *ref;
		@@ -804,13 +801,17 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans,
		INIT_LIST_HEAD(&prefs_delayed);

		key.objectid = bytenr;
		key.type = BTRFS_EXTENT_ITEM_KEY;
		key.offset = (u64)-1;
		if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))
		key.type = BTRFS_METADATA_ITEM_KEY;
		else
		key.type = BTRFS_EXTENT_ITEM_KEY;

		path = btrfs_alloc_path();
		if (!path)
		return -ENOMEM;
		path->search_commit_root = !!search_commit_root;
		if (!trans)
		path->search_commit_root = 1;

		/*
		* grab both a lock on the path and a lock on the delayed ref head.
		@@ -825,7 +826,7 @@ again:
		goto out;
		BUG_ON(ret == 0);

		if (trans != BTRFS_BACKREF_SEARCH_COMMIT_ROOT) {
		if (trans) {
		/*
		* look if there are updates for this ref queued and lock the
		* head
		@@ -869,7 +870,8 @@ again:
		slot = path->slots[0];
		btrfs_item_key_to_cpu(leaf, &key, slot);
		if (key.objectid == bytenr &&
		key.type == BTRFS_EXTENT_ITEM_KEY) {
		(key.type == BTRFS_EXTENT_ITEM_KEY \|\|
		key.type == BTRFS_METADATA_ITEM_KEY)) {
		ret = __add_inline_refs(fs_info, path, bytenr,
		&info_level, &prefs);
		if (ret)
		@@ -890,8 +892,8 @@ again:

		__merge_refs(&prefs, 1);

		ret = __resolve_indirect_refs(fs_info, search_commit_root, time_seq,
		&prefs, extent_item_pos);
		ret = __resolve_indirect_refs(fs_info, path, time_seq, &prefs,
		extent_item_pos);
		if (ret)
		goto out;

		@@ -1283,11 +1285,15 @@ int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
		{
		int ret;
		u64 flags;
		u64 size = 0;
		u32 item_size;
		struct extent_buffer *eb;
		struct btrfs_extent_item *ei;
		struct btrfs_key key;

		if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))
		key.type = BTRFS_METADATA_ITEM_KEY;
		else
		key.type = BTRFS_EXTENT_ITEM_KEY;
		key.objectid = logical;
		key.offset = (u64)-1;
		@@ -1301,9 +1307,15 @@ int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
		return ret;

		btrfs_item_key_to_cpu(path->nodes[0], found_key, path->slots[0]);
		if (found_key->type != BTRFS_EXTENT_ITEM_KEY \|\|
		if (found_key->type == BTRFS_METADATA_ITEM_KEY)
		size = fs_info->extent_root->leafsize;
		else if (found_key->type == BTRFS_EXTENT_ITEM_KEY)
		size = found_key->offset;

		if ((found_key->type != BTRFS_EXTENT_ITEM_KEY &&
		found_key->type != BTRFS_METADATA_ITEM_KEY) \|\|
		found_key->objectid > logical \|\|
		found_key->objectid + found_key->offset <= logical) {
		found_key->objectid + size <= logical) {
		pr_debug("logical %llu is not within any extent\n",
		(unsigned long long)logical);
		return -ENOENT;
		@@ -1459,7 +1471,7 @@ int iterate_extent_inodes(struct btrfs_fs_info *fs_info,
		iterate_extent_inodes_t iterate, void ctx)
		{
		int ret;
		struct btrfs_trans_handle *trans;
		struct btrfs_trans_handle *trans = NULL;
		struct ulist *refs = NULL;
		struct ulist *roots = NULL;
		struct ulist_node *ref_node = NULL;
		@@ -1471,9 +1483,7 @@ int iterate_extent_inodes(struct btrfs_fs_info *fs_info,
		pr_debug("resolving all inodes for extent %llu\n",
		extent_item_objectid);

		if (search_commit_root) {
		trans = BTRFS_BACKREF_SEARCH_COMMIT_ROOT;
		} else {
		if (!search_commit_root) {
		trans = btrfs_join_transaction(fs_info->extent_root);
		if (IS_ERR(trans))
		return PTR_ERR(trans);

fs/btrfs/backref.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -23,8 +23,6 @@
		#include "ulist.h"
		#include "extent_io.h"

		#define BTRFS_BACKREF_SEARCH_COMMIT_ROOT ((struct btrfs_trans_handle *)0)

		struct inode_fs_paths {
		struct btrfs_path *btrfs_path;
		struct btrfs_root *fs_root;

fs/btrfs/ctree.c

+43 −75

Original line number	Diff line number	Diff line
		@@ -1089,6 +1089,7 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
		btrfs_set_node_ptr_generation(parent, parent_slot,
		trans->transid);
		btrfs_mark_buffer_dirty(parent);
		if (last_ref)
		tree_mod_log_free_eb(root->fs_info, buf);
		btrfs_free_tree_block(trans, root, buf, parent_start,
		last_ref);
		@@ -1161,8 +1162,8 @@ __tree_mod_log_oldest_root(struct btrfs_fs_info *fs_info,
		* time_seq).
		*/
		static void
		__tree_mod_log_rewind(struct extent_buffer *eb, u64 time_seq,
		struct tree_mod_elem *first_tm)
		__tree_mod_log_rewind(struct btrfs_fs_info fs_info, struct extent_buffer eb,
		u64 time_seq, struct tree_mod_elem *first_tm)
		{
		u32 n;
		struct rb_node *next;
		@@ -1172,6 +1173,7 @@ __tree_mod_log_rewind(struct extent_buffer *eb, u64 time_seq,
		unsigned long p_size = sizeof(struct btrfs_key_ptr);

		n = btrfs_header_nritems(eb);
		tree_mod_log_read_lock(fs_info);
		while (tm && tm->seq >= time_seq) {
		/*
		* all the operations are recorded with the operator used for
		@@ -1226,6 +1228,7 @@ __tree_mod_log_rewind(struct extent_buffer *eb, u64 time_seq,
		if (tm->index != first_tm->index)
		break;
		}
		tree_mod_log_read_unlock(fs_info);
		btrfs_set_header_nritems(eb, n);
		}

		@@ -1274,7 +1277,7 @@ tree_mod_log_rewind(struct btrfs_fs_info fs_info, struct extent_buffer eb,

		extent_buffer_get(eb_rewin);
		btrfs_tree_read_lock(eb_rewin);
		__tree_mod_log_rewind(eb_rewin, time_seq, tm);
		__tree_mod_log_rewind(fs_info, eb_rewin, time_seq, tm);
		WARN_ON(btrfs_header_nritems(eb_rewin) >
		BTRFS_NODEPTRS_PER_BLOCK(fs_info->tree_root));

		@@ -1350,7 +1353,7 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
		btrfs_set_header_generation(eb, old_generation);
		}
		if (tm)
		__tree_mod_log_rewind(eb, time_seq, tm);
		__tree_mod_log_rewind(root->fs_info, eb, time_seq, tm);
		else
		WARN_ON(btrfs_header_level(eb) != 0);
		WARN_ON(btrfs_header_nritems(eb) > BTRFS_NODEPTRS_PER_BLOCK(root));
		@@ -2178,11 +2181,7 @@ static void reada_for_search(struct btrfs_root *root,
		}
		}

		/*
		* returns -EAGAIN if it had to drop the path, or zero if everything was in
		* cache
		*/
		static noinline int reada_for_balance(struct btrfs_root *root,
		static noinline void reada_for_balance(struct btrfs_root *root,
		struct btrfs_path *path, int level)
		{
		int slot;
		@@ -2192,12 +2191,11 @@ static noinline int reada_for_balance(struct btrfs_root *root,
		u64 gen;
		u64 block1 = 0;
		u64 block2 = 0;
		int ret = 0;
		int blocksize;

		parent = path->nodes[level + 1];
		if (!parent)
		return 0;
		return;

		nritems = btrfs_header_nritems(parent);
		slot = path->slots[level + 1];
		@@ -2224,28 +2222,11 @@ static noinline int reada_for_balance(struct btrfs_root *root,
		block2 = 0;
		free_extent_buffer(eb);
		}
		if (block1 \|\| block2) {
		ret = -EAGAIN;

		/* release the whole path */
		btrfs_release_path(path);

		/* read the blocks */
		if (block1)
		readahead_tree_block(root, block1, blocksize, 0);
		if (block2)
		readahead_tree_block(root, block2, blocksize, 0);

		if (block1) {
		eb = read_tree_block(root, block1, blocksize, 0);
		free_extent_buffer(eb);
		}
		if (block2) {
		eb = read_tree_block(root, block2, blocksize, 0);
		free_extent_buffer(eb);
		}
		}
		return ret;
		}


		@@ -2359,28 +2340,22 @@ read_block_for_search(struct btrfs_trans_handle *trans,
		tmp = btrfs_find_tree_block(root, blocknr, blocksize);
		if (tmp) {
		/* first we do an atomic uptodate check */
		if (btrfs_buffer_uptodate(tmp, 0, 1) > 0) {
		if (btrfs_buffer_uptodate(tmp, gen, 1) > 0) {
		/*
		* we found an up to date block without
		* sleeping, return
		* right away
		*/
		*eb_ret = tmp;
		return 0;
		}

		/* the pages were up to date, but we failed
		* the generation number check. Do a full
		* read for the generation number that is correct.
		* We must do this without dropping locks so
		* we can trust our generation number
		*/
		free_extent_buffer(tmp);
		btrfs_set_path_blocking(p);

		/* now we're allowed to do a blocking uptodate check */
		tmp = read_tree_block(root, blocknr, blocksize, gen);
		if (tmp && btrfs_buffer_uptodate(tmp, gen, 0) > 0) {
		ret = btrfs_read_buffer(tmp, gen);
		if (!ret) {
		*eb_ret = tmp;
		return 0;
		}
		@@ -2388,7 +2363,6 @@ read_block_for_search(struct btrfs_trans_handle *trans,
		btrfs_release_path(p);
		return -EIO;
		}
		}

		/*
		* reduce lock contention at high levels
		@@ -2448,11 +2422,8 @@ setup_nodes_for_search(struct btrfs_trans_handle *trans,
		goto again;
		}

		sret = reada_for_balance(root, p, level);
		if (sret)
		goto again;

		btrfs_set_path_blocking(p);
		reada_for_balance(root, p, level);
		sret = split_node(trans, root, p, level);
		btrfs_clear_path_blocking(p, NULL, 0);

		@@ -2472,11 +2443,8 @@ setup_nodes_for_search(struct btrfs_trans_handle *trans,
		goto again;
		}

		sret = reada_for_balance(root, p, level);
		if (sret)
		goto again;

		btrfs_set_path_blocking(p);
		reada_for_balance(root, p, level);
		sret = balance_level(trans, root, p, level);
		btrfs_clear_path_blocking(p, NULL, 0);

		@@ -3143,7 +3111,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
		*/
		static noinline int insert_new_root(struct btrfs_trans_handle *trans,
		struct btrfs_root *root,
		struct btrfs_path *path, int level, int log_removal)
		struct btrfs_path *path, int level)
		{
		u64 lower_gen;
		struct extent_buffer *lower;
		@@ -3194,7 +3162,7 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
		btrfs_mark_buffer_dirty(c);

		old = root->node;
		tree_mod_log_set_root_pointer(root, c, log_removal);
		tree_mod_log_set_root_pointer(root, c, 0);
		rcu_assign_pointer(root->node, c);

		/* the super has an extra ref to root->node */
		@@ -3278,14 +3246,14 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
		/*
		* trying to split the root, lets make a new one
		*
		* tree mod log: We pass 0 as log_removal parameter to
		* tree mod log: We don't log_removal old root in
		* insert_new_root, because that root buffer will be kept as a
		* normal node. We are going to log removal of half of the
		* elements below with tree_mod_log_eb_copy. We're holding a
		* tree lock on the buffer, which is why we cannot race with
		* other tree_mod_log users.
		*/
		ret = insert_new_root(trans, root, path, level + 1, 0);
		ret = insert_new_root(trans, root, path, level + 1);
		if (ret)
		return ret;
		} else {
		@@ -3986,7 +3954,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
		return -EOVERFLOW;

		/* first try to make some room by pushing left and right */
		if (data_size) {
		if (data_size && path->nodes[1]) {
		wret = push_leaf_right(trans, root, path, data_size,
		data_size, 0, 0);
		if (wret < 0)
		@@ -4005,7 +3973,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
		}

		if (!path->nodes[1]) {
		ret = insert_new_root(trans, root, path, 1, 1);
		ret = insert_new_root(trans, root, path, 1);
		if (ret)
		return ret;
		}

fs/btrfs/ctree.h

+86 −19

Original line number	Diff line number	Diff line
		@@ -961,8 +961,8 @@ struct btrfs_dev_replace_item {
		#define BTRFS_BLOCK_GROUP_RAID1 (1ULL << 4)
		#define BTRFS_BLOCK_GROUP_DUP (1ULL << 5)
		#define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6)
		#define BTRFS_BLOCK_GROUP_RAID5 (1 << 7)
		#define BTRFS_BLOCK_GROUP_RAID6 (1 << 8)
		#define BTRFS_BLOCK_GROUP_RAID5 (1ULL << 7)
		#define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8)
		#define BTRFS_BLOCK_GROUP_RESERVED BTRFS_AVAIL_ALLOC_BIT_SINGLE

		enum btrfs_raid_types {
		@@ -1101,6 +1101,18 @@ struct btrfs_space_info {
		u64 disk_total; /* total bytes on disk, takes mirrors into
		account */

		/*
		* bytes_pinned is kept in line with what is actually pinned, as in
		* we've called update_block_group and dropped the bytes_used counter
		* and increased the bytes_pinned counter. However this means that
		* bytes_pinned does not reflect the bytes that will be pinned once the
		* delayed refs are flushed, so this counter is inc'ed everytime we call
		* btrfs_free_extent so it is a realtime count of what will be freed
		* once the transaction is committed. It will be zero'ed everytime the
		* transaction commits.
		*/
		struct percpu_counter total_bytes_pinned;

		/*
		* we bump reservation progress every time we decrement
		* bytes_reserved. This way people waiting for reservations
		@@ -1437,25 +1449,22 @@ struct btrfs_fs_info {
		atomic_t open_ioctl_trans;

		/*
		* this is used by the balancing code to wait for all the pending
		* ordered extents
		* this is used to protect the following list -- ordered_roots.
		*/
		spinlock_t ordered_extent_lock;
		spinlock_t ordered_root_lock;

		/*
		* all of the data=ordered extents pending writeback
		* all fs/file tree roots in which there are data=ordered extents
		* pending writeback are added into this list.
		*
		* these can span multiple transactions and basically include
		* every dirty data page that isn't from nodatacow
		*/
		struct list_head ordered_extents;
		struct list_head ordered_roots;

		spinlock_t delalloc_lock;
		/*
		* all of the inodes that have delalloc bytes. It is possible for
		* this list to be empty even when there is still dirty data=ordered
		* extents waiting to finish IO.
		*/
		struct list_head delalloc_inodes;
		spinlock_t delalloc_root_lock;
		/* all fs/file tree roots that have delalloc inodes. */
		struct list_head delalloc_roots;

		/*
		* there is a pool of worker threads for checksumming during writes
		@@ -1498,8 +1507,6 @@ struct btrfs_fs_info {
		int do_barriers;
		int closing;
		int log_root_recovering;
		int enospc_unlink;
		int trans_no_join;

		u64 total_pinned;

		@@ -1594,6 +1601,12 @@ struct btrfs_fs_info {
		struct rb_root qgroup_tree;
		spinlock_t qgroup_lock;

		/*
		* used to avoid frequently calling ulist_alloc()/ulist_free()
		* when doing qgroup accounting, it must be protected by qgroup_lock.
		*/
		struct ulist *qgroup_ulist;

		/* protect user change for quota operations */
		struct mutex qgroup_ioctl_lock;

		@@ -1607,6 +1620,8 @@ struct btrfs_fs_info {
		struct mutex qgroup_rescan_lock; /* protects the progress item */
		struct btrfs_key qgroup_rescan_progress;
		struct btrfs_workers qgroup_rescan_workers;
		struct completion qgroup_rescan_completion;
		struct btrfs_work qgroup_rescan_work;

		/* filesystem state */
		unsigned long fs_state;
		@@ -1739,6 +1754,31 @@ struct btrfs_root {
		int force_cow;

		spinlock_t root_item_lock;
		atomic_t refs;

		spinlock_t delalloc_lock;
		/*
		* all of the inodes that have delalloc bytes. It is possible for
		* this list to be empty even when there is still dirty data=ordered
		* extents waiting to finish IO.
		*/
		struct list_head delalloc_inodes;
		struct list_head delalloc_root;
		u64 nr_delalloc_inodes;
		/*
		* this is used by the balancing code to wait for all the pending
		* ordered extents
		*/
		spinlock_t ordered_extent_lock;

		/*
		* all of the data=ordered extents pending writeback
		* these can span multiple transactions and basically include
		* every dirty data page that isn't from nodatacow
		*/
		struct list_head ordered_extents;
		struct list_head ordered_root;
		u64 nr_ordered_extents;
		};

		struct btrfs_ioctl_defrag_range_args {
		@@ -3028,6 +3068,8 @@ static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,
		num_items;
		}

		int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,
		struct btrfs_root *root);
		void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
		int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
		struct btrfs_root *root, unsigned long count);
		@@ -3039,6 +3081,8 @@ int btrfs_pin_extent(struct btrfs_root *root,
		u64 bytenr, u64 num, int reserved);
		int btrfs_pin_extent_for_log_replay(struct btrfs_root *root,
		u64 bytenr, u64 num_bytes);
		int btrfs_exclude_logged_extents(struct btrfs_root *root,
		struct extent_buffer *eb);
		int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
		struct btrfs_root *root,
		u64 objectid, u64 offset, u64 bytenr);
		@@ -3155,6 +3199,9 @@ int btrfs_block_rsv_refill(struct btrfs_root *root,
		int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
		struct btrfs_block_rsv *dst_rsv,
		u64 num_bytes);
		int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
		struct btrfs_block_rsv *dest, u64 num_bytes,
		int min_factor);
		void btrfs_block_rsv_release(struct btrfs_root *root,
		struct btrfs_block_rsv *block_rsv,
		u64 num_bytes);
		@@ -3311,6 +3358,18 @@ static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
		smp_mb();
		return fs_info->closing;
		}

		/*
		* If we remount the fs to be R/O or umount the fs, the cleaner needn't do
		* anything except sleeping. This function is used to check the status of
		* the fs.
		*/
		static inline int btrfs_need_cleaner_sleep(struct btrfs_root *root)
		{
		return (root->fs_info->sb->s_flags & MS_RDONLY \|\|
		btrfs_fs_closing(root->fs_info));
		}

		static inline void free_fs_info(struct btrfs_fs_info *fs_info)
		{
		kfree(fs_info->balance_ctl);
		@@ -3357,9 +3416,9 @@ int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
		struct btrfs_root_item *item);
		void btrfs_read_root_item(struct extent_buffer *eb, int slot,
		struct btrfs_root_item *item);
		int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
		btrfs_root_item item, struct btrfs_key key);
		int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid);
		int btrfs_find_root(struct btrfs_root root, struct btrfs_key search_key,
		struct btrfs_path path, struct btrfs_root_item root_item,
		struct btrfs_key *root_key);
		int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
		void btrfs_set_root_node(struct btrfs_root_item *item,
		struct extent_buffer *node);
		@@ -3493,6 +3552,10 @@ void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);
		struct extent_map btrfs_get_extent_fiemap(struct inode inode, struct page *page,
		size_t pg_offset, u64 start, u64 len,
		int create);
		noinline int can_nocow_extent(struct btrfs_trans_handle *trans,
		struct inode inode, u64 offset, u64 len,
		u64 orig_start, u64 orig_block_len,
		u64 *ram_bytes);

		/* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
		#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
		@@ -3530,6 +3593,8 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
		u32 min_type);

		int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
		int btrfs_start_all_delalloc_inodes(struct btrfs_fs_info *fs_info,
		int delay_iput);
		int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
		struct extent_state **cached_state);
		int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
		@@ -3814,6 +3879,8 @@ int btrfs_quota_enable(struct btrfs_trans_handle *trans,
		int btrfs_quota_disable(struct btrfs_trans_handle *trans,
		struct btrfs_fs_info *fs_info);
		int btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info);
		void btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info);
		int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info);
		int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans,
		struct btrfs_fs_info *fs_info, u64 src, u64 dst);
		int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans,

fs/btrfs/delayed-inode.c

+0 −14

Original line number	Diff line number	Diff line
		@@ -535,20 +535,6 @@ static struct btrfs_delayed_item *__btrfs_next_delayed_item(
		return next;
		}

		static inline struct btrfs_root btrfs_get_fs_root(struct btrfs_root root,
		u64 root_id)
		{
		struct btrfs_key root_key;

		if (root->objectid == root_id)
		return root;

		root_key.objectid = root_id;
		root_key.type = BTRFS_ROOT_ITEM_KEY;
		root_key.offset = (u64)-1;
		return btrfs_read_fs_root_no_name(root->fs_info, &root_key);
		}

		static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans,
		struct btrfs_root *root,
		struct btrfs_delayed_item *item)

Admin message