Btrfs: switch the btrfs tree locks to reader/writer

The btrfs metadata btree is the source of significant
lock contention, especially in the root node.   This
commit changes our locking to use a reader/writer
lock.

The lock is built on top of rw spinlocks, and it
extends the lock tracking to remember if we have a
read lock or a write lock when we go to blocking.  Atomics
count the number of blocking readers or writers at any
given time.

It removes all of the adaptive spinning from the old code
and uses only the spinning/blocking hints inside of btrfs
to decide when it should continue spinning.

In read heavy workloads this is dramatically faster.  In write
heavy workloads we're still faster because of less contention
on the root node lock.

We suffer slightly in dbench because we schedule more often
during write locks, but all other benchmarks so far are improved.

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

1 files changed, 3 insertions, 3 deletions

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 4ce8a9f41d1e..ac278dd83175 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -1730,8 +1730,8 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
                                 btrfs_read_buffer(next, ptr_gen);
 
                                 btrfs_tree_lock(next);
-                                clean_tree_block(trans, root, next);
                                 btrfs_set_lock_blocking(next);
+                                clean_tree_block(trans, root, next);
                                 btrfs_wait_tree_block_writeback(next);
                                 btrfs_tree_unlock(next);
 
@@ -1796,8 +1796,8 @@ static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
                                 next = path->nodes[*level];
 
                                 btrfs_tree_lock(next);
-                                clean_tree_block(trans, root, next);
                                 btrfs_set_lock_blocking(next);
+                                clean_tree_block(trans, root, next);
                                 btrfs_wait_tree_block_writeback(next);
                                 btrfs_tree_unlock(next);
 
@@ -1864,8 +1864,8 @@ static int walk_log_tree(struct btrfs_trans_handle *trans,
                         next = path->nodes[orig_level];
 
                         btrfs_tree_lock(next);
-                        clean_tree_block(trans, log, next);
                         btrfs_set_lock_blocking(next);
+                        clean_tree_block(trans, log, next);
                         btrfs_wait_tree_block_writeback(next);
                         btrfs_tree_unlock(next);