btrfs: Convert delayed_nodes_tree to XArray

Rename it to just 'delayed_nodes' and remove it from the protection of
btrfs_root->inode_lock.

Signed-off-by: Matthew Wilcox <willy@infradead.org>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index bc526941b0f024bcbd99fd7ed16faf5745e5b6a5..0d353fa2deba67a3c91c3dcc5b0d9548b378ee5f 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1199,11 +1199,9 @@ struct btrfs_root {
        /* red-black tree that keeps track of in-memory inodes */
        struct rb_root inode_tree;
 
-       /*
-        * radix tree that keeps track of delayed nodes of every inode,
-        * protected by inode_lock
-        */
-       struct radix_tree_root delayed_nodes_tree;
+       /* track delayed nodes of every inode */
+       struct xarray delayed_nodes;
+
        /*
         * right now this just gets used so that a root has its own devid
         * for stat.  It may be used for more later

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 43fdb2992956a0954734db87b9e0a99ba4cbb1a8..bdc41d9d83d522e837e94591acfb19b3e7b8b6a7 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -75,7 +75,7 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(
        }
 
        spin_lock(&root->inode_lock);
-       node = radix_tree_lookup(&root->delayed_nodes_tree, ino);
+       node = xa_load(&root->delayed_nodes, ino);
 
        if (node) {
                if (btrfs_inode->delayed_node) {
@@ -138,23 +138,17 @@ again:
        /* cached in the btrfs inode and can be accessed */
        refcount_set(&node->refs, 2);
 
-       ret = radix_tree_preload(GFP_NOFS);
+       xa_lock(&root->delayed_nodes);
+       ret = __xa_insert(&root->delayed_nodes, ino, node, GFP_NOFS);
        if (ret) {
+               xa_unlock(&root->delayed_nodes);
                kmem_cache_free(delayed_node_cache, node);
+               if (ret == -EBUSY)
+                       goto again;
                return ERR_PTR(ret);
        }
-
-       spin_lock(&root->inode_lock);
-       ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node);
-       if (ret == -EEXIST) {
-               spin_unlock(&root->inode_lock);
-               kmem_cache_free(delayed_node_cache, node);
-               radix_tree_preload_end();
-               goto again;
-       }
        btrfs_inode->delayed_node = node;
-       spin_unlock(&root->inode_lock);
-       radix_tree_preload_end();
+       xa_unlock(&root->delayed_nodes);
 
        return node;
 }
@@ -267,15 +261,12 @@ static void __btrfs_release_delayed_node(
        if (refcount_dec_and_test(&delayed_node->refs)) {
                struct btrfs_root *root = delayed_node->root;
 
-               spin_lock(&root->inode_lock);
                /*
                 * Once our refcount goes to zero, nobody is allowed to bump it
                 * back up.  We can delete it now.
                 */
                ASSERT(refcount_read(&delayed_node->refs) == 0);
-               radix_tree_delete(&root->delayed_nodes_tree,
-                                 delayed_node->inode_id);
-               spin_unlock(&root->inode_lock);
+               xa_erase(&root->delayed_nodes, delayed_node->inode_id);
                kmem_cache_free(delayed_node_cache, delayed_node);
        }
 }
@@ -1924,31 +1915,18 @@ void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode)
 
 void btrfs_kill_all_delayed_nodes(struct btrfs_root *root)
 {
-       u64 inode_id = 0;
-       struct btrfs_delayed_node *delayed_nodes[8];
-       int i, n;
-
-       while (1) {
-               spin_lock(&root->inode_lock);
-               n = radix_tree_gang_lookup(&root->delayed_nodes_tree,
-                                          (void **)delayed_nodes, inode_id,
-                                          ARRAY_SIZE(delayed_nodes));
-               if (!n) {
-                       spin_unlock(&root->inode_lock);
-                       break;
-               }
-
-               inode_id = delayed_nodes[n - 1]->inode_id + 1;
-
-               for (i = 0; i < n; i++)
-                       refcount_inc(&delayed_nodes[i]->refs);
-               spin_unlock(&root->inode_lock);
+       struct btrfs_delayed_node *node;
+       unsigned long inode_id;
 
-               for (i = 0; i < n; i++) {
-                       __btrfs_kill_delayed_node(delayed_nodes[i]);
-                       btrfs_release_delayed_node(delayed_nodes[i]);
-               }
+       xa_lock(&root->delayed_nodes);
+       xa_for_each(&root->delayed_nodes, inode_id, node) {
+               refcount_inc(&node->refs);
+               xa_unlock(&root->delayed_nodes);
+               __btrfs_kill_delayed_node(node);
+               btrfs_release_delayed_node(node);
+               xa_lock(&root->delayed_nodes);
        }
+       xa_unlock(&root->delayed_nodes);
 }
 
 void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info)

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 5c91e8f9f5d32478290c6d799e2c05e313082deb..4ab77bfc346aade079ae58cbdcdbb2d5c27ebbd1 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -5,7 +5,7 @@
 
 #include <linux/fs.h>
 #include <linux/blkdev.h>
-#include <linux/radix-tree.h>
+#include <linux/xarray.h>
 #include <linux/writeback.h>
 #include <linux/buffer_head.h>
 #include <linux/workqueue.h>
@@ -1162,7 +1162,7 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
        root->nr_delalloc_inodes = 0;
        root->nr_ordered_extents = 0;
        root->inode_tree = RB_ROOT;
-       INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
+       xa_init(&root->delayed_nodes);
        root->block_rsv = NULL;
 
        INIT_LIST_HEAD(&root->dirty_list);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index ee582a36653d30ee1f833153f9bc00225f7978ae..be269ab305b962e6fa51b5da434fc7608db87f73 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3735,7 +3735,7 @@ cache_index:
         * cache.
         *
         * This is required for both inode re-read from disk and delayed inode
-        * in delayed_nodes_tree.
+        * in delayed_nodes.
         */
        if (BTRFS_I(inode)->last_trans == fs_info->generation)
                set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,