xref: /linux/fs/bcachefs/snapshot.h (revision 4a4b30ea80d8cb5e8c4c62bb86201f4ea0d9b030)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _BCACHEFS_SNAPSHOT_H
3 #define _BCACHEFS_SNAPSHOT_H
4 
5 void bch2_snapshot_tree_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
6 int bch2_snapshot_tree_validate(struct bch_fs *, struct bkey_s_c,
7 				struct bkey_validate_context);
8 
9 #define bch2_bkey_ops_snapshot_tree ((struct bkey_ops) {	\
10 	.key_validate	= bch2_snapshot_tree_validate,		\
11 	.val_to_text	= bch2_snapshot_tree_to_text,		\
12 	.min_val_size	= 8,					\
13 })
14 
15 struct bkey_i_snapshot_tree *__bch2_snapshot_tree_create(struct btree_trans *);
16 
17 int bch2_snapshot_tree_lookup(struct btree_trans *, u32, struct bch_snapshot_tree *);
18 
19 void bch2_snapshot_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
20 int bch2_snapshot_validate(struct bch_fs *, struct bkey_s_c,
21 			   struct bkey_validate_context);
22 int bch2_mark_snapshot(struct btree_trans *, enum btree_id, unsigned,
23 		       struct bkey_s_c, struct bkey_s,
24 		       enum btree_iter_update_trigger_flags);
25 
26 #define bch2_bkey_ops_snapshot ((struct bkey_ops) {		\
27 	.key_validate	= bch2_snapshot_validate,		\
28 	.val_to_text	= bch2_snapshot_to_text,		\
29 	.trigger	= bch2_mark_snapshot,			\
30 	.min_val_size	= 24,					\
31 })
32 
__snapshot_t(struct snapshot_table * t,u32 id)33 static inline struct snapshot_t *__snapshot_t(struct snapshot_table *t, u32 id)
34 {
35 	u32 idx = U32_MAX - id;
36 
37 	return likely(t && idx < t->nr)
38 		? &t->s[idx]
39 		: NULL;
40 }
41 
snapshot_t(struct bch_fs * c,u32 id)42 static inline const struct snapshot_t *snapshot_t(struct bch_fs *c, u32 id)
43 {
44 	return __snapshot_t(rcu_dereference(c->snapshots), id);
45 }
46 
bch2_snapshot_tree(struct bch_fs * c,u32 id)47 static inline u32 bch2_snapshot_tree(struct bch_fs *c, u32 id)
48 {
49 	rcu_read_lock();
50 	const struct snapshot_t *s = snapshot_t(c, id);
51 	id = s ? s->tree : 0;
52 	rcu_read_unlock();
53 
54 	return id;
55 }
56 
__bch2_snapshot_parent_early(struct bch_fs * c,u32 id)57 static inline u32 __bch2_snapshot_parent_early(struct bch_fs *c, u32 id)
58 {
59 	const struct snapshot_t *s = snapshot_t(c, id);
60 	return s ? s->parent : 0;
61 }
62 
bch2_snapshot_parent_early(struct bch_fs * c,u32 id)63 static inline u32 bch2_snapshot_parent_early(struct bch_fs *c, u32 id)
64 {
65 	rcu_read_lock();
66 	id = __bch2_snapshot_parent_early(c, id);
67 	rcu_read_unlock();
68 
69 	return id;
70 }
71 
__bch2_snapshot_parent(struct bch_fs * c,u32 id)72 static inline u32 __bch2_snapshot_parent(struct bch_fs *c, u32 id)
73 {
74 	const struct snapshot_t *s = snapshot_t(c, id);
75 	if (!s)
76 		return 0;
77 
78 	u32 parent = s->parent;
79 	if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG) &&
80 	    parent &&
81 	    s->depth != snapshot_t(c, parent)->depth + 1)
82 		panic("id %u depth=%u parent %u depth=%u\n",
83 		      id, snapshot_t(c, id)->depth,
84 		      parent, snapshot_t(c, parent)->depth);
85 
86 	return parent;
87 }
88 
bch2_snapshot_parent(struct bch_fs * c,u32 id)89 static inline u32 bch2_snapshot_parent(struct bch_fs *c, u32 id)
90 {
91 	rcu_read_lock();
92 	id = __bch2_snapshot_parent(c, id);
93 	rcu_read_unlock();
94 
95 	return id;
96 }
97 
bch2_snapshot_nth_parent(struct bch_fs * c,u32 id,u32 n)98 static inline u32 bch2_snapshot_nth_parent(struct bch_fs *c, u32 id, u32 n)
99 {
100 	rcu_read_lock();
101 	while (n--)
102 		id = __bch2_snapshot_parent(c, id);
103 	rcu_read_unlock();
104 
105 	return id;
106 }
107 
108 u32 bch2_snapshot_tree_oldest_subvol(struct bch_fs *, u32);
109 u32 bch2_snapshot_skiplist_get(struct bch_fs *, u32);
110 
bch2_snapshot_root(struct bch_fs * c,u32 id)111 static 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 
__bch2_snapshot_exists(struct bch_fs * c,u32 id)123 static inline bool __bch2_snapshot_exists(struct bch_fs *c, u32 id)
124 {
125 	const struct snapshot_t *s = snapshot_t(c, id);
126 	return s ? s->live : 0;
127 }
128 
bch2_snapshot_exists(struct bch_fs * c,u32 id)129 static inline bool bch2_snapshot_exists(struct bch_fs *c, u32 id)
130 {
131 	rcu_read_lock();
132 	bool ret = __bch2_snapshot_exists(c, id);
133 	rcu_read_unlock();
134 
135 	return ret;
136 }
137 
bch2_snapshot_is_internal_node(struct bch_fs * c,u32 id)138 static 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 
bch2_snapshot_is_leaf(struct bch_fs * c,u32 id)148 static 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 
bch2_snapshot_depth(struct bch_fs * c,u32 parent)156 static 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 
167 bool __bch2_snapshot_is_ancestor(struct bch_fs *, u32, u32);
168 
bch2_snapshot_is_ancestor(struct bch_fs * c,u32 id,u32 ancestor)169 static inline bool bch2_snapshot_is_ancestor(struct bch_fs *c, u32 id, u32 ancestor)
170 {
171 	return id == ancestor
172 		? true
173 		: __bch2_snapshot_is_ancestor(c, id, ancestor);
174 }
175 
bch2_snapshot_has_children(struct bch_fs * c,u32 id)176 static 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 
snapshot_list_has_id(snapshot_id_list * s,u32 id)186 static 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 
snapshot_list_has_ancestor(struct bch_fs * c,snapshot_id_list * s,u32 id)194 static 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 
snapshot_list_add(struct bch_fs * c,snapshot_id_list * s,u32 id)202 static 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 
snapshot_list_add_nodup(struct bch_fs * c,snapshot_id_list * s,u32 id)211 static 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 		? 0
215 		: 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 
snapshot_list_merge(struct bch_fs * c,snapshot_id_list * dst,snapshot_id_list * src)221 static 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 
232 int bch2_snapshot_lookup(struct btree_trans *trans, u32 id,
233 			 struct bch_snapshot *s);
234 int bch2_snapshot_get_subvol(struct btree_trans *, u32,
235 			     struct bch_subvolume *);
236 
237 /* only exported for tests: */
238 int bch2_snapshot_node_create(struct btree_trans *, u32,
239 			      u32 *, u32 *, unsigned);
240 
241 int bch2_check_snapshot_trees(struct bch_fs *);
242 int bch2_check_snapshots(struct bch_fs *);
243 int bch2_reconstruct_snapshots(struct bch_fs *);
244 int bch2_check_key_has_snapshot(struct btree_trans *, struct btree_iter *, struct bkey_s_c);
245 
246 int bch2_snapshot_node_set_deleted(struct btree_trans *, u32);
247 void bch2_delete_dead_snapshots_work(struct work_struct *);
248 
249 int __bch2_key_has_snapshot_overwrites(struct btree_trans *, enum btree_id, struct bpos);
250 
bch2_key_has_snapshot_overwrites(struct btree_trans * trans,enum btree_id id,struct bpos pos)251 static 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 
262 int bch2_snapshots_read(struct bch_fs *);
263 void bch2_fs_snapshots_exit(struct bch_fs *);
264 
265 #endif /* _BCACHEFS_SNAPSHOT_H */
266