1 /* 2 * Copyright(c) 2013-2016 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/memremap.h> 14 #include <linux/blkdev.h> 15 #include <linux/device.h> 16 #include <linux/genhd.h> 17 #include <linux/sizes.h> 18 #include <linux/slab.h> 19 #include <linux/fs.h> 20 #include <linux/mm.h> 21 #include "nd-core.h" 22 #include "pfn.h" 23 #include "nd.h" 24 25 static void nd_pfn_release(struct device *dev) 26 { 27 struct nd_region *nd_region = to_nd_region(dev->parent); 28 struct nd_pfn *nd_pfn = to_nd_pfn(dev); 29 30 dev_dbg(dev, "%s\n", __func__); 31 nd_detach_ndns(&nd_pfn->dev, &nd_pfn->ndns); 32 ida_simple_remove(&nd_region->pfn_ida, nd_pfn->id); 33 kfree(nd_pfn->uuid); 34 kfree(nd_pfn); 35 } 36 37 static struct device_type nd_pfn_device_type = { 38 .name = "nd_pfn", 39 .release = nd_pfn_release, 40 }; 41 42 bool is_nd_pfn(struct device *dev) 43 { 44 return dev ? dev->type == &nd_pfn_device_type : false; 45 } 46 EXPORT_SYMBOL(is_nd_pfn); 47 48 struct nd_pfn *to_nd_pfn(struct device *dev) 49 { 50 struct nd_pfn *nd_pfn = container_of(dev, struct nd_pfn, dev); 51 52 WARN_ON(!is_nd_pfn(dev)); 53 return nd_pfn; 54 } 55 EXPORT_SYMBOL(to_nd_pfn); 56 57 static ssize_t mode_show(struct device *dev, 58 struct device_attribute *attr, char *buf) 59 { 60 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 61 62 switch (nd_pfn->mode) { 63 case PFN_MODE_RAM: 64 return sprintf(buf, "ram\n"); 65 case PFN_MODE_PMEM: 66 return sprintf(buf, "pmem\n"); 67 default: 68 return sprintf(buf, "none\n"); 69 } 70 } 71 72 static ssize_t mode_store(struct device *dev, 73 struct device_attribute *attr, const char *buf, size_t len) 74 { 75 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 76 ssize_t rc = 0; 77 78 device_lock(dev); 79 nvdimm_bus_lock(dev); 80 if (dev->driver) 81 rc = -EBUSY; 82 else { 83 size_t n = len - 1; 84 85 if (strncmp(buf, "pmem\n", n) == 0 86 || strncmp(buf, "pmem", n) == 0) { 87 nd_pfn->mode = PFN_MODE_PMEM; 88 } else if (strncmp(buf, "ram\n", n) == 0 89 || strncmp(buf, "ram", n) == 0) 90 nd_pfn->mode = PFN_MODE_RAM; 91 else if (strncmp(buf, "none\n", n) == 0 92 || strncmp(buf, "none", n) == 0) 93 nd_pfn->mode = PFN_MODE_NONE; 94 else 95 rc = -EINVAL; 96 } 97 dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, 98 rc, buf, buf[len - 1] == '\n' ? "" : "\n"); 99 nvdimm_bus_unlock(dev); 100 device_unlock(dev); 101 102 return rc ? rc : len; 103 } 104 static DEVICE_ATTR_RW(mode); 105 106 static ssize_t align_show(struct device *dev, 107 struct device_attribute *attr, char *buf) 108 { 109 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 110 111 return sprintf(buf, "%ld\n", nd_pfn->align); 112 } 113 114 static const unsigned long *nd_pfn_supported_alignments(void) 115 { 116 /* 117 * This needs to be a non-static variable because the *_SIZE 118 * macros aren't always constants. 119 */ 120 const unsigned long supported_alignments[] = { 121 PAGE_SIZE, 122 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 123 HPAGE_PMD_SIZE, 124 #ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD 125 HPAGE_PUD_SIZE, 126 #endif 127 #endif 128 0, 129 }; 130 static unsigned long data[ARRAY_SIZE(supported_alignments)]; 131 132 memcpy(data, supported_alignments, sizeof(data)); 133 134 return data; 135 } 136 137 static ssize_t align_store(struct device *dev, 138 struct device_attribute *attr, const char *buf, size_t len) 139 { 140 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 141 ssize_t rc; 142 143 device_lock(dev); 144 nvdimm_bus_lock(dev); 145 rc = nd_size_select_store(dev, buf, &nd_pfn->align, 146 nd_pfn_supported_alignments()); 147 dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, 148 rc, buf, buf[len - 1] == '\n' ? "" : "\n"); 149 nvdimm_bus_unlock(dev); 150 device_unlock(dev); 151 152 return rc ? rc : len; 153 } 154 static DEVICE_ATTR_RW(align); 155 156 static ssize_t uuid_show(struct device *dev, 157 struct device_attribute *attr, char *buf) 158 { 159 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 160 161 if (nd_pfn->uuid) 162 return sprintf(buf, "%pUb\n", nd_pfn->uuid); 163 return sprintf(buf, "\n"); 164 } 165 166 static ssize_t uuid_store(struct device *dev, 167 struct device_attribute *attr, const char *buf, size_t len) 168 { 169 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 170 ssize_t rc; 171 172 device_lock(dev); 173 rc = nd_uuid_store(dev, &nd_pfn->uuid, buf, len); 174 dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, 175 rc, buf, buf[len - 1] == '\n' ? "" : "\n"); 176 device_unlock(dev); 177 178 return rc ? rc : len; 179 } 180 static DEVICE_ATTR_RW(uuid); 181 182 static ssize_t namespace_show(struct device *dev, 183 struct device_attribute *attr, char *buf) 184 { 185 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 186 ssize_t rc; 187 188 nvdimm_bus_lock(dev); 189 rc = sprintf(buf, "%s\n", nd_pfn->ndns 190 ? dev_name(&nd_pfn->ndns->dev) : ""); 191 nvdimm_bus_unlock(dev); 192 return rc; 193 } 194 195 static ssize_t namespace_store(struct device *dev, 196 struct device_attribute *attr, const char *buf, size_t len) 197 { 198 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 199 ssize_t rc; 200 201 device_lock(dev); 202 nvdimm_bus_lock(dev); 203 rc = nd_namespace_store(dev, &nd_pfn->ndns, buf, len); 204 dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, 205 rc, buf, buf[len - 1] == '\n' ? "" : "\n"); 206 nvdimm_bus_unlock(dev); 207 device_unlock(dev); 208 209 return rc; 210 } 211 static DEVICE_ATTR_RW(namespace); 212 213 static ssize_t resource_show(struct device *dev, 214 struct device_attribute *attr, char *buf) 215 { 216 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 217 ssize_t rc; 218 219 device_lock(dev); 220 if (dev->driver) { 221 struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; 222 u64 offset = __le64_to_cpu(pfn_sb->dataoff); 223 struct nd_namespace_common *ndns = nd_pfn->ndns; 224 u32 start_pad = __le32_to_cpu(pfn_sb->start_pad); 225 struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); 226 227 rc = sprintf(buf, "%#llx\n", (unsigned long long) nsio->res.start 228 + start_pad + offset); 229 } else { 230 /* no address to convey if the pfn instance is disabled */ 231 rc = -ENXIO; 232 } 233 device_unlock(dev); 234 235 return rc; 236 } 237 static DEVICE_ATTR_RO(resource); 238 239 static ssize_t size_show(struct device *dev, 240 struct device_attribute *attr, char *buf) 241 { 242 struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); 243 ssize_t rc; 244 245 device_lock(dev); 246 if (dev->driver) { 247 struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; 248 u64 offset = __le64_to_cpu(pfn_sb->dataoff); 249 struct nd_namespace_common *ndns = nd_pfn->ndns; 250 u32 start_pad = __le32_to_cpu(pfn_sb->start_pad); 251 u32 end_trunc = __le32_to_cpu(pfn_sb->end_trunc); 252 struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); 253 254 rc = sprintf(buf, "%llu\n", (unsigned long long) 255 resource_size(&nsio->res) - start_pad 256 - end_trunc - offset); 257 } else { 258 /* no size to convey if the pfn instance is disabled */ 259 rc = -ENXIO; 260 } 261 device_unlock(dev); 262 263 return rc; 264 } 265 static DEVICE_ATTR_RO(size); 266 267 static ssize_t supported_alignments_show(struct device *dev, 268 struct device_attribute *attr, char *buf) 269 { 270 return nd_size_select_show(0, nd_pfn_supported_alignments(), buf); 271 } 272 static DEVICE_ATTR_RO(supported_alignments); 273 274 static struct attribute *nd_pfn_attributes[] = { 275 &dev_attr_mode.attr, 276 &dev_attr_namespace.attr, 277 &dev_attr_uuid.attr, 278 &dev_attr_align.attr, 279 &dev_attr_resource.attr, 280 &dev_attr_size.attr, 281 &dev_attr_supported_alignments.attr, 282 NULL, 283 }; 284 285 static umode_t pfn_visible(struct kobject *kobj, struct attribute *a, int n) 286 { 287 if (a == &dev_attr_resource.attr) 288 return 0400; 289 return a->mode; 290 } 291 292 struct attribute_group nd_pfn_attribute_group = { 293 .attrs = nd_pfn_attributes, 294 .is_visible = pfn_visible, 295 }; 296 297 static const struct attribute_group *nd_pfn_attribute_groups[] = { 298 &nd_pfn_attribute_group, 299 &nd_device_attribute_group, 300 &nd_numa_attribute_group, 301 NULL, 302 }; 303 304 struct device *nd_pfn_devinit(struct nd_pfn *nd_pfn, 305 struct nd_namespace_common *ndns) 306 { 307 struct device *dev = &nd_pfn->dev; 308 309 if (!nd_pfn) 310 return NULL; 311 312 nd_pfn->mode = PFN_MODE_NONE; 313 nd_pfn->align = PFN_DEFAULT_ALIGNMENT; 314 dev = &nd_pfn->dev; 315 device_initialize(&nd_pfn->dev); 316 if (ndns && !__nd_attach_ndns(&nd_pfn->dev, ndns, &nd_pfn->ndns)) { 317 dev_dbg(&ndns->dev, "%s failed, already claimed by %s\n", 318 __func__, dev_name(ndns->claim)); 319 put_device(dev); 320 return NULL; 321 } 322 return dev; 323 } 324 325 static struct nd_pfn *nd_pfn_alloc(struct nd_region *nd_region) 326 { 327 struct nd_pfn *nd_pfn; 328 struct device *dev; 329 330 nd_pfn = kzalloc(sizeof(*nd_pfn), GFP_KERNEL); 331 if (!nd_pfn) 332 return NULL; 333 334 nd_pfn->id = ida_simple_get(&nd_region->pfn_ida, 0, 0, GFP_KERNEL); 335 if (nd_pfn->id < 0) { 336 kfree(nd_pfn); 337 return NULL; 338 } 339 340 dev = &nd_pfn->dev; 341 dev_set_name(dev, "pfn%d.%d", nd_region->id, nd_pfn->id); 342 dev->groups = nd_pfn_attribute_groups; 343 dev->type = &nd_pfn_device_type; 344 dev->parent = &nd_region->dev; 345 346 return nd_pfn; 347 } 348 349 struct device *nd_pfn_create(struct nd_region *nd_region) 350 { 351 struct nd_pfn *nd_pfn; 352 struct device *dev; 353 354 if (!is_memory(&nd_region->dev)) 355 return NULL; 356 357 nd_pfn = nd_pfn_alloc(nd_region); 358 dev = nd_pfn_devinit(nd_pfn, NULL); 359 360 __nd_device_register(dev); 361 return dev; 362 } 363 364 int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig) 365 { 366 u64 checksum, offset; 367 unsigned long align; 368 enum nd_pfn_mode mode; 369 struct nd_namespace_io *nsio; 370 struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; 371 struct nd_namespace_common *ndns = nd_pfn->ndns; 372 const u8 *parent_uuid = nd_dev_to_uuid(&ndns->dev); 373 374 if (!pfn_sb || !ndns) 375 return -ENODEV; 376 377 if (!is_memory(nd_pfn->dev.parent)) 378 return -ENODEV; 379 380 if (nvdimm_read_bytes(ndns, SZ_4K, pfn_sb, sizeof(*pfn_sb), 0)) 381 return -ENXIO; 382 383 if (memcmp(pfn_sb->signature, sig, PFN_SIG_LEN) != 0) 384 return -ENODEV; 385 386 checksum = le64_to_cpu(pfn_sb->checksum); 387 pfn_sb->checksum = 0; 388 if (checksum != nd_sb_checksum((struct nd_gen_sb *) pfn_sb)) 389 return -ENODEV; 390 pfn_sb->checksum = cpu_to_le64(checksum); 391 392 if (memcmp(pfn_sb->parent_uuid, parent_uuid, 16) != 0) 393 return -ENODEV; 394 395 if (__le16_to_cpu(pfn_sb->version_minor) < 1) { 396 pfn_sb->start_pad = 0; 397 pfn_sb->end_trunc = 0; 398 } 399 400 if (__le16_to_cpu(pfn_sb->version_minor) < 2) 401 pfn_sb->align = 0; 402 403 switch (le32_to_cpu(pfn_sb->mode)) { 404 case PFN_MODE_RAM: 405 case PFN_MODE_PMEM: 406 break; 407 default: 408 return -ENXIO; 409 } 410 411 align = le32_to_cpu(pfn_sb->align); 412 offset = le64_to_cpu(pfn_sb->dataoff); 413 if (align == 0) 414 align = 1UL << ilog2(offset); 415 mode = le32_to_cpu(pfn_sb->mode); 416 417 if (!nd_pfn->uuid) { 418 /* 419 * When probing a namepace via nd_pfn_probe() the uuid 420 * is NULL (see: nd_pfn_devinit()) we init settings from 421 * pfn_sb 422 */ 423 nd_pfn->uuid = kmemdup(pfn_sb->uuid, 16, GFP_KERNEL); 424 if (!nd_pfn->uuid) 425 return -ENOMEM; 426 nd_pfn->align = align; 427 nd_pfn->mode = mode; 428 } else { 429 /* 430 * When probing a pfn / dax instance we validate the 431 * live settings against the pfn_sb 432 */ 433 if (memcmp(nd_pfn->uuid, pfn_sb->uuid, 16) != 0) 434 return -ENODEV; 435 436 /* 437 * If the uuid validates, but other settings mismatch 438 * return EINVAL because userspace has managed to change 439 * the configuration without specifying new 440 * identification. 441 */ 442 if (nd_pfn->align != align || nd_pfn->mode != mode) { 443 dev_err(&nd_pfn->dev, 444 "init failed, settings mismatch\n"); 445 dev_dbg(&nd_pfn->dev, "align: %lx:%lx mode: %d:%d\n", 446 nd_pfn->align, align, nd_pfn->mode, 447 mode); 448 return -EINVAL; 449 } 450 } 451 452 if (align > nvdimm_namespace_capacity(ndns)) { 453 dev_err(&nd_pfn->dev, "alignment: %lx exceeds capacity %llx\n", 454 align, nvdimm_namespace_capacity(ndns)); 455 return -EINVAL; 456 } 457 458 /* 459 * These warnings are verbose because they can only trigger in 460 * the case where the physical address alignment of the 461 * namespace has changed since the pfn superblock was 462 * established. 463 */ 464 nsio = to_nd_namespace_io(&ndns->dev); 465 if (offset >= resource_size(&nsio->res)) { 466 dev_err(&nd_pfn->dev, "pfn array size exceeds capacity of %s\n", 467 dev_name(&ndns->dev)); 468 return -EBUSY; 469 } 470 471 if ((align && !IS_ALIGNED(offset, align)) 472 || !IS_ALIGNED(offset, PAGE_SIZE)) { 473 dev_err(&nd_pfn->dev, 474 "bad offset: %#llx dax disabled align: %#lx\n", 475 offset, align); 476 return -ENXIO; 477 } 478 479 return 0; 480 } 481 EXPORT_SYMBOL(nd_pfn_validate); 482 483 int nd_pfn_probe(struct device *dev, struct nd_namespace_common *ndns) 484 { 485 int rc; 486 struct nd_pfn *nd_pfn; 487 struct device *pfn_dev; 488 struct nd_pfn_sb *pfn_sb; 489 struct nd_region *nd_region = to_nd_region(ndns->dev.parent); 490 491 if (ndns->force_raw) 492 return -ENODEV; 493 494 switch (ndns->claim_class) { 495 case NVDIMM_CCLASS_NONE: 496 case NVDIMM_CCLASS_PFN: 497 break; 498 default: 499 return -ENODEV; 500 } 501 502 nvdimm_bus_lock(&ndns->dev); 503 nd_pfn = nd_pfn_alloc(nd_region); 504 pfn_dev = nd_pfn_devinit(nd_pfn, ndns); 505 nvdimm_bus_unlock(&ndns->dev); 506 if (!pfn_dev) 507 return -ENOMEM; 508 pfn_sb = devm_kzalloc(dev, sizeof(*pfn_sb), GFP_KERNEL); 509 nd_pfn = to_nd_pfn(pfn_dev); 510 nd_pfn->pfn_sb = pfn_sb; 511 rc = nd_pfn_validate(nd_pfn, PFN_SIG); 512 dev_dbg(dev, "%s: pfn: %s\n", __func__, 513 rc == 0 ? dev_name(pfn_dev) : "<none>"); 514 if (rc < 0) { 515 nd_detach_ndns(pfn_dev, &nd_pfn->ndns); 516 put_device(pfn_dev); 517 } else 518 __nd_device_register(pfn_dev); 519 520 return rc; 521 } 522 EXPORT_SYMBOL(nd_pfn_probe); 523 524 /* 525 * We hotplug memory at section granularity, pad the reserved area from 526 * the previous section base to the namespace base address. 527 */ 528 static unsigned long init_altmap_base(resource_size_t base) 529 { 530 unsigned long base_pfn = PHYS_PFN(base); 531 532 return PFN_SECTION_ALIGN_DOWN(base_pfn); 533 } 534 535 static unsigned long init_altmap_reserve(resource_size_t base) 536 { 537 unsigned long reserve = PHYS_PFN(SZ_8K); 538 unsigned long base_pfn = PHYS_PFN(base); 539 540 reserve += base_pfn - PFN_SECTION_ALIGN_DOWN(base_pfn); 541 return reserve; 542 } 543 544 static struct vmem_altmap *__nvdimm_setup_pfn(struct nd_pfn *nd_pfn, 545 struct resource *res, struct vmem_altmap *altmap) 546 { 547 struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; 548 u64 offset = le64_to_cpu(pfn_sb->dataoff); 549 u32 start_pad = __le32_to_cpu(pfn_sb->start_pad); 550 u32 end_trunc = __le32_to_cpu(pfn_sb->end_trunc); 551 struct nd_namespace_common *ndns = nd_pfn->ndns; 552 struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); 553 resource_size_t base = nsio->res.start + start_pad; 554 struct vmem_altmap __altmap = { 555 .base_pfn = init_altmap_base(base), 556 .reserve = init_altmap_reserve(base), 557 }; 558 559 memcpy(res, &nsio->res, sizeof(*res)); 560 res->start += start_pad; 561 res->end -= end_trunc; 562 563 if (nd_pfn->mode == PFN_MODE_RAM) { 564 if (offset < SZ_8K) 565 return ERR_PTR(-EINVAL); 566 nd_pfn->npfns = le64_to_cpu(pfn_sb->npfns); 567 altmap = NULL; 568 } else if (nd_pfn->mode == PFN_MODE_PMEM) { 569 nd_pfn->npfns = PFN_SECTION_ALIGN_UP((resource_size(res) 570 - offset) / PAGE_SIZE); 571 if (le64_to_cpu(nd_pfn->pfn_sb->npfns) > nd_pfn->npfns) 572 dev_info(&nd_pfn->dev, 573 "number of pfns truncated from %lld to %ld\n", 574 le64_to_cpu(nd_pfn->pfn_sb->npfns), 575 nd_pfn->npfns); 576 memcpy(altmap, &__altmap, sizeof(*altmap)); 577 altmap->free = PHYS_PFN(offset - SZ_8K); 578 altmap->alloc = 0; 579 } else 580 return ERR_PTR(-ENXIO); 581 582 return altmap; 583 } 584 585 static int nd_pfn_init(struct nd_pfn *nd_pfn) 586 { 587 u32 dax_label_reserve = is_nd_dax(&nd_pfn->dev) ? SZ_128K : 0; 588 struct nd_namespace_common *ndns = nd_pfn->ndns; 589 u32 start_pad = 0, end_trunc = 0; 590 resource_size_t start, size; 591 struct nd_namespace_io *nsio; 592 struct nd_region *nd_region; 593 struct nd_pfn_sb *pfn_sb; 594 unsigned long npfns; 595 phys_addr_t offset; 596 const char *sig; 597 u64 checksum; 598 int rc; 599 600 pfn_sb = devm_kzalloc(&nd_pfn->dev, sizeof(*pfn_sb), GFP_KERNEL); 601 if (!pfn_sb) 602 return -ENOMEM; 603 604 nd_pfn->pfn_sb = pfn_sb; 605 if (is_nd_dax(&nd_pfn->dev)) 606 sig = DAX_SIG; 607 else 608 sig = PFN_SIG; 609 rc = nd_pfn_validate(nd_pfn, sig); 610 if (rc != -ENODEV) 611 return rc; 612 613 /* no info block, do init */; 614 nd_region = to_nd_region(nd_pfn->dev.parent); 615 if (nd_region->ro) { 616 dev_info(&nd_pfn->dev, 617 "%s is read-only, unable to init metadata\n", 618 dev_name(&nd_region->dev)); 619 return -ENXIO; 620 } 621 622 memset(pfn_sb, 0, sizeof(*pfn_sb)); 623 624 /* 625 * Check if pmem collides with 'System RAM' when section aligned and 626 * trim it accordingly 627 */ 628 nsio = to_nd_namespace_io(&ndns->dev); 629 start = PHYS_SECTION_ALIGN_DOWN(nsio->res.start); 630 size = resource_size(&nsio->res); 631 if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM, 632 IORES_DESC_NONE) == REGION_MIXED) { 633 start = nsio->res.start; 634 start_pad = PHYS_SECTION_ALIGN_UP(start) - start; 635 } 636 637 start = nsio->res.start; 638 size = PHYS_SECTION_ALIGN_UP(start + size) - start; 639 if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM, 640 IORES_DESC_NONE) == REGION_MIXED) { 641 size = resource_size(&nsio->res); 642 end_trunc = start + size - PHYS_SECTION_ALIGN_DOWN(start + size); 643 } 644 645 if (start_pad + end_trunc) 646 dev_info(&nd_pfn->dev, "%s section collision, truncate %d bytes\n", 647 dev_name(&ndns->dev), start_pad + end_trunc); 648 649 /* 650 * Note, we use 64 here for the standard size of struct page, 651 * debugging options may cause it to be larger in which case the 652 * implementation will limit the pfns advertised through 653 * ->direct_access() to those that are included in the memmap. 654 */ 655 start += start_pad; 656 size = resource_size(&nsio->res); 657 npfns = PFN_SECTION_ALIGN_UP((size - start_pad - end_trunc - SZ_8K) 658 / PAGE_SIZE); 659 if (nd_pfn->mode == PFN_MODE_PMEM) { 660 /* 661 * The altmap should be padded out to the block size used 662 * when populating the vmemmap. This *should* be equal to 663 * PMD_SIZE for most architectures. 664 */ 665 offset = ALIGN(start + SZ_8K + 64 * npfns + dax_label_reserve, 666 max(nd_pfn->align, PMD_SIZE)) - start; 667 } else if (nd_pfn->mode == PFN_MODE_RAM) 668 offset = ALIGN(start + SZ_8K + dax_label_reserve, 669 nd_pfn->align) - start; 670 else 671 return -ENXIO; 672 673 if (offset + start_pad + end_trunc >= size) { 674 dev_err(&nd_pfn->dev, "%s unable to satisfy requested alignment\n", 675 dev_name(&ndns->dev)); 676 return -ENXIO; 677 } 678 679 npfns = (size - offset - start_pad - end_trunc) / SZ_4K; 680 pfn_sb->mode = cpu_to_le32(nd_pfn->mode); 681 pfn_sb->dataoff = cpu_to_le64(offset); 682 pfn_sb->npfns = cpu_to_le64(npfns); 683 memcpy(pfn_sb->signature, sig, PFN_SIG_LEN); 684 memcpy(pfn_sb->uuid, nd_pfn->uuid, 16); 685 memcpy(pfn_sb->parent_uuid, nd_dev_to_uuid(&ndns->dev), 16); 686 pfn_sb->version_major = cpu_to_le16(1); 687 pfn_sb->version_minor = cpu_to_le16(2); 688 pfn_sb->start_pad = cpu_to_le32(start_pad); 689 pfn_sb->end_trunc = cpu_to_le32(end_trunc); 690 pfn_sb->align = cpu_to_le32(nd_pfn->align); 691 checksum = nd_sb_checksum((struct nd_gen_sb *) pfn_sb); 692 pfn_sb->checksum = cpu_to_le64(checksum); 693 694 return nvdimm_write_bytes(ndns, SZ_4K, pfn_sb, sizeof(*pfn_sb), 0); 695 } 696 697 /* 698 * Determine the effective resource range and vmem_altmap from an nd_pfn 699 * instance. 700 */ 701 struct vmem_altmap *nvdimm_setup_pfn(struct nd_pfn *nd_pfn, 702 struct resource *res, struct vmem_altmap *altmap) 703 { 704 int rc; 705 706 if (!nd_pfn->uuid || !nd_pfn->ndns) 707 return ERR_PTR(-ENODEV); 708 709 rc = nd_pfn_init(nd_pfn); 710 if (rc) 711 return ERR_PTR(rc); 712 713 /* we need a valid pfn_sb before we can init a vmem_altmap */ 714 return __nvdimm_setup_pfn(nd_pfn, res, altmap); 715 } 716 EXPORT_SYMBOL_GPL(nvdimm_setup_pfn); 717