1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _BCACHEFS_BTREE_GC_H |
3 | #define _BCACHEFS_BTREE_GC_H |
4 | |
5 | #include "bkey.h" |
6 | #include "btree_types.h" |
7 | |
8 | int bch2_check_topology(struct bch_fs *); |
9 | int bch2_gc(struct bch_fs *, bool, bool); |
10 | int bch2_gc_gens(struct bch_fs *); |
11 | void bch2_gc_thread_stop(struct bch_fs *); |
12 | int bch2_gc_thread_start(struct bch_fs *); |
13 | |
14 | /* |
15 | * For concurrent mark and sweep (with other index updates), we define a total |
16 | * ordering of _all_ references GC walks: |
17 | * |
18 | * Note that some references will have the same GC position as others - e.g. |
19 | * everything within the same btree node; in those cases we're relying on |
20 | * whatever locking exists for where those references live, i.e. the write lock |
21 | * on a btree node. |
22 | * |
23 | * That locking is also required to ensure GC doesn't pass the updater in |
24 | * between the updater adding/removing the reference and updating the GC marks; |
25 | * without that, we would at best double count sometimes. |
26 | * |
27 | * That part is important - whenever calling bch2_mark_pointers(), a lock _must_ |
28 | * be held that prevents GC from passing the position the updater is at. |
29 | * |
30 | * (What about the start of gc, when we're clearing all the marks? GC clears the |
31 | * mark with the gc pos seqlock held, and bch_mark_bucket checks against the gc |
32 | * position inside its cmpxchg loop, so crap magically works). |
33 | */ |
34 | |
35 | /* Position of (the start of) a gc phase: */ |
36 | static inline struct gc_pos gc_phase(enum gc_phase phase) |
37 | { |
38 | return (struct gc_pos) { |
39 | .phase = phase, |
40 | .pos = POS_MIN, |
41 | .level = 0, |
42 | }; |
43 | } |
44 | |
45 | static inline int gc_pos_cmp(struct gc_pos l, struct gc_pos r) |
46 | { |
47 | return cmp_int(l.phase, r.phase) ?: |
48 | bpos_cmp(l: l.pos, r: r.pos) ?: |
49 | cmp_int(l.level, r.level); |
50 | } |
51 | |
52 | static inline enum gc_phase btree_id_to_gc_phase(enum btree_id id) |
53 | { |
54 | switch (id) { |
55 | #define x(name, v, ...) case BTREE_ID_##name: return GC_PHASE_BTREE_##name; |
56 | BCH_BTREE_IDS() |
57 | #undef x |
58 | default: |
59 | BUG(); |
60 | } |
61 | } |
62 | |
63 | static inline struct gc_pos gc_pos_btree(enum btree_id id, |
64 | struct bpos pos, unsigned level) |
65 | { |
66 | return (struct gc_pos) { |
67 | .phase = btree_id_to_gc_phase(id), |
68 | .pos = pos, |
69 | .level = level, |
70 | }; |
71 | } |
72 | |
73 | /* |
74 | * GC position of the pointers within a btree node: note, _not_ for &b->key |
75 | * itself, that lives in the parent node: |
76 | */ |
77 | static inline struct gc_pos gc_pos_btree_node(struct btree *b) |
78 | { |
79 | return gc_pos_btree(id: b->c.btree_id, pos: b->key.k.p, level: b->c.level); |
80 | } |
81 | |
82 | /* |
83 | * GC position of the pointer to a btree root: we don't use |
84 | * gc_pos_pointer_to_btree_node() here to avoid a potential race with |
85 | * btree_split() increasing the tree depth - the new root will have level > the |
86 | * old root and thus have a greater gc position than the old root, but that |
87 | * would be incorrect since once gc has marked the root it's not coming back. |
88 | */ |
89 | static inline struct gc_pos gc_pos_btree_root(enum btree_id id) |
90 | { |
91 | return gc_pos_btree(id, SPOS_MAX, BTREE_MAX_DEPTH); |
92 | } |
93 | |
94 | static inline bool gc_visited(struct bch_fs *c, struct gc_pos pos) |
95 | { |
96 | unsigned seq; |
97 | bool ret; |
98 | |
99 | do { |
100 | seq = read_seqcount_begin(&c->gc_pos_lock); |
101 | ret = gc_pos_cmp(l: pos, r: c->gc_pos) <= 0; |
102 | } while (read_seqcount_retry(&c->gc_pos_lock, seq)); |
103 | |
104 | return ret; |
105 | } |
106 | |
107 | static inline void bch2_do_gc_gens(struct bch_fs *c) |
108 | { |
109 | atomic_inc(v: &c->kick_gc); |
110 | if (c->gc_thread) |
111 | wake_up_process(tsk: c->gc_thread); |
112 | } |
113 | |
114 | #endif /* _BCACHEFS_BTREE_GC_H */ |
115 | |