1 files changed, 34 insertions, 51 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index d3280b2b7592..b47330c8e02c 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2826,16 +2826,16 @@ static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
  * if there's a match, we allow the bio to finish.  If not, the code in
  * extent_io.c will try to find good copies for us.
  */
-static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
-                               struct extent_state *state, int mirror)
+static int btrfs_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
+                                      u64 phy_offset, struct page *page,
+                                      u64 start, u64 end, int mirror)
 {
         size_t offset = start - page_offset(page);
         struct inode *inode = page->mapping->host;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         char *kaddr;
-        u64 private = ~(u32)0;
-        int ret;
         struct btrfs_root *root = BTRFS_I(inode)->root;
+        u32 csum_expected;
         u32 csum = ~(u32)0;
         static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL,
                                       DEFAULT_RATELIMIT_BURST);
@@ -2855,19 +2855,13 @@ static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
                 return 0;
         }
 
-        if (state && state->start == start) {
-                private = state->private;
-                ret = 0;
-        } else {
-                ret = get_state_private(io_tree, start, &private);
-        }
-        kaddr = kmap_atomic(page);
-        if (ret)
-                goto zeroit;
+        phy_offset >>= inode->i_sb->s_blocksize_bits;
+        csum_expected = *(((u32 *)io_bio->csum) + phy_offset);
 
+        kaddr = kmap_atomic(page);
         csum = btrfs_csum_data(kaddr + offset, csum,  end - start + 1);
         btrfs_csum_final(csum, (char *)&csum);
-        if (csum != private)
+        if (csum != csum_expected)
                 goto zeroit;
 
         kunmap_atomic(kaddr);
@@ -2876,14 +2870,13 @@ good:
 
 zeroit:
         if (__ratelimit(&_rs))
-                btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u private %llu",
+                btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u",
                         (unsigned long long)btrfs_ino(page->mapping->host),
-                        (unsigned long long)start, csum,
-                        (unsigned long long)private);
+                        (unsigned long long)start, csum, csum_expected);
         memset(kaddr + offset, 1, end - start + 1);
         flush_dcache_page(page);
         kunmap_atomic(kaddr);
-        if (private == 0)
+        if (csum_expected == 0)
                 return 0;
         return -EIO;
 }
@@ -6812,26 +6805,6 @@ unlock_err:
         return ret;
 }
 
-struct btrfs_dio_private {
-        struct inode *inode;
-        u64 logical_offset;
-        u64 disk_bytenr;
-        u64 bytes;
-        void *private;
-
-        /* number of bios pending for this dio */
-        atomic_t pending_bios;
-
-        /* IO errors */
-        int errors;
-
-        /* orig_bio is our btrfs_io_bio */
-        struct bio *orig_bio;
-
-        /* dio_bio came from fs/direct-io.c */
-        struct bio *dio_bio;
-};
-
 static void btrfs_endio_direct_read(struct bio *bio, int err)
 {
         struct btrfs_dio_private *dip = bio->bi_private;
@@ -6840,6 +6813,8 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
         struct inode *inode = dip->inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct bio *dio_bio;
+        u32 *csums = (u32 *)dip->csum;
+        int index = 0;
         u64 start;
 
         start = dip->logical_offset;
@@ -6848,12 +6823,8 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
                         struct page *page = bvec->bv_page;
                         char *kaddr;
                         u32 csum = ~(u32)0;
-                        u64 private = ~(u32)0;
                         unsigned long flags;
 
-                        if (get_state_private(&BTRFS_I(inode)->io_tree,
-                                              start, &private))
-                                goto failed;
                         local_irq_save(flags);
                         kaddr = kmap_atomic(page);
                         csum = btrfs_csum_data(kaddr + bvec->bv_offset,
@@ -6863,18 +6834,18 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
                         local_irq_restore(flags);
 
                         flush_dcache_page(bvec->bv_page);
-                        if (csum != private) {
-failed:
-                                btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u private %u",
-                                        (unsigned long long)btrfs_ino(inode),
-                                        (unsigned long long)start,
-                                        csum, (unsigned)private);
+                        if (csum != csums[index]) {
+                                btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u",
+                                          (unsigned long long)btrfs_ino(inode),
+                                          (unsigned long long)start,
+                                          csum, csums[index]);
                                 err = -EIO;
                         }
                 }
 
                 start += bvec->bv_len;
                 bvec++;
+                index++;
         } while (bvec <= bvec_end);
 
         unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
@@ -6991,6 +6962,7 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
                                          int rw, u64 file_offset, int skip_sum,
                                          int async_submit)
 {
+        struct btrfs_dio_private *dip = bio->bi_private;
         int write = rw & REQ_WRITE;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret;
@@ -7025,7 +6997,8 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
                 if (ret)
                         goto err;
         } else if (!skip_sum) {
-                ret = btrfs_lookup_bio_sums_dio(root, inode, bio, file_offset);
+                ret = btrfs_lookup_bio_sums_dio(root, inode, dip, bio,
+                                                file_offset);
                 if (ret)
                         goto err;
         }
@@ -7060,6 +7033,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                 bio_put(orig_bio);
                 return -EIO;
         }
+
         if (map_length >= orig_bio->bi_size) {
                 bio = orig_bio;
                 goto submit;
@@ -7155,19 +7129,28 @@ static void btrfs_submit_direct(int rw, struct bio *dio_bio,
         struct btrfs_dio_private *dip;
         struct bio *io_bio;
         int skip_sum;
+        int sum_len;
         int write = rw & REQ_WRITE;
         int ret = 0;
+        u16 csum_size;
 
         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
         io_bio = btrfs_bio_clone(dio_bio, GFP_NOFS);
-
         if (!io_bio) {
                 ret = -ENOMEM;
                 goto free_ordered;
         }
 
-        dip = kmalloc(sizeof(*dip), GFP_NOFS);
+        if (!skip_sum && !write) {
+                csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
+                sum_len = dio_bio->bi_size >> inode->i_sb->s_blocksize_bits;
+                sum_len *= csum_size;
+        } else {
+                sum_len = 0;
+        }
+
+        dip = kmalloc(sizeof(*dip) + sum_len, GFP_NOFS);
         if (!dip) {
                 ret = -ENOMEM;
                 goto free_io_bio;