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

Pull libnvdimm updates from Dan Williams:
 "Aside from the recently added pmem sub-division support these have
  been in -next for several releases with no reported issues. The sub-
  division support was included in next-20161010 with no reported
  issues. It passes all unit tests including new tests for all the new
  functionality below.

  Summary:

   - PMEM sub-division support: Allow a single PMEM region to be divided
     into multiple namespaces. Originally, ~2 years ago, it was thought
     that partitions of a /dev/pmemX block device could handle
     sub-allocations of persistent memory for different use cases. With
     the decision to not support DAX mappings of raw block-devices, and
     the genesis of device-dax, the need for having multiple
     pmem-namespace per region has grown.

   - Device-DAX unified inode: In support of dynamic-resizing of a
     device-dax instance the kernel arranges for all mappings of a
     device-dax node to share the same inode. This allows unmap /
     truncate / invalidation events to affect all instances of the
     device similar to the behavior of mmap on block devices.

   - Hardware error scrubbing reworks: The original address-range-scrub
     and badblocks tracking solution allowed clearing entries at the
     individual namespace level, but it failed to clear the internal
     list of media errors maintained at the bus level. The result was
     that the next scrub or namespace disable/re-enable event would
     restore the cleared badblocks, but now that is fixed. The v4.8
     kernel introduced an auto-scrub-on-machine-check behavior to
     repopulate the badblocks list. Now, in v4.9, the auto-scrub
     behavior can be disabled and simply arrange for the error reported
     in the machine-check to be added to the list.

   - DIMM health-event notification support: ACPI 6.1 defines a
     notification event code that can be send to ACPI NVDIMM devices. A
     poll(2) capable file descriptor for these events can be obtained
     from the nmemX/nfit/flags sysfs-attribute of a libnvdimm memory
     device.

   - Miscellaneous fixes: NVDIMM-N probe error, device-dax build error,
     and a change to dedup the flush hint list to not flush the memory
     controller more than necessary"

* tag 'libnvdimm-for-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm: (39 commits)
  /dev/dax: fix Kconfig dependency build breakage
  dax: use correct dev_t value
  dax: convert devm_create_dax_dev to PTR_ERR
  libnvdimm, namespace: allow creation of multiple pmem-namespaces per region
  libnvdimm, namespace: lift single pmem limit in scan_labels()
  libnvdimm, namespace: filter out of range labels in scan_labels()
  libnvdimm, namespace: enable allocation of multiple pmem namespaces
  libnvdimm, namespace: update label implementation for multi-pmem
  libnvdimm, namespace: expand pmem device naming scheme for multi-pmem
  libnvdimm, region: update nd_region_available_dpa() for multi-pmem support
  libnvdimm, namespace: sort namespaces by dpa at init
  libnvdimm, namespace: allow multiple pmem-namespaces per region at scan time
  tools/testing/nvdimm: support for sub-dividing a pmem region
  libnvdimm, namespace: unify blk and pmem label scanning
  libnvdimm, namespace: refactor uuid_show() into a namespace_to_uuid() helper
  libnvdimm, label: convert label tracking to a linked list
  libnvdimm, region: move region-mapping input-paramters to nd_mapping_desc
  nvdimm: reduce duplicated wpq flushes
  libnvdimm: clear the internal poison_list when clearing badblocks
  pmem: reduce kmap_atomic sections to the memcpys only
  ...

4 files changed, 276 insertions, 48 deletions

diff --git a/tools/testing/nvdimm/Kbuild b/tools/testing/nvdimm/Kbuild
index ad6dd0543019..582db95127ed 100644
--- a/tools/testing/nvdimm/Kbuild
+++ b/tools/testing/nvdimm/Kbuild
@@ -13,6 +13,7 @@ ldflags-y += --wrap=__release_region
 ldflags-y += --wrap=devm_memremap_pages
 ldflags-y += --wrap=insert_resource
 ldflags-y += --wrap=remove_resource
+ldflags-y += --wrap=acpi_evaluate_object
 
 DRIVERS := ../../../drivers
 NVDIMM_SRC := $(DRIVERS)/nvdimm
diff --git a/tools/testing/nvdimm/test/iomap.c b/tools/testing/nvdimm/test/iomap.c
index c29f8dca9e67..3ccef732fce9 100644
--- a/tools/testing/nvdimm/test/iomap.c
+++ b/tools/testing/nvdimm/test/iomap.c
@@ -17,6 +17,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/pfn_t.h>
+#include <linux/acpi.h>
 #include <linux/io.h>
 #include <linux/mm.h>
 #include "nfit_test.h"
@@ -73,7 +74,7 @@ void __iomem *__nfit_test_ioremap(resource_size_t offset, unsigned long size,
 
         if (nfit_res)
                 return (void __iomem *) nfit_res->buf + offset
-                        - nfit_res->res->start;
+                        - nfit_res->res.start;
         return fallback_fn(offset, size);
 }
 
@@ -84,7 +85,7 @@ void __iomem *__wrap_devm_ioremap_nocache(struct device *dev,
 
         if (nfit_res)
                 return (void __iomem *) nfit_res->buf + offset
-                        - nfit_res->res->start;
+                        - nfit_res->res.start;
         return devm_ioremap_nocache(dev, offset, size);
 }
 EXPORT_SYMBOL(__wrap_devm_ioremap_nocache);
@@ -95,7 +96,7 @@ void *__wrap_devm_memremap(struct device *dev, resource_size_t offset,
         struct nfit_test_resource *nfit_res = get_nfit_res(offset);
 
         if (nfit_res)
-                return nfit_res->buf + offset - nfit_res->res->start;
+                return nfit_res->buf + offset - nfit_res->res.start;
         return devm_memremap(dev, offset, size, flags);
 }
 EXPORT_SYMBOL(__wrap_devm_memremap);
@@ -107,7 +108,7 @@ void *__wrap_devm_memremap_pages(struct device *dev, struct resource *res,
         struct nfit_test_resource *nfit_res = get_nfit_res(offset);
 
         if (nfit_res)
-                return nfit_res->buf + offset - nfit_res->res->start;
+                return nfit_res->buf + offset - nfit_res->res.start;
         return devm_memremap_pages(dev, res, ref, altmap);
 }
 EXPORT_SYMBOL(__wrap_devm_memremap_pages);
@@ -128,7 +129,7 @@ void *__wrap_memremap(resource_size_t offset, size_t size,
         struct nfit_test_resource *nfit_res = get_nfit_res(offset);
 
         if (nfit_res)
-                return nfit_res->buf + offset - nfit_res->res->start;
+                return nfit_res->buf + offset - nfit_res->res.start;
         return memremap(offset, size, flags);
 }
 EXPORT_SYMBOL(__wrap_memremap);
@@ -174,6 +175,63 @@ void __wrap_memunmap(void *addr)
 }
 EXPORT_SYMBOL(__wrap_memunmap);
 
+static bool nfit_test_release_region(struct device *dev,
+                struct resource *parent, resource_size_t start,
+                resource_size_t n);
+
+static void nfit_devres_release(struct device *dev, void *data)
+{
+        struct resource *res = *((struct resource **) data);
+
+        WARN_ON(!nfit_test_release_region(NULL, &iomem_resource, res->start,
+                        resource_size(res)));
+}
+
+static int match(struct device *dev, void *__res, void *match_data)
+{
+        struct resource *res = *((struct resource **) __res);
+        resource_size_t start = *((resource_size_t *) match_data);
+
+        return res->start == start;
+}
+
+static bool nfit_test_release_region(struct device *dev,
+                struct resource *parent, resource_size_t start,
+                resource_size_t n)
+{
+        if (parent == &iomem_resource) {
+                struct nfit_test_resource *nfit_res = get_nfit_res(start);
+
+                if (nfit_res) {
+                        struct nfit_test_request *req;
+                        struct resource *res = NULL;
+
+                        if (dev) {
+                                devres_release(dev, nfit_devres_release, match,
+                                                &start);
+                                return true;
+                        }
+
+                        spin_lock(&nfit_res->lock);
+                        list_for_each_entry(req, &nfit_res->requests, list)
+                                if (req->res.start == start) {
+                                        res = &req->res;
+                                        list_del(&req->list);
+                                        break;
+                                }
+                        spin_unlock(&nfit_res->lock);
+
+                        WARN(!res || resource_size(res) != n,
+                                        "%s: start: %llx n: %llx mismatch: %pr\n",
+                                                __func__, start, n, res);
+                        if (res)
+                                kfree(req);
+                        return true;
+                }
+        }
+        return false;
+}
+
 static struct resource *nfit_test_request_region(struct device *dev,
                 struct resource *parent, resource_size_t start,
                 resource_size_t n, const char *name, int flags)
@@ -183,21 +241,57 @@ static struct resource *nfit_test_request_region(struct device *dev,
         if (parent == &iomem_resource) {
                 nfit_res = get_nfit_res(start);
                 if (nfit_res) {
-                        struct resource *res = nfit_res->res + 1;
+                        struct nfit_test_request *req;
+                        struct resource *res = NULL;
 
-                        if (start + n > nfit_res->res->start
-                                        + resource_size(nfit_res->res)) {
+                        if (start + n > nfit_res->res.start
+                                        + resource_size(&nfit_res->res)) {
                                 pr_debug("%s: start: %llx n: %llx overflow: %pr\n",
                                                 __func__, start, n,
-                                                nfit_res->res);
+                                                &nfit_res->res);
                                 return NULL;
                         }
 
+                        spin_lock(&nfit_res->lock);
+                        list_for_each_entry(req, &nfit_res->requests, list)
+                                if (start == req->res.start) {
+                                        res = &req->res;
+                                        break;
+                                }
+                        spin_unlock(&nfit_res->lock);
+
+                        if (res) {
+                                WARN(1, "%pr already busy\n", res);
+                                return NULL;
+                        }
+
+                        req = kzalloc(sizeof(*req), GFP_KERNEL);
+                        if (!req)
+                                return NULL;
+                        INIT_LIST_HEAD(&req->list);
+                        res = &req->res;
+
                         res->start = start;
                         res->end = start + n - 1;
                         res->name = name;
                         res->flags = resource_type(parent);
                         res->flags |= IORESOURCE_BUSY | flags;
+                        spin_lock(&nfit_res->lock);
+                        list_add(&req->list, &nfit_res->requests);
+                        spin_unlock(&nfit_res->lock);
+
+                        if (dev) {
+                                struct resource **d;
+
+                                d = devres_alloc(nfit_devres_release,
+                                                sizeof(struct resource *),
+                                                GFP_KERNEL);
+                                if (!d)
+                                        return NULL;
+                                *d = res;
+                                devres_add(dev, d);
+                        }
+
                         pr_debug("%s: %pr\n", __func__, res);
                         return res;
                 }
@@ -241,29 +335,10 @@ struct resource *__wrap___devm_request_region(struct device *dev,
 }
 EXPORT_SYMBOL(__wrap___devm_request_region);
 
-static bool nfit_test_release_region(struct resource *parent,
-                resource_size_t start, resource_size_t n)
-{
-        if (parent == &iomem_resource) {
-                struct nfit_test_resource *nfit_res = get_nfit_res(start);
-                if (nfit_res) {
-                        struct resource *res = nfit_res->res + 1;
-
-                        if (start != res->start || resource_size(res) != n)
-                                pr_info("%s: start: %llx n: %llx mismatch: %pr\n",
-                                                __func__, start, n, res);
-                        else
-                                memset(res, 0, sizeof(*res));
-                        return true;
-                }
-        }
-        return false;
-}
-
 void __wrap___release_region(struct resource *parent, resource_size_t start,
                 resource_size_t n)
 {
-        if (!nfit_test_release_region(parent, start, n))
+        if (!nfit_test_release_region(NULL, parent, start, n))
                 __release_region(parent, start, n);
 }
 EXPORT_SYMBOL(__wrap___release_region);
@@ -271,9 +346,25 @@ EXPORT_SYMBOL(__wrap___release_region);
 void __wrap___devm_release_region(struct device *dev, struct resource *parent,
                 resource_size_t start, resource_size_t n)
 {
-        if (!nfit_test_release_region(parent, start, n))
+        if (!nfit_test_release_region(dev, parent, start, n))
                 __devm_release_region(dev, parent, start, n);
 }
 EXPORT_SYMBOL(__wrap___devm_release_region);
 
+acpi_status __wrap_acpi_evaluate_object(acpi_handle handle, acpi_string path,
+                struct acpi_object_list *p, struct acpi_buffer *buf)
+{
+        struct nfit_test_resource *nfit_res = get_nfit_res((long) handle);
+        union acpi_object **obj;
+
+        if (!nfit_res || strcmp(path, "_FIT") || !buf)
+                return acpi_evaluate_object(handle, path, p, buf);
+
+        obj = nfit_res->buf;
+        buf->length = sizeof(union acpi_object);
+        buf->pointer = *obj;
+        return AE_OK;
+}
+EXPORT_SYMBOL(__wrap_acpi_evaluate_object);
+
 MODULE_LICENSE("GPL v2");
diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index f64c57bf1d4b..c9a6458cb63e 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -132,6 +132,8 @@ static u32 handle[NUM_DCR] = {
         [4] = NFIT_DIMM_HANDLE(0, 1, 0, 0, 0),
 };
 
+static unsigned long dimm_fail_cmd_flags[NUM_DCR];
+
 struct nfit_test {
         struct acpi_nfit_desc acpi_desc;
         struct platform_device pdev;
@@ -154,11 +156,14 @@ struct nfit_test {
         int (*alloc)(struct nfit_test *t);
         void (*setup)(struct nfit_test *t);
         int setup_hotplug;
+        union acpi_object **_fit;
+        dma_addr_t _fit_dma;
         struct ars_state {
                 struct nd_cmd_ars_status *ars_status;
                 unsigned long deadline;
                 spinlock_t lock;
         } ars_state;
+        struct device *dimm_dev[NUM_DCR];
 };
 
 static struct nfit_test *to_nfit_test(struct device *dev)
@@ -411,6 +416,9 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                 if (i >= ARRAY_SIZE(handle))
                         return -ENXIO;
 
+                if ((1 << func) & dimm_fail_cmd_flags[i])
+                        return -EIO;
+
                 switch (func) {
                 case ND_CMD_GET_CONFIG_SIZE:
                         rc = nfit_test_cmd_get_config_size(buf, buf_len);
@@ -428,6 +436,9 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                         break;
                 case ND_CMD_SMART_THRESHOLD:
                         rc = nfit_test_cmd_smart_threshold(buf, buf_len);
+                        device_lock(&t->pdev.dev);
+                        __acpi_nvdimm_notify(t->dimm_dev[i], 0x81);
+                        device_unlock(&t->pdev.dev);
                         break;
                 default:
                         return -ENOTTY;
@@ -467,14 +478,12 @@ static struct nfit_test *instances[NUM_NFITS];
 static void release_nfit_res(void *data)
 {
         struct nfit_test_resource *nfit_res = data;
-        struct resource *res = nfit_res->res;
 
         spin_lock(&nfit_test_lock);
         list_del(&nfit_res->list);
         spin_unlock(&nfit_test_lock);
 
         vfree(nfit_res->buf);
-        kfree(res);
         kfree(nfit_res);
 }
 
@@ -482,12 +491,11 @@ static void *__test_alloc(struct nfit_test *t, size_t size, dma_addr_t *dma,
                 void *buf)
 {
         struct device *dev = &t->pdev.dev;
-        struct resource *res = kzalloc(sizeof(*res) * 2, GFP_KERNEL);
         struct nfit_test_resource *nfit_res = kzalloc(sizeof(*nfit_res),
                         GFP_KERNEL);
         int rc;
 
-        if (!res || !buf || !nfit_res)
+        if (!buf || !nfit_res)
                 goto err;
         rc = devm_add_action(dev, release_nfit_res, nfit_res);
         if (rc)
@@ -496,10 +504,11 @@ static void *__test_alloc(struct nfit_test *t, size_t size, dma_addr_t *dma,
         memset(buf, 0, size);
         nfit_res->dev = dev;
         nfit_res->buf = buf;
-        nfit_res->res = res;
-        res->start = *dma;
-        res->end = *dma + size - 1;
-        res->name = "NFIT";
+        nfit_res->res.start = *dma;
+        nfit_res->res.end = *dma + size - 1;
+        nfit_res->res.name = "NFIT";
+        spin_lock_init(&nfit_res->lock);
+        INIT_LIST_HEAD(&nfit_res->requests);
         spin_lock(&nfit_test_lock);
         list_add(&nfit_res->list, &t->resources);
         spin_unlock(&nfit_test_lock);
@@ -508,7 +517,6 @@ static void *__test_alloc(struct nfit_test *t, size_t size, dma_addr_t *dma,
  err:
         if (buf)
                 vfree(buf);
-        kfree(res);
         kfree(nfit_res);
         return NULL;
 }
@@ -533,13 +541,13 @@ static struct nfit_test_resource *nfit_test_lookup(resource_size_t addr)
                         continue;
                 spin_lock(&nfit_test_lock);
                 list_for_each_entry(n, &t->resources, list) {
-                        if (addr >= n->res->start && (addr < n->res->start
-                                                + resource_size(n->res))) {
+                        if (addr >= n->res.start && (addr < n->res.start
+                                                + resource_size(&n->res))) {
                                 nfit_res = n;
                                 break;
                         } else if (addr >= (unsigned long) n->buf
                                         && (addr < (unsigned long) n->buf
-                                                + resource_size(n->res))) {
+                                                + resource_size(&n->res))) {
                                 nfit_res = n;
                                 break;
                         }
@@ -564,6 +572,86 @@ static int ars_state_init(struct device *dev, struct ars_state *ars_state)
         return 0;
 }
 
+static void put_dimms(void *data)
+{
+        struct device **dimm_dev = data;
+        int i;
+
+        for (i = 0; i < NUM_DCR; i++)
+                if (dimm_dev[i])
+                        device_unregister(dimm_dev[i]);
+}
+
+static struct class *nfit_test_dimm;
+
+static int dimm_name_to_id(struct device *dev)
+{
+        int dimm;
+
+        if (sscanf(dev_name(dev), "test_dimm%d", &dimm) != 1
+                        || dimm >= NUM_DCR || dimm < 0)
+                return -ENXIO;
+        return dimm;
+}
+
+
+static ssize_t handle_show(struct device *dev, struct device_attribute *attr,
+                char *buf)
+{
+        int dimm = dimm_name_to_id(dev);
+
+        if (dimm < 0)
+                return dimm;
+
+        return sprintf(buf, "%#x", handle[dimm]);
+}
+DEVICE_ATTR_RO(handle);
+
+static ssize_t fail_cmd_show(struct device *dev, struct device_attribute *attr,
+                char *buf)
+{
+        int dimm = dimm_name_to_id(dev);
+
+        if (dimm < 0)
+                return dimm;
+
+        return sprintf(buf, "%#lx\n", dimm_fail_cmd_flags[dimm]);
+}
+
+static ssize_t fail_cmd_store(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t size)
+{
+        int dimm = dimm_name_to_id(dev);
+        unsigned long val;
+        ssize_t rc;
+
+        if (dimm < 0)
+                return dimm;
+
+        rc = kstrtol(buf, 0, &val);
+        if (rc)
+                return rc;
+
+        dimm_fail_cmd_flags[dimm] = val;
+        return size;
+}
+static DEVICE_ATTR_RW(fail_cmd);
+
+static struct attribute *nfit_test_dimm_attributes[] = {
+        &dev_attr_fail_cmd.attr,
+        &dev_attr_handle.attr,
+        NULL,
+};
+
+static struct attribute_group nfit_test_dimm_attribute_group = {
+        .attrs = nfit_test_dimm_attributes,
+};
+
+static const struct attribute_group *nfit_test_dimm_attribute_groups[] = {
+        &nfit_test_dimm_attribute_group,
+        NULL,
+};
+
 static int nfit_test0_alloc(struct nfit_test *t)
 {
         size_t nfit_size = sizeof(struct acpi_nfit_system_address) * NUM_SPA
@@ -616,6 +704,21 @@ static int nfit_test0_alloc(struct nfit_test *t)
                         return -ENOMEM;
         }
 
+        t->_fit = test_alloc(t, sizeof(union acpi_object **), &t->_fit_dma);
+        if (!t->_fit)
+                return -ENOMEM;
+
+        if (devm_add_action_or_reset(&t->pdev.dev, put_dimms, t->dimm_dev))
+                return -ENOMEM;
+        for (i = 0; i < NUM_DCR; i++) {
+                t->dimm_dev[i] = device_create_with_groups(nfit_test_dimm,
+                                &t->pdev.dev, 0, NULL,
+                                nfit_test_dimm_attribute_groups,
+                                "test_dimm%d", i);
+                if (!t->dimm_dev[i])
+                        return -ENOMEM;
+        }
+
         return ars_state_init(&t->pdev.dev, &t->ars_state);
 }
 
@@ -1409,6 +1512,8 @@ static int nfit_test_probe(struct platform_device *pdev)
         struct acpi_nfit_desc *acpi_desc;
         struct device *dev = &pdev->dev;
         struct nfit_test *nfit_test;
+        struct nfit_mem *nfit_mem;
+        union acpi_object *obj;
         int rc;
 
         nfit_test = to_nfit_test(&pdev->dev);
@@ -1476,14 +1581,30 @@ static int nfit_test_probe(struct platform_device *pdev)
         if (nfit_test->setup != nfit_test0_setup)
                 return 0;
 
-        flush_work(&acpi_desc->work);
         nfit_test->setup_hotplug = 1;
         nfit_test->setup(nfit_test);
 
-        rc = acpi_nfit_init(acpi_desc, nfit_test->nfit_buf,
-                        nfit_test->nfit_size);
-        if (rc)
-                return rc;
+        obj = kzalloc(sizeof(*obj), GFP_KERNEL);
+        if (!obj)
+                return -ENOMEM;
+        obj->type = ACPI_TYPE_BUFFER;
+        obj->buffer.length = nfit_test->nfit_size;
+        obj->buffer.pointer = nfit_test->nfit_buf;
+        *(nfit_test->_fit) = obj;
+        __acpi_nfit_notify(&pdev->dev, nfit_test, 0x80);
+
+        /* associate dimm devices with nfit_mem data for notification testing */
+        mutex_lock(&acpi_desc->init_mutex);
+        list_for_each_entry(nfit_mem, &acpi_desc->dimms, list) {
+                u32 nfit_handle = __to_nfit_memdev(nfit_mem)->device_handle;
+                int i;
+
+                for (i = 0; i < NUM_DCR; i++)
+                        if (nfit_handle == handle[i])
+                                dev_set_drvdata(nfit_test->dimm_dev[i],
+                                                nfit_mem);
+        }
+        mutex_unlock(&acpi_desc->init_mutex);
 
         return 0;
 }
@@ -1518,6 +1639,10 @@ static __init int nfit_test_init(void)
 {
         int rc, i;
 
+        nfit_test_dimm = class_create(THIS_MODULE, "nfit_test_dimm");
+        if (IS_ERR(nfit_test_dimm))
+                return PTR_ERR(nfit_test_dimm);
+
         nfit_test_setup(nfit_test_lookup);
 
         for (i = 0; i < NUM_NFITS; i++) {
@@ -1584,6 +1709,7 @@ static __exit void nfit_test_exit(void)
         for (i = 0; i < NUM_NFITS; i++)
                 platform_device_unregister(&instances[i]->pdev);
         nfit_test_teardown();
+        class_destroy(nfit_test_dimm);
 }
 
 module_init(nfit_test_init);
diff --git a/tools/testing/nvdimm/test/nfit_test.h b/tools/testing/nvdimm/test/nfit_test.h
index 9f18e2a4a862..c281dd2e5e2d 100644
--- a/tools/testing/nvdimm/test/nfit_test.h
+++ b/tools/testing/nvdimm/test/nfit_test.h
@@ -13,11 +13,21 @@
 #ifndef __NFIT_TEST_H__
 #define __NFIT_TEST_H__
 #include <linux/list.h>
+#include <linux/ioport.h>
+#include <linux/spinlock_types.h>
+
+struct nfit_test_request {
+        struct list_head list;
+        struct resource res;
+};
 
 struct nfit_test_resource {
+        struct list_head requests;
         struct list_head list;
-        struct resource *res;
+        struct resource res;
         struct device *dev;
+        spinlock_t lock;
+        int req_count;
         void *buf;
 };