Merge branch 'x86-pmem-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull PMEM driver from Ingo Molnar:
 "This is the initial support for the pmem block device driver:
  persistent non-volatile memory space mapped into the system's physical
  memory space as large physical memory regions.

  The driver is based on Intel code, written by Ross Zwisler, with fixes
  by Boaz Harrosh, integrated with x86 e820 memory resource management
  and tidied up by Christoph Hellwig.

  Note that there were two other separate pmem driver submissions to
  lkml: but apparently all parties (Ross Zwisler, Boaz Harrosh) are
  reasonably happy with this initial version.

  This version enables minimal support that enables persistent memory
  devices out in the wild to work as block devices, identified through a
  magic (non-standard) e820 flag and auto-discovered if
  CONFIG_X86_PMEM_LEGACY=y, or added explicitly through manipulating the
  memory maps via the "memmap=..." boot option with the new, special '!'
  modifier character.

  Limitations: this is a regular block device, and since the pmem areas
  are not struct page backed, they are invisible to the rest of the
  system (other than the block IO device), so direct IO to/from pmem
  areas, direct mmap() or XIP is not possible yet.  The page cache will
  also shadow and double buffer pmem contents, etc.

  Initial support is for x86"

* 'x86-pmem-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  drivers/block/pmem: Fix 32-bit build warning in pmem_alloc()
  drivers/block/pmem: Add a driver for persistent memory
  x86/mm: Add support for the non-standard protected e820 type

3 files changed, 274 insertions, 0 deletions

diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 1b8094d4d7af..eb1fed5bd516 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -404,6 +404,17 @@ config BLK_DEV_RAM_DAX
           and will prevent RAM block device backing store memory from being
           allocated from highmem (only a problem for highmem systems).
 
+config BLK_DEV_PMEM
+        tristate "Persistent memory block device support"
+        help
+          Saying Y here will allow you to use a contiguous range of reserved
+          memory as one or more persistent block devices.
+
+          To compile this driver as a module, choose M here: the module will be
+          called 'pmem'.
+
+          If unsure, say N.
+
 config CDROM_PKTCDVD
         tristate "Packet writing on CD/DVD media"
         depends on !UML
diff --git a/drivers/block/Makefile b/drivers/block/Makefile
index 02b688d1438d..9cc6c18a1c7e 100644
--- a/drivers/block/Makefile
+++ b/drivers/block/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_PS3_VRAM)		+= ps3vram.o
 obj-$(CONFIG_ATARI_FLOPPY)      += ataflop.o
 obj-$(CONFIG_AMIGA_Z2RAM)       += z2ram.o
 obj-$(CONFIG_BLK_DEV_RAM)       += brd.o
+obj-$(CONFIG_BLK_DEV_PMEM)      += pmem.o
 obj-$(CONFIG_BLK_DEV_LOOP)      += loop.o
 obj-$(CONFIG_BLK_CPQ_DA)        += cpqarray.o
 obj-$(CONFIG_BLK_CPQ_CISS_DA)  += cciss.o
diff --git a/drivers/block/pmem.c b/drivers/block/pmem.c
new file mode 100644
index 000000000000..eabf4a8d0085
--- /dev/null
+++ b/drivers/block/pmem.c
@@ -0,0 +1,262 @@
+/*
+ * Persistent Memory Driver
+ *
+ * Copyright (c) 2014, Intel Corporation.
+ * Copyright (c) 2015, Christoph Hellwig <hch@lst.de>.
+ * Copyright (c) 2015, Boaz Harrosh <boaz@plexistor.com>.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+#include <asm/cacheflush.h>
+#include <linux/blkdev.h>
+#include <linux/hdreg.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/slab.h>
+
+#define PMEM_MINORS             16
+
+struct pmem_device {
+        struct request_queue    *pmem_queue;
+        struct gendisk          *pmem_disk;
+
+        /* One contiguous memory region per device */
+        phys_addr_t             phys_addr;
+        void                    *virt_addr;
+        size_t                  size;
+};
+
+static int pmem_major;
+static atomic_t pmem_index;
+
+static void pmem_do_bvec(struct pmem_device *pmem, struct page *page,
+                        unsigned int len, unsigned int off, int rw,
+                        sector_t sector)
+{
+        void *mem = kmap_atomic(page);
+        size_t pmem_off = sector << 9;
+
+        if (rw == READ) {
+                memcpy(mem + off, pmem->virt_addr + pmem_off, len);
+                flush_dcache_page(page);
+        } else {
+                flush_dcache_page(page);
+                memcpy(pmem->virt_addr + pmem_off, mem + off, len);
+        }
+
+        kunmap_atomic(mem);
+}
+
+static void pmem_make_request(struct request_queue *q, struct bio *bio)
+{
+        struct block_device *bdev = bio->bi_bdev;
+        struct pmem_device *pmem = bdev->bd_disk->private_data;
+        int rw;
+        struct bio_vec bvec;
+        sector_t sector;
+        struct bvec_iter iter;
+        int err = 0;
+
+        if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) {
+                err = -EIO;
+                goto out;
+        }
+
+        BUG_ON(bio->bi_rw & REQ_DISCARD);
+
+        rw = bio_data_dir(bio);
+        sector = bio->bi_iter.bi_sector;
+        bio_for_each_segment(bvec, bio, iter) {
+                pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len, bvec.bv_offset,
+                             rw, sector);
+                sector += bvec.bv_len >> 9;
+        }
+
+out:
+        bio_endio(bio, err);
+}
+
+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;
+
+        pmem_do_bvec(pmem, page, PAGE_CACHE_SIZE, 0, rw, sector);
+        page_endio(page, rw & WRITE, 0);
+
+        return 0;
+}
+
+static long pmem_direct_access(struct block_device *bdev, sector_t sector,
+                              void **kaddr, unsigned long *pfn, long size)
+{
+        struct pmem_device *pmem = bdev->bd_disk->private_data;
+        size_t offset = sector << 9;
+
+        if (!pmem)
+                return -ENODEV;
+
+        *kaddr = pmem->virt_addr + offset;
+        *pfn = (pmem->phys_addr + offset) >> PAGE_SHIFT;
+
+        return pmem->size - offset;
+}
+
+static const struct block_device_operations pmem_fops = {
+        .owner =                THIS_MODULE,
+        .rw_page =              pmem_rw_page,
+        .direct_access =        pmem_direct_access,
+};
+
+static struct pmem_device *pmem_alloc(struct device *dev, struct resource *res)
+{
+        struct pmem_device *pmem;
+        struct gendisk *disk;
+        int idx, err;
+
+        err = -ENOMEM;
+        pmem = kzalloc(sizeof(*pmem), GFP_KERNEL);
+        if (!pmem)
+                goto out;
+
+        pmem->phys_addr = res->start;
+        pmem->size = resource_size(res);
+
+        err = -EINVAL;
+        if (!request_mem_region(pmem->phys_addr, pmem->size, "pmem")) {
+                dev_warn(dev, "could not reserve region [0x%pa:0x%zx]\n", &pmem->phys_addr, pmem->size);
+                goto out_free_dev;
+        }
+
+        /*
+         * Map the memory as non-cachable, as we can't write back the contents
+         * of the CPU caches in case of a crash.
+         */
+        err = -ENOMEM;
+        pmem->virt_addr = ioremap_nocache(pmem->phys_addr, pmem->size);
+        if (!pmem->virt_addr)
+                goto out_release_region;
+
+        pmem->pmem_queue = blk_alloc_queue(GFP_KERNEL);
+        if (!pmem->pmem_queue)
+                goto out_unmap;
+
+        blk_queue_make_request(pmem->pmem_queue, pmem_make_request);
+        blk_queue_max_hw_sectors(pmem->pmem_queue, 1024);
+        blk_queue_bounce_limit(pmem->pmem_queue, BLK_BOUNCE_ANY);
+
+        disk = alloc_disk(PMEM_MINORS);
+        if (!disk)
+                goto out_free_queue;
+
+        idx = atomic_inc_return(&pmem_index) - 1;
+
+        disk->major             = pmem_major;
+        disk->first_minor       = PMEM_MINORS * idx;
+        disk->fops              = &pmem_fops;
+        disk->private_data      = pmem;
+        disk->queue             = pmem->pmem_queue;
+        disk->flags             = GENHD_FL_EXT_DEVT;
+        sprintf(disk->disk_name, "pmem%d", idx);
+        disk->driverfs_dev = dev;
+        set_capacity(disk, pmem->size >> 9);
+        pmem->pmem_disk = disk;
+
+        add_disk(disk);
+
+        return pmem;
+
+out_free_queue:
+        blk_cleanup_queue(pmem->pmem_queue);
+out_unmap:
+        iounmap(pmem->virt_addr);
+out_release_region:
+        release_mem_region(pmem->phys_addr, pmem->size);
+out_free_dev:
+        kfree(pmem);
+out:
+        return ERR_PTR(err);
+}
+
+static void pmem_free(struct pmem_device *pmem)
+{
+        del_gendisk(pmem->pmem_disk);
+        put_disk(pmem->pmem_disk);
+        blk_cleanup_queue(pmem->pmem_queue);
+        iounmap(pmem->virt_addr);
+        release_mem_region(pmem->phys_addr, pmem->size);
+        kfree(pmem);
+}
+
+static int pmem_probe(struct platform_device *pdev)
+{
+        struct pmem_device *pmem;
+        struct resource *res;
+
+        if (WARN_ON(pdev->num_resources > 1))
+                return -ENXIO;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENXIO;
+
+        pmem = pmem_alloc(&pdev->dev, res);
+        if (IS_ERR(pmem))
+                return PTR_ERR(pmem);
+
+        platform_set_drvdata(pdev, pmem);
+
+        return 0;
+}
+
+static int pmem_remove(struct platform_device *pdev)
+{
+        struct pmem_device *pmem = platform_get_drvdata(pdev);
+
+        pmem_free(pmem);
+        return 0;
+}
+
+static struct platform_driver pmem_driver = {
+        .probe          = pmem_probe,
+        .remove         = pmem_remove,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "pmem",
+        },
+};
+
+static int __init pmem_init(void)
+{
+        int error;
+
+        pmem_major = register_blkdev(0, "pmem");
+        if (pmem_major < 0)
+                return pmem_major;
+
+        error = platform_driver_register(&pmem_driver);
+        if (error)
+                unregister_blkdev(pmem_major, "pmem");
+        return error;
+}
+module_init(pmem_init);
+
+static void pmem_exit(void)
+{
+        platform_driver_unregister(&pmem_driver);
+        unregister_blkdev(pmem_major, "pmem");
+}
+module_exit(pmem_exit);
+
+MODULE_AUTHOR("Ross Zwisler <ross.zwisler@linux.intel.com>");
+MODULE_LICENSE("GPL v2");