2 * Copyright (C) 2013 Fusion IO. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include <linux/slab.h>
20 #include "btrfs-tests.h"
22 #include "../disk-io.h"
23 #include "../free-space-cache.h"
25 #define BITS_PER_BITMAP (PAGE_SIZE * 8UL)
28 * This test just does basic sanity checking, making sure we can add an extent
29 * entry and remove space from either end and the middle, and make sure we can
30 * remove space that covers adjacent extent entries.
32 static int test_extents(struct btrfs_block_group_cache *cache)
36 test_msg("Running extent only tests\n");
38 /* First just make sure we can remove an entire entry */
39 ret = btrfs_add_free_space(cache, 0, SZ_4M);
41 test_msg("Error adding initial extents %d\n", ret);
45 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
47 test_msg("Error removing extent %d\n", ret);
51 if (test_check_exists(cache, 0, SZ_4M)) {
52 test_msg("Full remove left some lingering space\n");
56 /* Ok edge and middle cases now */
57 ret = btrfs_add_free_space(cache, 0, SZ_4M);
59 test_msg("Error adding half extent %d\n", ret);
63 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_1M);
65 test_msg("Error removing tail end %d\n", ret);
69 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
71 test_msg("Error removing front end %d\n", ret);
75 ret = btrfs_remove_free_space(cache, SZ_2M, 4096);
77 test_msg("Error removing middle piece %d\n", ret);
81 if (test_check_exists(cache, 0, SZ_1M)) {
82 test_msg("Still have space at the front\n");
86 if (test_check_exists(cache, SZ_2M, 4096)) {
87 test_msg("Still have space in the middle\n");
91 if (test_check_exists(cache, 3 * SZ_1M, SZ_1M)) {
92 test_msg("Still have space at the end\n");
97 __btrfs_remove_free_space_cache(cache->free_space_ctl);
102 static int test_bitmaps(struct btrfs_block_group_cache *cache,
105 u64 next_bitmap_offset;
108 test_msg("Running bitmap only tests\n");
110 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
112 test_msg("Couldn't create a bitmap entry %d\n", ret);
116 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
118 test_msg("Error removing bitmap full range %d\n", ret);
122 if (test_check_exists(cache, 0, SZ_4M)) {
123 test_msg("Left some space in bitmap\n");
127 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
129 test_msg("Couldn't add to our bitmap entry %d\n", ret);
133 ret = btrfs_remove_free_space(cache, SZ_1M, SZ_2M);
135 test_msg("Couldn't remove middle chunk %d\n", ret);
140 * The first bitmap we have starts at offset 0 so the next one is just
141 * at the end of the first bitmap.
143 next_bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
145 /* Test a bit straddling two bitmaps */
146 ret = test_add_free_space_entry(cache, next_bitmap_offset - SZ_2M,
149 test_msg("Couldn't add space that straddles two bitmaps %d\n",
154 ret = btrfs_remove_free_space(cache, next_bitmap_offset - SZ_1M, SZ_2M);
156 test_msg("Couldn't remove overlapping space %d\n", ret);
160 if (test_check_exists(cache, next_bitmap_offset - SZ_1M, SZ_2M)) {
161 test_msg("Left some space when removing overlapping\n");
165 __btrfs_remove_free_space_cache(cache->free_space_ctl);
170 /* This is the high grade jackassery */
171 static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache,
174 u64 bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
177 test_msg("Running bitmap and extent tests\n");
180 * First let's do something simple, an extent at the same offset as the
181 * bitmap, but the free space completely in the extent and then
182 * completely in the bitmap.
184 ret = test_add_free_space_entry(cache, SZ_4M, SZ_1M, 1);
186 test_msg("Couldn't create bitmap entry %d\n", ret);
190 ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
192 test_msg("Couldn't add extent entry %d\n", ret);
196 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
198 test_msg("Couldn't remove extent entry %d\n", ret);
202 if (test_check_exists(cache, 0, SZ_1M)) {
203 test_msg("Left remnants after our remove\n");
207 /* Now to add back the extent entry and remove from the bitmap */
208 ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
210 test_msg("Couldn't re-add extent entry %d\n", ret);
214 ret = btrfs_remove_free_space(cache, SZ_4M, SZ_1M);
216 test_msg("Couldn't remove from bitmap %d\n", ret);
220 if (test_check_exists(cache, SZ_4M, SZ_1M)) {
221 test_msg("Left remnants in the bitmap\n");
226 * Ok so a little more evil, extent entry and bitmap at the same offset,
227 * removing an overlapping chunk.
229 ret = test_add_free_space_entry(cache, SZ_1M, SZ_4M, 1);
231 test_msg("Couldn't add to a bitmap %d\n", ret);
235 ret = btrfs_remove_free_space(cache, SZ_512K, 3 * SZ_1M);
237 test_msg("Couldn't remove overlapping space %d\n", ret);
241 if (test_check_exists(cache, SZ_512K, 3 * SZ_1M)) {
242 test_msg("Left over pieces after removing overlapping\n");
246 __btrfs_remove_free_space_cache(cache->free_space_ctl);
248 /* Now with the extent entry offset into the bitmap */
249 ret = test_add_free_space_entry(cache, SZ_4M, SZ_4M, 1);
251 test_msg("Couldn't add space to the bitmap %d\n", ret);
255 ret = test_add_free_space_entry(cache, SZ_2M, SZ_2M, 0);
257 test_msg("Couldn't add extent to the cache %d\n", ret);
261 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_4M);
263 test_msg("Problem removing overlapping space %d\n", ret);
267 if (test_check_exists(cache, 3 * SZ_1M, SZ_4M)) {
268 test_msg("Left something behind when removing space");
273 * This has blown up in the past, the extent entry starts before the
274 * bitmap entry, but we're trying to remove an offset that falls
275 * completely within the bitmap range and is in both the extent entry
276 * and the bitmap entry, looks like this
282 __btrfs_remove_free_space_cache(cache->free_space_ctl);
283 ret = test_add_free_space_entry(cache, bitmap_offset + SZ_4M, SZ_4M, 1);
285 test_msg("Couldn't add bitmap %d\n", ret);
289 ret = test_add_free_space_entry(cache, bitmap_offset - SZ_1M,
292 test_msg("Couldn't add extent entry %d\n", ret);
296 ret = btrfs_remove_free_space(cache, bitmap_offset + SZ_1M, 5 * SZ_1M);
298 test_msg("Failed to free our space %d\n", ret);
302 if (test_check_exists(cache, bitmap_offset + SZ_1M, 5 * SZ_1M)) {
303 test_msg("Left stuff over\n");
307 __btrfs_remove_free_space_cache(cache->free_space_ctl);
310 * This blew up before, we have part of the free space in a bitmap and
311 * then the entirety of the rest of the space in an extent. This used
312 * to return -EAGAIN back from btrfs_remove_extent, make sure this
315 ret = test_add_free_space_entry(cache, SZ_1M, SZ_2M, 1);
317 test_msg("Couldn't add bitmap entry %d\n", ret);
321 ret = test_add_free_space_entry(cache, 3 * SZ_1M, SZ_1M, 0);
323 test_msg("Couldn't add extent entry %d\n", ret);
327 ret = btrfs_remove_free_space(cache, SZ_1M, 3 * SZ_1M);
329 test_msg("Error removing bitmap and extent overlapping %d\n", ret);
333 __btrfs_remove_free_space_cache(cache->free_space_ctl);
337 /* Used by test_steal_space_from_bitmap_to_extent(). */
338 static bool test_use_bitmap(struct btrfs_free_space_ctl *ctl,
339 struct btrfs_free_space *info)
341 return ctl->free_extents > 0;
344 /* Used by test_steal_space_from_bitmap_to_extent(). */
346 check_num_extents_and_bitmaps(const struct btrfs_block_group_cache *cache,
347 const int num_extents,
348 const int num_bitmaps)
350 if (cache->free_space_ctl->free_extents != num_extents) {
351 test_msg("Incorrect # of extent entries in the cache: %d, expected %d\n",
352 cache->free_space_ctl->free_extents, num_extents);
355 if (cache->free_space_ctl->total_bitmaps != num_bitmaps) {
356 test_msg("Incorrect # of extent entries in the cache: %d, expected %d\n",
357 cache->free_space_ctl->total_bitmaps, num_bitmaps);
363 /* Used by test_steal_space_from_bitmap_to_extent(). */
364 static int check_cache_empty(struct btrfs_block_group_cache *cache)
370 * Now lets confirm that there's absolutely no free space left to
373 if (cache->free_space_ctl->free_space != 0) {
374 test_msg("Cache free space is not 0\n");
378 /* And any allocation request, no matter how small, should fail now. */
379 offset = btrfs_find_space_for_alloc(cache, 0, 4096, 0,
382 test_msg("Space allocation did not fail, returned offset: %llu",
387 /* And no extent nor bitmap entries in the cache anymore. */
388 return check_num_extents_and_bitmaps(cache, 0, 0);
392 * Before we were able to steal free space from a bitmap entry to an extent
393 * entry, we could end up with 2 entries representing a contiguous free space.
394 * One would be an extent entry and the other a bitmap entry. Since in order
395 * to allocate space to a caller we use only 1 entry, we couldn't return that
396 * whole range to the caller if it was requested. This forced the caller to
397 * either assume ENOSPC or perform several smaller space allocations, which
398 * wasn't optimal as they could be spread all over the block group while under
399 * concurrency (extra overhead and fragmentation).
401 * This stealing approach is beneficial, since we always prefer to allocate
402 * from extent entries, both for clustered and non-clustered allocation
406 test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache,
412 const struct btrfs_free_space_op test_free_space_ops = {
413 .recalc_thresholds = cache->free_space_ctl->op->recalc_thresholds,
414 .use_bitmap = test_use_bitmap,
416 const struct btrfs_free_space_op *orig_free_space_ops;
418 test_msg("Running space stealing from bitmap to extent\n");
421 * For this test, we want to ensure we end up with an extent entry
422 * immediately adjacent to a bitmap entry, where the bitmap starts
423 * at an offset where the extent entry ends. We keep adding and
424 * removing free space to reach into this state, but to get there
425 * we need to reach a point where marking new free space doesn't
426 * result in adding new extent entries or merging the new space
427 * with existing extent entries - the space ends up being marked
428 * in an existing bitmap that covers the new free space range.
430 * To get there, we need to reach the threshold defined set at
431 * cache->free_space_ctl->extents_thresh, which currently is
432 * 256 extents on a x86_64 system at least, and a few other
433 * conditions (check free_space_cache.c). Instead of making the
434 * test much longer and complicated, use a "use_bitmap" operation
435 * that forces use of bitmaps as soon as we have at least 1
438 orig_free_space_ops = cache->free_space_ctl->op;
439 cache->free_space_ctl->op = &test_free_space_ops;
442 * Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[
444 ret = test_add_free_space_entry(cache, SZ_128M - SZ_256K, SZ_128K, 0);
446 test_msg("Couldn't add extent entry %d\n", ret);
450 /* Bitmap entry covering free space range [128Mb + 512Kb, 256Mb[ */
451 ret = test_add_free_space_entry(cache, SZ_128M + SZ_512K,
452 SZ_128M - SZ_512K, 1);
454 test_msg("Couldn't add bitmap entry %d\n", ret);
458 ret = check_num_extents_and_bitmaps(cache, 2, 1);
463 * Now make only the first 256Kb of the bitmap marked as free, so that
464 * we end up with only the following ranges marked as free space:
466 * [128Mb - 256Kb, 128Mb - 128Kb[
467 * [128Mb + 512Kb, 128Mb + 768Kb[
469 ret = btrfs_remove_free_space(cache,
470 SZ_128M + 768 * SZ_1K,
471 SZ_128M - 768 * SZ_1K);
473 test_msg("Failed to free part of bitmap space %d\n", ret);
477 /* Confirm that only those 2 ranges are marked as free. */
478 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_128K)) {
479 test_msg("Free space range missing\n");
482 if (!test_check_exists(cache, SZ_128M + SZ_512K, SZ_256K)) {
483 test_msg("Free space range missing\n");
488 * Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked
491 if (test_check_exists(cache, SZ_128M + 768 * SZ_1K,
492 SZ_128M - 768 * SZ_1K)) {
493 test_msg("Bitmap region not removed from space cache\n");
498 * Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is
499 * covered by the bitmap, isn't marked as free.
501 if (test_check_exists(cache, SZ_128M + SZ_256K, SZ_256K)) {
502 test_msg("Invalid bitmap region marked as free\n");
507 * Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered
508 * by the bitmap too, isn't marked as free either.
510 if (test_check_exists(cache, SZ_128M, SZ_256K)) {
511 test_msg("Invalid bitmap region marked as free\n");
516 * Now lets mark the region [128Mb, 128Mb + 512Kb[ as free too. But,
517 * lets make sure the free space cache marks it as free in the bitmap,
518 * and doesn't insert a new extent entry to represent this region.
520 ret = btrfs_add_free_space(cache, SZ_128M, SZ_512K);
522 test_msg("Error adding free space: %d\n", ret);
525 /* Confirm the region is marked as free. */
526 if (!test_check_exists(cache, SZ_128M, SZ_512K)) {
527 test_msg("Bitmap region not marked as free\n");
532 * Confirm that no new extent entries or bitmap entries were added to
533 * the cache after adding that free space region.
535 ret = check_num_extents_and_bitmaps(cache, 2, 1);
540 * Now lets add a small free space region to the right of the previous
541 * one, which is not contiguous with it and is part of the bitmap too.
542 * The goal is to test that the bitmap entry space stealing doesn't
543 * steal this space region.
545 ret = btrfs_add_free_space(cache, SZ_128M + SZ_16M, sectorsize);
547 test_msg("Error adding free space: %d\n", ret);
552 * Confirm that no new extent entries or bitmap entries were added to
553 * the cache after adding that free space region.
555 ret = check_num_extents_and_bitmaps(cache, 2, 1);
560 * Now mark the region [128Mb - 128Kb, 128Mb[ as free too. This will
561 * expand the range covered by the existing extent entry that represents
562 * the free space [128Mb - 256Kb, 128Mb - 128Kb[.
564 ret = btrfs_add_free_space(cache, SZ_128M - SZ_128K, SZ_128K);
566 test_msg("Error adding free space: %d\n", ret);
569 /* Confirm the region is marked as free. */
570 if (!test_check_exists(cache, SZ_128M - SZ_128K, SZ_128K)) {
571 test_msg("Extent region not marked as free\n");
576 * Confirm that our extent entry didn't stole all free space from the
577 * bitmap, because of the small 4Kb free space region.
579 ret = check_num_extents_and_bitmaps(cache, 2, 1);
584 * So now we have the range [128Mb - 256Kb, 128Mb + 768Kb[ as free
585 * space. Without stealing bitmap free space into extent entry space,
586 * we would have all this free space represented by 2 entries in the
589 * extent entry covering range: [128Mb - 256Kb, 128Mb[
590 * bitmap entry covering range: [128Mb, 128Mb + 768Kb[
592 * Attempting to allocate the whole free space (1Mb) would fail, because
593 * we can't allocate from multiple entries.
594 * With the bitmap free space stealing, we get a single extent entry
595 * that represents the 1Mb free space, and therefore we're able to
596 * allocate the whole free space at once.
598 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_1M)) {
599 test_msg("Expected region not marked as free\n");
603 if (cache->free_space_ctl->free_space != (SZ_1M + sectorsize)) {
604 test_msg("Cache free space is not 1Mb + %u\n", sectorsize);
608 offset = btrfs_find_space_for_alloc(cache,
611 if (offset != (SZ_128M - SZ_256K)) {
612 test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n",
618 * All that remains is a sectorsize free space region in a bitmap.
621 ret = check_num_extents_and_bitmaps(cache, 1, 1);
625 if (cache->free_space_ctl->free_space != sectorsize) {
626 test_msg("Cache free space is not %u\n", sectorsize);
630 offset = btrfs_find_space_for_alloc(cache,
633 if (offset != (SZ_128M + SZ_16M)) {
634 test_msg("Failed to allocate %u, returned offset : %llu\n",
639 ret = check_cache_empty(cache);
643 __btrfs_remove_free_space_cache(cache->free_space_ctl);
646 * Now test a similar scenario, but where our extent entry is located
647 * to the right of the bitmap entry, so that we can check that stealing
648 * space from a bitmap to the front of an extent entry works.
652 * Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[
654 ret = test_add_free_space_entry(cache, SZ_128M + SZ_128K, SZ_128K, 0);
656 test_msg("Couldn't add extent entry %d\n", ret);
660 /* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */
661 ret = test_add_free_space_entry(cache, 0, SZ_128M - SZ_512K, 1);
663 test_msg("Couldn't add bitmap entry %d\n", ret);
667 ret = check_num_extents_and_bitmaps(cache, 2, 1);
672 * Now make only the last 256Kb of the bitmap marked as free, so that
673 * we end up with only the following ranges marked as free space:
675 * [128Mb + 128b, 128Mb + 256Kb[
676 * [128Mb - 768Kb, 128Mb - 512Kb[
678 ret = btrfs_remove_free_space(cache, 0, SZ_128M - 768 * SZ_1K);
680 test_msg("Failed to free part of bitmap space %d\n", ret);
684 /* Confirm that only those 2 ranges are marked as free. */
685 if (!test_check_exists(cache, SZ_128M + SZ_128K, SZ_128K)) {
686 test_msg("Free space range missing\n");
689 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_256K)) {
690 test_msg("Free space range missing\n");
695 * Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked
698 if (test_check_exists(cache, 0, SZ_128M - 768 * SZ_1K)) {
699 test_msg("Bitmap region not removed from space cache\n");
704 * Confirm that the region [128Mb - 512Kb, 128Mb[, which is
705 * covered by the bitmap, isn't marked as free.
707 if (test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
708 test_msg("Invalid bitmap region marked as free\n");
713 * Now lets mark the region [128Mb - 512Kb, 128Mb[ as free too. But,
714 * lets make sure the free space cache marks it as free in the bitmap,
715 * and doesn't insert a new extent entry to represent this region.
717 ret = btrfs_add_free_space(cache, SZ_128M - SZ_512K, SZ_512K);
719 test_msg("Error adding free space: %d\n", ret);
722 /* Confirm the region is marked as free. */
723 if (!test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
724 test_msg("Bitmap region not marked as free\n");
729 * Confirm that no new extent entries or bitmap entries were added to
730 * the cache after adding that free space region.
732 ret = check_num_extents_and_bitmaps(cache, 2, 1);
737 * Now lets add a small free space region to the left of the previous
738 * one, which is not contiguous with it and is part of the bitmap too.
739 * The goal is to test that the bitmap entry space stealing doesn't
740 * steal this space region.
742 ret = btrfs_add_free_space(cache, SZ_32M, 2 * sectorsize);
744 test_msg("Error adding free space: %d\n", ret);
749 * Now mark the region [128Mb, 128Mb + 128Kb[ as free too. This will
750 * expand the range covered by the existing extent entry that represents
751 * the free space [128Mb + 128Kb, 128Mb + 256Kb[.
753 ret = btrfs_add_free_space(cache, SZ_128M, SZ_128K);
755 test_msg("Error adding free space: %d\n", ret);
758 /* Confirm the region is marked as free. */
759 if (!test_check_exists(cache, SZ_128M, SZ_128K)) {
760 test_msg("Extent region not marked as free\n");
765 * Confirm that our extent entry didn't stole all free space from the
766 * bitmap, because of the small 2 * sectorsize free space region.
768 ret = check_num_extents_and_bitmaps(cache, 2, 1);
773 * So now we have the range [128Mb - 768Kb, 128Mb + 256Kb[ as free
774 * space. Without stealing bitmap free space into extent entry space,
775 * we would have all this free space represented by 2 entries in the
778 * extent entry covering range: [128Mb, 128Mb + 256Kb[
779 * bitmap entry covering range: [128Mb - 768Kb, 128Mb[
781 * Attempting to allocate the whole free space (1Mb) would fail, because
782 * we can't allocate from multiple entries.
783 * With the bitmap free space stealing, we get a single extent entry
784 * that represents the 1Mb free space, and therefore we're able to
785 * allocate the whole free space at once.
787 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_1M)) {
788 test_msg("Expected region not marked as free\n");
792 if (cache->free_space_ctl->free_space != (SZ_1M + 2 * sectorsize)) {
793 test_msg("Cache free space is not 1Mb + %u\n", 2 * sectorsize);
797 offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0,
799 if (offset != (SZ_128M - 768 * SZ_1K)) {
800 test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n",
806 * All that remains is 2 * sectorsize free space region
807 * in a bitmap. Confirm.
809 ret = check_num_extents_and_bitmaps(cache, 1, 1);
813 if (cache->free_space_ctl->free_space != 2 * sectorsize) {
814 test_msg("Cache free space is not %u\n", 2 * sectorsize);
818 offset = btrfs_find_space_for_alloc(cache,
819 0, 2 * sectorsize, 0,
821 if (offset != SZ_32M) {
822 test_msg("Failed to allocate %u, offset: %llu\n",
828 ret = check_cache_empty(cache);
832 cache->free_space_ctl->op = orig_free_space_ops;
833 __btrfs_remove_free_space_cache(cache->free_space_ctl);
838 int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize)
840 struct btrfs_fs_info *fs_info;
841 struct btrfs_block_group_cache *cache;
842 struct btrfs_root *root = NULL;
845 test_msg("Running btrfs free space cache tests\n");
846 fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);
852 * For ppc64 (with 64k page size), bytes per bitmap might be
853 * larger than 1G. To make bitmap test available in ppc64,
854 * alloc dummy block group whose size cross bitmaps.
856 cache = btrfs_alloc_dummy_block_group(fs_info,
857 BITS_PER_BITMAP * sectorsize + PAGE_SIZE);
859 test_msg("Couldn't run the tests\n");
860 btrfs_free_dummy_fs_info(fs_info);
864 root = btrfs_alloc_dummy_root(fs_info);
870 root->fs_info->extent_root = root;
872 ret = test_extents(cache);
875 ret = test_bitmaps(cache, sectorsize);
878 ret = test_bitmaps_and_extents(cache, sectorsize);
882 ret = test_steal_space_from_bitmap_to_extent(cache, sectorsize);
884 btrfs_free_dummy_block_group(cache);
885 btrfs_free_dummy_root(root);
886 btrfs_free_dummy_fs_info(fs_info);
887 test_msg("Free space cache tests finished\n");