1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2013 Fusion IO. All rights reserved.
6 #include <linux/slab.h>
7 #include "btrfs-tests.h"
9 #include "../disk-io.h"
10 #include "../free-space-cache.h"
11 #include "../block-group.h"
13 #define BITS_PER_BITMAP (PAGE_SIZE * 8UL)
16 * This test just does basic sanity checking, making sure we can add an extent
17 * entry and remove space from either end and the middle, and make sure we can
18 * remove space that covers adjacent extent entries.
20 static int test_extents(struct btrfs_block_group *cache)
24 test_msg("running extent only tests");
26 /* First just make sure we can remove an entire entry */
27 ret = btrfs_add_free_space(cache, 0, SZ_4M);
29 test_err("error adding initial extents %d", ret);
33 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
35 test_err("error removing extent %d", ret);
39 if (test_check_exists(cache, 0, SZ_4M)) {
40 test_err("full remove left some lingering space");
44 /* Ok edge and middle cases now */
45 ret = btrfs_add_free_space(cache, 0, SZ_4M);
47 test_err("error adding half extent %d", ret);
51 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_1M);
53 test_err("error removing tail end %d", ret);
57 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
59 test_err("error removing front end %d", ret);
63 ret = btrfs_remove_free_space(cache, SZ_2M, 4096);
65 test_err("error removing middle piece %d", ret);
69 if (test_check_exists(cache, 0, SZ_1M)) {
70 test_err("still have space at the front");
74 if (test_check_exists(cache, SZ_2M, 4096)) {
75 test_err("still have space in the middle");
79 if (test_check_exists(cache, 3 * SZ_1M, SZ_1M)) {
80 test_err("still have space at the end");
85 btrfs_remove_free_space_cache(cache);
90 static int test_bitmaps(struct btrfs_block_group *cache, u32 sectorsize)
92 u64 next_bitmap_offset;
95 test_msg("running bitmap only tests");
97 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
99 test_err("couldn't create a bitmap entry %d", ret);
103 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
105 test_err("error removing bitmap full range %d", ret);
109 if (test_check_exists(cache, 0, SZ_4M)) {
110 test_err("left some space in bitmap");
114 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
116 test_err("couldn't add to our bitmap entry %d", ret);
120 ret = btrfs_remove_free_space(cache, SZ_1M, SZ_2M);
122 test_err("couldn't remove middle chunk %d", ret);
127 * The first bitmap we have starts at offset 0 so the next one is just
128 * at the end of the first bitmap.
130 next_bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
132 /* Test a bit straddling two bitmaps */
133 ret = test_add_free_space_entry(cache, next_bitmap_offset - SZ_2M,
136 test_err("couldn't add space that straddles two bitmaps %d",
141 ret = btrfs_remove_free_space(cache, next_bitmap_offset - SZ_1M, SZ_2M);
143 test_err("couldn't remove overlapping space %d", ret);
147 if (test_check_exists(cache, next_bitmap_offset - SZ_1M, SZ_2M)) {
148 test_err("left some space when removing overlapping");
152 btrfs_remove_free_space_cache(cache);
157 /* This is the high grade jackassery */
158 static int test_bitmaps_and_extents(struct btrfs_block_group *cache,
161 u64 bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
164 test_msg("running bitmap and extent tests");
167 * First let's do something simple, an extent at the same offset as the
168 * bitmap, but the free space completely in the extent and then
169 * completely in the bitmap.
171 ret = test_add_free_space_entry(cache, SZ_4M, SZ_1M, 1);
173 test_err("couldn't create bitmap entry %d", ret);
177 ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
179 test_err("couldn't add extent entry %d", ret);
183 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
185 test_err("couldn't remove extent entry %d", ret);
189 if (test_check_exists(cache, 0, SZ_1M)) {
190 test_err("left remnants after our remove");
194 /* Now to add back the extent entry and remove from the bitmap */
195 ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
197 test_err("couldn't re-add extent entry %d", ret);
201 ret = btrfs_remove_free_space(cache, SZ_4M, SZ_1M);
203 test_err("couldn't remove from bitmap %d", ret);
207 if (test_check_exists(cache, SZ_4M, SZ_1M)) {
208 test_err("left remnants in the bitmap");
213 * Ok so a little more evil, extent entry and bitmap at the same offset,
214 * removing an overlapping chunk.
216 ret = test_add_free_space_entry(cache, SZ_1M, SZ_4M, 1);
218 test_err("couldn't add to a bitmap %d", ret);
222 ret = btrfs_remove_free_space(cache, SZ_512K, 3 * SZ_1M);
224 test_err("couldn't remove overlapping space %d", ret);
228 if (test_check_exists(cache, SZ_512K, 3 * SZ_1M)) {
229 test_err("left over pieces after removing overlapping");
233 btrfs_remove_free_space_cache(cache);
235 /* Now with the extent entry offset into the bitmap */
236 ret = test_add_free_space_entry(cache, SZ_4M, SZ_4M, 1);
238 test_err("couldn't add space to the bitmap %d", ret);
242 ret = test_add_free_space_entry(cache, SZ_2M, SZ_2M, 0);
244 test_err("couldn't add extent to the cache %d", ret);
248 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_4M);
250 test_err("problem removing overlapping space %d", ret);
254 if (test_check_exists(cache, 3 * SZ_1M, SZ_4M)) {
255 test_err("left something behind when removing space");
260 * This has blown up in the past, the extent entry starts before the
261 * bitmap entry, but we're trying to remove an offset that falls
262 * completely within the bitmap range and is in both the extent entry
263 * and the bitmap entry, looks like this
269 btrfs_remove_free_space_cache(cache);
270 ret = test_add_free_space_entry(cache, bitmap_offset + SZ_4M, SZ_4M, 1);
272 test_err("couldn't add bitmap %d", ret);
276 ret = test_add_free_space_entry(cache, bitmap_offset - SZ_1M,
279 test_err("couldn't add extent entry %d", ret);
283 ret = btrfs_remove_free_space(cache, bitmap_offset + SZ_1M, 5 * SZ_1M);
285 test_err("failed to free our space %d", ret);
289 if (test_check_exists(cache, bitmap_offset + SZ_1M, 5 * SZ_1M)) {
290 test_err("left stuff over");
294 btrfs_remove_free_space_cache(cache);
297 * This blew up before, we have part of the free space in a bitmap and
298 * then the entirety of the rest of the space in an extent. This used
299 * to return -EAGAIN back from btrfs_remove_extent, make sure this
302 ret = test_add_free_space_entry(cache, SZ_1M, SZ_2M, 1);
304 test_err("couldn't add bitmap entry %d", ret);
308 ret = test_add_free_space_entry(cache, 3 * SZ_1M, SZ_1M, 0);
310 test_err("couldn't add extent entry %d", ret);
314 ret = btrfs_remove_free_space(cache, SZ_1M, 3 * SZ_1M);
316 test_err("error removing bitmap and extent overlapping %d", ret);
320 btrfs_remove_free_space_cache(cache);
324 /* Used by test_steal_space_from_bitmap_to_extent(). */
325 static bool test_use_bitmap(struct btrfs_free_space_ctl *ctl,
326 struct btrfs_free_space *info)
328 return ctl->free_extents > 0;
331 /* Used by test_steal_space_from_bitmap_to_extent(). */
333 check_num_extents_and_bitmaps(const struct btrfs_block_group *cache,
334 const int num_extents,
335 const int num_bitmaps)
337 if (cache->free_space_ctl->free_extents != num_extents) {
339 "incorrect # of extent entries in the cache: %d, expected %d",
340 cache->free_space_ctl->free_extents, num_extents);
343 if (cache->free_space_ctl->total_bitmaps != num_bitmaps) {
345 "incorrect # of extent entries in the cache: %d, expected %d",
346 cache->free_space_ctl->total_bitmaps, num_bitmaps);
352 /* Used by test_steal_space_from_bitmap_to_extent(). */
353 static int check_cache_empty(struct btrfs_block_group *cache)
359 * Now lets confirm that there's absolutely no free space left to
362 if (cache->free_space_ctl->free_space != 0) {
363 test_err("cache free space is not 0");
367 /* And any allocation request, no matter how small, should fail now. */
368 offset = btrfs_find_space_for_alloc(cache, 0, 4096, 0,
371 test_err("space allocation did not fail, returned offset: %llu",
376 /* And no extent nor bitmap entries in the cache anymore. */
377 return check_num_extents_and_bitmaps(cache, 0, 0);
381 * Before we were able to steal free space from a bitmap entry to an extent
382 * entry, we could end up with 2 entries representing a contiguous free space.
383 * One would be an extent entry and the other a bitmap entry. Since in order
384 * to allocate space to a caller we use only 1 entry, we couldn't return that
385 * whole range to the caller if it was requested. This forced the caller to
386 * either assume ENOSPC or perform several smaller space allocations, which
387 * wasn't optimal as they could be spread all over the block group while under
388 * concurrency (extra overhead and fragmentation).
390 * This stealing approach is beneficial, since we always prefer to allocate
391 * from extent entries, both for clustered and non-clustered allocation
395 test_steal_space_from_bitmap_to_extent(struct btrfs_block_group *cache,
401 const struct btrfs_free_space_op test_free_space_ops = {
402 .use_bitmap = test_use_bitmap,
404 const struct btrfs_free_space_op *orig_free_space_ops;
406 test_msg("running space stealing from bitmap to extent tests");
409 * For this test, we want to ensure we end up with an extent entry
410 * immediately adjacent to a bitmap entry, where the bitmap starts
411 * at an offset where the extent entry ends. We keep adding and
412 * removing free space to reach into this state, but to get there
413 * we need to reach a point where marking new free space doesn't
414 * result in adding new extent entries or merging the new space
415 * with existing extent entries - the space ends up being marked
416 * in an existing bitmap that covers the new free space range.
418 * To get there, we need to reach the threshold defined set at
419 * cache->free_space_ctl->extents_thresh, which currently is
420 * 256 extents on a x86_64 system at least, and a few other
421 * conditions (check free_space_cache.c). Instead of making the
422 * test much longer and complicated, use a "use_bitmap" operation
423 * that forces use of bitmaps as soon as we have at least 1
426 orig_free_space_ops = cache->free_space_ctl->op;
427 cache->free_space_ctl->op = &test_free_space_ops;
430 * Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[
432 ret = test_add_free_space_entry(cache, SZ_128M - SZ_256K, SZ_128K, 0);
434 test_err("couldn't add extent entry %d", ret);
438 /* Bitmap entry covering free space range [128Mb + 512Kb, 256Mb[ */
439 ret = test_add_free_space_entry(cache, SZ_128M + SZ_512K,
440 SZ_128M - SZ_512K, 1);
442 test_err("couldn't add bitmap entry %d", ret);
446 ret = check_num_extents_and_bitmaps(cache, 2, 1);
451 * Now make only the first 256Kb of the bitmap marked as free, so that
452 * we end up with only the following ranges marked as free space:
454 * [128Mb - 256Kb, 128Mb - 128Kb[
455 * [128Mb + 512Kb, 128Mb + 768Kb[
457 ret = btrfs_remove_free_space(cache,
458 SZ_128M + 768 * SZ_1K,
459 SZ_128M - 768 * SZ_1K);
461 test_err("failed to free part of bitmap space %d", ret);
465 /* Confirm that only those 2 ranges are marked as free. */
466 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_128K)) {
467 test_err("free space range missing");
470 if (!test_check_exists(cache, SZ_128M + SZ_512K, SZ_256K)) {
471 test_err("free space range missing");
476 * Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked
479 if (test_check_exists(cache, SZ_128M + 768 * SZ_1K,
480 SZ_128M - 768 * SZ_1K)) {
481 test_err("bitmap region not removed from space cache");
486 * Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is
487 * covered by the bitmap, isn't marked as free.
489 if (test_check_exists(cache, SZ_128M + SZ_256K, SZ_256K)) {
490 test_err("invalid bitmap region marked as free");
495 * Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered
496 * by the bitmap too, isn't marked as free either.
498 if (test_check_exists(cache, SZ_128M, SZ_256K)) {
499 test_err("invalid bitmap region marked as free");
504 * Now lets mark the region [128Mb, 128Mb + 512Kb[ as free too. But,
505 * lets make sure the free space cache marks it as free in the bitmap,
506 * and doesn't insert a new extent entry to represent this region.
508 ret = btrfs_add_free_space(cache, SZ_128M, SZ_512K);
510 test_err("error adding free space: %d", ret);
513 /* Confirm the region is marked as free. */
514 if (!test_check_exists(cache, SZ_128M, SZ_512K)) {
515 test_err("bitmap region not marked as free");
520 * Confirm that no new extent entries or bitmap entries were added to
521 * the cache after adding that free space region.
523 ret = check_num_extents_and_bitmaps(cache, 2, 1);
528 * Now lets add a small free space region to the right of the previous
529 * one, which is not contiguous with it and is part of the bitmap too.
530 * The goal is to test that the bitmap entry space stealing doesn't
531 * steal this space region.
533 ret = btrfs_add_free_space(cache, SZ_128M + SZ_16M, sectorsize);
535 test_err("error adding free space: %d", ret);
540 * Confirm that no new extent entries or bitmap entries were added to
541 * the cache after adding that free space region.
543 ret = check_num_extents_and_bitmaps(cache, 2, 1);
548 * Now mark the region [128Mb - 128Kb, 128Mb[ as free too. This will
549 * expand the range covered by the existing extent entry that represents
550 * the free space [128Mb - 256Kb, 128Mb - 128Kb[.
552 ret = btrfs_add_free_space(cache, SZ_128M - SZ_128K, SZ_128K);
554 test_err("error adding free space: %d", ret);
557 /* Confirm the region is marked as free. */
558 if (!test_check_exists(cache, SZ_128M - SZ_128K, SZ_128K)) {
559 test_err("extent region not marked as free");
564 * Confirm that our extent entry didn't stole all free space from the
565 * bitmap, because of the small 4Kb free space region.
567 ret = check_num_extents_and_bitmaps(cache, 2, 1);
572 * So now we have the range [128Mb - 256Kb, 128Mb + 768Kb[ as free
573 * space. Without stealing bitmap free space into extent entry space,
574 * we would have all this free space represented by 2 entries in the
577 * extent entry covering range: [128Mb - 256Kb, 128Mb[
578 * bitmap entry covering range: [128Mb, 128Mb + 768Kb[
580 * Attempting to allocate the whole free space (1Mb) would fail, because
581 * we can't allocate from multiple entries.
582 * With the bitmap free space stealing, we get a single extent entry
583 * that represents the 1Mb free space, and therefore we're able to
584 * allocate the whole free space at once.
586 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_1M)) {
587 test_err("expected region not marked as free");
591 if (cache->free_space_ctl->free_space != (SZ_1M + sectorsize)) {
592 test_err("cache free space is not 1Mb + %u", sectorsize);
596 offset = btrfs_find_space_for_alloc(cache,
599 if (offset != (SZ_128M - SZ_256K)) {
601 "failed to allocate 1Mb from space cache, returned offset is: %llu",
607 * All that remains is a sectorsize free space region in a bitmap.
610 ret = check_num_extents_and_bitmaps(cache, 1, 1);
614 if (cache->free_space_ctl->free_space != sectorsize) {
615 test_err("cache free space is not %u", sectorsize);
619 offset = btrfs_find_space_for_alloc(cache,
622 if (offset != (SZ_128M + SZ_16M)) {
623 test_err("failed to allocate %u, returned offset : %llu",
628 ret = check_cache_empty(cache);
632 btrfs_remove_free_space_cache(cache);
635 * Now test a similar scenario, but where our extent entry is located
636 * to the right of the bitmap entry, so that we can check that stealing
637 * space from a bitmap to the front of an extent entry works.
641 * Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[
643 ret = test_add_free_space_entry(cache, SZ_128M + SZ_128K, SZ_128K, 0);
645 test_err("couldn't add extent entry %d", ret);
649 /* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */
650 ret = test_add_free_space_entry(cache, 0, SZ_128M - SZ_512K, 1);
652 test_err("couldn't add bitmap entry %d", ret);
656 ret = check_num_extents_and_bitmaps(cache, 2, 1);
661 * Now make only the last 256Kb of the bitmap marked as free, so that
662 * we end up with only the following ranges marked as free space:
664 * [128Mb + 128b, 128Mb + 256Kb[
665 * [128Mb - 768Kb, 128Mb - 512Kb[
667 ret = btrfs_remove_free_space(cache, 0, SZ_128M - 768 * SZ_1K);
669 test_err("failed to free part of bitmap space %d", ret);
673 /* Confirm that only those 2 ranges are marked as free. */
674 if (!test_check_exists(cache, SZ_128M + SZ_128K, SZ_128K)) {
675 test_err("free space range missing");
678 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_256K)) {
679 test_err("free space range missing");
684 * Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked
687 if (test_check_exists(cache, 0, SZ_128M - 768 * SZ_1K)) {
688 test_err("bitmap region not removed from space cache");
693 * Confirm that the region [128Mb - 512Kb, 128Mb[, which is
694 * covered by the bitmap, isn't marked as free.
696 if (test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
697 test_err("invalid bitmap region marked as free");
702 * Now lets mark the region [128Mb - 512Kb, 128Mb[ as free too. But,
703 * lets make sure the free space cache marks it as free in the bitmap,
704 * and doesn't insert a new extent entry to represent this region.
706 ret = btrfs_add_free_space(cache, SZ_128M - SZ_512K, SZ_512K);
708 test_err("error adding free space: %d", ret);
711 /* Confirm the region is marked as free. */
712 if (!test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
713 test_err("bitmap region not marked as free");
718 * Confirm that no new extent entries or bitmap entries were added to
719 * the cache after adding that free space region.
721 ret = check_num_extents_and_bitmaps(cache, 2, 1);
726 * Now lets add a small free space region to the left of the previous
727 * one, which is not contiguous with it and is part of the bitmap too.
728 * The goal is to test that the bitmap entry space stealing doesn't
729 * steal this space region.
731 ret = btrfs_add_free_space(cache, SZ_32M, 2 * sectorsize);
733 test_err("error adding free space: %d", ret);
738 * Now mark the region [128Mb, 128Mb + 128Kb[ as free too. This will
739 * expand the range covered by the existing extent entry that represents
740 * the free space [128Mb + 128Kb, 128Mb + 256Kb[.
742 ret = btrfs_add_free_space(cache, SZ_128M, SZ_128K);
744 test_err("error adding free space: %d", ret);
747 /* Confirm the region is marked as free. */
748 if (!test_check_exists(cache, SZ_128M, SZ_128K)) {
749 test_err("extent region not marked as free");
754 * Confirm that our extent entry didn't stole all free space from the
755 * bitmap, because of the small 2 * sectorsize free space region.
757 ret = check_num_extents_and_bitmaps(cache, 2, 1);
762 * So now we have the range [128Mb - 768Kb, 128Mb + 256Kb[ as free
763 * space. Without stealing bitmap free space into extent entry space,
764 * we would have all this free space represented by 2 entries in the
767 * extent entry covering range: [128Mb, 128Mb + 256Kb[
768 * bitmap entry covering range: [128Mb - 768Kb, 128Mb[
770 * Attempting to allocate the whole free space (1Mb) would fail, because
771 * we can't allocate from multiple entries.
772 * With the bitmap free space stealing, we get a single extent entry
773 * that represents the 1Mb free space, and therefore we're able to
774 * allocate the whole free space at once.
776 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_1M)) {
777 test_err("expected region not marked as free");
781 if (cache->free_space_ctl->free_space != (SZ_1M + 2 * sectorsize)) {
782 test_err("cache free space is not 1Mb + %u", 2 * sectorsize);
786 offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0,
788 if (offset != (SZ_128M - 768 * SZ_1K)) {
790 "failed to allocate 1Mb from space cache, returned offset is: %llu",
796 * All that remains is 2 * sectorsize free space region
797 * in a bitmap. Confirm.
799 ret = check_num_extents_and_bitmaps(cache, 1, 1);
803 if (cache->free_space_ctl->free_space != 2 * sectorsize) {
804 test_err("cache free space is not %u", 2 * sectorsize);
808 offset = btrfs_find_space_for_alloc(cache,
809 0, 2 * sectorsize, 0,
811 if (offset != SZ_32M) {
812 test_err("failed to allocate %u, offset: %llu",
813 2 * sectorsize, offset);
817 ret = check_cache_empty(cache);
821 cache->free_space_ctl->op = orig_free_space_ops;
822 btrfs_remove_free_space_cache(cache);
827 static bool bytes_index_use_bitmap(struct btrfs_free_space_ctl *ctl,
828 struct btrfs_free_space *info)
833 static int test_bytes_index(struct btrfs_block_group *cache, u32 sectorsize)
835 const struct btrfs_free_space_op test_free_space_ops = {
836 .use_bitmap = bytes_index_use_bitmap,
838 const struct btrfs_free_space_op *orig_free_space_ops;
839 struct btrfs_free_space_ctl *ctl = cache->free_space_ctl;
840 struct btrfs_free_space *entry;
841 struct rb_node *node;
842 u64 offset, max_extent_size, bytes;
845 test_msg("running bytes index tests");
847 /* First just validate that it does everything in order. */
849 for (i = 0; i < 10; i++) {
850 bytes = (i + 1) * SZ_1M;
851 ret = test_add_free_space_entry(cache, offset, bytes, 0);
853 test_err("couldn't add extent entry %d\n", ret);
856 offset += bytes + sectorsize;
859 for (node = rb_first_cached(&ctl->free_space_bytes), i = 9; node;
860 node = rb_next(node), i--) {
861 entry = rb_entry(node, struct btrfs_free_space, bytes_index);
862 bytes = (i + 1) * SZ_1M;
863 if (entry->bytes != bytes) {
864 test_err("invalid bytes index order, found %llu expected %llu",
865 entry->bytes, bytes);
870 /* Now validate bitmaps do the correct thing. */
871 btrfs_remove_free_space_cache(cache);
872 for (i = 0; i < 2; i++) {
873 offset = i * BITS_PER_BITMAP * sectorsize;
874 bytes = (i + 1) * SZ_1M;
875 ret = test_add_free_space_entry(cache, offset, bytes, 1);
877 test_err("couldn't add bitmap entry");
882 for (node = rb_first_cached(&ctl->free_space_bytes), i = 1; node;
883 node = rb_next(node), i--) {
884 entry = rb_entry(node, struct btrfs_free_space, bytes_index);
885 bytes = (i + 1) * SZ_1M;
886 if (entry->bytes != bytes) {
887 test_err("invalid bytes index order, found %llu expected %llu",
888 entry->bytes, bytes);
893 /* Now validate bitmaps with different ->max_extent_size. */
894 btrfs_remove_free_space_cache(cache);
895 orig_free_space_ops = cache->free_space_ctl->op;
896 cache->free_space_ctl->op = &test_free_space_ops;
898 ret = test_add_free_space_entry(cache, 0, sectorsize, 1);
900 test_err("couldn't add bitmap entry");
904 offset = BITS_PER_BITMAP * sectorsize;
905 ret = test_add_free_space_entry(cache, offset, sectorsize, 1);
907 test_err("couldn't add bitmap_entry");
912 * Now set a bunch of sectorsize extents in the first entry so it's
915 for (i = 2; i < 20; i += 2) {
916 offset = sectorsize * i;
917 ret = btrfs_add_free_space(cache, offset, sectorsize);
919 test_err("error populating sparse bitmap %d", ret);
925 * Now set a contiguous extent in the second bitmap so its
926 * ->max_extent_size is larger than the first bitmaps.
928 offset = (BITS_PER_BITMAP * sectorsize) + sectorsize;
929 ret = btrfs_add_free_space(cache, offset, sectorsize);
931 test_err("error adding contiguous extent %d", ret);
936 * Since we don't set ->max_extent_size unless we search everything
937 * should be indexed on bytes.
939 entry = rb_entry(rb_first_cached(&ctl->free_space_bytes),
940 struct btrfs_free_space, bytes_index);
941 if (entry->bytes != (10 * sectorsize)) {
942 test_err("error, wrong entry in the first slot in bytes_index");
947 offset = btrfs_find_space_for_alloc(cache, cache->start, sectorsize * 3,
948 0, &max_extent_size);
950 test_err("found space to alloc even though we don't have enough space");
954 if (max_extent_size != (2 * sectorsize)) {
955 test_err("got the wrong max_extent size %llu expected %llu",
956 max_extent_size, (unsigned long long)(2 * sectorsize));
961 * The search should have re-arranged the bytes index to use the
962 * ->max_extent_size, validate it's now what we expect it to be.
964 entry = rb_entry(rb_first_cached(&ctl->free_space_bytes),
965 struct btrfs_free_space, bytes_index);
966 if (entry->bytes != (2 * sectorsize)) {
967 test_err("error, the bytes index wasn't recalculated properly");
971 /* Add another sectorsize to re-arrange the tree back to ->bytes. */
972 offset = (BITS_PER_BITMAP * sectorsize) - sectorsize;
973 ret = btrfs_add_free_space(cache, offset, sectorsize);
975 test_err("error adding extent to the sparse entry %d", ret);
979 entry = rb_entry(rb_first_cached(&ctl->free_space_bytes),
980 struct btrfs_free_space, bytes_index);
981 if (entry->bytes != (11 * sectorsize)) {
982 test_err("error, wrong entry in the first slot in bytes_index");
987 * Now make sure we find our correct entry after searching that will
988 * result in a re-arranging of the tree.
991 offset = btrfs_find_space_for_alloc(cache, cache->start, sectorsize * 2,
992 0, &max_extent_size);
993 if (offset != (BITS_PER_BITMAP * sectorsize)) {
994 test_err("error, found %llu instead of %llu for our alloc",
996 (unsigned long long)(BITS_PER_BITMAP * sectorsize));
1000 cache->free_space_ctl->op = orig_free_space_ops;
1001 btrfs_remove_free_space_cache(cache);
1005 int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize)
1007 struct btrfs_fs_info *fs_info;
1008 struct btrfs_block_group *cache;
1009 struct btrfs_root *root = NULL;
1012 test_msg("running btrfs free space cache tests");
1013 fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);
1015 test_std_err(TEST_ALLOC_FS_INFO);
1020 * For ppc64 (with 64k page size), bytes per bitmap might be
1021 * larger than 1G. To make bitmap test available in ppc64,
1022 * alloc dummy block group whose size cross bitmaps.
1024 cache = btrfs_alloc_dummy_block_group(fs_info,
1025 BITS_PER_BITMAP * sectorsize + PAGE_SIZE);
1027 test_std_err(TEST_ALLOC_BLOCK_GROUP);
1028 btrfs_free_dummy_fs_info(fs_info);
1032 root = btrfs_alloc_dummy_root(fs_info);
1034 test_std_err(TEST_ALLOC_ROOT);
1035 ret = PTR_ERR(root);
1039 root->root_key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
1040 root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1041 root->root_key.offset = 0;
1042 btrfs_global_root_insert(root);
1044 ret = test_extents(cache);
1047 ret = test_bitmaps(cache, sectorsize);
1050 ret = test_bitmaps_and_extents(cache, sectorsize);
1054 ret = test_steal_space_from_bitmap_to_extent(cache, sectorsize);
1057 ret = test_bytes_index(cache, sectorsize);
1059 btrfs_free_dummy_block_group(cache);
1060 btrfs_free_dummy_root(root);
1061 btrfs_free_dummy_fs_info(fs_info);