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; | |
5d4f98a2 | 61 | u64 flags_to_set; |
5d4f98a2 YZ |
62 | }; |
63 | ||
56bec294 CM |
64 | /* |
65 | * the head refs are used to hold a lock on a given extent, which allows us | |
66 | * to make sure that only one process is running the delayed refs | |
67 | * at a time for a single extent. They also store the sum of all the | |
68 | * reference count modifications we've queued up. | |
69 | */ | |
70 | struct btrfs_delayed_ref_head { | |
d278850e JB |
71 | u64 bytenr; |
72 | u64 num_bytes; | |
73 | refcount_t refs; | |
56bec294 CM |
74 | /* |
75 | * the mutex is held while running the refs, and it is also | |
76 | * held when checking the sum of reference modifications. | |
77 | */ | |
78 | struct mutex mutex; | |
79 | ||
d7df2c79 | 80 | spinlock_t lock; |
e3d03965 | 81 | struct rb_root_cached ref_tree; |
1d57ee94 WX |
82 | /* accumulate add BTRFS_ADD_DELAYED_REF nodes to this ref_add_list. */ |
83 | struct list_head ref_add_list; | |
c3e69d58 | 84 | |
c46effa6 LB |
85 | struct rb_node href_node; |
86 | ||
5d4f98a2 | 87 | struct btrfs_delayed_extent_op *extent_op; |
1262133b JB |
88 | |
89 | /* | |
90 | * This is used to track the final ref_mod from all the refs associated | |
91 | * with this head ref, this is not adjusted as delayed refs are run, | |
92 | * this is meant to track if we need to do the csum accounting or not. | |
93 | */ | |
94 | int total_ref_mod; | |
95 | ||
d278850e JB |
96 | /* |
97 | * This is the current outstanding mod references for this bytenr. This | |
98 | * is used with lookup_extent_info to get an accurate reference count | |
99 | * for a bytenr, so it is adjusted as delayed refs are run so that any | |
100 | * on disk reference count + ref_mod is accurate. | |
101 | */ | |
102 | int ref_mod; | |
103 | ||
56bec294 CM |
104 | /* |
105 | * when a new extent is allocated, it is just reserved in memory | |
106 | * The actual extent isn't inserted into the extent allocation tree | |
107 | * until the delayed ref is processed. must_insert_reserved is | |
108 | * used to flag a delayed ref so the accounting can be updated | |
109 | * when a full insert is done. | |
110 | * | |
111 | * It is possible the extent will be freed before it is ever | |
112 | * inserted into the extent allocation tree. In this case | |
113 | * we need to update the in ram accounting to properly reflect | |
114 | * the free has happened. | |
115 | */ | |
116 | unsigned int must_insert_reserved:1; | |
5d4f98a2 | 117 | unsigned int is_data:1; |
5e388e95 | 118 | unsigned int is_system:1; |
d7df2c79 | 119 | unsigned int processing:1; |
56bec294 CM |
120 | }; |
121 | ||
5d4f98a2 | 122 | struct btrfs_delayed_tree_ref { |
56bec294 | 123 | struct btrfs_delayed_ref_node node; |
eebe063b AJ |
124 | u64 root; |
125 | u64 parent; | |
5d4f98a2 YZ |
126 | int level; |
127 | }; | |
56bec294 | 128 | |
5d4f98a2 YZ |
129 | struct btrfs_delayed_data_ref { |
130 | struct btrfs_delayed_ref_node node; | |
eebe063b AJ |
131 | u64 root; |
132 | u64 parent; | |
5d4f98a2 YZ |
133 | u64 objectid; |
134 | u64 offset; | |
56bec294 CM |
135 | }; |
136 | ||
e19eb11f JB |
137 | enum btrfs_delayed_ref_flags { |
138 | /* Indicate that we are flushing delayed refs for the commit */ | |
139 | BTRFS_DELAYED_REFS_FLUSHING, | |
140 | }; | |
141 | ||
56bec294 | 142 | struct btrfs_delayed_ref_root { |
c46effa6 | 143 | /* head ref rbtree */ |
5c9d028b | 144 | struct rb_root_cached href_root; |
c46effa6 | 145 | |
3368d001 QW |
146 | /* dirty extent records */ |
147 | struct rb_root dirty_extent_root; | |
148 | ||
56bec294 CM |
149 | /* this spin lock protects the rbtree and the entries inside */ |
150 | spinlock_t lock; | |
151 | ||
152 | /* how many delayed ref updates we've queued, used by the | |
153 | * throttling code | |
154 | */ | |
d7df2c79 | 155 | atomic_t num_entries; |
56bec294 | 156 | |
c3e69d58 CM |
157 | /* total number of head nodes in tree */ |
158 | unsigned long num_heads; | |
159 | ||
160 | /* total number of head nodes ready for processing */ | |
161 | unsigned long num_heads_ready; | |
162 | ||
1262133b JB |
163 | u64 pending_csums; |
164 | ||
e19eb11f | 165 | unsigned long flags; |
c3e69d58 CM |
166 | |
167 | u64 run_delayed_start; | |
9086db86 QW |
168 | |
169 | /* | |
170 | * To make qgroup to skip given root. | |
01327610 | 171 | * This is for snapshot, as btrfs_qgroup_inherit() will manually |
9086db86 QW |
172 | * modify counters for snapshot and its source, so we should skip |
173 | * the snapshot in new_root/old_roots or it will get calculated twice | |
174 | */ | |
175 | u64 qgroup_to_skip; | |
56bec294 CM |
176 | }; |
177 | ||
b28b1f0c QW |
178 | enum btrfs_ref_type { |
179 | BTRFS_REF_NOT_SET, | |
180 | BTRFS_REF_DATA, | |
181 | BTRFS_REF_METADATA, | |
182 | BTRFS_REF_LAST, | |
183 | }; | |
184 | ||
185 | struct btrfs_data_ref { | |
186 | /* For EXTENT_DATA_REF */ | |
187 | ||
113479d5 NB |
188 | /* Original root this data extent belongs to */ |
189 | u64 owning_root; | |
b28b1f0c QW |
190 | |
191 | /* Inode which refers to this data extent */ | |
192 | u64 ino; | |
193 | ||
194 | /* | |
195 | * file_offset - extent_offset | |
196 | * | |
197 | * file_offset is the key.offset of the EXTENT_DATA key. | |
198 | * extent_offset is btrfs_file_extent_offset() of the EXTENT_DATA data. | |
199 | */ | |
200 | u64 offset; | |
201 | }; | |
202 | ||
203 | struct btrfs_tree_ref { | |
204 | /* | |
205 | * Level of this tree block | |
206 | * | |
207 | * Shared for skinny (TREE_BLOCK_REF) and normal tree ref. | |
208 | */ | |
209 | int level; | |
210 | ||
211 | /* | |
113479d5 | 212 | * Root which owns this tree block. |
b28b1f0c QW |
213 | * |
214 | * For TREE_BLOCK_REF (skinny metadata, either inline or keyed) | |
215 | */ | |
113479d5 | 216 | u64 owning_root; |
b28b1f0c QW |
217 | |
218 | /* For non-skinny metadata, no special member needed */ | |
219 | }; | |
220 | ||
221 | struct btrfs_ref { | |
222 | enum btrfs_ref_type type; | |
223 | int action; | |
224 | ||
225 | /* | |
226 | * Whether this extent should go through qgroup record. | |
227 | * | |
228 | * Normally false, but for certain cases like delayed subtree scan, | |
229 | * setting this flag can hugely reduce qgroup overhead. | |
230 | */ | |
231 | bool skip_qgroup; | |
232 | ||
eed2037f NB |
233 | #ifdef CONFIG_BTRFS_FS_REF_VERIFY |
234 | /* Through which root is this modification. */ | |
b28b1f0c | 235 | u64 real_root; |
eed2037f | 236 | #endif |
b28b1f0c QW |
237 | u64 bytenr; |
238 | u64 len; | |
239 | ||
240 | /* Bytenr of the parent tree block */ | |
241 | u64 parent; | |
242 | union { | |
243 | struct btrfs_data_ref data_ref; | |
244 | struct btrfs_tree_ref tree_ref; | |
245 | }; | |
246 | }; | |
247 | ||
78a6184a MX |
248 | extern struct kmem_cache *btrfs_delayed_ref_head_cachep; |
249 | extern struct kmem_cache *btrfs_delayed_tree_ref_cachep; | |
250 | extern struct kmem_cache *btrfs_delayed_data_ref_cachep; | |
251 | extern struct kmem_cache *btrfs_delayed_extent_op_cachep; | |
252 | ||
f5c29bd9 | 253 | int __init btrfs_delayed_ref_init(void); |
e67c718b | 254 | void __cold btrfs_delayed_ref_exit(void); |
78a6184a | 255 | |
0e55a545 FM |
256 | static inline u64 btrfs_calc_delayed_ref_bytes(const struct btrfs_fs_info *fs_info, |
257 | int num_delayed_refs) | |
258 | { | |
259 | u64 num_bytes; | |
260 | ||
261 | num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_delayed_refs); | |
262 | ||
263 | /* | |
264 | * We have to check the mount option here because we could be enabling | |
265 | * the free space tree for the first time and don't have the compat_ro | |
266 | * option set yet. | |
267 | * | |
268 | * We need extra reservations if we have the free space tree because | |
269 | * we'll have to modify that tree as well. | |
270 | */ | |
271 | if (btrfs_test_opt(fs_info, FREE_SPACE_TREE)) | |
272 | num_bytes *= 2; | |
273 | ||
274 | return num_bytes; | |
275 | } | |
276 | ||
b28b1f0c QW |
277 | static inline void btrfs_init_generic_ref(struct btrfs_ref *generic_ref, |
278 | int action, u64 bytenr, u64 len, u64 parent) | |
279 | { | |
280 | generic_ref->action = action; | |
281 | generic_ref->bytenr = bytenr; | |
282 | generic_ref->len = len; | |
283 | generic_ref->parent = parent; | |
284 | } | |
285 | ||
286 | static inline void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, | |
f42c5da6 | 287 | int level, u64 root, u64 mod_root, bool skip_qgroup) |
b28b1f0c | 288 | { |
eed2037f | 289 | #ifdef CONFIG_BTRFS_FS_REF_VERIFY |
b28b1f0c | 290 | /* If @real_root not set, use @root as fallback */ |
eed2037f NB |
291 | generic_ref->real_root = mod_root ?: root; |
292 | #endif | |
b28b1f0c | 293 | generic_ref->tree_ref.level = level; |
113479d5 | 294 | generic_ref->tree_ref.owning_root = root; |
b28b1f0c | 295 | generic_ref->type = BTRFS_REF_METADATA; |
681145d4 NB |
296 | if (skip_qgroup || !(is_fstree(root) && |
297 | (!mod_root || is_fstree(mod_root)))) | |
298 | generic_ref->skip_qgroup = true; | |
299 | else | |
300 | generic_ref->skip_qgroup = false; | |
301 | ||
b28b1f0c QW |
302 | } |
303 | ||
304 | static inline void btrfs_init_data_ref(struct btrfs_ref *generic_ref, | |
f42c5da6 NB |
305 | u64 ref_root, u64 ino, u64 offset, u64 mod_root, |
306 | bool skip_qgroup) | |
b28b1f0c | 307 | { |
eed2037f | 308 | #ifdef CONFIG_BTRFS_FS_REF_VERIFY |
b28b1f0c | 309 | /* If @real_root not set, use @root as fallback */ |
eed2037f NB |
310 | generic_ref->real_root = mod_root ?: ref_root; |
311 | #endif | |
113479d5 | 312 | generic_ref->data_ref.owning_root = ref_root; |
b28b1f0c QW |
313 | generic_ref->data_ref.ino = ino; |
314 | generic_ref->data_ref.offset = offset; | |
315 | generic_ref->type = BTRFS_REF_DATA; | |
681145d4 NB |
316 | if (skip_qgroup || !(is_fstree(ref_root) && |
317 | (!mod_root || is_fstree(mod_root)))) | |
318 | generic_ref->skip_qgroup = true; | |
319 | else | |
320 | generic_ref->skip_qgroup = false; | |
b28b1f0c QW |
321 | } |
322 | ||
78a6184a MX |
323 | static inline struct btrfs_delayed_extent_op * |
324 | btrfs_alloc_delayed_extent_op(void) | |
325 | { | |
326 | return kmem_cache_alloc(btrfs_delayed_extent_op_cachep, GFP_NOFS); | |
327 | } | |
328 | ||
329 | static inline void | |
330 | btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op *op) | |
331 | { | |
332 | if (op) | |
333 | kmem_cache_free(btrfs_delayed_extent_op_cachep, op); | |
334 | } | |
335 | ||
56bec294 CM |
336 | static inline void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref) |
337 | { | |
6df8cdf5 ER |
338 | WARN_ON(refcount_read(&ref->refs) == 0); |
339 | if (refcount_dec_and_test(&ref->refs)) { | |
56bec294 | 340 | WARN_ON(ref->in_tree); |
78a6184a MX |
341 | switch (ref->type) { |
342 | case BTRFS_TREE_BLOCK_REF_KEY: | |
343 | case BTRFS_SHARED_BLOCK_REF_KEY: | |
344 | kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref); | |
345 | break; | |
346 | case BTRFS_EXTENT_DATA_REF_KEY: | |
347 | case BTRFS_SHARED_DATA_REF_KEY: | |
348 | kmem_cache_free(btrfs_delayed_data_ref_cachep, ref); | |
349 | break; | |
78a6184a MX |
350 | default: |
351 | BUG(); | |
352 | } | |
56bec294 CM |
353 | } |
354 | } | |
355 | ||
2187374f JB |
356 | static inline u64 btrfs_ref_head_to_space_flags( |
357 | struct btrfs_delayed_ref_head *head_ref) | |
358 | { | |
359 | if (head_ref->is_data) | |
360 | return BTRFS_BLOCK_GROUP_DATA; | |
361 | else if (head_ref->is_system) | |
362 | return BTRFS_BLOCK_GROUP_SYSTEM; | |
363 | return BTRFS_BLOCK_GROUP_METADATA; | |
364 | } | |
365 | ||
d278850e JB |
366 | static inline void btrfs_put_delayed_ref_head(struct btrfs_delayed_ref_head *head) |
367 | { | |
368 | if (refcount_dec_and_test(&head->refs)) | |
369 | kmem_cache_free(btrfs_delayed_ref_head_cachep, head); | |
370 | } | |
371 | ||
44e1c47d | 372 | int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, |
ed4f255b | 373 | struct btrfs_ref *generic_ref, |
2187374f | 374 | struct btrfs_delayed_extent_op *extent_op); |
88a979c6 | 375 | int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, |
76675593 | 376 | struct btrfs_ref *generic_ref, |
2187374f | 377 | u64 reserved); |
c6e340bc | 378 | int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, |
5d4f98a2 YZ |
379 | u64 bytenr, u64 num_bytes, |
380 | struct btrfs_delayed_extent_op *extent_op); | |
0c555c97 | 381 | void btrfs_merge_delayed_refs(struct btrfs_fs_info *fs_info, |
ae1e206b JB |
382 | struct btrfs_delayed_ref_root *delayed_refs, |
383 | struct btrfs_delayed_ref_head *head); | |
56bec294 | 384 | |
1887be66 | 385 | struct btrfs_delayed_ref_head * |
f72ad18e LB |
386 | btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, |
387 | u64 bytenr); | |
9e920a6f | 388 | int btrfs_delayed_ref_lock(struct btrfs_delayed_ref_root *delayed_refs, |
c3e69d58 | 389 | struct btrfs_delayed_ref_head *head); |
093486c4 MX |
390 | static inline void btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head *head) |
391 | { | |
392 | mutex_unlock(&head->mutex); | |
393 | } | |
d7baffda JB |
394 | void btrfs_delete_ref_head(struct btrfs_delayed_ref_root *delayed_refs, |
395 | struct btrfs_delayed_ref_head *head); | |
d7df2c79 | 396 | |
5637c74b LF |
397 | struct btrfs_delayed_ref_head *btrfs_select_ref_head( |
398 | struct btrfs_delayed_ref_root *delayed_refs); | |
00f04b88 | 399 | |
41d0bd3b | 400 | int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq); |
00f04b88 | 401 | |
6ef03deb JB |
402 | void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr); |
403 | void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans); | |
404 | int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info, | |
405 | enum btrfs_reserve_flush_enum flush); | |
406 | void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info, | |
407 | struct btrfs_block_rsv *src, | |
408 | u64 num_bytes); | |
6ef03deb JB |
409 | bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info); |
410 | ||
56bec294 CM |
411 | /* |
412 | * helper functions to cast a node into its container | |
413 | */ | |
5d4f98a2 YZ |
414 | static inline struct btrfs_delayed_tree_ref * |
415 | btrfs_delayed_node_to_tree_ref(struct btrfs_delayed_ref_node *node) | |
56bec294 | 416 | { |
5d4f98a2 YZ |
417 | return container_of(node, struct btrfs_delayed_tree_ref, node); |
418 | } | |
56bec294 | 419 | |
5d4f98a2 YZ |
420 | static inline struct btrfs_delayed_data_ref * |
421 | btrfs_delayed_node_to_data_ref(struct btrfs_delayed_ref_node *node) | |
422 | { | |
5d4f98a2 | 423 | return container_of(node, struct btrfs_delayed_data_ref, node); |
56bec294 | 424 | } |
9888c340 | 425 | |
56bec294 | 426 | #endif |