10 files changed, 103 insertions, 61 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 61a53cca5963..1cb84e01f2fd 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -117,6 +117,7 @@ static inline unsigned long btrfs_chunk_item_size(int num_stripes)
 #define BTRFS_FS_STATE_REMOUNTING       1
 #define BTRFS_FS_STATE_TRANS_ABORTED    2
 #define BTRFS_FS_STATE_DEV_REPLACING    3
+#define BTRFS_FS_STATE_DUMMY_FS_INFO    4
 
 #define BTRFS_BACKREF_REV_MAX           256
 #define BTRFS_BACKREF_REV_SHIFT         56
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 802a3113854f..8e838b1cc806 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1233,6 +1233,7 @@ static void __setup_root(u32 nodesize, u32 sectorsize, u32 stripesize,
                          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->node = NULL;
         root->commit_root = NULL;
         root->sectorsize = sectorsize;
@@ -1287,14 +1288,14 @@ static void __setup_root(u32 nodesize, u32 sectorsize, u32 stripesize,
         root->log_transid = 0;
         root->log_transid_committed = -1;
         root->last_log_commit = 0;
-        if (fs_info)
+        if (!dummy)
                 extent_io_tree_init(&root->dirty_log_pages,
                                      fs_info->btree_inode->i_mapping);
 
         memset(&root->root_key, 0, sizeof(root->root_key));
         memset(&root->root_item, 0, sizeof(root->root_item));
         memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
-        if (fs_info)
+        if (!dummy)
                 root->defrag_trans_start = fs_info->generation;
         else
                 root->defrag_trans_start = 0;
@@ -1315,15 +1316,19 @@ static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
 
 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
 /* Should only be used by the testing infrastructure */
-struct btrfs_root *btrfs_alloc_dummy_root(u32 sectorsize, u32 nodesize)
+struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info,
+                                          u32 sectorsize, u32 nodesize)
 {
         struct btrfs_root *root;
 
-        root = btrfs_alloc_root(NULL, GFP_KERNEL);
+        if (!fs_info)
+                return ERR_PTR(-EINVAL);
+
+        root = btrfs_alloc_root(fs_info, GFP_KERNEL);
         if (!root)
                 return ERR_PTR(-ENOMEM);
         /* We don't use the stripesize in selftest, set it as sectorsize */
-        __setup_root(nodesize, sectorsize, sectorsize, root, NULL,
+        __setup_root(nodesize, sectorsize, sectorsize, root, fs_info,
                         BTRFS_ROOT_TREE_OBJECTID);
         set_bit(BTRFS_ROOT_DUMMY_ROOT, &root->state);
         root->alloc_bytenr = 0;
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index acba821499a9..c9d42c92da2b 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -90,7 +90,8 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
 void btrfs_free_fs_root(struct btrfs_root *root);
 
 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
-struct btrfs_root *btrfs_alloc_dummy_root(u32 sectorsize, u32 nodesize);
+struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info,
+                                          u32 sectorsize, u32 nodesize);
 #endif
 
 /*
diff --git a/fs/btrfs/tests/btrfs-tests.c b/fs/btrfs/tests/btrfs-tests.c
index 71d9a0129347..bf62ad919a95 100644
--- a/fs/btrfs/tests/btrfs-tests.c
+++ b/fs/btrfs/tests/btrfs-tests.c
@@ -128,14 +128,27 @@ struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(void)
         extent_io_tree_init(&fs_info->freed_extents[0], NULL);
         extent_io_tree_init(&fs_info->freed_extents[1], NULL);
         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;
+
         return fs_info;
 }
 
-static void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info)
+void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info)
 {
         struct radix_tree_iter iter;
         void **slot;
 
+        if (!fs_info)
+                return;
+
+        if (WARN_ON(!test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO,
+                              &fs_info->fs_state)))
+                return;
+
+        test_mnt->mnt_sb->s_fs_info = NULL;
+
         spin_lock(&fs_info->buffer_lock);
         radix_tree_for_each_slot(slot, &fs_info->buffer_radix, &iter, 0) {
                 struct extent_buffer *eb;
@@ -167,10 +180,11 @@ void btrfs_free_dummy_root(struct btrfs_root *root)
 {
         if (!root)
                 return;
+        /* Will be freed by btrfs_free_fs_roots */
+        if (WARN_ON(test_bit(BTRFS_ROOT_IN_RADIX, &root->state)))
+                return;
         if (root->node)
                 free_extent_buffer(root->node);
-        if (root->fs_info)
-                btrfs_free_dummy_fs_info(root->fs_info);
         kfree(root);
 }
 
diff --git a/fs/btrfs/tests/btrfs-tests.h b/fs/btrfs/tests/btrfs-tests.h
index e7d364f315db..b17ffbe8f9f3 100644
--- a/fs/btrfs/tests/btrfs-tests.h
+++ b/fs/btrfs/tests/btrfs-tests.h
@@ -35,6 +35,7 @@ int btrfs_test_qgroups(u32 sectorsize, u32 nodesize);
 int btrfs_test_free_space_tree(u32 sectorsize, u32 nodesize);
 struct inode *btrfs_new_test_inode(void);
 struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(void);
+void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info);
 void btrfs_free_dummy_root(struct btrfs_root *root);
 struct btrfs_block_group_cache *
 btrfs_alloc_dummy_block_group(unsigned long length, u32 sectorsize);
diff --git a/fs/btrfs/tests/extent-buffer-tests.c b/fs/btrfs/tests/extent-buffer-tests.c
index 4f8cbd1ec5ee..199569174637 100644
--- a/fs/btrfs/tests/extent-buffer-tests.c
+++ b/fs/btrfs/tests/extent-buffer-tests.c
@@ -24,8 +24,9 @@
 
 static int test_btrfs_split_item(u32 sectorsize, u32 nodesize)
 {
-        struct btrfs_path *path;
-        struct btrfs_root *root;
+        struct btrfs_fs_info *fs_info;
+        struct btrfs_path *path = NULL;
+        struct btrfs_root *root = NULL;
         struct extent_buffer *eb;
         struct btrfs_item *item;
         char *value = "mary had a little lamb";
@@ -40,17 +41,24 @@ static int test_btrfs_split_item(u32 sectorsize, u32 nodesize)
 
         test_msg("Running btrfs_split_item tests\n");
 
-        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
+        fs_info = btrfs_alloc_dummy_fs_info();
+        if (!fs_info) {
+                test_msg("Could not allocate fs_info\n");
+                return -ENOMEM;
+        }
+
+        root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
         if (IS_ERR(root)) {
                 test_msg("Could not allocate root\n");
-                return PTR_ERR(root);
+                ret = PTR_ERR(root);
+                goto out;
         }
 
         path = btrfs_alloc_path();
         if (!path) {
                 test_msg("Could not allocate path\n");
-                kfree(root);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto out;
         }
 
         path->nodes[0] = eb = alloc_dummy_extent_buffer(NULL, nodesize,
@@ -219,7 +227,8 @@ static int test_btrfs_split_item(u32 sectorsize, u32 nodesize)
         }
 out:
         btrfs_free_path(path);
-        kfree(root);
+        btrfs_free_dummy_root(root);
+        btrfs_free_dummy_fs_info(fs_info);
         return ret;
 }
 
diff --git a/fs/btrfs/tests/free-space-tests.c b/fs/btrfs/tests/free-space-tests.c
index 3956bb2ff84c..3221c8dee272 100644
--- a/fs/btrfs/tests/free-space-tests.c
+++ b/fs/btrfs/tests/free-space-tests.c
@@ -837,6 +837,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache,
 
 int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize)
 {
+        struct btrfs_fs_info *fs_info;
         struct btrfs_block_group_cache *cache;
         struct btrfs_root *root = NULL;
         int ret = -ENOMEM;
@@ -855,15 +856,17 @@ int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize)
                 return 0;
         }
 
-        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
-        if (IS_ERR(root)) {
-                ret = PTR_ERR(root);
+        fs_info = btrfs_alloc_dummy_fs_info();
+        if (!fs_info) {
+                ret = -ENOMEM;
                 goto out;
         }
 
-        root->fs_info = btrfs_alloc_dummy_fs_info();
-        if (!root->fs_info)
+        root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
+        if (IS_ERR(root)) {
+                ret = PTR_ERR(root);
                 goto out;
+        }
 
         root->fs_info->extent_root = root;
         cache->fs_info = root->fs_info;
@@ -882,6 +885,7 @@ int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize)
 out:
         btrfs_free_dummy_block_group(cache);
         btrfs_free_dummy_root(root);
+        btrfs_free_dummy_fs_info(fs_info);
         test_msg("Free space cache tests finished\n");
         return ret;
 }
diff --git a/fs/btrfs/tests/free-space-tree-tests.c b/fs/btrfs/tests/free-space-tree-tests.c
index aac507085ab0..7508d3b42780 100644
--- a/fs/btrfs/tests/free-space-tree-tests.c
+++ b/fs/btrfs/tests/free-space-tree-tests.c
@@ -443,23 +443,24 @@ typedef int (*test_func_t)(struct btrfs_trans_handle *,
 static int run_test(test_func_t test_func, int bitmaps,
                 u32 sectorsize, u32 nodesize)
 {
+        struct btrfs_fs_info *fs_info;
         struct btrfs_root *root = NULL;
         struct btrfs_block_group_cache *cache = NULL;
         struct btrfs_trans_handle trans;
         struct btrfs_path *path = NULL;
         int ret;
 
-        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
-        if (IS_ERR(root)) {
-                test_msg("Couldn't allocate dummy root\n");
-                ret = PTR_ERR(root);
+        fs_info = btrfs_alloc_dummy_fs_info();
+        if (!fs_info) {
+                test_msg("Couldn't allocate dummy fs info\n");
+                ret = -ENOMEM;
                 goto out;
         }
 
-        root->fs_info = btrfs_alloc_dummy_fs_info();
-        if (!root->fs_info) {
-                test_msg("Couldn't allocate dummy fs info\n");
-                ret = -ENOMEM;
+        root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
+        if (IS_ERR(root)) {
+                test_msg("Couldn't allocate dummy root\n");
+                ret = PTR_ERR(root);
                 goto out;
         }
 
@@ -534,6 +535,7 @@ out:
         btrfs_free_path(path);
         btrfs_free_dummy_block_group(cache);
         btrfs_free_dummy_root(root);
+        btrfs_free_dummy_fs_info(fs_info);
         return ret;
 }
 
diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c
index 29648c0a39f1..9f72aeda9220 100644
--- a/fs/btrfs/tests/inode-tests.c
+++ b/fs/btrfs/tests/inode-tests.c
@@ -230,6 +230,7 @@ static unsigned long vacancy_only = 0;
 
 static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
 {
+        struct btrfs_fs_info *fs_info = NULL;
         struct inode *inode = NULL;
         struct btrfs_root *root = NULL;
         struct extent_map *em = NULL;
@@ -248,19 +249,15 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
         BTRFS_I(inode)->location.objectid = BTRFS_FIRST_FREE_OBJECTID;
         BTRFS_I(inode)->location.offset = 0;
 
-        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
-        if (IS_ERR(root)) {
-                test_msg("Couldn't allocate root\n");
+        fs_info = btrfs_alloc_dummy_fs_info();
+        if (!fs_info) {
+                test_msg("Couldn't allocate dummy fs info\n");
                 goto out;
         }
 
-        /*
-         * We do this since btrfs_get_extent wants to assign em->bdev to
-         * root->fs_info->fs_devices->latest_bdev.
-         */
-        root->fs_info = btrfs_alloc_dummy_fs_info();
-        if (!root->fs_info) {
-                test_msg("Couldn't allocate dummy fs info\n");
+        root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
+        if (IS_ERR(root)) {
+                test_msg("Couldn't allocate root\n");
                 goto out;
         }
 
@@ -835,11 +832,13 @@ out:
                 free_extent_map(em);
         iput(inode);
         btrfs_free_dummy_root(root);
+        btrfs_free_dummy_fs_info(fs_info);
         return ret;
 }
 
 static int test_hole_first(u32 sectorsize, u32 nodesize)
 {
+        struct btrfs_fs_info *fs_info = NULL;
         struct inode *inode = NULL;
         struct btrfs_root *root = NULL;
         struct extent_map *em = NULL;
@@ -855,15 +854,15 @@ static int test_hole_first(u32 sectorsize, u32 nodesize)
         BTRFS_I(inode)->location.objectid = BTRFS_FIRST_FREE_OBJECTID;
         BTRFS_I(inode)->location.offset = 0;
 
-        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
-        if (IS_ERR(root)) {
-                test_msg("Couldn't allocate root\n");
+        fs_info = btrfs_alloc_dummy_fs_info();
+        if (!fs_info) {
+                test_msg("Couldn't allocate dummy fs info\n");
                 goto out;
         }
 
-        root->fs_info = btrfs_alloc_dummy_fs_info();
-        if (!root->fs_info) {
-                test_msg("Couldn't allocate dummy fs info\n");
+        root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
+        if (IS_ERR(root)) {
+                test_msg("Couldn't allocate root\n");
                 goto out;
         }
 
@@ -934,11 +933,13 @@ out:
                 free_extent_map(em);
         iput(inode);
         btrfs_free_dummy_root(root);
+        btrfs_free_dummy_fs_info(fs_info);
         return ret;
 }
 
 static int test_extent_accounting(u32 sectorsize, u32 nodesize)
 {
+        struct btrfs_fs_info *fs_info = NULL;
         struct inode *inode = NULL;
         struct btrfs_root *root = NULL;
         int ret = -ENOMEM;
@@ -949,15 +950,15 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize)
                 return ret;
         }
 
-        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
-        if (IS_ERR(root)) {
-                test_msg("Couldn't allocate root\n");
+        fs_info = btrfs_alloc_dummy_fs_info();
+        if (!fs_info) {
+                test_msg("Couldn't allocate dummy fs info\n");
                 goto out;
         }
 
-        root->fs_info = btrfs_alloc_dummy_fs_info();
-        if (!root->fs_info) {
-                test_msg("Couldn't allocate dummy fs info\n");
+        root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
+        if (IS_ERR(root)) {
+                test_msg("Couldn't allocate root\n");
                 goto out;
         }
 
@@ -1132,6 +1133,7 @@ out:
                                  NULL, GFP_KERNEL);
         iput(inode);
         btrfs_free_dummy_root(root);
+        btrfs_free_dummy_fs_info(fs_info);
         return ret;
 }
 
diff --git a/fs/btrfs/tests/qgroup-tests.c b/fs/btrfs/tests/qgroup-tests.c
index 57a12c0d680b..4407fef7c16c 100644
--- a/fs/btrfs/tests/qgroup-tests.c
+++ b/fs/btrfs/tests/qgroup-tests.c
@@ -453,22 +453,24 @@ static int test_multiple_refs(struct btrfs_root *root,
 
 int btrfs_test_qgroups(u32 sectorsize, u32 nodesize)
 {
+        struct btrfs_fs_info *fs_info = NULL;
         struct btrfs_root *root;
         struct btrfs_root *tmp_root;
         int ret = 0;
 
-        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
-        if (IS_ERR(root)) {
-                test_msg("Couldn't allocate root\n");
-                return PTR_ERR(root);
+        fs_info = btrfs_alloc_dummy_fs_info();
+        if (!fs_info) {
+                test_msg("Couldn't allocate dummy fs info\n");
+                return -ENOMEM;
         }
 
-        root->fs_info = btrfs_alloc_dummy_fs_info();
-        if (!root->fs_info) {
-                test_msg("Couldn't allocate dummy fs info\n");
-                ret = -ENOMEM;
+        root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
+        if (IS_ERR(root)) {
+                test_msg("Couldn't allocate root\n");
+                ret = PTR_ERR(root);
                 goto out;
         }
+
         /* We are using this root as our extent root */
         root->fs_info->extent_root = root;
 
@@ -495,7 +497,7 @@ int btrfs_test_qgroups(u32 sectorsize, u32 nodesize)
         btrfs_set_header_nritems(root->node, 0);
         root->alloc_bytenr += 2 * nodesize;
 
-        tmp_root = btrfs_alloc_dummy_root(sectorsize, nodesize);
+        tmp_root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
         if (IS_ERR(tmp_root)) {
                 test_msg("Couldn't allocate a fs root\n");
                 ret = PTR_ERR(tmp_root);
@@ -510,7 +512,7 @@ int btrfs_test_qgroups(u32 sectorsize, u32 nodesize)
                 goto out;
         }
 
-        tmp_root = btrfs_alloc_dummy_root(sectorsize, nodesize);
+        tmp_root = btrfs_alloc_dummy_root(fs_info, sectorsize, nodesize);
         if (IS_ERR(tmp_root)) {
                 test_msg("Couldn't allocate a fs root\n");
                 ret = PTR_ERR(tmp_root);
@@ -531,5 +533,6 @@ int btrfs_test_qgroups(u32 sectorsize, u32 nodesize)
         ret = test_multiple_refs(root, sectorsize, nodesize);
 out:
         btrfs_free_dummy_root(root);
+        btrfs_free_dummy_fs_info(fs_info);
         return ret;
 }