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

libnvdimm, pfn: 'struct page' provider infrastructure 



Implement the base infrastructure for libnvdimm PFN devices. Similar to
BTT devices they take a namespace as a backing device and layer
functionality on top. In this case the functionality is reserving space
for an array of 'struct page' entries to be handed out through
pfn_to_page(). For now this is just the basic libnvdimm-device-model for
configuring the base PFN device.

As the namespace claiming mechanism for PFN devices is mostly identical
to BTT devices drivers/nvdimm/claim.c is created to house the common
bits.

Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: default avatarDan Williams <dan.j.williams@intel.com>
parent 96601adb

drivers/nvdimm/Kconfig

+22 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ config BLK_DEV_PMEM 
	default LIBNVDIMM

	depends on HAS_IOMEM

	select ND_BTT if BTT

	select ND_PFN if NVDIMM_PFN

	help

	  Memory ranges for PMEM are described by either an NFIT

	  (NVDIMM Firmware Interface Table, see CONFIG_NFIT_ACPI), a
@@ -47,12 +48,16 @@ config ND_BLK 
	  (CONFIG_ACPI_NFIT), or otherwise exposes BLK-mode

	  capabilities.



config ND_CLAIM

	bool



config ND_BTT

	tristate



config BTT

	bool "BTT: Block Translation Table (atomic sector updates)"

	default y if LIBNVDIMM

	select ND_CLAIM

	help

	  The Block Translation Table (BTT) provides atomic sector

	  update semantics for persistent memory devices, so that
@@ -65,4 +70,21 @@ config BTT 


	  Select Y if unsure



config ND_PFN

	tristate



config NVDIMM_PFN

	bool "PFN: Map persistent (device) memory"

	default LIBNVDIMM

	select ND_CLAIM

	help

	  Map persistent memory, i.e. advertise it to the memory

	  management sub-system.  By default persistent memory does

	  not support direct I/O, RDMA, or any other usage that

	  requires a 'struct page' to mediate an I/O request.  This

	  driver allocates and initializes the infrastructure needed

	  to support those use cases.



	  Select Y if unsure



endif

drivers/nvdimm/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -20,4 +20,6 @@ libnvdimm-y += region_devs.o 
libnvdimm-y += region.o

libnvdimm-y += namespace_devs.o

libnvdimm-y += label.o

libnvdimm-$(CONFIG_ND_CLAIM) += claim.o

libnvdimm-$(CONFIG_BTT) += btt_devs.o

libnvdimm-$(CONFIG_NVDIMM_PFN) += pfn_devs.o

drivers/nvdimm/btt.c

+3 −3
Original line number Diff line number Diff line
@@ -731,6 +731,7 @@ static int create_arenas(struct btt *btt) 
static int btt_arena_write_layout(struct arena_info *arena)

{

	int ret;

	u64 sum;

	struct btt_sb *super;

	struct nd_btt *nd_btt = arena->nd_btt;

	const u8 *parent_uuid = nd_dev_to_uuid(&nd_btt->ndns->dev);
@@ -770,7 +771,8 @@ static int btt_arena_write_layout(struct arena_info *arena) 
	super->info2off = cpu_to_le64(arena->info2off - arena->infooff);



	super->flags = 0;

	super->checksum = cpu_to_le64(nd_btt_sb_checksum(super));

	sum = nd_sb_checksum((struct nd_gen_sb *) super);

	super->checksum = cpu_to_le64(sum);



	ret = btt_info_write(arena, super);
@@ -1422,8 +1424,6 @@ static int __init nd_btt_init(void) 
{

	int rc;



	BUILD_BUG_ON(sizeof(struct btt_sb) != SZ_4K);



	btt_major = register_blkdev(0, "btt");

	if (btt_major < 0)

		return btt_major;

drivers/nvdimm/btt_devs.c

+8 −164
Original line number Diff line number Diff line
@@ -21,63 +21,13 @@ 
#include "btt.h"

#include "nd.h"



static void __nd_btt_detach_ndns(struct nd_btt *nd_btt)

{

	struct nd_namespace_common *ndns = nd_btt->ndns;



	dev_WARN_ONCE(&nd_btt->dev, !mutex_is_locked(&ndns->dev.mutex)

			|| ndns->claim != &nd_btt->dev,

			"%s: invalid claim\n", __func__);

	ndns->claim = NULL;

	nd_btt->ndns = NULL;

	put_device(&ndns->dev);

}



static void nd_btt_detach_ndns(struct nd_btt *nd_btt)

{

	struct nd_namespace_common *ndns = nd_btt->ndns;



	if (!ndns)

		return;

	get_device(&ndns->dev);

	device_lock(&ndns->dev);

	__nd_btt_detach_ndns(nd_btt);

	device_unlock(&ndns->dev);

	put_device(&ndns->dev);

}



static bool __nd_btt_attach_ndns(struct nd_btt *nd_btt,

		struct nd_namespace_common *ndns)

{

	if (ndns->claim)

		return false;

	dev_WARN_ONCE(&nd_btt->dev, !mutex_is_locked(&ndns->dev.mutex)

			|| nd_btt->ndns,

			"%s: invalid claim\n", __func__);

	ndns->claim = &nd_btt->dev;

	nd_btt->ndns = ndns;

	get_device(&ndns->dev);

	return true;

}



static bool nd_btt_attach_ndns(struct nd_btt *nd_btt,

		struct nd_namespace_common *ndns)

{

	bool claimed;



	device_lock(&ndns->dev);

	claimed = __nd_btt_attach_ndns(nd_btt, ndns);

	device_unlock(&ndns->dev);

	return claimed;

}



static void nd_btt_release(struct device *dev)

{

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

	struct nd_btt *nd_btt = to_nd_btt(dev);



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

	nd_btt_detach_ndns(nd_btt);

	nd_detach_ndns(&nd_btt->dev, &nd_btt->ndns);

	ida_simple_remove(&nd_region->btt_ida, nd_btt->id);

	kfree(nd_btt->uuid);

	kfree(nd_btt);
@@ -172,104 +122,15 @@ static ssize_t namespace_show(struct device *dev, 
	return rc;

}



static int namespace_match(struct device *dev, void *data)

{

	char *name = data;



	return strcmp(name, dev_name(dev)) == 0;

}



static bool is_nd_btt_idle(struct device *dev)

{

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

	struct nd_btt *nd_btt = to_nd_btt(dev);



	if (nd_region->btt_seed == dev || nd_btt->ndns || dev->driver)

		return false;

	return true;

}



static ssize_t __namespace_store(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t len)

{

	struct nd_btt *nd_btt = to_nd_btt(dev);

	struct nd_namespace_common *ndns;

	struct device *found;

	char *name;



	if (dev->driver) {

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

		return -EBUSY;

	}



	name = kstrndup(buf, len, GFP_KERNEL);

	if (!name)

		return -ENOMEM;

	strim(name);



	if (strncmp(name, "namespace", 9) == 0 || strcmp(name, "") == 0)

		/* pass */;

	else {

		len = -EINVAL;

		goto out;

	}



	ndns = nd_btt->ndns;

	if (strcmp(name, "") == 0) {

		/* detach the namespace and destroy / reset the btt device */

		nd_btt_detach_ndns(nd_btt);

		if (is_nd_btt_idle(dev))

			nd_device_unregister(dev, ND_ASYNC);

		else {

			nd_btt->lbasize = 0;

			kfree(nd_btt->uuid);

			nd_btt->uuid = NULL;

		}

		goto out;

	} else if (ndns) {

		dev_dbg(dev, "namespace already set to: %s\n",

				dev_name(&ndns->dev));

		len = -EBUSY;

		goto out;

	}



	found = device_find_child(dev->parent, name, namespace_match);

	if (!found) {

		dev_dbg(dev, "'%s' not found under %s\n", name,

				dev_name(dev->parent));

		len = -ENODEV;

		goto out;

	}



	ndns = to_ndns(found);

	if (__nvdimm_namespace_capacity(ndns) < SZ_16M) {

		dev_dbg(dev, "%s too small to host btt\n", name);

		len = -ENXIO;

		goto out_attach;

	}



	WARN_ON_ONCE(!is_nvdimm_bus_locked(&nd_btt->dev));

	if (!nd_btt_attach_ndns(nd_btt, ndns)) {

		dev_dbg(dev, "%s already claimed\n",

				dev_name(&ndns->dev));

		len = -EBUSY;

	}



 out_attach:

	put_device(&ndns->dev); /* from device_find_child */

 out:

	kfree(name);

	return len;

}



static ssize_t namespace_store(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t len)

{

	struct nd_btt *nd_btt = to_nd_btt(dev);

	ssize_t rc;



	nvdimm_bus_lock(dev);

	device_lock(dev);

	rc = __namespace_store(dev, attr, buf, len);

	rc = nd_namespace_store(dev, &nd_btt->ndns, buf, len);

	dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__,

			rc, buf, buf[len - 1] == '\n' ? "" : "\n");

	device_unlock(dev);
@@ -324,7 +185,7 @@ static struct device *__nd_btt_create(struct nd_region *nd_region, 
	dev->type = &nd_btt_device_type;

	dev->groups = nd_btt_attribute_groups;

	device_initialize(&nd_btt->dev);

	if (ndns && !__nd_btt_attach_ndns(nd_btt, ndns)) {

	if (ndns && !__nd_attach_ndns(&nd_btt->dev, ndns, &nd_btt->ndns)) {

		dev_dbg(&ndns->dev, "%s failed, already claimed by %s\n",

				__func__, dev_name(ndns->claim));

		put_device(dev);
@@ -375,7 +236,7 @@ bool nd_btt_arena_is_valid(struct nd_btt *nd_btt, struct btt_sb *super) 


	checksum = le64_to_cpu(super->checksum);

	super->checksum = 0;

	if (checksum != nd_btt_sb_checksum(super))

	if (checksum != nd_sb_checksum((struct nd_gen_sb *) super))

		return false;

	super->checksum = cpu_to_le64(checksum);
@@ -387,25 +248,6 @@ bool nd_btt_arena_is_valid(struct nd_btt *nd_btt, struct btt_sb *super) 
}

EXPORT_SYMBOL(nd_btt_arena_is_valid);



/*

 * nd_btt_sb_checksum: compute checksum for btt info block

 *

 * Returns a fletcher64 checksum of everything in the given info block

 * except the last field (since that's where the checksum lives).

 */

u64 nd_btt_sb_checksum(struct btt_sb *btt_sb)

{

	u64 sum;

	__le64 sum_save;



	sum_save = btt_sb->checksum;

	btt_sb->checksum = 0;

	sum = nd_fletcher64(btt_sb, sizeof(*btt_sb), 1);

	btt_sb->checksum = sum_save;

	return sum;

}

EXPORT_SYMBOL(nd_btt_sb_checksum);



static int __nd_btt_probe(struct nd_btt *nd_btt,

		struct nd_namespace_common *ndns, struct btt_sb *btt_sb)

{
@@ -453,7 +295,9 @@ int nd_btt_probe(struct nd_namespace_common *ndns, void *drvdata) 
	dev_dbg(&ndns->dev, "%s: btt: %s\n", __func__,

			rc == 0 ? dev_name(dev) : "<none>");

	if (rc < 0) {

		__nd_btt_detach_ndns(to_nd_btt(dev));

		struct nd_btt *nd_btt = to_nd_btt(dev);



		__nd_detach_ndns(dev, &nd_btt->ndns);

		put_device(dev);

	}

drivers/nvdimm/claim.c

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

 * 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/sizes.h>

#include "nd-core.h"

#include "pfn.h"

#include "btt.h"

#include "nd.h"



void __nd_detach_ndns(struct device *dev, struct nd_namespace_common **_ndns)

{

	struct nd_namespace_common *ndns = *_ndns;



	dev_WARN_ONCE(dev, !mutex_is_locked(&ndns->dev.mutex)

			|| ndns->claim != dev,

			"%s: invalid claim\n", __func__);

	ndns->claim = NULL;

	*_ndns = NULL;

	put_device(&ndns->dev);

}



void nd_detach_ndns(struct device *dev,

		struct nd_namespace_common **_ndns)

{

	struct nd_namespace_common *ndns = *_ndns;



	if (!ndns)

		return;

	get_device(&ndns->dev);

	device_lock(&ndns->dev);

	__nd_detach_ndns(dev, _ndns);

	device_unlock(&ndns->dev);

	put_device(&ndns->dev);

}



bool __nd_attach_ndns(struct device *dev, struct nd_namespace_common *attach,

		struct nd_namespace_common **_ndns)

{

	if (attach->claim)

		return false;

	dev_WARN_ONCE(dev, !mutex_is_locked(&attach->dev.mutex)

			|| *_ndns,

			"%s: invalid claim\n", __func__);

	attach->claim = dev;

	*_ndns = attach;

	get_device(&attach->dev);

	return true;

}



bool nd_attach_ndns(struct device *dev, struct nd_namespace_common *attach,

		struct nd_namespace_common **_ndns)

{

	bool claimed;



	device_lock(&attach->dev);

	claimed = __nd_attach_ndns(dev, attach, _ndns);

	device_unlock(&attach->dev);

	return claimed;

}



static int namespace_match(struct device *dev, void *data)

{

	char *name = data;



	return strcmp(name, dev_name(dev)) == 0;

}



static bool is_idle(struct device *dev, struct nd_namespace_common *ndns)

{

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

	struct device *seed = NULL;



	if (is_nd_btt(dev))

		seed = nd_region->btt_seed;

	else if (is_nd_pfn(dev))

		seed = nd_region->pfn_seed;



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

		return false;

	return true;

}



static void nd_detach_and_reset(struct device *dev,

		struct nd_namespace_common **_ndns)

{

	/* detach the namespace and destroy / reset the device */

	nd_detach_ndns(dev, _ndns);

	if (is_idle(dev, *_ndns)) {

		nd_device_unregister(dev, ND_ASYNC);

	} else if (is_nd_btt(dev)) {

		struct nd_btt *nd_btt = to_nd_btt(dev);



		nd_btt->lbasize = 0;

		kfree(nd_btt->uuid);

		nd_btt->uuid = NULL;

	} else if (is_nd_pfn(dev)) {

		struct nd_pfn *nd_pfn = to_nd_pfn(dev);



		kfree(nd_pfn->uuid);

		nd_pfn->uuid = NULL;

		nd_pfn->mode = PFN_MODE_NONE;

	}

}



ssize_t nd_namespace_store(struct device *dev,

		struct nd_namespace_common **_ndns, const char *buf,

		size_t len)

{

	struct nd_namespace_common *ndns;

	struct device *found;

	char *name;



	if (dev->driver) {

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

		return -EBUSY;

	}



	name = kstrndup(buf, len, GFP_KERNEL);

	if (!name)

		return -ENOMEM;

	strim(name);



	if (strncmp(name, "namespace", 9) == 0 || strcmp(name, "") == 0)

		/* pass */;

	else {

		len = -EINVAL;

		goto out;

	}



	ndns = *_ndns;

	if (strcmp(name, "") == 0) {

		nd_detach_and_reset(dev, _ndns);

		goto out;

	} else if (ndns) {

		dev_dbg(dev, "namespace already set to: %s\n",

				dev_name(&ndns->dev));

		len = -EBUSY;

		goto out;

	}



	found = device_find_child(dev->parent, name, namespace_match);

	if (!found) {

		dev_dbg(dev, "'%s' not found under %s\n", name,

				dev_name(dev->parent));

		len = -ENODEV;

		goto out;

	}



	ndns = to_ndns(found);

	if (__nvdimm_namespace_capacity(ndns) < SZ_16M) {

		dev_dbg(dev, "%s too small to host\n", name);

		len = -ENXIO;

		goto out_attach;

	}



	WARN_ON_ONCE(!is_nvdimm_bus_locked(dev));

	if (!nd_attach_ndns(dev, ndns, _ndns)) {

		dev_dbg(dev, "%s already claimed\n",

				dev_name(&ndns->dev));

		len = -EBUSY;

	}



 out_attach:

	put_device(&ndns->dev); /* from device_find_child */

 out:

	kfree(name);

	return len;

}



/*

 * nd_sb_checksum: compute checksum for a generic info block

 *

 * Returns a fletcher64 checksum of everything in the given info block

 * except the last field (since that's where the checksum lives).

 */

u64 nd_sb_checksum(struct nd_gen_sb *nd_gen_sb)

{

	u64 sum;

	__le64 sum_save;



	BUILD_BUG_ON(sizeof(struct btt_sb) != SZ_4K);

	BUILD_BUG_ON(sizeof(struct nd_pfn_sb) != SZ_4K);

	BUILD_BUG_ON(sizeof(struct nd_gen_sb) != SZ_4K);



	sum_save = nd_gen_sb->checksum;

	nd_gen_sb->checksum = 0;

	sum = nd_fletcher64(nd_gen_sb, sizeof(*nd_gen_sb), 1);

	nd_gen_sb->checksum = sum_save;

	return sum;

}

EXPORT_SYMBOL(nd_sb_checksum);

CRA Git | Maintained and supported by SUSTech CRA and CCSE