1 files changed, 31 insertions, 19 deletions

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index f7b29f9db5e2..0c99cf9fb595 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -6,6 +6,7 @@
 #include <linux/blkdev.h>
 #include <linux/ratelimit.h>
 #include <linux/sched/mm.h>
+#include <crypto/hash.h>
 #include "ctree.h"
 #include "volumes.h"
 #include "disk-io.h"
@@ -1787,11 +1788,12 @@ static int scrub_checksum(struct scrub_block *sblock)
 static int scrub_checksum_data(struct scrub_block *sblock)
 {
         struct scrub_ctx *sctx = sblock->sctx;
+        struct btrfs_fs_info *fs_info = sctx->fs_info;
+        SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
         u8 csum[BTRFS_CSUM_SIZE];
         u8 *on_disk_csum;
         struct page *page;
         void *buffer;
-        u32 crc = ~(u32)0;
         u64 len;
         int index;
 
@@ -1799,6 +1801,9 @@ static int scrub_checksum_data(struct scrub_block *sblock)
         if (!sblock->pagev[0]->have_csum)
                 return 0;
 
+        shash->tfm = fs_info->csum_shash;
+        crypto_shash_init(shash);
+
         on_disk_csum = sblock->pagev[0]->csum;
         page = sblock->pagev[0]->page;
         buffer = kmap_atomic(page);
@@ -1808,7 +1813,7 @@ static int scrub_checksum_data(struct scrub_block *sblock)
         for (;;) {
                 u64 l = min_t(u64, len, PAGE_SIZE);
 
-                crc = btrfs_csum_data(buffer, crc, l);
+                crypto_shash_update(shash, buffer, l);
                 kunmap_atomic(buffer);
                 len -= l;
                 if (len == 0)
@@ -1820,7 +1825,7 @@ static int scrub_checksum_data(struct scrub_block *sblock)
                 buffer = kmap_atomic(page);
         }
 
-        btrfs_csum_final(crc, csum);
+        crypto_shash_final(shash, csum);
         if (memcmp(csum, on_disk_csum, sctx->csum_size))
                 sblock->checksum_error = 1;
 
@@ -1832,16 +1837,19 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
         struct scrub_ctx *sctx = sblock->sctx;
         struct btrfs_header *h;
         struct btrfs_fs_info *fs_info = sctx->fs_info;
+        SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
         u8 calculated_csum[BTRFS_CSUM_SIZE];
         u8 on_disk_csum[BTRFS_CSUM_SIZE];
         struct page *page;
         void *mapped_buffer;
         u64 mapped_size;
         void *p;
-        u32 crc = ~(u32)0;
         u64 len;
         int index;
 
+        shash->tfm = fs_info->csum_shash;
+        crypto_shash_init(shash);
+
         BUG_ON(sblock->page_count < 1);
         page = sblock->pagev[0]->page;
         mapped_buffer = kmap_atomic(page);
@@ -1875,7 +1883,7 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
         for (;;) {
                 u64 l = min_t(u64, len, mapped_size);
 
-                crc = btrfs_csum_data(p, crc, l);
+                crypto_shash_update(shash, p, l);
                 kunmap_atomic(mapped_buffer);
                 len -= l;
                 if (len == 0)
@@ -1889,7 +1897,7 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
                 p = mapped_buffer;
         }
 
-        btrfs_csum_final(crc, calculated_csum);
+        crypto_shash_final(shash, calculated_csum);
         if (memcmp(calculated_csum, on_disk_csum, sctx->csum_size))
                 sblock->checksum_error = 1;
 
@@ -1900,18 +1908,22 @@ static int scrub_checksum_super(struct scrub_block *sblock)
 {
         struct btrfs_super_block *s;
         struct scrub_ctx *sctx = sblock->sctx;
+        struct btrfs_fs_info *fs_info = sctx->fs_info;
+        SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
         u8 calculated_csum[BTRFS_CSUM_SIZE];
         u8 on_disk_csum[BTRFS_CSUM_SIZE];
         struct page *page;
         void *mapped_buffer;
         u64 mapped_size;
         void *p;
-        u32 crc = ~(u32)0;
         int fail_gen = 0;
         int fail_cor = 0;
         u64 len;
         int index;
 
+        shash->tfm = fs_info->csum_shash;
+        crypto_shash_init(shash);
+
         BUG_ON(sblock->page_count < 1);
         page = sblock->pagev[0]->page;
         mapped_buffer = kmap_atomic(page);
@@ -1934,7 +1946,7 @@ static int scrub_checksum_super(struct scrub_block *sblock)
         for (;;) {
                 u64 l = min_t(u64, len, mapped_size);
 
-                crc = btrfs_csum_data(p, crc, l);
+                crypto_shash_update(shash, p, l);
                 kunmap_atomic(mapped_buffer);
                 len -= l;
                 if (len == 0)
@@ -1948,7 +1960,7 @@ static int scrub_checksum_super(struct scrub_block *sblock)
                 p = mapped_buffer;
         }
 
-        btrfs_csum_final(crc, calculated_csum);
+        crypto_shash_final(shash, calculated_csum);
         if (memcmp(calculated_csum, on_disk_csum, sctx->csum_size))
                 ++fail_cor;
 
@@ -2448,7 +2460,7 @@ static int scrub_find_csum(struct scrub_ctx *sctx, u64 logical, u8 *csum)
         ASSERT(index < UINT_MAX);
 
         num_sectors = sum->len / sctx->fs_info->sectorsize;
-        memcpy(csum, sum->sums + index, sctx->csum_size);
+        memcpy(csum, sum->sums + index * sctx->csum_size, sctx->csum_size);
         if (index == num_sectors - 1) {
                 list_del(&sum->list);
                 kfree(sum);
@@ -2660,18 +2672,18 @@ static int get_raid56_logic_offset(u64 physical, int num,
         u64 last_offset;
         u32 stripe_index;
         u32 rot;
+        const int data_stripes = nr_data_stripes(map);
 
-        last_offset = (physical - map->stripes[num].physical) *
-                      nr_data_stripes(map);
+        last_offset = (physical - map->stripes[num].physical) * data_stripes;
         if (stripe_start)
                 *stripe_start = last_offset;
 
         *offset = last_offset;
-        for (i = 0; i < nr_data_stripes(map); i++) {
+        for (i = 0; i < data_stripes; i++) {
                 *offset = last_offset + i * map->stripe_len;
 
                 stripe_nr = div64_u64(*offset, map->stripe_len);
-                stripe_nr = div_u64(stripe_nr, nr_data_stripes(map));
+                stripe_nr = div_u64(stripe_nr, data_stripes);
 
                 /* Work out the disk rotation on this stripe-set */
                 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, &rot);
@@ -3079,7 +3091,7 @@ static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,
                 offset = map->stripe_len * (num / map->sub_stripes);
                 increment = map->stripe_len * factor;
                 mirror_num = num % map->sub_stripes + 1;
-        } else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
+        } else if (map->type & BTRFS_BLOCK_GROUP_RAID1_MASK) {
                 increment = map->stripe_len;
                 mirror_num = num % map->num_stripes + 1;
         } else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
@@ -3410,15 +3422,15 @@ static noinline_for_stack int scrub_chunk(struct scrub_ctx *sctx,
                                           struct btrfs_block_group_cache *cache)
 {
         struct btrfs_fs_info *fs_info = sctx->fs_info;
-        struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
+        struct extent_map_tree *map_tree = &fs_info->mapping_tree;
         struct map_lookup *map;
         struct extent_map *em;
         int i;
         int ret = 0;
 
-        read_lock(&map_tree->map_tree.lock);
-        em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
-        read_unlock(&map_tree->map_tree.lock);
+        read_lock(&map_tree->lock);
+        em = lookup_extent_mapping(map_tree, chunk_offset, 1);
+        read_unlock(&map_tree->lock);
 
         if (!em) {
                 /*