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(sizeof(*dev), GFP_KERNEL);
102 if (!dev)
103 return ERR_PTR(-ENOMEM);
104
105 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 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(sizeof(struct btrfs_fs_info),
121 GFP_KERNEL);
122
123 if (!fs_info)
124 return fs_info;
125 fs_info->fs_devices = kzalloc(sizeof(struct btrfs_fs_devices),
126 GFP_KERNEL);
127 if (!fs_info->fs_devices) {
128 kfree(fs_info);
129 return NULL;
130 }
131 INIT_LIST_HEAD(&fs_info->fs_devices->devices);
132
133 fs_info->super_copy = kzalloc(sizeof(struct btrfs_super_block),
134 GFP_KERNEL);
135 if (!fs_info->super_copy) {
136 kfree(fs_info->fs_devices);
137 kfree(fs_info);
138 return NULL;
139 }
140
141 btrfs_init_fs_info(fs_info);
142
143 fs_info->nodesize = nodesize;
144 fs_info->sectorsize = sectorsize;
145 fs_info->sectorsize_bits = ilog2(sectorsize);
146
147 /* CRC32C csum size. */
148 fs_info->csum_size = 4;
149 fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) /
150 fs_info->csum_size;
151 set_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
152
153 test_mnt->mnt_sb->s_fs_info = fs_info;
154
155 return fs_info;
156 }
157
btrfs_free_dummy_fs_info(struct btrfs_fs_info * fs_info)158 void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info)
159 {
160 struct radix_tree_iter iter;
161 void **slot;
162 struct btrfs_device *dev, *tmp;
163
164 if (!fs_info)
165 return;
166
167 if (WARN_ON(!btrfs_is_testing(fs_info)))
168 return;
169
170 test_mnt->mnt_sb->s_fs_info = NULL;
171
172 spin_lock(&fs_info->buffer_lock);
173 radix_tree_for_each_slot(slot, &fs_info->buffer_radix, &iter, 0) {
174 struct extent_buffer *eb;
175
176 eb = radix_tree_deref_slot_protected(slot, &fs_info->buffer_lock);
177 if (!eb)
178 continue;
179 /* Shouldn't happen but that kind of thinking creates CVE's */
180 if (radix_tree_exception(eb)) {
181 if (radix_tree_deref_retry(eb))
182 slot = radix_tree_iter_retry(&iter);
183 continue;
184 }
185 slot = radix_tree_iter_resume(slot, &iter);
186 spin_unlock(&fs_info->buffer_lock);
187 free_extent_buffer_stale(eb);
188 spin_lock(&fs_info->buffer_lock);
189 }
190 spin_unlock(&fs_info->buffer_lock);
191
192 btrfs_mapping_tree_free(fs_info);
193 list_for_each_entry_safe(dev, tmp, &fs_info->fs_devices->devices,
194 dev_list) {
195 btrfs_free_dummy_device(dev);
196 }
197 btrfs_free_qgroup_config(fs_info);
198 btrfs_free_fs_roots(fs_info);
199 kfree(fs_info->super_copy);
200 btrfs_check_leaked_roots(fs_info);
201 btrfs_extent_buffer_leak_debug_check(fs_info);
202 kfree(fs_info->fs_devices);
203 kfree(fs_info);
204 }
205
btrfs_free_dummy_root(struct btrfs_root * root)206 void btrfs_free_dummy_root(struct btrfs_root *root)
207 {
208 if (IS_ERR_OR_NULL(root))
209 return;
210 /* Will be freed by btrfs_free_fs_roots */
211 if (WARN_ON(test_bit(BTRFS_ROOT_IN_RADIX, &root->state)))
212 return;
213 btrfs_global_root_delete(root);
214 btrfs_put_root(root);
215 }
216
217 struct btrfs_block_group *
btrfs_alloc_dummy_block_group(struct btrfs_fs_info * fs_info,unsigned long length)218 btrfs_alloc_dummy_block_group(struct btrfs_fs_info *fs_info,
219 unsigned long length)
220 {
221 struct btrfs_block_group *cache;
222
223 cache = kzalloc(sizeof(*cache), GFP_KERNEL);
224 if (!cache)
225 return NULL;
226 cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
227 GFP_KERNEL);
228 if (!cache->free_space_ctl) {
229 kfree(cache);
230 return NULL;
231 }
232
233 cache->start = 0;
234 cache->length = length;
235 cache->full_stripe_len = fs_info->sectorsize;
236 cache->fs_info = fs_info;
237
238 INIT_LIST_HEAD(&cache->list);
239 INIT_LIST_HEAD(&cache->cluster_list);
240 INIT_LIST_HEAD(&cache->bg_list);
241 btrfs_init_free_space_ctl(cache, cache->free_space_ctl);
242 mutex_init(&cache->free_space_lock);
243
244 return cache;
245 }
246
btrfs_free_dummy_block_group(struct btrfs_block_group * cache)247 void btrfs_free_dummy_block_group(struct btrfs_block_group *cache)
248 {
249 if (!cache)
250 return;
251 btrfs_remove_free_space_cache(cache);
252 kfree(cache->free_space_ctl);
253 kfree(cache);
254 }
255
btrfs_init_dummy_transaction(struct btrfs_transaction * trans,struct btrfs_fs_info * fs_info)256 void btrfs_init_dummy_transaction(struct btrfs_transaction *trans, struct btrfs_fs_info *fs_info)
257 {
258 memset(trans, 0, sizeof(*trans));
259 trans->fs_info = fs_info;
260 xa_init(&trans->delayed_refs.head_refs);
261 xa_init(&trans->delayed_refs.dirty_extents);
262 spin_lock_init(&trans->delayed_refs.lock);
263 }
264
btrfs_init_dummy_trans(struct btrfs_trans_handle * trans,struct btrfs_fs_info * fs_info)265 void btrfs_init_dummy_trans(struct btrfs_trans_handle *trans,
266 struct btrfs_fs_info *fs_info)
267 {
268 memset(trans, 0, sizeof(*trans));
269 trans->transid = 1;
270 trans->type = __TRANS_DUMMY;
271 trans->fs_info = fs_info;
272 }
273
btrfs_run_sanity_tests(void)274 int btrfs_run_sanity_tests(void)
275 {
276 int ret, i;
277 u32 sectorsize, nodesize;
278 u32 test_sectorsize[] = {
279 PAGE_SIZE,
280 };
281 ret = btrfs_init_test_fs();
282 if (ret)
283 return ret;
284 for (i = 0; i < ARRAY_SIZE(test_sectorsize); i++) {
285 sectorsize = test_sectorsize[i];
286 for (nodesize = sectorsize;
287 nodesize <= BTRFS_MAX_METADATA_BLOCKSIZE;
288 nodesize <<= 1) {
289 pr_info("BTRFS: selftest: sectorsize: %u nodesize: %u\n",
290 sectorsize, nodesize);
291 ret = btrfs_test_free_space_cache(sectorsize, nodesize);
292 if (ret)
293 goto out;
294 ret = btrfs_test_extent_buffer_operations(sectorsize,
295 nodesize);
296 if (ret)
297 goto out;
298 ret = btrfs_test_extent_io(sectorsize, nodesize);
299 if (ret)
300 goto out;
301 ret = btrfs_test_inodes(sectorsize, nodesize);
302 if (ret)
303 goto out;
304 ret = btrfs_test_qgroups(sectorsize, nodesize);
305 if (ret)
306 goto out;
307 ret = btrfs_test_free_space_tree(sectorsize, nodesize);
308 if (ret)
309 goto out;
310 ret = btrfs_test_raid_stripe_tree(sectorsize, nodesize);
311 if (ret)
312 goto out;
313 ret = btrfs_test_delayed_refs(sectorsize, nodesize);
314 if (ret)
315 goto out;
316 }
317 }
318 ret = btrfs_test_extent_map();
319
320 out:
321 btrfs_destroy_test_fs();
322 return ret;
323 }
324