1 #ifndef _BCACHEFS_BSET_H
2 #define _BCACHEFS_BSET_H
4 #include <linux/kernel.h>
5 #include <linux/types.h>
7 #include "bcachefs_format.h"
9 #include "bkey_methods.h"
10 #include "btree_types.h"
11 #include "util.h" /* for time_stats */
17 * A bkey contains a key, a size field, a variable number of pointers, and some
18 * ancillary flag bits.
20 * We use two different functions for validating bkeys, bkey_invalid and
23 * The one exception to the rule that ptr_invalid() filters out invalid keys is
24 * that it also filters out keys of size 0 - these are keys that have been
25 * completely overwritten. It'd be safe to delete these in memory while leaving
26 * them on disk, just unnecessary work - so we filter them out when resorting
29 * We can't filter out stale keys when we're resorting, because garbage
30 * collection needs to find them to ensure bucket gens don't wrap around -
31 * unless we're rewriting the btree node those stale keys still exist on disk.
33 * We also implement functions here for removing some number of sectors from the
34 * front or the back of a bkey - this is mainly used for fixing overlapping
35 * extents, by removing the overlapping sectors from the older key.
39 * A bset is an array of bkeys laid out contiguously in memory in sorted order,
40 * along with a header. A btree node is made up of a number of these, written at
43 * There could be many of them on disk, but we never allow there to be more than
44 * 4 in memory - we lazily resort as needed.
46 * We implement code here for creating and maintaining auxiliary search trees
47 * (described below) for searching an individial bset, and on top of that we
48 * implement a btree iterator.
52 * Most of the code in bcache doesn't care about an individual bset - it needs
53 * to search entire btree nodes and iterate over them in sorted order.
55 * The btree iterator code serves both functions; it iterates through the keys
56 * in a btree node in sorted order, starting from either keys after a specific
57 * point (if you pass it a search key) or the start of the btree node.
59 * AUXILIARY SEARCH TREES:
61 * Since keys are variable length, we can't use a binary search on a bset - we
62 * wouldn't be able to find the start of the next key. But binary searches are
63 * slow anyways, due to terrible cache behaviour; bcache originally used binary
64 * searches and that code topped out at under 50k lookups/second.
66 * So we need to construct some sort of lookup table. Since we only insert keys
67 * into the last (unwritten) set, most of the keys within a given btree node are
68 * usually in sets that are mostly constant. We use two different types of
69 * lookup tables to take advantage of this.
71 * Both lookup tables share in common that they don't index every key in the
72 * set; they index one key every BSET_CACHELINE bytes, and then a linear search
73 * is used for the rest.
75 * For sets that have been written to disk and are no longer being inserted
76 * into, we construct a binary search tree in an array - traversing a binary
77 * search tree in an array gives excellent locality of reference and is very
78 * fast, since both children of any node are adjacent to each other in memory
79 * (and their grandchildren, and great grandchildren...) - this means
80 * prefetching can be used to great effect.
82 * It's quite useful performance wise to keep these nodes small - not just
83 * because they're more likely to be in L2, but also because we can prefetch
84 * more nodes on a single cacheline and thus prefetch more iterations in advance
85 * when traversing this tree.
87 * Nodes in the auxiliary search tree must contain both a key to compare against
88 * (we don't want to fetch the key from the set, that would defeat the purpose),
89 * and a pointer to the key. We use a few tricks to compress both of these.
91 * To compress the pointer, we take advantage of the fact that one node in the
92 * search tree corresponds to precisely BSET_CACHELINE bytes in the set. We have
93 * a function (to_inorder()) that takes the index of a node in a binary tree and
94 * returns what its index would be in an inorder traversal, so we only have to
95 * store the low bits of the offset.
97 * The key is 84 bits (KEY_DEV + key->key, the offset on the device). To
98 * compress that, we take advantage of the fact that when we're traversing the
99 * search tree at every iteration we know that both our search key and the key
100 * we're looking for lie within some range - bounded by our previous
101 * comparisons. (We special case the start of a search so that this is true even
102 * at the root of the tree).
104 * So we know the key we're looking for is between a and b, and a and b don't
105 * differ higher than bit 50, we don't need to check anything higher than bit
108 * We don't usually need the rest of the bits, either; we only need enough bits
109 * to partition the key range we're currently checking. Consider key n - the
110 * key our auxiliary search tree node corresponds to, and key p, the key
111 * immediately preceding n. The lowest bit we need to store in the auxiliary
112 * search tree is the highest bit that differs between n and p.
114 * Note that this could be bit 0 - we might sometimes need all 80 bits to do the
115 * comparison. But we'd really like our nodes in the auxiliary search tree to be
118 * The solution is to make them fixed size, and when we're constructing a node
119 * check if p and n differed in the bits we needed them to. If they don't we
120 * flag that node, and when doing lookups we fallback to comparing against the
121 * real key. As long as this doesn't happen to often (and it seems to reliably
122 * happen a bit less than 1% of the time), we win - even on failures, that key
123 * is then more likely to be in cache than if we were doing binary searches all
124 * the way, since we're touching so much less memory.
126 * The keys in the auxiliary search tree are stored in (software) floating
127 * point, with an exponent and a mantissa. The exponent needs to be big enough
128 * to address all the bits in the original key, but the number of bits in the
129 * mantissa is somewhat arbitrary; more bits just gets us fewer failures.
131 * We need 7 bits for the exponent and 3 bits for the key's offset (since keys
132 * are 8 byte aligned); using 22 bits for the mantissa means a node is 4 bytes.
133 * We need one node per 128 bytes in the btree node, which means the auxiliary
134 * search trees take up 3% as much memory as the btree itself.
136 * Constructing these auxiliary search trees is moderately expensive, and we
137 * don't want to be constantly rebuilding the search tree for the last set
138 * whenever we insert another key into it. For the unwritten set, we use a much
139 * simpler lookup table - it's just a flat array, so index i in the lookup table
140 * corresponds to the i range of BSET_CACHELINE bytes in the set. Indexing
141 * within each byte range works the same as with the auxiliary search trees.
143 * These are much easier to keep up to date when we insert a key - we do it
144 * somewhat lazily; when we shift a key up we usually just increment the pointer
145 * to it, only when it would overflow do we go to the trouble of finding the
146 * first key in that range of bytes again.
149 extern bool bch2_expensive_debug_checks;
151 static inline bool btree_keys_expensive_checks(const struct btree *b)
153 #ifdef CONFIG_BCACHEFS_DEBUG
154 return bch2_expensive_debug_checks || *b->expensive_debug_checks;
160 struct btree_node_iter;
161 struct btree_node_iter_set;
163 enum bset_aux_tree_type {
169 #define BSET_TREE_NR_TYPES 3
171 #define BSET_NO_AUX_TREE_VAL (U16_MAX)
172 #define BSET_RW_AUX_TREE_VAL (U16_MAX - 1)
174 static inline enum bset_aux_tree_type bset_aux_tree_type(const struct bset_tree *t)
177 case BSET_NO_AUX_TREE_VAL:
179 return BSET_NO_AUX_TREE;
180 case BSET_RW_AUX_TREE_VAL:
182 return BSET_RW_AUX_TREE;
185 return BSET_RO_AUX_TREE;
189 typedef void (*compiled_unpack_fn)(struct bkey *, const struct bkey_packed *);
192 __bkey_unpack_key_format_checked(const struct btree *b,
194 const struct bkey_packed *src)
196 #ifdef HAVE_BCACHEFS_COMPILED_UNPACK
198 compiled_unpack_fn unpack_fn = b->aux_data;
201 if (btree_keys_expensive_checks(b)) {
202 struct bkey dst2 = __bch2_bkey_unpack_key(&b->format, src);
205 * hack around a harmless race when compacting whiteouts
208 dst2.needs_whiteout = dst->needs_whiteout;
210 BUG_ON(memcmp(dst, &dst2, sizeof(*dst)));
214 *dst = __bch2_bkey_unpack_key(&b->format, src);
218 static inline struct bkey
219 bkey_unpack_key_format_checked(const struct btree *b,
220 const struct bkey_packed *src)
224 __bkey_unpack_key_format_checked(b, &dst, src);
228 static inline void __bkey_unpack_key(const struct btree *b,
230 const struct bkey_packed *src)
232 if (likely(bkey_packed(src)))
233 __bkey_unpack_key_format_checked(b, dst, src);
235 *dst = *packed_to_bkey_c(src);
239 * bkey_unpack_key -- unpack just the key, not the value
241 static inline struct bkey bkey_unpack_key(const struct btree *b,
242 const struct bkey_packed *src)
244 return likely(bkey_packed(src))
245 ? bkey_unpack_key_format_checked(b, src)
246 : *packed_to_bkey_c(src);
249 static inline struct bpos
250 bkey_unpack_pos_format_checked(const struct btree *b,
251 const struct bkey_packed *src)
253 #ifdef HAVE_BCACHEFS_COMPILED_UNPACK
254 return bkey_unpack_key_format_checked(b, src).p;
256 return __bkey_unpack_pos(&b->format, src);
260 static inline struct bpos bkey_unpack_pos(const struct btree *b,
261 const struct bkey_packed *src)
263 return likely(bkey_packed(src))
264 ? bkey_unpack_pos_format_checked(b, src)
265 : packed_to_bkey_c(src)->p;
268 /* Disassembled bkeys */
270 static inline struct bkey_s_c bkey_disassemble(struct btree *b,
271 const struct bkey_packed *k,
274 __bkey_unpack_key(b, u, k);
276 return (struct bkey_s_c) { u, bkeyp_val(&b->format, k), };
279 /* non const version: */
280 static inline struct bkey_s __bkey_disassemble(struct btree *b,
281 struct bkey_packed *k,
284 __bkey_unpack_key(b, u, k);
286 return (struct bkey_s) { .k = u, .v = bkeyp_val(&b->format, k), };
289 #define for_each_bset(_b, _t) \
290 for (_t = (_b)->set; _t < (_b)->set + (_b)->nsets; _t++)
292 static inline bool bset_has_ro_aux_tree(struct bset_tree *t)
294 return bset_aux_tree_type(t) == BSET_RO_AUX_TREE;
297 static inline bool bset_has_rw_aux_tree(struct bset_tree *t)
299 return bset_aux_tree_type(t) == BSET_RW_AUX_TREE;
302 static inline void bch2_bset_set_no_aux_tree(struct btree *b,
307 for (; t < b->set + ARRAY_SIZE(b->set); t++) {
309 t->extra = BSET_NO_AUX_TREE_VAL;
310 t->aux_data_offset = U16_MAX;
314 static inline void btree_node_set_format(struct btree *b,
315 struct bkey_format f)
320 b->nr_key_bits = bkey_format_key_bits(&f);
322 len = bch2_compile_bkey_format(&b->format, b->aux_data);
323 BUG_ON(len < 0 || len > U8_MAX);
325 b->unpack_fn_len = len;
327 bch2_bset_set_no_aux_tree(b, b->set);
330 static inline struct bset *bset_next_set(struct btree *b,
331 unsigned block_bytes)
333 struct bset *i = btree_bset_last(b);
335 EBUG_ON(!is_power_of_2(block_bytes));
337 return ((void *) i) + round_up(vstruct_bytes(i), block_bytes);
340 void bch2_btree_keys_free(struct btree *);
341 int bch2_btree_keys_alloc(struct btree *, unsigned, gfp_t);
342 void bch2_btree_keys_init(struct btree *, bool *);
344 void bch2_bset_init_first(struct btree *, struct bset *);
345 void bch2_bset_init_next(struct btree *, struct bset *);
346 void bch2_bset_build_aux_tree(struct btree *, struct bset_tree *, bool);
347 void bch2_bset_fix_invalidated_key(struct btree *, struct bset_tree *,
348 struct bkey_packed *);
350 void bch2_bset_insert(struct btree *, struct btree_node_iter *,
351 struct bkey_packed *, struct bkey_i *, unsigned);
352 void bch2_bset_delete(struct btree *, struct bkey_packed *, unsigned);
354 /* Bkey utility code */
356 /* packed or unpacked */
357 static inline int bkey_cmp_p_or_unp(const struct btree *b,
358 const struct bkey_packed *l,
359 const struct bkey_packed *r_packed,
362 EBUG_ON(r_packed && !bkey_packed(r_packed));
364 if (unlikely(!bkey_packed(l)))
365 return bkey_cmp(packed_to_bkey_c(l)->p, *r);
367 if (likely(r_packed))
368 return __bch2_bkey_cmp_packed_format_checked(l, r_packed, b);
370 return __bch2_bkey_cmp_left_packed_format_checked(b, l, r);
373 /* Returns true if @k is after iterator position @pos */
374 static inline bool btree_iter_pos_cmp_packed(const struct btree *b,
376 const struct bkey_packed *k,
377 bool strictly_greater)
379 int cmp = bkey_cmp_left_packed(b, k, pos);
382 (cmp == 0 && !strictly_greater && !bkey_deleted(k));
385 static inline bool btree_iter_pos_cmp_p_or_unp(const struct btree *b,
387 const struct bkey_packed *pos_packed,
388 const struct bkey_packed *k,
389 bool strictly_greater)
391 int cmp = bkey_cmp_p_or_unp(b, k, pos_packed, &pos);
394 (cmp == 0 && !strictly_greater && !bkey_deleted(k));
397 struct bset_tree *bch2_bkey_to_bset(struct btree *, struct bkey_packed *);
398 struct bkey_packed *bch2_bkey_prev_all(struct btree *, struct bset_tree *,
399 struct bkey_packed *);
400 struct bkey_packed *bch2_bkey_prev(struct btree *, struct bset_tree *,
401 struct bkey_packed *);
403 enum bch_extent_overlap {
404 BCH_EXTENT_OVERLAP_ALL = 0,
405 BCH_EXTENT_OVERLAP_BACK = 1,
406 BCH_EXTENT_OVERLAP_FRONT = 2,
407 BCH_EXTENT_OVERLAP_MIDDLE = 3,
410 /* Returns how k overlaps with m */
411 static inline enum bch_extent_overlap bch2_extent_overlap(const struct bkey *k,
412 const struct bkey *m)
414 int cmp1 = bkey_cmp(k->p, m->p) < 0;
415 int cmp2 = bkey_cmp(bkey_start_pos(k),
416 bkey_start_pos(m)) > 0;
418 return (cmp1 << 1) + cmp2;
421 /* Btree key iteration */
423 struct btree_node_iter {
426 struct btree_node_iter_set {
431 static inline void __bch2_btree_node_iter_init(struct btree_node_iter *iter,
434 iter->is_extents = is_extents;
435 memset(iter->data, 0, sizeof(iter->data));
438 void bch2_btree_node_iter_push(struct btree_node_iter *, struct btree *,
439 const struct bkey_packed *,
440 const struct bkey_packed *);
441 void bch2_btree_node_iter_init(struct btree_node_iter *, struct btree *,
442 struct bpos, bool, bool);
443 void bch2_btree_node_iter_init_from_start(struct btree_node_iter *,
444 struct btree *, bool);
445 struct bkey_packed *bch2_btree_node_iter_bset_pos(struct btree_node_iter *,
449 void bch2_btree_node_iter_sort(struct btree_node_iter *, struct btree *);
450 void bch2_btree_node_iter_set_drop(struct btree_node_iter *,
451 struct btree_node_iter_set *);
452 void bch2_btree_node_iter_advance(struct btree_node_iter *, struct btree *);
454 #define btree_node_iter_for_each(_iter, _set) \
455 for (_set = (_iter)->data; \
456 _set < (_iter)->data + ARRAY_SIZE((_iter)->data) && \
457 (_set)->k != (_set)->end; \
460 static inline bool __btree_node_iter_set_end(struct btree_node_iter *iter,
463 return iter->data[i].k == iter->data[i].end;
466 static inline bool bch2_btree_node_iter_end(struct btree_node_iter *iter)
468 return __btree_node_iter_set_end(iter, 0);
471 static inline int __btree_node_iter_cmp(bool is_extents,
473 struct bkey_packed *l,
474 struct bkey_packed *r)
477 * For non extents, when keys compare equal the deleted keys have to
478 * come first - so that bch2_btree_node_iter_next_check() can detect
479 * duplicate nondeleted keys (and possibly other reasons?)
481 * For extents, bkey_deleted() is used as a proxy for k->size == 0, so
482 * deleted keys have to sort last.
484 return bkey_cmp_packed(b, l, r) ?: is_extents
485 ? (int) bkey_deleted(l) - (int) bkey_deleted(r)
486 : (int) bkey_deleted(r) - (int) bkey_deleted(l);
489 static inline int btree_node_iter_cmp(struct btree_node_iter *iter,
491 struct btree_node_iter_set l,
492 struct btree_node_iter_set r)
494 return __btree_node_iter_cmp(iter->is_extents, b,
495 __btree_node_offset_to_key(b, l.k),
496 __btree_node_offset_to_key(b, r.k));
499 static inline void __bch2_btree_node_iter_push(struct btree_node_iter *iter,
501 const struct bkey_packed *k,
502 const struct bkey_packed *end)
505 struct btree_node_iter_set *pos;
507 btree_node_iter_for_each(iter, pos)
510 BUG_ON(pos >= iter->data + ARRAY_SIZE(iter->data));
511 *pos = (struct btree_node_iter_set) {
512 __btree_node_key_to_offset(b, k),
513 __btree_node_key_to_offset(b, end)
518 static inline struct bkey_packed *
519 __bch2_btree_node_iter_peek_all(struct btree_node_iter *iter,
522 return __btree_node_offset_to_key(b, iter->data->k);
525 static inline struct bkey_packed *
526 bch2_btree_node_iter_peek_all(struct btree_node_iter *iter,
529 return bch2_btree_node_iter_end(iter)
531 : __bch2_btree_node_iter_peek_all(iter, b);
534 static inline struct bkey_packed *
535 bch2_btree_node_iter_peek(struct btree_node_iter *iter, struct btree *b)
537 struct bkey_packed *ret;
539 while ((ret = bch2_btree_node_iter_peek_all(iter, b)) &&
541 bch2_btree_node_iter_advance(iter, b);
546 static inline struct bkey_packed *
547 bch2_btree_node_iter_next_all(struct btree_node_iter *iter, struct btree *b)
549 struct bkey_packed *ret = bch2_btree_node_iter_peek_all(iter, b);
552 bch2_btree_node_iter_advance(iter, b);
557 struct bkey_packed *bch2_btree_node_iter_prev_all(struct btree_node_iter *,
559 struct bkey_packed *bch2_btree_node_iter_prev(struct btree_node_iter *,
563 * Iterates over all _live_ keys - skipping deleted (and potentially
566 #define for_each_btree_node_key(b, k, iter, _is_extents) \
567 for (bch2_btree_node_iter_init_from_start((iter), (b), (_is_extents));\
568 ((k) = bch2_btree_node_iter_peek(iter, b)); \
569 bch2_btree_node_iter_advance(iter, b))
571 struct bkey_s_c bch2_btree_node_iter_peek_unpack(struct btree_node_iter *,
575 #define for_each_btree_node_key_unpack(b, k, iter, _is_extents, unpacked)\
576 for (bch2_btree_node_iter_init_from_start((iter), (b), (_is_extents));\
577 (k = bch2_btree_node_iter_peek_unpack((iter), (b), (unpacked))).k;\
578 bch2_btree_node_iter_advance(iter, b))
582 static inline void btree_keys_account_key(struct btree_nr_keys *n,
584 struct bkey_packed *k,
587 n->live_u64s += k->u64s * sign;
588 n->bset_u64s[bset] += k->u64s * sign;
591 n->packed_keys += sign;
593 n->unpacked_keys += sign;
596 #define btree_keys_account_key_add(_nr, _bset_idx, _k) \
597 btree_keys_account_key(_nr, _bset_idx, _k, 1)
598 #define btree_keys_account_key_drop(_nr, _bset_idx, _k) \
599 btree_keys_account_key(_nr, _bset_idx, _k, -1)
604 } sets[BSET_TREE_NR_TYPES];
607 size_t failed_unpacked;
609 size_t failed_overflow;
612 void bch2_btree_keys_stats(struct btree *, struct bset_stats *);
613 int bch2_bkey_print_bfloat(struct btree *, struct bkey_packed *,
618 void bch2_dump_bset(struct btree *, struct bset *, unsigned);
619 void bch2_dump_btree_node(struct btree *);
620 void bch2_dump_btree_node_iter(struct btree *, struct btree_node_iter *);
622 #ifdef CONFIG_BCACHEFS_DEBUG
624 void __bch2_verify_btree_nr_keys(struct btree *);
625 void bch2_btree_node_iter_verify(struct btree_node_iter *, struct btree *);
626 void bch2_verify_key_order(struct btree *, struct btree_node_iter *,
627 struct bkey_packed *);
631 static inline void __bch2_verify_btree_nr_keys(struct btree *b) {}
632 static inline void bch2_btree_node_iter_verify(struct btree_node_iter *iter,
634 static inline void bch2_verify_key_order(struct btree *b,
635 struct btree_node_iter *iter,
636 struct bkey_packed *where) {}
639 static inline void bch2_verify_btree_nr_keys(struct btree *b)
641 if (btree_keys_expensive_checks(b))
642 __bch2_verify_btree_nr_keys(b);
645 #endif /* _BCACHEFS_BSET_H */