static int run_test(test_func_t test_func, int bitmaps) { struct btrfs_root *root = NULL; struct btrfs_block_group_cache *cache = NULL; struct btrfs_trans_handle trans; struct btrfs_path *path = NULL; int ret; root = btrfs_alloc_dummy_root(); if (IS_ERR(root)) { test_msg("Couldn't allocate dummy root\n"); ret = PTR_ERR(root); goto out; } root->fs_info = btrfs_alloc_dummy_fs_info(); if (!root->fs_info) { test_msg("Couldn't allocate dummy fs info\n"); ret = -ENOMEM; goto out; } btrfs_set_super_compat_ro_flags(root->fs_info->super_copy, BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE); root->fs_info->free_space_root = root; root->fs_info->tree_root = root; root->node = alloc_test_extent_buffer(root->fs_info, 4096); if (!root->node) { test_msg("Couldn't allocate dummy buffer\n"); ret = -ENOMEM; goto out; } btrfs_set_header_level(root->node, 0); btrfs_set_header_nritems(root->node, 0); root->alloc_bytenr += 8192; cache = btrfs_alloc_dummy_block_group(8 * BITMAP_RANGE); if (!cache) { test_msg("Couldn't allocate dummy block group cache\n"); ret = -ENOMEM; goto out; } cache->bitmap_low_thresh = 0; cache->bitmap_high_thresh = (u32)-1; cache->needs_free_space = 1; btrfs_init_dummy_trans(&trans); path = btrfs_alloc_path(); if (!path) { test_msg("Couldn't allocate path\n"); return -ENOMEM; } ret = add_block_group_free_space(&trans, root->fs_info, cache); if (ret) { test_msg("Could not add block group free space\n"); goto out; } if (bitmaps) { ret = convert_free_space_to_bitmaps(&trans, root->fs_info, cache, path); if (ret) { test_msg("Could not convert block group to bitmaps\n"); goto out; } } ret = test_func(&trans, root->fs_info, cache, path); if (ret) goto out; ret = remove_block_group_free_space(&trans, root->fs_info, cache); if (ret) { test_msg("Could not remove block group free space\n"); goto out; } if (btrfs_header_nritems(root->node) != 0) { test_msg("Free space tree has leftover items\n"); ret = -EINVAL; goto out; } ret = 0; out: btrfs_free_path(path); btrfs_free_dummy_block_group(cache); btrfs_free_dummy_root(root); return ret; }
/* * Before we were able to steal free space from a bitmap entry to an extent * entry, we could end up with 2 entries representing a contiguous free space. * One would be an extent entry and the other a bitmap entry. Since in order * to allocate space to a caller we use only 1 entry, we couldn't return that * whole range to the caller if it was requested. This forced the caller to * either assume ENOSPC or perform several smaller space allocations, which * wasn't optimal as they could be spread all over the block group while under * concurrency (extra overhead and fragmentation). * * This stealing approach is beneficial, since we always prefer to allocate * from extent entries, both for clustered and non-clustered allocation * requests. */ static int test_steal_space_from_bitmap_to_extent(struct btrfs_block_group_cache *cache, u32 sectorsize) { int ret; u64 offset; u64 max_extent_size; const struct btrfs_free_space_op test_free_space_ops = { .recalc_thresholds = cache->free_space_ctl->op->recalc_thresholds, .use_bitmap = test_use_bitmap, }; const struct btrfs_free_space_op *orig_free_space_ops; test_msg("Running space stealing from bitmap to extent\n"); /* * For this test, we want to ensure we end up with an extent entry * immediately adjacent to a bitmap entry, where the bitmap starts * at an offset where the extent entry ends. We keep adding and * removing free space to reach into this state, but to get there * we need to reach a point where marking new free space doesn't * result in adding new extent entries or merging the new space * with existing extent entries - the space ends up being marked * in an existing bitmap that covers the new free space range. * * To get there, we need to reach the threshold defined set at * cache->free_space_ctl->extents_thresh, which currently is * 256 extents on a x86_64 system at least, and a few other * conditions (check free_space_cache.c). Instead of making the * test much longer and complicated, use a "use_bitmap" operation * that forces use of bitmaps as soon as we have at least 1 * extent entry. */ orig_free_space_ops = cache->free_space_ctl->op; cache->free_space_ctl->op = &test_free_space_ops; /* * Extent entry covering free space range [128Mb - 256Kb, 128Mb - 128Kb[ */ ret = test_add_free_space_entry(cache, SZ_128M - SZ_256K, SZ_128K, 0); if (ret) { test_msg("Couldn't add extent entry %d\n", ret); return ret; } /* Bitmap entry covering free space range [128Mb + 512Kb, 256Mb[ */ ret = test_add_free_space_entry(cache, SZ_128M + SZ_512K, SZ_128M - SZ_512K, 1); if (ret) { test_msg("Couldn't add bitmap entry %d\n", ret); return ret; } ret = check_num_extents_and_bitmaps(cache, 2, 1); if (ret) return ret; /* * Now make only the first 256Kb of the bitmap marked as free, so that * we end up with only the following ranges marked as free space: * * [128Mb - 256Kb, 128Mb - 128Kb[ * [128Mb + 512Kb, 128Mb + 768Kb[ */ ret = btrfs_remove_free_space(cache, SZ_128M + 768 * SZ_1K, SZ_128M - 768 * SZ_1K); if (ret) { test_msg("Failed to free part of bitmap space %d\n", ret); return ret; } /* Confirm that only those 2 ranges are marked as free. */ if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_128K)) { test_msg("Free space range missing\n"); return -ENOENT; } if (!test_check_exists(cache, SZ_128M + SZ_512K, SZ_256K)) { test_msg("Free space range missing\n"); return -ENOENT; } /* * Confirm that the bitmap range [128Mb + 768Kb, 256Mb[ isn't marked * as free anymore. */ if (test_check_exists(cache, SZ_128M + 768 * SZ_1K, SZ_128M - 768 * SZ_1K)) { test_msg("Bitmap region not removed from space cache\n"); return -EINVAL; } /* * Confirm that the region [128Mb + 256Kb, 128Mb + 512Kb[, which is * covered by the bitmap, isn't marked as free. */ if (test_check_exists(cache, SZ_128M + SZ_256K, SZ_256K)) { test_msg("Invalid bitmap region marked as free\n"); return -EINVAL; } /* * Confirm that the region [128Mb, 128Mb + 256Kb[, which is covered * by the bitmap too, isn't marked as free either. */ if (test_check_exists(cache, SZ_128M, SZ_256K)) { test_msg("Invalid bitmap region marked as free\n"); return -EINVAL; } /* * Now lets mark the region [128Mb, 128Mb + 512Kb[ as free too. But, * lets make sure the free space cache marks it as free in the bitmap, * and doesn't insert a new extent entry to represent this region. */ ret = btrfs_add_free_space(cache, SZ_128M, SZ_512K); if (ret) { test_msg("Error adding free space: %d\n", ret); return ret; } /* Confirm the region is marked as free. */ if (!test_check_exists(cache, SZ_128M, SZ_512K)) { test_msg("Bitmap region not marked as free\n"); return -ENOENT; } /* * Confirm that no new extent entries or bitmap entries were added to * the cache after adding that free space region. */ ret = check_num_extents_and_bitmaps(cache, 2, 1); if (ret) return ret; /* * Now lets add a small free space region to the right of the previous * one, which is not contiguous with it and is part of the bitmap too. * The goal is to test that the bitmap entry space stealing doesn't * steal this space region. */ ret = btrfs_add_free_space(cache, SZ_128M + SZ_16M, sectorsize); if (ret) { test_msg("Error adding free space: %d\n", ret); return ret; } /* * Confirm that no new extent entries or bitmap entries were added to * the cache after adding that free space region. */ ret = check_num_extents_and_bitmaps(cache, 2, 1); if (ret) return ret; /* * Now mark the region [128Mb - 128Kb, 128Mb[ as free too. This will * expand the range covered by the existing extent entry that represents * the free space [128Mb - 256Kb, 128Mb - 128Kb[. */ ret = btrfs_add_free_space(cache, SZ_128M - SZ_128K, SZ_128K); if (ret) { test_msg("Error adding free space: %d\n", ret); return ret; } /* Confirm the region is marked as free. */ if (!test_check_exists(cache, SZ_128M - SZ_128K, SZ_128K)) { test_msg("Extent region not marked as free\n"); return -ENOENT; } /* * Confirm that our extent entry didn't stole all free space from the * bitmap, because of the small 4Kb free space region. */ ret = check_num_extents_and_bitmaps(cache, 2, 1); if (ret) return ret; /* * So now we have the range [128Mb - 256Kb, 128Mb + 768Kb[ as free * space. Without stealing bitmap free space into extent entry space, * we would have all this free space represented by 2 entries in the * cache: * * extent entry covering range: [128Mb - 256Kb, 128Mb[ * bitmap entry covering range: [128Mb, 128Mb + 768Kb[ * * Attempting to allocate the whole free space (1Mb) would fail, because * we can't allocate from multiple entries. * With the bitmap free space stealing, we get a single extent entry * that represents the 1Mb free space, and therefore we're able to * allocate the whole free space at once. */ if (!test_check_exists(cache, SZ_128M - SZ_256K, SZ_1M)) { test_msg("Expected region not marked as free\n"); return -ENOENT; } if (cache->free_space_ctl->free_space != (SZ_1M + sectorsize)) { test_msg("Cache free space is not 1Mb + %u\n", sectorsize); return -EINVAL; } offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0, &max_extent_size); if (offset != (SZ_128M - SZ_256K)) { test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n", offset); return -EINVAL; } /* * All that remains is a sectorsize free space region in a bitmap. * Confirm. */ ret = check_num_extents_and_bitmaps(cache, 1, 1); if (ret) return ret; if (cache->free_space_ctl->free_space != sectorsize) { test_msg("Cache free space is not %u\n", sectorsize); return -EINVAL; } offset = btrfs_find_space_for_alloc(cache, 0, sectorsize, 0, &max_extent_size); if (offset != (SZ_128M + SZ_16M)) { test_msg("Failed to allocate %u, returned offset : %llu\n", sectorsize, offset); return -EINVAL; } ret = check_cache_empty(cache); if (ret) return ret; __btrfs_remove_free_space_cache(cache->free_space_ctl); /* * Now test a similar scenario, but where our extent entry is located * to the right of the bitmap entry, so that we can check that stealing * space from a bitmap to the front of an extent entry works. */ /* * Extent entry covering free space range [128Mb + 128Kb, 128Mb + 256Kb[ */ ret = test_add_free_space_entry(cache, SZ_128M + SZ_128K, SZ_128K, 0); if (ret) { test_msg("Couldn't add extent entry %d\n", ret); return ret; } /* Bitmap entry covering free space range [0, 128Mb - 512Kb[ */ ret = test_add_free_space_entry(cache, 0, SZ_128M - SZ_512K, 1); if (ret) { test_msg("Couldn't add bitmap entry %d\n", ret); return ret; } ret = check_num_extents_and_bitmaps(cache, 2, 1); if (ret) return ret; /* * Now make only the last 256Kb of the bitmap marked as free, so that * we end up with only the following ranges marked as free space: * * [128Mb + 128b, 128Mb + 256Kb[ * [128Mb - 768Kb, 128Mb - 512Kb[ */ ret = btrfs_remove_free_space(cache, 0, SZ_128M - 768 * SZ_1K); if (ret) { test_msg("Failed to free part of bitmap space %d\n", ret); return ret; } /* Confirm that only those 2 ranges are marked as free. */ if (!test_check_exists(cache, SZ_128M + SZ_128K, SZ_128K)) { test_msg("Free space range missing\n"); return -ENOENT; } if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_256K)) { test_msg("Free space range missing\n"); return -ENOENT; } /* * Confirm that the bitmap range [0, 128Mb - 768Kb[ isn't marked * as free anymore. */ if (test_check_exists(cache, 0, SZ_128M - 768 * SZ_1K)) { test_msg("Bitmap region not removed from space cache\n"); return -EINVAL; } /* * Confirm that the region [128Mb - 512Kb, 128Mb[, which is * covered by the bitmap, isn't marked as free. */ if (test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) { test_msg("Invalid bitmap region marked as free\n"); return -EINVAL; } /* * Now lets mark the region [128Mb - 512Kb, 128Mb[ as free too. But, * lets make sure the free space cache marks it as free in the bitmap, * and doesn't insert a new extent entry to represent this region. */ ret = btrfs_add_free_space(cache, SZ_128M - SZ_512K, SZ_512K); if (ret) { test_msg("Error adding free space: %d\n", ret); return ret; } /* Confirm the region is marked as free. */ if (!test_check_exists(cache, SZ_128M - SZ_512K, SZ_512K)) { test_msg("Bitmap region not marked as free\n"); return -ENOENT; } /* * Confirm that no new extent entries or bitmap entries were added to * the cache after adding that free space region. */ ret = check_num_extents_and_bitmaps(cache, 2, 1); if (ret) return ret; /* * Now lets add a small free space region to the left of the previous * one, which is not contiguous with it and is part of the bitmap too. * The goal is to test that the bitmap entry space stealing doesn't * steal this space region. */ ret = btrfs_add_free_space(cache, SZ_32M, 2 * sectorsize); if (ret) { test_msg("Error adding free space: %d\n", ret); return ret; } /* * Now mark the region [128Mb, 128Mb + 128Kb[ as free too. This will * expand the range covered by the existing extent entry that represents * the free space [128Mb + 128Kb, 128Mb + 256Kb[. */ ret = btrfs_add_free_space(cache, SZ_128M, SZ_128K); if (ret) { test_msg("Error adding free space: %d\n", ret); return ret; } /* Confirm the region is marked as free. */ if (!test_check_exists(cache, SZ_128M, SZ_128K)) { test_msg("Extent region not marked as free\n"); return -ENOENT; } /* * Confirm that our extent entry didn't stole all free space from the * bitmap, because of the small 2 * sectorsize free space region. */ ret = check_num_extents_and_bitmaps(cache, 2, 1); if (ret) return ret; /* * So now we have the range [128Mb - 768Kb, 128Mb + 256Kb[ as free * space. Without stealing bitmap free space into extent entry space, * we would have all this free space represented by 2 entries in the * cache: * * extent entry covering range: [128Mb, 128Mb + 256Kb[ * bitmap entry covering range: [128Mb - 768Kb, 128Mb[ * * Attempting to allocate the whole free space (1Mb) would fail, because * we can't allocate from multiple entries. * With the bitmap free space stealing, we get a single extent entry * that represents the 1Mb free space, and therefore we're able to * allocate the whole free space at once. */ if (!test_check_exists(cache, SZ_128M - 768 * SZ_1K, SZ_1M)) { test_msg("Expected region not marked as free\n"); return -ENOENT; } if (cache->free_space_ctl->free_space != (SZ_1M + 2 * sectorsize)) { test_msg("Cache free space is not 1Mb + %u\n", 2 * sectorsize); return -EINVAL; } offset = btrfs_find_space_for_alloc(cache, 0, SZ_1M, 0, &max_extent_size); if (offset != (SZ_128M - 768 * SZ_1K)) { test_msg("Failed to allocate 1Mb from space cache, returned offset is: %llu\n", offset); return -EINVAL; } /* * All that remains is 2 * sectorsize free space region * in a bitmap. Confirm. */ ret = check_num_extents_and_bitmaps(cache, 1, 1); if (ret) return ret; if (cache->free_space_ctl->free_space != 2 * sectorsize) { test_msg("Cache free space is not %u\n", 2 * sectorsize); return -EINVAL; } offset = btrfs_find_space_for_alloc(cache, 0, 2 * sectorsize, 0, &max_extent_size); if (offset != SZ_32M) { test_msg("Failed to allocate %u, offset: %llu\n", 2 * sectorsize, offset); return -EINVAL; } ret = check_cache_empty(cache); if (ret) return ret; cache->free_space_ctl->op = orig_free_space_ops; __btrfs_remove_free_space_cache(cache->free_space_ctl); return 0; } int btrfs_test_free_space_cache(u32 sectorsize, u32 nodesize) { struct btrfs_fs_info *fs_info; struct btrfs_block_group_cache *cache; struct btrfs_root *root = NULL; int ret = -ENOMEM; test_msg("Running btrfs free space cache tests\n"); fs_info = btrfs_alloc_dummy_fs_info(nodesize, sectorsize); if (!fs_info) return -ENOMEM; /* * For ppc64 (with 64k page size), bytes per bitmap might be * larger than 1G. To make bitmap test available in ppc64, * alloc dummy block group whose size cross bitmaps. */ cache = btrfs_alloc_dummy_block_group(fs_info, BITS_PER_BITMAP * sectorsize + PAGE_SIZE); if (!cache) { test_msg("Couldn't run the tests\n"); btrfs_free_dummy_fs_info(fs_info); return 0; } root = btrfs_alloc_dummy_root(fs_info); if (IS_ERR(root)) { ret = PTR_ERR(root); goto out; } root->fs_info->extent_root = root; ret = test_extents(cache); if (ret) goto out; ret = test_bitmaps(cache, sectorsize); if (ret) goto out; ret = test_bitmaps_and_extents(cache, sectorsize); if (ret) goto out; ret = test_steal_space_from_bitmap_to_extent(cache, sectorsize); out: btrfs_free_dummy_block_group(cache); btrfs_free_dummy_root(root); btrfs_free_dummy_fs_info(fs_info); test_msg("Free space cache tests finished\n"); return ret; }