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