X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=qgroup.c;h=f17fdaeeb986252616078aca5c67516c5b47231a;hb=ae60006cee1c15f87adee22d4595384ea5ab596b;hp=f9eb52dcc7710fed7eef207536ab3cdbe38d7562;hpb=0944502866628d6b31fb628108c3811465940760;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/qgroup.c b/qgroup.c index f9eb52d..f17fdae 100644 --- a/qgroup.c +++ b/qgroup.c @@ -20,6 +20,11 @@ #include #include "ctree.h" #include "ioctl.h" +#include "utils.h" +#include + +#define BTRFS_QGROUP_NFILTERS_INCREASE (2 * BTRFS_QGROUP_FILTER_MAX) +#define BTRFS_QGROUP_NCOMPS_INCREASE (2 * BTRFS_QGROUP_COMP_MAX) struct qgroup_lookup { struct rb_root root; @@ -27,6 +32,12 @@ struct qgroup_lookup { struct btrfs_qgroup { struct rb_node rb_node; + struct rb_node sort_node; + /* + *all_parent_node is used to + *filter a qgroup's all parent + */ + struct rb_node all_parent_node; u64 qgroupid; /* @@ -67,47 +78,72 @@ struct btrfs_qgroup_list { /* * qgroupid,rfer,excl default to set */ -struct { +static struct { char *name; char *column_name; int need_print; + unsigned unit_mode; + int max_len; } btrfs_qgroup_columns[] = { { .name = "qgroupid", .column_name = "Qgroupid", .need_print = 1, + .unit_mode = 0, + .max_len = 8, }, { .name = "rfer", .column_name = "Rfer", .need_print = 1, + .unit_mode = UNITS_DEFAULT, + .max_len = 12, }, { .name = "excl", .column_name = "Excl", .need_print = 1, + .unit_mode = UNITS_DEFAULT, + .max_len = 12, }, { .name = "max_rfer", .column_name = "Max_rfer", .need_print = 0, + .unit_mode = UNITS_DEFAULT, + .max_len = 12, + }, + { + .name = "max_excl", + .column_name = "Max_excl", + .need_print = 0, + .unit_mode = UNITS_DEFAULT, + .max_len = 12, }, { .name = "parent", .column_name = "Parent", .need_print = 0, + .unit_mode = 0, + .max_len = 7, }, { .name = "child", .column_name = "Child", .need_print = 0, + .unit_mode = 0, + .max_len = 5, }, { .name = NULL, .column_name = NULL, .need_print = 0, + .unit_mode = 0, }, }; +static btrfs_qgroup_filter_func all_filter_funcs[]; +static btrfs_qgroup_comp_func all_comp_funcs[]; + void btrfs_qgroup_setup_print_column(enum btrfs_qgroup_column_enum column) { int i; @@ -122,66 +158,106 @@ void btrfs_qgroup_setup_print_column(enum btrfs_qgroup_column_enum column) btrfs_qgroup_columns[i].need_print = 1; } -static void print_parent_column(struct btrfs_qgroup *qgroup) +void btrfs_qgroup_setup_units(unsigned unit_mode) +{ + btrfs_qgroup_columns[BTRFS_QGROUP_RFER].unit_mode = unit_mode; + btrfs_qgroup_columns[BTRFS_QGROUP_EXCL].unit_mode = unit_mode; + btrfs_qgroup_columns[BTRFS_QGROUP_MAX_RFER].unit_mode = unit_mode; + btrfs_qgroup_columns[BTRFS_QGROUP_MAX_EXCL].unit_mode = unit_mode; +} + +static int print_parent_column(struct btrfs_qgroup *qgroup) { struct btrfs_qgroup_list *list = NULL; + int len = 0; list_for_each_entry(list, &qgroup->qgroups, next_qgroup) { - printf("%llu/%llu", (list->qgroup)->qgroupid >> 48, - ((1ll << 48) - 1) & (list->qgroup)->qgroupid); + len += printf("%llu/%llu", + btrfs_qgroup_level(list->qgroup->qgroupid), + btrfs_qgroup_subvid(list->qgroup->qgroupid)); if (!list_is_last(&list->next_qgroup, &qgroup->qgroups)) - printf(","); + len += printf(","); } if (list_empty(&qgroup->qgroups)) - printf("---"); + len += printf("---"); + + return len; } -static void print_child_column(struct btrfs_qgroup *qgroup) +static int print_child_column(struct btrfs_qgroup *qgroup) { struct btrfs_qgroup_list *list = NULL; + int len = 0; list_for_each_entry(list, &qgroup->members, next_member) { - printf("%llu/%llu", (list->member)->qgroupid >> 48, - ((1ll << 48) - 1) & (list->member)->qgroupid); + len += printf("%llu/%llu", + btrfs_qgroup_level(list->member->qgroupid), + btrfs_qgroup_subvid(list->member->qgroupid)); if (!list_is_last(&list->next_member, &qgroup->members)) - printf(","); + len += printf(","); } if (list_empty(&qgroup->members)) - printf("---"); + len += printf("---"); + + return len; +} + +static void print_qgroup_column_add_blank(enum btrfs_qgroup_column_enum column, + int len) +{ + len = btrfs_qgroup_columns[column].max_len - len; + while (len--) + printf(" "); } static void print_qgroup_column(struct btrfs_qgroup *qgroup, enum btrfs_qgroup_column_enum column) { BUG_ON(column >= BTRFS_QGROUP_ALL || column < 0); + int len; + int unit_mode = btrfs_qgroup_columns[column].unit_mode; + int max_len = btrfs_qgroup_columns[column].max_len; switch (column) { case BTRFS_QGROUP_QGROUPID: - printf("%llu/%llu", qgroup->qgroupid >> 48, - ((1ll << 48) - 1) & qgroup->qgroupid); + len = printf("%llu/%llu", + btrfs_qgroup_level(qgroup->qgroupid), + btrfs_qgroup_subvid(qgroup->qgroupid)); + print_qgroup_column_add_blank(BTRFS_QGROUP_QGROUPID, len); break; case BTRFS_QGROUP_RFER: - printf("%lld", qgroup->rfer); + len = printf("%*s", max_len, pretty_size_mode(qgroup->rfer, unit_mode)); break; case BTRFS_QGROUP_EXCL: - printf("%lld", qgroup->excl); + len = printf("%*s", max_len, pretty_size_mode(qgroup->excl, unit_mode)); break; case BTRFS_QGROUP_PARENT: - print_parent_column(qgroup); + len = print_parent_column(qgroup); + print_qgroup_column_add_blank(BTRFS_QGROUP_PARENT, len); break; case BTRFS_QGROUP_MAX_RFER: - printf("%llu", qgroup->max_rfer); + if (qgroup->flags & BTRFS_QGROUP_LIMIT_MAX_RFER) + len = printf("%*s", max_len, pretty_size_mode(qgroup->max_rfer, unit_mode)); + else + len = printf("%*s", max_len, "none"); + break; + case BTRFS_QGROUP_MAX_EXCL: + if (qgroup->flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) + len = printf("%*s", max_len, pretty_size_mode(qgroup->max_excl, unit_mode)); + else + len = printf("%*s", max_len, "none"); break; case BTRFS_QGROUP_CHILD: - print_child_column(qgroup); + len = print_child_column(qgroup); + print_qgroup_column_add_blank(BTRFS_QGROUP_CHILD, len); break; default: break; } } -static void print_single_qgroup_default(struct btrfs_qgroup *qgroup) +static void print_single_qgroup_table(struct btrfs_qgroup *qgroup) { int i; @@ -190,12 +266,55 @@ static void print_single_qgroup_default(struct btrfs_qgroup *qgroup) continue; print_qgroup_column(qgroup, i); - if (i != BTRFS_QGROUP_ALL - 1) + if (i != BTRFS_QGROUP_CHILD) printf(" "); } printf("\n"); } +static void print_table_head(void) +{ + int i; + int len; + int max_len; + + for (i = 0; i < BTRFS_QGROUP_ALL; i++) { + max_len = btrfs_qgroup_columns[i].max_len; + if (!btrfs_qgroup_columns[i].need_print) + continue; + if ((i == BTRFS_QGROUP_QGROUPID) | (i == BTRFS_QGROUP_PARENT) | + (i == BTRFS_QGROUP_CHILD)) + printf("%-*s", max_len, btrfs_qgroup_columns[i].name); + else + printf("%*s", max_len, btrfs_qgroup_columns[i].name); + printf(" "); + } + printf("\n"); + for (i = 0; i < BTRFS_QGROUP_ALL; i++) { + max_len = btrfs_qgroup_columns[i].max_len; + if (!btrfs_qgroup_columns[i].need_print) + continue; + if ((i == BTRFS_QGROUP_QGROUPID) | (i == BTRFS_QGROUP_PARENT) | + (i == BTRFS_QGROUP_CHILD)) { + len = strlen(btrfs_qgroup_columns[i].name); + while (len--) + printf("-"); + len = max_len - strlen(btrfs_qgroup_columns[i].name); + while (len--) + printf(" "); + } else { + len = max_len - strlen(btrfs_qgroup_columns[i].name); + while (len--) + printf(" "); + len = strlen(btrfs_qgroup_columns[i].name); + while (len--) + printf("-"); + } + printf(" "); + } + printf("\n"); +} + static void qgroup_lookup_init(struct qgroup_lookup *tree) { tree->root.rb_node = NULL; @@ -218,6 +337,191 @@ static int comp_entry_with_qgroupid(struct btrfs_qgroup *entry1, return is_descending ? -ret : ret; } +static int comp_entry_with_rfer(struct btrfs_qgroup *entry1, + struct btrfs_qgroup *entry2, + int is_descending) +{ + int ret; + + if (entry1->rfer > entry2->rfer) + ret = 1; + else if (entry1->rfer < entry2->rfer) + ret = -1; + else + ret = 0; + + return is_descending ? -ret : ret; +} + +static int comp_entry_with_excl(struct btrfs_qgroup *entry1, + struct btrfs_qgroup *entry2, + int is_descending) +{ + int ret; + + if (entry1->excl > entry2->excl) + ret = 1; + else if (entry1->excl < entry2->excl) + ret = -1; + else + ret = 0; + + return is_descending ? -ret : ret; +} + +static int comp_entry_with_max_rfer(struct btrfs_qgroup *entry1, + struct btrfs_qgroup *entry2, + int is_descending) +{ + int ret; + + if (entry1->max_rfer > entry2->max_rfer) + ret = 1; + else if (entry1->max_rfer < entry2->max_rfer) + ret = -1; + else + ret = 0; + + return is_descending ? -ret : ret; +} + +static int comp_entry_with_max_excl(struct btrfs_qgroup *entry1, + struct btrfs_qgroup *entry2, + int is_descending) +{ + int ret; + + if (entry1->max_excl > entry2->max_excl) + ret = 1; + else if (entry1->max_excl < entry2->max_excl) + ret = -1; + else + ret = 0; + + return is_descending ? -ret : ret; +} + +static btrfs_qgroup_comp_func all_comp_funcs[] = { + [BTRFS_QGROUP_COMP_QGROUPID] = comp_entry_with_qgroupid, + [BTRFS_QGROUP_COMP_RFER] = comp_entry_with_rfer, + [BTRFS_QGROUP_COMP_EXCL] = comp_entry_with_excl, + [BTRFS_QGROUP_COMP_MAX_RFER] = comp_entry_with_max_rfer, + [BTRFS_QGROUP_COMP_MAX_EXCL] = comp_entry_with_max_excl +}; + +static char *all_sort_items[] = { + [BTRFS_QGROUP_COMP_QGROUPID] = "qgroupid", + [BTRFS_QGROUP_COMP_RFER] = "rfer", + [BTRFS_QGROUP_COMP_EXCL] = "excl", + [BTRFS_QGROUP_COMP_MAX_RFER] = "max_rfer", + [BTRFS_QGROUP_COMP_MAX_EXCL] = "max_excl", + [BTRFS_QGROUP_COMP_MAX] = NULL, +}; + +static int btrfs_qgroup_get_sort_item(char *sort_name) +{ + int i; + + for (i = 0; i < BTRFS_QGROUP_COMP_MAX; i++) { + if (strcmp(sort_name, all_sort_items[i]) == 0) + return i; + } + return -1; +} + +struct btrfs_qgroup_comparer_set *btrfs_qgroup_alloc_comparer_set(void) +{ + struct btrfs_qgroup_comparer_set *set; + int size; + size = sizeof(struct btrfs_qgroup_comparer_set) + + BTRFS_QGROUP_NCOMPS_INCREASE * + sizeof(struct btrfs_qgroup_comparer); + set = calloc(1, size); + if (!set) { + fprintf(stderr, "memory allocation failed\n"); + exit(1); + } + + set->total = BTRFS_QGROUP_NCOMPS_INCREASE; + + return set; +} + +void btrfs_qgroup_free_comparer_set(struct btrfs_qgroup_comparer_set *comp_set) +{ + free(comp_set); +} + +int btrfs_qgroup_setup_comparer(struct btrfs_qgroup_comparer_set **comp_set, + enum btrfs_qgroup_comp_enum comparer, + int is_descending) +{ + struct btrfs_qgroup_comparer_set *set = *comp_set; + int size; + + BUG_ON(!set); + BUG_ON(comparer >= BTRFS_QGROUP_COMP_MAX); + BUG_ON(set->ncomps > set->total); + + if (set->ncomps == set->total) { + void *tmp; + + size = set->total + BTRFS_QGROUP_NCOMPS_INCREASE; + size = sizeof(*set) + + size * sizeof(struct btrfs_qgroup_comparer); + tmp = set; + set = realloc(set, size); + if (!set) { + fprintf(stderr, "memory allocation failed\n"); + free(tmp); + exit(1); + } + + memset(&set->comps[set->total], 0, + BTRFS_QGROUP_NCOMPS_INCREASE * + sizeof(struct btrfs_qgroup_comparer)); + set->total += BTRFS_QGROUP_NCOMPS_INCREASE; + *comp_set = set; + } + + BUG_ON(set->comps[set->ncomps].comp_func); + + set->comps[set->ncomps].comp_func = all_comp_funcs[comparer]; + set->comps[set->ncomps].is_descending = is_descending; + set->ncomps++; + return 0; +} + +static int sort_comp(struct btrfs_qgroup *entry1, struct btrfs_qgroup *entry2, + struct btrfs_qgroup_comparer_set *set) +{ + int qgroupid_compared = 0; + int i, ret = 0; + + if (!set || !set->ncomps) + goto comp_qgroupid; + + for (i = 0; i < set->ncomps; i++) { + if (!set->comps[i].comp_func) + break; + + ret = set->comps[i].comp_func(entry1, entry2, + set->comps[i].is_descending); + if (ret) + return ret; + + if (set->comps[i].comp_func == comp_entry_with_qgroupid) + qgroupid_compared = 1; + } + + if (!qgroupid_compared) { +comp_qgroupid: + ret = comp_entry_with_qgroupid(entry1, entry2, 0); + } + + return ret; +} + /* * insert a new root into the tree. returns the existing root entry * if one is already there. qgroupid is used @@ -339,12 +643,11 @@ static int add_qgroup(struct qgroup_lookup *qgroup_lookup, u64 qgroupid, if (!ret) return 0; - bq = malloc(sizeof(*bq)); + bq = calloc(1, sizeof(*bq)); if (!bq) { printf("memory allocation failed\n"); exit(1); } - memset(bq, 0, sizeof(*bq)); if (qgroupid) { bq->qgroupid = qgroupid; INIT_LIST_HEAD(&bq->qgroups); @@ -388,7 +691,7 @@ static int add_qgroup(struct qgroup_lookup *qgroup_lookup, u64 qgroupid, return ret; } -void __free_btrfs_qgroup(struct btrfs_qgroup *bq) +static void __free_btrfs_qgroup(struct btrfs_qgroup *bq) { struct btrfs_qgroup_list *list; while (!list_empty(&bq->qgroups)) { @@ -410,7 +713,7 @@ void __free_btrfs_qgroup(struct btrfs_qgroup *bq) free(bq); } -void __free_all_qgroups(struct qgroup_lookup *root_tree) +static void __free_all_qgroups(struct qgroup_lookup *root_tree) { struct btrfs_qgroup *entry; struct rb_node *n; @@ -425,6 +728,320 @@ void __free_all_qgroups(struct qgroup_lookup *root_tree) } } +static int filter_all_parent_insert(struct qgroup_lookup *sort_tree, + struct btrfs_qgroup *bq) +{ + struct rb_node **p = &sort_tree->root.rb_node; + struct rb_node *parent = NULL; + struct btrfs_qgroup *curr; + int ret; + + while (*p) { + parent = *p; + curr = rb_entry(parent, struct btrfs_qgroup, all_parent_node); + + ret = comp_entry_with_qgroupid(bq, curr, 0); + if (ret < 0) + p = &(*p)->rb_left; + else if (ret > 0) + p = &(*p)->rb_right; + else + return -EEXIST; + } + rb_link_node(&bq->all_parent_node, parent, p); + rb_insert_color(&bq->all_parent_node, &sort_tree->root); + return 0; +} + +static int filter_by_parent(struct btrfs_qgroup *bq, u64 data) +{ + struct btrfs_qgroup *qgroup = + (struct btrfs_qgroup *)(unsigned long)data; + + if (data == 0) + return 0; + if (qgroup->qgroupid == bq->qgroupid) + return 1; + return 0; +} + +static int filter_by_all_parent(struct btrfs_qgroup *bq, u64 data) +{ + struct qgroup_lookup lookup; + struct qgroup_lookup *ql = &lookup; + struct btrfs_qgroup_list *list; + struct rb_node *n; + struct btrfs_qgroup *qgroup = + (struct btrfs_qgroup *)(unsigned long)data; + + if (data == 0) + return 0; + if (bq->qgroupid == qgroup->qgroupid) + return 1; + + qgroup_lookup_init(ql); + filter_all_parent_insert(ql, qgroup); + n = rb_first(&ql->root); + while (n) { + qgroup = rb_entry(n, struct btrfs_qgroup, all_parent_node); + if (!list_empty(&qgroup->qgroups)) { + list_for_each_entry(list, &qgroup->qgroups, + next_qgroup) { + if ((list->qgroup)->qgroupid == bq->qgroupid) + return 1; + filter_all_parent_insert(ql, list->qgroup); + } + } + rb_erase(n, &ql->root); + n = rb_first(&ql->root); + } + return 0; +} + +static btrfs_qgroup_filter_func all_filter_funcs[] = { + [BTRFS_QGROUP_FILTER_PARENT] = filter_by_parent, + [BTRFS_QGROUP_FILTER_ALL_PARENT] = filter_by_all_parent, +}; + +struct btrfs_qgroup_filter_set *btrfs_qgroup_alloc_filter_set(void) +{ + struct btrfs_qgroup_filter_set *set; + int size; + + size = sizeof(struct btrfs_qgroup_filter_set) + + BTRFS_QGROUP_NFILTERS_INCREASE * + sizeof(struct btrfs_qgroup_filter); + set = calloc(1, size); + if (!set) { + fprintf(stderr, "memory allocation failed\n"); + exit(1); + } + set->total = BTRFS_QGROUP_NFILTERS_INCREASE; + + return set; +} + +void btrfs_qgroup_free_filter_set(struct btrfs_qgroup_filter_set *filter_set) +{ + free(filter_set); +} + +int btrfs_qgroup_setup_filter(struct btrfs_qgroup_filter_set **filter_set, + enum btrfs_qgroup_filter_enum filter, u64 data) +{ + struct btrfs_qgroup_filter_set *set = *filter_set; + int size; + + BUG_ON(!set); + BUG_ON(filter >= BTRFS_QGROUP_FILTER_MAX); + BUG_ON(set->nfilters > set->total); + + if (set->nfilters == set->total) { + void *tmp; + + size = set->total + BTRFS_QGROUP_NFILTERS_INCREASE; + size = sizeof(*set) + size * sizeof(struct btrfs_qgroup_filter); + + tmp = set; + set = realloc(set, size); + if (!set) { + fprintf(stderr, "memory allocation failed\n"); + free(tmp); + exit(1); + } + memset(&set->filters[set->total], 0, + BTRFS_QGROUP_NFILTERS_INCREASE * + sizeof(struct btrfs_qgroup_filter)); + set->total += BTRFS_QGROUP_NFILTERS_INCREASE; + *filter_set = set; + } + BUG_ON(set->filters[set->nfilters].filter_func); + set->filters[set->nfilters].filter_func = all_filter_funcs[filter]; + set->filters[set->nfilters].data = data; + set->nfilters++; + return 0; +} + +static int filter_qgroup(struct btrfs_qgroup *bq, + struct btrfs_qgroup_filter_set *set) +{ + int i, ret; + + if (!set || !set->nfilters) + return 1; + for (i = 0; i < set->nfilters; i++) { + if (!set->filters[i].filter_func) + break; + ret = set->filters[i].filter_func(bq, set->filters[i].data); + if (!ret) + return 0; + } + return 1; +} + +static void pre_process_filter_set(struct qgroup_lookup *lookup, + struct btrfs_qgroup_filter_set *set) +{ + int i; + struct btrfs_qgroup *qgroup_for_filter = NULL; + + for (i = 0; i < set->nfilters; i++) { + + if (set->filters[i].filter_func == filter_by_all_parent + || set->filters[i].filter_func == filter_by_parent) { + qgroup_for_filter = qgroup_tree_search(lookup, + set->filters[i].data); + set->filters[i].data = + (u64)(unsigned long)qgroup_for_filter; + } + } +} + +static int sort_tree_insert(struct qgroup_lookup *sort_tree, + struct btrfs_qgroup *bq, + struct btrfs_qgroup_comparer_set *comp_set) +{ + struct rb_node **p = &sort_tree->root.rb_node; + struct rb_node *parent = NULL; + struct btrfs_qgroup *curr; + int ret; + + while (*p) { + parent = *p; + curr = rb_entry(parent, struct btrfs_qgroup, sort_node); + + ret = sort_comp(bq, curr, comp_set); + if (ret < 0) + p = &(*p)->rb_left; + else if (ret > 0) + p = &(*p)->rb_right; + else + return -EEXIST; + } + rb_link_node(&bq->sort_node, parent, p); + rb_insert_color(&bq->sort_node, &sort_tree->root); + return 0; +} + +static void __update_columns_max_len(struct btrfs_qgroup *bq, + enum btrfs_qgroup_column_enum column) +{ + BUG_ON(column >= BTRFS_QGROUP_ALL || column < 0); + struct btrfs_qgroup_list *list = NULL; + char tmp[100]; + int len; + unsigned unit_mode = btrfs_qgroup_columns[column].unit_mode; + + switch (column) { + + case BTRFS_QGROUP_QGROUPID: + sprintf(tmp, "%llu/%llu", + btrfs_qgroup_level(bq->qgroupid), + btrfs_qgroup_subvid(bq->qgroupid)); + len = strlen(tmp); + if (btrfs_qgroup_columns[column].max_len < len) + btrfs_qgroup_columns[column].max_len = len; + break; + case BTRFS_QGROUP_RFER: + len = strlen(pretty_size_mode(bq->rfer, unit_mode)); + if (btrfs_qgroup_columns[column].max_len < len) + btrfs_qgroup_columns[column].max_len = len; + break; + case BTRFS_QGROUP_EXCL: + len = strlen(pretty_size_mode(bq->excl, unit_mode)); + if (btrfs_qgroup_columns[column].max_len < len) + btrfs_qgroup_columns[column].max_len = len; + break; + case BTRFS_QGROUP_MAX_RFER: + len = strlen(pretty_size_mode(bq->max_rfer, unit_mode)); + if (btrfs_qgroup_columns[column].max_len < len) + btrfs_qgroup_columns[column].max_len = len; + break; + case BTRFS_QGROUP_MAX_EXCL: + len = strlen(pretty_size_mode(bq->max_excl, unit_mode)); + if (btrfs_qgroup_columns[column].max_len < len) + btrfs_qgroup_columns[column].max_len = len; + break; + case BTRFS_QGROUP_PARENT: + len = 0; + list_for_each_entry(list, &bq->qgroups, next_qgroup) { + len += sprintf(tmp, "%llu/%llu", + btrfs_qgroup_level(list->qgroup->qgroupid), + btrfs_qgroup_subvid(list->qgroup->qgroupid)); + if (!list_is_last(&list->next_qgroup, &bq->qgroups)) + len += 1; + } + if (btrfs_qgroup_columns[column].max_len < len) + btrfs_qgroup_columns[column].max_len = len; + break; + case BTRFS_QGROUP_CHILD: + len = 0; + list_for_each_entry(list, &bq->members, next_member) { + len += sprintf(tmp, "%llu/%llu", + btrfs_qgroup_level(list->member->qgroupid), + btrfs_qgroup_subvid(list->member->qgroupid)); + if (!list_is_last(&list->next_member, &bq->members)) + len += 1; + } + if (btrfs_qgroup_columns[column].max_len < len) + btrfs_qgroup_columns[column].max_len = len; + break; + default: + break; + } + +} + +static void update_columns_max_len(struct btrfs_qgroup *bq) +{ + int i; + + for (i = 0; i < BTRFS_QGROUP_ALL; i++) { + if (!btrfs_qgroup_columns[i].need_print) + continue; + __update_columns_max_len(bq, i); + } +} + +static void __filter_and_sort_qgroups(struct qgroup_lookup *all_qgroups, + struct qgroup_lookup *sort_tree, + struct btrfs_qgroup_filter_set *filter_set, + struct btrfs_qgroup_comparer_set *comp_set) +{ + struct rb_node *n; + struct btrfs_qgroup *entry; + int ret; + + qgroup_lookup_init(sort_tree); + pre_process_filter_set(all_qgroups, filter_set); + + n = rb_last(&all_qgroups->root); + while (n) { + entry = rb_entry(n, struct btrfs_qgroup, rb_node); + + ret = filter_qgroup(entry, filter_set); + if (ret) { + sort_tree_insert(sort_tree, entry, comp_set); + + update_columns_max_len(entry); + } + n = rb_prev(n); + } +} + +static inline void print_status_flag_warning(u64 flags) +{ + if (!(flags & BTRFS_QGROUP_STATUS_FLAG_ON)) + fprintf(stderr, + "WARNING: Quota disabled, qgroup data may be out of date\n"); + else if (flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) + fprintf(stderr, + "WARNING: Rescan is running, qgroup data may be incorrect\n"); + else if (flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) + fprintf(stderr, + "WARNING: Qgroup data inconsistent, rescan recommended\n"); +} + static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup) { int ret; @@ -433,7 +1050,6 @@ static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup) struct btrfs_ioctl_search_header *sh; unsigned long off = 0; unsigned int i; - int e; struct btrfs_qgroup_info_item *info; struct btrfs_qgroup_limit_item *limit; struct btrfs_qgroup *bq; @@ -448,7 +1064,7 @@ static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup) sk->tree_id = BTRFS_QUOTA_TREE_OBJECTID; sk->max_type = BTRFS_QGROUP_RELATION_KEY; - sk->min_type = BTRFS_QGROUP_INFO_KEY; + sk->min_type = BTRFS_QGROUP_STATUS_KEY; sk->max_objectid = (u64)-1; sk->max_offset = (u64)-1; sk->max_transid = (u64)-1; @@ -458,11 +1074,10 @@ static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup) while (1) { ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); - e = errno; if (ret < 0) { fprintf(stderr, "ERROR: can't perform the search - %s\n", - strerror(e)); + strerror(errno)); return ret; } /* the ioctl returns the number of item it found in nr_items */ @@ -479,7 +1094,17 @@ static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup) off); off += sizeof(*sh); - if (sh->type == BTRFS_QGROUP_INFO_KEY) { + if (btrfs_search_header_type(sh) + == BTRFS_QGROUP_STATUS_KEY) { + struct btrfs_qgroup_status_item *si; + u64 flags; + + si = (struct btrfs_qgroup_status_item *) + (args.buf + off); + flags = btrfs_stack_qgroup_status_flags(si); + print_status_flag_warning(flags); + } else if (btrfs_search_header_type(sh) + == BTRFS_QGROUP_INFO_KEY) { info = (struct btrfs_qgroup_info_item *) (args.buf + off); a1 = btrfs_stack_qgroup_info_generation(info); @@ -491,9 +1116,12 @@ static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup) a5 = btrfs_stack_qgroup_info_exclusive_compressed (info); - add_qgroup(qgroup_lookup, sh->offset, a1, a2, - a3, a4, a5, 0, 0, 0, 0, 0, 0, 0); - } else if (sh->type == BTRFS_QGROUP_LIMIT_KEY) { + add_qgroup(qgroup_lookup, + btrfs_search_header_offset(sh), a1, + a2, a3, a4, a5, 0, 0, 0, 0, 0, NULL, + NULL); + } else if (btrfs_search_header_type(sh) + == BTRFS_QGROUP_LIMIT_KEY) { limit = (struct btrfs_qgroup_limit_item *) (args.buf + off); @@ -506,33 +1134,38 @@ static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup) (limit); a5 = btrfs_stack_qgroup_limit_rsv_exclusive (limit); - add_qgroup(qgroup_lookup, sh->offset, 0, 0, - 0, 0, 0, a1, a2, a3, a4, a5, 0, 0); - } else if (sh->type == BTRFS_QGROUP_RELATION_KEY) { - if (sh->offset < sh->objectid) + add_qgroup(qgroup_lookup, + btrfs_search_header_offset(sh), 0, + 0, 0, 0, 0, a1, a2, a3, a4, a5, + NULL, NULL); + } else if (btrfs_search_header_type(sh) + == BTRFS_QGROUP_RELATION_KEY) { + if (btrfs_search_header_offset(sh) + < btrfs_search_header_objectid(sh)) goto skip; bq = qgroup_tree_search(qgroup_lookup, - sh->offset); + btrfs_search_header_offset(sh)); if (!bq) goto skip; bq1 = qgroup_tree_search(qgroup_lookup, - sh->objectid); + btrfs_search_header_objectid(sh)); if (!bq1) goto skip; - add_qgroup(qgroup_lookup, sh->offset, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, bq, bq1); + add_qgroup(qgroup_lookup, + btrfs_search_header_offset(sh), 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, bq, bq1); } else goto done; skip: - off += sh->len; + off += btrfs_search_header_len(sh); /* * record the mins in sk so we can make sure the * next search doesn't repeat this root */ - sk->min_type = sh->type; - sk->min_offset = sh->offset; - sk->min_objectid = sh->objectid; + sk->min_type = btrfs_search_header_type(sh); + sk->min_offset = btrfs_search_header_offset(sh); + sk->min_objectid = btrfs_search_header_objectid(sh); } sk->nr_items = 4096; /* @@ -555,56 +1188,107 @@ static void print_all_qgroups(struct qgroup_lookup *qgroup_lookup) struct rb_node *n; struct btrfs_qgroup *entry; + print_table_head(); + n = rb_first(&qgroup_lookup->root); while (n) { - entry = rb_entry(n, struct btrfs_qgroup, rb_node); - print_single_qgroup_default(entry); + entry = rb_entry(n, struct btrfs_qgroup, sort_node); + print_single_qgroup_table(entry); n = rb_next(n); } } -int btrfs_show_qgroups(int fd) +int btrfs_show_qgroups(int fd, + struct btrfs_qgroup_filter_set *filter_set, + struct btrfs_qgroup_comparer_set *comp_set) { struct qgroup_lookup qgroup_lookup; + struct qgroup_lookup sort_tree; int ret; ret = __qgroups_search(fd, &qgroup_lookup); if (ret) return ret; + __filter_and_sort_qgroups(&qgroup_lookup, &sort_tree, + filter_set, comp_set); + print_all_qgroups(&sort_tree); - print_all_qgroups(&qgroup_lookup); __free_all_qgroups(&qgroup_lookup); - + btrfs_qgroup_free_filter_set(filter_set); + btrfs_qgroup_free_comparer_set(comp_set); return ret; } -u64 parse_qgroupid(char *p) +u64 btrfs_get_path_rootid(int fd) { - char *s = strchr(p, '/'); - char *ptr_src_end = p + strlen(p); - char *ptr_parse_end = NULL; - u64 level; - u64 id; + int ret; + struct btrfs_ioctl_ino_lookup_args args; - if (!s) { - id = strtoull(p, &ptr_parse_end, 10); - if (ptr_parse_end != ptr_src_end) - goto err; - return id; + memset(&args, 0, sizeof(args)); + args.objectid = BTRFS_FIRST_FREE_OBJECTID; + + ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args); + if (ret < 0) { + fprintf(stderr, + "ERROR: can't perform the search - %s\n", + strerror(errno)); + return ret; } - level = strtoull(p, &ptr_parse_end, 10); - if (ptr_parse_end != s) - goto err; + return args.treeid; +} + +int btrfs_qgroup_parse_sort_string(char *opt_arg, + struct btrfs_qgroup_comparer_set **comps) +{ + int order; + int flag; + char *p; + char **ptr_argv; + int what_to_sort; + + while ((p = strtok(opt_arg, ",")) != NULL) { + flag = 0; + ptr_argv = all_sort_items; + + while (*ptr_argv) { + if (strcmp(*ptr_argv, p) == 0) { + flag = 1; + break; + } else { + p++; + if (strcmp(*ptr_argv, p) == 0) { + flag = 1; + p--; + break; + } + p--; + } + ptr_argv++; + } - id = strtoull(s+1, &ptr_parse_end, 10); - if (ptr_parse_end != ptr_src_end) - goto err; + if (flag == 0) + return -1; + + else { + if (*p == '+') { + order = 0; + p++; + } else if (*p == '-') { + order = 1; + p++; + } else + order = 0; - return (level << 48) | id; -err: - fprintf(stderr, "ERROR:invalid qgroupid\n"); - exit(-1); + what_to_sort = btrfs_qgroup_get_sort_item(p); + if (what_to_sort < 0) + return -1; + btrfs_qgroup_setup_comparer(comps, what_to_sort, order); + } + opt_arg = NULL; + } + + return 0; } int qgroup_inherit_size(struct btrfs_qgroup_inherit *p) @@ -629,7 +1313,7 @@ qgroup_inherit_realloc(struct btrfs_qgroup_inherit **inherit, int n, int pos) out = calloc(sizeof(*out) + sizeof(out->qgroups[0]) * (nitems + n), 1); if (out == NULL) { fprintf(stderr, "ERROR: Not enough memory\n"); - return 13; + return -ENOMEM; } if (*inherit) { @@ -657,7 +1341,7 @@ int qgroup_inherit_add_group(struct btrfs_qgroup_inherit **inherit, char *arg) if (qgroupid == 0) { fprintf(stderr, "ERROR: bad qgroup specification\n"); - return 12; + return -EINVAL; } if (*inherit) @@ -684,7 +1368,7 @@ int qgroup_inherit_add_copy(struct btrfs_qgroup_inherit **inherit, char *arg, if (!p) { bad: fprintf(stderr, "ERROR: bad copy specification\n"); - return 12; + return -EINVAL; } *p = 0; qgroup_src = parse_qgroupid(arg);