btrfs: introduce BTRFS_NESTING_SPLIT for split blocks

If we are splitting a leaf/node, we could do something like the
following

lock(leaf)  BTRFS_NESTING_NORMAL
  lock(left) BTRFS_NESTING_LEFT + BTRFS_NESTING_COW
    push from leaf -> left
      reset path to point to left
        split left
          allocate new block, lock block BTRFS_NESTING_SPLIT

at the new block point we need to have a different nesting level,
because we have already used either BTRFS_NESTING_LEFT or
BTRFS_NESTING_RIGHT when pushing items from the original leaf into the
adjacent leaves.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index ecf8bf240d73aa3d500739caa0d8933f55156e06..884c8b5a0e626d3037934236e2929233710664fe 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -3537,7 +3537,7 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
        btrfs_node_key(c, &disk_key, mid);
 
        split = alloc_tree_block_no_bg_flush(trans, root, 0, &disk_key, level,
-                                            c->start, 0, BTRFS_NESTING_NORMAL);
+                                            c->start, 0, BTRFS_NESTING_SPLIT);
        if (IS_ERR(split))
                return PTR_ERR(split);
 
@@ -4324,7 +4324,7 @@ again:
                btrfs_item_key(l, &disk_key, mid);
 
        right = alloc_tree_block_no_bg_flush(trans, root, 0, &disk_key, 0,
-                                            l->start, 0, BTRFS_NESTING_NORMAL);
+                                            l->start, 0, BTRFS_NESTING_SPLIT);
        if (IS_ERR(right))
                return PTR_ERR(right);
 

diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h
index 16563bc486c701f11bfd687d4d2d66aa21374636..a6b59808e04609e9f5c9cc0c56b1e3e6576efe12 100644 (file)
--- a/fs/btrfs/locking.h
+++ b/fs/btrfs/locking.h
@@ -52,6 +52,15 @@ enum btrfs_lock_nesting {
        BTRFS_NESTING_LEFT_COW,
        BTRFS_NESTING_RIGHT_COW,
 
+       /*
+        * When splitting we may push nodes to the left or right, but still use
+        * the subsequent nodes in our path, keeping our locks on those adjacent
+        * blocks.  Thus when we go to allocate a new split block we've already
+        * used up all of our available subclasses, so this subclass exists to
+        * handle this case where we need to allocate a new split block.
+        */
+       BTRFS_NESTING_SPLIT,
+
        /*
         * We are limited to MAX_LOCKDEP_SUBLCLASSES number of subclasses, so
         * add this in here and add a static_assert to keep us from going over