[deliverable/linux.git] / drivers / nvdimm / label.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/device.h>
#include <linux/ndctl.h>
#include <linux/io.h>
#include <linux/nd.h>
#include "nd-core.h"
#include "label.h"
#include "nd.h"

static u32 best_seq(u32 a, u32 b)
{
	a &= NSINDEX_SEQ_MASK;
	b &= NSINDEX_SEQ_MASK;

	if (a == 0 || a == b)
		return b;
	else if (b == 0)
		return a;
	else if (nd_inc_seq(a) == b)
		return b;
	else
		return a;
}

size_t sizeof_namespace_index(struct nvdimm_drvdata *ndd)
{
	u32 index_span;

	if (ndd->nsindex_size)
		return ndd->nsindex_size;

	/*
	 * The minimum index space is 512 bytes, with that amount of
	 * index we can describe ~1400 labels which is less than a byte
	 * of overhead per label.  Round up to a byte of overhead per
	 * label and determine the size of the index region.  Yes, this
	 * starts to waste space at larger config_sizes, but it's
	 * unlikely we'll ever see anything but 128K.
	 */
	index_span = ndd->nsarea.config_size / 129;
	index_span /= NSINDEX_ALIGN * 2;
	ndd->nsindex_size = index_span * NSINDEX_ALIGN;

	return ndd->nsindex_size;
}

int nd_label_validate(struct nvdimm_drvdata *ndd)
{
	/*
	 * On media label format consists of two index blocks followed
	 * by an array of labels.  None of these structures are ever
	 * updated in place.  A sequence number tracks the current
	 * active index and the next one to write, while labels are
	 * written to free slots.
	 *
	 *     +------------+
	 *     |            |
	 *     |  nsindex0  |
	 *     |            |
	 *     +------------+
	 *     |            |
	 *     |  nsindex1  |
	 *     |            |
	 *     +------------+
	 *     |   label0   |
	 *     +------------+
	 *     |   label1   |
	 *     +------------+
	 *     |            |
	 *      ....nslot...
	 *     |            |
	 *     +------------+
	 *     |   labelN   |
	 *     +------------+
	 */
	struct nd_namespace_index *nsindex[] = {
		to_namespace_index(ndd, 0),
		to_namespace_index(ndd, 1),
	};
	const int num_index = ARRAY_SIZE(nsindex);
	struct device *dev = ndd->dev;
	bool valid[2] = { 0 };
	int i, num_valid = 0;
	u32 seq;

	for (i = 0; i < num_index; i++) {
		u32 nslot;
		u8 sig[NSINDEX_SIG_LEN];
		u64 sum_save, sum, size;

		memcpy(sig, nsindex[i]->sig, NSINDEX_SIG_LEN);
		if (memcmp(sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN) != 0) {
			dev_dbg(dev, "%s: nsindex%d signature invalid\n",
					__func__, i);
			continue;
		}
		sum_save = __le64_to_cpu(nsindex[i]->checksum);
		nsindex[i]->checksum = __cpu_to_le64(0);
		sum = nd_fletcher64(nsindex[i], sizeof_namespace_index(ndd), 1);
		nsindex[i]->checksum = __cpu_to_le64(sum_save);
		if (sum != sum_save) {
			dev_dbg(dev, "%s: nsindex%d checksum invalid\n",
					__func__, i);
			continue;
		}

		seq = __le32_to_cpu(nsindex[i]->seq);
		if ((seq & NSINDEX_SEQ_MASK) == 0) {
			dev_dbg(dev, "%s: nsindex%d sequence: %#x invalid\n",
					__func__, i, seq);
			continue;
		}

		/* sanity check the index against expected values */
		if (__le64_to_cpu(nsindex[i]->myoff)
				!= i * sizeof_namespace_index(ndd)) {
			dev_dbg(dev, "%s: nsindex%d myoff: %#llx invalid\n",
					__func__, i, (unsigned long long)
					__le64_to_cpu(nsindex[i]->myoff));
			continue;
		}
		if (__le64_to_cpu(nsindex[i]->otheroff)
				!= (!i) * sizeof_namespace_index(ndd)) {
			dev_dbg(dev, "%s: nsindex%d otheroff: %#llx invalid\n",
					__func__, i, (unsigned long long)
					__le64_to_cpu(nsindex[i]->otheroff));
			continue;
		}

		size = __le64_to_cpu(nsindex[i]->mysize);
		if (size > sizeof_namespace_index(ndd)
				|| size < sizeof(struct nd_namespace_index)) {
			dev_dbg(dev, "%s: nsindex%d mysize: %#llx invalid\n",
					__func__, i, size);
			continue;
		}

		nslot = __le32_to_cpu(nsindex[i]->nslot);
		if (nslot * sizeof(struct nd_namespace_label)
				+ 2 * sizeof_namespace_index(ndd)
				> ndd->nsarea.config_size) {
			dev_dbg(dev, "%s: nsindex%d nslot: %u invalid, config_size: %#x\n",
					__func__, i, nslot,
					ndd->nsarea.config_size);
			continue;
		}
		valid[i] = true;
		num_valid++;
	}

	switch (num_valid) {
	case 0:
		break;
	case 1:
		for (i = 0; i < num_index; i++)
			if (valid[i])
				return i;
		/* can't have num_valid > 0 but valid[] = { false, false } */
		WARN_ON(1);
		break;
	default:
		/* pick the best index... */
		seq = best_seq(__le32_to_cpu(nsindex[0]->seq),
				__le32_to_cpu(nsindex[1]->seq));
		if (seq == (__le32_to_cpu(nsindex[1]->seq) & NSINDEX_SEQ_MASK))
			return 1;
		else
			return 0;
		break;
	}

	return -1;
}

void nd_label_copy(struct nvdimm_drvdata *ndd, struct nd_namespace_index *dst,
		struct nd_namespace_index *src)
{
	if (dst && src)
		/* pass */;
	else
		return;

	memcpy(dst, src, sizeof_namespace_index(ndd));
}

static struct nd_namespace_label *nd_label_base(struct nvdimm_drvdata *ndd)
{
	void *base = to_namespace_index(ndd, 0);

	return base + 2 * sizeof_namespace_index(ndd);
}

#define for_each_clear_bit_le(bit, addr, size) \
	for ((bit) = find_next_zero_bit_le((addr), (size), 0);  \
	     (bit) < (size);                                    \
	     (bit) = find_next_zero_bit_le((addr), (size), (bit) + 1))

/**
 * preamble_current - common variable initialization for nd_label_* routines
 * @ndd: dimm container for the relevant label set
 * @nsindex_out: on return set to the currently active namespace index
 * @free: on return set to the free label bitmap in the index
 * @nslot: on return set to the number of slots in the label space
 */
static bool preamble_current(struct nvdimm_drvdata *ndd,
		struct nd_namespace_index **nsindex_out,
		unsigned long **free, u32 *nslot)
{
	struct nd_namespace_index *nsindex;

	nsindex = to_current_namespace_index(ndd);
	if (nsindex == NULL)
		return false;

	*free = (unsigned long *) nsindex->free;
	*nslot = __le32_to_cpu(nsindex->nslot);
	*nsindex_out = nsindex;

	return true;
}

static char *nd_label_gen_id(struct nd_label_id *label_id, u8 *uuid, u32 flags)
{
	if (!label_id || !uuid)
		return NULL;
	snprintf(label_id->id, ND_LABEL_ID_SIZE, "%s-%pUb",
			flags & NSLABEL_FLAG_LOCAL ? "blk" : "pmem", uuid);
	return label_id->id;
}

static bool slot_valid(struct nd_namespace_label *nd_label, u32 slot)
{
	/* check that we are written where we expect to be written */
	if (slot != __le32_to_cpu(nd_label->slot))
		return false;

	/* check that DPA allocations are page aligned */
	if ((__le64_to_cpu(nd_label->dpa)
				| __le64_to_cpu(nd_label->rawsize)) % SZ_4K)
		return false;

	return true;
}

int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd)
{
	struct nd_namespace_index *nsindex;
	unsigned long *free;
	u32 nslot, slot;

	if (!preamble_current(ndd, &nsindex, &free, &nslot))
		return 0; /* no label, nothing to reserve */

	for_each_clear_bit_le(slot, free, nslot) {
		struct nd_namespace_label *nd_label;
		struct nd_region *nd_region = NULL;
		u8 label_uuid[NSLABEL_UUID_LEN];
		struct nd_label_id label_id;
		struct resource *res;
		u32 flags;

		nd_label = nd_label_base(ndd) + slot;

		if (!slot_valid(nd_label, slot))
			continue;

		memcpy(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN);
		flags = __le32_to_cpu(nd_label->flags);
		nd_label_gen_id(&label_id, label_uuid, flags);
		res = nvdimm_allocate_dpa(ndd, &label_id,
				__le64_to_cpu(nd_label->dpa),
				__le64_to_cpu(nd_label->rawsize));
		nd_dbg_dpa(nd_region, ndd, res, "reserve\n");
		if (!res)
			return -EBUSY;
	}

	return 0;
}
Commit	Line	Data
4a826c83 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/device.h>
	14	#include <linux/ndctl.h>
	15	#include <linux/io.h>
	16	#include <linux/nd.h>
	17	#include "nd-core.h"
	18	#include "label.h"
	19	#include "nd.h"
	20
	21	static u32 best_seq(u32 a, u32 b)
	22	{
	23	a &= NSINDEX_SEQ_MASK;
	24	b &= NSINDEX_SEQ_MASK;
	25
	26	if (a == 0 \|\| a == b)
	27	return b;
	28	else if (b == 0)
	29	return a;
	30	else if (nd_inc_seq(a) == b)
	31	return b;
	32	else
	33	return a;
	34	}
	35
	36	size_t sizeof_namespace_index(struct nvdimm_drvdata *ndd)
	37	{
	38	u32 index_span;
	39
	40	if (ndd->nsindex_size)
	41	return ndd->nsindex_size;
	42
	43	/*
	44	* The minimum index space is 512 bytes, with that amount of
	45	* index we can describe ~1400 labels which is less than a byte
	46	* of overhead per label. Round up to a byte of overhead per
	47	* label and determine the size of the index region. Yes, this
	48	* starts to waste space at larger config_sizes, but it's
	49	* unlikely we'll ever see anything but 128K.
	50	*/
	51	index_span = ndd->nsarea.config_size / 129;
	52	index_span /= NSINDEX_ALIGN * 2;
	53	ndd->nsindex_size = index_span * NSINDEX_ALIGN;
	54
	55	return ndd->nsindex_size;
	56	}
	57
	58	int nd_label_validate(struct nvdimm_drvdata *ndd)
	59	{
	60	/*
	61	* On media label format consists of two index blocks followed
	62	* by an array of labels. None of these structures are ever
	63	* updated in place. A sequence number tracks the current
	64	* active index and the next one to write, while labels are
65	* written to free slots.
66	*
67	* +------------+
68	* \| \|
69	* \| nsindex0 \|
70	* \| \|
71	* +------------+
72	* \| \|
73	* \| nsindex1 \|
74	* \| \|
75	* +------------+
76	* \| label0 \|
77	* +------------+
78	* \| label1 \|
79	* +------------+
80	* \| \|
81	* ....nslot...
82	* \| \|
83	* +------------+
84	* \| labelN \|
85	* +------------+
86	*/
87	struct nd_namespace_index *nsindex[] = {
88	to_namespace_index(ndd, 0),
89	to_namespace_index(ndd, 1),
90	};
91	const int num_index = ARRAY_SIZE(nsindex);
92	struct device *dev = ndd->dev;
93	bool valid[2] = { 0 };
94	int i, num_valid = 0;
95	u32 seq;
96
97	for (i = 0; i < num_index; i++) {
98	u32 nslot;
99	u8 sig[NSINDEX_SIG_LEN];
100	u64 sum_save, sum, size;
101
102	memcpy(sig, nsindex[i]->sig, NSINDEX_SIG_LEN);
103	if (memcmp(sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN) != 0) {
104	dev_dbg(dev, "%s: nsindex%d signature invalid\n",
105	__func__, i);
106	continue;
107	}
108	sum_save = __le64_to_cpu(nsindex[i]->checksum);
109	nsindex[i]->checksum = __cpu_to_le64(0);
110	sum = nd_fletcher64(nsindex[i], sizeof_namespace_index(ndd), 1);
111	nsindex[i]->checksum = __cpu_to_le64(sum_save);
112	if (sum != sum_save) {
113	dev_dbg(dev, "%s: nsindex%d checksum invalid\n",
114	__func__, i);
115	continue;
116	}
117
118	seq = __le32_to_cpu(nsindex[i]->seq);
119	if ((seq & NSINDEX_SEQ_MASK) == 0) {
120	dev_dbg(dev, "%s: nsindex%d sequence: %#x invalid\n",
121	__func__, i, seq);
122	continue;
123	}
124
125	/* sanity check the index against expected values */
126	if (__le64_to_cpu(nsindex[i]->myoff)
127	!= i * sizeof_namespace_index(ndd)) {
128	dev_dbg(dev, "%s: nsindex%d myoff: %#llx invalid\n",
129	__func__, i, (unsigned long long)
130	__le64_to_cpu(nsindex[i]->myoff));
131	continue;
132	}
133	if (__le64_to_cpu(nsindex[i]->otheroff)
134	!= (!i) * sizeof_namespace_index(ndd)) {
135	dev_dbg(dev, "%s: nsindex%d otheroff: %#llx invalid\n",
136	__func__, i, (unsigned long long)
137	__le64_to_cpu(nsindex[i]->otheroff));
138	continue;
139	}
140
141	size = __le64_to_cpu(nsindex[i]->mysize);
142	if (size > sizeof_namespace_index(ndd)
143	\|\| size < sizeof(struct nd_namespace_index)) {
144	dev_dbg(dev, "%s: nsindex%d mysize: %#llx invalid\n",
145	__func__, i, size);
146	continue;
147	}
148
149	nslot = __le32_to_cpu(nsindex[i]->nslot);
150	if (nslot * sizeof(struct nd_namespace_label)
151	+ 2 * sizeof_namespace_index(ndd)
152	> ndd->nsarea.config_size) {
153	dev_dbg(dev, "%s: nsindex%d nslot: %u invalid, config_size: %#x\n",
154	__func__, i, nslot,
155	ndd->nsarea.config_size);
156	continue;
157	}
158	valid[i] = true;
159	num_valid++;
160	}
161
162	switch (num_valid) {
163	case 0:
164	break;
165	case 1:
166	for (i = 0; i < num_index; i++)
167	if (valid[i])
168	return i;
169	/* can't have num_valid > 0 but valid[] = { false, false } */
170	WARN_ON(1);
171	break;
172	default:
173	/* pick the best index... */
174	seq = best_seq(__le32_to_cpu(nsindex[0]->seq),
175	__le32_to_cpu(nsindex[1]->seq));
176	if (seq == (__le32_to_cpu(nsindex[1]->seq) & NSINDEX_SEQ_MASK))
177	return 1;
178	else
179	return 0;
180	break;
181	}
182
183	return -1;
184	}
185
186	void nd_label_copy(struct nvdimm_drvdata ndd, struct nd_namespace_index dst,
187	struct nd_namespace_index *src)
188	{
189	if (dst && src)
190	/* pass */;
191	else
192	return;
193
194	memcpy(dst, src, sizeof_namespace_index(ndd));
195	}
196
197	static struct nd_namespace_label nd_label_base(struct nvdimm_drvdata ndd)
198	{
199	void *base = to_namespace_index(ndd, 0);
200
201	return base + 2 * sizeof_namespace_index(ndd);
202	}
203
204	#define for_each_clear_bit_le(bit, addr, size) \
205	for ((bit) = find_next_zero_bit_le((addr), (size), 0); \
206	(bit) < (size); \
207	(bit) = find_next_zero_bit_le((addr), (size), (bit) + 1))
208
209	/**
210	* preamble_current - common variable initialization for nd_label_* routines
211	* @ndd: dimm container for the relevant label set
212	* @nsindex_out: on return set to the currently active namespace index
213	* @free: on return set to the free label bitmap in the index
214	* @nslot: on return set to the number of slots in the label space
215	*/
216	static bool preamble_current(struct nvdimm_drvdata *ndd,
217	struct nd_namespace_index **nsindex_out,
218	unsigned long *free, u32 nslot)
219	{
220	struct nd_namespace_index *nsindex;
221
222	nsindex = to_current_namespace_index(ndd);
223	if (nsindex == NULL)
224	return false;
225
226	free = (unsigned long ) nsindex->free;
227	*nslot = __le32_to_cpu(nsindex->nslot);
228	*nsindex_out = nsindex;
229
230	return true;
231	}
232
233	static char nd_label_gen_id(struct nd_label_id label_id, u8 *uuid, u32 flags)
234	{
235	if (!label_id \|\| !uuid)
236	return NULL;
237	snprintf(label_id->id, ND_LABEL_ID_SIZE, "%s-%pUb",
238	flags & NSLABEL_FLAG_LOCAL ? "blk" : "pmem", uuid);
239	return label_id->id;
240	}
241
242	static bool slot_valid(struct nd_namespace_label *nd_label, u32 slot)
243	{
244	/* check that we are written where we expect to be written */
245	if (slot != __le32_to_cpu(nd_label->slot))
246	return false;
247
248	/* check that DPA allocations are page aligned */
249	if ((__le64_to_cpu(nd_label->dpa)
250	\| __le64_to_cpu(nd_label->rawsize)) % SZ_4K)
251	return false;
252
253	return true;
254	}
255
256	int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd)
257	{
258	struct nd_namespace_index *nsindex;
259	unsigned long *free;
260	u32 nslot, slot;
261
262	if (!preamble_current(ndd, &nsindex, &free, &nslot))
263	return 0; /* no label, nothing to reserve */
264
265	for_each_clear_bit_le(slot, free, nslot) {
266	struct nd_namespace_label *nd_label;
267	struct nd_region *nd_region = NULL;
268	u8 label_uuid[NSLABEL_UUID_LEN];
269	struct nd_label_id label_id;
270	struct resource *res;
271	u32 flags;
272
273	nd_label = nd_label_base(ndd) + slot;
274
275	if (!slot_valid(nd_label, slot))
276	continue;
277
278	memcpy(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN);
279	flags = __le32_to_cpu(nd_label->flags);
280	nd_label_gen_id(&label_id, label_uuid, flags);
281	res = nvdimm_allocate_dpa(ndd, &label_id,
282	__le64_to_cpu(nd_label->dpa),
283	__le64_to_cpu(nd_label->rawsize));
284	nd_dbg_dpa(nd_region, ndd, res, "reserve\n");
285	if (!res)
286	return -EBUSY;
287	}
288
289	return 0;
290	}