1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2011 STRATO. All rights reserved.
6 #include <linux/sched.h>
7 #include <linux/pagemap.h>
8 #include <linux/writeback.h>
9 #include <linux/blkdev.h>
10 #include <linux/rbtree.h>
11 #include <linux/slab.h>
12 #include <linux/workqueue.h>
13 #include <linux/btrfs.h>
14 #include <linux/sizes.h>
17 #include "transaction.h"
22 #include "extent_io.h"
27 * - subvol delete -> delete when ref goes to 0? delete limits also?
31 * - copy also limits on subvol creation
33 * - caches fuer ulists
34 * - performance benchmarks
35 * - check all ioctl parameters
39 * Helpers to access qgroup reservation
41 * Callers should ensure the lock context and type are valid
44 static u64
qgroup_rsv_total(const struct btrfs_qgroup
*qgroup
)
49 for (i
= 0; i
< BTRFS_QGROUP_RSV_LAST
; i
++)
50 ret
+= qgroup
->rsv
.values
[i
];
55 #ifdef CONFIG_BTRFS_DEBUG
56 static const char *qgroup_rsv_type_str(enum btrfs_qgroup_rsv_type type
)
58 if (type
== BTRFS_QGROUP_RSV_DATA
)
60 if (type
== BTRFS_QGROUP_RSV_META_PERTRANS
)
61 return "meta_pertrans";
62 if (type
== BTRFS_QGROUP_RSV_META_PREALLOC
)
63 return "meta_prealloc";
68 static void qgroup_rsv_add(struct btrfs_fs_info
*fs_info
,
69 struct btrfs_qgroup
*qgroup
, u64 num_bytes
,
70 enum btrfs_qgroup_rsv_type type
)
72 trace_qgroup_update_reserve(fs_info
, qgroup
, num_bytes
, type
);
73 qgroup
->rsv
.values
[type
] += num_bytes
;
76 static void qgroup_rsv_release(struct btrfs_fs_info
*fs_info
,
77 struct btrfs_qgroup
*qgroup
, u64 num_bytes
,
78 enum btrfs_qgroup_rsv_type type
)
80 trace_qgroup_update_reserve(fs_info
, qgroup
, -(s64
)num_bytes
, type
);
81 if (qgroup
->rsv
.values
[type
] >= num_bytes
) {
82 qgroup
->rsv
.values
[type
] -= num_bytes
;
85 #ifdef CONFIG_BTRFS_DEBUG
87 "qgroup %llu %s reserved space underflow, have %llu to free %llu",
88 qgroup
->qgroupid
, qgroup_rsv_type_str(type
),
89 qgroup
->rsv
.values
[type
], num_bytes
);
91 qgroup
->rsv
.values
[type
] = 0;
94 static void qgroup_rsv_add_by_qgroup(struct btrfs_fs_info
*fs_info
,
95 struct btrfs_qgroup
*dest
,
96 struct btrfs_qgroup
*src
)
100 for (i
= 0; i
< BTRFS_QGROUP_RSV_LAST
; i
++)
101 qgroup_rsv_add(fs_info
, dest
, src
->rsv
.values
[i
], i
);
104 static void qgroup_rsv_release_by_qgroup(struct btrfs_fs_info
*fs_info
,
105 struct btrfs_qgroup
*dest
,
106 struct btrfs_qgroup
*src
)
110 for (i
= 0; i
< BTRFS_QGROUP_RSV_LAST
; i
++)
111 qgroup_rsv_release(fs_info
, dest
, src
->rsv
.values
[i
], i
);
114 static void btrfs_qgroup_update_old_refcnt(struct btrfs_qgroup
*qg
, u64 seq
,
117 if (qg
->old_refcnt
< seq
)
118 qg
->old_refcnt
= seq
;
119 qg
->old_refcnt
+= mod
;
122 static void btrfs_qgroup_update_new_refcnt(struct btrfs_qgroup
*qg
, u64 seq
,
125 if (qg
->new_refcnt
< seq
)
126 qg
->new_refcnt
= seq
;
127 qg
->new_refcnt
+= mod
;
130 static inline u64
btrfs_qgroup_get_old_refcnt(struct btrfs_qgroup
*qg
, u64 seq
)
132 if (qg
->old_refcnt
< seq
)
134 return qg
->old_refcnt
- seq
;
137 static inline u64
btrfs_qgroup_get_new_refcnt(struct btrfs_qgroup
*qg
, u64 seq
)
139 if (qg
->new_refcnt
< seq
)
141 return qg
->new_refcnt
- seq
;
145 * glue structure to represent the relations between qgroups.
147 struct btrfs_qgroup_list
{
148 struct list_head next_group
;
149 struct list_head next_member
;
150 struct btrfs_qgroup
*group
;
151 struct btrfs_qgroup
*member
;
154 static inline u64
qgroup_to_aux(struct btrfs_qgroup
*qg
)
156 return (u64
)(uintptr_t)qg
;
159 static inline struct btrfs_qgroup
* unode_aux_to_qgroup(struct ulist_node
*n
)
161 return (struct btrfs_qgroup
*)(uintptr_t)n
->aux
;
165 qgroup_rescan_init(struct btrfs_fs_info
*fs_info
, u64 progress_objectid
,
167 static void qgroup_rescan_zero_tracking(struct btrfs_fs_info
*fs_info
);
169 /* must be called with qgroup_ioctl_lock held */
170 static struct btrfs_qgroup
*find_qgroup_rb(struct btrfs_fs_info
*fs_info
,
173 struct rb_node
*n
= fs_info
->qgroup_tree
.rb_node
;
174 struct btrfs_qgroup
*qgroup
;
177 qgroup
= rb_entry(n
, struct btrfs_qgroup
, node
);
178 if (qgroup
->qgroupid
< qgroupid
)
180 else if (qgroup
->qgroupid
> qgroupid
)
188 /* must be called with qgroup_lock held */
189 static struct btrfs_qgroup
*add_qgroup_rb(struct btrfs_fs_info
*fs_info
,
192 struct rb_node
**p
= &fs_info
->qgroup_tree
.rb_node
;
193 struct rb_node
*parent
= NULL
;
194 struct btrfs_qgroup
*qgroup
;
198 qgroup
= rb_entry(parent
, struct btrfs_qgroup
, node
);
200 if (qgroup
->qgroupid
< qgroupid
)
202 else if (qgroup
->qgroupid
> qgroupid
)
208 qgroup
= kzalloc(sizeof(*qgroup
), GFP_ATOMIC
);
210 return ERR_PTR(-ENOMEM
);
212 qgroup
->qgroupid
= qgroupid
;
213 INIT_LIST_HEAD(&qgroup
->groups
);
214 INIT_LIST_HEAD(&qgroup
->members
);
215 INIT_LIST_HEAD(&qgroup
->dirty
);
217 rb_link_node(&qgroup
->node
, parent
, p
);
218 rb_insert_color(&qgroup
->node
, &fs_info
->qgroup_tree
);
223 static void __del_qgroup_rb(struct btrfs_qgroup
*qgroup
)
225 struct btrfs_qgroup_list
*list
;
227 list_del(&qgroup
->dirty
);
228 while (!list_empty(&qgroup
->groups
)) {
229 list
= list_first_entry(&qgroup
->groups
,
230 struct btrfs_qgroup_list
, next_group
);
231 list_del(&list
->next_group
);
232 list_del(&list
->next_member
);
236 while (!list_empty(&qgroup
->members
)) {
237 list
= list_first_entry(&qgroup
->members
,
238 struct btrfs_qgroup_list
, next_member
);
239 list_del(&list
->next_group
);
240 list_del(&list
->next_member
);
246 /* must be called with qgroup_lock held */
247 static int del_qgroup_rb(struct btrfs_fs_info
*fs_info
, u64 qgroupid
)
249 struct btrfs_qgroup
*qgroup
= find_qgroup_rb(fs_info
, qgroupid
);
254 rb_erase(&qgroup
->node
, &fs_info
->qgroup_tree
);
255 __del_qgroup_rb(qgroup
);
259 /* must be called with qgroup_lock held */
260 static int add_relation_rb(struct btrfs_fs_info
*fs_info
,
261 u64 memberid
, u64 parentid
)
263 struct btrfs_qgroup
*member
;
264 struct btrfs_qgroup
*parent
;
265 struct btrfs_qgroup_list
*list
;
267 member
= find_qgroup_rb(fs_info
, memberid
);
268 parent
= find_qgroup_rb(fs_info
, parentid
);
269 if (!member
|| !parent
)
272 list
= kzalloc(sizeof(*list
), GFP_ATOMIC
);
276 list
->group
= parent
;
277 list
->member
= member
;
278 list_add_tail(&list
->next_group
, &member
->groups
);
279 list_add_tail(&list
->next_member
, &parent
->members
);
284 /* must be called with qgroup_lock held */
285 static int del_relation_rb(struct btrfs_fs_info
*fs_info
,
286 u64 memberid
, u64 parentid
)
288 struct btrfs_qgroup
*member
;
289 struct btrfs_qgroup
*parent
;
290 struct btrfs_qgroup_list
*list
;
292 member
= find_qgroup_rb(fs_info
, memberid
);
293 parent
= find_qgroup_rb(fs_info
, parentid
);
294 if (!member
|| !parent
)
297 list_for_each_entry(list
, &member
->groups
, next_group
) {
298 if (list
->group
== parent
) {
299 list_del(&list
->next_group
);
300 list_del(&list
->next_member
);
308 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
309 int btrfs_verify_qgroup_counts(struct btrfs_fs_info
*fs_info
, u64 qgroupid
,
312 struct btrfs_qgroup
*qgroup
;
314 qgroup
= find_qgroup_rb(fs_info
, qgroupid
);
317 if (qgroup
->rfer
!= rfer
|| qgroup
->excl
!= excl
)
324 * The full config is read in one go, only called from open_ctree()
325 * It doesn't use any locking, as at this point we're still single-threaded
327 int btrfs_read_qgroup_config(struct btrfs_fs_info
*fs_info
)
329 struct btrfs_key key
;
330 struct btrfs_key found_key
;
331 struct btrfs_root
*quota_root
= fs_info
->quota_root
;
332 struct btrfs_path
*path
= NULL
;
333 struct extent_buffer
*l
;
337 u64 rescan_progress
= 0;
339 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
))
342 fs_info
->qgroup_ulist
= ulist_alloc(GFP_KERNEL
);
343 if (!fs_info
->qgroup_ulist
) {
348 path
= btrfs_alloc_path();
354 /* default this to quota off, in case no status key is found */
355 fs_info
->qgroup_flags
= 0;
358 * pass 1: read status, all qgroup infos and limits
363 ret
= btrfs_search_slot_for_read(quota_root
, &key
, path
, 1, 1);
368 struct btrfs_qgroup
*qgroup
;
370 slot
= path
->slots
[0];
372 btrfs_item_key_to_cpu(l
, &found_key
, slot
);
374 if (found_key
.type
== BTRFS_QGROUP_STATUS_KEY
) {
375 struct btrfs_qgroup_status_item
*ptr
;
377 ptr
= btrfs_item_ptr(l
, slot
,
378 struct btrfs_qgroup_status_item
);
380 if (btrfs_qgroup_status_version(l
, ptr
) !=
381 BTRFS_QGROUP_STATUS_VERSION
) {
383 "old qgroup version, quota disabled");
386 if (btrfs_qgroup_status_generation(l
, ptr
) !=
387 fs_info
->generation
) {
388 flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
390 "qgroup generation mismatch, marked as inconsistent");
392 fs_info
->qgroup_flags
= btrfs_qgroup_status_flags(l
,
394 rescan_progress
= btrfs_qgroup_status_rescan(l
, ptr
);
398 if (found_key
.type
!= BTRFS_QGROUP_INFO_KEY
&&
399 found_key
.type
!= BTRFS_QGROUP_LIMIT_KEY
)
402 qgroup
= find_qgroup_rb(fs_info
, found_key
.offset
);
403 if ((qgroup
&& found_key
.type
== BTRFS_QGROUP_INFO_KEY
) ||
404 (!qgroup
&& found_key
.type
== BTRFS_QGROUP_LIMIT_KEY
)) {
405 btrfs_err(fs_info
, "inconsistent qgroup config");
406 flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
409 qgroup
= add_qgroup_rb(fs_info
, found_key
.offset
);
410 if (IS_ERR(qgroup
)) {
411 ret
= PTR_ERR(qgroup
);
415 switch (found_key
.type
) {
416 case BTRFS_QGROUP_INFO_KEY
: {
417 struct btrfs_qgroup_info_item
*ptr
;
419 ptr
= btrfs_item_ptr(l
, slot
,
420 struct btrfs_qgroup_info_item
);
421 qgroup
->rfer
= btrfs_qgroup_info_rfer(l
, ptr
);
422 qgroup
->rfer_cmpr
= btrfs_qgroup_info_rfer_cmpr(l
, ptr
);
423 qgroup
->excl
= btrfs_qgroup_info_excl(l
, ptr
);
424 qgroup
->excl_cmpr
= btrfs_qgroup_info_excl_cmpr(l
, ptr
);
425 /* generation currently unused */
428 case BTRFS_QGROUP_LIMIT_KEY
: {
429 struct btrfs_qgroup_limit_item
*ptr
;
431 ptr
= btrfs_item_ptr(l
, slot
,
432 struct btrfs_qgroup_limit_item
);
433 qgroup
->lim_flags
= btrfs_qgroup_limit_flags(l
, ptr
);
434 qgroup
->max_rfer
= btrfs_qgroup_limit_max_rfer(l
, ptr
);
435 qgroup
->max_excl
= btrfs_qgroup_limit_max_excl(l
, ptr
);
436 qgroup
->rsv_rfer
= btrfs_qgroup_limit_rsv_rfer(l
, ptr
);
437 qgroup
->rsv_excl
= btrfs_qgroup_limit_rsv_excl(l
, ptr
);
442 ret
= btrfs_next_item(quota_root
, path
);
448 btrfs_release_path(path
);
451 * pass 2: read all qgroup relations
454 key
.type
= BTRFS_QGROUP_RELATION_KEY
;
456 ret
= btrfs_search_slot_for_read(quota_root
, &key
, path
, 1, 0);
460 slot
= path
->slots
[0];
462 btrfs_item_key_to_cpu(l
, &found_key
, slot
);
464 if (found_key
.type
!= BTRFS_QGROUP_RELATION_KEY
)
467 if (found_key
.objectid
> found_key
.offset
) {
468 /* parent <- member, not needed to build config */
469 /* FIXME should we omit the key completely? */
473 ret
= add_relation_rb(fs_info
, found_key
.objectid
,
475 if (ret
== -ENOENT
) {
477 "orphan qgroup relation 0x%llx->0x%llx",
478 found_key
.objectid
, found_key
.offset
);
479 ret
= 0; /* ignore the error */
484 ret
= btrfs_next_item(quota_root
, path
);
491 fs_info
->qgroup_flags
|= flags
;
492 if (!(fs_info
->qgroup_flags
& BTRFS_QGROUP_STATUS_FLAG_ON
))
493 clear_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
);
494 else if (fs_info
->qgroup_flags
& BTRFS_QGROUP_STATUS_FLAG_RESCAN
&&
496 ret
= qgroup_rescan_init(fs_info
, rescan_progress
, 0);
497 btrfs_free_path(path
);
500 ulist_free(fs_info
->qgroup_ulist
);
501 fs_info
->qgroup_ulist
= NULL
;
502 fs_info
->qgroup_flags
&= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN
;
505 return ret
< 0 ? ret
: 0;
509 * This is called from close_ctree() or open_ctree() or btrfs_quota_disable(),
510 * first two are in single-threaded paths.And for the third one, we have set
511 * quota_root to be null with qgroup_lock held before, so it is safe to clean
512 * up the in-memory structures without qgroup_lock held.
514 void btrfs_free_qgroup_config(struct btrfs_fs_info
*fs_info
)
517 struct btrfs_qgroup
*qgroup
;
519 while ((n
= rb_first(&fs_info
->qgroup_tree
))) {
520 qgroup
= rb_entry(n
, struct btrfs_qgroup
, node
);
521 rb_erase(n
, &fs_info
->qgroup_tree
);
522 __del_qgroup_rb(qgroup
);
525 * we call btrfs_free_qgroup_config() when umounting
526 * filesystem and disabling quota, so we set qgroup_ulist
527 * to be null here to avoid double free.
529 ulist_free(fs_info
->qgroup_ulist
);
530 fs_info
->qgroup_ulist
= NULL
;
533 static int add_qgroup_relation_item(struct btrfs_trans_handle
*trans
, u64 src
,
537 struct btrfs_root
*quota_root
= trans
->fs_info
->quota_root
;
538 struct btrfs_path
*path
;
539 struct btrfs_key key
;
541 path
= btrfs_alloc_path();
546 key
.type
= BTRFS_QGROUP_RELATION_KEY
;
549 ret
= btrfs_insert_empty_item(trans
, quota_root
, path
, &key
, 0);
551 btrfs_mark_buffer_dirty(path
->nodes
[0]);
553 btrfs_free_path(path
);
557 static int del_qgroup_relation_item(struct btrfs_trans_handle
*trans
, u64 src
,
561 struct btrfs_root
*quota_root
= trans
->fs_info
->quota_root
;
562 struct btrfs_path
*path
;
563 struct btrfs_key key
;
565 path
= btrfs_alloc_path();
570 key
.type
= BTRFS_QGROUP_RELATION_KEY
;
573 ret
= btrfs_search_slot(trans
, quota_root
, &key
, path
, -1, 1);
582 ret
= btrfs_del_item(trans
, quota_root
, path
);
584 btrfs_free_path(path
);
588 static int add_qgroup_item(struct btrfs_trans_handle
*trans
,
589 struct btrfs_root
*quota_root
, u64 qgroupid
)
592 struct btrfs_path
*path
;
593 struct btrfs_qgroup_info_item
*qgroup_info
;
594 struct btrfs_qgroup_limit_item
*qgroup_limit
;
595 struct extent_buffer
*leaf
;
596 struct btrfs_key key
;
598 if (btrfs_is_testing(quota_root
->fs_info
))
601 path
= btrfs_alloc_path();
606 key
.type
= BTRFS_QGROUP_INFO_KEY
;
607 key
.offset
= qgroupid
;
610 * Avoid a transaction abort by catching -EEXIST here. In that
611 * case, we proceed by re-initializing the existing structure
615 ret
= btrfs_insert_empty_item(trans
, quota_root
, path
, &key
,
616 sizeof(*qgroup_info
));
617 if (ret
&& ret
!= -EEXIST
)
620 leaf
= path
->nodes
[0];
621 qgroup_info
= btrfs_item_ptr(leaf
, path
->slots
[0],
622 struct btrfs_qgroup_info_item
);
623 btrfs_set_qgroup_info_generation(leaf
, qgroup_info
, trans
->transid
);
624 btrfs_set_qgroup_info_rfer(leaf
, qgroup_info
, 0);
625 btrfs_set_qgroup_info_rfer_cmpr(leaf
, qgroup_info
, 0);
626 btrfs_set_qgroup_info_excl(leaf
, qgroup_info
, 0);
627 btrfs_set_qgroup_info_excl_cmpr(leaf
, qgroup_info
, 0);
629 btrfs_mark_buffer_dirty(leaf
);
631 btrfs_release_path(path
);
633 key
.type
= BTRFS_QGROUP_LIMIT_KEY
;
634 ret
= btrfs_insert_empty_item(trans
, quota_root
, path
, &key
,
635 sizeof(*qgroup_limit
));
636 if (ret
&& ret
!= -EEXIST
)
639 leaf
= path
->nodes
[0];
640 qgroup_limit
= btrfs_item_ptr(leaf
, path
->slots
[0],
641 struct btrfs_qgroup_limit_item
);
642 btrfs_set_qgroup_limit_flags(leaf
, qgroup_limit
, 0);
643 btrfs_set_qgroup_limit_max_rfer(leaf
, qgroup_limit
, 0);
644 btrfs_set_qgroup_limit_max_excl(leaf
, qgroup_limit
, 0);
645 btrfs_set_qgroup_limit_rsv_rfer(leaf
, qgroup_limit
, 0);
646 btrfs_set_qgroup_limit_rsv_excl(leaf
, qgroup_limit
, 0);
648 btrfs_mark_buffer_dirty(leaf
);
652 btrfs_free_path(path
);
656 static int del_qgroup_item(struct btrfs_trans_handle
*trans
, u64 qgroupid
)
659 struct btrfs_root
*quota_root
= trans
->fs_info
->quota_root
;
660 struct btrfs_path
*path
;
661 struct btrfs_key key
;
663 path
= btrfs_alloc_path();
668 key
.type
= BTRFS_QGROUP_INFO_KEY
;
669 key
.offset
= qgroupid
;
670 ret
= btrfs_search_slot(trans
, quota_root
, &key
, path
, -1, 1);
679 ret
= btrfs_del_item(trans
, quota_root
, path
);
683 btrfs_release_path(path
);
685 key
.type
= BTRFS_QGROUP_LIMIT_KEY
;
686 ret
= btrfs_search_slot(trans
, quota_root
, &key
, path
, -1, 1);
695 ret
= btrfs_del_item(trans
, quota_root
, path
);
698 btrfs_free_path(path
);
702 static int update_qgroup_limit_item(struct btrfs_trans_handle
*trans
,
703 struct btrfs_qgroup
*qgroup
)
705 struct btrfs_root
*quota_root
= trans
->fs_info
->quota_root
;
706 struct btrfs_path
*path
;
707 struct btrfs_key key
;
708 struct extent_buffer
*l
;
709 struct btrfs_qgroup_limit_item
*qgroup_limit
;
714 key
.type
= BTRFS_QGROUP_LIMIT_KEY
;
715 key
.offset
= qgroup
->qgroupid
;
717 path
= btrfs_alloc_path();
721 ret
= btrfs_search_slot(trans
, quota_root
, &key
, path
, 0, 1);
729 slot
= path
->slots
[0];
730 qgroup_limit
= btrfs_item_ptr(l
, slot
, struct btrfs_qgroup_limit_item
);
731 btrfs_set_qgroup_limit_flags(l
, qgroup_limit
, qgroup
->lim_flags
);
732 btrfs_set_qgroup_limit_max_rfer(l
, qgroup_limit
, qgroup
->max_rfer
);
733 btrfs_set_qgroup_limit_max_excl(l
, qgroup_limit
, qgroup
->max_excl
);
734 btrfs_set_qgroup_limit_rsv_rfer(l
, qgroup_limit
, qgroup
->rsv_rfer
);
735 btrfs_set_qgroup_limit_rsv_excl(l
, qgroup_limit
, qgroup
->rsv_excl
);
737 btrfs_mark_buffer_dirty(l
);
740 btrfs_free_path(path
);
744 static int update_qgroup_info_item(struct btrfs_trans_handle
*trans
,
745 struct btrfs_qgroup
*qgroup
)
747 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
748 struct btrfs_root
*quota_root
= fs_info
->quota_root
;
749 struct btrfs_path
*path
;
750 struct btrfs_key key
;
751 struct extent_buffer
*l
;
752 struct btrfs_qgroup_info_item
*qgroup_info
;
756 if (btrfs_is_testing(fs_info
))
760 key
.type
= BTRFS_QGROUP_INFO_KEY
;
761 key
.offset
= qgroup
->qgroupid
;
763 path
= btrfs_alloc_path();
767 ret
= btrfs_search_slot(trans
, quota_root
, &key
, path
, 0, 1);
775 slot
= path
->slots
[0];
776 qgroup_info
= btrfs_item_ptr(l
, slot
, struct btrfs_qgroup_info_item
);
777 btrfs_set_qgroup_info_generation(l
, qgroup_info
, trans
->transid
);
778 btrfs_set_qgroup_info_rfer(l
, qgroup_info
, qgroup
->rfer
);
779 btrfs_set_qgroup_info_rfer_cmpr(l
, qgroup_info
, qgroup
->rfer_cmpr
);
780 btrfs_set_qgroup_info_excl(l
, qgroup_info
, qgroup
->excl
);
781 btrfs_set_qgroup_info_excl_cmpr(l
, qgroup_info
, qgroup
->excl_cmpr
);
783 btrfs_mark_buffer_dirty(l
);
786 btrfs_free_path(path
);
790 static int update_qgroup_status_item(struct btrfs_trans_handle
*trans
)
792 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
793 struct btrfs_root
*quota_root
= fs_info
->quota_root
;
794 struct btrfs_path
*path
;
795 struct btrfs_key key
;
796 struct extent_buffer
*l
;
797 struct btrfs_qgroup_status_item
*ptr
;
802 key
.type
= BTRFS_QGROUP_STATUS_KEY
;
805 path
= btrfs_alloc_path();
809 ret
= btrfs_search_slot(trans
, quota_root
, &key
, path
, 0, 1);
817 slot
= path
->slots
[0];
818 ptr
= btrfs_item_ptr(l
, slot
, struct btrfs_qgroup_status_item
);
819 btrfs_set_qgroup_status_flags(l
, ptr
, fs_info
->qgroup_flags
);
820 btrfs_set_qgroup_status_generation(l
, ptr
, trans
->transid
);
821 btrfs_set_qgroup_status_rescan(l
, ptr
,
822 fs_info
->qgroup_rescan_progress
.objectid
);
824 btrfs_mark_buffer_dirty(l
);
827 btrfs_free_path(path
);
832 * called with qgroup_lock held
834 static int btrfs_clean_quota_tree(struct btrfs_trans_handle
*trans
,
835 struct btrfs_root
*root
)
837 struct btrfs_path
*path
;
838 struct btrfs_key key
;
839 struct extent_buffer
*leaf
= NULL
;
843 path
= btrfs_alloc_path();
847 path
->leave_spinning
= 1;
854 ret
= btrfs_search_slot(trans
, root
, &key
, path
, -1, 1);
857 leaf
= path
->nodes
[0];
858 nr
= btrfs_header_nritems(leaf
);
862 * delete the leaf one by one
863 * since the whole tree is going
867 ret
= btrfs_del_items(trans
, root
, path
, 0, nr
);
871 btrfs_release_path(path
);
875 btrfs_free_path(path
);
879 int btrfs_quota_enable(struct btrfs_fs_info
*fs_info
)
881 struct btrfs_root
*quota_root
;
882 struct btrfs_root
*tree_root
= fs_info
->tree_root
;
883 struct btrfs_path
*path
= NULL
;
884 struct btrfs_qgroup_status_item
*ptr
;
885 struct extent_buffer
*leaf
;
886 struct btrfs_key key
;
887 struct btrfs_key found_key
;
888 struct btrfs_qgroup
*qgroup
= NULL
;
889 struct btrfs_trans_handle
*trans
= NULL
;
893 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
894 if (fs_info
->quota_root
)
898 * 1 for quota root item
899 * 1 for BTRFS_QGROUP_STATUS item
901 * Yet we also need 2*n items for a QGROUP_INFO/QGROUP_LIMIT items
902 * per subvolume. However those are not currently reserved since it
903 * would be a lot of overkill.
905 trans
= btrfs_start_transaction(tree_root
, 2);
907 ret
= PTR_ERR(trans
);
912 fs_info
->qgroup_ulist
= ulist_alloc(GFP_KERNEL
);
913 if (!fs_info
->qgroup_ulist
) {
915 btrfs_abort_transaction(trans
, ret
);
920 * initially create the quota tree
922 quota_root
= btrfs_create_tree(trans
, fs_info
,
923 BTRFS_QUOTA_TREE_OBJECTID
);
924 if (IS_ERR(quota_root
)) {
925 ret
= PTR_ERR(quota_root
);
926 btrfs_abort_transaction(trans
, ret
);
930 path
= btrfs_alloc_path();
933 btrfs_abort_transaction(trans
, ret
);
938 key
.type
= BTRFS_QGROUP_STATUS_KEY
;
941 ret
= btrfs_insert_empty_item(trans
, quota_root
, path
, &key
,
944 btrfs_abort_transaction(trans
, ret
);
948 leaf
= path
->nodes
[0];
949 ptr
= btrfs_item_ptr(leaf
, path
->slots
[0],
950 struct btrfs_qgroup_status_item
);
951 btrfs_set_qgroup_status_generation(leaf
, ptr
, trans
->transid
);
952 btrfs_set_qgroup_status_version(leaf
, ptr
, BTRFS_QGROUP_STATUS_VERSION
);
953 fs_info
->qgroup_flags
= BTRFS_QGROUP_STATUS_FLAG_ON
|
954 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
955 btrfs_set_qgroup_status_flags(leaf
, ptr
, fs_info
->qgroup_flags
);
956 btrfs_set_qgroup_status_rescan(leaf
, ptr
, 0);
958 btrfs_mark_buffer_dirty(leaf
);
961 key
.type
= BTRFS_ROOT_REF_KEY
;
964 btrfs_release_path(path
);
965 ret
= btrfs_search_slot_for_read(tree_root
, &key
, path
, 1, 0);
969 btrfs_abort_transaction(trans
, ret
);
974 slot
= path
->slots
[0];
975 leaf
= path
->nodes
[0];
976 btrfs_item_key_to_cpu(leaf
, &found_key
, slot
);
978 if (found_key
.type
== BTRFS_ROOT_REF_KEY
) {
979 ret
= add_qgroup_item(trans
, quota_root
,
982 btrfs_abort_transaction(trans
, ret
);
986 qgroup
= add_qgroup_rb(fs_info
, found_key
.offset
);
987 if (IS_ERR(qgroup
)) {
988 ret
= PTR_ERR(qgroup
);
989 btrfs_abort_transaction(trans
, ret
);
993 ret
= btrfs_next_item(tree_root
, path
);
995 btrfs_abort_transaction(trans
, ret
);
1003 btrfs_release_path(path
);
1004 ret
= add_qgroup_item(trans
, quota_root
, BTRFS_FS_TREE_OBJECTID
);
1006 btrfs_abort_transaction(trans
, ret
);
1010 qgroup
= add_qgroup_rb(fs_info
, BTRFS_FS_TREE_OBJECTID
);
1011 if (IS_ERR(qgroup
)) {
1012 ret
= PTR_ERR(qgroup
);
1013 btrfs_abort_transaction(trans
, ret
);
1016 spin_lock(&fs_info
->qgroup_lock
);
1017 fs_info
->quota_root
= quota_root
;
1018 set_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
);
1019 spin_unlock(&fs_info
->qgroup_lock
);
1021 ret
= btrfs_commit_transaction(trans
);
1026 ret
= qgroup_rescan_init(fs_info
, 0, 1);
1028 qgroup_rescan_zero_tracking(fs_info
);
1029 btrfs_queue_work(fs_info
->qgroup_rescan_workers
,
1030 &fs_info
->qgroup_rescan_work
);
1034 btrfs_free_path(path
);
1037 free_extent_buffer(quota_root
->node
);
1038 free_extent_buffer(quota_root
->commit_root
);
1043 ulist_free(fs_info
->qgroup_ulist
);
1044 fs_info
->qgroup_ulist
= NULL
;
1046 btrfs_end_transaction(trans
);
1048 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
1052 int btrfs_quota_disable(struct btrfs_fs_info
*fs_info
)
1054 struct btrfs_root
*quota_root
;
1055 struct btrfs_trans_handle
*trans
= NULL
;
1058 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
1059 if (!fs_info
->quota_root
)
1063 * 1 For the root item
1065 * We should also reserve enough items for the quota tree deletion in
1066 * btrfs_clean_quota_tree but this is not done.
1068 trans
= btrfs_start_transaction(fs_info
->tree_root
, 1);
1069 if (IS_ERR(trans
)) {
1070 ret
= PTR_ERR(trans
);
1074 clear_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
);
1075 btrfs_qgroup_wait_for_completion(fs_info
, false);
1076 spin_lock(&fs_info
->qgroup_lock
);
1077 quota_root
= fs_info
->quota_root
;
1078 fs_info
->quota_root
= NULL
;
1079 fs_info
->qgroup_flags
&= ~BTRFS_QGROUP_STATUS_FLAG_ON
;
1080 spin_unlock(&fs_info
->qgroup_lock
);
1082 btrfs_free_qgroup_config(fs_info
);
1084 ret
= btrfs_clean_quota_tree(trans
, quota_root
);
1086 btrfs_abort_transaction(trans
, ret
);
1090 ret
= btrfs_del_root(trans
, "a_root
->root_key
);
1092 btrfs_abort_transaction(trans
, ret
);
1096 list_del("a_root
->dirty_list
);
1098 btrfs_tree_lock(quota_root
->node
);
1099 clean_tree_block(fs_info
, quota_root
->node
);
1100 btrfs_tree_unlock(quota_root
->node
);
1101 btrfs_free_tree_block(trans
, quota_root
, quota_root
->node
, 0, 1);
1103 free_extent_buffer(quota_root
->node
);
1104 free_extent_buffer(quota_root
->commit_root
);
1108 ret
= btrfs_end_transaction(trans
);
1110 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
1114 static void qgroup_dirty(struct btrfs_fs_info
*fs_info
,
1115 struct btrfs_qgroup
*qgroup
)
1117 if (list_empty(&qgroup
->dirty
))
1118 list_add(&qgroup
->dirty
, &fs_info
->dirty_qgroups
);
1122 * The easy accounting, we're updating qgroup relationship whose child qgroup
1123 * only has exclusive extents.
1125 * In this case, all exclsuive extents will also be exlusive for parent, so
1126 * excl/rfer just get added/removed.
1128 * So is qgroup reservation space, which should also be added/removed to
1130 * Or when child tries to release reservation space, parent will underflow its
1131 * reservation (for relationship adding case).
1133 * Caller should hold fs_info->qgroup_lock.
1135 static int __qgroup_excl_accounting(struct btrfs_fs_info
*fs_info
,
1136 struct ulist
*tmp
, u64 ref_root
,
1137 struct btrfs_qgroup
*src
, int sign
)
1139 struct btrfs_qgroup
*qgroup
;
1140 struct btrfs_qgroup_list
*glist
;
1141 struct ulist_node
*unode
;
1142 struct ulist_iterator uiter
;
1143 u64 num_bytes
= src
->excl
;
1146 qgroup
= find_qgroup_rb(fs_info
, ref_root
);
1150 qgroup
->rfer
+= sign
* num_bytes
;
1151 qgroup
->rfer_cmpr
+= sign
* num_bytes
;
1153 WARN_ON(sign
< 0 && qgroup
->excl
< num_bytes
);
1154 qgroup
->excl
+= sign
* num_bytes
;
1155 qgroup
->excl_cmpr
+= sign
* num_bytes
;
1158 qgroup_rsv_add_by_qgroup(fs_info
, qgroup
, src
);
1160 qgroup_rsv_release_by_qgroup(fs_info
, qgroup
, src
);
1162 qgroup_dirty(fs_info
, qgroup
);
1164 /* Get all of the parent groups that contain this qgroup */
1165 list_for_each_entry(glist
, &qgroup
->groups
, next_group
) {
1166 ret
= ulist_add(tmp
, glist
->group
->qgroupid
,
1167 qgroup_to_aux(glist
->group
), GFP_ATOMIC
);
1172 /* Iterate all of the parents and adjust their reference counts */
1173 ULIST_ITER_INIT(&uiter
);
1174 while ((unode
= ulist_next(tmp
, &uiter
))) {
1175 qgroup
= unode_aux_to_qgroup(unode
);
1176 qgroup
->rfer
+= sign
* num_bytes
;
1177 qgroup
->rfer_cmpr
+= sign
* num_bytes
;
1178 WARN_ON(sign
< 0 && qgroup
->excl
< num_bytes
);
1179 qgroup
->excl
+= sign
* num_bytes
;
1181 qgroup_rsv_add_by_qgroup(fs_info
, qgroup
, src
);
1183 qgroup_rsv_release_by_qgroup(fs_info
, qgroup
, src
);
1184 qgroup
->excl_cmpr
+= sign
* num_bytes
;
1185 qgroup_dirty(fs_info
, qgroup
);
1187 /* Add any parents of the parents */
1188 list_for_each_entry(glist
, &qgroup
->groups
, next_group
) {
1189 ret
= ulist_add(tmp
, glist
->group
->qgroupid
,
1190 qgroup_to_aux(glist
->group
), GFP_ATOMIC
);
1202 * Quick path for updating qgroup with only excl refs.
1204 * In that case, just update all parent will be enough.
1205 * Or we needs to do a full rescan.
1206 * Caller should also hold fs_info->qgroup_lock.
1208 * Return 0 for quick update, return >0 for need to full rescan
1209 * and mark INCONSISTENT flag.
1210 * Return < 0 for other error.
1212 static int quick_update_accounting(struct btrfs_fs_info
*fs_info
,
1213 struct ulist
*tmp
, u64 src
, u64 dst
,
1216 struct btrfs_qgroup
*qgroup
;
1220 qgroup
= find_qgroup_rb(fs_info
, src
);
1223 if (qgroup
->excl
== qgroup
->rfer
) {
1225 err
= __qgroup_excl_accounting(fs_info
, tmp
, dst
,
1234 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
1238 int btrfs_add_qgroup_relation(struct btrfs_trans_handle
*trans
, u64 src
,
1241 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1242 struct btrfs_root
*quota_root
;
1243 struct btrfs_qgroup
*parent
;
1244 struct btrfs_qgroup
*member
;
1245 struct btrfs_qgroup_list
*list
;
1249 /* Check the level of src and dst first */
1250 if (btrfs_qgroup_level(src
) >= btrfs_qgroup_level(dst
))
1253 tmp
= ulist_alloc(GFP_KERNEL
);
1257 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
1258 quota_root
= fs_info
->quota_root
;
1263 member
= find_qgroup_rb(fs_info
, src
);
1264 parent
= find_qgroup_rb(fs_info
, dst
);
1265 if (!member
|| !parent
) {
1270 /* check if such qgroup relation exist firstly */
1271 list_for_each_entry(list
, &member
->groups
, next_group
) {
1272 if (list
->group
== parent
) {
1278 ret
= add_qgroup_relation_item(trans
, src
, dst
);
1282 ret
= add_qgroup_relation_item(trans
, dst
, src
);
1284 del_qgroup_relation_item(trans
, src
, dst
);
1288 spin_lock(&fs_info
->qgroup_lock
);
1289 ret
= add_relation_rb(fs_info
, src
, dst
);
1291 spin_unlock(&fs_info
->qgroup_lock
);
1294 ret
= quick_update_accounting(fs_info
, tmp
, src
, dst
, 1);
1295 spin_unlock(&fs_info
->qgroup_lock
);
1297 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
1302 static int __del_qgroup_relation(struct btrfs_trans_handle
*trans
, u64 src
,
1305 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1306 struct btrfs_root
*quota_root
;
1307 struct btrfs_qgroup
*parent
;
1308 struct btrfs_qgroup
*member
;
1309 struct btrfs_qgroup_list
*list
;
1314 tmp
= ulist_alloc(GFP_KERNEL
);
1318 quota_root
= fs_info
->quota_root
;
1324 member
= find_qgroup_rb(fs_info
, src
);
1325 parent
= find_qgroup_rb(fs_info
, dst
);
1326 if (!member
|| !parent
) {
1331 /* check if such qgroup relation exist firstly */
1332 list_for_each_entry(list
, &member
->groups
, next_group
) {
1333 if (list
->group
== parent
)
1339 ret
= del_qgroup_relation_item(trans
, src
, dst
);
1340 err
= del_qgroup_relation_item(trans
, dst
, src
);
1344 spin_lock(&fs_info
->qgroup_lock
);
1345 del_relation_rb(fs_info
, src
, dst
);
1346 ret
= quick_update_accounting(fs_info
, tmp
, src
, dst
, -1);
1347 spin_unlock(&fs_info
->qgroup_lock
);
1353 int btrfs_del_qgroup_relation(struct btrfs_trans_handle
*trans
, u64 src
,
1356 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1359 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
1360 ret
= __del_qgroup_relation(trans
, src
, dst
);
1361 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
1366 int btrfs_create_qgroup(struct btrfs_trans_handle
*trans
, u64 qgroupid
)
1368 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1369 struct btrfs_root
*quota_root
;
1370 struct btrfs_qgroup
*qgroup
;
1373 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
1374 quota_root
= fs_info
->quota_root
;
1379 qgroup
= find_qgroup_rb(fs_info
, qgroupid
);
1385 ret
= add_qgroup_item(trans
, quota_root
, qgroupid
);
1389 spin_lock(&fs_info
->qgroup_lock
);
1390 qgroup
= add_qgroup_rb(fs_info
, qgroupid
);
1391 spin_unlock(&fs_info
->qgroup_lock
);
1394 ret
= PTR_ERR(qgroup
);
1396 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
1400 int btrfs_remove_qgroup(struct btrfs_trans_handle
*trans
, u64 qgroupid
)
1402 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1403 struct btrfs_root
*quota_root
;
1404 struct btrfs_qgroup
*qgroup
;
1405 struct btrfs_qgroup_list
*list
;
1408 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
1409 quota_root
= fs_info
->quota_root
;
1415 qgroup
= find_qgroup_rb(fs_info
, qgroupid
);
1420 /* check if there are no children of this qgroup */
1421 if (!list_empty(&qgroup
->members
)) {
1426 ret
= del_qgroup_item(trans
, qgroupid
);
1427 if (ret
&& ret
!= -ENOENT
)
1430 while (!list_empty(&qgroup
->groups
)) {
1431 list
= list_first_entry(&qgroup
->groups
,
1432 struct btrfs_qgroup_list
, next_group
);
1433 ret
= __del_qgroup_relation(trans
, qgroupid
,
1434 list
->group
->qgroupid
);
1439 spin_lock(&fs_info
->qgroup_lock
);
1440 del_qgroup_rb(fs_info
, qgroupid
);
1441 spin_unlock(&fs_info
->qgroup_lock
);
1443 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
1447 int btrfs_limit_qgroup(struct btrfs_trans_handle
*trans
, u64 qgroupid
,
1448 struct btrfs_qgroup_limit
*limit
)
1450 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1451 struct btrfs_root
*quota_root
;
1452 struct btrfs_qgroup
*qgroup
;
1454 /* Sometimes we would want to clear the limit on this qgroup.
1455 * To meet this requirement, we treat the -1 as a special value
1456 * which tell kernel to clear the limit on this qgroup.
1458 const u64 CLEAR_VALUE
= -1;
1460 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
1461 quota_root
= fs_info
->quota_root
;
1467 qgroup
= find_qgroup_rb(fs_info
, qgroupid
);
1473 spin_lock(&fs_info
->qgroup_lock
);
1474 if (limit
->flags
& BTRFS_QGROUP_LIMIT_MAX_RFER
) {
1475 if (limit
->max_rfer
== CLEAR_VALUE
) {
1476 qgroup
->lim_flags
&= ~BTRFS_QGROUP_LIMIT_MAX_RFER
;
1477 limit
->flags
&= ~BTRFS_QGROUP_LIMIT_MAX_RFER
;
1478 qgroup
->max_rfer
= 0;
1480 qgroup
->max_rfer
= limit
->max_rfer
;
1483 if (limit
->flags
& BTRFS_QGROUP_LIMIT_MAX_EXCL
) {
1484 if (limit
->max_excl
== CLEAR_VALUE
) {
1485 qgroup
->lim_flags
&= ~BTRFS_QGROUP_LIMIT_MAX_EXCL
;
1486 limit
->flags
&= ~BTRFS_QGROUP_LIMIT_MAX_EXCL
;
1487 qgroup
->max_excl
= 0;
1489 qgroup
->max_excl
= limit
->max_excl
;
1492 if (limit
->flags
& BTRFS_QGROUP_LIMIT_RSV_RFER
) {
1493 if (limit
->rsv_rfer
== CLEAR_VALUE
) {
1494 qgroup
->lim_flags
&= ~BTRFS_QGROUP_LIMIT_RSV_RFER
;
1495 limit
->flags
&= ~BTRFS_QGROUP_LIMIT_RSV_RFER
;
1496 qgroup
->rsv_rfer
= 0;
1498 qgroup
->rsv_rfer
= limit
->rsv_rfer
;
1501 if (limit
->flags
& BTRFS_QGROUP_LIMIT_RSV_EXCL
) {
1502 if (limit
->rsv_excl
== CLEAR_VALUE
) {
1503 qgroup
->lim_flags
&= ~BTRFS_QGROUP_LIMIT_RSV_EXCL
;
1504 limit
->flags
&= ~BTRFS_QGROUP_LIMIT_RSV_EXCL
;
1505 qgroup
->rsv_excl
= 0;
1507 qgroup
->rsv_excl
= limit
->rsv_excl
;
1510 qgroup
->lim_flags
|= limit
->flags
;
1512 spin_unlock(&fs_info
->qgroup_lock
);
1514 ret
= update_qgroup_limit_item(trans
, qgroup
);
1516 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
1517 btrfs_info(fs_info
, "unable to update quota limit for %llu",
1522 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
1526 int btrfs_qgroup_trace_extent_nolock(struct btrfs_fs_info
*fs_info
,
1527 struct btrfs_delayed_ref_root
*delayed_refs
,
1528 struct btrfs_qgroup_extent_record
*record
)
1530 struct rb_node
**p
= &delayed_refs
->dirty_extent_root
.rb_node
;
1531 struct rb_node
*parent_node
= NULL
;
1532 struct btrfs_qgroup_extent_record
*entry
;
1533 u64 bytenr
= record
->bytenr
;
1535 lockdep_assert_held(&delayed_refs
->lock
);
1536 trace_btrfs_qgroup_trace_extent(fs_info
, record
);
1540 entry
= rb_entry(parent_node
, struct btrfs_qgroup_extent_record
,
1542 if (bytenr
< entry
->bytenr
)
1544 else if (bytenr
> entry
->bytenr
)
1545 p
= &(*p
)->rb_right
;
1550 rb_link_node(&record
->node
, parent_node
, p
);
1551 rb_insert_color(&record
->node
, &delayed_refs
->dirty_extent_root
);
1555 int btrfs_qgroup_trace_extent_post(struct btrfs_fs_info
*fs_info
,
1556 struct btrfs_qgroup_extent_record
*qrecord
)
1558 struct ulist
*old_root
;
1559 u64 bytenr
= qrecord
->bytenr
;
1562 ret
= btrfs_find_all_roots(NULL
, fs_info
, bytenr
, 0, &old_root
, false);
1564 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
1566 "error accounting new delayed refs extent (err code: %d), quota inconsistent",
1572 * Here we don't need to get the lock of
1573 * trans->transaction->delayed_refs, since inserted qrecord won't
1574 * be deleted, only qrecord->node may be modified (new qrecord insert)
1576 * So modifying qrecord->old_roots is safe here
1578 qrecord
->old_roots
= old_root
;
1582 int btrfs_qgroup_trace_extent(struct btrfs_trans_handle
*trans
, u64 bytenr
,
1583 u64 num_bytes
, gfp_t gfp_flag
)
1585 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1586 struct btrfs_qgroup_extent_record
*record
;
1587 struct btrfs_delayed_ref_root
*delayed_refs
;
1590 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
)
1591 || bytenr
== 0 || num_bytes
== 0)
1593 record
= kmalloc(sizeof(*record
), gfp_flag
);
1597 delayed_refs
= &trans
->transaction
->delayed_refs
;
1598 record
->bytenr
= bytenr
;
1599 record
->num_bytes
= num_bytes
;
1600 record
->old_roots
= NULL
;
1602 spin_lock(&delayed_refs
->lock
);
1603 ret
= btrfs_qgroup_trace_extent_nolock(fs_info
, delayed_refs
, record
);
1604 spin_unlock(&delayed_refs
->lock
);
1609 return btrfs_qgroup_trace_extent_post(fs_info
, record
);
1612 int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle
*trans
,
1613 struct extent_buffer
*eb
)
1615 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1616 int nr
= btrfs_header_nritems(eb
);
1617 int i
, extent_type
, ret
;
1618 struct btrfs_key key
;
1619 struct btrfs_file_extent_item
*fi
;
1620 u64 bytenr
, num_bytes
;
1622 /* We can be called directly from walk_up_proc() */
1623 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
))
1626 for (i
= 0; i
< nr
; i
++) {
1627 btrfs_item_key_to_cpu(eb
, &key
, i
);
1629 if (key
.type
!= BTRFS_EXTENT_DATA_KEY
)
1632 fi
= btrfs_item_ptr(eb
, i
, struct btrfs_file_extent_item
);
1633 /* filter out non qgroup-accountable extents */
1634 extent_type
= btrfs_file_extent_type(eb
, fi
);
1636 if (extent_type
== BTRFS_FILE_EXTENT_INLINE
)
1639 bytenr
= btrfs_file_extent_disk_bytenr(eb
, fi
);
1643 num_bytes
= btrfs_file_extent_disk_num_bytes(eb
, fi
);
1645 ret
= btrfs_qgroup_trace_extent(trans
, bytenr
, num_bytes
,
1655 * Walk up the tree from the bottom, freeing leaves and any interior
1656 * nodes which have had all slots visited. If a node (leaf or
1657 * interior) is freed, the node above it will have it's slot
1658 * incremented. The root node will never be freed.
1660 * At the end of this function, we should have a path which has all
1661 * slots incremented to the next position for a search. If we need to
1662 * read a new node it will be NULL and the node above it will have the
1663 * correct slot selected for a later read.
1665 * If we increment the root nodes slot counter past the number of
1666 * elements, 1 is returned to signal completion of the search.
1668 static int adjust_slots_upwards(struct btrfs_path
*path
, int root_level
)
1672 struct extent_buffer
*eb
;
1674 if (root_level
== 0)
1677 while (level
<= root_level
) {
1678 eb
= path
->nodes
[level
];
1679 nr
= btrfs_header_nritems(eb
);
1680 path
->slots
[level
]++;
1681 slot
= path
->slots
[level
];
1682 if (slot
>= nr
|| level
== 0) {
1684 * Don't free the root - we will detect this
1685 * condition after our loop and return a
1686 * positive value for caller to stop walking the tree.
1688 if (level
!= root_level
) {
1689 btrfs_tree_unlock_rw(eb
, path
->locks
[level
]);
1690 path
->locks
[level
] = 0;
1692 free_extent_buffer(eb
);
1693 path
->nodes
[level
] = NULL
;
1694 path
->slots
[level
] = 0;
1698 * We have a valid slot to walk back down
1699 * from. Stop here so caller can process these
1708 eb
= path
->nodes
[root_level
];
1709 if (path
->slots
[root_level
] >= btrfs_header_nritems(eb
))
1716 * Helper function to trace a subtree tree block swap.
1718 * The swap will happen in highest tree block, but there may be a lot of
1719 * tree blocks involved.
1722 * OO = Old tree blocks
1723 * NN = New tree blocks allocated during balance
1725 * File tree (257) Reloc tree for 257
1728 * L1 OO OO (a) OO NN (a)
1730 * L0 OO OO OO OO OO OO NN NN
1733 * When calling qgroup_trace_extent_swap(), we will pass:
1735 * @dst_path = [ nodes[1] = NN(a), nodes[0] = NN(c) ]
1739 * In that case, qgroup_trace_extent_swap() will search from OO(a) to
1740 * reach OO(c), then mark both OO(c) and NN(c) as qgroup dirty.
1742 * The main work of qgroup_trace_extent_swap() can be split into 3 parts:
1744 * 1) Tree search from @src_eb
1745 * It should acts as a simplified btrfs_search_slot().
1746 * The key for search can be extracted from @dst_path->nodes[dst_level]
1749 * 2) Mark the final tree blocks in @src_path and @dst_path qgroup dirty
1750 * NOTE: In above case, OO(a) and NN(a) won't be marked qgroup dirty.
1751 * They should be marked during preivous (@dst_level = 1) iteration.
1753 * 3) Mark file extents in leaves dirty
1754 * We don't have good way to pick out new file extents only.
1755 * So we still follow the old method by scanning all file extents in
1758 * This function can free us from keeping two pathes, thus later we only need
1759 * to care about how to iterate all new tree blocks in reloc tree.
1761 static int qgroup_trace_extent_swap(struct btrfs_trans_handle
* trans
,
1762 struct extent_buffer
*src_eb
,
1763 struct btrfs_path
*dst_path
,
1764 int dst_level
, int root_level
,
1767 struct btrfs_key key
;
1768 struct btrfs_path
*src_path
;
1769 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1770 u32 nodesize
= fs_info
->nodesize
;
1771 int cur_level
= root_level
;
1774 BUG_ON(dst_level
> root_level
);
1775 /* Level mismatch */
1776 if (btrfs_header_level(src_eb
) != root_level
)
1779 src_path
= btrfs_alloc_path();
1786 btrfs_node_key_to_cpu(dst_path
->nodes
[dst_level
], &key
, 0);
1788 btrfs_item_key_to_cpu(dst_path
->nodes
[dst_level
], &key
, 0);
1791 extent_buffer_get(src_eb
);
1792 src_path
->nodes
[root_level
] = src_eb
;
1793 src_path
->slots
[root_level
] = dst_path
->slots
[root_level
];
1794 src_path
->locks
[root_level
] = 0;
1796 /* A simplified version of btrfs_search_slot() */
1797 while (cur_level
>= dst_level
) {
1798 struct btrfs_key src_key
;
1799 struct btrfs_key dst_key
;
1801 if (src_path
->nodes
[cur_level
] == NULL
) {
1802 struct btrfs_key first_key
;
1803 struct extent_buffer
*eb
;
1808 eb
= src_path
->nodes
[cur_level
+ 1];
1809 parent_slot
= src_path
->slots
[cur_level
+ 1];
1810 child_bytenr
= btrfs_node_blockptr(eb
, parent_slot
);
1811 child_gen
= btrfs_node_ptr_generation(eb
, parent_slot
);
1812 btrfs_node_key_to_cpu(eb
, &first_key
, parent_slot
);
1814 eb
= read_tree_block(fs_info
, child_bytenr
, child_gen
,
1815 cur_level
, &first_key
);
1819 } else if (!extent_buffer_uptodate(eb
)) {
1820 free_extent_buffer(eb
);
1825 src_path
->nodes
[cur_level
] = eb
;
1827 btrfs_tree_read_lock(eb
);
1828 btrfs_set_lock_blocking_rw(eb
, BTRFS_READ_LOCK
);
1829 src_path
->locks
[cur_level
] = BTRFS_READ_LOCK_BLOCKING
;
1832 src_path
->slots
[cur_level
] = dst_path
->slots
[cur_level
];
1834 btrfs_node_key_to_cpu(dst_path
->nodes
[cur_level
],
1835 &dst_key
, dst_path
->slots
[cur_level
]);
1836 btrfs_node_key_to_cpu(src_path
->nodes
[cur_level
],
1837 &src_key
, src_path
->slots
[cur_level
]);
1839 btrfs_item_key_to_cpu(dst_path
->nodes
[cur_level
],
1840 &dst_key
, dst_path
->slots
[cur_level
]);
1841 btrfs_item_key_to_cpu(src_path
->nodes
[cur_level
],
1842 &src_key
, src_path
->slots
[cur_level
]);
1844 /* Content mismatch, something went wrong */
1845 if (btrfs_comp_cpu_keys(&dst_key
, &src_key
)) {
1853 * Now both @dst_path and @src_path have been populated, record the tree
1854 * blocks for qgroup accounting.
1856 ret
= btrfs_qgroup_trace_extent(trans
, src_path
->nodes
[dst_level
]->start
,
1857 nodesize
, GFP_NOFS
);
1860 ret
= btrfs_qgroup_trace_extent(trans
,
1861 dst_path
->nodes
[dst_level
]->start
,
1862 nodesize
, GFP_NOFS
);
1866 /* Record leaf file extents */
1867 if (dst_level
== 0 && trace_leaf
) {
1868 ret
= btrfs_qgroup_trace_leaf_items(trans
, src_path
->nodes
[0]);
1871 ret
= btrfs_qgroup_trace_leaf_items(trans
, dst_path
->nodes
[0]);
1874 btrfs_free_path(src_path
);
1879 * Helper function to do recursive generation-aware depth-first search, to
1880 * locate all new tree blocks in a subtree of reloc tree.
1882 * E.g. (OO = Old tree blocks, NN = New tree blocks, whose gen == last_snapshot)
1891 * @dst_path = [ nodes[1] = NN(b), nodes[0] = NULL ],
1895 * We will iterate through tree blocks NN(b), NN(d) and info qgroup to trace
1896 * above tree blocks along with their counter parts in file tree.
1897 * While during search, old tree blocsk OO(c) will be skiped as tree block swap
1898 * won't affect OO(c).
1900 static int qgroup_trace_new_subtree_blocks(struct btrfs_trans_handle
* trans
,
1901 struct extent_buffer
*src_eb
,
1902 struct btrfs_path
*dst_path
,
1903 int cur_level
, int root_level
,
1904 u64 last_snapshot
, bool trace_leaf
)
1906 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
1907 struct extent_buffer
*eb
;
1908 bool need_cleanup
= false;
1912 /* Level sanity check */
1913 if (cur_level
< 0 || cur_level
>= BTRFS_MAX_LEVEL
||
1914 root_level
< 0 || root_level
>= BTRFS_MAX_LEVEL
||
1915 root_level
< cur_level
) {
1916 btrfs_err_rl(fs_info
,
1917 "%s: bad levels, cur_level=%d root_level=%d",
1918 __func__
, cur_level
, root_level
);
1922 /* Read the tree block if needed */
1923 if (dst_path
->nodes
[cur_level
] == NULL
) {
1924 struct btrfs_key first_key
;
1930 * dst_path->nodes[root_level] must be initialized before
1931 * calling this function.
1933 if (cur_level
== root_level
) {
1934 btrfs_err_rl(fs_info
,
1935 "%s: dst_path->nodes[%d] not initialized, root_level=%d cur_level=%d",
1936 __func__
, root_level
, root_level
, cur_level
);
1941 * We need to get child blockptr/gen from parent before we can
1944 eb
= dst_path
->nodes
[cur_level
+ 1];
1945 parent_slot
= dst_path
->slots
[cur_level
+ 1];
1946 child_bytenr
= btrfs_node_blockptr(eb
, parent_slot
);
1947 child_gen
= btrfs_node_ptr_generation(eb
, parent_slot
);
1948 btrfs_node_key_to_cpu(eb
, &first_key
, parent_slot
);
1950 /* This node is old, no need to trace */
1951 if (child_gen
< last_snapshot
)
1954 eb
= read_tree_block(fs_info
, child_bytenr
, child_gen
,
1955 cur_level
, &first_key
);
1959 } else if (!extent_buffer_uptodate(eb
)) {
1960 free_extent_buffer(eb
);
1965 dst_path
->nodes
[cur_level
] = eb
;
1966 dst_path
->slots
[cur_level
] = 0;
1968 btrfs_tree_read_lock(eb
);
1969 btrfs_set_lock_blocking_rw(eb
, BTRFS_READ_LOCK
);
1970 dst_path
->locks
[cur_level
] = BTRFS_READ_LOCK_BLOCKING
;
1971 need_cleanup
= true;
1974 /* Now record this tree block and its counter part for qgroups */
1975 ret
= qgroup_trace_extent_swap(trans
, src_eb
, dst_path
, cur_level
,
1976 root_level
, trace_leaf
);
1980 eb
= dst_path
->nodes
[cur_level
];
1982 if (cur_level
> 0) {
1983 /* Iterate all child tree blocks */
1984 for (i
= 0; i
< btrfs_header_nritems(eb
); i
++) {
1985 /* Skip old tree blocks as they won't be swapped */
1986 if (btrfs_node_ptr_generation(eb
, i
) < last_snapshot
)
1988 dst_path
->slots
[cur_level
] = i
;
1990 /* Recursive call (at most 7 times) */
1991 ret
= qgroup_trace_new_subtree_blocks(trans
, src_eb
,
1992 dst_path
, cur_level
- 1, root_level
,
1993 last_snapshot
, trace_leaf
);
2002 btrfs_tree_unlock_rw(dst_path
->nodes
[cur_level
],
2003 dst_path
->locks
[cur_level
]);
2004 free_extent_buffer(dst_path
->nodes
[cur_level
]);
2005 dst_path
->nodes
[cur_level
] = NULL
;
2006 dst_path
->slots
[cur_level
] = 0;
2007 dst_path
->locks
[cur_level
] = 0;
2014 * Inform qgroup to trace subtree swap used in balance.
2016 * Unlike btrfs_qgroup_trace_subtree(), this function will only trace
2017 * new tree blocks whose generation is equal to (or larger than) @last_snapshot.
2019 * Will go down the tree block pointed by @dst_eb (pointed by @dst_parent and
2020 * @dst_slot), and find any tree blocks whose generation is at @last_snapshot,
2021 * and then go down @src_eb (pointed by @src_parent and @src_slot) to find
2022 * the conterpart of the tree block, then mark both tree blocks as qgroup dirty,
2023 * and skip all tree blocks whose generation is smaller than last_snapshot.
2025 * This would skip tons of tree blocks of original btrfs_qgroup_trace_subtree(),
2026 * which could be the cause of very slow balance if the file tree is large.
2028 * @src_parent, @src_slot: pointer to src (file tree) eb.
2029 * @dst_parent, @dst_slot: pointer to dst (reloc tree) eb.
2031 int btrfs_qgroup_trace_subtree_swap(struct btrfs_trans_handle
*trans
,
2032 struct btrfs_block_group_cache
*bg_cache
,
2033 struct extent_buffer
*src_parent
, int src_slot
,
2034 struct extent_buffer
*dst_parent
, int dst_slot
,
2037 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
2038 struct btrfs_path
*dst_path
= NULL
;
2039 struct btrfs_key first_key
;
2040 struct extent_buffer
*src_eb
= NULL
;
2041 struct extent_buffer
*dst_eb
= NULL
;
2042 bool trace_leaf
= false;
2048 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
))
2051 /* Check parameter order */
2052 if (btrfs_node_ptr_generation(src_parent
, src_slot
) >
2053 btrfs_node_ptr_generation(dst_parent
, dst_slot
)) {
2054 btrfs_err_rl(fs_info
,
2055 "%s: bad parameter order, src_gen=%llu dst_gen=%llu", __func__
,
2056 btrfs_node_ptr_generation(src_parent
, src_slot
),
2057 btrfs_node_ptr_generation(dst_parent
, dst_slot
));
2062 * Only trace leaf if we're relocating data block groups, this could
2063 * reduce tons of data extents tracing for meta/sys bg relocation.
2065 if (bg_cache
->flags
& BTRFS_BLOCK_GROUP_DATA
)
2067 /* Read out real @src_eb, pointed by @src_parent and @src_slot */
2068 child_bytenr
= btrfs_node_blockptr(src_parent
, src_slot
);
2069 child_gen
= btrfs_node_ptr_generation(src_parent
, src_slot
);
2070 btrfs_node_key_to_cpu(src_parent
, &first_key
, src_slot
);
2072 src_eb
= read_tree_block(fs_info
, child_bytenr
, child_gen
,
2073 btrfs_header_level(src_parent
) - 1, &first_key
);
2074 if (IS_ERR(src_eb
)) {
2075 ret
= PTR_ERR(src_eb
);
2079 /* Read out real @dst_eb, pointed by @src_parent and @src_slot */
2080 child_bytenr
= btrfs_node_blockptr(dst_parent
, dst_slot
);
2081 child_gen
= btrfs_node_ptr_generation(dst_parent
, dst_slot
);
2082 btrfs_node_key_to_cpu(dst_parent
, &first_key
, dst_slot
);
2084 dst_eb
= read_tree_block(fs_info
, child_bytenr
, child_gen
,
2085 btrfs_header_level(dst_parent
) - 1, &first_key
);
2086 if (IS_ERR(dst_eb
)) {
2087 ret
= PTR_ERR(dst_eb
);
2091 if (!extent_buffer_uptodate(src_eb
) || !extent_buffer_uptodate(dst_eb
)) {
2096 level
= btrfs_header_level(dst_eb
);
2097 dst_path
= btrfs_alloc_path();
2104 extent_buffer_get(dst_eb
);
2105 dst_path
->nodes
[level
] = dst_eb
;
2106 dst_path
->slots
[level
] = 0;
2107 dst_path
->locks
[level
] = 0;
2109 /* Do the generation-aware breadth-first search */
2110 ret
= qgroup_trace_new_subtree_blocks(trans
, src_eb
, dst_path
, level
,
2111 level
, last_snapshot
, trace_leaf
);
2117 free_extent_buffer(src_eb
);
2118 free_extent_buffer(dst_eb
);
2119 btrfs_free_path(dst_path
);
2121 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
2125 int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle
*trans
,
2126 struct extent_buffer
*root_eb
,
2127 u64 root_gen
, int root_level
)
2129 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
2132 struct extent_buffer
*eb
= root_eb
;
2133 struct btrfs_path
*path
= NULL
;
2135 BUG_ON(root_level
< 0 || root_level
>= BTRFS_MAX_LEVEL
);
2136 BUG_ON(root_eb
== NULL
);
2138 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
))
2141 if (!extent_buffer_uptodate(root_eb
)) {
2142 ret
= btrfs_read_buffer(root_eb
, root_gen
, root_level
, NULL
);
2147 if (root_level
== 0) {
2148 ret
= btrfs_qgroup_trace_leaf_items(trans
, root_eb
);
2152 path
= btrfs_alloc_path();
2157 * Walk down the tree. Missing extent blocks are filled in as
2158 * we go. Metadata is accounted every time we read a new
2161 * When we reach a leaf, we account for file extent items in it,
2162 * walk back up the tree (adjusting slot pointers as we go)
2163 * and restart the search process.
2165 extent_buffer_get(root_eb
); /* For path */
2166 path
->nodes
[root_level
] = root_eb
;
2167 path
->slots
[root_level
] = 0;
2168 path
->locks
[root_level
] = 0; /* so release_path doesn't try to unlock */
2171 while (level
>= 0) {
2172 if (path
->nodes
[level
] == NULL
) {
2173 struct btrfs_key first_key
;
2179 * We need to get child blockptr/gen from parent before
2182 eb
= path
->nodes
[level
+ 1];
2183 parent_slot
= path
->slots
[level
+ 1];
2184 child_bytenr
= btrfs_node_blockptr(eb
, parent_slot
);
2185 child_gen
= btrfs_node_ptr_generation(eb
, parent_slot
);
2186 btrfs_node_key_to_cpu(eb
, &first_key
, parent_slot
);
2188 eb
= read_tree_block(fs_info
, child_bytenr
, child_gen
,
2193 } else if (!extent_buffer_uptodate(eb
)) {
2194 free_extent_buffer(eb
);
2199 path
->nodes
[level
] = eb
;
2200 path
->slots
[level
] = 0;
2202 btrfs_tree_read_lock(eb
);
2203 btrfs_set_lock_blocking_rw(eb
, BTRFS_READ_LOCK
);
2204 path
->locks
[level
] = BTRFS_READ_LOCK_BLOCKING
;
2206 ret
= btrfs_qgroup_trace_extent(trans
, child_bytenr
,
2214 ret
= btrfs_qgroup_trace_leaf_items(trans
,
2215 path
->nodes
[level
]);
2219 /* Nonzero return here means we completed our search */
2220 ret
= adjust_slots_upwards(path
, root_level
);
2224 /* Restart search with new slots */
2233 btrfs_free_path(path
);
2238 #define UPDATE_NEW 0
2239 #define UPDATE_OLD 1
2241 * Walk all of the roots that points to the bytenr and adjust their refcnts.
2243 static int qgroup_update_refcnt(struct btrfs_fs_info
*fs_info
,
2244 struct ulist
*roots
, struct ulist
*tmp
,
2245 struct ulist
*qgroups
, u64 seq
, int update_old
)
2247 struct ulist_node
*unode
;
2248 struct ulist_iterator uiter
;
2249 struct ulist_node
*tmp_unode
;
2250 struct ulist_iterator tmp_uiter
;
2251 struct btrfs_qgroup
*qg
;
2256 ULIST_ITER_INIT(&uiter
);
2257 while ((unode
= ulist_next(roots
, &uiter
))) {
2258 qg
= find_qgroup_rb(fs_info
, unode
->val
);
2263 ret
= ulist_add(qgroups
, qg
->qgroupid
, qgroup_to_aux(qg
),
2267 ret
= ulist_add(tmp
, qg
->qgroupid
, qgroup_to_aux(qg
), GFP_ATOMIC
);
2270 ULIST_ITER_INIT(&tmp_uiter
);
2271 while ((tmp_unode
= ulist_next(tmp
, &tmp_uiter
))) {
2272 struct btrfs_qgroup_list
*glist
;
2274 qg
= unode_aux_to_qgroup(tmp_unode
);
2276 btrfs_qgroup_update_old_refcnt(qg
, seq
, 1);
2278 btrfs_qgroup_update_new_refcnt(qg
, seq
, 1);
2279 list_for_each_entry(glist
, &qg
->groups
, next_group
) {
2280 ret
= ulist_add(qgroups
, glist
->group
->qgroupid
,
2281 qgroup_to_aux(glist
->group
),
2285 ret
= ulist_add(tmp
, glist
->group
->qgroupid
,
2286 qgroup_to_aux(glist
->group
),
2297 * Update qgroup rfer/excl counters.
2298 * Rfer update is easy, codes can explain themselves.
2300 * Excl update is tricky, the update is split into 2 part.
2301 * Part 1: Possible exclusive <-> sharing detect:
2303 * -------------------------------------
2305 * -------------------------------------
2307 * -------------------------------------
2310 * A: cur_old_roots < nr_old_roots (not exclusive before)
2311 * !A: cur_old_roots == nr_old_roots (possible exclusive before)
2312 * B: cur_new_roots < nr_new_roots (not exclusive now)
2313 * !B: cur_new_roots == nr_new_roots (possible exclusive now)
2316 * +: Possible sharing -> exclusive -: Possible exclusive -> sharing
2317 * *: Definitely not changed. **: Possible unchanged.
2319 * For !A and !B condition, the exception is cur_old/new_roots == 0 case.
2321 * To make the logic clear, we first use condition A and B to split
2322 * combination into 4 results.
2324 * Then, for result "+" and "-", check old/new_roots == 0 case, as in them
2325 * only on variant maybe 0.
2327 * Lastly, check result **, since there are 2 variants maybe 0, split them
2329 * But this time we don't need to consider other things, the codes and logic
2330 * is easy to understand now.
2332 static int qgroup_update_counters(struct btrfs_fs_info
*fs_info
,
2333 struct ulist
*qgroups
,
2336 u64 num_bytes
, u64 seq
)
2338 struct ulist_node
*unode
;
2339 struct ulist_iterator uiter
;
2340 struct btrfs_qgroup
*qg
;
2341 u64 cur_new_count
, cur_old_count
;
2343 ULIST_ITER_INIT(&uiter
);
2344 while ((unode
= ulist_next(qgroups
, &uiter
))) {
2347 qg
= unode_aux_to_qgroup(unode
);
2348 cur_old_count
= btrfs_qgroup_get_old_refcnt(qg
, seq
);
2349 cur_new_count
= btrfs_qgroup_get_new_refcnt(qg
, seq
);
2351 trace_qgroup_update_counters(fs_info
, qg
, cur_old_count
,
2354 /* Rfer update part */
2355 if (cur_old_count
== 0 && cur_new_count
> 0) {
2356 qg
->rfer
+= num_bytes
;
2357 qg
->rfer_cmpr
+= num_bytes
;
2360 if (cur_old_count
> 0 && cur_new_count
== 0) {
2361 qg
->rfer
-= num_bytes
;
2362 qg
->rfer_cmpr
-= num_bytes
;
2366 /* Excl update part */
2367 /* Exclusive/none -> shared case */
2368 if (cur_old_count
== nr_old_roots
&&
2369 cur_new_count
< nr_new_roots
) {
2370 /* Exclusive -> shared */
2371 if (cur_old_count
!= 0) {
2372 qg
->excl
-= num_bytes
;
2373 qg
->excl_cmpr
-= num_bytes
;
2378 /* Shared -> exclusive/none case */
2379 if (cur_old_count
< nr_old_roots
&&
2380 cur_new_count
== nr_new_roots
) {
2381 /* Shared->exclusive */
2382 if (cur_new_count
!= 0) {
2383 qg
->excl
+= num_bytes
;
2384 qg
->excl_cmpr
+= num_bytes
;
2389 /* Exclusive/none -> exclusive/none case */
2390 if (cur_old_count
== nr_old_roots
&&
2391 cur_new_count
== nr_new_roots
) {
2392 if (cur_old_count
== 0) {
2393 /* None -> exclusive/none */
2395 if (cur_new_count
!= 0) {
2396 /* None -> exclusive */
2397 qg
->excl
+= num_bytes
;
2398 qg
->excl_cmpr
+= num_bytes
;
2401 /* None -> none, nothing changed */
2403 /* Exclusive -> exclusive/none */
2405 if (cur_new_count
== 0) {
2406 /* Exclusive -> none */
2407 qg
->excl
-= num_bytes
;
2408 qg
->excl_cmpr
-= num_bytes
;
2411 /* Exclusive -> exclusive, nothing changed */
2416 qgroup_dirty(fs_info
, qg
);
2422 * Check if the @roots potentially is a list of fs tree roots
2424 * Return 0 for definitely not a fs/subvol tree roots ulist
2425 * Return 1 for possible fs/subvol tree roots in the list (considering an empty
2428 static int maybe_fs_roots(struct ulist
*roots
)
2430 struct ulist_node
*unode
;
2431 struct ulist_iterator uiter
;
2433 /* Empty one, still possible for fs roots */
2434 if (!roots
|| roots
->nnodes
== 0)
2437 ULIST_ITER_INIT(&uiter
);
2438 unode
= ulist_next(roots
, &uiter
);
2443 * If it contains fs tree roots, then it must belong to fs/subvol
2445 * If it contains a non-fs tree, it won't be shared with fs/subvol trees.
2447 return is_fstree(unode
->val
);
2450 int btrfs_qgroup_account_extent(struct btrfs_trans_handle
*trans
, u64 bytenr
,
2451 u64 num_bytes
, struct ulist
*old_roots
,
2452 struct ulist
*new_roots
)
2454 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
2455 struct ulist
*qgroups
= NULL
;
2456 struct ulist
*tmp
= NULL
;
2458 u64 nr_new_roots
= 0;
2459 u64 nr_old_roots
= 0;
2462 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
))
2466 if (!maybe_fs_roots(new_roots
))
2468 nr_new_roots
= new_roots
->nnodes
;
2471 if (!maybe_fs_roots(old_roots
))
2473 nr_old_roots
= old_roots
->nnodes
;
2476 /* Quick exit, either not fs tree roots, or won't affect any qgroup */
2477 if (nr_old_roots
== 0 && nr_new_roots
== 0)
2480 BUG_ON(!fs_info
->quota_root
);
2482 trace_btrfs_qgroup_account_extent(fs_info
, trans
->transid
, bytenr
,
2483 num_bytes
, nr_old_roots
, nr_new_roots
);
2485 qgroups
= ulist_alloc(GFP_NOFS
);
2490 tmp
= ulist_alloc(GFP_NOFS
);
2496 mutex_lock(&fs_info
->qgroup_rescan_lock
);
2497 if (fs_info
->qgroup_flags
& BTRFS_QGROUP_STATUS_FLAG_RESCAN
) {
2498 if (fs_info
->qgroup_rescan_progress
.objectid
<= bytenr
) {
2499 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
2504 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
2506 spin_lock(&fs_info
->qgroup_lock
);
2507 seq
= fs_info
->qgroup_seq
;
2509 /* Update old refcnts using old_roots */
2510 ret
= qgroup_update_refcnt(fs_info
, old_roots
, tmp
, qgroups
, seq
,
2515 /* Update new refcnts using new_roots */
2516 ret
= qgroup_update_refcnt(fs_info
, new_roots
, tmp
, qgroups
, seq
,
2521 qgroup_update_counters(fs_info
, qgroups
, nr_old_roots
, nr_new_roots
,
2525 * Bump qgroup_seq to avoid seq overlap
2527 fs_info
->qgroup_seq
+= max(nr_old_roots
, nr_new_roots
) + 1;
2529 spin_unlock(&fs_info
->qgroup_lock
);
2532 ulist_free(qgroups
);
2533 ulist_free(old_roots
);
2534 ulist_free(new_roots
);
2538 int btrfs_qgroup_account_extents(struct btrfs_trans_handle
*trans
)
2540 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
2541 struct btrfs_qgroup_extent_record
*record
;
2542 struct btrfs_delayed_ref_root
*delayed_refs
;
2543 struct ulist
*new_roots
= NULL
;
2544 struct rb_node
*node
;
2545 u64 num_dirty_extents
= 0;
2549 delayed_refs
= &trans
->transaction
->delayed_refs
;
2550 qgroup_to_skip
= delayed_refs
->qgroup_to_skip
;
2551 while ((node
= rb_first(&delayed_refs
->dirty_extent_root
))) {
2552 record
= rb_entry(node
, struct btrfs_qgroup_extent_record
,
2555 num_dirty_extents
++;
2556 trace_btrfs_qgroup_account_extents(fs_info
, record
);
2560 * Old roots should be searched when inserting qgroup
2563 if (WARN_ON(!record
->old_roots
)) {
2564 /* Search commit root to find old_roots */
2565 ret
= btrfs_find_all_roots(NULL
, fs_info
,
2567 &record
->old_roots
, false);
2573 * Use SEQ_LAST as time_seq to do special search, which
2574 * doesn't lock tree or delayed_refs and search current
2575 * root. It's safe inside commit_transaction().
2577 ret
= btrfs_find_all_roots(trans
, fs_info
,
2578 record
->bytenr
, SEQ_LAST
, &new_roots
, false);
2581 if (qgroup_to_skip
) {
2582 ulist_del(new_roots
, qgroup_to_skip
, 0);
2583 ulist_del(record
->old_roots
, qgroup_to_skip
,
2586 ret
= btrfs_qgroup_account_extent(trans
, record
->bytenr
,
2590 record
->old_roots
= NULL
;
2594 ulist_free(record
->old_roots
);
2595 ulist_free(new_roots
);
2597 rb_erase(node
, &delayed_refs
->dirty_extent_root
);
2601 trace_qgroup_num_dirty_extents(fs_info
, trans
->transid
,
2607 * called from commit_transaction. Writes all changed qgroups to disk.
2609 int btrfs_run_qgroups(struct btrfs_trans_handle
*trans
)
2611 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
2612 struct btrfs_root
*quota_root
= fs_info
->quota_root
;
2618 spin_lock(&fs_info
->qgroup_lock
);
2619 while (!list_empty(&fs_info
->dirty_qgroups
)) {
2620 struct btrfs_qgroup
*qgroup
;
2621 qgroup
= list_first_entry(&fs_info
->dirty_qgroups
,
2622 struct btrfs_qgroup
, dirty
);
2623 list_del_init(&qgroup
->dirty
);
2624 spin_unlock(&fs_info
->qgroup_lock
);
2625 ret
= update_qgroup_info_item(trans
, qgroup
);
2627 fs_info
->qgroup_flags
|=
2628 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
2629 ret
= update_qgroup_limit_item(trans
, qgroup
);
2631 fs_info
->qgroup_flags
|=
2632 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
2633 spin_lock(&fs_info
->qgroup_lock
);
2635 if (test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
))
2636 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_ON
;
2638 fs_info
->qgroup_flags
&= ~BTRFS_QGROUP_STATUS_FLAG_ON
;
2639 spin_unlock(&fs_info
->qgroup_lock
);
2641 ret
= update_qgroup_status_item(trans
);
2643 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
2649 * Copy the accounting information between qgroups. This is necessary
2650 * when a snapshot or a subvolume is created. Throwing an error will
2651 * cause a transaction abort so we take extra care here to only error
2652 * when a readonly fs is a reasonable outcome.
2654 int btrfs_qgroup_inherit(struct btrfs_trans_handle
*trans
, u64 srcid
,
2655 u64 objectid
, struct btrfs_qgroup_inherit
*inherit
)
2660 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
2661 struct btrfs_root
*quota_root
= fs_info
->quota_root
;
2662 struct btrfs_qgroup
*srcgroup
;
2663 struct btrfs_qgroup
*dstgroup
;
2667 mutex_lock(&fs_info
->qgroup_ioctl_lock
);
2668 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
))
2677 i_qgroups
= (u64
*)(inherit
+ 1);
2678 nums
= inherit
->num_qgroups
+ 2 * inherit
->num_ref_copies
+
2679 2 * inherit
->num_excl_copies
;
2680 for (i
= 0; i
< nums
; ++i
) {
2681 srcgroup
= find_qgroup_rb(fs_info
, *i_qgroups
);
2684 * Zero out invalid groups so we can ignore
2688 ((srcgroup
->qgroupid
>> 48) <= (objectid
>> 48)))
2696 * create a tracking group for the subvol itself
2698 ret
= add_qgroup_item(trans
, quota_root
, objectid
);
2703 * add qgroup to all inherited groups
2706 i_qgroups
= (u64
*)(inherit
+ 1);
2707 for (i
= 0; i
< inherit
->num_qgroups
; ++i
, ++i_qgroups
) {
2708 if (*i_qgroups
== 0)
2710 ret
= add_qgroup_relation_item(trans
, objectid
,
2712 if (ret
&& ret
!= -EEXIST
)
2714 ret
= add_qgroup_relation_item(trans
, *i_qgroups
,
2716 if (ret
&& ret
!= -EEXIST
)
2723 spin_lock(&fs_info
->qgroup_lock
);
2725 dstgroup
= add_qgroup_rb(fs_info
, objectid
);
2726 if (IS_ERR(dstgroup
)) {
2727 ret
= PTR_ERR(dstgroup
);
2731 if (inherit
&& inherit
->flags
& BTRFS_QGROUP_INHERIT_SET_LIMITS
) {
2732 dstgroup
->lim_flags
= inherit
->lim
.flags
;
2733 dstgroup
->max_rfer
= inherit
->lim
.max_rfer
;
2734 dstgroup
->max_excl
= inherit
->lim
.max_excl
;
2735 dstgroup
->rsv_rfer
= inherit
->lim
.rsv_rfer
;
2736 dstgroup
->rsv_excl
= inherit
->lim
.rsv_excl
;
2738 ret
= update_qgroup_limit_item(trans
, dstgroup
);
2740 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
2742 "unable to update quota limit for %llu",
2743 dstgroup
->qgroupid
);
2749 srcgroup
= find_qgroup_rb(fs_info
, srcid
);
2754 * We call inherit after we clone the root in order to make sure
2755 * our counts don't go crazy, so at this point the only
2756 * difference between the two roots should be the root node.
2758 level_size
= fs_info
->nodesize
;
2759 dstgroup
->rfer
= srcgroup
->rfer
;
2760 dstgroup
->rfer_cmpr
= srcgroup
->rfer_cmpr
;
2761 dstgroup
->excl
= level_size
;
2762 dstgroup
->excl_cmpr
= level_size
;
2763 srcgroup
->excl
= level_size
;
2764 srcgroup
->excl_cmpr
= level_size
;
2766 /* inherit the limit info */
2767 dstgroup
->lim_flags
= srcgroup
->lim_flags
;
2768 dstgroup
->max_rfer
= srcgroup
->max_rfer
;
2769 dstgroup
->max_excl
= srcgroup
->max_excl
;
2770 dstgroup
->rsv_rfer
= srcgroup
->rsv_rfer
;
2771 dstgroup
->rsv_excl
= srcgroup
->rsv_excl
;
2773 qgroup_dirty(fs_info
, dstgroup
);
2774 qgroup_dirty(fs_info
, srcgroup
);
2780 i_qgroups
= (u64
*)(inherit
+ 1);
2781 for (i
= 0; i
< inherit
->num_qgroups
; ++i
) {
2783 ret
= add_relation_rb(fs_info
, objectid
, *i_qgroups
);
2790 for (i
= 0; i
< inherit
->num_ref_copies
; ++i
, i_qgroups
+= 2) {
2791 struct btrfs_qgroup
*src
;
2792 struct btrfs_qgroup
*dst
;
2794 if (!i_qgroups
[0] || !i_qgroups
[1])
2797 src
= find_qgroup_rb(fs_info
, i_qgroups
[0]);
2798 dst
= find_qgroup_rb(fs_info
, i_qgroups
[1]);
2805 dst
->rfer
= src
->rfer
- level_size
;
2806 dst
->rfer_cmpr
= src
->rfer_cmpr
- level_size
;
2808 for (i
= 0; i
< inherit
->num_excl_copies
; ++i
, i_qgroups
+= 2) {
2809 struct btrfs_qgroup
*src
;
2810 struct btrfs_qgroup
*dst
;
2812 if (!i_qgroups
[0] || !i_qgroups
[1])
2815 src
= find_qgroup_rb(fs_info
, i_qgroups
[0]);
2816 dst
= find_qgroup_rb(fs_info
, i_qgroups
[1]);
2823 dst
->excl
= src
->excl
+ level_size
;
2824 dst
->excl_cmpr
= src
->excl_cmpr
+ level_size
;
2828 spin_unlock(&fs_info
->qgroup_lock
);
2830 mutex_unlock(&fs_info
->qgroup_ioctl_lock
);
2835 * Two limits to commit transaction in advance.
2837 * For RATIO, it will be 1/RATIO of the remaining limit
2838 * (excluding data and prealloc meta) as threshold.
2839 * For SIZE, it will be in byte unit as threshold.
2841 #define QGROUP_PERTRANS_RATIO 32
2842 #define QGROUP_PERTRANS_SIZE SZ_32M
2843 static bool qgroup_check_limits(struct btrfs_fs_info
*fs_info
,
2844 const struct btrfs_qgroup
*qg
, u64 num_bytes
)
2849 if ((qg
->lim_flags
& BTRFS_QGROUP_LIMIT_MAX_RFER
) &&
2850 qgroup_rsv_total(qg
) + (s64
)qg
->rfer
+ num_bytes
> qg
->max_rfer
)
2853 if ((qg
->lim_flags
& BTRFS_QGROUP_LIMIT_MAX_EXCL
) &&
2854 qgroup_rsv_total(qg
) + (s64
)qg
->excl
+ num_bytes
> qg
->max_excl
)
2858 * Even if we passed the check, it's better to check if reservation
2859 * for meta_pertrans is pushing us near limit.
2860 * If there is too much pertrans reservation or it's near the limit,
2861 * let's try commit transaction to free some, using transaction_kthread
2863 if ((qg
->lim_flags
& (BTRFS_QGROUP_LIMIT_MAX_RFER
|
2864 BTRFS_QGROUP_LIMIT_MAX_EXCL
))) {
2865 if (qg
->lim_flags
& BTRFS_QGROUP_LIMIT_MAX_EXCL
)
2866 limit
= qg
->max_excl
;
2868 limit
= qg
->max_rfer
;
2869 threshold
= (limit
- qg
->rsv
.values
[BTRFS_QGROUP_RSV_DATA
] -
2870 qg
->rsv
.values
[BTRFS_QGROUP_RSV_META_PREALLOC
]) /
2871 QGROUP_PERTRANS_RATIO
;
2872 threshold
= min_t(u64
, threshold
, QGROUP_PERTRANS_SIZE
);
2875 * Use transaction_kthread to commit transaction, so we no
2876 * longer need to bother nested transaction nor lock context.
2878 if (qg
->rsv
.values
[BTRFS_QGROUP_RSV_META_PERTRANS
] > threshold
)
2879 btrfs_commit_transaction_locksafe(fs_info
);
2885 static int qgroup_reserve(struct btrfs_root
*root
, u64 num_bytes
, bool enforce
,
2886 enum btrfs_qgroup_rsv_type type
)
2888 struct btrfs_root
*quota_root
;
2889 struct btrfs_qgroup
*qgroup
;
2890 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
2891 u64 ref_root
= root
->root_key
.objectid
;
2893 struct ulist_node
*unode
;
2894 struct ulist_iterator uiter
;
2896 if (!is_fstree(ref_root
))
2902 if (test_bit(BTRFS_FS_QUOTA_OVERRIDE
, &fs_info
->flags
) &&
2903 capable(CAP_SYS_RESOURCE
))
2906 spin_lock(&fs_info
->qgroup_lock
);
2907 quota_root
= fs_info
->quota_root
;
2911 qgroup
= find_qgroup_rb(fs_info
, ref_root
);
2916 * in a first step, we check all affected qgroups if any limits would
2919 ulist_reinit(fs_info
->qgroup_ulist
);
2920 ret
= ulist_add(fs_info
->qgroup_ulist
, qgroup
->qgroupid
,
2921 qgroup_to_aux(qgroup
), GFP_ATOMIC
);
2924 ULIST_ITER_INIT(&uiter
);
2925 while ((unode
= ulist_next(fs_info
->qgroup_ulist
, &uiter
))) {
2926 struct btrfs_qgroup
*qg
;
2927 struct btrfs_qgroup_list
*glist
;
2929 qg
= unode_aux_to_qgroup(unode
);
2931 if (enforce
&& !qgroup_check_limits(fs_info
, qg
, num_bytes
)) {
2936 list_for_each_entry(glist
, &qg
->groups
, next_group
) {
2937 ret
= ulist_add(fs_info
->qgroup_ulist
,
2938 glist
->group
->qgroupid
,
2939 qgroup_to_aux(glist
->group
), GFP_ATOMIC
);
2946 * no limits exceeded, now record the reservation into all qgroups
2948 ULIST_ITER_INIT(&uiter
);
2949 while ((unode
= ulist_next(fs_info
->qgroup_ulist
, &uiter
))) {
2950 struct btrfs_qgroup
*qg
;
2952 qg
= unode_aux_to_qgroup(unode
);
2954 trace_qgroup_update_reserve(fs_info
, qg
, num_bytes
, type
);
2955 qgroup_rsv_add(fs_info
, qg
, num_bytes
, type
);
2959 spin_unlock(&fs_info
->qgroup_lock
);
2964 * Free @num_bytes of reserved space with @type for qgroup. (Normally level 0
2967 * Will handle all higher level qgroup too.
2969 * NOTE: If @num_bytes is (u64)-1, this means to free all bytes of this qgroup.
2970 * This special case is only used for META_PERTRANS type.
2972 void btrfs_qgroup_free_refroot(struct btrfs_fs_info
*fs_info
,
2973 u64 ref_root
, u64 num_bytes
,
2974 enum btrfs_qgroup_rsv_type type
)
2976 struct btrfs_root
*quota_root
;
2977 struct btrfs_qgroup
*qgroup
;
2978 struct ulist_node
*unode
;
2979 struct ulist_iterator uiter
;
2982 if (!is_fstree(ref_root
))
2988 if (num_bytes
== (u64
)-1 && type
!= BTRFS_QGROUP_RSV_META_PERTRANS
) {
2989 WARN(1, "%s: Invalid type to free", __func__
);
2992 spin_lock(&fs_info
->qgroup_lock
);
2994 quota_root
= fs_info
->quota_root
;
2998 qgroup
= find_qgroup_rb(fs_info
, ref_root
);
3002 if (num_bytes
== (u64
)-1)
3004 * We're freeing all pertrans rsv, get reserved value from
3005 * level 0 qgroup as real num_bytes to free.
3007 num_bytes
= qgroup
->rsv
.values
[type
];
3009 ulist_reinit(fs_info
->qgroup_ulist
);
3010 ret
= ulist_add(fs_info
->qgroup_ulist
, qgroup
->qgroupid
,
3011 qgroup_to_aux(qgroup
), GFP_ATOMIC
);
3014 ULIST_ITER_INIT(&uiter
);
3015 while ((unode
= ulist_next(fs_info
->qgroup_ulist
, &uiter
))) {
3016 struct btrfs_qgroup
*qg
;
3017 struct btrfs_qgroup_list
*glist
;
3019 qg
= unode_aux_to_qgroup(unode
);
3021 trace_qgroup_update_reserve(fs_info
, qg
, -(s64
)num_bytes
, type
);
3022 qgroup_rsv_release(fs_info
, qg
, num_bytes
, type
);
3024 list_for_each_entry(glist
, &qg
->groups
, next_group
) {
3025 ret
= ulist_add(fs_info
->qgroup_ulist
,
3026 glist
->group
->qgroupid
,
3027 qgroup_to_aux(glist
->group
), GFP_ATOMIC
);
3034 spin_unlock(&fs_info
->qgroup_lock
);
3038 * Check if the leaf is the last leaf. Which means all node pointers
3039 * are at their last position.
3041 static bool is_last_leaf(struct btrfs_path
*path
)
3045 for (i
= 1; i
< BTRFS_MAX_LEVEL
&& path
->nodes
[i
]; i
++) {
3046 if (path
->slots
[i
] != btrfs_header_nritems(path
->nodes
[i
]) - 1)
3053 * returns < 0 on error, 0 when more leafs are to be scanned.
3054 * returns 1 when done.
3056 static int qgroup_rescan_leaf(struct btrfs_trans_handle
*trans
,
3057 struct btrfs_path
*path
)
3059 struct btrfs_fs_info
*fs_info
= trans
->fs_info
;
3060 struct btrfs_key found
;
3061 struct extent_buffer
*scratch_leaf
= NULL
;
3062 struct ulist
*roots
= NULL
;
3068 mutex_lock(&fs_info
->qgroup_rescan_lock
);
3069 ret
= btrfs_search_slot_for_read(fs_info
->extent_root
,
3070 &fs_info
->qgroup_rescan_progress
,
3073 btrfs_debug(fs_info
,
3074 "current progress key (%llu %u %llu), search_slot ret %d",
3075 fs_info
->qgroup_rescan_progress
.objectid
,
3076 fs_info
->qgroup_rescan_progress
.type
,
3077 fs_info
->qgroup_rescan_progress
.offset
, ret
);
3081 * The rescan is about to end, we will not be scanning any
3082 * further blocks. We cannot unset the RESCAN flag here, because
3083 * we want to commit the transaction if everything went well.
3084 * To make the live accounting work in this phase, we set our
3085 * scan progress pointer such that every real extent objectid
3088 fs_info
->qgroup_rescan_progress
.objectid
= (u64
)-1;
3089 btrfs_release_path(path
);
3090 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3093 done
= is_last_leaf(path
);
3095 btrfs_item_key_to_cpu(path
->nodes
[0], &found
,
3096 btrfs_header_nritems(path
->nodes
[0]) - 1);
3097 fs_info
->qgroup_rescan_progress
.objectid
= found
.objectid
+ 1;
3099 scratch_leaf
= btrfs_clone_extent_buffer(path
->nodes
[0]);
3100 if (!scratch_leaf
) {
3102 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3105 extent_buffer_get(scratch_leaf
);
3106 btrfs_tree_read_lock(scratch_leaf
);
3107 btrfs_set_lock_blocking_rw(scratch_leaf
, BTRFS_READ_LOCK
);
3108 slot
= path
->slots
[0];
3109 btrfs_release_path(path
);
3110 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3112 for (; slot
< btrfs_header_nritems(scratch_leaf
); ++slot
) {
3113 btrfs_item_key_to_cpu(scratch_leaf
, &found
, slot
);
3114 if (found
.type
!= BTRFS_EXTENT_ITEM_KEY
&&
3115 found
.type
!= BTRFS_METADATA_ITEM_KEY
)
3117 if (found
.type
== BTRFS_METADATA_ITEM_KEY
)
3118 num_bytes
= fs_info
->nodesize
;
3120 num_bytes
= found
.offset
;
3122 ret
= btrfs_find_all_roots(NULL
, fs_info
, found
.objectid
, 0,
3126 /* For rescan, just pass old_roots as NULL */
3127 ret
= btrfs_qgroup_account_extent(trans
, found
.objectid
,
3128 num_bytes
, NULL
, roots
);
3134 btrfs_tree_read_unlock_blocking(scratch_leaf
);
3135 free_extent_buffer(scratch_leaf
);
3140 fs_info
->qgroup_rescan_progress
.objectid
= (u64
)-1;
3145 static void btrfs_qgroup_rescan_worker(struct btrfs_work
*work
)
3147 struct btrfs_fs_info
*fs_info
= container_of(work
, struct btrfs_fs_info
,
3148 qgroup_rescan_work
);
3149 struct btrfs_path
*path
;
3150 struct btrfs_trans_handle
*trans
= NULL
;
3154 path
= btrfs_alloc_path();
3158 * Rescan should only search for commit root, and any later difference
3159 * should be recorded by qgroup
3161 path
->search_commit_root
= 1;
3162 path
->skip_locking
= 1;
3165 while (!err
&& !btrfs_fs_closing(fs_info
)) {
3166 trans
= btrfs_start_transaction(fs_info
->fs_root
, 0);
3167 if (IS_ERR(trans
)) {
3168 err
= PTR_ERR(trans
);
3171 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
)) {
3174 err
= qgroup_rescan_leaf(trans
, path
);
3177 btrfs_commit_transaction(trans
);
3179 btrfs_end_transaction(trans
);
3183 btrfs_free_path(path
);
3185 mutex_lock(&fs_info
->qgroup_rescan_lock
);
3186 if (!btrfs_fs_closing(fs_info
))
3187 fs_info
->qgroup_flags
&= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN
;
3190 fs_info
->qgroup_flags
& BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
) {
3191 fs_info
->qgroup_flags
&= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
3192 } else if (err
< 0) {
3193 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT
;
3195 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3198 * only update status, since the previous part has already updated the
3201 trans
= btrfs_start_transaction(fs_info
->quota_root
, 1);
3202 if (IS_ERR(trans
)) {
3203 err
= PTR_ERR(trans
);
3205 "fail to start transaction for status update: %d",
3209 ret
= update_qgroup_status_item(trans
);
3212 btrfs_err(fs_info
, "fail to update qgroup status: %d", err
);
3214 btrfs_end_transaction(trans
);
3216 if (btrfs_fs_closing(fs_info
)) {
3217 btrfs_info(fs_info
, "qgroup scan paused");
3218 } else if (err
>= 0) {
3219 btrfs_info(fs_info
, "qgroup scan completed%s",
3220 err
> 0 ? " (inconsistency flag cleared)" : "");
3222 btrfs_err(fs_info
, "qgroup scan failed with %d", err
);
3226 mutex_lock(&fs_info
->qgroup_rescan_lock
);
3227 fs_info
->qgroup_rescan_running
= false;
3228 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3229 complete_all(&fs_info
->qgroup_rescan_completion
);
3233 * Checks that (a) no rescan is running and (b) quota is enabled. Allocates all
3234 * memory required for the rescan context.
3237 qgroup_rescan_init(struct btrfs_fs_info
*fs_info
, u64 progress_objectid
,
3243 /* we're resuming qgroup rescan at mount time */
3244 if (!(fs_info
->qgroup_flags
&
3245 BTRFS_QGROUP_STATUS_FLAG_RESCAN
)) {
3247 "qgroup rescan init failed, qgroup is not enabled");
3249 } else if (!(fs_info
->qgroup_flags
&
3250 BTRFS_QGROUP_STATUS_FLAG_ON
)) {
3252 "qgroup rescan init failed, qgroup rescan is not queued");
3260 mutex_lock(&fs_info
->qgroup_rescan_lock
);
3261 spin_lock(&fs_info
->qgroup_lock
);
3264 if (fs_info
->qgroup_flags
& BTRFS_QGROUP_STATUS_FLAG_RESCAN
) {
3266 "qgroup rescan is already in progress");
3268 } else if (!(fs_info
->qgroup_flags
&
3269 BTRFS_QGROUP_STATUS_FLAG_ON
)) {
3271 "qgroup rescan init failed, qgroup is not enabled");
3276 spin_unlock(&fs_info
->qgroup_lock
);
3277 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3280 fs_info
->qgroup_flags
|= BTRFS_QGROUP_STATUS_FLAG_RESCAN
;
3283 memset(&fs_info
->qgroup_rescan_progress
, 0,
3284 sizeof(fs_info
->qgroup_rescan_progress
));
3285 fs_info
->qgroup_rescan_progress
.objectid
= progress_objectid
;
3286 init_completion(&fs_info
->qgroup_rescan_completion
);
3287 fs_info
->qgroup_rescan_running
= true;
3289 spin_unlock(&fs_info
->qgroup_lock
);
3290 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3292 memset(&fs_info
->qgroup_rescan_work
, 0,
3293 sizeof(fs_info
->qgroup_rescan_work
));
3294 btrfs_init_work(&fs_info
->qgroup_rescan_work
,
3295 btrfs_qgroup_rescan_helper
,
3296 btrfs_qgroup_rescan_worker
, NULL
, NULL
);
3301 qgroup_rescan_zero_tracking(struct btrfs_fs_info
*fs_info
)
3304 struct btrfs_qgroup
*qgroup
;
3306 spin_lock(&fs_info
->qgroup_lock
);
3307 /* clear all current qgroup tracking information */
3308 for (n
= rb_first(&fs_info
->qgroup_tree
); n
; n
= rb_next(n
)) {
3309 qgroup
= rb_entry(n
, struct btrfs_qgroup
, node
);
3311 qgroup
->rfer_cmpr
= 0;
3313 qgroup
->excl_cmpr
= 0;
3314 qgroup_dirty(fs_info
, qgroup
);
3316 spin_unlock(&fs_info
->qgroup_lock
);
3320 btrfs_qgroup_rescan(struct btrfs_fs_info
*fs_info
)
3323 struct btrfs_trans_handle
*trans
;
3325 ret
= qgroup_rescan_init(fs_info
, 0, 1);
3330 * We have set the rescan_progress to 0, which means no more
3331 * delayed refs will be accounted by btrfs_qgroup_account_ref.
3332 * However, btrfs_qgroup_account_ref may be right after its call
3333 * to btrfs_find_all_roots, in which case it would still do the
3335 * To solve this, we're committing the transaction, which will
3336 * ensure we run all delayed refs and only after that, we are
3337 * going to clear all tracking information for a clean start.
3340 trans
= btrfs_join_transaction(fs_info
->fs_root
);
3341 if (IS_ERR(trans
)) {
3342 fs_info
->qgroup_flags
&= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN
;
3343 return PTR_ERR(trans
);
3345 ret
= btrfs_commit_transaction(trans
);
3347 fs_info
->qgroup_flags
&= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN
;
3351 qgroup_rescan_zero_tracking(fs_info
);
3353 btrfs_queue_work(fs_info
->qgroup_rescan_workers
,
3354 &fs_info
->qgroup_rescan_work
);
3359 int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info
*fs_info
,
3365 mutex_lock(&fs_info
->qgroup_rescan_lock
);
3366 spin_lock(&fs_info
->qgroup_lock
);
3367 running
= fs_info
->qgroup_rescan_running
;
3368 spin_unlock(&fs_info
->qgroup_lock
);
3369 mutex_unlock(&fs_info
->qgroup_rescan_lock
);
3375 ret
= wait_for_completion_interruptible(
3376 &fs_info
->qgroup_rescan_completion
);
3378 wait_for_completion(&fs_info
->qgroup_rescan_completion
);
3384 * this is only called from open_ctree where we're still single threaded, thus
3385 * locking is omitted here.
3388 btrfs_qgroup_rescan_resume(struct btrfs_fs_info
*fs_info
)
3390 if (fs_info
->qgroup_flags
& BTRFS_QGROUP_STATUS_FLAG_RESCAN
)
3391 btrfs_queue_work(fs_info
->qgroup_rescan_workers
,
3392 &fs_info
->qgroup_rescan_work
);
3396 * Reserve qgroup space for range [start, start + len).
3398 * This function will either reserve space from related qgroups or doing
3399 * nothing if the range is already reserved.
3401 * Return 0 for successful reserve
3402 * Return <0 for error (including -EQUOT)
3404 * NOTE: this function may sleep for memory allocation.
3405 * if btrfs_qgroup_reserve_data() is called multiple times with
3406 * same @reserved, caller must ensure when error happens it's OK
3407 * to free *ALL* reserved space.
3409 int btrfs_qgroup_reserve_data(struct inode
*inode
,
3410 struct extent_changeset
**reserved_ret
, u64 start
,
3413 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
3414 struct ulist_node
*unode
;
3415 struct ulist_iterator uiter
;
3416 struct extent_changeset
*reserved
;
3421 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &root
->fs_info
->flags
) ||
3422 !is_fstree(root
->root_key
.objectid
) || len
== 0)
3425 /* @reserved parameter is mandatory for qgroup */
3426 if (WARN_ON(!reserved_ret
))
3428 if (!*reserved_ret
) {
3429 *reserved_ret
= extent_changeset_alloc();
3433 reserved
= *reserved_ret
;
3434 /* Record already reserved space */
3435 orig_reserved
= reserved
->bytes_changed
;
3436 ret
= set_record_extent_bits(&BTRFS_I(inode
)->io_tree
, start
,
3437 start
+ len
-1, EXTENT_QGROUP_RESERVED
, reserved
);
3439 /* Newly reserved space */
3440 to_reserve
= reserved
->bytes_changed
- orig_reserved
;
3441 trace_btrfs_qgroup_reserve_data(inode
, start
, len
,
3442 to_reserve
, QGROUP_RESERVE
);
3445 ret
= qgroup_reserve(root
, to_reserve
, true, BTRFS_QGROUP_RSV_DATA
);
3452 /* cleanup *ALL* already reserved ranges */
3453 ULIST_ITER_INIT(&uiter
);
3454 while ((unode
= ulist_next(&reserved
->range_changed
, &uiter
)))
3455 clear_extent_bit(&BTRFS_I(inode
)->io_tree
, unode
->val
,
3456 unode
->aux
, EXTENT_QGROUP_RESERVED
, 0, 0, NULL
);
3457 extent_changeset_release(reserved
);
3461 /* Free ranges specified by @reserved, normally in error path */
3462 static int qgroup_free_reserved_data(struct inode
*inode
,
3463 struct extent_changeset
*reserved
, u64 start
, u64 len
)
3465 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
3466 struct ulist_node
*unode
;
3467 struct ulist_iterator uiter
;
3468 struct extent_changeset changeset
;
3472 extent_changeset_init(&changeset
);
3473 len
= round_up(start
+ len
, root
->fs_info
->sectorsize
);
3474 start
= round_down(start
, root
->fs_info
->sectorsize
);
3476 ULIST_ITER_INIT(&uiter
);
3477 while ((unode
= ulist_next(&reserved
->range_changed
, &uiter
))) {
3478 u64 range_start
= unode
->val
;
3479 /* unode->aux is the inclusive end */
3480 u64 range_len
= unode
->aux
- range_start
+ 1;
3484 extent_changeset_release(&changeset
);
3486 /* Only free range in range [start, start + len) */
3487 if (range_start
>= start
+ len
||
3488 range_start
+ range_len
<= start
)
3490 free_start
= max(range_start
, start
);
3491 free_len
= min(start
+ len
, range_start
+ range_len
) -
3494 * TODO: To also modify reserved->ranges_reserved to reflect
3497 * However as long as we free qgroup reserved according to
3498 * EXTENT_QGROUP_RESERVED, we won't double free.
3499 * So not need to rush.
3501 ret
= clear_record_extent_bits(&BTRFS_I(inode
)->io_failure_tree
,
3502 free_start
, free_start
+ free_len
- 1,
3503 EXTENT_QGROUP_RESERVED
, &changeset
);
3506 freed
+= changeset
.bytes_changed
;
3508 btrfs_qgroup_free_refroot(root
->fs_info
, root
->root_key
.objectid
, freed
,
3509 BTRFS_QGROUP_RSV_DATA
);
3512 extent_changeset_release(&changeset
);
3516 static int __btrfs_qgroup_release_data(struct inode
*inode
,
3517 struct extent_changeset
*reserved
, u64 start
, u64 len
,
3520 struct extent_changeset changeset
;
3521 int trace_op
= QGROUP_RELEASE
;
3524 /* In release case, we shouldn't have @reserved */
3525 WARN_ON(!free
&& reserved
);
3526 if (free
&& reserved
)
3527 return qgroup_free_reserved_data(inode
, reserved
, start
, len
);
3528 extent_changeset_init(&changeset
);
3529 ret
= clear_record_extent_bits(&BTRFS_I(inode
)->io_tree
, start
,
3530 start
+ len
-1, EXTENT_QGROUP_RESERVED
, &changeset
);
3535 trace_op
= QGROUP_FREE
;
3536 trace_btrfs_qgroup_release_data(inode
, start
, len
,
3537 changeset
.bytes_changed
, trace_op
);
3539 btrfs_qgroup_free_refroot(BTRFS_I(inode
)->root
->fs_info
,
3540 BTRFS_I(inode
)->root
->root_key
.objectid
,
3541 changeset
.bytes_changed
, BTRFS_QGROUP_RSV_DATA
);
3542 ret
= changeset
.bytes_changed
;
3544 extent_changeset_release(&changeset
);
3549 * Free a reserved space range from io_tree and related qgroups
3551 * Should be called when a range of pages get invalidated before reaching disk.
3552 * Or for error cleanup case.
3553 * if @reserved is given, only reserved range in [@start, @start + @len) will
3556 * For data written to disk, use btrfs_qgroup_release_data().
3558 * NOTE: This function may sleep for memory allocation.
3560 int btrfs_qgroup_free_data(struct inode
*inode
,
3561 struct extent_changeset
*reserved
, u64 start
, u64 len
)
3563 return __btrfs_qgroup_release_data(inode
, reserved
, start
, len
, 1);
3567 * Release a reserved space range from io_tree only.
3569 * Should be called when a range of pages get written to disk and corresponding
3570 * FILE_EXTENT is inserted into corresponding root.
3572 * Since new qgroup accounting framework will only update qgroup numbers at
3573 * commit_transaction() time, its reserved space shouldn't be freed from
3576 * But we should release the range from io_tree, to allow further write to be
3579 * NOTE: This function may sleep for memory allocation.
3581 int btrfs_qgroup_release_data(struct inode
*inode
, u64 start
, u64 len
)
3583 return __btrfs_qgroup_release_data(inode
, NULL
, start
, len
, 0);
3586 static void add_root_meta_rsv(struct btrfs_root
*root
, int num_bytes
,
3587 enum btrfs_qgroup_rsv_type type
)
3589 if (type
!= BTRFS_QGROUP_RSV_META_PREALLOC
&&
3590 type
!= BTRFS_QGROUP_RSV_META_PERTRANS
)
3595 spin_lock(&root
->qgroup_meta_rsv_lock
);
3596 if (type
== BTRFS_QGROUP_RSV_META_PREALLOC
)
3597 root
->qgroup_meta_rsv_prealloc
+= num_bytes
;
3599 root
->qgroup_meta_rsv_pertrans
+= num_bytes
;
3600 spin_unlock(&root
->qgroup_meta_rsv_lock
);
3603 static int sub_root_meta_rsv(struct btrfs_root
*root
, int num_bytes
,
3604 enum btrfs_qgroup_rsv_type type
)
3606 if (type
!= BTRFS_QGROUP_RSV_META_PREALLOC
&&
3607 type
!= BTRFS_QGROUP_RSV_META_PERTRANS
)
3612 spin_lock(&root
->qgroup_meta_rsv_lock
);
3613 if (type
== BTRFS_QGROUP_RSV_META_PREALLOC
) {
3614 num_bytes
= min_t(u64
, root
->qgroup_meta_rsv_prealloc
,
3616 root
->qgroup_meta_rsv_prealloc
-= num_bytes
;
3618 num_bytes
= min_t(u64
, root
->qgroup_meta_rsv_pertrans
,
3620 root
->qgroup_meta_rsv_pertrans
-= num_bytes
;
3622 spin_unlock(&root
->qgroup_meta_rsv_lock
);
3626 int __btrfs_qgroup_reserve_meta(struct btrfs_root
*root
, int num_bytes
,
3627 enum btrfs_qgroup_rsv_type type
, bool enforce
)
3629 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
3632 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
) ||
3633 !is_fstree(root
->root_key
.objectid
) || num_bytes
== 0)
3636 BUG_ON(num_bytes
!= round_down(num_bytes
, fs_info
->nodesize
));
3637 trace_qgroup_meta_reserve(root
, type
, (s64
)num_bytes
);
3638 ret
= qgroup_reserve(root
, num_bytes
, enforce
, type
);
3642 * Record what we have reserved into root.
3644 * To avoid quota disabled->enabled underflow.
3645 * In that case, we may try to free space we haven't reserved
3646 * (since quota was disabled), so record what we reserved into root.
3647 * And ensure later release won't underflow this number.
3649 add_root_meta_rsv(root
, num_bytes
, type
);
3653 void btrfs_qgroup_free_meta_all_pertrans(struct btrfs_root
*root
)
3655 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
3657 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
) ||
3658 !is_fstree(root
->root_key
.objectid
))
3661 /* TODO: Update trace point to handle such free */
3662 trace_qgroup_meta_free_all_pertrans(root
);
3663 /* Special value -1 means to free all reserved space */
3664 btrfs_qgroup_free_refroot(fs_info
, root
->root_key
.objectid
, (u64
)-1,
3665 BTRFS_QGROUP_RSV_META_PERTRANS
);
3668 void __btrfs_qgroup_free_meta(struct btrfs_root
*root
, int num_bytes
,
3669 enum btrfs_qgroup_rsv_type type
)
3671 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
3673 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
) ||
3674 !is_fstree(root
->root_key
.objectid
))
3678 * reservation for META_PREALLOC can happen before quota is enabled,
3679 * which can lead to underflow.
3680 * Here ensure we will only free what we really have reserved.
3682 num_bytes
= sub_root_meta_rsv(root
, num_bytes
, type
);
3683 BUG_ON(num_bytes
!= round_down(num_bytes
, fs_info
->nodesize
));
3684 trace_qgroup_meta_reserve(root
, type
, -(s64
)num_bytes
);
3685 btrfs_qgroup_free_refroot(fs_info
, root
->root_key
.objectid
,
3689 static void qgroup_convert_meta(struct btrfs_fs_info
*fs_info
, u64 ref_root
,
3692 struct btrfs_root
*quota_root
= fs_info
->quota_root
;
3693 struct btrfs_qgroup
*qgroup
;
3694 struct ulist_node
*unode
;
3695 struct ulist_iterator uiter
;
3703 spin_lock(&fs_info
->qgroup_lock
);
3704 qgroup
= find_qgroup_rb(fs_info
, ref_root
);
3707 ulist_reinit(fs_info
->qgroup_ulist
);
3708 ret
= ulist_add(fs_info
->qgroup_ulist
, qgroup
->qgroupid
,
3709 qgroup_to_aux(qgroup
), GFP_ATOMIC
);
3712 ULIST_ITER_INIT(&uiter
);
3713 while ((unode
= ulist_next(fs_info
->qgroup_ulist
, &uiter
))) {
3714 struct btrfs_qgroup
*qg
;
3715 struct btrfs_qgroup_list
*glist
;
3717 qg
= unode_aux_to_qgroup(unode
);
3719 qgroup_rsv_release(fs_info
, qg
, num_bytes
,
3720 BTRFS_QGROUP_RSV_META_PREALLOC
);
3721 qgroup_rsv_add(fs_info
, qg
, num_bytes
,
3722 BTRFS_QGROUP_RSV_META_PERTRANS
);
3723 list_for_each_entry(glist
, &qg
->groups
, next_group
) {
3724 ret
= ulist_add(fs_info
->qgroup_ulist
,
3725 glist
->group
->qgroupid
,
3726 qgroup_to_aux(glist
->group
), GFP_ATOMIC
);
3732 spin_unlock(&fs_info
->qgroup_lock
);
3735 void btrfs_qgroup_convert_reserved_meta(struct btrfs_root
*root
, int num_bytes
)
3737 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
3739 if (!test_bit(BTRFS_FS_QUOTA_ENABLED
, &fs_info
->flags
) ||
3740 !is_fstree(root
->root_key
.objectid
))
3742 /* Same as btrfs_qgroup_free_meta_prealloc() */
3743 num_bytes
= sub_root_meta_rsv(root
, num_bytes
,
3744 BTRFS_QGROUP_RSV_META_PREALLOC
);
3745 trace_qgroup_meta_convert(root
, num_bytes
);
3746 qgroup_convert_meta(fs_info
, root
->root_key
.objectid
, num_bytes
);
3750 * Check qgroup reserved space leaking, normally at destroy inode
3753 void btrfs_qgroup_check_reserved_leak(struct inode
*inode
)
3755 struct extent_changeset changeset
;
3756 struct ulist_node
*unode
;
3757 struct ulist_iterator iter
;
3760 extent_changeset_init(&changeset
);
3761 ret
= clear_record_extent_bits(&BTRFS_I(inode
)->io_tree
, 0, (u64
)-1,
3762 EXTENT_QGROUP_RESERVED
, &changeset
);
3765 if (WARN_ON(changeset
.bytes_changed
)) {
3766 ULIST_ITER_INIT(&iter
);
3767 while ((unode
= ulist_next(&changeset
.range_changed
, &iter
))) {
3768 btrfs_warn(BTRFS_I(inode
)->root
->fs_info
,
3769 "leaking qgroup reserved space, ino: %lu, start: %llu, end: %llu",
3770 inode
->i_ino
, unode
->val
, unode
->aux
);
3772 btrfs_qgroup_free_refroot(BTRFS_I(inode
)->root
->fs_info
,
3773 BTRFS_I(inode
)->root
->root_key
.objectid
,
3774 changeset
.bytes_changed
, BTRFS_QGROUP_RSV_DATA
);
3777 extent_changeset_release(&changeset
);