Btrfs: remove the ideal caching code

This is a relic from before we had the disk space cache and it was to make
bootup times when you had btrfs as root not be so damned slow.  Now that we have
the disk space cache this isn't a problem anymore and really having this code
casues uneeded fragmentation and complexity, so just remove it.  Thanks,

Signed-off-by: Josef Bacik <josef@redhat.com>

1 files changed, 8 insertions, 85 deletions

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 37e0a800d34e..eccef6c06237 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -5260,11 +5260,10 @@ static int get_block_group_index(struct btrfs_block_group_cache *cache)
 }
 
 enum btrfs_loop_type {
-        LOOP_FIND_IDEAL = 0,
-        LOOP_CACHING_NOWAIT = 1,
-        LOOP_CACHING_WAIT = 2,
-        LOOP_ALLOC_CHUNK = 3,
-        LOOP_NO_EMPTY_SIZE = 4,
+        LOOP_CACHING_NOWAIT = 0,
+        LOOP_CACHING_WAIT = 1,
+        LOOP_ALLOC_CHUNK = 2,
+        LOOP_NO_EMPTY_SIZE = 3,
 };
 
 /*
@@ -5300,8 +5299,6 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
         bool failed_alloc = false;
         bool use_cluster = true;
         bool have_caching_bg = false;
-        u64 ideal_cache_percent = 0;
-        u64 ideal_cache_offset = 0;
 
         WARN_ON(num_bytes < root->sectorsize);
         btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
@@ -5351,7 +5348,6 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
                 empty_cluster = 0;
 
         if (search_start == hint_byte) {
-ideal_cache:
                 block_group = btrfs_lookup_block_group(root->fs_info,
                                                        search_start);
                 used_block_group = block_group;
@@ -5363,8 +5359,7 @@ ideal_cache:
                  * picked out then we don't care that the block group is cached.
                  */
                 if (block_group && block_group_bits(block_group, data) &&
-                    (block_group->cached != BTRFS_CACHE_NO ||
-                     search_start == ideal_cache_offset)) {
+                    block_group->cached != BTRFS_CACHE_NO) {
                         down_read(&space_info->groups_sem);
                         if (list_empty(&block_group->list) ||
                             block_group->ro) {
@@ -5418,44 +5413,12 @@ search:
 have_block_group:
                 cached = block_group_cache_done(block_group);
                 if (unlikely(!cached)) {
-                        u64 free_percent;
-
                         found_uncached_bg = true;
                         ret = cache_block_group(block_group, trans,
-                                                orig_root, 1);
-                        if (block_group->cached == BTRFS_CACHE_FINISHED)
-                                goto alloc;
-
-                        free_percent = btrfs_block_group_used(&block_group->item);
-                        free_percent *= 100;
-                        free_percent = div64_u64(free_percent,
-                                                 block_group->key.offset);
-                        free_percent = 100 - free_percent;
-                        if (free_percent > ideal_cache_percent &&
-                            likely(!block_group->ro)) {
-                                ideal_cache_offset = block_group->key.objectid;
-                                ideal_cache_percent = free_percent;
-                        }
-
-                        /*
-                         * The caching workers are limited to 2 threads, so we
-                         * can queue as much work as we care to.
-                         */
-                        if (loop > LOOP_FIND_IDEAL) {
-                                ret = cache_block_group(block_group, trans,
-                                                        orig_root, 0);
-                                BUG_ON(ret);
-                        }
-
-                        /*
-                         * If loop is set for cached only, try the next block
-                         * group.
-                         */
-                        if (loop == LOOP_FIND_IDEAL)
-                                goto loop;
+                                                orig_root, 0);
+                        BUG_ON(ret);
                 }
 
-alloc:
                 if (unlikely(block_group->ro))
                         goto loop;
 
@@ -5661,9 +5624,7 @@ loop:
         if (!ins->objectid && ++index < BTRFS_NR_RAID_TYPES)
                 goto search;
 
-        /* LOOP_FIND_IDEAL, only search caching/cached bg's, and don't wait for
-         *                      for them to make caching progress.  Also
-         *                      determine the best possible bg to cache
+        /*
          * LOOP_CACHING_NOWAIT, search partially cached block groups, kicking
          *                      caching kthreads as we move along
          * LOOP_CACHING_WAIT, search everything, and wait if our bg is caching
@@ -5673,45 +5634,7 @@ loop:
          */
         if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE) {
                 index = 0;
-                if (loop == LOOP_FIND_IDEAL && found_uncached_bg) {
-                        found_uncached_bg = false;
-                        loop++;
-                        if (!ideal_cache_percent)
-                                goto search;
-
-                        /*
-                         * 1 of the following 2 things have happened so far
-                         *
-                         * 1) We found an ideal block group for caching that
-                         * is mostly full and will cache quickly, so we might
-                         * as well wait for it.
-                         *
-                         * 2) We searched for cached only and we didn't find
-                         * anything, and we didn't start any caching kthreads
-                         * either, so chances are we will loop through and
-                         * start a couple caching kthreads, and then come back
-                         * around and just wait for them.  This will be slower
-                         * because we will have 2 caching kthreads reading at
-                         * the same time when we could have just started one
-                         * and waited for it to get far enough to give us an
-                         * allocation, so go ahead and go to the wait caching
-                         * loop.
-                         */
-                        loop = LOOP_CACHING_WAIT;
-                        search_start = ideal_cache_offset;
-                        ideal_cache_percent = 0;
-                        goto ideal_cache;
-                } else if (loop == LOOP_FIND_IDEAL) {
-                        /*
-                         * Didn't find a uncached bg, wait on anything we find
-                         * next.
-                         */
-                        loop = LOOP_CACHING_WAIT;
-                        goto search;
-                }
-
                 loop++;
-
                 if (loop == LOOP_ALLOC_CHUNK) {
                        if (allowed_chunk_alloc) {
                                 ret = do_chunk_alloc(trans, root, num_bytes +