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 */ 20 static 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->free_space_ctl); 86 87 return 0; 88 } 89 90 static 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->free_space_ctl); 153 154 return 0; 155 } 156 157 /* This is the high grade jackassery */ 158 static 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->free_space_ctl); 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->free_space_ctl); 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->free_space_ctl); 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->free_space_ctl); 321 return 0; 322 } 323 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) 327 { 328 return ctl->free_extents > 0; 329 } 330 331 /* Used by test_steal_space_from_bitmap_to_extent(). */ 332 static int 333 check_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(). */ 353 static 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 */ 394 static int 395 test_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 .recalc_thresholds = cache->free_space_ctl->op->recalc_thresholds, 403 .use_bitmap = test_use_bitmap, 404 }; 405 const struct btrfs_free_space_op *orig_free_space_ops; 406 407 test_msg("running space stealing from bitmap to extent tests"); 408 409 /* 410 * For this test, we want to ensure we end up with an extent entry 411 * immediately adjacent to a bitmap entry, where the bitmap starts 412 * at an offset where the extent entry ends. We keep adding and 413 * removing free space to reach into this state, but to get there 414 * we need to reach a point where marking new free space doesn't 415 * result in adding new extent entries or merging the new space 416 * with existing extent entries - the space ends up being marked 417 * in an existing bitmap that covers the new free space range. 418 * 419 * To get there, we need to reach the threshold defined set at 420 * cache->free_space_ctl->extents_thresh, which currently is 421 * 256 extents on a x86_64 system at least, and a few other 422 * conditions (check free_space_cache.c). Instead of making the 423 * test much longer and complicated, use a "use_bitmap" operation 424 * that forces use of bitmaps as soon as we have at least 1 425 * extent entry. 426 */ 427 orig_free_space_ops = cache->free_space_ctl->op; 428 cache->free_space_ctl->op = &test_free_space_ops; 429 430 /* 431 * Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[ 432 */ 433 ret = test_add_free_space_entry(cache, SZ_128M - SZ_256K, SZ_128K, 0); 434 if (ret) { 435 test_err("couldn't add extent entry %d", ret); 436 return ret; 437 } 438 439 /* Bitmap entry covering free space range [128Mb + 512Kb, 256Mb[ */ 440 ret = test_add_free_space_entry(cache, SZ_128M + SZ_512K, 441 SZ_128M - SZ_512K, 1); 442 if (ret) { 443 test_err("couldn't add bitmap entry %d", ret); 444 return ret; 445 } 446 447 ret = check_num_extents_and_bitmaps(cache, 2, 1); 448 if (ret) 449 return ret; 450 451 /* 452 * Now make only the first 256Kb of the bitmap marked as free, so that 453 * we end up with only the following ranges marked as free space: 454 * 455 * [128Mb - 256Kb, 128Mb - 128Kb[ 456 * [128Mb + 512Kb, 128Mb + 768Kb[ 457 */ 458 ret = btrfs_remove_free_space(cache, 459 SZ_128M + 768 * SZ_1K, 460 SZ_128M - 768 * SZ_1K); 461 if (ret) { 462 test_err("failed to free part of bitmap space %d", ret); 463 return ret; 464 } 465 466 /* Confirm that only those 2 ranges are marked as free. */ 467 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_128K)) { 468 test_err("free space range missing"); 469 return -ENOENT; 470 } 471 if (!test_check_exists(cache, SZ_128M + SZ_512K, SZ_256K)) { 472 test_err("free space range missing"); 473 return -ENOENT; 474 } 475 476 /* 477 * Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked 478 * as free anymore. 479 */ 480 if (test_check_exists(cache, SZ_128M + 768 * SZ_1K, 481 SZ_128M - 768 * SZ_1K)) { 482 test_err("bitmap region not removed from space cache"); 483 return -EINVAL; 484 } 485 486 /* 487 * Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is 488 * covered by the bitmap, isn't marked as free. 489 */ 490 if (test_check_exists(cache, SZ_128M + SZ_256K, SZ_256K)) { 491 test_err("invalid bitmap region marked as free"); 492 return -EINVAL; 493 } 494 495 /* 496 * Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered 497 * by the bitmap too, isn't marked as free either. 498 */ 499 if (test_check_exists(cache, SZ_128M, SZ_256K)) { 500 test_err("invalid bitmap region marked as free"); 501 return -EINVAL; 502 } 503 504 /* 505 * Now lets mark the region [128Mb, 128Mb + 512Kb[ as free too. But, 506 * lets make sure the free space cache marks it as free in the bitmap, 507 * and doesn't insert a new extent entry to represent this region. 508 */ 509 ret = btrfs_add_free_space(cache, SZ_128M, SZ_512K); 510 if (ret) { 511 test_err("error adding free space: %d", ret); 512 return ret; 513 } 514 /* Confirm the region is marked as free. */ 515 if (!test_check_exists(cache, SZ_128M, SZ_512K)) { 516 test_err("bitmap region not marked as free"); 517 return -ENOENT; 518 } 519 520 /* 521 * Confirm that no new extent entries or bitmap entries were added to 522 * the cache after adding that free space region. 523 */ 524 ret = check_num_extents_and_bitmaps(cache, 2, 1); 525 if (ret) 526 return ret; 527 528 /* 529 * Now lets add a small free space region to the right of the previous 530 * one, which is not contiguous with it and is part of the bitmap too. 531 * The goal is to test that the bitmap entry space stealing doesn't 532 * steal this space region. 533 */ 534 ret = btrfs_add_free_space(cache, SZ_128M + SZ_16M, sectorsize); 535 if (ret) { 536 test_err("error adding free space: %d", ret); 537 return ret; 538 } 539 540 /* 541 * Confirm that no new extent entries or bitmap entries were added to 542 * the cache after adding that free space region. 543 */ 544 ret = check_num_extents_and_bitmaps(cache, 2, 1); 545 if (ret) 546 return ret; 547 548 /* 549 * Now mark the region [128Mb - 128Kb, 128Mb[ as free too. This will 550 * expand the range covered by the existing extent entry that represents 551 * the free space [128Mb - 256Kb, 128Mb - 128Kb[. 552 */ 553 ret = btrfs_add_free_space(cache, SZ_128M - SZ_128K, SZ_128K); 554 if (ret) { 555 test_err("error adding free space: %d", ret); 556 return ret; 557 } 558 /* Confirm the region is marked as free. */ 559 if (!test_check_exists(cache, SZ_128M - SZ_128K, SZ_128K)) { 560 test_err("extent region not marked as free"); 561 return -ENOENT; 562 } 563 564 /* 565 * Confirm that our extent entry didn't stole all free space from the 566 * bitmap, because of the small 4Kb free space region. 567 */ 568 ret = check_num_extents_and_bitmaps(cache, 2, 1); 569 if (ret) 570 return ret; 571 572 /* 573 * So now we have the range [128Mb - 256Kb, 128Mb + 768Kb[ as free 574 * space. Without stealing bitmap free space into extent entry space, 575 * we would have all this free space represented by 2 entries in the 576 * cache: 577 * 578 * extent entry covering range: [128Mb - 256Kb, 128Mb[ 579 * bitmap entry covering range: [128Mb, 128Mb + 768Kb[ 580 * 581 * Attempting to allocate the whole free space (1Mb) would fail, because 582 * we can't allocate from multiple entries. 583 * With the bitmap free space stealing, we get a single extent entry 584 * that represents the 1Mb free space, and therefore we're able to 585 * allocate the whole free space at once. 586 */ 587 if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_1M)) { 588 test_err("expected region not marked as free"); 589 return -ENOENT; 590 } 591 592 if (cache->free_space_ctl->free_space != (SZ_1M + sectorsize)) { 593 test_err("cache free space is not 1Mb + %u", sectorsize); 594 return -EINVAL; 595 } 596 597 offset = btrfs_find_space_for_alloc(cache, 598 0, SZ_1M, 0, 599 &max_extent_size); 600 if (offset != (SZ_128M - SZ_256K)) { 601 test_err( 602 "failed to allocate 1Mb from space cache, returned offset is: %llu", 603 offset); 604 return -EINVAL; 605 } 606 607 /* 608 * All that remains is a sectorsize free space region in a bitmap. 609 * Confirm. 610 */ 611 ret = check_num_extents_and_bitmaps(cache, 1, 1); 612 if (ret) 613 return ret; 614 615 if (cache->free_space_ctl->free_space != sectorsize) { 616 test_err("cache free space is not %u", sectorsize); 617 return -EINVAL; 618 } 619 620 offset = btrfs_find_space_for_alloc(cache, 621 0, sectorsize, 0, 622 &max_extent_size); 623 if (offset != (SZ_128M + SZ_16M)) { 624 test_err("failed to allocate %u, returned offset : %llu", 625 sectorsize, offset); 626 return -EINVAL; 627 } 628 629 ret = check_cache_empty(cache); 630 if (ret) 631 return ret; 632 633 __btrfs_remove_free_space_cache(cache->free_space_ctl); 634 635 /* 636 * Now test a similar scenario, but where our extent entry is located 637 * to the right of the bitmap entry, so that we can check that stealing 638 * space from a bitmap to the front of an extent entry works. 639 */ 640 641 /* 642 * Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[ 643 */ 644 ret = test_add_free_space_entry(cache, SZ_128M + SZ_128K, SZ_128K, 0); 645 if (ret) { 646 test_err("couldn't add extent entry %d", ret); 647 return ret; 648 } 649 650 /* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */ 651 ret = test_add_free_space_entry(cache, 0, SZ_128M - SZ_512K, 1); 652 if (ret) { 653 test_err("couldn't add bitmap entry %d", ret); 654 return ret; 655 } 656 657 ret = check_num_extents_and_bitmaps(cache, 2, 1); 658 if (ret) 659 return ret; 660 661 /* 662 * Now make only the last 256Kb of the bitmap marked as free, so that 663 * we end up with only the following ranges marked as free space: 664 * 665 * [128Mb + 128b, 128Mb + 256Kb[ 666 * [128Mb - 768Kb, 128Mb - 512Kb[ 667 */ 668 ret = btrfs_remove_free_space(cache, 0, SZ_128M - 768 * SZ_1K); 669 if (ret) { 670 test_err("failed to free part of bitmap space %d", ret); 671 return ret; 672 } 673 674 /* Confirm that only those 2 ranges are marked as free. */ 675 if (!test_check_exists(cache, SZ_128M + SZ_128K, SZ_128K)) { 676 test_err("free space range missing"); 677 return -ENOENT; 678 } 679 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_256K)) { 680 test_err("free space range missing"); 681 return -ENOENT; 682 } 683 684 /* 685 * Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked 686 * as free anymore. 687 */ 688 if (test_check_exists(cache, 0, SZ_128M - 768 * SZ_1K)) { 689 test_err("bitmap region not removed from space cache"); 690 return -EINVAL; 691 } 692 693 /* 694 * Confirm that the region [128Mb - 512Kb, 128Mb[, which is 695 * covered by the bitmap, isn't marked as free. 696 */ 697 if (test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) { 698 test_err("invalid bitmap region marked as free"); 699 return -EINVAL; 700 } 701 702 /* 703 * Now lets mark the region [128Mb - 512Kb, 128Mb[ as free too. But, 704 * lets make sure the free space cache marks it as free in the bitmap, 705 * and doesn't insert a new extent entry to represent this region. 706 */ 707 ret = btrfs_add_free_space(cache, SZ_128M - SZ_512K, SZ_512K); 708 if (ret) { 709 test_err("error adding free space: %d", ret); 710 return ret; 711 } 712 /* Confirm the region is marked as free. */ 713 if (!test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) { 714 test_err("bitmap region not marked as free"); 715 return -ENOENT; 716 } 717 718 /* 719 * Confirm that no new extent entries or bitmap entries were added to 720 * the cache after adding that free space region. 721 */ 722 ret = check_num_extents_and_bitmaps(cache, 2, 1); 723 if (ret) 724 return ret; 725 726 /* 727 * Now lets add a small free space region to the left of the previous 728 * one, which is not contiguous with it and is part of the bitmap too. 729 * The goal is to test that the bitmap entry space stealing doesn't 730 * steal this space region. 731 */ 732 ret = btrfs_add_free_space(cache, SZ_32M, 2 * sectorsize); 733 if (ret) { 734 test_err("error adding free space: %d", ret); 735 return ret; 736 } 737 738 /* 739 * Now mark the region [128Mb, 128Mb + 128Kb[ as free too. This will 740 * expand the range covered by the existing extent entry that represents 741 * the free space [128Mb + 128Kb, 128Mb + 256Kb[. 742 */ 743 ret = btrfs_add_free_space(cache, SZ_128M, SZ_128K); 744 if (ret) { 745 test_err("error adding free space: %d", ret); 746 return ret; 747 } 748 /* Confirm the region is marked as free. */ 749 if (!test_check_exists(cache, SZ_128M, SZ_128K)) { 750 test_err("extent region not marked as free"); 751 return -ENOENT; 752 } 753 754 /* 755 * Confirm that our extent entry didn't stole all free space from the 756 * bitmap, because of the small 2 * sectorsize free space region. 757 */ 758 ret = check_num_extents_and_bitmaps(cache, 2, 1); 759 if (ret) 760 return ret; 761 762 /* 763 * So now we have the range [128Mb - 768Kb, 128Mb + 256Kb[ as free 764 * space. Without stealing bitmap free space into extent entry space, 765 * we would have all this free space represented by 2 entries in the 766 * cache: 767 * 768 * extent entry covering range: [128Mb, 128Mb + 256Kb[ 769 * bitmap entry covering range: [128Mb - 768Kb, 128Mb[ 770 * 771 * Attempting to allocate the whole free space (1Mb) would fail, because 772 * we can't allocate from multiple entries. 773 * With the bitmap free space stealing, we get a single extent entry 774 * that represents the 1Mb free space, and therefore we're able to 775 * allocate the whole free space at once. 776 */ 777 if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_1M)) { 778 test_err("expected region not marked as free"); 779 return -ENOENT; 780 } 781 782 if (cache->free_space_ctl->free_space != (SZ_1M + 2 * sectorsize)) { 783 test_err("cache free space is not 1Mb + %u", 2 * sectorsize); 784 return -EINVAL; 785 } 786 787 offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0, 788 &max_extent_size); 789 if (offset != (SZ_128M - 768 * SZ_1K)) { 790 test_err( 791 "failed to allocate 1Mb from space cache, returned offset is: %llu", 792 offset); 793 return -EINVAL; 794 } 795 796 /* 797 * All that remains is 2 * sectorsize free space region 798 * in a bitmap. Confirm. 799 */ 800 ret = check_num_extents_and_bitmaps(cache, 1, 1); 801 if (ret) 802 return ret; 803 804 if (cache->free_space_ctl->free_space != 2 * sectorsize) { 805 test_err("cache free space is not %u", 2 * sectorsize); 806 return -EINVAL; 807 } 808 809 offset = btrfs_find_space_for_alloc(cache, 810 0, 2 * sectorsize, 0, 811 &max_extent_size); 812 if (offset != SZ_32M) { 813 test_err("failed to allocate %u, offset: %llu", 814 2 * sectorsize, offset); 815 return -EINVAL; 816 } 817 818 ret = check_cache_empty(cache); 819 if (ret) 820 return ret; 821 822 cache->free_space_ctl->op = orig_free_space_ops; 823 __btrfs_remove_free_space_cache(cache->free_space_ctl); 824 825 return 0; 826 } 827 828 int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize) 829 { 830 struct btrfs_fs_info *fs_info; 831 struct btrfs_block_group *cache; 832 struct btrfs_root *root = NULL; 833 int ret = -ENOMEM; 834 835 test_msg("running btrfs free space cache tests"); 836 fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize); 837 if (!fs_info) { 838 test_std_err(TEST_ALLOC_FS_INFO); 839 return -ENOMEM; 840 } 841 842 /* 843 * For ppc64 (with 64k page size), bytes per bitmap might be 844 * larger than 1G. To make bitmap test available in ppc64, 845 * alloc dummy block group whose size cross bitmaps. 846 */ 847 cache = btrfs_alloc_dummy_block_group(fs_info, 848 BITS_PER_BITMAP * sectorsize + PAGE_SIZE); 849 if (!cache) { 850 test_std_err(TEST_ALLOC_BLOCK_GROUP); 851 btrfs_free_dummy_fs_info(fs_info); 852 return 0; 853 } 854 855 root = btrfs_alloc_dummy_root(fs_info); 856 if (IS_ERR(root)) { 857 test_std_err(TEST_ALLOC_ROOT); 858 ret = PTR_ERR(root); 859 goto out; 860 } 861 862 root->fs_info->extent_root = root; 863 864 ret = test_extents(cache); 865 if (ret) 866 goto out; 867 ret = test_bitmaps(cache, sectorsize); 868 if (ret) 869 goto out; 870 ret = test_bitmaps_and_extents(cache, sectorsize); 871 if (ret) 872 goto out; 873 874 ret = test_steal_space_from_bitmap_to_extent(cache, sectorsize); 875 out: 876 btrfs_free_dummy_block_group(cache); 877 btrfs_free_dummy_root(root); 878 btrfs_free_dummy_fs_info(fs_info); 879 return ret; 880 } 881