Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (C) 2009 Oracle. All rights reserved.
4 : */
5 :
6 : #include <linux/sched.h>
7 : #include <linux/slab.h>
8 : #include <linux/sort.h>
9 : #include "messages.h"
10 : #include "ctree.h"
11 : #include "delayed-ref.h"
12 : #include "transaction.h"
13 : #include "qgroup.h"
14 : #include "space-info.h"
15 : #include "tree-mod-log.h"
16 : #include "fs.h"
17 :
18 : struct kmem_cache *btrfs_delayed_ref_head_cachep;
19 : struct kmem_cache *btrfs_delayed_tree_ref_cachep;
20 : struct kmem_cache *btrfs_delayed_data_ref_cachep;
21 : struct kmem_cache *btrfs_delayed_extent_op_cachep;
22 : /*
23 : * delayed back reference update tracking. For subvolume trees
24 : * we queue up extent allocations and backref maintenance for
25 : * delayed processing. This avoids deep call chains where we
26 : * add extents in the middle of btrfs_search_slot, and it allows
27 : * us to buffer up frequently modified backrefs in an rb tree instead
28 : * of hammering updates on the extent allocation tree.
29 : */
30 :
31 3841026 : bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info)
32 : {
33 3841026 : struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
34 3841026 : struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
35 3841026 : bool ret = false;
36 3841026 : u64 reserved;
37 :
38 3841026 : spin_lock(&global_rsv->lock);
39 3841026 : reserved = global_rsv->reserved;
40 3841026 : spin_unlock(&global_rsv->lock);
41 :
42 : /*
43 : * Since the global reserve is just kind of magic we don't really want
44 : * to rely on it to save our bacon, so if our size is more than the
45 : * delayed_refs_rsv and the global rsv then it's time to think about
46 : * bailing.
47 : */
48 3841026 : spin_lock(&delayed_refs_rsv->lock);
49 3841026 : reserved += delayed_refs_rsv->reserved;
50 3841026 : if (delayed_refs_rsv->size >= reserved)
51 2303133 : ret = true;
52 3841026 : spin_unlock(&delayed_refs_rsv->lock);
53 3841026 : return ret;
54 : }
55 :
56 : /*
57 : * Release a ref head's reservation.
58 : *
59 : * @fs_info: the filesystem
60 : * @nr: number of items to drop
61 : *
62 : * Drops the delayed ref head's count from the delayed refs rsv and free any
63 : * excess reservation we had.
64 : */
65 51118175 : void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr)
66 : {
67 51118175 : struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;
68 51118175 : const u64 num_bytes = btrfs_calc_delayed_ref_bytes(fs_info, nr);
69 51118175 : u64 released = 0;
70 :
71 51118175 : released = btrfs_block_rsv_release(fs_info, block_rsv, num_bytes, NULL);
72 51118163 : if (released)
73 16119687 : trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
74 : 0, released, 0);
75 51117913 : }
76 :
77 : /*
78 : * Adjust the size of the delayed refs rsv.
79 : *
80 : * This is to be called anytime we may have adjusted trans->delayed_ref_updates,
81 : * it'll calculate the additional size and add it to the delayed_refs_rsv.
82 : */
83 94432364 : void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans)
84 : {
85 94432364 : struct btrfs_fs_info *fs_info = trans->fs_info;
86 94432364 : struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
87 94432364 : u64 num_bytes;
88 :
89 94432364 : if (!trans->delayed_ref_updates)
90 : return;
91 :
92 51121896 : num_bytes = btrfs_calc_delayed_ref_bytes(fs_info,
93 : trans->delayed_ref_updates);
94 :
95 51121896 : spin_lock(&delayed_rsv->lock);
96 51121912 : delayed_rsv->size += num_bytes;
97 51121912 : delayed_rsv->full = false;
98 51121912 : spin_unlock(&delayed_rsv->lock);
99 51121899 : trans->delayed_ref_updates = 0;
100 : }
101 :
102 : /*
103 : * Transfer bytes to our delayed refs rsv.
104 : *
105 : * @fs_info: the filesystem
106 : * @src: source block rsv to transfer from
107 : * @num_bytes: number of bytes to transfer
108 : *
109 : * This transfers up to the num_bytes amount from the src rsv to the
110 : * delayed_refs_rsv. Any extra bytes are returned to the space info.
111 : */
112 1393539 : void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,
113 : struct btrfs_block_rsv *src,
114 : u64 num_bytes)
115 : {
116 1393539 : struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
117 1393539 : u64 to_free = 0;
118 :
119 1393539 : spin_lock(&src->lock);
120 1393584 : src->reserved -= num_bytes;
121 1393584 : src->size -= num_bytes;
122 1393584 : spin_unlock(&src->lock);
123 :
124 1393579 : spin_lock(&delayed_refs_rsv->lock);
125 1393584 : if (delayed_refs_rsv->size > delayed_refs_rsv->reserved) {
126 1271713 : u64 delta = delayed_refs_rsv->size -
127 : delayed_refs_rsv->reserved;
128 1271713 : if (num_bytes > delta) {
129 701438 : to_free = num_bytes - delta;
130 701438 : num_bytes = delta;
131 : }
132 : } else {
133 : to_free = num_bytes;
134 : num_bytes = 0;
135 : }
136 :
137 1271713 : if (num_bytes)
138 1271713 : delayed_refs_rsv->reserved += num_bytes;
139 1393584 : if (delayed_refs_rsv->reserved >= delayed_refs_rsv->size)
140 842669 : delayed_refs_rsv->full = true;
141 1393584 : spin_unlock(&delayed_refs_rsv->lock);
142 :
143 1393582 : if (num_bytes)
144 1271712 : trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
145 : 0, num_bytes, 1);
146 1393566 : if (to_free)
147 823300 : btrfs_space_info_free_bytes_may_use(fs_info,
148 : delayed_refs_rsv->space_info, to_free);
149 1393568 : }
150 :
151 : /*
152 : * Refill based on our delayed refs usage.
153 : *
154 : * @fs_info: the filesystem
155 : * @flush: control how we can flush for this reservation.
156 : *
157 : * This will refill the delayed block_rsv up to 1 items size worth of space and
158 : * will return -ENOSPC if we can't make the reservation.
159 : */
160 2450328 : int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
161 : enum btrfs_reserve_flush_enum flush)
162 : {
163 2450328 : struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;
164 2450328 : u64 limit = btrfs_calc_delayed_ref_bytes(fs_info, 1);
165 2450328 : u64 num_bytes = 0;
166 2450328 : int ret = -ENOSPC;
167 :
168 2450328 : spin_lock(&block_rsv->lock);
169 2450333 : if (block_rsv->reserved < block_rsv->size) {
170 2449707 : num_bytes = block_rsv->size - block_rsv->reserved;
171 2449707 : num_bytes = min(num_bytes, limit);
172 : }
173 2450333 : spin_unlock(&block_rsv->lock);
174 :
175 2450333 : if (!num_bytes)
176 : return 0;
177 :
178 2449707 : ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);
179 2449707 : if (ret)
180 : return ret;
181 2441999 : btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);
182 2441999 : trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv",
183 : 0, num_bytes, 1);
184 2441999 : return 0;
185 : }
186 :
187 : /*
188 : * compare two delayed tree backrefs with same bytenr and type
189 : */
190 14166251 : static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref1,
191 : struct btrfs_delayed_tree_ref *ref2)
192 : {
193 14166251 : if (ref1->node.type == BTRFS_TREE_BLOCK_REF_KEY) {
194 686223 : if (ref1->root < ref2->root)
195 : return -1;
196 634158 : if (ref1->root > ref2->root)
197 20559 : return 1;
198 : } else {
199 13480028 : if (ref1->parent < ref2->parent)
200 : return -1;
201 5717132 : if (ref1->parent > ref2->parent)
202 4842407 : return 1;
203 : }
204 : return 0;
205 : }
206 :
207 : /*
208 : * compare two delayed data backrefs with same bytenr and type
209 : */
210 256012477 : static int comp_data_refs(struct btrfs_delayed_data_ref *ref1,
211 : struct btrfs_delayed_data_ref *ref2)
212 : {
213 256012477 : if (ref1->node.type == BTRFS_EXTENT_DATA_REF_KEY) {
214 248868912 : if (ref1->root < ref2->root)
215 : return -1;
216 248851572 : if (ref1->root > ref2->root)
217 : return 1;
218 248812948 : if (ref1->objectid < ref2->objectid)
219 : return -1;
220 248122141 : if (ref1->objectid > ref2->objectid)
221 : return 1;
222 242263796 : if (ref1->offset < ref2->offset)
223 : return -1;
224 241584454 : if (ref1->offset > ref2->offset)
225 235294552 : return 1;
226 : } else {
227 7143565 : if (ref1->parent < ref2->parent)
228 : return -1;
229 5113010 : if (ref1->parent > ref2->parent)
230 4417758 : return 1;
231 : }
232 : return 0;
233 : }
234 :
235 270996030 : static int comp_refs(struct btrfs_delayed_ref_node *ref1,
236 : struct btrfs_delayed_ref_node *ref2,
237 : bool check_seq)
238 : {
239 270996030 : int ret = 0;
240 :
241 270996030 : if (ref1->type < ref2->type)
242 : return -1;
243 270333678 : if (ref1->type > ref2->type)
244 : return 1;
245 270178599 : if (ref1->type == BTRFS_TREE_BLOCK_REF_KEY ||
246 : ref1->type == BTRFS_SHARED_BLOCK_REF_KEY)
247 14166122 : ret = comp_tree_refs(btrfs_delayed_node_to_tree_ref(ref1),
248 : btrfs_delayed_node_to_tree_ref(ref2));
249 : else
250 256012477 : ret = comp_data_refs(btrfs_delayed_node_to_data_ref(ref1),
251 : btrfs_delayed_node_to_data_ref(ref2));
252 270178599 : if (ret)
253 : return ret;
254 8473478 : if (check_seq) {
255 8438912 : if (ref1->seq < ref2->seq)
256 : return -1;
257 8438912 : if (ref1->seq > ref2->seq)
258 157882 : return 1;
259 : }
260 : return 0;
261 : }
262 :
263 : /* insert a new ref to head ref rbtree */
264 75848646 : static struct btrfs_delayed_ref_head *htree_insert(struct rb_root_cached *root,
265 : struct rb_node *node)
266 : {
267 75848646 : struct rb_node **p = &root->rb_root.rb_node;
268 75848646 : struct rb_node *parent_node = NULL;
269 75848646 : struct btrfs_delayed_ref_head *entry;
270 75848646 : struct btrfs_delayed_ref_head *ins;
271 75848646 : u64 bytenr;
272 75848646 : bool leftmost = true;
273 :
274 75848646 : ins = rb_entry(node, struct btrfs_delayed_ref_head, href_node);
275 75848646 : bytenr = ins->bytenr;
276 1162988482 : while (*p) {
277 1112421827 : parent_node = *p;
278 1112421827 : entry = rb_entry(parent_node, struct btrfs_delayed_ref_head,
279 : href_node);
280 :
281 1112421827 : if (bytenr < entry->bytenr) {
282 398145453 : p = &(*p)->rb_left;
283 714276374 : } else if (bytenr > entry->bytenr) {
284 688994383 : p = &(*p)->rb_right;
285 688994383 : leftmost = false;
286 : } else {
287 25281991 : return entry;
288 : }
289 : }
290 :
291 50566655 : rb_link_node(node, parent_node, p);
292 50566655 : rb_insert_color_cached(node, root, leftmost);
293 50566655 : return NULL;
294 : }
295 :
296 75779285 : static struct btrfs_delayed_ref_node* tree_insert(struct rb_root_cached *root,
297 : struct btrfs_delayed_ref_node *ins)
298 : {
299 75779285 : struct rb_node **p = &root->rb_root.rb_node;
300 75779285 : struct rb_node *node = &ins->ref_node;
301 75779285 : struct rb_node *parent_node = NULL;
302 75779285 : struct btrfs_delayed_ref_node *entry;
303 75779285 : bool leftmost = true;
304 :
305 332025947 : while (*p) {
306 264527692 : int comp;
307 :
308 264527692 : parent_node = *p;
309 264527692 : entry = rb_entry(parent_node, struct btrfs_delayed_ref_node,
310 : ref_node);
311 264527692 : comp = comp_refs(ins, entry, true);
312 264527692 : if (comp < 0) {
313 5461456 : p = &(*p)->rb_left;
314 259066236 : } else if (comp > 0) {
315 250785206 : p = &(*p)->rb_right;
316 250785206 : leftmost = false;
317 : } else {
318 8281030 : return entry;
319 : }
320 : }
321 :
322 67498255 : rb_link_node(node, parent_node, p);
323 67498255 : rb_insert_color_cached(node, root, leftmost);
324 67498255 : return NULL;
325 : }
326 :
327 : static struct btrfs_delayed_ref_head *find_first_ref_head(
328 : struct btrfs_delayed_ref_root *dr)
329 : {
330 613132 : struct rb_node *n;
331 613132 : struct btrfs_delayed_ref_head *entry;
332 :
333 613132 : n = rb_first_cached(&dr->href_root);
334 613132 : if (!n)
335 : return NULL;
336 :
337 241677 : entry = rb_entry(n, struct btrfs_delayed_ref_head, href_node);
338 :
339 241677 : return entry;
340 : }
341 :
342 : /*
343 : * Find a head entry based on bytenr. This returns the delayed ref head if it
344 : * was able to find one, or NULL if nothing was in that spot. If return_bigger
345 : * is given, the next bigger entry is returned if no exact match is found.
346 : */
347 63728684 : static struct btrfs_delayed_ref_head *find_ref_head(
348 : struct btrfs_delayed_ref_root *dr, u64 bytenr,
349 : bool return_bigger)
350 : {
351 63728684 : struct rb_root *root = &dr->href_root.rb_root;
352 63728684 : struct rb_node *n;
353 63728684 : struct btrfs_delayed_ref_head *entry;
354 :
355 63728684 : n = root->rb_node;
356 63728684 : entry = NULL;
357 599591749 : while (n) {
358 581444819 : entry = rb_entry(n, struct btrfs_delayed_ref_head, href_node);
359 :
360 581444819 : if (bytenr < entry->bytenr)
361 338441882 : n = n->rb_left;
362 243002937 : else if (bytenr > entry->bytenr)
363 197421183 : n = n->rb_right;
364 : else
365 45581754 : return entry;
366 : }
367 18146930 : if (entry && return_bigger) {
368 9884057 : if (bytenr > entry->bytenr) {
369 4424916 : n = rb_next(&entry->href_node);
370 4424916 : if (!n)
371 : return NULL;
372 4183239 : entry = rb_entry(n, struct btrfs_delayed_ref_head,
373 : href_node);
374 : }
375 9642380 : return entry;
376 : }
377 : return NULL;
378 : }
379 :
380 50022574 : int btrfs_delayed_ref_lock(struct btrfs_delayed_ref_root *delayed_refs,
381 : struct btrfs_delayed_ref_head *head)
382 : {
383 50022574 : lockdep_assert_held(&delayed_refs->lock);
384 50022574 : if (mutex_trylock(&head->mutex))
385 : return 0;
386 :
387 0 : refcount_inc(&head->refs);
388 0 : spin_unlock(&delayed_refs->lock);
389 :
390 0 : mutex_lock(&head->mutex);
391 0 : spin_lock(&delayed_refs->lock);
392 0 : if (RB_EMPTY_NODE(&head->href_node)) {
393 0 : mutex_unlock(&head->mutex);
394 0 : btrfs_put_delayed_ref_head(head);
395 0 : return -EAGAIN;
396 : }
397 0 : btrfs_put_delayed_ref_head(head);
398 0 : return 0;
399 : }
400 :
401 3693713 : static inline void drop_delayed_ref(struct btrfs_delayed_ref_root *delayed_refs,
402 : struct btrfs_delayed_ref_head *head,
403 : struct btrfs_delayed_ref_node *ref)
404 : {
405 3693713 : lockdep_assert_held(&head->lock);
406 3693713 : rb_erase_cached(&ref->ref_node, &head->ref_tree);
407 3693714 : RB_CLEAR_NODE(&ref->ref_node);
408 3693714 : if (!list_empty(&ref->add_list))
409 3655437 : list_del(&ref->add_list);
410 3693713 : btrfs_put_delayed_ref(ref);
411 3693716 : atomic_dec(&delayed_refs->num_entries);
412 3693718 : }
413 :
414 37320844 : static bool merge_ref(struct btrfs_delayed_ref_root *delayed_refs,
415 : struct btrfs_delayed_ref_head *head,
416 : struct btrfs_delayed_ref_node *ref,
417 : u64 seq)
418 : {
419 37320844 : struct btrfs_delayed_ref_node *next;
420 37320844 : struct rb_node *node = rb_next(&ref->ref_node);
421 37320844 : bool done = false;
422 :
423 37355412 : while (!done && node) {
424 6468482 : int mod;
425 :
426 6468482 : next = rb_entry(node, struct btrfs_delayed_ref_node, ref_node);
427 6468482 : node = rb_next(node);
428 6468541 : if (seq && next->seq >= seq)
429 : break;
430 6468535 : if (comp_refs(ref, next, false))
431 : break;
432 :
433 34566 : if (ref->action == next->action) {
434 0 : mod = next->ref_mod;
435 : } else {
436 34566 : if (ref->ref_mod < next->ref_mod) {
437 0 : swap(ref, next);
438 0 : done = true;
439 : }
440 34566 : mod = -next->ref_mod;
441 : }
442 :
443 34566 : drop_delayed_ref(delayed_refs, head, next);
444 34568 : ref->ref_mod += mod;
445 34568 : if (ref->ref_mod == 0) {
446 34568 : drop_delayed_ref(delayed_refs, head, ref);
447 34568 : done = true;
448 : } else {
449 : /*
450 : * Can't have multiples of the same ref on a tree block.
451 : */
452 0 : WARN_ON(ref->type == BTRFS_TREE_BLOCK_REF_KEY ||
453 : ref->type == BTRFS_SHARED_BLOCK_REF_KEY);
454 : }
455 : }
456 :
457 37320915 : return done;
458 : }
459 :
460 113833309 : void btrfs_merge_delayed_refs(struct btrfs_fs_info *fs_info,
461 : struct btrfs_delayed_ref_root *delayed_refs,
462 : struct btrfs_delayed_ref_head *head)
463 : {
464 113833309 : struct btrfs_delayed_ref_node *ref;
465 113833309 : struct rb_node *node;
466 113833309 : u64 seq = 0;
467 :
468 113833309 : lockdep_assert_held(&head->lock);
469 :
470 113833309 : if (RB_EMPTY_ROOT(&head->ref_tree.rb_root))
471 : return;
472 :
473 : /* We don't have too many refs to merge for data. */
474 63838906 : if (head->is_data)
475 : return;
476 :
477 30887181 : seq = btrfs_tree_mod_log_lowest_seq(fs_info);
478 30921763 : again:
479 68208242 : for (node = rb_first_cached(&head->ref_tree); node;
480 37286395 : node = rb_next(node)) {
481 37321103 : ref = rb_entry(node, struct btrfs_delayed_ref_node, ref_node);
482 37321103 : if (seq && ref->seq >= seq)
483 178 : continue;
484 37320925 : if (merge_ref(delayed_refs, head, ref, seq))
485 34568 : goto again;
486 : }
487 : }
488 :
489 949925 : int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq)
490 : {
491 949925 : int ret = 0;
492 949925 : u64 min_seq = btrfs_tree_mod_log_lowest_seq(fs_info);
493 :
494 949928 : if (min_seq != 0 && seq >= min_seq) {
495 172 : btrfs_debug(fs_info,
496 : "holding back delayed_ref %llu, lowest is %llu",
497 : seq, min_seq);
498 172 : ret = 1;
499 : }
500 :
501 949928 : return ret;
502 : }
503 :
504 51038956 : struct btrfs_delayed_ref_head *btrfs_select_ref_head(
505 : struct btrfs_delayed_ref_root *delayed_refs)
506 : {
507 51039184 : struct btrfs_delayed_ref_head *head;
508 :
509 51039184 : lockdep_assert_held(&delayed_refs->lock);
510 51039184 : again:
511 51039184 : head = find_ref_head(delayed_refs, delayed_refs->run_delayed_start,
512 : true);
513 51039184 : if (!head && delayed_refs->run_delayed_start != 0) {
514 613132 : delayed_refs->run_delayed_start = 0;
515 613132 : head = find_first_ref_head(delayed_refs);
516 : }
517 50667729 : if (!head)
518 1015092 : return NULL;
519 :
520 50030808 : while (head->processing) {
521 8264 : struct rb_node *node;
522 :
523 8264 : node = rb_next(&head->href_node);
524 8264 : if (!node) {
525 1548 : if (delayed_refs->run_delayed_start == 0)
526 : return NULL;
527 228 : delayed_refs->run_delayed_start = 0;
528 228 : goto again;
529 : }
530 6716 : head = rb_entry(node, struct btrfs_delayed_ref_head,
531 : href_node);
532 : }
533 :
534 50022544 : head->processing = true;
535 50022544 : WARN_ON(delayed_refs->num_heads_ready == 0);
536 50022544 : delayed_refs->num_heads_ready--;
537 50022544 : delayed_refs->run_delayed_start = head->bytenr +
538 50022544 : head->num_bytes;
539 50022544 : return head;
540 : }
541 :
542 50566657 : void btrfs_delete_ref_head(struct btrfs_delayed_ref_root *delayed_refs,
543 : struct btrfs_delayed_ref_head *head)
544 : {
545 50566657 : lockdep_assert_held(&delayed_refs->lock);
546 50566657 : lockdep_assert_held(&head->lock);
547 :
548 50566657 : rb_erase_cached(&head->href_node, &delayed_refs->href_root);
549 50566655 : RB_CLEAR_NODE(&head->href_node);
550 50566655 : atomic_dec(&delayed_refs->num_entries);
551 50566658 : delayed_refs->num_heads--;
552 50566658 : if (!head->processing)
553 544288 : delayed_refs->num_heads_ready--;
554 50566658 : }
555 :
556 : /*
557 : * Helper to insert the ref_node to the tail or merge with tail.
558 : *
559 : * Return false if the ref was inserted.
560 : * Return true if the ref was merged into an existing one (and therefore can be
561 : * freed by the caller).
562 : */
563 75779286 : static bool insert_delayed_ref(struct btrfs_delayed_ref_root *root,
564 : struct btrfs_delayed_ref_head *href,
565 : struct btrfs_delayed_ref_node *ref)
566 : {
567 75779286 : struct btrfs_delayed_ref_node *exist;
568 75779286 : int mod;
569 :
570 75779286 : spin_lock(&href->lock);
571 75779286 : exist = tree_insert(&href->ref_tree, ref);
572 75779281 : if (!exist) {
573 67498251 : if (ref->action == BTRFS_ADD_DELAYED_REF)
574 43182640 : list_add_tail(&ref->add_list, &href->ref_add_list);
575 67498251 : atomic_inc(&root->num_entries);
576 67498256 : spin_unlock(&href->lock);
577 67498256 : return false;
578 : }
579 :
580 : /* Now we are sure we can merge */
581 8281030 : if (exist->action == ref->action) {
582 4297634 : mod = ref->ref_mod;
583 : } else {
584 : /* Need to change action */
585 3983396 : if (exist->ref_mod < ref->ref_mod) {
586 0 : exist->action = ref->action;
587 0 : mod = -exist->ref_mod;
588 0 : exist->ref_mod = ref->ref_mod;
589 0 : if (ref->action == BTRFS_ADD_DELAYED_REF)
590 0 : list_add_tail(&exist->add_list,
591 : &href->ref_add_list);
592 0 : else if (ref->action == BTRFS_DROP_DELAYED_REF) {
593 0 : ASSERT(!list_empty(&exist->add_list));
594 0 : list_del(&exist->add_list);
595 : } else {
596 : ASSERT(0);
597 : }
598 : } else
599 3983396 : mod = -ref->ref_mod;
600 : }
601 8281030 : exist->ref_mod += mod;
602 :
603 : /* remove existing tail if its ref_mod is zero */
604 8281030 : if (exist->ref_mod == 0)
605 3624582 : drop_delayed_ref(root, href, exist);
606 8281030 : spin_unlock(&href->lock);
607 8281030 : return true;
608 : }
609 :
610 : /*
611 : * helper function to update the accounting in the head ref
612 : * existing and update must have the same bytenr
613 : */
614 25281991 : static noinline void update_existing_head_ref(struct btrfs_trans_handle *trans,
615 : struct btrfs_delayed_ref_head *existing,
616 : struct btrfs_delayed_ref_head *update)
617 : {
618 25281991 : struct btrfs_delayed_ref_root *delayed_refs =
619 25281991 : &trans->transaction->delayed_refs;
620 25281991 : struct btrfs_fs_info *fs_info = trans->fs_info;
621 25281991 : int old_ref_mod;
622 :
623 25281991 : BUG_ON(existing->is_data != update->is_data);
624 :
625 25281991 : spin_lock(&existing->lock);
626 25281991 : if (update->must_insert_reserved) {
627 : /* if the extent was freed and then
628 : * reallocated before the delayed ref
629 : * entries were processed, we can end up
630 : * with an existing head ref without
631 : * the must_insert_reserved flag set.
632 : * Set it again here
633 : */
634 0 : existing->must_insert_reserved = update->must_insert_reserved;
635 :
636 : /*
637 : * update the num_bytes so we make sure the accounting
638 : * is done correctly
639 : */
640 0 : existing->num_bytes = update->num_bytes;
641 :
642 : }
643 :
644 25281991 : if (update->extent_op) {
645 30294 : if (!existing->extent_op) {
646 30220 : existing->extent_op = update->extent_op;
647 : } else {
648 74 : if (update->extent_op->update_key) {
649 0 : memcpy(&existing->extent_op->key,
650 : &update->extent_op->key,
651 : sizeof(update->extent_op->key));
652 0 : existing->extent_op->update_key = true;
653 : }
654 74 : if (update->extent_op->update_flags) {
655 74 : existing->extent_op->flags_to_set |=
656 74 : update->extent_op->flags_to_set;
657 74 : existing->extent_op->update_flags = true;
658 : }
659 74 : btrfs_free_delayed_extent_op(update->extent_op);
660 : }
661 : }
662 : /*
663 : * update the reference mod on the head to reflect this new operation,
664 : * only need the lock for this case cause we could be processing it
665 : * currently, for refs we just added we know we're a-ok.
666 : */
667 25281991 : old_ref_mod = existing->total_ref_mod;
668 25281991 : existing->ref_mod += update->ref_mod;
669 25281991 : existing->total_ref_mod += update->ref_mod;
670 :
671 : /*
672 : * If we are going to from a positive ref mod to a negative or vice
673 : * versa we need to make sure to adjust pending_csums accordingly.
674 : */
675 25281991 : if (existing->is_data) {
676 17347727 : u64 csum_leaves =
677 17347727 : btrfs_csum_bytes_to_leaves(fs_info,
678 : existing->num_bytes);
679 :
680 17347727 : if (existing->total_ref_mod >= 0 && old_ref_mod < 0) {
681 6058 : delayed_refs->pending_csums -= existing->num_bytes;
682 6058 : btrfs_delayed_refs_rsv_release(fs_info, csum_leaves);
683 : }
684 17347727 : if (existing->total_ref_mod < 0 && old_ref_mod >= 0) {
685 9786 : delayed_refs->pending_csums += existing->num_bytes;
686 9786 : trans->delayed_ref_updates += csum_leaves;
687 : }
688 : }
689 :
690 25281991 : spin_unlock(&existing->lock);
691 25281991 : }
692 :
693 75847056 : static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref,
694 : struct btrfs_qgroup_extent_record *qrecord,
695 : u64 bytenr, u64 num_bytes, u64 ref_root,
696 : u64 reserved, int action, bool is_data,
697 : bool is_system)
698 : {
699 75847056 : int count_mod = 1;
700 75847056 : bool must_insert_reserved = false;
701 :
702 : /* If reserved is provided, it must be a data extent. */
703 75847056 : BUG_ON(!is_data && reserved);
704 :
705 75847056 : switch (action) {
706 : case BTRFS_UPDATE_DELAYED_HEAD:
707 : count_mod = 0;
708 : break;
709 : case BTRFS_DROP_DELAYED_REF:
710 : /*
711 : * The head node stores the sum of all the mods, so dropping a ref
712 : * should drop the sum in the head node by one.
713 : */
714 : count_mod = -1;
715 : break;
716 : case BTRFS_ADD_DELAYED_EXTENT:
717 : /*
718 : * BTRFS_ADD_DELAYED_EXTENT means that we need to update the
719 : * reserved accounting when the extent is finally added, or if a
720 : * later modification deletes the delayed ref without ever
721 : * inserting the extent into the extent allocation tree.
722 : * ref->must_insert_reserved is the flag used to record that
723 : * accounting mods are required.
724 : *
725 : * Once we record must_insert_reserved, switch the action to
726 : * BTRFS_ADD_DELAYED_REF because other special casing is not
727 : * required.
728 : */
729 : must_insert_reserved = true;
730 : break;
731 : }
732 :
733 75847056 : refcount_set(&head_ref->refs, 1);
734 75847056 : head_ref->bytenr = bytenr;
735 75847056 : head_ref->num_bytes = num_bytes;
736 75847056 : head_ref->ref_mod = count_mod;
737 75847056 : head_ref->must_insert_reserved = must_insert_reserved;
738 75847056 : head_ref->is_data = is_data;
739 75847056 : head_ref->is_system = is_system;
740 75847056 : head_ref->ref_tree = RB_ROOT_CACHED;
741 75847056 : INIT_LIST_HEAD(&head_ref->ref_add_list);
742 75847056 : RB_CLEAR_NODE(&head_ref->href_node);
743 75847056 : head_ref->processing = false;
744 75847056 : head_ref->total_ref_mod = count_mod;
745 75847056 : spin_lock_init(&head_ref->lock);
746 75843346 : mutex_init(&head_ref->mutex);
747 :
748 75845824 : if (qrecord) {
749 223450 : if (ref_root && reserved) {
750 17682 : qrecord->data_rsv = reserved;
751 17682 : qrecord->data_rsv_refroot = ref_root;
752 : }
753 223450 : qrecord->bytenr = bytenr;
754 223450 : qrecord->num_bytes = num_bytes;
755 223450 : qrecord->old_roots = NULL;
756 : }
757 75845824 : }
758 :
759 : /*
760 : * helper function to actually insert a head node into the rbtree.
761 : * this does all the dirty work in terms of maintaining the correct
762 : * overall modification count.
763 : */
764 : static noinline struct btrfs_delayed_ref_head *
765 75848646 : add_delayed_ref_head(struct btrfs_trans_handle *trans,
766 : struct btrfs_delayed_ref_head *head_ref,
767 : struct btrfs_qgroup_extent_record *qrecord,
768 : int action, bool *qrecord_inserted_ret)
769 : {
770 75848646 : struct btrfs_delayed_ref_head *existing;
771 75848646 : struct btrfs_delayed_ref_root *delayed_refs;
772 75848646 : bool qrecord_inserted = false;
773 :
774 75848646 : delayed_refs = &trans->transaction->delayed_refs;
775 :
776 : /* Record qgroup extent info if provided */
777 75848646 : if (qrecord) {
778 223465 : if (btrfs_qgroup_trace_extent_nolock(trans->fs_info,
779 : delayed_refs, qrecord))
780 47814 : kfree(qrecord);
781 : else
782 : qrecord_inserted = true;
783 : }
784 :
785 75848646 : trace_add_delayed_ref_head(trans->fs_info, head_ref, action);
786 :
787 75848643 : existing = htree_insert(&delayed_refs->href_root,
788 : &head_ref->href_node);
789 75848642 : if (existing) {
790 25281991 : update_existing_head_ref(trans, existing, head_ref);
791 : /*
792 : * we've updated the existing ref, free the newly
793 : * allocated ref
794 : */
795 25281991 : kmem_cache_free(btrfs_delayed_ref_head_cachep, head_ref);
796 25281991 : head_ref = existing;
797 : } else {
798 50566651 : if (head_ref->is_data && head_ref->ref_mod < 0) {
799 7262765 : delayed_refs->pending_csums += head_ref->num_bytes;
800 7262765 : trans->delayed_ref_updates +=
801 7262765 : btrfs_csum_bytes_to_leaves(trans->fs_info,
802 : head_ref->num_bytes);
803 : }
804 50566651 : delayed_refs->num_heads++;
805 50566651 : delayed_refs->num_heads_ready++;
806 50566651 : atomic_inc(&delayed_refs->num_entries);
807 50566659 : trans->delayed_ref_updates++;
808 : }
809 75848650 : if (qrecord_inserted_ret)
810 75779288 : *qrecord_inserted_ret = qrecord_inserted;
811 :
812 75848650 : return head_ref;
813 : }
814 :
815 : /*
816 : * init_delayed_ref_common - Initialize the structure which represents a
817 : * modification to a an extent.
818 : *
819 : * @fs_info: Internal to the mounted filesystem mount structure.
820 : *
821 : * @ref: The structure which is going to be initialized.
822 : *
823 : * @bytenr: The logical address of the extent for which a modification is
824 : * going to be recorded.
825 : *
826 : * @num_bytes: Size of the extent whose modification is being recorded.
827 : *
828 : * @ref_root: The id of the root where this modification has originated, this
829 : * can be either one of the well-known metadata trees or the
830 : * subvolume id which references this extent.
831 : *
832 : * @action: Can be one of BTRFS_ADD_DELAYED_REF/BTRFS_DROP_DELAYED_REF or
833 : * BTRFS_ADD_DELAYED_EXTENT
834 : *
835 : * @ref_type: Holds the type of the extent which is being recorded, can be
836 : * one of BTRFS_SHARED_BLOCK_REF_KEY/BTRFS_TREE_BLOCK_REF_KEY
837 : * when recording a metadata extent or BTRFS_SHARED_DATA_REF_KEY/
838 : * BTRFS_EXTENT_DATA_REF_KEY when recording data extent
839 : */
840 75778184 : static void init_delayed_ref_common(struct btrfs_fs_info *fs_info,
841 : struct btrfs_delayed_ref_node *ref,
842 : u64 bytenr, u64 num_bytes, u64 ref_root,
843 : int action, u8 ref_type)
844 : {
845 75778184 : u64 seq = 0;
846 :
847 75778184 : if (action == BTRFS_ADD_DELAYED_EXTENT)
848 12156925 : action = BTRFS_ADD_DELAYED_REF;
849 :
850 75778184 : if (is_fstree(ref_root))
851 57242093 : seq = atomic64_read(&fs_info->tree_mod_seq);
852 :
853 75778184 : refcount_set(&ref->refs, 1);
854 75778184 : ref->bytenr = bytenr;
855 75778184 : ref->num_bytes = num_bytes;
856 75778184 : ref->ref_mod = 1;
857 75778184 : ref->action = action;
858 75778184 : ref->seq = seq;
859 75778184 : ref->type = ref_type;
860 75778184 : RB_CLEAR_NODE(&ref->ref_node);
861 75778184 : INIT_LIST_HEAD(&ref->add_list);
862 75778184 : }
863 :
864 : /*
865 : * add a delayed tree ref. This does all of the accounting required
866 : * to make sure the delayed ref is eventually processed before this
867 : * transaction commits.
868 : */
869 33759079 : int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans,
870 : struct btrfs_ref *generic_ref,
871 : struct btrfs_delayed_extent_op *extent_op)
872 : {
873 33759079 : struct btrfs_fs_info *fs_info = trans->fs_info;
874 33759079 : struct btrfs_delayed_tree_ref *ref;
875 33759079 : struct btrfs_delayed_ref_head *head_ref;
876 33759079 : struct btrfs_delayed_ref_root *delayed_refs;
877 33759079 : struct btrfs_qgroup_extent_record *record = NULL;
878 33759079 : bool qrecord_inserted;
879 33759079 : bool is_system;
880 33759079 : bool merged;
881 33759079 : int action = generic_ref->action;
882 33759079 : int level = generic_ref->tree_ref.level;
883 33759079 : u64 bytenr = generic_ref->bytenr;
884 33759079 : u64 num_bytes = generic_ref->len;
885 33759079 : u64 parent = generic_ref->parent;
886 33759079 : u8 ref_type;
887 :
888 33759079 : is_system = (generic_ref->tree_ref.owning_root == BTRFS_CHUNK_TREE_OBJECTID);
889 :
890 33759079 : ASSERT(generic_ref->type == BTRFS_REF_METADATA && generic_ref->action);
891 33759079 : ref = kmem_cache_alloc(btrfs_delayed_tree_ref_cachep, GFP_NOFS);
892 33759335 : if (!ref)
893 : return -ENOMEM;
894 :
895 33759335 : head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
896 33759128 : if (!head_ref) {
897 0 : kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref);
898 0 : return -ENOMEM;
899 : }
900 :
901 67518256 : if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) &&
902 330309 : !generic_ref->skip_qgroup) {
903 166619 : record = kzalloc(sizeof(*record), GFP_NOFS);
904 166615 : if (!record) {
905 0 : kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref);
906 0 : kmem_cache_free(btrfs_delayed_ref_head_cachep, head_ref);
907 0 : return -ENOMEM;
908 : }
909 : }
910 :
911 33759124 : if (parent)
912 : ref_type = BTRFS_SHARED_BLOCK_REF_KEY;
913 : else
914 12743751 : ref_type = BTRFS_TREE_BLOCK_REF_KEY;
915 :
916 33759124 : init_delayed_ref_common(fs_info, &ref->node, bytenr, num_bytes,
917 : generic_ref->tree_ref.owning_root, action,
918 : ref_type);
919 33757674 : ref->root = generic_ref->tree_ref.owning_root;
920 33757674 : ref->parent = parent;
921 33757674 : ref->level = level;
922 :
923 33757674 : init_delayed_ref_head(head_ref, record, bytenr, num_bytes,
924 : generic_ref->tree_ref.owning_root, 0, action,
925 : false, is_system);
926 33758981 : head_ref->extent_op = extent_op;
927 :
928 33758981 : delayed_refs = &trans->transaction->delayed_refs;
929 33758981 : spin_lock(&delayed_refs->lock);
930 :
931 : /*
932 : * insert both the head node and the new ref without dropping
933 : * the spin lock
934 : */
935 33760102 : head_ref = add_delayed_ref_head(trans, head_ref, record,
936 : action, &qrecord_inserted);
937 :
938 33760102 : merged = insert_delayed_ref(delayed_refs, head_ref, &ref->node);
939 33760102 : spin_unlock(&delayed_refs->lock);
940 :
941 : /*
942 : * Need to update the delayed_refs_rsv with any changes we may have
943 : * made.
944 : */
945 33760102 : btrfs_update_delayed_refs_rsv(trans);
946 :
947 42104103 : trace_add_delayed_tree_ref(fs_info, &ref->node, ref,
948 : action == BTRFS_ADD_DELAYED_EXTENT ?
949 : BTRFS_ADD_DELAYED_REF : action);
950 33760100 : if (merged)
951 1419184 : kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref);
952 :
953 33760100 : if (qrecord_inserted)
954 127396 : btrfs_qgroup_trace_extent_post(trans, record);
955 :
956 : return 0;
957 : }
958 :
959 : /*
960 : * add a delayed data ref. it's similar to btrfs_add_delayed_tree_ref.
961 : */
962 42018948 : int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans,
963 : struct btrfs_ref *generic_ref,
964 : u64 reserved)
965 : {
966 42018948 : struct btrfs_fs_info *fs_info = trans->fs_info;
967 42018948 : struct btrfs_delayed_data_ref *ref;
968 42018948 : struct btrfs_delayed_ref_head *head_ref;
969 42018948 : struct btrfs_delayed_ref_root *delayed_refs;
970 42018948 : struct btrfs_qgroup_extent_record *record = NULL;
971 42018948 : bool qrecord_inserted;
972 42018948 : int action = generic_ref->action;
973 42018948 : bool merged;
974 42018948 : u64 bytenr = generic_ref->bytenr;
975 42018948 : u64 num_bytes = generic_ref->len;
976 42018948 : u64 parent = generic_ref->parent;
977 42018948 : u64 ref_root = generic_ref->data_ref.owning_root;
978 42018948 : u64 owner = generic_ref->data_ref.ino;
979 42018948 : u64 offset = generic_ref->data_ref.offset;
980 42018948 : u8 ref_type;
981 :
982 42018948 : ASSERT(generic_ref->type == BTRFS_REF_DATA && action);
983 42018948 : ref = kmem_cache_alloc(btrfs_delayed_data_ref_cachep, GFP_NOFS);
984 42018943 : if (!ref)
985 : return -ENOMEM;
986 :
987 42018943 : if (parent)
988 : ref_type = BTRFS_SHARED_DATA_REF_KEY;
989 : else
990 24850761 : ref_type = BTRFS_EXTENT_DATA_REF_KEY;
991 42018943 : init_delayed_ref_common(fs_info, &ref->node, bytenr, num_bytes,
992 : ref_root, action, ref_type);
993 42018533 : ref->root = ref_root;
994 42018533 : ref->parent = parent;
995 42018533 : ref->objectid = owner;
996 42018533 : ref->offset = offset;
997 :
998 :
999 42018533 : head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
1000 42018864 : if (!head_ref) {
1001 0 : kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
1002 0 : return -ENOMEM;
1003 : }
1004 :
1005 84037728 : if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) &&
1006 97283 : !generic_ref->skip_qgroup) {
1007 56833 : record = kzalloc(sizeof(*record), GFP_NOFS);
1008 56832 : if (!record) {
1009 0 : kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
1010 0 : kmem_cache_free(btrfs_delayed_ref_head_cachep,
1011 : head_ref);
1012 0 : return -ENOMEM;
1013 : }
1014 : }
1015 :
1016 42018863 : init_delayed_ref_head(head_ref, record, bytenr, num_bytes, ref_root,
1017 : reserved, action, true, false);
1018 42018884 : head_ref->extent_op = NULL;
1019 :
1020 42018884 : delayed_refs = &trans->transaction->delayed_refs;
1021 42018884 : spin_lock(&delayed_refs->lock);
1022 :
1023 : /*
1024 : * insert both the head node and the new ref without dropping
1025 : * the spin lock
1026 : */
1027 42019185 : head_ref = add_delayed_ref_head(trans, head_ref, record,
1028 : action, &qrecord_inserted);
1029 :
1030 42019186 : merged = insert_delayed_ref(delayed_refs, head_ref, &ref->node);
1031 42019179 : spin_unlock(&delayed_refs->lock);
1032 :
1033 : /*
1034 : * Need to update the delayed_refs_rsv with any changes we may have
1035 : * made.
1036 : */
1037 42019183 : btrfs_update_delayed_refs_rsv(trans);
1038 :
1039 45832460 : trace_add_delayed_data_ref(trans->fs_info, &ref->node, ref,
1040 : action == BTRFS_ADD_DELAYED_EXTENT ?
1041 : BTRFS_ADD_DELAYED_REF : action);
1042 42019176 : if (merged)
1043 6861846 : kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
1044 :
1045 :
1046 42019176 : if (qrecord_inserted)
1047 48255 : return btrfs_qgroup_trace_extent_post(trans, record);
1048 : return 0;
1049 : }
1050 :
1051 69362 : int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans,
1052 : u64 bytenr, u64 num_bytes,
1053 : struct btrfs_delayed_extent_op *extent_op)
1054 : {
1055 69362 : struct btrfs_delayed_ref_head *head_ref;
1056 69362 : struct btrfs_delayed_ref_root *delayed_refs;
1057 :
1058 69362 : head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
1059 69362 : if (!head_ref)
1060 : return -ENOMEM;
1061 :
1062 69362 : init_delayed_ref_head(head_ref, NULL, bytenr, num_bytes, 0, 0,
1063 : BTRFS_UPDATE_DELAYED_HEAD, false, false);
1064 69362 : head_ref->extent_op = extent_op;
1065 :
1066 69362 : delayed_refs = &trans->transaction->delayed_refs;
1067 69362 : spin_lock(&delayed_refs->lock);
1068 :
1069 69362 : add_delayed_ref_head(trans, head_ref, NULL, BTRFS_UPDATE_DELAYED_HEAD,
1070 : NULL);
1071 :
1072 69362 : spin_unlock(&delayed_refs->lock);
1073 :
1074 : /*
1075 : * Need to update the delayed_refs_rsv with any changes we may have
1076 : * made.
1077 : */
1078 69362 : btrfs_update_delayed_refs_rsv(trans);
1079 69362 : return 0;
1080 : }
1081 :
1082 : /*
1083 : * This does a simple search for the head node for a given extent. Returns the
1084 : * head node if found, or NULL if not.
1085 : */
1086 : struct btrfs_delayed_ref_head *
1087 12689500 : btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, u64 bytenr)
1088 : {
1089 12689500 : lockdep_assert_held(&delayed_refs->lock);
1090 :
1091 12689500 : return find_ref_head(delayed_refs, bytenr, false);
1092 : }
1093 :
1094 0 : void __cold btrfs_delayed_ref_exit(void)
1095 : {
1096 0 : kmem_cache_destroy(btrfs_delayed_ref_head_cachep);
1097 0 : kmem_cache_destroy(btrfs_delayed_tree_ref_cachep);
1098 0 : kmem_cache_destroy(btrfs_delayed_data_ref_cachep);
1099 0 : kmem_cache_destroy(btrfs_delayed_extent_op_cachep);
1100 0 : }
1101 :
1102 11 : int __init btrfs_delayed_ref_init(void)
1103 : {
1104 11 : btrfs_delayed_ref_head_cachep = kmem_cache_create(
1105 : "btrfs_delayed_ref_head",
1106 : sizeof(struct btrfs_delayed_ref_head), 0,
1107 : SLAB_MEM_SPREAD, NULL);
1108 11 : if (!btrfs_delayed_ref_head_cachep)
1109 0 : goto fail;
1110 :
1111 11 : btrfs_delayed_tree_ref_cachep = kmem_cache_create(
1112 : "btrfs_delayed_tree_ref",
1113 : sizeof(struct btrfs_delayed_tree_ref), 0,
1114 : SLAB_MEM_SPREAD, NULL);
1115 11 : if (!btrfs_delayed_tree_ref_cachep)
1116 0 : goto fail;
1117 :
1118 11 : btrfs_delayed_data_ref_cachep = kmem_cache_create(
1119 : "btrfs_delayed_data_ref",
1120 : sizeof(struct btrfs_delayed_data_ref), 0,
1121 : SLAB_MEM_SPREAD, NULL);
1122 11 : if (!btrfs_delayed_data_ref_cachep)
1123 0 : goto fail;
1124 :
1125 11 : btrfs_delayed_extent_op_cachep = kmem_cache_create(
1126 : "btrfs_delayed_extent_op",
1127 : sizeof(struct btrfs_delayed_extent_op), 0,
1128 : SLAB_MEM_SPREAD, NULL);
1129 11 : if (!btrfs_delayed_extent_op_cachep)
1130 0 : goto fail;
1131 :
1132 : return 0;
1133 0 : fail:
1134 0 : btrfs_delayed_ref_exit();
1135 0 : return -ENOMEM;
1136 : }
|
