?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs: replace leafsize with nodesize
[btrfs-progs-unstable/devel.git] / qgroup.c
bloba672ac049a5013dffad5a15444b00a2c7a61417f
1 /*
2 * Copyright (C) 2012 STRATO. All rights reserved.
3 *
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.
7 *
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.
12 *
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.
17 */
18
19 #include "qgroup.h"
20 #include <sys/ioctl.h>
21 #include "ctree.h"
22 #include "ioctl.h"
23 #include "utils.h"
24 #include <errno.h>
25
26 #define BTRFS_QGROUP_NFILTERS_INCREASE (2 * BTRFS_QGROUP_FILTER_MAX)
27 #define BTRFS_QGROUP_NCOMPS_INCREASE (2 * BTRFS_QGROUP_COMP_MAX)
28
29 struct qgroup_lookup {
30 struct rb_root root;
31 };
32
33 struct btrfs_qgroup {
34 struct rb_node rb_node;
35 struct rb_node sort_node;
36 /*
37 *all_parent_node is used to
38 *filter a qgroup's all parent
39 */
40 struct rb_node all_parent_node;
41 u64 qgroupid;
42
43 /*
44 * info_item
45 */
46 u64 generation;
47 u64 rfer; /*referenced*/
48 u64 rfer_cmpr; /*referenced compressed*/
49 u64 excl; /*exclusive*/
50 u64 excl_cmpr; /*exclusive compressed*/
51
52 /*
53 *limit_item
54 */
55 u64 flags; /*which limits are set*/
56 u64 max_rfer;
57 u64 max_excl;
58 u64 rsv_rfer;
59 u64 rsv_excl;
60
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;
65 };
66
67 /*
68 * glue structure to represent the relations
69 * between qgroups
70 */
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;
76 };
77
78 /*
79 * qgroupid,rfer,excl default to set
80 */
81 static struct {
82 char *name;
83 char *column_name;
84 int need_print;
85 unsigned unit_mode;
86 int max_len;
87 } btrfs_qgroup_columns[] = {
88 {
89 .name = "qgroupid",
90 .column_name = "Qgroupid",
91 .need_print = 1,
92 .unit_mode = 0,
93 .max_len = 8,
94 },
95 {
96 .name = "rfer",
97 .column_name = "Rfer",
98 .need_print = 1,
99 .unit_mode = UNITS_DEFAULT,
100 .max_len = 12,
101 },
102 {
103 .name = "excl",
104 .column_name = "Excl",
105 .need_print = 1,
106 .unit_mode = UNITS_DEFAULT,
107 .max_len = 12,
108 },
109 { .name = "max_rfer",
110 .column_name = "Max_rfer",
111 .need_print = 0,
112 .unit_mode = UNITS_DEFAULT,
113 .max_len = 12,
114 },
115 {
116 .name = "max_excl",
117 .column_name = "Max_excl",
118 .need_print = 0,
119 .unit_mode = UNITS_DEFAULT,
120 .max_len = 12,
121 },
122 {
123 .name = "parent",
124 .column_name = "Parent",
125 .need_print = 0,
126 .unit_mode = 0,
127 .max_len = 7,
128 },
129 {
130 .name = "child",
131 .column_name = "Child",
132 .need_print = 0,
133 .unit_mode = 0,
134 .max_len = 5,
135 },
136 {
137 .name = NULL,
138 .column_name = NULL,
139 .need_print = 0,
140 .unit_mode = 0,
141 },
142 };
143
144 static btrfs_qgroup_filter_func all_filter_funcs[];
145 static btrfs_qgroup_comp_func all_comp_funcs[];
146
147 void btrfs_qgroup_setup_print_column(enum btrfs_qgroup_column_enum column)
148 {
149 int i;
150
151 BUG_ON(column < 0 || column > BTRFS_QGROUP_ALL);
152
153 if (column < BTRFS_QGROUP_ALL) {
154 btrfs_qgroup_columns[column].need_print = 1;
155 return;
156 }
157 for (i = 0; i < BTRFS_QGROUP_ALL; i++)
158 btrfs_qgroup_columns[i].need_print = 1;
159 }
160
161 void btrfs_qgroup_setup_units(unsigned unit_mode)
162 {
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;
167 }
168
169 static int print_parent_column(struct btrfs_qgroup *qgroup)
170 {
171 struct btrfs_qgroup_list *list = NULL;
172 int len = 0;
173
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))
179 len += printf(",");
180 }
181 if (list_empty(&qgroup->qgroups))
182 len += printf("---");
183
184 return len;
185 }
186
187 static int print_child_column(struct btrfs_qgroup *qgroup)
188 {
189 struct btrfs_qgroup_list *list = NULL;
190 int len = 0;
191
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))
197 len += printf(",");
198 }
199 if (list_empty(&qgroup->members))
200 len += printf("---");
201
202 return len;
203 }
204
205 static void print_qgroup_column_add_blank(enum btrfs_qgroup_column_enum column,
206 int len)
207 {
208 len = btrfs_qgroup_columns[column].max_len - len;
209 while (len--)
210 printf(" ");
211 }
212
213 static void print_qgroup_column(struct btrfs_qgroup *qgroup,
214 enum btrfs_qgroup_column_enum column)
215 {
216 BUG_ON(column >= BTRFS_QGROUP_ALL || column < 0);
217 int len;
218 int unit_mode = btrfs_qgroup_columns[column].unit_mode;
219 int max_len = btrfs_qgroup_columns[column].max_len;
220
221 switch (column) {
222
223 case BTRFS_QGROUP_QGROUPID:
224 len = printf("%llu/%llu",
225 btrfs_qgroup_level(qgroup->qgroupid),
226 btrfs_qgroup_subvid(qgroup->qgroupid));
227 print_qgroup_column_add_blank(BTRFS_QGROUP_QGROUPID, len);
228 break;
229 case BTRFS_QGROUP_RFER:
230 len = printf("%*s", max_len, pretty_size_mode(qgroup->rfer, unit_mode));
231 break;
232 case BTRFS_QGROUP_EXCL:
233 len = printf("%*s", max_len, pretty_size_mode(qgroup->excl, unit_mode));
234 break;
235 case BTRFS_QGROUP_PARENT:
236 len = print_parent_column(qgroup);
237 print_qgroup_column_add_blank(BTRFS_QGROUP_PARENT, len);
238 break;
239 case BTRFS_QGROUP_MAX_RFER:
240 if (qgroup->flags & BTRFS_QGROUP_LIMIT_MAX_RFER)
241 len = printf("%*s", max_len, pretty_size_mode(qgroup->max_rfer, unit_mode));
242 else
243 len = printf("%*s", max_len, "none");
244 break;
245 case BTRFS_QGROUP_MAX_EXCL:
246 if (qgroup->flags & BTRFS_QGROUP_LIMIT_MAX_EXCL)
247 len = printf("%*s", max_len, pretty_size_mode(qgroup->max_excl, unit_mode));
248 else
249 len = printf("%*s", max_len, "none");
250 break;
251 case BTRFS_QGROUP_CHILD:
252 len = print_child_column(qgroup);
253 print_qgroup_column_add_blank(BTRFS_QGROUP_CHILD, len);
254 break;
255 default:
256 break;
257 }
258 }
259
260 static void print_single_qgroup_table(struct btrfs_qgroup *qgroup)
261 {
262 int i;
263
264 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
265 if (!btrfs_qgroup_columns[i].need_print)
266 continue;
267 print_qgroup_column(qgroup, i);
268
269 if (i != BTRFS_QGROUP_CHILD)
270 printf(" ");
271 }
272 printf("\n");
273 }
274
275 static void print_table_head(void)
276 {
277 int i;
278 int len;
279 int max_len;
280
281 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
282 max_len = btrfs_qgroup_columns[i].max_len;
283 if (!btrfs_qgroup_columns[i].need_print)
284 continue;
285 if ((i == BTRFS_QGROUP_QGROUPID) | (i == BTRFS_QGROUP_PARENT) |
286 (i == BTRFS_QGROUP_CHILD))
287 printf("%-*s", max_len, btrfs_qgroup_columns[i].name);
288 else
289 printf("%*s", max_len, btrfs_qgroup_columns[i].name);
290 printf(" ");
291 }
292 printf("\n");
293 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
294 max_len = btrfs_qgroup_columns[i].max_len;
295 if (!btrfs_qgroup_columns[i].need_print)
296 continue;
297 if ((i == BTRFS_QGROUP_QGROUPID) | (i == BTRFS_QGROUP_PARENT) |
298 (i == BTRFS_QGROUP_CHILD)) {
299 len = strlen(btrfs_qgroup_columns[i].name);
300 while (len--)
301 printf("-");
302 len = max_len - strlen(btrfs_qgroup_columns[i].name);
303 while (len--)
304 printf(" ");
305 } else {
306 len = max_len - strlen(btrfs_qgroup_columns[i].name);
307 while (len--)
308 printf(" ");
309 len = strlen(btrfs_qgroup_columns[i].name);
310 while (len--)
311 printf("-");
312 }
313 printf(" ");
314 }
315 printf("\n");
316 }
317
318 static void qgroup_lookup_init(struct qgroup_lookup *tree)
319 {
320 tree->root.rb_node = NULL;
321 }
322
323 static int comp_entry_with_qgroupid(struct btrfs_qgroup *entry1,
324 struct btrfs_qgroup *entry2,
325 int is_descending)
326 {
327
328 int ret;
329
330 if (entry1->qgroupid > entry2->qgroupid)
331 ret = 1;
332 else if (entry1->qgroupid < entry2->qgroupid)
333 ret = -1;
334 else
335 ret = 0;
336
337 return is_descending ? -ret : ret;
338 }
339
340 static int comp_entry_with_rfer(struct btrfs_qgroup *entry1,
341 struct btrfs_qgroup *entry2,
342 int is_descending)
343 {
344 int ret;
345
346 if (entry1->rfer > entry2->rfer)
347 ret = 1;
348 else if (entry1->rfer < entry2->rfer)
349 ret = -1;
350 else
351 ret = 0;
352
353 return is_descending ? -ret : ret;
354 }
355
356 static int comp_entry_with_excl(struct btrfs_qgroup *entry1,
357 struct btrfs_qgroup *entry2,
358 int is_descending)
359 {
360 int ret;
361
362 if (entry1->excl > entry2->excl)
363 ret = 1;
364 else if (entry1->excl < entry2->excl)
365 ret = -1;
366 else
367 ret = 0;
368
369 return is_descending ? -ret : ret;
370 }
371
372 static int comp_entry_with_max_rfer(struct btrfs_qgroup *entry1,
373 struct btrfs_qgroup *entry2,
374 int is_descending)
375 {
376 int ret;
377
378 if (entry1->max_rfer > entry2->max_rfer)
379 ret = 1;
380 else if (entry1->max_rfer < entry2->max_rfer)
381 ret = -1;
382 else
383 ret = 0;
384
385 return is_descending ? -ret : ret;
386 }
387
388 static int comp_entry_with_max_excl(struct btrfs_qgroup *entry1,
389 struct btrfs_qgroup *entry2,
390 int is_descending)
391 {
392 int ret;
393
394 if (entry1->max_excl > entry2->max_excl)
395 ret = 1;
396 else if (entry1->max_excl < entry2->max_excl)
397 ret = -1;
398 else
399 ret = 0;
400
401 return is_descending ? -ret : ret;
402 }
403
404 static btrfs_qgroup_comp_func all_comp_funcs[] = {
405 [BTRFS_QGROUP_COMP_QGROUPID] = comp_entry_with_qgroupid,
406 [BTRFS_QGROUP_COMP_RFER] = comp_entry_with_rfer,
407 [BTRFS_QGROUP_COMP_EXCL] = comp_entry_with_excl,
408 [BTRFS_QGROUP_COMP_MAX_RFER] = comp_entry_with_max_rfer,
409 [BTRFS_QGROUP_COMP_MAX_EXCL] = comp_entry_with_max_excl
410 };
411
412 static char *all_sort_items[] = {
413 [BTRFS_QGROUP_COMP_QGROUPID] = "qgroupid",
414 [BTRFS_QGROUP_COMP_RFER] = "rfer",
415 [BTRFS_QGROUP_COMP_EXCL] = "excl",
416 [BTRFS_QGROUP_COMP_MAX_RFER] = "max_rfer",
417 [BTRFS_QGROUP_COMP_MAX_EXCL] = "max_excl",
418 [BTRFS_QGROUP_COMP_MAX] = NULL,
419 };
420
421 static int btrfs_qgroup_get_sort_item(char *sort_name)
422 {
423 int i;
424
425 for (i = 0; i < BTRFS_QGROUP_COMP_MAX; i++) {
426 if (strcmp(sort_name, all_sort_items[i]) == 0)
427 return i;
428 }
429 return -1;
430 }
431
432 struct btrfs_qgroup_comparer_set *btrfs_qgroup_alloc_comparer_set(void)
433 {
434 struct btrfs_qgroup_comparer_set *set;
435 int size;
436 size = sizeof(struct btrfs_qgroup_comparer_set) +
437 BTRFS_QGROUP_NCOMPS_INCREASE *
438 sizeof(struct btrfs_qgroup_comparer);
439 set = calloc(1, size);
440 if (!set) {
441 fprintf(stderr, "memory allocation failed\n");
442 exit(1);
443 }
444
445 set->total = BTRFS_QGROUP_NCOMPS_INCREASE;
446
447 return set;
448 }
449
450 void btrfs_qgroup_free_comparer_set(struct btrfs_qgroup_comparer_set *comp_set)
451 {
452 free(comp_set);
453 }
454
455 int btrfs_qgroup_setup_comparer(struct btrfs_qgroup_comparer_set **comp_set,
456 enum btrfs_qgroup_comp_enum comparer,
457 int is_descending)
458 {
459 struct btrfs_qgroup_comparer_set *set = *comp_set;
460 int size;
461
462 BUG_ON(!set);
463 BUG_ON(comparer >= BTRFS_QGROUP_COMP_MAX);
464 BUG_ON(set->ncomps > set->total);
465
466 if (set->ncomps == set->total) {
467 void *tmp;
468
469 size = set->total + BTRFS_QGROUP_NCOMPS_INCREASE;
470 size = sizeof(*set) +
471 size * sizeof(struct btrfs_qgroup_comparer);
472 tmp = set;
473 set = realloc(set, size);
474 if (!set) {
475 fprintf(stderr, "memory allocation failed\n");
476 free(tmp);
477 exit(1);
478 }
479
480 memset(&set->comps[set->total], 0,
481 BTRFS_QGROUP_NCOMPS_INCREASE *
482 sizeof(struct btrfs_qgroup_comparer));
483 set->total += BTRFS_QGROUP_NCOMPS_INCREASE;
484 *comp_set = set;
485 }
486
487 BUG_ON(set->comps[set->ncomps].comp_func);
488
489 set->comps[set->ncomps].comp_func = all_comp_funcs[comparer];
490 set->comps[set->ncomps].is_descending = is_descending;
491 set->ncomps++;
492 return 0;
493 }
494
495 static int sort_comp(struct btrfs_qgroup *entry1, struct btrfs_qgroup *entry2,
496 struct btrfs_qgroup_comparer_set *set)
497 {
498 int qgroupid_compared = 0;
499 int i, ret = 0;
500
501 if (!set || !set->ncomps)
502 goto comp_qgroupid;
503
504 for (i = 0; i < set->ncomps; i++) {
505 if (!set->comps[i].comp_func)
506 break;
507
508 ret = set->comps[i].comp_func(entry1, entry2,
509 set->comps[i].is_descending);
510 if (ret)
511 return ret;
512
513 if (set->comps[i].comp_func == comp_entry_with_qgroupid)
514 qgroupid_compared = 1;
515 }
516
517 if (!qgroupid_compared) {
518 comp_qgroupid:
519 ret = comp_entry_with_qgroupid(entry1, entry2, 0);
520 }
521
522 return ret;
523 }
524
525 /*
526 * insert a new root into the tree. returns the existing root entry
527 * if one is already there. qgroupid is used
528 * as the key
529 */
530 static int qgroup_tree_insert(struct qgroup_lookup *root_tree,
531 struct btrfs_qgroup *ins)
532 {
533
534 struct rb_node **p = &root_tree->root.rb_node;
535 struct rb_node *parent = NULL;
536 struct btrfs_qgroup *curr;
537 int ret;
538
539 while (*p) {
540 parent = *p;
541 curr = rb_entry(parent, struct btrfs_qgroup, rb_node);
542
543 ret = comp_entry_with_qgroupid(ins, curr, 0);
544 if (ret < 0)
545 p = &(*p)->rb_left;
546 else if (ret > 0)
547 p = &(*p)->rb_right;
548 else
549 return -EEXIST;
550 }
551 rb_link_node(&ins->rb_node, parent, p);
552 rb_insert_color(&ins->rb_node, &root_tree->root);
553 return 0;
554 }
555
556 /*
557 *find a given qgroupid in the tree. We return the smallest one,
558 *rb_next can be used to move forward looking for more if required
559 */
560 static struct btrfs_qgroup *qgroup_tree_search(struct qgroup_lookup *root_tree,
561 u64 qgroupid)
562 {
563 struct rb_node *n = root_tree->root.rb_node;
564 struct btrfs_qgroup *entry;
565 struct btrfs_qgroup tmp;
566 int ret;
567
568 tmp.qgroupid = qgroupid;
569
570 while (n) {
571 entry = rb_entry(n, struct btrfs_qgroup, rb_node);
572
573 ret = comp_entry_with_qgroupid(&tmp, entry, 0);
574 if (ret < 0)
575 n = n->rb_left;
576 else if (ret > 0)
577 n = n->rb_right;
578 else
579 return entry;
580
581 }
582 return NULL;
583 }
584
585 static int update_qgroup(struct qgroup_lookup *qgroup_lookup, u64 qgroupid,
586 u64 generation, u64 rfer, u64 rfer_cmpr, u64 excl,
587 u64 excl_cmpr, u64 flags, u64 max_rfer, u64 max_excl,
588 u64 rsv_rfer, u64 rsv_excl, struct btrfs_qgroup *pa,
589 struct btrfs_qgroup *child)
590 {
591 struct btrfs_qgroup *bq;
592 struct btrfs_qgroup_list *list;
593
594 bq = qgroup_tree_search(qgroup_lookup, qgroupid);
595 if (!bq || bq->qgroupid != qgroupid)
596 return -ENOENT;
597
598 if (generation)
599 bq->generation = generation;
600 if (rfer)
601 bq->rfer = rfer;
602 if (rfer_cmpr)
603 bq->rfer_cmpr = rfer_cmpr;
604 if (excl)
605 bq->excl = excl;
606 if (excl_cmpr)
607 bq->excl_cmpr = excl_cmpr;
608 if (flags)
609 bq->flags = flags;
610 if (max_rfer)
611 bq->max_rfer = max_rfer;
612 if (max_excl)
613 bq->max_excl = max_excl;
614 if (rsv_rfer)
615 bq->rsv_rfer = rsv_rfer;
616 if (pa && child) {
617 list = malloc(sizeof(*list));
618 if (!list) {
619 fprintf(stderr, "memory allocation failed\n");
620 exit(1);
621 }
622 list->qgroup = pa;
623 list->member = child;
624 list_add_tail(&list->next_qgroup, &child->qgroups);
625 list_add_tail(&list->next_member, &pa->members);
626 }
627 return 0;
628 }
629
630 static int add_qgroup(struct qgroup_lookup *qgroup_lookup, u64 qgroupid,
631 u64 generation, u64 rfer, u64 rfer_cmpr, u64 excl,
632 u64 excl_cmpr, u64 flags, u64 max_rfer, u64 max_excl,
633 u64 rsv_rfer, u64 rsv_excl, struct btrfs_qgroup *parent,
634 struct btrfs_qgroup *child)
635 {
636 struct btrfs_qgroup *bq;
637 struct btrfs_qgroup_list *list;
638 int ret;
639
640 ret = update_qgroup(qgroup_lookup, qgroupid, generation, rfer,
641 rfer_cmpr, excl, excl_cmpr, flags, max_rfer,
642 max_excl, rsv_rfer, rsv_excl, parent, child);
643 if (!ret)
644 return 0;
645
646 bq = calloc(1, sizeof(*bq));
647 if (!bq) {
648 printf("memory allocation failed\n");
649 exit(1);
650 }
651 if (qgroupid) {
652 bq->qgroupid = qgroupid;
653 INIT_LIST_HEAD(&bq->qgroups);
654 INIT_LIST_HEAD(&bq->members);
655 }
656 if (generation)
657 bq->generation = generation;
658 if (rfer)
659 bq->rfer = rfer;
660 if (rfer_cmpr)
661 bq->rfer_cmpr = rfer_cmpr;
662 if (excl)
663 bq->excl = excl;
664 if (excl_cmpr)
665 bq->excl_cmpr = excl_cmpr;
666 if (flags)
667 bq->flags = flags;
668 if (max_rfer)
669 bq->max_rfer = max_rfer;
670 if (max_excl)
671 bq->max_excl = max_excl;
672 if (rsv_rfer)
673 bq->rsv_rfer = rsv_rfer;
674 if (parent && child) {
675 list = malloc(sizeof(*list));
676 if (!list) {
677 fprintf(stderr, "memory allocation failed\n");
678 exit(1);
679 }
680 list->qgroup = parent;
681 list->member = child;
682 list_add_tail(&list->next_qgroup, &child->qgroups);
683 list_add_tail(&list->next_member, &parent->members);
684 }
685 ret = qgroup_tree_insert(qgroup_lookup, bq);
686 if (ret) {
687 printf("failed to insert tree %llu\n",
688 bq->qgroupid);
689 exit(1);
690 }
691 return ret;
692 }
693
694 static void __free_btrfs_qgroup(struct btrfs_qgroup *bq)
695 {
696 struct btrfs_qgroup_list *list;
697 while (!list_empty(&bq->qgroups)) {
698 list = list_entry((&bq->qgroups)->next,
699 struct btrfs_qgroup_list,
700 next_qgroup);
701 list_del(&list->next_qgroup);
702 list_del(&list->next_member);
703 free(list);
704 }
705 while (!list_empty(&bq->members)) {
706 list = list_entry((&bq->members)->next,
707 struct btrfs_qgroup_list,
708 next_member);
709 list_del(&list->next_qgroup);
710 list_del(&list->next_member);
711 free(list);
712 }
713 free(bq);
714 }
715
716 static void __free_all_qgroups(struct qgroup_lookup *root_tree)
717 {
718 struct btrfs_qgroup *entry;
719 struct rb_node *n;
720
721 n = rb_first(&root_tree->root);
722 while (n) {
723 entry = rb_entry(n, struct btrfs_qgroup, rb_node);
724 rb_erase(n, &root_tree->root);
725 __free_btrfs_qgroup(entry);
726
727 n = rb_first(&root_tree->root);
728 }
729 }
730
731 static int filter_all_parent_insert(struct qgroup_lookup *sort_tree,
732 struct btrfs_qgroup *bq)
733 {
734 struct rb_node **p = &sort_tree->root.rb_node;
735 struct rb_node *parent = NULL;
736 struct btrfs_qgroup *curr;
737 int ret;
738
739 while (*p) {
740 parent = *p;
741 curr = rb_entry(parent, struct btrfs_qgroup, all_parent_node);
742
743 ret = comp_entry_with_qgroupid(bq, curr, 0);
744 if (ret < 0)
745 p = &(*p)->rb_left;
746 else if (ret > 0)
747 p = &(*p)->rb_right;
748 else
749 return -EEXIST;
750 }
751 rb_link_node(&bq->all_parent_node, parent, p);
752 rb_insert_color(&bq->all_parent_node, &sort_tree->root);
753 return 0;
754 }
755
756 static int filter_by_parent(struct btrfs_qgroup *bq, u64 data)
757 {
758 struct btrfs_qgroup *qgroup =
759 (struct btrfs_qgroup *)(unsigned long)data;
760
761 if (data == 0)
762 return 0;
763 if (qgroup->qgroupid == bq->qgroupid)
764 return 1;
765 return 0;
766 }
767
768 static int filter_by_all_parent(struct btrfs_qgroup *bq, u64 data)
769 {
770 struct qgroup_lookup lookup;
771 struct qgroup_lookup *ql = &lookup;
772 struct btrfs_qgroup_list *list;
773 struct rb_node *n;
774 struct btrfs_qgroup *qgroup =
775 (struct btrfs_qgroup *)(unsigned long)data;
776
777 if (data == 0)
778 return 0;
779 if (bq->qgroupid == qgroup->qgroupid)
780 return 1;
781
782 qgroup_lookup_init(ql);
783 filter_all_parent_insert(ql, qgroup);
784 n = rb_first(&ql->root);
785 while (n) {
786 qgroup = rb_entry(n, struct btrfs_qgroup, all_parent_node);
787 if (!list_empty(&qgroup->qgroups)) {
788 list_for_each_entry(list, &qgroup->qgroups,
789 next_qgroup) {
790 if ((list->qgroup)->qgroupid == bq->qgroupid)
791 return 1;
792 filter_all_parent_insert(ql, list->qgroup);
793 }
794 }
795 rb_erase(n, &ql->root);
796 n = rb_first(&ql->root);
797 }
798 return 0;
799 }
800
801 static btrfs_qgroup_filter_func all_filter_funcs[] = {
802 [BTRFS_QGROUP_FILTER_PARENT] = filter_by_parent,
803 [BTRFS_QGROUP_FILTER_ALL_PARENT] = filter_by_all_parent,
804 };
805
806 struct btrfs_qgroup_filter_set *btrfs_qgroup_alloc_filter_set(void)
807 {
808 struct btrfs_qgroup_filter_set *set;
809 int size;
810
811 size = sizeof(struct btrfs_qgroup_filter_set) +
812 BTRFS_QGROUP_NFILTERS_INCREASE *
813 sizeof(struct btrfs_qgroup_filter);
814 set = calloc(1, size);
815 if (!set) {
816 fprintf(stderr, "memory allocation failed\n");
817 exit(1);
818 }
819 set->total = BTRFS_QGROUP_NFILTERS_INCREASE;
820
821 return set;
822 }
823
824 void btrfs_qgroup_free_filter_set(struct btrfs_qgroup_filter_set *filter_set)
825 {
826 free(filter_set);
827 }
828
829 int btrfs_qgroup_setup_filter(struct btrfs_qgroup_filter_set **filter_set,
830 enum btrfs_qgroup_filter_enum filter, u64 data)
831 {
832 struct btrfs_qgroup_filter_set *set = *filter_set;
833 int size;
834
835 BUG_ON(!set);
836 BUG_ON(filter >= BTRFS_QGROUP_FILTER_MAX);
837 BUG_ON(set->nfilters > set->total);
838
839 if (set->nfilters == set->total) {
840 void *tmp;
841
842 size = set->total + BTRFS_QGROUP_NFILTERS_INCREASE;
843 size = sizeof(*set) + size * sizeof(struct btrfs_qgroup_filter);
844
845 tmp = set;
846 set = realloc(set, size);
847 if (!set) {
848 fprintf(stderr, "memory allocation failed\n");
849 free(tmp);
850 exit(1);
851 }
852 memset(&set->filters[set->total], 0,
853 BTRFS_QGROUP_NFILTERS_INCREASE *
854 sizeof(struct btrfs_qgroup_filter));
855 set->total += BTRFS_QGROUP_NFILTERS_INCREASE;
856 *filter_set = set;
857 }
858 BUG_ON(set->filters[set->nfilters].filter_func);
859 set->filters[set->nfilters].filter_func = all_filter_funcs[filter];
860 set->filters[set->nfilters].data = data;
861 set->nfilters++;
862 return 0;
863 }
864
865 static int filter_qgroup(struct btrfs_qgroup *bq,
866 struct btrfs_qgroup_filter_set *set)
867 {
868 int i, ret;
869
870 if (!set || !set->nfilters)
871 return 1;
872 for (i = 0; i < set->nfilters; i++) {
873 if (!set->filters[i].filter_func)
874 break;
875 ret = set->filters[i].filter_func(bq, set->filters[i].data);
876 if (!ret)
877 return 0;
878 }
879 return 1;
880 }
881
882 static void pre_process_filter_set(struct qgroup_lookup *lookup,
883 struct btrfs_qgroup_filter_set *set)
884 {
885 int i;
886 struct btrfs_qgroup *qgroup_for_filter = NULL;
887
888 for (i = 0; i < set->nfilters; i++) {
889
890 if (set->filters[i].filter_func == filter_by_all_parent
891 || set->filters[i].filter_func == filter_by_parent) {
892 qgroup_for_filter = qgroup_tree_search(lookup,
893 set->filters[i].data);
894 set->filters[i].data =
895 (u64)(unsigned long)qgroup_for_filter;
896 }
897 }
898 }
899
900 static int sort_tree_insert(struct qgroup_lookup *sort_tree,
901 struct btrfs_qgroup *bq,
902 struct btrfs_qgroup_comparer_set *comp_set)
903 {
904 struct rb_node **p = &sort_tree->root.rb_node;
905 struct rb_node *parent = NULL;
906 struct btrfs_qgroup *curr;
907 int ret;
908
909 while (*p) {
910 parent = *p;
911 curr = rb_entry(parent, struct btrfs_qgroup, sort_node);
912
913 ret = sort_comp(bq, curr, comp_set);
914 if (ret < 0)
915 p = &(*p)->rb_left;
916 else if (ret > 0)
917 p = &(*p)->rb_right;
918 else
919 return -EEXIST;
920 }
921 rb_link_node(&bq->sort_node, parent, p);
922 rb_insert_color(&bq->sort_node, &sort_tree->root);
923 return 0;
924 }
925
926 static void __update_columns_max_len(struct btrfs_qgroup *bq,
927 enum btrfs_qgroup_column_enum column)
928 {
929 BUG_ON(column >= BTRFS_QGROUP_ALL || column < 0);
930 struct btrfs_qgroup_list *list = NULL;
931 char tmp[100];
932 int len;
933 unsigned unit_mode = btrfs_qgroup_columns[column].unit_mode;
934
935 switch (column) {
936
937 case BTRFS_QGROUP_QGROUPID:
938 sprintf(tmp, "%llu/%llu",
939 btrfs_qgroup_level(bq->qgroupid),
940 btrfs_qgroup_subvid(bq->qgroupid));
941 len = strlen(tmp);
942 if (btrfs_qgroup_columns[column].max_len < len)
943 btrfs_qgroup_columns[column].max_len = len;
944 break;
945 case BTRFS_QGROUP_RFER:
946 len = strlen(pretty_size_mode(bq->rfer, unit_mode));
947 if (btrfs_qgroup_columns[column].max_len < len)
948 btrfs_qgroup_columns[column].max_len = len;
949 break;
950 case BTRFS_QGROUP_EXCL:
951 len = strlen(pretty_size_mode(bq->excl, unit_mode));
952 if (btrfs_qgroup_columns[column].max_len < len)
953 btrfs_qgroup_columns[column].max_len = len;
954 break;
955 case BTRFS_QGROUP_MAX_RFER:
956 len = strlen(pretty_size_mode(bq->max_rfer, unit_mode));
957 if (btrfs_qgroup_columns[column].max_len < len)
958 btrfs_qgroup_columns[column].max_len = len;
959 break;
960 case BTRFS_QGROUP_MAX_EXCL:
961 len = strlen(pretty_size_mode(bq->max_excl, unit_mode));
962 if (btrfs_qgroup_columns[column].max_len < len)
963 btrfs_qgroup_columns[column].max_len = len;
964 break;
965 case BTRFS_QGROUP_PARENT:
966 len = 0;
967 list_for_each_entry(list, &bq->qgroups, next_qgroup) {
968 len += sprintf(tmp, "%llu/%llu",
969 btrfs_qgroup_level(list->qgroup->qgroupid),
970 btrfs_qgroup_subvid(list->qgroup->qgroupid));
971 if (!list_is_last(&list->next_qgroup, &bq->qgroups))
972 len += 1;
973 }
974 if (btrfs_qgroup_columns[column].max_len < len)
975 btrfs_qgroup_columns[column].max_len = len;
976 break;
977 case BTRFS_QGROUP_CHILD:
978 len = 0;
979 list_for_each_entry(list, &bq->members, next_member) {
980 len += sprintf(tmp, "%llu/%llu",
981 btrfs_qgroup_level(list->member->qgroupid),
982 btrfs_qgroup_subvid(list->member->qgroupid));
983 if (!list_is_last(&list->next_member, &bq->members))
984 len += 1;
985 }
986 if (btrfs_qgroup_columns[column].max_len < len)
987 btrfs_qgroup_columns[column].max_len = len;
988 break;
989 default:
990 break;
991 }
992
993 }
994
995 static void update_columns_max_len(struct btrfs_qgroup *bq)
996 {
997 int i;
998
999 for (i = 0; i < BTRFS_QGROUP_ALL; i++) {
1000 if (!btrfs_qgroup_columns[i].need_print)
1001 continue;
1002 __update_columns_max_len(bq, i);
1003 }
1004 }
1005
1006 static void __filter_and_sort_qgroups(struct qgroup_lookup *all_qgroups,
1007 struct qgroup_lookup *sort_tree,
1008 struct btrfs_qgroup_filter_set *filter_set,
1009 struct btrfs_qgroup_comparer_set *comp_set)
1010 {
1011 struct rb_node *n;
1012 struct btrfs_qgroup *entry;
1013 int ret;
1014
1015 qgroup_lookup_init(sort_tree);
1016 pre_process_filter_set(all_qgroups, filter_set);
1017
1018 n = rb_last(&all_qgroups->root);
1019 while (n) {
1020 entry = rb_entry(n, struct btrfs_qgroup, rb_node);
1021
1022 ret = filter_qgroup(entry, filter_set);
1023 if (ret) {
1024 sort_tree_insert(sort_tree, entry, comp_set);
1025
1026 update_columns_max_len(entry);
1027 }
1028 n = rb_prev(n);
1029 }
1030 }
1031
1032 static inline void print_status_flag_warning(u64 flags)
1033 {
1034 if (!(flags & BTRFS_QGROUP_STATUS_FLAG_ON))
1035 fprintf(stderr,
1036 "WARNING: Quota disabled, qgroup data may be out of date\n");
1037 else if (flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
1038 fprintf(stderr,
1039 "WARNING: Rescan is running, qgroup data may be incorrect\n");
1040 else if (flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT)
1041 fprintf(stderr,
1042 "WARNING: Qgroup data inconsistent, rescan recommended\n");
1043 }
1044
1045 static int __qgroups_search(int fd, struct qgroup_lookup *qgroup_lookup)
1046 {
1047 int ret;
1048 struct btrfs_ioctl_search_args args;
1049 struct btrfs_ioctl_search_key *sk = &args.key;
1050 struct btrfs_ioctl_search_header *sh;
1051 unsigned long off = 0;
1052 unsigned int i;
1053 struct btrfs_qgroup_info_item *info;
1054 struct btrfs_qgroup_limit_item *limit;
1055 struct btrfs_qgroup *bq;
1056 struct btrfs_qgroup *bq1;
1057 u64 a1;
1058 u64 a2;
1059 u64 a3;
1060 u64 a4;
1061 u64 a5;
1062
1063 memset(&args, 0, sizeof(args));
1064
1065 sk->tree_id = BTRFS_QUOTA_TREE_OBJECTID;
1066 sk->max_type = BTRFS_QGROUP_RELATION_KEY;
1067 sk->min_type = BTRFS_QGROUP_STATUS_KEY;
1068 sk->max_objectid = (u64)-1;
1069 sk->max_offset = (u64)-1;
1070 sk->max_transid = (u64)-1;
1071 sk->nr_items = 4096;
1072
1073 qgroup_lookup_init(qgroup_lookup);
1074
1075 while (1) {
1076 ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
1077 if (ret < 0) {
1078 fprintf(stderr,
1079 "ERROR: can't perform the search - %s\n",
1080 strerror(errno));
1081 return ret;
1082 }
1083 /* the ioctl returns the number of item it found in nr_items */
1084 if (sk->nr_items == 0)
1085 break;
1086
1087 off = 0;
1088 /*
1089 * for each item, pull the key out of the header and then
1090 * read the root_ref item it contains
1091 */
1092 for (i = 0; i < sk->nr_items; i++) {
1093 sh = (struct btrfs_ioctl_search_header *)(args.buf +
1094 off);
1095 off += sizeof(*sh);
1096
1097 if (sh->type == BTRFS_QGROUP_STATUS_KEY) {
1098 struct btrfs_qgroup_status_item *si;
1099 u64 flags;
1100
1101 si = (struct btrfs_qgroup_status_item *)
1102 (args.buf + off);
1103 flags = btrfs_stack_qgroup_status_flags(si);
1104 print_status_flag_warning(flags);
1105 } else if (sh->type == BTRFS_QGROUP_INFO_KEY) {
1106 info = (struct btrfs_qgroup_info_item *)
1107 (args.buf + off);
1108 a1 = btrfs_stack_qgroup_info_generation(info);
1109 a2 = btrfs_stack_qgroup_info_referenced(info);
1110 a3 =
1111 btrfs_stack_qgroup_info_referenced_compressed
1112 (info);
1113 a4 = btrfs_stack_qgroup_info_exclusive(info);
1114 a5 =
1115 btrfs_stack_qgroup_info_exclusive_compressed
1116 (info);
1117 add_qgroup(qgroup_lookup, sh->offset, a1, a2,
1118 a3, a4, a5, 0, 0, 0, 0, 0,
1119 NULL, NULL);
1120 } else if (sh->type == BTRFS_QGROUP_LIMIT_KEY) {
1121 limit = (struct btrfs_qgroup_limit_item *)
1122 (args.buf + off);
1123
1124 a1 = btrfs_stack_qgroup_limit_flags(limit);
1125 a2 = btrfs_stack_qgroup_limit_max_referenced
1126 (limit);
1127 a3 = btrfs_stack_qgroup_limit_max_exclusive
1128 (limit);
1129 a4 = btrfs_stack_qgroup_limit_rsv_referenced
1130 (limit);
1131 a5 = btrfs_stack_qgroup_limit_rsv_exclusive
1132 (limit);
1133 add_qgroup(qgroup_lookup, sh->offset, 0, 0,
1134 0, 0, 0, a1, a2, a3, a4, a5,
1135 NULL, NULL);
1136 } else if (sh->type == BTRFS_QGROUP_RELATION_KEY) {
1137 if (sh->offset < sh->objectid)
1138 goto skip;
1139 bq = qgroup_tree_search(qgroup_lookup,
1140 sh->offset);
1141 if (!bq)
1142 goto skip;
1143 bq1 = qgroup_tree_search(qgroup_lookup,
1144 sh->objectid);
1145 if (!bq1)
1146 goto skip;
1147 add_qgroup(qgroup_lookup, sh->offset, 0, 0,
1148 0, 0, 0, 0, 0, 0, 0, 0, bq, bq1);
1149 } else
1150 goto done;
1151 skip:
1152 off += sh->len;
1153
1154 /*
1155 * record the mins in sk so we can make sure the
1156 * next search doesn't repeat this root
1157 */
1158 sk->min_type = sh->type;
1159 sk->min_offset = sh->offset;
1160 sk->min_objectid = sh->objectid;
1161 }
1162 sk->nr_items = 4096;
1163 /*
1164 * this iteration is done, step forward one qgroup for the next
1165 * ioctl
1166 */
1167 if (sk->min_offset < (u64)-1)
1168 sk->min_offset++;
1169 else
1170 break;
1171 }
1172
1173 done:
1174 return ret;
1175 }
1176
1177 static void print_all_qgroups(struct qgroup_lookup *qgroup_lookup)
1178 {
1179
1180 struct rb_node *n;
1181 struct btrfs_qgroup *entry;
1182
1183 print_table_head();
1184
1185 n = rb_first(&qgroup_lookup->root);
1186 while (n) {
1187 entry = rb_entry(n, struct btrfs_qgroup, sort_node);
1188 print_single_qgroup_table(entry);
1189 n = rb_next(n);
1190 }
1191 }
1192
1193 int btrfs_show_qgroups(int fd,
1194 struct btrfs_qgroup_filter_set *filter_set,
1195 struct btrfs_qgroup_comparer_set *comp_set)
1196 {
1197
1198 struct qgroup_lookup qgroup_lookup;
1199 struct qgroup_lookup sort_tree;
1200 int ret;
1201
1202 ret = __qgroups_search(fd, &qgroup_lookup);
1203 if (ret)
1204 return ret;
1205 __filter_and_sort_qgroups(&qgroup_lookup, &sort_tree,
1206 filter_set, comp_set);
1207 print_all_qgroups(&sort_tree);
1208
1209 __free_all_qgroups(&qgroup_lookup);
1210 btrfs_qgroup_free_filter_set(filter_set);
1211 btrfs_qgroup_free_comparer_set(comp_set);
1212 return ret;
1213 }
1214
1215 u64 btrfs_get_path_rootid(int fd)
1216 {
1217 int ret;
1218 struct btrfs_ioctl_ino_lookup_args args;
1219
1220 memset(&args, 0, sizeof(args));
1221 args.objectid = BTRFS_FIRST_FREE_OBJECTID;
1222
1223 ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
1224 if (ret < 0) {
1225 fprintf(stderr,
1226 "ERROR: can't perform the search - %s\n",
1227 strerror(errno));
1228 return ret;
1229 }
1230 return args.treeid;
1231 }
1232
1233 int btrfs_qgroup_parse_sort_string(char *opt_arg,
1234 struct btrfs_qgroup_comparer_set **comps)
1235 {
1236 int order;
1237 int flag;
1238 char *p;
1239 char **ptr_argv;
1240 int what_to_sort;
1241
1242 while ((p = strtok(opt_arg, ",")) != NULL) {
1243 flag = 0;
1244 ptr_argv = all_sort_items;
1245
1246 while (*ptr_argv) {
1247 if (strcmp(*ptr_argv, p) == 0) {
1248 flag = 1;
1249 break;
1250 } else {
1251 p++;
1252 if (strcmp(*ptr_argv, p) == 0) {
1253 flag = 1;
1254 p--;
1255 break;
1256 }
1257 p--;
1258 }
1259 ptr_argv++;
1260 }
1261
1262 if (flag == 0)
1263 return -1;
1264
1265 else {
1266 if (*p == '+') {
1267 order = 0;
1268 p++;
1269 } else if (*p == '-') {
1270 order = 1;
1271 p++;
1272 } else
1273 order = 0;
1274
1275 what_to_sort = btrfs_qgroup_get_sort_item(p);
1276 if (what_to_sort < 0)
1277 return -1;
1278 btrfs_qgroup_setup_comparer(comps, what_to_sort, order);
1279 }
1280 opt_arg = NULL;
1281 }
1282
1283 return 0;
1284 }
1285
1286 int qgroup_inherit_size(struct btrfs_qgroup_inherit *p)
1287 {
1288 return sizeof(*p) + sizeof(p->qgroups[0]) *
1289 (p->num_qgroups + 2 * p->num_ref_copies +
1290 2 * p->num_excl_copies);
1291 }
1292
1293 static int
1294 qgroup_inherit_realloc(struct btrfs_qgroup_inherit **inherit, int n, int pos)
1295 {
1296 struct btrfs_qgroup_inherit *out;
1297 int nitems = 0;
1298
1299 if (*inherit) {
1300 nitems = (*inherit)->num_qgroups +
1301 (*inherit)->num_ref_copies +
1302 (*inherit)->num_excl_copies;
1303 }
1304
1305 out = calloc(sizeof(*out) + sizeof(out->qgroups[0]) * (nitems + n), 1);
1306 if (out == NULL) {
1307 fprintf(stderr, "ERROR: Not enough memory\n");
1308 return -ENOMEM;
1309 }
1310
1311 if (*inherit) {
1312 struct btrfs_qgroup_inherit *i = *inherit;
1313 int s = sizeof(out->qgroups[0]);
1314
1315 out->num_qgroups = i->num_qgroups;
1316 out->num_ref_copies = i->num_ref_copies;
1317 out->num_excl_copies = i->num_excl_copies;
1318 memcpy(out->qgroups, i->qgroups, pos * s);
1319 memcpy(out->qgroups + pos + n, i->qgroups + pos,
1320 (nitems - pos) * s);
1321 }
1322 free(*inherit);
1323 *inherit = out;
1324
1325 return 0;
1326 }
1327
1328 int qgroup_inherit_add_group(struct btrfs_qgroup_inherit **inherit, char *arg)
1329 {
1330 int ret;
1331 u64 qgroupid = parse_qgroupid(arg);
1332 int pos = 0;
1333
1334 if (qgroupid == 0) {
1335 fprintf(stderr, "ERROR: bad qgroup specification\n");
1336 return -EINVAL;
1337 }
1338
1339 if (*inherit)
1340 pos = (*inherit)->num_qgroups;
1341 ret = qgroup_inherit_realloc(inherit, 1, pos);
1342 if (ret)
1343 return ret;
1344
1345 (*inherit)->qgroups[(*inherit)->num_qgroups++] = qgroupid;
1346
1347 return 0;
1348 }
1349
1350 int qgroup_inherit_add_copy(struct btrfs_qgroup_inherit **inherit, char *arg,
1351 int type)
1352 {
1353 int ret;
1354 u64 qgroup_src;
1355 u64 qgroup_dst;
1356 char *p;
1357 int pos = 0;
1358
1359 p = strchr(arg, ':');
1360 if (!p) {
1361 bad:
1362 fprintf(stderr, "ERROR: bad copy specification\n");
1363 return -EINVAL;
1364 }
1365 *p = 0;
1366 qgroup_src = parse_qgroupid(arg);
1367 qgroup_dst = parse_qgroupid(p + 1);
1368 *p = ':';
1369
1370 if (!qgroup_src || !qgroup_dst)
1371 goto bad;
1372
1373 if (*inherit)
1374 pos = (*inherit)->num_qgroups +
1375 (*inherit)->num_ref_copies * 2 * type;
1376
1377 ret = qgroup_inherit_realloc(inherit, 2, pos);
1378 if (ret)
1379 return ret;
1380
1381 (*inherit)->qgroups[pos++] = qgroup_src;
1382 (*inherit)->qgroups[pos++] = qgroup_dst;
1383
1384 if (!type)
1385 ++(*inherit)->num_ref_copies;
1386 else
1387 ++(*inherit)->num_excl_copies;
1388
1389 return 0;
1390 }
(deprecated) Btrfs progs developments and patch integration