btrfs: Introduce btrfs_io_geometry infrastructure

Add a structure that holds various parameters for IO calculations and a
helper that fills the values. This will help further refactoring and
reduction of functions that in some way open-coded the calculations.

Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 41813813f840ab1e5c5ffb781668515ee720510d..793494690e67d44becebef7fbe8196a6e97186d3 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -5915,6 +5915,102 @@ static bool need_full_stripe(enum btrfs_map_op op)
        return (op == BTRFS_MAP_WRITE || op == BTRFS_MAP_GET_READ_MIRRORS);
 }
 
+/*
+ * btrfs_get_io_geometry - calculates the geomery of a particular (address, len)
+ *                    tuple. This information is used to calculate how big a
+ *                    particular bio can get before it straddles a stripe.
+ *
+ * @fs_info - the filesystem
+ * @logical - address that we want to figure out the geometry of
+ * @len            - the length of IO we are going to perform, starting at @logical
+ * @op      - type of operation - write or read
+ * @io_geom - pointer used to return values
+ *
+ * Returns < 0 in case a chunk for the given logical address cannot be found,
+ * usually shouldn't happen unless @logical is corrupted, 0 otherwise.
+ */
+int btrfs_get_io_geometry(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
+                     u64 logical, u64 len, struct btrfs_io_geometry *io_geom)
+{
+       struct extent_map *em;
+       struct map_lookup *map;
+       u64 offset;
+       u64 stripe_offset;
+       u64 stripe_nr;
+       u64 stripe_len;
+       u64 raid56_full_stripe_start = (u64)-1;
+       int data_stripes;
+
+       ASSERT(op != BTRFS_MAP_DISCARD);
+
+       em = btrfs_get_chunk_map(fs_info, logical, len);
+       if (IS_ERR(em))
+               return PTR_ERR(em);
+
+       map = em->map_lookup;
+       /* Offset of this logical address in the chunk */
+       offset = logical - em->start;
+       /* Len of a stripe in a chunk */
+       stripe_len = map->stripe_len;
+       /* Stripe wher this block falls in */
+       stripe_nr = div64_u64(offset, stripe_len);
+       /* Offset of stripe in the chunk */
+       stripe_offset = stripe_nr * stripe_len;
+       if (offset < stripe_offset) {
+               btrfs_crit(fs_info,
+"stripe math has gone wrong, stripe_offset=%llu offset=%llu start=%llu logical=%llu stripe_len=%llu",
+                       stripe_offset, offset, em->start, logical, stripe_len);
+               free_extent_map(em);
+               return -EINVAL;
+       }
+
+       /* stripe_offset is the offset of this block in its stripe */
+       stripe_offset = offset - stripe_offset;
+       data_stripes = nr_data_stripes(map);
+
+       if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
+               u64 max_len = stripe_len - stripe_offset;
+
+               /*
+                * In case of raid56, we need to know the stripe aligned start
+                */
+               if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
+                       unsigned long full_stripe_len = stripe_len * data_stripes;
+                       raid56_full_stripe_start = offset;
+
+                       /*
+                        * Allow a write of a full stripe, but make sure we
+                        * don't allow straddling of stripes
+                        */
+                       raid56_full_stripe_start = div64_u64(raid56_full_stripe_start,
+                                       full_stripe_len);
+                       raid56_full_stripe_start *= full_stripe_len;
+
+                       /*
+                        * For writes to RAID[56], allow a full stripeset across
+                        * all disks. For other RAID types and for RAID[56]
+                        * reads, just allow a single stripe (on a single disk).
+                        */
+                       if (op == BTRFS_MAP_WRITE) {
+                               max_len = stripe_len * data_stripes -
+                                         (offset - raid56_full_stripe_start);
+                       }
+               }
+               len = min_t(u64, em->len - offset, max_len);
+       } else {
+               len = em->len - offset;
+       }
+
+       io_geom->len = len;
+       io_geom->offset = offset;
+       io_geom->stripe_len = stripe_len;
+       io_geom->stripe_nr = stripe_nr;
+       io_geom->stripe_offset = stripe_offset;
+       io_geom->raid56_stripe_offset = raid56_full_stripe_start;
+
+       return 0;
+}
+
 static int __btrfs_map_block(struct btrfs_fs_info *fs_info,
                             enum btrfs_map_op op,
                             u64 logical, u64 *length,

diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index fea7b65a712e09ec646f96667139e50cc3d805d4..2a8e398a8742e19598002d7f2c42a715a7685db5 100644 (file)
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -23,6 +23,21 @@ struct btrfs_pending_bios {
        struct bio *tail;
 };
 
+struct btrfs_io_geometry {
+       /* remaining bytes before crossing a stripe */
+       u64 len;
+       /* offset of logical address in chunk */
+       u64 offset;
+       /* length of single IO stripe */
+       u64 stripe_len;
+       /* number of stripe where address falls */
+       u64 stripe_nr;
+       /* offset of address in stripe */
+       u64 stripe_offset;
+       /* offset of raid56 stripe into the chunk */
+       u64 raid56_stripe_offset;
+};
+
 /*
  * Use sequence counter to get consistent device stat data on
  * 32-bit processors.
@@ -413,6 +428,8 @@ int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
 int btrfs_map_sblock(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
                     u64 logical, u64 *length,
                     struct btrfs_bio **bbio_ret);
+int btrfs_get_io_geometry(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
+                         u64 logical, u64 len, struct btrfs_io_geometry *io_geom);
 int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,
                     u64 physical, u64 **logical, int *naddrs, int *stripe_len);
 int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);