fs/btrfs/qgroup.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2011 STRATO.  All rights reserved.
   4  */
   5
   6 #include <linux/sched.h>
   7 #include <linux/pagemap.h>
   8 #include <linux/writeback.h>
   9 #include <linux/blkdev.h>
  10 #include <linux/rbtree.h>
  11 #include <linux/slab.h>
  12 #include <linux/workqueue.h>
  13 #include <linux/btrfs.h>
  14 #include <linux/sched/mm.h>
  15
  16 #include "ctree.h"
  17 #include "transaction.h"
  18 #include "disk-io.h"
  19 #include "locking.h"
  20 #include "ulist.h"
  21 #include "backref.h"
  22 #include "extent_io.h"
  23 #include "qgroup.h"
  24 #include "block-group.h"
  25 #include "sysfs.h"
  26 #include "tree-mod-log.h"
  27 #include "fs.h"
  28 #include "accessors.h"
  29 #include "extent-tree.h"
  30 #include "root-tree.h"
  31 #include "tree-checker.h"
  32
  33 enum btrfs_qgroup_mode btrfs_qgroup_mode(const struct btrfs_fs_info *fs_info)
  34 {
  35         if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
  36                 return BTRFS_QGROUP_MODE_DISABLED;
  37         if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE)
  38                 return BTRFS_QGROUP_MODE_SIMPLE;
  39         return BTRFS_QGROUP_MODE_FULL;
  40 }
  41
  42 bool btrfs_qgroup_enabled(const struct btrfs_fs_info *fs_info)
  43 {
  44         return btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_DISABLED;
  45 }
  46
  47 bool btrfs_qgroup_full_accounting(const struct btrfs_fs_info *fs_info)
  48 {
  49         return btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL;
  50 }
  51
  52 /*
  53  * Helpers to access qgroup reservation
  54  *
  55  * Callers should ensure the lock context and type are valid
  56  */
  57
  58 static u64 qgroup_rsv_total(const struct btrfs_qgroup *qgroup)
  59 {
  60         u64 ret = 0;
  61         int i;
  62
  63         for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++)
  64                 ret += qgroup->rsv.values[i];
  65
  66         return ret;
  67 }
  68
  69 #ifdef CONFIG_BTRFS_DEBUG
  70 static const char *qgroup_rsv_type_str(enum btrfs_qgroup_rsv_type type)
  71 {
  72         if (type == BTRFS_QGROUP_RSV_DATA)
  73                 return "data";
  74         if (type == BTRFS_QGROUP_RSV_META_PERTRANS)
  75                 return "meta_pertrans";
  76         if (type == BTRFS_QGROUP_RSV_META_PREALLOC)
  77                 return "meta_prealloc";
  78         return NULL;
  79 }
  80 #endif
  81
  82 static void qgroup_rsv_add(struct btrfs_fs_info *fs_info,
  83                            struct btrfs_qgroup *qgroup, u64 num_bytes,
  84                            enum btrfs_qgroup_rsv_type type)
  85 {
  86         trace_qgroup_update_reserve(fs_info, qgroup, num_bytes, type);
  87         qgroup->rsv.values[type] += num_bytes;
  88 }
  89
  90 static void qgroup_rsv_release(struct btrfs_fs_info *fs_info,
  91                                struct btrfs_qgroup *qgroup, u64 num_bytes,
  92                                enum btrfs_qgroup_rsv_type type)
  93 {
  94         trace_qgroup_update_reserve(fs_info, qgroup, -(s64)num_bytes, type);
  95         if (qgroup->rsv.values[type] >= num_bytes) {
  96                 qgroup->rsv.values[type] -= num_bytes;
  97                 return;
  98         }
  99 #ifdef CONFIG_BTRFS_DEBUG
 100         WARN_RATELIMIT(1,
 101                 "qgroup %llu %s reserved space underflow, have %llu to free %llu",
 102                 qgroup->qgroupid, qgroup_rsv_type_str(type),
 103                 qgroup->rsv.values[type], num_bytes);
 104 #endif
 105         qgroup->rsv.values[type] = 0;
 106 }
 107
 108 static void qgroup_rsv_add_by_qgroup(struct btrfs_fs_info *fs_info,
 109                                      struct btrfs_qgroup *dest,
 110                                      const struct btrfs_qgroup *src)
 111 {
 112         int i;
 113
 114         for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++)
 115                 qgroup_rsv_add(fs_info, dest, src->rsv.values[i], i);
 116 }
 117
 118 static void qgroup_rsv_release_by_qgroup(struct btrfs_fs_info *fs_info,
 119                                          struct btrfs_qgroup *dest,
 120                                          const struct btrfs_qgroup *src)
 121 {
 122         int i;
 123
 124         for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++)
 125                 qgroup_rsv_release(fs_info, dest, src->rsv.values[i], i);
 126 }
 127
 128 static void btrfs_qgroup_update_old_refcnt(struct btrfs_qgroup *qg, u64 seq,
 129                                            int mod)
 130 {
 131         if (qg->old_refcnt < seq)
 132                 qg->old_refcnt = seq;
 133         qg->old_refcnt += mod;
 134 }
 135
 136 static void btrfs_qgroup_update_new_refcnt(struct btrfs_qgroup *qg, u64 seq,
 137                                            int mod)
 138 {
 139         if (qg->new_refcnt < seq)
 140                 qg->new_refcnt = seq;
 141         qg->new_refcnt += mod;
 142 }
 143
 144 static inline u64 btrfs_qgroup_get_old_refcnt(const struct btrfs_qgroup *qg, u64 seq)
 145 {
 146         if (qg->old_refcnt < seq)
 147                 return 0;
 148         return qg->old_refcnt - seq;
 149 }
 150
 151 static inline u64 btrfs_qgroup_get_new_refcnt(const struct btrfs_qgroup *qg, u64 seq)
 152 {
 153         if (qg->new_refcnt < seq)
 154                 return 0;
 155         return qg->new_refcnt - seq;
 156 }
 157
 158 static int
 159 qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,
 160                    int init_flags);
 161 static void qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info);
 162
 163 /* must be called with qgroup_ioctl_lock held */
 164 static struct btrfs_qgroup *find_qgroup_rb(const struct btrfs_fs_info *fs_info,
 165                                            u64 qgroupid)
 166 {
 167         struct rb_node *n = fs_info->qgroup_tree.rb_node;
 168         struct btrfs_qgroup *qgroup;
 169
 170         while (n) {
 171                 qgroup = rb_entry(n, struct btrfs_qgroup, node);
 172                 if (qgroup->qgroupid < qgroupid)
 173                         n = n->rb_left;
 174                 else if (qgroup->qgroupid > qgroupid)
 175                         n = n->rb_right;
 176                 else
 177                         return qgroup;
 178         }
 179         return NULL;
 180 }
 181
 182 /*
 183  * Add qgroup to the filesystem's qgroup tree.
 184  *
 185  * Must be called with qgroup_lock held and @prealloc preallocated.
 186  *
 187  * The control on the lifespan of @prealloc would be transferred to this
 188  * function, thus caller should no longer touch @prealloc.
 189  */
 190 static struct btrfs_qgroup *add_qgroup_rb(struct btrfs_fs_info *fs_info,
 191                                           struct btrfs_qgroup *prealloc,
 192                                           u64 qgroupid)
 193 {
 194         struct rb_node **p = &fs_info->qgroup_tree.rb_node;
 195         struct rb_node *parent = NULL;
 196         struct btrfs_qgroup *qgroup;
 197
 198         /* Caller must have pre-allocated @prealloc. */
 199         ASSERT(prealloc);
 200
 201         while (*p) {
 202                 parent = *p;
 203                 qgroup = rb_entry(parent, struct btrfs_qgroup, node);
 204
 205                 if (qgroup->qgroupid < qgroupid) {
 206                         p = &(*p)->rb_left;
 207                 } else if (qgroup->qgroupid > qgroupid) {
 208                         p = &(*p)->rb_right;
 209                 } else {
 210                         kfree(prealloc);
 211                         return qgroup;
 212                 }
 213         }
 214
 215         qgroup = prealloc;
 216         qgroup->qgroupid = qgroupid;
 217         INIT_LIST_HEAD(&qgroup->groups);
 218         INIT_LIST_HEAD(&qgroup->members);
 219         INIT_LIST_HEAD(&qgroup->dirty);
 220         INIT_LIST_HEAD(&qgroup->iterator);
 221         INIT_LIST_HEAD(&qgroup->nested_iterator);
 222
 223         rb_link_node(&qgroup->node, parent, p);
 224         rb_insert_color(&qgroup->node, &fs_info->qgroup_tree);
 225
 226         return qgroup;
 227 }
 228
 229 static void __del_qgroup_rb(struct btrfs_qgroup *qgroup)
 230 {
 231         struct btrfs_qgroup_list *list;
 232
 233         list_del(&qgroup->dirty);
 234         while (!list_empty(&qgroup->groups)) {
 235                 list = list_first_entry(&qgroup->groups,
 236                                         struct btrfs_qgroup_list, next_group);
 237                 list_del(&list->next_group);
 238                 list_del(&list->next_member);
 239                 kfree(list);
 240         }
 241
 242         while (!list_empty(&qgroup->members)) {
 243                 list = list_first_entry(&qgroup->members,
 244                                         struct btrfs_qgroup_list, next_member);
 245                 list_del(&list->next_group);
 246                 list_del(&list->next_member);
 247                 kfree(list);
 248         }
 249 }
 250
 251 /* must be called with qgroup_lock held */
 252 static int del_qgroup_rb(struct btrfs_fs_info *fs_info, u64 qgroupid)
 253 {
 254         struct btrfs_qgroup *qgroup = find_qgroup_rb(fs_info, qgroupid);
 255
 256         if (!qgroup)
 257                 return -ENOENT;
 258
 259         rb_erase(&qgroup->node, &fs_info->qgroup_tree);
 260         __del_qgroup_rb(qgroup);
 261         return 0;
 262 }
 263
 264 /*
 265  * Add relation specified by two qgroups.
 266  *
 267  * Must be called with qgroup_lock held, the ownership of @prealloc is
 268  * transferred to this function and caller should not touch it anymore.
 269  *
 270  * Return: 0        on success
 271  *         -ENOENT  if one of the qgroups is NULL
 272  *         <0       other errors
 273  */
 274 static int __add_relation_rb(struct btrfs_qgroup_list *prealloc,
 275                              struct btrfs_qgroup *member,
 276                              struct btrfs_qgroup *parent)
 277 {
 278         if (!member || !parent) {
 279                 kfree(prealloc);
 280                 return -ENOENT;
 281         }
 282
 283         prealloc->group = parent;
 284         prealloc->member = member;
 285         list_add_tail(&prealloc->next_group, &member->groups);
 286         list_add_tail(&prealloc->next_member, &parent->members);
 287
 288         return 0;
 289 }
 290
 291 /*
 292  * Add relation specified by two qgroup ids.
 293  *
 294  * Must be called with qgroup_lock held.
 295  *
 296  * Return: 0        on success
 297  *         -ENOENT  if one of the ids does not exist
 298  *         <0       other errors
 299  */
 300 static int add_relation_rb(struct btrfs_fs_info *fs_info,
 301                            struct btrfs_qgroup_list *prealloc,
 302                            u64 memberid, u64 parentid)
 303 {
 304         struct btrfs_qgroup *member;
 305         struct btrfs_qgroup *parent;
 306
 307         member = find_qgroup_rb(fs_info, memberid);
 308         parent = find_qgroup_rb(fs_info, parentid);
 309
 310         return __add_relation_rb(prealloc, member, parent);
 311 }
 312
 313 /* Must be called with qgroup_lock held */
 314 static int del_relation_rb(struct btrfs_fs_info *fs_info,
 315                            u64 memberid, u64 parentid)
 316 {
 317         struct btrfs_qgroup *member;
 318         struct btrfs_qgroup *parent;
 319         struct btrfs_qgroup_list *list;
 320
 321         member = find_qgroup_rb(fs_info, memberid);
 322         parent = find_qgroup_rb(fs_info, parentid);
 323         if (!member || !parent)
 324                 return -ENOENT;
 325
 326         list_for_each_entry(list, &member->groups, next_group) {
 327                 if (list->group == parent) {
 328                         list_del(&list->next_group);
 329                         list_del(&list->next_member);
 330                         kfree(list);
 331                         return 0;
 332                 }
 333         }
 334         return -ENOENT;
 335 }
 336
 337 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
 338 int btrfs_verify_qgroup_counts(const struct btrfs_fs_info *fs_info, u64 qgroupid,
 339                                u64 rfer, u64 excl)
 340 {
 341         struct btrfs_qgroup *qgroup;
 342
 343         qgroup = find_qgroup_rb(fs_info, qgroupid);
 344         if (!qgroup)
 345                 return -EINVAL;
 346         if (qgroup->rfer != rfer || qgroup->excl != excl)
 347                 return -EINVAL;
 348         return 0;
 349 }
 350 #endif
 351
 352 static void qgroup_mark_inconsistent(struct btrfs_fs_info *fs_info)
 353 {
 354         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)
 355                 return;
 356         fs_info->qgroup_flags |= (BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT |
 357                                   BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN |
 358                                   BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING);
 359 }
 360
 361 static void qgroup_read_enable_gen(struct btrfs_fs_info *fs_info,
 362                                    struct extent_buffer *leaf, int slot,
 363                                    struct btrfs_qgroup_status_item *ptr)
 364 {
 365         ASSERT(btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));
 366         ASSERT(btrfs_item_size(leaf, slot) >= sizeof(*ptr));
 367         fs_info->qgroup_enable_gen = btrfs_qgroup_status_enable_gen(leaf, ptr);
 368 }
 369
 370 /*
 371  * The full config is read in one go, only called from open_ctree()
 372  * It doesn't use any locking, as at this point we're still single-threaded
 373  */
 374 int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
 375 {
 376         struct btrfs_key key;
 377         struct btrfs_key found_key;
 378         struct btrfs_root *quota_root = fs_info->quota_root;
 379         struct btrfs_path *path = NULL;
 380         struct extent_buffer *l;
 381         int slot;
 382         int ret = 0;
 383         u64 flags = 0;
 384         u64 rescan_progress = 0;
 385
 386         if (!fs_info->quota_root)
 387                 return 0;
 388
 389         fs_info->qgroup_ulist = ulist_alloc(GFP_KERNEL);
 390         if (!fs_info->qgroup_ulist) {
 391                 ret = -ENOMEM;
 392                 goto out;
 393         }
 394
 395         path = btrfs_alloc_path();
 396         if (!path) {
 397                 ret = -ENOMEM;
 398                 goto out;
 399         }
 400
 401         ret = btrfs_sysfs_add_qgroups(fs_info);
 402         if (ret < 0)
 403                 goto out;
 404         /* default this to quota off, in case no status key is found */
 405         fs_info->qgroup_flags = 0;
 406
 407         /*
 408          * pass 1: read status, all qgroup infos and limits
 409          */
 410         key.objectid = 0;
 411         key.type = 0;
 412         key.offset = 0;
 413         ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 1);
 414         if (ret)
 415                 goto out;
 416
 417         while (1) {
 418                 struct btrfs_qgroup *qgroup;
 419
 420                 slot = path->slots[0];
 421                 l = path->nodes[0];
 422                 btrfs_item_key_to_cpu(l, &found_key, slot);
 423
 424                 if (found_key.type == BTRFS_QGROUP_STATUS_KEY) {
 425                         struct btrfs_qgroup_status_item *ptr;
 426
 427                         ptr = btrfs_item_ptr(l, slot,
 428                                              struct btrfs_qgroup_status_item);
 429
 430                         if (btrfs_qgroup_status_version(l, ptr) !=
 431                             BTRFS_QGROUP_STATUS_VERSION) {
 432                                 btrfs_err(fs_info,
 433                                  "old qgroup version, quota disabled");
 434                                 goto out;
 435                         }
 436                         fs_info->qgroup_flags = btrfs_qgroup_status_flags(l, ptr);
 437                         if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE) {
 438                                 qgroup_read_enable_gen(fs_info, l, slot, ptr);
 439                         } else if (btrfs_qgroup_status_generation(l, ptr) != fs_info->generation) {
 440                                 qgroup_mark_inconsistent(fs_info);
 441                                 btrfs_err(fs_info,
 442                                         "qgroup generation mismatch, marked as inconsistent");
 443                         }
 444                         rescan_progress = btrfs_qgroup_status_rescan(l, ptr);
 445                         goto next1;
 446                 }
 447
 448                 if (found_key.type != BTRFS_QGROUP_INFO_KEY &&
 449                     found_key.type != BTRFS_QGROUP_LIMIT_KEY)
 450                         goto next1;
 451
 452                 qgroup = find_qgroup_rb(fs_info, found_key.offset);
 453                 if ((qgroup && found_key.type == BTRFS_QGROUP_INFO_KEY) ||
 454                     (!qgroup && found_key.type == BTRFS_QGROUP_LIMIT_KEY)) {
 455                         btrfs_err(fs_info, "inconsistent qgroup config");
 456                         qgroup_mark_inconsistent(fs_info);
 457                 }
 458                 if (!qgroup) {
 459                         struct btrfs_qgroup *prealloc;
 460                         struct btrfs_root *tree_root = fs_info->tree_root;
 461
 462                         prealloc = kzalloc(sizeof(*prealloc), GFP_KERNEL);
 463                         if (!prealloc) {
 464                                 ret = -ENOMEM;
 465                                 goto out;
 466                         }
 467                         qgroup = add_qgroup_rb(fs_info, prealloc, found_key.offset);
 468                         /*
 469                          * If a qgroup exists for a subvolume ID, it is possible
 470                          * that subvolume has been deleted, in which case
 471                          * reusing that ID would lead to incorrect accounting.
 472                          *
 473                          * Ensure that we skip any such subvol ids.
 474                          *
 475                          * We don't need to lock because this is only called
 476                          * during mount before we start doing things like creating
 477                          * subvolumes.
 478                          */
 479                         if (is_fstree(qgroup->qgroupid) &&
 480                             qgroup->qgroupid > tree_root->free_objectid)
 481                                 /*
 482                                  * Don't need to check against BTRFS_LAST_FREE_OBJECTID,
 483                                  * as it will get checked on the next call to
 484                                  * btrfs_get_free_objectid.
 485                                  */
 486                                 tree_root->free_objectid = qgroup->qgroupid + 1;
 487                 }
 488                 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
 489                 if (ret < 0)
 490                         goto out;
 491
 492                 switch (found_key.type) {
 493                 case BTRFS_QGROUP_INFO_KEY: {
 494                         struct btrfs_qgroup_info_item *ptr;
 495
 496                         ptr = btrfs_item_ptr(l, slot,
 497                                              struct btrfs_qgroup_info_item);
 498                         qgroup->rfer = btrfs_qgroup_info_rfer(l, ptr);
 499                         qgroup->rfer_cmpr = btrfs_qgroup_info_rfer_cmpr(l, ptr);
 500                         qgroup->excl = btrfs_qgroup_info_excl(l, ptr);
 501                         qgroup->excl_cmpr = btrfs_qgroup_info_excl_cmpr(l, ptr);
 502                         /* generation currently unused */
 503                         break;
 504                 }
 505                 case BTRFS_QGROUP_LIMIT_KEY: {
 506                         struct btrfs_qgroup_limit_item *ptr;
 507
 508                         ptr = btrfs_item_ptr(l, slot,
 509                                              struct btrfs_qgroup_limit_item);
 510                         qgroup->lim_flags = btrfs_qgroup_limit_flags(l, ptr);
 511                         qgroup->max_rfer = btrfs_qgroup_limit_max_rfer(l, ptr);
 512                         qgroup->max_excl = btrfs_qgroup_limit_max_excl(l, ptr);
 513                         qgroup->rsv_rfer = btrfs_qgroup_limit_rsv_rfer(l, ptr);
 514                         qgroup->rsv_excl = btrfs_qgroup_limit_rsv_excl(l, ptr);
 515                         break;
 516                 }
 517                 }
 518 next1:
 519                 ret = btrfs_next_item(quota_root, path);
 520                 if (ret < 0)
 521                         goto out;
 522                 if (ret)
 523                         break;
 524         }
 525         btrfs_release_path(path);
 526
 527         /*
 528          * pass 2: read all qgroup relations
 529          */
 530         key.objectid = 0;
 531         key.type = BTRFS_QGROUP_RELATION_KEY;
 532         key.offset = 0;
 533         ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 0);
 534         if (ret)
 535                 goto out;
 536         while (1) {
 537                 struct btrfs_qgroup_list *list = NULL;
 538
 539                 slot = path->slots[0];
 540                 l = path->nodes[0];
 541                 btrfs_item_key_to_cpu(l, &found_key, slot);
 542
 543                 if (found_key.type != BTRFS_QGROUP_RELATION_KEY)
 544                         goto next2;
 545
 546                 if (found_key.objectid > found_key.offset) {
 547                         /* parent <- member, not needed to build config */
 548                         /* FIXME should we omit the key completely? */
 549                         goto next2;
 550                 }
 551
 552                 list = kzalloc(sizeof(*list), GFP_KERNEL);
 553                 if (!list) {
 554                         ret = -ENOMEM;
 555                         goto out;
 556                 }
 557                 ret = add_relation_rb(fs_info, list, found_key.objectid,
 558                                       found_key.offset);
 559                 list = NULL;
 560                 if (ret == -ENOENT) {
 561                         btrfs_warn(fs_info,
 562                                 "orphan qgroup relation 0x%llx->0x%llx",
 563                                 found_key.objectid, found_key.offset);
 564                         ret = 0;        /* ignore the error */
 565                 }
 566                 if (ret)
 567                         goto out;
 568 next2:
 569                 ret = btrfs_next_item(quota_root, path);
 570                 if (ret < 0)
 571                         goto out;
 572                 if (ret)
 573                         break;
 574         }
 575 out:
 576         btrfs_free_path(path);
 577         fs_info->qgroup_flags |= flags;
 578         if (ret >= 0) {
 579                 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)
 580                         set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
 581                 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
 582                         ret = qgroup_rescan_init(fs_info, rescan_progress, 0);
 583         } else {
 584                 ulist_free(fs_info->qgroup_ulist);
 585                 fs_info->qgroup_ulist = NULL;
 586                 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
 587                 btrfs_sysfs_del_qgroups(fs_info);
 588         }
 589
 590         return ret < 0 ? ret : 0;
 591 }
 592
 593 /*
 594  * Called in close_ctree() when quota is still enabled.  This verifies we don't
 595  * leak some reserved space.
 596  *
 597  * Return false if no reserved space is left.
 598  * Return true if some reserved space is leaked.
 599  */
 600 bool btrfs_check_quota_leak(const struct btrfs_fs_info *fs_info)
 601 {
 602         struct rb_node *node;
 603         bool ret = false;
 604
 605         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED)
 606                 return ret;
 607         /*
 608          * Since we're unmounting, there is no race and no need to grab qgroup
 609          * lock.  And here we don't go post-order to provide a more user
 610          * friendly sorted result.
 611          */
 612         for (node = rb_first(&fs_info->qgroup_tree); node; node = rb_next(node)) {
 613                 struct btrfs_qgroup *qgroup;
 614                 int i;
 615
 616                 qgroup = rb_entry(node, struct btrfs_qgroup, node);
 617                 for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++) {
 618                         if (qgroup->rsv.values[i]) {
 619                                 ret = true;
 620                                 btrfs_warn(fs_info,
 621                 "qgroup %hu/%llu has unreleased space, type %d rsv %llu",
 622                                    btrfs_qgroup_level(qgroup->qgroupid),
 623                                    btrfs_qgroup_subvolid(qgroup->qgroupid),
 624                                    i, qgroup->rsv.values[i]);
 625                         }
 626                 }
 627         }
 628         return ret;
 629 }
 630
 631 /*
 632  * This is called from close_ctree() or open_ctree() or btrfs_quota_disable(),
 633  * first two are in single-threaded paths.And for the third one, we have set
 634  * quota_root to be null with qgroup_lock held before, so it is safe to clean
 635  * up the in-memory structures without qgroup_lock held.
 636  */
 637 void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info)
 638 {
 639         struct rb_node *n;
 640         struct btrfs_qgroup *qgroup;
 641
 642         while ((n = rb_first(&fs_info->qgroup_tree))) {
 643                 qgroup = rb_entry(n, struct btrfs_qgroup, node);
 644                 rb_erase(n, &fs_info->qgroup_tree);
 645                 __del_qgroup_rb(qgroup);
 646                 btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
 647                 kfree(qgroup);
 648         }
 649         /*
 650          * We call btrfs_free_qgroup_config() when unmounting
 651          * filesystem and disabling quota, so we set qgroup_ulist
 652          * to be null here to avoid double free.
 653          */
 654         ulist_free(fs_info->qgroup_ulist);
 655         fs_info->qgroup_ulist = NULL;
 656         btrfs_sysfs_del_qgroups(fs_info);
 657 }
 658
 659 static int add_qgroup_relation_item(struct btrfs_trans_handle *trans, u64 src,
 660                                     u64 dst)
 661 {
 662         int ret;
 663         struct btrfs_root *quota_root = trans->fs_info->quota_root;
 664         struct btrfs_path *path;
 665         struct btrfs_key key;
 666
 667         path = btrfs_alloc_path();
 668         if (!path)
 669                 return -ENOMEM;
 670
 671         key.objectid = src;
 672         key.type = BTRFS_QGROUP_RELATION_KEY;
 673         key.offset = dst;
 674
 675         ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 0);
 676
 677         btrfs_mark_buffer_dirty(trans, path->nodes[0]);
 678
 679         btrfs_free_path(path);
 680         return ret;
 681 }
 682
 683 static int del_qgroup_relation_item(struct btrfs_trans_handle *trans, u64 src,
 684                                     u64 dst)
 685 {
 686         int ret;
 687         struct btrfs_root *quota_root = trans->fs_info->quota_root;
 688         struct btrfs_path *path;
 689         struct btrfs_key key;
 690
 691         path = btrfs_alloc_path();
 692         if (!path)
 693                 return -ENOMEM;
 694
 695         key.objectid = src;
 696         key.type = BTRFS_QGROUP_RELATION_KEY;
 697         key.offset = dst;
 698
 699         ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1);
 700         if (ret < 0)
 701                 goto out;
 702
 703         if (ret > 0) {
 704                 ret = -ENOENT;
 705                 goto out;
 706         }
 707
 708         ret = btrfs_del_item(trans, quota_root, path);
 709 out:
 710         btrfs_free_path(path);
 711         return ret;
 712 }
 713
 714 static int add_qgroup_item(struct btrfs_trans_handle *trans,
 715                            struct btrfs_root *quota_root, u64 qgroupid)
 716 {
 717         int ret;
 718         struct btrfs_path *path;
 719         struct btrfs_qgroup_info_item *qgroup_info;
 720         struct btrfs_qgroup_limit_item *qgroup_limit;
 721         struct extent_buffer *leaf;
 722         struct btrfs_key key;
 723
 724         if (btrfs_is_testing(quota_root->fs_info))
 725                 return 0;
 726
 727         path = btrfs_alloc_path();
 728         if (!path)
 729                 return -ENOMEM;
 730
 731         key.objectid = 0;
 732         key.type = BTRFS_QGROUP_INFO_KEY;
 733         key.offset = qgroupid;
 734
 735         /*
 736          * Avoid a transaction abort by catching -EEXIST here. In that
 737          * case, we proceed by re-initializing the existing structure
 738          * on disk.
 739          */
 740
 741         ret = btrfs_insert_empty_item(trans, quota_root, path, &key,
 742                                       sizeof(*qgroup_info));
 743         if (ret && ret != -EEXIST)
 744                 goto out;
 745
 746         leaf = path->nodes[0];
 747         qgroup_info = btrfs_item_ptr(leaf, path->slots[0],
 748                                  struct btrfs_qgroup_info_item);
 749         btrfs_set_qgroup_info_generation(leaf, qgroup_info, trans->transid);
 750         btrfs_set_qgroup_info_rfer(leaf, qgroup_info, 0);
 751         btrfs_set_qgroup_info_rfer_cmpr(leaf, qgroup_info, 0);
 752         btrfs_set_qgroup_info_excl(leaf, qgroup_info, 0);
 753         btrfs_set_qgroup_info_excl_cmpr(leaf, qgroup_info, 0);
 754
 755         btrfs_mark_buffer_dirty(trans, leaf);
 756
 757         btrfs_release_path(path);
 758
 759         key.type = BTRFS_QGROUP_LIMIT_KEY;
 760         ret = btrfs_insert_empty_item(trans, quota_root, path, &key,
 761                                       sizeof(*qgroup_limit));
 762         if (ret && ret != -EEXIST)
 763                 goto out;
 764
 765         leaf = path->nodes[0];
 766         qgroup_limit = btrfs_item_ptr(leaf, path->slots[0],
 767                                   struct btrfs_qgroup_limit_item);
 768         btrfs_set_qgroup_limit_flags(leaf, qgroup_limit, 0);
 769         btrfs_set_qgroup_limit_max_rfer(leaf, qgroup_limit, 0);
 770         btrfs_set_qgroup_limit_max_excl(leaf, qgroup_limit, 0);
 771         btrfs_set_qgroup_limit_rsv_rfer(leaf, qgroup_limit, 0);
 772         btrfs_set_qgroup_limit_rsv_excl(leaf, qgroup_limit, 0);
 773
 774         btrfs_mark_buffer_dirty(trans, leaf);
 775
 776         ret = 0;
 777 out:
 778         btrfs_free_path(path);
 779         return ret;
 780 }
 781
 782 static int del_qgroup_item(struct btrfs_trans_handle *trans, u64 qgroupid)
 783 {
 784         int ret;
 785         struct btrfs_root *quota_root = trans->fs_info->quota_root;
 786         struct btrfs_path *path;
 787         struct btrfs_key key;
 788
 789         path = btrfs_alloc_path();
 790         if (!path)
 791                 return -ENOMEM;
 792
 793         key.objectid = 0;
 794         key.type = BTRFS_QGROUP_INFO_KEY;
 795         key.offset = qgroupid;
 796         ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1);
 797         if (ret < 0)
 798                 goto out;
 799
 800         if (ret > 0) {
 801                 ret = -ENOENT;
 802                 goto out;
 803         }
 804
 805         ret = btrfs_del_item(trans, quota_root, path);
 806         if (ret)
 807                 goto out;
 808
 809         btrfs_release_path(path);
 810
 811         key.type = BTRFS_QGROUP_LIMIT_KEY;
 812         ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1);
 813         if (ret < 0)
 814                 goto out;
 815
 816         if (ret > 0) {
 817                 ret = -ENOENT;
 818                 goto out;
 819         }
 820
 821         ret = btrfs_del_item(trans, quota_root, path);
 822
 823 out:
 824         btrfs_free_path(path);
 825         return ret;
 826 }
 827
 828 static int update_qgroup_limit_item(struct btrfs_trans_handle *trans,
 829                                     struct btrfs_qgroup *qgroup)
 830 {
 831         struct btrfs_root *quota_root = trans->fs_info->quota_root;
 832         struct btrfs_path *path;
 833         struct btrfs_key key;
 834         struct extent_buffer *l;
 835         struct btrfs_qgroup_limit_item *qgroup_limit;
 836         int ret;
 837         int slot;
 838
 839         key.objectid = 0;
 840         key.type = BTRFS_QGROUP_LIMIT_KEY;
 841         key.offset = qgroup->qgroupid;
 842
 843         path = btrfs_alloc_path();
 844         if (!path)
 845                 return -ENOMEM;
 846
 847         ret = btrfs_search_slot(trans, quota_root, &key, path, 0, 1);
 848         if (ret > 0)
 849                 ret = -ENOENT;
 850
 851         if (ret)
 852                 goto out;
 853
 854         l = path->nodes[0];
 855         slot = path->slots[0];
 856         qgroup_limit = btrfs_item_ptr(l, slot, struct btrfs_qgroup_limit_item);
 857         btrfs_set_qgroup_limit_flags(l, qgroup_limit, qgroup->lim_flags);
 858         btrfs_set_qgroup_limit_max_rfer(l, qgroup_limit, qgroup->max_rfer);
 859         btrfs_set_qgroup_limit_max_excl(l, qgroup_limit, qgroup->max_excl);
 860         btrfs_set_qgroup_limit_rsv_rfer(l, qgroup_limit, qgroup->rsv_rfer);
 861         btrfs_set_qgroup_limit_rsv_excl(l, qgroup_limit, qgroup->rsv_excl);
 862
 863         btrfs_mark_buffer_dirty(trans, l);
 864
 865 out:
 866         btrfs_free_path(path);
 867         return ret;
 868 }
 869
 870 static int update_qgroup_info_item(struct btrfs_trans_handle *trans,
 871                                    struct btrfs_qgroup *qgroup)
 872 {
 873         struct btrfs_fs_info *fs_info = trans->fs_info;
 874         struct btrfs_root *quota_root = fs_info->quota_root;
 875         struct btrfs_path *path;
 876         struct btrfs_key key;
 877         struct extent_buffer *l;
 878         struct btrfs_qgroup_info_item *qgroup_info;
 879         int ret;
 880         int slot;
 881
 882         if (btrfs_is_testing(fs_info))
 883                 return 0;
 884
 885         key.objectid = 0;
 886         key.type = BTRFS_QGROUP_INFO_KEY;
 887         key.offset = qgroup->qgroupid;
 888
 889         path = btrfs_alloc_path();
 890         if (!path)
 891                 return -ENOMEM;
 892
 893         ret = btrfs_search_slot(trans, quota_root, &key, path, 0, 1);
 894         if (ret > 0)
 895                 ret = -ENOENT;
 896
 897         if (ret)
 898                 goto out;
 899
 900         l = path->nodes[0];
 901         slot = path->slots[0];
 902         qgroup_info = btrfs_item_ptr(l, slot, struct btrfs_qgroup_info_item);
 903         btrfs_set_qgroup_info_generation(l, qgroup_info, trans->transid);
 904         btrfs_set_qgroup_info_rfer(l, qgroup_info, qgroup->rfer);
 905         btrfs_set_qgroup_info_rfer_cmpr(l, qgroup_info, qgroup->rfer_cmpr);
 906         btrfs_set_qgroup_info_excl(l, qgroup_info, qgroup->excl);
 907         btrfs_set_qgroup_info_excl_cmpr(l, qgroup_info, qgroup->excl_cmpr);
 908
 909         btrfs_mark_buffer_dirty(trans, l);
 910
 911 out:
 912         btrfs_free_path(path);
 913         return ret;
 914 }
 915
 916 static int update_qgroup_status_item(struct btrfs_trans_handle *trans)
 917 {
 918         struct btrfs_fs_info *fs_info = trans->fs_info;
 919         struct btrfs_root *quota_root = fs_info->quota_root;
 920         struct btrfs_path *path;
 921         struct btrfs_key key;
 922         struct extent_buffer *l;
 923         struct btrfs_qgroup_status_item *ptr;
 924         int ret;
 925         int slot;
 926
 927         key.objectid = 0;
 928         key.type = BTRFS_QGROUP_STATUS_KEY;
 929         key.offset = 0;
 930
 931         path = btrfs_alloc_path();
 932         if (!path)
 933                 return -ENOMEM;
 934
 935         ret = btrfs_search_slot(trans, quota_root, &key, path, 0, 1);
 936         if (ret > 0)
 937                 ret = -ENOENT;
 938
 939         if (ret)
 940                 goto out;
 941
 942         l = path->nodes[0];
 943         slot = path->slots[0];
 944         ptr = btrfs_item_ptr(l, slot, struct btrfs_qgroup_status_item);
 945         btrfs_set_qgroup_status_flags(l, ptr, fs_info->qgroup_flags &
 946                                       BTRFS_QGROUP_STATUS_FLAGS_MASK);
 947         btrfs_set_qgroup_status_generation(l, ptr, trans->transid);
 948         btrfs_set_qgroup_status_rescan(l, ptr,
 949                                 fs_info->qgroup_rescan_progress.objectid);
 950
 951         btrfs_mark_buffer_dirty(trans, l);
 952
 953 out:
 954         btrfs_free_path(path);
 955         return ret;
 956 }
 957
 958 /*
 959  * called with qgroup_lock held
 960  */
 961 static int btrfs_clean_quota_tree(struct btrfs_trans_handle *trans,
 962                                   struct btrfs_root *root)
 963 {
 964         struct btrfs_path *path;
 965         struct btrfs_key key;
 966         struct extent_buffer *leaf = NULL;
 967         int ret;
 968         int nr = 0;
 969
 970         path = btrfs_alloc_path();
 971         if (!path)
 972                 return -ENOMEM;
 973
 974         key.objectid = 0;
 975         key.offset = 0;
 976         key.type = 0;
 977
 978         while (1) {
 979                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 980                 if (ret < 0)
 981                         goto out;
 982                 leaf = path->nodes[0];
 983                 nr = btrfs_header_nritems(leaf);
 984                 if (!nr)
 985                         break;
 986                 /*
 987                  * delete the leaf one by one
 988                  * since the whole tree is going
 989                  * to be deleted.
 990                  */
 991                 path->slots[0] = 0;
 992                 ret = btrfs_del_items(trans, root, path, 0, nr);
 993                 if (ret)
 994                         goto out;
 995
 996                 btrfs_release_path(path);
 997         }
 998         ret = 0;
 999 out:
1000         btrfs_free_path(path);
1001         return ret;
1002 }
1003
1004 int btrfs_quota_enable(struct btrfs_fs_info *fs_info,
1005                        struct btrfs_ioctl_quota_ctl_args *quota_ctl_args)
1006 {
1007         struct btrfs_root *quota_root;
1008         struct btrfs_root *tree_root = fs_info->tree_root;
1009         struct btrfs_path *path = NULL;
1010         struct btrfs_qgroup_status_item *ptr;
1011         struct extent_buffer *leaf;
1012         struct btrfs_key key;
1013         struct btrfs_key found_key;
1014         struct btrfs_qgroup *qgroup = NULL;
1015         struct btrfs_qgroup *prealloc = NULL;
1016         struct btrfs_trans_handle *trans = NULL;
1017         struct ulist *ulist = NULL;
1018         const bool simple = (quota_ctl_args->cmd == BTRFS_QUOTA_CTL_ENABLE_SIMPLE_QUOTA);
1019         int ret = 0;
1020         int slot;
1021
1022         /*
1023          * We need to have subvol_sem write locked, to prevent races between
1024          * concurrent tasks trying to enable quotas, because we will unlock
1025          * and relock qgroup_ioctl_lock before setting fs_info->quota_root
1026          * and before setting BTRFS_FS_QUOTA_ENABLED.
1027          */
1028         lockdep_assert_held_write(&fs_info->subvol_sem);
1029
1030         if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
1031                 btrfs_err(fs_info,
1032                           "qgroups are currently unsupported in extent tree v2");
1033                 return -EINVAL;
1034         }
1035
1036         mutex_lock(&fs_info->qgroup_ioctl_lock);
1037         if (fs_info->quota_root)
1038                 goto out;
1039
1040         ulist = ulist_alloc(GFP_KERNEL);
1041         if (!ulist) {
1042                 ret = -ENOMEM;
1043                 goto out;
1044         }
1045
1046         ret = btrfs_sysfs_add_qgroups(fs_info);
1047         if (ret < 0)
1048                 goto out;
1049
1050         /*
1051          * Unlock qgroup_ioctl_lock before starting the transaction. This is to
1052          * avoid lock acquisition inversion problems (reported by lockdep) between
1053          * qgroup_ioctl_lock and the vfs freeze semaphores, acquired when we
1054          * start a transaction.
1055          * After we started the transaction lock qgroup_ioctl_lock again and
1056          * check if someone else created the quota root in the meanwhile. If so,
1057          * just return success and release the transaction handle.
1058          *
1059          * Also we don't need to worry about someone else calling
1060          * btrfs_sysfs_add_qgroups() after we unlock and getting an error because
1061          * that function returns 0 (success) when the sysfs entries already exist.
1062          */
1063         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1064
1065         /*
1066          * 1 for quota root item
1067          * 1 for BTRFS_QGROUP_STATUS item
1068          *
1069          * Yet we also need 2*n items for a QGROUP_INFO/QGROUP_LIMIT items
1070          * per subvolume. However those are not currently reserved since it
1071          * would be a lot of overkill.
1072          */
1073         trans = btrfs_start_transaction(tree_root, 2);
1074
1075         mutex_lock(&fs_info->qgroup_ioctl_lock);
1076         if (IS_ERR(trans)) {
1077                 ret = PTR_ERR(trans);
1078                 trans = NULL;
1079                 goto out;
1080         }
1081
1082         if (fs_info->quota_root)
1083                 goto out;
1084
1085         fs_info->qgroup_ulist = ulist;
1086         ulist = NULL;
1087
1088         /*
1089          * initially create the quota tree
1090          */
1091         quota_root = btrfs_create_tree(trans, BTRFS_QUOTA_TREE_OBJECTID);
1092         if (IS_ERR(quota_root)) {
1093                 ret =  PTR_ERR(quota_root);
1094                 btrfs_abort_transaction(trans, ret);
1095                 goto out;
1096         }
1097
1098         path = btrfs_alloc_path();
1099         if (!path) {
1100                 ret = -ENOMEM;
1101                 btrfs_abort_transaction(trans, ret);
1102                 goto out_free_root;
1103         }
1104
1105         key.objectid = 0;
1106         key.type = BTRFS_QGROUP_STATUS_KEY;
1107         key.offset = 0;
1108
1109         ret = btrfs_insert_empty_item(trans, quota_root, path, &key,
1110                                       sizeof(*ptr));
1111         if (ret) {
1112                 btrfs_abort_transaction(trans, ret);
1113                 goto out_free_path;
1114         }
1115
1116         leaf = path->nodes[0];
1117         ptr = btrfs_item_ptr(leaf, path->slots[0],
1118                                  struct btrfs_qgroup_status_item);
1119         btrfs_set_qgroup_status_generation(leaf, ptr, trans->transid);
1120         btrfs_set_qgroup_status_version(leaf, ptr, BTRFS_QGROUP_STATUS_VERSION);
1121         fs_info->qgroup_flags = BTRFS_QGROUP_STATUS_FLAG_ON;
1122         if (simple) {
1123                 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE;
1124                 btrfs_set_fs_incompat(fs_info, SIMPLE_QUOTA);
1125                 btrfs_set_qgroup_status_enable_gen(leaf, ptr, trans->transid);
1126         } else {
1127                 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
1128         }
1129         btrfs_set_qgroup_status_flags(leaf, ptr, fs_info->qgroup_flags &
1130                                       BTRFS_QGROUP_STATUS_FLAGS_MASK);
1131         btrfs_set_qgroup_status_rescan(leaf, ptr, 0);
1132
1133         btrfs_mark_buffer_dirty(trans, leaf);
1134
1135         key.objectid = 0;
1136         key.type = BTRFS_ROOT_REF_KEY;
1137         key.offset = 0;
1138
1139         btrfs_release_path(path);
1140         ret = btrfs_search_slot_for_read(tree_root, &key, path, 1, 0);
1141         if (ret > 0)
1142                 goto out_add_root;
1143         if (ret < 0) {
1144                 btrfs_abort_transaction(trans, ret);
1145                 goto out_free_path;
1146         }
1147
1148         while (1) {
1149                 slot = path->slots[0];
1150                 leaf = path->nodes[0];
1151                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
1152
1153                 if (found_key.type == BTRFS_ROOT_REF_KEY) {
1154
1155                         /* Release locks on tree_root before we access quota_root */
1156                         btrfs_release_path(path);
1157
1158                         /* We should not have a stray @prealloc pointer. */
1159                         ASSERT(prealloc == NULL);
1160                         prealloc = kzalloc(sizeof(*prealloc), GFP_NOFS);
1161                         if (!prealloc) {
1162                                 ret = -ENOMEM;
1163                                 btrfs_abort_transaction(trans, ret);
1164                                 goto out_free_path;
1165                         }
1166
1167                         ret = add_qgroup_item(trans, quota_root,
1168                                               found_key.offset);
1169                         if (ret) {
1170                                 btrfs_abort_transaction(trans, ret);
1171                                 goto out_free_path;
1172                         }
1173
1174                         qgroup = add_qgroup_rb(fs_info, prealloc, found_key.offset);
1175                         prealloc = NULL;
1176                         if (IS_ERR(qgroup)) {
1177                                 ret = PTR_ERR(qgroup);
1178                                 btrfs_abort_transaction(trans, ret);
1179                                 goto out_free_path;
1180                         }
1181                         ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
1182                         if (ret < 0) {
1183                                 btrfs_abort_transaction(trans, ret);
1184                                 goto out_free_path;
1185                         }
1186                         ret = btrfs_search_slot_for_read(tree_root, &found_key,
1187                                                          path, 1, 0);
1188                         if (ret < 0) {
1189                                 btrfs_abort_transaction(trans, ret);
1190                                 goto out_free_path;
1191                         }
1192                         if (ret > 0) {
1193                                 /*
1194                                  * Shouldn't happen, but in case it does we
1195                                  * don't need to do the btrfs_next_item, just
1196                                  * continue.
1197                                  */
1198                                 continue;
1199                         }
1200                 }
1201                 ret = btrfs_next_item(tree_root, path);
1202                 if (ret < 0) {
1203                         btrfs_abort_transaction(trans, ret);
1204                         goto out_free_path;
1205                 }
1206                 if (ret)
1207                         break;
1208         }
1209
1210 out_add_root:
1211         btrfs_release_path(path);
1212         ret = add_qgroup_item(trans, quota_root, BTRFS_FS_TREE_OBJECTID);
1213         if (ret) {
1214                 btrfs_abort_transaction(trans, ret);
1215                 goto out_free_path;
1216         }
1217
1218         ASSERT(prealloc == NULL);
1219         prealloc = kzalloc(sizeof(*prealloc), GFP_NOFS);
1220         if (!prealloc) {
1221                 ret = -ENOMEM;
1222                 goto out_free_path;
1223         }
1224         qgroup = add_qgroup_rb(fs_info, prealloc, BTRFS_FS_TREE_OBJECTID);
1225         prealloc = NULL;
1226         ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
1227         if (ret < 0) {
1228                 btrfs_abort_transaction(trans, ret);
1229                 goto out_free_path;
1230         }
1231
1232         fs_info->qgroup_enable_gen = trans->transid;
1233
1234         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1235         /*
1236          * Commit the transaction while not holding qgroup_ioctl_lock, to avoid
1237          * a deadlock with tasks concurrently doing other qgroup operations, such
1238          * adding/removing qgroups or adding/deleting qgroup relations for example,
1239          * because all qgroup operations first start or join a transaction and then
1240          * lock the qgroup_ioctl_lock mutex.
1241          * We are safe from a concurrent task trying to enable quotas, by calling
1242          * this function, since we are serialized by fs_info->subvol_sem.
1243          */
1244         ret = btrfs_commit_transaction(trans);
1245         trans = NULL;
1246         mutex_lock(&fs_info->qgroup_ioctl_lock);
1247         if (ret)
1248                 goto out_free_path;
1249
1250         /*
1251          * Set quota enabled flag after committing the transaction, to avoid
1252          * deadlocks on fs_info->qgroup_ioctl_lock with concurrent snapshot
1253          * creation.
1254          */
1255         spin_lock(&fs_info->qgroup_lock);
1256         fs_info->quota_root = quota_root;
1257         set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
1258         spin_unlock(&fs_info->qgroup_lock);
1259
1260         /* Skip rescan for simple qgroups. */
1261         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)
1262                 goto out_free_path;
1263
1264         ret = qgroup_rescan_init(fs_info, 0, 1);
1265         if (!ret) {
1266                 qgroup_rescan_zero_tracking(fs_info);
1267                 fs_info->qgroup_rescan_running = true;
1268                 btrfs_queue_work(fs_info->qgroup_rescan_workers,
1269                                  &fs_info->qgroup_rescan_work);
1270         } else {
1271                 /*
1272                  * We have set both BTRFS_FS_QUOTA_ENABLED and
1273                  * BTRFS_QGROUP_STATUS_FLAG_ON, so we can only fail with
1274                  * -EINPROGRESS. That can happen because someone started the
1275                  * rescan worker by calling quota rescan ioctl before we
1276                  * attempted to initialize the rescan worker. Failure due to
1277                  * quotas disabled in the meanwhile is not possible, because
1278                  * we are holding a write lock on fs_info->subvol_sem, which
1279                  * is also acquired when disabling quotas.
1280                  * Ignore such error, and any other error would need to undo
1281                  * everything we did in the transaction we just committed.
1282                  */
1283                 ASSERT(ret == -EINPROGRESS);
1284                 ret = 0;
1285         }
1286
1287 out_free_path:
1288         btrfs_free_path(path);
1289 out_free_root:
1290         if (ret)
1291                 btrfs_put_root(quota_root);
1292 out:
1293         if (ret) {
1294                 ulist_free(fs_info->qgroup_ulist);
1295                 fs_info->qgroup_ulist = NULL;
1296                 btrfs_sysfs_del_qgroups(fs_info);
1297         }
1298         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1299         if (ret && trans)
1300                 btrfs_end_transaction(trans);
1301         else if (trans)
1302                 ret = btrfs_end_transaction(trans);
1303         ulist_free(ulist);
1304         kfree(prealloc);
1305         return ret;
1306 }
1307
1308 /*
1309  * It is possible to have outstanding ordered extents which reserved bytes
1310  * before we disabled. We need to fully flush delalloc, ordered extents, and a
1311  * commit to ensure that we don't leak such reservations, only to have them
1312  * come back if we re-enable.
1313  *
1314  * - enable simple quotas
1315  * - reserve space
1316  * - release it, store rsv_bytes in OE
1317  * - disable quotas
1318  * - enable simple quotas (qgroup rsv are all 0)
1319  * - OE finishes
1320  * - run delayed refs
1321  * - free rsv_bytes, resulting in miscounting or even underflow
1322  */
1323 static int flush_reservations(struct btrfs_fs_info *fs_info)
1324 {
1325         int ret;
1326
1327         ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);
1328         if (ret)
1329                 return ret;
1330         btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);
1331
1332         return btrfs_commit_current_transaction(fs_info->tree_root);
1333 }
1334
1335 int btrfs_quota_disable(struct btrfs_fs_info *fs_info)
1336 {
1337         struct btrfs_root *quota_root = NULL;
1338         struct btrfs_trans_handle *trans = NULL;
1339         int ret = 0;
1340
1341         /*
1342          * We need to have subvol_sem write locked to prevent races with
1343          * snapshot creation.
1344          */
1345         lockdep_assert_held_write(&fs_info->subvol_sem);
1346
1347         /*
1348          * Relocation will mess with backrefs, so make sure we have the
1349          * cleaner_mutex held to protect us from relocate.
1350          */
1351         lockdep_assert_held(&fs_info->cleaner_mutex);
1352
1353         mutex_lock(&fs_info->qgroup_ioctl_lock);
1354         if (!fs_info->quota_root)
1355                 goto out;
1356
1357         /*
1358          * Unlock the qgroup_ioctl_lock mutex before waiting for the rescan worker to
1359          * complete. Otherwise we can deadlock because btrfs_remove_qgroup() needs
1360          * to lock that mutex while holding a transaction handle and the rescan
1361          * worker needs to commit a transaction.
1362          */
1363         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1364
1365         /*
1366          * Request qgroup rescan worker to complete and wait for it. This wait
1367          * must be done before transaction start for quota disable since it may
1368          * deadlock with transaction by the qgroup rescan worker.
1369          */
1370         clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
1371         btrfs_qgroup_wait_for_completion(fs_info, false);
1372
1373         /*
1374          * We have nothing held here and no trans handle, just return the error
1375          * if there is one.
1376          */
1377         ret = flush_reservations(fs_info);
1378         if (ret)
1379                 return ret;
1380
1381         /*
1382          * 1 For the root item
1383          *
1384          * We should also reserve enough items for the quota tree deletion in
1385          * btrfs_clean_quota_tree but this is not done.
1386          *
1387          * Also, we must always start a transaction without holding the mutex
1388          * qgroup_ioctl_lock, see btrfs_quota_enable().
1389          */
1390         trans = btrfs_start_transaction(fs_info->tree_root, 1);
1391
1392         mutex_lock(&fs_info->qgroup_ioctl_lock);
1393         if (IS_ERR(trans)) {
1394                 ret = PTR_ERR(trans);
1395                 trans = NULL;
1396                 set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
1397                 goto out;
1398         }
1399
1400         if (!fs_info->quota_root)
1401                 goto out;
1402
1403         spin_lock(&fs_info->qgroup_lock);
1404         quota_root = fs_info->quota_root;
1405         fs_info->quota_root = NULL;
1406         fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;
1407         fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE;
1408         fs_info->qgroup_drop_subtree_thres = BTRFS_QGROUP_DROP_SUBTREE_THRES_DEFAULT;
1409         spin_unlock(&fs_info->qgroup_lock);
1410
1411         btrfs_free_qgroup_config(fs_info);
1412
1413         ret = btrfs_clean_quota_tree(trans, quota_root);
1414         if (ret) {
1415                 btrfs_abort_transaction(trans, ret);
1416                 goto out;
1417         }
1418
1419         ret = btrfs_del_root(trans, &quota_root->root_key);
1420         if (ret) {
1421                 btrfs_abort_transaction(trans, ret);
1422                 goto out;
1423         }
1424
1425         spin_lock(&fs_info->trans_lock);
1426         list_del(&quota_root->dirty_list);
1427         spin_unlock(&fs_info->trans_lock);
1428
1429         btrfs_tree_lock(quota_root->node);
1430         btrfs_clear_buffer_dirty(trans, quota_root->node);
1431         btrfs_tree_unlock(quota_root->node);
1432         ret = btrfs_free_tree_block(trans, btrfs_root_id(quota_root),
1433                                     quota_root->node, 0, 1);
1434
1435         if (ret < 0)
1436                 btrfs_abort_transaction(trans, ret);
1437
1438 out:
1439         btrfs_put_root(quota_root);
1440         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1441         if (ret && trans)
1442                 btrfs_end_transaction(trans);
1443         else if (trans)
1444                 ret = btrfs_commit_transaction(trans);
1445         return ret;
1446 }
1447
1448 static void qgroup_dirty(struct btrfs_fs_info *fs_info,
1449                          struct btrfs_qgroup *qgroup)
1450 {
1451         if (list_empty(&qgroup->dirty))
1452                 list_add(&qgroup->dirty, &fs_info->dirty_qgroups);
1453 }
1454
1455 static void qgroup_iterator_add(struct list_head *head, struct btrfs_qgroup *qgroup)
1456 {
1457         if (!list_empty(&qgroup->iterator))
1458                 return;
1459
1460         list_add_tail(&qgroup->iterator, head);
1461 }
1462
1463 static void qgroup_iterator_clean(struct list_head *head)
1464 {
1465         while (!list_empty(head)) {
1466                 struct btrfs_qgroup *qgroup;
1467
1468                 qgroup = list_first_entry(head, struct btrfs_qgroup, iterator);
1469                 list_del_init(&qgroup->iterator);
1470         }
1471 }
1472
1473 /*
1474  * The easy accounting, we're updating qgroup relationship whose child qgroup
1475  * only has exclusive extents.
1476  *
1477  * In this case, all exclusive extents will also be exclusive for parent, so
1478  * excl/rfer just get added/removed.
1479  *
1480  * So is qgroup reservation space, which should also be added/removed to
1481  * parent.
1482  * Or when child tries to release reservation space, parent will underflow its
1483  * reservation (for relationship adding case).
1484  *
1485  * Caller should hold fs_info->qgroup_lock.
1486  */
1487 static int __qgroup_excl_accounting(struct btrfs_fs_info *fs_info, u64 ref_root,
1488                                     struct btrfs_qgroup *src, int sign)
1489 {
1490         struct btrfs_qgroup *qgroup;
1491         struct btrfs_qgroup *cur;
1492         LIST_HEAD(qgroup_list);
1493         u64 num_bytes = src->excl;
1494         int ret = 0;
1495
1496         qgroup = find_qgroup_rb(fs_info, ref_root);
1497         if (!qgroup)
1498                 goto out;
1499
1500         qgroup_iterator_add(&qgroup_list, qgroup);
1501         list_for_each_entry(cur, &qgroup_list, iterator) {
1502                 struct btrfs_qgroup_list *glist;
1503
1504                 qgroup->rfer += sign * num_bytes;
1505                 qgroup->rfer_cmpr += sign * num_bytes;
1506
1507                 WARN_ON(sign < 0 && qgroup->excl < num_bytes);
1508                 qgroup->excl += sign * num_bytes;
1509                 qgroup->excl_cmpr += sign * num_bytes;
1510
1511                 if (sign > 0)
1512                         qgroup_rsv_add_by_qgroup(fs_info, qgroup, src);
1513                 else
1514                         qgroup_rsv_release_by_qgroup(fs_info, qgroup, src);
1515                 qgroup_dirty(fs_info, qgroup);
1516
1517                 /* Append parent qgroups to @qgroup_list. */
1518                 list_for_each_entry(glist, &qgroup->groups, next_group)
1519                         qgroup_iterator_add(&qgroup_list, glist->group);
1520         }
1521         ret = 0;
1522 out:
1523         qgroup_iterator_clean(&qgroup_list);
1524         return ret;
1525 }
1526
1527
1528 /*
1529  * Quick path for updating qgroup with only excl refs.
1530  *
1531  * In that case, just update all parent will be enough.
1532  * Or we needs to do a full rescan.
1533  * Caller should also hold fs_info->qgroup_lock.
1534  *
1535  * Return 0 for quick update, return >0 for need to full rescan
1536  * and mark INCONSISTENT flag.
1537  * Return < 0 for other error.
1538  */
1539 static int quick_update_accounting(struct btrfs_fs_info *fs_info,
1540                                    u64 src, u64 dst, int sign)
1541 {
1542         struct btrfs_qgroup *qgroup;
1543         int ret = 1;
1544
1545         qgroup = find_qgroup_rb(fs_info, src);
1546         if (!qgroup)
1547                 goto out;
1548         if (qgroup->excl == qgroup->rfer) {
1549                 ret = __qgroup_excl_accounting(fs_info, dst, qgroup, sign);
1550                 if (ret < 0)
1551                         goto out;
1552                 ret = 0;
1553         }
1554 out:
1555         if (ret)
1556                 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
1557         return ret;
1558 }
1559
1560 /*
1561  * Add relation between @src and @dst qgroup. The @prealloc is allocated by the
1562  * callers and transferred here (either used or freed on error).
1563  */
1564 int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans, u64 src, u64 dst,
1565                               struct btrfs_qgroup_list *prealloc)
1566 {
1567         struct btrfs_fs_info *fs_info = trans->fs_info;
1568         struct btrfs_qgroup *parent;
1569         struct btrfs_qgroup *member;
1570         struct btrfs_qgroup_list *list;
1571         int ret = 0;
1572
1573         ASSERT(prealloc);
1574
1575         /* Check the level of src and dst first */
1576         if (btrfs_qgroup_level(src) >= btrfs_qgroup_level(dst))
1577                 return -EINVAL;
1578
1579         mutex_lock(&fs_info->qgroup_ioctl_lock);
1580         if (!fs_info->quota_root) {
1581                 ret = -ENOTCONN;
1582                 goto out;
1583         }
1584         member = find_qgroup_rb(fs_info, src);
1585         parent = find_qgroup_rb(fs_info, dst);
1586         if (!member || !parent) {
1587                 ret = -EINVAL;
1588                 goto out;
1589         }
1590
1591         /* check if such qgroup relation exist firstly */
1592         list_for_each_entry(list, &member->groups, next_group) {
1593                 if (list->group == parent) {
1594                         ret = -EEXIST;
1595                         goto out;
1596                 }
1597         }
1598
1599         ret = add_qgroup_relation_item(trans, src, dst);
1600         if (ret)
1601                 goto out;
1602
1603         ret = add_qgroup_relation_item(trans, dst, src);
1604         if (ret) {
1605                 del_qgroup_relation_item(trans, src, dst);
1606                 goto out;
1607         }
1608
1609         spin_lock(&fs_info->qgroup_lock);
1610         ret = __add_relation_rb(prealloc, member, parent);
1611         prealloc = NULL;
1612         if (ret < 0) {
1613                 spin_unlock(&fs_info->qgroup_lock);
1614                 goto out;
1615         }
1616         ret = quick_update_accounting(fs_info, src, dst, 1);
1617         spin_unlock(&fs_info->qgroup_lock);
1618 out:
1619         kfree(prealloc);
1620         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1621         return ret;
1622 }
1623
1624 static int __del_qgroup_relation(struct btrfs_trans_handle *trans, u64 src,
1625                                  u64 dst)
1626 {
1627         struct btrfs_fs_info *fs_info = trans->fs_info;
1628         struct btrfs_qgroup *parent;
1629         struct btrfs_qgroup *member;
1630         struct btrfs_qgroup_list *list;
1631         bool found = false;
1632         int ret = 0;
1633         int ret2;
1634
1635         if (!fs_info->quota_root) {
1636                 ret = -ENOTCONN;
1637                 goto out;
1638         }
1639
1640         member = find_qgroup_rb(fs_info, src);
1641         parent = find_qgroup_rb(fs_info, dst);
1642         /*
1643          * The parent/member pair doesn't exist, then try to delete the dead
1644          * relation items only.
1645          */
1646         if (!member || !parent)
1647                 goto delete_item;
1648
1649         /* check if such qgroup relation exist firstly */
1650         list_for_each_entry(list, &member->groups, next_group) {
1651                 if (list->group == parent) {
1652                         found = true;
1653                         break;
1654                 }
1655         }
1656
1657 delete_item:
1658         ret = del_qgroup_relation_item(trans, src, dst);
1659         if (ret < 0 && ret != -ENOENT)
1660                 goto out;
1661         ret2 = del_qgroup_relation_item(trans, dst, src);
1662         if (ret2 < 0 && ret2 != -ENOENT)
1663                 goto out;
1664
1665         /* At least one deletion succeeded, return 0 */
1666         if (!ret || !ret2)
1667                 ret = 0;
1668
1669         if (found) {
1670                 spin_lock(&fs_info->qgroup_lock);
1671                 del_relation_rb(fs_info, src, dst);
1672                 ret = quick_update_accounting(fs_info, src, dst, -1);
1673                 spin_unlock(&fs_info->qgroup_lock);
1674         }
1675 out:
1676         return ret;
1677 }
1678
1679 int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans, u64 src,
1680                               u64 dst)
1681 {
1682         struct btrfs_fs_info *fs_info = trans->fs_info;
1683         int ret = 0;
1684
1685         mutex_lock(&fs_info->qgroup_ioctl_lock);
1686         ret = __del_qgroup_relation(trans, src, dst);
1687         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1688
1689         return ret;
1690 }
1691
1692 int btrfs_create_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid)
1693 {
1694         struct btrfs_fs_info *fs_info = trans->fs_info;
1695         struct btrfs_root *quota_root;
1696         struct btrfs_qgroup *qgroup;
1697         struct btrfs_qgroup *prealloc = NULL;
1698         int ret = 0;
1699
1700         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED)
1701                 return 0;
1702
1703         mutex_lock(&fs_info->qgroup_ioctl_lock);
1704         if (!fs_info->quota_root) {
1705                 ret = -ENOTCONN;
1706                 goto out;
1707         }
1708         quota_root = fs_info->quota_root;
1709         qgroup = find_qgroup_rb(fs_info, qgroupid);
1710         if (qgroup) {
1711                 ret = -EEXIST;
1712                 goto out;
1713         }
1714
1715         prealloc = kzalloc(sizeof(*prealloc), GFP_NOFS);
1716         if (!prealloc) {
1717                 ret = -ENOMEM;
1718                 goto out;
1719         }
1720
1721         ret = add_qgroup_item(trans, quota_root, qgroupid);
1722         if (ret)
1723                 goto out;
1724
1725         spin_lock(&fs_info->qgroup_lock);
1726         qgroup = add_qgroup_rb(fs_info, prealloc, qgroupid);
1727         spin_unlock(&fs_info->qgroup_lock);
1728         prealloc = NULL;
1729
1730         ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
1731 out:
1732         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1733         kfree(prealloc);
1734         return ret;
1735 }
1736
1737 /*
1738  * Return 0 if we can not delete the qgroup (not empty or has children etc).
1739  * Return >0 if we can delete the qgroup.
1740  * Return <0 for other errors during tree search.
1741  */
1742 static int can_delete_qgroup(struct btrfs_fs_info *fs_info, struct btrfs_qgroup *qgroup)
1743 {
1744         struct btrfs_key key;
1745         struct btrfs_path *path;
1746         int ret;
1747
1748         /*
1749          * Squota would never be inconsistent, but there can still be case
1750          * where a dropped subvolume still has qgroup numbers, and squota
1751          * relies on such qgroup for future accounting.
1752          *
1753          * So for squota, do not allow dropping any non-zero qgroup.
1754          */
1755         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE &&
1756             (qgroup->rfer || qgroup->excl || qgroup->excl_cmpr || qgroup->rfer_cmpr))
1757                 return 0;
1758
1759         /* For higher level qgroup, we can only delete it if it has no child. */
1760         if (btrfs_qgroup_level(qgroup->qgroupid)) {
1761                 if (!list_empty(&qgroup->members))
1762                         return 0;
1763                 return 1;
1764         }
1765
1766         /*
1767          * For level-0 qgroups, we can only delete it if it has no subvolume
1768          * for it.
1769          * This means even a subvolume is unlinked but not yet fully dropped,
1770          * we can not delete the qgroup.
1771          */
1772         key.objectid = qgroup->qgroupid;
1773         key.type = BTRFS_ROOT_ITEM_KEY;
1774         key.offset = -1ULL;
1775         path = btrfs_alloc_path();
1776         if (!path)
1777                 return -ENOMEM;
1778
1779         ret = btrfs_find_root(fs_info->tree_root, &key, path, NULL, NULL);
1780         btrfs_free_path(path);
1781         /*
1782          * The @ret from btrfs_find_root() exactly matches our definition for
1783          * the return value, thus can be returned directly.
1784          */
1785         return ret;
1786 }
1787
1788 int btrfs_remove_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid)
1789 {
1790         struct btrfs_fs_info *fs_info = trans->fs_info;
1791         struct btrfs_qgroup *qgroup;
1792         struct btrfs_qgroup_list *list;
1793         int ret = 0;
1794
1795         mutex_lock(&fs_info->qgroup_ioctl_lock);
1796         if (!fs_info->quota_root) {
1797                 ret = -ENOTCONN;
1798                 goto out;
1799         }
1800
1801         qgroup = find_qgroup_rb(fs_info, qgroupid);
1802         if (!qgroup) {
1803                 ret = -ENOENT;
1804                 goto out;
1805         }
1806
1807         ret = can_delete_qgroup(fs_info, qgroup);
1808         if (ret < 0)
1809                 goto out;
1810         if (ret == 0) {
1811                 ret = -EBUSY;
1812                 goto out;
1813         }
1814
1815         /* Check if there are no children of this qgroup */
1816         if (!list_empty(&qgroup->members)) {
1817                 ret = -EBUSY;
1818                 goto out;
1819         }
1820
1821         ret = del_qgroup_item(trans, qgroupid);
1822         if (ret && ret != -ENOENT)
1823                 goto out;
1824
1825         while (!list_empty(&qgroup->groups)) {
1826                 list = list_first_entry(&qgroup->groups,
1827                                         struct btrfs_qgroup_list, next_group);
1828                 ret = __del_qgroup_relation(trans, qgroupid,
1829                                             list->group->qgroupid);
1830                 if (ret)
1831                         goto out;
1832         }
1833
1834         spin_lock(&fs_info->qgroup_lock);
1835         /*
1836          * Warn on reserved space. The subvolume should has no child nor
1837          * corresponding subvolume.
1838          * Thus its reserved space should all be zero, no matter if qgroup
1839          * is consistent or the mode.
1840          */
1841         WARN_ON(qgroup->rsv.values[BTRFS_QGROUP_RSV_DATA] ||
1842                 qgroup->rsv.values[BTRFS_QGROUP_RSV_META_PREALLOC] ||
1843                 qgroup->rsv.values[BTRFS_QGROUP_RSV_META_PERTRANS]);
1844         /*
1845          * The same for rfer/excl numbers, but that's only if our qgroup is
1846          * consistent and if it's in regular qgroup mode.
1847          * For simple mode it's not as accurate thus we can hit non-zero values
1848          * very frequently.
1849          */
1850         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL &&
1851             !(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT)) {
1852                 if (WARN_ON(qgroup->rfer || qgroup->excl ||
1853                             qgroup->rfer_cmpr || qgroup->excl_cmpr)) {
1854                         btrfs_warn_rl(fs_info,
1855 "to be deleted qgroup %u/%llu has non-zero numbers, rfer %llu rfer_cmpr %llu excl %llu excl_cmpr %llu",
1856                                       btrfs_qgroup_level(qgroup->qgroupid),
1857                                       btrfs_qgroup_subvolid(qgroup->qgroupid),
1858                                       qgroup->rfer, qgroup->rfer_cmpr,
1859                                       qgroup->excl, qgroup->excl_cmpr);
1860                         qgroup_mark_inconsistent(fs_info);
1861                 }
1862         }
1863         del_qgroup_rb(fs_info, qgroupid);
1864         spin_unlock(&fs_info->qgroup_lock);
1865
1866         /*
1867          * Remove the qgroup from sysfs now without holding the qgroup_lock
1868          * spinlock, since the sysfs_remove_group() function needs to take
1869          * the mutex kernfs_mutex through kernfs_remove_by_name_ns().
1870          */
1871         btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
1872         kfree(qgroup);
1873 out:
1874         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1875         return ret;
1876 }
1877
1878 int btrfs_qgroup_cleanup_dropped_subvolume(struct btrfs_fs_info *fs_info, u64 subvolid)
1879 {
1880         struct btrfs_trans_handle *trans;
1881         int ret;
1882
1883         if (!is_fstree(subvolid) || !btrfs_qgroup_enabled(fs_info) || !fs_info->quota_root)
1884                 return 0;
1885
1886         /*
1887          * Commit current transaction to make sure all the rfer/excl numbers
1888          * get updated.
1889          */
1890         trans = btrfs_start_transaction(fs_info->quota_root, 0);
1891         if (IS_ERR(trans))
1892                 return PTR_ERR(trans);
1893
1894         ret = btrfs_commit_transaction(trans);
1895         if (ret < 0)
1896                 return ret;
1897
1898         /* Start new trans to delete the qgroup info and limit items. */
1899         trans = btrfs_start_transaction(fs_info->quota_root, 2);
1900         if (IS_ERR(trans))
1901                 return PTR_ERR(trans);
1902         ret = btrfs_remove_qgroup(trans, subvolid);
1903         btrfs_end_transaction(trans);
1904         /*
1905          * It's squota and the subvolume still has numbers needed for future
1906          * accounting, in this case we can not delete it.  Just skip it.
1907          */
1908         if (ret == -EBUSY)
1909                 ret = 0;
1910         return ret;
1911 }
1912
1913 int btrfs_limit_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid,
1914                        struct btrfs_qgroup_limit *limit)
1915 {
1916         struct btrfs_fs_info *fs_info = trans->fs_info;
1917         struct btrfs_qgroup *qgroup;
1918         int ret = 0;
1919         /* Sometimes we would want to clear the limit on this qgroup.
1920          * To meet this requirement, we treat the -1 as a special value
1921          * which tell kernel to clear the limit on this qgroup.
1922          */
1923         const u64 CLEAR_VALUE = -1;
1924
1925         mutex_lock(&fs_info->qgroup_ioctl_lock);
1926         if (!fs_info->quota_root) {
1927                 ret = -ENOTCONN;
1928                 goto out;
1929         }
1930
1931         qgroup = find_qgroup_rb(fs_info, qgroupid);
1932         if (!qgroup) {
1933                 ret = -ENOENT;
1934                 goto out;
1935         }
1936
1937         spin_lock(&fs_info->qgroup_lock);
1938         if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_RFER) {
1939                 if (limit->max_rfer == CLEAR_VALUE) {
1940                         qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER;
1941                         limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER;
1942                         qgroup->max_rfer = 0;
1943                 } else {
1944                         qgroup->max_rfer = limit->max_rfer;
1945                 }
1946         }
1947         if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) {
1948                 if (limit->max_excl == CLEAR_VALUE) {
1949                         qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL;
1950                         limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL;
1951                         qgroup->max_excl = 0;
1952                 } else {
1953                         qgroup->max_excl = limit->max_excl;
1954                 }
1955         }
1956         if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_RFER) {
1957                 if (limit->rsv_rfer == CLEAR_VALUE) {
1958                         qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER;
1959                         limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER;
1960                         qgroup->rsv_rfer = 0;
1961                 } else {
1962                         qgroup->rsv_rfer = limit->rsv_rfer;
1963                 }
1964         }
1965         if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_EXCL) {
1966                 if (limit->rsv_excl == CLEAR_VALUE) {
1967                         qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL;
1968                         limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL;
1969                         qgroup->rsv_excl = 0;
1970                 } else {
1971                         qgroup->rsv_excl = limit->rsv_excl;
1972                 }
1973         }
1974         qgroup->lim_flags |= limit->flags;
1975
1976         spin_unlock(&fs_info->qgroup_lock);
1977
1978         ret = update_qgroup_limit_item(trans, qgroup);
1979         if (ret) {
1980                 qgroup_mark_inconsistent(fs_info);
1981                 btrfs_info(fs_info, "unable to update quota limit for %llu",
1982                        qgroupid);
1983         }
1984
1985 out:
1986         mutex_unlock(&fs_info->qgroup_ioctl_lock);
1987         return ret;
1988 }
1989
1990 /*
1991  * Inform qgroup to trace one dirty extent, its info is recorded in @record.
1992  * So qgroup can account it at transaction committing time.
1993  *
1994  * No lock version, caller must acquire delayed ref lock and allocated memory,
1995  * then call btrfs_qgroup_trace_extent_post() after exiting lock context.
1996  *
1997  * Return 0 for success insert
1998  * Return >0 for existing record, caller can free @record safely.
1999  * Return <0 for insertion failure, caller can free @record safely.
2000  */
2001 int btrfs_qgroup_trace_extent_nolock(struct btrfs_fs_info *fs_info,
2002                                      struct btrfs_delayed_ref_root *delayed_refs,
2003                                      struct btrfs_qgroup_extent_record *record,
2004                                      u64 bytenr)
2005 {
2006         struct btrfs_qgroup_extent_record *existing, *ret;
2007         const unsigned long index = (bytenr >> fs_info->sectorsize_bits);
2008
2009         if (!btrfs_qgroup_full_accounting(fs_info))
2010                 return 1;
2011
2012 #if BITS_PER_LONG == 32
2013         if (bytenr >= MAX_LFS_FILESIZE) {
2014                 btrfs_err_rl(fs_info,
2015 "qgroup record for extent at %llu is beyond 32bit page cache and xarray index limit",
2016                              bytenr);
2017                 btrfs_err_32bit_limit(fs_info);
2018                 return -EOVERFLOW;
2019         }
2020 #endif
2021
2022         trace_btrfs_qgroup_trace_extent(fs_info, record, bytenr);
2023
2024         xa_lock(&delayed_refs->dirty_extents);
2025         existing = xa_load(&delayed_refs->dirty_extents, index);
2026         if (existing) {
2027                 if (record->data_rsv && !existing->data_rsv) {
2028                         existing->data_rsv = record->data_rsv;
2029                         existing->data_rsv_refroot = record->data_rsv_refroot;
2030                 }
2031                 xa_unlock(&delayed_refs->dirty_extents);
2032                 return 1;
2033         }
2034
2035         ret = __xa_store(&delayed_refs->dirty_extents, index, record, GFP_ATOMIC);
2036         xa_unlock(&delayed_refs->dirty_extents);
2037         if (xa_is_err(ret)) {
2038                 qgroup_mark_inconsistent(fs_info);
2039                 return xa_err(ret);
2040         }
2041
2042         return 0;
2043 }
2044
2045 /*
2046  * Post handler after qgroup_trace_extent_nolock().
2047  *
2048  * NOTE: Current qgroup does the expensive backref walk at transaction
2049  * committing time with TRANS_STATE_COMMIT_DOING, this blocks incoming
2050  * new transaction.
2051  * This is designed to allow btrfs_find_all_roots() to get correct new_roots
2052  * result.
2053  *
2054  * However for old_roots there is no need to do backref walk at that time,
2055  * since we search commit roots to walk backref and result will always be
2056  * correct.
2057  *
2058  * Due to the nature of no lock version, we can't do backref there.
2059  * So we must call btrfs_qgroup_trace_extent_post() after exiting
2060  * spinlock context.
2061  *
2062  * TODO: If we can fix and prove btrfs_find_all_roots() can get correct result
2063  * using current root, then we can move all expensive backref walk out of
2064  * transaction committing, but not now as qgroup accounting will be wrong again.
2065  */
2066 int btrfs_qgroup_trace_extent_post(struct btrfs_trans_handle *trans,
2067                                    struct btrfs_qgroup_extent_record *qrecord,
2068                                    u64 bytenr)
2069 {
2070         struct btrfs_fs_info *fs_info = trans->fs_info;
2071         struct btrfs_backref_walk_ctx ctx = {
2072                 .bytenr = bytenr,
2073                 .fs_info = fs_info,
2074         };
2075         int ret;
2076
2077         if (!btrfs_qgroup_full_accounting(fs_info))
2078                 return 0;
2079         /*
2080          * We are always called in a context where we are already holding a
2081          * transaction handle. Often we are called when adding a data delayed
2082          * reference from btrfs_truncate_inode_items() (truncating or unlinking),
2083          * in which case we will be holding a write lock on extent buffer from a
2084          * subvolume tree. In this case we can't allow btrfs_find_all_roots() to
2085          * acquire fs_info->commit_root_sem, because that is a higher level lock
2086          * that must be acquired before locking any extent buffers.
2087          *
2088          * So we want btrfs_find_all_roots() to not acquire the commit_root_sem
2089          * but we can't pass it a non-NULL transaction handle, because otherwise
2090          * it would not use commit roots and would lock extent buffers, causing
2091          * a deadlock if it ends up trying to read lock the same extent buffer
2092          * that was previously write locked at btrfs_truncate_inode_items().
2093          *
2094          * So pass a NULL transaction handle to btrfs_find_all_roots() and
2095          * explicitly tell it to not acquire the commit_root_sem - if we are
2096          * holding a transaction handle we don't need its protection.
2097          */
2098         ASSERT(trans != NULL);
2099
2100         if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING)
2101                 return 0;
2102
2103         ret = btrfs_find_all_roots(&ctx, true);
2104         if (ret < 0) {
2105                 qgroup_mark_inconsistent(fs_info);
2106                 btrfs_warn(fs_info,
2107 "error accounting new delayed refs extent (err code: %d), quota inconsistent",
2108                         ret);
2109                 return 0;
2110         }
2111
2112         /*
2113          * Here we don't need to get the lock of
2114          * trans->transaction->delayed_refs, since inserted qrecord won't
2115          * be deleted, only qrecord->node may be modified (new qrecord insert)
2116          *
2117          * So modifying qrecord->old_roots is safe here
2118          */
2119         qrecord->old_roots = ctx.roots;
2120         return 0;
2121 }
2122
2123 /*
2124  * Inform qgroup to trace one dirty extent, specified by @bytenr and
2125  * @num_bytes.
2126  * So qgroup can account it at commit trans time.
2127  *
2128  * Better encapsulated version, with memory allocation and backref walk for
2129  * commit roots.
2130  * So this can sleep.
2131  *
2132  * Return 0 if the operation is done.
2133  * Return <0 for error, like memory allocation failure or invalid parameter
2134  * (NULL trans)
2135  */
2136 int btrfs_qgroup_trace_extent(struct btrfs_trans_handle *trans, u64 bytenr,
2137                               u64 num_bytes)
2138 {
2139         struct btrfs_fs_info *fs_info = trans->fs_info;
2140         struct btrfs_qgroup_extent_record *record;
2141         struct btrfs_delayed_ref_root *delayed_refs = &trans->transaction->delayed_refs;
2142         const unsigned long index = (bytenr >> fs_info->sectorsize_bits);
2143         int ret;
2144
2145         if (!btrfs_qgroup_full_accounting(fs_info) || bytenr == 0 || num_bytes == 0)
2146                 return 0;
2147         record = kzalloc(sizeof(*record), GFP_NOFS);
2148         if (!record)
2149                 return -ENOMEM;
2150
2151         if (xa_reserve(&delayed_refs->dirty_extents, index, GFP_NOFS)) {
2152                 kfree(record);
2153                 return -ENOMEM;
2154         }
2155
2156         record->num_bytes = num_bytes;
2157
2158         ret = btrfs_qgroup_trace_extent_nolock(fs_info, delayed_refs, record, bytenr);
2159         if (ret) {
2160                 /* Clean up if insertion fails or item exists. */
2161                 xa_release(&delayed_refs->dirty_extents, index);
2162                 kfree(record);
2163                 return 0;
2164         }
2165         return btrfs_qgroup_trace_extent_post(trans, record, bytenr);
2166 }
2167
2168 /*
2169  * Inform qgroup to trace all leaf items of data
2170  *
2171  * Return 0 for success
2172  * Return <0 for error(ENOMEM)
2173  */
2174 int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle *trans,
2175                                   struct extent_buffer *eb)
2176 {
2177         struct btrfs_fs_info *fs_info = trans->fs_info;
2178         int nr = btrfs_header_nritems(eb);
2179         int i, extent_type, ret;
2180         struct btrfs_key key;
2181         struct btrfs_file_extent_item *fi;
2182         u64 bytenr, num_bytes;
2183
2184         /* We can be called directly from walk_up_proc() */
2185         if (!btrfs_qgroup_full_accounting(fs_info))
2186                 return 0;
2187
2188         for (i = 0; i < nr; i++) {
2189                 btrfs_item_key_to_cpu(eb, &key, i);
2190
2191                 if (key.type != BTRFS_EXTENT_DATA_KEY)
2192                         continue;
2193
2194                 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
2195                 /* filter out non qgroup-accountable extents  */
2196                 extent_type = btrfs_file_extent_type(eb, fi);
2197
2198                 if (extent_type == BTRFS_FILE_EXTENT_INLINE)
2199                         continue;
2200
2201                 bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
2202                 if (!bytenr)
2203                         continue;
2204
2205                 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
2206
2207                 ret = btrfs_qgroup_trace_extent(trans, bytenr, num_bytes);
2208                 if (ret)
2209                         return ret;
2210         }
2211         cond_resched();
2212         return 0;
2213 }
2214
2215 /*
2216  * Walk up the tree from the bottom, freeing leaves and any interior
2217  * nodes which have had all slots visited. If a node (leaf or
2218  * interior) is freed, the node above it will have it's slot
2219  * incremented. The root node will never be freed.
2220  *
2221  * At the end of this function, we should have a path which has all
2222  * slots incremented to the next position for a search. If we need to
2223  * read a new node it will be NULL and the node above it will have the
2224  * correct slot selected for a later read.
2225  *
2226  * If we increment the root nodes slot counter past the number of
2227  * elements, 1 is returned to signal completion of the search.
2228  */
2229 static int adjust_slots_upwards(struct btrfs_path *path, int root_level)
2230 {
2231         int level = 0;
2232         int nr, slot;
2233         struct extent_buffer *eb;
2234
2235         if (root_level == 0)
2236                 return 1;
2237
2238         while (level <= root_level) {
2239                 eb = path->nodes[level];
2240                 nr = btrfs_header_nritems(eb);
2241                 path->slots[level]++;
2242                 slot = path->slots[level];
2243                 if (slot >= nr || level == 0) {
2244                         /*
2245                          * Don't free the root -  we will detect this
2246                          * condition after our loop and return a
2247                          * positive value for caller to stop walking the tree.
2248                          */
2249                         if (level != root_level) {
2250                                 btrfs_tree_unlock_rw(eb, path->locks[level]);
2251                                 path->locks[level] = 0;
2252
2253                                 free_extent_buffer(eb);
2254                                 path->nodes[level] = NULL;
2255                                 path->slots[level] = 0;
2256                         }
2257                 } else {
2258                         /*
2259                          * We have a valid slot to walk back down
2260                          * from. Stop here so caller can process these
2261                          * new nodes.
2262                          */
2263                         break;
2264                 }
2265
2266                 level++;
2267         }
2268
2269         eb = path->nodes[root_level];
2270         if (path->slots[root_level] >= btrfs_header_nritems(eb))
2271                 return 1;
2272
2273         return 0;
2274 }
2275
2276 /*
2277  * Helper function to trace a subtree tree block swap.
2278  *
2279  * The swap will happen in highest tree block, but there may be a lot of
2280  * tree blocks involved.
2281  *
2282  * For example:
2283  *  OO = Old tree blocks
2284  *  NN = New tree blocks allocated during balance
2285  *
2286  *           File tree (257)                  Reloc tree for 257
2287  * L2              OO                                NN
2288  *               /    \                            /    \
2289  * L1          OO      OO (a)                    OO      NN (a)
2290  *            / \     / \                       / \     / \
2291  * L0       OO   OO OO   OO                   OO   OO NN   NN
2292  *                  (b)  (c)                          (b)  (c)
2293  *
2294  * When calling qgroup_trace_extent_swap(), we will pass:
2295  * @src_eb = OO(a)
2296  * @dst_path = [ nodes[1] = NN(a), nodes[0] = NN(c) ]
2297  * @dst_level = 0
2298  * @root_level = 1
2299  *
2300  * In that case, qgroup_trace_extent_swap() will search from OO(a) to
2301  * reach OO(c), then mark both OO(c) and NN(c) as qgroup dirty.
2302  *
2303  * The main work of qgroup_trace_extent_swap() can be split into 3 parts:
2304  *
2305  * 1) Tree search from @src_eb
2306  *    It should acts as a simplified btrfs_search_slot().
2307  *    The key for search can be extracted from @dst_path->nodes[dst_level]
2308  *    (first key).
2309  *
2310  * 2) Mark the final tree blocks in @src_path and @dst_path qgroup dirty
2311  *    NOTE: In above case, OO(a) and NN(a) won't be marked qgroup dirty.
2312  *    They should be marked during previous (@dst_level = 1) iteration.
2313  *
2314  * 3) Mark file extents in leaves dirty
2315  *    We don't have good way to pick out new file extents only.
2316  *    So we still follow the old method by scanning all file extents in
2317  *    the leave.
2318  *
2319  * This function can free us from keeping two paths, thus later we only need
2320  * to care about how to iterate all new tree blocks in reloc tree.
2321  */
2322 static int qgroup_trace_extent_swap(struct btrfs_trans_handle* trans,
2323                                     struct extent_buffer *src_eb,
2324                                     struct btrfs_path *dst_path,
2325                                     int dst_level, int root_level,
2326                                     bool trace_leaf)
2327 {
2328         struct btrfs_key key;
2329         struct btrfs_path *src_path;
2330         struct btrfs_fs_info *fs_info = trans->fs_info;
2331         u32 nodesize = fs_info->nodesize;
2332         int cur_level = root_level;
2333         int ret;
2334
2335         BUG_ON(dst_level > root_level);
2336         /* Level mismatch */
2337         if (btrfs_header_level(src_eb) != root_level)
2338                 return -EINVAL;
2339
2340         src_path = btrfs_alloc_path();
2341         if (!src_path) {
2342                 ret = -ENOMEM;
2343                 goto out;
2344         }
2345
2346         if (dst_level)
2347                 btrfs_node_key_to_cpu(dst_path->nodes[dst_level], &key, 0);
2348         else
2349                 btrfs_item_key_to_cpu(dst_path->nodes[dst_level], &key, 0);
2350
2351         /* For src_path */
2352         atomic_inc(&src_eb->refs);
2353         src_path->nodes[root_level] = src_eb;
2354         src_path->slots[root_level] = dst_path->slots[root_level];
2355         src_path->locks[root_level] = 0;
2356
2357         /* A simplified version of btrfs_search_slot() */
2358         while (cur_level >= dst_level) {
2359                 struct btrfs_key src_key;
2360                 struct btrfs_key dst_key;
2361
2362                 if (src_path->nodes[cur_level] == NULL) {
2363                         struct extent_buffer *eb;
2364                         int parent_slot;
2365
2366                         eb = src_path->nodes[cur_level + 1];
2367                         parent_slot = src_path->slots[cur_level + 1];
2368
2369                         eb = btrfs_read_node_slot(eb, parent_slot);
2370                         if (IS_ERR(eb)) {
2371                                 ret = PTR_ERR(eb);
2372                                 goto out;
2373                         }
2374
2375                         src_path->nodes[cur_level] = eb;
2376
2377                         btrfs_tree_read_lock(eb);
2378                         src_path->locks[cur_level] = BTRFS_READ_LOCK;
2379                 }
2380
2381                 src_path->slots[cur_level] = dst_path->slots[cur_level];
2382                 if (cur_level) {
2383                         btrfs_node_key_to_cpu(dst_path->nodes[cur_level],
2384                                         &dst_key, dst_path->slots[cur_level]);
2385                         btrfs_node_key_to_cpu(src_path->nodes[cur_level],
2386                                         &src_key, src_path->slots[cur_level]);
2387                 } else {
2388                         btrfs_item_key_to_cpu(dst_path->nodes[cur_level],
2389                                         &dst_key, dst_path->slots[cur_level]);
2390                         btrfs_item_key_to_cpu(src_path->nodes[cur_level],
2391                                         &src_key, src_path->slots[cur_level]);
2392                 }
2393                 /* Content mismatch, something went wrong */
2394                 if (btrfs_comp_cpu_keys(&dst_key, &src_key)) {
2395                         ret = -ENOENT;
2396                         goto out;
2397                 }
2398                 cur_level--;
2399         }
2400
2401         /*
2402          * Now both @dst_path and @src_path have been populated, record the tree
2403          * blocks for qgroup accounting.
2404          */
2405         ret = btrfs_qgroup_trace_extent(trans, src_path->nodes[dst_level]->start,
2406                                         nodesize);
2407         if (ret < 0)
2408                 goto out;
2409         ret = btrfs_qgroup_trace_extent(trans, dst_path->nodes[dst_level]->start,
2410                                         nodesize);
2411         if (ret < 0)
2412                 goto out;
2413
2414         /* Record leaf file extents */
2415         if (dst_level == 0 && trace_leaf) {
2416                 ret = btrfs_qgroup_trace_leaf_items(trans, src_path->nodes[0]);
2417                 if (ret < 0)
2418                         goto out;
2419                 ret = btrfs_qgroup_trace_leaf_items(trans, dst_path->nodes[0]);
2420         }
2421 out:
2422         btrfs_free_path(src_path);
2423         return ret;
2424 }
2425
2426 /*
2427  * Helper function to do recursive generation-aware depth-first search, to
2428  * locate all new tree blocks in a subtree of reloc tree.
2429  *
2430  * E.g. (OO = Old tree blocks, NN = New tree blocks, whose gen == last_snapshot)
2431  *         reloc tree
2432  * L2         NN (a)
2433  *          /    \
2434  * L1    OO        NN (b)
2435  *      /  \      /  \
2436  * L0  OO  OO    OO  NN
2437  *               (c) (d)
2438  * If we pass:
2439  * @dst_path = [ nodes[1] = NN(b), nodes[0] = NULL ],
2440  * @cur_level = 1
2441  * @root_level = 1
2442  *
2443  * We will iterate through tree blocks NN(b), NN(d) and info qgroup to trace
2444  * above tree blocks along with their counter parts in file tree.
2445  * While during search, old tree blocks OO(c) will be skipped as tree block swap
2446  * won't affect OO(c).
2447  */
2448 static int qgroup_trace_new_subtree_blocks(struct btrfs_trans_handle* trans,
2449                                            struct extent_buffer *src_eb,
2450                                            struct btrfs_path *dst_path,
2451                                            int cur_level, int root_level,
2452                                            u64 last_snapshot, bool trace_leaf)
2453 {
2454         struct btrfs_fs_info *fs_info = trans->fs_info;
2455         struct extent_buffer *eb;
2456         bool need_cleanup = false;
2457         int ret = 0;
2458         int i;
2459
2460         /* Level sanity check */
2461         if (cur_level < 0 || cur_level >= BTRFS_MAX_LEVEL - 1 ||
2462             root_level < 0 || root_level >= BTRFS_MAX_LEVEL - 1 ||
2463             root_level < cur_level) {
2464                 btrfs_err_rl(fs_info,
2465                         "%s: bad levels, cur_level=%d root_level=%d",
2466                         __func__, cur_level, root_level);
2467                 return -EUCLEAN;
2468         }
2469
2470         /* Read the tree block if needed */
2471         if (dst_path->nodes[cur_level] == NULL) {
2472                 int parent_slot;
2473                 u64 child_gen;
2474
2475                 /*
2476                  * dst_path->nodes[root_level] must be initialized before
2477                  * calling this function.
2478                  */
2479                 if (cur_level == root_level) {
2480                         btrfs_err_rl(fs_info,
2481         "%s: dst_path->nodes[%d] not initialized, root_level=%d cur_level=%d",
2482                                 __func__, root_level, root_level, cur_level);
2483                         return -EUCLEAN;
2484                 }
2485
2486                 /*
2487                  * We need to get child blockptr/gen from parent before we can
2488                  * read it.
2489                   */
2490                 eb = dst_path->nodes[cur_level + 1];
2491                 parent_slot = dst_path->slots[cur_level + 1];
2492                 child_gen = btrfs_node_ptr_generation(eb, parent_slot);
2493
2494                 /* This node is old, no need to trace */
2495                 if (child_gen < last_snapshot)
2496                         goto out;
2497
2498                 eb = btrfs_read_node_slot(eb, parent_slot);
2499                 if (IS_ERR(eb)) {
2500                         ret = PTR_ERR(eb);
2501                         goto out;
2502                 }
2503
2504                 dst_path->nodes[cur_level] = eb;
2505                 dst_path->slots[cur_level] = 0;
2506
2507                 btrfs_tree_read_lock(eb);
2508                 dst_path->locks[cur_level] = BTRFS_READ_LOCK;
2509                 need_cleanup = true;
2510         }
2511
2512         /* Now record this tree block and its counter part for qgroups */
2513         ret = qgroup_trace_extent_swap(trans, src_eb, dst_path, cur_level,
2514                                        root_level, trace_leaf);
2515         if (ret < 0)
2516                 goto cleanup;
2517
2518         eb = dst_path->nodes[cur_level];
2519
2520         if (cur_level > 0) {
2521                 /* Iterate all child tree blocks */
2522                 for (i = 0; i < btrfs_header_nritems(eb); i++) {
2523                         /* Skip old tree blocks as they won't be swapped */
2524                         if (btrfs_node_ptr_generation(eb, i) < last_snapshot)
2525                                 continue;
2526                         dst_path->slots[cur_level] = i;
2527
2528                         /* Recursive call (at most 7 times) */
2529                         ret = qgroup_trace_new_subtree_blocks(trans, src_eb,
2530                                         dst_path, cur_level - 1, root_level,
2531                                         last_snapshot, trace_leaf);
2532                         if (ret < 0)
2533                                 goto cleanup;
2534                 }
2535         }
2536
2537 cleanup:
2538         if (need_cleanup) {
2539                 /* Clean up */
2540                 btrfs_tree_unlock_rw(dst_path->nodes[cur_level],
2541                                      dst_path->locks[cur_level]);
2542                 free_extent_buffer(dst_path->nodes[cur_level]);
2543                 dst_path->nodes[cur_level] = NULL;
2544                 dst_path->slots[cur_level] = 0;
2545                 dst_path->locks[cur_level] = 0;
2546         }
2547 out:
2548         return ret;
2549 }
2550
2551 static int qgroup_trace_subtree_swap(struct btrfs_trans_handle *trans,
2552                                 struct extent_buffer *src_eb,
2553                                 struct extent_buffer *dst_eb,
2554                                 u64 last_snapshot, bool trace_leaf)
2555 {
2556         struct btrfs_fs_info *fs_info = trans->fs_info;
2557         struct btrfs_path *dst_path = NULL;
2558         int level;
2559         int ret;
2560
2561         if (!btrfs_qgroup_full_accounting(fs_info))
2562                 return 0;
2563
2564         /* Wrong parameter order */
2565         if (btrfs_header_generation(src_eb) > btrfs_header_generation(dst_eb)) {
2566                 btrfs_err_rl(fs_info,
2567                 "%s: bad parameter order, src_gen=%llu dst_gen=%llu", __func__,
2568                              btrfs_header_generation(src_eb),
2569                              btrfs_header_generation(dst_eb));
2570                 return -EUCLEAN;
2571         }
2572
2573         if (!extent_buffer_uptodate(src_eb) || !extent_buffer_uptodate(dst_eb)) {
2574                 ret = -EIO;
2575                 goto out;
2576         }
2577
2578         level = btrfs_header_level(dst_eb);
2579         dst_path = btrfs_alloc_path();
2580         if (!dst_path) {
2581                 ret = -ENOMEM;
2582                 goto out;
2583         }
2584         /* For dst_path */
2585         atomic_inc(&dst_eb->refs);
2586         dst_path->nodes[level] = dst_eb;
2587         dst_path->slots[level] = 0;
2588         dst_path->locks[level] = 0;
2589
2590         /* Do the generation aware breadth-first search */
2591         ret = qgroup_trace_new_subtree_blocks(trans, src_eb, dst_path, level,
2592                                               level, last_snapshot, trace_leaf);
2593         if (ret < 0)
2594                 goto out;
2595         ret = 0;
2596
2597 out:
2598         btrfs_free_path(dst_path);
2599         if (ret < 0)
2600                 qgroup_mark_inconsistent(fs_info);
2601         return ret;
2602 }
2603
2604 /*
2605  * Inform qgroup to trace a whole subtree, including all its child tree
2606  * blocks and data.
2607  * The root tree block is specified by @root_eb.
2608  *
2609  * Normally used by relocation(tree block swap) and subvolume deletion.
2610  *
2611  * Return 0 for success
2612  * Return <0 for error(ENOMEM or tree search error)
2613  */
2614 int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,
2615                                struct extent_buffer *root_eb,
2616                                u64 root_gen, int root_level)
2617 {
2618         struct btrfs_fs_info *fs_info = trans->fs_info;
2619         int ret = 0;
2620         int level;
2621         u8 drop_subptree_thres;
2622         struct extent_buffer *eb = root_eb;
2623         struct btrfs_path *path = NULL;
2624
2625         ASSERT(0 <= root_level && root_level < BTRFS_MAX_LEVEL);
2626         ASSERT(root_eb != NULL);
2627
2628         if (!btrfs_qgroup_full_accounting(fs_info))
2629                 return 0;
2630
2631         spin_lock(&fs_info->qgroup_lock);
2632         drop_subptree_thres = fs_info->qgroup_drop_subtree_thres;
2633         spin_unlock(&fs_info->qgroup_lock);
2634
2635         /*
2636          * This function only gets called for snapshot drop, if we hit a high
2637          * node here, it means we are going to change ownership for quite a lot
2638          * of extents, which will greatly slow down btrfs_commit_transaction().
2639          *
2640          * So here if we find a high tree here, we just skip the accounting and
2641          * mark qgroup inconsistent.
2642          */
2643         if (root_level >= drop_subptree_thres) {
2644                 qgroup_mark_inconsistent(fs_info);
2645                 return 0;
2646         }
2647
2648         if (!extent_buffer_uptodate(root_eb)) {
2649                 struct btrfs_tree_parent_check check = {
2650                         .transid = root_gen,
2651                         .level = root_level
2652                 };
2653
2654                 ret = btrfs_read_extent_buffer(root_eb, &check);
2655                 if (ret)
2656                         goto out;
2657         }
2658
2659         if (root_level == 0) {
2660                 ret = btrfs_qgroup_trace_leaf_items(trans, root_eb);
2661                 goto out;
2662         }
2663
2664         path = btrfs_alloc_path();
2665         if (!path)
2666                 return -ENOMEM;
2667
2668         /*
2669          * Walk down the tree.  Missing extent blocks are filled in as
2670          * we go. Metadata is accounted every time we read a new
2671          * extent block.
2672          *
2673          * When we reach a leaf, we account for file extent items in it,
2674          * walk back up the tree (adjusting slot pointers as we go)
2675          * and restart the search process.
2676          */
2677         atomic_inc(&root_eb->refs);     /* For path */
2678         path->nodes[root_level] = root_eb;
2679         path->slots[root_level] = 0;
2680         path->locks[root_level] = 0; /* so release_path doesn't try to unlock */
2681 walk_down:
2682         level = root_level;
2683         while (level >= 0) {
2684                 if (path->nodes[level] == NULL) {
2685                         int parent_slot;
2686                         u64 child_bytenr;
2687
2688                         /*
2689                          * We need to get child blockptr from parent before we
2690                          * can read it.
2691                           */
2692                         eb = path->nodes[level + 1];
2693                         parent_slot = path->slots[level + 1];
2694                         child_bytenr = btrfs_node_blockptr(eb, parent_slot);
2695
2696                         eb = btrfs_read_node_slot(eb, parent_slot);
2697                         if (IS_ERR(eb)) {
2698                                 ret = PTR_ERR(eb);
2699                                 goto out;
2700                         }
2701
2702                         path->nodes[level] = eb;
2703                         path->slots[level] = 0;
2704
2705                         btrfs_tree_read_lock(eb);
2706                         path->locks[level] = BTRFS_READ_LOCK;
2707
2708                         ret = btrfs_qgroup_trace_extent(trans, child_bytenr,
2709                                                         fs_info->nodesize);
2710                         if (ret)
2711                                 goto out;
2712                 }
2713
2714                 if (level == 0) {
2715                         ret = btrfs_qgroup_trace_leaf_items(trans,
2716                                                             path->nodes[level]);
2717                         if (ret)
2718                                 goto out;
2719
2720                         /* Nonzero return here means we completed our search */
2721                         ret = adjust_slots_upwards(path, root_level);
2722                         if (ret)
2723                                 break;
2724
2725                         /* Restart search with new slots */
2726                         goto walk_down;
2727                 }
2728
2729                 level--;
2730         }
2731
2732         ret = 0;
2733 out:
2734         btrfs_free_path(path);
2735
2736         return ret;
2737 }
2738
2739 static void qgroup_iterator_nested_add(struct list_head *head, struct btrfs_qgroup *qgroup)
2740 {
2741         if (!list_empty(&qgroup->nested_iterator))
2742                 return;
2743
2744         list_add_tail(&qgroup->nested_iterator, head);
2745 }
2746
2747 static void qgroup_iterator_nested_clean(struct list_head *head)
2748 {
2749         while (!list_empty(head)) {
2750                 struct btrfs_qgroup *qgroup;
2751
2752                 qgroup = list_first_entry(head, struct btrfs_qgroup, nested_iterator);
2753                 list_del_init(&qgroup->nested_iterator);
2754         }
2755 }
2756
2757 #define UPDATE_NEW      0
2758 #define UPDATE_OLD      1
2759 /*
2760  * Walk all of the roots that points to the bytenr and adjust their refcnts.
2761  */
2762 static void qgroup_update_refcnt(struct btrfs_fs_info *fs_info,
2763                                  struct ulist *roots, struct list_head *qgroups,
2764                                  u64 seq, int update_old)
2765 {
2766         struct ulist_node *unode;
2767         struct ulist_iterator uiter;
2768         struct btrfs_qgroup *qg;
2769
2770         if (!roots)
2771                 return;
2772         ULIST_ITER_INIT(&uiter);
2773         while ((unode = ulist_next(roots, &uiter))) {
2774                 LIST_HEAD(tmp);
2775
2776                 qg = find_qgroup_rb(fs_info, unode->val);
2777                 if (!qg)
2778                         continue;
2779
2780                 qgroup_iterator_nested_add(qgroups, qg);
2781                 qgroup_iterator_add(&tmp, qg);
2782                 list_for_each_entry(qg, &tmp, iterator) {
2783                         struct btrfs_qgroup_list *glist;
2784
2785                         if (update_old)
2786                                 btrfs_qgroup_update_old_refcnt(qg, seq, 1);
2787                         else
2788                                 btrfs_qgroup_update_new_refcnt(qg, seq, 1);
2789
2790                         list_for_each_entry(glist, &qg->groups, next_group) {
2791                                 qgroup_iterator_nested_add(qgroups, glist->group);
2792                                 qgroup_iterator_add(&tmp, glist->group);
2793                         }
2794                 }
2795                 qgroup_iterator_clean(&tmp);
2796         }
2797 }
2798
2799 /*
2800  * Update qgroup rfer/excl counters.
2801  * Rfer update is easy, codes can explain themselves.
2802  *
2803  * Excl update is tricky, the update is split into 2 parts.
2804  * Part 1: Possible exclusive <-> sharing detect:
2805  *      |       A       |       !A      |
2806  *  -------------------------------------
2807  *  B   |       *       |       -       |
2808  *  -------------------------------------
2809  *  !B  |       +       |       **      |
2810  *  -------------------------------------
2811  *
2812  * Conditions:
2813  * A:   cur_old_roots < nr_old_roots    (not exclusive before)
2814  * !A:  cur_old_roots == nr_old_roots   (possible exclusive before)
2815  * B:   cur_new_roots < nr_new_roots    (not exclusive now)
2816  * !B:  cur_new_roots == nr_new_roots   (possible exclusive now)
2817  *
2818  * Results:
2819  * +: Possible sharing -> exclusive     -: Possible exclusive -> sharing
2820  * *: Definitely not changed.           **: Possible unchanged.
2821  *
2822  * For !A and !B condition, the exception is cur_old/new_roots == 0 case.
2823  *
2824  * To make the logic clear, we first use condition A and B to split
2825  * combination into 4 results.
2826  *
2827  * Then, for result "+" and "-", check old/new_roots == 0 case, as in them
2828  * only on variant maybe 0.
2829  *
2830  * Lastly, check result **, since there are 2 variants maybe 0, split them
2831  * again(2x2).
2832  * But this time we don't need to consider other things, the codes and logic
2833  * is easy to understand now.
2834  */
2835 static void qgroup_update_counters(struct btrfs_fs_info *fs_info,
2836                                    struct list_head *qgroups, u64 nr_old_roots,
2837                                    u64 nr_new_roots, u64 num_bytes, u64 seq)
2838 {
2839         struct btrfs_qgroup *qg;
2840
2841         list_for_each_entry(qg, qgroups, nested_iterator) {
2842                 u64 cur_new_count, cur_old_count;
2843                 bool dirty = false;
2844
2845                 cur_old_count = btrfs_qgroup_get_old_refcnt(qg, seq);
2846                 cur_new_count = btrfs_qgroup_get_new_refcnt(qg, seq);
2847
2848                 trace_qgroup_update_counters(fs_info, qg, cur_old_count,
2849                                              cur_new_count);
2850
2851                 /* Rfer update part */
2852                 if (cur_old_count == 0 && cur_new_count > 0) {
2853                         qg->rfer += num_bytes;
2854                         qg->rfer_cmpr += num_bytes;
2855                         dirty = true;
2856                 }
2857                 if (cur_old_count > 0 && cur_new_count == 0) {
2858                         qg->rfer -= num_bytes;
2859                         qg->rfer_cmpr -= num_bytes;
2860                         dirty = true;
2861                 }
2862
2863                 /* Excl update part */
2864                 /* Exclusive/none -> shared case */
2865                 if (cur_old_count == nr_old_roots &&
2866                     cur_new_count < nr_new_roots) {
2867                         /* Exclusive -> shared */
2868                         if (cur_old_count != 0) {
2869                                 qg->excl -= num_bytes;
2870                                 qg->excl_cmpr -= num_bytes;
2871                                 dirty = true;
2872                         }
2873                 }
2874
2875                 /* Shared -> exclusive/none case */
2876                 if (cur_old_count < nr_old_roots &&
2877                     cur_new_count == nr_new_roots) {
2878                         /* Shared->exclusive */
2879                         if (cur_new_count != 0) {
2880                                 qg->excl += num_bytes;
2881                                 qg->excl_cmpr += num_bytes;
2882                                 dirty = true;
2883                         }
2884                 }
2885
2886                 /* Exclusive/none -> exclusive/none case */
2887                 if (cur_old_count == nr_old_roots &&
2888                     cur_new_count == nr_new_roots) {
2889                         if (cur_old_count == 0) {
2890                                 /* None -> exclusive/none */
2891
2892                                 if (cur_new_count != 0) {
2893                                         /* None -> exclusive */
2894                                         qg->excl += num_bytes;
2895                                         qg->excl_cmpr += num_bytes;
2896                                         dirty = true;
2897                                 }
2898                                 /* None -> none, nothing changed */
2899                         } else {
2900                                 /* Exclusive -> exclusive/none */
2901
2902                                 if (cur_new_count == 0) {
2903                                         /* Exclusive -> none */
2904                                         qg->excl -= num_bytes;
2905                                         qg->excl_cmpr -= num_bytes;
2906                                         dirty = true;
2907                                 }
2908                                 /* Exclusive -> exclusive, nothing changed */
2909                         }
2910                 }
2911
2912                 if (dirty)
2913                         qgroup_dirty(fs_info, qg);
2914         }
2915 }
2916
2917 /*
2918  * Check if the @roots potentially is a list of fs tree roots
2919  *
2920  * Return 0 for definitely not a fs/subvol tree roots ulist
2921  * Return 1 for possible fs/subvol tree roots in the list (considering an empty
2922  *          one as well)
2923  */
2924 static int maybe_fs_roots(struct ulist *roots)
2925 {
2926         struct ulist_node *unode;
2927         struct ulist_iterator uiter;
2928
2929         /* Empty one, still possible for fs roots */
2930         if (!roots || roots->nnodes == 0)
2931                 return 1;
2932
2933         ULIST_ITER_INIT(&uiter);
2934         unode = ulist_next(roots, &uiter);
2935         if (!unode)
2936                 return 1;
2937
2938         /*
2939          * If it contains fs tree roots, then it must belong to fs/subvol
2940          * trees.
2941          * If it contains a non-fs tree, it won't be shared with fs/subvol trees.
2942          */
2943         return is_fstree(unode->val);
2944 }
2945
2946 int btrfs_qgroup_account_extent(struct btrfs_trans_handle *trans, u64 bytenr,
2947                                 u64 num_bytes, struct ulist *old_roots,
2948                                 struct ulist *new_roots)
2949 {
2950         struct btrfs_fs_info *fs_info = trans->fs_info;
2951         LIST_HEAD(qgroups);
2952         u64 seq;
2953         u64 nr_new_roots = 0;
2954         u64 nr_old_roots = 0;
2955         int ret = 0;
2956
2957         /*
2958          * If quotas get disabled meanwhile, the resources need to be freed and
2959          * we can't just exit here.
2960          */
2961         if (!btrfs_qgroup_full_accounting(fs_info) ||
2962             fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING)
2963                 goto out_free;
2964
2965         if (new_roots) {
2966                 if (!maybe_fs_roots(new_roots))
2967                         goto out_free;
2968                 nr_new_roots = new_roots->nnodes;
2969         }
2970         if (old_roots) {
2971                 if (!maybe_fs_roots(old_roots))
2972                         goto out_free;
2973                 nr_old_roots = old_roots->nnodes;
2974         }
2975
2976         /* Quick exit, either not fs tree roots, or won't affect any qgroup */
2977         if (nr_old_roots == 0 && nr_new_roots == 0)
2978                 goto out_free;
2979
2980         trace_btrfs_qgroup_account_extent(fs_info, trans->transid, bytenr,
2981                                         num_bytes, nr_old_roots, nr_new_roots);
2982
2983         mutex_lock(&fs_info->qgroup_rescan_lock);
2984         if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
2985                 if (fs_info->qgroup_rescan_progress.objectid <= bytenr) {
2986                         mutex_unlock(&fs_info->qgroup_rescan_lock);
2987                         ret = 0;
2988                         goto out_free;
2989                 }
2990         }
2991         mutex_unlock(&fs_info->qgroup_rescan_lock);
2992
2993         spin_lock(&fs_info->qgroup_lock);
2994         seq = fs_info->qgroup_seq;
2995
2996         /* Update old refcnts using old_roots */
2997         qgroup_update_refcnt(fs_info, old_roots, &qgroups, seq, UPDATE_OLD);
2998
2999         /* Update new refcnts using new_roots */
3000         qgroup_update_refcnt(fs_info, new_roots, &qgroups, seq, UPDATE_NEW);
3001
3002         qgroup_update_counters(fs_info, &qgroups, nr_old_roots, nr_new_roots,
3003                                num_bytes, seq);
3004
3005         /*
3006          * We're done using the iterator, release all its qgroups while holding
3007          * fs_info->qgroup_lock so that we don't race with btrfs_remove_qgroup()
3008          * and trigger use-after-free accesses to qgroups.
3009          */
3010         qgroup_iterator_nested_clean(&qgroups);
3011
3012         /*
3013          * Bump qgroup_seq to avoid seq overlap
3014          */
3015         fs_info->qgroup_seq += max(nr_old_roots, nr_new_roots) + 1;
3016         spin_unlock(&fs_info->qgroup_lock);
3017 out_free:
3018         ulist_free(old_roots);
3019         ulist_free(new_roots);
3020         return ret;
3021 }
3022
3023 int btrfs_qgroup_account_extents(struct btrfs_trans_handle *trans)
3024 {
3025         struct btrfs_fs_info *fs_info = trans->fs_info;
3026         struct btrfs_qgroup_extent_record *record;
3027         struct btrfs_delayed_ref_root *delayed_refs;
3028         struct ulist *new_roots = NULL;
3029         unsigned long index;
3030         u64 num_dirty_extents = 0;
3031         u64 qgroup_to_skip;
3032         int ret = 0;
3033
3034         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)
3035                 return 0;
3036
3037         delayed_refs = &trans->transaction->delayed_refs;
3038         qgroup_to_skip = delayed_refs->qgroup_to_skip;
3039         xa_for_each(&delayed_refs->dirty_extents, index, record) {
3040                 const u64 bytenr = (((u64)index) << fs_info->sectorsize_bits);
3041
3042                 num_dirty_extents++;
3043                 trace_btrfs_qgroup_account_extents(fs_info, record, bytenr);
3044
3045                 if (!ret && !(fs_info->qgroup_flags &
3046                               BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING)) {
3047                         struct btrfs_backref_walk_ctx ctx = { 0 };
3048
3049                         ctx.bytenr = bytenr;
3050                         ctx.fs_info = fs_info;
3051
3052                         /*
3053                          * Old roots should be searched when inserting qgroup
3054                          * extent record.
3055                          *
3056                          * But for INCONSISTENT (NO_ACCOUNTING) -> rescan case,
3057                          * we may have some record inserted during
3058                          * NO_ACCOUNTING (thus no old_roots populated), but
3059                          * later we start rescan, which clears NO_ACCOUNTING,
3060                          * leaving some inserted records without old_roots
3061                          * populated.
3062                          *
3063                          * Those cases are rare and should not cause too much
3064                          * time spent during commit_transaction().
3065                          */
3066                         if (!record->old_roots) {
3067                                 /* Search commit root to find old_roots */
3068                                 ret = btrfs_find_all_roots(&ctx, false);
3069                                 if (ret < 0)
3070                                         goto cleanup;
3071                                 record->old_roots = ctx.roots;
3072                                 ctx.roots = NULL;
3073                         }
3074
3075                         /*
3076                          * Use BTRFS_SEQ_LAST as time_seq to do special search,
3077                          * which doesn't lock tree or delayed_refs and search
3078                          * current root. It's safe inside commit_transaction().
3079                          */
3080                         ctx.trans = trans;
3081                         ctx.time_seq = BTRFS_SEQ_LAST;
3082                         ret = btrfs_find_all_roots(&ctx, false);
3083                         if (ret < 0)
3084                                 goto cleanup;
3085                         new_roots = ctx.roots;
3086                         if (qgroup_to_skip) {
3087                                 ulist_del(new_roots, qgroup_to_skip, 0);
3088                                 ulist_del(record->old_roots, qgroup_to_skip,
3089                                           0);
3090                         }
3091                         ret = btrfs_qgroup_account_extent(trans, bytenr,
3092                                                           record->num_bytes,
3093                                                           record->old_roots,
3094                                                           new_roots);
3095                         record->old_roots = NULL;
3096                         new_roots = NULL;
3097                 }
3098                 /* Free the reserved data space */
3099                 btrfs_qgroup_free_refroot(fs_info,
3100                                 record->data_rsv_refroot,
3101                                 record->data_rsv,
3102                                 BTRFS_QGROUP_RSV_DATA);
3103 cleanup:
3104                 ulist_free(record->old_roots);
3105                 ulist_free(new_roots);
3106                 new_roots = NULL;
3107                 xa_erase(&delayed_refs->dirty_extents, index);
3108                 kfree(record);
3109
3110         }
3111         trace_qgroup_num_dirty_extents(fs_info, trans->transid,
3112                                        num_dirty_extents);
3113         return ret;
3114 }
3115
3116 /*
3117  * Writes all changed qgroups to disk.
3118  * Called by the transaction commit path and the qgroup assign ioctl.
3119  */
3120 int btrfs_run_qgroups(struct btrfs_trans_handle *trans)
3121 {
3122         struct btrfs_fs_info *fs_info = trans->fs_info;
3123         int ret = 0;
3124
3125         /*
3126          * In case we are called from the qgroup assign ioctl, assert that we
3127          * are holding the qgroup_ioctl_lock, otherwise we can race with a quota
3128          * disable operation (ioctl) and access a freed quota root.
3129          */
3130         if (trans->transaction->state != TRANS_STATE_COMMIT_DOING)
3131                 lockdep_assert_held(&fs_info->qgroup_ioctl_lock);
3132
3133         if (!fs_info->quota_root)
3134                 return ret;
3135
3136         spin_lock(&fs_info->qgroup_lock);
3137         while (!list_empty(&fs_info->dirty_qgroups)) {
3138                 struct btrfs_qgroup *qgroup;
3139                 qgroup = list_first_entry(&fs_info->dirty_qgroups,
3140                                           struct btrfs_qgroup, dirty);
3141                 list_del_init(&qgroup->dirty);
3142                 spin_unlock(&fs_info->qgroup_lock);
3143                 ret = update_qgroup_info_item(trans, qgroup);
3144                 if (ret)
3145                         qgroup_mark_inconsistent(fs_info);
3146                 ret = update_qgroup_limit_item(trans, qgroup);
3147                 if (ret)
3148                         qgroup_mark_inconsistent(fs_info);
3149                 spin_lock(&fs_info->qgroup_lock);
3150         }
3151         if (btrfs_qgroup_enabled(fs_info))
3152                 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_ON;
3153         else
3154                 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;
3155         spin_unlock(&fs_info->qgroup_lock);
3156
3157         ret = update_qgroup_status_item(trans);
3158         if (ret)
3159                 qgroup_mark_inconsistent(fs_info);
3160
3161         return ret;
3162 }
3163
3164 int btrfs_qgroup_check_inherit(struct btrfs_fs_info *fs_info,
3165                                struct btrfs_qgroup_inherit *inherit,
3166                                size_t size)
3167 {
3168         if (inherit->flags & ~BTRFS_QGROUP_INHERIT_FLAGS_SUPP)
3169                 return -EOPNOTSUPP;
3170         if (size < sizeof(*inherit) || size > PAGE_SIZE)
3171                 return -EINVAL;
3172
3173         /*
3174          * In the past we allowed btrfs_qgroup_inherit to specify to copy
3175          * rfer/excl numbers directly from other qgroups.  This behavior has
3176          * been disabled in userspace for a very long time, but here we should
3177          * also disable it in kernel, as this behavior is known to mark qgroup
3178          * inconsistent, and a rescan would wipe out the changes anyway.
3179          *
3180          * Reject any btrfs_qgroup_inherit with num_ref_copies or num_excl_copies.
3181          */
3182         if (inherit->num_ref_copies > 0 || inherit->num_excl_copies > 0)
3183                 return -EINVAL;
3184
3185         if (size != struct_size(inherit, qgroups, inherit->num_qgroups))
3186                 return -EINVAL;
3187
3188         /*
3189          * Skip the inherit source qgroups check if qgroup is not enabled.
3190          * Qgroup can still be later enabled causing problems, but in that case
3191          * btrfs_qgroup_inherit() would just ignore those invalid ones.
3192          */
3193         if (!btrfs_qgroup_enabled(fs_info))
3194                 return 0;
3195
3196         /*
3197          * Now check all the remaining qgroups, they should all:
3198          *
3199          * - Exist
3200          * - Be higher level qgroups.
3201          */
3202         for (int i = 0; i < inherit->num_qgroups; i++) {
3203                 struct btrfs_qgroup *qgroup;
3204                 u64 qgroupid = inherit->qgroups[i];
3205
3206                 if (btrfs_qgroup_level(qgroupid) == 0)
3207                         return -EINVAL;
3208
3209                 spin_lock(&fs_info->qgroup_lock);
3210                 qgroup = find_qgroup_rb(fs_info, qgroupid);
3211                 if (!qgroup) {
3212                         spin_unlock(&fs_info->qgroup_lock);
3213                         return -ENOENT;
3214                 }
3215                 spin_unlock(&fs_info->qgroup_lock);
3216         }
3217         return 0;
3218 }
3219
3220 static int qgroup_auto_inherit(struct btrfs_fs_info *fs_info,
3221                                u64 inode_rootid,
3222                                struct btrfs_qgroup_inherit **inherit)
3223 {
3224         int i = 0;
3225         u64 num_qgroups = 0;
3226         struct btrfs_qgroup *inode_qg;
3227         struct btrfs_qgroup_list *qg_list;
3228         struct btrfs_qgroup_inherit *res;
3229         size_t struct_sz;
3230         u64 *qgids;
3231
3232         if (*inherit)
3233                 return -EEXIST;
3234
3235         inode_qg = find_qgroup_rb(fs_info, inode_rootid);
3236         if (!inode_qg)
3237                 return -ENOENT;
3238
3239         num_qgroups = list_count_nodes(&inode_qg->groups);
3240
3241         if (!num_qgroups)
3242                 return 0;
3243
3244         struct_sz = struct_size(res, qgroups, num_qgroups);
3245         if (struct_sz == SIZE_MAX)
3246                 return -ERANGE;
3247
3248         res = kzalloc(struct_sz, GFP_NOFS);
3249         if (!res)
3250                 return -ENOMEM;
3251         res->num_qgroups = num_qgroups;
3252         qgids = res->qgroups;
3253
3254         list_for_each_entry(qg_list, &inode_qg->groups, next_group)
3255                 qgids[i++] = qg_list->group->qgroupid;
3256
3257         *inherit = res;
3258         return 0;
3259 }
3260
3261 /*
3262  * Check if we can skip rescan when inheriting qgroups.  If @src has a single
3263  * @parent, and that @parent is owning all its bytes exclusively, we can skip
3264  * the full rescan, by just adding nodesize to the @parent's excl/rfer.
3265  *
3266  * Return <0 for fatal errors (like srcid/parentid has no qgroup).
3267  * Return 0 if a quick inherit is done.
3268  * Return >0 if a quick inherit is not possible, and a full rescan is needed.
3269  */
3270 static int qgroup_snapshot_quick_inherit(struct btrfs_fs_info *fs_info,
3271                                          u64 srcid, u64 parentid)
3272 {
3273         struct btrfs_qgroup *src;
3274         struct btrfs_qgroup *parent;
3275         struct btrfs_qgroup_list *list;
3276         int nr_parents = 0;
3277
3278         src = find_qgroup_rb(fs_info, srcid);
3279         if (!src)
3280                 return -ENOENT;
3281         parent = find_qgroup_rb(fs_info, parentid);
3282         if (!parent)
3283                 return -ENOENT;
3284
3285         /*
3286          * Source has no parent qgroup, but our new qgroup would have one.
3287          * Qgroup numbers would become inconsistent.
3288          */
3289         if (list_empty(&src->groups))
3290                 return 1;
3291
3292         list_for_each_entry(list, &src->groups, next_group) {
3293                 /* The parent is not the same, quick update is not possible. */
3294                 if (list->group->qgroupid != parentid)
3295                         return 1;
3296                 nr_parents++;
3297                 /*
3298                  * More than one parent qgroup, we can't be sure about accounting
3299                  * consistency.
3300                  */
3301                 if (nr_parents > 1)
3302                         return 1;
3303         }
3304
3305         /*
3306          * The parent is not exclusively owning all its bytes.  We're not sure
3307          * if the source has any bytes not fully owned by the parent.
3308          */
3309         if (parent->excl != parent->rfer)
3310                 return 1;
3311
3312         parent->excl += fs_info->nodesize;
3313         parent->rfer += fs_info->nodesize;
3314         return 0;
3315 }
3316
3317 /*
3318  * Copy the accounting information between qgroups. This is necessary
3319  * when a snapshot or a subvolume is created. Throwing an error will
3320  * cause a transaction abort so we take extra care here to only error
3321  * when a readonly fs is a reasonable outcome.
3322  */
3323 int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans, u64 srcid,
3324                          u64 objectid, u64 inode_rootid,
3325                          struct btrfs_qgroup_inherit *inherit)
3326 {
3327         int ret = 0;
3328         u64 *i_qgroups;
3329         bool committing = false;
3330         struct btrfs_fs_info *fs_info = trans->fs_info;
3331         struct btrfs_root *quota_root;
3332         struct btrfs_qgroup *srcgroup;
3333         struct btrfs_qgroup *dstgroup;
3334         struct btrfs_qgroup *prealloc;
3335         struct btrfs_qgroup_list **qlist_prealloc = NULL;
3336         bool free_inherit = false;
3337         bool need_rescan = false;
3338         u32 level_size = 0;
3339         u64 nums;
3340
3341         prealloc = kzalloc(sizeof(*prealloc), GFP_NOFS);
3342         if (!prealloc)
3343                 return -ENOMEM;
3344
3345         /*
3346          * There are only two callers of this function.
3347          *
3348          * One in create_subvol() in the ioctl context, which needs to hold
3349          * the qgroup_ioctl_lock.
3350          *
3351          * The other one in create_pending_snapshot() where no other qgroup
3352          * code can modify the fs as they all need to either start a new trans
3353          * or hold a trans handler, thus we don't need to hold
3354          * qgroup_ioctl_lock.
3355          * This would avoid long and complex lock chain and make lockdep happy.
3356          */
3357         spin_lock(&fs_info->trans_lock);
3358         if (trans->transaction->state == TRANS_STATE_COMMIT_DOING)
3359                 committing = true;
3360         spin_unlock(&fs_info->trans_lock);
3361
3362         if (!committing)
3363                 mutex_lock(&fs_info->qgroup_ioctl_lock);
3364         if (!btrfs_qgroup_enabled(fs_info))
3365                 goto out;
3366
3367         quota_root = fs_info->quota_root;
3368         if (!quota_root) {
3369                 ret = -EINVAL;
3370                 goto out;
3371         }
3372
3373         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE && !inherit) {
3374                 ret = qgroup_auto_inherit(fs_info, inode_rootid, &inherit);
3375                 if (ret)
3376                         goto out;
3377                 free_inherit = true;
3378         }
3379
3380         if (inherit) {
3381                 i_qgroups = (u64 *)(inherit + 1);
3382                 nums = inherit->num_qgroups + 2 * inherit->num_ref_copies +
3383                        2 * inherit->num_excl_copies;
3384                 for (int i = 0; i < nums; i++) {
3385                         srcgroup = find_qgroup_rb(fs_info, *i_qgroups);
3386
3387                         /*
3388                          * Zero out invalid groups so we can ignore
3389                          * them later.
3390                          */
3391                         if (!srcgroup ||
3392                             ((srcgroup->qgroupid >> 48) <= (objectid >> 48)))
3393                                 *i_qgroups = 0ULL;
3394
3395                         ++i_qgroups;
3396                 }
3397         }
3398
3399         /*
3400          * create a tracking group for the subvol itself
3401          */
3402         ret = add_qgroup_item(trans, quota_root, objectid);
3403         if (ret)
3404                 goto out;
3405
3406         /*
3407          * add qgroup to all inherited groups
3408          */
3409         if (inherit) {
3410                 i_qgroups = (u64 *)(inherit + 1);
3411                 for (int i = 0; i < inherit->num_qgroups; i++, i_qgroups++) {
3412                         if (*i_qgroups == 0)
3413                                 continue;
3414                         ret = add_qgroup_relation_item(trans, objectid,
3415                                                        *i_qgroups);
3416                         if (ret && ret != -EEXIST)
3417                                 goto out;
3418                         ret = add_qgroup_relation_item(trans, *i_qgroups,
3419                                                        objectid);
3420                         if (ret && ret != -EEXIST)
3421                                 goto out;
3422                 }
3423                 ret = 0;
3424
3425                 qlist_prealloc = kcalloc(inherit->num_qgroups,
3426                                          sizeof(struct btrfs_qgroup_list *),
3427                                          GFP_NOFS);
3428                 if (!qlist_prealloc) {
3429                         ret = -ENOMEM;
3430                         goto out;
3431                 }
3432                 for (int i = 0; i < inherit->num_qgroups; i++) {
3433                         qlist_prealloc[i] = kzalloc(sizeof(struct btrfs_qgroup_list),
3434                                                     GFP_NOFS);
3435                         if (!qlist_prealloc[i]) {
3436                                 ret = -ENOMEM;
3437                                 goto out;
3438                         }
3439                 }
3440         }
3441
3442         spin_lock(&fs_info->qgroup_lock);
3443
3444         dstgroup = add_qgroup_rb(fs_info, prealloc, objectid);
3445         prealloc = NULL;
3446
3447         if (inherit && inherit->flags & BTRFS_QGROUP_INHERIT_SET_LIMITS) {
3448                 dstgroup->lim_flags = inherit->lim.flags;
3449                 dstgroup->max_rfer = inherit->lim.max_rfer;
3450                 dstgroup->max_excl = inherit->lim.max_excl;
3451                 dstgroup->rsv_rfer = inherit->lim.rsv_rfer;
3452                 dstgroup->rsv_excl = inherit->lim.rsv_excl;
3453
3454                 qgroup_dirty(fs_info, dstgroup);
3455         }
3456
3457         if (srcid && btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_FULL) {
3458                 srcgroup = find_qgroup_rb(fs_info, srcid);
3459                 if (!srcgroup)
3460                         goto unlock;
3461
3462                 /*
3463                  * We call inherit after we clone the root in order to make sure
3464                  * our counts don't go crazy, so at this point the only
3465                  * difference between the two roots should be the root node.
3466                  */
3467                 level_size = fs_info->nodesize;
3468                 dstgroup->rfer = srcgroup->rfer;
3469                 dstgroup->rfer_cmpr = srcgroup->rfer_cmpr;
3470                 dstgroup->excl = level_size;
3471                 dstgroup->excl_cmpr = level_size;
3472                 srcgroup->excl = level_size;
3473                 srcgroup->excl_cmpr = level_size;
3474
3475                 /* inherit the limit info */
3476                 dstgroup->lim_flags = srcgroup->lim_flags;
3477                 dstgroup->max_rfer = srcgroup->max_rfer;
3478                 dstgroup->max_excl = srcgroup->max_excl;
3479                 dstgroup->rsv_rfer = srcgroup->rsv_rfer;
3480                 dstgroup->rsv_excl = srcgroup->rsv_excl;
3481
3482                 qgroup_dirty(fs_info, dstgroup);
3483                 qgroup_dirty(fs_info, srcgroup);
3484
3485                 /*
3486                  * If the source qgroup has parent but the new one doesn't,
3487                  * we need a full rescan.
3488                  */
3489                 if (!inherit && !list_empty(&srcgroup->groups))
3490                         need_rescan = true;
3491         }
3492
3493         if (!inherit)
3494                 goto unlock;
3495
3496         i_qgroups = (u64 *)(inherit + 1);
3497         for (int i = 0; i < inherit->num_qgroups; i++) {
3498                 if (*i_qgroups) {
3499                         ret = add_relation_rb(fs_info, qlist_prealloc[i], objectid,
3500                                               *i_qgroups);
3501                         qlist_prealloc[i] = NULL;
3502                         if (ret)
3503                                 goto unlock;
3504                 }
3505                 if (srcid) {
3506                         /* Check if we can do a quick inherit. */
3507                         ret = qgroup_snapshot_quick_inherit(fs_info, srcid, *i_qgroups);
3508                         if (ret < 0)
3509                                 goto unlock;
3510                         if (ret > 0)
3511                                 need_rescan = true;
3512                         ret = 0;
3513                 }
3514                 ++i_qgroups;
3515         }
3516
3517         for (int i = 0; i < inherit->num_ref_copies; i++, i_qgroups += 2) {
3518                 struct btrfs_qgroup *src;
3519                 struct btrfs_qgroup *dst;
3520
3521                 if (!i_qgroups[0] || !i_qgroups[1])
3522                         continue;
3523
3524                 src = find_qgroup_rb(fs_info, i_qgroups[0]);
3525                 dst = find_qgroup_rb(fs_info, i_qgroups[1]);
3526
3527                 if (!src || !dst) {
3528                         ret = -EINVAL;
3529                         goto unlock;
3530                 }
3531
3532                 dst->rfer = src->rfer - level_size;
3533                 dst->rfer_cmpr = src->rfer_cmpr - level_size;
3534
3535                 /* Manually tweaking numbers certainly needs a rescan */
3536                 need_rescan = true;
3537         }
3538         for (int i = 0; i < inherit->num_excl_copies; i++, i_qgroups += 2) {
3539                 struct btrfs_qgroup *src;
3540                 struct btrfs_qgroup *dst;
3541
3542                 if (!i_qgroups[0] || !i_qgroups[1])
3543                         continue;
3544
3545                 src = find_qgroup_rb(fs_info, i_qgroups[0]);
3546                 dst = find_qgroup_rb(fs_info, i_qgroups[1]);
3547
3548                 if (!src || !dst) {
3549                         ret = -EINVAL;
3550                         goto unlock;
3551                 }
3552
3553                 dst->excl = src->excl + level_size;
3554                 dst->excl_cmpr = src->excl_cmpr + level_size;
3555                 need_rescan = true;
3556         }
3557
3558 unlock:
3559         spin_unlock(&fs_info->qgroup_lock);
3560         if (!ret)
3561                 ret = btrfs_sysfs_add_one_qgroup(fs_info, dstgroup);
3562 out:
3563         if (!committing)
3564                 mutex_unlock(&fs_info->qgroup_ioctl_lock);
3565         if (need_rescan)
3566                 qgroup_mark_inconsistent(fs_info);
3567         if (qlist_prealloc) {
3568                 for (int i = 0; i < inherit->num_qgroups; i++)
3569                         kfree(qlist_prealloc[i]);
3570                 kfree(qlist_prealloc);
3571         }
3572         if (free_inherit)
3573                 kfree(inherit);
3574         kfree(prealloc);
3575         return ret;
3576 }
3577
3578 static bool qgroup_check_limits(const struct btrfs_qgroup *qg, u64 num_bytes)
3579 {
3580         if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_RFER) &&
3581             qgroup_rsv_total(qg) + (s64)qg->rfer + num_bytes > qg->max_rfer)
3582                 return false;
3583
3584         if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) &&
3585             qgroup_rsv_total(qg) + (s64)qg->excl + num_bytes > qg->max_excl)
3586                 return false;
3587
3588         return true;
3589 }
3590
3591 static int qgroup_reserve(struct btrfs_root *root, u64 num_bytes, bool enforce,
3592                           enum btrfs_qgroup_rsv_type type)
3593 {
3594         struct btrfs_qgroup *qgroup;
3595         struct btrfs_fs_info *fs_info = root->fs_info;
3596         u64 ref_root = btrfs_root_id(root);
3597         int ret = 0;
3598         LIST_HEAD(qgroup_list);
3599
3600         if (!is_fstree(ref_root))
3601                 return 0;
3602
3603         if (num_bytes == 0)
3604                 return 0;
3605
3606         if (test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags) &&
3607             capable(CAP_SYS_RESOURCE))
3608                 enforce = false;
3609
3610         spin_lock(&fs_info->qgroup_lock);
3611         if (!fs_info->quota_root)
3612                 goto out;
3613
3614         qgroup = find_qgroup_rb(fs_info, ref_root);
3615         if (!qgroup)
3616                 goto out;
3617
3618         qgroup_iterator_add(&qgroup_list, qgroup);
3619         list_for_each_entry(qgroup, &qgroup_list, iterator) {
3620                 struct btrfs_qgroup_list *glist;
3621
3622                 if (enforce && !qgroup_check_limits(qgroup, num_bytes)) {
3623                         ret = -EDQUOT;
3624                         goto out;
3625                 }
3626
3627                 list_for_each_entry(glist, &qgroup->groups, next_group)
3628                         qgroup_iterator_add(&qgroup_list, glist->group);
3629         }
3630
3631         ret = 0;
3632         /*
3633          * no limits exceeded, now record the reservation into all qgroups
3634          */
3635         list_for_each_entry(qgroup, &qgroup_list, iterator)
3636                 qgroup_rsv_add(fs_info, qgroup, num_bytes, type);
3637
3638 out:
3639         qgroup_iterator_clean(&qgroup_list);
3640         spin_unlock(&fs_info->qgroup_lock);
3641         return ret;
3642 }
3643
3644 /*
3645  * Free @num_bytes of reserved space with @type for qgroup.  (Normally level 0
3646  * qgroup).
3647  *
3648  * Will handle all higher level qgroup too.
3649  *
3650  * NOTE: If @num_bytes is (u64)-1, this means to free all bytes of this qgroup.
3651  * This special case is only used for META_PERTRANS type.
3652  */
3653 void btrfs_qgroup_free_refroot(struct btrfs_fs_info *fs_info,
3654                                u64 ref_root, u64 num_bytes,
3655                                enum btrfs_qgroup_rsv_type type)
3656 {
3657         struct btrfs_qgroup *qgroup;
3658         LIST_HEAD(qgroup_list);
3659
3660         if (!is_fstree(ref_root))
3661                 return;
3662
3663         if (num_bytes == 0)
3664                 return;
3665
3666         if (num_bytes == (u64)-1 && type != BTRFS_QGROUP_RSV_META_PERTRANS) {
3667                 WARN(1, "%s: Invalid type to free", __func__);
3668                 return;
3669         }
3670         spin_lock(&fs_info->qgroup_lock);
3671
3672         if (!fs_info->quota_root)
3673                 goto out;
3674
3675         qgroup = find_qgroup_rb(fs_info, ref_root);
3676         if (!qgroup)
3677                 goto out;
3678
3679         if (num_bytes == (u64)-1)
3680                 /*
3681                  * We're freeing all pertrans rsv, get reserved value from
3682                  * level 0 qgroup as real num_bytes to free.
3683                  */
3684                 num_bytes = qgroup->rsv.values[type];
3685
3686         qgroup_iterator_add(&qgroup_list, qgroup);
3687         list_for_each_entry(qgroup, &qgroup_list, iterator) {
3688                 struct btrfs_qgroup_list *glist;
3689
3690                 qgroup_rsv_release(fs_info, qgroup, num_bytes, type);
3691                 list_for_each_entry(glist, &qgroup->groups, next_group) {
3692                         qgroup_iterator_add(&qgroup_list, glist->group);
3693                 }
3694         }
3695 out:
3696         qgroup_iterator_clean(&qgroup_list);
3697         spin_unlock(&fs_info->qgroup_lock);
3698 }
3699
3700 /*
3701  * Check if the leaf is the last leaf. Which means all node pointers
3702  * are at their last position.
3703  */
3704 static bool is_last_leaf(struct btrfs_path *path)
3705 {
3706         int i;
3707
3708         for (i = 1; i < BTRFS_MAX_LEVEL && path->nodes[i]; i++) {
3709                 if (path->slots[i] != btrfs_header_nritems(path->nodes[i]) - 1)
3710                         return false;
3711         }
3712         return true;
3713 }
3714
3715 /*
3716  * returns < 0 on error, 0 when more leafs are to be scanned.
3717  * returns 1 when done.
3718  */
3719 static int qgroup_rescan_leaf(struct btrfs_trans_handle *trans,
3720                               struct btrfs_path *path)
3721 {
3722         struct btrfs_fs_info *fs_info = trans->fs_info;
3723         struct btrfs_root *extent_root;
3724         struct btrfs_key found;
3725         struct extent_buffer *scratch_leaf = NULL;
3726         u64 num_bytes;
3727         bool done;
3728         int slot;
3729         int ret;
3730
3731         if (!btrfs_qgroup_full_accounting(fs_info))
3732                 return 1;
3733
3734         mutex_lock(&fs_info->qgroup_rescan_lock);
3735         extent_root = btrfs_extent_root(fs_info,
3736                                 fs_info->qgroup_rescan_progress.objectid);
3737         ret = btrfs_search_slot_for_read(extent_root,
3738                                          &fs_info->qgroup_rescan_progress,
3739                                          path, 1, 0);
3740
3741         btrfs_debug(fs_info,
3742                 "current progress key (%llu %u %llu), search_slot ret %d",
3743                 fs_info->qgroup_rescan_progress.objectid,
3744                 fs_info->qgroup_rescan_progress.type,
3745                 fs_info->qgroup_rescan_progress.offset, ret);
3746
3747         if (ret) {
3748                 /*
3749                  * The rescan is about to end, we will not be scanning any
3750                  * further blocks. We cannot unset the RESCAN flag here, because
3751                  * we want to commit the transaction if everything went well.
3752                  * To make the live accounting work in this phase, we set our
3753                  * scan progress pointer such that every real extent objectid
3754                  * will be smaller.
3755                  */
3756                 fs_info->qgroup_rescan_progress.objectid = (u64)-1;
3757                 btrfs_release_path(path);
3758                 mutex_unlock(&fs_info->qgroup_rescan_lock);
3759                 return ret;
3760         }
3761         done = is_last_leaf(path);
3762
3763         btrfs_item_key_to_cpu(path->nodes[0], &found,
3764                               btrfs_header_nritems(path->nodes[0]) - 1);
3765         fs_info->qgroup_rescan_progress.objectid = found.objectid + 1;
3766
3767         scratch_leaf = btrfs_clone_extent_buffer(path->nodes[0]);
3768         if (!scratch_leaf) {
3769                 ret = -ENOMEM;
3770                 mutex_unlock(&fs_info->qgroup_rescan_lock);
3771                 goto out;
3772         }
3773         slot = path->slots[0];
3774         btrfs_release_path(path);
3775         mutex_unlock(&fs_info->qgroup_rescan_lock);
3776
3777         for (; slot < btrfs_header_nritems(scratch_leaf); ++slot) {
3778                 struct btrfs_backref_walk_ctx ctx = { 0 };
3779
3780                 btrfs_item_key_to_cpu(scratch_leaf, &found, slot);
3781                 if (found.type != BTRFS_EXTENT_ITEM_KEY &&
3782                     found.type != BTRFS_METADATA_ITEM_KEY)
3783                         continue;
3784                 if (found.type == BTRFS_METADATA_ITEM_KEY)
3785                         num_bytes = fs_info->nodesize;
3786                 else
3787                         num_bytes = found.offset;
3788
3789                 ctx.bytenr = found.objectid;
3790                 ctx.fs_info = fs_info;
3791
3792                 ret = btrfs_find_all_roots(&ctx, false);
3793                 if (ret < 0)
3794                         goto out;
3795                 /* For rescan, just pass old_roots as NULL */
3796                 ret = btrfs_qgroup_account_extent(trans, found.objectid,
3797                                                   num_bytes, NULL, ctx.roots);
3798                 if (ret < 0)
3799                         goto out;
3800         }
3801 out:
3802         if (scratch_leaf)
3803                 free_extent_buffer(scratch_leaf);
3804
3805         if (done && !ret) {
3806                 ret = 1;
3807                 fs_info->qgroup_rescan_progress.objectid = (u64)-1;
3808         }
3809         return ret;
3810 }
3811
3812 static bool rescan_should_stop(struct btrfs_fs_info *fs_info)
3813 {
3814         if (btrfs_fs_closing(fs_info))
3815                 return true;
3816         if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state))
3817                 return true;
3818         if (!btrfs_qgroup_enabled(fs_info))
3819                 return true;
3820         if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN)
3821                 return true;
3822         return false;
3823 }
3824
3825 static void btrfs_qgroup_rescan_worker(struct btrfs_work *work)
3826 {
3827         struct btrfs_fs_info *fs_info = container_of(work, struct btrfs_fs_info,
3828                                                      qgroup_rescan_work);
3829         struct btrfs_path *path;
3830         struct btrfs_trans_handle *trans = NULL;
3831         int ret = 0;
3832         bool stopped = false;
3833         bool did_leaf_rescans = false;
3834
3835         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)
3836                 return;
3837
3838         path = btrfs_alloc_path();
3839         if (!path) {
3840                 ret = -ENOMEM;
3841                 goto out;
3842         }
3843         /*
3844          * Rescan should only search for commit root, and any later difference
3845          * should be recorded by qgroup
3846          */
3847         path->search_commit_root = 1;
3848         path->skip_locking = 1;
3849
3850         while (!ret && !(stopped = rescan_should_stop(fs_info))) {
3851                 trans = btrfs_start_transaction(fs_info->fs_root, 0);
3852                 if (IS_ERR(trans)) {
3853                         ret = PTR_ERR(trans);
3854                         break;
3855                 }
3856
3857                 ret = qgroup_rescan_leaf(trans, path);
3858                 did_leaf_rescans = true;
3859
3860                 if (ret > 0)
3861                         btrfs_commit_transaction(trans);
3862                 else
3863                         btrfs_end_transaction(trans);
3864         }
3865
3866 out:
3867         btrfs_free_path(path);
3868
3869         mutex_lock(&fs_info->qgroup_rescan_lock);
3870         if (ret > 0 &&
3871             fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) {
3872                 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
3873         } else if (ret < 0 || stopped) {
3874                 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
3875         }
3876         mutex_unlock(&fs_info->qgroup_rescan_lock);
3877
3878         /*
3879          * Only update status, since the previous part has already updated the
3880          * qgroup info, and only if we did any actual work. This also prevents
3881          * race with a concurrent quota disable, which has already set
3882          * fs_info->quota_root to NULL and cleared BTRFS_FS_QUOTA_ENABLED at
3883          * btrfs_quota_disable().
3884          */
3885         if (did_leaf_rescans) {
3886                 trans = btrfs_start_transaction(fs_info->quota_root, 1);
3887                 if (IS_ERR(trans)) {
3888                         ret = PTR_ERR(trans);
3889                         trans = NULL;
3890                         btrfs_err(fs_info,
3891                                   "fail to start transaction for status update: %d",
3892                                   ret);
3893                 }
3894         } else {
3895                 trans = NULL;
3896         }
3897
3898         mutex_lock(&fs_info->qgroup_rescan_lock);
3899         if (!stopped ||
3900             fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN)
3901                 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
3902         if (trans) {
3903                 int ret2 = update_qgroup_status_item(trans);
3904
3905                 if (ret2 < 0) {
3906                         ret = ret2;
3907                         btrfs_err(fs_info, "fail to update qgroup status: %d", ret);
3908                 }
3909         }
3910         fs_info->qgroup_rescan_running = false;
3911         fs_info->qgroup_flags &= ~BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN;
3912         complete_all(&fs_info->qgroup_rescan_completion);
3913         mutex_unlock(&fs_info->qgroup_rescan_lock);
3914
3915         if (!trans)
3916                 return;
3917
3918         btrfs_end_transaction(trans);
3919
3920         if (stopped) {
3921                 btrfs_info(fs_info, "qgroup scan paused");
3922         } else if (fs_info->qgroup_flags & BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN) {
3923                 btrfs_info(fs_info, "qgroup scan cancelled");
3924         } else if (ret >= 0) {
3925                 btrfs_info(fs_info, "qgroup scan completed%s",
3926                         ret > 0 ? " (inconsistency flag cleared)" : "");
3927         } else {
3928                 btrfs_err(fs_info, "qgroup scan failed with %d", ret);
3929         }
3930 }
3931
3932 /*
3933  * Checks that (a) no rescan is running and (b) quota is enabled. Allocates all
3934  * memory required for the rescan context.
3935  */
3936 static int
3937 qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,
3938                    int init_flags)
3939 {
3940         int ret = 0;
3941
3942         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE) {
3943                 btrfs_warn(fs_info, "qgroup rescan init failed, running in simple mode");
3944                 return -EINVAL;
3945         }
3946
3947         if (!init_flags) {
3948                 /* we're resuming qgroup rescan at mount time */
3949                 if (!(fs_info->qgroup_flags &
3950                       BTRFS_QGROUP_STATUS_FLAG_RESCAN)) {
3951                         btrfs_debug(fs_info,
3952                         "qgroup rescan init failed, qgroup rescan is not queued");
3953                         ret = -EINVAL;
3954                 } else if (!(fs_info->qgroup_flags &
3955                              BTRFS_QGROUP_STATUS_FLAG_ON)) {
3956                         btrfs_debug(fs_info,
3957                         "qgroup rescan init failed, qgroup is not enabled");
3958                         ret = -ENOTCONN;
3959                 }
3960
3961                 if (ret)
3962                         return ret;
3963         }
3964
3965         mutex_lock(&fs_info->qgroup_rescan_lock);
3966
3967         if (init_flags) {
3968                 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
3969                         ret = -EINPROGRESS;
3970                 } else if (!(fs_info->qgroup_flags &
3971                              BTRFS_QGROUP_STATUS_FLAG_ON)) {
3972                         btrfs_debug(fs_info,
3973                         "qgroup rescan init failed, qgroup is not enabled");
3974                         ret = -ENOTCONN;
3975                 } else if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED) {
3976                         /* Quota disable is in progress */
3977                         ret = -EBUSY;
3978                 }
3979
3980                 if (ret) {
3981                         mutex_unlock(&fs_info->qgroup_rescan_lock);
3982                         return ret;
3983                 }
3984                 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN;
3985         }
3986
3987         memset(&fs_info->qgroup_rescan_progress, 0,
3988                 sizeof(fs_info->qgroup_rescan_progress));
3989         fs_info->qgroup_flags &= ~(BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN |
3990                                    BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING);
3991         fs_info->qgroup_rescan_progress.objectid = progress_objectid;
3992         init_completion(&fs_info->qgroup_rescan_completion);
3993         mutex_unlock(&fs_info->qgroup_rescan_lock);
3994
3995         btrfs_init_work(&fs_info->qgroup_rescan_work,
3996                         btrfs_qgroup_rescan_worker, NULL);
3997         return 0;
3998 }
3999
4000 static void
4001 qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info)
4002 {
4003         struct rb_node *n;
4004         struct btrfs_qgroup *qgroup;
4005
4006         spin_lock(&fs_info->qgroup_lock);
4007         /* clear all current qgroup tracking information */
4008         for (n = rb_first(&fs_info->qgroup_tree); n; n = rb_next(n)) {
4009                 qgroup = rb_entry(n, struct btrfs_qgroup, node);
4010                 qgroup->rfer = 0;
4011                 qgroup->rfer_cmpr = 0;
4012                 qgroup->excl = 0;
4013                 qgroup->excl_cmpr = 0;
4014                 qgroup_dirty(fs_info, qgroup);
4015         }
4016         spin_unlock(&fs_info->qgroup_lock);
4017 }
4018
4019 int
4020 btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
4021 {
4022         int ret = 0;
4023
4024         ret = qgroup_rescan_init(fs_info, 0, 1);
4025         if (ret)
4026                 return ret;
4027
4028         /*
4029          * We have set the rescan_progress to 0, which means no more
4030          * delayed refs will be accounted by btrfs_qgroup_account_ref.
4031          * However, btrfs_qgroup_account_ref may be right after its call
4032          * to btrfs_find_all_roots, in which case it would still do the
4033          * accounting.
4034          * To solve this, we're committing the transaction, which will
4035          * ensure we run all delayed refs and only after that, we are
4036          * going to clear all tracking information for a clean start.
4037          */
4038
4039         ret = btrfs_commit_current_transaction(fs_info->fs_root);
4040         if (ret) {
4041                 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
4042                 return ret;
4043         }
4044
4045         qgroup_rescan_zero_tracking(fs_info);
4046
4047         mutex_lock(&fs_info->qgroup_rescan_lock);
4048         fs_info->qgroup_rescan_running = true;
4049         btrfs_queue_work(fs_info->qgroup_rescan_workers,
4050                          &fs_info->qgroup_rescan_work);
4051         mutex_unlock(&fs_info->qgroup_rescan_lock);
4052
4053         return 0;
4054 }
4055
4056 int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info,
4057                                      bool interruptible)
4058 {
4059         int running;
4060         int ret = 0;
4061
4062         mutex_lock(&fs_info->qgroup_rescan_lock);
4063         running = fs_info->qgroup_rescan_running;
4064         mutex_unlock(&fs_info->qgroup_rescan_lock);
4065
4066         if (!running)
4067                 return 0;
4068
4069         if (interruptible)
4070                 ret = wait_for_completion_interruptible(
4071                                         &fs_info->qgroup_rescan_completion);
4072         else
4073                 wait_for_completion(&fs_info->qgroup_rescan_completion);
4074
4075         return ret;
4076 }
4077
4078 /*
4079  * this is only called from open_ctree where we're still single threaded, thus
4080  * locking is omitted here.
4081  */
4082 void
4083 btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info)
4084 {
4085         if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
4086                 mutex_lock(&fs_info->qgroup_rescan_lock);
4087                 fs_info->qgroup_rescan_running = true;
4088                 btrfs_queue_work(fs_info->qgroup_rescan_workers,
4089                                  &fs_info->qgroup_rescan_work);
4090                 mutex_unlock(&fs_info->qgroup_rescan_lock);
4091         }
4092 }
4093
4094 #define rbtree_iterate_from_safe(node, next, start)                             \
4095        for (node = start; node && ({ next = rb_next(node); 1;}); node = next)
4096
4097 static int qgroup_unreserve_range(struct btrfs_inode *inode,
4098                                   struct extent_changeset *reserved, u64 start,
4099                                   u64 len)
4100 {
4101         struct rb_node *node;
4102         struct rb_node *next;
4103         struct ulist_node *entry;
4104         int ret = 0;
4105
4106         node = reserved->range_changed.root.rb_node;
4107         if (!node)
4108                 return 0;
4109         while (node) {
4110                 entry = rb_entry(node, struct ulist_node, rb_node);
4111                 if (entry->val < start)
4112                         node = node->rb_right;
4113                 else
4114                         node = node->rb_left;
4115         }
4116
4117         if (entry->val > start && rb_prev(&entry->rb_node))
4118                 entry = rb_entry(rb_prev(&entry->rb_node), struct ulist_node,
4119                                  rb_node);
4120
4121         rbtree_iterate_from_safe(node, next, &entry->rb_node) {
4122                 u64 entry_start;
4123                 u64 entry_end;
4124                 u64 entry_len;
4125                 int clear_ret;
4126
4127                 entry = rb_entry(node, struct ulist_node, rb_node);
4128                 entry_start = entry->val;
4129                 entry_end = entry->aux;
4130                 entry_len = entry_end - entry_start + 1;
4131
4132                 if (entry_start >= start + len)
4133                         break;
4134                 if (entry_start + entry_len <= start)
4135                         continue;
4136                 /*
4137                  * Now the entry is in [start, start + len), revert the
4138                  * EXTENT_QGROUP_RESERVED bit.
4139                  */
4140                 clear_ret = clear_extent_bits(&inode->io_tree, entry_start,
4141                                               entry_end, EXTENT_QGROUP_RESERVED);
4142                 if (!ret && clear_ret < 0)
4143                         ret = clear_ret;
4144
4145                 ulist_del(&reserved->range_changed, entry->val, entry->aux);
4146                 if (likely(reserved->bytes_changed >= entry_len)) {
4147                         reserved->bytes_changed -= entry_len;
4148                 } else {
4149                         WARN_ON(1);
4150                         reserved->bytes_changed = 0;
4151                 }
4152         }
4153
4154         return ret;
4155 }
4156
4157 /*
4158  * Try to free some space for qgroup.
4159  *
4160  * For qgroup, there are only 3 ways to free qgroup space:
4161  * - Flush nodatacow write
4162  *   Any nodatacow write will free its reserved data space at run_delalloc_range().
4163  *   In theory, we should only flush nodatacow inodes, but it's not yet
4164  *   possible, so we need to flush the whole root.
4165  *
4166  * - Wait for ordered extents
4167  *   When ordered extents are finished, their reserved metadata is finally
4168  *   converted to per_trans status, which can be freed by later commit
4169  *   transaction.
4170  *
4171  * - Commit transaction
4172  *   This would free the meta_per_trans space.
4173  *   In theory this shouldn't provide much space, but any more qgroup space
4174  *   is needed.
4175  */
4176 static int try_flush_qgroup(struct btrfs_root *root)
4177 {
4178         int ret;
4179
4180         /* Can't hold an open transaction or we run the risk of deadlocking. */
4181         ASSERT(current->journal_info == NULL);
4182         if (WARN_ON(current->journal_info))
4183                 return 0;
4184
4185         /*
4186          * We don't want to run flush again and again, so if there is a running
4187          * one, we won't try to start a new flush, but exit directly.
4188          */
4189         if (test_and_set_bit(BTRFS_ROOT_QGROUP_FLUSHING, &root->state)) {
4190                 wait_event(root->qgroup_flush_wait,
4191                         !test_bit(BTRFS_ROOT_QGROUP_FLUSHING, &root->state));
4192                 return 0;
4193         }
4194
4195         ret = btrfs_start_delalloc_snapshot(root, true);
4196         if (ret < 0)
4197                 goto out;
4198         btrfs_wait_ordered_extents(root, U64_MAX, NULL);
4199
4200         /*
4201          * After waiting for ordered extents run delayed iputs in order to free
4202          * space from unlinked files before committing the current transaction,
4203          * as ordered extents may have been holding the last reference of an
4204          * inode and they add a delayed iput when they complete.
4205          */
4206         btrfs_run_delayed_iputs(root->fs_info);
4207         btrfs_wait_on_delayed_iputs(root->fs_info);
4208
4209         ret = btrfs_commit_current_transaction(root);
4210 out:
4211         clear_bit(BTRFS_ROOT_QGROUP_FLUSHING, &root->state);
4212         wake_up(&root->qgroup_flush_wait);
4213         return ret;
4214 }
4215
4216 static int qgroup_reserve_data(struct btrfs_inode *inode,
4217                         struct extent_changeset **reserved_ret, u64 start,
4218                         u64 len)
4219 {
4220         struct btrfs_root *root = inode->root;
4221         struct extent_changeset *reserved;
4222         bool new_reserved = false;
4223         u64 orig_reserved;
4224         u64 to_reserve;
4225         int ret;
4226
4227         if (btrfs_qgroup_mode(root->fs_info) == BTRFS_QGROUP_MODE_DISABLED ||
4228             !is_fstree(btrfs_root_id(root)) || len == 0)
4229                 return 0;
4230
4231         /* @reserved parameter is mandatory for qgroup */
4232         if (WARN_ON(!reserved_ret))
4233                 return -EINVAL;
4234         if (!*reserved_ret) {
4235                 new_reserved = true;
4236                 *reserved_ret = extent_changeset_alloc();
4237                 if (!*reserved_ret)
4238                         return -ENOMEM;
4239         }
4240         reserved = *reserved_ret;
4241         /* Record already reserved space */
4242         orig_reserved = reserved->bytes_changed;
4243         ret = set_record_extent_bits(&inode->io_tree, start,
4244                         start + len -1, EXTENT_QGROUP_RESERVED, reserved);
4245
4246         /* Newly reserved space */
4247         to_reserve = reserved->bytes_changed - orig_reserved;
4248         trace_btrfs_qgroup_reserve_data(&inode->vfs_inode, start, len,
4249                                         to_reserve, QGROUP_RESERVE);
4250         if (ret < 0)
4251                 goto out;
4252         ret = qgroup_reserve(root, to_reserve, true, BTRFS_QGROUP_RSV_DATA);
4253         if (ret < 0)
4254                 goto cleanup;
4255
4256         return ret;
4257
4258 cleanup:
4259         qgroup_unreserve_range(inode, reserved, start, len);
4260 out:
4261         if (new_reserved) {
4262                 extent_changeset_free(reserved);
4263                 *reserved_ret = NULL;
4264         }
4265         return ret;
4266 }
4267
4268 /*
4269  * Reserve qgroup space for range [start, start + len).
4270  *
4271  * This function will either reserve space from related qgroups or do nothing
4272  * if the range is already reserved.
4273  *
4274  * Return 0 for successful reservation
4275  * Return <0 for error (including -EQUOT)
4276  *
4277  * NOTE: This function may sleep for memory allocation, dirty page flushing and
4278  *       commit transaction. So caller should not hold any dirty page locked.
4279  */
4280 int btrfs_qgroup_reserve_data(struct btrfs_inode *inode,
4281                         struct extent_changeset **reserved_ret, u64 start,
4282                         u64 len)
4283 {
4284         int ret;
4285
4286         ret = qgroup_reserve_data(inode, reserved_ret, start, len);
4287         if (ret <= 0 && ret != -EDQUOT)
4288                 return ret;
4289
4290         ret = try_flush_qgroup(inode->root);
4291         if (ret < 0)
4292                 return ret;
4293         return qgroup_reserve_data(inode, reserved_ret, start, len);
4294 }
4295
4296 /* Free ranges specified by @reserved, normally in error path */
4297 static int qgroup_free_reserved_data(struct btrfs_inode *inode,
4298                                      struct extent_changeset *reserved,
4299                                      u64 start, u64 len, u64 *freed_ret)
4300 {
4301         struct btrfs_root *root = inode->root;
4302         struct ulist_node *unode;
4303         struct ulist_iterator uiter;
4304         struct extent_changeset changeset;
4305         u64 freed = 0;
4306         int ret;
4307
4308         extent_changeset_init(&changeset);
4309         len = round_up(start + len, root->fs_info->sectorsize);
4310         start = round_down(start, root->fs_info->sectorsize);
4311
4312         ULIST_ITER_INIT(&uiter);
4313         while ((unode = ulist_next(&reserved->range_changed, &uiter))) {
4314                 u64 range_start = unode->val;
4315                 /* unode->aux is the inclusive end */
4316                 u64 range_len = unode->aux - range_start + 1;
4317                 u64 free_start;
4318                 u64 free_len;
4319
4320                 extent_changeset_release(&changeset);
4321
4322                 /* Only free range in range [start, start + len) */
4323                 if (range_start >= start + len ||
4324                     range_start + range_len <= start)
4325                         continue;
4326                 free_start = max(range_start, start);
4327                 free_len = min(start + len, range_start + range_len) -
4328                            free_start;
4329                 /*
4330                  * TODO: To also modify reserved->ranges_reserved to reflect
4331                  * the modification.
4332                  *
4333                  * However as long as we free qgroup reserved according to
4334                  * EXTENT_QGROUP_RESERVED, we won't double free.
4335                  * So not need to rush.
4336                  */
4337                 ret = clear_record_extent_bits(&inode->io_tree, free_start,
4338                                 free_start + free_len - 1,
4339                                 EXTENT_QGROUP_RESERVED, &changeset);
4340                 if (ret < 0)
4341                         goto out;
4342                 freed += changeset.bytes_changed;
4343         }
4344         btrfs_qgroup_free_refroot(root->fs_info, btrfs_root_id(root), freed,
4345                                   BTRFS_QGROUP_RSV_DATA);
4346         if (freed_ret)
4347                 *freed_ret = freed;
4348         ret = 0;
4349 out:
4350         extent_changeset_release(&changeset);
4351         return ret;
4352 }
4353
4354 static int __btrfs_qgroup_release_data(struct btrfs_inode *inode,
4355                         struct extent_changeset *reserved, u64 start, u64 len,
4356                         u64 *released, int free)
4357 {
4358         struct extent_changeset changeset;
4359         int trace_op = QGROUP_RELEASE;
4360         int ret;
4361
4362         if (btrfs_qgroup_mode(inode->root->fs_info) == BTRFS_QGROUP_MODE_DISABLED) {
4363                 return clear_record_extent_bits(&inode->io_tree, start,
4364                                                 start + len - 1,
4365                                                 EXTENT_QGROUP_RESERVED, NULL);
4366         }
4367
4368         /* In release case, we shouldn't have @reserved */
4369         WARN_ON(!free && reserved);
4370         if (free && reserved)
4371                 return qgroup_free_reserved_data(inode, reserved, start, len, released);
4372         extent_changeset_init(&changeset);
4373         ret = clear_record_extent_bits(&inode->io_tree, start, start + len -1,
4374                                        EXTENT_QGROUP_RESERVED, &changeset);
4375         if (ret < 0)
4376                 goto out;
4377
4378         if (free)
4379                 trace_op = QGROUP_FREE;
4380         trace_btrfs_qgroup_release_data(&inode->vfs_inode, start, len,
4381                                         changeset.bytes_changed, trace_op);
4382         if (free)
4383                 btrfs_qgroup_free_refroot(inode->root->fs_info,
4384                                 btrfs_root_id(inode->root),
4385                                 changeset.bytes_changed, BTRFS_QGROUP_RSV_DATA);
4386         if (released)
4387                 *released = changeset.bytes_changed;
4388 out:
4389         extent_changeset_release(&changeset);
4390         return ret;
4391 }
4392
4393 /*
4394  * Free a reserved space range from io_tree and related qgroups
4395  *
4396  * Should be called when a range of pages get invalidated before reaching disk.
4397  * Or for error cleanup case.
4398  * if @reserved is given, only reserved range in [@start, @start + @len) will
4399  * be freed.
4400  *
4401  * For data written to disk, use btrfs_qgroup_release_data().
4402  *
4403  * NOTE: This function may sleep for memory allocation.
4404  */
4405 int btrfs_qgroup_free_data(struct btrfs_inode *inode,
4406                            struct extent_changeset *reserved,
4407                            u64 start, u64 len, u64 *freed)
4408 {
4409         return __btrfs_qgroup_release_data(inode, reserved, start, len, freed, 1);
4410 }
4411
4412 /*
4413  * Release a reserved space range from io_tree only.
4414  *
4415  * Should be called when a range of pages get written to disk and corresponding
4416  * FILE_EXTENT is inserted into corresponding root.
4417  *
4418  * Since new qgroup accounting framework will only update qgroup numbers at
4419  * commit_transaction() time, its reserved space shouldn't be freed from
4420  * related qgroups.
4421  *
4422  * But we should release the range from io_tree, to allow further write to be
4423  * COWed.
4424  *
4425  * NOTE: This function may sleep for memory allocation.
4426  */
4427 int btrfs_qgroup_release_data(struct btrfs_inode *inode, u64 start, u64 len, u64 *released)
4428 {
4429         return __btrfs_qgroup_release_data(inode, NULL, start, len, released, 0);
4430 }
4431
4432 static void add_root_meta_rsv(struct btrfs_root *root, int num_bytes,
4433                               enum btrfs_qgroup_rsv_type type)
4434 {
4435         if (type != BTRFS_QGROUP_RSV_META_PREALLOC &&
4436             type != BTRFS_QGROUP_RSV_META_PERTRANS)
4437                 return;
4438         if (num_bytes == 0)
4439                 return;
4440
4441         spin_lock(&root->qgroup_meta_rsv_lock);
4442         if (type == BTRFS_QGROUP_RSV_META_PREALLOC)
4443                 root->qgroup_meta_rsv_prealloc += num_bytes;
4444         else
4445                 root->qgroup_meta_rsv_pertrans += num_bytes;
4446         spin_unlock(&root->qgroup_meta_rsv_lock);
4447 }
4448
4449 static int sub_root_meta_rsv(struct btrfs_root *root, int num_bytes,
4450                              enum btrfs_qgroup_rsv_type type)
4451 {
4452         if (type != BTRFS_QGROUP_RSV_META_PREALLOC &&
4453             type != BTRFS_QGROUP_RSV_META_PERTRANS)
4454                 return 0;
4455         if (num_bytes == 0)
4456                 return 0;
4457
4458         spin_lock(&root->qgroup_meta_rsv_lock);
4459         if (type == BTRFS_QGROUP_RSV_META_PREALLOC) {
4460                 num_bytes = min_t(u64, root->qgroup_meta_rsv_prealloc,
4461                                   num_bytes);
4462                 root->qgroup_meta_rsv_prealloc -= num_bytes;
4463         } else {
4464                 num_bytes = min_t(u64, root->qgroup_meta_rsv_pertrans,
4465                                   num_bytes);
4466                 root->qgroup_meta_rsv_pertrans -= num_bytes;
4467         }
4468         spin_unlock(&root->qgroup_meta_rsv_lock);
4469         return num_bytes;
4470 }
4471
4472 int btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes,
4473                               enum btrfs_qgroup_rsv_type type, bool enforce)
4474 {
4475         struct btrfs_fs_info *fs_info = root->fs_info;
4476         int ret;
4477
4478         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||
4479             !is_fstree(btrfs_root_id(root)) || num_bytes == 0)
4480                 return 0;
4481
4482         BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize));
4483         trace_qgroup_meta_reserve(root, (s64)num_bytes, type);
4484         ret = qgroup_reserve(root, num_bytes, enforce, type);
4485         if (ret < 0)
4486                 return ret;
4487         /*
4488          * Record what we have reserved into root.
4489          *
4490          * To avoid quota disabled->enabled underflow.
4491          * In that case, we may try to free space we haven't reserved
4492          * (since quota was disabled), so record what we reserved into root.
4493          * And ensure later release won't underflow this number.
4494          */
4495         add_root_meta_rsv(root, num_bytes, type);
4496         return ret;
4497 }
4498
4499 int __btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes,
4500                                 enum btrfs_qgroup_rsv_type type, bool enforce,
4501                                 bool noflush)
4502 {
4503         int ret;
4504
4505         ret = btrfs_qgroup_reserve_meta(root, num_bytes, type, enforce);
4506         if ((ret <= 0 && ret != -EDQUOT) || noflush)
4507                 return ret;
4508
4509         ret = try_flush_qgroup(root);
4510         if (ret < 0)
4511                 return ret;
4512         return btrfs_qgroup_reserve_meta(root, num_bytes, type, enforce);
4513 }
4514
4515 /*
4516  * Per-transaction meta reservation should be all freed at transaction commit
4517  * time
4518  */
4519 void btrfs_qgroup_free_meta_all_pertrans(struct btrfs_root *root)
4520 {
4521         struct btrfs_fs_info *fs_info = root->fs_info;
4522
4523         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||
4524             !is_fstree(btrfs_root_id(root)))
4525                 return;
4526
4527         /* TODO: Update trace point to handle such free */
4528         trace_qgroup_meta_free_all_pertrans(root);
4529         /* Special value -1 means to free all reserved space */
4530         btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(root), (u64)-1,
4531                                   BTRFS_QGROUP_RSV_META_PERTRANS);
4532 }
4533
4534 void __btrfs_qgroup_free_meta(struct btrfs_root *root, int num_bytes,
4535                               enum btrfs_qgroup_rsv_type type)
4536 {
4537         struct btrfs_fs_info *fs_info = root->fs_info;
4538
4539         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||
4540             !is_fstree(btrfs_root_id(root)))
4541                 return;
4542
4543         /*
4544          * reservation for META_PREALLOC can happen before quota is enabled,
4545          * which can lead to underflow.
4546          * Here ensure we will only free what we really have reserved.
4547          */
4548         num_bytes = sub_root_meta_rsv(root, num_bytes, type);
4549         BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize));
4550         trace_qgroup_meta_reserve(root, -(s64)num_bytes, type);
4551         btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(root), num_bytes, type);
4552 }
4553
4554 static void qgroup_convert_meta(struct btrfs_fs_info *fs_info, u64 ref_root,
4555                                 int num_bytes)
4556 {
4557         struct btrfs_qgroup *qgroup;
4558         LIST_HEAD(qgroup_list);
4559
4560         if (num_bytes == 0)
4561                 return;
4562         if (!fs_info->quota_root)
4563                 return;
4564
4565         spin_lock(&fs_info->qgroup_lock);
4566         qgroup = find_qgroup_rb(fs_info, ref_root);
4567         if (!qgroup)
4568                 goto out;
4569
4570         qgroup_iterator_add(&qgroup_list, qgroup);
4571         list_for_each_entry(qgroup, &qgroup_list, iterator) {
4572                 struct btrfs_qgroup_list *glist;
4573
4574                 qgroup_rsv_release(fs_info, qgroup, num_bytes,
4575                                 BTRFS_QGROUP_RSV_META_PREALLOC);
4576                 if (!sb_rdonly(fs_info->sb))
4577                         qgroup_rsv_add(fs_info, qgroup, num_bytes,
4578                                        BTRFS_QGROUP_RSV_META_PERTRANS);
4579
4580                 list_for_each_entry(glist, &qgroup->groups, next_group)
4581                         qgroup_iterator_add(&qgroup_list, glist->group);
4582         }
4583 out:
4584         qgroup_iterator_clean(&qgroup_list);
4585         spin_unlock(&fs_info->qgroup_lock);
4586 }
4587
4588 /*
4589  * Convert @num_bytes of META_PREALLOCATED reservation to META_PERTRANS.
4590  *
4591  * This is called when preallocated meta reservation needs to be used.
4592  * Normally after btrfs_join_transaction() call.
4593  */
4594 void btrfs_qgroup_convert_reserved_meta(struct btrfs_root *root, int num_bytes)
4595 {
4596         struct btrfs_fs_info *fs_info = root->fs_info;
4597
4598         if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_DISABLED ||
4599             !is_fstree(btrfs_root_id(root)))
4600                 return;
4601         /* Same as btrfs_qgroup_free_meta_prealloc() */
4602         num_bytes = sub_root_meta_rsv(root, num_bytes,
4603                                       BTRFS_QGROUP_RSV_META_PREALLOC);
4604         trace_qgroup_meta_convert(root, num_bytes);
4605         qgroup_convert_meta(fs_info, btrfs_root_id(root), num_bytes);
4606         if (!sb_rdonly(fs_info->sb))
4607                 add_root_meta_rsv(root, num_bytes, BTRFS_QGROUP_RSV_META_PERTRANS);
4608 }
4609
4610 /*
4611  * Check qgroup reserved space leaking, normally at destroy inode
4612  * time
4613  */
4614 void btrfs_qgroup_check_reserved_leak(struct btrfs_inode *inode)
4615 {
4616         struct extent_changeset changeset;
4617         struct ulist_node *unode;
4618         struct ulist_iterator iter;
4619         int ret;
4620
4621         extent_changeset_init(&changeset);
4622         ret = clear_record_extent_bits(&inode->io_tree, 0, (u64)-1,
4623                         EXTENT_QGROUP_RESERVED, &changeset);
4624
4625         WARN_ON(ret < 0);
4626         if (WARN_ON(changeset.bytes_changed)) {
4627                 ULIST_ITER_INIT(&iter);
4628                 while ((unode = ulist_next(&changeset.range_changed, &iter))) {
4629                         btrfs_warn(inode->root->fs_info,
4630                 "leaking qgroup reserved space, ino: %llu, start: %llu, end: %llu",
4631                                 btrfs_ino(inode), unode->val, unode->aux);
4632                 }
4633                 btrfs_qgroup_free_refroot(inode->root->fs_info,
4634                                 btrfs_root_id(inode->root),
4635                                 changeset.bytes_changed, BTRFS_QGROUP_RSV_DATA);
4636
4637         }
4638         extent_changeset_release(&changeset);
4639 }
4640
4641 void btrfs_qgroup_init_swapped_blocks(
4642         struct btrfs_qgroup_swapped_blocks *swapped_blocks)
4643 {
4644         int i;
4645
4646         spin_lock_init(&swapped_blocks->lock);
4647         for (i = 0; i < BTRFS_MAX_LEVEL; i++)
4648                 swapped_blocks->blocks[i] = RB_ROOT;
4649         swapped_blocks->swapped = false;
4650 }
4651
4652 /*
4653  * Delete all swapped blocks record of @root.
4654  * Every record here means we skipped a full subtree scan for qgroup.
4655  *
4656  * Gets called when committing one transaction.
4657  */
4658 void btrfs_qgroup_clean_swapped_blocks(struct btrfs_root *root)
4659 {
4660         struct btrfs_qgroup_swapped_blocks *swapped_blocks;
4661         int i;
4662
4663         swapped_blocks = &root->swapped_blocks;
4664
4665         spin_lock(&swapped_blocks->lock);
4666         if (!swapped_blocks->swapped)
4667                 goto out;
4668         for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
4669                 struct rb_root *cur_root = &swapped_blocks->blocks[i];
4670                 struct btrfs_qgroup_swapped_block *entry;
4671                 struct btrfs_qgroup_swapped_block *next;
4672
4673                 rbtree_postorder_for_each_entry_safe(entry, next, cur_root,
4674                                                      node)
4675                         kfree(entry);
4676                 swapped_blocks->blocks[i] = RB_ROOT;
4677         }
4678         swapped_blocks->swapped = false;
4679 out:
4680         spin_unlock(&swapped_blocks->lock);
4681 }
4682
4683 /*
4684  * Add subtree roots record into @subvol_root.
4685  *
4686  * @subvol_root:        tree root of the subvolume tree get swapped
4687  * @bg:                 block group under balance
4688  * @subvol_parent/slot: pointer to the subtree root in subvolume tree
4689  * @reloc_parent/slot:  pointer to the subtree root in reloc tree
4690  *                      BOTH POINTERS ARE BEFORE TREE SWAP
4691  * @last_snapshot:      last snapshot generation of the subvolume tree
4692  */
4693 int btrfs_qgroup_add_swapped_blocks(struct btrfs_root *subvol_root,
4694                 struct btrfs_block_group *bg,
4695                 struct extent_buffer *subvol_parent, int subvol_slot,
4696                 struct extent_buffer *reloc_parent, int reloc_slot,
4697                 u64 last_snapshot)
4698 {
4699         struct btrfs_fs_info *fs_info = subvol_root->fs_info;
4700         struct btrfs_qgroup_swapped_blocks *blocks = &subvol_root->swapped_blocks;
4701         struct btrfs_qgroup_swapped_block *block;
4702         struct rb_node **cur;
4703         struct rb_node *parent = NULL;
4704         int level = btrfs_header_level(subvol_parent) - 1;
4705         int ret = 0;
4706
4707         if (!btrfs_qgroup_full_accounting(fs_info))
4708                 return 0;
4709
4710         if (btrfs_node_ptr_generation(subvol_parent, subvol_slot) >
4711             btrfs_node_ptr_generation(reloc_parent, reloc_slot)) {
4712                 btrfs_err_rl(fs_info,
4713                 "%s: bad parameter order, subvol_gen=%llu reloc_gen=%llu",
4714                         __func__,
4715                         btrfs_node_ptr_generation(subvol_parent, subvol_slot),
4716                         btrfs_node_ptr_generation(reloc_parent, reloc_slot));
4717                 return -EUCLEAN;
4718         }
4719
4720         block = kmalloc(sizeof(*block), GFP_NOFS);
4721         if (!block) {
4722                 ret = -ENOMEM;
4723                 goto out;
4724         }
4725
4726         /*
4727          * @reloc_parent/slot is still before swap, while @block is going to
4728          * record the bytenr after swap, so we do the swap here.
4729          */
4730         block->subvol_bytenr = btrfs_node_blockptr(reloc_parent, reloc_slot);
4731         block->subvol_generation = btrfs_node_ptr_generation(reloc_parent,
4732                                                              reloc_slot);
4733         block->reloc_bytenr = btrfs_node_blockptr(subvol_parent, subvol_slot);
4734         block->reloc_generation = btrfs_node_ptr_generation(subvol_parent,
4735                                                             subvol_slot);
4736         block->last_snapshot = last_snapshot;
4737         block->level = level;
4738
4739         /*
4740          * If we have bg == NULL, we're called from btrfs_recover_relocation(),
4741          * no one else can modify tree blocks thus we qgroup will not change
4742          * no matter the value of trace_leaf.
4743          */
4744         if (bg && bg->flags & BTRFS_BLOCK_GROUP_DATA)
4745                 block->trace_leaf = true;
4746         else
4747                 block->trace_leaf = false;
4748         btrfs_node_key_to_cpu(reloc_parent, &block->first_key, reloc_slot);
4749
4750         /* Insert @block into @blocks */
4751         spin_lock(&blocks->lock);
4752         cur = &blocks->blocks[level].rb_node;
4753         while (*cur) {
4754                 struct btrfs_qgroup_swapped_block *entry;
4755
4756                 parent = *cur;
4757                 entry = rb_entry(parent, struct btrfs_qgroup_swapped_block,
4758                                  node);
4759
4760                 if (entry->subvol_bytenr < block->subvol_bytenr) {
4761                         cur = &(*cur)->rb_left;
4762                 } else if (entry->subvol_bytenr > block->subvol_bytenr) {
4763                         cur = &(*cur)->rb_right;
4764                 } else {
4765                         if (entry->subvol_generation !=
4766                                         block->subvol_generation ||
4767                             entry->reloc_bytenr != block->reloc_bytenr ||
4768                             entry->reloc_generation !=
4769                                         block->reloc_generation) {
4770                                 /*
4771                                  * Duplicated but mismatch entry found.
4772                                  * Shouldn't happen.
4773                                  *
4774                                  * Marking qgroup inconsistent should be enough
4775                                  * for end users.
4776                                  */
4777                                 WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
4778                                 ret = -EEXIST;
4779                         }
4780                         kfree(block);
4781                         goto out_unlock;
4782                 }
4783         }
4784         rb_link_node(&block->node, parent, cur);
4785         rb_insert_color(&block->node, &blocks->blocks[level]);
4786         blocks->swapped = true;
4787 out_unlock:
4788         spin_unlock(&blocks->lock);
4789 out:
4790         if (ret < 0)
4791                 qgroup_mark_inconsistent(fs_info);
4792         return ret;
4793 }
4794
4795 /*
4796  * Check if the tree block is a subtree root, and if so do the needed
4797  * delayed subtree trace for qgroup.
4798  *
4799  * This is called during btrfs_cow_block().
4800  */
4801 int btrfs_qgroup_trace_subtree_after_cow(struct btrfs_trans_handle *trans,
4802                                          struct btrfs_root *root,
4803                                          struct extent_buffer *subvol_eb)
4804 {
4805         struct btrfs_fs_info *fs_info = root->fs_info;
4806         struct btrfs_tree_parent_check check = { 0 };
4807         struct btrfs_qgroup_swapped_blocks *blocks = &root->swapped_blocks;
4808         struct btrfs_qgroup_swapped_block *block;
4809         struct extent_buffer *reloc_eb = NULL;
4810         struct rb_node *node;
4811         bool found = false;
4812         bool swapped = false;
4813         int level = btrfs_header_level(subvol_eb);
4814         int ret = 0;
4815         int i;
4816
4817         if (!btrfs_qgroup_full_accounting(fs_info))
4818                 return 0;
4819         if (!is_fstree(btrfs_root_id(root)) || !root->reloc_root)
4820                 return 0;
4821
4822         spin_lock(&blocks->lock);
4823         if (!blocks->swapped) {
4824                 spin_unlock(&blocks->lock);
4825                 return 0;
4826         }
4827         node = blocks->blocks[level].rb_node;
4828
4829         while (node) {
4830                 block = rb_entry(node, struct btrfs_qgroup_swapped_block, node);
4831                 if (block->subvol_bytenr < subvol_eb->start) {
4832                         node = node->rb_left;
4833                 } else if (block->subvol_bytenr > subvol_eb->start) {
4834                         node = node->rb_right;
4835                 } else {
4836                         found = true;
4837                         break;
4838                 }
4839         }
4840         if (!found) {
4841                 spin_unlock(&blocks->lock);
4842                 goto out;
4843         }
4844         /* Found one, remove it from @blocks first and update blocks->swapped */
4845         rb_erase(&block->node, &blocks->blocks[level]);
4846         for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
4847                 if (RB_EMPTY_ROOT(&blocks->blocks[i])) {
4848                         swapped = true;
4849                         break;
4850                 }
4851         }
4852         blocks->swapped = swapped;
4853         spin_unlock(&blocks->lock);
4854
4855         check.level = block->level;
4856         check.transid = block->reloc_generation;
4857         check.has_first_key = true;
4858         memcpy(&check.first_key, &block->first_key, sizeof(check.first_key));
4859
4860         /* Read out reloc subtree root */
4861         reloc_eb = read_tree_block(fs_info, block->reloc_bytenr, &check);
4862         if (IS_ERR(reloc_eb)) {
4863                 ret = PTR_ERR(reloc_eb);
4864                 reloc_eb = NULL;
4865                 goto free_out;
4866         }
4867         if (!extent_buffer_uptodate(reloc_eb)) {
4868                 ret = -EIO;
4869                 goto free_out;
4870         }
4871
4872         ret = qgroup_trace_subtree_swap(trans, reloc_eb, subvol_eb,
4873                         block->last_snapshot, block->trace_leaf);
4874 free_out:
4875         kfree(block);
4876         free_extent_buffer(reloc_eb);
4877 out:
4878         if (ret < 0) {
4879                 btrfs_err_rl(fs_info,
4880                              "failed to account subtree at bytenr %llu: %d",
4881                              subvol_eb->start, ret);
4882                 qgroup_mark_inconsistent(fs_info);
4883         }
4884         return ret;
4885 }
4886
4887 void btrfs_qgroup_destroy_extent_records(struct btrfs_transaction *trans)
4888 {
4889         struct btrfs_qgroup_extent_record *entry;
4890         unsigned long index;
4891
4892         xa_for_each(&trans->delayed_refs.dirty_extents, index, entry) {
4893                 ulist_free(entry->old_roots);
4894                 kfree(entry);
4895         }
4896         xa_destroy(&trans->delayed_refs.dirty_extents);
4897 }
4898
4899 int btrfs_record_squota_delta(struct btrfs_fs_info *fs_info,
4900                               const struct btrfs_squota_delta *delta)
4901 {
4902         int ret;
4903         struct btrfs_qgroup *qgroup;
4904         struct btrfs_qgroup *qg;
4905         LIST_HEAD(qgroup_list);
4906         u64 root = delta->root;
4907         u64 num_bytes = delta->num_bytes;
4908         const int sign = (delta->is_inc ? 1 : -1);
4909
4910         if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_SIMPLE)
4911                 return 0;
4912
4913         if (!is_fstree(root))
4914                 return 0;
4915
4916         /* If the extent predates enabling quotas, don't count it. */
4917         if (delta->generation < fs_info->qgroup_enable_gen)
4918                 return 0;
4919
4920         spin_lock(&fs_info->qgroup_lock);
4921         qgroup = find_qgroup_rb(fs_info, root);
4922         if (!qgroup) {
4923                 ret = -ENOENT;
4924                 goto out;
4925         }
4926
4927         ret = 0;
4928         qgroup_iterator_add(&qgroup_list, qgroup);
4929         list_for_each_entry(qg, &qgroup_list, iterator) {
4930                 struct btrfs_qgroup_list *glist;
4931
4932                 qg->excl += num_bytes * sign;
4933                 qg->rfer += num_bytes * sign;
4934                 qgroup_dirty(fs_info, qg);
4935
4936                 list_for_each_entry(glist, &qg->groups, next_group)
4937                         qgroup_iterator_add(&qgroup_list, glist->group);
4938         }
4939         qgroup_iterator_clean(&qgroup_list);
4940
4941 out:
4942         spin_unlock(&fs_info->qgroup_lock);
4943         return ret;
4944 }