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/blkdev.h>
 14#include <linux/device.h>
 15#include <linux/genhd.h>
 16#include <linux/sizes.h>
 17#include <linux/slab.h>
 18#include <linux/fs.h>
 19#include <linux/mm.h>
 20#include "nd-core.h"
 21#include "btt.h"
 22#include "nd.h"
 23
 24static void nd_btt_release(struct device *dev)
 25{
 26	struct nd_region *nd_region = to_nd_region(dev->parent);
 27	struct nd_btt *nd_btt = to_nd_btt(dev);
 28
 29	dev_dbg(dev, "%s\n", __func__);
 30	nd_detach_ndns(&nd_btt->dev, &nd_btt->ndns);
 31	ida_simple_remove(&nd_region->btt_ida, nd_btt->id);
 32	kfree(nd_btt->uuid);
 33	kfree(nd_btt);
 34}
 35
 36static struct device_type nd_btt_device_type = {
 37	.name = "nd_btt",
 38	.release = nd_btt_release,
 39};
 40
 41bool is_nd_btt(struct device *dev)
 42{
 43	return dev->type == &nd_btt_device_type;
 44}
 45EXPORT_SYMBOL(is_nd_btt);
 46
 47struct nd_btt *to_nd_btt(struct device *dev)
 48{
 49	struct nd_btt *nd_btt = container_of(dev, struct nd_btt, dev);
 50
 51	WARN_ON(!is_nd_btt(dev));
 52	return nd_btt;
 53}
 54EXPORT_SYMBOL(to_nd_btt);
 55
 56static const unsigned long btt_lbasize_supported[] = { 512, 520, 528,
 57	4096, 4104, 4160, 4224, 0 };
 58
 59static ssize_t sector_size_show(struct device *dev,
 60		struct device_attribute *attr, char *buf)
 61{
 62	struct nd_btt *nd_btt = to_nd_btt(dev);
 63
 64	return nd_sector_size_show(nd_btt->lbasize, btt_lbasize_supported, buf);
 65}
 66
 67static ssize_t sector_size_store(struct device *dev,
 68		struct device_attribute *attr, const char *buf, size_t len)
 69{
 70	struct nd_btt *nd_btt = to_nd_btt(dev);
 71	ssize_t rc;
 72
 73	device_lock(dev);
 74	nvdimm_bus_lock(dev);
 75	rc = nd_sector_size_store(dev, buf, &nd_btt->lbasize,
 76			btt_lbasize_supported);
 77	dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__,
 78			rc, buf, buf[len - 1] == '\n' ? "" : "\n");
 79	nvdimm_bus_unlock(dev);
 80	device_unlock(dev);
 81
 82	return rc ? rc : len;
 83}
 84static DEVICE_ATTR_RW(sector_size);
 85
 86static ssize_t uuid_show(struct device *dev,
 87		struct device_attribute *attr, char *buf)
 88{
 89	struct nd_btt *nd_btt = to_nd_btt(dev);
 90
 91	if (nd_btt->uuid)
 92		return sprintf(buf, "%pUb\n", nd_btt->uuid);
 93	return sprintf(buf, "\n");
 94}
 95
 96static ssize_t uuid_store(struct device *dev,
 97		struct device_attribute *attr, const char *buf, size_t len)
 98{
 99	struct nd_btt *nd_btt = to_nd_btt(dev);
100	ssize_t rc;
101
102	device_lock(dev);
103	rc = nd_uuid_store(dev, &nd_btt->uuid, buf, len);
104	dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__,
105			rc, buf, buf[len - 1] == '\n' ? "" : "\n");
106	device_unlock(dev);
107
108	return rc ? rc : len;
109}
110static DEVICE_ATTR_RW(uuid);
111
112static ssize_t namespace_show(struct device *dev,
113		struct device_attribute *attr, char *buf)
114{
115	struct nd_btt *nd_btt = to_nd_btt(dev);
116	ssize_t rc;
117
118	nvdimm_bus_lock(dev);
119	rc = sprintf(buf, "%s\n", nd_btt->ndns
120			? dev_name(&nd_btt->ndns->dev) : "");
121	nvdimm_bus_unlock(dev);
122	return rc;
123}
124
125static ssize_t namespace_store(struct device *dev,
126		struct device_attribute *attr, const char *buf, size_t len)
127{
128	struct nd_btt *nd_btt = to_nd_btt(dev);
129	ssize_t rc;
130
131	device_lock(dev);
132	nvdimm_bus_lock(dev);
133	rc = nd_namespace_store(dev, &nd_btt->ndns, buf, len);
134	dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__,
135			rc, buf, buf[len - 1] == '\n' ? "" : "\n");
136	nvdimm_bus_unlock(dev);
137	device_unlock(dev);
138
139	return rc;
140}
141static DEVICE_ATTR_RW(namespace);
142
143static ssize_t size_show(struct device *dev,
144		struct device_attribute *attr, char *buf)
145{
146	struct nd_btt *nd_btt = to_nd_btt(dev);
147	ssize_t rc;
148
149	device_lock(dev);
150	if (dev->driver)
151		rc = sprintf(buf, "%llu\n", nd_btt->size);
152	else {
153		/* no size to convey if the btt instance is disabled */
154		rc = -ENXIO;
155	}
156	device_unlock(dev);
157
158	return rc;
159}
160static DEVICE_ATTR_RO(size);
161
162static struct attribute *nd_btt_attributes[] = {
163	&dev_attr_sector_size.attr,
164	&dev_attr_namespace.attr,
165	&dev_attr_uuid.attr,
166	&dev_attr_size.attr,
167	NULL,
168};
169
170static struct attribute_group nd_btt_attribute_group = {
171	.attrs = nd_btt_attributes,
172};
173
174static const struct attribute_group *nd_btt_attribute_groups[] = {
175	&nd_btt_attribute_group,
176	&nd_device_attribute_group,
177	&nd_numa_attribute_group,
178	NULL,
179};
180
181static struct device *__nd_btt_create(struct nd_region *nd_region,
182		unsigned long lbasize, u8 *uuid,
183		struct nd_namespace_common *ndns)
184{
185	struct nd_btt *nd_btt;
186	struct device *dev;
187
188	nd_btt = kzalloc(sizeof(*nd_btt), GFP_KERNEL);
189	if (!nd_btt)
190		return NULL;
191
192	nd_btt->id = ida_simple_get(&nd_region->btt_ida, 0, 0, GFP_KERNEL);
193	if (nd_btt->id < 0) {
194		kfree(nd_btt);
195		return NULL;
196	}
197
198	nd_btt->lbasize = lbasize;
199	if (uuid)
200		uuid = kmemdup(uuid, 16, GFP_KERNEL);
201	nd_btt->uuid = uuid;
202	dev = &nd_btt->dev;
203	dev_set_name(dev, "btt%d.%d", nd_region->id, nd_btt->id);
204	dev->parent = &nd_region->dev;
205	dev->type = &nd_btt_device_type;
206	dev->groups = nd_btt_attribute_groups;
207	device_initialize(&nd_btt->dev);
208	if (ndns && !__nd_attach_ndns(&nd_btt->dev, ndns, &nd_btt->ndns)) {
209		dev_dbg(&ndns->dev, "%s failed, already claimed by %s\n",
210				__func__, dev_name(ndns->claim));
211		put_device(dev);
212		return NULL;
213	}
214	return dev;
215}
216
217struct device *nd_btt_create(struct nd_region *nd_region)
218{
219	struct device *dev = __nd_btt_create(nd_region, 0, NULL, NULL);
220
221	__nd_device_register(dev);
222	return dev;
223}
224
225static bool uuid_is_null(u8 *uuid)
226{
227	static const u8 null_uuid[16];
228
229	return (memcmp(uuid, null_uuid, 16) == 0);
230}
231
232/**
233 * nd_btt_arena_is_valid - check if the metadata layout is valid
234 * @nd_btt:	device with BTT geometry and backing device info
235 * @super:	pointer to the arena's info block being tested
236 *
237 * Check consistency of the btt info block with itself by validating
238 * the checksum, and with the parent namespace by verifying the
239 * parent_uuid contained in the info block with the one supplied in.
240 *
241 * Returns:
242 * false for an invalid info block, true for a valid one
243 */
244bool nd_btt_arena_is_valid(struct nd_btt *nd_btt, struct btt_sb *super)
245{
246	const u8 *parent_uuid = nd_dev_to_uuid(&nd_btt->ndns->dev);
247	u64 checksum;
248
249	if (memcmp(super->signature, BTT_SIG, BTT_SIG_LEN) != 0)
250		return false;
251
252	if (!uuid_is_null(super->parent_uuid))
253		if (memcmp(super->parent_uuid, parent_uuid, 16) != 0)
254			return false;
255
256	checksum = le64_to_cpu(super->checksum);
257	super->checksum = 0;
258	if (checksum != nd_sb_checksum((struct nd_gen_sb *) super))
259		return false;
260	super->checksum = cpu_to_le64(checksum);
261
262	/* TODO: figure out action for this */
263	if ((le32_to_cpu(super->flags) & IB_FLAG_ERROR_MASK) != 0)
264		dev_info(&nd_btt->dev, "Found arena with an error flag\n");
265
266	return true;
267}
268EXPORT_SYMBOL(nd_btt_arena_is_valid);
269
270static int __nd_btt_probe(struct nd_btt *nd_btt,
271		struct nd_namespace_common *ndns, struct btt_sb *btt_sb)
272{
273	if (!btt_sb || !ndns || !nd_btt)
274		return -ENODEV;
275
276	if (nvdimm_read_bytes(ndns, SZ_4K, btt_sb, sizeof(*btt_sb)))
277		return -ENXIO;
278
279	if (nvdimm_namespace_capacity(ndns) < SZ_16M)
280		return -ENXIO;
281
282	if (!nd_btt_arena_is_valid(nd_btt, btt_sb))
283		return -ENODEV;
284
285	nd_btt->lbasize = le32_to_cpu(btt_sb->external_lbasize);
286	nd_btt->uuid = kmemdup(btt_sb->uuid, 16, GFP_KERNEL);
287	if (!nd_btt->uuid)
288		return -ENOMEM;
289
290	__nd_device_register(&nd_btt->dev);
291
292	return 0;
293}
294
295int nd_btt_probe(struct device *dev, struct nd_namespace_common *ndns)
296{
297	int rc;
298	struct device *btt_dev;
299	struct btt_sb *btt_sb;
300	struct nd_region *nd_region = to_nd_region(ndns->dev.parent);
301
302	if (ndns->force_raw)
303		return -ENODEV;
304
305	nvdimm_bus_lock(&ndns->dev);
306	btt_dev = __nd_btt_create(nd_region, 0, NULL, ndns);
307	nvdimm_bus_unlock(&ndns->dev);
308	if (!btt_dev)
309		return -ENOMEM;
310	btt_sb = devm_kzalloc(dev, sizeof(*btt_sb), GFP_KERNEL);
311	rc = __nd_btt_probe(to_nd_btt(btt_dev), ndns, btt_sb);
312	dev_dbg(dev, "%s: btt: %s\n", __func__,
313			rc == 0 ? dev_name(btt_dev) : "<none>");
314	if (rc < 0) {
315		struct nd_btt *nd_btt = to_nd_btt(btt_dev);
316
317		__nd_detach_ndns(btt_dev, &nd_btt->ndns);
318		put_device(btt_dev);
319	}
320
321	return rc;
322}
323EXPORT_SYMBOL(nd_btt_probe);