bcache: Abstract out stuff needed for sorting

Signed-off-by: Kent Overstreet <kmo@daterainc.com>

9 files changed, 423 insertions, 289 deletions

diff --git a/drivers/md/bcache/Makefile b/drivers/md/bcache/Makefile
index 0e9c82523be6..c488b846f831 100644
--- a/drivers/md/bcache/Makefile
+++ b/drivers/md/bcache/Makefile
@@ -1,7 +1,8 @@
 
 obj-$(CONFIG_BCACHE)    += bcache.o
 
-bcache-y                := alloc.o btree.o bset.o io.o journal.o writeback.o\
-        movinggc.o request.o super.o sysfs.o debug.o util.o trace.o stats.o closure.o
+bcache-y                := alloc.o bset.o btree.o closure.o debug.o extents.o\
+        io.o journal.o movinggc.o request.o stats.o super.o sysfs.o trace.o\
+        util.o writeback.o
 
 CFLAGS_request.o        += -Iblock
diff --git a/drivers/md/bcache/bset.c b/drivers/md/bcache/bset.c
index e04e5908e29f..c2c42cbbe885 100644
--- a/drivers/md/bcache/bset.c
+++ b/drivers/md/bcache/bset.c
@@ -63,140 +63,6 @@ void bch_keylist_pop_front(struct keylist *l)
                 bch_keylist_bytes(l));
 }
 
-/* Pointer validation */
-
-static bool __ptr_invalid(struct cache_set *c, const struct bkey *k)
-{
-        unsigned i;
-
-        for (i = 0; i < KEY_PTRS(k); i++)
-                if (ptr_available(c, k, i)) {
-                        struct cache *ca = PTR_CACHE(c, k, i);
-                        size_t bucket = PTR_BUCKET_NR(c, k, i);
-                        size_t r = bucket_remainder(c, PTR_OFFSET(k, i));
-
-                        if (KEY_SIZE(k) + r > c->sb.bucket_size ||
-                            bucket <  ca->sb.first_bucket ||
-                            bucket >= ca->sb.nbuckets)
-                                return true;
-                }
-
-        return false;
-}
-
-bool bch_btree_ptr_invalid(struct cache_set *c, const struct bkey *k)
-{
-        char buf[80];
-
-        if (!KEY_PTRS(k) || !KEY_SIZE(k) || KEY_DIRTY(k))
-                goto bad;
-
-        if (__ptr_invalid(c, k))
-                goto bad;
-
-        return false;
-bad:
-        bch_bkey_to_text(buf, sizeof(buf), k);
-        cache_bug(c, "spotted btree ptr %s: %s", buf, bch_ptr_status(c, k));
-        return true;
-}
-
-bool bch_extent_ptr_invalid(struct cache_set *c, const struct bkey *k)
-{
-        char buf[80];
-
-        if (!KEY_SIZE(k))
-                return true;
-
-        if (KEY_SIZE(k) > KEY_OFFSET(k))
-                goto bad;
-
-        if (__ptr_invalid(c, k))
-                goto bad;
-
-        return false;
-bad:
-        bch_bkey_to_text(buf, sizeof(buf), k);
-        cache_bug(c, "spotted extent %s: %s", buf, bch_ptr_status(c, k));
-        return true;
-}
-
-static bool ptr_bad_expensive_checks(struct btree *b, const struct bkey *k,
-                                     unsigned ptr)
-{
-        struct bucket *g = PTR_BUCKET(b->c, k, ptr);
-        char buf[80];
-
-        if (mutex_trylock(&b->c->bucket_lock)) {
-                if (b->level) {
-                        if (KEY_DIRTY(k) ||
-                            g->prio != BTREE_PRIO ||
-                            (b->c->gc_mark_valid &&
-                             GC_MARK(g) != GC_MARK_METADATA))
-                                goto err;
-
-                } else {
-                        if (g->prio == BTREE_PRIO)
-                                goto err;
-
-                        if (KEY_DIRTY(k) &&
-                            b->c->gc_mark_valid &&
-                            GC_MARK(g) != GC_MARK_DIRTY)
-                                goto err;
-                }
-                mutex_unlock(&b->c->bucket_lock);
-        }
-
-        return false;
-err:
-        mutex_unlock(&b->c->bucket_lock);
-        bch_bkey_to_text(buf, sizeof(buf), k);
-        btree_bug(b,
-"inconsistent pointer %s: bucket %zu pin %i prio %i gen %i last_gc %i mark %llu gc_gen %i",
-                  buf, PTR_BUCKET_NR(b->c, k, ptr), atomic_read(&g->pin),
-                  g->prio, g->gen, g->last_gc, GC_MARK(g), g->gc_gen);
-        return true;
-}
-
-bool bch_ptr_bad(struct btree *b, const struct bkey *k)
-{
-        struct bucket *g;
-        unsigned i, stale;
-
-        if (!bkey_cmp(k, &ZERO_KEY) ||
-            !KEY_PTRS(k) ||
-            bch_ptr_invalid(b, k))
-                return true;
-
-        for (i = 0; i < KEY_PTRS(k); i++)
-                if (!ptr_available(b->c, k, i))
-                        return true;
-
-        if (!expensive_debug_checks(b->c) && KEY_DIRTY(k))
-                return false;
-
-        for (i = 0; i < KEY_PTRS(k); i++) {
-                g = PTR_BUCKET(b->c, k, i);
-                stale = ptr_stale(b->c, k, i);
-
-                btree_bug_on(stale > 96, b,
-                             "key too stale: %i, need_gc %u",
-                             stale, b->c->need_gc);
-
-                btree_bug_on(stale && KEY_DIRTY(k) && KEY_SIZE(k),
-                             b, "stale dirty pointer");
-
-                if (stale)
-                        return true;
-
-                if (expensive_debug_checks(b->c) &&
-                    ptr_bad_expensive_checks(b, k, i))
-                        return true;
-        }
-
-        return false;
-}
-
 /* Key/pointer manipulation */
 
 void bch_bkey_copy_single_ptr(struct bkey *dest, const struct bkey *src,
@@ -251,57 +117,6 @@ bool __bch_cut_back(const struct bkey *where, struct bkey *k)
         return true;
 }
 
-static uint64_t merge_chksums(struct bkey *l, struct bkey *r)
-{
-        return (l->ptr[KEY_PTRS(l)] + r->ptr[KEY_PTRS(r)]) &
-                ~((uint64_t)1 << 63);
-}
-
-/* Tries to merge l and r: l should be lower than r
- * Returns true if we were able to merge. If we did merge, l will be the merged
- * key, r will be untouched.
- */
-bool bch_bkey_try_merge(struct btree *b, struct bkey *l, struct bkey *r)
-{
-        unsigned i;
-
-        if (key_merging_disabled(b->c))
-                return false;
-
-        if (KEY_PTRS(l) != KEY_PTRS(r) ||
-            KEY_DIRTY(l) != KEY_DIRTY(r) ||
-            bkey_cmp(l, &START_KEY(r)))
-                return false;
-
-        for (i = 0; i < KEY_PTRS(l); i++)
-                if (l->ptr[i] + PTR(0, KEY_SIZE(l), 0) != r->ptr[i] ||