btrfs: zoned: support RAID0/1/10 on top of raid stripe tree

When we have a raid-stripe-tree, we can do RAID0/1/10 on zoned devices
for data block groups. For metadata block groups, we don't actually
need anything special, as all metadata I/O is protected by the
btrfs_zoned_meta_io_lock() already.

Signed-off-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/raid-stripe-tree.h b/fs/btrfs/raid-stripe-tree.h
index f0f3c99b8a6f29ebda61114edd35f9c02ab25198..cdb58b38fcb5ea3ede8cd36a5e2dccf958b345aa 100644 (file)
--- a/fs/btrfs/raid-stripe-tree.h
+++ b/fs/btrfs/raid-stripe-tree.h
@@ -6,6 +6,11 @@
 #ifndef BTRFS_RAID_STRIPE_TREE_H
 #define BTRFS_RAID_STRIPE_TREE_H
 
+#define BTRFS_RST_SUPP_BLOCK_GROUP_MASK    (BTRFS_BLOCK_GROUP_DUP |            \
+                                           BTRFS_BLOCK_GROUP_RAID1_MASK |      \
+                                           BTRFS_BLOCK_GROUP_RAID0 |           \
+                                           BTRFS_BLOCK_GROUP_RAID10)
+
 struct btrfs_io_context;
 struct btrfs_io_stripe;
 struct btrfs_ordered_extent;
@@ -30,7 +35,7 @@ static inline bool btrfs_need_stripe_tree_update(struct btrfs_fs_info *fs_info,
        if (type != BTRFS_BLOCK_GROUP_DATA)
                return false;
 
-       if (profile & BTRFS_BLOCK_GROUP_RAID1_MASK)
+       if (profile & BTRFS_RST_SUPP_BLOCK_GROUP_MASK)
                return true;
 
        return false;

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index af0abc775b7fdfb3fbfe6cfbd7b478e1dafa5cf3..bc8d46cbc7c59dbad149cfb495caa29ceb7af311 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -6453,6 +6453,8 @@ int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
         * I/O context structure.
         */
        if (smap && num_alloc_stripes == 1 &&
+           !(btrfs_need_stripe_tree_update(fs_info, map->type) &&
+             op != BTRFS_MAP_READ) &&
            !((map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) && mirror_num > 1)) {
                ret = set_io_stripe(fs_info, op, logical, length, smap, map,
                                    stripe_index, stripe_offset, stripe_nr);

diff --git a/fs/btrfs/zoned.c b/fs/btrfs/zoned.c
index 0992ad6ee76450f4c00135c0e6f02ca84dca0113..3504ade30cb0c3426bcd64c0418b326f1d7a6153 100644 (file)
--- a/fs/btrfs/zoned.c
+++ b/fs/btrfs/zoned.c
@@ -1397,9 +1397,10 @@ static int btrfs_load_block_group_dup(struct btrfs_block_group *bg,
                                      struct zone_info *zone_info,
                                      unsigned long *active)
 {
-       if (map->type & BTRFS_BLOCK_GROUP_DATA) {
-               btrfs_err(bg->fs_info,
-                         "zoned: profile DUP not yet supported on data bg");
+       struct btrfs_fs_info *fs_info = bg->fs_info;
+
+       if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
+               btrfs_err(fs_info, "zoned: data DUP profile needs raid-stripe-tree");
                return -EINVAL;
        }
 
@@ -1433,6 +1434,121 @@ static int btrfs_load_block_group_dup(struct btrfs_block_group *bg,
        return 0;
 }
 
+static int btrfs_load_block_group_raid1(struct btrfs_block_group *bg,
+                                       struct map_lookup *map,
+                                       struct zone_info *zone_info,
+                                       unsigned long *active)
+{
+       struct btrfs_fs_info *fs_info = bg->fs_info;
+       int i;
+
+       if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
+               btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",
+                         btrfs_bg_type_to_raid_name(map->type));
+               return -EINVAL;
+       }
+
+       for (i = 0; i < map->num_stripes; i++) {
+               if (zone_info[i].alloc_offset == WP_MISSING_DEV ||
+                   zone_info[i].alloc_offset == WP_CONVENTIONAL)
+                       continue;
+
+               if ((zone_info[0].alloc_offset != zone_info[i].alloc_offset) &&
+                   !btrfs_test_opt(fs_info, DEGRADED)) {
+                       btrfs_err(fs_info,
+                       "zoned: write pointer offset mismatch of zones in %s profile",
+                                 btrfs_bg_type_to_raid_name(map->type));
+                       return -EIO;
+               }
+               if (test_bit(0, active) != test_bit(i, active)) {
+                       if (!btrfs_test_opt(fs_info, DEGRADED) &&
+                           !btrfs_zone_activate(bg)) {
+                               return -EIO;
+                       }
+               } else {
+                       if (test_bit(0, active))
+                               set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
+               }
+               /* In case a device is missing we have a cap of 0, so don't use it. */
+               bg->zone_capacity = min_not_zero(zone_info[0].capacity,
+                                                zone_info[1].capacity);
+       }
+
+       if (zone_info[0].alloc_offset != WP_MISSING_DEV)
+               bg->alloc_offset = zone_info[0].alloc_offset;
+       else
+               bg->alloc_offset = zone_info[i - 1].alloc_offset;
+
+       return 0;
+}
+
+static int btrfs_load_block_group_raid0(struct btrfs_block_group *bg,
+                                       struct map_lookup *map,
+                                       struct zone_info *zone_info,
+                                       unsigned long *active)
+{
+       struct btrfs_fs_info *fs_info = bg->fs_info;
+
+       if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
+               btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",
+                         btrfs_bg_type_to_raid_name(map->type));
+               return -EINVAL;
+       }
+
+       for (int i = 0; i < map->num_stripes; i++) {
+               if (zone_info[i].alloc_offset == WP_MISSING_DEV ||
+                   zone_info[i].alloc_offset == WP_CONVENTIONAL)
+                       continue;
+
+               if (test_bit(0, active) != test_bit(i, active)) {
+                       if (!btrfs_zone_activate(bg))
+                               return -EIO;
+               } else {
+                       if (test_bit(0, active))
+                               set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
+               }
+               bg->zone_capacity += zone_info[i].capacity;
+               bg->alloc_offset += zone_info[i].alloc_offset;
+       }
+
+       return 0;
+}
+
+static int btrfs_load_block_group_raid10(struct btrfs_block_group *bg,
+                                        struct map_lookup *map,
+                                        struct zone_info *zone_info,
+                                        unsigned long *active)
+{
+       struct btrfs_fs_info *fs_info = bg->fs_info;
+
+       if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
+               btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",
+                         btrfs_bg_type_to_raid_name(map->type));
+               return -EINVAL;
+       }
+
+       for (int i = 0; i < map->num_stripes; i++) {
+               if (zone_info[i].alloc_offset == WP_MISSING_DEV ||
+                   zone_info[i].alloc_offset == WP_CONVENTIONAL)
+                       continue;
+
+               if (test_bit(0, active) != test_bit(i, active)) {
+                       if (!btrfs_zone_activate(bg))
+                               return -EIO;
+               } else {
+                       if (test_bit(0, active))
+                               set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
+               }
+
+               if ((i % map->sub_stripes) == 0) {
+                       bg->zone_capacity += zone_info[i].capacity;
+                       bg->alloc_offset += zone_info[i].alloc_offset;
+               }
+       }
+
+       return 0;
+}
+
 int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache, bool new)
 {
        struct btrfs_fs_info *fs_info = cache->fs_info;
@@ -1525,11 +1641,18 @@ int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache, bool new)
                ret = btrfs_load_block_group_dup(cache, map, zone_info, active);
                break;
        case BTRFS_BLOCK_GROUP_RAID1:
+       case BTRFS_BLOCK_GROUP_RAID1C3:
+       case BTRFS_BLOCK_GROUP_RAID1C4:
+               ret = btrfs_load_block_group_raid1(cache, map, zone_info, active);
+               break;
        case BTRFS_BLOCK_GROUP_RAID0:
+               ret = btrfs_load_block_group_raid0(cache, map, zone_info, active);
+               break;
        case BTRFS_BLOCK_GROUP_RAID10:
+               ret = btrfs_load_block_group_raid10(cache, map, zone_info, active);
+               break;
        case BTRFS_BLOCK_GROUP_RAID5:
        case BTRFS_BLOCK_GROUP_RAID6:
-               /* non-single profiles are not supported yet */
        default:
                btrfs_err(fs_info, "zoned: profile %s not yet supported",
                          btrfs_bg_type_to_raid_name(map->type));