Btrfs: don't cache the csum value into the extent state tree

Before applying this patch, we cached the csum value into the extent state
tree when reading some data from the disk, this operation increased the lock
contention of the state tree.

Now, we just store the csum value into the bio structure or other unshared
structure, so we can reduce the lock contention.

Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>

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;