Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2013 Fusion IO. All rights reserved.
4 */
5
6#include <linux/slab.h>
7#include "btrfs-tests.h"
8#include "../ctree.h"
9#include "../disk-io.h"
10#include "../free-space-cache.h"
11#include "../block-group.h"
12
13#define BITS_PER_BITMAP (PAGE_SIZE * 8UL)
14
15/*
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.
19 */
20static int test_extents(struct btrfs_block_group *cache)
21{
22 int ret = 0;
23
24 test_msg("running extent only tests");
25
26 /* First just make sure we can remove an entire entry */
27 ret = btrfs_add_free_space(cache, 0, SZ_4M);
28 if (ret) {
29 test_err("error adding initial extents %d", ret);
30 return ret;
31 }
32
33 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
34 if (ret) {
35 test_err("error removing extent %d", ret);
36 return ret;
37 }
38
39 if (test_check_exists(cache, 0, SZ_4M)) {
40 test_err("full remove left some lingering space");
41 return -1;
42 }
43
44 /* Ok edge and middle cases now */
45 ret = btrfs_add_free_space(cache, 0, SZ_4M);
46 if (ret) {
47 test_err("error adding half extent %d", ret);
48 return ret;
49 }
50
51 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_1M);
52 if (ret) {
53 test_err("error removing tail end %d", ret);
54 return ret;
55 }
56
57 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
58 if (ret) {
59 test_err("error removing front end %d", ret);
60 return ret;
61 }
62
63 ret = btrfs_remove_free_space(cache, SZ_2M, 4096);
64 if (ret) {
65 test_err("error removing middle piece %d", ret);
66 return ret;
67 }
68
69 if (test_check_exists(cache, 0, SZ_1M)) {
70 test_err("still have space at the front");
71 return -1;
72 }
73
74 if (test_check_exists(cache, SZ_2M, 4096)) {
75 test_err("still have space in the middle");
76 return -1;
77 }
78
79 if (test_check_exists(cache, 3 * SZ_1M, SZ_1M)) {
80 test_err("still have space at the end");
81 return -1;
82 }
83
84 /* Cleanup */
85 btrfs_remove_free_space_cache(cache);
86
87 return 0;
88}
89
90static int test_bitmaps(struct btrfs_block_group *cache, u32 sectorsize)
91{
92 u64 next_bitmap_offset;
93 int ret;
94
95 test_msg("running bitmap only tests");
96
97 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
98 if (ret) {
99 test_err("couldn't create a bitmap entry %d", ret);
100 return ret;
101 }
102
103 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
104 if (ret) {
105 test_err("error removing bitmap full range %d", ret);
106 return ret;
107 }
108
109 if (test_check_exists(cache, 0, SZ_4M)) {
110 test_err("left some space in bitmap");
111 return -1;
112 }
113
114 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
115 if (ret) {
116 test_err("couldn't add to our bitmap entry %d", ret);
117 return ret;
118 }
119
120 ret = btrfs_remove_free_space(cache, SZ_1M, SZ_2M);
121 if (ret) {
122 test_err("couldn't remove middle chunk %d", ret);
123 return ret;
124 }
125
126 /*
127 * The first bitmap we have starts at offset 0 so the next one is just
128 * at the end of the first bitmap.
129 */
130 next_bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
131
132 /* Test a bit straddling two bitmaps */
133 ret = test_add_free_space_entry(cache, next_bitmap_offset - SZ_2M,
134 SZ_4M, 1);
135 if (ret) {
136 test_err("couldn't add space that straddles two bitmaps %d",
137 ret);
138 return ret;
139 }
140
141 ret = btrfs_remove_free_space(cache, next_bitmap_offset - SZ_1M, SZ_2M);
142 if (ret) {
143 test_err("couldn't remove overlapping space %d", ret);
144 return ret;
145 }
146
147 if (test_check_exists(cache, next_bitmap_offset - SZ_1M, SZ_2M)) {
148 test_err("left some space when removing overlapping");
149 return -1;
150 }
151
152 btrfs_remove_free_space_cache(cache);
153
154 return 0;
155}
156
157/* This is the high grade jackassery */
158static int test_bitmaps_and_extents(struct btrfs_block_group *cache,
159 u32 sectorsize)
160{
161 u64 bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
162 int ret;
163
164 test_msg("running bitmap and extent tests");
165
166 /*
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.
170 */
171 ret = test_add_free_space_entry(cache, SZ_4M, SZ_1M, 1);
172 if (ret) {
173 test_err("couldn't create bitmap entry %d", ret);
174 return ret;
175 }
176
177 ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
178 if (ret) {
179 test_err("couldn't add extent entry %d", ret);
180 return ret;
181 }
182
183 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
184 if (ret) {
185 test_err("couldn't remove extent entry %d", ret);
186 return ret;
187 }
188
189 if (test_check_exists(cache, 0, SZ_1M)) {
190 test_err("left remnants after our remove");
191 return -1;
192 }
193
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);
196 if (ret) {
197 test_err("couldn't re-add extent entry %d", ret);
198 return ret;
199 }
200
201 ret = btrfs_remove_free_space(cache, SZ_4M, SZ_1M);
202 if (ret) {
203 test_err("couldn't remove from bitmap %d", ret);
204 return ret;
205 }
206
207 if (test_check_exists(cache, SZ_4M, SZ_1M)) {
208 test_err("left remnants in the bitmap");
209 return -1;
210 }
211
212 /*
213 * Ok so a little more evil, extent entry and bitmap at the same offset,
214 * removing an overlapping chunk.
215 */
216 ret = test_add_free_space_entry(cache, SZ_1M, SZ_4M, 1);
217 if (ret) {
218 test_err("couldn't add to a bitmap %d", ret);
219 return ret;
220 }
221
222 ret = btrfs_remove_free_space(cache, SZ_512K, 3 * SZ_1M);
223 if (ret) {
224 test_err("couldn't remove overlapping space %d", ret);
225 return ret;
226 }
227
228 if (test_check_exists(cache, SZ_512K, 3 * SZ_1M)) {
229 test_err("left over pieces after removing overlapping");
230 return -1;
231 }
232
233 btrfs_remove_free_space_cache(cache);
234
235 /* Now with the extent entry offset into the bitmap */
236 ret = test_add_free_space_entry(cache, SZ_4M, SZ_4M, 1);
237 if (ret) {
238 test_err("couldn't add space to the bitmap %d", ret);
239 return ret;
240 }
241
242 ret = test_add_free_space_entry(cache, SZ_2M, SZ_2M, 0);
243 if (ret) {
244 test_err("couldn't add extent to the cache %d", ret);
245 return ret;
246 }
247
248 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_4M);
249 if (ret) {
250 test_err("problem removing overlapping space %d", ret);
251 return ret;
252 }
253
254 if (test_check_exists(cache, 3 * SZ_1M, SZ_4M)) {
255 test_err("left something behind when removing space");
256 return -1;
257 }
258
259 /*
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
264 *
265 * [ extent ]
266 * [ bitmap ]
267 * [ del ]
268 */
269 btrfs_remove_free_space_cache(cache);
270 ret = test_add_free_space_entry(cache, bitmap_offset + SZ_4M, SZ_4M, 1);
271 if (ret) {
272 test_err("couldn't add bitmap %d", ret);
273 return ret;
274 }
275
276 ret = test_add_free_space_entry(cache, bitmap_offset - SZ_1M,
277 5 * SZ_1M, 0);
278 if (ret) {
279 test_err("couldn't add extent entry %d", ret);
280 return ret;
281 }
282
283 ret = btrfs_remove_free_space(cache, bitmap_offset + SZ_1M, 5 * SZ_1M);
284 if (ret) {
285 test_err("failed to free our space %d", ret);
286 return ret;
287 }
288
289 if (test_check_exists(cache, bitmap_offset + SZ_1M, 5 * SZ_1M)) {
290 test_err("left stuff over");
291 return -1;
292 }
293
294 btrfs_remove_free_space_cache(cache);
295
296 /*
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
300 * doesn't happen.
301 */
302 ret = test_add_free_space_entry(cache, SZ_1M, SZ_2M, 1);
303 if (ret) {
304 test_err("couldn't add bitmap entry %d", ret);
305 return ret;
306 }
307
308 ret = test_add_free_space_entry(cache, 3 * SZ_1M, SZ_1M, 0);
309 if (ret) {
310 test_err("couldn't add extent entry %d", ret);
311 return ret;
312 }
313
314 ret = btrfs_remove_free_space(cache, SZ_1M, 3 * SZ_1M);
315 if (ret) {
316 test_err("error removing bitmap and extent overlapping %d", ret);
317 return ret;
318 }
319
320 btrfs_remove_free_space_cache(cache);
321 return 0;
322}
323
324/* Used by test_steal_space_from_bitmap_to_extent(). */
325static bool test_use_bitmap(struct btrfs_free_space_ctl *ctl,
326 struct btrfs_free_space *info)
327{
328 return ctl->free_extents > 0;
329}
330
331/* Used by test_steal_space_from_bitmap_to_extent(). */
332static int
333check_num_extents_and_bitmaps(const struct btrfs_block_group *cache,
334 const int num_extents,
335 const int num_bitmaps)
336{
337 if (cache->free_space_ctl->free_extents != num_extents) {
338 test_err(
339 "incorrect # of extent entries in the cache: %d, expected %d",
340 cache->free_space_ctl->free_extents, num_extents);
341 return -EINVAL;
342 }
343 if (cache->free_space_ctl->total_bitmaps != num_bitmaps) {
344 test_err(
345 "incorrect # of extent entries in the cache: %d, expected %d",
346 cache->free_space_ctl->total_bitmaps, num_bitmaps);
347 return -EINVAL;
348 }
349 return 0;
350}
351
352/* Used by test_steal_space_from_bitmap_to_extent(). */
353static int check_cache_empty(struct btrfs_block_group *cache)
354{
355 u64 offset;
356 u64 max_extent_size;
357
358 /*
359 * Now lets confirm that there's absolutely no free space left to
360 * allocate.
361 */
362 if (cache->free_space_ctl->free_space != 0) {
363 test_err("cache free space is not 0");
364 return -EINVAL;
365 }
366
367 /* And any allocation request, no matter how small, should fail now. */
368 offset = btrfs_find_space_for_alloc(cache, 0, 4096, 0,
369 &max_extent_size);
370 if (offset != 0) {
371 test_err("space allocation did not fail, returned offset: %llu",
372 offset);
373 return -EINVAL;
374 }
375
376 /* And no extent nor bitmap entries in the cache anymore. */
377 return check_num_extents_and_bitmaps(cache, 0, 0);
378}
379
380/*
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).
389 *
390 * This stealing approach is beneficial, since we always prefer to allocate
391 * from extent entries, both for clustered and non-clustered allocation
392 * requests.
393 */
394static int
395test_steal_space_from_bitmap_to_extent(struct btrfs_block_group *cache,
396 u32 sectorsize)
397{
398 int ret;
399 u64 offset;
400 u64 max_extent_size;
401 const struct btrfs_free_space_op test_free_space_ops = {
402 .use_bitmap = test_use_bitmap,
403 };
404 const struct btrfs_free_space_op *orig_free_space_ops;
405
406 test_msg("running space stealing from bitmap to extent tests");
407
408 /*
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.
417 *
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
424 * extent entry.
425 */
426 orig_free_space_ops = cache->free_space_ctl->op;
427 cache->free_space_ctl->op = &test_free_space_ops;
428
429 /*
430 * Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[
431 */
432 ret = test_add_free_space_entry(cache, SZ_128M - SZ_256K, SZ_128K, 0);
433 if (ret) {
434 test_err("couldn't add extent entry %d", ret);
435 return ret;
436 }
437
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);
441 if (ret) {
442 test_err("couldn't add bitmap entry %d", ret);
443 return ret;
444 }
445
446 ret = check_num_extents_and_bitmaps(cache, 2, 1);
447 if (ret)
448 return ret;
449
450 /*
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:
453 *
454 * [128Mb - 256Kb, 128Mb - 128Kb[
455 * [128Mb + 512Kb, 128Mb + 768Kb[
456 */
457 ret = btrfs_remove_free_space(cache,
458 SZ_128M + 768 * SZ_1K,
459 SZ_128M - 768 * SZ_1K);
460 if (ret) {
461 test_err("failed to free part of bitmap space %d", ret);
462 return ret;
463 }
464
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");
468 return -ENOENT;
469 }
470 if (!test_check_exists(cache, SZ_128M + SZ_512K, SZ_256K)) {
471 test_err("free space range missing");
472 return -ENOENT;
473 }
474
475 /*
476 * Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked
477 * as free anymore.
478 */
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");
482 return -EINVAL;
483 }
484
485 /*
486 * Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is
487 * covered by the bitmap, isn't marked as free.
488 */
489 if (test_check_exists(cache, SZ_128M + SZ_256K, SZ_256K)) {
490 test_err("invalid bitmap region marked as free");
491 return -EINVAL;
492 }
493
494 /*
495 * Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered
496 * by the bitmap too, isn't marked as free either.
497 */
498 if (test_check_exists(cache, SZ_128M, SZ_256K)) {
499 test_err("invalid bitmap region marked as free");
500 return -EINVAL;
501 }
502
503 /*
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.
507 */
508 ret = btrfs_add_free_space(cache, SZ_128M, SZ_512K);
509 if (ret) {
510 test_err("error adding free space: %d", ret);
511 return ret;
512 }
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");
516 return -ENOENT;
517 }
518
519 /*
520 * Confirm that no new extent entries or bitmap entries were added to
521 * the cache after adding that free space region.
522 */
523 ret = check_num_extents_and_bitmaps(cache, 2, 1);
524 if (ret)
525 return ret;
526
527 /*
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.
532 */
533 ret = btrfs_add_free_space(cache, SZ_128M + SZ_16M, sectorsize);
534 if (ret) {
535 test_err("error adding free space: %d", ret);
536 return ret;
537 }
538
539 /*
540 * Confirm that no new extent entries or bitmap entries were added to
541 * the cache after adding that free space region.
542 */
543 ret = check_num_extents_and_bitmaps(cache, 2, 1);
544 if (ret)
545 return ret;
546
547 /*
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[.
551 */
552 ret = btrfs_add_free_space(cache, SZ_128M - SZ_128K, SZ_128K);
553 if (ret) {
554 test_err("error adding free space: %d", ret);
555 return ret;
556 }
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");
560 return -ENOENT;
561 }
562
563 /*
564 * Confirm that our extent entry didn't stole all free space from the
565 * bitmap, because of the small 4Kb free space region.
566 */
567 ret = check_num_extents_and_bitmaps(cache, 2, 1);
568 if (ret)
569 return ret;
570
571 /*
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
575 * cache:
576 *
577 * extent entry covering range: [128Mb - 256Kb, 128Mb[
578 * bitmap entry covering range: [128Mb, 128Mb + 768Kb[
579 *
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.
585 */
586 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_1M)) {
587 test_err("expected region not marked as free");
588 return -ENOENT;
589 }
590
591 if (cache->free_space_ctl->free_space != (SZ_1M + sectorsize)) {
592 test_err("cache free space is not 1Mb + %u", sectorsize);
593 return -EINVAL;
594 }
595
596 offset = btrfs_find_space_for_alloc(cache,
597 0, SZ_1M, 0,
598 &max_extent_size);
599 if (offset != (SZ_128M - SZ_256K)) {
600 test_err(
601 "failed to allocate 1Mb from space cache, returned offset is: %llu",
602 offset);
603 return -EINVAL;
604 }
605
606 /*
607 * All that remains is a sectorsize free space region in a bitmap.
608 * Confirm.
609 */
610 ret = check_num_extents_and_bitmaps(cache, 1, 1);
611 if (ret)
612 return ret;
613
614 if (cache->free_space_ctl->free_space != sectorsize) {
615 test_err("cache free space is not %u", sectorsize);
616 return -EINVAL;
617 }
618
619 offset = btrfs_find_space_for_alloc(cache,
620 0, sectorsize, 0,
621 &max_extent_size);
622 if (offset != (SZ_128M + SZ_16M)) {
623 test_err("failed to allocate %u, returned offset : %llu",
624 sectorsize, offset);
625 return -EINVAL;
626 }
627
628 ret = check_cache_empty(cache);
629 if (ret)
630 return ret;
631
632 btrfs_remove_free_space_cache(cache);
633
634 /*
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.
638 */
639
640 /*
641 * Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[
642 */
643 ret = test_add_free_space_entry(cache, SZ_128M + SZ_128K, SZ_128K, 0);
644 if (ret) {
645 test_err("couldn't add extent entry %d", ret);
646 return ret;
647 }
648
649 /* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */
650 ret = test_add_free_space_entry(cache, 0, SZ_128M - SZ_512K, 1);
651 if (ret) {
652 test_err("couldn't add bitmap entry %d", ret);
653 return ret;
654 }
655
656 ret = check_num_extents_and_bitmaps(cache, 2, 1);
657 if (ret)
658 return ret;
659
660 /*
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:
663 *
664 * [128Mb + 128b, 128Mb + 256Kb[
665 * [128Mb - 768Kb, 128Mb - 512Kb[
666 */
667 ret = btrfs_remove_free_space(cache, 0, SZ_128M - 768 * SZ_1K);
668 if (ret) {
669 test_err("failed to free part of bitmap space %d", ret);
670 return ret;
671 }
672
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");
676 return -ENOENT;
677 }
678 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_256K)) {
679 test_err("free space range missing");
680 return -ENOENT;
681 }
682
683 /*
684 * Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked
685 * as free anymore.
686 */
687 if (test_check_exists(cache, 0, SZ_128M - 768 * SZ_1K)) {
688 test_err("bitmap region not removed from space cache");
689 return -EINVAL;
690 }
691
692 /*
693 * Confirm that the region [128Mb - 512Kb, 128Mb[, which is
694 * covered by the bitmap, isn't marked as free.
695 */
696 if (test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
697 test_err("invalid bitmap region marked as free");
698 return -EINVAL;
699 }
700
701 /*
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.
705 */
706 ret = btrfs_add_free_space(cache, SZ_128M - SZ_512K, SZ_512K);
707 if (ret) {
708 test_err("error adding free space: %d", ret);
709 return ret;
710 }
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");
714 return -ENOENT;
715 }
716
717 /*
718 * Confirm that no new extent entries or bitmap entries were added to
719 * the cache after adding that free space region.
720 */
721 ret = check_num_extents_and_bitmaps(cache, 2, 1);
722 if (ret)
723 return ret;
724
725 /*
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.
730 */
731 ret = btrfs_add_free_space(cache, SZ_32M, 2 * sectorsize);
732 if (ret) {
733 test_err("error adding free space: %d", ret);
734 return ret;
735 }
736
737 /*
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[.
741 */
742 ret = btrfs_add_free_space(cache, SZ_128M, SZ_128K);
743 if (ret) {
744 test_err("error adding free space: %d", ret);
745 return ret;
746 }
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");
750 return -ENOENT;
751 }
752
753 /*
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.
756 */
757 ret = check_num_extents_and_bitmaps(cache, 2, 1);
758 if (ret)
759 return ret;
760
761 /*
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
765 * cache:
766 *
767 * extent entry covering range: [128Mb, 128Mb + 256Kb[
768 * bitmap entry covering range: [128Mb - 768Kb, 128Mb[
769 *
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.
775 */
776 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_1M)) {
777 test_err("expected region not marked as free");
778 return -ENOENT;
779 }
780
781 if (cache->free_space_ctl->free_space != (SZ_1M + 2 * sectorsize)) {
782 test_err("cache free space is not 1Mb + %u", 2 * sectorsize);
783 return -EINVAL;
784 }
785
786 offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0,
787 &max_extent_size);
788 if (offset != (SZ_128M - 768 * SZ_1K)) {
789 test_err(
790 "failed to allocate 1Mb from space cache, returned offset is: %llu",
791 offset);
792 return -EINVAL;
793 }
794
795 /*
796 * All that remains is 2 * sectorsize free space region
797 * in a bitmap. Confirm.
798 */
799 ret = check_num_extents_and_bitmaps(cache, 1, 1);
800 if (ret)
801 return ret;
802
803 if (cache->free_space_ctl->free_space != 2 * sectorsize) {
804 test_err("cache free space is not %u", 2 * sectorsize);
805 return -EINVAL;
806 }
807
808 offset = btrfs_find_space_for_alloc(cache,
809 0, 2 * sectorsize, 0,
810 &max_extent_size);
811 if (offset != SZ_32M) {
812 test_err("failed to allocate %u, offset: %llu",
813 2 * sectorsize, offset);
814 return -EINVAL;
815 }
816
817 ret = check_cache_empty(cache);
818 if (ret)
819 return ret;
820
821 cache->free_space_ctl->op = orig_free_space_ops;
822 btrfs_remove_free_space_cache(cache);
823
824 return 0;
825}
826
827static bool bytes_index_use_bitmap(struct btrfs_free_space_ctl *ctl,
828 struct btrfs_free_space *info)
829{
830 return true;
831}
832
833static int test_bytes_index(struct btrfs_block_group *cache, u32 sectorsize)
834{
835 const struct btrfs_free_space_op test_free_space_ops = {
836 .use_bitmap = bytes_index_use_bitmap,
837 };
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;
843 int ret, i;
844
845 test_msg("running bytes index tests");
846
847 /* First just validate that it does everything in order. */
848 offset = 0;
849 for (i = 0; i < 10; i++) {
850 bytes = (i + 1) * SZ_1M;
851 ret = test_add_free_space_entry(cache, offset, bytes, 0);
852 if (ret) {
853 test_err("couldn't add extent entry %d\n", ret);
854 return ret;
855 }
856 offset += bytes + sectorsize;
857 }
858
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);
866 return -EINVAL;
867 }
868 }
869
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);
876 if (ret) {
877 test_err("couldn't add bitmap entry");
878 return ret;
879 }
880 }
881
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);
889 return -EINVAL;
890 }
891 }
892
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;
897
898 ret = test_add_free_space_entry(cache, 0, sectorsize, 1);
899 if (ret) {
900 test_err("couldn't add bitmap entry");
901 return ret;
902 }
903
904 offset = BITS_PER_BITMAP * sectorsize;
905 ret = test_add_free_space_entry(cache, offset, sectorsize, 1);
906 if (ret) {
907 test_err("couldn't add bitmap_entry");
908 return ret;
909 }
910
911 /*
912 * Now set a bunch of sectorsize extents in the first entry so it's
913 * ->bytes is large.
914 */
915 for (i = 2; i < 20; i += 2) {
916 offset = sectorsize * i;
917 ret = btrfs_add_free_space(cache, offset, sectorsize);
918 if (ret) {
919 test_err("error populating sparse bitmap %d", ret);
920 return ret;
921 }
922 }
923
924 /*
925 * Now set a contiguous extent in the second bitmap so its
926 * ->max_extent_size is larger than the first bitmaps.
927 */
928 offset = (BITS_PER_BITMAP * sectorsize) + sectorsize;
929 ret = btrfs_add_free_space(cache, offset, sectorsize);
930 if (ret) {
931 test_err("error adding contiguous extent %d", ret);
932 return ret;
933 }
934
935 /*
936 * Since we don't set ->max_extent_size unless we search everything
937 * should be indexed on bytes.
938 */
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");
943 return -EINVAL;
944 }
945
946 max_extent_size = 0;
947 offset = btrfs_find_space_for_alloc(cache, cache->start, sectorsize * 3,
948 0, &max_extent_size);
949 if (offset != 0) {
950 test_err("found space to alloc even though we don't have enough space");
951 return -EINVAL;
952 }
953
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));
957 return -EINVAL;
958 }
959
960 /*
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.
963 */
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");
968 return -EINVAL;
969 }
970
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);
974 if (ret) {
975 test_err("error adding extent to the sparse entry %d", ret);
976 return ret;
977 }
978
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");
983 return -EINVAL;
984 }
985
986 /*
987 * Now make sure we find our correct entry after searching that will
988 * result in a re-arranging of the tree.
989 */
990 max_extent_size = 0;
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",
995 offset,
996 (unsigned long long)(BITS_PER_BITMAP * sectorsize));
997 return -EINVAL;
998 }
999
1000 cache->free_space_ctl->op = orig_free_space_ops;
1001 btrfs_remove_free_space_cache(cache);
1002 return 0;
1003}
1004
1005int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize)
1006{
1007 struct btrfs_fs_info *fs_info;
1008 struct btrfs_block_group *cache;
1009 struct btrfs_root *root = NULL;
1010 int ret = -ENOMEM;
1011
1012 test_msg("running btrfs free space cache tests");
1013 fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);
1014 if (!fs_info) {
1015 test_std_err(TEST_ALLOC_FS_INFO);
1016 return -ENOMEM;
1017 }
1018
1019 /*
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.
1023 */
1024 cache = btrfs_alloc_dummy_block_group(fs_info,
1025 BITS_PER_BITMAP * sectorsize + PAGE_SIZE);
1026 if (!cache) {
1027 test_std_err(TEST_ALLOC_BLOCK_GROUP);
1028 btrfs_free_dummy_fs_info(fs_info);
1029 return 0;
1030 }
1031
1032 root = btrfs_alloc_dummy_root(fs_info);
1033 if (IS_ERR(root)) {
1034 test_std_err(TEST_ALLOC_ROOT);
1035 ret = PTR_ERR(root);
1036 goto out;
1037 }
1038
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);
1043
1044 ret = test_extents(cache);
1045 if (ret)
1046 goto out;
1047 ret = test_bitmaps(cache, sectorsize);
1048 if (ret)
1049 goto out;
1050 ret = test_bitmaps_and_extents(cache, sectorsize);
1051 if (ret)
1052 goto out;
1053
1054 ret = test_steal_space_from_bitmap_to_extent(cache, sectorsize);
1055 if (ret)
1056 goto out;
1057 ret = test_bytes_index(cache, sectorsize);
1058out:
1059 btrfs_free_dummy_block_group(cache);
1060 btrfs_free_dummy_root(root);
1061 btrfs_free_dummy_fs_info(fs_info);
1062 return ret;
1063}
1/*
2 * Copyright (C) 2013 Fusion IO. All rights reserved.
3 *
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.
7 *
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.
12 *
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.
17 */
18
19#include <linux/slab.h>
20#include "btrfs-tests.h"
21#include "../ctree.h"
22#include "../disk-io.h"
23#include "../free-space-cache.h"
24
25#define BITS_PER_BITMAP (PAGE_SIZE * 8UL)
26
27/*
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.
31 */
32static int test_extents(struct btrfs_block_group_cache *cache)
33{
34 int ret = 0;
35
36 test_msg("Running extent only tests\n");
37
38 /* First just make sure we can remove an entire entry */
39 ret = btrfs_add_free_space(cache, 0, SZ_4M);
40 if (ret) {
41 test_msg("Error adding initial extents %d\n", ret);
42 return ret;
43 }
44
45 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
46 if (ret) {
47 test_msg("Error removing extent %d\n", ret);
48 return ret;
49 }
50
51 if (test_check_exists(cache, 0, SZ_4M)) {
52 test_msg("Full remove left some lingering space\n");
53 return -1;
54 }
55
56 /* Ok edge and middle cases now */
57 ret = btrfs_add_free_space(cache, 0, SZ_4M);
58 if (ret) {
59 test_msg("Error adding half extent %d\n", ret);
60 return ret;
61 }
62
63 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_1M);
64 if (ret) {
65 test_msg("Error removing tail end %d\n", ret);
66 return ret;
67 }
68
69 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
70 if (ret) {
71 test_msg("Error removing front end %d\n", ret);
72 return ret;
73 }
74
75 ret = btrfs_remove_free_space(cache, SZ_2M, 4096);
76 if (ret) {
77 test_msg("Error removing middle piece %d\n", ret);
78 return ret;
79 }
80
81 if (test_check_exists(cache, 0, SZ_1M)) {
82 test_msg("Still have space at the front\n");
83 return -1;
84 }
85
86 if (test_check_exists(cache, SZ_2M, 4096)) {
87 test_msg("Still have space in the middle\n");
88 return -1;
89 }
90
91 if (test_check_exists(cache, 3 * SZ_1M, SZ_1M)) {
92 test_msg("Still have space at the end\n");
93 return -1;
94 }
95
96 /* Cleanup */
97 __btrfs_remove_free_space_cache(cache->free_space_ctl);
98
99 return 0;
100}
101
102static int test_bitmaps(struct btrfs_block_group_cache *cache,
103 u32 sectorsize)
104{
105 u64 next_bitmap_offset;
106 int ret;
107
108 test_msg("Running bitmap only tests\n");
109
110 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
111 if (ret) {
112 test_msg("Couldn't create a bitmap entry %d\n", ret);
113 return ret;
114 }
115
116 ret = btrfs_remove_free_space(cache, 0, SZ_4M);
117 if (ret) {
118 test_msg("Error removing bitmap full range %d\n", ret);
119 return ret;
120 }
121
122 if (test_check_exists(cache, 0, SZ_4M)) {
123 test_msg("Left some space in bitmap\n");
124 return -1;
125 }
126
127 ret = test_add_free_space_entry(cache, 0, SZ_4M, 1);
128 if (ret) {
129 test_msg("Couldn't add to our bitmap entry %d\n", ret);
130 return ret;
131 }
132
133 ret = btrfs_remove_free_space(cache, SZ_1M, SZ_2M);
134 if (ret) {
135 test_msg("Couldn't remove middle chunk %d\n", ret);
136 return ret;
137 }
138
139 /*
140 * The first bitmap we have starts at offset 0 so the next one is just
141 * at the end of the first bitmap.
142 */
143 next_bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
144
145 /* Test a bit straddling two bitmaps */
146 ret = test_add_free_space_entry(cache, next_bitmap_offset - SZ_2M,
147 SZ_4M, 1);
148 if (ret) {
149 test_msg("Couldn't add space that straddles two bitmaps %d\n",
150 ret);
151 return ret;
152 }
153
154 ret = btrfs_remove_free_space(cache, next_bitmap_offset - SZ_1M, SZ_2M);
155 if (ret) {
156 test_msg("Couldn't remove overlapping space %d\n", ret);
157 return ret;
158 }
159
160 if (test_check_exists(cache, next_bitmap_offset - SZ_1M, SZ_2M)) {
161 test_msg("Left some space when removing overlapping\n");
162 return -1;
163 }
164
165 __btrfs_remove_free_space_cache(cache->free_space_ctl);
166
167 return 0;
168}
169
170/* This is the high grade jackassery */
171static int test_bitmaps_and_extents(struct btrfs_block_group_cache *cache,
172 u32 sectorsize)
173{
174 u64 bitmap_offset = (u64)(BITS_PER_BITMAP * sectorsize);
175 int ret;
176
177 test_msg("Running bitmap and extent tests\n");
178
179 /*
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.
183 */
184 ret = test_add_free_space_entry(cache, SZ_4M, SZ_1M, 1);
185 if (ret) {
186 test_msg("Couldn't create bitmap entry %d\n", ret);
187 return ret;
188 }
189
190 ret = test_add_free_space_entry(cache, 0, SZ_1M, 0);
191 if (ret) {
192 test_msg("Couldn't add extent entry %d\n", ret);
193 return ret;
194 }
195
196 ret = btrfs_remove_free_space(cache, 0, SZ_1M);
197 if (ret) {
198 test_msg("Couldn't remove extent entry %d\n", ret);
199 return ret;
200 }
201
202 if (test_check_exists(cache, 0, SZ_1M)) {
203 test_msg("Left remnants after our remove\n");
204 return -1;
205 }
206
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);
209 if (ret) {
210 test_msg("Couldn't re-add extent entry %d\n", ret);
211 return ret;
212 }
213
214 ret = btrfs_remove_free_space(cache, SZ_4M, SZ_1M);
215 if (ret) {
216 test_msg("Couldn't remove from bitmap %d\n", ret);
217 return ret;
218 }
219
220 if (test_check_exists(cache, SZ_4M, SZ_1M)) {
221 test_msg("Left remnants in the bitmap\n");
222 return -1;
223 }
224
225 /*
226 * Ok so a little more evil, extent entry and bitmap at the same offset,
227 * removing an overlapping chunk.
228 */
229 ret = test_add_free_space_entry(cache, SZ_1M, SZ_4M, 1);
230 if (ret) {
231 test_msg("Couldn't add to a bitmap %d\n", ret);
232 return ret;
233 }
234
235 ret = btrfs_remove_free_space(cache, SZ_512K, 3 * SZ_1M);
236 if (ret) {
237 test_msg("Couldn't remove overlapping space %d\n", ret);
238 return ret;
239 }
240
241 if (test_check_exists(cache, SZ_512K, 3 * SZ_1M)) {
242 test_msg("Left over pieces after removing overlapping\n");
243 return -1;
244 }
245
246 __btrfs_remove_free_space_cache(cache->free_space_ctl);
247
248 /* Now with the extent entry offset into the bitmap */
249 ret = test_add_free_space_entry(cache, SZ_4M, SZ_4M, 1);
250 if (ret) {
251 test_msg("Couldn't add space to the bitmap %d\n", ret);
252 return ret;
253 }
254
255 ret = test_add_free_space_entry(cache, SZ_2M, SZ_2M, 0);
256 if (ret) {
257 test_msg("Couldn't add extent to the cache %d\n", ret);
258 return ret;
259 }
260
261 ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_4M);
262 if (ret) {
263 test_msg("Problem removing overlapping space %d\n", ret);
264 return ret;
265 }
266
267 if (test_check_exists(cache, 3 * SZ_1M, SZ_4M)) {
268 test_msg("Left something behind when removing space");
269 return -1;
270 }
271
272 /*
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
277 *
278 * [ extent ]
279 * [ bitmap ]
280 * [ del ]
281 */
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);
284 if (ret) {
285 test_msg("Couldn't add bitmap %d\n", ret);
286 return ret;
287 }
288
289 ret = test_add_free_space_entry(cache, bitmap_offset - SZ_1M,
290 5 * SZ_1M, 0);
291 if (ret) {
292 test_msg("Couldn't add extent entry %d\n", ret);
293 return ret;
294 }
295
296 ret = btrfs_remove_free_space(cache, bitmap_offset + SZ_1M, 5 * SZ_1M);
297 if (ret) {
298 test_msg("Failed to free our space %d\n", ret);
299 return ret;
300 }
301
302 if (test_check_exists(cache, bitmap_offset + SZ_1M, 5 * SZ_1M)) {
303 test_msg("Left stuff over\n");
304 return -1;
305 }
306
307 __btrfs_remove_free_space_cache(cache->free_space_ctl);
308
309 /*
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
313 * doesn't happen.
314 */
315 ret = test_add_free_space_entry(cache, SZ_1M, SZ_2M, 1);
316 if (ret) {
317 test_msg("Couldn't add bitmap entry %d\n", ret);
318 return ret;
319 }
320
321 ret = test_add_free_space_entry(cache, 3 * SZ_1M, SZ_1M, 0);
322 if (ret) {
323 test_msg("Couldn't add extent entry %d\n", ret);
324 return ret;
325 }
326
327 ret = btrfs_remove_free_space(cache, SZ_1M, 3 * SZ_1M);
328 if (ret) {
329 test_msg("Error removing bitmap and extent overlapping %d\n", ret);
330 return ret;
331 }
332
333 __btrfs_remove_free_space_cache(cache->free_space_ctl);
334 return 0;
335}
336
337/* Used by test_steal_space_from_bitmap_to_extent(). */
338static bool test_use_bitmap(struct btrfs_free_space_ctl *ctl,
339 struct btrfs_free_space *info)
340{
341 return ctl->free_extents > 0;
342}
343
344/* Used by test_steal_space_from_bitmap_to_extent(). */
345static int
346check_num_extents_and_bitmaps(const struct btrfs_block_group_cache *cache,
347 const int num_extents,
348 const int num_bitmaps)
349{
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);
353 return -EINVAL;
354 }
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);
358 return -EINVAL;
359 }
360 return 0;
361}
362
363/* Used by test_steal_space_from_bitmap_to_extent(). */
364static int check_cache_empty(struct btrfs_block_group_cache *cache)
365{
366 u64 offset;
367 u64 max_extent_size;
368
369 /*
370 * Now lets confirm that there's absolutely no free space left to
371 * allocate.
372 */
373 if (cache->free_space_ctl->free_space != 0) {
374 test_msg("Cache free space is not 0\n");
375 return -EINVAL;
376 }
377
378 /* And any allocation request, no matter how small, should fail now. */
379 offset = btrfs_find_space_for_alloc(cache, 0, 4096, 0,
380 &max_extent_size);
381 if (offset != 0) {
382 test_msg("Space allocation did not fail, returned offset: %llu",
383 offset);
384 return -EINVAL;
385 }
386
387 /* And no extent nor bitmap entries in the cache anymore. */
388 return check_num_extents_and_bitmaps(cache, 0, 0);
389}
390
391/*
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).
400 *
401 * This stealing approach is beneficial, since we always prefer to allocate
402 * from extent entries, both for clustered and non-clustered allocation
403 * requests.
404 */
405static int
406test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache,
407 u32 sectorsize)
408{
409 int ret;
410 u64 offset;
411 u64 max_extent_size;
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,
415 };
416 const struct btrfs_free_space_op *orig_free_space_ops;
417
418 test_msg("Running space stealing from bitmap to extent\n");
419
420 /*
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.
429 *
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
436 * extent entry.
437 */
438 orig_free_space_ops = cache->free_space_ctl->op;
439 cache->free_space_ctl->op = &test_free_space_ops;
440
441 /*
442 * Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[
443 */
444 ret = test_add_free_space_entry(cache, SZ_128M - SZ_256K, SZ_128K, 0);
445 if (ret) {
446 test_msg("Couldn't add extent entry %d\n", ret);
447 return ret;
448 }
449
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);
453 if (ret) {
454 test_msg("Couldn't add bitmap entry %d\n", ret);
455 return ret;
456 }
457
458 ret = check_num_extents_and_bitmaps(cache, 2, 1);
459 if (ret)
460 return ret;
461
462 /*
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:
465 *
466 * [128Mb - 256Kb, 128Mb - 128Kb[
467 * [128Mb + 512Kb, 128Mb + 768Kb[
468 */
469 ret = btrfs_remove_free_space(cache,
470 SZ_128M + 768 * SZ_1K,
471 SZ_128M - 768 * SZ_1K);
472 if (ret) {
473 test_msg("Failed to free part of bitmap space %d\n", ret);
474 return ret;
475 }
476
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");
480 return -ENOENT;
481 }
482 if (!test_check_exists(cache, SZ_128M + SZ_512K, SZ_256K)) {
483 test_msg("Free space range missing\n");
484 return -ENOENT;
485 }
486
487 /*
488 * Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked
489 * as free anymore.
490 */
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");
494 return -EINVAL;
495 }
496
497 /*
498 * Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is
499 * covered by the bitmap, isn't marked as free.
500 */
501 if (test_check_exists(cache, SZ_128M + SZ_256K, SZ_256K)) {
502 test_msg("Invalid bitmap region marked as free\n");
503 return -EINVAL;
504 }
505
506 /*
507 * Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered
508 * by the bitmap too, isn't marked as free either.
509 */
510 if (test_check_exists(cache, SZ_128M, SZ_256K)) {
511 test_msg("Invalid bitmap region marked as free\n");
512 return -EINVAL;
513 }
514
515 /*
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.
519 */
520 ret = btrfs_add_free_space(cache, SZ_128M, SZ_512K);
521 if (ret) {
522 test_msg("Error adding free space: %d\n", ret);
523 return ret;
524 }
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");
528 return -ENOENT;
529 }
530
531 /*
532 * Confirm that no new extent entries or bitmap entries were added to
533 * the cache after adding that free space region.
534 */
535 ret = check_num_extents_and_bitmaps(cache, 2, 1);
536 if (ret)
537 return ret;
538
539 /*
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.
544 */
545 ret = btrfs_add_free_space(cache, SZ_128M + SZ_16M, sectorsize);
546 if (ret) {
547 test_msg("Error adding free space: %d\n", ret);
548 return ret;
549 }
550
551 /*
552 * Confirm that no new extent entries or bitmap entries were added to
553 * the cache after adding that free space region.
554 */
555 ret = check_num_extents_and_bitmaps(cache, 2, 1);
556 if (ret)
557 return ret;
558
559 /*
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[.
563 */
564 ret = btrfs_add_free_space(cache, SZ_128M - SZ_128K, SZ_128K);
565 if (ret) {
566 test_msg("Error adding free space: %d\n", ret);
567 return ret;
568 }
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");
572 return -ENOENT;
573 }
574
575 /*
576 * Confirm that our extent entry didn't stole all free space from the
577 * bitmap, because of the small 4Kb free space region.
578 */
579 ret = check_num_extents_and_bitmaps(cache, 2, 1);
580 if (ret)
581 return ret;
582
583 /*
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
587 * cache:
588 *
589 * extent entry covering range: [128Mb - 256Kb, 128Mb[
590 * bitmap entry covering range: [128Mb, 128Mb + 768Kb[
591 *
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.
597 */
598 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_1M)) {
599 test_msg("Expected region not marked as free\n");
600 return -ENOENT;
601 }
602
603 if (cache->free_space_ctl->free_space != (SZ_1M + sectorsize)) {
604 test_msg("Cache free space is not 1Mb + %u\n", sectorsize);
605 return -EINVAL;
606 }
607
608 offset = btrfs_find_space_for_alloc(cache,
609 0, SZ_1M, 0,
610 &max_extent_size);
611 if (offset != (SZ_128M - SZ_256K)) {
612 test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n",
613 offset);
614 return -EINVAL;
615 }
616
617 /*
618 * All that remains is a sectorsize free space region in a bitmap.
619 * Confirm.
620 */
621 ret = check_num_extents_and_bitmaps(cache, 1, 1);
622 if (ret)
623 return ret;
624
625 if (cache->free_space_ctl->free_space != sectorsize) {
626 test_msg("Cache free space is not %u\n", sectorsize);
627 return -EINVAL;
628 }
629
630 offset = btrfs_find_space_for_alloc(cache,
631 0, sectorsize, 0,
632 &max_extent_size);
633 if (offset != (SZ_128M + SZ_16M)) {
634 test_msg("Failed to allocate %u, returned offset : %llu\n",
635 sectorsize, offset);
636 return -EINVAL;
637 }
638
639 ret = check_cache_empty(cache);
640 if (ret)
641 return ret;
642
643 __btrfs_remove_free_space_cache(cache->free_space_ctl);
644
645 /*
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.
649 */
650
651 /*
652 * Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[
653 */
654 ret = test_add_free_space_entry(cache, SZ_128M + SZ_128K, SZ_128K, 0);
655 if (ret) {
656 test_msg("Couldn't add extent entry %d\n", ret);
657 return ret;
658 }
659
660 /* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */
661 ret = test_add_free_space_entry(cache, 0, SZ_128M - SZ_512K, 1);
662 if (ret) {
663 test_msg("Couldn't add bitmap entry %d\n", ret);
664 return ret;
665 }
666
667 ret = check_num_extents_and_bitmaps(cache, 2, 1);
668 if (ret)
669 return ret;
670
671 /*
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:
674 *
675 * [128Mb + 128b, 128Mb + 256Kb[
676 * [128Mb - 768Kb, 128Mb - 512Kb[
677 */
678 ret = btrfs_remove_free_space(cache, 0, SZ_128M - 768 * SZ_1K);
679 if (ret) {
680 test_msg("Failed to free part of bitmap space %d\n", ret);
681 return ret;
682 }
683
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");
687 return -ENOENT;
688 }
689 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_256K)) {
690 test_msg("Free space range missing\n");
691 return -ENOENT;
692 }
693
694 /*
695 * Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked
696 * as free anymore.
697 */
698 if (test_check_exists(cache, 0, SZ_128M - 768 * SZ_1K)) {
699 test_msg("Bitmap region not removed from space cache\n");
700 return -EINVAL;
701 }
702
703 /*
704 * Confirm that the region [128Mb - 512Kb, 128Mb[, which is
705 * covered by the bitmap, isn't marked as free.
706 */
707 if (test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) {
708 test_msg("Invalid bitmap region marked as free\n");
709 return -EINVAL;
710 }
711
712 /*
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.
716 */
717 ret = btrfs_add_free_space(cache, SZ_128M - SZ_512K, SZ_512K);
718 if (ret) {
719 test_msg("Error adding free space: %d\n", ret);
720 return ret;
721 }
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");
725 return -ENOENT;
726 }
727
728 /*
729 * Confirm that no new extent entries or bitmap entries were added to
730 * the cache after adding that free space region.
731 */
732 ret = check_num_extents_and_bitmaps(cache, 2, 1);
733 if (ret)
734 return ret;
735
736 /*
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.
741 */
742 ret = btrfs_add_free_space(cache, SZ_32M, 2 * sectorsize);
743 if (ret) {
744 test_msg("Error adding free space: %d\n", ret);
745 return ret;
746 }
747
748 /*
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[.
752 */
753 ret = btrfs_add_free_space(cache, SZ_128M, SZ_128K);
754 if (ret) {
755 test_msg("Error adding free space: %d\n", ret);
756 return ret;
757 }
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");
761 return -ENOENT;
762 }
763
764 /*
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.
767 */
768 ret = check_num_extents_and_bitmaps(cache, 2, 1);
769 if (ret)
770 return ret;
771
772 /*
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
776 * cache:
777 *
778 * extent entry covering range: [128Mb, 128Mb + 256Kb[
779 * bitmap entry covering range: [128Mb - 768Kb, 128Mb[
780 *
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.
786 */
787 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_1M)) {
788 test_msg("Expected region not marked as free\n");
789 return -ENOENT;
790 }
791
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);
794 return -EINVAL;
795 }
796
797 offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0,
798 &max_extent_size);
799 if (offset != (SZ_128M - 768 * SZ_1K)) {
800 test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n",
801 offset);
802 return -EINVAL;
803 }
804
805 /*
806 * All that remains is 2 * sectorsize free space region
807 * in a bitmap. Confirm.
808 */
809 ret = check_num_extents_and_bitmaps(cache, 1, 1);
810 if (ret)
811 return ret;
812
813 if (cache->free_space_ctl->free_space != 2 * sectorsize) {
814 test_msg("Cache free space is not %u\n", 2 * sectorsize);
815 return -EINVAL;
816 }
817
818 offset = btrfs_find_space_for_alloc(cache,
819 0, 2 * sectorsize, 0,
820 &max_extent_size);
821 if (offset != SZ_32M) {
822 test_msg("Failed to allocate %u, offset: %llu\n",
823 2 * sectorsize,
824 offset);
825 return -EINVAL;
826 }
827
828 ret = check_cache_empty(cache);
829 if (ret)
830 return ret;
831
832 cache->free_space_ctl->op = orig_free_space_ops;
833 __btrfs_remove_free_space_cache(cache->free_space_ctl);
834
835 return 0;
836}
837
838int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize)
839{
840 struct btrfs_fs_info *fs_info;
841 struct btrfs_block_group_cache *cache;
842 struct btrfs_root *root = NULL;
843 int ret = -ENOMEM;
844
845 test_msg("Running btrfs free space cache tests\n");
846 fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize);
847 if (!fs_info)
848 return -ENOMEM;
849
850
851 /*
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.
855 */
856 cache = btrfs_alloc_dummy_block_group(fs_info,
857 BITS_PER_BITMAP * sectorsize + PAGE_SIZE);
858 if (!cache) {
859 test_msg("Couldn't run the tests\n");
860 btrfs_free_dummy_fs_info(fs_info);
861 return 0;
862 }
863
864 root = btrfs_alloc_dummy_root(fs_info);
865 if (IS_ERR(root)) {
866 ret = PTR_ERR(root);
867 goto out;
868 }
869
870 root->fs_info->extent_root = root;
871
872 ret = test_extents(cache);
873 if (ret)
874 goto out;
875 ret = test_bitmaps(cache, sectorsize);
876 if (ret)
877 goto out;
878 ret = test_bitmaps_and_extents(cache, sectorsize);
879 if (ret)
880 goto out;
881
882 ret = test_steal_space_from_bitmap_to_extent(cache, sectorsize);
883out:
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");
888 return ret;
889}