libnvdimm: namespace indices: read and validate

This on media label format [1] consists of two index blocks followed by
an array of labels.  None of these structures are ever updated in place.
A sequence number tracks the current active index and the next one to
write, while labels are written to free slots.

    +------------+
    |            |
    |  nsindex0  |
    |            |
    +------------+
    |            |
    |  nsindex1  |
    |            |
    +------------+
    |   label0   |
    +------------+
    |   label1   |
    +------------+
    |            |
     ....nslot...
    |            |
    +------------+
    |   labelN   |
    +------------+

After reading valid labels, store the dpa ranges they claim into
per-dimm resource trees.

[1]: http://pmem.io/documents/NVDIMM_Namespace_Spec.pdf

Cc: Neil Brown <neilb@suse.de>
Acked-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

7 files changed, 520 insertions, 2 deletions

diff --git a/drivers/nvdimm/Makefile b/drivers/nvdimm/Makefile
index 4d2a27f52faa..abce98f87f16 100644
--- a/drivers/nvdimm/Makefile
+++ b/drivers/nvdimm/Makefile
@@ -10,3 +10,4 @@ libnvdimm-y += dimm.o
 libnvdimm-y += region_devs.o
 libnvdimm-y += region.o
 libnvdimm-y += namespace_devs.o
+libnvdimm-y += label.o
diff --git a/drivers/nvdimm/dimm.c b/drivers/nvdimm/dimm.c
index eb20fc2df32b..2df97c3c3b34 100644
--- a/drivers/nvdimm/dimm.c
+++ b/drivers/nvdimm/dimm.c
@@ -18,6 +18,7 @@
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/nd.h>
+#include "label.h"
 #include "nd.h"
 
 static void free_data(struct nvdimm_drvdata *ndd)
@@ -42,6 +43,11 @@ static int nvdimm_probe(struct device *dev)
                 return -ENOMEM;
 
         dev_set_drvdata(dev, ndd);
+        ndd->dpa.name = dev_name(dev);
+        ndd->ns_current = -1;
+        ndd->ns_next = -1;
+        ndd->dpa.start = 0;
+        ndd->dpa.end = -1;
         ndd->dev = dev;
 
         rc = nvdimm_init_nsarea(ndd);
@@ -54,6 +60,17 @@ static int nvdimm_probe(struct device *dev)
 
         dev_dbg(dev, "config data size: %d\n", ndd->nsarea.config_size);
 
+        nvdimm_bus_lock(dev);
+        ndd->ns_current = nd_label_validate(ndd);
+        ndd->ns_next = nd_label_next_nsindex(ndd->ns_current);
+        nd_label_copy(ndd, to_next_namespace_index(ndd),
+                        to_current_namespace_index(ndd));
+        rc = nd_label_reserve_dpa(ndd);
+        nvdimm_bus_unlock(dev);
+
+        if (rc)
+                goto err;
+
         return 0;
 
  err:
@@ -64,7 +81,13 @@ static int nvdimm_probe(struct device *dev)
 static int nvdimm_remove(struct device *dev)
 {
         struct nvdimm_drvdata *ndd = dev_get_drvdata(dev);
+        struct resource *res, *_r;
 
+        nvdimm_bus_lock(dev);
+        dev_set_drvdata(dev, NULL);
+        for_each_dpa_resource_safe(ndd, res, _r)
+                nvdimm_free_dpa(ndd, res);
+        nvdimm_bus_unlock(dev);
         free_data(ndd);
 
         return 0;
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index bdf8241b6525..d2ef02e4be6c 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -92,8 +92,12 @@ int nvdimm_init_config_data(struct nvdimm_drvdata *ndd)
         if (ndd->data)
                 return 0;
 
-        if (ndd->nsarea.status || ndd->nsarea.max_xfer == 0)
+        if (ndd->nsarea.status || ndd->nsarea.max_xfer == 0
+                        || ndd->nsarea.config_size < ND_LABEL_MIN_SIZE) {
+                dev_dbg(ndd->dev, "failed to init config data area: (%d:%d)\n",
+                                ndd->nsarea.max_xfer, ndd->nsarea.config_size);
                 return -ENXIO;
+        }
 
         ndd->data = kmalloc(ndd->nsarea.config_size, GFP_KERNEL);
         if (!ndd->data)
@@ -243,6 +247,30 @@ struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
 }
 EXPORT_SYMBOL_GPL(nvdimm_create);
 
+void nvdimm_free_dpa(struct nvdimm_drvdata *ndd, struct resource *res)
+{
+        WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
+        kfree(res->name);
+        __release_region(&ndd->dpa, res->start, resource_size(res));
+}
+
+struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
+                struct nd_label_id *label_id, resource_size_t start,
+                resource_size_t n)
+{
+        char *name = kmemdup(label_id, sizeof(*label_id), GFP_KERNEL);
+        struct resource *res;
+
+        if (!name)
+                return NULL;
+
+        WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
+        res = __request_region(&ndd->dpa, start, n, name, 0);
+        if (!res)
+                kfree(name);
+        return res;
+}
+
 static int count_dimms(struct device *dev, void *c)
 {
         int *count = c;
diff --git a/drivers/nvdimm/label.c b/drivers/nvdimm/label.c
new file mode 100644
index 000000000000..db5d7492dc8d
--- /dev/null
+++ b/drivers/nvdimm/label.c
@@ -0,0 +1,290 @@
+/*
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License 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.
+ */
+#include <linux/device.h>
+#include <linux/ndctl.h>
+#include <linux/io.h>
+#include <linux/nd.h>
+#include "nd-core.h"
+#include "label.h"
+#include "nd.h"
+
+static u32 best_seq(u32 a, u32 b)
+{
+        a &= NSINDEX_SEQ_MASK;
+        b &= NSINDEX_SEQ_MASK;
+
+        if (a == 0 || a == b)
+                return b;
+        else if (b == 0)
+                return a;
+        else if (nd_inc_seq(a) == b)
+                return b;
+        else
+                return a;
+}
+
+size_t sizeof_namespace_index(struct nvdimm_drvdata *ndd)
+{
+        u32 index_span;
+
+        if (ndd->nsindex_size)
+                return ndd->nsindex_size;
+
+        /*
+         * The minimum index space is 512 bytes, with that amount of
+         * index we can describe ~1400 labels which is less than a byte
+         * of overhead per label.  Round up to a byte of overhead per
+         * label and determine the size of the index region.  Yes, this
+         * starts to waste space at larger config_sizes, but it's
+         * unlikely we'll ever see anything but 128K.
+         */
+        index_span = ndd->nsarea.config_size / 129;
+        index_span /= NSINDEX_ALIGN * 2;
+        ndd->nsindex_size = index_span * NSINDEX_ALIGN;
+
+        return ndd->nsindex_size;
+}
+
+int nd_label_validate(struct nvdimm_drvdata *ndd)
+{
+        /*
+         * On media label format consists of two index blocks followed
+         * by an array of labels.  None of these structures are ever
+         * updated in place.  A sequence number tracks the current
+         * active index and the next one to write, while labels are
+         * written to free slots.
+         *
+         *     +------------+
+         *     |            |
+         *     |  nsindex0  |
+         *     |            |
+         *     +------------+
+         *     |            |
+         *     |  nsindex1  |
+         *     |            |
+         *     +------------+
+         *     |   label0   |
+         *     +------------+
+         *     |   label1   |
+         *     +------------+
+         *     |            |
+         *      ....nslot...