Btrfs: add device counters for detected IO and checksum errors

The goal is to detect when drives start to get an increased error rate,
when drives should be replaced soon. Therefore statistic counters are
added that count IO errors (read, write and flush). Additionally, the
software detected errors like checksum errors and corrupted blocks are
counted.

Signed-off-by: Stefan Behrens <sbehrens@giantdisaster.de>

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));
+}