1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Copyright (C) 2008 Oracle. All rights reserved.
4 */
5
6 #ifndef BTRFS_DELAYED_REF_H
7 #define BTRFS_DELAYED_REF_H
8
9 #include <linux/types.h>
10 #include <linux/refcount.h>
11 #include <linux/list.h>
12 #include <linux/rbtree.h>
13 #include <linux/mutex.h>
14 #include <linux/spinlock.h>
15 #include <linux/slab.h>
16 #include <uapi/linux/btrfs_tree.h>
17
18 struct btrfs_trans_handle;
19 struct btrfs_fs_info;
20
21 /* these are the possible values of struct btrfs_delayed_ref_node->action */
22 enum btrfs_delayed_ref_action {
23 /* Add one backref to the tree */
24 BTRFS_ADD_DELAYED_REF = 1,
25 /* Delete one backref from the tree */
26 BTRFS_DROP_DELAYED_REF,
27 /* Record a full extent allocation */
28 BTRFS_ADD_DELAYED_EXTENT,
29 /* Not changing ref count on head ref */
30 BTRFS_UPDATE_DELAYED_HEAD,
31 } __packed;
32
33 struct btrfs_data_ref {
34 /* For EXTENT_DATA_REF */
35
36 /* Inode which refers to this data extent */
37 u64 objectid;
38
39 /*
40 * file_offset - extent_offset
41 *
42 * file_offset is the key.offset of the EXTENT_DATA key.
43 * extent_offset is btrfs_file_extent_offset() of the EXTENT_DATA data.
44 */
45 u64 offset;
46 };
47
48 struct btrfs_tree_ref {
49 /*
50 * Level of this tree block.
51 *
52 * Shared for skinny (TREE_BLOCK_REF) and normal tree ref.
53 */
54 int level;
55
56 /* For non-skinny metadata, no special member needed */
57 };
58
59 struct btrfs_delayed_ref_node {
60 struct rb_node ref_node;
61 /*
62 * If action is BTRFS_ADD_DELAYED_REF, also link this node to
63 * ref_head->ref_add_list, then we do not need to iterate the
64 * whole ref_head->ref_list to find BTRFS_ADD_DELAYED_REF nodes.
65 */
66 struct list_head add_list;
67
68 /* the starting bytenr of the extent */
69 u64 bytenr;
70
71 /* the size of the extent */
72 u64 num_bytes;
73
74 /* seq number to keep track of insertion order */
75 u64 seq;
76
77 /* The ref_root for this ref */
78 u64 ref_root;
79
80 /*
81 * The parent for this ref, if this isn't set the ref_root is the
82 * reference owner.
83 */
84 u64 parent;
85
86 /* ref count on this data structure */
87 refcount_t refs;
88
89 /*
90 * how many refs is this entry adding or deleting. For
91 * head refs, this may be a negative number because it is keeping
92 * track of the total mods done to the reference count.
93 * For individual refs, this will always be a positive number
94 *
95 * It may be more than one, since it is possible for a single
96 * parent to have more than one ref on an extent
97 */
98 int ref_mod;
99
100 unsigned int action:8;
101 unsigned int type:8;
102
103 union {
104 struct btrfs_tree_ref tree_ref;
105 struct btrfs_data_ref data_ref;
106 };
107 };
108
109 struct btrfs_delayed_extent_op {
110 struct btrfs_disk_key key;
111 bool update_key;
112 bool update_flags;
113 u64 flags_to_set;
114 };
115
116 /*
117 * the head refs are used to hold a lock on a given extent, which allows us
118 * to make sure that only one process is running the delayed refs
119 * at a time for a single extent. They also store the sum of all the
120 * reference count modifications we've queued up.
121 */
122 struct btrfs_delayed_ref_head {
123 u64 bytenr;
124 u64 num_bytes;
125 /*
126 * For insertion into struct btrfs_delayed_ref_root::href_root.
127 * Keep it in the same cache line as 'bytenr' for more efficient
128 * searches in the rbtree.
129 */
130 struct rb_node href_node;
131 /*
132 * the mutex is held while running the refs, and it is also
133 * held when checking the sum of reference modifications.
134 */
135 struct mutex mutex;
136
137 refcount_t refs;
138
139 /* Protects 'ref_tree' and 'ref_add_list'. */
140 spinlock_t lock;
141 struct rb_root_cached ref_tree;
142 /* accumulate add BTRFS_ADD_DELAYED_REF nodes to this ref_add_list. */
143 struct list_head ref_add_list;
144
145 struct btrfs_delayed_extent_op *extent_op;
146
147 /*
148 * This is used to track the final ref_mod from all the refs associated
149 * with this head ref, this is not adjusted as delayed refs are run,
150 * this is meant to track if we need to do the csum accounting or not.
151 */
152 int total_ref_mod;
153
154 /*
155 * This is the current outstanding mod references for this bytenr. This
156 * is used with lookup_extent_info to get an accurate reference count
157 * for a bytenr, so it is adjusted as delayed refs are run so that any
158 * on disk reference count + ref_mod is accurate.
159 */
160 int ref_mod;
161
162 /*
163 * The root that triggered the allocation when must_insert_reserved is
164 * set to true.
165 */
166 u64 owning_root;
167
168 /*
169 * Track reserved bytes when setting must_insert_reserved. On success
170 * or cleanup, we will need to free the reservation.
171 */
172 u64 reserved_bytes;
173
174 /* Tree block level, for metadata only. */
175 u8 level;
176
177 /*
178 * when a new extent is allocated, it is just reserved in memory
179 * The actual extent isn't inserted into the extent allocation tree
180 * until the delayed ref is processed. must_insert_reserved is
181 * used to flag a delayed ref so the accounting can be updated
182 * when a full insert is done.
183 *
184 * It is possible the extent will be freed before it is ever
185 * inserted into the extent allocation tree. In this case
186 * we need to update the in ram accounting to properly reflect
187 * the free has happened.
188 */
189 bool must_insert_reserved;
190
191 bool is_data;
192 bool is_system;
193 bool processing;
194 };
195
196 enum btrfs_delayed_ref_flags {
197 /* Indicate that we are flushing delayed refs for the commit */
198 BTRFS_DELAYED_REFS_FLUSHING,
199 };
200
201 struct btrfs_delayed_ref_root {
202 /* head ref rbtree */
203 struct rb_root_cached href_root;
204
205 /* Track dirty extent records. */
206 struct xarray dirty_extents;
207
208 /* this spin lock protects the rbtree and the entries inside */
209 spinlock_t lock;
210
211 /* how many delayed ref updates we've queued, used by the
212 * throttling code
213 */
214 atomic_t num_entries;
215
216 /* total number of head nodes in tree */
217 unsigned long num_heads;
218
219 /* total number of head nodes ready for processing */
220 unsigned long num_heads_ready;
221
222 u64 pending_csums;
223
224 unsigned long flags;
225
226 u64 run_delayed_start;
227
228 /*
229 * To make qgroup to skip given root.
230 * This is for snapshot, as btrfs_qgroup_inherit() will manually
231 * modify counters for snapshot and its source, so we should skip
232 * the snapshot in new_root/old_roots or it will get calculated twice
233 */
234 u64 qgroup_to_skip;
235 };
236
237 enum btrfs_ref_type {
238 BTRFS_REF_NOT_SET,
239 BTRFS_REF_DATA,
240 BTRFS_REF_METADATA,
241 BTRFS_REF_LAST,
242 } __packed;
243
244 struct btrfs_ref {
245 enum btrfs_ref_type type;
246 enum btrfs_delayed_ref_action action;
247
248 /*
249 * Whether this extent should go through qgroup record.
250 *
251 * Normally false, but for certain cases like delayed subtree scan,
252 * setting this flag can hugely reduce qgroup overhead.
253 */
254 bool skip_qgroup;
255
256 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
257 /* Through which root is this modification. */
258 u64 real_root;
259 #endif
260 u64 bytenr;
261 u64 num_bytes;
262 u64 owning_root;
263
264 /*
265 * The root that owns the reference for this reference, this will be set
266 * or ->parent will be set, depending on what type of reference this is.
267 */
268 u64 ref_root;
269
270 /* Bytenr of the parent tree block */
271 u64 parent;
272 union {
273 struct btrfs_data_ref data_ref;
274 struct btrfs_tree_ref tree_ref;
275 };
276 };
277
278 extern struct kmem_cache *btrfs_delayed_ref_head_cachep;
279 extern struct kmem_cache *btrfs_delayed_ref_node_cachep;
280 extern struct kmem_cache *btrfs_delayed_extent_op_cachep;
281
282 int __init btrfs_delayed_ref_init(void);
283 void __cold btrfs_delayed_ref_exit(void);
284
btrfs_calc_delayed_ref_bytes(const struct btrfs_fs_info * fs_info,int num_delayed_refs)285 static inline u64 btrfs_calc_delayed_ref_bytes(const struct btrfs_fs_info *fs_info,
286 int num_delayed_refs)
287 {
288 u64 num_bytes;
289
290 num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_delayed_refs);
291
292 /*
293 * We have to check the mount option here because we could be enabling
294 * the free space tree for the first time and don't have the compat_ro
295 * option set yet.
296 *
297 * We need extra reservations if we have the free space tree because
298 * we'll have to modify that tree as well.
299 */
300 if (btrfs_test_opt(fs_info, FREE_SPACE_TREE))
301 num_bytes *= 2;
302
303 return num_bytes;
304 }
305
btrfs_calc_delayed_ref_csum_bytes(const struct btrfs_fs_info * fs_info,int num_csum_items)306 static inline u64 btrfs_calc_delayed_ref_csum_bytes(const struct btrfs_fs_info *fs_info,
307 int num_csum_items)
308 {
309 /*
310 * Deleting csum items does not result in new nodes/leaves and does not
311 * require changing the free space tree, only the csum tree, so this is
312 * all we need.
313 */
314 return btrfs_calc_metadata_size(fs_info, num_csum_items);
315 }
316
317 void btrfs_init_tree_ref(struct btrfs_ref *generic_ref, int level, u64 mod_root,
318 bool skip_qgroup);
319 void btrfs_init_data_ref(struct btrfs_ref *generic_ref, u64 ino, u64 offset,
320 u64 mod_root, bool skip_qgroup);
321
322 static inline struct btrfs_delayed_extent_op *
btrfs_alloc_delayed_extent_op(void)323 btrfs_alloc_delayed_extent_op(void)
324 {
325 return kmem_cache_alloc(btrfs_delayed_extent_op_cachep, GFP_NOFS);
326 }
327
328 static inline void
btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op * op)329 btrfs_free_delayed_extent_op(struct btrfs_delayed_extent_op *op)
330 {
331 if (op)
332 kmem_cache_free(btrfs_delayed_extent_op_cachep, op);
333 }
334
335 void btrfs_put_delayed_ref(struct btrfs_delayed_ref_node *ref);
336
btrfs_ref_head_to_space_flags(struct btrfs_delayed_ref_head * head_ref)337 static inline u64 btrfs_ref_head_to_space_flags(
338 struct btrfs_delayed_ref_head *head_ref)
339 {
340 if (head_ref->is_data)
341 return BTRFS_BLOCK_GROUP_DATA;
342 else if (head_ref->is_system)
343 return BTRFS_BLOCK_GROUP_SYSTEM;
344 return BTRFS_BLOCK_GROUP_METADATA;
345 }
346
btrfs_put_delayed_ref_head(struct btrfs_delayed_ref_head * head)347 static inline void btrfs_put_delayed_ref_head(struct btrfs_delayed_ref_head *head)
348 {
349 if (refcount_dec_and_test(&head->refs))
350 kmem_cache_free(btrfs_delayed_ref_head_cachep, head);
351 }
352
353 int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,
354 struct btrfs_ref *generic_ref,
355 struct btrfs_delayed_extent_op *extent_op);
356 int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,
357 struct btrfs_ref *generic_ref,
358 u64 reserved);
359 int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans,
360 u64 bytenr, u64 num_bytes, u8 level,
361 struct btrfs_delayed_extent_op *extent_op);
362 void btrfs_merge_delayed_refs(struct btrfs_fs_info *fs_info,
363 struct btrfs_delayed_ref_root *delayed_refs,
364 struct btrfs_delayed_ref_head *head);
365
366 struct btrfs_delayed_ref_head *
367 btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs,
368 u64 bytenr);
369 int btrfs_delayed_ref_lock(struct btrfs_delayed_ref_root *delayed_refs,
370 struct btrfs_delayed_ref_head *head);
btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head * head)371 static inline void btrfs_delayed_ref_unlock(struct btrfs_delayed_ref_head *head)
372 {
373 mutex_unlock(&head->mutex);
374 }
375 void btrfs_delete_ref_head(struct btrfs_delayed_ref_root *delayed_refs,
376 struct btrfs_delayed_ref_head *head);
377
378 struct btrfs_delayed_ref_head *btrfs_select_ref_head(
379 struct btrfs_delayed_ref_root *delayed_refs);
380
381 int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq);
382
383 void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr_refs, int nr_csums);
384 void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans);
385 void btrfs_inc_delayed_refs_rsv_bg_inserts(struct btrfs_fs_info *fs_info);
386 void btrfs_dec_delayed_refs_rsv_bg_inserts(struct btrfs_fs_info *fs_info);
387 void btrfs_inc_delayed_refs_rsv_bg_updates(struct btrfs_fs_info *fs_info);
388 void btrfs_dec_delayed_refs_rsv_bg_updates(struct btrfs_fs_info *fs_info);
389 int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
390 enum btrfs_reserve_flush_enum flush);
391 bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info);
392 bool btrfs_find_delayed_tree_ref(struct btrfs_delayed_ref_head *head,
393 u64 root, u64 parent);
394
btrfs_delayed_ref_owner(struct btrfs_delayed_ref_node * node)395 static inline u64 btrfs_delayed_ref_owner(struct btrfs_delayed_ref_node *node)
396 {
397 if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
398 node->type == BTRFS_SHARED_DATA_REF_KEY)
399 return node->data_ref.objectid;
400 return node->tree_ref.level;
401 }
402
btrfs_delayed_ref_offset(struct btrfs_delayed_ref_node * node)403 static inline u64 btrfs_delayed_ref_offset(struct btrfs_delayed_ref_node *node)
404 {
405 if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
406 node->type == BTRFS_SHARED_DATA_REF_KEY)
407 return node->data_ref.offset;
408 return 0;
409 }
410
btrfs_ref_type(struct btrfs_ref * ref)411 static inline u8 btrfs_ref_type(struct btrfs_ref *ref)
412 {
413 ASSERT(ref->type == BTRFS_REF_DATA || ref->type == BTRFS_REF_METADATA);
414
415 if (ref->type == BTRFS_REF_DATA) {
416 if (ref->parent)
417 return BTRFS_SHARED_DATA_REF_KEY;
418 else
419 return BTRFS_EXTENT_DATA_REF_KEY;
420 } else {
421 if (ref->parent)
422 return BTRFS_SHARED_BLOCK_REF_KEY;
423 else
424 return BTRFS_TREE_BLOCK_REF_KEY;
425 }
426
427 return 0;
428 }
429
430 #endif
431