Commit | Line | Data |
---|---|---|
9888c340 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
56bec294 CM |
2 | /* |
3 | * Copyright (C) 2008 Oracle. All rights reserved. | |
56bec294 | 4 | */ |
9888c340 DS |
5 | |
6 | #ifndef BTRFS_DELAYED_REF_H | |
7 | #define BTRFS_DELAYED_REF_H | |
56bec294 | 8 | |
6df8cdf5 ER |
9 | #include <linux/refcount.h> |
10 | ||
44a075bd | 11 | /* these are the possible values of struct btrfs_delayed_ref_node->action */ |
56bec294 CM |
12 | #define BTRFS_ADD_DELAYED_REF 1 /* add one backref to the tree */ |
13 | #define BTRFS_DROP_DELAYED_REF 2 /* delete one backref from the tree */ | |
14 | #define BTRFS_ADD_DELAYED_EXTENT 3 /* record a full extent allocation */ | |
1a81af4d | 15 | #define BTRFS_UPDATE_DELAYED_HEAD 4 /* not changing ref count on head ref */ |
56bec294 CM |
16 | |
17 | struct btrfs_delayed_ref_node { | |
0e0adbcf | 18 | struct rb_node ref_node; |
1d57ee94 WX |
19 | /* |
20 | * If action is BTRFS_ADD_DELAYED_REF, also link this node to | |
21 | * ref_head->ref_add_list, then we do not need to iterate the | |
22 | * whole ref_head->ref_list to find BTRFS_ADD_DELAYED_REF nodes. | |
23 | */ | |
24 | struct list_head add_list; | |
c6fc2454 | 25 | |
56bec294 CM |
26 | /* the starting bytenr of the extent */ |
27 | u64 bytenr; | |
28 | ||
56bec294 CM |
29 | /* the size of the extent */ |
30 | u64 num_bytes; | |
31 | ||
00f04b88 AJ |
32 | /* seq number to keep track of insertion order */ |
33 | u64 seq; | |
34 | ||
56bec294 | 35 | /* ref count on this data structure */ |
6df8cdf5 | 36 | refcount_t refs; |
56bec294 CM |
37 | |
38 | /* | |
39 | * how many refs is this entry adding or deleting. For | |
40 | * head refs, this may be a negative number because it is keeping | |
41 | * track of the total mods done to the reference count. | |
42 | * For individual refs, this will always be a positive number | |
43 | * | |
44 | * It may be more than one, since it is possible for a single | |
45 | * parent to have more than one ref on an extent | |
46 | */ | |
47 | int ref_mod; | |
48 | ||
5d4f98a2 YZ |
49 | unsigned int action:8; |
50 | unsigned int type:8; | |
56bec294 | 51 | /* is this node still in the rbtree? */ |
5d4f98a2 | 52 | unsigned int is_head:1; |
56bec294 CM |
53 | unsigned int in_tree:1; |
54 | }; | |
55 | ||
5d4f98a2 YZ |
56 | struct btrfs_delayed_extent_op { |
57 | struct btrfs_disk_key key; | |
35b3ad50 DS |
58 | u8 level; |
59 | bool update_key; | |
60 | bool update_flags; | |
61 | bool is_data; | |
5d4f98a2 | 62 | u64 flags_to_set; |
5d4f98a2 YZ |
63 | }; |
64 | ||
56bec294 CM |
65 | /* |
66 | * the head refs are used to hold a lock on a given extent, which allows us | |
67 | * to make sure that only one process is running the delayed refs | |
68 | * at a time for a single extent. They also store the sum of all the | |
69 | * reference count modifications we've queued up. | |
70 | */ | |
71 | struct btrfs_delayed_ref_head { | |
d278850e JB |
72 | u64 bytenr; |
73 | u64 num_bytes; | |
74 | refcount_t refs; | |
56bec294 CM |
75 | /* |
76 | * the mutex is held while running the refs, and it is also | |
77 | * held when checking the sum of reference modifications. | |
78 | */ | |
79 | struct mutex mutex; | |
80 | ||
d7df2c79 | 81 | spinlock_t lock; |
e3d03965 | 82 | struct rb_root_cached ref_tree; |
1d57ee94 WX |
83 | /* accumulate add BTRFS_ADD_DELAYED_REF nodes to this ref_add_list. */ |
84 | struct list_head ref_add_list; | |
c3e69d58 | 85 | |
c46effa6 LB |
86 | struct rb_node href_node; |
87 | ||
5d4f98a2 | 88 | struct btrfs_delayed_extent_op *extent_op; |
1262133b JB |
89 | |
90 | /* | |
91 | * This is used to track the final ref_mod from all the refs associated | |
92 | * with this head ref, this is not adjusted as delayed refs are run, | |
93 | * this is meant to track if we need to do the csum accounting or not. | |
94 | */ | |
95 | int total_ref_mod; | |
96 | ||
d278850e JB |
97 | /* |
98 | * This is the current outstanding mod references for this bytenr. This | |
99 | * is used with lookup_extent_info to get an accurate reference count | |
100 | * for a bytenr, so it is adjusted as delayed refs are run so that any | |
101 | * on disk reference count + ref_mod is accurate. | |
102 | */ | |
103 | int ref_mod; | |
104 | ||
56bec294 CM |
105 | /* |
106 | * when a new extent is allocated, it is just reserved in memory | |
107 | * The actual extent isn't inserted into the extent allocation tree | |
108 | * until the delayed ref is processed. must_insert_reserved is | |
109 | * used to flag a delayed ref so the accounting can be updated | |
110 | * when a full insert is done. | |
111 | * | |
112 | * It is possible the extent will be freed before it is ever | |
113 | * inserted into the extent allocation tree. In this case | |
114 | * we need to update the in ram accounting to properly reflect | |
115 | * the free has happened. | |
116 | */ | |
117 | unsigned int must_insert_reserved:1; | |
5d4f98a2 | 118 | unsigned int is_data:1; |
5e388e95 | 119 | unsigned int is_system:1; |
d7df2c79 | 120 | unsigned int processing:1; |
56bec294 CM |
121 | }; |
122 | ||
5d4f98a2 | 123 | struct btrfs_delayed_tree_ref { |
56bec294 | 124 | struct btrfs_delayed_ref_node node; |
eebe063b AJ |
125 | u64 root; |
126 | u64 parent; | |
5d4f98a2 YZ |
127 | int level; |
128 | }; | |
56bec294 | 129 | |
5d4f98a2 YZ |
130 | struct btrfs_delayed_data_ref { |
131 | struct btrfs_delayed_ref_node node; | |
eebe063b AJ |
132 | u64 root; |
133 | u64 parent; | |
5d4f98a2 YZ |
134 | u64 objectid; |
135 | u64 offset; | |
56bec294 CM |
136 | }; |
137 | ||
e19eb11f JB |
138 | enum btrfs_delayed_ref_flags { |
139 | /* Indicate that we are flushing delayed refs for the commit */ | |
140 | BTRFS_DELAYED_REFS_FLUSHING, | |
141 | }; | |
142 | ||
56bec294 | 143 | struct btrfs_delayed_ref_root { |
c46effa6 | 144 | /* head ref rbtree */ |
5c9d028b | 145 | struct rb_root_cached href_root; |
c46effa6 | 146 | |
3368d001 QW |
147 | /* dirty extent records */ |
148 | struct rb_root dirty_extent_root; | |
149 | ||
56bec294 CM |
150 | /* this spin lock protects the rbtree and the entries inside */ |
151 | spinlock_t lock; | |
152 | ||
153 | /* how many delayed ref updates we've queued, used by the | |
154 | * throttling code | |
155 | */ | |
d7df2c79 | 156 | atomic_t num_entries; |
56bec294 | 157 | |
c3e69d58 CM |
158 | /* total number of head nodes in tree */ |
159 | unsigned long num_heads; | |
160 | ||
161 | /* total number of head nodes ready for processing */ | |
162 | unsigned long num_heads_ready; | |
163 | ||
1262133b JB |
164 | u64 pending_csums; |
165 | ||
e19eb11f | 166 | unsigned long flags; |
c3e69d58 CM |
167 | |
168 | u64 run_delayed_start; | |
9086db86 QW |
169 | |
170 | /* | |
171 | * To make qgroup to skip given root. | |
01327610 | 172 | * This is for snapshot, as btrfs_qgroup_inherit() will manually |
9086db86 QW |
173 | * modify counters for snapshot and its source, so we should skip |
174 | * the snapshot in new_root/old_roots or it will get calculated twice | |
175 | */ | |
176 | u64 qgroup_to_skip; | |
56bec294 CM |
177 | }; |
178 | ||
b28b1f0c QW |
179 | enum btrfs_ref_type { |
180 | BTRFS_REF_NOT_SET, | |
181 | BTRFS_REF_DATA, | |
182 | BTRFS_REF_METADATA, | |
183 | BTRFS_REF_LAST, | |
184 | }; | |
185 | ||
186 | struct btrfs_data_ref { | |
187 | /* For EXTENT_DATA_REF */ | |
188 | ||
189 | /* Root which refers to this data extent */ | |
190 | u64 ref_root; | |
191 | ||
192 | /* Inode which refers to this data extent */ | |
193 | u64 ino; | |
194 | ||
195 | /* | |
196 | * file_offset - extent_offset | |
197 | * | |
198 | * file_offset is the key.offset of the EXTENT_DATA key. | |
199 | * extent_offset is btrfs_file_extent_offset() of the EXTENT_DATA data. | |
200 | */ | |
201 | u64 offset; | |
202 | }; | |
203 | ||
204 | struct btrfs_tree_ref { | |
205 | /* | |
206 | * Level of this tree block | |
207 | * | |
208 | * Shared for skinny (TREE_BLOCK_REF) and normal tree ref. | |
209 | */ | |
210 | int level; | |
211 | ||
212 | /* | |
213 | * Root which refers to this tree block. | |
214 | * | |
215 | * For TREE_BLOCK_REF (skinny metadata, either inline or keyed) | |
216 | */ | |
217 | u64 root; | |
218 | ||
219 | /* For non-skinny metadata, no special member needed */ | |
220 | }; | |
221 | ||
222 | struct btrfs_ref { | |
223 | enum btrfs_ref_type type; | |
224 | int action; | |
225 | ||
226 | /* | |
227 | * Whether this extent should go through qgroup record. | |
228 | * | |
229 | * Normally false, but for certain cases like delayed subtree scan, | |
230 | * setting this flag can hugely reduce qgroup overhead. | |
231 | */ | |
232 | bool skip_qgroup; | |
233 | ||
234 | /* | |
235 | * Optional. For which root is this modification. | |
236 | * Mostly used for qgroup optimization. | |
237 | * | |
238 | * When unset, data/tree ref init code will populate it. | |
239 | * In certain cases, we're modifying reference for a different root. | |
240 | * E.g. COW fs tree blocks for balance. | |
241 | * In that case, tree_ref::root will be fs tree, but we're doing this | |
242 | * for reloc tree, then we should set @real_root to reloc tree. | |
243 | */ | |
244 | u64 real_root; | |
245 | u64 bytenr; | |
246 | u64 len; | |
247 | ||
248 | /* Bytenr of the parent tree block */ | |
249 | u64 parent; | |
250 | union { | |
251 | struct btrfs_data_ref data_ref; | |
252 | struct btrfs_tree_ref tree_ref; | |
253 | }; | |
254 | }; | |
255 | ||
78a6184a MX |
256 | extern struct kmem_cache *btrfs_delayed_ref_head_cachep; |
257 | extern struct kmem_cache *btrfs_delayed_tree_ref_cachep; | |
258 | extern struct kmem_cache *btrfs_delayed_data_ref_cachep; | |
259 | extern struct kmem_cache *btrfs_delayed_extent_op_cachep; | |
260 | ||
f5c29bd9 | 261 | int __init btrfs_delayed_ref_init(void); |
e67c718b | 262 | void __cold btrfs_delayed_ref_exit(void); |
78a6184a | 263 | |
b28b1f0c QW |
264 | static inline void btrfs_init_generic_ref(struct btrfs_ref *generic_ref, |
265 | int action, u64 bytenr, u64 len, u64 parent) | |
266 | { | |
267 | generic_ref->action = action; | |
268 | generic_ref->bytenr = bytenr; | |
269 | generic_ref->len = len; | |
270 | generic_ref->parent = parent; | |
271 | } | |
272 | ||
273 | static inline void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, | |
274 | int level, u64 root) | |
275 | { | |
276 | /* If @real_root not set, use @root as fallback */ | |
277 | if (!generic_ref->real_root) | |
278 | generic_ref->real_root = root; | |
279 | generic_ref->tree_ref.level = level; | |
280 | generic_ref->tree_ref.root = root; | |
281 | generic_ref->type = BTRFS_REF_METADATA; | |
282 | } | |
283 | ||
284 | static inline void btrfs_init_data_ref(struct btrfs_ref *generic_ref, | |
285 | u64 ref_root, u64 ino, u64 offset) | |
286 | { | |
287 | /* If @real_root not set, use @root as fallback */ | |
288 | if (!generic_ref->real_root) | |
289 | generic_ref->real_root = ref_root; | |
290 | generic_ref->data_ref.ref_root = ref_root; | |
291 | generic_ref->data_ref.ino = ino; | |
292 | generic_ref->data_ref.offset = offset; | |
293 | generic_ref->type = BTRFS_REF_DATA; | |
294 | } | |
295 | ||
78a6184a MX |
296 | static inline struct btrfs_delayed_extent_op * |
297 | btrfs_alloc_delayed_extent_op(void) | |
298 | { | |
299 | return kmem_cache_alloc(btrfs_delayed_extent_op_cachep, GFP_NOFS); | |
300 | } | |
301 | ||
302 | static inline void | |
303 | btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op *op) | |
304 | { | |
305 | if (op) | |
306 | kmem_cache_free(btrfs_delayed_extent_op_cachep, op); | |
307 | } | |
308 | ||
56bec294 CM |
309 | static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref) |
310 | { | |
6df8cdf5 ER |
311 | WARN_ON(refcount_read(&ref->refs) == 0); |
312 | if (refcount_dec_and_test(&ref->refs)) { | |
56bec294 | 313 | WARN_ON(ref->in_tree); |
78a6184a MX |
314 | switch (ref->type) { |
315 | case BTRFS_TREE_BLOCK_REF_KEY: | |
316 | case BTRFS_SHARED_BLOCK_REF_KEY: | |
317 | kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref); | |
318 | break; | |
319 | case BTRFS_EXTENT_DATA_REF_KEY: | |
320 | case BTRFS_SHARED_DATA_REF_KEY: | |
321 | kmem_cache_free(btrfs_delayed_data_ref_cachep, ref); | |
322 | break; | |
78a6184a MX |
323 | default: |
324 | BUG(); | |
325 | } | |
56bec294 CM |
326 | } |
327 | } | |
328 | ||
2187374f JB |
329 | static inline u64 btrfs_ref_head_to_space_flags( |
330 | struct btrfs_delayed_ref_head *head_ref) | |
331 | { | |
332 | if (head_ref->is_data) | |
333 | return BTRFS_BLOCK_GROUP_DATA; | |
334 | else if (head_ref->is_system) | |
335 | return BTRFS_BLOCK_GROUP_SYSTEM; | |
336 | return BTRFS_BLOCK_GROUP_METADATA; | |
337 | } | |
338 | ||
d278850e JB |
339 | static inline void btrfs_put_delayed_ref_head(struct btrfs_delayed_ref_head *head) |
340 | { | |
341 | if (refcount_dec_and_test(&head->refs)) | |
342 | kmem_cache_free(btrfs_delayed_ref_head_cachep, head); | |
343 | } | |
344 | ||
44e1c47d | 345 | int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, |
ed4f255b | 346 | struct btrfs_ref *generic_ref, |
2187374f | 347 | struct btrfs_delayed_extent_op *extent_op); |
88a979c6 | 348 | int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, |
76675593 | 349 | struct btrfs_ref *generic_ref, |
2187374f | 350 | u64 reserved); |
c6e340bc | 351 | int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, |
5d4f98a2 YZ |
352 | u64 bytenr, u64 num_bytes, |
353 | struct btrfs_delayed_extent_op *extent_op); | |
ae1e206b | 354 | void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans, |
ae1e206b JB |
355 | struct btrfs_delayed_ref_root *delayed_refs, |
356 | struct btrfs_delayed_ref_head *head); | |
56bec294 | 357 | |
1887be66 | 358 | struct btrfs_delayed_ref_head * |
f72ad18e LB |
359 | btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, |
360 | u64 bytenr); | |
9e920a6f | 361 | int btrfs_delayed_ref_lock(struct btrfs_delayed_ref_root *delayed_refs, |
c3e69d58 | 362 | struct btrfs_delayed_ref_head *head); |
093486c4 MX |
363 | static inline void btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head *head) |
364 | { | |
365 | mutex_unlock(&head->mutex); | |
366 | } | |
d7baffda JB |
367 | void btrfs_delete_ref_head(struct btrfs_delayed_ref_root *delayed_refs, |
368 | struct btrfs_delayed_ref_head *head); | |
d7df2c79 | 369 | |
5637c74b LF |
370 | struct btrfs_delayed_ref_head *btrfs_select_ref_head( |
371 | struct btrfs_delayed_ref_root *delayed_refs); | |
00f04b88 | 372 | |
41d0bd3b | 373 | int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq); |
00f04b88 | 374 | |
6ef03deb JB |
375 | void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr); |
376 | void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans); | |
377 | int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info, | |
378 | enum btrfs_reserve_flush_enum flush); | |
379 | void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info, | |
380 | struct btrfs_block_rsv *src, | |
381 | u64 num_bytes); | |
382 | int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans); | |
383 | bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info); | |
384 | ||
56bec294 CM |
385 | /* |
386 | * helper functions to cast a node into its container | |
387 | */ | |
5d4f98a2 YZ |
388 | static inline struct btrfs_delayed_tree_ref * |
389 | btrfs_delayed_node_to_tree_ref(struct btrfs_delayed_ref_node *node) | |
56bec294 | 390 | { |
5d4f98a2 YZ |
391 | return container_of(node, struct btrfs_delayed_tree_ref, node); |
392 | } | |
56bec294 | 393 | |
5d4f98a2 YZ |
394 | static inline struct btrfs_delayed_data_ref * |
395 | btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node) | |
396 | { | |
5d4f98a2 | 397 | return container_of(node, struct btrfs_delayed_data_ref, node); |
56bec294 | 398 | } |
9888c340 | 399 | |
56bec294 | 400 | #endif |