1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. 4 */ 5 #include <linux/device.h> 6 #include <linux/ndctl.h> 7 #include <linux/uuid.h> 8 #include <linux/slab.h> 9 #include <linux/io.h> 10 #include <linux/nd.h> 11 #include "nd-core.h" 12 #include "label.h" 13 #include "nd.h" 14 15 static guid_t nvdimm_btt_guid; 16 static guid_t nvdimm_btt2_guid; 17 static guid_t nvdimm_pfn_guid; 18 static guid_t nvdimm_dax_guid; 19 20 static const char NSINDEX_SIGNATURE[] = "NAMESPACE_INDEX\0"; 21 22 static u32 best_seq(u32 a, u32 b) 23 { 24 a &= NSINDEX_SEQ_MASK; 25 b &= NSINDEX_SEQ_MASK; 26 27 if (a == 0 || a == b) 28 return b; 29 else if (b == 0) 30 return a; 31 else if (nd_inc_seq(a) == b) 32 return b; 33 else 34 return a; 35 } 36 37 unsigned sizeof_namespace_label(struct nvdimm_drvdata *ndd) 38 { 39 return ndd->nslabel_size; 40 } 41 42 static size_t __sizeof_namespace_index(u32 nslot) 43 { 44 return ALIGN(sizeof(struct nd_namespace_index) + DIV_ROUND_UP(nslot, 8), 45 NSINDEX_ALIGN); 46 } 47 48 static int __nvdimm_num_label_slots(struct nvdimm_drvdata *ndd, 49 size_t index_size) 50 { 51 return (ndd->nsarea.config_size - index_size * 2) / 52 sizeof_namespace_label(ndd); 53 } 54 55 int nvdimm_num_label_slots(struct nvdimm_drvdata *ndd) 56 { 57 u32 tmp_nslot, n; 58 59 tmp_nslot = ndd->nsarea.config_size / sizeof_namespace_label(ndd); 60 n = __sizeof_namespace_index(tmp_nslot) / NSINDEX_ALIGN; 61 62 return __nvdimm_num_label_slots(ndd, NSINDEX_ALIGN * n); 63 } 64 65 size_t sizeof_namespace_index(struct nvdimm_drvdata *ndd) 66 { 67 u32 nslot, space, size; 68 69 /* 70 * Per UEFI 2.7, the minimum size of the Label Storage Area is large 71 * enough to hold 2 index blocks and 2 labels. The minimum index 72 * block size is 256 bytes. The label size is 128 for namespaces 73 * prior to version 1.2 and at minimum 256 for version 1.2 and later. 74 */ 75 nslot = nvdimm_num_label_slots(ndd); 76 space = ndd->nsarea.config_size - nslot * sizeof_namespace_label(ndd); 77 size = __sizeof_namespace_index(nslot) * 2; 78 if (size <= space && nslot >= 2) 79 return size / 2; 80 81 dev_err(ndd->dev, "label area (%d) too small to host (%d byte) labels\n", 82 ndd->nsarea.config_size, sizeof_namespace_label(ndd)); 83 return 0; 84 } 85 86 static int __nd_label_validate(struct nvdimm_drvdata *ndd) 87 { 88 /* 89 * On media label format consists of two index blocks followed 90 * by an array of labels. None of these structures are ever 91 * updated in place. A sequence number tracks the current 92 * active index and the next one to write, while labels are 93 * written to free slots. 94 * 95 * +------------+ 96 * | | 97 * | nsindex0 | 98 * | | 99 * +------------+ 100 * | | 101 * | nsindex1 | 102 * | | 103 * +------------+ 104 * | label0 | 105 * +------------+ 106 * | label1 | 107 * +------------+ 108 * | | 109 * ....nslot... 110 * | | 111 * +------------+ 112 * | labelN | 113 * +------------+ 114 */ 115 struct nd_namespace_index *nsindex[] = { 116 to_namespace_index(ndd, 0), 117 to_namespace_index(ndd, 1), 118 }; 119 const int num_index = ARRAY_SIZE(nsindex); 120 struct device *dev = ndd->dev; 121 bool valid[2] = { 0 }; 122 int i, num_valid = 0; 123 u32 seq; 124 125 for (i = 0; i < num_index; i++) { 126 u32 nslot; 127 u8 sig[NSINDEX_SIG_LEN]; 128 u64 sum_save, sum, size; 129 unsigned int version, labelsize; 130 131 memcpy(sig, nsindex[i]->sig, NSINDEX_SIG_LEN); 132 if (memcmp(sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN) != 0) { 133 dev_dbg(dev, "nsindex%d signature invalid\n", i); 134 continue; 135 } 136 137 /* label sizes larger than 128 arrived with v1.2 */ 138 version = __le16_to_cpu(nsindex[i]->major) * 100 139 + __le16_to_cpu(nsindex[i]->minor); 140 if (version >= 102) 141 labelsize = 1 << (7 + nsindex[i]->labelsize); 142 else 143 labelsize = 128; 144 145 if (labelsize != sizeof_namespace_label(ndd)) { 146 dev_dbg(dev, "nsindex%d labelsize %d invalid\n", 147 i, nsindex[i]->labelsize); 148 continue; 149 } 150 151 sum_save = __le64_to_cpu(nsindex[i]->checksum); 152 nsindex[i]->checksum = __cpu_to_le64(0); 153 sum = nd_fletcher64(nsindex[i], sizeof_namespace_index(ndd), 1); 154 nsindex[i]->checksum = __cpu_to_le64(sum_save); 155 if (sum != sum_save) { 156 dev_dbg(dev, "nsindex%d checksum invalid\n", i); 157 continue; 158 } 159 160 seq = __le32_to_cpu(nsindex[i]->seq); 161 if ((seq & NSINDEX_SEQ_MASK) == 0) { 162 dev_dbg(dev, "nsindex%d sequence: %#x invalid\n", i, seq); 163 continue; 164 } 165 166 /* sanity check the index against expected values */ 167 if (__le64_to_cpu(nsindex[i]->myoff) 168 != i * sizeof_namespace_index(ndd)) { 169 dev_dbg(dev, "nsindex%d myoff: %#llx invalid\n", 170 i, (unsigned long long) 171 __le64_to_cpu(nsindex[i]->myoff)); 172 continue; 173 } 174 if (__le64_to_cpu(nsindex[i]->otheroff) 175 != (!i) * sizeof_namespace_index(ndd)) { 176 dev_dbg(dev, "nsindex%d otheroff: %#llx invalid\n", 177 i, (unsigned long long) 178 __le64_to_cpu(nsindex[i]->otheroff)); 179 continue; 180 } 181 if (__le64_to_cpu(nsindex[i]->labeloff) 182 != 2 * sizeof_namespace_index(ndd)) { 183 dev_dbg(dev, "nsindex%d labeloff: %#llx invalid\n", 184 i, (unsigned long long) 185 __le64_to_cpu(nsindex[i]->labeloff)); 186 continue; 187 } 188 189 size = __le64_to_cpu(nsindex[i]->mysize); 190 if (size > sizeof_namespace_index(ndd) 191 || size < sizeof(struct nd_namespace_index)) { 192 dev_dbg(dev, "nsindex%d mysize: %#llx invalid\n", i, size); 193 continue; 194 } 195 196 nslot = __le32_to_cpu(nsindex[i]->nslot); 197 if (nslot * sizeof_namespace_label(ndd) 198 + 2 * sizeof_namespace_index(ndd) 199 > ndd->nsarea.config_size) { 200 dev_dbg(dev, "nsindex%d nslot: %u invalid, config_size: %#x\n", 201 i, nslot, ndd->nsarea.config_size); 202 continue; 203 } 204 valid[i] = true; 205 num_valid++; 206 } 207 208 switch (num_valid) { 209 case 0: 210 break; 211 case 1: 212 for (i = 0; i < num_index; i++) 213 if (valid[i]) 214 return i; 215 /* can't have num_valid > 0 but valid[] = { false, false } */ 216 WARN_ON(1); 217 break; 218 default: 219 /* pick the best index... */ 220 seq = best_seq(__le32_to_cpu(nsindex[0]->seq), 221 __le32_to_cpu(nsindex[1]->seq)); 222 if (seq == (__le32_to_cpu(nsindex[1]->seq) & NSINDEX_SEQ_MASK)) 223 return 1; 224 else 225 return 0; 226 break; 227 } 228 229 return -1; 230 } 231 232 static int nd_label_validate(struct nvdimm_drvdata *ndd) 233 { 234 /* 235 * In order to probe for and validate namespace index blocks we 236 * need to know the size of the labels, and we can't trust the 237 * size of the labels until we validate the index blocks. 238 * Resolve this dependency loop by probing for known label 239 * sizes, but default to v1.2 256-byte namespace labels if 240 * discovery fails. 241 */ 242 int label_size[] = { 128, 256 }; 243 int i, rc; 244 245 for (i = 0; i < ARRAY_SIZE(label_size); i++) { 246 ndd->nslabel_size = label_size[i]; 247 rc = __nd_label_validate(ndd); 248 if (rc >= 0) 249 return rc; 250 } 251 252 return -1; 253 } 254 255 static void nd_label_copy(struct nvdimm_drvdata *ndd, 256 struct nd_namespace_index *dst, 257 struct nd_namespace_index *src) 258 { 259 /* just exit if either destination or source is NULL */ 260 if (!dst || !src) 261 return; 262 263 memcpy(dst, src, sizeof_namespace_index(ndd)); 264 } 265 266 static struct nd_namespace_label *nd_label_base(struct nvdimm_drvdata *ndd) 267 { 268 void *base = to_namespace_index(ndd, 0); 269 270 return base + 2 * sizeof_namespace_index(ndd); 271 } 272 273 static int to_slot(struct nvdimm_drvdata *ndd, 274 struct nd_namespace_label *nd_label) 275 { 276 unsigned long label, base; 277 278 label = (unsigned long) nd_label; 279 base = (unsigned long) nd_label_base(ndd); 280 281 return (label - base) / sizeof_namespace_label(ndd); 282 } 283 284 static struct nd_namespace_label *to_label(struct nvdimm_drvdata *ndd, int slot) 285 { 286 unsigned long label, base; 287 288 base = (unsigned long) nd_label_base(ndd); 289 label = base + sizeof_namespace_label(ndd) * slot; 290 291 return (struct nd_namespace_label *) label; 292 } 293 294 #define for_each_clear_bit_le(bit, addr, size) \ 295 for ((bit) = find_next_zero_bit_le((addr), (size), 0); \ 296 (bit) < (size); \ 297 (bit) = find_next_zero_bit_le((addr), (size), (bit) + 1)) 298 299 /** 300 * preamble_index - common variable initialization for nd_label_* routines 301 * @ndd: dimm container for the relevant label set 302 * @idx: namespace_index index 303 * @nsindex_out: on return set to the currently active namespace index 304 * @free: on return set to the free label bitmap in the index 305 * @nslot: on return set to the number of slots in the label space 306 */ 307 static bool preamble_index(struct nvdimm_drvdata *ndd, int idx, 308 struct nd_namespace_index **nsindex_out, 309 unsigned long **free, u32 *nslot) 310 { 311 struct nd_namespace_index *nsindex; 312 313 nsindex = to_namespace_index(ndd, idx); 314 if (nsindex == NULL) 315 return false; 316 317 *free = (unsigned long *) nsindex->free; 318 *nslot = __le32_to_cpu(nsindex->nslot); 319 *nsindex_out = nsindex; 320 321 return true; 322 } 323 324 char *nd_label_gen_id(struct nd_label_id *label_id, u8 *uuid, u32 flags) 325 { 326 if (!label_id || !uuid) 327 return NULL; 328 snprintf(label_id->id, ND_LABEL_ID_SIZE, "%s-%pUb", 329 flags & NSLABEL_FLAG_LOCAL ? "blk" : "pmem", uuid); 330 return label_id->id; 331 } 332 333 static bool preamble_current(struct nvdimm_drvdata *ndd, 334 struct nd_namespace_index **nsindex, 335 unsigned long **free, u32 *nslot) 336 { 337 return preamble_index(ndd, ndd->ns_current, nsindex, 338 free, nslot); 339 } 340 341 static bool preamble_next(struct nvdimm_drvdata *ndd, 342 struct nd_namespace_index **nsindex, 343 unsigned long **free, u32 *nslot) 344 { 345 return preamble_index(ndd, ndd->ns_next, nsindex, 346 free, nslot); 347 } 348 349 static bool nsl_validate_checksum(struct nvdimm_drvdata *ndd, 350 struct nd_namespace_label *nd_label) 351 { 352 u64 sum, sum_save; 353 354 if (!namespace_label_has(ndd, checksum)) 355 return true; 356 357 sum_save = nsl_get_checksum(ndd, nd_label); 358 nsl_set_checksum(ndd, nd_label, 0); 359 sum = nd_fletcher64(nd_label, sizeof_namespace_label(ndd), 1); 360 nsl_set_checksum(ndd, nd_label, sum_save); 361 return sum == sum_save; 362 } 363 364 static void nsl_calculate_checksum(struct nvdimm_drvdata *ndd, 365 struct nd_namespace_label *nd_label) 366 { 367 u64 sum; 368 369 if (!namespace_label_has(ndd, checksum)) 370 return; 371 nsl_set_checksum(ndd, nd_label, 0); 372 sum = nd_fletcher64(nd_label, sizeof_namespace_label(ndd), 1); 373 nsl_set_checksum(ndd, nd_label, sum); 374 } 375 376 static bool slot_valid(struct nvdimm_drvdata *ndd, 377 struct nd_namespace_label *nd_label, u32 slot) 378 { 379 bool valid; 380 381 /* check that we are written where we expect to be written */ 382 if (slot != nsl_get_slot(ndd, nd_label)) 383 return false; 384 valid = nsl_validate_checksum(ndd, nd_label); 385 if (!valid) 386 dev_dbg(ndd->dev, "fail checksum. slot: %d\n", slot); 387 return valid; 388 } 389 390 int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd) 391 { 392 struct nd_namespace_index *nsindex; 393 unsigned long *free; 394 u32 nslot, slot; 395 396 if (!preamble_current(ndd, &nsindex, &free, &nslot)) 397 return 0; /* no label, nothing to reserve */ 398 399 for_each_clear_bit_le(slot, free, nslot) { 400 struct nvdimm *nvdimm = to_nvdimm(ndd->dev); 401 struct nd_namespace_label *nd_label; 402 struct nd_region *nd_region = NULL; 403 u8 label_uuid[NSLABEL_UUID_LEN]; 404 struct nd_label_id label_id; 405 struct resource *res; 406 u32 flags; 407 408 nd_label = to_label(ndd, slot); 409 410 if (!slot_valid(ndd, nd_label, slot)) 411 continue; 412 413 memcpy(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN); 414 flags = nsl_get_flags(ndd, nd_label); 415 if (test_bit(NDD_NOBLK, &nvdimm->flags)) 416 flags &= ~NSLABEL_FLAG_LOCAL; 417 nd_label_gen_id(&label_id, label_uuid, flags); 418 res = nvdimm_allocate_dpa(ndd, &label_id, 419 nsl_get_dpa(ndd, nd_label), 420 nsl_get_rawsize(ndd, nd_label)); 421 nd_dbg_dpa(nd_region, ndd, res, "reserve\n"); 422 if (!res) 423 return -EBUSY; 424 } 425 426 return 0; 427 } 428 429 int nd_label_data_init(struct nvdimm_drvdata *ndd) 430 { 431 size_t config_size, read_size, max_xfer, offset; 432 struct nd_namespace_index *nsindex; 433 unsigned int i; 434 int rc = 0; 435 u32 nslot; 436 437 if (ndd->data) 438 return 0; 439 440 if (ndd->nsarea.status || ndd->nsarea.max_xfer == 0) { 441 dev_dbg(ndd->dev, "failed to init config data area: (%u:%u)\n", 442 ndd->nsarea.max_xfer, ndd->nsarea.config_size); 443 return -ENXIO; 444 } 445 446 /* 447 * We need to determine the maximum index area as this is the section 448 * we must read and validate before we can start processing labels. 449 * 450 * If the area is too small to contain the two indexes and 2 labels 451 * then we abort. 452 * 453 * Start at a label size of 128 as this should result in the largest 454 * possible namespace index size. 455 */ 456 ndd->nslabel_size = 128; 457 read_size = sizeof_namespace_index(ndd) * 2; 458 if (!read_size) 459 return -ENXIO; 460 461 /* Allocate config data */ 462 config_size = ndd->nsarea.config_size; 463 ndd->data = kvzalloc(config_size, GFP_KERNEL); 464 if (!ndd->data) 465 return -ENOMEM; 466 467 /* 468 * We want to guarantee as few reads as possible while conserving 469 * memory. To do that we figure out how much unused space will be left 470 * in the last read, divide that by the total number of reads it is 471 * going to take given our maximum transfer size, and then reduce our 472 * maximum transfer size based on that result. 473 */ 474 max_xfer = min_t(size_t, ndd->nsarea.max_xfer, config_size); 475 if (read_size < max_xfer) { 476 /* trim waste */ 477 max_xfer -= ((max_xfer - 1) - (config_size - 1) % max_xfer) / 478 DIV_ROUND_UP(config_size, max_xfer); 479 /* make certain we read indexes in exactly 1 read */ 480 if (max_xfer < read_size) 481 max_xfer = read_size; 482 } 483 484 /* Make our initial read size a multiple of max_xfer size */ 485 read_size = min(DIV_ROUND_UP(read_size, max_xfer) * max_xfer, 486 config_size); 487 488 /* Read the index data */ 489 rc = nvdimm_get_config_data(ndd, ndd->data, 0, read_size); 490 if (rc) 491 goto out_err; 492 493 /* Validate index data, if not valid assume all labels are invalid */ 494 ndd->ns_current = nd_label_validate(ndd); 495 if (ndd->ns_current < 0) 496 return 0; 497 498 /* Record our index values */ 499 ndd->ns_next = nd_label_next_nsindex(ndd->ns_current); 500 501 /* Copy "current" index on top of the "next" index */ 502 nsindex = to_current_namespace_index(ndd); 503 nd_label_copy(ndd, to_next_namespace_index(ndd), nsindex); 504 505 /* Determine starting offset for label data */ 506 offset = __le64_to_cpu(nsindex->labeloff); 507 nslot = __le32_to_cpu(nsindex->nslot); 508 509 /* Loop through the free list pulling in any active labels */ 510 for (i = 0; i < nslot; i++, offset += ndd->nslabel_size) { 511 size_t label_read_size; 512 513 /* zero out the unused labels */ 514 if (test_bit_le(i, nsindex->free)) { 515 memset(ndd->data + offset, 0, ndd->nslabel_size); 516 continue; 517 } 518 519 /* if we already read past here then just continue */ 520 if (offset + ndd->nslabel_size <= read_size) 521 continue; 522 523 /* if we haven't read in a while reset our read_size offset */ 524 if (read_size < offset) 525 read_size = offset; 526 527 /* determine how much more will be read after this next call. */ 528 label_read_size = offset + ndd->nslabel_size - read_size; 529 label_read_size = DIV_ROUND_UP(label_read_size, max_xfer) * 530 max_xfer; 531 532 /* truncate last read if needed */ 533 if (read_size + label_read_size > config_size) 534 label_read_size = config_size - read_size; 535 536 /* Read the label data */ 537 rc = nvdimm_get_config_data(ndd, ndd->data + read_size, 538 read_size, label_read_size); 539 if (rc) 540 goto out_err; 541 542 /* push read_size to next read offset */ 543 read_size += label_read_size; 544 } 545 546 dev_dbg(ndd->dev, "len: %zu rc: %d\n", offset, rc); 547 out_err: 548 return rc; 549 } 550 551 int nd_label_active_count(struct nvdimm_drvdata *ndd) 552 { 553 struct nd_namespace_index *nsindex; 554 unsigned long *free; 555 u32 nslot, slot; 556 int count = 0; 557 558 if (!preamble_current(ndd, &nsindex, &free, &nslot)) 559 return 0; 560 561 for_each_clear_bit_le(slot, free, nslot) { 562 struct nd_namespace_label *nd_label; 563 564 nd_label = to_label(ndd, slot); 565 566 if (!slot_valid(ndd, nd_label, slot)) { 567 u32 label_slot = nsl_get_slot(ndd, nd_label); 568 u64 size = nsl_get_rawsize(ndd, nd_label); 569 u64 dpa = nsl_get_dpa(ndd, nd_label); 570 571 dev_dbg(ndd->dev, 572 "slot%d invalid slot: %d dpa: %llx size: %llx\n", 573 slot, label_slot, dpa, size); 574 continue; 575 } 576 count++; 577 } 578 return count; 579 } 580 581 struct nd_namespace_label *nd_label_active(struct nvdimm_drvdata *ndd, int n) 582 { 583 struct nd_namespace_index *nsindex; 584 unsigned long *free; 585 u32 nslot, slot; 586 587 if (!preamble_current(ndd, &nsindex, &free, &nslot)) 588 return NULL; 589 590 for_each_clear_bit_le(slot, free, nslot) { 591 struct nd_namespace_label *nd_label; 592 593 nd_label = to_label(ndd, slot); 594 if (!slot_valid(ndd, nd_label, slot)) 595 continue; 596 597 if (n-- == 0) 598 return to_label(ndd, slot); 599 } 600 601 return NULL; 602 } 603 604 u32 nd_label_alloc_slot(struct nvdimm_drvdata *ndd) 605 { 606 struct nd_namespace_index *nsindex; 607 unsigned long *free; 608 u32 nslot, slot; 609 610 if (!preamble_next(ndd, &nsindex, &free, &nslot)) 611 return UINT_MAX; 612 613 WARN_ON(!is_nvdimm_bus_locked(ndd->dev)); 614 615 slot = find_next_bit_le(free, nslot, 0); 616 if (slot == nslot) 617 return UINT_MAX; 618 619 clear_bit_le(slot, free); 620 621 return slot; 622 } 623 624 bool nd_label_free_slot(struct nvdimm_drvdata *ndd, u32 slot) 625 { 626 struct nd_namespace_index *nsindex; 627 unsigned long *free; 628 u32 nslot; 629 630 if (!preamble_next(ndd, &nsindex, &free, &nslot)) 631 return false; 632 633 WARN_ON(!is_nvdimm_bus_locked(ndd->dev)); 634 635 if (slot < nslot) 636 return !test_and_set_bit_le(slot, free); 637 return false; 638 } 639 640 u32 nd_label_nfree(struct nvdimm_drvdata *ndd) 641 { 642 struct nd_namespace_index *nsindex; 643 unsigned long *free; 644 u32 nslot; 645 646 WARN_ON(!is_nvdimm_bus_locked(ndd->dev)); 647 648 if (!preamble_next(ndd, &nsindex, &free, &nslot)) 649 return nvdimm_num_label_slots(ndd); 650 651 return bitmap_weight(free, nslot); 652 } 653 654 static int nd_label_write_index(struct nvdimm_drvdata *ndd, int index, u32 seq, 655 unsigned long flags) 656 { 657 struct nd_namespace_index *nsindex; 658 unsigned long offset; 659 u64 checksum; 660 u32 nslot; 661 int rc; 662 663 nsindex = to_namespace_index(ndd, index); 664 if (flags & ND_NSINDEX_INIT) 665 nslot = nvdimm_num_label_slots(ndd); 666 else 667 nslot = __le32_to_cpu(nsindex->nslot); 668 669 memcpy(nsindex->sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN); 670 memset(&nsindex->flags, 0, 3); 671 nsindex->labelsize = sizeof_namespace_label(ndd) >> 8; 672 nsindex->seq = __cpu_to_le32(seq); 673 offset = (unsigned long) nsindex 674 - (unsigned long) to_namespace_index(ndd, 0); 675 nsindex->myoff = __cpu_to_le64(offset); 676 nsindex->mysize = __cpu_to_le64(sizeof_namespace_index(ndd)); 677 offset = (unsigned long) to_namespace_index(ndd, 678 nd_label_next_nsindex(index)) 679 - (unsigned long) to_namespace_index(ndd, 0); 680 nsindex->otheroff = __cpu_to_le64(offset); 681 offset = (unsigned long) nd_label_base(ndd) 682 - (unsigned long) to_namespace_index(ndd, 0); 683 nsindex->labeloff = __cpu_to_le64(offset); 684 nsindex->nslot = __cpu_to_le32(nslot); 685 nsindex->major = __cpu_to_le16(1); 686 if (sizeof_namespace_label(ndd) < 256) 687 nsindex->minor = __cpu_to_le16(1); 688 else 689 nsindex->minor = __cpu_to_le16(2); 690 nsindex->checksum = __cpu_to_le64(0); 691 if (flags & ND_NSINDEX_INIT) { 692 unsigned long *free = (unsigned long *) nsindex->free; 693 u32 nfree = ALIGN(nslot, BITS_PER_LONG); 694 int last_bits, i; 695 696 memset(nsindex->free, 0xff, nfree / 8); 697 for (i = 0, last_bits = nfree - nslot; i < last_bits; i++) 698 clear_bit_le(nslot + i, free); 699 } 700 checksum = nd_fletcher64(nsindex, sizeof_namespace_index(ndd), 1); 701 nsindex->checksum = __cpu_to_le64(checksum); 702 rc = nvdimm_set_config_data(ndd, __le64_to_cpu(nsindex->myoff), 703 nsindex, sizeof_namespace_index(ndd)); 704 if (rc < 0) 705 return rc; 706 707 if (flags & ND_NSINDEX_INIT) 708 return 0; 709 710 /* copy the index we just wrote to the new 'next' */ 711 WARN_ON(index != ndd->ns_next); 712 nd_label_copy(ndd, to_current_namespace_index(ndd), nsindex); 713 ndd->ns_current = nd_label_next_nsindex(ndd->ns_current); 714 ndd->ns_next = nd_label_next_nsindex(ndd->ns_next); 715 WARN_ON(ndd->ns_current == ndd->ns_next); 716 717 return 0; 718 } 719 720 static unsigned long nd_label_offset(struct nvdimm_drvdata *ndd, 721 struct nd_namespace_label *nd_label) 722 { 723 return (unsigned long) nd_label 724 - (unsigned long) to_namespace_index(ndd, 0); 725 } 726 727 enum nvdimm_claim_class to_nvdimm_cclass(guid_t *guid) 728 { 729 if (guid_equal(guid, &nvdimm_btt_guid)) 730 return NVDIMM_CCLASS_BTT; 731 else if (guid_equal(guid, &nvdimm_btt2_guid)) 732 return NVDIMM_CCLASS_BTT2; 733 else if (guid_equal(guid, &nvdimm_pfn_guid)) 734 return NVDIMM_CCLASS_PFN; 735 else if (guid_equal(guid, &nvdimm_dax_guid)) 736 return NVDIMM_CCLASS_DAX; 737 else if (guid_equal(guid, &guid_null)) 738 return NVDIMM_CCLASS_NONE; 739 740 return NVDIMM_CCLASS_UNKNOWN; 741 } 742 743 static const guid_t *to_abstraction_guid(enum nvdimm_claim_class claim_class, 744 guid_t *target) 745 { 746 if (claim_class == NVDIMM_CCLASS_BTT) 747 return &nvdimm_btt_guid; 748 else if (claim_class == NVDIMM_CCLASS_BTT2) 749 return &nvdimm_btt2_guid; 750 else if (claim_class == NVDIMM_CCLASS_PFN) 751 return &nvdimm_pfn_guid; 752 else if (claim_class == NVDIMM_CCLASS_DAX) 753 return &nvdimm_dax_guid; 754 else if (claim_class == NVDIMM_CCLASS_UNKNOWN) { 755 /* 756 * If we're modifying a namespace for which we don't 757 * know the claim_class, don't touch the existing guid. 758 */ 759 return target; 760 } else 761 return &guid_null; 762 } 763 764 static void reap_victim(struct nd_mapping *nd_mapping, 765 struct nd_label_ent *victim) 766 { 767 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 768 u32 slot = to_slot(ndd, victim->label); 769 770 dev_dbg(ndd->dev, "free: %d\n", slot); 771 nd_label_free_slot(ndd, slot); 772 victim->label = NULL; 773 } 774 775 static int __pmem_label_update(struct nd_region *nd_region, 776 struct nd_mapping *nd_mapping, struct nd_namespace_pmem *nspm, 777 int pos, unsigned long flags) 778 { 779 struct nd_namespace_common *ndns = &nspm->nsio.common; 780 struct nd_interleave_set *nd_set = nd_region->nd_set; 781 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 782 struct nd_namespace_label *nd_label; 783 struct nd_namespace_index *nsindex; 784 struct nd_label_ent *label_ent; 785 struct nd_label_id label_id; 786 struct resource *res; 787 unsigned long *free; 788 u32 nslot, slot; 789 size_t offset; 790 u64 cookie; 791 int rc; 792 793 if (!preamble_next(ndd, &nsindex, &free, &nslot)) 794 return -ENXIO; 795 796 cookie = nd_region_interleave_set_cookie(nd_region, nsindex); 797 nd_label_gen_id(&label_id, nspm->uuid, 0); 798 for_each_dpa_resource(ndd, res) 799 if (strcmp(res->name, label_id.id) == 0) 800 break; 801 802 if (!res) { 803 WARN_ON_ONCE(1); 804 return -ENXIO; 805 } 806 807 /* allocate and write the label to the staging (next) index */ 808 slot = nd_label_alloc_slot(ndd); 809 if (slot == UINT_MAX) 810 return -ENXIO; 811 dev_dbg(ndd->dev, "allocated: %d\n", slot); 812 813 nd_label = to_label(ndd, slot); 814 memset(nd_label, 0, sizeof_namespace_label(ndd)); 815 memcpy(nd_label->uuid, nspm->uuid, NSLABEL_UUID_LEN); 816 nsl_set_name(ndd, nd_label, nspm->alt_name); 817 nsl_set_flags(ndd, nd_label, flags); 818 nsl_set_nlabel(ndd, nd_label, nd_region->ndr_mappings); 819 nsl_set_position(ndd, nd_label, pos); 820 nsl_set_isetcookie(ndd, nd_label, cookie); 821 nsl_set_rawsize(ndd, nd_label, resource_size(res)); 822 nsl_set_lbasize(ndd, nd_label, nspm->lbasize); 823 nsl_set_dpa(ndd, nd_label, res->start); 824 nsl_set_slot(ndd, nd_label, slot); 825 if (namespace_label_has(ndd, type_guid)) 826 guid_copy(&nd_label->type_guid, &nd_set->type_guid); 827 if (namespace_label_has(ndd, abstraction_guid)) 828 guid_copy(&nd_label->abstraction_guid, 829 to_abstraction_guid(ndns->claim_class, 830 &nd_label->abstraction_guid)); 831 nsl_calculate_checksum(ndd, nd_label); 832 nd_dbg_dpa(nd_region, ndd, res, "\n"); 833 834 /* update label */ 835 offset = nd_label_offset(ndd, nd_label); 836 rc = nvdimm_set_config_data(ndd, offset, nd_label, 837 sizeof_namespace_label(ndd)); 838 if (rc < 0) 839 return rc; 840 841 /* Garbage collect the previous label */ 842 mutex_lock(&nd_mapping->lock); 843 list_for_each_entry(label_ent, &nd_mapping->labels, list) { 844 if (!label_ent->label) 845 continue; 846 if (test_and_clear_bit(ND_LABEL_REAP, &label_ent->flags) 847 || memcmp(nspm->uuid, label_ent->label->uuid, 848 NSLABEL_UUID_LEN) == 0) 849 reap_victim(nd_mapping, label_ent); 850 } 851 852 /* update index */ 853 rc = nd_label_write_index(ndd, ndd->ns_next, 854 nd_inc_seq(__le32_to_cpu(nsindex->seq)), 0); 855 if (rc == 0) { 856 list_for_each_entry(label_ent, &nd_mapping->labels, list) 857 if (!label_ent->label) { 858 label_ent->label = nd_label; 859 nd_label = NULL; 860 break; 861 } 862 dev_WARN_ONCE(&nspm->nsio.common.dev, nd_label, 863 "failed to track label: %d\n", 864 to_slot(ndd, nd_label)); 865 if (nd_label) 866 rc = -ENXIO; 867 } 868 mutex_unlock(&nd_mapping->lock); 869 870 return rc; 871 } 872 873 static bool is_old_resource(struct resource *res, struct resource **list, int n) 874 { 875 int i; 876 877 if (res->flags & DPA_RESOURCE_ADJUSTED) 878 return false; 879 for (i = 0; i < n; i++) 880 if (res == list[i]) 881 return true; 882 return false; 883 } 884 885 static struct resource *to_resource(struct nvdimm_drvdata *ndd, 886 struct nd_namespace_label *nd_label) 887 { 888 struct resource *res; 889 890 for_each_dpa_resource(ndd, res) { 891 if (res->start != nsl_get_dpa(ndd, nd_label)) 892 continue; 893 if (resource_size(res) != nsl_get_rawsize(ndd, nd_label)) 894 continue; 895 return res; 896 } 897 898 return NULL; 899 } 900 901 static void nsl_set_blk_isetcookie(struct nvdimm_drvdata *ndd, 902 struct nd_namespace_label *nd_label, 903 u64 isetcookie) 904 { 905 if (namespace_label_has(ndd, type_guid)) { 906 nsl_set_isetcookie(ndd, nd_label, isetcookie); 907 return; 908 } 909 nsl_set_isetcookie(ndd, nd_label, 0); /* N/A */ 910 } 911 912 bool nsl_validate_blk_isetcookie(struct nvdimm_drvdata *ndd, 913 struct nd_namespace_label *nd_label, 914 u64 isetcookie) 915 { 916 if (!namespace_label_has(ndd, type_guid)) 917 return true; 918 919 if (nsl_get_isetcookie(ndd, nd_label) != isetcookie) { 920 dev_dbg(ndd->dev, "expect cookie %#llx got %#llx\n", isetcookie, 921 nsl_get_isetcookie(ndd, nd_label)); 922 return false; 923 } 924 925 return true; 926 } 927 928 /* 929 * 1/ Account all the labels that can be freed after this update 930 * 2/ Allocate and write the label to the staging (next) index 931 * 3/ Record the resources in the namespace device 932 */ 933 static int __blk_label_update(struct nd_region *nd_region, 934 struct nd_mapping *nd_mapping, struct nd_namespace_blk *nsblk, 935 int num_labels) 936 { 937 int i, alloc, victims, nfree, old_num_resources, nlabel, rc = -ENXIO; 938 struct nd_interleave_set *nd_set = nd_region->nd_set; 939 struct nd_namespace_common *ndns = &nsblk->common; 940 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 941 struct nd_namespace_label *nd_label; 942 struct nd_label_ent *label_ent, *e; 943 struct nd_namespace_index *nsindex; 944 unsigned long *free, *victim_map = NULL; 945 struct resource *res, **old_res_list; 946 struct nd_label_id label_id; 947 u8 uuid[NSLABEL_UUID_LEN]; 948 int min_dpa_idx = 0; 949 LIST_HEAD(list); 950 u32 nslot, slot; 951 952 if (!preamble_next(ndd, &nsindex, &free, &nslot)) 953 return -ENXIO; 954 955 old_res_list = nsblk->res; 956 nfree = nd_label_nfree(ndd); 957 old_num_resources = nsblk->num_resources; 958 nd_label_gen_id(&label_id, nsblk->uuid, NSLABEL_FLAG_LOCAL); 959 960 /* 961 * We need to loop over the old resources a few times, which seems a 962 * bit inefficient, but we need to know that we have the label 963 * space before we start mutating the tracking structures. 964 * Otherwise the recovery method of last resort for userspace is 965 * disable and re-enable the parent region. 966 */ 967 alloc = 0; 968 for_each_dpa_resource(ndd, res) { 969 if (strcmp(res->name, label_id.id) != 0) 970 continue; 971 if (!is_old_resource(res, old_res_list, old_num_resources)) 972 alloc++; 973 } 974 975 victims = 0; 976 if (old_num_resources) { 977 /* convert old local-label-map to dimm-slot victim-map */ 978 victim_map = bitmap_zalloc(nslot, GFP_KERNEL); 979 if (!victim_map) 980 return -ENOMEM; 981 982 /* mark unused labels for garbage collection */ 983 for_each_clear_bit_le(slot, free, nslot) { 984 nd_label = to_label(ndd, slot); 985 memcpy(uuid, nd_label->uuid, NSLABEL_UUID_LEN); 986 if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) != 0) 987 continue; 988 res = to_resource(ndd, nd_label); 989 if (res && is_old_resource(res, old_res_list, 990 old_num_resources)) 991 continue; 992 slot = to_slot(ndd, nd_label); 993 set_bit(slot, victim_map); 994 victims++; 995 } 996 } 997 998 /* don't allow updates that consume the last label */ 999 if (nfree - alloc < 0 || nfree - alloc + victims < 1) { 1000 dev_info(&nsblk->common.dev, "insufficient label space\n"); 1001 bitmap_free(victim_map); 1002 return -ENOSPC; 1003 } 1004 /* from here on we need to abort on error */ 1005 1006 1007 /* assign all resources to the namespace before writing the labels */ 1008 nsblk->res = NULL; 1009 nsblk->num_resources = 0; 1010 for_each_dpa_resource(ndd, res) { 1011 if (strcmp(res->name, label_id.id) != 0) 1012 continue; 1013 if (!nsblk_add_resource(nd_region, ndd, nsblk, res->start)) { 1014 rc = -ENOMEM; 1015 goto abort; 1016 } 1017 } 1018 1019 /* release slots associated with any invalidated UUIDs */ 1020 mutex_lock(&nd_mapping->lock); 1021 list_for_each_entry_safe(label_ent, e, &nd_mapping->labels, list) 1022 if (test_and_clear_bit(ND_LABEL_REAP, &label_ent->flags)) { 1023 reap_victim(nd_mapping, label_ent); 1024 list_move(&label_ent->list, &list); 1025 } 1026 mutex_unlock(&nd_mapping->lock); 1027 1028 /* 1029 * Find the resource associated with the first label in the set 1030 * per the v1.2 namespace specification. 1031 */ 1032 for (i = 0; i < nsblk->num_resources; i++) { 1033 struct resource *min = nsblk->res[min_dpa_idx]; 1034 1035 res = nsblk->res[i]; 1036 if (res->start < min->start) 1037 min_dpa_idx = i; 1038 } 1039 1040 for (i = 0; i < nsblk->num_resources; i++) { 1041 size_t offset; 1042 1043 res = nsblk->res[i]; 1044 if (is_old_resource(res, old_res_list, old_num_resources)) 1045 continue; /* carry-over */ 1046 slot = nd_label_alloc_slot(ndd); 1047 if (slot == UINT_MAX) { 1048 rc = -ENXIO; 1049 goto abort; 1050 } 1051 dev_dbg(ndd->dev, "allocated: %d\n", slot); 1052 1053 nd_label = to_label(ndd, slot); 1054 memset(nd_label, 0, sizeof_namespace_label(ndd)); 1055 memcpy(nd_label->uuid, nsblk->uuid, NSLABEL_UUID_LEN); 1056 nsl_set_name(ndd, nd_label, nsblk->alt_name); 1057 nsl_set_flags(ndd, nd_label, NSLABEL_FLAG_LOCAL); 1058 1059 /* 1060 * Use the presence of the type_guid as a flag to 1061 * determine isetcookie usage and nlabel + position 1062 * policy for blk-aperture namespaces. 1063 */ 1064 if (namespace_label_has(ndd, type_guid)) { 1065 if (i == min_dpa_idx) { 1066 nsl_set_nlabel(ndd, nd_label, nsblk->num_resources); 1067 nsl_set_position(ndd, nd_label, 0); 1068 } else { 1069 nsl_set_nlabel(ndd, nd_label, 0xffff); 1070 nsl_set_position(ndd, nd_label, 0xffff); 1071 } 1072 } else { 1073 nsl_set_nlabel(ndd, nd_label, 0); /* N/A */ 1074 nsl_set_position(ndd, nd_label, 0); /* N/A */ 1075 } 1076 nsl_set_blk_isetcookie(ndd, nd_label, nd_set->cookie2); 1077 1078 nsl_set_dpa(ndd, nd_label, res->start); 1079 nsl_set_rawsize(ndd, nd_label, resource_size(res)); 1080 nsl_set_lbasize(ndd, nd_label, nsblk->lbasize); 1081 nsl_set_slot(ndd, nd_label, slot); 1082 if (namespace_label_has(ndd, type_guid)) 1083 guid_copy(&nd_label->type_guid, &nd_set->type_guid); 1084 if (namespace_label_has(ndd, abstraction_guid)) 1085 guid_copy(&nd_label->abstraction_guid, 1086 to_abstraction_guid(ndns->claim_class, 1087 &nd_label->abstraction_guid)); 1088 nsl_calculate_checksum(ndd, nd_label); 1089 1090 /* update label */ 1091 offset = nd_label_offset(ndd, nd_label); 1092 rc = nvdimm_set_config_data(ndd, offset, nd_label, 1093 sizeof_namespace_label(ndd)); 1094 if (rc < 0) 1095 goto abort; 1096 } 1097 1098 /* free up now unused slots in the new index */ 1099 for_each_set_bit(slot, victim_map, victim_map ? nslot : 0) { 1100 dev_dbg(ndd->dev, "free: %d\n", slot); 1101 nd_label_free_slot(ndd, slot); 1102 } 1103 1104 /* update index */ 1105 rc = nd_label_write_index(ndd, ndd->ns_next, 1106 nd_inc_seq(__le32_to_cpu(nsindex->seq)), 0); 1107 if (rc) 1108 goto abort; 1109 1110 /* 1111 * Now that the on-dimm labels are up to date, fix up the tracking 1112 * entries in nd_mapping->labels 1113 */ 1114 nlabel = 0; 1115 mutex_lock(&nd_mapping->lock); 1116 list_for_each_entry_safe(label_ent, e, &nd_mapping->labels, list) { 1117 nd_label = label_ent->label; 1118 if (!nd_label) 1119 continue; 1120 nlabel++; 1121 memcpy(uuid, nd_label->uuid, NSLABEL_UUID_LEN); 1122 if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) != 0) 1123 continue; 1124 nlabel--; 1125 list_move(&label_ent->list, &list); 1126 label_ent->label = NULL; 1127 } 1128 list_splice_tail_init(&list, &nd_mapping->labels); 1129 mutex_unlock(&nd_mapping->lock); 1130 1131 if (nlabel + nsblk->num_resources > num_labels) { 1132 /* 1133 * Bug, we can't end up with more resources than 1134 * available labels 1135 */ 1136 WARN_ON_ONCE(1); 1137 rc = -ENXIO; 1138 goto out; 1139 } 1140 1141 mutex_lock(&nd_mapping->lock); 1142 label_ent = list_first_entry_or_null(&nd_mapping->labels, 1143 typeof(*label_ent), list); 1144 if (!label_ent) { 1145 WARN_ON(1); 1146 mutex_unlock(&nd_mapping->lock); 1147 rc = -ENXIO; 1148 goto out; 1149 } 1150 for_each_clear_bit_le(slot, free, nslot) { 1151 nd_label = to_label(ndd, slot); 1152 memcpy(uuid, nd_label->uuid, NSLABEL_UUID_LEN); 1153 if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) != 0) 1154 continue; 1155 res = to_resource(ndd, nd_label); 1156 res->flags &= ~DPA_RESOURCE_ADJUSTED; 1157 dev_vdbg(&nsblk->common.dev, "assign label slot: %d\n", slot); 1158 list_for_each_entry_from(label_ent, &nd_mapping->labels, list) { 1159 if (label_ent->label) 1160 continue; 1161 label_ent->label = nd_label; 1162 nd_label = NULL; 1163 break; 1164 } 1165 if (nd_label) 1166 dev_WARN(&nsblk->common.dev, 1167 "failed to track label slot%d\n", slot); 1168 } 1169 mutex_unlock(&nd_mapping->lock); 1170 1171 out: 1172 kfree(old_res_list); 1173 bitmap_free(victim_map); 1174 return rc; 1175 1176 abort: 1177 /* 1178 * 1/ repair the allocated label bitmap in the index 1179 * 2/ restore the resource list 1180 */ 1181 nd_label_copy(ndd, nsindex, to_current_namespace_index(ndd)); 1182 kfree(nsblk->res); 1183 nsblk->res = old_res_list; 1184 nsblk->num_resources = old_num_resources; 1185 old_res_list = NULL; 1186 goto out; 1187 } 1188 1189 static int init_labels(struct nd_mapping *nd_mapping, int num_labels) 1190 { 1191 int i, old_num_labels = 0; 1192 struct nd_label_ent *label_ent; 1193 struct nd_namespace_index *nsindex; 1194 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1195 1196 mutex_lock(&nd_mapping->lock); 1197 list_for_each_entry(label_ent, &nd_mapping->labels, list) 1198 old_num_labels++; 1199 mutex_unlock(&nd_mapping->lock); 1200 1201 /* 1202 * We need to preserve all the old labels for the mapping so 1203 * they can be garbage collected after writing the new labels. 1204 */ 1205 for (i = old_num_labels; i < num_labels; i++) { 1206 label_ent = kzalloc(sizeof(*label_ent), GFP_KERNEL); 1207 if (!label_ent) 1208 return -ENOMEM; 1209 mutex_lock(&nd_mapping->lock); 1210 list_add_tail(&label_ent->list, &nd_mapping->labels); 1211 mutex_unlock(&nd_mapping->lock); 1212 } 1213 1214 if (ndd->ns_current == -1 || ndd->ns_next == -1) 1215 /* pass */; 1216 else 1217 return max(num_labels, old_num_labels); 1218 1219 nsindex = to_namespace_index(ndd, 0); 1220 memset(nsindex, 0, ndd->nsarea.config_size); 1221 for (i = 0; i < 2; i++) { 1222 int rc = nd_label_write_index(ndd, i, 3 - i, ND_NSINDEX_INIT); 1223 1224 if (rc) 1225 return rc; 1226 } 1227 ndd->ns_next = 1; 1228 ndd->ns_current = 0; 1229 1230 return max(num_labels, old_num_labels); 1231 } 1232 1233 static int del_labels(struct nd_mapping *nd_mapping, u8 *uuid) 1234 { 1235 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1236 struct nd_label_ent *label_ent, *e; 1237 struct nd_namespace_index *nsindex; 1238 u8 label_uuid[NSLABEL_UUID_LEN]; 1239 unsigned long *free; 1240 LIST_HEAD(list); 1241 u32 nslot, slot; 1242 int active = 0; 1243 1244 if (!uuid) 1245 return 0; 1246 1247 /* no index || no labels == nothing to delete */ 1248 if (!preamble_next(ndd, &nsindex, &free, &nslot)) 1249 return 0; 1250 1251 mutex_lock(&nd_mapping->lock); 1252 list_for_each_entry_safe(label_ent, e, &nd_mapping->labels, list) { 1253 struct nd_namespace_label *nd_label = label_ent->label; 1254 1255 if (!nd_label) 1256 continue; 1257 active++; 1258 memcpy(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN); 1259 if (memcmp(label_uuid, uuid, NSLABEL_UUID_LEN) != 0) 1260 continue; 1261 active--; 1262 slot = to_slot(ndd, nd_label); 1263 nd_label_free_slot(ndd, slot); 1264 dev_dbg(ndd->dev, "free: %d\n", slot); 1265 list_move_tail(&label_ent->list, &list); 1266 label_ent->label = NULL; 1267 } 1268 list_splice_tail_init(&list, &nd_mapping->labels); 1269 1270 if (active == 0) { 1271 nd_mapping_free_labels(nd_mapping); 1272 dev_dbg(ndd->dev, "no more active labels\n"); 1273 } 1274 mutex_unlock(&nd_mapping->lock); 1275 1276 return nd_label_write_index(ndd, ndd->ns_next, 1277 nd_inc_seq(__le32_to_cpu(nsindex->seq)), 0); 1278 } 1279 1280 int nd_pmem_namespace_label_update(struct nd_region *nd_region, 1281 struct nd_namespace_pmem *nspm, resource_size_t size) 1282 { 1283 int i, rc; 1284 1285 for (i = 0; i < nd_region->ndr_mappings; i++) { 1286 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 1287 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1288 struct resource *res; 1289 int count = 0; 1290 1291 if (size == 0) { 1292 rc = del_labels(nd_mapping, nspm->uuid); 1293 if (rc) 1294 return rc; 1295 continue; 1296 } 1297 1298 for_each_dpa_resource(ndd, res) 1299 if (strncmp(res->name, "pmem", 4) == 0) 1300 count++; 1301 WARN_ON_ONCE(!count); 1302 1303 rc = init_labels(nd_mapping, count); 1304 if (rc < 0) 1305 return rc; 1306 1307 rc = __pmem_label_update(nd_region, nd_mapping, nspm, i, 1308 NSLABEL_FLAG_UPDATING); 1309 if (rc) 1310 return rc; 1311 } 1312 1313 if (size == 0) 1314 return 0; 1315 1316 /* Clear the UPDATING flag per UEFI 2.7 expectations */ 1317 for (i = 0; i < nd_region->ndr_mappings; i++) { 1318 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 1319 1320 rc = __pmem_label_update(nd_region, nd_mapping, nspm, i, 0); 1321 if (rc) 1322 return rc; 1323 } 1324 1325 return 0; 1326 } 1327 1328 int nd_blk_namespace_label_update(struct nd_region *nd_region, 1329 struct nd_namespace_blk *nsblk, resource_size_t size) 1330 { 1331 struct nd_mapping *nd_mapping = &nd_region->mapping[0]; 1332 struct resource *res; 1333 int count = 0; 1334 1335 if (size == 0) 1336 return del_labels(nd_mapping, nsblk->uuid); 1337 1338 for_each_dpa_resource(to_ndd(nd_mapping), res) 1339 count++; 1340 1341 count = init_labels(nd_mapping, count); 1342 if (count < 0) 1343 return count; 1344 1345 return __blk_label_update(nd_region, nd_mapping, nsblk, count); 1346 } 1347 1348 int __init nd_label_init(void) 1349 { 1350 WARN_ON(guid_parse(NVDIMM_BTT_GUID, &nvdimm_btt_guid)); 1351 WARN_ON(guid_parse(NVDIMM_BTT2_GUID, &nvdimm_btt2_guid)); 1352 WARN_ON(guid_parse(NVDIMM_PFN_GUID, &nvdimm_pfn_guid)); 1353 WARN_ON(guid_parse(NVDIMM_DAX_GUID, &nvdimm_dax_guid)); 1354 1355 return 0; 1356 } 1357