Commit c75e8394 authored by Josef Bacik's avatar Josef Bacik Committed by David Sterba
Browse files

btrfs: kill the subvol_srcu 



Now that we have proper root ref counting everywhere we can kill the
subvol_srcu.

* removal of fs_info::subvol_srcu reduces size of fs_info by 1176 bytes

* the refcount_t used for the references checks for accidental 0->1
  in cases where the root lifetime would not be properly protected

* there's a leak detector for roots to catch unfreed roots at umount
  time

* SRCU served us well over the years but is was not a proper
  synchronization mechanism for some cases

Signed-off-by: default avatarJosef Bacik <josef@toxicpanda.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
[ update changelog ]
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent efc34534

fs/btrfs/backref.c

+1 −11
Original line number Diff line number Diff line
@@ -542,24 +542,19 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, 
	int ret = 0;

	int root_level;

	int level = ref->level;

	int index;

	struct btrfs_key search_key = ref->key_for_search;



	root_key.objectid = ref->root_id;

	root_key.type = BTRFS_ROOT_ITEM_KEY;

	root_key.offset = (u64)-1;



	index = srcu_read_lock(&fs_info->subvol_srcu);



	root = btrfs_get_fs_root(fs_info, &root_key, false);

	if (IS_ERR(root)) {

		srcu_read_unlock(&fs_info->subvol_srcu, index);

		ret = PTR_ERR(root);

		goto out_free;

	}



	if (btrfs_is_testing(fs_info)) {

		srcu_read_unlock(&fs_info->subvol_srcu, index);

		ret = -ENOENT;

		goto out;

	}
@@ -571,10 +566,8 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, 
	else

		root_level = btrfs_old_root_level(root, time_seq);



	if (root_level + 1 == level) {

		srcu_read_unlock(&fs_info->subvol_srcu, index);

	if (root_level + 1 == level)

		goto out;

	}



	/*

	 * We can often find data backrefs with an offset that is too large
@@ -604,9 +597,6 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, 
	else

		ret = btrfs_search_old_slot(root, &search_key, path, time_seq);



	/* root node has been locked, we can release @subvol_srcu safely here */

	srcu_read_unlock(&fs_info->subvol_srcu, index);



	btrfs_debug(fs_info,

		"search slot in root %llu (level %d, ref count %d) returned %d for key (%llu %u %llu)",

		 ref->root_id, level, ref->count, ret,

fs/btrfs/ctree.h

+0 −1
Original line number Diff line number Diff line
@@ -697,7 +697,6 @@ struct btrfs_fs_info { 
	struct rw_semaphore cleanup_work_sem;



	struct rw_semaphore subvol_sem;

	struct srcu_struct subvol_srcu;



	spinlock_t trans_lock;

	/*

fs/btrfs/disk-io.c

+9 −28
Original line number Diff line number Diff line
@@ -2757,46 +2757,33 @@ static int init_mount_fs_info(struct btrfs_fs_info *fs_info, struct super_block 
	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)

		return ret;



	ret = percpu_counter_init(&fs_info->dio_bytes, 0, GFP_KERNEL);

	if (ret)

		goto fail;

		return ret;



	ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);

	if (ret)

		goto fail;

		return ret;



	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;

		return ret;



	ret = percpu_counter_init(&fs_info->dev_replace.bio_counter, 0,

			GFP_KERNEL);

	if (ret)

		goto fail;

		return ret;



	fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),

					GFP_KERNEL);

	if (!fs_info->delayed_root) {

		ret = -ENOMEM;

		goto fail;

	}

	if (!fs_info->delayed_root)

		return -ENOMEM;

	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;

	return btrfs_alloc_stripe_hash_table(fs_info);

}



static int btrfs_uuid_rescan_kthread(void *data)
@@ -2870,13 +2857,13 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device 
	fs_info->chunk_root = chunk_root;

	if (!tree_root || !chunk_root) {

		err = -ENOMEM;

		goto fail_srcu;

		goto fail;

	}



	fs_info->btree_inode = new_inode(sb);

	if (!fs_info->btree_inode) {

		err = -ENOMEM;

		goto fail_srcu;

		goto fail;

	}

	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);

	btrfs_init_btree_inode(fs_info);
@@ -3398,8 +3385,6 @@ fail_alloc: 
	btrfs_mapping_tree_free(&fs_info->mapping_tree);



	iput(fs_info->btree_inode);

fail_srcu:

	cleanup_srcu_struct(&fs_info->subvol_srcu);

fail:

	btrfs_close_devices(fs_info->fs_devices);

	return err;
@@ -3902,9 +3887,6 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info, 
		drop_ref = true;

	spin_unlock(&fs_info->fs_roots_radix_lock);



	if (btrfs_root_refs(&root->root_item) == 0)

		synchronize_srcu(&fs_info->subvol_srcu);



	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {

		btrfs_free_log(NULL, root);

		if (root->reloc_root) {
@@ -4116,7 +4098,6 @@ 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);

	cleanup_srcu_struct(&fs_info->subvol_srcu);

}



int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,

fs/btrfs/export.c

+4 −17
Original line number Diff line number Diff line
@@ -65,8 +65,6 @@ struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, 
	struct btrfs_root *root;

	struct inode *inode;

	struct btrfs_key key;

	int index;

	int err = 0;



	if (objectid < BTRFS_FIRST_FREE_OBJECTID)

		return ERR_PTR(-ESTALE);
@@ -75,13 +73,9 @@ struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, 
	key.type = BTRFS_ROOT_ITEM_KEY;

	key.offset = (u64)-1;



	index = srcu_read_lock(&fs_info->subvol_srcu);



	root = btrfs_get_fs_root(fs_info, &key, true);

	if (IS_ERR(root)) {

		err = PTR_ERR(root);

		goto fail;

	}

	if (IS_ERR(root))

		return ERR_CAST(root);



	key.objectid = objectid;

	key.type = BTRFS_INODE_ITEM_KEY;
@@ -89,12 +83,8 @@ struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, 


	inode = btrfs_iget(sb, &key, root);

	btrfs_put_root(root);

	if (IS_ERR(inode)) {

		err = PTR_ERR(inode);

		goto fail;

	}



	srcu_read_unlock(&fs_info->subvol_srcu, index);

	if (IS_ERR(inode))

		return ERR_CAST(inode);



	if (check_generation && generation != inode->i_generation) {

		iput(inode);
@@ -102,9 +92,6 @@ struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, 
	}



	return d_obtain_alias(inode);

fail:

	srcu_read_unlock(&fs_info->subvol_srcu, index);

	return ERR_PTR(err);

}



static struct dentry *btrfs_fh_to_parent(struct super_block *sb, struct fid *fh,

fs/btrfs/file.c

+0 −5
Original line number Diff line number Diff line
@@ -278,7 +278,6 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, 
	struct btrfs_key key;

	struct btrfs_ioctl_defrag_range_args range;

	int num_defrag;

	int index;

	int ret;



	/* get the inode */
@@ -286,8 +285,6 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, 
	key.type = BTRFS_ROOT_ITEM_KEY;

	key.offset = (u64)-1;



	index = srcu_read_lock(&fs_info->subvol_srcu);



	inode_root = btrfs_get_fs_root(fs_info, &key, true);

	if (IS_ERR(inode_root)) {

		ret = PTR_ERR(inode_root);
@@ -303,7 +300,6 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, 
		ret = PTR_ERR(inode);

		goto cleanup;

	}

	srcu_read_unlock(&fs_info->subvol_srcu, index);



	/* do a chunk of defrag */

	clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
@@ -339,7 +335,6 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, 
	iput(inode);

	return 0;

cleanup:

	srcu_read_unlock(&fs_info->subvol_srcu, index);

	kmem_cache_free(btrfs_inode_defrag_cachep, defrag);

	return ret;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE