1 files changed, 110 insertions, 9 deletions

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 71b2d1c7da69..44f06201f376 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -34,6 +34,8 @@
 #include "locking.h"
 #include "free-space-cache.h"
 
+#undef SCRAMBLE_DELAYED_REFS
+
 /*
  * control flags for do_chunk_alloc's force field
  * CHUNK_ALLOC_NO_FORCE means to only allocate a chunk
@@ -2217,6 +2219,7 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
         struct btrfs_delayed_ref_node *ref;
         struct btrfs_delayed_ref_head *locked_ref = NULL;
         struct btrfs_delayed_extent_op *extent_op;
+        struct btrfs_fs_info *fs_info = root->fs_info;
         int ret;
         int count = 0;
         int must_insert_reserved = 0;
@@ -2255,7 +2258,7 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                 ref = select_delayed_ref(locked_ref);
 
                 if (ref && ref->seq &&
-                    btrfs_check_delayed_seq(delayed_refs, ref->seq)) {
+                    btrfs_check_delayed_seq(fs_info, delayed_refs, ref->seq)) {
                         /*
                          * there are still refs with lower seq numbers in the
                          * process of being added. Don't run this ref yet.
@@ -2337,7 +2340,7 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                 }
 
 next:
-                do_chunk_alloc(trans, root->fs_info->extent_root,
+                do_chunk_alloc(trans, fs_info->extent_root,
                                2 * 1024 * 1024,
                                btrfs_get_alloc_profile(root, 0),
                                CHUNK_ALLOC_NO_FORCE);
@@ -2347,21 +2350,99 @@ next:
         return count;
 }
 
-static void wait_for_more_refs(struct btrfs_delayed_ref_root *delayed_refs,
+static void wait_for_more_refs(struct btrfs_fs_info *fs_info,
+                               struct btrfs_delayed_ref_root *delayed_refs,
                                unsigned long num_refs,
                                struct list_head *first_seq)
 {
         spin_unlock(&delayed_refs->lock);
         pr_debug("waiting for more refs (num %ld, first %p)\n",
                  num_refs, first_seq);
-        wait_event(delayed_refs->seq_wait,
+        wait_event(fs_info->tree_mod_seq_wait,
                    num_refs != delayed_refs->num_entries ||
-                   delayed_refs->seq_head.next != first_seq);
+                   fs_info->tree_mod_seq_list.next != first_seq);
         pr_debug("done waiting for more refs (num %ld, first %p)\n",
-                 delayed_refs->num_entries, delayed_refs->seq_head.next);
+                 delayed_refs->num_entries, fs_info->tree_mod_seq_list.next);
         spin_lock(&delayed_refs->lock);
 }
 
+#ifdef SCRAMBLE_DELAYED_REFS
+/*
+ * Normally delayed refs get processed in ascending bytenr order. This
+ * correlates in most cases to the order added. To expose dependencies on this
+ * order, we start to process the tree in the middle instead of the beginning
+ */
+static u64 find_middle(struct rb_root *root)
+{
+        struct rb_node *n = root->rb_node;
+        struct btrfs_delayed_ref_node *entry;
+        int alt = 1;
+        u64 middle;
+        u64 first = 0, last = 0;
+
+        n = rb_first(root);
+        if (n) {
+                entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
+                first = entry->bytenr;
+        }
+        n = rb_last(root);
+        if (n) {
+                entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
+                last = entry->bytenr;
+        }
+        n = root->rb_node;
+
+        while (n) {
+                entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
+                WARN_ON(!entry->in_tree);
+
+                middle = entry->bytenr;
+
+                if (alt)
+                        n = n->rb_left;
+                else
+                        n = n->rb_right;
+
+                alt = 1 - alt;
+        }
+        return middle;
+}
+#endif
+
+int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
+                                         struct btrfs_fs_info *fs_info)
+{
+        struct qgroup_update *qgroup_update;
+        int ret = 0;
+
+        if (list_empty(&trans->qgroup_ref_list) !=
+            !trans->delayed_ref_elem.seq) {
+                /* list without seq or seq without list */
+                printk(KERN_ERR "btrfs: qgroup accounting update error, list is%s empty, seq is %llu\n",
+                        list_empty(&trans->qgroup_ref_list) ? "" : " not",
+                        trans->delayed_ref_elem.seq);
+                BUG();
+        }
+
+        if (!trans->delayed_ref_elem.seq)
+                return 0;
+
+        while (!list_empty(&trans->qgroup_ref_list)) {
+                qgroup_update = list_first_entry(&trans->qgroup_ref_list,
+                                                 struct qgroup_update, list);
+                list_del(&qgroup_update->list);
+                if (!ret)
+                        ret = btrfs_qgroup_account_ref(
+                                        trans, fs_info, qgroup_update->node,
+                                        qgroup_update->extent_op);
+                kfree(qgroup_update);
+        }
+
+        btrfs_put_tree_mod_seq(fs_info, &trans->delayed_ref_elem);
+
+        return ret;
+}
+
 /*
  * this starts processing the delayed reference count updates and
  * extent insertions we have queued up so far.  count can be
@@ -2398,11 +2479,18 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
                        2 * 1024 * 1024, btrfs_get_alloc_profile(root, 0),
                        CHUNK_ALLOC_NO_FORCE);
 
+        btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
+
         delayed_refs = &trans->transaction->delayed_refs;
         INIT_LIST_HEAD(&cluster);
 again:
         consider_waiting = 0;
         spin_lock(&delayed_refs->lock);
+
+#ifdef SCRAMBLE_DELAYED_REFS
+        delayed_refs->run_delayed_start = find_middle(&delayed_refs->root);
+#endif
+
         if (count == 0) {
                 count = delayed_refs->num_entries * 2;
                 run_most = 1;
@@ -2437,7 +2525,7 @@ again:
                                 num_refs = delayed_refs->num_entries;
                                 first_seq = root->fs_info->tree_mod_seq_list.next;
                         } else {
-                                wait_for_more_refs(delayed_refs,
+                                wait_for_more_refs(root->fs_info, delayed_refs,
                                                    num_refs, first_seq);
                                 /*
                                  * after waiting, things have changed. we
@@ -2502,6 +2590,7 @@ again:
         }
 out:
         spin_unlock(&delayed_refs->lock);
+        assert_qgroups_uptodate(trans);
         return 0;
 }
 
@@ -4479,6 +4568,13 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
         csum_bytes = BTRFS_I(inode)->csum_bytes;
         spin_unlock(&BTRFS_I(inode)->lock);
 
+        if (root->fs_info->quota_enabled) {
+                ret = btrfs_qgroup_reserve(root, num_bytes +
+                                           nr_extents * root->leafsize);
+                if (ret)
+                        return ret;
+        }
+
         ret = reserve_metadata_bytes(root, block_rsv, to_reserve, flush);
         if (ret) {
                 u64 to_free = 0;
@@ -4557,6 +4653,11 @@ void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
 
         trace_btrfs_space_reservation(root->fs_info, "delalloc",
                                       btrfs_ino(inode), to_free, 0);
+        if (root->fs_info->quota_enabled) {
+                btrfs_qgroup_free(root, num_bytes +
+                                        dropped * root->leafsize);
+        }
+
         btrfs_block_rsv_release(root, &root->fs_info->delalloc_block_rsv,
                                 to_free);
 }
@@ -5193,8 +5294,8 @@ static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
         rb_erase(&head->node.rb_node, &delayed_refs->root);
 
         delayed_refs->num_entries--;
-        if (waitqueue_active(&delayed_refs->seq_wait))
-                wake_up(&delayed_refs->seq_wait);
+        if (waitqueue_active(&root->fs_info->tree_mod_seq_wait))
+                wake_up(&root->fs_info->tree_mod_seq_wait);
 
         /*
          * we don't take a ref on the node because we're removing it from the