1 files changed, 92 insertions, 2 deletions

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 48a06d1fc067..2915521f44ee 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -23,6 +23,7 @@
 #include <linux/random.h>
 #include <linux/iocontext.h>
 #include <linux/capability.h>
+#include <linux/ratelimit.h>
 #include <linux/kthread.h>
 #include <asm/div64.h>
 #include "compat.h"
@@ -4001,13 +4002,58 @@ int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
         return 0;
 }
 
+static void *merge_stripe_index_into_bio_private(void *bi_private,
+                                                 unsigned int stripe_index)
+{
+        /*
+         * with single, dup, RAID0, RAID1 and RAID10, stripe_index is
+         * at most 1.
+         * The alternative solution (instead of stealing bits from the
+         * pointer) would be to allocate an intermediate structure
+         * that contains the old private pointer plus the stripe_index.
+         */
+        BUG_ON((((uintptr_t)bi_private) & 3) != 0);
+        BUG_ON(stripe_index > 3);
+        return (void *)(((uintptr_t)bi_private) | stripe_index);
+}
+
+static struct btrfs_bio *extract_bbio_from_bio_private(void *bi_private)
+{
+        return (struct btrfs_bio *)(((uintptr_t)bi_private) & ~((uintptr_t)3));
+}
+
+static unsigned int extract_stripe_index_from_bio_private(void *bi_private)
+{
+        return (unsigned int)((uintptr_t)bi_private) & 3;
+}
+
 static void btrfs_end_bio(struct bio *bio, int err)
 {
-        struct btrfs_bio *bbio = bio->bi_private;
+        struct btrfs_bio *bbio = extract_bbio_from_bio_private(bio->bi_private);
         int is_orig_bio = 0;
 
-        if (err)
+        if (err) {
                 atomic_inc(&bbio->error);
+                if (err == -EIO || err == -EREMOTEIO) {
+                        unsigned int stripe_index =
+                                extract_stripe_index_from_bio_private(
+                                        bio->bi_private);
+                        struct btrfs_device *dev;
+
+                        BUG_ON(stripe_index >= bbio->num_stripes);
+                        dev = bbio->stripes[stripe_index].dev;
+                        if (bio->bi_rw & WRITE)
+                                btrfs_dev_stat_inc(dev,
+                                                   BTRFS_DEV_STAT_WRITE_ERRS);
+                        else
+                                btrfs_dev_stat_inc(dev,
+                                                   BTRFS_DEV_STAT_READ_ERRS);
+                        if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
+                                btrfs_dev_stat_inc(dev,
+                                                   BTRFS_DEV_STAT_FLUSH_ERRS);
+                        btrfs_dev_stat_print_on_error(dev);
+                }
+        }
 
         if (bio == bbio->orig_bio)
                 is_orig_bio = 1;
@@ -4149,6 +4195,8 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
                         bio = first_bio;
                 }
                 bio->bi_private = bbio;
+                bio->bi_private = merge_stripe_index_into_bio_private(
+                                bio->bi_private, (unsigned int)dev_nr);
                 bio->bi_end_io = btrfs_end_bio;
                 bio->bi_sector = bbio->stripes[dev_nr].physical >> 9;
                 dev = bbio->stripes[dev_nr].dev;
@@ -4509,6 +4557,28 @@ int btrfs_read_sys_array(struct btrfs_root *root)
         return ret;
 }
 
+struct btrfs_device *btrfs_find_device_for_logical(struct btrfs_root *root,
+                                                   u64 logical, int mirror_num)
+{
+        struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
+        int ret;
+        u64 map_length = 0;
+        struct btrfs_bio *bbio = NULL;
+        struct btrfs_device *device;
+
+        BUG_ON(mirror_num == 0);
+        ret = btrfs_map_block(map_tree, WRITE, logical, &map_length, &bbio,
+                              mirror_num);
+        if (ret) {
+                BUG_ON(bbio != NULL);
+                return NULL;
+        }
+        BUG_ON(mirror_num != bbio->mirror_num);
+        device = bbio->stripes[mirror_num - 1].dev;
+        kfree(bbio);
+        return device;
+}
+
 int btrfs_read_chunk_tree(struct btrfs_root *root)
 {
         struct btrfs_path *path;
@@ -4583,3 +4653,23 @@ error:
         btrfs_free_path(path);
         return ret;
 }
+
+void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index)
+{
+        btrfs_dev_stat_inc(dev, index);
+        btrfs_dev_stat_print_on_error(dev);
+}
+
+void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
+{
+        printk_ratelimited(KERN_ERR
+                           "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
+                           dev->name,
+                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
+                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
+                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
+                           btrfs_dev_stat_read(dev,
+                                               BTRFS_DEV_STAT_CORRUPTION_ERRS),
+                           btrfs_dev_stat_read(dev,
+                                               BTRFS_DEV_STAT_GENERATION_ERRS));
+}