* [PATCH 0/4] device-dax prepare for dynamic resize / allocate
@ 2016-08-16 17:09 Dan Williams
2016-08-16 17:09 ` [PATCH 1/4] dax: check resource alignment at dax region/device create Dan Williams
` (3 more replies)
0 siblings, 4 replies; 5+ messages in thread
From: Dan Williams @ 2016-08-16 17:09 UTC (permalink / raw)
To: linux-nvdimm; +Cc: linux-kernel
In preparation for dynamic resize / allocation support:
- convert device-dax instances to reserve memory ranges from their
parent region
- produce a 'seed' device instance to accept new allocation requests
---
Dan Williams (4):
dax: check resource alignment at dax region/device create
dax: add region-available-size attribute
dax: convert devm_create_dax_dev to PTR_ERR
dax: register seed device
drivers/dax/dax.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++++----
drivers/dax/dax.h | 5 +
drivers/dax/pmem.c | 5 +
3 files changed, 196 insertions(+), 22 deletions(-)
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH 1/4] dax: check resource alignment at dax region/device create
2016-08-16 17:09 [PATCH 0/4] device-dax prepare for dynamic resize / allocate Dan Williams
@ 2016-08-16 17:09 ` Dan Williams
2016-08-16 17:09 ` [PATCH 2/4] dax: add region-available-size attribute Dan Williams
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Dan Williams @ 2016-08-16 17:09 UTC (permalink / raw)
To: linux-nvdimm; +Cc: linux-kernel
All the extents of a dax-device must match the alignment of the region.
Otherwise, we are unable to guarantee fault semantics of a given page
size. The region must be self-consistent itself as well.
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/dax/dax.c | 22 +++++++++++++++++++---
1 file changed, 19 insertions(+), 3 deletions(-)
diff --git a/drivers/dax/dax.c b/drivers/dax/dax.c
index 0a7899d5c65c..03bb54f7f58f 100644
--- a/drivers/dax/dax.c
+++ b/drivers/dax/dax.c
@@ -206,8 +206,11 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id,
{
struct dax_region *dax_region;
- dax_region = kzalloc(sizeof(*dax_region), GFP_KERNEL);
+ if (!IS_ALIGNED(res->start, align)
+ || !IS_ALIGNED(resource_size(res), align))
+ return NULL;
+ dax_region = kzalloc(sizeof(*dax_region), GFP_KERNEL);
if (!dax_region)
return NULL;
@@ -560,15 +563,29 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
{
struct device *parent = dax_region->dev;
struct dax_dev *dax_dev;
+ int rc = 0, minor, i;
struct device *dev;
struct cdev *cdev;
- int rc, minor;
dev_t dev_t;
dax_dev = kzalloc(sizeof(*dax_dev) + sizeof(*res) * count, GFP_KERNEL);
if (!dax_dev)
return -ENOMEM;
+ for (i = 0; i < count; i++) {
+ if (!IS_ALIGNED(res[i].start, dax_region->align)
+ || !IS_ALIGNED(resource_size(&res[i]),
+ dax_region->align)) {
+ rc = -EINVAL;
+ break;
+ }
+ dax_dev->res[i].start = res[i].start;
+ dax_dev->res[i].end = res[i].end;
+ }
+
+ if (i < count)
+ goto err_id;
+
dax_dev->id = ida_simple_get(&dax_region->ida, 0, 0, GFP_KERNEL);
if (dax_dev->id < 0) {
rc = dax_dev->id;
@@ -601,7 +618,6 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
goto err_cdev;
/* from here on we're committed to teardown via dax_dev_release() */
- memcpy(dax_dev->res, res, sizeof(*res) * count);
dax_dev->num_resources = count;
dax_dev->alive = true;
dax_dev->region = dax_region;
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH 2/4] dax: add region-available-size attribute
2016-08-16 17:09 [PATCH 0/4] device-dax prepare for dynamic resize / allocate Dan Williams
2016-08-16 17:09 ` [PATCH 1/4] dax: check resource alignment at dax region/device create Dan Williams
@ 2016-08-16 17:09 ` Dan Williams
2016-08-16 17:09 ` [PATCH 3/4] dax: convert devm_create_dax_dev to PTR_ERR Dan Williams
2016-08-16 17:09 ` [PATCH 4/4] dax: register seed device Dan Williams
3 siblings, 0 replies; 5+ messages in thread
From: Dan Williams @ 2016-08-16 17:09 UTC (permalink / raw)
To: linux-nvdimm; +Cc: linux-kernel
In preparation for a facility that enables dax regions to be
sub-divided, introduce a 'dax/available_size' attribute. This attribute
appears under the parent device that registered the device-dax region,
and it assumes that the device-dax-core owns the driver-data for that
device.
'dax/available_size' adjusts dynamically as dax-device instances are
registered and unregistered.
As a side effect of using __request_region() to reserve capacity from
the dax_region we now track pointers to those returned resources rather
than duplicating the passed in resource array.
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/dax/dax.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++++-----
1 file changed, 123 insertions(+), 12 deletions(-)
diff --git a/drivers/dax/dax.c b/drivers/dax/dax.c
index 03bb54f7f58f..257cad62bd1d 100644
--- a/drivers/dax/dax.c
+++ b/drivers/dax/dax.c
@@ -38,6 +38,7 @@ MODULE_PARM_DESC(nr_dax, "max number of device-dax instances");
* @id: kernel-wide unique region for a memory range
* @base: linear address corresponding to @res
* @kref: to pin while other agents have a need to do lookups
+ * @lock: synchronize changes / consistent-access to the resource tree (@res)
* @dev: parent device backing this region
* @align: allocation and mapping alignment for child dax devices
* @res: physical address range of the region
@@ -48,6 +49,7 @@ struct dax_region {
struct ida ida;
void *base;
struct kref kref;
+ struct mutex lock;
struct device *dev;
unsigned int align;
struct resource res;
@@ -72,7 +74,56 @@ struct dax_dev {
bool alive;
int id;
int num_resources;
- struct resource res[0];
+ struct resource **res;
+};
+
+#define for_each_dax_region_resource(dax_region, res) \
+ for (res = (dax_region)->res.child; res; res = res->sibling)
+
+static unsigned long long dax_region_avail_size(
+ struct dax_region *dax_region)
+{
+ unsigned long long size;
+ struct resource *res;
+
+ mutex_lock(&dax_region->lock);
+ size = resource_size(&dax_region->res);
+ for_each_dax_region_resource(dax_region, res)
+ size -= resource_size(res);
+ mutex_unlock(&dax_region->lock);
+
+ return size;
+}
+
+static ssize_t available_size_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct dax_region *dax_region;
+ ssize_t rc = -ENXIO;
+
+ device_lock(dev);
+ dax_region = dev_get_drvdata(dev);
+ if (dax_region)
+ rc = sprintf(buf, "%llu\n", dax_region_avail_size(dax_region));
+ device_unlock(dev);
+
+ return rc;
+}
+static DEVICE_ATTR_RO(available_size);
+
+static struct attribute *dax_region_attributes[] = {
+ &dev_attr_available_size.attr,
+ NULL,
+};
+
+static const struct attribute_group dax_region_attribute_group = {
+ .name = "dax_region",
+ .attrs = dax_region_attributes,
+};
+
+static const struct attribute_group *dax_region_attribute_groups[] = {
+ &dax_region_attribute_group,
+ NULL,
};
static struct inode *dax_alloc_inode(struct super_block *sb)
@@ -200,12 +251,27 @@ void dax_region_put(struct dax_region *dax_region)
}
EXPORT_SYMBOL_GPL(dax_region_put);
+
+static void dax_region_unregister(void *region)
+{
+ struct dax_region *dax_region = region;
+
+ sysfs_remove_groups(&dax_region->dev->kobj,
+ dax_region_attribute_groups);
+ dax_region_put(dax_region);
+}
+
struct dax_region *alloc_dax_region(struct device *parent, int region_id,
struct resource *res, unsigned int align, void *addr,
unsigned long pfn_flags)
{
struct dax_region *dax_region;
+ if (dev_get_drvdata(parent)) {
+ dev_WARN(parent, "dax core found drvdata already in use\n");
+ return NULL;
+ }
+
if (!IS_ALIGNED(res->start, align)
|| !IS_ALIGNED(resource_size(res), align))
return NULL;
@@ -213,16 +279,26 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id,
dax_region = kzalloc(sizeof(*dax_region), GFP_KERNEL);
if (!dax_region)
return NULL;
-
- memcpy(&dax_region->res, res, sizeof(*res));
+ dev_set_drvdata(parent, dax_region);
+ dax_region->res.name = dev_name(parent);
+ dax_region->res.start = res->start;
+ dax_region->res.end = res->end;
dax_region->pfn_flags = pfn_flags;
+ mutex_init(&dax_region->lock);
kref_init(&dax_region->kref);
dax_region->id = region_id;
ida_init(&dax_region->ida);
dax_region->align = align;
dax_region->dev = parent;
dax_region->base = addr;
+ if (sysfs_create_groups(&parent->kobj, dax_region_attribute_groups)) {
+ kfree(dax_region);
+ return NULL;;
+ }
+ kref_get(&dax_region->kref);
+ if (devm_add_action_or_reset(parent, dax_region_unregister, dax_region))
+ return NULL;
return dax_region;
}
EXPORT_SYMBOL_GPL(alloc_dax_region);
@@ -240,7 +316,7 @@ static ssize_t size_show(struct device *dev,
int i;
for (i = 0; i < dax_dev->num_resources; i++)
- size += resource_size(&dax_dev->res[i]);
+ size += resource_size(dax_dev->res[i]);
return sprintf(buf, "%llu\n", size);
}
@@ -309,7 +385,7 @@ static phys_addr_t pgoff_to_phys(struct dax_dev *dax_dev, pgoff_t pgoff,
int i;
for (i = 0; i < dax_dev->num_resources; i++) {
- res = &dax_dev->res[i];
+ res = dax_dev->res[i];
phys = pgoff * PAGE_SIZE + res->start;
if (phys >= res->start && phys <= res->end)
break;
@@ -317,7 +393,7 @@ static phys_addr_t pgoff_to_phys(struct dax_dev *dax_dev, pgoff_t pgoff,
}
if (i < dax_dev->num_resources) {
- res = &dax_dev->res[i];
+ res = dax_dev->res[i];
if (phys + size - 1 <= res->end)
return phys;
}
@@ -534,13 +610,16 @@ static void dax_dev_release(struct device *dev)
ida_simple_remove(&dax_minor_ida, MINOR(dev->devt));
dax_region_put(dax_region);
iput(dax_dev->inode);
+ kfree(dax_dev->res);
kfree(dax_dev);
}
static void unregister_dax_dev(void *dev)
{
struct dax_dev *dax_dev = to_dax_dev(dev);
+ struct dax_region *dax_region = dax_dev->region;
struct cdev *cdev = &dax_dev->cdev;
+ int i;
dev_dbg(dev, "%s\n", __func__);
@@ -554,6 +633,13 @@ static void unregister_dax_dev(void *dev)
dax_dev->alive = false;
synchronize_rcu();
unmap_mapping_range(dax_dev->inode->i_mapping, 0, 0, 1);
+
+ mutex_lock(&dax_region->lock);
+ for (i = 0; i < dax_dev->num_resources; i++)
+ __release_region(&dax_region->res, dax_dev->res[i]->start,
+ resource_size(dax_dev->res[i]));
+ mutex_unlock(&dax_region->lock);
+
cdev_del(cdev);
device_unregister(dev);
}
@@ -568,28 +654,42 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
struct cdev *cdev;
dev_t dev_t;
- dax_dev = kzalloc(sizeof(*dax_dev) + sizeof(*res) * count, GFP_KERNEL);
+ dax_dev = kzalloc(sizeof(*dax_dev), GFP_KERNEL);
if (!dax_dev)
return -ENOMEM;
+ dax_dev->res = kzalloc(sizeof(res) * count, GFP_KERNEL);
+ if (!dax_dev->res)
+ goto err_res;
+
for (i = 0; i < count; i++) {
+ struct resource *dax_res;
+
if (!IS_ALIGNED(res[i].start, dax_region->align)
|| !IS_ALIGNED(resource_size(&res[i]),
dax_region->align)) {
rc = -EINVAL;
break;
}
- dax_dev->res[i].start = res[i].start;
- dax_dev->res[i].end = res[i].end;
+
+ mutex_lock(&dax_region->lock);
+ dax_res = __request_region(&dax_region->res, res[i].start,
+ resource_size(&res[i]), NULL, 0);
+ mutex_unlock(&dax_region->lock);
+ if (!dax_res) {
+ rc = -EBUSY;
+ break;
+ }
+ dax_dev->res[i] = dax_res;
}
if (i < count)
- goto err_id;
+ goto err_request_region;
dax_dev->id = ida_simple_get(&dax_region->ida, 0, 0, GFP_KERNEL);
if (dax_dev->id < 0) {
rc = dax_dev->id;
- goto err_id;
+ goto err_request_region;
}
minor = ida_simple_get(&dax_minor_ida, 0, 0, GFP_KERNEL);
@@ -629,6 +729,10 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
dev->groups = dax_attribute_groups;
dev->release = dax_dev_release;
dev_set_name(dev, "dax%d.%d", dax_region->id, dax_dev->id);
+ /* update resource names now that the owner device is named */
+ for (i = 0; i < dax_dev->num_resources; i++)
+ dax_dev->res[i]->name = dev_name(dev);
+
rc = device_add(dev);
if (rc) {
put_device(dev);
@@ -643,7 +747,14 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
ida_simple_remove(&dax_minor_ida, minor);
err_minor:
ida_simple_remove(&dax_region->ida, dax_dev->id);
- err_id:
+ err_request_region:
+ mutex_lock(&dax_region->lock);
+ for (i--; i >= 0; i--)
+ __release_region(&dax_region->res, dax_dev->res[i]->start,
+ resource_size(dax_dev->res[i]));
+ mutex_unlock(&dax_region->lock);
+ kfree(dax_dev->res);
+ err_res:
kfree(dax_dev);
return rc;
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH 3/4] dax: convert devm_create_dax_dev to PTR_ERR
2016-08-16 17:09 [PATCH 0/4] device-dax prepare for dynamic resize / allocate Dan Williams
2016-08-16 17:09 ` [PATCH 1/4] dax: check resource alignment at dax region/device create Dan Williams
2016-08-16 17:09 ` [PATCH 2/4] dax: add region-available-size attribute Dan Williams
@ 2016-08-16 17:09 ` Dan Williams
2016-08-16 17:09 ` [PATCH 4/4] dax: register seed device Dan Williams
3 siblings, 0 replies; 5+ messages in thread
From: Dan Williams @ 2016-08-16 17:09 UTC (permalink / raw)
To: linux-nvdimm; +Cc: linux-kernel
For sub-division support we need access to the dax_dev created by
devm_create_dax_dev().
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/dax/dax.c | 16 ++++++++++------
drivers/dax/dax.h | 5 +++--
drivers/dax/pmem.c | 5 +++--
3 files changed, 16 insertions(+), 10 deletions(-)
diff --git a/drivers/dax/dax.c b/drivers/dax/dax.c
index 257cad62bd1d..cbc765c81600 100644
--- a/drivers/dax/dax.c
+++ b/drivers/dax/dax.c
@@ -644,8 +644,8 @@ static void unregister_dax_dev(void *dev)
device_unregister(dev);
}
-int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
- int count)
+struct dax_dev *devm_create_dax_dev(struct dax_region *dax_region,
+ struct resource *res, int count)
{
struct device *parent = dax_region->dev;
struct dax_dev *dax_dev;
@@ -656,7 +656,7 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
dax_dev = kzalloc(sizeof(*dax_dev), GFP_KERNEL);
if (!dax_dev)
- return -ENOMEM;
+ return ERR_PTR(-ENOMEM);
dax_dev->res = kzalloc(sizeof(res) * count, GFP_KERNEL);
if (!dax_dev->res)
@@ -736,10 +736,14 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
rc = device_add(dev);
if (rc) {
put_device(dev);
- return rc;
+ return ERR_PTR(rc);
}
- return devm_add_action_or_reset(dax_region->dev, unregister_dax_dev, dev);
+ rc = devm_add_action_or_reset(dax_region->dev, unregister_dax_dev, dev);
+ if (rc)
+ return ERR_PTR(rc);
+
+ return dax_dev;
err_cdev:
iput(dax_dev->inode);
@@ -757,7 +761,7 @@ int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
err_res:
kfree(dax_dev);
- return rc;
+ return ERR_PTR(rc);
}
EXPORT_SYMBOL_GPL(devm_create_dax_dev);
diff --git a/drivers/dax/dax.h b/drivers/dax/dax.h
index d8b8f1f25054..ddd829ab58c0 100644
--- a/drivers/dax/dax.h
+++ b/drivers/dax/dax.h
@@ -13,12 +13,13 @@
#ifndef __DAX_H__
#define __DAX_H__
struct device;
+struct dax_dev;
struct resource;
struct dax_region;
void dax_region_put(struct dax_region *dax_region);
struct dax_region *alloc_dax_region(struct device *parent,
int region_id, struct resource *res, unsigned int align,
void *addr, unsigned long flags);
-int devm_create_dax_dev(struct dax_region *dax_region, struct resource *res,
- int count);
+struct dax_dev *devm_create_dax_dev(struct dax_region *dax_region,
+ struct resource *res, int count);
#endif /* __DAX_H__ */
diff --git a/drivers/dax/pmem.c b/drivers/dax/pmem.c
index 59b75c5972bb..c24d32ec9ce6 100644
--- a/drivers/dax/pmem.c
+++ b/drivers/dax/pmem.c
@@ -61,6 +61,7 @@ static int dax_pmem_probe(struct device *dev)
int rc;
void *addr;
struct resource res;
+ struct dax_dev *dax_dev;
struct nd_pfn_sb *pfn_sb;
struct dax_pmem *dax_pmem;
struct nd_region *nd_region;
@@ -123,12 +124,12 @@ static int dax_pmem_probe(struct device *dev)
return -ENOMEM;
/* TODO: support for subdividing a dax region... */
- rc = devm_create_dax_dev(dax_region, &res, 1);
+ dax_dev = devm_create_dax_dev(dax_region, &res, 1);
/* child dax_dev instances now own the lifetime of the dax_region */
dax_region_put(dax_region);
- return rc;
+ return PTR_ERR_OR_ZERO(dax_dev);
}
static struct nd_device_driver dax_pmem_driver = {
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH 4/4] dax: register seed device
2016-08-16 17:09 [PATCH 0/4] device-dax prepare for dynamic resize / allocate Dan Williams
` (2 preceding siblings ...)
2016-08-16 17:09 ` [PATCH 3/4] dax: convert devm_create_dax_dev to PTR_ERR Dan Williams
@ 2016-08-16 17:09 ` Dan Williams
3 siblings, 0 replies; 5+ messages in thread
From: Dan Williams @ 2016-08-16 17:09 UTC (permalink / raw)
To: linux-nvdimm; +Cc: linux-kernel
Towards adding support for sub-dividing device-dax regions, add a seed
device. Similar to libnvdimm a 'seed' device is un-configured device
that is enabled after setting configuration parameters. After a given
seed device is enabled another is created and this process repeats until
no more seed devices can be activated due to dax_available_size being
exhausted.
For now, this simply registers a seed instance after the first dax
device instance is established.
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/dax/dax.c | 41 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
diff --git a/drivers/dax/dax.c b/drivers/dax/dax.c
index cbc765c81600..51334bcb5aa7 100644
--- a/drivers/dax/dax.c
+++ b/drivers/dax/dax.c
@@ -40,8 +40,10 @@ MODULE_PARM_DESC(nr_dax, "max number of device-dax instances");
* @kref: to pin while other agents have a need to do lookups
* @lock: synchronize changes / consistent-access to the resource tree (@res)
* @dev: parent device backing this region
+ * @seed: next device for dynamic allocation / configuration
* @align: allocation and mapping alignment for child dax devices
* @res: physical address range of the region
+ * @child_count: number of registered dax device instances
* @pfn_flags: identify whether the pfns are paged back or not
*/
struct dax_region {
@@ -51,8 +53,10 @@ struct dax_region {
struct kref kref;
struct mutex lock;
struct device *dev;
+ struct device *seed;
unsigned int align;
struct resource res;
+ atomic_t child_count;
unsigned long pfn_flags;
};
@@ -111,8 +115,29 @@ static ssize_t available_size_show(struct device *dev,
}
static DEVICE_ATTR_RO(available_size);
+static ssize_t seed_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct dax_region *dax_region;
+ ssize_t rc = -ENXIO;
+
+ device_lock(dev);
+ dax_region = dev_get_drvdata(dev);
+ if (dax_region) {
+ mutex_lock(&dax_region->lock);
+ if (dax_region->seed)
+ rc = sprintf(buf, "%s\n", dev_name(dax_region->seed));
+ mutex_unlock(&dax_region->lock);
+ }
+ device_unlock(dev);
+
+ return rc;
+}
+static DEVICE_ATTR_RO(seed);
+
static struct attribute *dax_region_attributes[] = {
&dev_attr_available_size.attr,
+ &dev_attr_seed.attr,
NULL,
};
@@ -242,6 +267,9 @@ static void dax_region_free(struct kref *kref)
struct dax_region *dax_region;
dax_region = container_of(kref, struct dax_region, kref);
+ WARN(atomic_read(&dax_region->child_count),
+ "%s: child count not zero\n",
+ dev_name(dax_region->dev));
kfree(dax_region);
}
@@ -638,7 +666,10 @@ static void unregister_dax_dev(void *dev)
for (i = 0; i < dax_dev->num_resources; i++)
__release_region(&dax_region->res, dax_dev->res[i]->start,
resource_size(dax_dev->res[i]));
+ if (dax_region->seed == dev)
+ dax_region->seed = NULL;
mutex_unlock(&dax_region->lock);
+ atomic_dec(&dax_region->child_count);
cdev_del(cdev);
device_unregister(dev);
@@ -743,6 +774,16 @@ struct dax_dev *devm_create_dax_dev(struct dax_region *dax_region,
if (rc)
return ERR_PTR(rc);
+ if (atomic_inc_return(&dax_region->child_count) == 1) {
+ struct dax_dev *seed;
+
+ seed = devm_create_dax_dev(dax_region, NULL, 0);
+ if (IS_ERR(seed))
+ dev_warn(parent, "failed to create region seed\n");
+ else
+ dax_region->seed = &seed->dev;
+ }
+
return dax_dev;
err_cdev:
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm
^ permalink raw reply related [flat|nested] 5+ messages in thread
end of thread, other threads:[~2016-08-16 17:13 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-08-16 17:09 [PATCH 0/4] device-dax prepare for dynamic resize / allocate Dan Williams
2016-08-16 17:09 ` [PATCH 1/4] dax: check resource alignment at dax region/device create Dan Williams
2016-08-16 17:09 ` [PATCH 2/4] dax: add region-available-size attribute Dan Williams
2016-08-16 17:09 ` [PATCH 3/4] dax: convert devm_create_dax_dev to PTR_ERR Dan Williams
2016-08-16 17:09 ` [PATCH 4/4] dax: register seed device Dan Williams
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).