1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2013 Fusion IO. All rights reserved.
4 */
5
6 #include <linux/fs.h>
7 #include <linux/mount.h>
8 #include <linux/pseudo_fs.h>
9 #include <linux/magic.h>
10 #include "btrfs-tests.h"
11 #include "../ctree.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"
19 #include "../fs.h"
20
21 static struct vfsmount *test_mnt = NULL;
22
23 const char *test_error[] = {
24 [TEST_ALLOC_FS_INFO] = "cannot allocate fs_info",
25 [TEST_ALLOC_ROOT] = "cannot allocate root",
26 [TEST_ALLOC_EXTENT_BUFFER] = "cannot extent buffer",
27 [TEST_ALLOC_PATH] = "cannot allocate path",
28 [TEST_ALLOC_INODE] = "cannot allocate inode",
29 [TEST_ALLOC_BLOCK_GROUP] = "cannot allocate block group",
30 [TEST_ALLOC_EXTENT_MAP] = "cannot allocate extent map",
31 [TEST_ALLOC_CHUNK_MAP] = "cannot allocate chunk map",
32 [TEST_ALLOC_IO_CONTEXT] = "cannot allocate io context",
33 [TEST_ALLOC_TRANSACTION] = "cannot allocate transaction",
34 };
35
36 static const struct super_operations btrfs_test_super_ops = {
37 .alloc_inode = btrfs_alloc_inode,
38 .destroy_inode = btrfs_test_destroy_inode,
39 };
40
41
btrfs_test_init_fs_context(struct fs_context * fc)42 static int btrfs_test_init_fs_context(struct fs_context *fc)
43 {
44 struct pseudo_fs_context *ctx = init_pseudo(fc, BTRFS_TEST_MAGIC);
45 if (!ctx)
46 return -ENOMEM;
47 ctx->ops = &btrfs_test_super_ops;
48 return 0;
49 }
50
51 static struct file_system_type test_type = {
52 .name = "btrfs_test_fs",
53 .init_fs_context = btrfs_test_init_fs_context,
54 .kill_sb = kill_anon_super,
55 };
56
btrfs_new_test_inode(void)57 struct inode *btrfs_new_test_inode(void)
58 {
59 struct inode *inode;
60
61 inode = new_inode(test_mnt->mnt_sb);
62 if (!inode)
63 return NULL;
64
65 inode->i_mode = S_IFREG;
66 btrfs_set_inode_number(BTRFS_I(inode), BTRFS_FIRST_FREE_OBJECTID);
67 inode_init_owner(&nop_mnt_idmap, inode, NULL, S_IFREG);
68
69 return inode;
70 }
71
btrfs_init_test_fs(void)72 static int btrfs_init_test_fs(void)
73 {
74 int ret;
75
76 ret = register_filesystem(&test_type);
77 if (ret) {
78 printk(KERN_ERR "btrfs: cannot register test file system\n");
79 return ret;
80 }
81
82 test_mnt = kern_mount(&test_type);
83 if (IS_ERR(test_mnt)) {
84 printk(KERN_ERR "btrfs: cannot mount test file system\n");
85 unregister_filesystem(&test_type);
86 return PTR_ERR(test_mnt);
87 }
88 return 0;
89 }
90
btrfs_destroy_test_fs(void)91 static void btrfs_destroy_test_fs(void)
92 {
93 kern_unmount(test_mnt);
94 unregister_filesystem(&test_type);
95 }
96
btrfs_alloc_dummy_device(struct btrfs_fs_info * fs_info)97 struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info)
98 {
99 struct btrfs_device *dev;
100
101 dev = kzalloc_obj(*dev);
102 if (!dev)
103 return ERR_PTR(-ENOMEM);
104
105 btrfs_extent_io_tree_init(fs_info, &dev->alloc_state, 0);
106 INIT_LIST_HEAD(&dev->dev_list);
107 list_add(&dev->dev_list, &fs_info->fs_devices->devices);
108
109 return dev;
110 }
111
btrfs_free_dummy_device(struct btrfs_device * dev)112 static void btrfs_free_dummy_device(struct btrfs_device *dev)
113 {
114 btrfs_extent_io_tree_release(&dev->alloc_state);
115 kfree(dev);
116 }
117
btrfs_alloc_dummy_fs_info(u32 nodesize,u32 sectorsize)118 struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(u32 nodesize, u32 sectorsize)
119 {
120 struct btrfs_fs_info *fs_info = kzalloc_obj(struct btrfs_fs_info);
121
122 if (!fs_info)
123 return fs_info;
124 fs_info->fs_devices = kzalloc_obj(struct btrfs_fs_devices);
125 if (!fs_info->fs_devices) {
126 kfree(fs_info);
127 return NULL;
128 }
129 INIT_LIST_HEAD(&fs_info->fs_devices->devices);
130
131 fs_info->super_copy = kzalloc_obj(struct btrfs_super_block);
132 if (!fs_info->super_copy) {
133 kfree(fs_info->fs_devices);
134 kfree(fs_info);
135 return NULL;
136 }
137
138 btrfs_init_fs_info(fs_info);
139
140 fs_info->nodesize = nodesize;
141 fs_info->sectorsize = sectorsize;
142 fs_info->sectorsize_bits = ilog2(sectorsize);
143
144 /* CRC32C csum size. */
145 fs_info->csum_size = 4;
146 fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) /
147 fs_info->csum_size;
148 set_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
149
150 test_mnt->mnt_sb->s_fs_info = fs_info;
151
152 return fs_info;
153 }
154
btrfs_free_dummy_fs_info(struct btrfs_fs_info * fs_info)155 void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info)
156 {
157 struct btrfs_device *dev, *tmp;
158 struct extent_buffer *eb;
159 unsigned long index;
160
161 if (!fs_info)
162 return;
163
164 if (WARN_ON(!btrfs_is_testing(fs_info)))
165 return;
166
167 test_mnt->mnt_sb->s_fs_info = NULL;
168
169 xa_lock_irq(&fs_info->buffer_tree);
170 xa_for_each(&fs_info->buffer_tree, index, eb) {
171 xa_unlock_irq(&fs_info->buffer_tree);
172 free_extent_buffer(eb);
173 xa_lock_irq(&fs_info->buffer_tree);
174 }
175 xa_unlock_irq(&fs_info->buffer_tree);
176
177 btrfs_mapping_tree_free(fs_info);
178 list_for_each_entry_safe(dev, tmp, &fs_info->fs_devices->devices,
179 dev_list) {
180 btrfs_free_dummy_device(dev);
181 }
182 btrfs_free_qgroup_config(fs_info);
183 btrfs_free_fs_roots(fs_info);
184 kfree(fs_info->super_copy);
185 btrfs_check_leaked_roots(fs_info);
186 btrfs_extent_buffer_leak_debug_check(fs_info);
187 kfree(fs_info->fs_devices);
188 kfree(fs_info);
189 }
190
btrfs_free_dummy_root(struct btrfs_root * root)191 void btrfs_free_dummy_root(struct btrfs_root *root)
192 {
193 if (IS_ERR_OR_NULL(root))
194 return;
195 /* Will be freed by btrfs_free_fs_roots */
196 if (WARN_ON(test_bit(BTRFS_ROOT_IN_RADIX, &root->state)))
197 return;
198 btrfs_global_root_delete(root);
199 btrfs_put_root(root);
200 }
201
202 struct btrfs_block_group *
btrfs_alloc_dummy_block_group(struct btrfs_fs_info * fs_info,unsigned long length)203 btrfs_alloc_dummy_block_group(struct btrfs_fs_info *fs_info,
204 unsigned long length)
205 {
206 struct btrfs_block_group *cache;
207
208 cache = kzalloc_obj(*cache);
209 if (!cache)
210 return NULL;
211 cache->free_space_ctl = kzalloc_obj(*cache->free_space_ctl);
212 if (!cache->free_space_ctl) {
213 kfree(cache);
214 return NULL;
215 }
216
217 cache->start = 0;
218 cache->length = length;
219 cache->full_stripe_len = fs_info->sectorsize;
220 cache->fs_info = fs_info;
221
222 INIT_LIST_HEAD(&cache->list);
223 INIT_LIST_HEAD(&cache->cluster_list);
224 INIT_LIST_HEAD(&cache->bg_list);
225 btrfs_init_free_space_ctl(cache, cache->free_space_ctl);
226 mutex_init(&cache->free_space_lock);
227
228 return cache;
229 }
230
btrfs_free_dummy_block_group(struct btrfs_block_group * cache)231 void btrfs_free_dummy_block_group(struct btrfs_block_group *cache)
232 {
233 if (!cache)
234 return;
235 btrfs_remove_free_space_cache(cache);
236 kfree(cache->free_space_ctl);
237 kfree(cache);
238 }
239
btrfs_init_dummy_transaction(struct btrfs_transaction * trans,struct btrfs_fs_info * fs_info)240 void btrfs_init_dummy_transaction(struct btrfs_transaction *trans, struct btrfs_fs_info *fs_info)
241 {
242 memset(trans, 0, sizeof(*trans));
243 trans->fs_info = fs_info;
244 xa_init(&trans->delayed_refs.head_refs);
245 xa_init(&trans->delayed_refs.dirty_extents);
246 spin_lock_init(&trans->delayed_refs.lock);
247 }
248
btrfs_init_dummy_trans(struct btrfs_trans_handle * trans,struct btrfs_fs_info * fs_info)249 void btrfs_init_dummy_trans(struct btrfs_trans_handle *trans,
250 struct btrfs_fs_info *fs_info)
251 {
252 memset(trans, 0, sizeof(*trans));
253 trans->transid = 1;
254 trans->type = __TRANS_DUMMY;
255 trans->fs_info = fs_info;
256 }
257
btrfs_run_sanity_tests(void)258 int btrfs_run_sanity_tests(void)
259 {
260 int ret, i;
261 u32 sectorsize, nodesize;
262 u32 test_sectorsize[] = {
263 PAGE_SIZE,
264 };
265 ret = btrfs_init_test_fs();
266 if (ret)
267 return ret;
268 for (i = 0; i < ARRAY_SIZE(test_sectorsize); i++) {
269 sectorsize = test_sectorsize[i];
270 for (nodesize = sectorsize;
271 nodesize <= BTRFS_MAX_METADATA_BLOCKSIZE;
272 nodesize <<= 1) {
273 pr_info("BTRFS: selftest: sectorsize: %u nodesize: %u\n",
274 sectorsize, nodesize);
275 ret = btrfs_test_free_space_cache(sectorsize, nodesize);
276 if (ret)
277 goto out;
278 ret = btrfs_test_extent_buffer_operations(sectorsize,
279 nodesize);
280 if (ret)
281 goto out;
282 ret = btrfs_test_extent_io(sectorsize, nodesize);
283 if (ret)
284 goto out;
285 ret = btrfs_test_inodes(sectorsize, nodesize);
286 if (ret)
287 goto out;
288 ret = btrfs_test_qgroups(sectorsize, nodesize);
289 if (ret)
290 goto out;
291 ret = btrfs_test_free_space_tree(sectorsize, nodesize);
292 if (ret)
293 goto out;
294 ret = btrfs_test_raid_stripe_tree(sectorsize, nodesize);
295 if (ret)
296 goto out;
297 ret = btrfs_test_delayed_refs(sectorsize, nodesize);
298 if (ret)
299 goto out;
300 ret = btrfs_test_chunk_allocation(sectorsize, nodesize);
301 if (ret)
302 goto out;
303 }
304 }
305 ret = btrfs_test_extent_map();
306
307 out:
308 btrfs_destroy_test_fs();
309 return ret;
310 }
311