1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. 4 */ 5#include <linux/kstrtox.h> 6#include <linux/module.h> 7#include <linux/device.h> 8#include <linux/sort.h> 9#include <linux/slab.h> 10#include <linux/list.h> 11#include <linux/nd.h> 12#include "nd-core.h" 13#include "pmem.h" 14#include "pfn.h" 15#include "nd.h" 16 17static void namespace_io_release(struct device *dev) 18{ 19 struct nd_namespace_io *nsio = to_nd_namespace_io(dev); 20 21 kfree(nsio); 22} 23 24static void namespace_pmem_release(struct device *dev) 25{ 26 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 27 struct nd_region *nd_region = to_nd_region(dev->parent); 28 29 if (nspm->id >= 0) 30 ida_free(&nd_region->ns_ida, nspm->id); 31 kfree(nspm->alt_name); 32 kfree(nspm->uuid); 33 kfree(nspm); 34} 35 36static bool is_namespace_pmem(const struct device *dev); 37static bool is_namespace_io(const struct device *dev); 38 39static int is_uuid_busy(struct device *dev, void *data) 40{ 41 uuid_t *uuid1 = data, *uuid2 = NULL; 42 43 if (is_namespace_pmem(dev)) { 44 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 45 46 uuid2 = nspm->uuid; 47 } else if (is_nd_btt(dev)) { 48 struct nd_btt *nd_btt = to_nd_btt(dev); 49 50 uuid2 = nd_btt->uuid; 51 } else if (is_nd_pfn(dev)) { 52 struct nd_pfn *nd_pfn = to_nd_pfn(dev); 53 54 uuid2 = nd_pfn->uuid; 55 } 56 57 if (uuid2 && uuid_equal(uuid1, uuid2)) 58 return -EBUSY; 59 60 return 0; 61} 62 63static int is_namespace_uuid_busy(struct device *dev, void *data) 64{ 65 if (is_nd_region(dev)) 66 return device_for_each_child(dev, data, is_uuid_busy); 67 return 0; 68} 69 70/** 71 * nd_is_uuid_unique - verify that no other namespace has @uuid 72 * @dev: any device on a nvdimm_bus 73 * @uuid: uuid to check 74 * 75 * Returns: %true if the uuid is unique, %false if not 76 */ 77bool nd_is_uuid_unique(struct device *dev, uuid_t *uuid) 78{ 79 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev); 80 81 if (!nvdimm_bus) 82 return false; 83 WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm_bus->dev)); 84 if (device_for_each_child(&nvdimm_bus->dev, uuid, 85 is_namespace_uuid_busy) != 0) 86 return false; 87 return true; 88} 89 90bool pmem_should_map_pages(struct device *dev) 91{ 92 struct nd_region *nd_region = to_nd_region(dev->parent); 93 struct nd_namespace_common *ndns = to_ndns(dev); 94 struct nd_namespace_io *nsio; 95 96 if (!IS_ENABLED(CONFIG_ZONE_DEVICE)) 97 return false; 98 99 if (!test_bit(ND_REGION_PAGEMAP, &nd_region->flags)) 100 return false; 101 102 if (is_nd_pfn(dev) || is_nd_btt(dev)) 103 return false; 104 105 if (ndns->force_raw) 106 return false; 107 108 nsio = to_nd_namespace_io(dev); 109 if (region_intersects(nsio->res.start, resource_size(&nsio->res), 110 IORESOURCE_SYSTEM_RAM, 111 IORES_DESC_NONE) == REGION_MIXED) 112 return false; 113 114 return ARCH_MEMREMAP_PMEM == MEMREMAP_WB; 115} 116EXPORT_SYMBOL(pmem_should_map_pages); 117 118unsigned int pmem_sector_size(struct nd_namespace_common *ndns) 119{ 120 if (is_namespace_pmem(&ndns->dev)) { 121 struct nd_namespace_pmem *nspm; 122 123 nspm = to_nd_namespace_pmem(&ndns->dev); 124 if (nspm->lbasize == 0 || nspm->lbasize == 512) 125 /* default */; 126 else if (nspm->lbasize == 4096) 127 return 4096; 128 else 129 dev_WARN(&ndns->dev, "unsupported sector size: %ld\n", 130 nspm->lbasize); 131 } 132 133 /* 134 * There is no namespace label (is_namespace_io()), or the label 135 * indicates the default sector size. 136 */ 137 return 512; 138} 139EXPORT_SYMBOL(pmem_sector_size); 140 141const char *nvdimm_namespace_disk_name(struct nd_namespace_common *ndns, 142 char *name) 143{ 144 struct nd_region *nd_region = to_nd_region(ndns->dev.parent); 145 const char *suffix = NULL; 146 147 if (ndns->claim && is_nd_btt(ndns->claim)) 148 suffix = "s"; 149 150 if (is_namespace_pmem(&ndns->dev) || is_namespace_io(&ndns->dev)) { 151 int nsidx = 0; 152 153 if (is_namespace_pmem(&ndns->dev)) { 154 struct nd_namespace_pmem *nspm; 155 156 nspm = to_nd_namespace_pmem(&ndns->dev); 157 nsidx = nspm->id; 158 } 159 160 if (nsidx) 161 sprintf(name, "pmem%d.%d%s", nd_region->id, nsidx, 162 suffix ? suffix : ""); 163 else 164 sprintf(name, "pmem%d%s", nd_region->id, 165 suffix ? suffix : ""); 166 } else { 167 return NULL; 168 } 169 170 return name; 171} 172EXPORT_SYMBOL(nvdimm_namespace_disk_name); 173 174const uuid_t *nd_dev_to_uuid(struct device *dev) 175{ 176 if (dev && is_namespace_pmem(dev)) { 177 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 178 179 return nspm->uuid; 180 } 181 return &uuid_null; 182} 183EXPORT_SYMBOL(nd_dev_to_uuid); 184 185static ssize_t nstype_show(struct device *dev, 186 struct device_attribute *attr, char *buf) 187{ 188 struct nd_region *nd_region = to_nd_region(dev->parent); 189 190 return sprintf(buf, "%d\n", nd_region_to_nstype(nd_region)); 191} 192static DEVICE_ATTR_RO(nstype); 193 194static ssize_t __alt_name_store(struct device *dev, const char *buf, 195 const size_t len) 196{ 197 char *input, *pos, *alt_name, **ns_altname; 198 ssize_t rc; 199 200 if (is_namespace_pmem(dev)) { 201 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 202 203 ns_altname = &nspm->alt_name; 204 } else 205 return -ENXIO; 206 207 if (dev->driver || to_ndns(dev)->claim) 208 return -EBUSY; 209 210 input = kstrndup(buf, len, GFP_KERNEL); 211 if (!input) 212 return -ENOMEM; 213 214 pos = strim(input); 215 if (strlen(pos) + 1 > NSLABEL_NAME_LEN) { 216 rc = -EINVAL; 217 goto out; 218 } 219 220 alt_name = kzalloc(NSLABEL_NAME_LEN, GFP_KERNEL); 221 if (!alt_name) { 222 rc = -ENOMEM; 223 goto out; 224 } 225 kfree(*ns_altname); 226 *ns_altname = alt_name; 227 sprintf(*ns_altname, "%s", pos); 228 rc = len; 229 230out: 231 kfree(input); 232 return rc; 233} 234 235static int nd_namespace_label_update(struct nd_region *nd_region, 236 struct device *dev) 237{ 238 dev_WARN_ONCE(dev, dev->driver || to_ndns(dev)->claim, 239 "namespace must be idle during label update\n"); 240 if (dev->driver || to_ndns(dev)->claim) 241 return 0; 242 243 /* 244 * Only allow label writes that will result in a valid namespace 245 * or deletion of an existing namespace. 246 */ 247 if (is_namespace_pmem(dev)) { 248 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 249 resource_size_t size = resource_size(&nspm->nsio.res); 250 251 if (size == 0 && nspm->uuid) 252 /* delete allocation */; 253 else if (!nspm->uuid) 254 return 0; 255 256 return nd_pmem_namespace_label_update(nd_region, nspm, size); 257 } else 258 return -ENXIO; 259} 260 261static ssize_t alt_name_store(struct device *dev, 262 struct device_attribute *attr, const char *buf, size_t len) 263{ 264 struct nd_region *nd_region = to_nd_region(dev->parent); 265 ssize_t rc; 266 267 device_lock(dev); 268 nvdimm_bus_lock(dev); 269 wait_nvdimm_bus_probe_idle(dev); 270 rc = __alt_name_store(dev, buf, len); 271 if (rc >= 0) 272 rc = nd_namespace_label_update(nd_region, dev); 273 dev_dbg(dev, "%s(%zd)\n", rc < 0 ? "fail " : "", rc); 274 nvdimm_bus_unlock(dev); 275 device_unlock(dev); 276 277 return rc < 0 ? rc : len; 278} 279 280static ssize_t alt_name_show(struct device *dev, 281 struct device_attribute *attr, char *buf) 282{ 283 char *ns_altname; 284 285 if (is_namespace_pmem(dev)) { 286 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 287 288 ns_altname = nspm->alt_name; 289 } else 290 return -ENXIO; 291 292 return sprintf(buf, "%s\n", ns_altname ? ns_altname : ""); 293} 294static DEVICE_ATTR_RW(alt_name); 295 296static int scan_free(struct nd_region *nd_region, 297 struct nd_mapping *nd_mapping, struct nd_label_id *label_id, 298 resource_size_t n) 299{ 300 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 301 int rc = 0; 302 303 while (n) { 304 struct resource *res, *last; 305 306 last = NULL; 307 for_each_dpa_resource(ndd, res) 308 if (strcmp(res->name, label_id->id) == 0) 309 last = res; 310 res = last; 311 if (!res) 312 return 0; 313 314 if (n >= resource_size(res)) { 315 n -= resource_size(res); 316 nd_dbg_dpa(nd_region, ndd, res, "delete %d\n", rc); 317 nvdimm_free_dpa(ndd, res); 318 /* retry with last resource deleted */ 319 continue; 320 } 321 322 rc = adjust_resource(res, res->start, resource_size(res) - n); 323 if (rc == 0) 324 res->flags |= DPA_RESOURCE_ADJUSTED; 325 nd_dbg_dpa(nd_region, ndd, res, "shrink %d\n", rc); 326 break; 327 } 328 329 return rc; 330} 331 332/** 333 * shrink_dpa_allocation - for each dimm in region free n bytes for label_id 334 * @nd_region: the set of dimms to reclaim @n bytes from 335 * @label_id: unique identifier for the namespace consuming this dpa range 336 * @n: number of bytes per-dimm to release 337 * 338 * Assumes resources are ordered. Starting from the end try to 339 * adjust_resource() the allocation to @n, but if @n is larger than the 340 * allocation delete it and find the 'new' last allocation in the label 341 * set. 342 * 343 * Returns: %0 on success on -errno on error 344 */ 345static int shrink_dpa_allocation(struct nd_region *nd_region, 346 struct nd_label_id *label_id, resource_size_t n) 347{ 348 int i; 349 350 for (i = 0; i < nd_region->ndr_mappings; i++) { 351 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 352 int rc; 353 354 rc = scan_free(nd_region, nd_mapping, label_id, n); 355 if (rc) 356 return rc; 357 } 358 359 return 0; 360} 361 362static resource_size_t init_dpa_allocation(struct nd_label_id *label_id, 363 struct nd_region *nd_region, struct nd_mapping *nd_mapping, 364 resource_size_t n) 365{ 366 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 367 struct resource *res; 368 int rc = 0; 369 370 /* first resource allocation for this label-id or dimm */ 371 res = nvdimm_allocate_dpa(ndd, label_id, nd_mapping->start, n); 372 if (!res) 373 rc = -EBUSY; 374 375 nd_dbg_dpa(nd_region, ndd, res, "init %d\n", rc); 376 return rc ? n : 0; 377} 378 379 380/** 381 * space_valid() - validate free dpa space against constraints 382 * @nd_region: hosting region of the free space 383 * @ndd: dimm device data for debug 384 * @label_id: namespace id to allocate space 385 * @prev: potential allocation that precedes free space 386 * @next: allocation that follows the given free space range 387 * @exist: first allocation with same id in the mapping 388 * @n: range that must satisfied for pmem allocations 389 * @valid: free space range to validate 390 * 391 * BLK-space is valid as long as it does not precede a PMEM 392 * allocation in a given region. PMEM-space must be contiguous 393 * and adjacent to an existing allocation (if one 394 * exists). If reserving PMEM any space is valid. 395 */ 396static void space_valid(struct nd_region *nd_region, struct nvdimm_drvdata *ndd, 397 struct nd_label_id *label_id, struct resource *prev, 398 struct resource *next, struct resource *exist, 399 resource_size_t n, struct resource *valid) 400{ 401 bool is_reserve = strcmp(label_id->id, "pmem-reserve") == 0; 402 unsigned long align; 403 404 align = nd_region->align / nd_region->ndr_mappings; 405 valid->start = ALIGN(valid->start, align); 406 valid->end = ALIGN_DOWN(valid->end + 1, align) - 1; 407 408 if (valid->start >= valid->end) 409 goto invalid; 410 411 if (is_reserve) 412 return; 413 414 /* allocation needs to be contiguous, so this is all or nothing */ 415 if (resource_size(valid) < n) 416 goto invalid; 417 418 /* we've got all the space we need and no existing allocation */ 419 if (!exist) 420 return; 421 422 /* allocation needs to be contiguous with the existing namespace */ 423 if (valid->start == exist->end + 1 424 || valid->end == exist->start - 1) 425 return; 426 427 invalid: 428 /* truncate @valid size to 0 */ 429 valid->end = valid->start - 1; 430} 431 432enum alloc_loc { 433 ALLOC_ERR = 0, ALLOC_BEFORE, ALLOC_MID, ALLOC_AFTER, 434}; 435 436static resource_size_t scan_allocate(struct nd_region *nd_region, 437 struct nd_mapping *nd_mapping, struct nd_label_id *label_id, 438 resource_size_t n) 439{ 440 resource_size_t mapping_end = nd_mapping->start + nd_mapping->size - 1; 441 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 442 struct resource *res, *exist = NULL, valid; 443 const resource_size_t to_allocate = n; 444 int first; 445 446 for_each_dpa_resource(ndd, res) 447 if (strcmp(label_id->id, res->name) == 0) 448 exist = res; 449 450 valid.start = nd_mapping->start; 451 valid.end = mapping_end; 452 valid.name = "free space"; 453 retry: 454 first = 0; 455 for_each_dpa_resource(ndd, res) { 456 struct resource *next = res->sibling, *new_res = NULL; 457 resource_size_t allocate, available = 0; 458 enum alloc_loc loc = ALLOC_ERR; 459 const char *action; 460 int rc = 0; 461 462 /* ignore resources outside this nd_mapping */ 463 if (res->start > mapping_end) 464 continue; 465 if (res->end < nd_mapping->start) 466 continue; 467 468 /* space at the beginning of the mapping */ 469 if (!first++ && res->start > nd_mapping->start) { 470 valid.start = nd_mapping->start; 471 valid.end = res->start - 1; 472 space_valid(nd_region, ndd, label_id, NULL, next, exist, 473 to_allocate, &valid); 474 available = resource_size(&valid); 475 if (available) 476 loc = ALLOC_BEFORE; 477 } 478 479 /* space between allocations */ 480 if (!loc && next) { 481 valid.start = res->start + resource_size(res); 482 valid.end = min(mapping_end, next->start - 1); 483 space_valid(nd_region, ndd, label_id, res, next, exist, 484 to_allocate, &valid); 485 available = resource_size(&valid); 486 if (available) 487 loc = ALLOC_MID; 488 } 489 490 /* space at the end of the mapping */ 491 if (!loc && !next) { 492 valid.start = res->start + resource_size(res); 493 valid.end = mapping_end; 494 space_valid(nd_region, ndd, label_id, res, next, exist, 495 to_allocate, &valid); 496 available = resource_size(&valid); 497 if (available) 498 loc = ALLOC_AFTER; 499 } 500 501 if (!loc || !available) 502 continue; 503 allocate = min(available, n); 504 switch (loc) { 505 case ALLOC_BEFORE: 506 if (strcmp(res->name, label_id->id) == 0) { 507 /* adjust current resource up */ 508 rc = adjust_resource(res, res->start - allocate, 509 resource_size(res) + allocate); 510 action = "cur grow up"; 511 } else 512 action = "allocate"; 513 break; 514 case ALLOC_MID: 515 if (strcmp(next->name, label_id->id) == 0) { 516 /* adjust next resource up */ 517 rc = adjust_resource(next, next->start 518 - allocate, resource_size(next) 519 + allocate); 520 new_res = next; 521 action = "next grow up"; 522 } else if (strcmp(res->name, label_id->id) == 0) { 523 action = "grow down"; 524 } else 525 action = "allocate"; 526 break; 527 case ALLOC_AFTER: 528 if (strcmp(res->name, label_id->id) == 0) 529 action = "grow down"; 530 else 531 action = "allocate"; 532 break; 533 default: 534 return n; 535 } 536 537 if (strcmp(action, "allocate") == 0) { 538 new_res = nvdimm_allocate_dpa(ndd, label_id, 539 valid.start, allocate); 540 if (!new_res) 541 rc = -EBUSY; 542 } else if (strcmp(action, "grow down") == 0) { 543 /* adjust current resource down */ 544 rc = adjust_resource(res, res->start, resource_size(res) 545 + allocate); 546 if (rc == 0) 547 res->flags |= DPA_RESOURCE_ADJUSTED; 548 } 549 550 if (!new_res) 551 new_res = res; 552 553 nd_dbg_dpa(nd_region, ndd, new_res, "%s(%d) %d\n", 554 action, loc, rc); 555 556 if (rc) 557 return n; 558 559 n -= allocate; 560 if (n) { 561 /* 562 * Retry scan with newly inserted resources. 563 * For example, if we did an ALLOC_BEFORE 564 * insertion there may also have been space 565 * available for an ALLOC_AFTER insertion, so we 566 * need to check this same resource again 567 */ 568 goto retry; 569 } else 570 return 0; 571 } 572 573 if (n == to_allocate) 574 return init_dpa_allocation(label_id, nd_region, nd_mapping, n); 575 return n; 576} 577 578static int merge_dpa(struct nd_region *nd_region, 579 struct nd_mapping *nd_mapping, struct nd_label_id *label_id) 580{ 581 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 582 struct resource *res; 583 584 if (strncmp("pmem", label_id->id, 4) == 0) 585 return 0; 586 retry: 587 for_each_dpa_resource(ndd, res) { 588 int rc; 589 struct resource *next = res->sibling; 590 resource_size_t end = res->start + resource_size(res); 591 592 if (!next || strcmp(res->name, label_id->id) != 0 593 || strcmp(next->name, label_id->id) != 0 594 || end != next->start) 595 continue; 596 end += resource_size(next); 597 nvdimm_free_dpa(ndd, next); 598 rc = adjust_resource(res, res->start, end - res->start); 599 nd_dbg_dpa(nd_region, ndd, res, "merge %d\n", rc); 600 if (rc) 601 return rc; 602 res->flags |= DPA_RESOURCE_ADJUSTED; 603 goto retry; 604 } 605 606 return 0; 607} 608 609int __reserve_free_pmem(struct device *dev, void *data) 610{ 611 struct nvdimm *nvdimm = data; 612 struct nd_region *nd_region; 613 struct nd_label_id label_id; 614 int i; 615 616 if (!is_memory(dev)) 617 return 0; 618 619 nd_region = to_nd_region(dev); 620 if (nd_region->ndr_mappings == 0) 621 return 0; 622 623 memset(&label_id, 0, sizeof(label_id)); 624 strcat(label_id.id, "pmem-reserve"); 625 for (i = 0; i < nd_region->ndr_mappings; i++) { 626 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 627 resource_size_t n, rem = 0; 628 629 if (nd_mapping->nvdimm != nvdimm) 630 continue; 631 632 n = nd_pmem_available_dpa(nd_region, nd_mapping); 633 if (n == 0) 634 return 0; 635 rem = scan_allocate(nd_region, nd_mapping, &label_id, n); 636 dev_WARN_ONCE(&nd_region->dev, rem, 637 "pmem reserve underrun: %#llx of %#llx bytes\n", 638 (unsigned long long) n - rem, 639 (unsigned long long) n); 640 return rem ? -ENXIO : 0; 641 } 642 643 return 0; 644} 645 646void release_free_pmem(struct nvdimm_bus *nvdimm_bus, 647 struct nd_mapping *nd_mapping) 648{ 649 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 650 struct resource *res, *_res; 651 652 for_each_dpa_resource_safe(ndd, res, _res) 653 if (strcmp(res->name, "pmem-reserve") == 0) 654 nvdimm_free_dpa(ndd, res); 655} 656 657/** 658 * grow_dpa_allocation - for each dimm allocate n bytes for @label_id 659 * @nd_region: the set of dimms to allocate @n more bytes from 660 * @label_id: unique identifier for the namespace consuming this dpa range 661 * @n: number of bytes per-dimm to add to the existing allocation 662 * 663 * Assumes resources are ordered. For BLK regions, first consume 664 * BLK-only available DPA free space, then consume PMEM-aliased DPA 665 * space starting at the highest DPA. For PMEM regions start 666 * allocations from the start of an interleave set and end at the first 667 * BLK allocation or the end of the interleave set, whichever comes 668 * first. 669 * 670 * Returns: %0 on success on -errno on error 671 */ 672static int grow_dpa_allocation(struct nd_region *nd_region, 673 struct nd_label_id *label_id, resource_size_t n) 674{ 675 int i; 676 677 for (i = 0; i < nd_region->ndr_mappings; i++) { 678 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 679 resource_size_t rem = n; 680 int rc; 681 682 rem = scan_allocate(nd_region, nd_mapping, label_id, rem); 683 dev_WARN_ONCE(&nd_region->dev, rem, 684 "allocation underrun: %#llx of %#llx bytes\n", 685 (unsigned long long) n - rem, 686 (unsigned long long) n); 687 if (rem) 688 return -ENXIO; 689 690 rc = merge_dpa(nd_region, nd_mapping, label_id); 691 if (rc) 692 return rc; 693 } 694 695 return 0; 696} 697 698static void nd_namespace_pmem_set_resource(struct nd_region *nd_region, 699 struct nd_namespace_pmem *nspm, resource_size_t size) 700{ 701 struct resource *res = &nspm->nsio.res; 702 resource_size_t offset = 0; 703 704 if (size && !nspm->uuid) { 705 WARN_ON_ONCE(1); 706 size = 0; 707 } 708 709 if (size && nspm->uuid) { 710 struct nd_mapping *nd_mapping = &nd_region->mapping[0]; 711 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 712 struct nd_label_id label_id; 713 struct resource *res; 714 715 if (!ndd) { 716 size = 0; 717 goto out; 718 } 719 720 nd_label_gen_id(&label_id, nspm->uuid, 0); 721 722 /* calculate a spa offset from the dpa allocation offset */ 723 for_each_dpa_resource(ndd, res) 724 if (strcmp(res->name, label_id.id) == 0) { 725 offset = (res->start - nd_mapping->start) 726 * nd_region->ndr_mappings; 727 goto out; 728 } 729 730 WARN_ON_ONCE(1); 731 size = 0; 732 } 733 734 out: 735 res->start = nd_region->ndr_start + offset; 736 res->end = res->start + size - 1; 737} 738 739static bool uuid_not_set(const uuid_t *uuid, struct device *dev, 740 const char *where) 741{ 742 if (!uuid) { 743 dev_dbg(dev, "%s: uuid not set\n", where); 744 return true; 745 } 746 return false; 747} 748 749static ssize_t __size_store(struct device *dev, unsigned long long val) 750{ 751 resource_size_t allocated = 0, available = 0; 752 struct nd_region *nd_region = to_nd_region(dev->parent); 753 struct nd_namespace_common *ndns = to_ndns(dev); 754 struct nd_mapping *nd_mapping; 755 struct nvdimm_drvdata *ndd; 756 struct nd_label_id label_id; 757 u32 flags = 0, remainder; 758 int rc, i, id = -1; 759 uuid_t *uuid = NULL; 760 761 if (dev->driver || ndns->claim) 762 return -EBUSY; 763 764 if (is_namespace_pmem(dev)) { 765 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 766 767 uuid = nspm->uuid; 768 id = nspm->id; 769 } 770 771 /* 772 * We need a uuid for the allocation-label and dimm(s) on which 773 * to store the label. 774 */ 775 if (uuid_not_set(uuid, dev, __func__)) 776 return -ENXIO; 777 if (nd_region->ndr_mappings == 0) { 778 dev_dbg(dev, "not associated with dimm(s)\n"); 779 return -ENXIO; 780 } 781 782 div_u64_rem(val, nd_region->align, &remainder); 783 if (remainder) { 784 dev_dbg(dev, "%llu is not %ldK aligned\n", val, 785 nd_region->align / SZ_1K); 786 return -EINVAL; 787 } 788 789 nd_label_gen_id(&label_id, uuid, flags); 790 for (i = 0; i < nd_region->ndr_mappings; i++) { 791 nd_mapping = &nd_region->mapping[i]; 792 ndd = to_ndd(nd_mapping); 793 794 /* 795 * All dimms in an interleave set, need to be enabled 796 * for the size to be changed. 797 */ 798 if (!ndd) 799 return -ENXIO; 800 801 allocated += nvdimm_allocated_dpa(ndd, &label_id); 802 } 803 available = nd_region_allocatable_dpa(nd_region); 804 805 if (val > available + allocated) 806 return -ENOSPC; 807 808 if (val == allocated) 809 return 0; 810 811 val = div_u64(val, nd_region->ndr_mappings); 812 allocated = div_u64(allocated, nd_region->ndr_mappings); 813 if (val < allocated) 814 rc = shrink_dpa_allocation(nd_region, &label_id, 815 allocated - val); 816 else 817 rc = grow_dpa_allocation(nd_region, &label_id, val - allocated); 818 819 if (rc) 820 return rc; 821 822 if (is_namespace_pmem(dev)) { 823 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 824 825 nd_namespace_pmem_set_resource(nd_region, nspm, 826 val * nd_region->ndr_mappings); 827 } 828 829 /* 830 * Try to delete the namespace if we deleted all of its 831 * allocation, this is not the seed or 0th device for the 832 * region, and it is not actively claimed by a btt, pfn, or dax 833 * instance. 834 */ 835 if (val == 0 && id != 0 && nd_region->ns_seed != dev && !ndns->claim) 836 nd_device_unregister(dev, ND_ASYNC); 837 838 return rc; 839} 840 841static ssize_t size_store(struct device *dev, 842 struct device_attribute *attr, const char *buf, size_t len) 843{ 844 struct nd_region *nd_region = to_nd_region(dev->parent); 845 unsigned long long val; 846 int rc; 847 848 rc = kstrtoull(buf, 0, &val); 849 if (rc) 850 return rc; 851 852 device_lock(dev); 853 nvdimm_bus_lock(dev); 854 wait_nvdimm_bus_probe_idle(dev); 855 rc = __size_store(dev, val); 856 if (rc >= 0) 857 rc = nd_namespace_label_update(nd_region, dev); 858 859 /* setting size zero == 'delete namespace' */ 860 if (rc == 0 && val == 0 && is_namespace_pmem(dev)) { 861 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 862 863 kfree(nspm->uuid); 864 nspm->uuid = NULL; 865 } 866 867 dev_dbg(dev, "%llx %s (%d)\n", val, rc < 0 ? "fail" : "success", rc); 868 869 nvdimm_bus_unlock(dev); 870 device_unlock(dev); 871 872 return rc < 0 ? rc : len; 873} 874 875resource_size_t __nvdimm_namespace_capacity(struct nd_namespace_common *ndns) 876{ 877 struct device *dev = &ndns->dev; 878 879 if (is_namespace_pmem(dev)) { 880 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 881 882 return resource_size(&nspm->nsio.res); 883 } else if (is_namespace_io(dev)) { 884 struct nd_namespace_io *nsio = to_nd_namespace_io(dev); 885 886 return resource_size(&nsio->res); 887 } else 888 WARN_ONCE(1, "unknown namespace type\n"); 889 return 0; 890} 891 892resource_size_t nvdimm_namespace_capacity(struct nd_namespace_common *ndns) 893{ 894 resource_size_t size; 895 896 nvdimm_bus_lock(&ndns->dev); 897 size = __nvdimm_namespace_capacity(ndns); 898 nvdimm_bus_unlock(&ndns->dev); 899 900 return size; 901} 902EXPORT_SYMBOL(nvdimm_namespace_capacity); 903 904bool nvdimm_namespace_locked(struct nd_namespace_common *ndns) 905{ 906 int i; 907 bool locked = false; 908 struct device *dev = &ndns->dev; 909 struct nd_region *nd_region = to_nd_region(dev->parent); 910 911 for (i = 0; i < nd_region->ndr_mappings; i++) { 912 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 913 struct nvdimm *nvdimm = nd_mapping->nvdimm; 914 915 if (test_bit(NDD_LOCKED, &nvdimm->flags)) { 916 dev_dbg(dev, "%s locked\n", nvdimm_name(nvdimm)); 917 locked = true; 918 } 919 } 920 return locked; 921} 922EXPORT_SYMBOL(nvdimm_namespace_locked); 923 924static ssize_t size_show(struct device *dev, 925 struct device_attribute *attr, char *buf) 926{ 927 return sprintf(buf, "%llu\n", (unsigned long long) 928 nvdimm_namespace_capacity(to_ndns(dev))); 929} 930static DEVICE_ATTR(size, 0444, size_show, size_store); 931 932static uuid_t *namespace_to_uuid(struct device *dev) 933{ 934 if (is_namespace_pmem(dev)) { 935 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 936 937 return nspm->uuid; 938 } 939 return ERR_PTR(-ENXIO); 940} 941 942static ssize_t uuid_show(struct device *dev, struct device_attribute *attr, 943 char *buf) 944{ 945 uuid_t *uuid = namespace_to_uuid(dev); 946 947 if (IS_ERR(uuid)) 948 return PTR_ERR(uuid); 949 if (uuid) 950 return sprintf(buf, "%pUb\n", uuid); 951 return sprintf(buf, "\n"); 952} 953 954/** 955 * namespace_update_uuid - check for a unique uuid and whether we're "renaming" 956 * @nd_region: parent region so we can updates all dimms in the set 957 * @dev: namespace type for generating label_id 958 * @new_uuid: incoming uuid 959 * @old_uuid: reference to the uuid storage location in the namespace object 960 * 961 * Returns: %0 on success on -errno on error 962 */ 963static int namespace_update_uuid(struct nd_region *nd_region, 964 struct device *dev, uuid_t *new_uuid, 965 uuid_t **old_uuid) 966{ 967 struct nd_label_id old_label_id; 968 struct nd_label_id new_label_id; 969 int i; 970 971 if (!nd_is_uuid_unique(dev, new_uuid)) 972 return -EINVAL; 973 974 if (*old_uuid == NULL) 975 goto out; 976 977 /* 978 * If we've already written a label with this uuid, then it's 979 * too late to rename because we can't reliably update the uuid 980 * without losing the old namespace. Userspace must delete this 981 * namespace to abandon the old uuid. 982 */ 983 for (i = 0; i < nd_region->ndr_mappings; i++) { 984 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 985 986 /* 987 * This check by itself is sufficient because old_uuid 988 * would be NULL above if this uuid did not exist in the 989 * currently written set. 990 * 991 * FIXME: can we delete uuid with zero dpa allocated? 992 */ 993 if (list_empty(&nd_mapping->labels)) 994 return -EBUSY; 995 } 996 997 nd_label_gen_id(&old_label_id, *old_uuid, 0); 998 nd_label_gen_id(&new_label_id, new_uuid, 0); 999 for (i = 0; i < nd_region->ndr_mappings; i++) { 1000 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 1001 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1002 struct nd_label_ent *label_ent; 1003 struct resource *res; 1004 1005 for_each_dpa_resource(ndd, res) 1006 if (strcmp(res->name, old_label_id.id) == 0) 1007 sprintf((void *) res->name, "%s", 1008 new_label_id.id); 1009 1010 mutex_lock(&nd_mapping->lock); 1011 list_for_each_entry(label_ent, &nd_mapping->labels, list) { 1012 struct nd_namespace_label *nd_label = label_ent->label; 1013 struct nd_label_id label_id; 1014 uuid_t uuid; 1015 1016 if (!nd_label) 1017 continue; 1018 nsl_get_uuid(ndd, nd_label, &uuid); 1019 nd_label_gen_id(&label_id, &uuid, 1020 nsl_get_flags(ndd, nd_label)); 1021 if (strcmp(old_label_id.id, label_id.id) == 0) 1022 set_bit(ND_LABEL_REAP, &label_ent->flags); 1023 } 1024 mutex_unlock(&nd_mapping->lock); 1025 } 1026 kfree(*old_uuid); 1027 out: 1028 *old_uuid = new_uuid; 1029 return 0; 1030} 1031 1032static ssize_t uuid_store(struct device *dev, 1033 struct device_attribute *attr, const char *buf, size_t len) 1034{ 1035 struct nd_region *nd_region = to_nd_region(dev->parent); 1036 uuid_t *uuid = NULL; 1037 uuid_t **ns_uuid; 1038 ssize_t rc = 0; 1039 1040 if (is_namespace_pmem(dev)) { 1041 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 1042 1043 ns_uuid = &nspm->uuid; 1044 } else 1045 return -ENXIO; 1046 1047 device_lock(dev); 1048 nvdimm_bus_lock(dev); 1049 wait_nvdimm_bus_probe_idle(dev); 1050 if (to_ndns(dev)->claim) 1051 rc = -EBUSY; 1052 if (rc >= 0) 1053 rc = nd_uuid_store(dev, &uuid, buf, len); 1054 if (rc >= 0) 1055 rc = namespace_update_uuid(nd_region, dev, uuid, ns_uuid); 1056 if (rc >= 0) 1057 rc = nd_namespace_label_update(nd_region, dev); 1058 else 1059 kfree(uuid); 1060 dev_dbg(dev, "result: %zd wrote: %s%s", rc, buf, 1061 buf[len - 1] == '\n' ? "" : "\n"); 1062 nvdimm_bus_unlock(dev); 1063 device_unlock(dev); 1064 1065 return rc < 0 ? rc : len; 1066} 1067static DEVICE_ATTR_RW(uuid); 1068 1069static ssize_t resource_show(struct device *dev, 1070 struct device_attribute *attr, char *buf) 1071{ 1072 struct resource *res; 1073 1074 if (is_namespace_pmem(dev)) { 1075 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 1076 1077 res = &nspm->nsio.res; 1078 } else if (is_namespace_io(dev)) { 1079 struct nd_namespace_io *nsio = to_nd_namespace_io(dev); 1080 1081 res = &nsio->res; 1082 } else 1083 return -ENXIO; 1084 1085 /* no address to convey if the namespace has no allocation */ 1086 if (resource_size(res) == 0) 1087 return -ENXIO; 1088 return sprintf(buf, "%#llx\n", (unsigned long long) res->start); 1089} 1090static DEVICE_ATTR_ADMIN_RO(resource); 1091 1092static const unsigned long pmem_lbasize_supported[] = { 512, 4096, 0 }; 1093 1094static ssize_t sector_size_show(struct device *dev, 1095 struct device_attribute *attr, char *buf) 1096{ 1097 if (is_namespace_pmem(dev)) { 1098 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 1099 1100 return nd_size_select_show(nspm->lbasize, 1101 pmem_lbasize_supported, buf); 1102 } 1103 return -ENXIO; 1104} 1105 1106static ssize_t sector_size_store(struct device *dev, 1107 struct device_attribute *attr, const char *buf, size_t len) 1108{ 1109 struct nd_region *nd_region = to_nd_region(dev->parent); 1110 const unsigned long *supported; 1111 unsigned long *lbasize; 1112 ssize_t rc = 0; 1113 1114 if (is_namespace_pmem(dev)) { 1115 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 1116 1117 lbasize = &nspm->lbasize; 1118 supported = pmem_lbasize_supported; 1119 } else 1120 return -ENXIO; 1121 1122 device_lock(dev); 1123 nvdimm_bus_lock(dev); 1124 if (to_ndns(dev)->claim) 1125 rc = -EBUSY; 1126 if (rc >= 0) 1127 rc = nd_size_select_store(dev, buf, lbasize, supported); 1128 if (rc >= 0) 1129 rc = nd_namespace_label_update(nd_region, dev); 1130 dev_dbg(dev, "result: %zd %s: %s%s", rc, rc < 0 ? "tried" : "wrote", 1131 buf, buf[len - 1] == '\n' ? "" : "\n"); 1132 nvdimm_bus_unlock(dev); 1133 device_unlock(dev); 1134 1135 return rc ? rc : len; 1136} 1137static DEVICE_ATTR_RW(sector_size); 1138 1139static ssize_t dpa_extents_show(struct device *dev, 1140 struct device_attribute *attr, char *buf) 1141{ 1142 struct nd_region *nd_region = to_nd_region(dev->parent); 1143 struct nd_label_id label_id; 1144 uuid_t *uuid = NULL; 1145 int count = 0, i; 1146 u32 flags = 0; 1147 1148 nvdimm_bus_lock(dev); 1149 if (is_namespace_pmem(dev)) { 1150 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); 1151 1152 uuid = nspm->uuid; 1153 flags = 0; 1154 } 1155 1156 if (!uuid) 1157 goto out; 1158 1159 nd_label_gen_id(&label_id, uuid, flags); 1160 for (i = 0; i < nd_region->ndr_mappings; i++) { 1161 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 1162 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1163 struct resource *res; 1164 1165 for_each_dpa_resource(ndd, res) 1166 if (strcmp(res->name, label_id.id) == 0) 1167 count++; 1168 } 1169 out: 1170 nvdimm_bus_unlock(dev); 1171 1172 return sprintf(buf, "%d\n", count); 1173} 1174static DEVICE_ATTR_RO(dpa_extents); 1175 1176static int btt_claim_class(struct device *dev) 1177{ 1178 struct nd_region *nd_region = to_nd_region(dev->parent); 1179 int i, loop_bitmask = 0; 1180 1181 for (i = 0; i < nd_region->ndr_mappings; i++) { 1182 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 1183 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1184 struct nd_namespace_index *nsindex; 1185 1186 /* 1187 * If any of the DIMMs do not support labels the only 1188 * possible BTT format is v1. 1189 */ 1190 if (!ndd) { 1191 loop_bitmask = 0; 1192 break; 1193 } 1194 1195 nsindex = to_namespace_index(ndd, ndd->ns_current); 1196 if (nsindex == NULL) 1197 loop_bitmask |= 1; 1198 else { 1199 /* check whether existing labels are v1.1 or v1.2 */ 1200 if (__le16_to_cpu(nsindex->major) == 1 1201 && __le16_to_cpu(nsindex->minor) == 1) 1202 loop_bitmask |= 2; 1203 else 1204 loop_bitmask |= 4; 1205 } 1206 } 1207 /* 1208 * If nsindex is null loop_bitmask's bit 0 will be set, and if an index 1209 * block is found, a v1.1 label for any mapping will set bit 1, and a 1210 * v1.2 label will set bit 2. 1211 * 1212 * At the end of the loop, at most one of the three bits must be set. 1213 * If multiple bits were set, it means the different mappings disagree 1214 * about their labels, and this must be cleaned up first. 1215 * 1216 * If all the label index blocks are found to agree, nsindex of NULL 1217 * implies labels haven't been initialized yet, and when they will, 1218 * they will be of the 1.2 format, so we can assume BTT2.0 1219 * 1220 * If 1.1 labels are found, we enforce BTT1.1, and if 1.2 labels are 1221 * found, we enforce BTT2.0 1222 * 1223 * If the loop was never entered, default to BTT1.1 (legacy namespaces) 1224 */ 1225 switch (loop_bitmask) { 1226 case 0: 1227 case 2: 1228 return NVDIMM_CCLASS_BTT; 1229 case 1: 1230 case 4: 1231 return NVDIMM_CCLASS_BTT2; 1232 default: 1233 return -ENXIO; 1234 } 1235} 1236 1237static ssize_t holder_show(struct device *dev, 1238 struct device_attribute *attr, char *buf) 1239{ 1240 struct nd_namespace_common *ndns = to_ndns(dev); 1241 ssize_t rc; 1242 1243 device_lock(dev); 1244 rc = sprintf(buf, "%s\n", ndns->claim ? dev_name(ndns->claim) : ""); 1245 device_unlock(dev); 1246 1247 return rc; 1248} 1249static DEVICE_ATTR_RO(holder); 1250 1251static int __holder_class_store(struct device *dev, const char *buf) 1252{ 1253 struct nd_namespace_common *ndns = to_ndns(dev); 1254 1255 if (dev->driver || ndns->claim) 1256 return -EBUSY; 1257 1258 if (sysfs_streq(buf, "btt")) { 1259 int rc = btt_claim_class(dev); 1260 1261 if (rc < NVDIMM_CCLASS_NONE) 1262 return rc; 1263 ndns->claim_class = rc; 1264 } else if (sysfs_streq(buf, "pfn")) 1265 ndns->claim_class = NVDIMM_CCLASS_PFN; 1266 else if (sysfs_streq(buf, "dax")) 1267 ndns->claim_class = NVDIMM_CCLASS_DAX; 1268 else if (sysfs_streq(buf, "")) 1269 ndns->claim_class = NVDIMM_CCLASS_NONE; 1270 else 1271 return -EINVAL; 1272 1273 return 0; 1274} 1275 1276static ssize_t holder_class_store(struct device *dev, 1277 struct device_attribute *attr, const char *buf, size_t len) 1278{ 1279 struct nd_region *nd_region = to_nd_region(dev->parent); 1280 int rc; 1281 1282 device_lock(dev); 1283 nvdimm_bus_lock(dev); 1284 wait_nvdimm_bus_probe_idle(dev); 1285 rc = __holder_class_store(dev, buf); 1286 if (rc >= 0) 1287 rc = nd_namespace_label_update(nd_region, dev); 1288 dev_dbg(dev, "%s(%d)\n", rc < 0 ? "fail " : "", rc); 1289 nvdimm_bus_unlock(dev); 1290 device_unlock(dev); 1291 1292 return rc < 0 ? rc : len; 1293} 1294 1295static ssize_t holder_class_show(struct device *dev, 1296 struct device_attribute *attr, char *buf) 1297{ 1298 struct nd_namespace_common *ndns = to_ndns(dev); 1299 ssize_t rc; 1300 1301 device_lock(dev); 1302 if (ndns->claim_class == NVDIMM_CCLASS_NONE) 1303 rc = sprintf(buf, "\n"); 1304 else if ((ndns->claim_class == NVDIMM_CCLASS_BTT) || 1305 (ndns->claim_class == NVDIMM_CCLASS_BTT2)) 1306 rc = sprintf(buf, "btt\n"); 1307 else if (ndns->claim_class == NVDIMM_CCLASS_PFN) 1308 rc = sprintf(buf, "pfn\n"); 1309 else if (ndns->claim_class == NVDIMM_CCLASS_DAX) 1310 rc = sprintf(buf, "dax\n"); 1311 else 1312 rc = sprintf(buf, "<unknown>\n"); 1313 device_unlock(dev); 1314 1315 return rc; 1316} 1317static DEVICE_ATTR_RW(holder_class); 1318 1319static ssize_t mode_show(struct device *dev, 1320 struct device_attribute *attr, char *buf) 1321{ 1322 struct nd_namespace_common *ndns = to_ndns(dev); 1323 struct device *claim; 1324 char *mode; 1325 ssize_t rc; 1326 1327 device_lock(dev); 1328 claim = ndns->claim; 1329 if (claim && is_nd_btt(claim)) 1330 mode = "safe"; 1331 else if (claim && is_nd_pfn(claim)) 1332 mode = "memory"; 1333 else if (claim && is_nd_dax(claim)) 1334 mode = "dax"; 1335 else if (!claim && pmem_should_map_pages(dev)) 1336 mode = "memory"; 1337 else 1338 mode = "raw"; 1339 rc = sprintf(buf, "%s\n", mode); 1340 device_unlock(dev); 1341 1342 return rc; 1343} 1344static DEVICE_ATTR_RO(mode); 1345 1346static ssize_t force_raw_store(struct device *dev, 1347 struct device_attribute *attr, const char *buf, size_t len) 1348{ 1349 bool force_raw; 1350 int rc = kstrtobool(buf, &force_raw); 1351 1352 if (rc) 1353 return rc; 1354 1355 to_ndns(dev)->force_raw = force_raw; 1356 return len; 1357} 1358 1359static ssize_t force_raw_show(struct device *dev, 1360 struct device_attribute *attr, char *buf) 1361{ 1362 return sprintf(buf, "%d\n", to_ndns(dev)->force_raw); 1363} 1364static DEVICE_ATTR_RW(force_raw); 1365 1366static struct attribute *nd_namespace_attributes[] = { 1367 &dev_attr_nstype.attr, 1368 &dev_attr_size.attr, 1369 &dev_attr_mode.attr, 1370 &dev_attr_uuid.attr, 1371 &dev_attr_holder.attr, 1372 &dev_attr_resource.attr, 1373 &dev_attr_alt_name.attr, 1374 &dev_attr_force_raw.attr, 1375 &dev_attr_sector_size.attr, 1376 &dev_attr_dpa_extents.attr, 1377 &dev_attr_holder_class.attr, 1378 NULL, 1379}; 1380 1381static umode_t namespace_visible(struct kobject *kobj, 1382 struct attribute *a, int n) 1383{ 1384 struct device *dev = container_of(kobj, struct device, kobj); 1385 1386 if (is_namespace_pmem(dev)) { 1387 if (a == &dev_attr_size.attr) 1388 return 0644; 1389 1390 return a->mode; 1391 } 1392 1393 /* base is_namespace_io() attributes */ 1394 if (a == &dev_attr_nstype.attr || a == &dev_attr_size.attr || 1395 a == &dev_attr_holder.attr || a == &dev_attr_holder_class.attr || 1396 a == &dev_attr_force_raw.attr || a == &dev_attr_mode.attr || 1397 a == &dev_attr_resource.attr) 1398 return a->mode; 1399 1400 return 0; 1401} 1402 1403static struct attribute_group nd_namespace_attribute_group = { 1404 .attrs = nd_namespace_attributes, 1405 .is_visible = namespace_visible, 1406}; 1407 1408static const struct attribute_group *nd_namespace_attribute_groups[] = { 1409 &nd_device_attribute_group, 1410 &nd_namespace_attribute_group, 1411 &nd_numa_attribute_group, 1412 NULL, 1413}; 1414 1415static const struct device_type namespace_io_device_type = { 1416 .name = "nd_namespace_io", 1417 .release = namespace_io_release, 1418 .groups = nd_namespace_attribute_groups, 1419}; 1420 1421static const struct device_type namespace_pmem_device_type = { 1422 .name = "nd_namespace_pmem", 1423 .release = namespace_pmem_release, 1424 .groups = nd_namespace_attribute_groups, 1425}; 1426 1427static bool is_namespace_pmem(const struct device *dev) 1428{ 1429 return dev ? dev->type == &namespace_pmem_device_type : false; 1430} 1431 1432static bool is_namespace_io(const struct device *dev) 1433{ 1434 return dev ? dev->type == &namespace_io_device_type : false; 1435} 1436 1437struct nd_namespace_common *nvdimm_namespace_common_probe(struct device *dev) 1438{ 1439 struct nd_btt *nd_btt = is_nd_btt(dev) ? to_nd_btt(dev) : NULL; 1440 struct nd_pfn *nd_pfn = is_nd_pfn(dev) ? to_nd_pfn(dev) : NULL; 1441 struct nd_dax *nd_dax = is_nd_dax(dev) ? to_nd_dax(dev) : NULL; 1442 struct nd_namespace_common *ndns = NULL; 1443 resource_size_t size; 1444 1445 if (nd_btt || nd_pfn || nd_dax) { 1446 if (nd_btt) 1447 ndns = nd_btt->ndns; 1448 else if (nd_pfn) 1449 ndns = nd_pfn->ndns; 1450 else if (nd_dax) 1451 ndns = nd_dax->nd_pfn.ndns; 1452 1453 if (!ndns) 1454 return ERR_PTR(-ENODEV); 1455 1456 /* 1457 * Flush any in-progess probes / removals in the driver 1458 * for the raw personality of this namespace. 1459 */ 1460 device_lock(&ndns->dev); 1461 device_unlock(&ndns->dev); 1462 if (ndns->dev.driver) { 1463 dev_dbg(&ndns->dev, "is active, can't bind %s\n", 1464 dev_name(dev)); 1465 return ERR_PTR(-EBUSY); 1466 } 1467 if (dev_WARN_ONCE(&ndns->dev, ndns->claim != dev, 1468 "host (%s) vs claim (%s) mismatch\n", 1469 dev_name(dev), 1470 dev_name(ndns->claim))) 1471 return ERR_PTR(-ENXIO); 1472 } else { 1473 ndns = to_ndns(dev); 1474 if (ndns->claim) { 1475 dev_dbg(dev, "claimed by %s, failing probe\n", 1476 dev_name(ndns->claim)); 1477 1478 return ERR_PTR(-ENXIO); 1479 } 1480 } 1481 1482 if (nvdimm_namespace_locked(ndns)) 1483 return ERR_PTR(-EACCES); 1484 1485 size = nvdimm_namespace_capacity(ndns); 1486 if (size < ND_MIN_NAMESPACE_SIZE) { 1487 dev_dbg(&ndns->dev, "%pa, too small must be at least %#x\n", 1488 &size, ND_MIN_NAMESPACE_SIZE); 1489 return ERR_PTR(-ENODEV); 1490 } 1491 1492 /* 1493 * Note, alignment validation for fsdax and devdax mode 1494 * namespaces happens in nd_pfn_validate() where infoblock 1495 * padding parameters can be applied. 1496 */ 1497 if (pmem_should_map_pages(dev)) { 1498 struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); 1499 struct resource *res = &nsio->res; 1500 1501 if (!IS_ALIGNED(res->start | (res->end + 1), 1502 memremap_compat_align())) { 1503 dev_err(&ndns->dev, "%pr misaligned, unable to map\n", res); 1504 return ERR_PTR(-EOPNOTSUPP); 1505 } 1506 } 1507 1508 if (is_namespace_pmem(&ndns->dev)) { 1509 struct nd_namespace_pmem *nspm; 1510 1511 nspm = to_nd_namespace_pmem(&ndns->dev); 1512 if (uuid_not_set(nspm->uuid, &ndns->dev, __func__)) 1513 return ERR_PTR(-ENODEV); 1514 } 1515 1516 return ndns; 1517} 1518EXPORT_SYMBOL(nvdimm_namespace_common_probe); 1519 1520int devm_namespace_enable(struct device *dev, struct nd_namespace_common *ndns, 1521 resource_size_t size) 1522{ 1523 return devm_nsio_enable(dev, to_nd_namespace_io(&ndns->dev), size); 1524} 1525EXPORT_SYMBOL_GPL(devm_namespace_enable); 1526 1527void devm_namespace_disable(struct device *dev, struct nd_namespace_common *ndns) 1528{ 1529 devm_nsio_disable(dev, to_nd_namespace_io(&ndns->dev)); 1530} 1531EXPORT_SYMBOL_GPL(devm_namespace_disable); 1532 1533static struct device **create_namespace_io(struct nd_region *nd_region) 1534{ 1535 struct nd_namespace_io *nsio; 1536 struct device *dev, **devs; 1537 struct resource *res; 1538 1539 nsio = kzalloc(sizeof(*nsio), GFP_KERNEL); 1540 if (!nsio) 1541 return NULL; 1542 1543 devs = kcalloc(2, sizeof(struct device *), GFP_KERNEL); 1544 if (!devs) { 1545 kfree(nsio); 1546 return NULL; 1547 } 1548 1549 dev = &nsio->common.dev; 1550 dev->type = &namespace_io_device_type; 1551 dev->parent = &nd_region->dev; 1552 res = &nsio->res; 1553 res->name = dev_name(&nd_region->dev); 1554 res->flags = IORESOURCE_MEM; 1555 res->start = nd_region->ndr_start; 1556 res->end = res->start + nd_region->ndr_size - 1; 1557 1558 devs[0] = dev; 1559 return devs; 1560} 1561 1562static bool has_uuid_at_pos(struct nd_region *nd_region, const uuid_t *uuid, 1563 u64 cookie, u16 pos) 1564{ 1565 struct nd_namespace_label *found = NULL; 1566 int i; 1567 1568 for (i = 0; i < nd_region->ndr_mappings; i++) { 1569 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 1570 struct nd_interleave_set *nd_set = nd_region->nd_set; 1571 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1572 struct nd_label_ent *label_ent; 1573 bool found_uuid = false; 1574 1575 list_for_each_entry(label_ent, &nd_mapping->labels, list) { 1576 struct nd_namespace_label *nd_label = label_ent->label; 1577 u16 position; 1578 1579 if (!nd_label) 1580 continue; 1581 position = nsl_get_position(ndd, nd_label); 1582 1583 if (!nsl_validate_isetcookie(ndd, nd_label, cookie)) 1584 continue; 1585 1586 if (!nsl_uuid_equal(ndd, nd_label, uuid)) 1587 continue; 1588 1589 if (!nsl_validate_type_guid(ndd, nd_label, 1590 &nd_set->type_guid)) 1591 continue; 1592 1593 if (found_uuid) { 1594 dev_dbg(ndd->dev, "duplicate entry for uuid\n"); 1595 return false; 1596 } 1597 found_uuid = true; 1598 if (!nsl_validate_nlabel(nd_region, ndd, nd_label)) 1599 continue; 1600 if (position != pos) 1601 continue; 1602 found = nd_label; 1603 break; 1604 } 1605 if (found) 1606 break; 1607 } 1608 return found != NULL; 1609} 1610 1611static int select_pmem_id(struct nd_region *nd_region, const uuid_t *pmem_id) 1612{ 1613 int i; 1614 1615 if (!pmem_id) 1616 return -ENODEV; 1617 1618 for (i = 0; i < nd_region->ndr_mappings; i++) { 1619 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 1620 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1621 struct nd_namespace_label *nd_label = NULL; 1622 u64 hw_start, hw_end, pmem_start, pmem_end; 1623 struct nd_label_ent *label_ent; 1624 1625 lockdep_assert_held(&nd_mapping->lock); 1626 list_for_each_entry(label_ent, &nd_mapping->labels, list) { 1627 nd_label = label_ent->label; 1628 if (!nd_label) 1629 continue; 1630 if (nsl_uuid_equal(ndd, nd_label, pmem_id)) 1631 break; 1632 nd_label = NULL; 1633 } 1634 1635 if (!nd_label) { 1636 WARN_ON(1); 1637 return -EINVAL; 1638 } 1639 1640 /* 1641 * Check that this label is compliant with the dpa 1642 * range published in NFIT 1643 */ 1644 hw_start = nd_mapping->start; 1645 hw_end = hw_start + nd_mapping->size; 1646 pmem_start = nsl_get_dpa(ndd, nd_label); 1647 pmem_end = pmem_start + nsl_get_rawsize(ndd, nd_label); 1648 if (pmem_start >= hw_start && pmem_start < hw_end 1649 && pmem_end <= hw_end && pmem_end > hw_start) 1650 /* pass */; 1651 else { 1652 dev_dbg(&nd_region->dev, "%s invalid label for %pUb\n", 1653 dev_name(ndd->dev), 1654 nsl_uuid_raw(ndd, nd_label)); 1655 return -EINVAL; 1656 } 1657 1658 /* move recently validated label to the front of the list */ 1659 list_move(&label_ent->list, &nd_mapping->labels); 1660 } 1661 return 0; 1662} 1663 1664/** 1665 * create_namespace_pmem - validate interleave set labelling, retrieve label0 1666 * @nd_region: region with mappings to validate 1667 * @nd_mapping: container of dpa-resource-root + labels 1668 * @nd_label: target pmem namespace label to evaluate 1669 * 1670 * Returns: the created &struct device on success or ERR_PTR(-errno) on error 1671 */ 1672static struct device *create_namespace_pmem(struct nd_region *nd_region, 1673 struct nd_mapping *nd_mapping, 1674 struct nd_namespace_label *nd_label) 1675{ 1676 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1677 struct nd_namespace_index *nsindex = 1678 to_namespace_index(ndd, ndd->ns_current); 1679 u64 cookie = nd_region_interleave_set_cookie(nd_region, nsindex); 1680 u64 altcookie = nd_region_interleave_set_altcookie(nd_region); 1681 struct nd_label_ent *label_ent; 1682 struct nd_namespace_pmem *nspm; 1683 resource_size_t size = 0; 1684 struct resource *res; 1685 struct device *dev; 1686 uuid_t uuid; 1687 int rc = 0; 1688 u16 i; 1689 1690 if (cookie == 0) { 1691 dev_dbg(&nd_region->dev, "invalid interleave-set-cookie\n"); 1692 return ERR_PTR(-ENXIO); 1693 } 1694 1695 if (!nsl_validate_isetcookie(ndd, nd_label, cookie)) { 1696 dev_dbg(&nd_region->dev, "invalid cookie in label: %pUb\n", 1697 nsl_uuid_raw(ndd, nd_label)); 1698 if (!nsl_validate_isetcookie(ndd, nd_label, altcookie)) 1699 return ERR_PTR(-EAGAIN); 1700 1701 dev_dbg(&nd_region->dev, "valid altcookie in label: %pUb\n", 1702 nsl_uuid_raw(ndd, nd_label)); 1703 } 1704 1705 nspm = kzalloc(sizeof(*nspm), GFP_KERNEL); 1706 if (!nspm) 1707 return ERR_PTR(-ENOMEM); 1708 1709 nspm->id = -1; 1710 dev = &nspm->nsio.common.dev; 1711 dev->type = &namespace_pmem_device_type; 1712 dev->parent = &nd_region->dev; 1713 res = &nspm->nsio.res; 1714 res->name = dev_name(&nd_region->dev); 1715 res->flags = IORESOURCE_MEM; 1716 1717 for (i = 0; i < nd_region->ndr_mappings; i++) { 1718 nsl_get_uuid(ndd, nd_label, &uuid); 1719 if (has_uuid_at_pos(nd_region, &uuid, cookie, i)) 1720 continue; 1721 if (has_uuid_at_pos(nd_region, &uuid, altcookie, i)) 1722 continue; 1723 break; 1724 } 1725 1726 if (i < nd_region->ndr_mappings) { 1727 struct nvdimm *nvdimm = nd_region->mapping[i].nvdimm; 1728 1729 /* 1730 * Give up if we don't find an instance of a uuid at each 1731 * position (from 0 to nd_region->ndr_mappings - 1), or if we 1732 * find a dimm with two instances of the same uuid. 1733 */ 1734 dev_err(&nd_region->dev, "%s missing label for %pUb\n", 1735 nvdimm_name(nvdimm), nsl_uuid_raw(ndd, nd_label)); 1736 rc = -EINVAL; 1737 goto err; 1738 } 1739 1740 /* 1741 * Fix up each mapping's 'labels' to have the validated pmem label for 1742 * that position at labels[0], and NULL at labels[1]. In the process, 1743 * check that the namespace aligns with interleave-set. 1744 */ 1745 nsl_get_uuid(ndd, nd_label, &uuid); 1746 rc = select_pmem_id(nd_region, &uuid); 1747 if (rc) 1748 goto err; 1749 1750 /* Calculate total size and populate namespace properties from label0 */ 1751 for (i = 0; i < nd_region->ndr_mappings; i++) { 1752 struct nd_namespace_label *label0; 1753 struct nvdimm_drvdata *ndd; 1754 1755 nd_mapping = &nd_region->mapping[i]; 1756 label_ent = list_first_entry_or_null(&nd_mapping->labels, 1757 typeof(*label_ent), list); 1758 label0 = label_ent ? label_ent->label : NULL; 1759 1760 if (!label0) { 1761 WARN_ON(1); 1762 continue; 1763 } 1764 1765 ndd = to_ndd(nd_mapping); 1766 size += nsl_get_rawsize(ndd, label0); 1767 if (nsl_get_position(ndd, label0) != 0) 1768 continue; 1769 WARN_ON(nspm->alt_name || nspm->uuid); 1770 nspm->alt_name = kmemdup(nsl_ref_name(ndd, label0), 1771 NSLABEL_NAME_LEN, GFP_KERNEL); 1772 nsl_get_uuid(ndd, label0, &uuid); 1773 nspm->uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL); 1774 nspm->lbasize = nsl_get_lbasize(ndd, label0); 1775 nspm->nsio.common.claim_class = 1776 nsl_get_claim_class(ndd, label0); 1777 } 1778 1779 if (!nspm->alt_name || !nspm->uuid) { 1780 rc = -ENOMEM; 1781 goto err; 1782 } 1783 1784 nd_namespace_pmem_set_resource(nd_region, nspm, size); 1785 1786 return dev; 1787 err: 1788 namespace_pmem_release(dev); 1789 switch (rc) { 1790 case -EINVAL: 1791 dev_dbg(&nd_region->dev, "invalid label(s)\n"); 1792 break; 1793 case -ENODEV: 1794 dev_dbg(&nd_region->dev, "label not found\n"); 1795 break; 1796 default: 1797 dev_dbg(&nd_region->dev, "unexpected err: %d\n", rc); 1798 break; 1799 } 1800 return ERR_PTR(rc); 1801} 1802 1803static struct device *nd_namespace_pmem_create(struct nd_region *nd_region) 1804{ 1805 struct nd_namespace_pmem *nspm; 1806 struct resource *res; 1807 struct device *dev; 1808 1809 if (!is_memory(&nd_region->dev)) 1810 return NULL; 1811 1812 nspm = kzalloc(sizeof(*nspm), GFP_KERNEL); 1813 if (!nspm) 1814 return NULL; 1815 1816 dev = &nspm->nsio.common.dev; 1817 dev->type = &namespace_pmem_device_type; 1818 dev->parent = &nd_region->dev; 1819 res = &nspm->nsio.res; 1820 res->name = dev_name(&nd_region->dev); 1821 res->flags = IORESOURCE_MEM; 1822 1823 nspm->id = ida_alloc(&nd_region->ns_ida, GFP_KERNEL); 1824 if (nspm->id < 0) { 1825 kfree(nspm); 1826 return NULL; 1827 } 1828 dev_set_name(dev, "namespace%d.%d", nd_region->id, nspm->id); 1829 nd_namespace_pmem_set_resource(nd_region, nspm, 0); 1830 1831 return dev; 1832} 1833 1834static struct lock_class_key nvdimm_namespace_key; 1835 1836void nd_region_create_ns_seed(struct nd_region *nd_region) 1837{ 1838 WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev)); 1839 1840 if (nd_region_to_nstype(nd_region) == ND_DEVICE_NAMESPACE_IO) 1841 return; 1842 1843 nd_region->ns_seed = nd_namespace_pmem_create(nd_region); 1844 1845 /* 1846 * Seed creation failures are not fatal, provisioning is simply 1847 * disabled until memory becomes available 1848 */ 1849 if (!nd_region->ns_seed) 1850 dev_err(&nd_region->dev, "failed to create namespace\n"); 1851 else { 1852 device_initialize(nd_region->ns_seed); 1853 lockdep_set_class(&nd_region->ns_seed->mutex, 1854 &nvdimm_namespace_key); 1855 nd_device_register(nd_region->ns_seed); 1856 } 1857} 1858 1859void nd_region_create_dax_seed(struct nd_region *nd_region) 1860{ 1861 WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev)); 1862 nd_region->dax_seed = nd_dax_create(nd_region); 1863 /* 1864 * Seed creation failures are not fatal, provisioning is simply 1865 * disabled until memory becomes available 1866 */ 1867 if (!nd_region->dax_seed) 1868 dev_err(&nd_region->dev, "failed to create dax namespace\n"); 1869} 1870 1871void nd_region_create_pfn_seed(struct nd_region *nd_region) 1872{ 1873 WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev)); 1874 nd_region->pfn_seed = nd_pfn_create(nd_region); 1875 /* 1876 * Seed creation failures are not fatal, provisioning is simply 1877 * disabled until memory becomes available 1878 */ 1879 if (!nd_region->pfn_seed) 1880 dev_err(&nd_region->dev, "failed to create pfn namespace\n"); 1881} 1882 1883void nd_region_create_btt_seed(struct nd_region *nd_region) 1884{ 1885 WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev)); 1886 nd_region->btt_seed = nd_btt_create(nd_region); 1887 /* 1888 * Seed creation failures are not fatal, provisioning is simply 1889 * disabled until memory becomes available 1890 */ 1891 if (!nd_region->btt_seed) 1892 dev_err(&nd_region->dev, "failed to create btt namespace\n"); 1893} 1894 1895static int add_namespace_resource(struct nd_region *nd_region, 1896 struct nd_namespace_label *nd_label, struct device **devs, 1897 int count) 1898{ 1899 struct nd_mapping *nd_mapping = &nd_region->mapping[0]; 1900 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1901 int i; 1902 1903 for (i = 0; i < count; i++) { 1904 uuid_t *uuid = namespace_to_uuid(devs[i]); 1905 1906 if (IS_ERR(uuid)) { 1907 WARN_ON(1); 1908 continue; 1909 } 1910 1911 if (!nsl_uuid_equal(ndd, nd_label, uuid)) 1912 continue; 1913 dev_err(&nd_region->dev, 1914 "error: conflicting extents for uuid: %pUb\n", uuid); 1915 return -ENXIO; 1916 } 1917 1918 return i; 1919} 1920 1921static int cmp_dpa(const void *a, const void *b) 1922{ 1923 const struct device *dev_a = *(const struct device **) a; 1924 const struct device *dev_b = *(const struct device **) b; 1925 struct nd_namespace_pmem *nspm_a, *nspm_b; 1926 1927 if (is_namespace_io(dev_a)) 1928 return 0; 1929 1930 nspm_a = to_nd_namespace_pmem(dev_a); 1931 nspm_b = to_nd_namespace_pmem(dev_b); 1932 1933 return memcmp(&nspm_a->nsio.res.start, &nspm_b->nsio.res.start, 1934 sizeof(resource_size_t)); 1935} 1936 1937static struct device **scan_labels(struct nd_region *nd_region) 1938{ 1939 int i, count = 0; 1940 struct device *dev, **devs = NULL; 1941 struct nd_label_ent *label_ent, *e; 1942 struct nd_mapping *nd_mapping = &nd_region->mapping[0]; 1943 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 1944 resource_size_t map_end = nd_mapping->start + nd_mapping->size - 1; 1945 1946 /* "safe" because create_namespace_pmem() might list_move() label_ent */ 1947 list_for_each_entry_safe(label_ent, e, &nd_mapping->labels, list) { 1948 struct nd_namespace_label *nd_label = label_ent->label; 1949 struct device **__devs; 1950 1951 if (!nd_label) 1952 continue; 1953 1954 /* skip labels that describe extents outside of the region */ 1955 if (nsl_get_dpa(ndd, nd_label) < nd_mapping->start || 1956 nsl_get_dpa(ndd, nd_label) > map_end) 1957 continue; 1958 1959 i = add_namespace_resource(nd_region, nd_label, devs, count); 1960 if (i < 0) 1961 goto err; 1962 if (i < count) 1963 continue; 1964 __devs = kcalloc(count + 2, sizeof(dev), GFP_KERNEL); 1965 if (!__devs) 1966 goto err; 1967 memcpy(__devs, devs, sizeof(dev) * count); 1968 kfree(devs); 1969 devs = __devs; 1970 1971 dev = create_namespace_pmem(nd_region, nd_mapping, nd_label); 1972 if (IS_ERR(dev)) { 1973 switch (PTR_ERR(dev)) { 1974 case -EAGAIN: 1975 /* skip invalid labels */ 1976 continue; 1977 case -ENODEV: 1978 /* fallthrough to seed creation */ 1979 break; 1980 default: 1981 goto err; 1982 } 1983 } else 1984 devs[count++] = dev; 1985 1986 } 1987 1988 dev_dbg(&nd_region->dev, "discovered %d namespace%s\n", count, 1989 count == 1 ? "" : "s"); 1990 1991 if (count == 0) { 1992 struct nd_namespace_pmem *nspm; 1993 1994 /* Publish a zero-sized namespace for userspace to configure. */ 1995 nd_mapping_free_labels(nd_mapping); 1996 1997 devs = kcalloc(2, sizeof(dev), GFP_KERNEL); 1998 if (!devs) 1999 goto err; 2000 2001 nspm = kzalloc(sizeof(*nspm), GFP_KERNEL); 2002 if (!nspm) 2003 goto err; 2004 dev = &nspm->nsio.common.dev; 2005 dev->type = &namespace_pmem_device_type; 2006 nd_namespace_pmem_set_resource(nd_region, nspm, 0); 2007 dev->parent = &nd_region->dev; 2008 devs[count++] = dev; 2009 } else if (is_memory(&nd_region->dev)) { 2010 /* clean unselected labels */ 2011 for (i = 0; i < nd_region->ndr_mappings; i++) { 2012 struct list_head *l, *e; 2013 LIST_HEAD(list); 2014 int j; 2015 2016 nd_mapping = &nd_region->mapping[i]; 2017 if (list_empty(&nd_mapping->labels)) { 2018 WARN_ON(1); 2019 continue; 2020 } 2021 2022 j = count; 2023 list_for_each_safe(l, e, &nd_mapping->labels) { 2024 if (!j--) 2025 break; 2026 list_move_tail(l, &list); 2027 } 2028 nd_mapping_free_labels(nd_mapping); 2029 list_splice_init(&list, &nd_mapping->labels); 2030 } 2031 } 2032 2033 if (count > 1) 2034 sort(devs, count, sizeof(struct device *), cmp_dpa, NULL); 2035 2036 return devs; 2037 2038 err: 2039 if (devs) { 2040 for (i = 0; devs[i]; i++) 2041 namespace_pmem_release(devs[i]); 2042 kfree(devs); 2043 } 2044 return NULL; 2045} 2046 2047static struct device **create_namespaces(struct nd_region *nd_region) 2048{ 2049 struct nd_mapping *nd_mapping; 2050 struct device **devs; 2051 int i; 2052 2053 if (nd_region->ndr_mappings == 0) 2054 return NULL; 2055 2056 /* lock down all mappings while we scan labels */ 2057 for (i = 0; i < nd_region->ndr_mappings; i++) { 2058 nd_mapping = &nd_region->mapping[i]; 2059 mutex_lock_nested(&nd_mapping->lock, i); 2060 } 2061 2062 devs = scan_labels(nd_region); 2063 2064 for (i = 0; i < nd_region->ndr_mappings; i++) { 2065 int reverse = nd_region->ndr_mappings - 1 - i; 2066 2067 nd_mapping = &nd_region->mapping[reverse]; 2068 mutex_unlock(&nd_mapping->lock); 2069 } 2070 2071 return devs; 2072} 2073 2074static void deactivate_labels(void *region) 2075{ 2076 struct nd_region *nd_region = region; 2077 int i; 2078 2079 for (i = 0; i < nd_region->ndr_mappings; i++) { 2080 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 2081 struct nvdimm_drvdata *ndd = nd_mapping->ndd; 2082 struct nvdimm *nvdimm = nd_mapping->nvdimm; 2083 2084 mutex_lock(&nd_mapping->lock); 2085 nd_mapping_free_labels(nd_mapping); 2086 mutex_unlock(&nd_mapping->lock); 2087 2088 put_ndd(ndd); 2089 nd_mapping->ndd = NULL; 2090 if (ndd) 2091 atomic_dec(&nvdimm->busy); 2092 } 2093} 2094 2095static int init_active_labels(struct nd_region *nd_region) 2096{ 2097 int i, rc = 0; 2098 2099 for (i = 0; i < nd_region->ndr_mappings; i++) { 2100 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 2101 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 2102 struct nvdimm *nvdimm = nd_mapping->nvdimm; 2103 struct nd_label_ent *label_ent; 2104 int count, j; 2105 2106 /* 2107 * If the dimm is disabled then we may need to prevent 2108 * the region from being activated. 2109 */ 2110 if (!ndd) { 2111 if (test_bit(NDD_LOCKED, &nvdimm->flags)) 2112 /* fail, label data may be unreadable */; 2113 else if (test_bit(NDD_LABELING, &nvdimm->flags)) 2114 /* fail, labels needed to disambiguate dpa */; 2115 else 2116 continue; 2117 2118 dev_err(&nd_region->dev, "%s: is %s, failing probe\n", 2119 dev_name(&nd_mapping->nvdimm->dev), 2120 test_bit(NDD_LOCKED, &nvdimm->flags) 2121 ? "locked" : "disabled"); 2122 rc = -ENXIO; 2123 goto out; 2124 } 2125 nd_mapping->ndd = ndd; 2126 atomic_inc(&nvdimm->busy); 2127 get_ndd(ndd); 2128 2129 count = nd_label_active_count(ndd); 2130 dev_dbg(ndd->dev, "count: %d\n", count); 2131 if (!count) 2132 continue; 2133 for (j = 0; j < count; j++) { 2134 struct nd_namespace_label *label; 2135 2136 label_ent = kzalloc(sizeof(*label_ent), GFP_KERNEL); 2137 if (!label_ent) 2138 break; 2139 label = nd_label_active(ndd, j); 2140 label_ent->label = label; 2141 2142 mutex_lock(&nd_mapping->lock); 2143 list_add_tail(&label_ent->list, &nd_mapping->labels); 2144 mutex_unlock(&nd_mapping->lock); 2145 } 2146 2147 if (j < count) 2148 break; 2149 } 2150 2151 if (i < nd_region->ndr_mappings) 2152 rc = -ENOMEM; 2153 2154out: 2155 if (rc) { 2156 deactivate_labels(nd_region); 2157 return rc; 2158 } 2159 2160 return devm_add_action_or_reset(&nd_region->dev, deactivate_labels, 2161 nd_region); 2162} 2163 2164int nd_region_register_namespaces(struct nd_region *nd_region, int *err) 2165{ 2166 struct device **devs = NULL; 2167 int i, rc = 0, type; 2168 2169 *err = 0; 2170 nvdimm_bus_lock(&nd_region->dev); 2171 rc = init_active_labels(nd_region); 2172 if (rc) { 2173 nvdimm_bus_unlock(&nd_region->dev); 2174 return rc; 2175 } 2176 2177 type = nd_region_to_nstype(nd_region); 2178 switch (type) { 2179 case ND_DEVICE_NAMESPACE_IO: 2180 devs = create_namespace_io(nd_region); 2181 break; 2182 case ND_DEVICE_NAMESPACE_PMEM: 2183 devs = create_namespaces(nd_region); 2184 break; 2185 default: 2186 break; 2187 } 2188 nvdimm_bus_unlock(&nd_region->dev); 2189 2190 if (!devs) 2191 return -ENODEV; 2192 2193 for (i = 0; devs[i]; i++) { 2194 struct device *dev = devs[i]; 2195 int id; 2196 2197 if (type == ND_DEVICE_NAMESPACE_PMEM) { 2198 struct nd_namespace_pmem *nspm; 2199 2200 nspm = to_nd_namespace_pmem(dev); 2201 id = ida_alloc(&nd_region->ns_ida, GFP_KERNEL); 2202 nspm->id = id; 2203 } else 2204 id = i; 2205 2206 if (id < 0) 2207 break; 2208 dev_set_name(dev, "namespace%d.%d", nd_region->id, id); 2209 device_initialize(dev); 2210 lockdep_set_class(&dev->mutex, &nvdimm_namespace_key); 2211 nd_device_register(dev); 2212 } 2213 if (i) 2214 nd_region->ns_seed = devs[0]; 2215 2216 if (devs[i]) { 2217 int j; 2218 2219 for (j = i; devs[j]; j++) { 2220 struct device *dev = devs[j]; 2221 2222 device_initialize(dev); 2223 put_device(dev); 2224 } 2225 *err = j - i; 2226 /* 2227 * All of the namespaces we tried to register failed, so 2228 * fail region activation. 2229 */ 2230 if (*err == 0) 2231 rc = -ENODEV; 2232 } 2233 kfree(devs); 2234 2235 if (rc == -ENODEV) 2236 return rc; 2237 2238 return i; 2239} 2240