266 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2#ifndef _BCACHEFS_SNAPSHOT_H3#define _BCACHEFS_SNAPSHOT_H4 5enum bch_validate_flags;6 7void bch2_snapshot_tree_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);8int bch2_snapshot_tree_validate(struct bch_fs *, struct bkey_s_c,9 enum bch_validate_flags);10 11#define bch2_bkey_ops_snapshot_tree ((struct bkey_ops) { \12 .key_validate = bch2_snapshot_tree_validate, \13 .val_to_text = bch2_snapshot_tree_to_text, \14 .min_val_size = 8, \15})16 17struct bkey_i_snapshot_tree *__bch2_snapshot_tree_create(struct btree_trans *);18 19int bch2_snapshot_tree_lookup(struct btree_trans *, u32, struct bch_snapshot_tree *);20 21void bch2_snapshot_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);22int bch2_snapshot_validate(struct bch_fs *, struct bkey_s_c, enum bch_validate_flags);23int bch2_mark_snapshot(struct btree_trans *, enum btree_id, unsigned,24 struct bkey_s_c, struct bkey_s,25 enum btree_iter_update_trigger_flags);26 27#define bch2_bkey_ops_snapshot ((struct bkey_ops) { \28 .key_validate = bch2_snapshot_validate, \29 .val_to_text = bch2_snapshot_to_text, \30 .trigger = bch2_mark_snapshot, \31 .min_val_size = 24, \32})33 34static inline struct snapshot_t *__snapshot_t(struct snapshot_table *t, u32 id)35{36 u32 idx = U32_MAX - id;37 38 return likely(t && idx < t->nr)39 ? &t->s[idx]40 : NULL;41}42 43static inline const struct snapshot_t *snapshot_t(struct bch_fs *c, u32 id)44{45 return __snapshot_t(rcu_dereference(c->snapshots), id);46}47 48static inline u32 bch2_snapshot_tree(struct bch_fs *c, u32 id)49{50 rcu_read_lock();51 const struct snapshot_t *s = snapshot_t(c, id);52 id = s ? s->tree : 0;53 rcu_read_unlock();54 55 return id;56}57 58static inline u32 __bch2_snapshot_parent_early(struct bch_fs *c, u32 id)59{60 const struct snapshot_t *s = snapshot_t(c, id);61 return s ? s->parent : 0;62}63 64static inline u32 bch2_snapshot_parent_early(struct bch_fs *c, u32 id)65{66 rcu_read_lock();67 id = __bch2_snapshot_parent_early(c, id);68 rcu_read_unlock();69 70 return id;71}72 73static inline u32 __bch2_snapshot_parent(struct bch_fs *c, u32 id)74{75 const struct snapshot_t *s = snapshot_t(c, id);76 if (!s)77 return 0;78 79 u32 parent = s->parent;80 if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG) &&81 parent &&82 s->depth != snapshot_t(c, parent)->depth + 1)83 panic("id %u depth=%u parent %u depth=%u\n",84 id, snapshot_t(c, id)->depth,85 parent, snapshot_t(c, parent)->depth);86 87 return parent;88}89 90static inline u32 bch2_snapshot_parent(struct bch_fs *c, u32 id)91{92 rcu_read_lock();93 id = __bch2_snapshot_parent(c, id);94 rcu_read_unlock();95 96 return id;97}98 99static inline u32 bch2_snapshot_nth_parent(struct bch_fs *c, u32 id, u32 n)100{101 rcu_read_lock();102 while (n--)103 id = __bch2_snapshot_parent(c, id);104 rcu_read_unlock();105 106 return id;107}108 109u32 bch2_snapshot_skiplist_get(struct bch_fs *, u32);110 111static inline u32 bch2_snapshot_root(struct bch_fs *c, u32 id)112{113 u32 parent;114 115 rcu_read_lock();116 while ((parent = __bch2_snapshot_parent(c, id)))117 id = parent;118 rcu_read_unlock();119 120 return id;121}122 123static inline u32 __bch2_snapshot_equiv(struct bch_fs *c, u32 id)124{125 const struct snapshot_t *s = snapshot_t(c, id);126 return s ? s->equiv : 0;127}128 129static inline u32 bch2_snapshot_equiv(struct bch_fs *c, u32 id)130{131 rcu_read_lock();132 id = __bch2_snapshot_equiv(c, id);133 rcu_read_unlock();134 135 return id;136}137 138static inline int bch2_snapshot_is_internal_node(struct bch_fs *c, u32 id)139{140 rcu_read_lock();141 const struct snapshot_t *s = snapshot_t(c, id);142 int ret = s ? s->children[0] : -BCH_ERR_invalid_snapshot_node;143 rcu_read_unlock();144 145 return ret;146}147 148static inline int bch2_snapshot_is_leaf(struct bch_fs *c, u32 id)149{150 int ret = bch2_snapshot_is_internal_node(c, id);151 if (ret < 0)152 return ret;153 return !ret;154}155 156static inline u32 bch2_snapshot_depth(struct bch_fs *c, u32 parent)157{158 u32 depth;159 160 rcu_read_lock();161 depth = parent ? snapshot_t(c, parent)->depth + 1 : 0;162 rcu_read_unlock();163 164 return depth;165}166 167bool __bch2_snapshot_is_ancestor(struct bch_fs *, u32, u32);168 169static inline bool bch2_snapshot_is_ancestor(struct bch_fs *c, u32 id, u32 ancestor)170{171 return id == ancestor172 ? true173 : __bch2_snapshot_is_ancestor(c, id, ancestor);174}175 176static inline bool bch2_snapshot_has_children(struct bch_fs *c, u32 id)177{178 rcu_read_lock();179 const struct snapshot_t *t = snapshot_t(c, id);180 bool ret = t && (t->children[0]|t->children[1]) != 0;181 rcu_read_unlock();182 183 return ret;184}185 186static inline bool snapshot_list_has_id(snapshot_id_list *s, u32 id)187{188 darray_for_each(*s, i)189 if (*i == id)190 return true;191 return false;192}193 194static inline bool snapshot_list_has_ancestor(struct bch_fs *c, snapshot_id_list *s, u32 id)195{196 darray_for_each(*s, i)197 if (bch2_snapshot_is_ancestor(c, id, *i))198 return true;199 return false;200}201 202static inline int snapshot_list_add(struct bch_fs *c, snapshot_id_list *s, u32 id)203{204 BUG_ON(snapshot_list_has_id(s, id));205 int ret = darray_push(s, id);206 if (ret)207 bch_err(c, "error reallocating snapshot_id_list (size %zu)", s->size);208 return ret;209}210 211static inline int snapshot_list_add_nodup(struct bch_fs *c, snapshot_id_list *s, u32 id)212{213 int ret = snapshot_list_has_id(s, id)214 ? 0215 : darray_push(s, id);216 if (ret)217 bch_err(c, "error reallocating snapshot_id_list (size %zu)", s->size);218 return ret;219}220 221static inline int snapshot_list_merge(struct bch_fs *c, snapshot_id_list *dst, snapshot_id_list *src)222{223 darray_for_each(*src, i) {224 int ret = snapshot_list_add_nodup(c, dst, *i);225 if (ret)226 return ret;227 }228 229 return 0;230}231 232int bch2_snapshot_lookup(struct btree_trans *trans, u32 id,233 struct bch_snapshot *s);234int bch2_snapshot_get_subvol(struct btree_trans *, u32,235 struct bch_subvolume *);236 237/* only exported for tests: */238int bch2_snapshot_node_create(struct btree_trans *, u32,239 u32 *, u32 *, unsigned);240 241int bch2_check_snapshot_trees(struct bch_fs *);242int bch2_check_snapshots(struct bch_fs *);243int bch2_reconstruct_snapshots(struct bch_fs *);244int bch2_check_key_has_snapshot(struct btree_trans *, struct btree_iter *, struct bkey_s_c);245 246int bch2_snapshot_node_set_deleted(struct btree_trans *, u32);247void bch2_delete_dead_snapshots_work(struct work_struct *);248 249int __bch2_key_has_snapshot_overwrites(struct btree_trans *, enum btree_id, struct bpos);250 251static inline int bch2_key_has_snapshot_overwrites(struct btree_trans *trans,252 enum btree_id id,253 struct bpos pos)254{255 if (!btree_type_has_snapshots(id) ||256 bch2_snapshot_is_leaf(trans->c, pos.snapshot) > 0)257 return 0;258 259 return __bch2_key_has_snapshot_overwrites(trans, id, pos);260}261 262int bch2_snapshots_read(struct bch_fs *);263void bch2_fs_snapshots_exit(struct bch_fs *);264 265#endif /* _BCACHEFS_SNAPSHOT_H */266