btrfs: load block group size class when caching

Since the size class is an artifact of an arbitrary anti fragmentation
strategy, it doesn't really make sense to persist it. Furthermore, most
of the size class logic assumes fresh block groups. That is of course
not a reasonable assumption -- we will be upgrading kernels with
existing filesystems whose block groups are not classified.

To work around those issues, implement logic to compute the size class
of the block groups as we cache them in. To perfectly assess the state
of a block group, we would have to read the entire extent tree (since
the free space cache mashes together contiguous extent items) which
would be prohibitively expensive for larger file systems with more
extents.

We can do it relatively cheaply by implementing a simple heuristic of
sampling a handful of extents and picking the smallest one we see. In
the happy case where the block group was classified, we will only see
extents of the correct size. In the unhappy case, we will hopefully find
one of the smaller extents, but there is no perfect answer anyway.
Autorelocation will eventually churn up the block group if there is
significant freeing anyway.

There was no regression in mount performance at end state of the fsperf
test suite, and the delay until the block group is marked cached is
minimized by the constant number of extent samples.

Signed-off-by: Boris Burkov <boris@bur.io>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
index 6557b1b7f89ae2291700cbd87d14659be2a89d30..8a711b42951597b30270689700675a625088b5f0 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -540,6 +540,153 @@ u64 add_new_free_space(struct btrfs_block_group *block_group, u64 start, u64 end
        return total_added;
 }
 
+/*
+ * Get an arbitrary extent item index / max_index through the block group
+ *
+ * @block_group   the block group to sample from
+ * @index:        the integral step through the block group to grab from
+ * @max_index:    the granularity of the sampling
+ * @key:          return value parameter for the item we find
+ *
+ * Pre-conditions on indices:
+ * 0 <= index <= max_index
+ * 0 < max_index
+ *
+ * Returns: 0 on success, 1 if the search didn't yield a useful item, negative
+ * error code on error.
+ */
+static int sample_block_group_extent_item(struct btrfs_caching_control *caching_ctl,
+                                         struct btrfs_block_group *block_group,
+                                         int index, int max_index,
+                                         struct btrfs_key *key)
+{
+       struct btrfs_fs_info *fs_info = block_group->fs_info;
+       struct btrfs_root *extent_root;
+       int ret = 0;
+       u64 search_offset;
+       u64 search_end = block_group->start + block_group->length;
+       struct btrfs_path *path;
+
+       ASSERT(index >= 0);
+       ASSERT(index <= max_index);
+       ASSERT(max_index > 0);
+       lockdep_assert_held(&caching_ctl->mutex);
+       lockdep_assert_held_read(&fs_info->commit_root_sem);
+
+       path = btrfs_alloc_path();
+       if (!path)
+               return -ENOMEM;
+
+       extent_root = btrfs_extent_root(fs_info, max_t(u64, block_group->start,
+                                                      BTRFS_SUPER_INFO_OFFSET));
+
+       path->skip_locking = 1;
+       path->search_commit_root = 1;
+       path->reada = READA_FORWARD;
+
+       search_offset = index * div_u64(block_group->length, max_index);
+       key->objectid = block_group->start + search_offset;
+       key->type = BTRFS_EXTENT_ITEM_KEY;
+       key->offset = 0;
+
+       while (1) {
+               ret = btrfs_search_forward(extent_root, key, path, 0);
+               if (ret != 0)
+                       goto out;
+               /* Success; sampled an extent item in the block group */
+               if (key->type == BTRFS_EXTENT_ITEM_KEY &&
+                   key->objectid >= block_group->start &&
+                   key->objectid + key->offset <= search_end)
+                       goto out;
+
+               /* We can't possibly find a valid extent item anymore */
+               if (key->objectid >= search_end) {
+                       ret = 1;
+                       break;
+               }
+               if (key->type < BTRFS_EXTENT_ITEM_KEY)
+                       key->type = BTRFS_EXTENT_ITEM_KEY;
+               else
+                       key->objectid++;
+               btrfs_release_path(path);
+               up_read(&fs_info->commit_root_sem);
+               mutex_unlock(&caching_ctl->mutex);
+               cond_resched();
+               mutex_lock(&caching_ctl->mutex);
+               down_read(&fs_info->commit_root_sem);
+       }
+out:
+       lockdep_assert_held(&caching_ctl->mutex);
+       lockdep_assert_held_read(&fs_info->commit_root_sem);
+       btrfs_free_path(path);
+       return ret;
+}
+
+/*
+ * Best effort attempt to compute a block group's size class while caching it.
+ *
+ * @block_group: the block group we are caching
+ *
+ * We cannot infer the size class while adding free space extents, because that
+ * logic doesn't care about contiguous file extents (it doesn't differentiate
+ * between a 100M extent and 100 contiguous 1M extents). So we need to read the
+ * file extent items. Reading all of them is quite wasteful, because usually
+ * only a handful are enough to give a good answer. Therefore, we just grab 5 of
+ * them at even steps through the block group and pick the smallest size class
+ * we see. Since size class is best effort, and not guaranteed in general,
+ * inaccuracy is acceptable.
+ *
+ * To be more explicit about why this algorithm makes sense:
+ *
+ * If we are caching in a block group from disk, then there are three major cases
+ * to consider:
+ * 1. the block group is well behaved and all extents in it are the same size
+ *    class.
+ * 2. the block group is mostly one size class with rare exceptions for last
+ *    ditch allocations
+ * 3. the block group was populated before size classes and can have a totally
+ *    arbitrary mix of size classes.
+ *
+ * In case 1, looking at any extent in the block group will yield the correct
+ * result. For the mixed cases, taking the minimum size class seems like a good
+ * approximation, since gaps from frees will be usable to the size class. For
+ * 2., a small handful of file extents is likely to yield the right answer. For
+ * 3, we can either read every file extent, or admit that this is best effort
+ * anyway and try to stay fast.
+ *
+ * Returns: 0 on success, negative error code on error.
+ */
+static int load_block_group_size_class(struct btrfs_caching_control *caching_ctl,
+                                      struct btrfs_block_group *block_group)
+{
+       struct btrfs_key key;
+       int i;
+       u64 min_size = block_group->length;
+       enum btrfs_block_group_size_class size_class = BTRFS_BG_SZ_NONE;
+       int ret;
+
+       if (!btrfs_is_block_group_data_only(block_group))
+               return 0;
+
+       for (i = 0; i < 5; ++i) {
+               ret = sample_block_group_extent_item(caching_ctl, block_group, i, 5, &key);
+               if (ret < 0)
+                       goto out;
+               if (ret > 0)
+                       continue;
+               min_size = min_t(u64, min_size, key.offset);
+               size_class = btrfs_calc_block_group_size_class(min_size);
+       }
+       if (size_class != BTRFS_BG_SZ_NONE) {
+               spin_lock(&block_group->lock);
+               block_group->size_class = size_class;
+               spin_unlock(&block_group->lock);
+       }
+
+out:
+       return ret;
+}
+
 static int load_extent_tree_free(struct btrfs_caching_control *caching_ctl)
 {
        struct btrfs_block_group *block_group = caching_ctl->block_group;
@@ -684,6 +831,7 @@ static noinline void caching_thread(struct btrfs_work *work)
        mutex_lock(&caching_ctl->mutex);
        down_read(&fs_info->commit_root_sem);
 
+       load_block_group_size_class(caching_ctl, block_group);
        if (btrfs_test_opt(fs_info, SPACE_CACHE)) {
                ret = load_free_space_cache(block_group);
                if (ret == 1) {