1 /* 2 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of version 2 of the GNU General Public License as 6 * published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 */ 13 #include <linux/scatterlist.h> 14 #include <linux/highmem.h> 15 #include <linux/sched.h> 16 #include <linux/slab.h> 17 #include <linux/sort.h> 18 #include <linux/io.h> 19 #include <linux/nd.h> 20 #include "nd-core.h" 21 #include "nd.h" 22 23 static DEFINE_IDA(region_ida); 24 25 static void nd_region_release(struct device *dev) 26 { 27 struct nd_region *nd_region = to_nd_region(dev); 28 u16 i; 29 30 for (i = 0; i < nd_region->ndr_mappings; i++) { 31 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 32 struct nvdimm *nvdimm = nd_mapping->nvdimm; 33 34 put_device(&nvdimm->dev); 35 } 36 free_percpu(nd_region->lane); 37 ida_simple_remove(®ion_ida, nd_region->id); 38 if (is_nd_blk(dev)) 39 kfree(to_nd_blk_region(dev)); 40 else 41 kfree(nd_region); 42 } 43 44 static struct device_type nd_blk_device_type = { 45 .name = "nd_blk", 46 .release = nd_region_release, 47 }; 48 49 static struct device_type nd_pmem_device_type = { 50 .name = "nd_pmem", 51 .release = nd_region_release, 52 }; 53 54 static struct device_type nd_volatile_device_type = { 55 .name = "nd_volatile", 56 .release = nd_region_release, 57 }; 58 59 bool is_nd_pmem(struct device *dev) 60 { 61 return dev ? dev->type == &nd_pmem_device_type : false; 62 } 63 64 bool is_nd_blk(struct device *dev) 65 { 66 return dev ? dev->type == &nd_blk_device_type : false; 67 } 68 69 struct nd_region *to_nd_region(struct device *dev) 70 { 71 struct nd_region *nd_region = container_of(dev, struct nd_region, dev); 72 73 WARN_ON(dev->type->release != nd_region_release); 74 return nd_region; 75 } 76 EXPORT_SYMBOL_GPL(to_nd_region); 77 78 struct nd_blk_region *to_nd_blk_region(struct device *dev) 79 { 80 struct nd_region *nd_region = to_nd_region(dev); 81 82 WARN_ON(!is_nd_blk(dev)); 83 return container_of(nd_region, struct nd_blk_region, nd_region); 84 } 85 EXPORT_SYMBOL_GPL(to_nd_blk_region); 86 87 void *nd_region_provider_data(struct nd_region *nd_region) 88 { 89 return nd_region->provider_data; 90 } 91 EXPORT_SYMBOL_GPL(nd_region_provider_data); 92 93 void *nd_blk_region_provider_data(struct nd_blk_region *ndbr) 94 { 95 return ndbr->blk_provider_data; 96 } 97 EXPORT_SYMBOL_GPL(nd_blk_region_provider_data); 98 99 void nd_blk_region_set_provider_data(struct nd_blk_region *ndbr, void *data) 100 { 101 ndbr->blk_provider_data = data; 102 } 103 EXPORT_SYMBOL_GPL(nd_blk_region_set_provider_data); 104 105 /** 106 * nd_region_to_nstype() - region to an integer namespace type 107 * @nd_region: region-device to interrogate 108 * 109 * This is the 'nstype' attribute of a region as well, an input to the 110 * MODALIAS for namespace devices, and bit number for a nvdimm_bus to match 111 * namespace devices with namespace drivers. 112 */ 113 int nd_region_to_nstype(struct nd_region *nd_region) 114 { 115 if (is_nd_pmem(&nd_region->dev)) { 116 u16 i, alias; 117 118 for (i = 0, alias = 0; i < nd_region->ndr_mappings; i++) { 119 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 120 struct nvdimm *nvdimm = nd_mapping->nvdimm; 121 122 if (nvdimm->flags & NDD_ALIASING) 123 alias++; 124 } 125 if (alias) 126 return ND_DEVICE_NAMESPACE_PMEM; 127 else 128 return ND_DEVICE_NAMESPACE_IO; 129 } else if (is_nd_blk(&nd_region->dev)) { 130 return ND_DEVICE_NAMESPACE_BLK; 131 } 132 133 return 0; 134 } 135 EXPORT_SYMBOL(nd_region_to_nstype); 136 137 static ssize_t size_show(struct device *dev, 138 struct device_attribute *attr, char *buf) 139 { 140 struct nd_region *nd_region = to_nd_region(dev); 141 unsigned long long size = 0; 142 143 if (is_nd_pmem(dev)) { 144 size = nd_region->ndr_size; 145 } else if (nd_region->ndr_mappings == 1) { 146 struct nd_mapping *nd_mapping = &nd_region->mapping[0]; 147 148 size = nd_mapping->size; 149 } 150 151 return sprintf(buf, "%llu\n", size); 152 } 153 static DEVICE_ATTR_RO(size); 154 155 static ssize_t mappings_show(struct device *dev, 156 struct device_attribute *attr, char *buf) 157 { 158 struct nd_region *nd_region = to_nd_region(dev); 159 160 return sprintf(buf, "%d\n", nd_region->ndr_mappings); 161 } 162 static DEVICE_ATTR_RO(mappings); 163 164 static ssize_t nstype_show(struct device *dev, 165 struct device_attribute *attr, char *buf) 166 { 167 struct nd_region *nd_region = to_nd_region(dev); 168 169 return sprintf(buf, "%d\n", nd_region_to_nstype(nd_region)); 170 } 171 static DEVICE_ATTR_RO(nstype); 172 173 static ssize_t set_cookie_show(struct device *dev, 174 struct device_attribute *attr, char *buf) 175 { 176 struct nd_region *nd_region = to_nd_region(dev); 177 struct nd_interleave_set *nd_set = nd_region->nd_set; 178 179 if (is_nd_pmem(dev) && nd_set) 180 /* pass, should be precluded by region_visible */; 181 else 182 return -ENXIO; 183 184 return sprintf(buf, "%#llx\n", nd_set->cookie); 185 } 186 static DEVICE_ATTR_RO(set_cookie); 187 188 resource_size_t nd_region_available_dpa(struct nd_region *nd_region) 189 { 190 resource_size_t blk_max_overlap = 0, available, overlap; 191 int i; 192 193 WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev)); 194 195 retry: 196 available = 0; 197 overlap = blk_max_overlap; 198 for (i = 0; i < nd_region->ndr_mappings; i++) { 199 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 200 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); 201 202 /* if a dimm is disabled the available capacity is zero */ 203 if (!ndd) 204 return 0; 205 206 if (is_nd_pmem(&nd_region->dev)) { 207 available += nd_pmem_available_dpa(nd_region, 208 nd_mapping, &overlap); 209 if (overlap > blk_max_overlap) { 210 blk_max_overlap = overlap; 211 goto retry; 212 } 213 } else if (is_nd_blk(&nd_region->dev)) { 214 available += nd_blk_available_dpa(nd_mapping); 215 } 216 } 217 218 return available; 219 } 220 221 static ssize_t available_size_show(struct device *dev, 222 struct device_attribute *attr, char *buf) 223 { 224 struct nd_region *nd_region = to_nd_region(dev); 225 unsigned long long available = 0; 226 227 /* 228 * Flush in-flight updates and grab a snapshot of the available 229 * size. Of course, this value is potentially invalidated the 230 * memory nvdimm_bus_lock() is dropped, but that's userspace's 231 * problem to not race itself. 232 */ 233 nvdimm_bus_lock(dev); 234 wait_nvdimm_bus_probe_idle(dev); 235 available = nd_region_available_dpa(nd_region); 236 nvdimm_bus_unlock(dev); 237 238 return sprintf(buf, "%llu\n", available); 239 } 240 static DEVICE_ATTR_RO(available_size); 241 242 static ssize_t init_namespaces_show(struct device *dev, 243 struct device_attribute *attr, char *buf) 244 { 245 struct nd_region_namespaces *num_ns = dev_get_drvdata(dev); 246 ssize_t rc; 247 248 nvdimm_bus_lock(dev); 249 if (num_ns) 250 rc = sprintf(buf, "%d/%d\n", num_ns->active, num_ns->count); 251 else 252 rc = -ENXIO; 253 nvdimm_bus_unlock(dev); 254 255 return rc; 256 } 257 static DEVICE_ATTR_RO(init_namespaces); 258 259 static ssize_t namespace_seed_show(struct device *dev, 260 struct device_attribute *attr, char *buf) 261 { 262 struct nd_region *nd_region = to_nd_region(dev); 263 ssize_t rc; 264 265 nvdimm_bus_lock(dev); 266 if (nd_region->ns_seed) 267 rc = sprintf(buf, "%s\n", dev_name(nd_region->ns_seed)); 268 else 269 rc = sprintf(buf, "\n"); 270 nvdimm_bus_unlock(dev); 271 return rc; 272 } 273 static DEVICE_ATTR_RO(namespace_seed); 274 275 static ssize_t btt_seed_show(struct device *dev, 276 struct device_attribute *attr, char *buf) 277 { 278 struct nd_region *nd_region = to_nd_region(dev); 279 ssize_t rc; 280 281 nvdimm_bus_lock(dev); 282 if (nd_region->btt_seed) 283 rc = sprintf(buf, "%s\n", dev_name(nd_region->btt_seed)); 284 else 285 rc = sprintf(buf, "\n"); 286 nvdimm_bus_unlock(dev); 287 288 return rc; 289 } 290 static DEVICE_ATTR_RO(btt_seed); 291 292 static ssize_t pfn_seed_show(struct device *dev, 293 struct device_attribute *attr, char *buf) 294 { 295 struct nd_region *nd_region = to_nd_region(dev); 296 ssize_t rc; 297 298 nvdimm_bus_lock(dev); 299 if (nd_region->pfn_seed) 300 rc = sprintf(buf, "%s\n", dev_name(nd_region->pfn_seed)); 301 else 302 rc = sprintf(buf, "\n"); 303 nvdimm_bus_unlock(dev); 304 305 return rc; 306 } 307 static DEVICE_ATTR_RO(pfn_seed); 308 309 static ssize_t dax_seed_show(struct device *dev, 310 struct device_attribute *attr, char *buf) 311 { 312 struct nd_region *nd_region = to_nd_region(dev); 313 ssize_t rc; 314 315 nvdimm_bus_lock(dev); 316 if (nd_region->dax_seed) 317 rc = sprintf(buf, "%s\n", dev_name(nd_region->dax_seed)); 318 else 319 rc = sprintf(buf, "\n"); 320 nvdimm_bus_unlock(dev); 321 322 return rc; 323 } 324 static DEVICE_ATTR_RO(dax_seed); 325 326 static ssize_t read_only_show(struct device *dev, 327 struct device_attribute *attr, char *buf) 328 { 329 struct nd_region *nd_region = to_nd_region(dev); 330 331 return sprintf(buf, "%d\n", nd_region->ro); 332 } 333 334 static ssize_t read_only_store(struct device *dev, 335 struct device_attribute *attr, const char *buf, size_t len) 336 { 337 bool ro; 338 int rc = strtobool(buf, &ro); 339 struct nd_region *nd_region = to_nd_region(dev); 340 341 if (rc) 342 return rc; 343 344 nd_region->ro = ro; 345 return len; 346 } 347 static DEVICE_ATTR_RW(read_only); 348 349 static struct attribute *nd_region_attributes[] = { 350 &dev_attr_size.attr, 351 &dev_attr_nstype.attr, 352 &dev_attr_mappings.attr, 353 &dev_attr_btt_seed.attr, 354 &dev_attr_pfn_seed.attr, 355 &dev_attr_dax_seed.attr, 356 &dev_attr_read_only.attr, 357 &dev_attr_set_cookie.attr, 358 &dev_attr_available_size.attr, 359 &dev_attr_namespace_seed.attr, 360 &dev_attr_init_namespaces.attr, 361 NULL, 362 }; 363 364 static umode_t region_visible(struct kobject *kobj, struct attribute *a, int n) 365 { 366 struct device *dev = container_of(kobj, typeof(*dev), kobj); 367 struct nd_region *nd_region = to_nd_region(dev); 368 struct nd_interleave_set *nd_set = nd_region->nd_set; 369 int type = nd_region_to_nstype(nd_region); 370 371 if (!is_nd_pmem(dev) && a == &dev_attr_pfn_seed.attr) 372 return 0; 373 374 if (!is_nd_pmem(dev) && a == &dev_attr_dax_seed.attr) 375 return 0; 376 377 if (a != &dev_attr_set_cookie.attr 378 && a != &dev_attr_available_size.attr) 379 return a->mode; 380 381 if ((type == ND_DEVICE_NAMESPACE_PMEM 382 || type == ND_DEVICE_NAMESPACE_BLK) 383 && a == &dev_attr_available_size.attr) 384 return a->mode; 385 else if (is_nd_pmem(dev) && nd_set) 386 return a->mode; 387 388 return 0; 389 } 390 391 struct attribute_group nd_region_attribute_group = { 392 .attrs = nd_region_attributes, 393 .is_visible = region_visible, 394 }; 395 EXPORT_SYMBOL_GPL(nd_region_attribute_group); 396 397 u64 nd_region_interleave_set_cookie(struct nd_region *nd_region) 398 { 399 struct nd_interleave_set *nd_set = nd_region->nd_set; 400 401 if (nd_set) 402 return nd_set->cookie; 403 return 0; 404 } 405 406 /* 407 * Upon successful probe/remove, take/release a reference on the 408 * associated interleave set (if present), and plant new btt + namespace 409 * seeds. Also, on the removal of a BLK region, notify the provider to 410 * disable the region. 411 */ 412 static void nd_region_notify_driver_action(struct nvdimm_bus *nvdimm_bus, 413 struct device *dev, bool probe) 414 { 415 struct nd_region *nd_region; 416 417 if (!probe && (is_nd_pmem(dev) || is_nd_blk(dev))) { 418 int i; 419 420 nd_region = to_nd_region(dev); 421 for (i = 0; i < nd_region->ndr_mappings; i++) { 422 struct nd_mapping *nd_mapping = &nd_region->mapping[i]; 423 struct nvdimm_drvdata *ndd = nd_mapping->ndd; 424 struct nvdimm *nvdimm = nd_mapping->nvdimm; 425 426 kfree(nd_mapping->labels); 427 nd_mapping->labels = NULL; 428 put_ndd(ndd); 429 nd_mapping->ndd = NULL; 430 if (ndd) 431 atomic_dec(&nvdimm->busy); 432 } 433 434 if (is_nd_pmem(dev)) 435 return; 436 } 437 if (dev->parent && is_nd_blk(dev->parent) && probe) { 438 nd_region = to_nd_region(dev->parent); 439 nvdimm_bus_lock(dev); 440 if (nd_region->ns_seed == dev) 441 nd_region_create_blk_seed(nd_region); 442 nvdimm_bus_unlock(dev); 443 } 444 if (is_nd_btt(dev) && probe) { 445 struct nd_btt *nd_btt = to_nd_btt(dev); 446 447 nd_region = to_nd_region(dev->parent); 448 nvdimm_bus_lock(dev); 449 if (nd_region->btt_seed == dev) 450 nd_region_create_btt_seed(nd_region); 451 if (nd_region->ns_seed == &nd_btt->ndns->dev && 452 is_nd_blk(dev->parent)) 453 nd_region_create_blk_seed(nd_region); 454 nvdimm_bus_unlock(dev); 455 } 456 if (is_nd_pfn(dev) && probe) { 457 nd_region = to_nd_region(dev->parent); 458 nvdimm_bus_lock(dev); 459 if (nd_region->pfn_seed == dev) 460 nd_region_create_pfn_seed(nd_region); 461 nvdimm_bus_unlock(dev); 462 } 463 if (is_nd_dax(dev) && probe) { 464 nd_region = to_nd_region(dev->parent); 465 nvdimm_bus_lock(dev); 466 if (nd_region->dax_seed == dev) 467 nd_region_create_dax_seed(nd_region); 468 nvdimm_bus_unlock(dev); 469 } 470 } 471 472 void nd_region_probe_success(struct nvdimm_bus *nvdimm_bus, struct device *dev) 473 { 474 nd_region_notify_driver_action(nvdimm_bus, dev, true); 475 } 476 477 void nd_region_disable(struct nvdimm_bus *nvdimm_bus, struct device *dev) 478 { 479 nd_region_notify_driver_action(nvdimm_bus, dev, false); 480 } 481 482 static ssize_t mappingN(struct device *dev, char *buf, int n) 483 { 484 struct nd_region *nd_region = to_nd_region(dev); 485 struct nd_mapping *nd_mapping; 486 struct nvdimm *nvdimm; 487 488 if (n >= nd_region->ndr_mappings) 489 return -ENXIO; 490 nd_mapping = &nd_region->mapping[n]; 491 nvdimm = nd_mapping->nvdimm; 492 493 return sprintf(buf, "%s,%llu,%llu\n", dev_name(&nvdimm->dev), 494 nd_mapping->start, nd_mapping->size); 495 } 496 497 #define REGION_MAPPING(idx) \ 498 static ssize_t mapping##idx##_show(struct device *dev, \ 499 struct device_attribute *attr, char *buf) \ 500 { \ 501 return mappingN(dev, buf, idx); \ 502 } \ 503 static DEVICE_ATTR_RO(mapping##idx) 504 505 /* 506 * 32 should be enough for a while, even in the presence of socket 507 * interleave a 32-way interleave set is a degenerate case. 508 */ 509 REGION_MAPPING(0); 510 REGION_MAPPING(1); 511 REGION_MAPPING(2); 512 REGION_MAPPING(3); 513 REGION_MAPPING(4); 514 REGION_MAPPING(5); 515 REGION_MAPPING(6); 516 REGION_MAPPING(7); 517 REGION_MAPPING(8); 518 REGION_MAPPING(9); 519 REGION_MAPPING(10); 520 REGION_MAPPING(11); 521 REGION_MAPPING(12); 522 REGION_MAPPING(13); 523 REGION_MAPPING(14); 524 REGION_MAPPING(15); 525 REGION_MAPPING(16); 526 REGION_MAPPING(17); 527 REGION_MAPPING(18); 528 REGION_MAPPING(19); 529 REGION_MAPPING(20); 530 REGION_MAPPING(21); 531 REGION_MAPPING(22); 532 REGION_MAPPING(23); 533 REGION_MAPPING(24); 534 REGION_MAPPING(25); 535 REGION_MAPPING(26); 536 REGION_MAPPING(27); 537 REGION_MAPPING(28); 538 REGION_MAPPING(29); 539 REGION_MAPPING(30); 540 REGION_MAPPING(31); 541 542 static umode_t mapping_visible(struct kobject *kobj, struct attribute *a, int n) 543 { 544 struct device *dev = container_of(kobj, struct device, kobj); 545 struct nd_region *nd_region = to_nd_region(dev); 546 547 if (n < nd_region->ndr_mappings) 548 return a->mode; 549 return 0; 550 } 551 552 static struct attribute *mapping_attributes[] = { 553 &dev_attr_mapping0.attr, 554 &dev_attr_mapping1.attr, 555 &dev_attr_mapping2.attr, 556 &dev_attr_mapping3.attr, 557 &dev_attr_mapping4.attr, 558 &dev_attr_mapping5.attr, 559 &dev_attr_mapping6.attr, 560 &dev_attr_mapping7.attr, 561 &dev_attr_mapping8.attr, 562 &dev_attr_mapping9.attr, 563 &dev_attr_mapping10.attr, 564 &dev_attr_mapping11.attr, 565 &dev_attr_mapping12.attr, 566 &dev_attr_mapping13.attr, 567 &dev_attr_mapping14.attr, 568 &dev_attr_mapping15.attr, 569 &dev_attr_mapping16.attr, 570 &dev_attr_mapping17.attr, 571 &dev_attr_mapping18.attr, 572 &dev_attr_mapping19.attr, 573 &dev_attr_mapping20.attr, 574 &dev_attr_mapping21.attr, 575 &dev_attr_mapping22.attr, 576 &dev_attr_mapping23.attr, 577 &dev_attr_mapping24.attr, 578 &dev_attr_mapping25.attr, 579 &dev_attr_mapping26.attr, 580 &dev_attr_mapping27.attr, 581 &dev_attr_mapping28.attr, 582 &dev_attr_mapping29.attr, 583 &dev_attr_mapping30.attr, 584 &dev_attr_mapping31.attr, 585 NULL, 586 }; 587 588 struct attribute_group nd_mapping_attribute_group = { 589 .is_visible = mapping_visible, 590 .attrs = mapping_attributes, 591 }; 592 EXPORT_SYMBOL_GPL(nd_mapping_attribute_group); 593 594 int nd_blk_region_init(struct nd_region *nd_region) 595 { 596 struct device *dev = &nd_region->dev; 597 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev); 598 599 if (!is_nd_blk(dev)) 600 return 0; 601 602 if (nd_region->ndr_mappings < 1) { 603 dev_err(dev, "invalid BLK region\n"); 604 return -ENXIO; 605 } 606 607 return to_nd_blk_region(dev)->enable(nvdimm_bus, dev); 608 } 609 610 /** 611 * nd_region_acquire_lane - allocate and lock a lane 612 * @nd_region: region id and number of lanes possible 613 * 614 * A lane correlates to a BLK-data-window and/or a log slot in the BTT. 615 * We optimize for the common case where there are 256 lanes, one 616 * per-cpu. For larger systems we need to lock to share lanes. For now 617 * this implementation assumes the cost of maintaining an allocator for 618 * free lanes is on the order of the lock hold time, so it implements a 619 * static lane = cpu % num_lanes mapping. 620 * 621 * In the case of a BTT instance on top of a BLK namespace a lane may be 622 * acquired recursively. We lock on the first instance. 623 * 624 * In the case of a BTT instance on top of PMEM, we only acquire a lane 625 * for the BTT metadata updates. 626 */ 627 unsigned int nd_region_acquire_lane(struct nd_region *nd_region) 628 { 629 unsigned int cpu, lane; 630 631 cpu = get_cpu(); 632 if (nd_region->num_lanes < nr_cpu_ids) { 633 struct nd_percpu_lane *ndl_lock, *ndl_count; 634 635 lane = cpu % nd_region->num_lanes; 636 ndl_count = per_cpu_ptr(nd_region->lane, cpu); 637 ndl_lock = per_cpu_ptr(nd_region->lane, lane); 638 if (ndl_count->count++ == 0) 639 spin_lock(&ndl_lock->lock); 640 } else 641 lane = cpu; 642 643 return lane; 644 } 645 EXPORT_SYMBOL(nd_region_acquire_lane); 646 647 void nd_region_release_lane(struct nd_region *nd_region, unsigned int lane) 648 { 649 if (nd_region->num_lanes < nr_cpu_ids) { 650 unsigned int cpu = get_cpu(); 651 struct nd_percpu_lane *ndl_lock, *ndl_count; 652 653 ndl_count = per_cpu_ptr(nd_region->lane, cpu); 654 ndl_lock = per_cpu_ptr(nd_region->lane, lane); 655 if (--ndl_count->count == 0) 656 spin_unlock(&ndl_lock->lock); 657 put_cpu(); 658 } 659 put_cpu(); 660 } 661 EXPORT_SYMBOL(nd_region_release_lane); 662 663 static struct nd_region *nd_region_create(struct nvdimm_bus *nvdimm_bus, 664 struct nd_region_desc *ndr_desc, struct device_type *dev_type, 665 const char *caller) 666 { 667 struct nd_region *nd_region; 668 struct device *dev; 669 void *region_buf; 670 unsigned int i; 671 int ro = 0; 672 673 for (i = 0; i < ndr_desc->num_mappings; i++) { 674 struct nd_mapping *nd_mapping = &ndr_desc->nd_mapping[i]; 675 struct nvdimm *nvdimm = nd_mapping->nvdimm; 676 677 if ((nd_mapping->start | nd_mapping->size) % SZ_4K) { 678 dev_err(&nvdimm_bus->dev, "%s: %s mapping%d is not 4K aligned\n", 679 caller, dev_name(&nvdimm->dev), i); 680 681 return NULL; 682 } 683 684 if (nvdimm->flags & NDD_UNARMED) 685 ro = 1; 686 } 687 688 if (dev_type == &nd_blk_device_type) { 689 struct nd_blk_region_desc *ndbr_desc; 690 struct nd_blk_region *ndbr; 691 692 ndbr_desc = to_blk_region_desc(ndr_desc); 693 ndbr = kzalloc(sizeof(*ndbr) + sizeof(struct nd_mapping) 694 * ndr_desc->num_mappings, 695 GFP_KERNEL); 696 if (ndbr) { 697 nd_region = &ndbr->nd_region; 698 ndbr->enable = ndbr_desc->enable; 699 ndbr->do_io = ndbr_desc->do_io; 700 } 701 region_buf = ndbr; 702 } else { 703 nd_region = kzalloc(sizeof(struct nd_region) 704 + sizeof(struct nd_mapping) 705 * ndr_desc->num_mappings, 706 GFP_KERNEL); 707 region_buf = nd_region; 708 } 709 710 if (!region_buf) 711 return NULL; 712 nd_region->id = ida_simple_get(®ion_ida, 0, 0, GFP_KERNEL); 713 if (nd_region->id < 0) 714 goto err_id; 715 716 nd_region->lane = alloc_percpu(struct nd_percpu_lane); 717 if (!nd_region->lane) 718 goto err_percpu; 719 720 for (i = 0; i < nr_cpu_ids; i++) { 721 struct nd_percpu_lane *ndl; 722 723 ndl = per_cpu_ptr(nd_region->lane, i); 724 spin_lock_init(&ndl->lock); 725 ndl->count = 0; 726 } 727 728 memcpy(nd_region->mapping, ndr_desc->nd_mapping, 729 sizeof(struct nd_mapping) * ndr_desc->num_mappings); 730 for (i = 0; i < ndr_desc->num_mappings; i++) { 731 struct nd_mapping *nd_mapping = &ndr_desc->nd_mapping[i]; 732 struct nvdimm *nvdimm = nd_mapping->nvdimm; 733 734 get_device(&nvdimm->dev); 735 } 736 nd_region->ndr_mappings = ndr_desc->num_mappings; 737 nd_region->provider_data = ndr_desc->provider_data; 738 nd_region->nd_set = ndr_desc->nd_set; 739 nd_region->num_lanes = ndr_desc->num_lanes; 740 nd_region->flags = ndr_desc->flags; 741 nd_region->ro = ro; 742 nd_region->numa_node = ndr_desc->numa_node; 743 ida_init(&nd_region->ns_ida); 744 ida_init(&nd_region->btt_ida); 745 ida_init(&nd_region->pfn_ida); 746 ida_init(&nd_region->dax_ida); 747 dev = &nd_region->dev; 748 dev_set_name(dev, "region%d", nd_region->id); 749 dev->parent = &nvdimm_bus->dev; 750 dev->type = dev_type; 751 dev->groups = ndr_desc->attr_groups; 752 nd_region->ndr_size = resource_size(ndr_desc->res); 753 nd_region->ndr_start = ndr_desc->res->start; 754 nd_device_register(dev); 755 756 return nd_region; 757 758 err_percpu: 759 ida_simple_remove(®ion_ida, nd_region->id); 760 err_id: 761 kfree(region_buf); 762 return NULL; 763 } 764 765 struct nd_region *nvdimm_pmem_region_create(struct nvdimm_bus *nvdimm_bus, 766 struct nd_region_desc *ndr_desc) 767 { 768 ndr_desc->num_lanes = ND_MAX_LANES; 769 return nd_region_create(nvdimm_bus, ndr_desc, &nd_pmem_device_type, 770 __func__); 771 } 772 EXPORT_SYMBOL_GPL(nvdimm_pmem_region_create); 773 774 struct nd_region *nvdimm_blk_region_create(struct nvdimm_bus *nvdimm_bus, 775 struct nd_region_desc *ndr_desc) 776 { 777 if (ndr_desc->num_mappings > 1) 778 return NULL; 779 ndr_desc->num_lanes = min(ndr_desc->num_lanes, ND_MAX_LANES); 780 return nd_region_create(nvdimm_bus, ndr_desc, &nd_blk_device_type, 781 __func__); 782 } 783 EXPORT_SYMBOL_GPL(nvdimm_blk_region_create); 784 785 struct nd_region *nvdimm_volatile_region_create(struct nvdimm_bus *nvdimm_bus, 786 struct nd_region_desc *ndr_desc) 787 { 788 ndr_desc->num_lanes = ND_MAX_LANES; 789 return nd_region_create(nvdimm_bus, ndr_desc, &nd_volatile_device_type, 790 __func__); 791 } 792 EXPORT_SYMBOL_GPL(nvdimm_volatile_region_create); 793 794 void __exit nd_region_devs_exit(void) 795 { 796 ida_destroy(®ion_ida); 797 } 798