fs/btrfs/tests/free-space-tests.c

   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
  12 #define BITS_PER_BITMAP         (PAGE_SIZE * 8UL)
  13
  14 /*
  15  * This test just does basic sanity checking, making sure we can add an extent
  16  * entry and remove space from either end and the middle, and make sure we can
  17  * remove space that covers adjacent extent entries.
  18  */
  19 static int test_extents(struct btrfs_block_group_cache *cache)
  20 {
  21         int ret = 0;
  22
  23         test_msg("running extent only tests");
  24
  25         /* First just make sure we can remove an entire entry */
  26         ret = btrfs_add_free_space(cache, 0, SZ_4M);
  27         if (ret) {
  28                 test_err("error adding initial extents %d", ret);
  29                 return ret;
  30         }
  31
  32         ret = btrfs_remove_free_space(cache, 0, SZ_4M);
  33         if (ret) {
  34                 test_err("error removing extent %d", ret);
  35                 return ret;
  36         }
  37
  38         if (test_check_exists(cache, 0, SZ_4M)) {
  39                 test_err("full remove left some lingering space");
  40                 return -1;
  41         }
  42
  43         /* Ok edge and middle cases now */
  44         ret = btrfs_add_free_space(cache, 0, SZ_4M);
  45         if (ret) {
  46                 test_err("error adding half extent %d", ret);
  47                 return ret;
  48         }
  49
  50         ret = btrfs_remove_free_space(cache, 3 * SZ_1M, SZ_1M);
  51         if (ret) {
  52                 test_err("error removing tail end %d", ret);
  53                 return ret;
  54         }
  55
  56         ret = btrfs_remove_free_space(cache, 0, SZ_1M);
  57         if (ret) {
  58                 test_err("error removing front end %d", ret);
  59                 return ret;
  60         }
  61
  62         ret = btrfs_remove_free_space(cache, SZ_2M, 4096);
  63         if (ret) {
  64                 test_err("error removing middle piece %d", ret);
  65                 return ret;
  66         }
  67
  68         if (test_check_exists(cache, 0, SZ_1M)) {
  69                 test_err("still have space at the front");
  70                 return -1;
  71         }
  72
  73         if (test_check_exists(cache, SZ_2M, 4096)) {
  74                 test_err("still have space in the middle");
  75                 return -1;
  76         }
  77
  78         if (test_check_exists(cache, 3 * SZ_1M, SZ_1M)) {
  79                 test_err("still have space at the end");
  80                 return -1;
  81         }
  82
  83         /* Cleanup */
  84         __btrfs_remove_free_space_cache(cache->free_space_ctl);
  85
  86         return 0;
  87 }
  88
  89 static int test_bitmaps(struct btrfs_block_group_cache *cache,
  90                         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 *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 *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 *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 *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");
 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 *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                 return -ENOMEM;
 839
 840
 841         /*
 842          * For ppc64 (with 64k page size), bytes per bitmap might be
 843          * larger than 1G.  To make bitmap test available in ppc64,
 844          * alloc dummy block group whose size cross bitmaps.
 845          */
 846         cache = btrfs_alloc_dummy_block_group(fs_info,
 847                                       BITS_PER_BITMAP * sectorsize + PAGE_SIZE);
 848         if (!cache) {
 849                 test_err("couldn't run the tests");
 850                 btrfs_free_dummy_fs_info(fs_info);
 851                 return 0;
 852         }
 853
 854         root = btrfs_alloc_dummy_root(fs_info);
 855         if (IS_ERR(root)) {
 856                 ret = PTR_ERR(root);
 857                 goto out;
 858         }
 859
 860         root->fs_info->extent_root = root;
 861
 862         ret = test_extents(cache);
 863         if (ret)
 864                 goto out;
 865         ret = test_bitmaps(cache, sectorsize);
 866         if (ret)
 867                 goto out;
 868         ret = test_bitmaps_and_extents(cache, sectorsize);
 869         if (ret)
 870                 goto out;
 871
 872         ret = test_steal_space_from_bitmap_to_extent(cache, sectorsize);
 873 out:
 874         btrfs_free_dummy_block_group(cache);
 875         btrfs_free_dummy_root(root);
 876         btrfs_free_dummy_fs_info(fs_info);
 877         test_msg("free space cache tests finished");
 878         return ret;
 879 }