Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cd03412a authored by Dan Williams's avatar Dan Williams
Browse files

libnvdimm, dax: introduce device-dax infrastructure 



Device DAX is the device-centric analogue of Filesystem DAX
(CONFIG_FS_DAX).  It allows persistent memory ranges to be allocated and
mapped without need of an intervening file system.  This initial
infrastructure arranges for a libnvdimm pfn-device to be represented as
a different device-type so that it can be attached to a driver other
than the pmem driver.

Signed-off-by: default avatarDan Williams <dan.j.williams@intel.com>
parent 0bfb8dd3

drivers/nvdimm/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -88,4 +88,17 @@ config NVDIMM_PFN 


	  Select Y if unsure



config NVDIMM_DAX

	bool "NVDIMM DAX: Raw access to persistent memory"

	default LIBNVDIMM

	depends on NVDIMM_PFN

	help

	  Support raw device dax access to a persistent memory

	  namespace.  For environments that want to hard partition

	  peristent memory, this capability provides a mechanism to

	  sub-divide a namespace into character devices that can only be

	  accessed via DAX (mmap(2)).



	  Select Y if unsure



endif

drivers/nvdimm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -23,3 +23,4 @@ libnvdimm-y += label.o 
libnvdimm-$(CONFIG_ND_CLAIM) += claim.o

libnvdimm-$(CONFIG_BTT) += btt_devs.o

libnvdimm-$(CONFIG_NVDIMM_PFN) += pfn_devs.o

libnvdimm-$(CONFIG_NVDIMM_DAX) += dax_devs.o

drivers/nvdimm/bus.c

+4 −0
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ static int to_nd_device_type(struct device *dev) 
		return ND_DEVICE_REGION_PMEM;

	else if (is_nd_blk(dev))

		return ND_DEVICE_REGION_BLK;

	else if (is_nd_dax(dev))

		return ND_DEVICE_DAX_PMEM;

	else if (is_nd_pmem(dev->parent) || is_nd_blk(dev->parent))

		return nd_region_to_nstype(to_nd_region(dev->parent));
@@ -246,6 +248,8 @@ static void nd_async_device_unregister(void *d, async_cookie_t cookie) 


void __nd_device_register(struct device *dev)

{

	if (!dev)

		return;

	dev->bus = &nvdimm_bus_type;

	get_device(dev);

	async_schedule_domain(nd_async_device_register, dev,

drivers/nvdimm/claim.c

+2 −0
Original line number Diff line number Diff line
@@ -85,6 +85,8 @@ static bool is_idle(struct device *dev, struct nd_namespace_common *ndns) 
		seed = nd_region->btt_seed;

	else if (is_nd_pfn(dev))

		seed = nd_region->pfn_seed;

	else if (is_nd_dax(dev))

		seed = nd_region->dax_seed;



	if (seed == dev || ndns || dev->driver)

		return false;

drivers/nvdimm/dax_devs.c

0 → 100644
+99 −0
Original line number Diff line number Diff line 
/*

 * Copyright(c) 2013-2016 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/sizes.h>

#include <linux/slab.h>

#include <linux/mm.h>

#include "nd-core.h"

#include "nd.h"



static void nd_dax_release(struct device *dev)

{

	struct nd_region *nd_region = to_nd_region(dev->parent);

	struct nd_dax *nd_dax = to_nd_dax(dev);

	struct nd_pfn *nd_pfn = &nd_dax->nd_pfn;



	dev_dbg(dev, "%s\n", __func__);

	nd_detach_ndns(dev, &nd_pfn->ndns);

	ida_simple_remove(&nd_region->dax_ida, nd_pfn->id);

	kfree(nd_pfn->uuid);

	kfree(nd_dax);

}



static struct device_type nd_dax_device_type = {

	.name = "nd_dax",

	.release = nd_dax_release,

};



bool is_nd_dax(struct device *dev)

{

	return dev ? dev->type == &nd_dax_device_type : false;

}

EXPORT_SYMBOL(is_nd_dax);



struct nd_dax *to_nd_dax(struct device *dev)

{

	struct nd_dax *nd_dax = container_of(dev, struct nd_dax, nd_pfn.dev);



	WARN_ON(!is_nd_dax(dev));

	return nd_dax;

}

EXPORT_SYMBOL(to_nd_dax);



static const struct attribute_group *nd_dax_attribute_groups[] = {

	&nd_pfn_attribute_group,

	&nd_device_attribute_group,

	&nd_numa_attribute_group,

	NULL,

};



static struct nd_dax *nd_dax_alloc(struct nd_region *nd_region)

{

	struct nd_pfn *nd_pfn;

	struct nd_dax *nd_dax;

	struct device *dev;



	nd_dax = kzalloc(sizeof(*nd_dax), GFP_KERNEL);

	if (!nd_dax)

		return NULL;



	nd_pfn = &nd_dax->nd_pfn;

	nd_pfn->id = ida_simple_get(&nd_region->dax_ida, 0, 0, GFP_KERNEL);

	if (nd_pfn->id < 0) {

		kfree(nd_dax);

		return NULL;

	}



	dev = &nd_pfn->dev;

	dev_set_name(dev, "dax%d.%d", nd_region->id, nd_pfn->id);

	dev->groups = nd_dax_attribute_groups;

	dev->type = &nd_dax_device_type;

	dev->parent = &nd_region->dev;



	return nd_dax;

}



struct device *nd_dax_create(struct nd_region *nd_region)

{

	struct device *dev = NULL;

	struct nd_dax *nd_dax;



	if (!is_nd_pmem(&nd_region->dev))

		return NULL;



	nd_dax = nd_dax_alloc(nd_region);

	if (nd_dax)

		dev = nd_pfn_devinit(&nd_dax->nd_pfn, NULL);

	__nd_device_register(dev);

	return dev;

}