btrfs: Convert reada_zones to XArray

The use of the reada_lock means we have to use the xa_reserve() API.
If we can avoid using reada_lock to protect this xarray, we can drop
the use of that function.

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

diff --git a/fs/btrfs/reada.c b/fs/btrfs/reada.c
index bb5bd49573b4cc116274d92d0bef180b0c1ec19f..49da50d69e707e37a07f76134bc7de6488e625ea 100644 (file)
--- a/fs/btrfs/reada.c
+++ b/fs/btrfs/reada.c
@@ -225,17 +225,16 @@ static struct reada_zone *reada_find_zone(struct btrfs_device *dev, u64 logical,
 {
        struct btrfs_fs_info *fs_info = dev->fs_info;
        int ret;
-       struct reada_zone *zone;
+       struct reada_zone *curr, *zone;
        struct btrfs_block_group_cache *cache = NULL;
        u64 start;
        u64 end;
+       unsigned long index = logical >> PAGE_SHIFT;
        int i;
 
-       zone = NULL;
        spin_lock(&fs_info->reada_lock);
-       ret = radix_tree_gang_lookup(&dev->reada_zones, (void **)&zone,
-                                    logical >> PAGE_SHIFT, 1);
-       if (ret == 1 && logical >= zone->start && logical <= zone->end) {
+       zone = xa_find(&dev->reada_zones, &index, ULONG_MAX, XA_PRESENT);
+       if (zone && logical >= zone->start && logical <= zone->end) {
                kref_get(&zone->refcnt);
                spin_unlock(&fs_info->reada_lock);
                return zone;
@@ -255,8 +254,8 @@ static struct reada_zone *reada_find_zone(struct btrfs_device *dev, u64 logical,
        if (!zone)
                return NULL;
 
-       ret = radix_tree_preload(GFP_KERNEL);
-       if (ret) {
+       ret = xa_insert(&dev->reada_zones, end >> PAGE_SHIFT, NULL, GFP_KERNEL);
+       if (ret == -ENOMEM) {
                kfree(zone);
                return NULL;
        }
@@ -276,21 +275,17 @@ static struct reada_zone *reada_find_zone(struct btrfs_device *dev, u64 logical,
        zone->ndevs = bbio->num_stripes;
 
        spin_lock(&fs_info->reada_lock);
-       ret = radix_tree_insert(&dev->reada_zones,
-                               (unsigned long)(zone->end >> PAGE_SHIFT),
-                               zone);
-
-       if (ret == -EEXIST) {
+       curr = xa_cmpxchg(&dev->reada_zones, zone->end >> PAGE_SHIFT,
+                               XA_ZERO_ENTRY, zone, GFP_NOWAIT | __GFP_NOWARN);
+       if (curr) {
                kfree(zone);
-               ret = radix_tree_gang_lookup(&dev->reada_zones, (void **)&zone,
-                                            logical >> PAGE_SHIFT, 1);
-               if (ret == 1 && logical >= zone->start && logical <= zone->end)
+               zone = curr;
+               if (logical >= zone->start && logical <= zone->end)
                        kref_get(&zone->refcnt);
                else
                        zone = NULL;
        }
        spin_unlock(&fs_info->reada_lock);
-       radix_tree_preload_end();
 
        return zone;
 }
@@ -525,9 +520,7 @@ static void reada_zone_release(struct kref *kref)
 {
        struct reada_zone *zone = container_of(kref, struct reada_zone, refcnt);
 
-       radix_tree_delete(&zone->device->reada_zones,
-                         zone->end >> PAGE_SHIFT);
-
+       xa_erase(&zone->device->reada_zones, zone->end >> PAGE_SHIFT);
        kfree(zone);
 }
 
@@ -580,7 +573,7 @@ static void reada_peer_zones_set_lock(struct reada_zone *zone, int lock)
 
        for (i = 0; i < zone->ndevs; ++i) {
                struct reada_zone *peer;
-               peer = radix_tree_lookup(&zone->devs[i]->reada_zones, index);
+               peer = xa_load(&zone->devs[i]->reada_zones, index);
                if (peer && peer->device != zone->device)
                        peer->locked = lock;
        }
@@ -591,12 +584,11 @@ static void reada_peer_zones_set_lock(struct reada_zone *zone, int lock)
  */
 static int reada_pick_zone(struct btrfs_device *dev)
 {
-       struct reada_zone *top_zone = NULL;
+       struct reada_zone *zone, *top_zone = NULL;
        struct reada_zone *top_locked_zone = NULL;
        u64 top_elems = 0;
        u64 top_locked_elems = 0;
-       unsigned long index = 0;
-       int ret;
+       unsigned long index;
 
        if (dev->reada_curr_zone) {
                reada_peer_zones_set_lock(dev->reada_curr_zone, 0);
@@ -604,14 +596,7 @@ static int reada_pick_zone(struct btrfs_device *dev)
                dev->reada_curr_zone = NULL;
        }
        /* pick the zone with the most elements */
-       while (1) {
-               struct reada_zone *zone;
-
-               ret = radix_tree_gang_lookup(&dev->reada_zones,
-                                            (void **)&zone, index, 1);
-               if (ret == 0)
-                       break;
-               index = (zone->end >> PAGE_SHIFT) + 1;
+       xa_for_each(&dev->reada_zones, index, zone) {
                if (zone->locked) {
                        if (zone->elems > top_locked_elems) {
                                top_locked_elems = zone->elems;
@@ -812,15 +797,11 @@ static void dump_devs(struct btrfs_fs_info *fs_info, int all)
 
        spin_lock(&fs_info->reada_lock);
        list_for_each_entry(device, &fs_devices->devices, dev_list) {
+               struct reada_zone *zone;
+
                btrfs_debug(fs_info, "dev %lld has %d in flight", device->devid,
                        atomic_read(&device->reada_in_flight));
-               index = 0;
-               while (1) {
-                       struct reada_zone *zone;
-                       ret = radix_tree_gang_lookup(&device->reada_zones,
-                                                    (void **)&zone, index, 1);
-                       if (ret == 0)
-                               break;
+               xa_for_each(&device->reada_zones, index, zone) {
                        pr_debug("  zone %llu-%llu elems %llu locked %d devs",
                                    zone->start, zone->end, zone->elems,
                                    zone->locked);
@@ -832,7 +813,6 @@ static void dump_devs(struct btrfs_fs_info *fs_info, int all)
                                pr_cont(" curr off %llu",
                                        device->reada_next - zone->start);
                        pr_cont("\n");
-                       index = (zone->end >> PAGE_SHIFT) + 1;
                }
                cnt = 0;
                index = 0;

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index d74b74ca07afd00d9302954408a8b87b04c0b09f..12f040cc95a609e351364499382b7cea5694d1a2 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -415,7 +415,7 @@ static struct btrfs_device *__alloc_device(void)
        atomic_set(&dev->reada_in_flight, 0);
        atomic_set(&dev->dev_stats_ccnt, 0);
        btrfs_device_data_ordered_init(dev);
-       INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
+       xa_init(&dev->reada_zones);
        INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
        extent_io_tree_init(NULL, &dev->alloc_state, 0, NULL);
 

diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 7f6aa1816409dca00c4024fd6e488af29b26f29c..67532445226bb3176ef4a6efbd4a8314b093e57c 100644 (file)
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -138,7 +138,7 @@ struct btrfs_device {
        atomic_t reada_in_flight;
        u64 reada_next;
        struct reada_zone *reada_curr_zone;
-       struct radix_tree_root reada_zones;
+       struct xarray reada_zones;
        struct radix_tree_root reada_extents;
 
        /* disk I/O failure stats. For detailed description refer to