Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dc11dd5d authored by Josef Bacik's avatar Josef Bacik Committed by Chris Mason
Browse files

Btrfs: separate out tests into their own directory 



The plan is to have a bunch of unit tests that run when btrfs is loaded when you
build with the appropriate config option.  My ultimate goal is to have a test
for every non-static function we have, but at first I'm going to focus on the
things that cause us the most problems.  To start out with this just adds a
tests/ directory and moves the existing free space cache tests into that
directory and sets up all of the infrastructure.  Thanks,

Signed-off-by: default avatarJosef Bacik <jbacik@fusionio.com>
Signed-off-by: default avatarChris Mason <chris.mason@fusionio.com>
parent 00361589

fs/btrfs/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -12,3 +12,5 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ 


btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o

btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o



btrfs-$(CONFIG_BTRFS_FS_RUN_SANITY_TESTS) += tests/free-space-tests.o

fs/btrfs/free-space-cache.c

+58 −430
Original line number Diff line number Diff line
@@ -2972,33 +2972,68 @@ int btrfs_write_out_ino_cache(struct btrfs_root *root, 
}



#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS

static struct btrfs_block_group_cache *init_test_block_group(void)

/*

 * Use this if you need to make a bitmap or extent entry specifically, it

 * doesn't do any of the merging that add_free_space does, this acts a lot like

 * how the free space cache loading stuff works, so you can get really weird

 * configurations.

 */

int test_add_free_space_entry(struct btrfs_block_group_cache *cache,

			      u64 offset, u64 bytes, bool bitmap)

{

	struct btrfs_block_group_cache *cache;

	struct btrfs_free_space_ctl *ctl = cache->free_space_ctl;

	struct btrfs_free_space *info = NULL, *bitmap_info;

	void *map = NULL;

	u64 bytes_added;

	int ret;



	cache = kzalloc(sizeof(*cache), GFP_NOFS);

	if (!cache)

		return NULL;

	cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),

					GFP_NOFS);

	if (!cache->free_space_ctl) {

		kfree(cache);

		return NULL;

again:

	if (!info) {

		info = kmem_cache_zalloc(btrfs_free_space_cachep, GFP_NOFS);

		if (!info)

			return -ENOMEM;

	}



	cache->key.objectid = 0;

	cache->key.offset = 1024 * 1024 * 1024;

	cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;

	cache->sectorsize = 4096;

	if (!bitmap) {

		spin_lock(&ctl->tree_lock);

		info->offset = offset;

		info->bytes = bytes;

		ret = link_free_space(ctl, info);

		spin_unlock(&ctl->tree_lock);

		if (ret)

			kmem_cache_free(btrfs_free_space_cachep, info);

		return ret;

	}



	if (!map) {

		map = kzalloc(PAGE_CACHE_SIZE, GFP_NOFS);

		if (!map) {

			kmem_cache_free(btrfs_free_space_cachep, info);

			return -ENOMEM;

		}

	}



	spin_lock(&ctl->tree_lock);

	bitmap_info = tree_search_offset(ctl, offset_to_bitmap(ctl, offset),

					 1, 0);

	if (!bitmap_info) {

		info->bitmap = map;

		map = NULL;

		add_new_bitmap(ctl, info, offset);

		bitmap_info = info;

	}



	spin_lock_init(&cache->lock);

	INIT_LIST_HEAD(&cache->list);

	INIT_LIST_HEAD(&cache->cluster_list);

	INIT_LIST_HEAD(&cache->new_bg_list);

	bytes_added = add_bytes_to_bitmap(ctl, bitmap_info, offset, bytes);

	bytes -= bytes_added;

	offset += bytes_added;

	spin_unlock(&ctl->tree_lock);



	btrfs_init_free_space_ctl(cache);

	if (bytes)

		goto again;



	return cache;

	if (map)

		kfree(map);

	return 0;

}



/*
@@ -3006,8 +3041,8 @@ static struct btrfs_block_group_cache *init_test_block_group(void) 
 * just used to check the absence of space, so if there is free space in the

 * range at all we will return 1.

 */

static int check_exists(struct btrfs_block_group_cache *cache, u64 offset,

			u64 bytes)

int test_check_exists(struct btrfs_block_group_cache *cache,

		      u64 offset, u64 bytes)

{

	struct btrfs_free_space_ctl *ctl = cache->free_space_ctl;

	struct btrfs_free_space *info;
@@ -3084,411 +3119,4 @@ static int check_exists(struct btrfs_block_group_cache *cache, u64 offset, 
	spin_unlock(&ctl->tree_lock);

	return ret;

}



/*

 * Use this if you need to make a bitmap or extent entry specifically, it

 * doesn't do any of the merging that add_free_space does, this acts a lot like

 * how the free space cache loading stuff works, so you can get really weird

 * configurations.

 */

static int add_free_space_entry(struct btrfs_block_group_cache *cache,

				u64 offset, u64 bytes, bool bitmap)

{

	struct btrfs_free_space_ctl *ctl = cache->free_space_ctl;

	struct btrfs_free_space *info = NULL, *bitmap_info;

	void *map = NULL;

	u64 bytes_added;

	int ret;



again:

	if (!info) {

		info = kmem_cache_zalloc(btrfs_free_space_cachep, GFP_NOFS);

		if (!info)

			return -ENOMEM;

	}



	if (!bitmap) {

		spin_lock(&ctl->tree_lock);

		info->offset = offset;

		info->bytes = bytes;

		ret = link_free_space(ctl, info);

		spin_unlock(&ctl->tree_lock);

		if (ret)

			kmem_cache_free(btrfs_free_space_cachep, info);

		return ret;

	}



	if (!map) {

		map = kzalloc(PAGE_CACHE_SIZE, GFP_NOFS);

		if (!map) {

			kmem_cache_free(btrfs_free_space_cachep, info);

			return -ENOMEM;

		}

	}



	spin_lock(&ctl->tree_lock);

	bitmap_info = tree_search_offset(ctl, offset_to_bitmap(ctl, offset),

					 1, 0);

	if (!bitmap_info) {

		info->bitmap = map;

		map = NULL;

		add_new_bitmap(ctl, info, offset);

		bitmap_info = info;

	}



	bytes_added = add_bytes_to_bitmap(ctl, bitmap_info, offset, bytes);

	bytes -= bytes_added;

	offset += bytes_added;

	spin_unlock(&ctl->tree_lock);



	if (bytes)

		goto again;



	if (map)

		kfree(map);

	return 0;

}



#define test_msg(fmt, ...) printk(KERN_INFO "btrfs: selftest: " fmt, ##__VA_ARGS__)



/*

 * This test just does basic sanity checking, making sure we can add an exten

 * entry and remove space from either end and the middle, and make sure we can

 * remove space that covers adjacent extent entries.

 */

static int test_extents(struct btrfs_block_group_cache *cache)

{

	int ret = 0;



	test_msg("Running extent only tests\n");



	/* First just make sure we can remove an entire entry */

	ret = btrfs_add_free_space(cache, 0, 4 * 1024 * 1024);

	if (ret) {

		test_msg("Error adding initial extents %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 0, 4 * 1024 * 1024);

	if (ret) {

		test_msg("Error removing extent %d\n", ret);

		return ret;

	}



	if (check_exists(cache, 0, 4 * 1024 * 1024)) {

		test_msg("Full remove left some lingering space\n");

		return -1;

	}



	/* Ok edge and middle cases now */

	ret = btrfs_add_free_space(cache, 0, 4 * 1024 * 1024);

	if (ret) {

		test_msg("Error adding half extent %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 3 * 1024 * 1024, 1 * 1024 * 1024);

	if (ret) {

		test_msg("Error removing tail end %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 0, 1 * 1024 * 1024);

	if (ret) {

		test_msg("Error removing front end %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 2 * 1024 * 1024, 4096);

	if (ret) {

		test_msg("Error removing middle piece %d\n", ret);

		return ret;

	}



	if (check_exists(cache, 0, 1 * 1024 * 1024)) {

		test_msg("Still have space at the front\n");

		return -1;

	}



	if (check_exists(cache, 2 * 1024 * 1024, 4096)) {

		test_msg("Still have space in the middle\n");

		return -1;

	}



	if (check_exists(cache, 3 * 1024 * 1024, 1 * 1024 * 1024)) {

		test_msg("Still have space at the end\n");

		return -1;

	}



	/* Cleanup */

	__btrfs_remove_free_space_cache(cache->free_space_ctl);



	return 0;

}



static int test_bitmaps(struct btrfs_block_group_cache *cache)

{

	u64 next_bitmap_offset;

	int ret;



	test_msg("Running bitmap only tests\n");



	ret = add_free_space_entry(cache, 0, 4 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't create a bitmap entry %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 0, 4 * 1024 * 1024);

	if (ret) {

		test_msg("Error removing bitmap full range %d\n", ret);

		return ret;

	}



	if (check_exists(cache, 0, 4 * 1024 * 1024)) {

		test_msg("Left some space in bitmap\n");

		return -1;

	}



	ret = add_free_space_entry(cache, 0, 4 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't add to our bitmap entry %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 1 * 1024 * 1024, 2 * 1024 * 1024);

	if (ret) {

		test_msg("Couldn't remove middle chunk %d\n", ret);

		return ret;

	}



	/*

	 * The first bitmap we have starts at offset 0 so the next one is just

	 * at the end of the first bitmap.

	 */

	next_bitmap_offset = (u64)(BITS_PER_BITMAP * 4096);



	/* Test a bit straddling two bitmaps */

	ret = add_free_space_entry(cache, next_bitmap_offset -

				   (2 * 1024 * 1024), 4 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't add space that straddles two bitmaps %d\n",

				ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, next_bitmap_offset -

				      (1 * 1024 * 1024), 2 * 1024 * 1024);

	if (ret) {

		test_msg("Couldn't remove overlapping space %d\n", ret);

		return ret;

	}



	if (check_exists(cache, next_bitmap_offset - (1 * 1024 * 1024),

			 2 * 1024 * 1024)) {

		test_msg("Left some space when removing overlapping\n");

		return -1;

	}



	__btrfs_remove_free_space_cache(cache->free_space_ctl);



	return 0;

}



/* This is the high grade jackassery */

static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache)

{

	u64 bitmap_offset = (u64)(BITS_PER_BITMAP * 4096);

	int ret;



	test_msg("Running bitmap and extent tests\n");



	/*

	 * First let's do something simple, an extent at the same offset as the

	 * bitmap, but the free space completely in the extent and then

	 * completely in the bitmap.

	 */

	ret = add_free_space_entry(cache, 4 * 1024 * 1024, 1 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't create bitmap entry %d\n", ret);

		return ret;

	}



	ret = add_free_space_entry(cache, 0, 1 * 1024 * 1024, 0);

	if (ret) {

		test_msg("Couldn't add extent entry %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 0, 1 * 1024 * 1024);

	if (ret) {

		test_msg("Couldn't remove extent entry %d\n", ret);

		return ret;

	}



	if (check_exists(cache, 0, 1 * 1024 * 1024)) {

		test_msg("Left remnants after our remove\n");

		return -1;

	}



	/* Now to add back the extent entry and remove from the bitmap */

	ret = add_free_space_entry(cache, 0, 1 * 1024 * 1024, 0);

	if (ret) {

		test_msg("Couldn't re-add extent entry %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 4 * 1024 * 1024, 1 * 1024 * 1024);

	if (ret) {

		test_msg("Couldn't remove from bitmap %d\n", ret);

		return ret;

	}



	if (check_exists(cache, 4 * 1024 * 1024, 1 * 1024 * 1024)) {

		test_msg("Left remnants in the bitmap\n");

		return -1;

	}



	/*

	 * Ok so a little more evil, extent entry and bitmap at the same offset,

	 * removing an overlapping chunk.

	 */

	ret = add_free_space_entry(cache, 1 * 1024 * 1024, 4 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't add to a bitmap %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 512 * 1024, 3 * 1024 * 1024);

	if (ret) {

		test_msg("Couldn't remove overlapping space %d\n", ret);

		return ret;

	}



	if (check_exists(cache, 512 * 1024, 3 * 1024 * 1024)) {

		test_msg("Left over peices after removing overlapping\n");

		return -1;

	}



	__btrfs_remove_free_space_cache(cache->free_space_ctl);



	/* Now with the extent entry offset into the bitmap */

	ret = add_free_space_entry(cache, 4 * 1024 * 1024, 4 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't add space to the bitmap %d\n", ret);

		return ret;

	}



	ret = add_free_space_entry(cache, 2 * 1024 * 1024, 2 * 1024 * 1024, 0);

	if (ret) {

		test_msg("Couldn't add extent to the cache %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 3 * 1024 * 1024, 4 * 1024 * 1024);

	if (ret) {

		test_msg("Problem removing overlapping space %d\n", ret);

		return ret;

	}



	if (check_exists(cache, 3 * 1024 * 1024, 4 * 1024 * 1024)) {

		test_msg("Left something behind when removing space");

		return -1;

	}



	/*

	 * This has blown up in the past, the extent entry starts before the

	 * bitmap entry, but we're trying to remove an offset that falls

	 * completely within the bitmap range and is in both the extent entry

	 * and the bitmap entry, looks like this

	 *

	 *   [ extent ]

	 *      [ bitmap ]

	 *        [ del ]

	 */

	__btrfs_remove_free_space_cache(cache->free_space_ctl);

	ret = add_free_space_entry(cache, bitmap_offset + 4 * 1024 * 1024,

				   4 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't add bitmap %d\n", ret);

		return ret;

	}



	ret = add_free_space_entry(cache, bitmap_offset - 1 * 1024 * 1024,

				   5 * 1024 * 1024, 0);

	if (ret) {

		test_msg("Couldn't add extent entry %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, bitmap_offset + 1 * 1024 * 1024,

				      5 * 1024 * 1024);

	if (ret) {

		test_msg("Failed to free our space %d\n", ret);

		return ret;

	}



	if (check_exists(cache, bitmap_offset + 1 * 1024 * 1024,

			 5 * 1024 * 1024)) {

		test_msg("Left stuff over\n");

		return -1;

	}



	__btrfs_remove_free_space_cache(cache->free_space_ctl);



	/*

	 * This blew up before, we have part of the free space in a bitmap and

	 * then the entirety of the rest of the space in an extent.  This used

	 * to return -EAGAIN back from btrfs_remove_extent, make sure this

	 * doesn't happen.

	 */

	ret = add_free_space_entry(cache, 1 * 1024 * 1024, 2 * 1024 * 1024, 1);

	if (ret) {

		test_msg("Couldn't add bitmap entry %d\n", ret);

		return ret;

	}



	ret = add_free_space_entry(cache, 3 * 1024 * 1024, 1 * 1024 * 1024, 0);

	if (ret) {

		test_msg("Couldn't add extent entry %d\n", ret);

		return ret;

	}



	ret = btrfs_remove_free_space(cache, 1 * 1024 * 1024, 3 * 1024 * 1024);

	if (ret) {

		test_msg("Error removing bitmap and extent overlapping %d\n", ret);

		return ret;

	}



	__btrfs_remove_free_space_cache(cache->free_space_ctl);

	return 0;

}



void btrfs_test_free_space_cache(void)

{

	struct btrfs_block_group_cache *cache;



	test_msg("Running btrfs free space cache tests\n");



	cache = init_test_block_group();

	if (!cache) {

		test_msg("Couldn't run the tests\n");

		return;

	}



	if (test_extents(cache))

		goto out;

	if (test_bitmaps(cache))

		goto out;

	if (test_bitmaps_and_extents(cache))

		goto out;

out:

	__btrfs_remove_free_space_cache(cache->free_space_ctl);

	kfree(cache->free_space_ctl);

	kfree(cache);

	test_msg("Free space cache tests finished\n");

}

#undef test_msg

#else /* !CONFIG_BTRFS_FS_RUN_SANITY_TESTS */

void btrfs_test_free_space_cache(void) {}

#endif /* !CONFIG_BTRFS_FS_RUN_SANITY_TESTS */
 
#endif /* CONFIG_BTRFS_FS_RUN_SANITY_TESTS */

fs/btrfs/free-space-cache.h

+7 −1
Original line number Diff line number Diff line
@@ -112,6 +112,12 @@ int btrfs_return_cluster_to_free_space( 
int btrfs_trim_block_group(struct btrfs_block_group_cache *block_group,

			   u64 *trimmed, u64 start, u64 end, u64 minlen);



void btrfs_test_free_space_cache(void);

/* Support functions for runnint our sanity tests */

#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS

int test_add_free_space_entry(struct btrfs_block_group_cache *cache,

			      u64 offset, u64 bytes, bool bitmap);

int test_check_exists(struct btrfs_block_group_cache *cache,

		      u64 offset, u64 bytes);

#endif



#endif

fs/btrfs/super.c

+14 −5
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ 
#include "rcu-string.h"

#include "dev-replace.h"

#include "free-space-cache.h"

#include "tests/btrfs-tests.h"



#define CREATE_TRACE_POINTS

#include <trace/events/btrfs.h>
@@ -1762,6 +1763,11 @@ static void btrfs_print_info(void) 
			"\n");

}



static int btrfs_run_sanity_tests(void)

{

	return btrfs_test_free_space_cache();

}



static int __init init_btrfs_fs(void)

{

	int err;
@@ -1804,14 +1810,17 @@ static int __init init_btrfs_fs(void) 
	if (err)

		goto free_delayed_ref;



	err = register_filesystem(&btrfs_fs_type);

	if (err)

		goto unregister_ioctl;



	btrfs_init_lockdep();



	btrfs_print_info();

	btrfs_test_free_space_cache();



	err = btrfs_run_sanity_tests();

	if (err)

		goto unregister_ioctl;



	err = register_filesystem(&btrfs_fs_type);

	if (err)

		goto unregister_ioctl;



	return 0;

fs/btrfs/tests/btrfs-tests.h

0 → 100644
+34 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2013 Fusion IO.  All rights reserved.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public

 * License v2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public

 * License along with this program; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 021110-1307, USA.

 */



#ifndef __BTRFS_TESTS

#define __BTRFS_TESTS



#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS



#define test_msg(fmt, ...) pr_info("btrfs: selftest: " fmt, ##__VA_ARGS__)



int btrfs_test_free_space_cache(void);

#else

static inline int btrfs_test_free_space_cache(void)

{

	return 0;

}

#endif



#endif