Merge branch 'for-4.9/block' of git://git.kernel.dk/linux-block

Pull block layer updates from Jens Axboe:
 "This is the main pull request for block layer changes in 4.9.

  As mentioned at the last merge window, I've changed things up and now
  do just one branch for core block layer changes, and driver changes.
  This avoids dependencies between the two branches. Outside of this
  main pull request, there are two topical branches coming as well.

  This pull request contains:

   - A set of fixes, and a conversion to blk-mq, of nbd. From Josef.

   - Set of fixes and updates for lightnvm from Matias, Simon, and Arnd.
     Followup dependency fix from Geert.

   - General fixes from Bart, Baoyou, Guoqing, and Linus W.

   - CFQ async write starvation fix from Glauber.

   - Add supprot for delayed kick of the requeue list, from Mike.

   - Pull out the scalable bitmap code from blk-mq-tag.c and make it
     generally available under the name of sbitmap. Only blk-mq-tag uses
     it for now, but the blk-mq scheduling bits will use it as well.
     From Omar.

   - bdev thaw error progagation from Pierre.

   - Improve the blk polling statistics, and allow the user to clear
     them. From Stephen.

   - Set of minor cleanups from Christoph in block/blk-mq.

   - Set of cleanups and optimizations from me for block/blk-mq.

   - Various nvme/nvmet/nvmeof fixes from the various folks"

* 'for-4.9/block' of git://git.kernel.dk/linux-block: (54 commits)
  fs/block_dev.c: return the right error in thaw_bdev()
  nvme: Pass pointers, not dma addresses, to nvme_get/set_features()
  nvme/scsi: Remove power management support
  nvmet: Make dsm number of ranges zero based
  nvmet: Use direct IO for writes
  admin-cmd: Added smart-log command support.
  nvme-fabrics: Add host_traddr options field to host infrastructure
  nvme-fabrics: revise host transport option descriptions
  nvme-fabrics: rework nvmf_get_address() for variable options
  nbd: use BLK_MQ_F_BLOCKING
  blkcg: Annotate blkg_hint correctly
  cfq: fix starvation of asynchronous writes
  blk-mq: add flag for drivers wanting blocking ->queue_rq()
  blk-mq: remove non-blocking pass in blk_mq_map_request
  blk-mq: get rid of manual run of queue with __blk_mq_run_hw_queue()
  block: export bio_free_pages to other modules
  lightnvm: propagate device_add() error code
  lightnvm: expose device geometry through sysfs
  lightnvm: control life of nvm_dev in driver
  blk-mq: register device instead of disk
  ...

5 files changed, 258 insertions, 34 deletions

diff --git a/drivers/lightnvm/Kconfig b/drivers/lightnvm/Kconfig
index 61c68a1f054a..2f5d5f4a4c75 100644
--- a/drivers/lightnvm/Kconfig
+++ b/drivers/lightnvm/Kconfig
@@ -4,7 +4,7 @@
 
 menuconfig NVM
         bool "Open-Channel SSD target support"
-        depends on BLOCK
+        depends on BLOCK && HAS_DMA
         help
           Say Y here to get to enable Open-channel SSDs.
 
diff --git a/drivers/lightnvm/Makefile b/drivers/lightnvm/Makefile
index a7a0a22cf1a5..1f6b6521016a 100644
--- a/drivers/lightnvm/Makefile
+++ b/drivers/lightnvm/Makefile
@@ -2,6 +2,6 @@
 # Makefile for Open-Channel SSDs.
 #
 
-obj-$(CONFIG_NVM)               := core.o sysblk.o
+obj-$(CONFIG_NVM)               := core.o sysblk.o sysfs.o
 obj-$(CONFIG_NVM_GENNVM)        += gennvm.o
 obj-$(CONFIG_NVM_RRPC)          += rrpc.o
diff --git a/drivers/lightnvm/core.c b/drivers/lightnvm/core.c
index c784ddcd4405..1cac0f8bc0dc 100644
--- a/drivers/lightnvm/core.c
+++ b/drivers/lightnvm/core.c
@@ -27,6 +27,8 @@
 #include <linux/lightnvm.h>
 #include <linux/sched/sysctl.h>
 
+#include "lightnvm.h"
+
 static LIST_HEAD(nvm_tgt_types);
 static DECLARE_RWSEM(nvm_tgtt_lock);
 static LIST_HEAD(nvm_mgrs);
@@ -581,6 +583,8 @@ static int nvm_core_init(struct nvm_dev *dev)
         mutex_init(&dev->mlock);
         spin_lock_init(&dev->lock);
 
+        blk_queue_logical_block_size(dev->q, dev->sec_size);
+
         return 0;
 err_fmtype:
         kfree(dev->lun_map);
@@ -596,15 +600,19 @@ static void nvm_free_mgr(struct nvm_dev *dev)
         dev->mt = NULL;
 }
 
-static void nvm_free(struct nvm_dev *dev)
+void nvm_free(struct nvm_dev *dev)
 {
         if (!dev)
                 return;
 
         nvm_free_mgr(dev);
 
+        if (dev->dma_pool)
+                dev->ops->destroy_dma_pool(dev->dma_pool);
+
         kfree(dev->lptbl);
         kfree(dev->lun_map);
+        kfree(dev);
 }
 
 static int nvm_init(struct nvm_dev *dev)
@@ -651,30 +659,19 @@ err:
 
 static void nvm_exit(struct nvm_dev *dev)
 {
-        if (dev->dma_pool)
-                dev->ops->destroy_dma_pool(dev->dma_pool);
-        nvm_free(dev);
+        nvm_sysfs_unregister_dev(dev);
+}
 
-        pr_info("nvm: successfully unloaded\n");
+struct nvm_dev *nvm_alloc_dev(int node)
+{
+        return kzalloc_node(sizeof(struct nvm_dev), GFP_KERNEL, node);
 }
+EXPORT_SYMBOL(nvm_alloc_dev);
 
-int nvm_register(struct request_queue *q, char *disk_name,
-                                                        struct nvm_dev_ops *ops)
+int nvm_register(struct nvm_dev *dev)
 {
-        struct nvm_dev *dev;
         int ret;
 
-        if (!ops->identity)
-                return -EINVAL;
-
-        dev = kzalloc(sizeof(struct nvm_dev), GFP_KERNEL);
-        if (!dev)
-                return -ENOMEM;
-
-        dev->q = q;
-        dev->ops = ops;
-        strncpy(dev->name, disk_name, DISK_NAME_LEN);
-
         ret = nvm_init(dev);
         if (ret)
                 goto err_init;
@@ -694,6 +691,10 @@ int nvm_register(struct request_queue *q, char *disk_name,
                 }
         }
 
+        ret = nvm_sysfs_register_dev(dev);
+        if (ret)
+                goto err_ppalist;
+
         if (dev->identity.cap & NVM_ID_DCAP_BBLKMGMT) {
                 ret = nvm_get_sysblock(dev, &dev->sb);
                 if (!ret)
@@ -710,31 +711,21 @@ int nvm_register(struct request_queue *q, char *disk_name,
         up_write(&nvm_lock);
 
         return 0;
+err_ppalist:
+        dev->ops->destroy_dma_pool(dev->dma_pool);
 err_init:
         kfree(dev->lun_map);
-        kfree(dev);
         return ret;
 }
 EXPORT_SYMBOL(nvm_register);
 
-void nvm_unregister(char *disk_name)
+void nvm_unregister(struct nvm_dev *dev)
 {
-        struct nvm_dev *dev;
-
         down_write(&nvm_lock);
-        dev = nvm_find_nvm_dev(disk_name);
-        if (!dev) {
-                pr_err("nvm: could not find device %s to unregister\n",
-                                                                disk_name);
-                up_write(&nvm_lock);
-                return;
-        }
-
         list_del(&dev->devices);
         up_write(&nvm_lock);
 
         nvm_exit(dev);
-        kfree(dev);
 }
 EXPORT_SYMBOL(nvm_unregister);
 
diff --git a/drivers/lightnvm/lightnvm.h b/drivers/lightnvm/lightnvm.h
new file mode 100644
index 000000000000..305c181509a6
--- /dev/null
+++ b/drivers/lightnvm/lightnvm.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 CNEX Labs. All rights reserved.
+ * Initial release: Matias Bjorling <matias@cnexlabs.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
+ * USA.
+ *
+ */
+
+#ifndef LIGHTNVM_H
+#define LIGHTNVM_H
+
+#include <linux/lightnvm.h>
+
+/* core -> sysfs.c */
+int __must_check nvm_sysfs_register_dev(struct nvm_dev *);
+void nvm_sysfs_unregister_dev(struct nvm_dev *);
+int nvm_sysfs_register(void);
+void nvm_sysfs_unregister(void);
+
+/* sysfs > core */
+void nvm_free(struct nvm_dev *);
+
+#endif
diff --git a/drivers/lightnvm/sysfs.c b/drivers/lightnvm/sysfs.c
new file mode 100644
index 000000000000..0338c27ab95a
--- /dev/null
+++ b/drivers/lightnvm/sysfs.c
@@ -0,0 +1,198 @@
+#include <linux/kernel.h>
+#include <linux/lightnvm.h>
+#include <linux/miscdevice.h>
+#include <linux/kobject.h>
+#include <linux/blk-mq.h>
+
+#include "lightnvm.h"
+
+static ssize_t nvm_dev_attr_show(struct device *dev,
+                                 struct device_attribute *dattr, char *page)
+{
+        struct nvm_dev *ndev = container_of(dev, struct nvm_dev, dev);
+        struct nvm_id *id = &ndev->identity;
+        struct nvm_id_group *grp = &id->groups[0];
+        struct attribute *attr = &dattr->attr;
+
+        if (strcmp(attr->name, "version") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", id->ver_id);
+        } else if (strcmp(attr->name, "vendor_opcode") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", id->vmnt);
+        } else if (strcmp(attr->name, "capabilities") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", id->cap);
+        } else if (strcmp(attr->name, "device_mode") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", id->dom);
+        } else if (strcmp(attr->name, "media_manager") == 0) {
+                if (!ndev->mt)
+                        return scnprintf(page, PAGE_SIZE, "%s\n", "none");
+                return scnprintf(page, PAGE_SIZE, "%s\n", ndev->mt->name);
+        } else if (strcmp(attr->name, "ppa_format") == 0) {
+                return scnprintf(page, PAGE_SIZE,
+                        "0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
+                        id->ppaf.ch_offset, id->ppaf.ch_len,
+                        id->ppaf.lun_offset, id->ppaf.lun_len,
+                        id->ppaf.pln_offset, id->ppaf.pln_len,
+                        id->ppaf.blk_offset, id->ppaf.blk_len,
+                        id->ppaf.pg_offset, id->ppaf.pg_len,
+                        id->ppaf.sect_offset, id->ppaf.sect_len);
+        } else if (strcmp(attr->name, "media_type") == 0) {     /* u8 */
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->mtype);
+        } else if (strcmp(attr->name, "flash_media_type") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->fmtype);
+        } else if (strcmp(attr->name, "num_channels") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->num_ch);
+        } else if (strcmp(attr->name, "num_luns") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->num_lun);
+        } else if (strcmp(attr->name, "num_planes") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->num_pln);
+        } else if (strcmp(attr->name, "num_blocks") == 0) {     /* u16 */
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->num_blk);
+        } else if (strcmp(attr->name, "num_pages") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->num_pg);
+        } else if (strcmp(attr->name, "page_size") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->fpg_sz);
+        } else if (strcmp(attr->name, "hw_sector_size") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->csecs);
+        } else if (strcmp(attr->name, "oob_sector_size") == 0) {/* u32 */
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->sos);
+        } else if (strcmp(attr->name, "read_typ") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->trdt);
+        } else if (strcmp(attr->name, "read_max") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->trdm);
+        } else if (strcmp(attr->name, "prog_typ") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->tprt);
+        } else if (strcmp(attr->name, "prog_max") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->tprm);
+        } else if (strcmp(attr->name, "erase_typ") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->tbet);
+        } else if (strcmp(attr->name, "erase_max") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n", grp->tbem);
+        } else if (strcmp(attr->name, "multiplane_modes") == 0) {
+                return scnprintf(page, PAGE_SIZE, "0x%08x\n", grp->mpos);
+        } else if (strcmp(attr->name, "media_capabilities") == 0) {
+                return scnprintf(page, PAGE_SIZE, "0x%08x\n", grp->mccap);
+        } else if (strcmp(attr->name, "max_phys_secs") == 0) {
+                return scnprintf(page, PAGE_SIZE, "%u\n",
+                                ndev->ops->max_phys_sect);
+        } else {
+                return scnprintf(page,
+                                 PAGE_SIZE,
+                                 "Unhandled attr(%s) in `nvm_dev_attr_show`\n",
+                                 attr->name);
+        }
+}
+
+#define NVM_DEV_ATTR_RO(_name)                                          \
+        DEVICE_ATTR(_name, S_IRUGO, nvm_dev_attr_show, NULL)
+
+static NVM_DEV_ATTR_RO(version);
+static NVM_DEV_ATTR_RO(vendor_opcode);
+static NVM_DEV_ATTR_RO(capabilities);
+static NVM_DEV_ATTR_RO(device_mode);
+static NVM_DEV_ATTR_RO(ppa_format);
+static NVM_DEV_ATTR_RO(media_manager);
+
+static NVM_DEV_ATTR_RO(media_type);
+static NVM_DEV_ATTR_RO(flash_media_type);
+static NVM_DEV_ATTR_RO(num_channels);
+static NVM_DEV_ATTR_RO(num_luns);
+static NVM_DEV_ATTR_RO(num_planes);
+static NVM_DEV_ATTR_RO(num_blocks);
+static NVM_DEV_ATTR_RO(num_pages);
+static NVM_DEV_ATTR_RO(page_size);
+static NVM_DEV_ATTR_RO(hw_sector_size);
+static NVM_DEV_ATTR_RO(oob_sector_size);
+static NVM_DEV_ATTR_RO(read_typ);
+static NVM_DEV_ATTR_RO(read_max);
+static NVM_DEV_ATTR_RO(prog_typ);
+static NVM_DEV_ATTR_RO(prog_max);
+static NVM_DEV_ATTR_RO(erase_typ);
+static NVM_DEV_ATTR_RO(erase_max);
+static NVM_DEV_ATTR_RO(multiplane_modes);
+static NVM_DEV_ATTR_RO(media_capabilities);
+static NVM_DEV_ATTR_RO(max_phys_secs);
+
+#define NVM_DEV_ATTR(_name) (dev_attr_##_name##)
+
+static struct attribute *nvm_dev_attrs[] = {
+        &dev_attr_version.attr,
+        &dev_attr_vendor_opcode.attr,
+        &dev_attr_capabilities.attr,
+        &dev_attr_device_mode.attr,
+        &dev_attr_media_manager.attr,
+
+        &dev_attr_ppa_format.attr,
+        &dev_attr_media_type.attr,
+        &dev_attr_flash_media_type.attr,
+        &dev_attr_num_channels.attr,
+        &dev_attr_num_luns.attr,
+        &dev_attr_num_planes.attr,
+        &dev_attr_num_blocks.attr,
+        &dev_attr_num_pages.attr,
+        &dev_attr_page_size.attr,
+        &dev_attr_hw_sector_size.attr,
+        &dev_attr_oob_sector_size.attr,
+        &dev_attr_read_typ.attr,
+        &dev_attr_read_max.attr,
+        &dev_attr_prog_typ.attr,
+        &dev_attr_prog_max.attr,
+        &dev_attr_erase_typ.attr,
+        &dev_attr_erase_max.attr,
+        &dev_attr_multiplane_modes.attr,
+        &dev_attr_media_capabilities.attr,
+        &dev_attr_max_phys_secs.attr,
+        NULL,
+};
+
+static struct attribute_group nvm_dev_attr_group = {
+        .name = "lightnvm",
+        .attrs = nvm_dev_attrs,
+};
+
+static const struct attribute_group *nvm_dev_attr_groups[] = {
+        &nvm_dev_attr_group,
+        NULL,
+};
+
+static void nvm_dev_release(struct device *device)
+{
+        struct nvm_dev *dev = container_of(device, struct nvm_dev, dev);
+        struct request_queue *q = dev->q;
+
+        pr_debug("nvm/sysfs: `nvm_dev_release`\n");
+
+        blk_mq_unregister_dev(device, q);
+
+        nvm_free(dev);
+}
+
+static struct device_type nvm_type = {
+        .name           = "lightnvm",
+        .groups         = nvm_dev_attr_groups,
+        .release        = nvm_dev_release,
+};
+
+int nvm_sysfs_register_dev(struct nvm_dev *dev)
+{
+        int ret;
+
+        if (!dev->parent_dev)
+                return 0;
+
+        dev->dev.parent = dev->parent_dev;
+        dev_set_name(&dev->dev, "%s", dev->name);
+        dev->dev.type = &nvm_type;
+        device_initialize(&dev->dev);
+        ret = device_add(&dev->dev);
+
+        if (!ret)
+                blk_mq_register_dev(&dev->dev, dev->q);
+
+        return ret;
+}
+
+void nvm_sysfs_unregister_dev(struct nvm_dev *dev)
+{
+        if (dev && dev->parent_dev)
+                kobject_put(&dev->dev.kobj);
+}