Cleanup how we handle root refs, part 2
v3 cover Cleanup how we handle root refs, part 2
v2->v3:
- Rebased onto the latest misc-next, so the snapshot aware defrag related patches got dropped.
v1->v2:
- Fixed a error missed put in an error condition in relink_extent_backref
- Added "btrfs: make the init of static elements in fs_info" so that we could clean up fs_info init and make the leak detectors work for the self tests.
-- original email --
In testing with the recent fsstress I stumbled upon a deadlock in how we deal with disappearing subvolumes. We sort of half-ass a srcu lock to protect us, but it's used inconsistently so doesn't really provide us with actual protection, mostly it just makes us feel good.
In order to do away with this srcu thing we need to have proper ref counting for our roots. We currently refcount them, but only to handle the actual kfree, it doesn't really control the lifetime of the root. And again, this is not done in any sort of consistent manner so it doesn't actually protect us.
This is the first set of patches, and yes I realize there are a lot of them. Most of them are just "hold a ref on the root" in all of the call sites that called btrfs_read_fs_root*() variations. Now that we're going to actually hold references to roots we need to make sure we put the reference when we're done with them, so these patches go through each callsite and make sure we drop the references appropriately.
Then there's a variety of cleanups and consolidations to make things clearer and make it so we only have 1 place to get roots.
Finally there's the root leak detection patch. I used this with a bunch of testing to make sure I was never leaking roots with these patches. I've been testing these for several weeks cleaning up all the corners, so they should be in relatively good shape. Most of the patches are small so straightforward to review.
This is just part 1, this is the prep work we need to make the root lifetime a little saner, and will allow us to drop the subvol srcu, as well as the inode rbtree. It doesn't really fundamentally change how roots are handled other than making the refcounting actually protect us from freeing the root while we're using it. That work will come later. Thanks,
Josef
PATCH v3 1/43 btrfs: push __setup_root into btrfs_alloc_root
There's no reason to not init the root at alloc time, and with later patches it actually causes problems if we error out mounting the fs before the tree_root is init'ed because we expect it to have a valid ref count. Fix this by pushing __setup_root into btrfs_alloc_root.
--- fs/btrfs/disk-io.c | 34 +++++++++++++--------------------- 1 file changed, 13 insertions(+), 21 deletions(-)
fs/btrfs/disk-io.c +13 -21
@@ -1130,6 +1130,7 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info, u64 objectid) {bool dummy =test_bit (BTRFS_FS_STATE_DUMMY_FS_INFO , &fs_info->fs_state); + root->fs_info = fs_info; root->node =NULL ; root->commit_root =NULL ; root->state =0 ;
@@ -1198,11 +1199,11 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info, }static struct btrfs_root *btrfs_alloc_root (struct btrfs_fs_info *fs_info, -gfp_t flags) +u64 objectid,gfp_t flags) {struct btrfs_root *root =kzalloc (sizeof (*root), flags);if (root) - root->fs_info = fs_info; +__setup_root (root, fs_info, objectid);return root; }
@@ -1215,12 +1216,11 @@ struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)if (!fs_info)return ERR_PTR (-EINVAL ); - root =btrfs_alloc_root (fs_info,GFP_KERNEL ); + root =btrfs_alloc_root (fs_info,BTRFS_ROOT_TREE_OBJECTID ,GFP_KERNEL );if (!root)return ERR_PTR (-ENOMEM );/* We don't use the stripesize in selftest, set it as sectorsize */ -__setup_root (root, fs_info,BTRFS_ROOT_TREE_OBJECTID ); root->alloc_bytenr =0 ;return root;
@@ -1244,12 +1244,11 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,* context to avoid deadlock if reclaim happens. */ nofs_flag =memalloc_nofs_save (); - root =btrfs_alloc_root (fs_info,GFP_KERNEL ); + root =btrfs_alloc_root (fs_info, objectid,GFP_KERNEL );memalloc_nofs_restore (nofs_flag);if (!root)return ERR_PTR (-ENOMEM ); -__setup_root (root, fs_info, objectid); root->root_key.objectid = objectid; root->root_key.type =BTRFS_ROOT_ITEM_KEY ; root->root_key.offset =0 ;
@@ -1309,12 +1308,10 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,struct btrfs_root *root;struct extent_buffer *leaf; - root =btrfs_alloc_root (fs_info,GFP_NOFS ); + root =btrfs_alloc_root (fs_info,BTRFS_TREE_LOG_OBJECTID ,GFP_NOFS );if (!root)return ERR_PTR (-ENOMEM ); -__setup_root (root, fs_info,BTRFS_TREE_LOG_OBJECTID ); - root->root_key.objectid =BTRFS_TREE_LOG_OBJECTID ; root->root_key.type =BTRFS_ROOT_ITEM_KEY ; root->root_key.offset =BTRFS_TREE_LOG_OBJECTID ;
@@ -1401,14 +1398,12 @@ static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,if (!path)return ERR_PTR (-ENOMEM ); - root =btrfs_alloc_root (fs_info,GFP_NOFS ); + root =btrfs_alloc_root (fs_info, key->objectid,GFP_NOFS );if (!root) { ret = -ENOMEM ; goto alloc_fail; } -__setup_root (root, fs_info, key->objectid); - ret =btrfs_find_root (tree_root, key, path, &root->root_item, &root->root_key);if (ret) {
@@ -2208,12 +2203,11 @@ static int btrfs_replay_log(struct btrfs_fs_info *fs_info,return -EIO ; } - log_tree_root =btrfs_alloc_root (fs_info,GFP_KERNEL ); + log_tree_root =btrfs_alloc_root (fs_info,BTRFS_TREE_LOG_OBJECTID , +GFP_KERNEL );if (!log_tree_root)return -ENOMEM ; -__setup_root (log_tree_root, fs_info,BTRFS_TREE_LOG_OBJECTID ); - log_tree_root->node =read_tree_block (fs_info, bytenr, fs_info->generation +1 , level,NULL );
@@ -2645,8 +2639,10 @@ int __cold open_ctree(struct super_block *sb,int clear_free_space_tree =0 ;int level; - tree_root = fs_info->tree_root =btrfs_alloc_root (fs_info,GFP_KERNEL ); - chunk_root = fs_info->chunk_root =btrfs_alloc_root (fs_info,GFP_KERNEL ); + tree_root = fs_info->tree_root =btrfs_alloc_root (fs_info, +BTRFS_ROOT_TREE_OBJECTID ,GFP_KERNEL ); + chunk_root = fs_info->chunk_root =btrfs_alloc_root (fs_info, +BTRFS_CHUNK_TREE_OBJECTID ,GFP_KERNEL );if (!tree_root || !chunk_root) { err = -ENOMEM ; goto fail;
@@ -2825,8 +2821,6 @@ int __cold open_ctree(struct super_block *sb, goto fail_alloc; } -__setup_root (tree_root, fs_info,BTRFS_ROOT_TREE_OBJECTID ); -invalidate_bdev (fs_devices->latest_bdev);/*
@@ -3022,8 +3016,6 @@ int __cold open_ctree(struct super_block *sb, generation =btrfs_super_chunk_root_generation (disk_super); level =btrfs_super_chunk_root_level (disk_super); -__setup_root (chunk_root, fs_info,BTRFS_CHUNK_TREE_OBJECTID ); - chunk_root->node =read_tree_block (fs_info,btrfs_super_chunk_root (disk_super), generation, level,NULL );
Signature · 1 line
2.24.1
PATCH v3 2/43 btrfs: move fs root init stuff into btrfs_init_fs_root
In reply to Josef BacikWe have a helper for reading fs roots that just reads the fs root off the disk and then sets REF_COWS and init's the inheritable flags. Move this into btrfs_init_fs_root so we can later get rid of this helper and consolidate all of the fs root reading into one helper.
--- fs/btrfs/disk-io.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)
fs/btrfs/disk-io.c +5 -6
@@ -1445,12 +1445,6 @@ struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root, root =btrfs_read_tree_root (tree_root, location);if (IS_ERR (root))return root; - -if (root->root_key.objectid !=BTRFS_TREE_LOG_OBJECTID ) { -set_bit (BTRFS_ROOT_REF_COWS , &root->state); -btrfs_check_and_init_root_item (&root->root_item); - } -return root; }
@@ -1474,6 +1468,11 @@ int btrfs_init_fs_root(struct btrfs_root *root) } root->subv_writers = writers; +if (root->root_key.objectid !=BTRFS_TREE_LOG_OBJECTID ) { +set_bit (BTRFS_ROOT_REF_COWS , &root->state); +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);
Signature · 1 line
2.24.1
PATCH v3 3/43 btrfs: make btrfs_find_orphan_roots use btrfs_get_fs_root
In reply to Josef Bacikbtrfs_find_orphan_roots has this weird thing where it looks up the root in cache to see if it is there before just reading the root. But the read it uses just reads the root, it doesn't do any of the init work, we do that by hand here. But this is unnecessary, all we really want is to see if the root still exists and add it to the dead roots list to be cleaned up, otherwise we delete the orphan item.
Fix this by just using btrfs_get_fs_root directly with check_ref set to false so we get the orphan root items. Then we just handle in cache and out of cache roots the same, add them to the dead roots list and carry on.
--- fs/btrfs/root-tree.c | 37 +++---------------------------------- 1 file changed, 3 insertions(+), 34 deletions(-)
fs/btrfs/root-tree.c +3 -34
@@ -255,25 +255,7 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info) root_key.objectid = key.offset; key.offset++; -/* -* The root might have been inserted already, as before we look -* for orphan roots, log replay might have happened, which -* triggers a transaction commit and qgroup accounting, which -* in turn reads and inserts fs roots while doing backref -* walking. -*/ - root =btrfs_lookup_fs_root (fs_info, root_key.objectid); -if (root) { -WARN_ON (!test_bit (BTRFS_ROOT_ORPHAN_ITEM_INSERTED , - &root->state)); -if (btrfs_root_refs (&root->root_item) ==0 ) { -set_bit (BTRFS_ROOT_DEAD_TREE , &root->state); -btrfs_add_dead_root (root); - } -continue ; - } - - root =btrfs_read_fs_root (tree_root, &root_key); + root =btrfs_get_fs_root (fs_info, &root_key, false); err =PTR_ERR_OR_ZERO (root);if (err && err != -ENOENT ) {break ;
@@ -300,21 +282,8 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)continue ; } - err =btrfs_init_fs_root (root); -if (err) { -btrfs_free_fs_root (root); -break ; - } - -set_bit (BTRFS_ROOT_ORPHAN_ITEM_INSERTED , &root->state); - - err =btrfs_insert_fs_root (fs_info, root); -if (err) { -BUG_ON (err == -EEXIST ); -btrfs_free_fs_root (root); -break ; - } - +WARN_ON (!test_bit (BTRFS_ROOT_ORPHAN_ITEM_INSERTED , + &root->state));if (btrfs_root_refs (&root->root_item) ==0 ) {set_bit (BTRFS_ROOT_DEAD_TREE , &root->state);btrfs_add_dead_root (root);
Signature · 1 line
2.24.1
PATCH v3 4/43 btrfs: export and use btrfs_read_tree_root
In reply to Josef Baciklog-tree uses btrfs_read_fs_root to load its log, but this just calls btrfs_read_tree_root. We don't save the log roots in our root cache, so just export this helper and use it in the logging code.
--- fs/btrfs/disk-io.c | 4 ++-- fs/btrfs/disk-io.h | 2 ++ fs/btrfs/tree-log.c | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-)
fs/btrfs/disk-io.c +2 -2
@@ -1384,8 +1384,8 @@ int btrfs_add_log_tree(struct btrfs_trans_handle *trans,return 0 ; } -static struct btrfs_root *btrfs_read_tree_root (struct btrfs_root *tree_root, -struct btrfs_key *key) +struct btrfs_root *btrfs_read_tree_root (struct btrfs_root *tree_root, +struct btrfs_key *key) {struct btrfs_root *root;struct btrfs_fs_info *fs_info = tree_root->fs_info;
fs/btrfs/disk-io.h +2 -0
@@ -58,6 +58,8 @@ struct buffer_head *btrfs_read_dev_super(struct block_device *bdev);int btrfs_read_dev_one_super (struct block_device *bdev,int copy_num,struct buffer_head **bh_ret);int btrfs_commit_super (struct btrfs_fs_info *fs_info); +struct btrfs_root *btrfs_read_tree_root (struct btrfs_root *tree_root, +struct btrfs_key *key);struct btrfs_root *btrfs_read_fs_root (struct btrfs_root *tree_root,struct btrfs_key *location);int btrfs_init_fs_root (struct btrfs_root *root);
fs/btrfs/tree-log.c +1 -1
@@ -6101,7 +6101,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)if (found_key.objectid !=BTRFS_TREE_LOG_OBJECTID )break ; - log =btrfs_read_fs_root (log_root_tree, &found_key); + log =btrfs_read_tree_root (log_root_tree, &found_key);if (IS_ERR (log)) { ret =PTR_ERR (log); btrfs_handle_fs_error(fs_info, ret,
Signature · 1 line
2.24.1
PATCH v3 5/43 btrfs: make relocation use btrfs_read_tree_root()
In reply to Josef BacikRelocation has it's special roots, we don't want to save these in the root cache either, so swap it to use btrfs_read_tree_roo(). However the reloc root does need REF_COWS set, so make sure we set it everywhere we use this helper, as it no longer does the REF_COWS setting.
--- fs/btrfs/relocation.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/btrfs/relocation.c +4 -2
@@ -1447,8 +1447,9 @@ static struct btrfs_root *create_reloc_root(struct btrfs_trans_handle *trans,BUG_ON (ret);kfree (root_item); - reloc_root =btrfs_read_fs_root (fs_info->tree_root, &root_key); + reloc_root =btrfs_read_tree_root (fs_info->tree_root, &root_key);BUG_ON (IS_ERR (reloc_root)); +set_bit (BTRFS_ROOT_REF_COWS , &reloc_root->state); reloc_root->last_trans = trans->transid;return reloc_root; }
@@ -4537,12 +4538,13 @@ int btrfs_recover_relocation(struct btrfs_root *root) key.type != BTRFS_ROOT_ITEM_KEY)break ; - reloc_root =btrfs_read_fs_root (root, &key); + reloc_root =btrfs_read_tree_root (root, &key);if (IS_ERR (reloc_root)) { err =PTR_ERR (reloc_root); goto out; } +set_bit (BTRFS_ROOT_REF_COWS , &reloc_root->state);list_add (&reloc_root->root_list, &reloc_roots);if (btrfs_root_refs (&reloc_root->root_item) >0 ) {
Signature · 1 line
2.24.1
PATCH v3 6/43 btrfs: kill btrfs_read_fs_root
In reply to Josef BacikAll helpers should either be using btrfs_get_fs_root() or btrfs_read_tree_root().
--- fs/btrfs/disk-io.c | 13 +------------ fs/btrfs/disk-io.h | 2 -- 2 files changed, 1 insertion(+), 14 deletions(-)
fs/btrfs/disk-io.c +1 -12
@@ -1437,17 +1437,6 @@ struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root, goto out; } -struct btrfs_root *btrfs_read_fs_root (struct btrfs_root *tree_root, -struct btrfs_key *location) -{ -struct btrfs_root *root; - - root =btrfs_read_tree_root (tree_root, location); -if (IS_ERR (root)) -return root; -return root; -} -int btrfs_init_fs_root (struct btrfs_root *root) {int ret;
@@ -1568,7 +1557,7 @@ struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,return root; } - root =btrfs_read_fs_root (fs_info->tree_root, location); + root =btrfs_read_tree_root (fs_info->tree_root, location);if (IS_ERR (root))return root;
fs/btrfs/disk-io.h +0 -2
@@ -60,8 +60,6 @@ int btrfs_read_dev_one_super(struct block_device *bdev, int copy_num,int btrfs_commit_super (struct btrfs_fs_info *fs_info);struct btrfs_root *btrfs_read_tree_root (struct btrfs_root *tree_root,struct btrfs_key *key); -struct btrfs_root *btrfs_read_fs_root (struct btrfs_root *tree_root, -struct btrfs_key *location);int btrfs_init_fs_root (struct btrfs_root *root);struct btrfs_root *btrfs_lookup_fs_root (struct btrfs_fs_info *fs_info,u64 root_id);
Signature · 1 line
2.24.1
PATCH v3 7/43 btrfs: kill the btrfs_read_fs_root_no_name helper
In reply to Josef BacikAll this does is call btrfs_get_fs_root() with check_ref == true. Just use btrfs_get_fs_root() so we don't have a bunch of different helpers that do the same thing.
--- fs/btrfs/disk-io.c | 2 +- fs/btrfs/disk-io.h | 6 ------ fs/btrfs/export.c | 2 +- fs/btrfs/file.c | 2 +- fs/btrfs/inode.c | 2 +- fs/btrfs/ioctl.c | 12 ++++++------ fs/btrfs/scrub.c | 2 +- fs/btrfs/send.c | 4 ++-- fs/btrfs/super.c | 2 +- fs/btrfs/transaction.c | 2 +- fs/btrfs/tree-log.c | 2 +- fs/btrfs/volumes.c | 2 +- 12 files changed, 17 insertions(+), 23 deletions(-)
fs/btrfs/disk-io.c +1 -1
@@ -3176,7 +3176,7 @@ int __cold open_ctree(struct super_block *sb, location.type =BTRFS_ROOT_ITEM_KEY ; location.offset =0 ; - fs_info->fs_root =btrfs_read_fs_root_no_name (fs_info, &location); + fs_info->fs_root =btrfs_get_fs_root (fs_info, &location, true);if (IS_ERR (fs_info->fs_root)) { err =PTR_ERR (fs_info->fs_root);btrfs_warn (fs_info,"failed to read fs tree: %d" , err);
fs/btrfs/disk-io.h +0 -6
@@ -70,12 +70,6 @@ void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info);struct btrfs_root *btrfs_get_fs_root (struct btrfs_fs_info *fs_info,struct btrfs_key *key,bool check_ref); -static inline struct btrfs_root * -btrfs_read_fs_root_no_name (struct btrfs_fs_info *fs_info, -struct btrfs_key *location) -{ -return btrfs_get_fs_root (fs_info, location, true); -}int btrfs_cleanup_fs_roots (struct btrfs_fs_info *fs_info);void btrfs_btree_balance_dirty (struct btrfs_fs_info *fs_info);
fs/btrfs/export.c +1 -1
@@ -77,7 +77,7 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, index =srcu_read_lock (&fs_info->subvol_srcu); - root =btrfs_read_fs_root_no_name (fs_info, &key); + root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (root)) { err =PTR_ERR (root); goto fail;
fs/btrfs/file.c +1 -1
@@ -287,7 +287,7 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, index =srcu_read_lock (&fs_info->subvol_srcu); - inode_root =btrfs_read_fs_root_no_name (fs_info, &key); + inode_root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (inode_root)) { ret =PTR_ERR (inode_root); goto cleanup;
fs/btrfs/inode.c +1 -1
@@ -5021,7 +5021,7 @@ static int fixup_tree_root_location(struct btrfs_fs_info *fs_info,btrfs_release_path (path); - new_root =btrfs_read_fs_root_no_name (fs_info, location); + new_root =btrfs_get_fs_root (fs_info, location, true);if (IS_ERR (new_root)) { err =PTR_ERR (new_root); goto out;
fs/btrfs/ioctl.c +6 -6
@@ -666,7 +666,7 @@ static noinline int create_subvol(struct inode *dir, goto fail; key.offset = (u64)-1 ; - new_root =btrfs_read_fs_root_no_name (fs_info, &key); + new_root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (new_root)) { ret =PTR_ERR (new_root);btrfs_abort_transaction (trans, ret);
@@ -2179,7 +2179,7 @@ static noinline int search_ioctl(struct inode *inode, key.objectid = sk->tree_id; key.type =BTRFS_ROOT_ITEM_KEY ; key.offset = (u64)-1 ; - root =btrfs_read_fs_root_no_name (info, &key); + root =btrfs_get_fs_root (info, &key, true);if (IS_ERR (root)) {btrfs_free_path (path);return PTR_ERR (root);
@@ -2314,7 +2314,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, key.objectid = tree_id; key.type =BTRFS_ROOT_ITEM_KEY ; key.offset = (u64)-1 ; - root =btrfs_read_fs_root_no_name (info, &key); + root =btrfs_get_fs_root (info, &key, true);if (IS_ERR (root)) { ret =PTR_ERR (root); goto out;
@@ -2408,7 +2408,7 @@ static int btrfs_search_path_in_tree_user(struct inode *inode, key.objectid = treeid; key.type =BTRFS_ROOT_ITEM_KEY ; key.offset = (u64)-1 ; - root =btrfs_read_fs_root_no_name (fs_info, &key); + root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (root)) { ret =PTR_ERR (root); goto out;
@@ -2653,7 +2653,7 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp) key.objectid =BTRFS_I (inode)->root->root_key.objectid; key.type =BTRFS_ROOT_ITEM_KEY ; key.offset = (u64)-1 ; - root =btrfs_read_fs_root_no_name (fs_info, &key); + root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (root)) { ret =PTR_ERR (root); goto out;
@@ -3980,7 +3980,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp) location.type =BTRFS_ROOT_ITEM_KEY ; location.offset = (u64)-1 ; - new_root =btrfs_read_fs_root_no_name (fs_info, &location); + new_root =btrfs_get_fs_root (fs_info, &location, true);if (IS_ERR (new_root)) { ret =PTR_ERR (new_root); goto out;
fs/btrfs/scrub.c +1 -1
@@ -653,7 +653,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, root_key.objectid = root; root_key.type =BTRFS_ROOT_ITEM_KEY ; root_key.offset = (u64)-1 ; - local_root =btrfs_read_fs_root_no_name (fs_info, &root_key); + local_root =btrfs_get_fs_root (fs_info, &root_key, true);if (IS_ERR (local_root)) { ret =PTR_ERR (local_root); goto err;
fs/btrfs/send.c +2 -2
@@ -7194,7 +7194,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) index =srcu_read_lock (&fs_info->subvol_srcu); - clone_root =btrfs_read_fs_root_no_name (fs_info, &key); + clone_root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (clone_root)) {srcu_read_unlock (&fs_info->subvol_srcu, index); ret =PTR_ERR (clone_root);
@@ -7233,7 +7233,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) index =srcu_read_lock (&fs_info->subvol_srcu); - sctx->parent_root =btrfs_read_fs_root_no_name (fs_info, &key); + sctx->parent_root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (sctx->parent_root)) {srcu_read_unlock (&fs_info->subvol_srcu, index); ret =PTR_ERR (sctx->parent_root);
fs/btrfs/super.c +1 -1
@@ -1096,7 +1096,7 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, key.objectid = subvol_objectid; key.type =BTRFS_ROOT_ITEM_KEY ; key.offset = (u64)-1 ; - fs_root =btrfs_read_fs_root_no_name (fs_info, &key); + fs_root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (fs_root)) { ret =PTR_ERR (fs_root); goto err;
fs/btrfs/transaction.c +1 -1
@@ -1631,7 +1631,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, } key.offset = (u64)-1 ; - pending->snap =btrfs_read_fs_root_no_name (fs_info, &key); + pending->snap =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (pending->snap)) { ret =PTR_ERR (pending->snap);btrfs_abort_transaction (trans, ret);
fs/btrfs/tree-log.c +1 -1
@@ -6113,7 +6113,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) tmp_key.type =BTRFS_ROOT_ITEM_KEY ; tmp_key.offset = (u64)-1 ; - wc.replay_dest =btrfs_read_fs_root_no_name (fs_info, &tmp_key); + wc.replay_dest =btrfs_get_fs_root (fs_info, &tmp_key, true);if (IS_ERR (wc.replay_dest)) { ret =PTR_ERR (wc.replay_dest);
fs/btrfs/volumes.c +1 -1
@@ -4375,7 +4375,7 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info, key.objectid = subid; key.type =BTRFS_ROOT_ITEM_KEY ; key.offset = (u64)-1 ; - subvol_root =btrfs_read_fs_root_no_name (fs_info, &key); + subvol_root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (subvol_root)) { ret =PTR_ERR (subvol_root);if (ret == -ENOENT )
Signature · 1 line
2.24.1
PATCH v3 8/43 btrfs: make the fs root init functions static
In reply to Josef BacikNow that the orphan cleanup stuff doesn't use this directly we can just make them static.
--- fs/btrfs/disk-io.c | 6 +++--- fs/btrfs/disk-io.h | 3 --- 2 files changed, 3 insertions(+), 6 deletions(-)
fs/btrfs/disk-io.c +3 -3
@@ -1437,7 +1437,7 @@ struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root, goto out; } -int btrfs_init_fs_root (struct btrfs_root *root) +static int btrfs_init_fs_root (struct btrfs_root *root) {int ret;struct btrfs_subvolume_writers *writers;
@@ -1488,8 +1488,8 @@ int btrfs_init_fs_root(struct btrfs_root *root)return ret; } -struct btrfs_root *btrfs_lookup_fs_root (struct btrfs_fs_info *fs_info, -u64 root_id) +static struct btrfs_root *btrfs_lookup_fs_root (struct btrfs_fs_info *fs_info, +u64 root_id) {struct btrfs_root *root;
fs/btrfs/disk-io.h +0 -3
@@ -60,9 +60,6 @@ int btrfs_read_dev_one_super(struct block_device *bdev, int copy_num,int btrfs_commit_super (struct btrfs_fs_info *fs_info);struct btrfs_root *btrfs_read_tree_root (struct btrfs_root *tree_root,struct btrfs_key *key); -int btrfs_init_fs_root (struct btrfs_root *root); -struct btrfs_root *btrfs_lookup_fs_root (struct btrfs_fs_info *fs_info, -u64 root_id);int btrfs_insert_fs_root (struct btrfs_fs_info *fs_info,struct btrfs_root *root);void btrfs_free_fs_roots (struct btrfs_fs_info *fs_info);
Signature · 1 line
2.24.1
PATCH v3 9/43 btrfs: handle NULL roots in btrfs_put/btrfs_grab_fs_root
In reply to Josef BacikWe want to use this for dropping all roots, and in some error cases we may not have a root, so handle this to make the cleanup code easier. Make btrfs_grab_fs_root the same so we can use it in cases where the root may not exist (like the quota root).
--- fs/btrfs/disk-io.h | 4 ++++ 1 file changed, 4 insertions(+)
fs/btrfs/disk-io.h +4 -0
@@ -88,6 +88,8 @@ struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info);*/ static inline struct btrfs_root *btrfs_grab_fs_root (struct btrfs_root *root) { +if (!root) +return NULL ;if (refcount_inc_not_zero (&root->refs))return root;return NULL ;
@@ -95,6 +97,8 @@ static inline struct btrfs_root *btrfs_grab_fs_root(struct btrfs_root *root)static inline void btrfs_put_fs_root (struct btrfs_root *root) { +if (!root) +return ;if (refcount_dec_and_test (&root->refs))kfree (root); }
Signature · 1 line
2.24.1
PATCH v3 10/43 btrfs: hold a ref on fs roots while they're in the radix tree
In reply to Josef BacikIf we're sitting in the radix tree, we should probably have a ref for the radix tree. Grab a ref on the root when we insert it, and drop it when it gets deleted.
--- fs/btrfs/disk-io.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
fs/btrfs/disk-io.c +5 -1
@@ -1513,8 +1513,10 @@ int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info, ret =radix_tree_insert (&fs_info->fs_roots_radix, (unsigned long )root->root_key.objectid, root); -if (ret ==0 ) +if (ret ==0 ) { +btrfs_grab_fs_root (root);set_bit (BTRFS_ROOT_IN_RADIX , &root->state); + }spin_unlock (&fs_info->fs_roots_radix_lock);radix_tree_preload_end ();
@@ -3814,6 +3816,8 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,spin_lock (&fs_info->fs_roots_radix_lock);radix_tree_delete (&fs_info->fs_roots_radix, (unsigned long )root->root_key.objectid); +if (test_and_clear_bit (BTRFS_ROOT_IN_RADIX , &root->state)) +btrfs_put_fs_root (root);spin_unlock (&fs_info->fs_roots_radix_lock);if (btrfs_root_refs (&root->root_item) ==0 )
Signature · 1 line
2.24.1
PATCH v3 11/43 btrfs: hold a ref on the root in resolve_indirect_ref
In reply to Josef BacikWe're looking up a random root, we need to hold a ref on it while we're using it.
--- fs/btrfs/backref.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
fs/btrfs/backref.c +9 -1
@@ -524,7 +524,13 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info,if (IS_ERR (root)) {srcu_read_unlock (&fs_info->subvol_srcu, index); ret =PTR_ERR (root); - goto out; + goto out_free; + } + +if (!btrfs_grab_fs_root (root)) { +srcu_read_unlock (&fs_info->subvol_srcu, index); + ret = -ENOENT ; + goto out_free; }if (btrfs_is_testing (fs_info)) {
@@ -577,6 +583,8 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, ret =add_all_parents (root, path, parents, ref, level, time_seq, extent_item_pos, total_refs, ignore_offset); out: +btrfs_put_fs_root (root); +out_free: path->lowest_level =0 ;btrfs_release_path (path);return ret;
Signature · 1 line
2.24.1
PATCH v3 12/43 btrfs: hold a root ref in btrfs_get_dentry
In reply to Josef BacikLooking up the inode we need to search the root, make sure we hold a reference on that root while we're doing the lookup.
--- fs/btrfs/export.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/btrfs/export.c +5 -0
@@ -82,12 +82,17 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, err =PTR_ERR (root); goto fail; } +if (!btrfs_grab_fs_root (root)) { + err = -ENOENT ; + goto fail; + } key.objectid = objectid; key.type =BTRFS_INODE_ITEM_KEY ; key.offset =0 ; inode =btrfs_iget (sb, &key, root); +btrfs_put_fs_root (root);if (IS_ERR (inode)) { err =PTR_ERR (inode); goto fail;
Signature · 1 line
2.24.1
PATCH v3 13/43 btrfs: hold a ref on the root in __btrfs_run_defrag_inode
In reply to Josef BacikWe are looking up an arbitrary inode, we need to hold a ref on the root while we're doing this.
--- fs/btrfs/file.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/btrfs/file.c +5 -0
@@ -292,11 +292,16 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, ret =PTR_ERR (inode_root); goto cleanup; } +if (!btrfs_grab_fs_root (inode_root)) { + ret = -ENOENT ; + goto cleanup; + } key.objectid = defrag->ino; key.type =BTRFS_INODE_ITEM_KEY ; key.offset =0 ; inode =btrfs_iget (fs_info->sb, &key, inode_root); +btrfs_put_fs_root (inode_root);if (IS_ERR (inode)) { ret =PTR_ERR (inode); goto cleanup;
Signature · 1 line
2.24.1
PATCH v3 14/43 btrfs: hold a ref on the root in fixup_tree_root_location
In reply to Josef BacikLooking up the inode from an arbitrary tree means we need to hold a ref on that root.
--- fs/btrfs/inode.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/btrfs/inode.c +6 -0
@@ -5026,6 +5026,10 @@ static int fixup_tree_root_location(struct btrfs_fs_info *fs_info, err =PTR_ERR (new_root); goto out; } +if (!btrfs_grab_fs_root (new_root)) { + err = -ENOENT ; + goto out; + } *sub_root = new_root; location->objectid =btrfs_root_dirid (&new_root->root_item);
@@ -5268,6 +5272,8 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry) }else { inode =btrfs_iget (dir->i_sb, &location, sub_root); } +if (root != sub_root) +btrfs_put_fs_root (sub_root);srcu_read_unlock (&fs_info->subvol_srcu, index);if (!IS_ERR (inode) && root != sub_root) {
Signature · 1 line
2.24.1
PATCH v3 15/43 btrfs: hold a ref on the root in create_subvol
In reply to Josef BacikWe're creating the new root here, but we should hold the ref until after we've initialized the inode for it.
--- fs/btrfs/ioctl.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/btrfs/ioctl.c +6 -0
@@ -672,10 +672,16 @@ static noinline int create_subvol(struct inode *dir,btrfs_abort_transaction (trans, ret); goto fail; } +if (!btrfs_grab_fs_root (new_root)) { + ret = -ENOENT ; +btrfs_abort_transaction (trans, ret); + goto fail; + }btrfs_record_root_in_trans (trans, new_root); ret =btrfs_create_subvol_root (trans, new_root, root, new_dirid); +btrfs_put_fs_root (new_root);if (ret) {/* We potentially lose an unused inode item here */ btrfs_abort_transaction (trans, ret);
Signature · 1 line
2.24.1
PATCH v3 16/43 btrfs: hold a ref on the root in search_ioctl
In reply to Josef BacikWe lookup a arbitrary fs root, we need to hold a ref on that root. If we're using our own inodes root then grab a ref on that as well to make the cleanup easier.
--- fs/btrfs/ioctl.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
fs/btrfs/ioctl.c +6 -1
@@ -2180,7 +2180,7 @@ static noinline int search_ioctl(struct inode *inode,if (sk->tree_id ==0 ) {/* search the root of the inode that was passed */ - root =BTRFS_I (inode)->root; + root =btrfs_grab_fs_root (BTRFS_I (inode)->root); }else { key.objectid = sk->tree_id; key.type =BTRFS_ROOT_ITEM_KEY ;
@@ -2190,6 +2190,10 @@ static noinline int search_ioctl(struct inode *inode,btrfs_free_path (path);return PTR_ERR (root); } +if (!btrfs_grab_fs_root (root)) { +btrfs_free_path (path); +return -ENOENT ; + } } key.objectid = sk->min_objectid;
@@ -2214,6 +2218,7 @@ static noinline int search_ioctl(struct inode *inode, ret =0 ; err: sk->nr_items = num_found; +btrfs_put_fs_root (root);btrfs_free_path (path);return ret; }
Signature · 1 line
2.24.1
PATCH v3 17/43 btrfs: hold a ref on the root in btrfs_search_path_in_tree
In reply to Josef BacikWe look up an arbitrary fs root, we need to hold a ref on it while we're doing our search.
--- fs/btrfs/ioctl.c | 8 ++++++++ 1 file changed, 8 insertions(+)
fs/btrfs/ioctl.c +8 -0
@@ -2328,6 +2328,12 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, root =btrfs_get_fs_root (info, &key, true);if (IS_ERR (root)) { ret =PTR_ERR (root); + root =NULL ; + goto out; + } +if (!btrfs_grab_fs_root (root)) { + ret = -ENOENT ; + root =NULL ; goto out; }
@@ -2378,6 +2384,8 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, name[total_len] ='\0' ; ret =0 ; out: +if (root) +btrfs_put_fs_root (root);btrfs_free_path (path);return ret; }
Signature · 1 line
2.24.1
PATCH v3 18/43 btrfs: hold a ref on the root in btrfs_search_path_in_tree_user
In reply to Josef BacikWe can wander into a different root, so grab a ref on the root we look up. Later on we make root = fs_info->tree_root so we need this separate out label to make sure we do the right cleanup only in the case we're looking up a different root.
--- fs/btrfs/ioctl.c | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-)
fs/btrfs/ioctl.c +18 -10
@@ -2432,6 +2432,10 @@ static int btrfs_search_path_in_tree_user(struct inode *inode, ret =PTR_ERR (root); goto out; } +if (!btrfs_grab_fs_root (root)) { + ret = -ENOENT ; + goto out; + } key.objectid = dirid; key.type =BTRFS_INODE_REF_KEY ;
@@ -2439,15 +2443,15 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,while (1 ) { ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 );if (ret <0 ) { - goto out; + goto out_put; }else if (ret >0 ) { ret =btrfs_previous_item (root, path, dirid,BTRFS_INODE_REF_KEY );if (ret <0 ) { - goto out; + goto out_put; }else if (ret >0 ) { ret = -ENOENT ; - goto out; + goto out_put; } }
@@ -2461,7 +2465,7 @@ static int btrfs_search_path_in_tree_user(struct inode *inode, total_len += len +1 ;if (ptr < args->path) { ret = -ENAMETOOLONG ; - goto out; + goto out_put; } *(ptr + len) ='/' ;
@@ -2472,10 +2476,10 @@ static int btrfs_search_path_in_tree_user(struct inode *inode, ret =btrfs_previous_item (root, path, dirid,BTRFS_INODE_ITEM_KEY );if (ret <0 ) { - goto out; + goto out_put; }else if (ret >0 ) { ret = -ENOENT ; - goto out; + goto out_put; } leaf = path->nodes[0 ];
@@ -2483,26 +2487,26 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,btrfs_item_key_to_cpu (leaf, &key2, slot);if (key2.objectid != dirid) { ret = -ENOENT ; - goto out; + goto out_put; } temp_inode =btrfs_iget (sb, &key2, root);if (IS_ERR (temp_inode)) { ret =PTR_ERR (temp_inode); - goto out; + goto out_put; } ret =inode_permission (temp_inode,MAY_READ |MAY_EXEC );iput (temp_inode);if (ret) { ret = -EACCES ; - goto out; + goto out_put; }if (key.offset == upper_limit.objectid)break ;if (key.objectid ==BTRFS_FIRST_FREE_OBJECTID ) { ret = -EACCES ; - goto out; + goto out_put; }btrfs_release_path (path);
@@ -2513,6 +2517,7 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,memmove (args->path, ptr, total_len); args->path[total_len] ='\0' ; +btrfs_put_fs_root (root);btrfs_release_path (path); }
@@ -2551,6 +2556,9 @@ static int btrfs_search_path_in_tree_user(struct inode *inode, out:btrfs_free_path (path);return ret; +out_put: +btrfs_put_fs_root (root); + goto out; } static noinline int btrfs_ioctl_ino_lookup(struct file *file,
Signature · 1 line
2.24.1
PATCH v3 19/43 btrfs: hold a ref on the root in btrfs_ioctl_get_subvol_info
In reply to Josef BacikWe look up whatever root userspace has given us, we need to hold a ref throughout this operation.
--- fs/btrfs/ioctl.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/btrfs/ioctl.c +6 -0
@@ -2683,6 +2683,10 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp) root =btrfs_get_fs_root (fs_info, &key, true);if (IS_ERR (root)) { ret =PTR_ERR (root); + goto out_free; + } +if (!btrfs_grab_fs_root (root)) { + ret = -ENOENT ; goto out; } root_item = &root->root_item;
@@ -2760,6 +2764,8 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp) ret = -EFAULT ; out: +btrfs_put_fs_root (root); +out_free:btrfs_free_path (path);kzfree (subvol_info);return ret;
Signature · 1 line
2.24.1
PATCH v3 20/43 btrfs: hold ref on root in btrfs_ioctl_default_subvol
In reply to Josef BacikWe look up an arbitrary fs root here, we need to hold a ref on the root for the duration.
--- fs/btrfs/ioctl.c | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-)
fs/btrfs/ioctl.c +14 -8
@@ -3987,7 +3987,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)struct btrfs_root *new_root;struct btrfs_dir_item *di;struct btrfs_trans_handle *trans; -struct btrfs_path *path; +struct btrfs_path *path =NULL ;struct btrfs_key location;struct btrfs_disk_key disk_key;u64 objectid =0 ;
@@ -4018,44 +4018,50 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp) ret =PTR_ERR (new_root); goto out; } -if (!is_fstree (new_root->root_key.objectid)) { +if (!btrfs_grab_fs_root (root)) { ret = -ENOENT ; goto out; } +if (!is_fstree (new_root->root_key.objectid)) { + ret = -ENOENT ; + goto out_free; + } path =btrfs_alloc_path ();if (!path) { ret = -ENOMEM ; - goto out; + goto out_free; } path->leave_spinning =1 ; trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) { -btrfs_free_path (path); ret =PTR_ERR (trans); - goto out; + goto out_free; } dir_id =btrfs_super_root_dir (fs_info->super_copy); di =btrfs_lookup_dir_item (trans, fs_info->tree_root, path, dir_id,"default" ,7 ,1 );if (IS_ERR_OR_NULL (di)) { -btrfs_free_path (path); +btrfs_release_path (path);btrfs_end_transaction (trans);btrfs_err (fs_info,"Umm, you don't have the default diritem, this isn't going to work" ); ret = -ENOENT ; - goto out; + goto out_free; }btrfs_cpu_key_to_disk (&disk_key, &new_root->root_key);btrfs_set_dir_item_key (path->nodes[0 ], di, &disk_key);btrfs_mark_buffer_dirty (path->nodes[0 ]); -btrfs_free_path (path); +btrfs_release_path (path);btrfs_set_fs_incompat (fs_info,DEFAULT_SUBVOL );btrfs_end_transaction (trans); +out_free: +btrfs_put_fs_root (new_root); +btrfs_free_path (path); out:mnt_drop_write_file (file);return ret;
Signature · 1 line
2.24.1
PATCH v3 21/43 btrfs: hold a ref on the root in build_backref_tree
In reply to Josef BacikThis is trickier than the previous conversions. We have backref_node's that need to hold onto their root for their lifetime. Do the read of the root and grab the ref. If at any point we don't use the root we discard it, however if we use it in our backref node we don't free it until we free the backref node. Any time we switch the root's for the backref node we need to drop our ref on the old root and grab the ref on the new root, and if we dupe a node we need to get a ref on the root there as well.
--- fs/btrfs/relocation.c | 37 +++++++++++++++++++++++++++++-------- 1 file changed, 29 insertions(+), 8 deletions(-)
fs/btrfs/relocation.c +29 -8
@@ -256,6 +256,8 @@ static void free_backref_node(struct backref_cache *cache, {if (node) { cache->nr_nodes--; +if (node->root) +btrfs_put_fs_root (node->root);kfree (node); } }
@@ -891,6 +893,10 @@ struct backref_node *build_backref_tree(struct reloc_control *rc, err =PTR_ERR (root); goto out; } +if (!btrfs_grab_fs_root (root)) { + err = -ENOENT ; + goto out; + }if (!test_bit (BTRFS_ROOT_REF_COWS , &root->state)) cur->cowonly =1 ;
@@ -899,10 +905,12 @@ struct backref_node *build_backref_tree(struct reloc_control *rc,/* tree root */ ASSERT (btrfs_root_bytenr (&root->root_item) == cur->bytenr); -if (should_ignore_root (root)) +if (should_ignore_root (root)) { +btrfs_put_fs_root (root);list_add (&cur->list, &useless); -else + }else { cur->root = root; + }break ; }
@@ -915,6 +923,7 @@ struct backref_node *build_backref_tree(struct reloc_control *rc, ret =btrfs_search_slot (NULL , root, node_key, path2,0 ,0 ); path2->lowest_level =0 ;if (ret <0 ) { +btrfs_put_fs_root (root); err = ret; goto out; }
@@ -930,6 +939,7 @@ struct backref_node *build_backref_tree(struct reloc_control *rc, root->root_key.objectid, node_key->objectid, node_key->type, node_key->offset); +btrfs_put_fs_root (root); err = -ENOENT ; goto out; }
@@ -941,15 +951,18 @@ struct backref_node *build_backref_tree(struct reloc_control *rc,if (!path2->nodes[level]) {ASSERT (btrfs_root_bytenr (&root->root_item) == lower->bytenr); -if (should_ignore_root (root)) +if (should_ignore_root (root)) { +btrfs_put_fs_root (root);list_add (&lower->list, &useless); -else + }else { lower->root = root; + }break ; } edge =alloc_backref_edge (cache);if (!edge) { +btrfs_put_fs_root (root); err = -ENOMEM ; goto out; }
@@ -959,6 +972,7 @@ struct backref_node *build_backref_tree(struct reloc_control *rc,if (!rb_node) { upper =alloc_backref_node (cache);if (!upper) { +btrfs_put_fs_root (root);free_backref_edge (cache, edge); err = -ENOMEM ; goto out;
@@ -1006,8 +1020,10 @@ struct backref_node *build_backref_tree(struct reloc_control *rc, edge->node[LOWER ] = lower; edge->node[UPPER ] = upper; -if (rb_node) +if (rb_node) { +btrfs_put_fs_root (root);break ; + } lower = upper; upper =NULL ; }
@@ -1244,7 +1260,8 @@ static int clone_backref_node(struct btrfs_trans_handle *trans, new_node->level = node->level; new_node->lowest = node->lowest; new_node->checked =1 ; - new_node->root = dest; + new_node->root =btrfs_grab_fs_root (dest); +ASSERT (new_node->root);if (!node->lowest) {list_for_each_entry (edge, &node->lower, list[UPPER ]) {
@@ -2622,7 +2639,9 @@ struct btrfs_root *select_reloc_root(struct btrfs_trans_handle *trans,BUG_ON (next->new_bytenr);BUG_ON (!list_empty (&next->list)); next->new_bytenr = root->node->start; - next->root = root; +btrfs_put_fs_root (next->root); + next->root =btrfs_grab_fs_root (root); +ASSERT (next->root);list_add_tail (&next->list, &rc->backref_cache.changed);__mark_block_processed (rc, next);
@@ -3094,7 +3113,9 @@ static int relocate_tree_block(struct btrfs_trans_handle *trans,btrfs_record_root_in_trans (trans, root); root = root->reloc_root; node->new_bytenr = root->node->start; - node->root = root; +btrfs_put_fs_root (node->root); + node->root =btrfs_grab_fs_root (root); +ASSERT (node->root);list_add_tail (&node->list, &rc->backref_cache.changed); }else { path->lowest_level = node->level;
Signature · 1 line
2.24.1
PATCH v3 22/43 btrfs: hold a ref on the root in prepare_to_merge
In reply to Josef BacikWe look up the reloc roots corresponding root, we need to hold a ref on that root.
--- fs/btrfs/relocation.c | 3 +++ 1 file changed, 3 insertions(+)
fs/btrfs/relocation.c +3 -0
@@ -2474,6 +2474,8 @@ int prepare_to_merge(struct reloc_control *rc, int err)list_del_init (&reloc_root->root_list); root =read_fs_root (fs_info, reloc_root->root_key.offset); +if (!btrfs_grab_fs_root (root)) +BUG ();BUG_ON (IS_ERR (root));BUG_ON (root->reloc_root != reloc_root);
@@ -2486,6 +2488,7 @@ int prepare_to_merge(struct reloc_control *rc, int err)btrfs_update_reloc_root (trans, root);list_add (&reloc_root->root_list, &reloc_roots); +btrfs_put_fs_root (root); }list_splice (&reloc_roots, &rc->reloc_roots);
Signature · 1 line
2.24.1
PATCH v3 23/43 btrfs: hold a ref on the root in merge_reloc_roots
In reply to Josef BacikWe look up the corresponding root for the reloc root, we need to hold a ref while we're messing with it.
--- fs/btrfs/relocation.c | 3 +++ 1 file changed, 3 insertions(+)
fs/btrfs/relocation.c +3 -0
@@ -2546,10 +2546,13 @@ void merge_reloc_roots(struct reloc_control *rc)if (btrfs_root_refs (&reloc_root->root_item) >0 ) { root =read_fs_root (fs_info, reloc_root->root_key.offset); +if (!btrfs_grab_fs_root (root)) +BUG ();BUG_ON (IS_ERR (root));BUG_ON (root->reloc_root != reloc_root); ret =merge_reloc_root (rc, root); +btrfs_put_fs_root (root);if (ret) {if (list_empty (&reloc_root->root_list)) list_add_tail(&reloc_root->root_list,
Signature · 1 line
2.24.1
PATCH v3 24/43 btrfs: hold a ref on the root in record_reloc_root_in_trans
In reply to Josef BacikWe are recording this root in the transaction, so we need to hold a ref on it until we do that.
--- fs/btrfs/relocation.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
fs/btrfs/relocation.c +6 -1
@@ -2604,15 +2604,20 @@ static int record_reloc_root_in_trans(struct btrfs_trans_handle *trans, {struct btrfs_fs_info *fs_info = reloc_root->fs_info;struct btrfs_root *root; +int ret;if (reloc_root->last_trans == trans->transid)return 0 ; root =read_fs_root (fs_info, reloc_root->root_key.offset); +if (!btrfs_grab_fs_root (root)) +BUG ();BUG_ON (IS_ERR (root));BUG_ON (root->reloc_root != reloc_root); + ret =btrfs_record_root_in_trans (trans, root); +btrfs_put_fs_root (root); -return btrfs_record_root_in_trans (trans, root); +return ret; } static noinline_for_stack
Signature · 1 line
2.24.1
PATCH v3 25/43 btrfs: hold a ref on the root in find_data_references
In reply to Josef BacikWe're looking up the data references for the bytenr in a root, we need to hold a ref on that root while we're doing that.
--- fs/btrfs/relocation.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
fs/btrfs/relocation.c +7 -1
@@ -3708,7 +3708,11 @@ static int find_data_references(struct reloc_control *rc, root =read_fs_root (fs_info, ref_root);if (IS_ERR (root)) { err =PTR_ERR (root); - goto out; + goto out_free; + } +if (!btrfs_grab_fs_root (root)) { + err = -ENOENT ; + goto out_free; } key.objectid = ref_objectid;
@@ -3821,6 +3825,8 @@ static int find_data_references(struct reloc_control *rc, } out: +btrfs_put_fs_root (root); +out_free:btrfs_free_path (path);return err; }
Signature · 1 line
2.24.1
PATCH v3 26/43 btrfs: hold a ref on the root in create_reloc_inode
In reply to Josef BacikWe're creating a reloc inode in the data reloc tree, we need to hold a ref on the root while we're doing that.
--- fs/btrfs/relocation.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
fs/btrfs/relocation.c +6 -1
@@ -4308,10 +4308,14 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info, root =read_fs_root (fs_info,BTRFS_DATA_RELOC_TREE_OBJECTID );if (IS_ERR (root))return ERR_CAST (root); +if (!btrfs_grab_fs_root (root)) +return ERR_PTR (-ENOENT ); trans =btrfs_start_transaction (root,6 ); -if (IS_ERR (trans)) +if (IS_ERR (trans)) { +btrfs_put_fs_root (root);return ERR_CAST (trans); + } err =btrfs_find_free_objectid (root, &objectid);if (err)
@@ -4329,6 +4333,7 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info, err =btrfs_orphan_add (trans,BTRFS_I (inode)); out: +btrfs_put_fs_root (root);btrfs_end_transaction (trans);btrfs_btree_balance_dirty (fs_info);if (err) {
Signature · 1 line
2.24.1
PATCH v3 27/43 btrfs: hold a ref on the root in btrfs_recover_relocation
In reply to Josef BacikWe look up the fs root in various places in here when recovering from a crashed relcoation. Make sure we hold a ref on the root whenever we look them up.
--- fs/btrfs/relocation.c | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-)
fs/btrfs/relocation.c +18 -3
@@ -4593,6 +4593,10 @@ int btrfs_recover_relocation(struct btrfs_root *root)if (btrfs_root_refs (&reloc_root->root_item) >0 ) { fs_root =read_fs_root (fs_info, reloc_root->root_key.offset); +if (!btrfs_grab_fs_root (fs_root)) { + err = -ENOENT ; + goto out; + }if (IS_ERR (fs_root)) { ret =PTR_ERR (fs_root);if (ret != -ENOENT ) {
@@ -4604,6 +4608,8 @@ int btrfs_recover_relocation(struct btrfs_root *root) err = ret; goto out; } + }else { +btrfs_put_fs_root (fs_root); } }
@@ -4653,10 +4659,15 @@ int btrfs_recover_relocation(struct btrfs_root *root)list_add_tail (&reloc_root->root_list, &reloc_roots); goto out_free; } +if (!btrfs_grab_fs_root (fs_root)) { + err = -ENOENT ; + goto out_free; + } err =__add_reloc_root (reloc_root);BUG_ON (err <0 );/* -ENOMEM or logic error */ fs_root->reloc_root = reloc_root; +btrfs_put_fs_root (fs_root); } err =btrfs_commit_transaction (trans);
@@ -4688,10 +4699,14 @@ int btrfs_recover_relocation(struct btrfs_root *root)if (err ==0 ) {/* cleanup orphan inode in data relocation tree */ fs_root =read_fs_root (fs_info,BTRFS_DATA_RELOC_TREE_OBJECTID ); -if (IS_ERR (fs_root)) +if (IS_ERR (fs_root)) { err =PTR_ERR (fs_root); -else - err =btrfs_orphan_cleanup (fs_root); + }else { +if (btrfs_grab_fs_root (fs_root)) { + err =btrfs_orphan_cleanup (fs_root); +btrfs_put_fs_root (fs_root); + } + } }return err; }
Signature · 1 line
2.24.1
PATCH v3 28/43 btrfs: push grab_fs_root into read_fs_root
In reply to Josef BacikAll of relocation uses read_fs_root to lookup fs roots, so push the btrfs_grab_fs_root() up into that helper and remove the individual calls.
--- fs/btrfs/relocation.c | 38 +++++++++----------------------------- 1 file changed, 9 insertions(+), 29 deletions(-)
fs/btrfs/relocation.c +9 -29
@@ -613,6 +613,7 @@ static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info, u64 root_objectid) {struct btrfs_key key; +struct btrfs_root *root; key.objectid = root_objectid; key.type =BTRFS_ROOT_ITEM_KEY ;
@@ -621,7 +622,12 @@ static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info,else key.offset = (u64)-1 ; -return btrfs_get_fs_root (fs_info, &key, false); + root =btrfs_get_fs_root (fs_info, &key, false); +if (IS_ERR (root)) +return root; +if (!btrfs_grab_fs_root (root)) +return ERR_PTR (-ENOENT ); +return root; } static noinline_for_stack
@@ -893,10 +899,6 @@ struct backref_node *build_backref_tree(struct reloc_control *rc, err =PTR_ERR (root); goto out; } -if (!btrfs_grab_fs_root (root)) { - err = -ENOENT ; - goto out; - }if (!test_bit (BTRFS_ROOT_REF_COWS , &root->state)) cur->cowonly =1 ;
@@ -2474,8 +2476,6 @@ int prepare_to_merge(struct reloc_control *rc, int err)list_del_init (&reloc_root->root_list); root =read_fs_root (fs_info, reloc_root->root_key.offset); -if (!btrfs_grab_fs_root (root)) -BUG ();BUG_ON (IS_ERR (root));BUG_ON (root->reloc_root != reloc_root);
@@ -2546,8 +2546,6 @@ void merge_reloc_roots(struct reloc_control *rc)if (btrfs_root_refs (&reloc_root->root_item) >0 ) { root =read_fs_root (fs_info, reloc_root->root_key.offset); -if (!btrfs_grab_fs_root (root)) -BUG ();BUG_ON (IS_ERR (root));BUG_ON (root->reloc_root != reloc_root);
@@ -2610,8 +2608,6 @@ static int record_reloc_root_in_trans(struct btrfs_trans_handle *trans,return 0 ; root =read_fs_root (fs_info, reloc_root->root_key.offset); -if (!btrfs_grab_fs_root (root)) -BUG ();BUG_ON (IS_ERR (root));BUG_ON (root->reloc_root != reloc_root); ret =btrfs_record_root_in_trans (trans, root);
@@ -3710,10 +3706,6 @@ static int find_data_references(struct reloc_control *rc, err =PTR_ERR (root); goto out_free; } -if (!btrfs_grab_fs_root (root)) { - err = -ENOENT ; - goto out_free; - } key.objectid = ref_objectid; key.type =BTRFS_EXTENT_DATA_KEY ;
@@ -4308,8 +4300,6 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info, root =read_fs_root (fs_info,BTRFS_DATA_RELOC_TREE_OBJECTID );if (IS_ERR (root))return ERR_CAST (root); -if (!btrfs_grab_fs_root (root)) -return ERR_PTR (-ENOENT ); trans =btrfs_start_transaction (root,6 );if (IS_ERR (trans)) {
@@ -4593,10 +4583,6 @@ int btrfs_recover_relocation(struct btrfs_root *root)if (btrfs_root_refs (&reloc_root->root_item) >0 ) { fs_root =read_fs_root (fs_info, reloc_root->root_key.offset); -if (!btrfs_grab_fs_root (fs_root)) { - err = -ENOENT ; - goto out; - }if (IS_ERR (fs_root)) { ret =PTR_ERR (fs_root);if (ret != -ENOENT ) {
@@ -4659,10 +4645,6 @@ int btrfs_recover_relocation(struct btrfs_root *root)list_add_tail (&reloc_root->root_list, &reloc_roots); goto out_free; } -if (!btrfs_grab_fs_root (fs_root)) { - err = -ENOENT ; - goto out_free; - } err =__add_reloc_root (reloc_root);BUG_ON (err <0 );/* -ENOMEM or logic error */
@@ -4702,10 +4684,8 @@ int btrfs_recover_relocation(struct btrfs_root *root)if (IS_ERR (fs_root)) { err =PTR_ERR (fs_root); }else { -if (btrfs_grab_fs_root (fs_root)) { - err =btrfs_orphan_cleanup (fs_root); -btrfs_put_fs_root (fs_root); - } + err =btrfs_orphan_cleanup (fs_root); +btrfs_put_fs_root (fs_root); } }return err;
Signature · 1 line
2.24.1
PATCH v3 29/43 btrfs: hold a ref for the root in btrfs_find_orphan_roots
In reply to Josef BacikWe lookup roots for every orphan item we have, we need to hold a ref on the root while we're doing this work.
--- fs/btrfs/root-tree.c | 3 +++ 1 file changed, 3 insertions(+)
fs/btrfs/root-tree.c +3 -0
@@ -257,6 +257,8 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info) root =btrfs_get_fs_root (fs_info, &root_key, false); err =PTR_ERR_OR_ZERO (root); +if (!err && !btrfs_grab_fs_root (root)) + err = -ENOENT ;if (err && err != -ENOENT ) {break ; }else if (err == -ENOENT ) {
@@ -288,6 +290,7 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)set_bit (BTRFS_ROOT_DEAD_TREE , &root->state);btrfs_add_dead_root (root); } +btrfs_put_fs_root (root); }btrfs_free_path (path);
Signature · 1 line
2.24.1
PATCH v3 30/43 btrfs: hold a ref on the root in scrub_print_warning_inode
In reply to Josef BacikWe look up the root for the bytenr that is failing, so we need to hold a ref on the root for that operation.
--- fs/btrfs/scrub.c | 7 +++++++ 1 file changed, 7 insertions(+)
fs/btrfs/scrub.c +7 -0
@@ -658,6 +658,10 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, ret =PTR_ERR (local_root); goto err; } +if (!btrfs_grab_fs_root (local_root)) { + ret = -ENOENT ; + goto err; + }/* * this makes the path point to (inum INODE_ITEM ioff)
@@ -668,6 +672,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, ret =btrfs_search_slot (NULL , local_root, &key, swarn->path,0 ,0 );if (ret) { +btrfs_put_fs_root (local_root);btrfs_release_path (swarn->path); goto err; }
@@ -688,6 +693,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, ipath =init_ipath (4096 , local_root, swarn->path);memalloc_nofs_restore (nofs_flag);if (IS_ERR (ipath)) { +btrfs_put_fs_root (local_root); ret =PTR_ERR (ipath); ipath =NULL ; goto err;
@@ -711,6 +717,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,min (isize - offset, (u64 )PAGE_SIZE ), nlink, (char *)(unsigned long)ipath->fspath->val[i]); +btrfs_put_fs_root (local_root);free_ipath (ipath);return 0 ;
Signature · 1 line
2.24.1
PATCH v3 31/43 btrfs: hold a ref on the root in btrfs_ioctl_send
In reply to Josef BacikWe lookup all the clone roots and the parent root for send, so we need to hold refs on all of these roots while we're processing them.
--- fs/btrfs/send.c | 28 ++++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-)
fs/btrfs/send.c +24 -4
@@ -7200,11 +7200,17 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) ret =PTR_ERR (clone_root); goto out; } +if (!btrfs_grab_fs_root (clone_root)) { +srcu_read_unlock (&fs_info->subvol_srcu, index); + ret = -ENOENT ; + goto out; + }spin_lock (&clone_root->root_item_lock);if (!btrfs_root_readonly (clone_root) ||btrfs_root_dead (clone_root)) {spin_unlock (&clone_root->root_item_lock);srcu_read_unlock (&fs_info->subvol_srcu, index); +btrfs_put_fs_root (clone_root); ret = -EPERM ; goto out; }
@@ -7212,6 +7218,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)dedupe_in_progress_warn (clone_root);spin_unlock (&clone_root->root_item_lock);srcu_read_unlock (&fs_info->subvol_srcu, index); +btrfs_put_fs_root (clone_root); ret = -EAGAIN ; goto out; }
@@ -7239,6 +7246,12 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) ret =PTR_ERR (sctx->parent_root); goto out; } +if (!btrfs_grab_fs_root (sctx->parent_root)) { +srcu_read_unlock (&fs_info->subvol_srcu, index); + ret = -ENOENT ; + sctx->parent_root =ERR_PTR (ret); + goto out; + }spin_lock (&sctx->parent_root->root_item_lock); sctx->parent_root->send_in_progress++;
@@ -7266,7 +7279,8 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)* is behind the current send position. This is checked while searching * for possible clone sources. */ - sctx->clone_roots[sctx->clone_roots_cnt++].root = sctx->send_root; + sctx->clone_roots[sctx->clone_roots_cnt++].root = +btrfs_grab_fs_root (sctx->send_root);/* We do a bsearch later */ sort(sctx->clone_roots, sctx->clone_roots_cnt,
@@ -7351,18 +7365,24 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) }if (sort_clone_roots) { -for (i =0 ; i < sctx->clone_roots_cnt; i++) +for (i =0 ; i < sctx->clone_roots_cnt; i++) {btrfs_root_dec_send_in_progress ( sctx->clone_roots[i].root); +btrfs_put_fs_root (sctx->clone_roots[i].root); + } }else { -for (i =0 ; sctx && i < clone_sources_to_rollback; i++) +for (i =0 ; sctx && i < clone_sources_to_rollback; i++) {btrfs_root_dec_send_in_progress ( sctx->clone_roots[i].root); +btrfs_put_fs_root (sctx->clone_roots[i].root); + }btrfs_root_dec_send_in_progress (send_root); } -if (sctx && !IS_ERR_OR_NULL (sctx->parent_root)) +if (sctx && !IS_ERR_OR_NULL (sctx->parent_root)) {btrfs_root_dec_send_in_progress (sctx->parent_root); +btrfs_put_fs_root (sctx->parent_root); + }kvfree (clone_sources_tmp);
Signature · 1 line
2.24.1
PATCH v3 32/43 btrfs: hold a ref on the root in get_subvol_name_from_objectid
In reply to Josef BacikWe lookup the name of a subvol which means we'll cross into different roots. Hold a ref while we're doing the look ups in the fs_root we're searching.
--- fs/btrfs/super.c | 9 +++++++++ 1 file changed, 9 insertions(+)
fs/btrfs/super.c +9 -0
@@ -1101,6 +1101,10 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ret =PTR_ERR (fs_root); goto err; } +if (!btrfs_grab_fs_root (fs_root)) { + ret = -ENOENT ; + goto err; + }/* * Walk up the filesystem tree by inode refs until we hit the
@@ -1113,13 +1117,16 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ret =btrfs_search_slot (NULL , fs_root, &key, path,0 ,0 );if (ret <0 ) { +btrfs_put_fs_root (fs_root); goto err; }else if (ret >0 ) { ret =btrfs_previous_item (fs_root, path, dirid,BTRFS_INODE_REF_KEY );if (ret <0 ) { +btrfs_put_fs_root (fs_root); goto err; }else if (ret >0 ) { +btrfs_put_fs_root (fs_root); ret = -ENOENT ; goto err; }
@@ -1136,6 +1143,7 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ptr -= len +1 ;if (ptr < name) { ret = -ENAMETOOLONG ; +btrfs_put_fs_root (fs_root); goto err; } read_extent_buffer(path->nodes[0], ptr + 1,
@@ -1143,6 +1151,7 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ptr[0 ] ='/' ;btrfs_release_path (path); } +btrfs_put_fs_root (fs_root); }btrfs_free_path (path);
Signature · 1 line
2.24.1
PATCH v3 33/43 btrfs: hold a ref on the root in create_pending_snapshot
In reply to Josef BacikWe create the snapshot and then use it for a bunch of things, we need to hold a ref on it while we're messing with it.
--- fs/btrfs/ioctl.c | 1 + fs/btrfs/transaction.c | 6 ++++++ 2 files changed, 7 insertions(+)
fs/btrfs/ioctl.c +1 -0
@@ -875,6 +875,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,d_instantiate (dentry, inode); ret =0 ; fail: +btrfs_put_fs_root (pending_snapshot->snap);btrfs_subvolume_release_metadata (fs_info, &pending_snapshot->block_rsv); dec_and_free:if (snapshot_force_cow)
fs/btrfs/transaction.c +6 -0
@@ -1637,6 +1637,12 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,btrfs_abort_transaction (trans, ret); goto fail; } +if (!btrfs_grab_fs_root (pending->snap)) { + ret = -ENOENT ; + pending->snap =NULL ; +btrfs_abort_transaction (trans, ret); + goto fail; + } ret =btrfs_reloc_post_snapshot (trans, pending);if (ret) {
Signature · 1 line
2.24.1
PATCH v3 34/43 btrfs: hold a ref on the root in btrfs_recover_log_trees
In reply to Josef BacikWe replay the log into arbitrary fs roots, hold a ref on the root while we're doing this.
--- fs/btrfs/tree-log.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/btrfs/tree-log.c +5 -0
@@ -6114,6 +6114,10 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) tmp_key.offset = (u64)-1 ; wc.replay_dest =btrfs_get_fs_root (fs_info, &tmp_key, true); +if (!IS_ERR (wc.replay_dest)) { +if (!btrfs_grab_fs_root (wc.replay_dest)) + wc.replay_dest =ERR_PTR (-ENOENT ); + }if (IS_ERR (wc.replay_dest)) { ret =PTR_ERR (wc.replay_dest);
@@ -6170,6 +6174,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) } wc.replay_dest->log_root =NULL ; +btrfs_put_fs_root (wc.replay_dest);free_extent_buffer (log->node);free_extent_buffer (log->commit_root);kfree (log);
Signature · 1 line
2.24.1
PATCH v3 35/43 btrfs: hold a ref on the root in btrfs_check_uuid_tree_entry
In reply to Josef BacikWe lookup the uuid of arbitrary subvolumes, hold a ref on the root while we're doing this.
--- fs/btrfs/volumes.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
fs/btrfs/volumes.c +5 -1
@@ -4382,6 +4382,10 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info, ret =1 ; goto out; } +if (!btrfs_grab_fs_root (subvol_root)) { + ret =1 ; + goto out; + }switch (type) {case BTRFS_UUID_KEY_SUBVOL :
@@ -4394,7 +4398,7 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info, ret =1 ;break ; } - +btrfs_put_fs_root (subvol_root); out:return ret; }
Signature · 1 line
2.24.1
PATCH v3 36/43 btrfs: hold a ref on the root in open_ctree
In reply to Josef BacikWe lookup the fs_root and put it in our fs_info directly, we should hold a ref on this root for the lifetime of the fs_info. Rework the free'ing function so that it calls btrfs_put_fs_root() on the root at free time with all of the other global trees.
--- fs/btrfs/ctree.h | 17 ----------------- fs/btrfs/disk-io.c | 26 ++++++++++++++++++++++++++ fs/btrfs/disk-io.h | 1 + fs/btrfs/super.c | 6 +++--- 4 files changed, 30 insertions(+), 20 deletions(-)
fs/btrfs/ctree.h +0 -17
@@ -2697,23 +2697,6 @@ static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)return fs_info->sb->s_flags &SB_RDONLY ||btrfs_fs_closing (fs_info); } -static inline void free_fs_info (struct btrfs_fs_info *fs_info) -{ -kfree (fs_info->balance_ctl); -kfree (fs_info->delayed_root); -kfree (fs_info->extent_root); -kfree (fs_info->tree_root); -kfree (fs_info->chunk_root); -kfree (fs_info->dev_root); -kfree (fs_info->csum_root); -kfree (fs_info->quota_root); -kfree (fs_info->uuid_root); -kfree (fs_info->free_space_root); -kfree (fs_info->super_copy); -kfree (fs_info->super_for_commit); -kvfree (fs_info); -} -/* tree mod log functions from ctree.c */ u64 btrfs_get_tree_mod_seq (struct btrfs_fs_info *fs_info,struct seq_list *elem);
fs/btrfs/disk-io.c +26 -0
@@ -1523,6 +1523,25 @@ int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,return ret; } +void btrfs_free_fs_info (struct btrfs_fs_info *fs_info) +{ +kfree (fs_info->balance_ctl); +kfree (fs_info->delayed_root); +kfree (fs_info->extent_root); +kfree (fs_info->tree_root); +kfree (fs_info->chunk_root); +kfree (fs_info->dev_root); +kfree (fs_info->csum_root); +kfree (fs_info->quota_root); +kfree (fs_info->uuid_root); +kfree (fs_info->free_space_root); +kfree (fs_info->super_copy); +kfree (fs_info->super_for_commit); +btrfs_put_fs_root (fs_info->fs_root); +kvfree (fs_info); +} + +struct btrfs_root *btrfs_get_fs_root (struct btrfs_fs_info *fs_info,struct btrfs_key *location,bool check_ref)
@@ -3185,6 +3204,13 @@ int __cold open_ctree(struct super_block *sb, goto fail_qgroup; } +if (!btrfs_grab_fs_root (fs_info->fs_root)) { + fs_info->fs_root =NULL ; + err = -ENOENT ; +btrfs_warn (fs_info,"failed to grab a ref on the fs tree" ); + goto fail_qgroup; + } +if (sb_rdonly (sb))return 0 ;
fs/btrfs/disk-io.h +1 -0
@@ -68,6 +68,7 @@ struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,struct btrfs_key *key, bool check_ref); +void btrfs_free_fs_info (struct btrfs_fs_info *fs_info);int btrfs_cleanup_fs_roots (struct btrfs_fs_info *fs_info);void btrfs_btree_balance_dirty (struct btrfs_fs_info *fs_info);void btrfs_btree_balance_dirty_nodelay (struct btrfs_fs_info *fs_info);
fs/btrfs/super.c +3 -3
@@ -1580,7 +1580,7 @@ static struct dentry *btrfs_mount_root(struct file_system_type *fs_type,if (s->s_root) {btrfs_close_devices (fs_devices); -free_fs_info (fs_info); +btrfs_free_fs_info (fs_info);if ((flags ^ s->s_flags) &SB_RDONLY ) error = -EBUSY ; }else {
@@ -1603,7 +1603,7 @@ static struct dentry *btrfs_mount_root(struct file_system_type *fs_type, error_close_devices:btrfs_close_devices (fs_devices); error_fs_info: -free_fs_info (fs_info); +btrfs_free_fs_info (fs_info); error_sec_opts:security_free_mnt_opts (&new_sec_opts);return ERR_PTR (error);
@@ -2169,7 +2169,7 @@ static void btrfs_kill_super(struct super_block *sb) {struct btrfs_fs_info *fs_info =btrfs_sb (sb);kill_anon_super (sb); -free_fs_info (fs_info); +btrfs_free_fs_info (fs_info); }static struct file_system_type btrfs_fs_type = {
Signature · 1 line
2.24.1
PATCH v3 37/43 btrfs: use btrfs_put_fs_root to free roots always
In reply to Josef BacikIf we are going to track leaked roots we need to free them all the same way, so don't kfree() roots directly, use btrfs_put_fs_root.
--- fs/btrfs/disk-io.c | 30 +++++++++++++++--------------- fs/btrfs/free-space-tree.c | 2 +- fs/btrfs/qgroup.c | 4 ++-- fs/btrfs/tests/btrfs-tests.c | 2 +- fs/btrfs/tree-log.c | 8 ++++---- 5 files changed, 23 insertions(+), 23 deletions(-)
fs/btrfs/disk-io.c +15 -15
@@ -1297,7 +1297,7 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,free_extent_buffer (root->commit_root);free_extent_buffer (leaf); } -kfree (root); +btrfs_put_fs_root (root);return ERR_PTR (ret); }
@@ -1328,7 +1328,7 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans, leaf =btrfs_alloc_tree_block (trans, root,0 ,BTRFS_TREE_LOG_OBJECTID ,NULL ,0 ,0 ,0 );if (IS_ERR (leaf)) { -kfree (root); +btrfs_put_fs_root (root);return ERR_CAST (leaf); }
@@ -1431,7 +1431,7 @@ struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,return root; find_fail: -kfree (root); +btrfs_put_fs_root (root); alloc_fail: root =ERR_PTR (ret); goto out;
@@ -1527,17 +1527,17 @@ void btrfs_free_fs_info(struct btrfs_fs_info *fs_info) {kfree (fs_info->balance_ctl);kfree (fs_info->delayed_root); -kfree (fs_info->extent_root); -kfree (fs_info->tree_root); -kfree (fs_info->chunk_root); -kfree (fs_info->dev_root); -kfree (fs_info->csum_root); -kfree (fs_info->quota_root); -kfree (fs_info->uuid_root); -kfree (fs_info->free_space_root); +btrfs_put_fs_root (fs_info->extent_root); +btrfs_put_fs_root (fs_info->tree_root); +btrfs_put_fs_root (fs_info->chunk_root); +btrfs_put_fs_root (fs_info->dev_root); +btrfs_put_fs_root (fs_info->csum_root); +btrfs_put_fs_root (fs_info->quota_root); +btrfs_put_fs_root (fs_info->uuid_root); +btrfs_put_fs_root (fs_info->free_space_root); +btrfs_put_fs_root (fs_info->fs_root);kfree (fs_info->super_copy);kfree (fs_info->super_for_commit); -btrfs_put_fs_root (fs_info->fs_root);kvfree (fs_info); }
@@ -2223,12 +2223,12 @@ static int btrfs_replay_log(struct btrfs_fs_info *fs_info,if (IS_ERR (log_tree_root->node)) {btrfs_warn (fs_info,"failed to read log tree" ); ret =PTR_ERR (log_tree_root->node); -kfree (log_tree_root); +btrfs_put_fs_root (log_tree_root);return ret; }else if (!extent_buffer_uptodate (log_tree_root->node)) {btrfs_err (fs_info,"failed to read log tree" );free_extent_buffer (log_tree_root->node); -kfree (log_tree_root); +btrfs_put_fs_root (log_tree_root);return -EIO ; }/* returns with log_tree_root freed on success */
@@ -2237,7 +2237,7 @@ static int btrfs_replay_log(struct btrfs_fs_info *fs_info,btrfs_handle_fs_error (fs_info, ret,"Failed to recover log tree" );free_extent_buffer (log_tree_root->node); -kfree (log_tree_root); +btrfs_put_fs_root (log_tree_root);return ret; }
fs/btrfs/free-space-tree.c +1 -1
@@ -1253,7 +1253,7 @@ int btrfs_clear_free_space_tree(struct btrfs_fs_info *fs_info)free_extent_buffer (free_space_root->node);free_extent_buffer (free_space_root->commit_root); -kfree (free_space_root); +btrfs_put_fs_root (free_space_root);return btrfs_commit_transaction (trans);
fs/btrfs/qgroup.c +2 -2
@@ -1040,7 +1040,7 @@ int btrfs_quota_enable(struct btrfs_fs_info *fs_info)if (ret) {free_extent_buffer (quota_root->node);free_extent_buffer (quota_root->commit_root); -kfree (quota_root); +btrfs_put_fs_root (quota_root); } out:if (ret) {
@@ -1106,7 +1106,7 @@ int btrfs_quota_disable(struct btrfs_fs_info *fs_info)free_extent_buffer (quota_root->node);free_extent_buffer (quota_root->commit_root); -kfree (quota_root); +btrfs_put_fs_root (quota_root); end_trans: ret =btrfs_end_transaction (trans);
fs/btrfs/tests/btrfs-tests.c +1 -1
@@ -228,7 +228,7 @@ void btrfs_free_dummy_root(struct btrfs_root *root)/* One for allocate_extent_buffer */ free_extent_buffer (root->node); } -kfree (root); +btrfs_put_fs_root (root); } struct btrfs_block_group *
fs/btrfs/tree-log.c +4 -4
@@ -3284,7 +3284,7 @@ static void free_log_tree(struct btrfs_trans_handle *trans,clear_extent_bits (&log->dirty_log_pages,0 , (u64)-1 ,EXTENT_DIRTY |EXTENT_NEW |EXTENT_NEED_WAIT );free_extent_buffer (log->node); -kfree (log); +btrfs_put_fs_root (log); }/*
@@ -6138,7 +6138,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) log->node->len);free_extent_buffer (log->node);free_extent_buffer (log->commit_root); -kfree (log); +btrfs_put_fs_root (log);if (!ret) goto next;
@@ -6177,7 +6177,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)btrfs_put_fs_root (wc.replay_dest);free_extent_buffer (log->node);free_extent_buffer (log->commit_root); -kfree (log); +btrfs_put_fs_root (log);if (ret) goto error;
@@ -6211,7 +6211,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)free_extent_buffer (log_root_tree->node); log_root_tree->log_root =NULL ;clear_bit (BTRFS_FS_LOG_RECOVERING , &fs_info->flags); -kfree (log_root_tree); +btrfs_put_fs_root (log_root_tree);return 0 ; error:
Signature · 1 line
2.24.1
PATCH v3 38/43 btrfs: push btrfs_grab_fs_root into btrfs_get_fs_root
In reply to Josef BacikNow that all callers of btrfs_get_fs_root are subsequently calling btrfs_grab_fs_root and handling dropping the ref when they are done appropriately, go ahead and push btrfs_grab_fs_root up into btrfs_get_fs_root.
--- fs/btrfs/backref.c | 6 ------ fs/btrfs/disk-io.c | 45 ++++++++++++++++++++++++------------------ fs/btrfs/export.c | 4 ---- fs/btrfs/file.c | 4 ---- fs/btrfs/inode.c | 4 ---- fs/btrfs/ioctl.c | 26 ------------------------ fs/btrfs/relocation.c | 8 +------- fs/btrfs/root-tree.c | 2 -- fs/btrfs/scrub.c | 4 ---- fs/btrfs/send.c | 11 ----------- fs/btrfs/super.c | 4 ---- fs/btrfs/transaction.c | 6 ------ fs/btrfs/tree-log.c | 4 ---- fs/btrfs/volumes.c | 4 ---- 14 files changed, 27 insertions(+), 105 deletions(-)
fs/btrfs/backref.c +0 -6
@@ -527,12 +527,6 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, goto out_free; } -if (!btrfs_grab_fs_root (root)) { -srcu_read_unlock (&fs_info->subvol_srcu, index); - ret = -ENOENT ; - goto out_free; - } -if (btrfs_is_testing (fs_info)) {srcu_read_unlock (&fs_info->subvol_srcu, index); ret = -ENOENT ;
fs/btrfs/disk-io.c +26 -19
82 lines not on this page · raw message
fs/btrfs/export.c +0 -4
@@ -82,10 +82,6 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, err =PTR_ERR (root); goto fail; } -if (!btrfs_grab_fs_root (root)) { - err = -ENOENT ; - goto fail; - } key.objectid = objectid; key.type =BTRFS_INODE_ITEM_KEY ;
fs/btrfs/file.c +0 -4
@@ -292,10 +292,6 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, ret =PTR_ERR (inode_root); goto cleanup; } -if (!btrfs_grab_fs_root (inode_root)) { - ret = -ENOENT ; - goto cleanup; - } key.objectid = defrag->ino; key.type =BTRFS_INODE_ITEM_KEY ;
fs/btrfs/inode.c +0 -4
@@ -5026,10 +5026,6 @@ static int fixup_tree_root_location(struct btrfs_fs_info *fs_info, err =PTR_ERR (new_root); goto out; } -if (!btrfs_grab_fs_root (new_root)) { - err = -ENOENT ; - goto out; - } *sub_root = new_root; location->objectid =btrfs_root_dirid (&new_root->root_item);
fs/btrfs/ioctl.c +0 -26
@@ -672,11 +672,6 @@ static noinline int create_subvol(struct inode *dir,btrfs_abort_transaction (trans, ret); goto fail; } -if (!btrfs_grab_fs_root (new_root)) { - ret = -ENOENT ; -btrfs_abort_transaction (trans, ret); - goto fail; - }btrfs_record_root_in_trans (trans, new_root);
@@ -2191,10 +2186,6 @@ static noinline int search_ioctl(struct inode *inode,btrfs_free_path (path);return PTR_ERR (root); } -if (!btrfs_grab_fs_root (root)) { -btrfs_free_path (path); -return -ENOENT ; - } } key.objectid = sk->min_objectid;
@@ -2332,11 +2323,6 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, root =NULL ; goto out; } -if (!btrfs_grab_fs_root (root)) { - ret = -ENOENT ; - root =NULL ; - goto out; - } key.objectid = dirid; key.type =BTRFS_INODE_REF_KEY ;
@@ -2433,10 +2419,6 @@ static int btrfs_search_path_in_tree_user(struct inode *inode, ret =PTR_ERR (root); goto out; } -if (!btrfs_grab_fs_root (root)) { - ret = -ENOENT ; - goto out; - } key.objectid = dirid; key.type =BTRFS_INODE_REF_KEY ;
@@ -2686,10 +2668,6 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp) ret =PTR_ERR (root); goto out_free; } -if (!btrfs_grab_fs_root (root)) { - ret = -ENOENT ; - goto out; - } root_item = &root->root_item; subvol_info->treeid = key.objectid;
@@ -4019,10 +3997,6 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp) ret =PTR_ERR (new_root); goto out; } -if (!btrfs_grab_fs_root (root)) { - ret = -ENOENT ; - goto out; - }if (!is_fstree (new_root->root_key.objectid)) { ret = -ENOENT ; goto out_free;
fs/btrfs/relocation.c +1 -7
@@ -613,7 +613,6 @@ static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info, u64 root_objectid) {struct btrfs_key key; -struct btrfs_root *root; key.objectid = root_objectid; key.type =BTRFS_ROOT_ITEM_KEY ;
@@ -622,12 +621,7 @@ static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info,else key.offset = (u64)-1 ; - root =btrfs_get_fs_root (fs_info, &key, false); -if (IS_ERR (root)) -return root; -if (!btrfs_grab_fs_root (root)) -return ERR_PTR (-ENOENT ); -return root; +return btrfs_get_fs_root (fs_info, &key, false); } static noinline_for_stack
fs/btrfs/root-tree.c +0 -2
@@ -257,8 +257,6 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info) root =btrfs_get_fs_root (fs_info, &root_key, false); err =PTR_ERR_OR_ZERO (root); -if (!err && !btrfs_grab_fs_root (root)) - err = -ENOENT ;if (err && err != -ENOENT ) {break ; }else if (err == -ENOENT ) {
fs/btrfs/scrub.c +0 -4
@@ -658,10 +658,6 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, ret =PTR_ERR (local_root); goto err; } -if (!btrfs_grab_fs_root (local_root)) { - ret = -ENOENT ; - goto err; - }/* * this makes the path point to (inum INODE_ITEM ioff)
fs/btrfs/send.c +0 -11
@@ -7200,11 +7200,6 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) ret =PTR_ERR (clone_root); goto out; } -if (!btrfs_grab_fs_root (clone_root)) { -srcu_read_unlock (&fs_info->subvol_srcu, index); - ret = -ENOENT ; - goto out; - }spin_lock (&clone_root->root_item_lock);if (!btrfs_root_readonly (clone_root) ||btrfs_root_dead (clone_root)) {
@@ -7246,12 +7241,6 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) ret =PTR_ERR (sctx->parent_root); goto out; } -if (!btrfs_grab_fs_root (sctx->parent_root)) { -srcu_read_unlock (&fs_info->subvol_srcu, index); - ret = -ENOENT ; - sctx->parent_root =ERR_PTR (ret); - goto out; - }spin_lock (&sctx->parent_root->root_item_lock); sctx->parent_root->send_in_progress++;
fs/btrfs/super.c +0 -4
@@ -1101,10 +1101,6 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ret =PTR_ERR (fs_root); goto err; } -if (!btrfs_grab_fs_root (fs_root)) { - ret = -ENOENT ; - goto err; - }/* * Walk up the filesystem tree by inode refs until we hit the
fs/btrfs/transaction.c +0 -6
@@ -1637,12 +1637,6 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,btrfs_abort_transaction (trans, ret); goto fail; } -if (!btrfs_grab_fs_root (pending->snap)) { - ret = -ENOENT ; - pending->snap =NULL ; -btrfs_abort_transaction (trans, ret); - goto fail; - } ret =btrfs_reloc_post_snapshot (trans, pending);if (ret) {
fs/btrfs/tree-log.c +0 -4
@@ -6114,10 +6114,6 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) tmp_key.offset = (u64)-1 ; wc.replay_dest =btrfs_get_fs_root (fs_info, &tmp_key, true); -if (!IS_ERR (wc.replay_dest)) { -if (!btrfs_grab_fs_root (wc.replay_dest)) - wc.replay_dest =ERR_PTR (-ENOENT ); - }if (IS_ERR (wc.replay_dest)) { ret =PTR_ERR (wc.replay_dest);
fs/btrfs/volumes.c +0 -4
@@ -4382,10 +4382,6 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info, ret =1 ; goto out; } -if (!btrfs_grab_fs_root (subvol_root)) { - ret =1 ; - goto out; - }switch (type) {case BTRFS_UUID_KEY_SUBVOL :
Signature · 1 line
2.24.1
PATCH v3 39/43 btrfs: free more things in btrfs_free_fs_info
In reply to Josef BacikThings like the percpu_counters, the mapping_tree, and the csum hash can all be free'd at btrfs_free_fs_info time, since the helpers all check if the structure has been init'ed already. This significantly cleans up the error cases in open_ctree.
--- fs/btrfs/disk-io.c | 60 +++++++++++++++++++--------------------------- 1 file changed, 24 insertions(+), 36 deletions(-)
fs/btrfs/disk-io.c +24 -36
@@ -98,6 +98,12 @@ void __cold btrfs_end_io_wq_exit(void)kmem_cache_destroy (btrfs_end_io_wq_cache); } +static void btrfs_free_csum_hash (struct btrfs_fs_info *fs_info) +{ +if (fs_info->csum_shash) +crypto_free_shash (fs_info->csum_shash); +} +/* * async submit bios are used to offload expensive checksumming * onto the worker threads. They checksum file and metadata bios
@@ -1527,6 +1533,13 @@ int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,void btrfs_free_fs_info (struct btrfs_fs_info *fs_info) { +percpu_counter_destroy (&fs_info->dirty_metadata_bytes); +percpu_counter_destroy (&fs_info->delalloc_bytes); +percpu_counter_destroy (&fs_info->dio_bytes); +percpu_counter_destroy (&fs_info->dev_replace.bio_counter); +btrfs_free_csum_hash (fs_info); +btrfs_free_stripe_hash_table (fs_info); +btrfs_free_ref_cache (fs_info);kfree (fs_info->balance_ctl);kfree (fs_info->delayed_root);btrfs_put_fs_root (fs_info->extent_root);
@@ -2207,11 +2220,6 @@ static int btrfs_init_csum_hash(struct btrfs_fs_info *fs_info, u16 csum_type)return 0 ; } -static void btrfs_free_csum_hash (struct btrfs_fs_info *fs_info) -{ -crypto_free_shash (fs_info->csum_shash); -} -static int btrfs_replay_log (struct btrfs_fs_info *fs_info,struct btrfs_fs_devices *fs_devices) {
@@ -2686,7 +2694,7 @@ int __cold open_ctree(struct super_block *sb, ret =percpu_counter_init (&fs_info->dirty_metadata_bytes,0 ,GFP_KERNEL );if (ret) { err = ret; - goto fail_dio_bytes; + goto fail_srcu; } fs_info->dirty_metadata_batch =PAGE_SIZE * (1 +ilog2 (nr_cpu_ids));
@@ -2694,14 +2702,14 @@ int __cold open_ctree(struct super_block *sb, ret =percpu_counter_init (&fs_info->delalloc_bytes,0 ,GFP_KERNEL );if (ret) { err = ret; - goto fail_dirty_metadata_bytes; + goto fail_srcu; } ret =percpu_counter_init (&fs_info->dev_replace.bio_counter,0 ,GFP_KERNEL );if (ret) { err = ret; - goto fail_delalloc_bytes; + goto fail_srcu; }INIT_RADIX_TREE (&fs_info->fs_roots_radix,GFP_ATOMIC );
@@ -2769,7 +2777,7 @@ int __cold open_ctree(struct super_block *sb, fs_info->btree_inode =new_inode (sb);if (!fs_info->btree_inode) { err = -ENOMEM ; - goto fail_bio_counter; + goto fail_srcu; }mapping_set_gfp_mask (fs_info->btree_inode->i_mapping,GFP_NOFS );
@@ -2882,7 +2890,7 @@ int __cold open_ctree(struct super_block *sb,btrfs_err (fs_info,"superblock checksum mismatch" ); err = -EINVAL ;brelse (bh); - goto fail_csum; + goto fail_alloc; }/*
@@ -2919,11 +2927,11 @@ int __cold open_ctree(struct super_block *sb,if (ret) {btrfs_err (fs_info,"superblock contains fatal errors" ); err = -EINVAL ; - goto fail_csum; + goto fail_alloc; }if (!btrfs_super_root (disk_super)) - goto fail_csum; + goto fail_alloc;/* check FS state, whether FS is broken. */ if (btrfs_super_flags (disk_super) &BTRFS_SUPER_FLAG_ERROR )
@@ -2938,7 +2946,7 @@ int __cold open_ctree(struct super_block *sb, ret =btrfs_parse_options (fs_info, options, sb->s_flags);if (ret) { err = ret; - goto fail_csum; + goto fail_alloc; } features = btrfs_super_incompat_flags(disk_super) &
@@ -2948,7 +2956,7 @@ int __cold open_ctree(struct super_block *sb,"cannot mount because of unsupported optional features (%llx)" , features); err = -EINVAL ; - goto fail_csum; + goto fail_alloc; } features =btrfs_super_incompat_flags (disk_super);
@@ -2992,7 +3000,7 @@ int __cold open_ctree(struct super_block *sb,btrfs_err (fs_info,"unequal nodesize/sectorsize (%u != %u) are not allowed for mixed block groups" , nodesize, sectorsize); - goto fail_csum; + goto fail_alloc; }/*
@@ -3008,7 +3016,7 @@ int __cold open_ctree(struct super_block *sb,"cannot mount read-write because of unsupported optional features (%llx)" , features); err = -EINVAL ; - goto fail_csum; + goto fail_alloc; } ret =btrfs_init_workqueues (fs_info, fs_devices);
@@ -3343,25 +3351,14 @@ int __cold open_ctree(struct super_block *sb, fail_sb_buffer:btrfs_stop_all_workers (fs_info);btrfs_free_block_groups (fs_info); -fail_csum: -btrfs_free_csum_hash (fs_info); fail_alloc: fail_iput:btrfs_mapping_tree_free (&fs_info->mapping_tree);iput (fs_info->btree_inode); -fail_bio_counter: -percpu_counter_destroy (&fs_info->dev_replace.bio_counter); -fail_delalloc_bytes: -percpu_counter_destroy (&fs_info->delalloc_bytes); -fail_dirty_metadata_bytes: -percpu_counter_destroy (&fs_info->dirty_metadata_bytes); -fail_dio_bytes: -percpu_counter_destroy (&fs_info->dio_bytes); fail_srcu:cleanup_srcu_struct (&fs_info->subvol_srcu); fail: -btrfs_free_stripe_hash_table (fs_info);btrfs_close_devices (fs_info->fs_devices);return err; }
@@ -4061,16 +4058,7 @@ void __cold close_ctree(struct btrfs_fs_info *fs_info)btrfs_mapping_tree_free (&fs_info->mapping_tree);btrfs_close_devices (fs_info->fs_devices); - -percpu_counter_destroy (&fs_info->dirty_metadata_bytes); -percpu_counter_destroy (&fs_info->delalloc_bytes); -percpu_counter_destroy (&fs_info->dio_bytes); -percpu_counter_destroy (&fs_info->dev_replace.bio_counter);cleanup_srcu_struct (&fs_info->subvol_srcu); - -btrfs_free_csum_hash (fs_info); -btrfs_free_stripe_hash_table (fs_info); -btrfs_free_ref_cache (fs_info); } int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
Signature · 1 line
2.24.1
PATCH v3 40/43 btrfs: move fs_info init work into it's own helper function
In reply to Josef Bacikopen_ctree mixes initialization of fs stuff and fs_info stuff, which makes it confusing when doing things like adding the root leak detection. Make a separate function that init's all the static structures inside of the fs_info needed for the fs to operate, and then call that before we start setting up the fs_info to be mounted.
--- fs/btrfs/disk-io.c | 162 +++++++++++++++++++++++---------------------- 1 file changed, 83 insertions(+), 79 deletions(-)
fs/btrfs/disk-io.c +83 -79
@@ -2649,68 +2649,9 @@ static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)return ret; } -int __cold open_ctree (struct super_block *sb, -struct btrfs_fs_devices *fs_devices, -char *options) +static int init_fs_info (struct btrfs_fs_info *fs_info,struct super_block *sb) { -u32 sectorsize; -u32 nodesize; -u32 stripesize; -u64 generation; -u64 features; -u16 csum_type; -struct btrfs_key location; -struct buffer_head *bh; -struct btrfs_super_block *disk_super; -struct btrfs_fs_info *fs_info =btrfs_sb (sb); -struct btrfs_root *tree_root; -struct btrfs_root *chunk_root;int ret; -int err = -EINVAL ; -int clear_free_space_tree =0 ; -int level; - - tree_root = fs_info->tree_root =btrfs_alloc_root (fs_info, -BTRFS_ROOT_TREE_OBJECTID ,GFP_KERNEL ); - chunk_root = fs_info->chunk_root =btrfs_alloc_root (fs_info, -BTRFS_CHUNK_TREE_OBJECTID ,GFP_KERNEL ); -if (!tree_root || !chunk_root) { - err = -ENOMEM ; - goto fail; - } - - ret =init_srcu_struct (&fs_info->subvol_srcu); -if (ret) { - err = ret; - goto fail; - } - - ret =percpu_counter_init (&fs_info->dio_bytes,0 ,GFP_KERNEL ); -if (ret) { - err = ret; - goto fail_srcu; - } - - ret =percpu_counter_init (&fs_info->dirty_metadata_bytes,0 ,GFP_KERNEL ); -if (ret) { - err = ret; - goto fail_srcu; - } - fs_info->dirty_metadata_batch =PAGE_SIZE * - (1 +ilog2 (nr_cpu_ids)); - - ret =percpu_counter_init (&fs_info->delalloc_bytes,0 ,GFP_KERNEL ); -if (ret) { - err = ret; - goto fail_srcu; - } - - ret =percpu_counter_init (&fs_info->dev_replace.bio_counter,0 , -GFP_KERNEL ); -if (ret) { - err = ret; - goto fail_srcu; - }INIT_RADIX_TREE (&fs_info->fs_roots_radix,GFP_ATOMIC );INIT_RADIX_TREE (&fs_info->buffer_radix,GFP_ATOMIC );
@@ -2774,21 +2715,6 @@ int __cold open_ctree(struct super_block *sb,INIT_LIST_HEAD (&fs_info->ordered_roots);spin_lock_init (&fs_info->ordered_root_lock); - fs_info->btree_inode =new_inode (sb); -if (!fs_info->btree_inode) { - err = -ENOMEM ; - goto fail_srcu; - } -mapping_set_gfp_mask (fs_info->btree_inode->i_mapping,GFP_NOFS ); - - fs_info->delayed_root =kmalloc (sizeof (struct btrfs_delayed_root ), -GFP_KERNEL ); -if (!fs_info->delayed_root) { - err = -ENOMEM ; - goto fail_iput; - } -btrfs_init_delayed_root (fs_info->delayed_root); -btrfs_init_scrub (fs_info);#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY fs_info->check_integrity_print_mask =0 ;
@@ -2799,8 +2725,6 @@ int __cold open_ctree(struct super_block *sb, sb->s_blocksize =BTRFS_BDEV_BLOCKSIZE ; sb->s_blocksize_bits =blksize_bits (BTRFS_BDEV_BLOCKSIZE ); -btrfs_init_btree_inode (fs_info); -spin_lock_init (&fs_info->block_group_cache_lock); fs_info->block_group_cache_tree =RB_ROOT ; fs_info->first_logical_byte = (u64)-1 ;
@@ -2846,12 +2770,93 @@ int __cold open_ctree(struct super_block *sb, fs_info->send_in_progress =0 ; + ret =init_srcu_struct (&fs_info->subvol_srcu); +if (ret) +return ret; + + ret =percpu_counter_init (&fs_info->dio_bytes,0 ,GFP_KERNEL ); +if (ret) + goto fail; + + ret =percpu_counter_init (&fs_info->dirty_metadata_bytes,0 ,GFP_KERNEL ); +if (ret) + goto fail; + + fs_info->dirty_metadata_batch =PAGE_SIZE * + (1 +ilog2 (nr_cpu_ids)); + + ret =percpu_counter_init (&fs_info->delalloc_bytes,0 ,GFP_KERNEL ); +if (ret) + goto fail; + + ret =percpu_counter_init (&fs_info->dev_replace.bio_counter,0 , +GFP_KERNEL ); +if (ret) + goto fail; + + fs_info->delayed_root =kmalloc (sizeof (struct btrfs_delayed_root ), +GFP_KERNEL ); +if (!fs_info->delayed_root) { + ret = -ENOMEM ; + goto fail; + } +btrfs_init_delayed_root (fs_info->delayed_root); + ret =btrfs_alloc_stripe_hash_table (fs_info); +if (ret) + goto fail; + +return 0 ; +fail: +cleanup_srcu_struct (&fs_info->subvol_srcu); +return ret; +} + +int __cold open_ctree (struct super_block *sb, +struct btrfs_fs_devices *fs_devices, +char *options) +{ +u32 sectorsize; +u32 nodesize; +u32 stripesize; +u64 generation; +u64 features; +u16 csum_type; +struct btrfs_key location; +struct buffer_head *bh; +struct btrfs_super_block *disk_super; +struct btrfs_fs_info *fs_info =btrfs_sb (sb); +struct btrfs_root *tree_root; +struct btrfs_root *chunk_root; +int ret; +int err = -EINVAL ; +int clear_free_space_tree =0 ; +int level; + + ret =init_fs_info (fs_info, sb);if (ret) { err = ret; - goto fail_alloc; + goto fail; } +/* These need to be init'ed before we start creating inodes and such. */ + tree_root = fs_info->tree_root =btrfs_alloc_root (fs_info, +BTRFS_ROOT_TREE_OBJECTID ,GFP_KERNEL ); + chunk_root = fs_info->chunk_root =btrfs_alloc_root (fs_info, +BTRFS_CHUNK_TREE_OBJECTID ,GFP_KERNEL ); +if (!tree_root || !chunk_root) { + err = -ENOMEM ; + goto fail_srcu; + } + + fs_info->btree_inode =new_inode (sb); +if (!fs_info->btree_inode) { + err = -ENOMEM ; + goto fail_srcu; + } +mapping_set_gfp_mask (fs_info->btree_inode->i_mapping,GFP_NOFS ); +btrfs_init_btree_inode (fs_info); +invalidate_bdev (fs_devices->latest_bdev);/*
@@ -3352,7 +3357,6 @@ int __cold open_ctree(struct super_block *sb,btrfs_stop_all_workers (fs_info);btrfs_free_block_groups (fs_info); fail_alloc: -fail_iput:btrfs_mapping_tree_free (&fs_info->mapping_tree);iput (fs_info->btree_inode);
Signature · 1 line
2.24.1
PATCH v3 41/43 btrfs: make the init of static elements in fs_info separate
In reply to Josef BacikIn adding things like eb leak checking and root leak checking there were a lot of weird corner cases that come from the fact that
1) We do not init the fs_info until we get to open_ctree time in the normal case and
2) The test infrastructure half-init's the fs_info for things that it needs.
This makes it really annoying to make changes because you have to add init in two different places, have special cases for testing fs_info's that may not have certain things init'ed, and cases for fs_info's that didn't make it to open_ctree and thus are not fully init'ed.
Fix this by extracting out the non-allocating init of the fs info into it's own public function and use that to make sure we're all getting consistent views of an allocated fs_info.
--- fs/btrfs/disk-io.c | 19 +++++++++++-------- fs/btrfs/disk-io.h | 1 + fs/btrfs/super.c | 1 + fs/btrfs/tests/btrfs-tests.c | 28 ++++------------------------ 4 files changed, 17 insertions(+), 32 deletions(-)
fs/btrfs/disk-io.c +11 -8
@@ -2649,10 +2649,8 @@ static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)return ret; } -static int init_fs_info (struct btrfs_fs_info *fs_info,struct super_block *sb) +void btrfs_init_fs_info (struct btrfs_fs_info *fs_info) { -int ret; -INIT_RADIX_TREE (&fs_info->fs_roots_radix,GFP_ATOMIC );INIT_RADIX_TREE (&fs_info->buffer_radix,GFP_ATOMIC );INIT_LIST_HEAD (&fs_info->trans_list);
@@ -2696,7 +2694,6 @@ static int init_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb)atomic_set (&fs_info->reada_works_cnt,0 );atomic_set (&fs_info->nr_delayed_iputs,0 );atomic64_set (&fs_info->tree_mod_seq,0 ); - fs_info->sb = sb; fs_info->max_inline =BTRFS_DEFAULT_MAX_INLINE ; fs_info->metadata_ratio =0 ; fs_info->defrag_inodes =RB_ROOT ;
@@ -2722,9 +2719,6 @@ static int init_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb)btrfs_init_balance (fs_info);btrfs_init_async_reclaim_work (&fs_info->async_reclaim_work); - sb->s_blocksize =BTRFS_BDEV_BLOCKSIZE ; - sb->s_blocksize_bits =blksize_bits (BTRFS_BDEV_BLOCKSIZE ); -spin_lock_init (&fs_info->block_group_cache_lock); fs_info->block_group_cache_tree =RB_ROOT ; fs_info->first_logical_byte = (u64)-1 ;
@@ -2769,6 +2763,15 @@ static int init_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb) fs_info->swapfile_pins =RB_ROOT ; fs_info->send_in_progress =0 ; +} + +static int init_mount_fs_info (struct btrfs_fs_info *fs_info,struct super_block *sb) +{ +int ret; + + fs_info->sb = sb; + sb->s_blocksize =BTRFS_BDEV_BLOCKSIZE ; + sb->s_blocksize_bits =blksize_bits (BTRFS_BDEV_BLOCKSIZE ); ret =init_srcu_struct (&fs_info->subvol_srcu);if (ret)
@@ -2833,7 +2836,7 @@ int __cold open_ctree(struct super_block *sb,int clear_free_space_tree =0 ;int level; - ret =init_fs_info (fs_info, sb); + ret =init_mount_fs_info (fs_info, sb);if (ret) { err = ret; goto fail;
fs/btrfs/disk-io.h +1 -0
@@ -39,6 +39,7 @@ static inline u64 btrfs_sb_offset(int mirror)struct btrfs_device ;struct btrfs_fs_devices ; +void btrfs_init_fs_info (struct btrfs_fs_info *fs_info);int btrfs_verify_level_key (struct extent_buffer *eb,int level,struct btrfs_key *first_key,u64 parent_transid); struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
fs/btrfs/super.c +1 -0
@@ -1531,6 +1531,7 @@ static struct dentry *btrfs_mount_root(struct file_system_type *fs_type, error = -ENOMEM ; goto error_sec_opts; } +btrfs_init_fs_info (fs_info); fs_info->super_copy =kzalloc (BTRFS_SUPER_INFO_SIZE ,GFP_KERNEL ); fs_info->super_for_commit =kzalloc (BTRFS_SUPER_INFO_SIZE ,GFP_KERNEL );
fs/btrfs/tests/btrfs-tests.c +4 -24
@@ -120,6 +120,8 @@ struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(u32 nodesize, u32 sectorsize)kfree (fs_info);return NULL ; } +INIT_LIST_HEAD (&fs_info->fs_devices->devices); + fs_info->super_copy =kzalloc (sizeof (struct btrfs_super_block ),GFP_KERNEL );if (!fs_info->super_copy) {
@@ -128,6 +130,8 @@ struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(u32 nodesize, u32 sectorsize)return NULL ; } +btrfs_init_fs_info (fs_info); + fs_info->nodesize = nodesize; fs_info->sectorsize = sectorsize;
@@ -138,30 +142,6 @@ struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(u32 nodesize, u32 sectorsize)return NULL ; } -spin_lock_init (&fs_info->buffer_lock); -spin_lock_init (&fs_info->qgroup_lock); -spin_lock_init (&fs_info->super_lock); -spin_lock_init (&fs_info->fs_roots_radix_lock); -spin_lock_init (&fs_info->tree_mod_seq_lock); -mutex_init (&fs_info->qgroup_ioctl_lock); -mutex_init (&fs_info->qgroup_rescan_lock); -rwlock_init (&fs_info->tree_mod_log_lock); - fs_info->running_transaction =NULL ; - fs_info->qgroup_tree =RB_ROOT ; - fs_info->qgroup_ulist =NULL ; -atomic64_set (&fs_info->tree_mod_seq,0 ); -INIT_LIST_HEAD (&fs_info->dirty_qgroups); -INIT_LIST_HEAD (&fs_info->dead_roots); -INIT_LIST_HEAD (&fs_info->tree_mod_seq_list); -INIT_LIST_HEAD (&fs_info->fs_devices->devices); -INIT_RADIX_TREE (&fs_info->buffer_radix,GFP_ATOMIC ); -INIT_RADIX_TREE (&fs_info->fs_roots_radix,GFP_ATOMIC ); -extent_io_tree_init (fs_info, &fs_info->freed_extents[0 ], -IO_TREE_FS_INFO_FREED_EXTENTS0 ,NULL ); -extent_io_tree_init (fs_info, &fs_info->freed_extents[1 ], -IO_TREE_FS_INFO_FREED_EXTENTS1 ,NULL ); -extent_map_tree_init (&fs_info->mapping_tree); - fs_info->pinned_extents = &fs_info->freed_extents[0 ];set_bit (BTRFS_FS_STATE_DUMMY_FS_INFO , &fs_info->fs_state); test_mnt->mnt_sb->s_fs_info = fs_info;
Signature · 1 line
2.24.1
PATCH v3 42/43 btrfs: add a leak check for roots
In reply to Josef BacikNow that we're going to start relying on getting ref counting right for roots, add a list to track allocated roots and print out any roots that aren't free'd up at free_fs_info time. Hide this behind CONFIG_BTRFS_DEBUG because this will just be used for developers to verify they aren't breaking things.
--- fs/btrfs/ctree.h | 5 +++++ fs/btrfs/disk-io.c | 28 ++++++++++++++++++++++++++++ fs/btrfs/disk-io.h | 9 ++++++++- fs/btrfs/tests/btrfs-tests.c | 1 + 4 files changed, 42 insertions(+), 1 deletion(-)
fs/btrfs/ctree.h +5 -0
@@ -949,6 +949,7 @@ struct btrfs_fs_info {#ifdef CONFIG_BTRFS_DEBUG struct kobject *debug_kobj;struct kobject *discard_debug_kobj; +struct list_head alloced_roots;#endif };
@@ -1151,6 +1152,10 @@ struct btrfs_root {#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS u64 alloc_bytenr;#endif + +#ifdef CONFIG_BTRFS_DEBUG +struct list_head leak_list; +#endif };struct btrfs_clone_extent_info {
fs/btrfs/disk-io.c +28 -0
@@ -1202,6 +1202,12 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,spin_lock_init (&root->root_item_lock);btrfs_qgroup_init_swapped_blocks (&root->swapped_blocks); +#ifdef CONFIG_BTRFS_DEBUG +INIT_LIST_HEAD (&root->leak_list); +spin_lock (&fs_info->fs_roots_radix_lock); +list_add_tail (&root->leak_list, &fs_info->alloced_roots); +spin_unlock (&fs_info->fs_roots_radix_lock); +#endif } static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
@@ -1531,6 +1537,24 @@ int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,return ret; } +void btrfs_check_leaked_roots (struct btrfs_fs_info *fs_info) +{ +#ifdef CONFIG_BTRFS_DEBUG +struct btrfs_root *root; + +while (!list_empty (&fs_info->alloced_roots)) { + root =list_first_entry (&fs_info->alloced_roots, + struct btrfs_root, leak_list); +btrfs_err (fs_info,"leaked root %llu-%llu refcount %d" , + root->root_key.objectid, root->root_key.offset, +refcount_read (&root->refs)); +while (refcount_read (&root->refs) >1 ) +btrfs_put_fs_root (root); +btrfs_put_fs_root (root); + } +#endif +} +void btrfs_free_fs_info (struct btrfs_fs_info *fs_info) {percpu_counter_destroy (&fs_info->dirty_metadata_bytes);
@@ -1551,6 +1575,7 @@ void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)btrfs_put_fs_root (fs_info->uuid_root);btrfs_put_fs_root (fs_info->free_space_root);btrfs_put_fs_root (fs_info->fs_root); +btrfs_check_leaked_roots (fs_info);kfree (fs_info->super_copy);kfree (fs_info->super_for_commit);kvfree (fs_info);
@@ -2678,6 +2703,9 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)INIT_LIST_HEAD (&fs_info->space_info);INIT_LIST_HEAD (&fs_info->tree_mod_seq_list);INIT_LIST_HEAD (&fs_info->unused_bgs); +#ifdef CONFIG_BTRFS_DEBUG +INIT_LIST_HEAD (&fs_info->alloced_roots); +#endif extent_map_tree_init (&fs_info->mapping_tree);btrfs_init_block_rsv (&fs_info->global_block_rsv,BTRFS_BLOCK_RSV_GLOBAL );
fs/btrfs/disk-io.h +8 -1
@@ -39,6 +39,7 @@ static inline u64 btrfs_sb_offset(int mirror)struct btrfs_device ;struct btrfs_fs_devices ; +void btrfs_check_leaked_roots (struct btrfs_fs_info *fs_info);void btrfs_init_fs_info (struct btrfs_fs_info *fs_info);int btrfs_verify_level_key (struct extent_buffer *eb,int level,struct btrfs_key *first_key,u64 parent_transid);
@@ -101,8 +102,14 @@ static inline void btrfs_put_fs_root(struct btrfs_root *root) {if (!root)return ; -if (refcount_dec_and_test (&root->refs)) +if (refcount_dec_and_test (&root->refs)) { +#ifdef CONFIG_BTRFS_DEBUG +spin_lock (&root->fs_info->fs_roots_radix_lock); +list_del_init (&root->leak_list); +spin_unlock (&root->fs_info->fs_roots_radix_lock); +#endif kfree (root); + } }void btrfs_mark_buffer_dirty (struct extent_buffer *buf);
fs/btrfs/tests/btrfs-tests.c +1 -0
@@ -193,6 +193,7 @@ void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info)btrfs_free_fs_roots (fs_info);cleanup_srcu_struct (&fs_info->subvol_srcu);kfree (fs_info->super_copy); +btrfs_check_leaked_roots (fs_info);kfree (fs_info->fs_devices);kfree (fs_info); }
Signature · 1 line
2.24.1
PATCH v3 43/43 btrfs: rename btrfs_put_fs_root and btrfs_grab_fs_root
In reply to Josef BacikWe are now using these for all roots, rename them to btrfs_put_root() and btrfs_grab_root();
--- fs/btrfs/backref.c | 2 +- fs/btrfs/disk-io.c | 78 ++++++++++++++++++------------------ fs/btrfs/disk-io.h | 4 +- fs/btrfs/export.c | 2 +- fs/btrfs/extent-tree.c | 2 +- fs/btrfs/file.c | 2 +- fs/btrfs/free-space-tree.c | 2 +- fs/btrfs/inode.c | 6 +-- fs/btrfs/ioctl.c | 18 ++++----- fs/btrfs/ordered-data.c | 4 +- fs/btrfs/qgroup.c | 4 +- fs/btrfs/relocation.c | 48 +++++++++++----------- fs/btrfs/root-tree.c | 2 +- fs/btrfs/scrub.c | 6 +-- fs/btrfs/send.c | 12 +++--- fs/btrfs/super.c | 10 ++--- fs/btrfs/tests/btrfs-tests.c | 2 +- fs/btrfs/tree-log.c | 10 ++--- fs/btrfs/volumes.c | 2 +- 19 files changed, 108 insertions(+), 108 deletions(-)
fs/btrfs/backref.c +1 -1
@@ -577,7 +577,7 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, ret =add_all_parents (root, path, parents, ref, level, time_seq, extent_item_pos, total_refs, ignore_offset); out: -btrfs_put_fs_root (root); +btrfs_put_root (root); out_free: path->lowest_level =0 ;btrfs_release_path (path);
fs/btrfs/disk-io.c +39 -39
216 lines not on this page · raw message
fs/btrfs/disk-io.h +2 -2
@@ -89,7 +89,7 @@ struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info);* If you want to ensure the whole tree is safe, you should use * fs_info->subvol_srcu */ -static inline struct btrfs_root *btrfs_grab_fs_root (struct btrfs_root *root) +static inline struct btrfs_root *btrfs_grab_root (struct btrfs_root *root) {if (!root)return NULL ;
@@ -98,7 +98,7 @@ static inline struct btrfs_root *btrfs_grab_fs_root(struct btrfs_root *root)return NULL ; } -static inline void btrfs_put_fs_root (struct btrfs_root *root) +static inline void btrfs_put_root (struct btrfs_root *root) {if (!root)return ;
fs/btrfs/export.c +1 -1
@@ -88,7 +88,7 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, key.offset =0 ; inode =btrfs_iget (sb, &key, root); -btrfs_put_fs_root (root); +btrfs_put_root (root);if (IS_ERR (inode)) { err =PTR_ERR (inode); goto fail;
fs/btrfs/extent-tree.c +1 -1
@@ -5416,7 +5416,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root, }else {free_extent_buffer (root->node);free_extent_buffer (root->commit_root); -btrfs_put_fs_root (root); +btrfs_put_root (root); } root_dropped = true; out_end_trans:
fs/btrfs/file.c +1 -1
@@ -297,7 +297,7 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, key.type =BTRFS_INODE_ITEM_KEY ; key.offset =0 ; inode =btrfs_iget (fs_info->sb, &key, inode_root); -btrfs_put_fs_root (inode_root); +btrfs_put_root (inode_root);if (IS_ERR (inode)) { ret =PTR_ERR (inode); goto cleanup;
fs/btrfs/free-space-tree.c +1 -1
@@ -1253,7 +1253,7 @@ int btrfs_clear_free_space_tree(struct btrfs_fs_info *fs_info)free_extent_buffer (free_space_root->node);free_extent_buffer (free_space_root->commit_root); -btrfs_put_fs_root (free_space_root); +btrfs_put_root (free_space_root);return btrfs_commit_transaction (trans);
fs/btrfs/inode.c +3 -3
@@ -5269,7 +5269,7 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry) inode =btrfs_iget (dir->i_sb, &location, sub_root); }if (root != sub_root) -btrfs_put_fs_root (sub_root); +btrfs_put_root (sub_root);srcu_read_unlock (&fs_info->subvol_srcu, index);if (!IS_ERR (inode) && root != sub_root) {
@@ -9588,14 +9588,14 @@ int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int nr)while (!list_empty (&splice) && nr) { root = list_first_entry(&splice, struct btrfs_root, delalloc_root); - root =btrfs_grab_fs_root (root); + root =btrfs_grab_root (root);BUG_ON (!root);list_move_tail (&root->delalloc_root, &fs_info->delalloc_roots);spin_unlock (&fs_info->delalloc_root_lock); ret =start_delalloc_inodes (root, nr, false); -btrfs_put_fs_root (root); +btrfs_put_root (root);if (ret <0 ) goto out;
fs/btrfs/ioctl.c +9 -9
@@ -676,7 +676,7 @@ static noinline int create_subvol(struct inode *dir,btrfs_record_root_in_trans (trans, new_root); ret =btrfs_create_subvol_root (trans, new_root, root, new_dirid); -btrfs_put_fs_root (new_root); +btrfs_put_root (new_root);if (ret) {/* We potentially lose an unused inode item here */ btrfs_abort_transaction (trans, ret);
@@ -870,7 +870,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,d_instantiate (dentry, inode); ret =0 ; fail: -btrfs_put_fs_root (pending_snapshot->snap); +btrfs_put_root (pending_snapshot->snap);btrfs_subvolume_release_metadata (fs_info, &pending_snapshot->block_rsv); dec_and_free:if (snapshot_force_cow)
@@ -2176,7 +2176,7 @@ static noinline int search_ioctl(struct inode *inode,if (sk->tree_id ==0 ) {/* search the root of the inode that was passed */ - root =btrfs_grab_fs_root (BTRFS_I (inode)->root); + root =btrfs_grab_root (BTRFS_I (inode)->root); }else { key.objectid = sk->tree_id; key.type =BTRFS_ROOT_ITEM_KEY ;
@@ -2210,7 +2210,7 @@ static noinline int search_ioctl(struct inode *inode, ret =0 ; err: sk->nr_items = num_found; -btrfs_put_fs_root (root); +btrfs_put_root (root);btrfs_free_path (path);return ret; }
@@ -2372,7 +2372,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, ret =0 ; out:if (root) -btrfs_put_fs_root (root); +btrfs_put_root (root);btrfs_free_path (path);return ret; }
@@ -2500,7 +2500,7 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,memmove (args->path, ptr, total_len); args->path[total_len] ='\0' ; -btrfs_put_fs_root (root); +btrfs_put_root (root);btrfs_release_path (path); }
@@ -2540,7 +2540,7 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,btrfs_free_path (path);return ret; out_put: -btrfs_put_fs_root (root); +btrfs_put_root (root); goto out; }
@@ -2743,7 +2743,7 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp) ret = -EFAULT ; out: -btrfs_put_fs_root (root); +btrfs_put_root (root); out_free:btrfs_free_path (path);kzfree (subvol_info);
@@ -4035,7 +4035,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)btrfs_set_fs_incompat (fs_info,DEFAULT_SUBVOL );btrfs_end_transaction (trans); out_free: -btrfs_put_fs_root (new_root); +btrfs_put_root (new_root);btrfs_free_path (path); out:mnt_drop_write_file (file);
fs/btrfs/ordered-data.c +2 -2
@@ -580,7 +580,7 @@ void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,while (!list_empty (&splice) && nr) { root = list_first_entry(&splice, struct btrfs_root, ordered_root); - root =btrfs_grab_fs_root (root); + root =btrfs_grab_root (root);BUG_ON (!root);list_move_tail (&root->ordered_root, &fs_info->ordered_roots);
@@ -588,7 +588,7 @@ void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr, done =btrfs_wait_ordered_extents (root, nr, range_start, range_len); -btrfs_put_fs_root (root); +btrfs_put_root (root);spin_lock (&fs_info->ordered_root_lock);if (nr !=U64_MAX ) {
fs/btrfs/qgroup.c +2 -2
@@ -1040,7 +1040,7 @@ int btrfs_quota_enable(struct btrfs_fs_info *fs_info)if (ret) {free_extent_buffer (quota_root->node);free_extent_buffer (quota_root->commit_root); -btrfs_put_fs_root (quota_root); +btrfs_put_root (quota_root); } out:if (ret) {
@@ -1106,7 +1106,7 @@ int btrfs_quota_disable(struct btrfs_fs_info *fs_info)free_extent_buffer (quota_root->node);free_extent_buffer (quota_root->commit_root); -btrfs_put_fs_root (quota_root); +btrfs_put_root (quota_root); end_trans: ret =btrfs_end_transaction (trans);
fs/btrfs/relocation.c +24 -24
180 lines not on this page · raw message
fs/btrfs/root-tree.c +1 -1
@@ -288,7 +288,7 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)set_bit (BTRFS_ROOT_DEAD_TREE , &root->state);btrfs_add_dead_root (root); } -btrfs_put_fs_root (root); +btrfs_put_root (root); }btrfs_free_path (path);
fs/btrfs/scrub.c +3 -3
@@ -668,7 +668,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, ret =btrfs_search_slot (NULL , local_root, &key, swarn->path,0 ,0 );if (ret) { -btrfs_put_fs_root (local_root); +btrfs_put_root (local_root);btrfs_release_path (swarn->path); goto err; }
@@ -689,7 +689,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, ipath =init_ipath (4096 , local_root, swarn->path);memalloc_nofs_restore (nofs_flag);if (IS_ERR (ipath)) { -btrfs_put_fs_root (local_root); +btrfs_put_root (local_root); ret =PTR_ERR (ipath); ipath =NULL ; goto err;
@@ -713,7 +713,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,min (isize - offset, (u64 )PAGE_SIZE ), nlink, (char *)(unsigned long)ipath->fspath->val[i]); -btrfs_put_fs_root (local_root); +btrfs_put_root (local_root);free_ipath (ipath);return 0 ;
fs/btrfs/send.c +6 -6
@@ -7205,7 +7205,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) btrfs_root_dead(clone_root)) {spin_unlock (&clone_root->root_item_lock);srcu_read_unlock (&fs_info->subvol_srcu, index); -btrfs_put_fs_root (clone_root); +btrfs_put_root (clone_root); ret = -EPERM ; goto out; }
@@ -7213,7 +7213,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)dedupe_in_progress_warn (clone_root);spin_unlock (&clone_root->root_item_lock);srcu_read_unlock (&fs_info->subvol_srcu, index); -btrfs_put_fs_root (clone_root); +btrfs_put_root (clone_root); ret = -EAGAIN ; goto out; }
@@ -7269,7 +7269,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)* for possible clone sources. */ sctx->clone_roots[sctx->clone_roots_cnt++].root = -btrfs_grab_fs_root (sctx->send_root); +btrfs_grab_root (sctx->send_root);/* We do a bsearch later */ sort(sctx->clone_roots, sctx->clone_roots_cnt,
@@ -7357,20 +7357,20 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)for (i =0 ; i < sctx->clone_roots_cnt; i++) {btrfs_root_dec_send_in_progress ( sctx->clone_roots[i].root); -btrfs_put_fs_root (sctx->clone_roots[i].root); +btrfs_put_root (sctx->clone_roots[i].root); } }else {for (i =0 ; sctx && i < clone_sources_to_rollback; i++) {btrfs_root_dec_send_in_progress ( sctx->clone_roots[i].root); -btrfs_put_fs_root (sctx->clone_roots[i].root); +btrfs_put_root (sctx->clone_roots[i].root); }btrfs_root_dec_send_in_progress (send_root); }if (sctx && !IS_ERR_OR_NULL (sctx->parent_root)) {btrfs_root_dec_send_in_progress (sctx->parent_root); -btrfs_put_fs_root (sctx->parent_root); +btrfs_put_root (sctx->parent_root); }kvfree (clone_sources_tmp);
fs/btrfs/super.c +5 -5
@@ -1113,16 +1113,16 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ret =btrfs_search_slot (NULL , fs_root, &key, path,0 ,0 );if (ret <0 ) { -btrfs_put_fs_root (fs_root); +btrfs_put_root (fs_root); goto err; }else if (ret >0 ) { ret =btrfs_previous_item (fs_root, path, dirid,BTRFS_INODE_REF_KEY );if (ret <0 ) { -btrfs_put_fs_root (fs_root); +btrfs_put_root (fs_root); goto err; }else if (ret >0 ) { -btrfs_put_fs_root (fs_root); +btrfs_put_root (fs_root); ret = -ENOENT ; goto err; }
@@ -1139,7 +1139,7 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ptr -= len +1 ;if (ptr < name) { ret = -ENAMETOOLONG ; -btrfs_put_fs_root (fs_root); +btrfs_put_root (fs_root); goto err; } read_extent_buffer(path->nodes[0], ptr + 1,
@@ -1147,7 +1147,7 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, ptr[0 ] ='/' ;btrfs_release_path (path); } -btrfs_put_fs_root (fs_root); +btrfs_put_root (fs_root); }btrfs_free_path (path);
fs/btrfs/tests/btrfs-tests.c +1 -1
@@ -209,7 +209,7 @@ void btrfs_free_dummy_root(struct btrfs_root *root)/* One for allocate_extent_buffer */ free_extent_buffer (root->node); } -btrfs_put_fs_root (root); +btrfs_put_root (root); } struct btrfs_block_group *
fs/btrfs/tree-log.c +5 -5
@@ -3284,7 +3284,7 @@ static void free_log_tree(struct btrfs_trans_handle *trans,clear_extent_bits (&log->dirty_log_pages,0 , (u64)-1 ,EXTENT_DIRTY |EXTENT_NEW |EXTENT_NEED_WAIT );free_extent_buffer (log->node); -btrfs_put_fs_root (log); +btrfs_put_root (log); }/*
@@ -6134,7 +6134,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) log->node->len);free_extent_buffer (log->node);free_extent_buffer (log->commit_root); -btrfs_put_fs_root (log); +btrfs_put_root (log);if (!ret) goto next;
@@ -6170,10 +6170,10 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) } wc.replay_dest->log_root =NULL ; -btrfs_put_fs_root (wc.replay_dest); +btrfs_put_root (wc.replay_dest);free_extent_buffer (log->node);free_extent_buffer (log->commit_root); -btrfs_put_fs_root (log); +btrfs_put_root (log);if (ret) goto error;
@@ -6207,7 +6207,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)free_extent_buffer (log_root_tree->node); log_root_tree->log_root =NULL ;clear_bit (BTRFS_FS_LOG_RECOVERING , &fs_info->flags); -btrfs_put_fs_root (log_root_tree); +btrfs_put_root (log_root_tree);return 0 ; error:
fs/btrfs/volumes.c +1 -1
@@ -4394,7 +4394,7 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info, ret =1 ;break ; } -btrfs_put_fs_root (subvol_root); +btrfs_put_root (subvol_root); out:return ret; }
Signature · 1 line
2.24.1