215 lines · c
1// SPDX-License-Identifier: GPL-2.02#include "bcachefs.h"3#include "bkey_buf.h"4#include "bkey_cmp.h"5#include "bkey_sort.h"6#include "bset.h"7#include "extents.h"8 9typedef int (*sort_cmp_fn)(const struct btree *,10 const struct bkey_packed *,11 const struct bkey_packed *);12 13static inline bool sort_iter_end(struct sort_iter *iter)14{15 return !iter->used;16}17 18static inline void sort_iter_sift(struct sort_iter *iter, unsigned from,19 sort_cmp_fn cmp)20{21 unsigned i;22 23 for (i = from;24 i + 1 < iter->used &&25 cmp(iter->b, iter->data[i].k, iter->data[i + 1].k) > 0;26 i++)27 swap(iter->data[i], iter->data[i + 1]);28}29 30static inline void sort_iter_sort(struct sort_iter *iter, sort_cmp_fn cmp)31{32 unsigned i = iter->used;33 34 while (i--)35 sort_iter_sift(iter, i, cmp);36}37 38static inline struct bkey_packed *sort_iter_peek(struct sort_iter *iter)39{40 return !sort_iter_end(iter) ? iter->data->k : NULL;41}42 43static inline void sort_iter_advance(struct sort_iter *iter, sort_cmp_fn cmp)44{45 struct sort_iter_set *i = iter->data;46 47 BUG_ON(!iter->used);48 49 i->k = bkey_p_next(i->k);50 51 BUG_ON(i->k > i->end);52 53 if (i->k == i->end)54 array_remove_item(iter->data, iter->used, 0);55 else56 sort_iter_sift(iter, 0, cmp);57}58 59static inline struct bkey_packed *sort_iter_next(struct sort_iter *iter,60 sort_cmp_fn cmp)61{62 struct bkey_packed *ret = sort_iter_peek(iter);63 64 if (ret)65 sort_iter_advance(iter, cmp);66 67 return ret;68}69 70/*71 * If keys compare equal, compare by pointer order:72 */73static inline int key_sort_fix_overlapping_cmp(const struct btree *b,74 const struct bkey_packed *l,75 const struct bkey_packed *r)76{77 return bch2_bkey_cmp_packed(b, l, r) ?:78 cmp_int((unsigned long) l, (unsigned long) r);79}80 81static inline bool should_drop_next_key(struct sort_iter *iter)82{83 /*84 * key_sort_cmp() ensures that when keys compare equal the older key85 * comes first; so if l->k compares equal to r->k then l->k is older86 * and should be dropped.87 */88 return iter->used >= 2 &&89 !bch2_bkey_cmp_packed(iter->b,90 iter->data[0].k,91 iter->data[1].k);92}93 94struct btree_nr_keys95bch2_key_sort_fix_overlapping(struct bch_fs *c, struct bset *dst,96 struct sort_iter *iter)97{98 struct bkey_packed *out = dst->start;99 struct bkey_packed *k;100 struct btree_nr_keys nr;101 102 memset(&nr, 0, sizeof(nr));103 104 sort_iter_sort(iter, key_sort_fix_overlapping_cmp);105 106 while ((k = sort_iter_peek(iter))) {107 if (!bkey_deleted(k) &&108 !should_drop_next_key(iter)) {109 bkey_p_copy(out, k);110 btree_keys_account_key_add(&nr, 0, out);111 out = bkey_p_next(out);112 }113 114 sort_iter_advance(iter, key_sort_fix_overlapping_cmp);115 }116 117 dst->u64s = cpu_to_le16((u64 *) out - dst->_data);118 return nr;119}120 121/* Sort + repack in a new format: */122struct btree_nr_keys123bch2_sort_repack(struct bset *dst, struct btree *src,124 struct btree_node_iter *src_iter,125 struct bkey_format *out_f,126 bool filter_whiteouts)127{128 struct bkey_format *in_f = &src->format;129 struct bkey_packed *in, *out = vstruct_last(dst);130 struct btree_nr_keys nr;131 bool transform = memcmp(out_f, &src->format, sizeof(*out_f));132 133 memset(&nr, 0, sizeof(nr));134 135 while ((in = bch2_btree_node_iter_next_all(src_iter, src))) {136 if (filter_whiteouts && bkey_deleted(in))137 continue;138 139 if (!transform)140 bkey_p_copy(out, in);141 else if (bch2_bkey_transform(out_f, out, bkey_packed(in)142 ? in_f : &bch2_bkey_format_current, in))143 out->format = KEY_FORMAT_LOCAL_BTREE;144 else145 bch2_bkey_unpack(src, (void *) out, in);146 147 out->needs_whiteout = false;148 149 btree_keys_account_key_add(&nr, 0, out);150 out = bkey_p_next(out);151 }152 153 dst->u64s = cpu_to_le16((u64 *) out - dst->_data);154 return nr;155}156 157static inline int keep_unwritten_whiteouts_cmp(const struct btree *b,158 const struct bkey_packed *l,159 const struct bkey_packed *r)160{161 return bch2_bkey_cmp_packed_inlined(b, l, r) ?:162 (int) bkey_deleted(r) - (int) bkey_deleted(l) ?:163 (long) l - (long) r;164}165 166#include "btree_update_interior.h"167 168/*169 * For sorting in the btree node write path: whiteouts not in the unwritten170 * whiteouts area are dropped, whiteouts in the unwritten whiteouts area are171 * dropped if overwritten by real keys:172 */173unsigned bch2_sort_keys_keep_unwritten_whiteouts(struct bkey_packed *dst, struct sort_iter *iter)174{175 struct bkey_packed *in, *next, *out = dst;176 177 sort_iter_sort(iter, keep_unwritten_whiteouts_cmp);178 179 while ((in = sort_iter_next(iter, keep_unwritten_whiteouts_cmp))) {180 if (bkey_deleted(in) && in < unwritten_whiteouts_start(iter->b))181 continue;182 183 if ((next = sort_iter_peek(iter)) &&184 !bch2_bkey_cmp_packed_inlined(iter->b, in, next))185 continue;186 187 bkey_p_copy(out, in);188 out = bkey_p_next(out);189 }190 191 return (u64 *) out - (u64 *) dst;192}193 194/*195 * Main sort routine for compacting a btree node in memory: we always drop196 * whiteouts because any whiteouts that need to be written are in the unwritten197 * whiteouts area:198 */199unsigned bch2_sort_keys(struct bkey_packed *dst, struct sort_iter *iter)200{201 struct bkey_packed *in, *out = dst;202 203 sort_iter_sort(iter, bch2_bkey_cmp_packed_inlined);204 205 while ((in = sort_iter_next(iter, bch2_bkey_cmp_packed_inlined))) {206 if (bkey_deleted(in))207 continue;208 209 bkey_p_copy(out, in);210 out = bkey_p_next(out);211 }212 213 return (u64 *) out - (u64 *) dst;214}215