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

fs/btrfs/async-thread.c

+2 −0

Original line number	Diff line number	Diff line
		@@ -323,6 +323,8 @@ void btrfs_destroy_workqueue(struct btrfs_workqueue *wq)

		void btrfs_workqueue_set_max(struct btrfs_workqueue *wq, int max)
		{
		if (!wq)
		return;
		wq->normal->max_active = max;
		if (wq->high)
		wq->high->max_active = max;

fs/btrfs/backref.c

+27 −6

Original line number	Diff line number	Diff line
		@@ -330,6 +330,9 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
		goto out;
		}

		if (path->search_commit_root)
		root_level = btrfs_header_level(root->commit_root);
		else
		root_level = btrfs_old_root_level(root, time_seq);

		if (root_level + 1 == level) {
		@@ -1099,7 +1102,7 @@ static int btrfs_find_all_leafs(struct btrfs_trans_handle *trans,
		*
		* returns 0 on success, < 0 on error.
		*/
		int btrfs_find_all_roots(struct btrfs_trans_handle *trans,
		static int __btrfs_find_all_roots(struct btrfs_trans_handle *trans,
		struct btrfs_fs_info *fs_info, u64 bytenr,
		u64 time_seq, struct ulist **roots)
		{
		@@ -1137,6 +1140,20 @@ int btrfs_find_all_roots(struct btrfs_trans_handle *trans,
		return 0;
		}

		int btrfs_find_all_roots(struct btrfs_trans_handle *trans,
		struct btrfs_fs_info *fs_info, u64 bytenr,
		u64 time_seq, struct ulist **roots)
		{
		int ret;

		if (!trans)
		down_read(&fs_info->commit_root_sem);
		ret = __btrfs_find_all_roots(trans, fs_info, bytenr, time_seq, roots);
		if (!trans)
		up_read(&fs_info->commit_root_sem);
		return ret;
		}

		/*
		* this makes the path point to (inum INODE_ITEM ioff)
		*/
		@@ -1516,6 +1533,8 @@ int iterate_extent_inodes(struct btrfs_fs_info *fs_info,
		if (IS_ERR(trans))
		return PTR_ERR(trans);
		btrfs_get_tree_mod_seq(fs_info, &tree_mod_seq_elem);
		} else {
		down_read(&fs_info->commit_root_sem);
		}

		ret = btrfs_find_all_leafs(trans, fs_info, extent_item_objectid,
		@@ -1526,7 +1545,7 @@ int iterate_extent_inodes(struct btrfs_fs_info *fs_info,

		ULIST_ITER_INIT(&ref_uiter);
		while (!ret && (ref_node = ulist_next(refs, &ref_uiter))) {
		ret = btrfs_find_all_roots(trans, fs_info, ref_node->val,
		ret = __btrfs_find_all_roots(trans, fs_info, ref_node->val,
		tree_mod_seq_elem.seq, &roots);
		if (ret)
		break;
		@@ -1549,6 +1568,8 @@ out:
		if (!search_commit_root) {
		btrfs_put_tree_mod_seq(fs_info, &tree_mod_seq_elem);
		btrfs_end_transaction(trans, fs_info->extent_root);
		} else {
		up_read(&fs_info->commit_root_sem);
		}

		return ret;

fs/btrfs/ctree.c

+6 −88

Original line number	Diff line number	Diff line
		@@ -2769,9 +2769,13 @@ again:
		* the commit roots are read only
		* so we always do read locks
		*/
		if (p->need_commit_sem)
		down_read(&root->fs_info->commit_root_sem);
		b = root->commit_root;
		extent_buffer_get(b);
		level = btrfs_header_level(b);
		if (p->need_commit_sem)
		up_read(&root->fs_info->commit_root_sem);
		if (!p->skip_locking)
		btrfs_tree_read_lock(b);
		} else {
		@@ -5360,7 +5364,6 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
		{
		int ret;
		int cmp;
		struct btrfs_trans_handle *trans = NULL;
		struct btrfs_path *left_path = NULL;
		struct btrfs_path *right_path = NULL;
		struct btrfs_key left_key;
		@@ -5378,9 +5381,6 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
		u64 right_blockptr;
		u64 left_gen;
		u64 right_gen;
		u64 left_start_ctransid;
		u64 right_start_ctransid;
		u64 ctransid;

		left_path = btrfs_alloc_path();
		if (!left_path) {
		@@ -5404,21 +5404,6 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
		right_path->search_commit_root = 1;
		right_path->skip_locking = 1;

		spin_lock(&left_root->root_item_lock);
		left_start_ctransid = btrfs_root_ctransid(&left_root->root_item);
		spin_unlock(&left_root->root_item_lock);

		spin_lock(&right_root->root_item_lock);
		right_start_ctransid = btrfs_root_ctransid(&right_root->root_item);
		spin_unlock(&right_root->root_item_lock);

		trans = btrfs_join_transaction(left_root);
		if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		trans = NULL;
		goto out;
		}

		/*
		* Strategy: Go to the first items of both trees. Then do
		*
		@@ -5455,6 +5440,7 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
		* the right if possible or go up and right.
		*/

		down_read(&left_root->fs_info->commit_root_sem);
		left_level = btrfs_header_level(left_root->commit_root);
		left_root_level = left_level;
		left_path->nodes[left_level] = left_root->commit_root;
		@@ -5464,6 +5450,7 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
		right_root_level = right_level;
		right_path->nodes[right_level] = right_root->commit_root;
		extent_buffer_get(right_path->nodes[right_level]);
		up_read(&left_root->fs_info->commit_root_sem);

		if (left_level == 0)
		btrfs_item_key_to_cpu(left_path->nodes[left_level],
		@@ -5482,67 +5469,6 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
		advance_left = advance_right = 0;

		while (1) {
		/*
		* We need to make sure the transaction does not get committed
		* while we do anything on commit roots. This means, we need to
		* join and leave transactions for every item that we process.
		*/
		if (trans && btrfs_should_end_transaction(trans, left_root)) {
		btrfs_release_path(left_path);
		btrfs_release_path(right_path);

		ret = btrfs_end_transaction(trans, left_root);
		trans = NULL;
		if (ret < 0)
		goto out;
		}
		/* now rejoin the transaction */
		if (!trans) {
		trans = btrfs_join_transaction(left_root);
		if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		trans = NULL;
		goto out;
		}

		spin_lock(&left_root->root_item_lock);
		ctransid = btrfs_root_ctransid(&left_root->root_item);
		spin_unlock(&left_root->root_item_lock);
		if (ctransid != left_start_ctransid)
		left_start_ctransid = 0;

		spin_lock(&right_root->root_item_lock);
		ctransid = btrfs_root_ctransid(&right_root->root_item);
		spin_unlock(&right_root->root_item_lock);
		if (ctransid != right_start_ctransid)
		right_start_ctransid = 0;

		if (!left_start_ctransid \|\| !right_start_ctransid) {
		WARN(1, KERN_WARNING
		"BTRFS: btrfs_compare_tree detected "
		"a change in one of the trees while "
		"iterating. This is probably a "
		"bug.\n");
		ret = -EIO;
		goto out;
		}

		/*
		* the commit root may have changed, so start again
		* where we stopped
		*/
		left_path->lowest_level = left_level;
		right_path->lowest_level = right_level;
		ret = btrfs_search_slot(NULL, left_root,
		&left_key, left_path, 0, 0);
		if (ret < 0)
		goto out;
		ret = btrfs_search_slot(NULL, right_root,
		&right_key, right_path, 0, 0);
		if (ret < 0)
		goto out;
		}

		if (advance_left && !left_end_reached) {
		ret = tree_advance(left_root, left_path, &left_level,
		left_root_level,
		@@ -5672,14 +5598,6 @@ out:
		btrfs_free_path(left_path);
		btrfs_free_path(right_path);
		kfree(tmp_buf);

		if (trans) {
		if (!ret)
		ret = btrfs_end_transaction(trans, left_root);
		else
		btrfs_end_transaction(trans, left_root);
		}

		return ret;
		}

fs/btrfs/ctree.h

+10 −3

Original line number	Diff line number	Diff line
		@@ -609,6 +609,7 @@ struct btrfs_path {
		unsigned int skip_locking:1;
		unsigned int leave_spinning:1;
		unsigned int search_commit_root:1;
		unsigned int need_commit_sem:1;
		};

		/*
		@@ -986,7 +987,8 @@ struct btrfs_dev_replace_item {
		#define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6)
		#define BTRFS_BLOCK_GROUP_RAID5 (1ULL << 7)
		#define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8)
		#define BTRFS_BLOCK_GROUP_RESERVED BTRFS_AVAIL_ALLOC_BIT_SINGLE
		#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE \| \
		BTRFS_SPACE_INFO_GLOBAL_RSV)

		enum btrfs_raid_types {
		BTRFS_RAID_RAID10,
		@@ -1018,6 +1020,12 @@ enum btrfs_raid_types {
		*/
		#define BTRFS_AVAIL_ALLOC_BIT_SINGLE (1ULL << 48)

		/*
		* A fake block group type that is used to communicate global block reserve
		* size to userspace via the SPACE_INFO ioctl.
		*/
		#define BTRFS_SPACE_INFO_GLOBAL_RSV (1ULL << 49)

		#define BTRFS_EXTENDED_PROFILE_MASK (BTRFS_BLOCK_GROUP_PROFILE_MASK \| \
		BTRFS_AVAIL_ALLOC_BIT_SINGLE)

		@@ -1440,7 +1448,7 @@ struct btrfs_fs_info {
		*/
		struct mutex ordered_extent_flush_mutex;

		struct rw_semaphore extent_commit_sem;
		struct rw_semaphore commit_root_sem;

		struct rw_semaphore cleanup_work_sem;

		@@ -1711,7 +1719,6 @@ struct btrfs_root {
		struct btrfs_block_rsv *block_rsv;

		/* free ino cache stuff */
		struct mutex fs_commit_mutex;
		struct btrfs_free_space_ctl *free_ino_ctl;
		enum btrfs_caching_type cached;
		spinlock_t cache_lock;

fs/btrfs/disk-io.c

+20 −3

Original line number	Diff line number	Diff line
		@@ -329,6 +329,8 @@ static int verify_parent_transid(struct extent_io_tree *io_tree,
		{
		struct extent_state *cached_state = NULL;
		int ret;
		bool need_lock = (current->journal_info ==
		(void *)BTRFS_SEND_TRANS_STUB);

		if (!parent_transid \|\| btrfs_header_generation(eb) == parent_transid)
		return 0;
		@@ -336,6 +338,11 @@ static int verify_parent_transid(struct extent_io_tree *io_tree,
		if (atomic)
		return -EAGAIN;

		if (need_lock) {
		btrfs_tree_read_lock(eb);
		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
		}

		lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
		0, &cached_state);
		if (extent_buffer_uptodate(eb) &&
		@@ -347,10 +354,21 @@ static int verify_parent_transid(struct extent_io_tree *io_tree,
		"found %llu\n",
		eb->start, parent_transid, btrfs_header_generation(eb));
		ret = 1;

		/*
		* Things reading via commit roots that don't have normal protection,
		* like send, can have a really old block in cache that may point at a
		* block that has been free'd and re-allocated. So don't clear uptodate
		* if we find an eb that is under IO (dirty/writeback) because we could
		* end up reading in the stale data and then writing it back out and
		* making everybody very sad.
		*/
		if (!extent_buffer_under_io(eb))
		clear_extent_buffer_uptodate(eb);
		out:
		unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
		&cached_state, GFP_NOFS);
		btrfs_tree_read_unlock_blocking(eb);
		return ret;
		}

		@@ -1546,7 +1564,6 @@ int btrfs_init_fs_root(struct btrfs_root *root)
		root->subv_writers = writers;

		btrfs_init_free_ino_ctl(root);
		mutex_init(&root->fs_commit_mutex);
		spin_lock_init(&root->cache_lock);
		init_waitqueue_head(&root->cache_wait);

		@@ -2324,7 +2341,7 @@ int open_ctree(struct super_block *sb,
		mutex_init(&fs_info->transaction_kthread_mutex);
		mutex_init(&fs_info->cleaner_mutex);
		mutex_init(&fs_info->volume_mutex);
		init_rwsem(&fs_info->extent_commit_sem);
		init_rwsem(&fs_info->commit_root_sem);
		init_rwsem(&fs_info->cleanup_work_sem);
		init_rwsem(&fs_info->subvol_sem);
		sema_init(&fs_info->uuid_tree_rescan_sem, 1);

Admin message