[deliverable/linux.git] / drivers / nvdimm / core.c

/*
 * 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/libnvdimm.h>
#include <linux/export.h>
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/device.h>
#include <linux/ctype.h>
#include <linux/ndctl.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include "nd-core.h"
#include "nd.h"

LIST_HEAD(nvdimm_bus_list);
DEFINE_MUTEX(nvdimm_bus_list_mutex);
static DEFINE_IDA(nd_ida);

void nvdimm_bus_lock(struct device *dev)
{
	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);

	if (!nvdimm_bus)
		return;
	mutex_lock(&nvdimm_bus->reconfig_mutex);
}
EXPORT_SYMBOL(nvdimm_bus_lock);

void nvdimm_bus_unlock(struct device *dev)
{
	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);

	if (!nvdimm_bus)
		return;
	mutex_unlock(&nvdimm_bus->reconfig_mutex);
}
EXPORT_SYMBOL(nvdimm_bus_unlock);

bool is_nvdimm_bus_locked(struct device *dev)
{
	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);

	if (!nvdimm_bus)
		return false;
	return mutex_is_locked(&nvdimm_bus->reconfig_mutex);
}
EXPORT_SYMBOL(is_nvdimm_bus_locked);

u64 nd_fletcher64(void *addr, size_t len, bool le)
{
	u32 *buf = addr;
	u32 lo32 = 0;
	u64 hi32 = 0;
	int i;

	for (i = 0; i < len / sizeof(u32); i++) {
		lo32 += le ? le32_to_cpu((__le32) buf[i]) : buf[i];
		hi32 += lo32;
	}

	return hi32 << 32 | lo32;
}
EXPORT_SYMBOL_GPL(nd_fletcher64);

static void nvdimm_bus_release(struct device *dev)
{
	struct nvdimm_bus *nvdimm_bus;

	nvdimm_bus = container_of(dev, struct nvdimm_bus, dev);
	ida_simple_remove(&nd_ida, nvdimm_bus->id);
	kfree(nvdimm_bus);
}

struct nvdimm_bus *to_nvdimm_bus(struct device *dev)
{
	struct nvdimm_bus *nvdimm_bus;

	nvdimm_bus = container_of(dev, struct nvdimm_bus, dev);
	WARN_ON(nvdimm_bus->dev.release != nvdimm_bus_release);
	return nvdimm_bus;
}
EXPORT_SYMBOL_GPL(to_nvdimm_bus);

struct nvdimm_bus_descriptor *to_nd_desc(struct nvdimm_bus *nvdimm_bus)
{
	/* struct nvdimm_bus definition is private to libnvdimm */
	return nvdimm_bus->nd_desc;
}
EXPORT_SYMBOL_GPL(to_nd_desc);

struct nvdimm_bus *walk_to_nvdimm_bus(struct device *nd_dev)
{
	struct device *dev;

	for (dev = nd_dev; dev; dev = dev->parent)
		if (dev->release == nvdimm_bus_release)
			break;
	dev_WARN_ONCE(nd_dev, !dev, "invalid dev, not on nd bus\n");
	if (dev)
		return to_nvdimm_bus(dev);
	return NULL;
}

static bool is_uuid_sep(char sep)
{
	if (sep == '\n' || sep == '-' || sep == ':' || sep == '\0')
		return true;
	return false;
}

static int nd_uuid_parse(struct device *dev, u8 *uuid_out, const char *buf,
		size_t len)
{
	const char *str = buf;
	u8 uuid[16];
	int i;

	for (i = 0; i < 16; i++) {
		if (!isxdigit(str[0]) || !isxdigit(str[1])) {
			dev_dbg(dev, "%s: pos: %d buf[%zd]: %c buf[%zd]: %c\n",
					__func__, i, str - buf, str[0],
					str + 1 - buf, str[1]);
			return -EINVAL;
		}

		uuid[i] = (hex_to_bin(str[0]) << 4) | hex_to_bin(str[1]);
		str += 2;
		if (is_uuid_sep(*str))
			str++;
	}

	memcpy(uuid_out, uuid, sizeof(uuid));
	return 0;
}

/**
 * nd_uuid_store: common implementation for writing 'uuid' sysfs attributes
 * @dev: container device for the uuid property
 * @uuid_out: uuid buffer to replace
 * @buf: raw sysfs buffer to parse
 *
 * Enforce that uuids can only be changed while the device is disabled
 * (driver detached)
 * LOCKING: expects device_lock() is held on entry
 */
int nd_uuid_store(struct device *dev, u8 **uuid_out, const char *buf,
		size_t len)
{
	u8 uuid[16];
	int rc;

	if (dev->driver)
		return -EBUSY;

	rc = nd_uuid_parse(dev, uuid, buf, len);
	if (rc)
		return rc;

	kfree(*uuid_out);
	*uuid_out = kmemdup(uuid, sizeof(uuid), GFP_KERNEL);
	if (!(*uuid_out))
		return -ENOMEM;

	return 0;
}

ssize_t nd_sector_size_show(unsigned long current_lbasize,
		const unsigned long *supported, char *buf)
{
	ssize_t len = 0;
	int i;

	for (i = 0; supported[i]; i++)
		if (current_lbasize == supported[i])
			len += sprintf(buf + len, "[%ld] ", supported[i]);
		else
			len += sprintf(buf + len, "%ld ", supported[i]);
	len += sprintf(buf + len, "\n");
	return len;
}

ssize_t nd_sector_size_store(struct device *dev, const char *buf,
		unsigned long *current_lbasize, const unsigned long *supported)
{
	unsigned long lbasize;
	int rc, i;

	if (dev->driver)
		return -EBUSY;

	rc = kstrtoul(buf, 0, &lbasize);
	if (rc)
		return rc;

	for (i = 0; supported[i]; i++)
		if (lbasize == supported[i])
			break;

	if (supported[i]) {
		*current_lbasize = lbasize;
		return 0;
	} else {
		return -EINVAL;
	}
}

void __nd_iostat_start(struct bio *bio, unsigned long *start)
{
	struct gendisk *disk = bio->bi_bdev->bd_disk;
	const int rw = bio_data_dir(bio);
	int cpu = part_stat_lock();

	*start = jiffies;
	part_round_stats(cpu, &disk->part0);
	part_stat_inc(cpu, &disk->part0, ios[rw]);
	part_stat_add(cpu, &disk->part0, sectors[rw], bio_sectors(bio));
	part_inc_in_flight(&disk->part0, rw);
	part_stat_unlock();
}
EXPORT_SYMBOL(__nd_iostat_start);

void nd_iostat_end(struct bio *bio, unsigned long start)
{
	struct gendisk *disk = bio->bi_bdev->bd_disk;
	unsigned long duration = jiffies - start;
	const int rw = bio_data_dir(bio);
	int cpu = part_stat_lock();

	part_stat_add(cpu, &disk->part0, ticks[rw], duration);
	part_round_stats(cpu, &disk->part0);
	part_dec_in_flight(&disk->part0, rw);
	part_stat_unlock();
}
EXPORT_SYMBOL(nd_iostat_end);

static ssize_t commands_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	int cmd, len = 0;
	struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
	struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;

	for_each_set_bit(cmd, &nd_desc->dsm_mask, BITS_PER_LONG)
		len += sprintf(buf + len, "%s ", nvdimm_bus_cmd_name(cmd));
	len += sprintf(buf + len, "\n");
	return len;
}
static DEVICE_ATTR_RO(commands);

static const char *nvdimm_bus_provider(struct nvdimm_bus *nvdimm_bus)
{
	struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
	struct device *parent = nvdimm_bus->dev.parent;

	if (nd_desc->provider_name)
		return nd_desc->provider_name;
	else if (parent)
		return dev_name(parent);
	else
		return "unknown";
}

static ssize_t provider_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);

	return sprintf(buf, "%s\n", nvdimm_bus_provider(nvdimm_bus));
}
static DEVICE_ATTR_RO(provider);

static int flush_namespaces(struct device *dev, void *data)
{
	device_lock(dev);
	device_unlock(dev);
	return 0;
}

static int flush_regions_dimms(struct device *dev, void *data)
{
	device_lock(dev);
	device_unlock(dev);
	device_for_each_child(dev, NULL, flush_namespaces);
	return 0;
}

static ssize_t wait_probe_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	nd_synchronize();
	device_for_each_child(dev, NULL, flush_regions_dimms);
	return sprintf(buf, "1\n");
}
static DEVICE_ATTR_RO(wait_probe);

static struct attribute *nvdimm_bus_attributes[] = {
	&dev_attr_commands.attr,
	&dev_attr_wait_probe.attr,
	&dev_attr_provider.attr,
	NULL,
};

struct attribute_group nvdimm_bus_attribute_group = {
	.attrs = nvdimm_bus_attributes,
};
EXPORT_SYMBOL_GPL(nvdimm_bus_attribute_group);

struct nvdimm_bus *__nvdimm_bus_register(struct device *parent,
		struct nvdimm_bus_descriptor *nd_desc, struct module *module)
{
	struct nvdimm_bus *nvdimm_bus;
	int rc;

	nvdimm_bus = kzalloc(sizeof(*nvdimm_bus), GFP_KERNEL);
	if (!nvdimm_bus)
		return NULL;
	INIT_LIST_HEAD(&nvdimm_bus->list);
	init_waitqueue_head(&nvdimm_bus->probe_wait);
	nvdimm_bus->id = ida_simple_get(&nd_ida, 0, 0, GFP_KERNEL);
	mutex_init(&nvdimm_bus->reconfig_mutex);
	if (nvdimm_bus->id < 0) {
		kfree(nvdimm_bus);
		return NULL;
	}
	nvdimm_bus->nd_desc = nd_desc;
	nvdimm_bus->module = module;
	nvdimm_bus->dev.parent = parent;
	nvdimm_bus->dev.release = nvdimm_bus_release;
	nvdimm_bus->dev.groups = nd_desc->attr_groups;
	dev_set_name(&nvdimm_bus->dev, "ndbus%d", nvdimm_bus->id);
	rc = device_register(&nvdimm_bus->dev);
	if (rc) {
		dev_dbg(&nvdimm_bus->dev, "registration failed: %d\n", rc);
		goto err;
	}

	rc = nvdimm_bus_create_ndctl(nvdimm_bus);
	if (rc)
		goto err;

	mutex_lock(&nvdimm_bus_list_mutex);
	list_add_tail(&nvdimm_bus->list, &nvdimm_bus_list);
	mutex_unlock(&nvdimm_bus_list_mutex);

	return nvdimm_bus;
 err:
	put_device(&nvdimm_bus->dev);
	return NULL;
}
EXPORT_SYMBOL_GPL(__nvdimm_bus_register);

static int child_unregister(struct device *dev, void *data)
{
	/*
	 * the singular ndctl class device per bus needs to be
	 * "device_destroy"ed, so skip it here
	 *
	 * i.e. remove classless children
	 */
	if (dev->class)
		/* pass */;
	else
		nd_device_unregister(dev, ND_SYNC);
	return 0;
}

void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus)
{
	if (!nvdimm_bus)
		return;

	mutex_lock(&nvdimm_bus_list_mutex);
	list_del_init(&nvdimm_bus->list);
	mutex_unlock(&nvdimm_bus_list_mutex);

	nd_synchronize();
	device_for_each_child(&nvdimm_bus->dev, NULL, child_unregister);
	nvdimm_bus_destroy_ndctl(nvdimm_bus);

	device_unregister(&nvdimm_bus->dev);
}
EXPORT_SYMBOL_GPL(nvdimm_bus_unregister);

#ifdef CONFIG_BLK_DEV_INTEGRITY
int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
{
	struct blk_integrity bi;

	if (meta_size == 0)
		return 0;

	bi.profile = NULL;
	bi.tuple_size = meta_size;
	bi.tag_size = meta_size;

	blk_integrity_register(disk, &bi);
	blk_queue_max_integrity_segments(disk->queue, 1);

	return 0;
}
EXPORT_SYMBOL(nd_integrity_init);

#else /* CONFIG_BLK_DEV_INTEGRITY */
int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
{
	return 0;
}
EXPORT_SYMBOL(nd_integrity_init);

#endif

static __init int libnvdimm_init(void)
{
	int rc;

	rc = nvdimm_bus_init();
	if (rc)
		return rc;
	rc = nvdimm_init();
	if (rc)
		goto err_dimm;
	rc = nd_region_init();
	if (rc)
		goto err_region;
	return 0;
 err_region:
	nvdimm_exit();
 err_dimm:
	nvdimm_bus_exit();
	return rc;
}

static __exit void libnvdimm_exit(void)
{
	WARN_ON(!list_empty(&nvdimm_bus_list));
	nd_region_exit();
	nvdimm_exit();
	nvdimm_bus_exit();
}

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Intel Corporation");
subsys_initcall(libnvdimm_init);
module_exit(libnvdimm_exit);
Commit	Line	Data
b94d5230 DW	1	/*
	2	* Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of version 2 of the GNU General Public License as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* General Public License for more details.
	12	*/
	13	#include <linux/libnvdimm.h>
	14	#include <linux/export.h>
	15	#include <linux/module.h>
41cd8b70	16	#include <linux/blkdev.h>
b94d5230	17	#include <linux/device.h>
bf9bccc1	18	#include <linux/ctype.h>
62232e45	19	#include <linux/ndctl.h>
45def22c	20	#include <linux/mutex.h>
b94d5230 DW	21	#include <linux/slab.h>
b94d5230 DW	22	#include "nd-core.h"
4d88a97a	23	#include "nd.h"
b94d5230	24
e6dfb2de DW	25	LIST_HEAD(nvdimm_bus_list);
e6dfb2de DW	26	DEFINE_MUTEX(nvdimm_bus_list_mutex);
b94d5230 DW	27	static DEFINE_IDA(nd_ida);
b94d5230 DW	28
3d88002e DW	29	void nvdimm_bus_lock(struct device *dev)
	30	{
	31	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
	32
	33	if (!nvdimm_bus)
	34	return;
	35	mutex_lock(&nvdimm_bus->reconfig_mutex);
	36	}
	37	EXPORT_SYMBOL(nvdimm_bus_lock);
	38
	39	void nvdimm_bus_unlock(struct device *dev)
	40	{
	41	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
	42
	43	if (!nvdimm_bus)
	44	return;
	45	mutex_unlock(&nvdimm_bus->reconfig_mutex);
	46	}
	47	EXPORT_SYMBOL(nvdimm_bus_unlock);
	48
	49	bool is_nvdimm_bus_locked(struct device *dev)
	50	{
	51	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
	52
	53	if (!nvdimm_bus)
	54	return false;
	55	return mutex_is_locked(&nvdimm_bus->reconfig_mutex);
	56	}
	57	EXPORT_SYMBOL(is_nvdimm_bus_locked);
	58
eaf96153 DW	59	u64 nd_fletcher64(void *addr, size_t len, bool le)
	60	{
	61	u32 *buf = addr;
	62	u32 lo32 = 0;
	63	u64 hi32 = 0;
	64	int i;
	65
	66	for (i = 0; i < len / sizeof(u32); i++) {
	67	lo32 += le ? le32_to_cpu((__le32) buf[i]) : buf[i];
	68	hi32 += lo32;
	69	}
	70
	71	return hi32 << 32 \| lo32;
	72	}
	73	EXPORT_SYMBOL_GPL(nd_fletcher64);
	74
b94d5230 DW	75	static void nvdimm_bus_release(struct device *dev)
	76	{
	77	struct nvdimm_bus *nvdimm_bus;
	78
	79	nvdimm_bus = container_of(dev, struct nvdimm_bus, dev);
	80	ida_simple_remove(&nd_ida, nvdimm_bus->id);
	81	kfree(nvdimm_bus);
	82	}
	83
45def22c DW	84	struct nvdimm_bus to_nvdimm_bus(struct device dev)
	85	{
	86	struct nvdimm_bus *nvdimm_bus;
	87
	88	nvdimm_bus = container_of(dev, struct nvdimm_bus, dev);
	89	WARN_ON(nvdimm_bus->dev.release != nvdimm_bus_release);
	90	return nvdimm_bus;
	91	}
	92	EXPORT_SYMBOL_GPL(to_nvdimm_bus);
	93
	94	struct nvdimm_bus_descriptor to_nd_desc(struct nvdimm_bus nvdimm_bus)
	95	{
	96	/* struct nvdimm_bus definition is private to libnvdimm */
	97	return nvdimm_bus->nd_desc;
	98	}
	99	EXPORT_SYMBOL_GPL(to_nd_desc);
	100
e6dfb2de DW	101	struct nvdimm_bus walk_to_nvdimm_bus(struct device nd_dev)
	102	{
	103	struct device *dev;
	104
	105	for (dev = nd_dev; dev; dev = dev->parent)
	106	if (dev->release == nvdimm_bus_release)
	107	break;
	108	dev_WARN_ONCE(nd_dev, !dev, "invalid dev, not on nd bus\n");
	109	if (dev)
	110	return to_nvdimm_bus(dev);
	111	return NULL;
	112	}
	113
bf9bccc1 DW	114	static bool is_uuid_sep(char sep)
	115	{
	116	if (sep == '\n' \|\| sep == '-' \|\| sep == ':' \|\| sep == '\0')
	117	return true;
	118	return false;
	119	}
	120
	121	static int nd_uuid_parse(struct device dev, u8 uuid_out, const char *buf,
	122	size_t len)
	123	{
	124	const char *str = buf;
	125	u8 uuid[16];
	126	int i;
	127
	128	for (i = 0; i < 16; i++) {
	129	if (!isxdigit(str[0]) \|\| !isxdigit(str[1])) {
	130	dev_dbg(dev, "%s: pos: %d buf[%zd]: %c buf[%zd]: %c\n",
	131	__func__, i, str - buf, str[0],
	132	str + 1 - buf, str[1]);
	133	return -EINVAL;
	134	}
	135
	136	uuid[i] = (hex_to_bin(str[0]) << 4) \| hex_to_bin(str[1]);
	137	str += 2;
	138	if (is_uuid_sep(*str))
	139	str++;
	140	}
	141
	142	memcpy(uuid_out, uuid, sizeof(uuid));
	143	return 0;
	144	}
	145
	146	/**
	147	* nd_uuid_store: common implementation for writing 'uuid' sysfs attributes
	148	* @dev: container device for the uuid property
	149	* @uuid_out: uuid buffer to replace
	150	* @buf: raw sysfs buffer to parse
	151	*
	152	* Enforce that uuids can only be changed while the device is disabled
	153	* (driver detached)
	154	* LOCKING: expects device_lock() is held on entry
	155	*/
	156	int nd_uuid_store(struct device dev, u8 uuid_out, const char buf,
	157	size_t len)
	158	{
	159	u8 uuid[16];
	160	int rc;
	161
	162	if (dev->driver)
	163	return -EBUSY;
	164
	165	rc = nd_uuid_parse(dev, uuid, buf, len);
	166	if (rc)
	167	return rc;
	168
	169	kfree(*uuid_out);
	170	*uuid_out = kmemdup(uuid, sizeof(uuid), GFP_KERNEL);
	171	if (!(*uuid_out))
	172	return -ENOMEM;
	173
	174	return 0;
	175	}
	176
1b40e09a DW	177	ssize_t nd_sector_size_show(unsigned long current_lbasize,
	178	const unsigned long supported, char buf)
	179	{
	180	ssize_t len = 0;
	181	int i;
	182
	183	for (i = 0; supported[i]; i++)
	184	if (current_lbasize == supported[i])
	185	len += sprintf(buf + len, "[%ld] ", supported[i]);
	186	else
	187	len += sprintf(buf + len, "%ld ", supported[i]);
	188	len += sprintf(buf + len, "\n");
	189	return len;
	190	}
	191
	192	ssize_t nd_sector_size_store(struct device dev, const char buf,
	193	unsigned long current_lbasize, const unsigned long supported)
	194	{
	195	unsigned long lbasize;
	196	int rc, i;
	197
	198	if (dev->driver)
	199	return -EBUSY;
	200
	201	rc = kstrtoul(buf, 0, &lbasize);
	202	if (rc)
	203	return rc;
	204
	205	for (i = 0; supported[i]; i++)
	206	if (lbasize == supported[i])
	207	break;
	208
	209	if (supported[i]) {
	210	*current_lbasize = lbasize;
	211	return 0;
	212	} else {
	213	return -EINVAL;
	214	}
	215	}
	216
f0dc089c DW	217	void __nd_iostat_start(struct bio bio, unsigned long start)
	218	{
	219	struct gendisk *disk = bio->bi_bdev->bd_disk;
	220	const int rw = bio_data_dir(bio);
	221	int cpu = part_stat_lock();
	222
	223	*start = jiffies;
	224	part_round_stats(cpu, &disk->part0);
	225	part_stat_inc(cpu, &disk->part0, ios[rw]);
	226	part_stat_add(cpu, &disk->part0, sectors[rw], bio_sectors(bio));
	227	part_inc_in_flight(&disk->part0, rw);
	228	part_stat_unlock();
	229	}
	230	EXPORT_SYMBOL(__nd_iostat_start);
	231
	232	void nd_iostat_end(struct bio *bio, unsigned long start)
	233	{
	234	struct gendisk *disk = bio->bi_bdev->bd_disk;
	235	unsigned long duration = jiffies - start;
	236	const int rw = bio_data_dir(bio);
	237	int cpu = part_stat_lock();
	238
	239	part_stat_add(cpu, &disk->part0, ticks[rw], duration);
	240	part_round_stats(cpu, &disk->part0);
	241	part_dec_in_flight(&disk->part0, rw);
	242	part_stat_unlock();
	243	}
	244	EXPORT_SYMBOL(nd_iostat_end);
	245
62232e45 DW	246	static ssize_t commands_show(struct device *dev,
	247	struct device_attribute attr, char buf)
	248	{
	249	int cmd, len = 0;
	250	struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
	251	struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
	252
	253	for_each_set_bit(cmd, &nd_desc->dsm_mask, BITS_PER_LONG)
	254	len += sprintf(buf + len, "%s ", nvdimm_bus_cmd_name(cmd));
	255	len += sprintf(buf + len, "\n");
	256	return len;
	257	}
	258	static DEVICE_ATTR_RO(commands);
	259
45def22c DW	260	static const char nvdimm_bus_provider(struct nvdimm_bus nvdimm_bus)
	261	{
	262	struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
	263	struct device *parent = nvdimm_bus->dev.parent;
	264
	265	if (nd_desc->provider_name)
	266	return nd_desc->provider_name;
	267	else if (parent)
	268	return dev_name(parent);
	269	else
	270	return "unknown";
	271	}
	272
	273	static ssize_t provider_show(struct device *dev,
	274	struct device_attribute attr, char buf)
	275	{
	276	struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
	277
	278	return sprintf(buf, "%s\n", nvdimm_bus_provider(nvdimm_bus));
	279	}
	280	static DEVICE_ATTR_RO(provider);
	281
4d88a97a DW	282	static int flush_namespaces(struct device dev, void data)
	283	{
	284	device_lock(dev);
	285	device_unlock(dev);
	286	return 0;
	287	}
	288
	289	static int flush_regions_dimms(struct device dev, void data)
	290	{
	291	device_lock(dev);
	292	device_unlock(dev);
	293	device_for_each_child(dev, NULL, flush_namespaces);
	294	return 0;
	295	}
	296
	297	static ssize_t wait_probe_show(struct device *dev,
	298	struct device_attribute attr, char buf)
	299	{
	300	nd_synchronize();
	301	device_for_each_child(dev, NULL, flush_regions_dimms);
	302	return sprintf(buf, "1\n");
	303	}
	304	static DEVICE_ATTR_RO(wait_probe);
	305
45def22c	306	static struct attribute *nvdimm_bus_attributes[] = {
62232e45	307	&dev_attr_commands.attr,
4d88a97a	308	&dev_attr_wait_probe.attr,
45def22c DW	309	&dev_attr_provider.attr,
	310	NULL,
	311	};
	312
	313	struct attribute_group nvdimm_bus_attribute_group = {
	314	.attrs = nvdimm_bus_attributes,
	315	};
	316	EXPORT_SYMBOL_GPL(nvdimm_bus_attribute_group);
	317
3d88002e DW	318	struct nvdimm_bus __nvdimm_bus_register(struct device parent,
3d88002e DW	319	struct nvdimm_bus_descriptor nd_desc, struct module module)
b94d5230 DW	320	{
	321	struct nvdimm_bus *nvdimm_bus;
	322	int rc;
	323
	324	nvdimm_bus = kzalloc(sizeof(*nvdimm_bus), GFP_KERNEL);
	325	if (!nvdimm_bus)
	326	return NULL;
45def22c	327	INIT_LIST_HEAD(&nvdimm_bus->list);
eaf96153	328	init_waitqueue_head(&nvdimm_bus->probe_wait);
b94d5230	329	nvdimm_bus->id = ida_simple_get(&nd_ida, 0, 0, GFP_KERNEL);
3d88002e	330	mutex_init(&nvdimm_bus->reconfig_mutex);
b94d5230 DW	331	if (nvdimm_bus->id < 0) {
	332	kfree(nvdimm_bus);
	333	return NULL;
	334	}
	335	nvdimm_bus->nd_desc = nd_desc;
3d88002e	336	nvdimm_bus->module = module;
b94d5230 DW	337	nvdimm_bus->dev.parent = parent;
b94d5230 DW	338	nvdimm_bus->dev.release = nvdimm_bus_release;
45def22c	339	nvdimm_bus->dev.groups = nd_desc->attr_groups;
b94d5230 DW	340	dev_set_name(&nvdimm_bus->dev, "ndbus%d", nvdimm_bus->id);
	341	rc = device_register(&nvdimm_bus->dev);
	342	if (rc) {
	343	dev_dbg(&nvdimm_bus->dev, "registration failed: %d\n", rc);
45def22c	344	goto err;
b94d5230 DW	345	}
b94d5230 DW	346
45def22c DW	347	rc = nvdimm_bus_create_ndctl(nvdimm_bus);
	348	if (rc)
	349	goto err;
	350
	351	mutex_lock(&nvdimm_bus_list_mutex);
	352	list_add_tail(&nvdimm_bus->list, &nvdimm_bus_list);
	353	mutex_unlock(&nvdimm_bus_list_mutex);
	354
b94d5230	355	return nvdimm_bus;
45def22c DW	356	err:
	357	put_device(&nvdimm_bus->dev);
	358	return NULL;
b94d5230	359	}
3d88002e	360	EXPORT_SYMBOL_GPL(__nvdimm_bus_register);
b94d5230	361
e6dfb2de DW	362	static int child_unregister(struct device dev, void data)
	363	{
	364	/*
	365	* the singular ndctl class device per bus needs to be
	366	* "device_destroy"ed, so skip it here
	367	*
	368	* i.e. remove classless children
	369	*/
	370	if (dev->class)
	371	/* pass */;
	372	else
4d88a97a	373	nd_device_unregister(dev, ND_SYNC);
e6dfb2de DW	374	return 0;
	375	}
	376
b94d5230 DW	377	void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus)
	378	{
	379	if (!nvdimm_bus)
	380	return;
45def22c DW	381
	382	mutex_lock(&nvdimm_bus_list_mutex);
	383	list_del_init(&nvdimm_bus->list);
	384	mutex_unlock(&nvdimm_bus_list_mutex);
	385
4d88a97a	386	nd_synchronize();
e6dfb2de	387	device_for_each_child(&nvdimm_bus->dev, NULL, child_unregister);
45def22c DW	388	nvdimm_bus_destroy_ndctl(nvdimm_bus);
45def22c DW	389
b94d5230 DW	390	device_unregister(&nvdimm_bus->dev);
	391	}
	392	EXPORT_SYMBOL_GPL(nvdimm_bus_unregister);
	393
41cd8b70	394	#ifdef CONFIG_BLK_DEV_INTEGRITY
41cd8b70 VV	395	int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
41cd8b70 VV	396	{
0f8087ec	397	struct blk_integrity bi;
41cd8b70	398
fcae6957 VV	399	if (meta_size == 0)
	400	return 0;
	401
4125a09b	402	bi.profile = NULL;
0f8087ec MP	403	bi.tuple_size = meta_size;
	404	bi.tag_size = meta_size;
	405
25520d55	406	blk_integrity_register(disk, &bi);
41cd8b70 VV	407	blk_queue_max_integrity_segments(disk->queue, 1);
	408
	409	return 0;
	410	}
	411	EXPORT_SYMBOL(nd_integrity_init);
	412
	413	#else /* CONFIG_BLK_DEV_INTEGRITY */
	414	int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
	415	{
	416	return 0;
	417	}
	418	EXPORT_SYMBOL(nd_integrity_init);
	419
	420	#endif
	421
45def22c DW	422	static __init int libnvdimm_init(void)
45def22c DW	423	{
4d88a97a DW	424	int rc;
	425
	426	rc = nvdimm_bus_init();
	427	if (rc)
	428	return rc;
	429	rc = nvdimm_init();
	430	if (rc)
	431	goto err_dimm;
3d88002e DW	432	rc = nd_region_init();
	433	if (rc)
	434	goto err_region;
4d88a97a	435	return 0;
3d88002e DW	436	err_region:
3d88002e DW	437	nvdimm_exit();
4d88a97a DW	438	err_dimm:
	439	nvdimm_bus_exit();
	440	return rc;
45def22c DW	441	}
	442
	443	static __exit void libnvdimm_exit(void)
	444	{
	445	WARN_ON(!list_empty(&nvdimm_bus_list));
3d88002e	446	nd_region_exit();
4d88a97a	447	nvdimm_exit();
45def22c DW	448	nvdimm_bus_exit();
	449	}
	450
b94d5230 DW	451	MODULE_LICENSE("GPL v2");
b94d5230 DW	452	MODULE_AUTHOR("Intel Corporation");
45def22c DW	453	subsys_initcall(libnvdimm_init);
45def22c DW	454	module_exit(libnvdimm_exit);