New upstream release

[bcachefs-tools-debian] / libbcachefs / bset.c

diff --git a/libbcachefs/bset.c b/libbcachefs/bset.c
index 09423536447049066def097c1b6c32b3ab4657d1..bcdf28f39b9c3db2b1b3f14b093348f3a0412da6 100644 (file)
--- a/libbcachefs/bset.c
+++ b/libbcachefs/bset.c
@@ -10,6 +10,7 @@
 #include "btree_cache.h"
 #include "bset.h"
 #include "eytzinger.h"
+#include "trace.h"
 #include "util.h"
 
 #include <asm/unaligned.h>
@@ -17,10 +18,6 @@
 #include <linux/random.h>
 #include <linux/prefetch.h>
 
-/* hack.. */
-#include "alloc_types.h"
-#include <trace/events/bcachefs.h>
-
 static inline void __bch2_btree_node_iter_advance(struct btree_node_iter *,
                                                  struct btree *);
 
@@ -36,16 +33,7 @@ static inline unsigned __btree_node_iter_used(struct btree_node_iter *iter)
 
 struct bset_tree *bch2_bkey_to_bset(struct btree *b, struct bkey_packed *k)
 {
-       unsigned offset = __btree_node_key_to_offset(b, k);
-       struct bset_tree *t;
-
-       for_each_bset(b, t)
-               if (offset <= t->end_offset) {
-                       EBUG_ON(offset < btree_bkey_first_offset(t));
-                       return t;
-               }
-
-       BUG();
+       return bch2_bkey_to_bset_inlined(b, k);
 }
 
 /*
@@ -78,7 +66,7 @@ void bch2_dump_bset(struct bch_fs *c, struct btree *b,
        for (_k = i->start;
             _k < vstruct_last(i);
             _k = _n) {
-               _n = bkey_next(_k);
+               _n = bkey_p_next(_k);
 
                k = bkey_disassemble(b, _k, &uk);
 
@@ -95,13 +83,12 @@ void bch2_dump_bset(struct bch_fs *c, struct btree *b,
 
                n = bkey_unpack_key(b, _n);
 
-               if (bpos_cmp(n.p, k.k->p) < 0) {
+               if (bpos_lt(n.p, k.k->p)) {
                        printk(KERN_ERR "Key skipped backwards\n");
                        continue;
                }
 
-               if (!bkey_deleted(k.k) &&
-                   !bpos_cmp(n.p, k.k->p))
+               if (!bkey_deleted(k.k) && bpos_eq(n.p, k.k->p))
                        printk(KERN_ERR "Duplicate keys\n");
        }
 
@@ -542,7 +529,7 @@ static void bch2_bset_verify_rw_aux_tree(struct btree *b,
        goto start;
        while (1) {
                if (rw_aux_to_bkey(b, t, j) == k) {
-                       BUG_ON(bpos_cmp(rw_aux_tree(b, t)[j].k,
+                       BUG_ON(!bpos_eq(rw_aux_tree(b, t)[j].k,
                                        bkey_unpack_pos(b, k)));
 start:
                        if (++j == t->size)
@@ -552,7 +539,7 @@ start:
                               rw_aux_tree(b, t)[j - 1].offset);
                }
 
-               k = bkey_next(k);
+               k = bkey_p_next(k);
                BUG_ON(k >= btree_bkey_last(b, t));
        }
 }
@@ -612,11 +599,10 @@ static inline unsigned bkey_mantissa(const struct bkey_packed *k,
        return (u16) v;
 }
 
-__always_inline
-static inline void make_bfloat(struct btree *b, struct bset_tree *t,
-                              unsigned j,
-                              struct bkey_packed *min_key,
-                              struct bkey_packed *max_key)
+static __always_inline void make_bfloat(struct btree *b, struct bset_tree *t,
+                                       unsigned j,
+                                       struct bkey_packed *min_key,
+                                       struct bkey_packed *max_key)
 {
        struct bkey_float *f = bkey_float(b, t, j);
        struct bkey_packed *m = tree_to_bkey(b, t, j);
@@ -743,7 +729,7 @@ retry:
        /* First we figure out where the first key in each cacheline is */
        eytzinger1_for_each(j, t->size - 1) {
                while (bkey_to_cacheline(b, t, k) < cacheline)
-                       prev = k, k = bkey_next(k);
+                       prev = k, k = bkey_p_next(k);
 
                if (k >= btree_bkey_last(b, t)) {
                        /* XXX: this path sucks */
@@ -760,7 +746,7 @@ retry:
        }
 
        while (k != btree_bkey_last(b, t))
-               prev = k, k = bkey_next(k);
+               prev = k, k = bkey_p_next(k);
 
        if (!bkey_pack_pos(bkey_to_packed(&min_key), b->data->min_key, b)) {
                bkey_init(&min_key.k);
@@ -898,7 +884,7 @@ struct bkey_packed *bch2_bkey_prev_filter(struct btree *b,
        struct bkey_packed *p, *i, *ret = NULL, *orig_k = k;
 
        while ((p = __bkey_prev(b, t, k)) && !ret) {
-               for (i = p; i != k; i = bkey_next(i))
+               for (i = p; i != k; i = bkey_p_next(i))
                        if (i->type >= min_key_type)
                                ret = i;
 
@@ -909,10 +895,10 @@ struct bkey_packed *bch2_bkey_prev_filter(struct btree *b,
                BUG_ON(ret >= orig_k);
 
                for (i = ret
-                       ? bkey_next(ret)
+                       ? bkey_p_next(ret)
                        : btree_bkey_first(b, t);
                     i != orig_k;
-                    i = bkey_next(i))
+                    i = bkey_p_next(i))
                        BUG_ON(i->type >= min_key_type);
        }
 
@@ -984,7 +970,7 @@ static void bch2_bset_fix_lookup_table(struct btree *b,
                struct bkey_packed *k = start;
 
                while (1) {
-                       k = bkey_next(k);
+                       k = bkey_p_next(k);
                        if (k == end)
                                break;
 
@@ -1035,7 +1021,7 @@ void bch2_bset_insert(struct btree *b,
                set_btree_bset_end(b, t);
        }
 
-       memcpy_u64s(where, src,
+       memcpy_u64s_small(where, src,
                    bkeyp_key_u64s(f, src));
        memcpy_u64s(bkeyp_val(f, where), &insert->v,
                    bkeyp_val_u64s(f, src));
@@ -1077,7 +1063,7 @@ static struct bkey_packed *bset_search_write_set(const struct btree *b,
        while (l + 1 != r) {
                unsigned m = (l + r) >> 1;
 
-               if (bpos_cmp(rw_aux_tree(b, t)[m].k, *search) < 0)
+               if (bpos_lt(rw_aux_tree(b, t)[m].k, *search))
                        l = m;
                else
                        r = m;
@@ -1218,12 +1204,12 @@ struct bkey_packed *bch2_bset_search_linear(struct btree *b,
                while (m != btree_bkey_last(b, t) &&
                       bkey_iter_cmp_p_or_unp(b, m,
                                        lossy_packed_search, search) < 0)
-                       m = bkey_next(m);
+                       m = bkey_p_next(m);
 
        if (!packed_search)
                while (m != btree_bkey_last(b, t) &&
                       bkey_iter_pos_cmp(b, m, search) < 0)
-                       m = bkey_next(m);
+                       m = bkey_p_next(m);
 
        if (bch2_expensive_debug_checks) {
                struct bkey_packed *prev = bch2_bkey_prev_all(b, t, m);
@@ -1330,8 +1316,8 @@ void bch2_btree_node_iter_init(struct btree_node_iter *iter,
        struct bkey_packed *k[MAX_BSETS];
        unsigned i;
 
-       EBUG_ON(bpos_cmp(*search, b->data->min_key) < 0);
-       EBUG_ON(bpos_cmp(*search, b->data->max_key) > 0);
+       EBUG_ON(bpos_lt(*search, b->data->min_key));
+       EBUG_ON(bpos_gt(*search, b->data->max_key));
        bset_aux_tree_verify(b);
 
        memset(iter, 0, sizeof(*iter));
@@ -1546,9 +1532,9 @@ struct bkey_s_c bch2_btree_node_iter_peek_unpack(struct btree_node_iter *iter,
 
 /* Mergesort */
 
-void bch2_btree_keys_stats(struct btree *b, struct bset_stats *stats)
+void bch2_btree_keys_stats(const struct btree *b, struct bset_stats *stats)
 {
-       struct bset_tree *t;
+       const struct bset_tree *t;
 
        for_each_bset(b, t) {
                enum bset_aux_tree_type type = bset_aux_tree_type(t);