Merge tag 'libnvdimm-for-4.12' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm

Pull libnvdimm updates from Dan Williams:
 "The bulk of this has been in multiple -next releases. There were a few
  late breaking fixes and small features that got added in the last
  couple days, but the whole set has received a build success
  notification from the kbuild robot.

  Change summary:

   - Region media error reporting: A libnvdimm region device is the
     parent to one or more namespaces. To date, media errors have been
     reported via the "badblocks" attribute attached to pmem block
     devices for namespaces in "raw" or "memory" mode. Given that
     namespaces can be in "device-dax" or "btt-sector" mode this new
     interface reports media errors generically, i.e. independent of
     namespace modes or state.

     This subsequently allows userspace tooling to craft "ACPI 6.1
     Section 9.20.7.6 Function Index 4 - Clear Uncorrectable Error"
     requests and submit them via the ioctl path for NVDIMM root bus
     devices.

   - Introduce 'struct dax_device' and 'struct dax_operations': Prompted
     by a request from Linus and feedback from Christoph this allows for
     dax capable drivers to publish their own custom dax operations.
     This fixes the broken assumption that all dax operations are
     related to a persistent memory device, and makes it easier for
     other architectures and platforms to add customized persistent
     memory support.

   - 'libnvdimm' core updates: A new "deep_flush" sysfs attribute is
     available for storage appliance applications to manually trigger
     memory controllers to drain write-pending buffers that would
     otherwise be flushed automatically by the platform ADR
     (asynchronous-DRAM-refresh) mechanism at a power loss event.
     Support for "locked" DIMMs is included to prevent namespaces from
     surfacing when the namespace label data area is locked. Finally,
     fixes for various reported deadlocks and crashes, also tagged for
     -stable.

   - ACPI / nfit driver updates: General updates of the nfit driver to
     add DSM command overrides, ACPI 6.1 health state flags support, DSM
     payload debug available by default, and various fixes.

  Acknowledgements that came after the branch was pushed:

   - commmit 565851c972b5 "device-dax: fix sysfs attribute deadlock":
     Tested-by: Yi Zhang <yizhan@redhat.com>

   - commit 23f498448362 "libnvdimm: rework region badblocks clearing"
     Tested-by: Toshi Kani <toshi.kani@hpe.com>"

* tag 'libnvdimm-for-4.12' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm: (52 commits)
  libnvdimm, pfn: fix 'npfns' vs section alignment
  libnvdimm: handle locked label storage areas
  libnvdimm: convert NDD_ flags to use bitops, introduce NDD_LOCKED
  brd: fix uninitialized use of brd->dax_dev
  block, dax: use correct format string in bdev_dax_supported
  device-dax: fix sysfs attribute deadlock
  libnvdimm: restore "libnvdimm: band aid btt vs clear poison locking"
  libnvdimm: fix nvdimm_bus_lock() vs device_lock() ordering
  libnvdimm: rework region badblocks clearing
  acpi, nfit: kill ACPI_NFIT_DEBUG
  libnvdimm: fix clear length of nvdimm_forget_poison()
  libnvdimm, pmem: fix a NULL pointer BUG in nd_pmem_notify
  libnvdimm, region: sysfs trigger for nvdimm_flush()
  libnvdimm: fix phys_addr for nvdimm_clear_poison
  x86, dax, pmem: remove indirection around memcpy_from_pmem()
  block: remove block_device_operations ->direct_access()
  block, dax: convert bdev_dax_supported() to dax_direct_access()
  filesystem-dax: convert to dax_direct_access()
  Revert "block: use DAX for partition table reads"
  ext2, ext4, xfs: retrieve dax_device for iomap operations
  ...

7 files changed, 88 insertions, 49 deletions

diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index 7468a22f9d10..349ff8813401 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -200,6 +200,7 @@ config BLK_DEV_DM_BUILTIN
 config BLK_DEV_DM
         tristate "Device mapper support"
         select BLK_DEV_DM_BUILTIN
+        select DAX
         ---help---
           Device-mapper is a low level volume manager.  It works by allowing
           people to specify mappings for ranges of logical sectors.  Various
diff --git a/drivers/md/dm-core.h b/drivers/md/dm-core.h
index 97db4d11c05a..52ca8d059e82 100644
--- a/drivers/md/dm-core.h
+++ b/drivers/md/dm-core.h
@@ -58,6 +58,7 @@ struct mapped_device {
         struct target_type *immutable_target_type;
 
         struct gendisk *disk;
+        struct dax_device *dax_dev;
         char name[16];
 
         void *interface_ptr;
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index a5120961632a..7d42a9d9f406 100644
--- a/drivers/md/dm-linear.c
+++ b/drivers/md/dm-linear.c
@@ -9,6 +9,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/bio.h>
+#include <linux/dax.h>
 #include <linux/slab.h>
 #include <linux/device-mapper.h>
 
@@ -142,22 +143,20 @@ static int linear_iterate_devices(struct dm_target *ti,
         return fn(ti, lc->dev, lc->start, ti->len, data);
 }
 
-static long linear_direct_access(struct dm_target *ti, sector_t sector,
-                                 void **kaddr, pfn_t *pfn, long size)
+static long linear_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
+                long nr_pages, void **kaddr, pfn_t *pfn)
 {
+        long ret;
         struct linear_c *lc = ti->private;
         struct block_device *bdev = lc->dev->bdev;
-        struct blk_dax_ctl dax = {
-                .sector = linear_map_sector(ti, sector),
-                .size = size,
-        };
-        long ret;
-
-        ret = bdev_direct_access(bdev, &dax);
-        *kaddr = dax.addr;
-        *pfn = dax.pfn;
-
-        return ret;
+        struct dax_device *dax_dev = lc->dev->dax_dev;
+        sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
+
+        dev_sector = linear_map_sector(ti, sector);
+        ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages * PAGE_SIZE, &pgoff);
+        if (ret)
+                return ret;
+        return dax_direct_access(dax_dev, pgoff, nr_pages, kaddr, pfn);
 }
 
 static struct target_type linear_target = {
@@ -171,7 +170,7 @@ static struct target_type linear_target = {
         .status = linear_status,
         .prepare_ioctl = linear_prepare_ioctl,
         .iterate_devices = linear_iterate_devices,
-        .direct_access = linear_direct_access,
+        .direct_access = linear_dax_direct_access,
 };
 
 int __init dm_linear_init(void)
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index c65feeada864..e152d9817c81 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -2302,8 +2302,8 @@ static int origin_map(struct dm_target *ti, struct bio *bio)
         return do_origin(o->dev, bio);
 }
 
-static long origin_direct_access(struct dm_target *ti, sector_t sector,
-                void **kaddr, pfn_t *pfn, long size)
+static long origin_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
+                long nr_pages, void **kaddr, pfn_t *pfn)
 {
         DMWARN("device does not support dax.");
         return -EIO;
@@ -2368,7 +2368,7 @@ static struct target_type origin_target = {
         .postsuspend = origin_postsuspend,
         .status  = origin_status,
         .iterate_devices = origin_iterate_devices,
-        .direct_access = origin_direct_access,
+        .direct_access = origin_dax_direct_access,
 };
 
 static struct target_type snapshot_target = {
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index 4b50ae115c6d..75152482f3ad 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -11,6 +11,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/bio.h>
+#include <linux/dax.h>
 #include <linux/slab.h>
 #include <linux/log2.h>
 
@@ -310,27 +311,25 @@ static int stripe_map(struct dm_target *ti, struct bio *bio)
         return DM_MAPIO_REMAPPED;
 }
 
-static long stripe_direct_access(struct dm_target *ti, sector_t sector,
-                                 void **kaddr, pfn_t *pfn, long size)
+static long stripe_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
+                long nr_pages, void **kaddr, pfn_t *pfn)
 {
+        sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
         struct stripe_c *sc = ti->private;
-        uint32_t stripe;
+        struct dax_device *dax_dev;
         struct block_device *bdev;
-        struct blk_dax_ctl dax = {
-                .size = size,
-        };
+        uint32_t stripe;
         long ret;
 
-        stripe_map_sector(sc, sector, &stripe, &dax.sector);
-
-        dax.sector += sc->stripe[stripe].physical_start;
+        stripe_map_sector(sc, sector, &stripe, &dev_sector);
+        dev_sector += sc->stripe[stripe].physical_start;
+        dax_dev = sc->stripe[stripe].dev->dax_dev;
         bdev = sc->stripe[stripe].dev->bdev;
 
-        ret = bdev_direct_access(bdev, &dax);
-        *kaddr = dax.addr;
-        *pfn = dax.pfn;
-
-        return ret;
+        ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages * PAGE_SIZE, &pgoff);
+        if (ret)
+                return ret;
+        return dax_direct_access(dax_dev, pgoff, nr_pages, kaddr, pfn);
 }
 
 /*
@@ -451,7 +450,7 @@ static struct target_type stripe_target = {
         .status = stripe_status,
         .iterate_devices = stripe_iterate_devices,
         .io_hints = stripe_io_hints,
-        .direct_access = stripe_direct_access,
+        .direct_access = stripe_dax_direct_access,
 };
 
 int __init dm_stripe_init(void)
diff --git a/drivers/md/dm-target.c b/drivers/md/dm-target.c
index 6264ff00dcf0..b242b750542f 100644
--- a/drivers/md/dm-target.c
+++ b/drivers/md/dm-target.c
@@ -142,8 +142,8 @@ static void io_err_release_clone_rq(struct request *clone)
 {
 }
 
-static long io_err_direct_access(struct dm_target *ti, sector_t sector,
-                                 void **kaddr, pfn_t *pfn, long size)
+static long io_err_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
+                long nr_pages, void **kaddr, pfn_t *pfn)
 {
         return -EIO;
 }
@@ -157,7 +157,7 @@ static struct target_type error_target = {
         .map  = io_err_map,
         .clone_and_map_rq = io_err_clone_and_map_rq,
         .release_clone_rq = io_err_release_clone_rq,
-        .direct_access = io_err_direct_access,
+        .direct_access = io_err_dax_direct_access,
 };
 
 int __init dm_target_init(void)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 268edf402bbb..6ef9500226c0 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -16,6 +16,7 @@
 #include <linux/blkpg.h>
 #include <linux/bio.h>
 #include <linux/mempool.h>
+#include <linux/dax.h>
 #include <linux/slab.h>
 #include <linux/idr.h>
 #include <linux/hdreg.h>
@@ -629,6 +630,7 @@ static int open_table_device(struct table_device *td, dev_t dev,
         }
 
         td->dm_dev.bdev = bdev;
+        td->dm_dev.dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);
         return 0;
 }
 
@@ -642,7 +644,9 @@ static void close_table_device(struct table_device *td, struct mapped_device *md
 
         bd_unlink_disk_holder(td->dm_dev.bdev, dm_disk(md));
         blkdev_put(td->dm_dev.bdev, td->dm_dev.mode | FMODE_EXCL);
+        put_dax(td->dm_dev.dax_dev);
         td->dm_dev.bdev = NULL;
+        td->dm_dev.dax_dev = NULL;
 }
 
 static struct table_device *find_table_device(struct list_head *l, dev_t dev,
@@ -920,31 +924,49 @@ int dm_set_target_max_io_len(struct dm_target *ti, sector_t len)
 }
 EXPORT_SYMBOL_GPL(dm_set_target_max_io_len);
 
-static long dm_blk_direct_access(struct block_device *bdev, sector_t sector,
-                                 void **kaddr, pfn_t *pfn, long size)
+static struct dm_target *dm_dax_get_live_target(struct mapped_device *md,
+                sector_t sector, int *srcu_idx)
 {
-        struct mapped_device *md = bdev->bd_disk->private_data;
         struct dm_table *map;
         struct dm_target *ti;
-        int srcu_idx;
-        long len, ret = -EIO;
 
-        map = dm_get_live_table(md, &srcu_idx);
+        map = dm_get_live_table(md, srcu_idx);
         if (!map)
-                goto out;
+                return NULL;
 
         ti = dm_table_find_target(map, sector);
         if (!dm_target_is_valid(ti))
-                goto out;
+                return NULL;
+
+        return ti;
+}
+
+static long dm_dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff,
+                long nr_pages, void **kaddr, pfn_t *pfn)
+{
+        struct mapped_device *md = dax_get_private(dax_dev);
+        sector_t sector = pgoff * PAGE_SECTORS;
+        struct dm_target *ti;
+        long len, ret = -EIO;
+        int srcu_idx;
 
-        len = max_io_len(sector, ti) << SECTOR_SHIFT;
-        size = min(len, size);
+        ti = dm_dax_get_live_target(md, sector, &srcu_idx);
 
+        if (!ti)
+                goto out;
+        if (!ti->type->direct_access)
+                goto out;
+        len = max_io_len(sector, ti) / PAGE_SECTORS;
+        if (len < 1)
+                goto out;
+        nr_pages = min(len, nr_pages);
         if (ti->type->direct_access)
-                ret = ti->type->direct_access(ti, sector, kaddr, pfn, size);
-out:
+                ret = ti->type->direct_access(ti, pgoff, nr_pages, kaddr, pfn);
+
+ out:
         dm_put_live_table(md, srcu_idx);
-        return min(ret, size);
+
+        return ret;
 }
 
 /*
@@ -1471,6 +1493,7 @@ static int next_free_minor(int *minor)
 }
 
 static const struct block_device_operations dm_blk_dops;
+static const struct dax_operations dm_dax_ops;
 
 static void dm_wq_work(struct work_struct *work);
 
@@ -1517,6 +1540,12 @@ static void cleanup_mapped_device(struct mapped_device *md)
         if (md->bs)
                 bioset_free(md->bs);
 
+        if (md->dax_dev) {
+                kill_dax(md->dax_dev);
+                put_dax(md->dax_dev);
+                md->dax_dev = NULL;
+        }
+
         if (md->disk) {
                 spin_lock(&_minor_lock);
                 md->disk->private_data = NULL;
@@ -1544,6 +1573,7 @@ static void cleanup_mapped_device(struct mapped_device *md)
 static struct mapped_device *alloc_dev(int minor)
 {
         int r, numa_node_id = dm_get_numa_node();
+        struct dax_device *dax_dev;
         struct mapped_device *md;
         void *old_md;
 
@@ -1608,6 +1638,12 @@ static struct mapped_device *alloc_dev(int minor)
         md->disk->queue = md->queue;
         md->disk->private_data = md;
         sprintf(md->disk->disk_name, "dm-%d", minor);
+
+        dax_dev = alloc_dax(md, md->disk->disk_name, &dm_dax_ops);
+        if (!dax_dev)
+                goto bad;
+        md->dax_dev = dax_dev;
+
         add_disk(md->disk);
         format_dev_t(md->name, MKDEV(_major, minor));
 
@@ -2816,12 +2852,15 @@ static const struct block_device_operations dm_blk_dops = {
         .open = dm_blk_open,
         .release = dm_blk_close,
         .ioctl = dm_blk_ioctl,
-        .direct_access = dm_blk_direct_access,
         .getgeo = dm_blk_getgeo,
         .pr_ops = &dm_pr_ops,
         .owner = THIS_MODULE
 };
 
+static const struct dax_operations dm_dax_ops = {
+        .direct_access = dm_dax_direct_access,
+};
+
 /*
  * module hooks
  */