Commit f5d80856 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-5.10-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux 

Pull btrfs fixes from David Sterba:

 - lockdep fixes:
     - drop path locks before manipulating sysfs objects or qgroups
     - preliminary fixes before tree locks get switched to rwsem
     - use annotated seqlock

 - build warning fixes (printk format)

 - fix relocation vs fallocate race

 - tree checker properly validates number of stripes and parity

 - readahead vs device replace fixes

 - iomap dio fix for unnecessary buffered io fallback

* tag 'for-5.10-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
  btrfs: convert data_seqcount to seqcount_mutex_t
  btrfs: don't fallback to buffered read if we don't need to
  btrfs: add a helper to read the tree_root commit root for backref lookup
  btrfs: drop the path before adding qgroup items when enabling qgroups
  btrfs: fix readahead hang and use-after-free after removing a device
  btrfs: fix use-after-free on readahead extent after failure to create it
  btrfs: tree-checker: validate number of chunk stripes and parity
  btrfs: tree-checker: fix incorrect printk format
  btrfs: drop the path before adding block group sysfs files
  btrfs: fix relocation failure due to race with fallocate
parents aab6bf50 d5c82388

fs/btrfs/backref.c

+12 −1
Original line number Diff line number Diff line
@@ -544,6 +544,17 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, 
	int level = ref->level;

	struct btrfs_key search_key = ref->key_for_search;



	/*

	 * If we're search_commit_root we could possibly be holding locks on

	 * other tree nodes.  This happens when qgroups does backref walks when

	 * adding new delayed refs.  To deal with this we need to look in cache

	 * for the root, and if we don't find it then we need to search the

	 * tree_root's commit root, thus the btrfs_get_fs_root_commit_root usage

	 * here.

	 */

	if (path->search_commit_root)

		root = btrfs_get_fs_root_commit_root(fs_info, path, ref->root_id);

	else

		root = btrfs_get_fs_root(fs_info, ref->root_id, false);

	if (IS_ERR(root)) {

		ret = PTR_ERR(root);

fs/btrfs/block-group.c

+1 −0
Original line number Diff line number Diff line
@@ -2024,6 +2024,7 @@ int btrfs_read_block_groups(struct btrfs_fs_info *info) 
		key.offset = 0;

		btrfs_release_path(path);

	}

	btrfs_release_path(path);



	list_for_each_entry(space_info, &info->space_info, list) {

		int i;

fs/btrfs/ctree.h

+2 −0
Original line number Diff line number Diff line
@@ -3564,6 +3564,8 @@ struct reada_control *btrfs_reada_add(struct btrfs_root *root, 
int btrfs_reada_wait(void *handle);

void btrfs_reada_detach(void *handle);

int btree_readahead_hook(struct extent_buffer *eb, int err);

void btrfs_reada_remove_dev(struct btrfs_device *dev);

void btrfs_reada_undo_remove_dev(struct btrfs_device *dev);



static inline int is_fstree(u64 rootid)

{

fs/btrfs/dev-replace.c

+5 −0
Original line number Diff line number Diff line
@@ -688,6 +688,9 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info, 
	}

	btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);



	if (!scrub_ret)

		btrfs_reada_remove_dev(src_device);



	/*

	 * We have to use this loop approach because at this point src_device

	 * has to be available for transaction commit to complete, yet new
@@ -696,6 +699,7 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info, 
	while (1) {

		trans = btrfs_start_transaction(root, 0);

		if (IS_ERR(trans)) {

			btrfs_reada_undo_remove_dev(src_device);

			mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);

			return PTR_ERR(trans);

		}
@@ -746,6 +750,7 @@ error: 
		up_write(&dev_replace->rwsem);

		mutex_unlock(&fs_info->chunk_mutex);

		mutex_unlock(&fs_info->fs_devices->device_list_mutex);

		btrfs_reada_undo_remove_dev(src_device);

		btrfs_rm_dev_replace_blocked(fs_info);

		if (tgt_device)

			btrfs_destroy_dev_replace_tgtdev(tgt_device);

fs/btrfs/disk-io.c

+99 −40
Original line number Diff line number Diff line
@@ -1281,32 +1281,26 @@ int btrfs_add_log_tree(struct btrfs_trans_handle *trans, 
	return 0;

}



struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,

static struct btrfs_root *read_tree_root_path(struct btrfs_root *tree_root,

					      struct btrfs_path *path,

					      struct btrfs_key *key)

{

	struct btrfs_root *root;

	struct btrfs_fs_info *fs_info = tree_root->fs_info;

	struct btrfs_path *path;

	u64 generation;

	int ret;

	int level;



	path = btrfs_alloc_path();

	if (!path)

		return ERR_PTR(-ENOMEM);



	root = btrfs_alloc_root(fs_info, key->objectid, GFP_NOFS);

	if (!root) {

		ret = -ENOMEM;

		goto alloc_fail;

	}

	if (!root)

		return ERR_PTR(-ENOMEM);



	ret = btrfs_find_root(tree_root, key, path,

			      &root->root_item, &root->root_key);

	if (ret) {

		if (ret > 0)

			ret = -ENOENT;

		goto find_fail;

		goto fail;

	}



	generation = btrfs_root_generation(&root->root_item);
@@ -1317,21 +1311,31 @@ struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root, 
	if (IS_ERR(root->node)) {

		ret = PTR_ERR(root->node);

		root->node = NULL;

		goto find_fail;

		goto fail;

	} else if (!btrfs_buffer_uptodate(root->node, generation, 0)) {

		ret = -EIO;

		goto find_fail;

		goto fail;

	}

	root->commit_root = btrfs_root_node(root);

out:

	btrfs_free_path(path);

	return root;



find_fail:

fail:

	btrfs_put_root(root);

alloc_fail:

	root = ERR_PTR(ret);

	goto out;

	return ERR_PTR(ret);

}



struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,

					struct btrfs_key *key)

{

	struct btrfs_root *root;

	struct btrfs_path *path;



	path = btrfs_alloc_path();

	if (!path)

		return ERR_PTR(-ENOMEM);

	root = read_tree_root_path(tree_root, path, key);

	btrfs_free_path(path);



	return root;

}



/*
@@ -1419,6 +1423,31 @@ static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info, 
	return root;

}



static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,

						u64 objectid)

{

	if (objectid == BTRFS_ROOT_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->tree_root);

	if (objectid == BTRFS_EXTENT_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->extent_root);

	if (objectid == BTRFS_CHUNK_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->chunk_root);

	if (objectid == BTRFS_DEV_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->dev_root);

	if (objectid == BTRFS_CSUM_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->csum_root);

	if (objectid == BTRFS_QUOTA_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->quota_root) ?

			fs_info->quota_root : ERR_PTR(-ENOENT);

	if (objectid == BTRFS_UUID_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->uuid_root) ?

			fs_info->uuid_root : ERR_PTR(-ENOENT);

	if (objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->free_space_root) ?

			fs_info->free_space_root : ERR_PTR(-ENOENT);

	return NULL;

}



int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,

			 struct btrfs_root *root)

{
@@ -1518,25 +1547,9 @@ static struct btrfs_root *btrfs_get_root_ref(struct btrfs_fs_info *fs_info, 
	struct btrfs_key key;

	int ret;



	if (objectid == BTRFS_ROOT_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->tree_root);

	if (objectid == BTRFS_EXTENT_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->extent_root);

	if (objectid == BTRFS_CHUNK_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->chunk_root);

	if (objectid == BTRFS_DEV_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->dev_root);

	if (objectid == BTRFS_CSUM_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->csum_root);

	if (objectid == BTRFS_QUOTA_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->quota_root) ?

			fs_info->quota_root : ERR_PTR(-ENOENT);

	if (objectid == BTRFS_UUID_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->uuid_root) ?

			fs_info->uuid_root : ERR_PTR(-ENOENT);

	if (objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)

		return btrfs_grab_root(fs_info->free_space_root) ?

			fs_info->free_space_root : ERR_PTR(-ENOENT);

	root = btrfs_get_global_root(fs_info, objectid);

	if (root)

		return root;

again:

	root = btrfs_lookup_fs_root(fs_info, objectid);

	if (root) {
@@ -1621,6 +1634,52 @@ struct btrfs_root *btrfs_get_new_fs_root(struct btrfs_fs_info *fs_info, 
	return btrfs_get_root_ref(fs_info, objectid, anon_dev, true);

}



/*

 * btrfs_get_fs_root_commit_root - return a root for the given objectid

 * @fs_info:	the fs_info

 * @objectid:	the objectid we need to lookup

 *

 * This is exclusively used for backref walking, and exists specifically because

 * of how qgroups does lookups.  Qgroups will do a backref lookup at delayed ref

 * creation time, which means we may have to read the tree_root in order to look

 * up a fs root that is not in memory.  If the root is not in memory we will

 * read the tree root commit root and look up the fs root from there.  This is a

 * temporary root, it will not be inserted into the radix tree as it doesn't

 * have the most uptodate information, it'll simply be discarded once the

 * backref code is finished using the root.

 */

struct btrfs_root *btrfs_get_fs_root_commit_root(struct btrfs_fs_info *fs_info,

						 struct btrfs_path *path,

						 u64 objectid)

{

	struct btrfs_root *root;

	struct btrfs_key key;



	ASSERT(path->search_commit_root && path->skip_locking);



	/*

	 * This can return -ENOENT if we ask for a root that doesn't exist, but

	 * since this is called via the backref walking code we won't be looking

	 * up a root that doesn't exist, unless there's corruption.  So if root

	 * != NULL just return it.

	 */

	root = btrfs_get_global_root(fs_info, objectid);

	if (root)

		return root;



	root = btrfs_lookup_fs_root(fs_info, objectid);

	if (root)

		return root;



	key.objectid = objectid;

	key.type = BTRFS_ROOT_ITEM_KEY;

	key.offset = (u64)-1;

	root = read_tree_root_path(fs_info->tree_root, path, &key);

	btrfs_release_path(path);



	return root;

}



/*

 * called by the kthread helper functions to finally call the bio end_io

 * functions.  This is where read checksum verification actually happens

CRA Git | Maintained and supported by SUSTech CRA and CCSE