1 files changed, 181 insertions, 102 deletions

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index 9d49c586995a..1280eff8af56 100644
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -98,13 +98,10 @@ struct btrfs_qgroup_list {
         struct btrfs_qgroup *member;
 };
 
-struct qgroup_rescan {
-        struct btrfs_work       work;
-        struct btrfs_fs_info    *fs_info;
-};
-
-static void qgroup_rescan_start(struct btrfs_fs_info *fs_info,
-                                struct qgroup_rescan *qscan);
+static int
+qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,
+                   int init_flags);
+static void qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info);
 
 /* must be called with qgroup_ioctl_lock held */
 static struct btrfs_qgroup *find_qgroup_rb(struct btrfs_fs_info *fs_info,
@@ -255,10 +252,17 @@ int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
         int slot;
         int ret = 0;
         u64 flags = 0;
+        u64 rescan_progress = 0;
 
         if (!fs_info->quota_enabled)
                 return 0;
 
+        fs_info->qgroup_ulist = ulist_alloc(GFP_NOFS);
+        if (!fs_info->qgroup_ulist) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
         path = btrfs_alloc_path();
         if (!path) {
                 ret = -ENOMEM;
@@ -306,20 +310,7 @@ int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
                         }
                         fs_info->qgroup_flags = btrfs_qgroup_status_flags(l,
                                                                           ptr);
-                        fs_info->qgroup_rescan_progress.objectid =
-                                        btrfs_qgroup_status_rescan(l, ptr);
-                        if (fs_info->qgroup_flags &
-                            BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
-                                struct qgroup_rescan *qscan =
-                                        kmalloc(sizeof(*qscan), GFP_NOFS);
-                                if (!qscan) {
-                                        ret = -ENOMEM;
-                                        goto out;
-                                }
-                                fs_info->qgroup_rescan_progress.type = 0;
-                                fs_info->qgroup_rescan_progress.offset = 0;
-                                qgroup_rescan_start(fs_info, qscan);
-                        }
+                        rescan_progress = btrfs_qgroup_status_rescan(l, ptr);
                         goto next1;
                 }
 
@@ -421,9 +412,18 @@ out:
         if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)) {
                 fs_info->quota_enabled = 0;
                 fs_info->pending_quota_state = 0;
+        } else if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN &&
+                   ret >= 0) {
+                ret = qgroup_rescan_init(fs_info, rescan_progress, 0);
         }
         btrfs_free_path(path);
 
+        if (ret < 0) {
+                ulist_free(fs_info->qgroup_ulist);
+                fs_info->qgroup_ulist = NULL;
+                fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
+        }
+
         return ret < 0 ? ret : 0;
 }
 
@@ -460,6 +460,7 @@ void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info)
                 }
                 kfree(qgroup);
         }
+        ulist_free(fs_info->qgroup_ulist);
 }
 
 static int add_qgroup_relation_item(struct btrfs_trans_handle *trans,
@@ -819,6 +820,12 @@ int btrfs_quota_enable(struct btrfs_trans_handle *trans,
                 goto out;
         }
 
+        fs_info->qgroup_ulist = ulist_alloc(GFP_NOFS);
+        if (!fs_info->qgroup_ulist) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
         /*
          * initially create the quota tree
          */
@@ -916,6 +923,10 @@ out_free_root:
                 kfree(quota_root);
         }
 out:
+        if (ret) {
+                ulist_free(fs_info->qgroup_ulist);
+                fs_info->qgroup_ulist = NULL;
+        }
         mutex_unlock(&fs_info->qgroup_ioctl_lock);
         return ret;
 }
@@ -1355,7 +1366,6 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
         u64 ref_root;
         struct btrfs_qgroup *qgroup;
         struct ulist *roots = NULL;
-        struct ulist *tmp = NULL;
         u64 seq;
         int ret = 0;
         int sgn;
@@ -1428,14 +1438,7 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
         if (ret < 0)
                 return ret;
 
-        mutex_lock(&fs_info->qgroup_rescan_lock);
         spin_lock(&fs_info->qgroup_lock);
-        if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
-                if (fs_info->qgroup_rescan_progress.objectid <= node->bytenr) {
-                        ret = 0;
-                        goto unlock;
-                }
-        }
 
         quota_root = fs_info->quota_root;
         if (!quota_root)
@@ -1448,39 +1451,34 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
         /*
          * step 1: for each old ref, visit all nodes once and inc refcnt
          */
-        tmp = ulist_alloc(GFP_ATOMIC);
-        if (!tmp) {
-                ret = -ENOMEM;
-                goto unlock;
-        }
+        ulist_reinit(fs_info->qgroup_ulist);
         seq = fs_info->qgroup_seq;
         fs_info->qgroup_seq += roots->nnodes + 1; /* max refcnt */
 
-        ret = qgroup_account_ref_step1(fs_info, roots, tmp, seq);
+        ret = qgroup_account_ref_step1(fs_info, roots, fs_info->qgroup_ulist,
+                                       seq);
         if (ret)
                 goto unlock;
 
         /*
          * step 2: walk from the new root
          */
-        ret = qgroup_account_ref_step2(fs_info, roots, tmp, seq, sgn,
-                                       node->num_bytes, qgroup);
+        ret = qgroup_account_ref_step2(fs_info, roots, fs_info->qgroup_ulist,
+                                       seq, sgn, node->num_bytes, qgroup);
         if (ret)
                 goto unlock;
 
         /*
          * step 3: walk again from old refs
          */
-        ret = qgroup_account_ref_step3(fs_info, roots, tmp, seq, sgn,
-                                       node->num_bytes);
+        ret = qgroup_account_ref_step3(fs_info, roots, fs_info->qgroup_ulist,
+                                       seq, sgn, node->num_bytes);
         if (ret)
                 goto unlock;
 
 unlock:
         spin_unlock(&fs_info->qgroup_lock);
-        mutex_unlock(&fs_info->qgroup_rescan_lock);
         ulist_free(roots);
-        ulist_free(tmp);
 
         return ret;
 }
@@ -1527,9 +1525,12 @@ int btrfs_run_qgroups(struct btrfs_trans_handle *trans,
                 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
 
         if (!ret && start_rescan_worker) {
-                ret = btrfs_qgroup_rescan(fs_info);
-                if (ret)
-                        pr_err("btrfs: start rescan quota failed: %d\n", ret);
+                ret = qgroup_rescan_init(fs_info, 0, 1);
+                if (!ret) {
+                        qgroup_rescan_zero_tracking(fs_info);
+                        btrfs_queue_worker(&fs_info->qgroup_rescan_workers,
+                                           &fs_info->qgroup_rescan_work);
+                }
                 ret = 0;
         }
 
@@ -1720,7 +1721,6 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
         struct btrfs_fs_info *fs_info = root->fs_info;
         u64 ref_root = root->root_key.objectid;
         int ret = 0;
-        struct ulist *ulist = NULL;
         struct ulist_node *unode;
         struct ulist_iterator uiter;
 
@@ -1743,17 +1743,13 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
          * in a first step, we check all affected qgroups if any limits would
          * be exceeded
          */
-        ulist = ulist_alloc(GFP_ATOMIC);
-        if (!ulist) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        ret = ulist_add(ulist, qgroup->qgroupid,
+        ulist_reinit(fs_info->qgroup_ulist);
+        ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid,
                         (uintptr_t)qgroup, GFP_ATOMIC);
         if (ret < 0)
                 goto out;
         ULIST_ITER_INIT(&uiter);
-        while ((unode = ulist_next(ulist, &uiter))) {
+        while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
@@ -1774,7 +1770,8 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
                 }
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
-                        ret = ulist_add(ulist, glist->group->qgroupid,
+                        ret = ulist_add(fs_info->qgroup_ulist,
+                                        glist->group->qgroupid,
                                         (uintptr_t)glist->group, GFP_ATOMIC);
                         if (ret < 0)
                                 goto out;
@@ -1785,7 +1782,7 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
          * no limits exceeded, now record the reservation into all qgroups
          */
         ULIST_ITER_INIT(&uiter);
-        while ((unode = ulist_next(ulist, &uiter))) {
+        while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
 
                 qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
@@ -1795,8 +1792,6 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
 
 out:
         spin_unlock(&fs_info->qgroup_lock);
-        ulist_free(ulist);
-
         return ret;
 }
 
@@ -1805,7 +1800,6 @@ void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes)
         struct btrfs_root *quota_root;
         struct btrfs_qgroup *qgroup;
         struct btrfs_fs_info *fs_info = root->fs_info;
-        struct ulist *ulist = NULL;
         struct ulist_node *unode;
         struct ulist_iterator uiter;
         u64 ref_root = root->root_key.objectid;
@@ -1827,17 +1821,13 @@ void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes)
         if (!qgroup)
                 goto out;
 
-        ulist = ulist_alloc(GFP_ATOMIC);
-        if (!ulist) {
-                btrfs_std_error(fs_info, -ENOMEM);
-                goto out;
-        }
-        ret = ulist_add(ulist, qgroup->qgroupid,
+        ulist_reinit(fs_info->qgroup_ulist);
+        ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid,
                         (uintptr_t)qgroup, GFP_ATOMIC);
         if (ret < 0)
                 goto out;
         ULIST_ITER_INIT(&uiter);
-        while ((unode = ulist_next(ulist, &uiter))) {
+        while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
@@ -1846,7 +1836,8 @@ void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes)
                 qg->reserved -= num_bytes;
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
-                        ret = ulist_add(ulist, glist->group->qgroupid,
+                        ret = ulist_add(fs_info->qgroup_ulist,
+                                        glist->group->qgroupid,
                                         (uintptr_t)glist->group, GFP_ATOMIC);
                         if (ret < 0)
                                 goto out;
@@ -1855,7 +1846,6 @@ void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes)
 
 out:
         spin_unlock(&fs_info->qgroup_lock);
-        ulist_free(ulist);
 }
 
 void assert_qgroups_uptodate(struct btrfs_trans_handle *trans)
@@ -1874,12 +1864,11 @@ void assert_qgroups_uptodate(struct btrfs_trans_handle *trans)
  * returns 1 when done, 2 when done and FLAG_INCONSISTENT was cleared.
  */
 static int
-qgroup_rescan_leaf(struct qgroup_rescan *qscan, struct btrfs_path *path,
+qgroup_rescan_leaf(struct btrfs_fs_info *fs_info, struct btrfs_path *path,
                    struct btrfs_trans_handle *trans, struct ulist *tmp,
                    struct extent_buffer *scratch_leaf)
 {
         struct btrfs_key found;
-        struct btrfs_fs_info *fs_info = qscan->fs_info;
         struct ulist *roots = NULL;
         struct ulist_node *unode;
         struct ulist_iterator uiter;
@@ -2007,11 +1996,10 @@ out:
 
 static void btrfs_qgroup_rescan_worker(struct btrfs_work *work)
 {
-        struct qgroup_rescan *qscan = container_of(work, struct qgroup_rescan,
-                                                   work);
+        struct btrfs_fs_info *fs_info = container_of(work, struct btrfs_fs_info,
+                                                     qgroup_rescan_work);
         struct btrfs_path *path;
         struct btrfs_trans_handle *trans = NULL;
-        struct btrfs_fs_info *fs_info = qscan->fs_info;
         struct ulist *tmp = NULL;
         struct extent_buffer *scratch_leaf = NULL;
         int err = -ENOMEM;
@@ -2036,7 +2024,7 @@ static void btrfs_qgroup_rescan_worker(struct btrfs_work *work)
                 if (!fs_info->quota_enabled) {
                         err = -EINTR;
                 } else {
-                        err = qgroup_rescan_leaf(qscan, path, trans,
+                        err = qgroup_rescan_leaf(fs_info, path, trans,
                                                  tmp, scratch_leaf);
                 }
                 if (err > 0)
@@ -2049,7 +2037,6 @@ out:
         kfree(scratch_leaf);
         ulist_free(tmp);
         btrfs_free_path(path);
-        kfree(qscan);
 
         mutex_lock(&fs_info->qgroup_rescan_lock);
         fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
@@ -2068,47 +2055,74 @@ out:
         } else {
                 pr_err("btrfs: qgroup scan failed with %d\n", err);
         }
-}
 
-static void
-qgroup_rescan_start(struct btrfs_fs_info *fs_info, struct qgroup_rescan *qscan)
-{
-        memset(&qscan->work, 0, sizeof(qscan->work));
-        qscan->work.func = btrfs_qgroup_rescan_worker;
-        qscan->fs_info = fs_info;
-
-        pr_info("btrfs: qgroup scan started\n");
-        btrfs_queue_worker(&fs_info->qgroup_rescan_workers, &qscan->work);
+        complete_all(&fs_info->qgroup_rescan_completion);
 }
 
-int
-btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
+/*
+ * Checks that (a) no rescan is running and (b) quota is enabled. Allocates all
+ * memory required for the rescan context.
+ */
+static int
+qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid,
+                   int init_flags)
 {
         int ret = 0;
-        struct rb_node *n;
-        struct btrfs_qgroup *qgroup;
-        struct qgroup_rescan *qscan = kmalloc(sizeof(*qscan), GFP_NOFS);
 
-        if (!qscan)
-                return -ENOMEM;
+        if (!init_flags &&
+            (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) ||
+             !(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))) {
+                ret = -EINVAL;
+                goto err;
+        }
 
         mutex_lock(&fs_info->qgroup_rescan_lock);
         spin_lock(&fs_info->qgroup_lock);
-        if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
-                ret = -EINPROGRESS;
-        else if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))
-                ret = -EINVAL;
-        if (ret) {
-                spin_unlock(&fs_info->qgroup_lock);
-                mutex_unlock(&fs_info->qgroup_rescan_lock);
-                kfree(qscan);
-                return ret;
+
+        if (init_flags) {
+                if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
+                        ret = -EINPROGRESS;
+                else if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))
+                        ret = -EINVAL;
+
+                if (ret) {
+                        spin_unlock(&fs_info->qgroup_lock);
+                        mutex_unlock(&fs_info->qgroup_rescan_lock);
+                        goto err;
+                }
+
+                fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN;
         }
 
-        fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN;
         memset(&fs_info->qgroup_rescan_progress, 0,
                 sizeof(fs_info->qgroup_rescan_progress));
+        fs_info->qgroup_rescan_progress.objectid = progress_objectid;
+
+        spin_unlock(&fs_info->qgroup_lock);
+        mutex_unlock(&fs_info->qgroup_rescan_lock);
+
+        init_completion(&fs_info->qgroup_rescan_completion);
+
+        memset(&fs_info->qgroup_rescan_work, 0,
+               sizeof(fs_info->qgroup_rescan_work));
+        fs_info->qgroup_rescan_work.func = btrfs_qgroup_rescan_worker;
+
+        if (ret) {
+err:
+                pr_info("btrfs: qgroup_rescan_init failed with %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static void
+qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info)
+{
+        struct rb_node *n;
+        struct btrfs_qgroup *qgroup;
 
+        spin_lock(&fs_info->qgroup_lock);
         /* clear all current qgroup tracking information */
         for (n = rb_first(&fs_info->qgroup_tree); n; n = rb_next(n)) {
                 qgroup = rb_entry(n, struct btrfs_qgroup, node);
@@ -2118,9 +2132,74 @@ btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
                 qgroup->excl_cmpr = 0;
         }
         spin_unlock(&fs_info->qgroup_lock);
-        mutex_unlock(&fs_info->qgroup_rescan_lock);
+}
+
+int
+btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
+{
+        int ret = 0;
+        struct btrfs_trans_handle *trans;
 
-        qgroup_rescan_start(fs_info, qscan);
+        ret = qgroup_rescan_init(fs_info, 0, 1);
+        if (ret)
+                return ret;
+
+        /*
+         * We have set the rescan_progress to 0, which means no more
+         * delayed refs will be accounted by btrfs_qgroup_account_ref.
+         * However, btrfs_qgroup_account_ref may be right after its call
+         * to btrfs_find_all_roots, in which case it would still do the
+         * accounting.
+         * To solve this, we're committing the transaction, which will
+         * ensure we run all delayed refs and only after that, we are
+         * going to clear all tracking information for a clean start.
+         */
+
+        trans = btrfs_join_transaction(fs_info->fs_root);
+        if (IS_ERR(trans)) {
+                fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
+                return PTR_ERR(trans);
+        }
+        ret = btrfs_commit_transaction(trans, fs_info->fs_root);
+        if (ret) {
+                fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
+                return ret;
+        }
+
+        qgroup_rescan_zero_tracking(fs_info);
+
+        btrfs_queue_worker(&fs_info->qgroup_rescan_workers,
+                           &fs_info->qgroup_rescan_work);
 
         return 0;
 }
+
+int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info)
+{
+        int running;
+        int ret = 0;
+
+        mutex_lock(&fs_info->qgroup_rescan_lock);
+        spin_lock(&fs_info->qgroup_lock);
+        running = fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN;
+        spin_unlock(&fs_info->qgroup_lock);
+        mutex_unlock(&fs_info->qgroup_rescan_lock);
+
+        if (running)
+                ret = wait_for_completion_interruptible(
+                                        &fs_info->qgroup_rescan_completion);
+
+        return ret;
+}
+
+/*
+ * this is only called from open_ctree where we're still single threaded, thus
+ * locking is omitted here.
+ */
+void
+btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info)
+{
+        if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN)
+                btrfs_queue_worker(&fs_info->qgroup_rescan_workers,
+                                   &fs_info->qgroup_rescan_work);
+}