Merge branch 'for-4.5/block-dax' into for-4.5/libnvdimm

4 files changed, 233 insertions, 9 deletions

diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index 82c49bb87055..2e2832b83c93 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -11,6 +11,7 @@
  * General Public License for more details.
  */
 #include <linux/libnvdimm.h>
+#include <linux/badblocks.h>
 #include <linux/export.h>
 #include <linux/module.h>
 #include <linux/blkdev.h>
@@ -325,6 +326,7 @@ struct nvdimm_bus *__nvdimm_bus_register(struct device *parent,
         if (!nvdimm_bus)
                 return NULL;
         INIT_LIST_HEAD(&nvdimm_bus->list);
+        INIT_LIST_HEAD(&nvdimm_bus->poison_list);
         init_waitqueue_head(&nvdimm_bus->probe_wait);
         nvdimm_bus->id = ida_simple_get(&nd_ida, 0, 0, GFP_KERNEL);
         mutex_init(&nvdimm_bus->reconfig_mutex);
@@ -359,6 +361,172 @@ struct nvdimm_bus *__nvdimm_bus_register(struct device *parent,
 }
 EXPORT_SYMBOL_GPL(__nvdimm_bus_register);
 
+static void set_badblock(struct badblocks *bb, sector_t s, int num)
+{
+        dev_dbg(bb->dev, "Found a poison range (0x%llx, 0x%llx)\n",
+                        (u64) s * 512, (u64) num * 512);
+        /* this isn't an error as the hardware will still throw an exception */
+        if (badblocks_set(bb, s, num, 1))
+                dev_info_once(bb->dev, "%s: failed for sector %llx\n",
+                                __func__, (u64) s);
+}
+
+/**
+ * __add_badblock_range() - Convert a physical address range to bad sectors
+ * @bb:         badblocks instance to populate
+ * @ns_offset:  namespace offset where the error range begins (in bytes)
+ * @len:        number of bytes of poison to be added
+ *
+ * This assumes that the range provided with (ns_offset, len) is within
+ * the bounds of physical addresses for this namespace, i.e. lies in the
+ * interval [ns_start, ns_start + ns_size)
+ */
+static void __add_badblock_range(struct badblocks *bb, u64 ns_offset, u64 len)
+{
+        const unsigned int sector_size = 512;
+        sector_t start_sector;
+        u64 num_sectors;
+        u32 rem;
+
+        start_sector = div_u64(ns_offset, sector_size);
+        num_sectors = div_u64_rem(len, sector_size, &rem);
+        if (rem)
+                num_sectors++;
+
+        if (unlikely(num_sectors > (u64)INT_MAX)) {
+                u64 remaining = num_sectors;
+                sector_t s = start_sector;
+
+                while (remaining) {
+                        int done = min_t(u64, remaining, INT_MAX);
+
+                        set_badblock(bb, s, done);
+                        remaining -= done;
+                        s += done;
+                }
+        } else
+                set_badblock(bb, start_sector, num_sectors);
+}
+
+/**
+ * nvdimm_namespace_add_poison() - Convert a list of poison ranges to badblocks
+ * @ndns:       the namespace containing poison ranges
+ * @bb:         badblocks instance to populate
+ * @offset:     offset at the start of the namespace before 'sector 0'
+ *
+ * The poison list generated during NFIT initialization may contain multiple,
+ * possibly overlapping ranges in the SPA (System Physical Address) space.
+ * Compare each of these ranges to the namespace currently being initialized,
+ * and add badblocks to the gendisk for all matching sub-ranges
+ */
+void nvdimm_namespace_add_poison(struct nd_namespace_common *ndns,
+                struct badblocks *bb, resource_size_t offset)
+{
+        struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
+        struct nd_region *nd_region = to_nd_region(ndns->dev.parent);
+        struct nvdimm_bus *nvdimm_bus;
+        struct list_head *poison_list;
+        u64 ns_start, ns_end, ns_size;
+        struct nd_poison *pl;
+
+        ns_size = nvdimm_namespace_capacity(ndns) - offset;
+        ns_start = nsio->res.start + offset;
+        ns_end = nsio->res.end;
+
+        nvdimm_bus = to_nvdimm_bus(nd_region->dev.parent);
+        poison_list = &nvdimm_bus->poison_list;
+        if (list_empty(poison_list))
+                return;
+
+        list_for_each_entry(pl, poison_list, list) {
+                u64 pl_end = pl->start + pl->length - 1;
+
+                /* Discard intervals with no intersection */
+                if (pl_end < ns_start)
+                        continue;
+                if (pl->start > ns_end)
+                        continue;
+                /* Deal with any overlap after start of the namespace */
+                if (pl->start >= ns_start) {
+                        u64 start = pl->start;
+                        u64 len;
+
+                        if (pl_end <= ns_end)
+                                len = pl->length;
+                        else
+                                len = ns_start + ns_size - pl->start;
+                        __add_badblock_range(bb, start - ns_start, len);
+                        continue;
+                }
+                /* Deal with overlap for poison starting before the namespace */
+                if (pl->start < ns_start) {
+                        u64 len;
+
+                        if (pl_end < ns_end)
+                                len = pl->start + pl->length - ns_start;
+                        else
+                                len = ns_size;
+                        __add_badblock_range(bb, 0, len);
+                }
+        }
+}
+EXPORT_SYMBOL_GPL(nvdimm_namespace_add_poison);
+
+static int __add_poison(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
+{
+        struct nd_poison *pl;
+
+        pl = kzalloc(sizeof(*pl), GFP_KERNEL);
+        if (!pl)
+                return -ENOMEM;
+
+        pl->start = addr;
+        pl->length = length;
+        list_add_tail(&pl->list, &nvdimm_bus->poison_list);
+
+        return 0;
+}
+
+int nvdimm_bus_add_poison(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
+{
+        struct nd_poison *pl;
+
+        if (list_empty(&nvdimm_bus->poison_list))
+                return __add_poison(nvdimm_bus, addr, length);
+
+        /*
+         * There is a chance this is a duplicate, check for those first.
+         * This will be the common case as ARS_STATUS returns all known
+         * errors in the SPA space, and we can't query it per region
+         */
+        list_for_each_entry(pl, &nvdimm_bus->poison_list, list)
+                if (pl->start == addr) {
+                        /* If length has changed, update this list entry */
+                        if (pl->length != length)
+                                pl->length = length;
+                        return 0;
+                }
+
+        /*
+         * If not a duplicate or a simple length update, add the entry as is,
+         * as any overlapping ranges will get resolved when the list is consumed
+         * and converted to badblocks
+         */
+        return __add_poison(nvdimm_bus, addr, length);
+}
+EXPORT_SYMBOL_GPL(nvdimm_bus_add_poison);
+
+static void free_poison_list(struct list_head *poison_list)
+{
+        struct nd_poison *pl, *next;
+
+        list_for_each_entry_safe(pl, next, poison_list, list) {
+                list_del(&pl->list);
+                kfree(pl);
+        }
+        list_del_init(poison_list);
+}
+
 static int child_unregister(struct device *dev, void *data)
 {
         /*
@@ -385,6 +553,7 @@ void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus)
 
         nd_synchronize();
         device_for_each_child(&nvdimm_bus->dev, NULL, child_unregister);
+        free_poison_list(&nvdimm_bus->poison_list);
         nvdimm_bus_destroy_ndctl(nvdimm_bus);
 
         device_unregister(&nvdimm_bus->dev);
diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
index 3249c498892a..1d1500f3d8b5 100644
--- a/drivers/nvdimm/nd-core.h
+++ b/drivers/nvdimm/nd-core.h
@@ -30,6 +30,7 @@ struct nvdimm_bus {
         struct list_head list;
         struct device dev;
         int id, probe_active;
+        struct list_head poison_list;
         struct mutex reconfig_mutex;
 };
 
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index e4e9f9ae0cc8..ba1633b9da31 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -31,6 +31,12 @@ enum {
         INT_LBASIZE_ALIGNMENT = 64,
 };
 
+struct nd_poison {
+        u64 start;
+        u64 length;
+        struct list_head list;
+};
+
 struct nvdimm_drvdata {
         struct device *dev;
         int nsindex_size;
@@ -256,6 +262,8 @@ int nvdimm_namespace_attach_btt(struct nd_namespace_common *ndns);
 int nvdimm_namespace_detach_btt(struct nd_namespace_common *ndns);
 const char *nvdimm_namespace_disk_name(struct nd_namespace_common *ndns,
                 char *name);
+void nvdimm_namespace_add_poison(struct nd_namespace_common *ndns,
+                struct badblocks *bb, resource_size_t offset);
 int nd_blk_region_init(struct nd_region *nd_region);
 void __nd_iostat_start(struct bio *bio, unsigned long *start);
 static inline bool nd_iostat_start(struct bio *bio, unsigned long *start)
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index ab689bca727d..b493ff3fccb2 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -23,6 +23,7 @@
 #include <linux/module.h>
 #include <linux/memory_hotplug.h>
 #include <linux/moduleparam.h>
+#include <linux/badblocks.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
 #include <linux/pmem.h>
@@ -41,11 +42,25 @@ struct pmem_device {
         phys_addr_t             data_offset;
         void __pmem             *virt_addr;
         size_t                  size;
+        struct badblocks        bb;
 };
 
 static int pmem_major;
 
-static void pmem_do_bvec(struct pmem_device *pmem, struct page *page,
+static bool is_bad_pmem(struct badblocks *bb, sector_t sector, unsigned int len)
+{
+        if (bb->count) {
+                sector_t first_bad;
+                int num_bad;
+
+                return !!badblocks_check(bb, sector, len / 512, &first_bad,
+                                &num_bad);
+        }
+
+        return false;
+}
+
+static int pmem_do_bvec(struct pmem_device *pmem, struct page *page,
                         unsigned int len, unsigned int off, int rw,
                         sector_t sector)
 {
@@ -54,6 +69,8 @@ static void pmem_do_bvec(struct pmem_device *pmem, struct page *page,
         void __pmem *pmem_addr = pmem->virt_addr + pmem_off;
 
         if (rw == READ) {
+                if (unlikely(is_bad_pmem(&pmem->bb, sector, len)))
+                        return -EIO;
                 memcpy_from_pmem(mem + off, pmem_addr, len);
                 flush_dcache_page(page);
         } else {
@@ -62,10 +79,12 @@ static void pmem_do_bvec(struct pmem_device *pmem, struct page *page,
         }
 
         kunmap_atomic(mem);
+        return 0;
 }
 
 static blk_qc_t pmem_make_request(struct request_queue *q, struct bio *bio)
 {
+        int rc = 0;
         bool do_acct;
         unsigned long start;
         struct bio_vec bvec;
@@ -74,9 +93,15 @@ static blk_qc_t pmem_make_request(struct request_queue *q, struct bio *bio)
         struct pmem_device *pmem = bdev->bd_disk->private_data;
 
         do_acct = nd_iostat_start(bio, &start);
-        bio_for_each_segment(bvec, bio, iter)
-                pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len, bvec.bv_offset,
-                                bio_data_dir(bio), iter.bi_sector);
+        bio_for_each_segment(bvec, bio, iter) {
+                rc = pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len,
+                                bvec.bv_offset, bio_data_dir(bio),
+                                iter.bi_sector);
+                if (rc) {
+                        bio->bi_error = rc;
+                        break;
+                }
+        }
         if (do_acct)
                 nd_iostat_end(bio, start);
 
@@ -91,13 +116,22 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector,
                        struct page *page, int rw)
 {
         struct pmem_device *pmem = bdev->bd_disk->private_data;
+        int rc;
 
-        pmem_do_bvec(pmem, page, PAGE_CACHE_SIZE, 0, rw, sector);
+        rc = pmem_do_bvec(pmem, page, PAGE_CACHE_SIZE, 0, rw, sector);
         if (rw & WRITE)
                 wmb_pmem();
-        page_endio(page, rw & WRITE, 0);
 
-        return 0;
+        /*
+         * The ->rw_page interface is subtle and tricky.  The core
+         * retries on any error, so we can only invoke page_endio() in
+         * the successful completion case.  Otherwise, we'll see crashes
+         * caused by double completion.
+         */
+        if (rc == 0)
+                page_endio(page, rw & WRITE, 0);
+
+        return rc;
 }
 
 static long pmem_direct_access(struct block_device *bdev, sector_t sector,
@@ -195,7 +229,12 @@ static int pmem_attach_disk(struct device *dev,
         disk->driverfs_dev = dev;
         set_capacity(disk, (pmem->size - pmem->data_offset) / 512);
         pmem->pmem_disk = disk;
+        devm_exit_badblocks(dev, &pmem->bb);
+        if (devm_init_badblocks(dev, &pmem->bb))
+                return -ENOMEM;
+        nvdimm_namespace_add_poison(ndns, &pmem->bb, pmem->data_offset);
 
+        disk->bb = &pmem->bb;
         add_disk(disk);
         revalidate_disk(disk);
 
@@ -212,9 +251,13 @@ static int pmem_rw_bytes(struct nd_namespace_common *ndns,
                 return -EFAULT;
         }
 
-        if (rw == READ)
+        if (rw == READ) {
+                unsigned int sz_align = ALIGN(size + (offset & (512 - 1)), 512);
+
+                if (unlikely(is_bad_pmem(&pmem->bb, offset / 512, sz_align)))
+                        return -EIO;
                 memcpy_from_pmem(buf, pmem->virt_addr + offset, size);
-        else {
+        } else {
                 memcpy_to_pmem(pmem->virt_addr + offset, buf, size);
                 wmb_pmem();
         }
@@ -377,6 +420,9 @@ static int nd_pmem_probe(struct device *dev)
         pmem->ndns = ndns;
         dev_set_drvdata(dev, pmem);
         ndns->rw_bytes = pmem_rw_bytes;
+        if (devm_init_badblocks(dev, &pmem->bb))
+                return -ENOMEM;
+        nvdimm_namespace_add_poison(ndns, &pmem->bb, 0);
 
         if (is_nd_btt(dev))
                 return nvdimm_namespace_attach_btt(ndns);