~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/btrfs/qgroup.c

Version: ~ [ linux-5.7-rc7 ] ~ [ linux-5.6.14 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.42 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.124 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.181 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.224 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.224 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.84 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
2193 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp