2 * Copyright (C) 2009 Oracle. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <linux/sort.h>
23 #include "delayed-ref.h"
24 #include "transaction.h"
27 struct kmem_cache
*btrfs_delayed_ref_head_cachep
;
28 struct kmem_cache
*btrfs_delayed_tree_ref_cachep
;
29 struct kmem_cache
*btrfs_delayed_data_ref_cachep
;
30 struct kmem_cache
*btrfs_delayed_extent_op_cachep
;
32 * delayed back reference update tracking. For subvolume trees
33 * we queue up extent allocations and backref maintenance for
34 * delayed processing. This avoids deep call chains where we
35 * add extents in the middle of btrfs_search_slot, and it allows
36 * us to buffer up frequently modified backrefs in an rb tree instead
37 * of hammering updates on the extent allocation tree.
41 * compare two delayed tree backrefs with same bytenr and type
43 static int comp_tree_refs(struct btrfs_delayed_tree_ref
*ref2
,
44 struct btrfs_delayed_tree_ref
*ref1
, int type
)
46 if (type
== BTRFS_TREE_BLOCK_REF_KEY
) {
47 if (ref1
->root
< ref2
->root
)
49 if (ref1
->root
> ref2
->root
)
52 if (ref1
->parent
< ref2
->parent
)
54 if (ref1
->parent
> ref2
->parent
)
61 * compare two delayed data backrefs with same bytenr and type
63 static int comp_data_refs(struct btrfs_delayed_data_ref
*ref2
,
64 struct btrfs_delayed_data_ref
*ref1
)
66 if (ref1
->node
.type
== BTRFS_EXTENT_DATA_REF_KEY
) {
67 if (ref1
->root
< ref2
->root
)
69 if (ref1
->root
> ref2
->root
)
71 if (ref1
->objectid
< ref2
->objectid
)
73 if (ref1
->objectid
> ref2
->objectid
)
75 if (ref1
->offset
< ref2
->offset
)
77 if (ref1
->offset
> ref2
->offset
)
80 if (ref1
->parent
< ref2
->parent
)
82 if (ref1
->parent
> ref2
->parent
)
88 /* insert a new ref to head ref rbtree */
89 static struct btrfs_delayed_ref_head
*htree_insert(struct rb_root
*root
,
92 struct rb_node
**p
= &root
->rb_node
;
93 struct rb_node
*parent_node
= NULL
;
94 struct btrfs_delayed_ref_head
*entry
;
95 struct btrfs_delayed_ref_head
*ins
;
98 ins
= rb_entry(node
, struct btrfs_delayed_ref_head
, href_node
);
99 bytenr
= ins
->node
.bytenr
;
102 entry
= rb_entry(parent_node
, struct btrfs_delayed_ref_head
,
105 if (bytenr
< entry
->node
.bytenr
)
107 else if (bytenr
> entry
->node
.bytenr
)
113 rb_link_node(node
, parent_node
, p
);
114 rb_insert_color(node
, root
);
119 * find an head entry based on bytenr. This returns the delayed ref
120 * head if it was able to find one, or NULL if nothing was in that spot.
121 * If return_bigger is given, the next bigger entry is returned if no exact
124 static struct btrfs_delayed_ref_head
*
125 find_ref_head(struct rb_root
*root
, u64 bytenr
,
129 struct btrfs_delayed_ref_head
*entry
;
134 entry
= rb_entry(n
, struct btrfs_delayed_ref_head
, href_node
);
136 if (bytenr
< entry
->node
.bytenr
)
138 else if (bytenr
> entry
->node
.bytenr
)
143 if (entry
&& return_bigger
) {
144 if (bytenr
> entry
->node
.bytenr
) {
145 n
= rb_next(&entry
->href_node
);
148 entry
= rb_entry(n
, struct btrfs_delayed_ref_head
,
157 int btrfs_delayed_ref_lock(struct btrfs_trans_handle
*trans
,
158 struct btrfs_delayed_ref_head
*head
)
160 struct btrfs_delayed_ref_root
*delayed_refs
;
162 delayed_refs
= &trans
->transaction
->delayed_refs
;
163 assert_spin_locked(&delayed_refs
->lock
);
164 if (mutex_trylock(&head
->mutex
))
167 atomic_inc(&head
->node
.refs
);
168 spin_unlock(&delayed_refs
->lock
);
170 mutex_lock(&head
->mutex
);
171 spin_lock(&delayed_refs
->lock
);
172 if (!head
->node
.in_tree
) {
173 mutex_unlock(&head
->mutex
);
174 btrfs_put_delayed_ref(&head
->node
);
177 btrfs_put_delayed_ref(&head
->node
);
181 static inline void drop_delayed_ref(struct btrfs_trans_handle
*trans
,
182 struct btrfs_delayed_ref_root
*delayed_refs
,
183 struct btrfs_delayed_ref_head
*head
,
184 struct btrfs_delayed_ref_node
*ref
)
186 if (btrfs_delayed_ref_is_head(ref
)) {
187 head
= btrfs_delayed_node_to_head(ref
);
188 rb_erase(&head
->href_node
, &delayed_refs
->href_root
);
190 assert_spin_locked(&head
->lock
);
191 list_del(&ref
->list
);
194 btrfs_put_delayed_ref(ref
);
195 atomic_dec(&delayed_refs
->num_entries
);
196 if (trans
->delayed_ref_updates
)
197 trans
->delayed_ref_updates
--;
200 int btrfs_check_delayed_seq(struct btrfs_fs_info
*fs_info
,
201 struct btrfs_delayed_ref_root
*delayed_refs
,
204 struct seq_list
*elem
;
207 spin_lock(&fs_info
->tree_mod_seq_lock
);
208 if (!list_empty(&fs_info
->tree_mod_seq_list
)) {
209 elem
= list_first_entry(&fs_info
->tree_mod_seq_list
,
210 struct seq_list
, list
);
211 if (seq
>= elem
->seq
) {
212 pr_debug("holding back delayed_ref %#x.%x, lowest is %#x.%x (%p)\n",
213 (u32
)(seq
>> 32), (u32
)seq
,
214 (u32
)(elem
->seq
>> 32), (u32
)elem
->seq
,
220 spin_unlock(&fs_info
->tree_mod_seq_lock
);
224 struct btrfs_delayed_ref_head
*
225 btrfs_select_ref_head(struct btrfs_trans_handle
*trans
)
227 struct btrfs_delayed_ref_root
*delayed_refs
;
228 struct btrfs_delayed_ref_head
*head
;
232 delayed_refs
= &trans
->transaction
->delayed_refs
;
235 start
= delayed_refs
->run_delayed_start
;
236 head
= find_ref_head(&delayed_refs
->href_root
, start
, 1);
237 if (!head
&& !loop
) {
238 delayed_refs
->run_delayed_start
= 0;
241 head
= find_ref_head(&delayed_refs
->href_root
, start
, 1);
244 } else if (!head
&& loop
) {
248 while (head
->processing
) {
249 struct rb_node
*node
;
251 node
= rb_next(&head
->href_node
);
255 delayed_refs
->run_delayed_start
= 0;
260 head
= rb_entry(node
, struct btrfs_delayed_ref_head
,
264 head
->processing
= 1;
265 WARN_ON(delayed_refs
->num_heads_ready
== 0);
266 delayed_refs
->num_heads_ready
--;
267 delayed_refs
->run_delayed_start
= head
->node
.bytenr
+
268 head
->node
.num_bytes
;
273 * Helper to insert the ref_node to the tail or merge with tail.
275 * Return 0 for insert.
276 * Return >0 for merge.
279 add_delayed_ref_tail_merge(struct btrfs_trans_handle
*trans
,
280 struct btrfs_delayed_ref_root
*root
,
281 struct btrfs_delayed_ref_head
*href
,
282 struct btrfs_delayed_ref_node
*ref
)
284 struct btrfs_delayed_ref_node
*exist
;
288 spin_lock(&href
->lock
);
289 /* Check whether we can merge the tail node with ref */
290 if (list_empty(&href
->ref_list
))
292 exist
= list_entry(href
->ref_list
.prev
, struct btrfs_delayed_ref_node
,
294 /* No need to compare bytenr nor is_head */
295 if (exist
->type
!= ref
->type
|| exist
->no_quota
!= ref
->no_quota
||
296 exist
->seq
!= ref
->seq
)
299 if ((exist
->type
== BTRFS_TREE_BLOCK_REF_KEY
||
300 exist
->type
== BTRFS_SHARED_BLOCK_REF_KEY
) &&
301 comp_tree_refs(btrfs_delayed_node_to_tree_ref(exist
),
302 btrfs_delayed_node_to_tree_ref(ref
),
305 if ((exist
->type
== BTRFS_EXTENT_DATA_REF_KEY
||
306 exist
->type
== BTRFS_SHARED_DATA_REF_KEY
) &&
307 comp_data_refs(btrfs_delayed_node_to_data_ref(exist
),
308 btrfs_delayed_node_to_data_ref(ref
)))
311 /* Now we are sure we can merge */
313 if (exist
->action
== ref
->action
) {
316 /* Need to change action */
317 if (exist
->ref_mod
< ref
->ref_mod
) {
318 exist
->action
= ref
->action
;
319 mod
= -exist
->ref_mod
;
320 exist
->ref_mod
= ref
->ref_mod
;
324 exist
->ref_mod
+= mod
;
326 /* remove existing tail if its ref_mod is zero */
327 if (exist
->ref_mod
== 0)
328 drop_delayed_ref(trans
, root
, href
, exist
);
329 spin_unlock(&href
->lock
);
333 list_add_tail(&ref
->list
, &href
->ref_list
);
334 atomic_inc(&root
->num_entries
);
335 trans
->delayed_ref_updates
++;
336 spin_unlock(&href
->lock
);
341 * helper function to update the accounting in the head ref
342 * existing and update must have the same bytenr
345 update_existing_head_ref(struct btrfs_delayed_ref_root
*delayed_refs
,
346 struct btrfs_delayed_ref_node
*existing
,
347 struct btrfs_delayed_ref_node
*update
)
349 struct btrfs_delayed_ref_head
*existing_ref
;
350 struct btrfs_delayed_ref_head
*ref
;
353 existing_ref
= btrfs_delayed_node_to_head(existing
);
354 ref
= btrfs_delayed_node_to_head(update
);
355 BUG_ON(existing_ref
->is_data
!= ref
->is_data
);
357 spin_lock(&existing_ref
->lock
);
358 if (ref
->must_insert_reserved
) {
359 /* if the extent was freed and then
360 * reallocated before the delayed ref
361 * entries were processed, we can end up
362 * with an existing head ref without
363 * the must_insert_reserved flag set.
366 existing_ref
->must_insert_reserved
= ref
->must_insert_reserved
;
369 * update the num_bytes so we make sure the accounting
372 existing
->num_bytes
= update
->num_bytes
;
376 if (ref
->extent_op
) {
377 if (!existing_ref
->extent_op
) {
378 existing_ref
->extent_op
= ref
->extent_op
;
380 if (ref
->extent_op
->update_key
) {
381 memcpy(&existing_ref
->extent_op
->key
,
382 &ref
->extent_op
->key
,
383 sizeof(ref
->extent_op
->key
));
384 existing_ref
->extent_op
->update_key
= 1;
386 if (ref
->extent_op
->update_flags
) {
387 existing_ref
->extent_op
->flags_to_set
|=
388 ref
->extent_op
->flags_to_set
;
389 existing_ref
->extent_op
->update_flags
= 1;
391 btrfs_free_delayed_extent_op(ref
->extent_op
);
395 * update the reference mod on the head to reflect this new operation,
396 * only need the lock for this case cause we could be processing it
397 * currently, for refs we just added we know we're a-ok.
399 old_ref_mod
= existing_ref
->total_ref_mod
;
400 existing
->ref_mod
+= update
->ref_mod
;
401 existing_ref
->total_ref_mod
+= update
->ref_mod
;
404 * If we are going to from a positive ref mod to a negative or vice
405 * versa we need to make sure to adjust pending_csums accordingly.
407 if (existing_ref
->is_data
) {
408 if (existing_ref
->total_ref_mod
>= 0 && old_ref_mod
< 0)
409 delayed_refs
->pending_csums
-= existing
->num_bytes
;
410 if (existing_ref
->total_ref_mod
< 0 && old_ref_mod
>= 0)
411 delayed_refs
->pending_csums
+= existing
->num_bytes
;
413 spin_unlock(&existing_ref
->lock
);
417 * helper function to actually insert a head node into the rbtree.
418 * this does all the dirty work in terms of maintaining the correct
419 * overall modification count.
421 static noinline
struct btrfs_delayed_ref_head
*
422 add_delayed_ref_head(struct btrfs_fs_info
*fs_info
,
423 struct btrfs_trans_handle
*trans
,
424 struct btrfs_delayed_ref_node
*ref
,
425 struct btrfs_qgroup_extent_record
*qrecord
,
426 u64 bytenr
, u64 num_bytes
, int action
, int is_data
)
428 struct btrfs_delayed_ref_head
*existing
;
429 struct btrfs_delayed_ref_head
*head_ref
= NULL
;
430 struct btrfs_delayed_ref_root
*delayed_refs
;
431 struct btrfs_qgroup_extent_record
*qexisting
;
433 int must_insert_reserved
= 0;
436 * the head node stores the sum of all the mods, so dropping a ref
437 * should drop the sum in the head node by one.
439 if (action
== BTRFS_UPDATE_DELAYED_HEAD
)
441 else if (action
== BTRFS_DROP_DELAYED_REF
)
445 * BTRFS_ADD_DELAYED_EXTENT means that we need to update
446 * the reserved accounting when the extent is finally added, or
447 * if a later modification deletes the delayed ref without ever
448 * inserting the extent into the extent allocation tree.
449 * ref->must_insert_reserved is the flag used to record
450 * that accounting mods are required.
452 * Once we record must_insert_reserved, switch the action to
453 * BTRFS_ADD_DELAYED_REF because other special casing is not required.
455 if (action
== BTRFS_ADD_DELAYED_EXTENT
)
456 must_insert_reserved
= 1;
458 must_insert_reserved
= 0;
460 delayed_refs
= &trans
->transaction
->delayed_refs
;
462 /* first set the basic ref node struct up */
463 atomic_set(&ref
->refs
, 1);
464 ref
->bytenr
= bytenr
;
465 ref
->num_bytes
= num_bytes
;
466 ref
->ref_mod
= count_mod
;
473 head_ref
= btrfs_delayed_node_to_head(ref
);
474 head_ref
->must_insert_reserved
= must_insert_reserved
;
475 head_ref
->is_data
= is_data
;
476 INIT_LIST_HEAD(&head_ref
->ref_list
);
477 head_ref
->processing
= 0;
478 head_ref
->total_ref_mod
= count_mod
;
479 head_ref
->qgroup_reserved
= 0;
480 head_ref
->qgroup_ref_root
= 0;
482 /* Record qgroup extent info if provided */
484 qrecord
->bytenr
= bytenr
;
485 qrecord
->num_bytes
= num_bytes
;
486 qrecord
->old_roots
= NULL
;
488 qexisting
= btrfs_qgroup_insert_dirty_extent(delayed_refs
,
494 spin_lock_init(&head_ref
->lock
);
495 mutex_init(&head_ref
->mutex
);
497 trace_add_delayed_ref_head(ref
, head_ref
, action
);
499 existing
= htree_insert(&delayed_refs
->href_root
,
500 &head_ref
->href_node
);
502 update_existing_head_ref(delayed_refs
, &existing
->node
, ref
);
504 * we've updated the existing ref, free the newly
507 kmem_cache_free(btrfs_delayed_ref_head_cachep
, head_ref
);
510 if (is_data
&& count_mod
< 0)
511 delayed_refs
->pending_csums
+= num_bytes
;
512 delayed_refs
->num_heads
++;
513 delayed_refs
->num_heads_ready
++;
514 atomic_inc(&delayed_refs
->num_entries
);
515 trans
->delayed_ref_updates
++;
521 * helper to insert a delayed tree ref into the rbtree.
524 add_delayed_tree_ref(struct btrfs_fs_info
*fs_info
,
525 struct btrfs_trans_handle
*trans
,
526 struct btrfs_delayed_ref_head
*head_ref
,
527 struct btrfs_delayed_ref_node
*ref
, u64 bytenr
,
528 u64 num_bytes
, u64 parent
, u64 ref_root
, int level
,
529 int action
, int no_quota
)
531 struct btrfs_delayed_tree_ref
*full_ref
;
532 struct btrfs_delayed_ref_root
*delayed_refs
;
536 if (action
== BTRFS_ADD_DELAYED_EXTENT
)
537 action
= BTRFS_ADD_DELAYED_REF
;
539 if (is_fstree(ref_root
))
540 seq
= atomic64_read(&fs_info
->tree_mod_seq
);
541 delayed_refs
= &trans
->transaction
->delayed_refs
;
543 /* first set the basic ref node struct up */
544 atomic_set(&ref
->refs
, 1);
545 ref
->bytenr
= bytenr
;
546 ref
->num_bytes
= num_bytes
;
548 ref
->action
= action
;
551 ref
->no_quota
= no_quota
;
554 full_ref
= btrfs_delayed_node_to_tree_ref(ref
);
555 full_ref
->parent
= parent
;
556 full_ref
->root
= ref_root
;
558 ref
->type
= BTRFS_SHARED_BLOCK_REF_KEY
;
560 ref
->type
= BTRFS_TREE_BLOCK_REF_KEY
;
561 full_ref
->level
= level
;
563 trace_add_delayed_tree_ref(ref
, full_ref
, action
);
565 ret
= add_delayed_ref_tail_merge(trans
, delayed_refs
, head_ref
, ref
);
568 * XXX: memory should be freed at the same level allocated.
569 * But bad practice is anywhere... Follow it now. Need cleanup.
572 kmem_cache_free(btrfs_delayed_tree_ref_cachep
, full_ref
);
576 * helper to insert a delayed data ref into the rbtree.
579 add_delayed_data_ref(struct btrfs_fs_info
*fs_info
,
580 struct btrfs_trans_handle
*trans
,
581 struct btrfs_delayed_ref_head
*head_ref
,
582 struct btrfs_delayed_ref_node
*ref
, u64 bytenr
,
583 u64 num_bytes
, u64 parent
, u64 ref_root
, u64 owner
,
584 u64 offset
, int action
, int no_quota
)
586 struct btrfs_delayed_data_ref
*full_ref
;
587 struct btrfs_delayed_ref_root
*delayed_refs
;
591 if (action
== BTRFS_ADD_DELAYED_EXTENT
)
592 action
= BTRFS_ADD_DELAYED_REF
;
594 delayed_refs
= &trans
->transaction
->delayed_refs
;
596 if (is_fstree(ref_root
))
597 seq
= atomic64_read(&fs_info
->tree_mod_seq
);
599 /* first set the basic ref node struct up */
600 atomic_set(&ref
->refs
, 1);
601 ref
->bytenr
= bytenr
;
602 ref
->num_bytes
= num_bytes
;
604 ref
->action
= action
;
607 ref
->no_quota
= no_quota
;
610 full_ref
= btrfs_delayed_node_to_data_ref(ref
);
611 full_ref
->parent
= parent
;
612 full_ref
->root
= ref_root
;
614 ref
->type
= BTRFS_SHARED_DATA_REF_KEY
;
616 ref
->type
= BTRFS_EXTENT_DATA_REF_KEY
;
618 full_ref
->objectid
= owner
;
619 full_ref
->offset
= offset
;
621 trace_add_delayed_data_ref(ref
, full_ref
, action
);
623 ret
= add_delayed_ref_tail_merge(trans
, delayed_refs
, head_ref
, ref
);
626 kmem_cache_free(btrfs_delayed_data_ref_cachep
, full_ref
);
630 * add a delayed tree ref. This does all of the accounting required
631 * to make sure the delayed ref is eventually processed before this
632 * transaction commits.
634 int btrfs_add_delayed_tree_ref(struct btrfs_fs_info
*fs_info
,
635 struct btrfs_trans_handle
*trans
,
636 u64 bytenr
, u64 num_bytes
, u64 parent
,
637 u64 ref_root
, int level
, int action
,
638 struct btrfs_delayed_extent_op
*extent_op
,
641 struct btrfs_delayed_tree_ref
*ref
;
642 struct btrfs_delayed_ref_head
*head_ref
;
643 struct btrfs_delayed_ref_root
*delayed_refs
;
644 struct btrfs_qgroup_extent_record
*record
= NULL
;
646 if (!is_fstree(ref_root
) || !fs_info
->quota_enabled
)
649 BUG_ON(extent_op
&& extent_op
->is_data
);
650 ref
= kmem_cache_alloc(btrfs_delayed_tree_ref_cachep
, GFP_NOFS
);
654 head_ref
= kmem_cache_alloc(btrfs_delayed_ref_head_cachep
, GFP_NOFS
);
658 if (fs_info
->quota_enabled
&& is_fstree(ref_root
)) {
659 record
= kmalloc(sizeof(*record
), GFP_NOFS
);
664 head_ref
->extent_op
= extent_op
;
666 delayed_refs
= &trans
->transaction
->delayed_refs
;
667 spin_lock(&delayed_refs
->lock
);
670 * insert both the head node and the new ref without dropping
673 head_ref
= add_delayed_ref_head(fs_info
, trans
, &head_ref
->node
, record
,
674 bytenr
, num_bytes
, action
, 0);
676 add_delayed_tree_ref(fs_info
, trans
, head_ref
, &ref
->node
, bytenr
,
677 num_bytes
, parent
, ref_root
, level
, action
,
679 spin_unlock(&delayed_refs
->lock
);
684 kmem_cache_free(btrfs_delayed_ref_head_cachep
, head_ref
);
686 kmem_cache_free(btrfs_delayed_tree_ref_cachep
, ref
);
692 * add a delayed data ref. it's similar to btrfs_add_delayed_tree_ref.
694 int btrfs_add_delayed_data_ref(struct btrfs_fs_info
*fs_info
,
695 struct btrfs_trans_handle
*trans
,
696 u64 bytenr
, u64 num_bytes
,
697 u64 parent
, u64 ref_root
,
698 u64 owner
, u64 offset
, int action
,
699 struct btrfs_delayed_extent_op
*extent_op
,
702 struct btrfs_delayed_data_ref
*ref
;
703 struct btrfs_delayed_ref_head
*head_ref
;
704 struct btrfs_delayed_ref_root
*delayed_refs
;
705 struct btrfs_qgroup_extent_record
*record
= NULL
;
707 if (!is_fstree(ref_root
) || !fs_info
->quota_enabled
)
710 BUG_ON(extent_op
&& !extent_op
->is_data
);
711 ref
= kmem_cache_alloc(btrfs_delayed_data_ref_cachep
, GFP_NOFS
);
715 head_ref
= kmem_cache_alloc(btrfs_delayed_ref_head_cachep
, GFP_NOFS
);
717 kmem_cache_free(btrfs_delayed_data_ref_cachep
, ref
);
721 if (fs_info
->quota_enabled
&& is_fstree(ref_root
)) {
722 record
= kmalloc(sizeof(*record
), GFP_NOFS
);
724 kmem_cache_free(btrfs_delayed_data_ref_cachep
, ref
);
725 kmem_cache_free(btrfs_delayed_ref_head_cachep
,
731 head_ref
->extent_op
= extent_op
;
733 delayed_refs
= &trans
->transaction
->delayed_refs
;
734 spin_lock(&delayed_refs
->lock
);
737 * insert both the head node and the new ref without dropping
740 head_ref
= add_delayed_ref_head(fs_info
, trans
, &head_ref
->node
, record
,
741 bytenr
, num_bytes
, action
, 1);
743 add_delayed_data_ref(fs_info
, trans
, head_ref
, &ref
->node
, bytenr
,
744 num_bytes
, parent
, ref_root
, owner
, offset
,
746 spin_unlock(&delayed_refs
->lock
);
751 int btrfs_add_delayed_qgroup_reserve(struct btrfs_fs_info
*fs_info
,
752 struct btrfs_trans_handle
*trans
,
753 u64 ref_root
, u64 bytenr
, u64 num_bytes
)
755 struct btrfs_delayed_ref_root
*delayed_refs
;
756 struct btrfs_delayed_ref_head
*ref_head
;
759 if (!fs_info
->quota_enabled
|| !is_fstree(ref_root
))
762 delayed_refs
= &trans
->transaction
->delayed_refs
;
764 spin_lock(&delayed_refs
->lock
);
765 ref_head
= find_ref_head(&delayed_refs
->href_root
, bytenr
, 0);
770 WARN_ON(ref_head
->qgroup_reserved
|| ref_head
->qgroup_ref_root
);
771 ref_head
->qgroup_ref_root
= ref_root
;
772 ref_head
->qgroup_reserved
= num_bytes
;
774 spin_unlock(&delayed_refs
->lock
);
778 int btrfs_add_delayed_extent_op(struct btrfs_fs_info
*fs_info
,
779 struct btrfs_trans_handle
*trans
,
780 u64 bytenr
, u64 num_bytes
,
781 struct btrfs_delayed_extent_op
*extent_op
)
783 struct btrfs_delayed_ref_head
*head_ref
;
784 struct btrfs_delayed_ref_root
*delayed_refs
;
786 head_ref
= kmem_cache_alloc(btrfs_delayed_ref_head_cachep
, GFP_NOFS
);
790 head_ref
->extent_op
= extent_op
;
792 delayed_refs
= &trans
->transaction
->delayed_refs
;
793 spin_lock(&delayed_refs
->lock
);
795 add_delayed_ref_head(fs_info
, trans
, &head_ref
->node
, NULL
, bytenr
,
796 num_bytes
, BTRFS_UPDATE_DELAYED_HEAD
,
799 spin_unlock(&delayed_refs
->lock
);
804 * this does a simple search for the head node for a given extent.
805 * It must be called with the delayed ref spinlock held, and it returns
806 * the head node if any where found, or NULL if not.
808 struct btrfs_delayed_ref_head
*
809 btrfs_find_delayed_ref_head(struct btrfs_trans_handle
*trans
, u64 bytenr
)
811 struct btrfs_delayed_ref_root
*delayed_refs
;
813 delayed_refs
= &trans
->transaction
->delayed_refs
;
814 return find_ref_head(&delayed_refs
->href_root
, bytenr
, 0);
817 void btrfs_delayed_ref_exit(void)
819 if (btrfs_delayed_ref_head_cachep
)
820 kmem_cache_destroy(btrfs_delayed_ref_head_cachep
);
821 if (btrfs_delayed_tree_ref_cachep
)
822 kmem_cache_destroy(btrfs_delayed_tree_ref_cachep
);
823 if (btrfs_delayed_data_ref_cachep
)
824 kmem_cache_destroy(btrfs_delayed_data_ref_cachep
);
825 if (btrfs_delayed_extent_op_cachep
)
826 kmem_cache_destroy(btrfs_delayed_extent_op_cachep
);
829 int btrfs_delayed_ref_init(void)
831 btrfs_delayed_ref_head_cachep
= kmem_cache_create(
832 "btrfs_delayed_ref_head",
833 sizeof(struct btrfs_delayed_ref_head
), 0,
834 SLAB_RECLAIM_ACCOUNT
| SLAB_MEM_SPREAD
, NULL
);
835 if (!btrfs_delayed_ref_head_cachep
)
838 btrfs_delayed_tree_ref_cachep
= kmem_cache_create(
839 "btrfs_delayed_tree_ref",
840 sizeof(struct btrfs_delayed_tree_ref
), 0,
841 SLAB_RECLAIM_ACCOUNT
| SLAB_MEM_SPREAD
, NULL
);
842 if (!btrfs_delayed_tree_ref_cachep
)
845 btrfs_delayed_data_ref_cachep
= kmem_cache_create(
846 "btrfs_delayed_data_ref",
847 sizeof(struct btrfs_delayed_data_ref
), 0,
848 SLAB_RECLAIM_ACCOUNT
| SLAB_MEM_SPREAD
, NULL
);
849 if (!btrfs_delayed_data_ref_cachep
)
852 btrfs_delayed_extent_op_cachep
= kmem_cache_create(
853 "btrfs_delayed_extent_op",
854 sizeof(struct btrfs_delayed_extent_op
), 0,
855 SLAB_RECLAIM_ACCOUNT
| SLAB_MEM_SPREAD
, NULL
);
856 if (!btrfs_delayed_extent_op_cachep
)
861 btrfs_delayed_ref_exit();