1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/sched.h>
20#include <linux/pagemap.h>
21#include <linux/writeback.h>
22#include <linux/blkdev.h>
23#include <linux/rbtree.h>
24#include <linux/slab.h>
25#include <linux/workqueue.h>
26#include <linux/btrfs.h>
27
28#include "ctree.h"
29#include "transaction.h"
30#include "disk-io.h"
31#include "locking.h"
32#include "ulist.h"
33#include "backref.h"
34#include "extent_io.h"
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51struct btrfs_qgroup {
52 u64 qgroupid;
53
54
55
56
57 u64 rfer;
58 u64 rfer_cmpr;
59 u64 excl;
60 u64 excl_cmpr;
61
62
63
64
65 u64 lim_flags;
66 u64 max_rfer;
67 u64 max_excl;
68 u64 rsv_rfer;
69 u64 rsv_excl;
70
71
72
73
74 u64 reserved;
75
76
77
78
79 struct list_head groups;
80 struct list_head members;
81 struct list_head dirty;
82 struct rb_node node;
83
84
85
86
87 u64 tag;
88 u64 refcnt;
89};
90
91
92
93
94struct btrfs_qgroup_list {
95 struct list_head next_group;
96 struct list_head next_member;
97 struct btrfs_qgroup *group;
98 struct btrfs_qgroup *member;
99};
100
101static int
102qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,
103 int init_flags);
104static void qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info);
105
106
107static struct btrfs_qgroup *find_qgroup_rb(struct btrfs_fs_info *fs_info,
108 u64 qgroupid)
109{
110 struct rb_node *n = fs_info->qgroup_tree.rb_node;
111 struct btrfs_qgroup *qgroup;
112
113 while (n) {
114 qgroup = rb_entry(n, struct btrfs_qgroup, node);
115 if (qgroup->qgroupid < qgroupid)
116 n = n->rb_left;
117 else if (qgroup->qgroupid > qgroupid)
118 n = n->rb_right;
119 else
120 return qgroup;
121 }
122 return NULL;
123}
124
125
126static struct btrfs_qgroup *add_qgroup_rb(struct btrfs_fs_info *fs_info,
127 u64 qgroupid)
128{
129 struct rb_node **p = &fs_info->qgroup_tree.rb_node;
130 struct rb_node *parent = NULL;
131 struct btrfs_qgroup *qgroup;
132
133 while (*p) {
134 parent = *p;
135 qgroup = rb_entry(parent, struct btrfs_qgroup, node);
136
137 if (qgroup->qgroupid < qgroupid)
138 p = &(*p)->rb_left;
139 else if (qgroup->qgroupid > qgroupid)
140 p = &(*p)->rb_right;
141 else
142 return qgroup;
143 }
144
145 qgroup = kzalloc(sizeof(*qgroup), GFP_ATOMIC);
146 if (!qgroup)
147 return ERR_PTR(-ENOMEM);
148
149 qgroup->qgroupid = qgroupid;
150 INIT_LIST_HEAD(&qgroup->groups);
151 INIT_LIST_HEAD(&qgroup->members);
152 INIT_LIST_HEAD(&qgroup->dirty);
153
154 rb_link_node(&qgroup->node, parent, p);
155 rb_insert_color(&qgroup->node, &fs_info->qgroup_tree);
156
157 return qgroup;
158}
159
160static void __del_qgroup_rb(struct btrfs_qgroup *qgroup)
161{
162 struct btrfs_qgroup_list *list;
163
164 list_del(&qgroup->dirty);
165 while (!list_empty(&qgroup->groups)) {
166 list = list_first_entry(&qgroup->groups,
167 struct btrfs_qgroup_list, next_group);
168 list_del(&list->next_group);
169 list_del(&list->next_member);
170 kfree(list);
171 }
172
173 while (!list_empty(&qgroup->members)) {
174 list = list_first_entry(&qgroup->members,
175 struct btrfs_qgroup_list, next_member);
176 list_del(&list->next_group);
177 list_del(&list->next_member);
178 kfree(list);
179 }
180 kfree(qgroup);
181}
182
183
184static int del_qgroup_rb(struct btrfs_fs_info *fs_info, u64 qgroupid)
185{
186 struct btrfs_qgroup *qgroup = find_qgroup_rb(fs_info, qgroupid);
187
188 if (!qgroup)
189 return -ENOENT;
190
191 rb_erase(&qgroup->node, &fs_info->qgroup_tree);
192 __del_qgroup_rb(qgroup);
193 return 0;
194}
195
196
197static int add_relation_rb(struct btrfs_fs_info *fs_info,
198 u64 memberid, u64 parentid)
199{
200 struct btrfs_qgroup *member;
201 struct btrfs_qgroup *parent;
202 struct btrfs_qgroup_list *list;
203
204 member = find_qgroup_rb(fs_info, memberid);
205 parent = find_qgroup_rb(fs_info, parentid);
206 if (!member || !parent)
207 return -ENOENT;
208
209 list = kzalloc(sizeof(*list), GFP_ATOMIC);
210 if (!list)
211 return -ENOMEM;
212
213 list->group = parent;
214 list->member = member;
215 list_add_tail(&list->next_group, &member->groups);
216 list_add_tail(&list->next_member, &parent->members);
217
218 return 0;
219}
220
221
222static int del_relation_rb(struct btrfs_fs_info *fs_info,
223 u64 memberid, u64 parentid)
224{
225 struct btrfs_qgroup *member;
226 struct btrfs_qgroup *parent;
227 struct btrfs_qgroup_list *list;
228
229 member = find_qgroup_rb(fs_info, memberid);
230 parent = find_qgroup_rb(fs_info, parentid);
231 if (!member || !parent)
232 return -ENOENT;
233
234 list_for_each_entry(list, &member->groups, next_group) {
235 if (list->group == parent) {
236 list_del(&list->next_group);
237 list_del(&list->next_member);
238 kfree(list);
239 return 0;
240 }
241 }
242 return -ENOENT;
243}
244
245
246
247
248
249int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
250{
251 struct btrfs_key key;
252 struct btrfs_key found_key;
253 struct btrfs_root *quota_root = fs_info->quota_root;
254 struct btrfs_path *path = NULL;
255 struct extent_buffer *l;
256 int slot;
257 int ret = 0;
258 u64 flags = 0;
259 u64 rescan_progress = 0;
260
261 if (!fs_info->quota_enabled)
262 return 0;
263
264 fs_info->qgroup_ulist = ulist_alloc(GFP_NOFS);
265 if (!fs_info->qgroup_ulist) {
266 ret = -ENOMEM;
267 goto out;
268 }
269
270 path = btrfs_alloc_path();
271 if (!path) {
272 ret = -ENOMEM;
273 goto out;
274 }
275
276
277 fs_info->qgroup_flags = 0;
278
279
280
281
282 key.objectid = 0;
283 key.type = 0;
284 key.offset = 0;
285 ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 1);
286 if (ret)
287 goto out;
288
289 while (1) {
290 struct btrfs_qgroup *qgroup;
291
292 slot = path->slots[0];
293 l = path->nodes[0];
294 btrfs_item_key_to_cpu(l, &found_key, slot);
295
296 if (found_key.type == BTRFS_QGROUP_STATUS_KEY) {
297 struct btrfs_qgroup_status_item *ptr;
298
299 ptr = btrfs_item_ptr(l, slot,
300 struct btrfs_qgroup_status_item);
301
302 if (btrfs_qgroup_status_version(l, ptr) !=
303 BTRFS_QGROUP_STATUS_VERSION) {
304 btrfs_err(fs_info,
305 "old qgroup version, quota disabled");
306 goto out;
307 }
308 if (btrfs_qgroup_status_generation(l, ptr) !=
309 fs_info->generation) {
310 flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
311 btrfs_err(fs_info,
312 "qgroup generation mismatch, "
313 "marked as inconsistent");
314 }
315 fs_info->qgroup_flags = btrfs_qgroup_status_flags(l,
316 ptr);
317 rescan_progress = btrfs_qgroup_status_rescan(l, ptr);
318 goto next1;
319 }
320
321 if (found_key.type != BTRFS_QGROUP_INFO_KEY &&
322 found_key.type != BTRFS_QGROUP_LIMIT_KEY)
323 goto next1;
324
325 qgroup = find_qgroup_rb(fs_info, found_key.offset);
326 if ((qgroup && found_key.type == BTRFS_QGROUP_INFO_KEY) ||
327 (!qgroup && found_key.type == BTRFS_QGROUP_LIMIT_KEY)) {
328 btrfs_err(fs_info, "inconsitent qgroup config");
329 flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
330 }
331 if (!qgroup) {
332 qgroup = add_qgroup_rb(fs_info, found_key.offset);
333 if (IS_ERR(qgroup)) {
334 ret = PTR_ERR(qgroup);
335 goto out;
336 }
337 }
338 switch (found_key.type) {
339 case BTRFS_QGROUP_INFO_KEY: {
340 struct btrfs_qgroup_info_item *ptr;
341
342 ptr = btrfs_item_ptr(l, slot,
343 struct btrfs_qgroup_info_item);
344 qgroup->rfer = btrfs_qgroup_info_rfer(l, ptr);
345 qgroup->rfer_cmpr = btrfs_qgroup_info_rfer_cmpr(l, ptr);
346 qgroup->excl = btrfs_qgroup_info_excl(l, ptr);
347 qgroup->excl_cmpr = btrfs_qgroup_info_excl_cmpr(l, ptr);
348
349 break;
350 }
351 case BTRFS_QGROUP_LIMIT_KEY: {
352 struct btrfs_qgroup_limit_item *ptr;
353
354 ptr = btrfs_item_ptr(l, slot,
355 struct btrfs_qgroup_limit_item);
356 qgroup->lim_flags = btrfs_qgroup_limit_flags(l, ptr);
357 qgroup->max_rfer = btrfs_qgroup_limit_max_rfer(l, ptr);
358 qgroup->max_excl = btrfs_qgroup_limit_max_excl(l, ptr);
359 qgroup->rsv_rfer = btrfs_qgroup_limit_rsv_rfer(l, ptr);
360 qgroup->rsv_excl = btrfs_qgroup_limit_rsv_excl(l, ptr);
361 break;
362 }
363 }
364next1:
365 ret = btrfs_next_item(quota_root, path);
366 if (ret < 0)
367 goto out;
368 if (ret)
369 break;
370 }
371 btrfs_release_path(path);
372
373
374
375
376 key.objectid = 0;
377 key.type = BTRFS_QGROUP_RELATION_KEY;
378 key.offset = 0;
379 ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 0);
380 if (ret)
381 goto out;
382 while (1) {
383 slot = path->slots[0];
384 l = path->nodes[0];
385 btrfs_item_key_to_cpu(l, &found_key, slot);
386
387 if (found_key.type != BTRFS_QGROUP_RELATION_KEY)
388 goto next2;
389
390 if (found_key.objectid > found_key.offset) {
391
392
393 goto next2;
394 }
395
396 ret = add_relation_rb(fs_info, found_key.objectid,
397 found_key.offset);
398 if (ret == -ENOENT) {
399 btrfs_warn(fs_info,
400 "orphan qgroup relation 0x%llx->0x%llx",
401 found_key.objectid, found_key.offset);
402 ret = 0;
403 }
404 if (ret)
405 goto out;
406next2:
407 ret = btrfs_next_item(quota_root, path);
408 if (ret < 0)
409 goto out;
410 if (ret)
411 break;
412 }
413out:
414 fs_info->qgroup_flags |= flags;
415 if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)) {
416 fs_info->quota_enabled = 0;
417 fs_info->pending_quota_state = 0;
418 } else if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN &&
419 ret >= 0) {
420 ret = qgroup_rescan_init(fs_info, rescan_progress, 0);
421 }
422 btrfs_free_path(path);
423
424 if (ret < 0) {
425 ulist_free(fs_info->qgroup_ulist);
426 fs_info->qgroup_ulist = NULL;
427 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
428 }
429
430 return ret < 0 ? ret : 0;
431}
432
433
434
435
436
437
438
439void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info)
440{
441 struct rb_node *n;
442 struct btrfs_qgroup *qgroup;
443
444 while ((n = rb_first(&fs_info->qgroup_tree))) {
445 qgroup = rb_entry(n, struct btrfs_qgroup, node);
446 rb_erase(n, &fs_info->qgroup_tree);
447 __del_qgroup_rb(qgroup);
448 }
449
450
451
452
453
454 ulist_free(fs_info->qgroup_ulist);
455 fs_info->qgroup_ulist = NULL;
456}
457
458static int add_qgroup_relation_item(struct btrfs_trans_handle *trans,
459 struct btrfs_root *quota_root,
460 u64 src, u64 dst)
461{
462 int ret;
463 struct btrfs_path *path;
464 struct btrfs_key key;
465
466 path = btrfs_alloc_path();
467 if (!path)
468 return -ENOMEM;
469
470 key.objectid = src;
471 key.type = BTRFS_QGROUP_RELATION_KEY;
472 key.offset = dst;
473
474 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 0);
475
476 btrfs_mark_buffer_dirty(path->nodes[0]);
477
478 btrfs_free_path(path);
479 return ret;
480}
481
482static int del_qgroup_relation_item(struct btrfs_trans_handle *trans,
483 struct btrfs_root *quota_root,
484 u64 src, u64 dst)
485{
486 int ret;
487 struct btrfs_path *path;
488 struct btrfs_key key;
489
490 path = btrfs_alloc_path();
491 if (!path)
492 return -ENOMEM;
493
494 key.objectid = src;
495 key.type = BTRFS_QGROUP_RELATION_KEY;
496 key.offset = dst;
497
498 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1);
499 if (ret < 0)
500 goto out;
501
502 if (ret > 0) {
503 ret = -ENOENT;
504 goto out;
505 }
506
507 ret = btrfs_del_item(trans, quota_root, path);
508out:
509 btrfs_free_path(path);
510 return ret;
511}
512
513static int add_qgroup_item(struct btrfs_trans_handle *trans,
514 struct btrfs_root *quota_root, u64 qgroupid)
515{
516 int ret;
517 struct btrfs_path *path;
518 struct btrfs_qgroup_info_item *qgroup_info;
519 struct btrfs_qgroup_limit_item *qgroup_limit;
520 struct extent_buffer *leaf;
521 struct btrfs_key key;
522
523 path = btrfs_alloc_path();
524 if (!path)
525 return -ENOMEM;
526
527 key.objectid = 0;
528 key.type = BTRFS_QGROUP_INFO_KEY;
529 key.offset = qgroupid;
530
531 ret = btrfs_insert_empty_item(trans, quota_root, path, &key,
532 sizeof(*qgroup_info));
533 if (ret)
534 goto out;
535
536 leaf = path->nodes[0];
537 qgroup_info = btrfs_item_ptr(leaf, path->slots[0],
538 struct btrfs_qgroup_info_item);
539 btrfs_set_qgroup_info_generation(leaf, qgroup_info, trans->transid);
540 btrfs_set_qgroup_info_rfer(leaf, qgroup_info, 0);
541 btrfs_set_qgroup_info_rfer_cmpr(leaf, qgroup_info, 0);
542 btrfs_set_qgroup_info_excl(leaf, qgroup_info, 0);
543 btrfs_set_qgroup_info_excl_cmpr(leaf, qgroup_info, 0);
544
545 btrfs_mark_buffer_dirty(leaf);
546
547 btrfs_release_path(path);
548
549 key.type = BTRFS_QGROUP_LIMIT_KEY;
550 ret = btrfs_insert_empty_item(trans, quota_root, path, &key,
551 sizeof(*qgroup_limit));
552 if (ret)
553 goto out;
554
555 leaf = path->nodes[0];
556 qgroup_limit = btrfs_item_ptr(leaf, path->slots[0],
557 struct btrfs_qgroup_limit_item);
558 btrfs_set_qgroup_limit_flags(leaf, qgroup_limit, 0);
559 btrfs_set_qgroup_limit_max_rfer(leaf, qgroup_limit, 0);
560 btrfs_set_qgroup_limit_max_excl(leaf, qgroup_limit, 0);
561 btrfs_set_qgroup_limit_rsv_rfer(leaf, qgroup_limit, 0);
562 btrfs_set_qgroup_limit_rsv_excl(leaf, qgroup_limit, 0);
563
564 btrfs_mark_buffer_dirty(leaf);
565
566 ret = 0;
567out:
568 btrfs_free_path(path);
569 return ret;
570}
571
572static int del_qgroup_item(struct btrfs_trans_handle *trans,
573 struct btrfs_root *quota_root, u64 qgroupid)
574{
575 int ret;
576 struct btrfs_path *path;
577 struct btrfs_key key;
578
579 path = btrfs_alloc_path();
580 if (!path)
581 return -ENOMEM;
582
583 key.objectid = 0;
584 key.type = BTRFS_QGROUP_INFO_KEY;
585 key.offset = qgroupid;
586 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1);
587 if (ret < 0)
588 goto out;
589
590 if (ret > 0) {
591 ret = -ENOENT;
592 goto out;
593 }
594
595 ret = btrfs_del_item(trans, quota_root, path);
596 if (ret)
597 goto out;
598
599 btrfs_release_path(path);
600
601 key.type = BTRFS_QGROUP_LIMIT_KEY;
602 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1);
603 if (ret < 0)
604 goto out;
605
606 if (ret > 0) {
607 ret = -ENOENT;
608 goto out;
609 }
610
611 ret = btrfs_del_item(trans, quota_root, path);
612
613out:
614 btrfs_free_path(path);
615 return ret;
616}
617
618static int update_qgroup_limit_item(struct btrfs_trans_handle *trans,
619 struct btrfs_root *root, u64 qgroupid,
620 u64 flags, u64 max_rfer, u64 max_excl,
621 u64 rsv_rfer, u64 rsv_excl)
622{
623 struct btrfs_path *path;
624 struct btrfs_key key;
625 struct extent_buffer *l;
626 struct btrfs_qgroup_limit_item *qgroup_limit;
627 int ret;
628 int slot;
629
630 key.objectid = 0;
631 key.type = BTRFS_QGROUP_LIMIT_KEY;
632 key.offset = qgroupid;
633
634 path = btrfs_alloc_path();
635 if (!path)
636 return -ENOMEM;
637
638 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
639 if (ret > 0)
640 ret = -ENOENT;
641
642 if (ret)
643 goto out;
644
645 l = path->nodes[0];
646 slot = path->slots[0];
647 qgroup_limit = btrfs_item_ptr(l, slot, struct btrfs_qgroup_limit_item);
648 btrfs_set_qgroup_limit_flags(l, qgroup_limit, flags);
649 btrfs_set_qgroup_limit_max_rfer(l, qgroup_limit, max_rfer);
650 btrfs_set_qgroup_limit_max_excl(l, qgroup_limit, max_excl);
651 btrfs_set_qgroup_limit_rsv_rfer(l, qgroup_limit, rsv_rfer);
652 btrfs_set_qgroup_limit_rsv_excl(l, qgroup_limit, rsv_excl);
653
654 btrfs_mark_buffer_dirty(l);
655
656out:
657 btrfs_free_path(path);
658 return ret;
659}
660
661static int update_qgroup_info_item(struct btrfs_trans_handle *trans,
662 struct btrfs_root *root,
663 struct btrfs_qgroup *qgroup)
664{
665 struct btrfs_path *path;
666 struct btrfs_key key;
667 struct extent_buffer *l;
668 struct btrfs_qgroup_info_item *qgroup_info;
669 int ret;
670 int slot;
671
672 key.objectid = 0;
673 key.type = BTRFS_QGROUP_INFO_KEY;
674 key.offset = qgroup->qgroupid;
675
676 path = btrfs_alloc_path();
677 if (!path)
678 return -ENOMEM;
679
680 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
681 if (ret > 0)
682 ret = -ENOENT;
683
684 if (ret)
685 goto out;
686
687 l = path->nodes[0];
688 slot = path->slots[0];
689 qgroup_info = btrfs_item_ptr(l, slot, struct btrfs_qgroup_info_item);
690 btrfs_set_qgroup_info_generation(l, qgroup_info, trans->transid);
691 btrfs_set_qgroup_info_rfer(l, qgroup_info, qgroup->rfer);
692 btrfs_set_qgroup_info_rfer_cmpr(l, qgroup_info, qgroup->rfer_cmpr);
693 btrfs_set_qgroup_info_excl(l, qgroup_info, qgroup->excl);
694 btrfs_set_qgroup_info_excl_cmpr(l, qgroup_info, qgroup->excl_cmpr);
695
696 btrfs_mark_buffer_dirty(l);
697
698out:
699 btrfs_free_path(path);
700 return ret;
701}
702
703static int update_qgroup_status_item(struct btrfs_trans_handle *trans,
704 struct btrfs_fs_info *fs_info,
705 struct btrfs_root *root)
706{
707 struct btrfs_path *path;
708 struct btrfs_key key;
709 struct extent_buffer *l;
710 struct btrfs_qgroup_status_item *ptr;
711 int ret;
712 int slot;
713
714 key.objectid = 0;
715 key.type = BTRFS_QGROUP_STATUS_KEY;
716 key.offset = 0;
717
718 path = btrfs_alloc_path();
719 if (!path)
720 return -ENOMEM;
721
722 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
723 if (ret > 0)
724 ret = -ENOENT;
725
726 if (ret)
727 goto out;
728
729 l = path->nodes[0];
730 slot = path->slots[0];
731 ptr = btrfs_item_ptr(l, slot, struct btrfs_qgroup_status_item);
732 btrfs_set_qgroup_status_flags(l, ptr, fs_info->qgroup_flags);
733 btrfs_set_qgroup_status_generation(l, ptr, trans->transid);
734 btrfs_set_qgroup_status_rescan(l, ptr,
735 fs_info->qgroup_rescan_progress.objectid);
736
737 btrfs_mark_buffer_dirty(l);
738
739out:
740 btrfs_free_path(path);
741 return ret;
742}
743
744
745
746
747static int btrfs_clean_quota_tree(struct btrfs_trans_handle *trans,
748 struct btrfs_root *root)
749{
750 struct btrfs_path *path;
751 struct btrfs_key key;
752 struct extent_buffer *leaf = NULL;
753 int ret;
754 int nr = 0;
755
756 path = btrfs_alloc_path();
757 if (!path)
758 return -ENOMEM;
759
760 path->leave_spinning = 1;
761
762 key.objectid = 0;
763 key.offset = 0;
764 key.type = 0;
765
766 while (1) {
767 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
768 if (ret < 0)
769 goto out;
770 leaf = path->nodes[0];
771 nr = btrfs_header_nritems(leaf);
772 if (!nr)
773 break;
774
775
776
777
778
779 path->slots[0] = 0;
780 ret = btrfs_del_items(trans, root, path, 0, nr);
781 if (ret)
782 goto out;
783
784 btrfs_release_path(path);
785 }
786 ret = 0;
787out:
788 root->fs_info->pending_quota_state = 0;
789 btrfs_free_path(path);
790 return ret;
791}
792
793int btrfs_quota_enable(struct btrfs_trans_handle *trans,
794 struct btrfs_fs_info *fs_info)
795{
796 struct btrfs_root *quota_root;
797 struct btrfs_root *tree_root = fs_info->tree_root;
798 struct btrfs_path *path = NULL;
799 struct btrfs_qgroup_status_item *ptr;
800 struct extent_buffer *leaf;
801 struct btrfs_key key;
802 struct btrfs_key found_key;
803 struct btrfs_qgroup *qgroup = NULL;
804 int ret = 0;
805 int slot;
806
807 mutex_lock(&fs_info->qgroup_ioctl_lock);
808 if (fs_info->quota_root) {
809 fs_info->pending_quota_state = 1;
810 goto out;
811 }
812
813 fs_info->qgroup_ulist = ulist_alloc(GFP_NOFS);
814 if (!fs_info->qgroup_ulist) {
815 ret = -ENOMEM;
816 goto out;
817 }
818
819
820
821
822 quota_root = btrfs_create_tree(trans, fs_info,
823 BTRFS_QUOTA_TREE_OBJECTID);
824 if (IS_ERR(quota_root)) {
825 ret = PTR_ERR(quota_root);
826 goto out;
827 }
828
829 path = btrfs_alloc_path();
830 if (!path) {
831 ret = -ENOMEM;
832 goto out_free_root;
833 }
834
835 key.objectid = 0;
836 key.type = BTRFS_QGROUP_STATUS_KEY;
837 key.offset = 0;
838
839 ret = btrfs_insert_empty_item(trans, quota_root, path, &key,
840 sizeof(*ptr));
841 if (ret)
842 goto out_free_path;
843
844 leaf = path->nodes[0];
845 ptr = btrfs_item_ptr(leaf, path->slots[0],
846 struct btrfs_qgroup_status_item);
847 btrfs_set_qgroup_status_generation(leaf, ptr, trans->transid);
848 btrfs_set_qgroup_status_version(leaf, ptr, BTRFS_QGROUP_STATUS_VERSION);
849 fs_info->qgroup_flags = BTRFS_QGROUP_STATUS_FLAG_ON |
850 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
851 btrfs_set_qgroup_status_flags(leaf, ptr, fs_info->qgroup_flags);
852 btrfs_set_qgroup_status_rescan(leaf, ptr, 0);
853
854 btrfs_mark_buffer_dirty(leaf);
855
856 key.objectid = 0;
857 key.type = BTRFS_ROOT_REF_KEY;
858 key.offset = 0;
859
860 btrfs_release_path(path);
861 ret = btrfs_search_slot_for_read(tree_root, &key, path, 1, 0);
862 if (ret > 0)
863 goto out_add_root;
864 if (ret < 0)
865 goto out_free_path;
866
867
868 while (1) {
869 slot = path->slots[0];
870 leaf = path->nodes[0];
871 btrfs_item_key_to_cpu(leaf, &found_key, slot);
872
873 if (found_key.type == BTRFS_ROOT_REF_KEY) {
874 ret = add_qgroup_item(trans, quota_root,
875 found_key.offset);
876 if (ret)
877 goto out_free_path;
878
879 qgroup = add_qgroup_rb(fs_info, found_key.offset);
880 if (IS_ERR(qgroup)) {
881 ret = PTR_ERR(qgroup);
882 goto out_free_path;
883 }
884 }
885 ret = btrfs_next_item(tree_root, path);
886 if (ret < 0)
887 goto out_free_path;
888 if (ret)
889 break;
890 }
891
892out_add_root:
893 btrfs_release_path(path);
894 ret = add_qgroup_item(trans, quota_root, BTRFS_FS_TREE_OBJECTID);
895 if (ret)
896 goto out_free_path;
897
898 qgroup = add_qgroup_rb(fs_info, BTRFS_FS_TREE_OBJECTID);
899 if (IS_ERR(qgroup)) {
900 ret = PTR_ERR(qgroup);
901 goto out_free_path;
902 }
903 spin_lock(&fs_info->qgroup_lock);
904 fs_info->quota_root = quota_root;
905 fs_info->pending_quota_state = 1;
906 spin_unlock(&fs_info->qgroup_lock);
907out_free_path:
908 btrfs_free_path(path);
909out_free_root:
910 if (ret) {
911 free_extent_buffer(quota_root->node);
912 free_extent_buffer(quota_root->commit_root);
913 kfree(quota_root);
914 }
915out:
916 if (ret) {
917 ulist_free(fs_info->qgroup_ulist);
918 fs_info->qgroup_ulist = NULL;
919 }
920 mutex_unlock(&fs_info->qgroup_ioctl_lock);
921 return ret;
922}
923
924int btrfs_quota_disable(struct btrfs_trans_handle *trans,
925 struct btrfs_fs_info *fs_info)
926{
927 struct btrfs_root *tree_root = fs_info->tree_root;
928 struct btrfs_root *quota_root;
929 int ret = 0;
930
931 mutex_lock(&fs_info->qgroup_ioctl_lock);
932 if (!fs_info->quota_root)
933 goto out;
934 spin_lock(&fs_info->qgroup_lock);
935 fs_info->quota_enabled = 0;
936 fs_info->pending_quota_state = 0;
937 quota_root = fs_info->quota_root;
938 fs_info->quota_root = NULL;
939 spin_unlock(&fs_info->qgroup_lock);
940
941 btrfs_free_qgroup_config(fs_info);
942
943 ret = btrfs_clean_quota_tree(trans, quota_root);
944 if (ret)
945 goto out;
946
947 ret = btrfs_del_root(trans, tree_root, "a_root->root_key);
948 if (ret)
949 goto out;
950
951 list_del("a_root->dirty_list);
952
953 btrfs_tree_lock(quota_root->node);
954 clean_tree_block(trans, tree_root, quota_root->node);
955 btrfs_tree_unlock(quota_root->node);
956 btrfs_free_tree_block(trans, quota_root, quota_root->node, 0, 1);
957
958 free_extent_buffer(quota_root->node);
959 free_extent_buffer(quota_root->commit_root);
960 kfree(quota_root);
961out:
962 mutex_unlock(&fs_info->qgroup_ioctl_lock);
963 return ret;
964}
965
966static void qgroup_dirty(struct btrfs_fs_info *fs_info,
967 struct btrfs_qgroup *qgroup)
968{
969 if (list_empty(&qgroup->dirty))
970 list_add(&qgroup->dirty, &fs_info->dirty_qgroups);
971}
972
973int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans,
974 struct btrfs_fs_info *fs_info, u64 src, u64 dst)
975{
976 struct btrfs_root *quota_root;
977 struct btrfs_qgroup *parent;
978 struct btrfs_qgroup *member;
979 struct btrfs_qgroup_list *list;
980 int ret = 0;
981
982 mutex_lock(&fs_info->qgroup_ioctl_lock);
983 quota_root = fs_info->quota_root;
984 if (!quota_root) {
985 ret = -EINVAL;
986 goto out;
987 }
988 member = find_qgroup_rb(fs_info, src);
989 parent = find_qgroup_rb(fs_info, dst);
990 if (!member || !parent) {
991 ret = -EINVAL;
992 goto out;
993 }
994
995
996 list_for_each_entry(list, &member->groups, next_group) {
997 if (list->group == parent) {
998 ret = -EEXIST;
999 goto out;
1000 }
1001 }
1002
1003 ret = add_qgroup_relation_item(trans, quota_root, src, dst);
1004 if (ret)
1005 goto out;
1006
1007 ret = add_qgroup_relation_item(trans, quota_root, dst, src);
1008 if (ret) {
1009 del_qgroup_relation_item(trans, quota_root, src, dst);
1010 goto out;
1011 }
1012
1013 spin_lock(&fs_info->qgroup_lock);
1014 ret = add_relation_rb(quota_root->fs_info, src, dst);
1015 spin_unlock(&fs_info->qgroup_lock);
1016out:
1017 mutex_unlock(&fs_info->qgroup_ioctl_lock);
1018 return ret;
1019}
1020
1021int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans,
1022 struct btrfs_fs_info *fs_info, u64 src, u64 dst)
1023{
1024 struct btrfs_root *quota_root;
1025 struct btrfs_qgroup *parent;
1026 struct btrfs_qgroup *member;
1027 struct btrfs_qgroup_list *list;
1028 int ret = 0;
1029 int err;
1030
1031 mutex_lock(&fs_info->qgroup_ioctl_lock);
1032 quota_root = fs_info->quota_root;
1033 if (!quota_root) {
1034 ret = -EINVAL;
1035 goto out;
1036 }
1037
1038 member = find_qgroup_rb(fs_info, src);
1039 parent = find_qgroup_rb(fs_info, dst);
1040 if (!member || !parent) {
1041 ret = -EINVAL;
1042 goto out;
1043 }
1044
1045
1046 list_for_each_entry(list, &member->groups, next_group) {
1047 if (list->group == parent)
1048 goto exist;
1049 }
1050 ret = -ENOENT;
1051 goto out;
1052exist:
1053 ret = del_qgroup_relation_item(trans, quota_root, src, dst);
1054 err = del_qgroup_relation_item(trans, quota_root, dst, src);
1055 if (err && !ret)
1056 ret = err;
1057
1058 spin_lock(&fs_info->qgroup_lock);
1059 del_relation_rb(fs_info, src, dst);
1060 spin_unlock(&fs_info->qgroup_lock);
1061out:
1062 mutex_unlock(&fs_info->qgroup_ioctl_lock);
1063 return ret;
1064}
1065
1066int btrfs_create_qgroup(struct btrfs_trans_handle *trans,
1067 struct btrfs_fs_info *fs_info, u64 qgroupid, char *name)
1068{
1069 struct btrfs_root *quota_root;
1070 struct btrfs_qgroup *qgroup;
1071 int ret = 0;
1072
1073 mutex_lock(&fs_info->qgroup_ioctl_lock);
1074 quota_root = fs_info->quota_root;
1075 if (!quota_root) {
1076 ret = -EINVAL;
1077 goto out;
1078 }
1079 qgroup = find_qgroup_rb(fs_info, qgroupid);
1080 if (qgroup) {
1081 ret = -EEXIST;
1082 goto out;
1083 }
1084
1085 ret = add_qgroup_item(trans, quota_root, qgroupid);
1086 if (ret)
1087 goto out;
1088
1089 spin_lock(&fs_info->qgroup_lock);
1090 qgroup = add_qgroup_rb(fs_info, qgroupid);
1091 spin_unlock(&fs_info->qgroup_lock);
1092
1093 if (IS_ERR(qgroup))
1094 ret = PTR_ERR(qgroup);
1095out:
1096 mutex_unlock(&fs_info->qgroup_ioctl_lock);
1097 return ret;
1098}
1099
1100int btrfs_remove_qgroup(struct btrfs_trans_handle *trans,
1101 struct btrfs_fs_info *fs_info, u64 qgroupid)
1102{
1103 struct btrfs_root *quota_root;
1104 struct btrfs_qgroup *qgroup;
1105 int ret = 0;
1106
1107 mutex_lock(&fs_info->qgroup_ioctl_lock);
1108 quota_root = fs_info->quota_root;
1109 if (!quota_root) {
1110 ret = -EINVAL;
1111 goto out;
1112 }
1113
1114 qgroup = find_qgroup_rb(fs_info, qgroupid);
1115 if (!qgroup) {
1116 ret = -ENOENT;
1117 goto out;
1118 } else {
1119
1120 if (!list_empty(&qgroup->groups) ||
1121 !list_empty(&qgroup->members)) {
1122 ret = -EBUSY;
1123 goto out;
1124 }
1125 }
1126 ret = del_qgroup_item(trans, quota_root, qgroupid);
1127
1128 spin_lock(&fs_info->qgroup_lock);
1129 del_qgroup_rb(quota_root->fs_info, qgroupid);
1130 spin_unlock(&fs_info->qgroup_lock);
1131out:
1132 mutex_unlock(&fs_info->qgroup_ioctl_lock);
1133 return ret;
1134}
1135
1136int btrfs_limit_qgroup(struct btrfs_trans_handle *trans,
1137 struct btrfs_fs_info *fs_info, u64 qgroupid,
1138 struct btrfs_qgroup_limit *limit)
1139{
1140 struct btrfs_root *quota_root;
1141 struct btrfs_qgroup *qgroup;
1142 int ret = 0;
1143
1144 mutex_lock(&fs_info->qgroup_ioctl_lock);
1145 quota_root = fs_info->quota_root;
1146 if (!quota_root) {
1147 ret = -EINVAL;
1148 goto out;
1149 }
1150
1151 qgroup = find_qgroup_rb(fs_info, qgroupid);
1152 if (!qgroup) {
1153 ret = -ENOENT;
1154 goto out;
1155 }
1156 ret = update_qgroup_limit_item(trans, quota_root, qgroupid,
1157 limit->flags, limit->max_rfer,
1158 limit->max_excl, limit->rsv_rfer,
1159 limit->rsv_excl);
1160 if (ret) {
1161 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
1162 btrfs_info(fs_info, "unable to update quota limit for %llu",
1163 qgroupid);
1164 }
1165
1166 spin_lock(&fs_info->qgroup_lock);
1167 qgroup->lim_flags = limit->flags;
1168 qgroup->max_rfer = limit->max_rfer;
1169 qgroup->max_excl = limit->max_excl;
1170 qgroup->rsv_rfer = limit->rsv_rfer;
1171 qgroup->rsv_excl = limit->rsv_excl;
1172 spin_unlock(&fs_info->qgroup_lock);
1173out:
1174 mutex_unlock(&fs_info->qgroup_ioctl_lock);
1175 return ret;
1176}
1177
1178
1179
1180
1181
1182
1183int btrfs_qgroup_record_ref(struct btrfs_trans_handle *trans,
1184 struct btrfs_delayed_ref_node *node,
1185 struct btrfs_delayed_extent_op *extent_op)
1186{
1187 struct qgroup_update *u;
1188
1189 BUG_ON(!trans->delayed_ref_elem.seq);
1190 u = kmalloc(sizeof(*u), GFP_NOFS);
1191 if (!u)
1192 return -ENOMEM;
1193
1194 u->node = node;
1195 u->extent_op = extent_op;
1196 list_add_tail(&u->list, &trans->qgroup_ref_list);
1197
1198 return 0;
1199}
1200
1201static int qgroup_account_ref_step1(struct btrfs_fs_info *fs_info,
1202 struct ulist *roots, struct ulist *tmp,
1203 u64 seq)
1204{
1205 struct ulist_node *unode;
1206 struct ulist_iterator uiter;
1207 struct ulist_node *tmp_unode;
1208 struct ulist_iterator tmp_uiter;
1209 struct btrfs_qgroup *qg;
1210 int ret;
1211
1212 ULIST_ITER_INIT(&uiter);
1213 while ((unode = ulist_next(roots, &uiter))) {
1214 qg = find_qgroup_rb(fs_info, unode->val);
1215 if (!qg)
1216 continue;
1217
1218 ulist_reinit(tmp);
1219
1220 ret = ulist_add(tmp, qg->qgroupid,
1221 (u64)(uintptr_t)qg, GFP_ATOMIC);
1222 if (ret < 0)
1223 return ret;
1224 ULIST_ITER_INIT(&tmp_uiter);
1225 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
1226 struct btrfs_qgroup_list *glist;
1227
1228 qg = (struct btrfs_qgroup *)(uintptr_t)tmp_unode->aux;
1229 if (qg->refcnt < seq)
1230 qg->refcnt = seq + 1;
1231 else
1232 ++qg->refcnt;
1233
1234 list_for_each_entry(glist, &qg->groups, next_group) {
1235 ret = ulist_add(tmp, glist->group->qgroupid,
1236 (u64)(uintptr_t)glist->group,
1237 GFP_ATOMIC);
1238 if (ret < 0)
1239 return ret;
1240 }
1241 }
1242 }
1243
1244 return 0;
1245}
1246
1247static int qgroup_account_ref_step2(struct btrfs_fs_info *fs_info,
1248 struct ulist *roots, struct ulist *tmp,
1249 u64 seq, int sgn, u64 num_bytes,
1250 struct btrfs_qgroup *qgroup)
1251{
1252 struct ulist_node *unode;
1253 struct ulist_iterator uiter;
1254 struct btrfs_qgroup *qg;
1255 struct btrfs_qgroup_list *glist;
1256 int ret;
1257
1258 ulist_reinit(tmp);
1259 ret = ulist_add(tmp, qgroup->qgroupid, (uintptr_t)qgroup, GFP_ATOMIC);
1260 if (ret < 0)
1261 return ret;
1262
1263 ULIST_ITER_INIT(&uiter);
1264 while ((unode = ulist_next(tmp, &uiter))) {
1265 qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
1266 if (qg->refcnt < seq) {
1267
1268 qg->rfer += sgn * num_bytes;
1269 qg->rfer_cmpr += sgn * num_bytes;
1270 if (roots->nnodes == 0) {
1271 qg->excl += sgn * num_bytes;
1272 qg->excl_cmpr += sgn * num_bytes;
1273 }
1274 qgroup_dirty(fs_info, qg);
1275 }
1276 WARN_ON(qg->tag >= seq);
1277 qg->tag = seq;
1278
1279 list_for_each_entry(glist, &qg->groups, next_group) {
1280 ret = ulist_add(tmp, glist->group->qgroupid,
1281 (uintptr_t)glist->group, GFP_ATOMIC);
1282 if (ret < 0)
1283 return ret;
1284 }
1285 }
1286
1287 return 0;
1288}
1289
1290static int qgroup_account_ref_step3(struct btrfs_fs_info *fs_info,
1291 struct ulist *roots, struct ulist *tmp,
1292 u64 seq, int sgn, u64 num_bytes)
1293{
1294 struct ulist_node *unode;
1295 struct ulist_iterator uiter;
1296 struct btrfs_qgroup *qg;
1297 struct ulist_node *tmp_unode;
1298 struct ulist_iterator tmp_uiter;
1299 int ret;
1300
1301 ULIST_ITER_INIT(&uiter);
1302 while ((unode = ulist_next(roots, &uiter))) {
1303 qg = find_qgroup_rb(fs_info, unode->val);
1304 if (!qg)
1305 continue;
1306
1307 ulist_reinit(tmp);
1308 ret = ulist_add(tmp, qg->qgroupid, (uintptr_t)qg, GFP_ATOMIC);
1309 if (ret < 0)
1310 return ret;
1311
1312 ULIST_ITER_INIT(&tmp_uiter);
1313 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
1314 struct btrfs_qgroup_list *glist;
1315
1316 qg = (struct btrfs_qgroup *)(uintptr_t)tmp_unode->aux;
1317 if (qg->tag == seq)
1318 continue;
1319
1320 if (qg->refcnt - seq == roots->nnodes) {
1321 qg->excl -= sgn * num_bytes;
1322 qg->excl_cmpr -= sgn * num_bytes;
1323 qgroup_dirty(fs_info, qg);
1324 }
1325
1326 list_for_each_entry(glist, &qg->groups, next_group) {
1327 ret = ulist_add(tmp, glist->group->qgroupid,
1328 (uintptr_t)glist->group,
1329 GFP_ATOMIC);
1330 if (ret < 0)
1331 return ret;
1332 }
1333 }
1334 }
1335
1336 return 0;
1337}
1338
1339
1340
1341
1342
1343
1344
1345int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
1346 struct btrfs_fs_info *fs_info,
1347 struct btrfs_delayed_ref_node *node,
1348 struct btrfs_delayed_extent_op *extent_op)
1349{
1350 struct btrfs_root *quota_root;
1351 u64 ref_root;
1352 struct btrfs_qgroup *qgroup;
1353 struct ulist *roots = NULL;
1354 u64 seq;
1355 int ret = 0;
1356 int sgn;
1357
1358 if (!fs_info->quota_enabled)
1359 return 0;
1360
1361 BUG_ON(!fs_info->quota_root);
1362
1363 if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
1364 node->type == BTRFS_SHARED_BLOCK_REF_KEY) {
1365 struct btrfs_delayed_tree_ref *ref;
1366 ref = btrfs_delayed_node_to_tree_ref(node);
1367 ref_root = ref->root;
1368 } else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
1369 node->type == BTRFS_SHARED_DATA_REF_KEY) {
1370 struct btrfs_delayed_data_ref *ref;
1371 ref = btrfs_delayed_node_to_data_ref(node);
1372 ref_root = ref->root;
1373 } else {
1374 BUG();
1375 }
1376
1377 if (!is_fstree(ref_root)) {
1378
1379
1380
1381 return 0;
1382 }
1383
1384 switch (node->action) {
1385 case BTRFS_ADD_DELAYED_REF:
1386 case BTRFS_ADD_DELAYED_EXTENT:
1387 sgn = 1;
1388 seq = btrfs_tree_mod_seq_prev(node->seq);
1389 break;
1390 case BTRFS_DROP_DELAYED_REF:
1391 sgn = -1;
1392 seq = node->seq;
1393 break;
1394 case BTRFS_UPDATE_DELAYED_HEAD:
1395 return 0;
1396 default:
1397 BUG();
1398 }
1399
1400 mutex_lock(&fs_info->qgroup_rescan_lock);
1401 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
1402 if (fs_info->qgroup_rescan_progress.objectid <= node->bytenr) {
1403 mutex_unlock(&fs_info->qgroup_rescan_lock);
1404 return 0;
1405 }
1406 }
1407 mutex_unlock(&fs_info->qgroup_rescan_lock);
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418 ret = btrfs_find_all_roots(trans, fs_info, node->bytenr, seq, &roots);
1419 if (ret < 0)
1420 return ret;
1421
1422 spin_lock(&fs_info->qgroup_lock);
1423
1424 quota_root = fs_info->quota_root;
1425 if (!quota_root)
1426 goto unlock;
1427
1428 qgroup = find_qgroup_rb(fs_info, ref_root);
1429 if (!qgroup)
1430 goto unlock;
1431
1432
1433
1434
1435 ulist_reinit(fs_info->qgroup_ulist);
1436 seq = fs_info->qgroup_seq;
1437 fs_info->qgroup_seq += roots->nnodes + 1;
1438
1439 ret = qgroup_account_ref_step1(fs_info, roots, fs_info->qgroup_ulist,
1440 seq);
1441 if (ret)
1442 goto unlock;
1443
1444
1445
1446
1447 ret = qgroup_account_ref_step2(fs_info, roots, fs_info->qgroup_ulist,
1448 seq, sgn, node->num_bytes, qgroup);
1449 if (ret)
1450 goto unlock;
1451
1452
1453
1454
1455 ret = qgroup_account_ref_step3(fs_info, roots, fs_info->qgroup_ulist,
1456 seq, sgn, node->num_bytes);
1457 if (ret)
1458 goto unlock;
1459
1460unlock:
1461 spin_unlock(&fs_info->qgroup_lock);
1462 ulist_free(roots);
1463
1464 return ret;
1465}
1466
1467
1468
1469
1470int btrfs_run_qgroups(struct btrfs_trans_handle *trans,
1471 struct btrfs_fs_info *fs_info)
1472{
1473 struct btrfs_root *quota_root = fs_info->quota_root;
1474 int ret = 0;
1475 int start_rescan_worker = 0;
1476
1477 if (!quota_root)
1478 goto out;
1479
1480 if (!fs_info->quota_enabled && fs_info->pending_quota_state)
1481 start_rescan_worker = 1;
1482
1483 fs_info->quota_enabled = fs_info->pending_quota_state;
1484
1485 spin_lock(&fs_info->qgroup_lock);
1486 while (!list_empty(&fs_info->dirty_qgroups)) {
1487 struct btrfs_qgroup *qgroup;
1488 qgroup = list_first_entry(&fs_info->dirty_qgroups,
1489 struct btrfs_qgroup, dirty);
1490 list_del_init(&qgroup->dirty);
1491 spin_unlock(&fs_info->qgroup_lock);
1492 ret = update_qgroup_info_item(trans, quota_root, qgroup);
1493 if (ret)
1494 fs_info->qgroup_flags |=
1495 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
1496 spin_lock(&fs_info->qgroup_lock);
1497 }
1498 if (fs_info->quota_enabled)
1499 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_ON;
1500 else
1501 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;
1502 spin_unlock(&fs_info->qgroup_lock);
1503
1504 ret = update_qgroup_status_item(trans, fs_info, quota_root);
1505 if (ret)
1506 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
1507
1508 if (!ret && start_rescan_worker) {
1509 ret = qgroup_rescan_init(fs_info, 0, 1);
1510 if (!ret) {
1511 qgroup_rescan_zero_tracking(fs_info);
1512 btrfs_queue_work(fs_info->qgroup_rescan_workers,
1513 &fs_info->qgroup_rescan_work);
1514 }
1515 ret = 0;
1516 }
1517
1518out:
1519
1520 return ret;
1521}
1522
1523
1524
1525
1526
1527int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans,
1528 struct btrfs_fs_info *fs_info, u64 srcid, u64 objectid,
1529 struct btrfs_qgroup_inherit *inherit)
1530{
1531 int ret = 0;
1532 int i;
1533 u64 *i_qgroups;
1534 struct btrfs_root *quota_root = fs_info->quota_root;
1535 struct btrfs_qgroup *srcgroup;
1536 struct btrfs_qgroup *dstgroup;
1537 u32 level_size = 0;
1538 u64 nums;
1539
1540 mutex_lock(&fs_info->qgroup_ioctl_lock);
1541 if (!fs_info->quota_enabled)
1542 goto out;
1543
1544 if (!quota_root) {
1545 ret = -EINVAL;
1546 goto out;
1547 }
1548
1549 if (inherit) {
1550 i_qgroups = (u64 *)(inherit + 1);
1551 nums = inherit->num_qgroups + 2 * inherit->num_ref_copies +
1552 2 * inherit->num_excl_copies;
1553 for (i = 0; i < nums; ++i) {
1554 srcgroup = find_qgroup_rb(fs_info, *i_qgroups);
1555 if (!srcgroup) {
1556 ret = -EINVAL;
1557 goto out;
1558 }
1559 ++i_qgroups;
1560 }
1561 }
1562
1563
1564
1565
1566 ret = add_qgroup_item(trans, quota_root, objectid);
1567 if (ret)
1568 goto out;
1569
1570 if (inherit && inherit->flags & BTRFS_QGROUP_INHERIT_SET_LIMITS) {
1571 ret = update_qgroup_limit_item(trans, quota_root, objectid,
1572 inherit->lim.flags,
1573 inherit->lim.max_rfer,
1574 inherit->lim.max_excl,
1575 inherit->lim.rsv_rfer,
1576 inherit->lim.rsv_excl);
1577 if (ret)
1578 goto out;
1579 }
1580
1581 if (srcid) {
1582 struct btrfs_root *srcroot;
1583 struct btrfs_key srckey;
1584 int srcroot_level;
1585
1586 srckey.objectid = srcid;
1587 srckey.type = BTRFS_ROOT_ITEM_KEY;
1588 srckey.offset = (u64)-1;
1589 srcroot = btrfs_read_fs_root_no_name(fs_info, &srckey);
1590 if (IS_ERR(srcroot)) {
1591 ret = PTR_ERR(srcroot);
1592 goto out;
1593 }
1594
1595 rcu_read_lock();
1596 srcroot_level = btrfs_header_level(srcroot->node);
1597 level_size = btrfs_level_size(srcroot, srcroot_level);
1598 rcu_read_unlock();
1599 }
1600
1601
1602
1603
1604 if (inherit) {
1605 i_qgroups = (u64 *)(inherit + 1);
1606 for (i = 0; i < inherit->num_qgroups; ++i) {
1607 ret = add_qgroup_relation_item(trans, quota_root,
1608 objectid, *i_qgroups);
1609 if (ret)
1610 goto out;
1611 ret = add_qgroup_relation_item(trans, quota_root,
1612 *i_qgroups, objectid);
1613 if (ret)
1614 goto out;
1615 ++i_qgroups;
1616 }
1617 }
1618
1619
1620 spin_lock(&fs_info->qgroup_lock);
1621
1622 dstgroup = add_qgroup_rb(fs_info, objectid);
1623 if (IS_ERR(dstgroup)) {
1624 ret = PTR_ERR(dstgroup);
1625 goto unlock;
1626 }
1627
1628 if (srcid) {
1629 srcgroup = find_qgroup_rb(fs_info, srcid);
1630 if (!srcgroup)
1631 goto unlock;
1632 dstgroup->rfer = srcgroup->rfer - level_size;
1633 dstgroup->rfer_cmpr = srcgroup->rfer_cmpr - level_size;
1634 srcgroup->excl = level_size;
1635 srcgroup->excl_cmpr = level_size;
1636 qgroup_dirty(fs_info, dstgroup);
1637 qgroup_dirty(fs_info, srcgroup);
1638 }
1639
1640 if (!inherit)
1641 goto unlock;
1642
1643 i_qgroups = (u64 *)(inherit + 1);
1644 for (i = 0; i < inherit->num_qgroups; ++i) {
1645 ret = add_relation_rb(quota_root->fs_info, objectid,
1646 *i_qgroups);
1647 if (ret)
1648 goto unlock;
1649 ++i_qgroups;
1650 }
1651
1652 for (i = 0; i < inherit->num_ref_copies; ++i) {
1653 struct btrfs_qgroup *src;
1654 struct btrfs_qgroup *dst;
1655
1656 src = find_qgroup_rb(fs_info, i_qgroups[0]);
1657 dst = find_qgroup_rb(fs_info, i_qgroups[1]);
1658
1659 if (!src || !dst) {
1660 ret = -EINVAL;
1661 goto unlock;
1662 }
1663
1664 dst->rfer = src->rfer - level_size;
1665 dst->rfer_cmpr = src->rfer_cmpr - level_size;
1666 i_qgroups += 2;
1667 }
1668 for (i = 0; i < inherit->num_excl_copies; ++i) {
1669 struct btrfs_qgroup *src;
1670 struct btrfs_qgroup *dst;
1671
1672 src = find_qgroup_rb(fs_info, i_qgroups[0]);
1673 dst = find_qgroup_rb(fs_info, i_qgroups[1]);
1674
1675 if (!src || !dst) {
1676 ret = -EINVAL;
1677 goto unlock;
1678 }
1679
1680 dst->excl = src->excl + level_size;
1681 dst->excl_cmpr = src->excl_cmpr + level_size;
1682 i_qgroups += 2;
1683 }
1684
1685unlock:
1686 spin_unlock(&fs_info->qgroup_lock);
1687out:
1688 mutex_unlock(&fs_info->qgroup_ioctl_lock);
1689 return ret;
1690}
1691
1692
1693
1694
1695
1696
1697
1698int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
1699{
1700 struct btrfs_root *quota_root;
1701 struct btrfs_qgroup *qgroup;
1702 struct btrfs_fs_info *fs_info = root->fs_info;
1703 u64 ref_root = root->root_key.objectid;
1704 int ret = 0;
1705 struct ulist_node *unode;
1706 struct ulist_iterator uiter;
1707
1708 if (!is_fstree(ref_root))
1709 return 0;
1710
1711 if (num_bytes == 0)
1712 return 0;
1713
1714 spin_lock(&fs_info->qgroup_lock);
1715 quota_root = fs_info->quota_root;
1716 if (!quota_root)
1717 goto out;
1718
1719 qgroup = find_qgroup_rb(fs_info, ref_root);
1720 if (!qgroup)
1721 goto out;
1722
1723
1724
1725
1726
1727 ulist_reinit(fs_info->qgroup_ulist);
1728 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid,
1729 (uintptr_t)qgroup, GFP_ATOMIC);
1730 if (ret < 0)
1731 goto out;
1732 ULIST_ITER_INIT(&uiter);
1733 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) {
1734 struct btrfs_qgroup *qg;
1735 struct btrfs_qgroup_list *glist;
1736
1737 qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
1738
1739 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_RFER) &&
1740 qg->reserved + (s64)qg->rfer + num_bytes >
1741 qg->max_rfer) {
1742 ret = -EDQUOT;
1743 goto out;
1744 }
1745
1746 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) &&
1747 qg->reserved + (s64)qg->excl + num_bytes >
1748 qg->max_excl) {
1749 ret = -EDQUOT;
1750 goto out;
1751 }
1752
1753 list_for_each_entry(glist, &qg->groups, next_group) {
1754 ret = ulist_add(fs_info->qgroup_ulist,
1755 glist->group->qgroupid,
1756 (uintptr_t)glist->group, GFP_ATOMIC);
1757 if (ret < 0)
1758 goto out;
1759 }
1760 }
1761 ret = 0;
1762
1763
1764
1765 ULIST_ITER_INIT(&uiter);
1766 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) {
1767 struct btrfs_qgroup *qg;
1768
1769 qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
1770
1771 qg->reserved += num_bytes;
1772 }
1773
1774out:
1775 spin_unlock(&fs_info->qgroup_lock);
1776 return ret;
1777}
1778
1779void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes)
1780{
1781 struct btrfs_root *quota_root;
1782 struct btrfs_qgroup *qgroup;
1783 struct btrfs_fs_info *fs_info = root->fs_info;
1784 struct ulist_node *unode;
1785 struct ulist_iterator uiter;
1786 u64 ref_root = root->root_key.objectid;
1787 int ret = 0;
1788
1789 if (!is_fstree(ref_root))
1790 return;
1791
1792 if (num_bytes == 0)
1793 return;
1794
1795 spin_lock(&fs_info->qgroup_lock);
1796
1797 quota_root = fs_info->quota_root;
1798 if (!quota_root)
1799 goto out;
1800
1801 qgroup = find_qgroup_rb(fs_info, ref_root);
1802 if (!qgroup)
1803 goto out;
1804
1805 ulist_reinit(fs_info->qgroup_ulist);
1806 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid,
1807 (uintptr_t)qgroup, GFP_ATOMIC);
1808 if (ret < 0)
1809 goto out;
1810 ULIST_ITER_INIT(&uiter);
1811 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) {
1812 struct btrfs_qgroup *qg;
1813 struct btrfs_qgroup_list *glist;
1814
1815 qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
1816
1817 qg->reserved -= num_bytes;
1818
1819 list_for_each_entry(glist, &qg->groups, next_group) {
1820 ret = ulist_add(fs_info->qgroup_ulist,
1821 glist->group->qgroupid,
1822 (uintptr_t)glist->group, GFP_ATOMIC);
1823 if (ret < 0)
1824 goto out;
1825 }
1826 }
1827
1828out:
1829 spin_unlock(&fs_info->qgroup_lock);
1830}
1831
1832void assert_qgroups_uptodate(struct btrfs_trans_handle *trans)
1833{
1834 if (list_empty(&trans->qgroup_ref_list) && !trans->delayed_ref_elem.seq)
1835 return;
1836 btrfs_err(trans->root->fs_info,
1837 "qgroups not uptodate in trans handle %p: list is%s empty, "
1838 "seq is %#x.%x",
1839 trans, list_empty(&trans->qgroup_ref_list) ? "" : " not",
1840 (u32)(trans->delayed_ref_elem.seq >> 32),
1841 (u32)trans->delayed_ref_elem.seq);
1842 BUG();
1843}
1844
1845
1846
1847
1848
1849static int
1850qgroup_rescan_leaf(struct btrfs_fs_info *fs_info, struct btrfs_path *path,
1851 struct btrfs_trans_handle *trans, struct ulist *tmp,
1852 struct extent_buffer *scratch_leaf)
1853{
1854 struct btrfs_key found;
1855 struct ulist *roots = NULL;
1856 struct ulist_node *unode;
1857 struct ulist_iterator uiter;
1858 struct seq_list tree_mod_seq_elem = {};
1859 u64 seq;
1860 int slot;
1861 int ret;
1862
1863 path->leave_spinning = 1;
1864 mutex_lock(&fs_info->qgroup_rescan_lock);
1865 ret = btrfs_search_slot_for_read(fs_info->extent_root,
1866 &fs_info->qgroup_rescan_progress,
1867 path, 1, 0);
1868
1869 pr_debug("current progress key (%llu %u %llu), search_slot ret %d\n",
1870 fs_info->qgroup_rescan_progress.objectid,
1871 fs_info->qgroup_rescan_progress.type,
1872 fs_info->qgroup_rescan_progress.offset, ret);
1873
1874 if (ret) {
1875
1876
1877
1878
1879
1880
1881
1882
1883 fs_info->qgroup_rescan_progress.objectid = (u64)-1;
1884 btrfs_release_path(path);
1885 mutex_unlock(&fs_info->qgroup_rescan_lock);
1886 return ret;
1887 }
1888
1889 btrfs_item_key_to_cpu(path->nodes[0], &found,
1890 btrfs_header_nritems(path->nodes[0]) - 1);
1891 fs_info->qgroup_rescan_progress.objectid = found.objectid + 1;
1892
1893 btrfs_get_tree_mod_seq(fs_info, &tree_mod_seq_elem);
1894 memcpy(scratch_leaf, path->nodes[0], sizeof(*scratch_leaf));
1895 slot = path->slots[0];
1896 btrfs_release_path(path);
1897 mutex_unlock(&fs_info->qgroup_rescan_lock);
1898
1899 for (; slot < btrfs_header_nritems(scratch_leaf); ++slot) {
1900 u64 num_bytes;
1901
1902 btrfs_item_key_to_cpu(scratch_leaf, &found, slot);
1903 if (found.type != BTRFS_EXTENT_ITEM_KEY &&
1904 found.type != BTRFS_METADATA_ITEM_KEY)
1905 continue;
1906 if (found.type == BTRFS_METADATA_ITEM_KEY)
1907 num_bytes = fs_info->extent_root->leafsize;
1908 else
1909 num_bytes = found.offset;
1910
1911 ret = btrfs_find_all_roots(trans, fs_info, found.objectid,
1912 tree_mod_seq_elem.seq, &roots);
1913 if (ret < 0)
1914 goto out;
1915 spin_lock(&fs_info->qgroup_lock);
1916 seq = fs_info->qgroup_seq;
1917 fs_info->qgroup_seq += roots->nnodes + 1;
1918
1919 ret = qgroup_account_ref_step1(fs_info, roots, tmp, seq);
1920 if (ret) {
1921 spin_unlock(&fs_info->qgroup_lock);
1922 ulist_free(roots);
1923 goto out;
1924 }
1925
1926
1927
1928
1929
1930 ulist_reinit(tmp);
1931 ULIST_ITER_INIT(&uiter);
1932 while ((unode = ulist_next(roots, &uiter))) {
1933 struct btrfs_qgroup *qg;
1934
1935 qg = find_qgroup_rb(fs_info, unode->val);
1936 if (!qg)
1937 continue;
1938
1939 ret = ulist_add(tmp, qg->qgroupid, (uintptr_t)qg,
1940 GFP_ATOMIC);
1941 if (ret < 0) {
1942 spin_unlock(&fs_info->qgroup_lock);
1943 ulist_free(roots);
1944 goto out;
1945 }
1946 }
1947
1948
1949 ULIST_ITER_INIT(&uiter);
1950 while ((unode = ulist_next(tmp, &uiter))) {
1951 struct btrfs_qgroup *qg;
1952 struct btrfs_qgroup_list *glist;
1953
1954 qg = (struct btrfs_qgroup *)(uintptr_t) unode->aux;
1955 qg->rfer += num_bytes;
1956 qg->rfer_cmpr += num_bytes;
1957 WARN_ON(qg->tag >= seq);
1958 if (qg->refcnt - seq == roots->nnodes) {
1959 qg->excl += num_bytes;
1960 qg->excl_cmpr += num_bytes;
1961 }
1962 qgroup_dirty(fs_info, qg);
1963
1964 list_for_each_entry(glist, &qg->groups, next_group) {
1965 ret = ulist_add(tmp, glist->group->qgroupid,
1966 (uintptr_t)glist->group,
1967 GFP_ATOMIC);
1968 if (ret < 0) {
1969 spin_unlock(&fs_info->qgroup_lock);
1970 ulist_free(roots);
1971 goto out;
1972 }
1973 }
1974 }
1975
1976 spin_unlock(&fs_info->qgroup_lock);
1977 ulist_free(roots);
1978 ret = 0;
1979 }
1980
1981out:
1982 btrfs_put_tree_mod_seq(fs_info, &tree_mod_seq_elem);
1983
1984 return ret;
1985}
1986
1987static void btrfs_qgroup_rescan_worker(struct btrfs_work *work)
1988{
1989 struct btrfs_fs_info *fs_info = container_of(work, struct btrfs_fs_info,
1990 qgroup_rescan_work);
1991 struct btrfs_path *path;
1992 struct btrfs_trans_handle *trans = NULL;
1993 struct ulist *tmp = NULL;
1994 struct extent_buffer *scratch_leaf = NULL;
1995 int err = -ENOMEM;
1996
1997 path = btrfs_alloc_path();
1998 if (!path)
1999 goto out;
2000 tmp = ulist_alloc(GFP_NOFS);
2001 if (!tmp)
2002 goto out;
2003 scratch_leaf = kmalloc(sizeof(*scratch_leaf), GFP_NOFS);
2004 if (!scratch_leaf)
2005 goto out;
2006
2007 err = 0;
2008 while (!err) {
2009 trans = btrfs_start_transaction(fs_info->fs_root, 0);
2010 if (IS_ERR(trans)) {
2011 err = PTR_ERR(trans);
2012 break;
2013 }
2014 if (!fs_info->quota_enabled) {
2015 err = -EINTR;
2016 } else {
2017 err = qgroup_rescan_leaf(fs_info, path, trans,
2018 tmp, scratch_leaf);
2019 }
2020 if (err > 0)
2021 btrfs_commit_transaction(trans, fs_info->fs_root);
2022 else
2023 btrfs_end_transaction(trans, fs_info->fs_root);
2024 }
2025
2026out:
2027 kfree(scratch_leaf);
2028 ulist_free(tmp);
2029 btrfs_free_path(path);
2030
2031 mutex_lock(&fs_info->qgroup_rescan_lock);
2032 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
2033
2034 if (err == 2 &&
2035 fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) {
2036 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
2037 } else if (err < 0) {
2038 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
2039 }
2040 mutex_unlock(&fs_info->qgroup_rescan_lock);
2041
2042 if (err >= 0) {
2043 btrfs_info(fs_info, "qgroup scan completed%s",
2044 err == 2 ? " (inconsistency flag cleared)" : "");
2045 } else {
2046 btrfs_err(fs_info, "qgroup scan failed with %d", err);
2047 }
2048
2049 complete_all(&fs_info->qgroup_rescan_completion);
2050}
2051
2052
2053
2054
2055
2056static int
2057qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,
2058 int init_flags)
2059{
2060 int ret = 0;
2061
2062 if (!init_flags &&
2063 (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) ||
2064 !(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))) {
2065 ret = -EINVAL;
2066 goto err;
2067 }
2068
2069 mutex_lock(&fs_info->qgroup_rescan_lock);
2070 spin_lock(&fs_info->qgroup_lock);
2071
2072 if (init_flags) {
2073 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
2074 ret = -EINPROGRESS;
2075 else if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))
2076 ret = -EINVAL;
2077
2078 if (ret) {
2079 spin_unlock(&fs_info->qgroup_lock);
2080 mutex_unlock(&fs_info->qgroup_rescan_lock);
2081 goto err;
2082 }
2083
2084 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN;
2085 }
2086
2087 memset(&fs_info->qgroup_rescan_progress, 0,
2088 sizeof(fs_info->qgroup_rescan_progress));
2089 fs_info->qgroup_rescan_progress.objectid = progress_objectid;
2090
2091 spin_unlock(&fs_info->qgroup_lock);
2092 mutex_unlock(&fs_info->qgroup_rescan_lock);
2093
2094 init_completion(&fs_info->qgroup_rescan_completion);
2095
2096 memset(&fs_info->qgroup_rescan_work, 0,
2097 sizeof(fs_info->qgroup_rescan_work));
2098 btrfs_init_work(&fs_info->qgroup_rescan_work,
2099 btrfs_qgroup_rescan_worker, NULL, NULL);
2100
2101 if (ret) {
2102err:
2103 btrfs_info(fs_info, "qgroup_rescan_init failed with %d", ret);
2104 return ret;
2105 }
2106
2107 return 0;
2108}
2109
2110static void
2111qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info)
2112{
2113 struct rb_node *n;
2114 struct btrfs_qgroup *qgroup;
2115
2116 spin_lock(&fs_info->qgroup_lock);
2117
2118 for (n = rb_first(&fs_info->qgroup_tree); n; n = rb_next(n)) {
2119 qgroup = rb_entry(n, struct btrfs_qgroup, node);
2120 qgroup->rfer = 0;
2121 qgroup->rfer_cmpr = 0;
2122 qgroup->excl = 0;
2123 qgroup->excl_cmpr = 0;
2124 }
2125 spin_unlock(&fs_info->qgroup_lock);
2126}
2127
2128int
2129btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
2130{
2131 int ret = 0;
2132 struct btrfs_trans_handle *trans;
2133
2134 ret = qgroup_rescan_init(fs_info, 0, 1);
2135 if (ret)
2136 return ret;
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149 trans = btrfs_join_transaction(fs_info->fs_root);
2150 if (IS_ERR(trans)) {
2151 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
2152 return PTR_ERR(trans);
2153 }
2154 ret = btrfs_commit_transaction(trans, fs_info->fs_root);
2155 if (ret) {
2156 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
2157 return ret;
2158 }
2159
2160 qgroup_rescan_zero_tracking(fs_info);
2161
2162 btrfs_queue_work(fs_info->qgroup_rescan_workers,
2163 &fs_info->qgroup_rescan_work);
2164
2165 return 0;
2166}
2167
2168int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info)
2169{
2170 int running;
2171 int ret = 0;
2172
2173 mutex_lock(&fs_info->qgroup_rescan_lock);
2174 spin_lock(&fs_info->qgroup_lock);
2175 running = fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN;
2176 spin_unlock(&fs_info->qgroup_lock);
2177 mutex_unlock(&fs_info->qgroup_rescan_lock);
2178
2179 if (running)
2180 ret = wait_for_completion_interruptible(
2181 &fs_info->qgroup_rescan_completion);
2182
2183 return ret;
2184}
2185
2186
2187
2188
2189
2190void
2191btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info)
2192{
2193 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
2194 btrfs_queue_work(fs_info->qgroup_rescan_workers,
2195 &fs_info->qgroup_rescan_work);
2196}
2197