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.pos, 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(b->c.btree_id, b->key.k.p, 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(pos, 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(&c->kick_gc); 110 if (c->gc_thread) 111 wake_up_process(c->gc_thread); 112 } 113 114 #endif /* _BCACHEFS_BTREE_GC_H */ 115