btrfs: reduce div64 calls by limiting the number of stripes of a chunk to u32

There are quite some div64 calls inside btrfs_map_block() and its
variants.

Such calls are for @stripe_nr, where @stripe_nr is the number of
stripes before our logical bytenr inside a chunk.

However we can eliminate such div64 calls by just reducing the width of
@stripe_nr from 64 to 32.

This can be done because our chunk size limit is already 10G, with fixed
stripe length 64K.
Thus a U32 is definitely enough to contain the number of stripes.

With such width reduction, we can get rid of slower div64, and extra
warning for certain 32bit arch.

This patch would do:

- Add a new tree-checker chunk validation on chunk length
  Make sure no chunk can reach 256G, which can also act as a bitflip
  checker.

- Reduce the width from u64 to u32 for @stripe_nr variables

- Replace unnecessary div64 calls with regular modulo and division
  32bit division and modulo are much faster than 64bit operations, and
  we are finally free of the div64 fear at least in those involved
  functions.

Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
index b27474731e7ba619a0ddbfa01fa2f43a877acf6e..46a8ca24afaa8efd6a04c5699af0770e0e2b3323 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -1992,8 +1992,8 @@ int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,
 
        for (i = 0; i < map->num_stripes; i++) {
                bool already_inserted = false;
-               u64 stripe_nr;
-               u64 offset;
+               u32 stripe_nr;
+               u32 offset;
                int j;
 
                if (!in_range(physical, map->stripes[i].physical,
@@ -2006,16 +2006,14 @@ int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,
                         BTRFS_STRIPE_LEN_MASK;
 
                if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
-                                BTRFS_BLOCK_GROUP_RAID10)) {
-                       stripe_nr = stripe_nr * map->num_stripes + i;
-                       stripe_nr = div_u64(stripe_nr, map->sub_stripes);
-               }
+                                BTRFS_BLOCK_GROUP_RAID10))
+                       stripe_nr = div_u64(stripe_nr * map->num_stripes + i,
+                                           map->sub_stripes);
                /*
                 * The remaining case would be for RAID56, multiply by
                 * nr_data_stripes().  Alternatively, just use rmap_len below
                 * instead of map->stripe_len
                 */
-
                bytenr = chunk_start + stripe_nr * io_stripe_size + offset;
 
                /* Ensure we don't add duplicate addresses */

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 190536b9077992b42c84423d3f8404e9e98802e5..e1910a045c240f9ad693c8f93578c4adcd3173c5 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -2908,10 +2908,7 @@ static int get_raid56_logic_offset(u64 physical, int num,
 {
        int i;
        int j = 0;
-       u64 stripe_nr;
        u64 last_offset;
-       u32 stripe_index;
-       u32 rot;
        const int data_stripes = nr_data_stripes(map);
 
        last_offset = (physical - map->stripes[num].physical) * data_stripes;
@@ -2920,13 +2917,17 @@ static int get_raid56_logic_offset(u64 physical, int num,
 
        *offset = last_offset;
        for (i = 0; i < data_stripes; i++) {
+               u32 stripe_nr;
+               u32 stripe_index;
+               u32 rot;
+
                *offset = last_offset + (i << BTRFS_STRIPE_LEN_SHIFT);
 
-               stripe_nr = *offset >> BTRFS_STRIPE_LEN_SHIFT;
-               stripe_nr = div_u64(stripe_nr, data_stripes);
+               stripe_nr = (u32)(*offset >> BTRFS_STRIPE_LEN_SHIFT) / data_stripes;
 
                /* Work out the disk rotation on this stripe-set */
-               stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, &rot);
+               rot = stripe_nr % map->num_stripes;
+               stripe_nr /= map->num_stripes;
                /* calculate which stripe this data locates */
                rot += i;
                stripe_index = rot % map->num_stripes;

diff --git a/fs/btrfs/tree-checker.c b/fs/btrfs/tree-checker.c
index baad1ed7e1118784b19178b81208ed7775b65eb0..e2b54793bf0c248a9031ed445c4209fdadc4601f 100644 (file)
--- a/fs/btrfs/tree-checker.c
+++ b/fs/btrfs/tree-checker.c
@@ -849,6 +849,20 @@ int btrfs_check_chunk_valid(struct extent_buffer *leaf,
                          stripe_len);
                return -EUCLEAN;
        }
+       /*
+        * We artificially limit the chunk size, so that the number of stripes
+        * inside a chunk can be fit into a U32.  The current limit (256G) is
+        * way too large for real world usage anyway, and it's also much larger
+        * than our existing limit (10G).
+        *
+        * Thus it should be a good way to catch obvious bitflips.
+        */
+       if (unlikely(length >= ((u64)U32_MAX << BTRFS_STRIPE_LEN_SHIFT))) {
+               chunk_err(leaf, chunk, logical,
+                         "chunk length too large: have %llu limit %llu",
+                         length, (u64)U32_MAX << BTRFS_STRIPE_LEN_SHIFT);
+               return -EUCLEAN;
+       }
        if (unlikely(type & ~(BTRFS_BLOCK_GROUP_TYPE_MASK |
                              BTRFS_BLOCK_GROUP_PROFILE_MASK))) {
                chunk_err(leaf, chunk, logical,

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index d2b8b8a8bd89bf71dabff8e07bf0a0f508f09365..9f80ff74101fb9a5796698e9ee76f4bdac7a61cb 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -5970,15 +5970,15 @@ struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,
        struct btrfs_discard_stripe *stripes;
        u64 length = *length_ret;
        u64 offset;
-       u64 stripe_nr;
-       u64 stripe_nr_end;
+       u32 stripe_nr;
+       u32 stripe_nr_end;
+       u32 stripe_cnt;
        u64 stripe_end_offset;
-       u64 stripe_cnt;
        u64 stripe_offset;
        u32 stripe_index;
        u32 factor = 0;
        u32 sub_stripes = 0;
-       u64 stripes_per_dev = 0;
+       u32 stripes_per_dev = 0;
        u32 remaining_stripes = 0;
        u32 last_stripe = 0;
        int ret;
@@ -6031,18 +6031,19 @@ struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,
                factor = map->num_stripes / sub_stripes;
                *num_stripes = min_t(u64, map->num_stripes,
                                    sub_stripes * stripe_cnt);
-               stripe_nr = div_u64_rem(stripe_nr, factor, &stripe_index);
+               stripe_index = stripe_nr % factor;
+               stripe_nr /= factor;
                stripe_index *= sub_stripes;
-               stripes_per_dev = div_u64_rem(stripe_cnt, factor,
-                                             &remaining_stripes);
-               div_u64_rem(stripe_nr_end - 1, factor, &last_stripe);
-               last_stripe *= sub_stripes;
+
+               remaining_stripes = stripe_cnt % factor;
+               stripes_per_dev = stripe_cnt / factor;
+               last_stripe = ((stripe_nr_end - 1) % factor) * sub_stripes;
        } else if (map->type & (BTRFS_BLOCK_GROUP_RAID1_MASK |
                                BTRFS_BLOCK_GROUP_DUP)) {
                *num_stripes = map->num_stripes;
        } else {
-               stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
-                                       &stripe_index);
+               stripe_index = stripe_nr % map->num_stripes;
+               stripe_nr /= map->num_stripes;
        }
 
        stripes = kcalloc(*num_stripes, sizeof(*stripes), GFP_NOFS);
@@ -6298,7 +6299,7 @@ static bool need_full_stripe(enum btrfs_map_op op)
 }
 
 static u64 btrfs_max_io_len(struct map_lookup *map, enum btrfs_map_op op,
-                           u64 offset, u64 *stripe_nr, u64 *stripe_offset,
+                           u64 offset, u32 *stripe_nr, u64 *stripe_offset,
                            u64 *full_stripe_start)
 {
        ASSERT(op != BTRFS_MAP_DISCARD);
@@ -6346,7 +6347,7 @@ static u64 btrfs_max_io_len(struct map_lookup *map, enum btrfs_map_op op,
 }
 
 static void set_io_stripe(struct btrfs_io_stripe *dst, const struct map_lookup *map,
-                         u32 stripe_index, u64 stripe_offset, u64 stripe_nr)
+                         u32 stripe_index, u64 stripe_offset, u32 stripe_nr)
 {
        dst->dev = map->stripes[stripe_index].dev;
        dst->physical = map->stripes[stripe_index].physical +
@@ -6363,7 +6364,7 @@ int __btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
        struct map_lookup *map;
        u64 map_offset;
        u64 stripe_offset;
-       u64 stripe_nr;
+       u32 stripe_nr;
        u32 stripe_index;
        int data_stripes;
        int i;
@@ -6422,8 +6423,8 @@ int __btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
        num_stripes = 1;
        stripe_index = 0;
        if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
-               stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
-                               &stripe_index);
+               stripe_index = stripe_nr % map->num_stripes;
+               stripe_nr /= map->num_stripes;
                if (!need_full_stripe(op))
                        mirror_num = 1;
        } else if (map->type & BTRFS_BLOCK_GROUP_RAID1_MASK) {
@@ -6449,8 +6450,8 @@ int __btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
        } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
                u32 factor = map->num_stripes / map->sub_stripes;
 
-               stripe_nr = div_u64_rem(stripe_nr, factor, &stripe_index);
-               stripe_index *= map->sub_stripes;
+               stripe_index = (stripe_nr % factor) * map->sub_stripes;
+               stripe_nr /= factor;
 
                if (need_full_stripe(op))
                        num_stripes = map->sub_stripes;
@@ -6466,9 +6467,16 @@ int __btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
 
        } else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
                if (need_raid_map && (need_full_stripe(op) || mirror_num > 1)) {
-                       /* push stripe_nr back to the start of the full stripe */
-                       stripe_nr = div64_u64(raid56_full_stripe_start,
-                                             data_stripes << BTRFS_STRIPE_LEN_SHIFT);
+                       /*
+                        * Push stripe_nr back to the start of the full stripe
+                        * For those cases needing a full stripe, @stripe_nr
+                        * is the full stripe number.
+                        *
+                        * Originally we go raid56_full_stripe_start / full_stripe_len,
+                        * but that can be expensive.  Here we just divide
+                        * @stripe_nr with @data_stripes.
+                        */
+                       stripe_nr /= data_stripes;
 
                        /* RAID[56] write or recovery. Return all stripes */
                        num_stripes = map->num_stripes;
@@ -6486,25 +6494,24 @@ int __btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
                         * Mirror #2 is RAID5 parity block.
                         * Mirror #3 is RAID6 Q block.
                         */
-                       stripe_nr = div_u64_rem(stripe_nr,
-                                       data_stripes, &stripe_index);
+                       stripe_index = stripe_nr % data_stripes;
+                       stripe_nr /= data_stripes;
                        if (mirror_num > 1)
                                stripe_index = data_stripes + mirror_num - 2;
 
                        /* We distribute the parity blocks across stripes */
-                       div_u64_rem(stripe_nr + stripe_index, map->num_stripes,
-                                       &stripe_index);
+                       stripe_index = (stripe_nr + stripe_index) % map->num_stripes;
                        if (!need_full_stripe(op) && mirror_num <= 1)
                                mirror_num = 1;
                }
        } else {
                /*
-                * after this, stripe_nr is the number of stripes on this
+                * After this, stripe_nr is the number of stripes on this
                 * device we have to walk to find the data, and stripe_index is
                 * the number of our device in the stripe array
                 */
-               stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
-                               &stripe_index);
+               stripe_index = stripe_nr % map->num_stripes;
+               stripe_nr /= map->num_stripes;
                mirror_num = stripe_index + 1;
        }
        if (stripe_index >= map->num_stripes) {
@@ -6566,7 +6573,7 @@ int __btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
                unsigned rot;
 
                /* Work out the disk rotation on this stripe-set */
-               div_u64_rem(stripe_nr, num_stripes, &rot);
+               rot = stripe_nr % num_stripes;
 
                /* Fill in the logical address of each stripe */
                tmp = stripe_nr * data_stripes;