Btrfs: process the delayed reference queue in clusters

The delayed reference queue maintains pending operations that need to
be done to the extent allocation tree.  These are processed by
finding records in the tree that are not currently being processed one at
a time.

This is slow because it uses lots of time searching through the rbtree
and because it creates lock contention on the extent allocation tree
when lots of different procs are running delayed refs at the same time.

This commit changes things to grab a cluster of refs for processing,
using a cursor into the rbtree as the starting point of the next search.
This way we walk smoothly through the rbtree.

Signed-off-by: Chris Mason <chris.mason@oracle.com>

1 files changed, 98 insertions, 51 deletions

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 8471c79b0877..3b8b6c212701 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -926,52 +926,41 @@ again:
         return NULL;
 }
 
-/*
- * this starts processing the delayed reference count updates and
- * extent insertions we have queued up so far.  count can be
- * 0, which means to process everything in the tree at the start
- * of the run (but not newly added entries), or it can be some target
- * number you'd like to process.
- */
-int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
-                           struct btrfs_root *root, unsigned long count)
+static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
+                                       struct btrfs_root *root,
+                                       struct list_head *cluster)
 {
-        struct rb_node *node;
         struct btrfs_delayed_ref_root *delayed_refs;
         struct btrfs_delayed_ref_node *ref;
         struct btrfs_delayed_ref_head *locked_ref = NULL;
         int ret;
+        int count = 0;
         int must_insert_reserved = 0;
-        int run_all = count == (unsigned long)-1;
-
-        if (root == root->fs_info->extent_root)
-                root = root->fs_info->tree_root;
 
         delayed_refs = &trans->transaction->delayed_refs;
-again:
-        spin_lock(&delayed_refs->lock);
-        if (count == 0)
-                count = delayed_refs->num_entries;
         while (1) {
                 if (!locked_ref) {
-                        /*
-                         * no locked ref, go find something we can
-                         * process in the rbtree.  We start at
-                         * the beginning of the tree, there may be less
-                         * lock contention if we do something smarter here.
-                         */
-                        node = rb_first(&delayed_refs->root);
-                        if (!node) {
-                                spin_unlock(&delayed_refs->lock);
+                        /* pick a new head ref from the cluster list */
+                        if (list_empty(cluster))
                                 break;
-                        }
 
-                        ref = rb_entry(node, struct btrfs_delayed_ref_node,
-                                       rb_node);
-                        ret = btrfs_lock_delayed_ref(trans, ref, &locked_ref);
-                        if (ret) {
-                                spin_unlock(&delayed_refs->lock);
-                                break;
+                        locked_ref = list_entry(cluster->next,
+                                     struct btrfs_delayed_ref_head, cluster);
+
+                        /* grab the lock that says we are going to process
+                         * all the refs for this head */
+                        ret = btrfs_delayed_ref_lock(trans, locked_ref);
+
+                        /*
+                         * we may have dropped the spin lock to get the head
+                         * mutex lock, and that might have given someone else
+                         * time to free the head.  If that's true, it has been
+                         * removed from our list and we can move on.
+                         */
+                        if (ret == -EAGAIN) {
+                                locked_ref = NULL;
+                                count++;
+                                continue;
                         }
                 }
 
@@ -986,7 +975,6 @@ again:
                  * locked_ref is the head node, so we have to go one
                  * node back for any delayed ref updates
                  */
-
                 ref = select_delayed_ref(locked_ref);
                 if (!ref) {
                         /* All delayed refs have been processed, Go ahead
@@ -994,6 +982,7 @@ again:
                          * so that any accounting fixes can happen
                          */
                         ref = &locked_ref->node;
+                        list_del_init(&locked_ref->cluster);
                         locked_ref = NULL;
                 }
 
@@ -1007,30 +996,72 @@ again:
                 BUG_ON(ret);
                 btrfs_put_delayed_ref(ref);
 
-                /* once we lock the head ref, we have to process all the
-                 * entries for it.  So, we might end up doing more entries
-                 * that count was asking us to do.
-                 */
-                if (count > 0)
-                        count--;
+                count++;
+                cond_resched();
+                spin_lock(&delayed_refs->lock);
+        }
+        return count;
+}
+
+/*
+ * this starts processing the delayed reference count updates and
+ * extent insertions we have queued up so far.  count can be
+ * 0, which means to process everything in the tree at the start
+ * of the run (but not newly added entries), or it can be some target
+ * number you'd like to process.
+ */
+int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
+                           struct btrfs_root *root, unsigned long count)
+{
+        struct rb_node *node;
+        struct btrfs_delayed_ref_root *delayed_refs;
+        struct btrfs_delayed_ref_node *ref;
+        struct list_head cluster;
+        int ret;
+        int run_all = count == (unsigned long)-1;
+        int run_most = 0;
+
+        if (root == root->fs_info->extent_root)
+                root = root->fs_info->tree_root;
+
+        delayed_refs = &trans->transaction->delayed_refs;
+        INIT_LIST_HEAD(&cluster);
+again:
+        spin_lock(&delayed_refs->lock);
+        if (count == 0) {
+                count = delayed_refs->num_entries * 2;
+                run_most = 1;
+        }
+        while (1) {
+                if (!(run_all || run_most) &&
+                    delayed_refs->num_heads_ready < 64)
+                        break;
 
                 /*
-                 * we set locked_ref to null above if we're all done
-                 * with this bytenr
+                 * go find something we can process in the rbtree.  We start at
+                 * the beginning of the tree, and then build a cluster
+                 * of refs to process starting at the first one we are able to
+                 * lock
                  */
-                if (!locked_ref && count == 0)
+                ret = btrfs_find_ref_cluster(trans, &cluster,
+                                             delayed_refs->run_delayed_start);
+                if (ret)
                         break;
 
-                cond_resched();
-                spin_lock(&delayed_refs->lock);
+                ret = run_clustered_refs(trans, root, &cluster);
+                BUG_ON(ret < 0);
+
+                count -= min_t(unsigned long, ret, count);
+
+                if (count == 0)
+                        break;
         }
+
         if (run_all) {
-                spin_lock(&delayed_refs->lock);
                 node = rb_first(&delayed_refs->root);
-                if (!node) {
-                        spin_unlock(&delayed_refs->lock);
+                if (!node)
                         goto out;
-                }
+                count = (unsigned long)-1;
 
                 while (node) {
                         ref = rb_entry(node, struct btrfs_delayed_ref_node,
@@ -1052,11 +1083,11 @@ again:
                         node = rb_next(node);
                 }
                 spin_unlock(&delayed_refs->lock);
-                count = (unsigned long)-1;
                 schedule_timeout(1);
                 goto again;
         }
 out:
+        spin_unlock(&delayed_refs->lock);
         return 0;
 }
 
@@ -2407,12 +2438,18 @@ static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
          */
         head->node.in_tree = 0;
         rb_erase(&head->node.rb_node, &delayed_refs->root);
+
         delayed_refs->num_entries--;
 
         /*
          * we don't take a ref on the node because we're removing it from the
          * tree, so we just steal the ref the tree was holding.
          */
+        delayed_refs->num_heads--;
+        if (list_empty(&head->cluster))
+                delayed_refs->num_heads_ready--;
+
+        list_del_init(&head->cluster);
         spin_unlock(&delayed_refs->lock);
 
         ret = run_one_delayed_ref(trans, root->fs_info->tree_root,
@@ -3705,6 +3742,7 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
         struct btrfs_path *path;
         int i;
         int orig_level;
+        int update_count;
         struct btrfs_root_item *root_item = &root->root_item;
 
         WARN_ON(!mutex_is_locked(&root->fs_info->drop_mutex));
@@ -3746,6 +3784,7 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
                 }
         }
         while (1) {
+                unsigned long update;
                 wret = walk_down_tree(trans, root, path, &level);
                 if (wret > 0)
                         break;
@@ -3764,6 +3803,14 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
                 }
                 atomic_inc(&root->fs_info->throttle_gen);
                 wake_up(&root->fs_info->transaction_throttle);
+                for (update_count = 0; update_count < 16; update_count++) {
+                        update = trans->delayed_ref_updates;
+                        trans->delayed_ref_updates = 0;
+                        if (update)
+                                btrfs_run_delayed_refs(trans, root, update);
+                        else
+                                break;
+                }
         }
         for (i = 0; i <= orig_level; i++) {
                 if (path->nodes[i]) {