2018-04-03 19:16:55 +02:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2013-08-14 15:05:12 -04:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2013 Fusion IO. All rights reserved.
|
|
|
|
*/
|
|
|
|
|
2018-04-03 19:16:55 +02:00
|
|
|
#ifndef BTRFS_TESTS_H
|
|
|
|
#define BTRFS_TESTS_H
|
2013-08-14 15:05:12 -04:00
|
|
|
|
|
|
|
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
|
2016-06-20 13:16:40 -04:00
|
|
|
int btrfs_run_sanity_tests(void);
|
2013-08-14 15:05:12 -04:00
|
|
|
|
2018-05-17 00:00:44 +02:00
|
|
|
#define test_msg(fmt, ...) pr_info("BTRFS: selftest: " fmt "\n", ##__VA_ARGS__)
|
2019-03-15 17:03:55 +01:00
|
|
|
#define test_err(fmt, ...) pr_err("BTRFS: selftest: %s:%d " fmt "\n", \
|
|
|
|
__FILE__, __LINE__, ##__VA_ARGS__)
|
2013-08-14 15:05:12 -04:00
|
|
|
|
2019-03-15 17:23:30 +01:00
|
|
|
#define test_std_err(index) test_err("%s", test_error[index])
|
|
|
|
|
|
|
|
enum {
|
|
|
|
TEST_ALLOC_FS_INFO,
|
|
|
|
TEST_ALLOC_ROOT,
|
|
|
|
TEST_ALLOC_EXTENT_BUFFER,
|
|
|
|
TEST_ALLOC_PATH,
|
|
|
|
TEST_ALLOC_INODE,
|
|
|
|
TEST_ALLOC_BLOCK_GROUP,
|
|
|
|
TEST_ALLOC_EXTENT_MAP,
|
btrfs: use a dedicated data structure for chunk maps
Currently we abuse the extent_map structure for two purposes:
1) To actually represent extents for inodes;
2) To represent chunk mappings.
This is odd and has several disadvantages:
1) To create a chunk map, we need to do two memory allocations: one for
an extent_map structure and another one for a map_lookup structure, so
more potential for an allocation failure and more complicated code to
manage and link two structures;
2) For a chunk map we actually only use 3 fields (24 bytes) of the
respective extent map structure: the 'start' field to have the logical
start address of the chunk, the 'len' field to have the chunk's size,
and the 'orig_block_len' field to contain the chunk's stripe size.
Besides wasting a memory, it's also odd and not intuitive at all to
have the stripe size in a field named 'orig_block_len'.
We are also using 'block_len' of the extent_map structure to contain
the chunk size, so we have 2 fields for the same value, 'len' and
'block_len', which is pointless;
3) When an extent map is associated to a chunk mapping, we set the bit
EXTENT_FLAG_FS_MAPPING on its flags and then make its member named
'map_lookup' point to the associated map_lookup structure. This means
that for an extent map associated to an inode extent, we are not using
this 'map_lookup' pointer, so wasting 8 bytes (on a 64 bits platform);
4) Extent maps associated to a chunk mapping are never merged or split so
it's pointless to use the existing extent map infrastructure.
So add a dedicated data structure named 'btrfs_chunk_map' to represent
chunk mappings, this is basically the existing map_lookup structure with
some extra fields:
1) 'start' to contain the chunk logical address;
2) 'chunk_len' to contain the chunk's length;
3) 'stripe_size' for the stripe size;
4) 'rb_node' for insertion into a rb tree;
5) 'refs' for reference counting.
This way we do a single memory allocation for chunk mappings and we don't
waste memory for them with unused/unnecessary fields from an extent_map.
We also save 8 bytes from the extent_map structure by removing the
'map_lookup' pointer, so the size of struct extent_map is reduced from
144 bytes down to 136 bytes, and we can now have 30 extents map per 4K
page instead of 28.
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2023-11-21 13:38:38 +00:00
|
|
|
TEST_ALLOC_CHUNK_MAP,
|
2019-03-15 17:23:30 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
extern const char *test_error[];
|
|
|
|
|
2014-05-07 17:06:09 -04:00
|
|
|
struct btrfs_root;
|
2015-09-29 20:50:36 -07:00
|
|
|
struct btrfs_trans_handle;
|
2014-05-07 17:06:09 -04:00
|
|
|
|
2016-06-01 19:18:25 +08:00
|
|
|
int btrfs_test_extent_buffer_operations(u32 sectorsize, u32 nodesize);
|
2016-06-20 13:16:40 -04:00
|
|
|
int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize);
|
2016-06-01 19:18:25 +08:00
|
|
|
int btrfs_test_extent_io(u32 sectorsize, u32 nodesize);
|
|
|
|
int btrfs_test_inodes(u32 sectorsize, u32 nodesize);
|
|
|
|
int btrfs_test_qgroups(u32 sectorsize, u32 nodesize);
|
|
|
|
int btrfs_test_free_space_tree(u32 sectorsize, u32 nodesize);
|
2018-01-05 12:51:12 -07:00
|
|
|
int btrfs_test_extent_map(void);
|
2013-10-09 12:00:56 -04:00
|
|
|
struct inode *btrfs_new_test_inode(void);
|
2016-06-15 09:22:56 -04:00
|
|
|
struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(u32 nodesize, u32 sectorsize);
|
2016-06-20 14:14:09 -04:00
|
|
|
void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info);
|
2014-05-07 17:06:09 -04:00
|
|
|
void btrfs_free_dummy_root(struct btrfs_root *root);
|
2019-10-29 19:20:18 +01:00
|
|
|
struct btrfs_block_group *
|
2016-06-15 09:22:56 -04:00
|
|
|
btrfs_alloc_dummy_block_group(struct btrfs_fs_info *fs_info, unsigned long length);
|
2019-10-29 19:20:18 +01:00
|
|
|
void btrfs_free_dummy_block_group(struct btrfs_block_group *cache);
|
2018-05-10 15:44:40 +03:00
|
|
|
void btrfs_init_dummy_trans(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info);
|
2019-11-19 14:05:51 +02:00
|
|
|
struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info);
|
2013-08-14 15:05:12 -04:00
|
|
|
#else
|
2016-06-20 13:16:40 -04:00
|
|
|
static inline int btrfs_run_sanity_tests(void)
|
2015-09-29 20:50:36 -07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2013-08-14 15:05:12 -04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|