1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2013 Fusion IO. All rights reserved.
7 #include <linux/mount.h>
8 #include <linux/pseudo_fs.h>
9 #include <linux/magic.h>
10 #include "btrfs-tests.h"
12 #include "../free-space-cache.h"
13 #include "../free-space-tree.h"
14 #include "../transaction.h"
15 #include "../volumes.h"
16 #include "../disk-io.h"
17 #include "../qgroup.h"
18 #include "../block-group.h"
20 static struct vfsmount
*test_mnt
= NULL
;
22 const char *test_error
[] = {
23 [TEST_ALLOC_FS_INFO
] = "cannot allocate fs_info",
24 [TEST_ALLOC_ROOT
] = "cannot allocate root",
25 [TEST_ALLOC_EXTENT_BUFFER
] = "cannot extent buffer",
26 [TEST_ALLOC_PATH
] = "cannot allocate path",
27 [TEST_ALLOC_INODE
] = "cannot allocate inode",
28 [TEST_ALLOC_BLOCK_GROUP
] = "cannot allocate block group",
29 [TEST_ALLOC_EXTENT_MAP
] = "cannot allocate extent map",
32 static const struct super_operations btrfs_test_super_ops
= {
33 .alloc_inode
= btrfs_alloc_inode
,
34 .destroy_inode
= btrfs_test_destroy_inode
,
38 static int btrfs_test_init_fs_context(struct fs_context
*fc
)
40 struct pseudo_fs_context
*ctx
= init_pseudo(fc
, BTRFS_TEST_MAGIC
);
43 ctx
->ops
= &btrfs_test_super_ops
;
47 static struct file_system_type test_type
= {
48 .name
= "btrfs_test_fs",
49 .init_fs_context
= btrfs_test_init_fs_context
,
50 .kill_sb
= kill_anon_super
,
53 struct inode
*btrfs_new_test_inode(void)
57 inode
= new_inode(test_mnt
->mnt_sb
);
61 inode
->i_mode
= S_IFREG
;
62 inode
->i_ino
= BTRFS_FIRST_FREE_OBJECTID
;
63 BTRFS_I(inode
)->location
.type
= BTRFS_INODE_ITEM_KEY
;
64 BTRFS_I(inode
)->location
.objectid
= BTRFS_FIRST_FREE_OBJECTID
;
65 BTRFS_I(inode
)->location
.offset
= 0;
66 inode_init_owner(&init_user_ns
, inode
, NULL
, S_IFREG
);
71 static int btrfs_init_test_fs(void)
75 ret
= register_filesystem(&test_type
);
77 printk(KERN_ERR
"btrfs: cannot register test file system\n");
81 test_mnt
= kern_mount(&test_type
);
82 if (IS_ERR(test_mnt
)) {
83 printk(KERN_ERR
"btrfs: cannot mount test file system\n");
84 unregister_filesystem(&test_type
);
85 return PTR_ERR(test_mnt
);
90 static void btrfs_destroy_test_fs(void)
92 kern_unmount(test_mnt
);
93 unregister_filesystem(&test_type
);
96 struct btrfs_device
*btrfs_alloc_dummy_device(struct btrfs_fs_info
*fs_info
)
98 struct btrfs_device
*dev
;
100 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
102 return ERR_PTR(-ENOMEM
);
104 extent_io_tree_init(NULL
, &dev
->alloc_state
, 0, NULL
);
105 INIT_LIST_HEAD(&dev
->dev_list
);
106 list_add(&dev
->dev_list
, &fs_info
->fs_devices
->devices
);
111 static void btrfs_free_dummy_device(struct btrfs_device
*dev
)
113 extent_io_tree_release(&dev
->alloc_state
);
117 struct btrfs_fs_info
*btrfs_alloc_dummy_fs_info(u32 nodesize
, u32 sectorsize
)
119 struct btrfs_fs_info
*fs_info
= kzalloc(sizeof(struct btrfs_fs_info
),
124 fs_info
->fs_devices
= kzalloc(sizeof(struct btrfs_fs_devices
),
126 if (!fs_info
->fs_devices
) {
130 INIT_LIST_HEAD(&fs_info
->fs_devices
->devices
);
132 fs_info
->super_copy
= kzalloc(sizeof(struct btrfs_super_block
),
134 if (!fs_info
->super_copy
) {
135 kfree(fs_info
->fs_devices
);
140 btrfs_init_fs_info(fs_info
);
142 fs_info
->nodesize
= nodesize
;
143 fs_info
->sectorsize
= sectorsize
;
144 fs_info
->sectorsize_bits
= ilog2(sectorsize
);
145 set_bit(BTRFS_FS_STATE_DUMMY_FS_INFO
, &fs_info
->fs_state
);
147 test_mnt
->mnt_sb
->s_fs_info
= fs_info
;
152 void btrfs_free_dummy_fs_info(struct btrfs_fs_info
*fs_info
)
154 struct radix_tree_iter iter
;
156 struct btrfs_device
*dev
, *tmp
;
161 if (WARN_ON(!test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO
,
162 &fs_info
->fs_state
)))
165 test_mnt
->mnt_sb
->s_fs_info
= NULL
;
167 spin_lock(&fs_info
->buffer_lock
);
168 radix_tree_for_each_slot(slot
, &fs_info
->buffer_radix
, &iter
, 0) {
169 struct extent_buffer
*eb
;
171 eb
= radix_tree_deref_slot_protected(slot
, &fs_info
->buffer_lock
);
174 /* Shouldn't happen but that kind of thinking creates CVE's */
175 if (radix_tree_exception(eb
)) {
176 if (radix_tree_deref_retry(eb
))
177 slot
= radix_tree_iter_retry(&iter
);
180 slot
= radix_tree_iter_resume(slot
, &iter
);
181 spin_unlock(&fs_info
->buffer_lock
);
182 free_extent_buffer_stale(eb
);
183 spin_lock(&fs_info
->buffer_lock
);
185 spin_unlock(&fs_info
->buffer_lock
);
187 btrfs_mapping_tree_free(&fs_info
->mapping_tree
);
188 list_for_each_entry_safe(dev
, tmp
, &fs_info
->fs_devices
->devices
,
190 btrfs_free_dummy_device(dev
);
192 btrfs_free_qgroup_config(fs_info
);
193 btrfs_free_fs_roots(fs_info
);
194 kfree(fs_info
->super_copy
);
195 btrfs_check_leaked_roots(fs_info
);
196 btrfs_extent_buffer_leak_debug_check(fs_info
);
197 kfree(fs_info
->fs_devices
);
201 void btrfs_free_dummy_root(struct btrfs_root
*root
)
205 /* Will be freed by btrfs_free_fs_roots */
206 if (WARN_ON(test_bit(BTRFS_ROOT_IN_RADIX
, &root
->state
)))
208 btrfs_global_root_delete(root
);
209 btrfs_put_root(root
);
212 struct btrfs_block_group
*
213 btrfs_alloc_dummy_block_group(struct btrfs_fs_info
*fs_info
,
214 unsigned long length
)
216 struct btrfs_block_group
*cache
;
218 cache
= kzalloc(sizeof(*cache
), GFP_KERNEL
);
221 cache
->free_space_ctl
= kzalloc(sizeof(*cache
->free_space_ctl
),
223 if (!cache
->free_space_ctl
) {
229 cache
->length
= length
;
230 cache
->full_stripe_len
= fs_info
->sectorsize
;
231 cache
->fs_info
= fs_info
;
233 INIT_LIST_HEAD(&cache
->list
);
234 INIT_LIST_HEAD(&cache
->cluster_list
);
235 INIT_LIST_HEAD(&cache
->bg_list
);
236 btrfs_init_free_space_ctl(cache
, cache
->free_space_ctl
);
237 mutex_init(&cache
->free_space_lock
);
242 void btrfs_free_dummy_block_group(struct btrfs_block_group
*cache
)
246 __btrfs_remove_free_space_cache(cache
->free_space_ctl
);
247 kfree(cache
->free_space_ctl
);
251 void btrfs_init_dummy_trans(struct btrfs_trans_handle
*trans
,
252 struct btrfs_fs_info
*fs_info
)
254 memset(trans
, 0, sizeof(*trans
));
256 trans
->type
= __TRANS_DUMMY
;
257 trans
->fs_info
= fs_info
;
260 int btrfs_run_sanity_tests(void)
263 u32 sectorsize
, nodesize
;
264 u32 test_sectorsize
[] = {
267 ret
= btrfs_init_test_fs();
270 for (i
= 0; i
< ARRAY_SIZE(test_sectorsize
); i
++) {
271 sectorsize
= test_sectorsize
[i
];
272 for (nodesize
= sectorsize
;
273 nodesize
<= BTRFS_MAX_METADATA_BLOCKSIZE
;
275 pr_info("BTRFS: selftest: sectorsize: %u nodesize: %u\n",
276 sectorsize
, nodesize
);
277 ret
= btrfs_test_free_space_cache(sectorsize
, nodesize
);
280 ret
= btrfs_test_extent_buffer_operations(sectorsize
,
284 ret
= btrfs_test_extent_io(sectorsize
, nodesize
);
287 ret
= btrfs_test_inodes(sectorsize
, nodesize
);
290 ret
= btrfs_test_qgroups(sectorsize
, nodesize
);
293 ret
= btrfs_test_free_space_tree(sectorsize
, nodesize
);
298 ret
= btrfs_test_extent_map();
301 btrfs_destroy_test_fs();