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, "trace\n"); 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, "result: %zd wrote: %s%s", rc, buf, 98 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, "result: %zd wrote: %s%s", rc, buf, 148 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, "result: %zd wrote: %s%s", rc, buf, 175 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, "result: %zd wrote: %s%s", rc, buf, 205 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, "failed, already claimed by %s\n", 318 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 enum nd_pfn_mode mode; 368 struct nd_namespace_io *nsio; 369 unsigned long align, start_pad; 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 start_pad = le32_to_cpu(pfn_sb->start_pad); 414 if (align == 0) 415 align = 1UL << ilog2(offset); 416 mode = le32_to_cpu(pfn_sb->mode); 417 418 if (!nd_pfn->uuid) { 419 /* 420 * When probing a namepace via nd_pfn_probe() the uuid 421 * is NULL (see: nd_pfn_devinit()) we init settings from 422 * pfn_sb 423 */ 424 nd_pfn->uuid = kmemdup(pfn_sb->uuid, 16, GFP_KERNEL); 425 if (!nd_pfn->uuid) 426 return -ENOMEM; 427 nd_pfn->align = align; 428 nd_pfn->mode = mode; 429 } else { 430 /* 431 * When probing a pfn / dax instance we validate the 432 * live settings against the pfn_sb 433 */ 434 if (memcmp(nd_pfn->uuid, pfn_sb->uuid, 16) != 0) 435 return -ENODEV; 436 437 /* 438 * If the uuid validates, but other settings mismatch 439 * return EINVAL because userspace has managed to change 440 * the configuration without specifying new 441 * identification. 442 */ 443 if (nd_pfn->align != align || nd_pfn->mode != mode) { 444 dev_err(&nd_pfn->dev, 445 "init failed, settings mismatch\n"); 446 dev_dbg(&nd_pfn->dev, "align: %lx:%lx mode: %d:%d\n", 447 nd_pfn->align, align, nd_pfn->mode, 448 mode); 449 return -EINVAL; 450 } 451 } 452 453 if (align > nvdimm_namespace_capacity(ndns)) { 454 dev_err(&nd_pfn->dev, "alignment: %lx exceeds capacity %llx\n", 455 align, nvdimm_namespace_capacity(ndns)); 456 return -EINVAL; 457 } 458 459 /* 460 * These warnings are verbose because they can only trigger in 461 * the case where the physical address alignment of the 462 * namespace has changed since the pfn superblock was 463 * established. 464 */ 465 nsio = to_nd_namespace_io(&ndns->dev); 466 if (offset >= resource_size(&nsio->res)) { 467 dev_err(&nd_pfn->dev, "pfn array size exceeds capacity of %s\n", 468 dev_name(&ndns->dev)); 469 return -EBUSY; 470 } 471 472 if ((align && !IS_ALIGNED(nsio->res.start + offset + start_pad, align)) 473 || !IS_ALIGNED(offset, PAGE_SIZE)) { 474 dev_err(&nd_pfn->dev, 475 "bad offset: %#llx dax disabled align: %#lx\n", 476 offset, align); 477 return -ENXIO; 478 } 479 480 return 0; 481 } 482 EXPORT_SYMBOL(nd_pfn_validate); 483 484 int nd_pfn_probe(struct device *dev, struct nd_namespace_common *ndns) 485 { 486 int rc; 487 struct nd_pfn *nd_pfn; 488 struct device *pfn_dev; 489 struct nd_pfn_sb *pfn_sb; 490 struct nd_region *nd_region = to_nd_region(ndns->dev.parent); 491 492 if (ndns->force_raw) 493 return -ENODEV; 494 495 switch (ndns->claim_class) { 496 case NVDIMM_CCLASS_NONE: 497 case NVDIMM_CCLASS_PFN: 498 break; 499 default: 500 return -ENODEV; 501 } 502 503 nvdimm_bus_lock(&ndns->dev); 504 nd_pfn = nd_pfn_alloc(nd_region); 505 pfn_dev = nd_pfn_devinit(nd_pfn, ndns); 506 nvdimm_bus_unlock(&ndns->dev); 507 if (!pfn_dev) 508 return -ENOMEM; 509 pfn_sb = devm_kzalloc(dev, sizeof(*pfn_sb), GFP_KERNEL); 510 nd_pfn = to_nd_pfn(pfn_dev); 511 nd_pfn->pfn_sb = pfn_sb; 512 rc = nd_pfn_validate(nd_pfn, PFN_SIG); 513 dev_dbg(dev, "pfn: %s\n", 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 int __nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap) 545 { 546 struct resource *res = &pgmap->res; 547 struct vmem_altmap *altmap = &pgmap->altmap; 548 struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; 549 u64 offset = le64_to_cpu(pfn_sb->dataoff); 550 u32 start_pad = __le32_to_cpu(pfn_sb->start_pad); 551 u32 end_trunc = __le32_to_cpu(pfn_sb->end_trunc); 552 struct nd_namespace_common *ndns = nd_pfn->ndns; 553 struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); 554 resource_size_t base = nsio->res.start + start_pad; 555 struct vmem_altmap __altmap = { 556 .base_pfn = init_altmap_base(base), 557 .reserve = init_altmap_reserve(base), 558 }; 559 560 memcpy(res, &nsio->res, sizeof(*res)); 561 res->start += start_pad; 562 res->end -= end_trunc; 563 564 pgmap->type = MEMORY_DEVICE_HOST; 565 566 if (nd_pfn->mode == PFN_MODE_RAM) { 567 if (offset < SZ_8K) 568 return -EINVAL; 569 nd_pfn->npfns = le64_to_cpu(pfn_sb->npfns); 570 pgmap->altmap_valid = false; 571 } else if (nd_pfn->mode == PFN_MODE_PMEM) { 572 nd_pfn->npfns = PFN_SECTION_ALIGN_UP((resource_size(res) 573 - offset) / PAGE_SIZE); 574 if (le64_to_cpu(nd_pfn->pfn_sb->npfns) > nd_pfn->npfns) 575 dev_info(&nd_pfn->dev, 576 "number of pfns truncated from %lld to %ld\n", 577 le64_to_cpu(nd_pfn->pfn_sb->npfns), 578 nd_pfn->npfns); 579 memcpy(altmap, &__altmap, sizeof(*altmap)); 580 altmap->free = PHYS_PFN(offset - SZ_8K); 581 altmap->alloc = 0; 582 pgmap->altmap_valid = true; 583 } else 584 return -ENXIO; 585 586 return 0; 587 } 588 589 static u64 phys_pmem_align_down(struct nd_pfn *nd_pfn, u64 phys) 590 { 591 return min_t(u64, PHYS_SECTION_ALIGN_DOWN(phys), 592 ALIGN_DOWN(phys, nd_pfn->align)); 593 } 594 595 static int nd_pfn_init(struct nd_pfn *nd_pfn) 596 { 597 u32 dax_label_reserve = is_nd_dax(&nd_pfn->dev) ? SZ_128K : 0; 598 struct nd_namespace_common *ndns = nd_pfn->ndns; 599 u32 start_pad = 0, end_trunc = 0; 600 resource_size_t start, size; 601 struct nd_namespace_io *nsio; 602 struct nd_region *nd_region; 603 struct nd_pfn_sb *pfn_sb; 604 unsigned long npfns; 605 phys_addr_t offset; 606 const char *sig; 607 u64 checksum; 608 int rc; 609 610 pfn_sb = devm_kzalloc(&nd_pfn->dev, sizeof(*pfn_sb), GFP_KERNEL); 611 if (!pfn_sb) 612 return -ENOMEM; 613 614 nd_pfn->pfn_sb = pfn_sb; 615 if (is_nd_dax(&nd_pfn->dev)) 616 sig = DAX_SIG; 617 else 618 sig = PFN_SIG; 619 rc = nd_pfn_validate(nd_pfn, sig); 620 if (rc != -ENODEV) 621 return rc; 622 623 /* no info block, do init */; 624 nd_region = to_nd_region(nd_pfn->dev.parent); 625 if (nd_region->ro) { 626 dev_info(&nd_pfn->dev, 627 "%s is read-only, unable to init metadata\n", 628 dev_name(&nd_region->dev)); 629 return -ENXIO; 630 } 631 632 memset(pfn_sb, 0, sizeof(*pfn_sb)); 633 634 /* 635 * Check if pmem collides with 'System RAM' when section aligned and 636 * trim it accordingly 637 */ 638 nsio = to_nd_namespace_io(&ndns->dev); 639 start = PHYS_SECTION_ALIGN_DOWN(nsio->res.start); 640 size = resource_size(&nsio->res); 641 if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM, 642 IORES_DESC_NONE) == REGION_MIXED) { 643 start = nsio->res.start; 644 start_pad = PHYS_SECTION_ALIGN_UP(start) - start; 645 } 646 647 start = nsio->res.start; 648 size = PHYS_SECTION_ALIGN_UP(start + size) - start; 649 if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM, 650 IORES_DESC_NONE) == REGION_MIXED 651 || !IS_ALIGNED(start + resource_size(&nsio->res), 652 nd_pfn->align)) { 653 size = resource_size(&nsio->res); 654 end_trunc = start + size - phys_pmem_align_down(nd_pfn, 655 start + size); 656 } 657 658 if (start_pad + end_trunc) 659 dev_info(&nd_pfn->dev, "%s alignment collision, truncate %d bytes\n", 660 dev_name(&ndns->dev), start_pad + end_trunc); 661 662 /* 663 * Note, we use 64 here for the standard size of struct page, 664 * debugging options may cause it to be larger in which case the 665 * implementation will limit the pfns advertised through 666 * ->direct_access() to those that are included in the memmap. 667 */ 668 start += start_pad; 669 size = resource_size(&nsio->res); 670 npfns = PFN_SECTION_ALIGN_UP((size - start_pad - end_trunc - SZ_8K) 671 / PAGE_SIZE); 672 if (nd_pfn->mode == PFN_MODE_PMEM) { 673 /* 674 * The altmap should be padded out to the block size used 675 * when populating the vmemmap. This *should* be equal to 676 * PMD_SIZE for most architectures. 677 */ 678 offset = ALIGN(start + SZ_8K + 64 * npfns + dax_label_reserve, 679 max(nd_pfn->align, PMD_SIZE)) - start; 680 } else if (nd_pfn->mode == PFN_MODE_RAM) 681 offset = ALIGN(start + SZ_8K + dax_label_reserve, 682 nd_pfn->align) - start; 683 else 684 return -ENXIO; 685 686 if (offset + start_pad + end_trunc >= size) { 687 dev_err(&nd_pfn->dev, "%s unable to satisfy requested alignment\n", 688 dev_name(&ndns->dev)); 689 return -ENXIO; 690 } 691 692 npfns = (size - offset - start_pad - end_trunc) / SZ_4K; 693 pfn_sb->mode = cpu_to_le32(nd_pfn->mode); 694 pfn_sb->dataoff = cpu_to_le64(offset); 695 pfn_sb->npfns = cpu_to_le64(npfns); 696 memcpy(pfn_sb->signature, sig, PFN_SIG_LEN); 697 memcpy(pfn_sb->uuid, nd_pfn->uuid, 16); 698 memcpy(pfn_sb->parent_uuid, nd_dev_to_uuid(&ndns->dev), 16); 699 pfn_sb->version_major = cpu_to_le16(1); 700 pfn_sb->version_minor = cpu_to_le16(2); 701 pfn_sb->start_pad = cpu_to_le32(start_pad); 702 pfn_sb->end_trunc = cpu_to_le32(end_trunc); 703 pfn_sb->align = cpu_to_le32(nd_pfn->align); 704 checksum = nd_sb_checksum((struct nd_gen_sb *) pfn_sb); 705 pfn_sb->checksum = cpu_to_le64(checksum); 706 707 return nvdimm_write_bytes(ndns, SZ_4K, pfn_sb, sizeof(*pfn_sb), 0); 708 } 709 710 /* 711 * Determine the effective resource range and vmem_altmap from an nd_pfn 712 * instance. 713 */ 714 int nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap) 715 { 716 int rc; 717 718 if (!nd_pfn->uuid || !nd_pfn->ndns) 719 return -ENODEV; 720 721 rc = nd_pfn_init(nd_pfn); 722 if (rc) 723 return rc; 724 725 /* we need a valid pfn_sb before we can init a dev_pagemap */ 726 return __nvdimm_setup_pfn(nd_pfn, pgmap); 727 } 728 EXPORT_SYMBOL_GPL(nvdimm_setup_pfn); 729