2 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
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.
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.
13 #include <linux/device.h>
14 #include <linux/ndctl.h>
15 #include <linux/slab.h>
22 static u32 best_seq(u32 a, u32 b)
24 a &= NSINDEX_SEQ_MASK;
25 b &= NSINDEX_SEQ_MASK;
31 else if (nd_inc_seq(a) == b)
37 size_t sizeof_namespace_index(struct nvdimm_drvdata *ndd)
41 if (ndd->nsindex_size)
42 return ndd->nsindex_size;
45 * The minimum index space is 512 bytes, with that amount of
46 * index we can describe ~1400 labels which is less than a byte
47 * of overhead per label. Round up to a byte of overhead per
48 * label and determine the size of the index region. Yes, this
49 * starts to waste space at larger config_sizes, but it's
50 * unlikely we'll ever see anything but 128K.
52 index_span = ndd->nsarea.config_size / 129;
53 index_span /= NSINDEX_ALIGN * 2;
54 ndd->nsindex_size = index_span * NSINDEX_ALIGN;
56 return ndd->nsindex_size;
59 static int nvdimm_num_label_slots(struct nvdimm_drvdata *ndd)
61 return ndd->nsarea.config_size / 129;
64 int nd_label_validate(struct nvdimm_drvdata *ndd)
67 * On media label format consists of two index blocks followed
68 * by an array of labels. None of these structures are ever
69 * updated in place. A sequence number tracks the current
70 * active index and the next one to write, while labels are
71 * written to free slots.
93 struct nd_namespace_index *nsindex[] = {
94 to_namespace_index(ndd, 0),
95 to_namespace_index(ndd, 1),
97 const int num_index = ARRAY_SIZE(nsindex);
98 struct device *dev = ndd->dev;
99 bool valid[2] = { 0 };
100 int i, num_valid = 0;
103 for (i = 0; i < num_index; i++) {
105 u8 sig[NSINDEX_SIG_LEN];
106 u64 sum_save, sum, size;
108 memcpy(sig, nsindex[i]->sig, NSINDEX_SIG_LEN);
109 if (memcmp(sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN) != 0) {
110 dev_dbg(dev, "%s: nsindex%d signature invalid\n",
114 sum_save = __le64_to_cpu(nsindex[i]->checksum);
115 nsindex[i]->checksum = __cpu_to_le64(0);
116 sum = nd_fletcher64(nsindex[i], sizeof_namespace_index(ndd), 1);
117 nsindex[i]->checksum = __cpu_to_le64(sum_save);
118 if (sum != sum_save) {
119 dev_dbg(dev, "%s: nsindex%d checksum invalid\n",
124 seq = __le32_to_cpu(nsindex[i]->seq);
125 if ((seq & NSINDEX_SEQ_MASK) == 0) {
126 dev_dbg(dev, "%s: nsindex%d sequence: %#x invalid\n",
131 /* sanity check the index against expected values */
132 if (__le64_to_cpu(nsindex[i]->myoff)
133 != i * sizeof_namespace_index(ndd)) {
134 dev_dbg(dev, "%s: nsindex%d myoff: %#llx invalid\n",
135 __func__, i, (unsigned long long)
136 __le64_to_cpu(nsindex[i]->myoff));
139 if (__le64_to_cpu(nsindex[i]->otheroff)
140 != (!i) * sizeof_namespace_index(ndd)) {
141 dev_dbg(dev, "%s: nsindex%d otheroff: %#llx invalid\n",
142 __func__, i, (unsigned long long)
143 __le64_to_cpu(nsindex[i]->otheroff));
147 size = __le64_to_cpu(nsindex[i]->mysize);
148 if (size > sizeof_namespace_index(ndd)
149 || size < sizeof(struct nd_namespace_index)) {
150 dev_dbg(dev, "%s: nsindex%d mysize: %#llx invalid\n",
155 nslot = __le32_to_cpu(nsindex[i]->nslot);
156 if (nslot * sizeof(struct nd_namespace_label)
157 + 2 * sizeof_namespace_index(ndd)
158 > ndd->nsarea.config_size) {
159 dev_dbg(dev, "%s: nsindex%d nslot: %u invalid, config_size: %#x\n",
161 ndd->nsarea.config_size);
172 for (i = 0; i < num_index; i++)
175 /* can't have num_valid > 0 but valid[] = { false, false } */
179 /* pick the best index... */
180 seq = best_seq(__le32_to_cpu(nsindex[0]->seq),
181 __le32_to_cpu(nsindex[1]->seq));
182 if (seq == (__le32_to_cpu(nsindex[1]->seq) & NSINDEX_SEQ_MASK))
192 void nd_label_copy(struct nvdimm_drvdata *ndd, struct nd_namespace_index *dst,
193 struct nd_namespace_index *src)
200 memcpy(dst, src, sizeof_namespace_index(ndd));
203 static struct nd_namespace_label *nd_label_base(struct nvdimm_drvdata *ndd)
205 void *base = to_namespace_index(ndd, 0);
207 return base + 2 * sizeof_namespace_index(ndd);
210 static int to_slot(struct nvdimm_drvdata *ndd,
211 struct nd_namespace_label *nd_label)
213 return nd_label - nd_label_base(ndd);
216 #define for_each_clear_bit_le(bit, addr, size) \
217 for ((bit) = find_next_zero_bit_le((addr), (size), 0); \
219 (bit) = find_next_zero_bit_le((addr), (size), (bit) + 1))
222 * preamble_index - common variable initialization for nd_label_* routines
223 * @ndd: dimm container for the relevant label set
224 * @idx: namespace_index index
225 * @nsindex_out: on return set to the currently active namespace index
226 * @free: on return set to the free label bitmap in the index
227 * @nslot: on return set to the number of slots in the label space
229 static bool preamble_index(struct nvdimm_drvdata *ndd, int idx,
230 struct nd_namespace_index **nsindex_out,
231 unsigned long **free, u32 *nslot)
233 struct nd_namespace_index *nsindex;
235 nsindex = to_namespace_index(ndd, idx);
239 *free = (unsigned long *) nsindex->free;
240 *nslot = __le32_to_cpu(nsindex->nslot);
241 *nsindex_out = nsindex;
246 char *nd_label_gen_id(struct nd_label_id *label_id, u8 *uuid, u32 flags)
248 if (!label_id || !uuid)
250 snprintf(label_id->id, ND_LABEL_ID_SIZE, "%s-%pUb",
251 flags & NSLABEL_FLAG_LOCAL ? "blk" : "pmem", uuid);
255 static bool preamble_current(struct nvdimm_drvdata *ndd,
256 struct nd_namespace_index **nsindex,
257 unsigned long **free, u32 *nslot)
259 return preamble_index(ndd, ndd->ns_current, nsindex,
263 static bool preamble_next(struct nvdimm_drvdata *ndd,
264 struct nd_namespace_index **nsindex,
265 unsigned long **free, u32 *nslot)
267 return preamble_index(ndd, ndd->ns_next, nsindex,
271 static bool slot_valid(struct nd_namespace_label *nd_label, u32 slot)
273 /* check that we are written where we expect to be written */
274 if (slot != __le32_to_cpu(nd_label->slot))
277 /* check that DPA allocations are page aligned */
278 if ((__le64_to_cpu(nd_label->dpa)
279 | __le64_to_cpu(nd_label->rawsize)) % SZ_4K)
285 int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd)
287 struct nd_namespace_index *nsindex;
291 if (!preamble_current(ndd, &nsindex, &free, &nslot))
292 return 0; /* no label, nothing to reserve */
294 for_each_clear_bit_le(slot, free, nslot) {
295 struct nd_namespace_label *nd_label;
296 struct nd_region *nd_region = NULL;
297 u8 label_uuid[NSLABEL_UUID_LEN];
298 struct nd_label_id label_id;
299 struct resource *res;
302 nd_label = nd_label_base(ndd) + slot;
304 if (!slot_valid(nd_label, slot))
307 memcpy(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN);
308 flags = __le32_to_cpu(nd_label->flags);
309 nd_label_gen_id(&label_id, label_uuid, flags);
310 res = nvdimm_allocate_dpa(ndd, &label_id,
311 __le64_to_cpu(nd_label->dpa),
312 __le64_to_cpu(nd_label->rawsize));
313 nd_dbg_dpa(nd_region, ndd, res, "reserve\n");
321 int nd_label_active_count(struct nvdimm_drvdata *ndd)
323 struct nd_namespace_index *nsindex;
328 if (!preamble_current(ndd, &nsindex, &free, &nslot))
331 for_each_clear_bit_le(slot, free, nslot) {
332 struct nd_namespace_label *nd_label;
334 nd_label = nd_label_base(ndd) + slot;
336 if (!slot_valid(nd_label, slot)) {
337 u32 label_slot = __le32_to_cpu(nd_label->slot);
338 u64 size = __le64_to_cpu(nd_label->rawsize);
339 u64 dpa = __le64_to_cpu(nd_label->dpa);
342 "%s: slot%d invalid slot: %d dpa: %llx size: %llx\n",
343 __func__, slot, label_slot, dpa, size);
351 struct nd_namespace_label *nd_label_active(struct nvdimm_drvdata *ndd, int n)
353 struct nd_namespace_index *nsindex;
357 if (!preamble_current(ndd, &nsindex, &free, &nslot))
360 for_each_clear_bit_le(slot, free, nslot) {
361 struct nd_namespace_label *nd_label;
363 nd_label = nd_label_base(ndd) + slot;
364 if (!slot_valid(nd_label, slot))
368 return nd_label_base(ndd) + slot;
374 static u32 nd_label_alloc_slot(struct nvdimm_drvdata *ndd)
376 struct nd_namespace_index *nsindex;
380 if (!preamble_next(ndd, &nsindex, &free, &nslot))
383 WARN_ON(!is_nvdimm_bus_locked(ndd->dev));
385 slot = find_next_bit_le(free, nslot, 0);
389 clear_bit_le(slot, free);
394 static bool nd_label_free_slot(struct nvdimm_drvdata *ndd, u32 slot)
396 struct nd_namespace_index *nsindex;
400 if (!preamble_next(ndd, &nsindex, &free, &nslot))
403 WARN_ON(!is_nvdimm_bus_locked(ndd->dev));
406 return !test_and_set_bit_le(slot, free);
410 u32 nd_label_nfree(struct nvdimm_drvdata *ndd)
412 struct nd_namespace_index *nsindex;
416 WARN_ON(!is_nvdimm_bus_locked(ndd->dev));
418 if (!preamble_next(ndd, &nsindex, &free, &nslot))
421 return bitmap_weight(free, nslot);
424 static int nd_label_write_index(struct nvdimm_drvdata *ndd, int index, u32 seq,
427 struct nd_namespace_index *nsindex;
428 unsigned long offset;
433 nsindex = to_namespace_index(ndd, index);
434 if (flags & ND_NSINDEX_INIT)
435 nslot = nvdimm_num_label_slots(ndd);
437 nslot = __le32_to_cpu(nsindex->nslot);
439 memcpy(nsindex->sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN);
440 nsindex->flags = __cpu_to_le32(0);
441 nsindex->seq = __cpu_to_le32(seq);
442 offset = (unsigned long) nsindex
443 - (unsigned long) to_namespace_index(ndd, 0);
444 nsindex->myoff = __cpu_to_le64(offset);
445 nsindex->mysize = __cpu_to_le64(sizeof_namespace_index(ndd));
446 offset = (unsigned long) to_namespace_index(ndd,
447 nd_label_next_nsindex(index))
448 - (unsigned long) to_namespace_index(ndd, 0);
449 nsindex->otheroff = __cpu_to_le64(offset);
450 offset = (unsigned long) nd_label_base(ndd)
451 - (unsigned long) to_namespace_index(ndd, 0);
452 nsindex->labeloff = __cpu_to_le64(offset);
453 nsindex->nslot = __cpu_to_le32(nslot);
454 nsindex->major = __cpu_to_le16(1);
455 nsindex->minor = __cpu_to_le16(1);
456 nsindex->checksum = __cpu_to_le64(0);
457 if (flags & ND_NSINDEX_INIT) {
458 unsigned long *free = (unsigned long *) nsindex->free;
459 u32 nfree = ALIGN(nslot, BITS_PER_LONG);
462 memset(nsindex->free, 0xff, nfree / 8);
463 for (i = 0, last_bits = nfree - nslot; i < last_bits; i++)
464 clear_bit_le(nslot + i, free);
466 checksum = nd_fletcher64(nsindex, sizeof_namespace_index(ndd), 1);
467 nsindex->checksum = __cpu_to_le64(checksum);
468 rc = nvdimm_set_config_data(ndd, __le64_to_cpu(nsindex->myoff),
469 nsindex, sizeof_namespace_index(ndd));
473 if (flags & ND_NSINDEX_INIT)
476 /* copy the index we just wrote to the new 'next' */
477 WARN_ON(index != ndd->ns_next);
478 nd_label_copy(ndd, to_current_namespace_index(ndd), nsindex);
479 ndd->ns_current = nd_label_next_nsindex(ndd->ns_current);
480 ndd->ns_next = nd_label_next_nsindex(ndd->ns_next);
481 WARN_ON(ndd->ns_current == ndd->ns_next);
486 static unsigned long nd_label_offset(struct nvdimm_drvdata *ndd,
487 struct nd_namespace_label *nd_label)
489 return (unsigned long) nd_label
490 - (unsigned long) to_namespace_index(ndd, 0);
493 static int __pmem_label_update(struct nd_region *nd_region,
494 struct nd_mapping *nd_mapping, struct nd_namespace_pmem *nspm,
497 u64 cookie = nd_region_interleave_set_cookie(nd_region), rawsize;
498 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
499 struct nd_namespace_label *victim_label;
500 struct nd_namespace_label *nd_label;
501 struct nd_namespace_index *nsindex;
507 if (!preamble_next(ndd, &nsindex, &free, &nslot))
510 /* allocate and write the label to the staging (next) index */
511 slot = nd_label_alloc_slot(ndd);
512 if (slot == UINT_MAX)
514 dev_dbg(ndd->dev, "%s: allocated: %d\n", __func__, slot);
516 nd_label = nd_label_base(ndd) + slot;
517 memset(nd_label, 0, sizeof(struct nd_namespace_label));
518 memcpy(nd_label->uuid, nspm->uuid, NSLABEL_UUID_LEN);
520 memcpy(nd_label->name, nspm->alt_name, NSLABEL_NAME_LEN);
521 nd_label->flags = __cpu_to_le32(NSLABEL_FLAG_UPDATING);
522 nd_label->nlabel = __cpu_to_le16(nd_region->ndr_mappings);
523 nd_label->position = __cpu_to_le16(pos);
524 nd_label->isetcookie = __cpu_to_le64(cookie);
525 rawsize = div_u64(resource_size(&nspm->nsio.res),
526 nd_region->ndr_mappings);
527 nd_label->rawsize = __cpu_to_le64(rawsize);
528 nd_label->dpa = __cpu_to_le64(nd_mapping->start);
529 nd_label->slot = __cpu_to_le32(slot);
532 offset = nd_label_offset(ndd, nd_label);
533 rc = nvdimm_set_config_data(ndd, offset, nd_label,
534 sizeof(struct nd_namespace_label));
538 /* Garbage collect the previous label */
539 victim_label = nd_mapping->labels[0];
541 slot = to_slot(ndd, victim_label);
542 nd_label_free_slot(ndd, slot);
543 dev_dbg(ndd->dev, "%s: free: %d\n", __func__, slot);
547 rc = nd_label_write_index(ndd, ndd->ns_next,
548 nd_inc_seq(__le32_to_cpu(nsindex->seq)), 0);
552 nd_mapping->labels[0] = nd_label;
557 static int init_labels(struct nd_mapping *nd_mapping)
560 struct nd_namespace_index *nsindex;
561 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
563 if (!nd_mapping->labels)
564 nd_mapping->labels = kcalloc(2, sizeof(void *), GFP_KERNEL);
566 if (!nd_mapping->labels)
569 if (ndd->ns_current == -1 || ndd->ns_next == -1)
574 nsindex = to_namespace_index(ndd, 0);
575 memset(nsindex, 0, ndd->nsarea.config_size);
576 for (i = 0; i < 2; i++) {
577 int rc = nd_label_write_index(ndd, i, i*2, ND_NSINDEX_INIT);
588 static int del_labels(struct nd_mapping *nd_mapping, u8 *uuid)
590 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
591 struct nd_namespace_label *nd_label;
592 struct nd_namespace_index *nsindex;
593 u8 label_uuid[NSLABEL_UUID_LEN];
594 int l, num_freed = 0;
601 /* no index || no labels == nothing to delete */
602 if (!preamble_next(ndd, &nsindex, &free, &nslot)
603 || !nd_mapping->labels)
606 for_each_label(l, nd_label, nd_mapping->labels) {
609 memcpy(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN);
610 if (memcmp(label_uuid, uuid, NSLABEL_UUID_LEN) != 0)
612 slot = to_slot(ndd, nd_label);
613 nd_label_free_slot(ndd, slot);
614 dev_dbg(ndd->dev, "%s: free: %d\n", __func__, slot);
615 for (j = l; nd_mapping->labels[j + 1]; j++) {
616 struct nd_namespace_label *next_label;
618 next_label = nd_mapping->labels[j + 1];
619 nd_mapping->labels[j] = next_label;
621 nd_mapping->labels[j] = NULL;
627 * num_freed will only ever be > l when we delete the last
630 kfree(nd_mapping->labels);
631 nd_mapping->labels = NULL;
632 dev_dbg(ndd->dev, "%s: no more labels\n", __func__);
635 return nd_label_write_index(ndd, ndd->ns_next,
636 nd_inc_seq(__le32_to_cpu(nsindex->seq)), 0);
639 int nd_pmem_namespace_label_update(struct nd_region *nd_region,
640 struct nd_namespace_pmem *nspm, resource_size_t size)
644 for (i = 0; i < nd_region->ndr_mappings; i++) {
645 struct nd_mapping *nd_mapping = &nd_region->mapping[i];
649 rc = del_labels(nd_mapping, nspm->uuid);
655 rc = init_labels(nd_mapping);
659 rc = __pmem_label_update(nd_region, nd_mapping, nspm, i);