2 * Copyright (C) 2012 STRATO. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
20 #include <sys/ioctl.h>
26 #define BTRFS_QGROUP_NFILTERS_INCREASE (2 * BTRFS_QGROUP_FILTER_MAX)
27 #define BTRFS_QGROUP_NCOMPS_INCREASE (2 * BTRFS_QGROUP_COMP_MAX)
29 struct qgroup_lookup {
34 struct rb_node rb_node;
35 struct rb_node sort_node;
37 *all_parent_node is used to
38 *filter a qgroup's all parent
40 struct rb_node all_parent_node;
47 u64 rfer; /*referenced*/
48 u64 rfer_cmpr; /*referenced compressed*/
49 u64 excl; /*exclusive*/
50 u64 excl_cmpr; /*exclusive compressed*/
55 u64 flags; /*which limits are set*/
61 /*qgroups this group is member of*/
62 struct list_head qgroups;
63 /*qgroups that are members of this group*/
64 struct list_head members;
68 * glue structure to represent the relations
71 struct btrfs_qgroup_list {
72 struct list_head next_qgroup;
73 struct list_head next_member;
74 struct btrfs_qgroup *qgroup;
75 struct btrfs_qgroup *member;
79 * qgroupid,rfer,excl default to set
87 } btrfs_qgroup_columns[] = {
90 .column_name = "Qgroupid",
97 .column_name = "Rfer",
99 .unit_mode = UNITS_DEFAULT,
104 .column_name = "Excl",
106 .unit_mode = UNITS_DEFAULT,
109 { .name = "max_rfer",
110 .column_name = "Max_rfer",
112 .unit_mode = UNITS_DEFAULT,
117 .column_name = "Max_excl",
119 .unit_mode = UNITS_DEFAULT,
124 .column_name = "Parent",
131 .column_name = "Child",
144 static btrfs_qgroup_filter_func all_filter_funcs[];
145 static btrfs_qgroup_comp_func all_comp_funcs[];
147 void btrfs_qgroup_setup_print_column(enum btrfs_qgroup_column_enum column)
151 ASSERT(0 <= column && column <= BTRFS_QGROUP_ALL);
153 if (column < BTRFS_QGROUP_ALL) {
154 btrfs_qgroup_columns[column].need_print = 1;
157 for (i = 0; i < BTRFS_QGROUP_ALL; i++)
158 btrfs_qgroup_columns[i].need_print = 1;
161 void btrfs_qgroup_setup_units(unsigned unit_mode)
163 btrfs_qgroup_columns[BTRFS_QGROUP_RFER].unit_mode = unit_mode;
164 btrfs_qgroup_columns[BTRFS_QGROUP_EXCL].unit_mode = unit_mode;
165 btrfs_qgroup_columns[BTRFS_QGROUP_MAX_RFER].unit_mode = unit_mode;
166 btrfs_qgroup_columns[BTRFS_QGROUP_MAX_EXCL].unit_mode = unit_mode;
169 static int print_parent_column(struct btrfs_qgroup *qgroup)
171 struct btrfs_qgroup_list *list = NULL;
174 list_for_each_entry(list, &qgroup->qgroups, next_qgroup) {
175 len += printf("%llu/%llu",
176 btrfs_qgroup_level(list->qgroup->qgroupid),
177 btrfs_qgroup_subvid(list->qgroup->qgroupid));
178 if (!list_is_last(&list->next_qgroup, &qgroup->qgroups))
181 if (list_empty(&qgroup->qgroups))
182 len += printf("---");
187 static int print_child_column(struct btrfs_qgroup *qgroup)
189 struct btrfs_qgroup_list *list = NULL;
192 list_for_each_entry(list, &qgroup->members, next_member) {
193 len += printf("%llu/%llu",
194 btrfs_qgroup_level(list->member->qgroupid),
195 btrfs_qgroup_subvid(list->member->qgroupid));
196 if (!list_is_last(&list->next_member, &qgroup->members))
199 if (list_empty(&qgroup->members))
200 len += printf("---");
205 static void print_qgroup_column_add_blank(enum btrfs_qgroup_column_enum column,
208 len = btrfs_qgroup_columns[column].max_len - len;
213 static void print_qgroup_column(struct btrfs_qgroup *qgroup,
214 enum btrfs_qgroup_column_enum column)
217 int unit_mode = btrfs_qgroup_columns[column].unit_mode;
218 int max_len = btrfs_qgroup_columns[column].max_len;
220 ASSERT(0 <= column && column < BTRFS_QGROUP_ALL);
224 case BTRFS_QGROUP_QGROUPID:
225 len = printf("%llu/%llu",
226 btrfs_qgroup_level(qgroup->qgroupid),
227 btrfs_qgroup_subvid(qgroup->qgroupid));
228 print_qgroup_column_add_blank(BTRFS_QGROUP_QGROUPID, len);
230 case BTRFS_QGROUP_RFER:
231 len = printf("%*s", max_len, pretty_size_mode(qgroup->rfer, unit_mode));
233 case BTRFS_QGROUP_EXCL:
234 len = printf("%*s", max_len, pretty_size_mode(qgroup->excl, unit_mode));
236 case BTRFS_QGROUP_PARENT:
237 len = print_parent_column(qgroup);
238 print_qgroup_column_add_blank(BTRFS_QGROUP_PARENT, len);
240 case BTRFS_QGROUP_MAX_RFER:
241 if (qgroup->flags & BTRFS_QGROUP_LIMIT_MAX_RFER)
242 len = printf("%*s", max_len, pretty_size_mode(qgroup->max_rfer, unit_mode));
244 len = printf("%*s", max_len, "none");
246 case BTRFS_QGROUP_MAX_EXCL:
247 if (qgroup->flags & BTRFS_QGROUP_LIMIT_MAX_EXCL)
248 len = printf("%*s", max_len, pretty_size_mode(qgroup->max_excl, unit_mode));
250 len = printf("%*s", max_len, "none");
252 case BTRFS_QGROUP_CHILD:
253 len = print_child_column(qgroup);
254 print_qgroup_column_add_blank(BTRFS_QGROUP_CHILD, len);
261 static void print_single_qgroup_table(struct btrfs_qgroup *qgroup)
265 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
266 if (!btrfs_qgroup_columns[i].need_print)
268 print_qgroup_column(qgroup, i);
270 if (i != BTRFS_QGROUP_CHILD)
276 static void print_table_head(void)
282 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
283 max_len = btrfs_qgroup_columns[i].max_len;
284 if (!btrfs_qgroup_columns[i].need_print)
286 if ((i == BTRFS_QGROUP_QGROUPID) | (i == BTRFS_QGROUP_PARENT) |
287 (i == BTRFS_QGROUP_CHILD))
288 printf("%-*s", max_len, btrfs_qgroup_columns[i].name);
290 printf("%*s", max_len, btrfs_qgroup_columns[i].name);
294 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
295 max_len = btrfs_qgroup_columns[i].max_len;
296 if (!btrfs_qgroup_columns[i].need_print)
298 if ((i == BTRFS_QGROUP_QGROUPID) | (i == BTRFS_QGROUP_PARENT) |
299 (i == BTRFS_QGROUP_CHILD)) {
300 len = strlen(btrfs_qgroup_columns[i].name);
303 len = max_len - strlen(btrfs_qgroup_columns[i].name);
307 len = max_len - strlen(btrfs_qgroup_columns[i].name);
310 len = strlen(btrfs_qgroup_columns[i].name);
319 static void qgroup_lookup_init(struct qgroup_lookup *tree)
321 tree->root.rb_node = NULL;
324 static int comp_entry_with_qgroupid(struct btrfs_qgroup *entry1,
325 struct btrfs_qgroup *entry2,
331 if (entry1->qgroupid > entry2->qgroupid)
333 else if (entry1->qgroupid < entry2->qgroupid)
338 return is_descending ? -ret : ret;
341 static int comp_entry_with_rfer(struct btrfs_qgroup *entry1,
342 struct btrfs_qgroup *entry2,
347 if (entry1->rfer > entry2->rfer)
349 else if (entry1->rfer < entry2->rfer)
354 return is_descending ? -ret : ret;
357 static int comp_entry_with_excl(struct btrfs_qgroup *entry1,
358 struct btrfs_qgroup *entry2,
363 if (entry1->excl > entry2->excl)
365 else if (entry1->excl < entry2->excl)
370 return is_descending ? -ret : ret;
373 static int comp_entry_with_max_rfer(struct btrfs_qgroup *entry1,
374 struct btrfs_qgroup *entry2,
379 if (entry1->max_rfer > entry2->max_rfer)
381 else if (entry1->max_rfer < entry2->max_rfer)
386 return is_descending ? -ret : ret;
389 static int comp_entry_with_max_excl(struct btrfs_qgroup *entry1,
390 struct btrfs_qgroup *entry2,
395 if (entry1->max_excl > entry2->max_excl)
397 else if (entry1->max_excl < entry2->max_excl)
402 return is_descending ? -ret : ret;
405 static btrfs_qgroup_comp_func all_comp_funcs[] = {
406 [BTRFS_QGROUP_COMP_QGROUPID] = comp_entry_with_qgroupid,
407 [BTRFS_QGROUP_COMP_RFER] = comp_entry_with_rfer,
408 [BTRFS_QGROUP_COMP_EXCL] = comp_entry_with_excl,
409 [BTRFS_QGROUP_COMP_MAX_RFER] = comp_entry_with_max_rfer,
410 [BTRFS_QGROUP_COMP_MAX_EXCL] = comp_entry_with_max_excl
413 static char *all_sort_items[] = {
414 [BTRFS_QGROUP_COMP_QGROUPID] = "qgroupid",
415 [BTRFS_QGROUP_COMP_RFER] = "rfer",
416 [BTRFS_QGROUP_COMP_EXCL] = "excl",
417 [BTRFS_QGROUP_COMP_MAX_RFER] = "max_rfer",
418 [BTRFS_QGROUP_COMP_MAX_EXCL] = "max_excl",
419 [BTRFS_QGROUP_COMP_MAX] = NULL,
422 static int btrfs_qgroup_get_sort_item(char *sort_name)
426 for (i = 0; i < BTRFS_QGROUP_COMP_MAX; i++) {
427 if (strcmp(sort_name, all_sort_items[i]) == 0)
433 struct btrfs_qgroup_comparer_set *btrfs_qgroup_alloc_comparer_set(void)
435 struct btrfs_qgroup_comparer_set *set;
437 size = sizeof(struct btrfs_qgroup_comparer_set) +
438 BTRFS_QGROUP_NCOMPS_INCREASE *
439 sizeof(struct btrfs_qgroup_comparer);
440 set = calloc(1, size);
442 fprintf(stderr, "memory allocation failed\n");
446 set->total = BTRFS_QGROUP_NCOMPS_INCREASE;
451 void btrfs_qgroup_free_comparer_set(struct btrfs_qgroup_comparer_set *comp_set)
456 int btrfs_qgroup_setup_comparer(struct btrfs_qgroup_comparer_set **comp_set,
457 enum btrfs_qgroup_comp_enum comparer,
460 struct btrfs_qgroup_comparer_set *set = *comp_set;
464 ASSERT(comparer < BTRFS_QGROUP_COMP_MAX);
465 ASSERT(set->ncomps <= set->total);
467 if (set->ncomps == set->total) {
470 size = set->total + BTRFS_QGROUP_NCOMPS_INCREASE;
471 size = sizeof(*set) +
472 size * sizeof(struct btrfs_qgroup_comparer);
474 set = realloc(set, size);
476 fprintf(stderr, "memory allocation failed\n");
481 memset(&set->comps[set->total], 0,
482 BTRFS_QGROUP_NCOMPS_INCREASE *
483 sizeof(struct btrfs_qgroup_comparer));
484 set->total += BTRFS_QGROUP_NCOMPS_INCREASE;
488 ASSERT(set->comps[set->ncomps].comp_func != NULL);
490 set->comps[set->ncomps].comp_func = all_comp_funcs[comparer];
491 set->comps[set->ncomps].is_descending = is_descending;
496 static int sort_comp(struct btrfs_qgroup *entry1, struct btrfs_qgroup *entry2,
497 struct btrfs_qgroup_comparer_set *set)
499 int qgroupid_compared = 0;
502 if (!set || !set->ncomps)
505 for (i = 0; i < set->ncomps; i++) {
506 if (!set->comps[i].comp_func)
509 ret = set->comps[i].comp_func(entry1, entry2,
510 set->comps[i].is_descending);
514 if (set->comps[i].comp_func == comp_entry_with_qgroupid)
515 qgroupid_compared = 1;
518 if (!qgroupid_compared) {
520 ret = comp_entry_with_qgroupid(entry1, entry2, 0);
527 * insert a new root into the tree. returns the existing root entry
528 * if one is already there. qgroupid is used
531 static int qgroup_tree_insert(struct qgroup_lookup *root_tree,
532 struct btrfs_qgroup *ins)
535 struct rb_node **p = &root_tree->root.rb_node;
536 struct rb_node *parent = NULL;
537 struct btrfs_qgroup *curr;
542 curr = rb_entry(parent, struct btrfs_qgroup, rb_node);
544 ret = comp_entry_with_qgroupid(ins, curr, 0);
552 rb_link_node(&ins->rb_node, parent, p);
553 rb_insert_color(&ins->rb_node, &root_tree->root);
558 *find a given qgroupid in the tree. We return the smallest one,
559 *rb_next can be used to move forward looking for more if required
561 static struct btrfs_qgroup *qgroup_tree_search(struct qgroup_lookup *root_tree,
564 struct rb_node *n = root_tree->root.rb_node;
565 struct btrfs_qgroup *entry;
566 struct btrfs_qgroup tmp;
569 tmp.qgroupid = qgroupid;
572 entry = rb_entry(n, struct btrfs_qgroup, rb_node);
574 ret = comp_entry_with_qgroupid(&tmp, entry, 0);
586 static int update_qgroup(struct qgroup_lookup *qgroup_lookup, u64 qgroupid,
587 u64 generation, u64 rfer, u64 rfer_cmpr, u64 excl,
588 u64 excl_cmpr, u64 flags, u64 max_rfer, u64 max_excl,
589 u64 rsv_rfer, u64 rsv_excl, struct btrfs_qgroup *pa,
590 struct btrfs_qgroup *child)
592 struct btrfs_qgroup *bq;
593 struct btrfs_qgroup_list *list;
595 bq = qgroup_tree_search(qgroup_lookup, qgroupid);
596 if (!bq || bq->qgroupid != qgroupid)
600 bq->generation = generation;
604 bq->rfer_cmpr = rfer_cmpr;
608 bq->excl_cmpr = excl_cmpr;
612 bq->max_rfer = max_rfer;
614 bq->max_excl = max_excl;
616 bq->rsv_rfer = rsv_rfer;
618 list = malloc(sizeof(*list));
620 fprintf(stderr, "memory allocation failed\n");
624 list->member = child;
625 list_add_tail(&list->next_qgroup, &child->qgroups);
626 list_add_tail(&list->next_member, &pa->members);
631 static int add_qgroup(struct qgroup_lookup *qgroup_lookup, u64 qgroupid,
632 u64 generation, u64 rfer, u64 rfer_cmpr, u64 excl,
633 u64 excl_cmpr, u64 flags, u64 max_rfer, u64 max_excl,
634 u64 rsv_rfer, u64 rsv_excl, struct btrfs_qgroup *parent,
635 struct btrfs_qgroup *child)
637 struct btrfs_qgroup *bq;
638 struct btrfs_qgroup_list *list;
641 ret = update_qgroup(qgroup_lookup, qgroupid, generation, rfer,
642 rfer_cmpr, excl, excl_cmpr, flags, max_rfer,
643 max_excl, rsv_rfer, rsv_excl, parent, child);
647 bq = calloc(1, sizeof(*bq));
649 printf("memory allocation failed\n");
653 bq->qgroupid = qgroupid;
654 INIT_LIST_HEAD(&bq->qgroups);
655 INIT_LIST_HEAD(&bq->members);
658 bq->generation = generation;
662 bq->rfer_cmpr = rfer_cmpr;
666 bq->excl_cmpr = excl_cmpr;
670 bq->max_rfer = max_rfer;
672 bq->max_excl = max_excl;
674 bq->rsv_rfer = rsv_rfer;
675 if (parent && child) {
676 list = malloc(sizeof(*list));
678 fprintf(stderr, "memory allocation failed\n");
681 list->qgroup = parent;
682 list->member = child;
683 list_add_tail(&list->next_qgroup, &child->qgroups);
684 list_add_tail(&list->next_member, &parent->members);
686 ret = qgroup_tree_insert(qgroup_lookup, bq);
688 printf("failed to insert tree %llu\n",
695 static void __free_btrfs_qgroup(struct btrfs_qgroup *bq)
697 struct btrfs_qgroup_list *list;
698 while (!list_empty(&bq->qgroups)) {
699 list = list_entry((&bq->qgroups)->next,
700 struct btrfs_qgroup_list,
702 list_del(&list->next_qgroup);
703 list_del(&list->next_member);
706 while (!list_empty(&bq->members)) {
707 list = list_entry((&bq->members)->next,
708 struct btrfs_qgroup_list,
710 list_del(&list->next_qgroup);
711 list_del(&list->next_member);
717 static void __free_all_qgroups(struct qgroup_lookup *root_tree)
719 struct btrfs_qgroup *entry;
722 n = rb_first(&root_tree->root);
724 entry = rb_entry(n, struct btrfs_qgroup, rb_node);
725 rb_erase(n, &root_tree->root);
726 __free_btrfs_qgroup(entry);
728 n = rb_first(&root_tree->root);
732 static int filter_all_parent_insert(struct qgroup_lookup *sort_tree,
733 struct btrfs_qgroup *bq)
735 struct rb_node **p = &sort_tree->root.rb_node;
736 struct rb_node *parent = NULL;
737 struct btrfs_qgroup *curr;
742 curr = rb_entry(parent, struct btrfs_qgroup, all_parent_node);
744 ret = comp_entry_with_qgroupid(bq, curr, 0);
752 rb_link_node(&bq->all_parent_node, parent, p);
753 rb_insert_color(&bq->all_parent_node, &sort_tree->root);
757 static int filter_by_parent(struct btrfs_qgroup *bq, u64 data)
759 struct btrfs_qgroup *qgroup =
760 (struct btrfs_qgroup *)(unsigned long)data;
764 if (qgroup->qgroupid == bq->qgroupid)
769 static int filter_by_all_parent(struct btrfs_qgroup *bq, u64 data)
771 struct qgroup_lookup lookup;
772 struct qgroup_lookup *ql = &lookup;
773 struct btrfs_qgroup_list *list;
775 struct btrfs_qgroup *qgroup =
776 (struct btrfs_qgroup *)(unsigned long)data;
780 if (bq->qgroupid == qgroup->qgroupid)
783 qgroup_lookup_init(ql);
784 filter_all_parent_insert(ql, qgroup);
785 n = rb_first(&ql->root);
787 qgroup = rb_entry(n, struct btrfs_qgroup, all_parent_node);
788 if (!list_empty(&qgroup->qgroups)) {
789 list_for_each_entry(list, &qgroup->qgroups,
791 if ((list->qgroup)->qgroupid == bq->qgroupid)
793 filter_all_parent_insert(ql, list->qgroup);
796 rb_erase(n, &ql->root);
797 n = rb_first(&ql->root);
802 static btrfs_qgroup_filter_func all_filter_funcs[] = {
803 [BTRFS_QGROUP_FILTER_PARENT] = filter_by_parent,
804 [BTRFS_QGROUP_FILTER_ALL_PARENT] = filter_by_all_parent,
807 struct btrfs_qgroup_filter_set *btrfs_qgroup_alloc_filter_set(void)
809 struct btrfs_qgroup_filter_set *set;
812 size = sizeof(struct btrfs_qgroup_filter_set) +
813 BTRFS_QGROUP_NFILTERS_INCREASE *
814 sizeof(struct btrfs_qgroup_filter);
815 set = calloc(1, size);
817 fprintf(stderr, "memory allocation failed\n");
820 set->total = BTRFS_QGROUP_NFILTERS_INCREASE;
825 void btrfs_qgroup_free_filter_set(struct btrfs_qgroup_filter_set *filter_set)
830 int btrfs_qgroup_setup_filter(struct btrfs_qgroup_filter_set **filter_set,
831 enum btrfs_qgroup_filter_enum filter, u64 data)
833 struct btrfs_qgroup_filter_set *set = *filter_set;
837 ASSERT(filter < BTRFS_QGROUP_FILTER_MAX);
838 ASSERT(set->nfilters <= set->total);
840 if (set->nfilters == set->total) {
843 size = set->total + BTRFS_QGROUP_NFILTERS_INCREASE;
844 size = sizeof(*set) + size * sizeof(struct btrfs_qgroup_filter);
847 set = realloc(set, size);
849 fprintf(stderr, "memory allocation failed\n");
853 memset(&set->filters[set->total], 0,
854 BTRFS_QGROUP_NFILTERS_INCREASE *
855 sizeof(struct btrfs_qgroup_filter));
856 set->total += BTRFS_QGROUP_NFILTERS_INCREASE;
860 ASSERT(set->filters[set->nfilters].filter_func != NULL);
861 set->filters[set->nfilters].filter_func = all_filter_funcs[filter];
862 set->filters[set->nfilters].data = data;
867 static int filter_qgroup(struct btrfs_qgroup *bq,
868 struct btrfs_qgroup_filter_set *set)
872 if (!set || !set->nfilters)
874 for (i = 0; i < set->nfilters; i++) {
875 if (!set->filters[i].filter_func)
877 ret = set->filters[i].filter_func(bq, set->filters[i].data);
884 static void pre_process_filter_set(struct qgroup_lookup *lookup,
885 struct btrfs_qgroup_filter_set *set)
888 struct btrfs_qgroup *qgroup_for_filter = NULL;
890 for (i = 0; i < set->nfilters; i++) {
892 if (set->filters[i].filter_func == filter_by_all_parent
893 || set->filters[i].filter_func == filter_by_parent) {
894 qgroup_for_filter = qgroup_tree_search(lookup,
895 set->filters[i].data);
896 set->filters[i].data =
897 (u64)(unsigned long)qgroup_for_filter;
902 static int sort_tree_insert(struct qgroup_lookup *sort_tree,
903 struct btrfs_qgroup *bq,
904 struct btrfs_qgroup_comparer_set *comp_set)
906 struct rb_node **p = &sort_tree->root.rb_node;
907 struct rb_node *parent = NULL;
908 struct btrfs_qgroup *curr;
913 curr = rb_entry(parent, struct btrfs_qgroup, sort_node);
915 ret = sort_comp(bq, curr, comp_set);
923 rb_link_node(&bq->sort_node, parent, p);
924 rb_insert_color(&bq->sort_node, &sort_tree->root);
928 static void __update_columns_max_len(struct btrfs_qgroup *bq,
929 enum btrfs_qgroup_column_enum column)
931 struct btrfs_qgroup_list *list = NULL;
934 unsigned unit_mode = btrfs_qgroup_columns[column].unit_mode;
936 ASSERT(0 <= column && column < BTRFS_QGROUP_ALL);
940 case BTRFS_QGROUP_QGROUPID:
941 sprintf(tmp, "%llu/%llu",
942 btrfs_qgroup_level(bq->qgroupid),
943 btrfs_qgroup_subvid(bq->qgroupid));
945 if (btrfs_qgroup_columns[column].max_len < len)
946 btrfs_qgroup_columns[column].max_len = len;
948 case BTRFS_QGROUP_RFER:
949 len = strlen(pretty_size_mode(bq->rfer, unit_mode));
950 if (btrfs_qgroup_columns[column].max_len < len)
951 btrfs_qgroup_columns[column].max_len = len;
953 case BTRFS_QGROUP_EXCL:
954 len = strlen(pretty_size_mode(bq->excl, unit_mode));
955 if (btrfs_qgroup_columns[column].max_len < len)
956 btrfs_qgroup_columns[column].max_len = len;
958 case BTRFS_QGROUP_MAX_RFER:
959 len = strlen(pretty_size_mode(bq->max_rfer, unit_mode));
960 if (btrfs_qgroup_columns[column].max_len < len)
961 btrfs_qgroup_columns[column].max_len = len;
963 case BTRFS_QGROUP_MAX_EXCL:
964 len = strlen(pretty_size_mode(bq->max_excl, unit_mode));
965 if (btrfs_qgroup_columns[column].max_len < len)
966 btrfs_qgroup_columns[column].max_len = len;
968 case BTRFS_QGROUP_PARENT:
970 list_for_each_entry(list, &bq->qgroups, next_qgroup) {
971 len += sprintf(tmp, "%llu/%llu",
972 btrfs_qgroup_level(list->qgroup->qgroupid),
973 btrfs_qgroup_subvid(list->qgroup->qgroupid));
974 if (!list_is_last(&list->next_qgroup, &bq->qgroups))
977 if (btrfs_qgroup_columns[column].max_len < len)
978 btrfs_qgroup_columns[column].max_len = len;
980 case BTRFS_QGROUP_CHILD:
982 list_for_each_entry(list, &bq->members, next_member) {
983 len += sprintf(tmp, "%llu/%llu",
984 btrfs_qgroup_level(list->member->qgroupid),
985 btrfs_qgroup_subvid(list->member->qgroupid));
986 if (!list_is_last(&list->next_member, &bq->members))
989 if (btrfs_qgroup_columns[column].max_len < len)
990 btrfs_qgroup_columns[column].max_len = len;
998 static void update_columns_max_len(struct btrfs_qgroup *bq)
1002 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
1003 if (!btrfs_qgroup_columns[i].need_print)
1005 __update_columns_max_len(bq, i);
1009 static void __filter_and_sort_qgroups(struct qgroup_lookup *all_qgroups,
1010 struct qgroup_lookup *sort_tree,
1011 struct btrfs_qgroup_filter_set *filter_set,
1012 struct btrfs_qgroup_comparer_set *comp_set)
1015 struct btrfs_qgroup *entry;
1018 qgroup_lookup_init(sort_tree);
1019 pre_process_filter_set(all_qgroups, filter_set);
1021 n = rb_last(&all_qgroups->root);
1023 entry = rb_entry(n, struct btrfs_qgroup, rb_node);
1025 ret = filter_qgroup(entry, filter_set);
1027 sort_tree_insert(sort_tree, entry, comp_set);
1029 update_columns_max_len(entry);
1035 static inline void print_status_flag_warning(u64 flags)
1037 if (!(flags & BTRFS_QGROUP_STATUS_FLAG_ON))
1039 "WARNING: Quota disabled, qgroup data may be out of date\n");
1040 else if (flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
1042 "WARNING: Rescan is running, qgroup data may be incorrect\n");
1043 else if (flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT)
1045 "WARNING: Qgroup data inconsistent, rescan recommended\n");
1048 static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup)
1051 struct btrfs_ioctl_search_args args;
1052 struct btrfs_ioctl_search_key *sk = &args.key;
1053 struct btrfs_ioctl_search_header *sh;
1054 unsigned long off = 0;
1056 struct btrfs_qgroup_info_item *info;
1057 struct btrfs_qgroup_limit_item *limit;
1058 struct btrfs_qgroup *bq;
1059 struct btrfs_qgroup *bq1;
1066 memset(&args, 0, sizeof(args));
1068 sk->tree_id = BTRFS_QUOTA_TREE_OBJECTID;
1069 sk->max_type = BTRFS_QGROUP_RELATION_KEY;
1070 sk->min_type = BTRFS_QGROUP_STATUS_KEY;
1071 sk->max_objectid = (u64)-1;
1072 sk->max_offset = (u64)-1;
1073 sk->max_transid = (u64)-1;
1074 sk->nr_items = 4096;
1076 qgroup_lookup_init(qgroup_lookup);
1079 ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
1082 "ERROR: can't perform the search - %s\n",
1086 /* the ioctl returns the number of item it found in nr_items */
1087 if (sk->nr_items == 0)
1092 * for each item, pull the key out of the header and then
1093 * read the root_ref item it contains
1095 for (i = 0; i < sk->nr_items; i++) {
1096 sh = (struct btrfs_ioctl_search_header *)(args.buf +
1100 if (btrfs_search_header_type(sh)
1101 == BTRFS_QGROUP_STATUS_KEY) {
1102 struct btrfs_qgroup_status_item *si;
1105 si = (struct btrfs_qgroup_status_item *)
1107 flags = btrfs_stack_qgroup_status_flags(si);
1108 print_status_flag_warning(flags);
1109 } else if (btrfs_search_header_type(sh)
1110 == BTRFS_QGROUP_INFO_KEY) {
1111 info = (struct btrfs_qgroup_info_item *)
1113 a1 = btrfs_stack_qgroup_info_generation(info);
1114 a2 = btrfs_stack_qgroup_info_referenced(info);
1116 btrfs_stack_qgroup_info_referenced_compressed
1118 a4 = btrfs_stack_qgroup_info_exclusive(info);
1120 btrfs_stack_qgroup_info_exclusive_compressed
1122 add_qgroup(qgroup_lookup,
1123 btrfs_search_header_offset(sh), a1,
1124 a2, a3, a4, a5, 0, 0, 0, 0, 0, NULL,
1126 } else if (btrfs_search_header_type(sh)
1127 == BTRFS_QGROUP_LIMIT_KEY) {
1128 limit = (struct btrfs_qgroup_limit_item *)
1131 a1 = btrfs_stack_qgroup_limit_flags(limit);
1132 a2 = btrfs_stack_qgroup_limit_max_referenced
1134 a3 = btrfs_stack_qgroup_limit_max_exclusive
1136 a4 = btrfs_stack_qgroup_limit_rsv_referenced
1138 a5 = btrfs_stack_qgroup_limit_rsv_exclusive
1140 add_qgroup(qgroup_lookup,
1141 btrfs_search_header_offset(sh), 0,
1142 0, 0, 0, 0, a1, a2, a3, a4, a5,
1144 } else if (btrfs_search_header_type(sh)
1145 == BTRFS_QGROUP_RELATION_KEY) {
1146 if (btrfs_search_header_offset(sh)
1147 < btrfs_search_header_objectid(sh))
1149 bq = qgroup_tree_search(qgroup_lookup,
1150 btrfs_search_header_offset(sh));
1153 bq1 = qgroup_tree_search(qgroup_lookup,
1154 btrfs_search_header_objectid(sh));
1157 add_qgroup(qgroup_lookup,
1158 btrfs_search_header_offset(sh), 0,
1159 0, 0, 0, 0, 0, 0, 0, 0, 0, bq, bq1);
1163 off += btrfs_search_header_len(sh);
1166 * record the mins in sk so we can make sure the
1167 * next search doesn't repeat this root
1169 sk->min_type = btrfs_search_header_type(sh);
1170 sk->min_offset = btrfs_search_header_offset(sh);
1171 sk->min_objectid = btrfs_search_header_objectid(sh);
1173 sk->nr_items = 4096;
1175 * this iteration is done, step forward one qgroup for the next
1178 if (sk->min_offset < (u64)-1)
1188 static void print_all_qgroups(struct qgroup_lookup *qgroup_lookup)
1192 struct btrfs_qgroup *entry;
1196 n = rb_first(&qgroup_lookup->root);
1198 entry = rb_entry(n, struct btrfs_qgroup, sort_node);
1199 print_single_qgroup_table(entry);
1204 int btrfs_show_qgroups(int fd,
1205 struct btrfs_qgroup_filter_set *filter_set,
1206 struct btrfs_qgroup_comparer_set *comp_set)
1209 struct qgroup_lookup qgroup_lookup;
1210 struct qgroup_lookup sort_tree;
1213 ret = __qgroups_search(fd, &qgroup_lookup);
1216 __filter_and_sort_qgroups(&qgroup_lookup, &sort_tree,
1217 filter_set, comp_set);
1218 print_all_qgroups(&sort_tree);
1220 __free_all_qgroups(&qgroup_lookup);
1221 btrfs_qgroup_free_filter_set(filter_set);
1222 btrfs_qgroup_free_comparer_set(comp_set);
1226 u64 btrfs_get_path_rootid(int fd)
1229 struct btrfs_ioctl_ino_lookup_args args;
1231 memset(&args, 0, sizeof(args));
1232 args.objectid = BTRFS_FIRST_FREE_OBJECTID;
1234 ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
1237 "ERROR: can't perform the search - %s\n",
1244 int btrfs_qgroup_parse_sort_string(char *opt_arg,
1245 struct btrfs_qgroup_comparer_set **comps)
1253 while ((p = strtok(opt_arg, ",")) != NULL) {
1255 ptr_argv = all_sort_items;
1258 if (strcmp(*ptr_argv, p) == 0) {
1263 if (strcmp(*ptr_argv, p) == 0) {
1280 } else if (*p == '-') {
1286 what_to_sort = btrfs_qgroup_get_sort_item(p);
1287 if (what_to_sort < 0)
1289 btrfs_qgroup_setup_comparer(comps, what_to_sort, order);
1297 int qgroup_inherit_size(struct btrfs_qgroup_inherit *p)
1299 return sizeof(*p) + sizeof(p->qgroups[0]) *
1300 (p->num_qgroups + 2 * p->num_ref_copies +
1301 2 * p->num_excl_copies);
1305 qgroup_inherit_realloc(struct btrfs_qgroup_inherit **inherit, int n, int pos)
1307 struct btrfs_qgroup_inherit *out;
1311 nitems = (*inherit)->num_qgroups +
1312 (*inherit)->num_ref_copies +
1313 (*inherit)->num_excl_copies;
1316 out = calloc(sizeof(*out) + sizeof(out->qgroups[0]) * (nitems + n), 1);
1318 fprintf(stderr, "ERROR: Not enough memory\n");
1323 struct btrfs_qgroup_inherit *i = *inherit;
1324 int s = sizeof(out->qgroups[0]);
1326 out->num_qgroups = i->num_qgroups;
1327 out->num_ref_copies = i->num_ref_copies;
1328 out->num_excl_copies = i->num_excl_copies;
1329 memcpy(out->qgroups, i->qgroups, pos * s);
1330 memcpy(out->qgroups + pos + n, i->qgroups + pos,
1331 (nitems - pos) * s);
1339 int qgroup_inherit_add_group(struct btrfs_qgroup_inherit **inherit, char *arg)
1342 u64 qgroupid = parse_qgroupid(arg);
1345 if (qgroupid == 0) {
1346 fprintf(stderr, "ERROR: bad qgroup specification\n");
1351 pos = (*inherit)->num_qgroups;
1352 ret = qgroup_inherit_realloc(inherit, 1, pos);
1356 (*inherit)->qgroups[(*inherit)->num_qgroups++] = qgroupid;
1361 int qgroup_inherit_add_copy(struct btrfs_qgroup_inherit **inherit, char *arg,
1370 p = strchr(arg, ':');
1373 fprintf(stderr, "ERROR: bad copy specification\n");
1377 qgroup_src = parse_qgroupid(arg);
1378 qgroup_dst = parse_qgroupid(p + 1);
1381 if (!qgroup_src || !qgroup_dst)
1385 pos = (*inherit)->num_qgroups +
1386 (*inherit)->num_ref_copies * 2 * type;
1388 ret = qgroup_inherit_realloc(inherit, 2, pos);
1392 (*inherit)->qgroups[pos++] = qgroup_src;
1393 (*inherit)->qgroups[pos++] = qgroup_dst;
1396 ++(*inherit)->num_ref_copies;
1398 ++(*inherit)->num_excl_copies;