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