drivers/nvdimm/region_devs.c

   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/sched.h>
  15 #include <linux/slab.h>
  16 #include <linux/sort.h>
  17 #include <linux/io.h>
  18 #include <linux/nd.h>
  19 #include "nd-core.h"
  20 #include "nd.h"
  21
  22 static DEFINE_IDA(region_ida);
  23
  24 static void nd_region_release(struct device *dev)
  25 {
  26         struct nd_region *nd_region = to_nd_region(dev);
  27         u16 i;
  28
  29         for (i = 0; i < nd_region->ndr_mappings; i++) {
  30                 struct nd_mapping *nd_mapping = &nd_region->mapping[i];
  31                 struct nvdimm *nvdimm = nd_mapping->nvdimm;
  32
  33                 put_device(&nvdimm->dev);
  34         }
  35         ida_simple_remove(&region_ida, nd_region->id);
  36         kfree(nd_region);
  37 }
  38
  39 static struct device_type nd_blk_device_type = {
  40         .name = "nd_blk",
  41         .release = nd_region_release,
  42 };
  43
  44 static struct device_type nd_pmem_device_type = {
  45         .name = "nd_pmem",
  46         .release = nd_region_release,
  47 };
  48
  49 static struct device_type nd_volatile_device_type = {
  50         .name = "nd_volatile",
  51         .release = nd_region_release,
  52 };
  53
  54 bool is_nd_pmem(struct device *dev)
  55 {
  56         return dev ? dev->type == &nd_pmem_device_type : false;
  57 }
  58
  59 bool is_nd_blk(struct device *dev)
  60 {
  61         return dev ? dev->type == &nd_blk_device_type : false;
  62 }
  63
  64 struct nd_region *to_nd_region(struct device *dev)
  65 {
  66         struct nd_region *nd_region = container_of(dev, struct nd_region, dev);
  67
  68         WARN_ON(dev->type->release != nd_region_release);
  69         return nd_region;
  70 }
  71 EXPORT_SYMBOL_GPL(to_nd_region);
  72
  73 /**
  74  * nd_region_to_nstype() - region to an integer namespace type
  75  * @nd_region: region-device to interrogate
  76  *
  77  * This is the 'nstype' attribute of a region as well, an input to the
  78  * MODALIAS for namespace devices, and bit number for a nvdimm_bus to match
  79  * namespace devices with namespace drivers.
  80  */
  81 int nd_region_to_nstype(struct nd_region *nd_region)
  82 {
  83         if (is_nd_pmem(&nd_region->dev)) {
  84                 u16 i, alias;
  85
  86                 for (i = 0, alias = 0; i < nd_region->ndr_mappings; i++) {
  87                         struct nd_mapping *nd_mapping = &nd_region->mapping[i];
  88                         struct nvdimm *nvdimm = nd_mapping->nvdimm;
  89
  90                         if (nvdimm->flags & NDD_ALIASING)
  91                                 alias++;
  92                 }
  93                 if (alias)
  94                         return ND_DEVICE_NAMESPACE_PMEM;
  95                 else
  96                         return ND_DEVICE_NAMESPACE_IO;
  97         } else if (is_nd_blk(&nd_region->dev)) {
  98                 return ND_DEVICE_NAMESPACE_BLK;
  99         }
 100
 101         return 0;
 102 }
 103 EXPORT_SYMBOL(nd_region_to_nstype);
 104
 105 static int is_uuid_busy(struct device *dev, void *data)
 106 {
 107         struct nd_region *nd_region = to_nd_region(dev->parent);
 108         u8 *uuid = data;
 109
 110         switch (nd_region_to_nstype(nd_region)) {
 111         case ND_DEVICE_NAMESPACE_PMEM: {
 112                 struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);
 113
 114                 if (!nspm->uuid)
 115                         break;
 116                 if (memcmp(uuid, nspm->uuid, NSLABEL_UUID_LEN) == 0)
 117                         return -EBUSY;
 118                 break;
 119         }
 120         case ND_DEVICE_NAMESPACE_BLK: {
 121                 struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev);
 122
 123                 if (!nsblk->uuid)
 124                         break;
 125                 if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) == 0)
 126                         return -EBUSY;
 127                 break;
 128         }
 129         default:
 130                 break;
 131         }
 132
 133         return 0;
 134 }
 135
 136 static int is_namespace_uuid_busy(struct device *dev, void *data)
 137 {
 138         if (is_nd_pmem(dev) || is_nd_blk(dev))
 139                 return device_for_each_child(dev, data, is_uuid_busy);
 140         return 0;
 141 }
 142
 143 /**
 144  * nd_is_uuid_unique - verify that no other namespace has @uuid
 145  * @dev: any device on a nvdimm_bus
 146  * @uuid: uuid to check
 147  */
 148 bool nd_is_uuid_unique(struct device *dev, u8 *uuid)
 149 {
 150         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
 151
 152         if (!nvdimm_bus)
 153                 return false;
 154         WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm_bus->dev));
 155         if (device_for_each_child(&nvdimm_bus->dev, uuid,
 156                                 is_namespace_uuid_busy) != 0)
 157                 return false;
 158         return true;
 159 }
 160
 161 static ssize_t size_show(struct device *dev,
 162                 struct device_attribute *attr, char *buf)
 163 {
 164         struct nd_region *nd_region = to_nd_region(dev);
 165         unsigned long long size = 0;
 166
 167         if (is_nd_pmem(dev)) {
 168                 size = nd_region->ndr_size;
 169         } else if (nd_region->ndr_mappings == 1) {
 170                 struct nd_mapping *nd_mapping = &nd_region->mapping[0];
 171
 172                 size = nd_mapping->size;
 173         }
 174
 175         return sprintf(buf, "%llu\n", size);
 176 }
 177 static DEVICE_ATTR_RO(size);
 178
 179 static ssize_t mappings_show(struct device *dev,
 180                 struct device_attribute *attr, char *buf)
 181 {
 182         struct nd_region *nd_region = to_nd_region(dev);
 183
 184         return sprintf(buf, "%d\n", nd_region->ndr_mappings);
 185 }
 186 static DEVICE_ATTR_RO(mappings);
 187
 188 static ssize_t nstype_show(struct device *dev,
 189                 struct device_attribute *attr, char *buf)
 190 {
 191         struct nd_region *nd_region = to_nd_region(dev);
 192
 193         return sprintf(buf, "%d\n", nd_region_to_nstype(nd_region));
 194 }
 195 static DEVICE_ATTR_RO(nstype);
 196
 197 static ssize_t set_cookie_show(struct device *dev,
 198                 struct device_attribute *attr, char *buf)
 199 {
 200         struct nd_region *nd_region = to_nd_region(dev);
 201         struct nd_interleave_set *nd_set = nd_region->nd_set;
 202
 203         if (is_nd_pmem(dev) && nd_set)
 204                 /* pass, should be precluded by region_visible */;
 205         else
 206                 return -ENXIO;
 207
 208         return sprintf(buf, "%#llx\n", nd_set->cookie);
 209 }
 210 static DEVICE_ATTR_RO(set_cookie);
 211
 212 resource_size_t nd_region_available_dpa(struct nd_region *nd_region)
 213 {
 214         resource_size_t blk_max_overlap = 0, available, overlap;
 215         int i;
 216
 217         WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev));
 218
 219  retry:
 220         available = 0;
 221         overlap = blk_max_overlap;
 222         for (i = 0; i < nd_region->ndr_mappings; i++) {
 223                 struct nd_mapping *nd_mapping = &nd_region->mapping[i];
 224                 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
 225
 226                 /* if a dimm is disabled the available capacity is zero */
 227                 if (!ndd)
 228                         return 0;
 229
 230                 if (is_nd_pmem(&nd_region->dev)) {
 231                         available += nd_pmem_available_dpa(nd_region,
 232                                         nd_mapping, &overlap);
 233                         if (overlap > blk_max_overlap) {
 234                                 blk_max_overlap = overlap;
 235                                 goto retry;
 236                         }
 237                 } else if (is_nd_blk(&nd_region->dev)) {
 238                         available += nd_blk_available_dpa(nd_mapping);
 239                 }
 240         }
 241
 242         return available;
 243 }
 244
 245 static ssize_t available_size_show(struct device *dev,
 246                 struct device_attribute *attr, char *buf)
 247 {
 248         struct nd_region *nd_region = to_nd_region(dev);
 249         unsigned long long available = 0;
 250
 251         /*
 252          * Flush in-flight updates and grab a snapshot of the available
 253          * size.  Of course, this value is potentially invalidated the
 254          * memory nvdimm_bus_lock() is dropped, but that's userspace's
 255          * problem to not race itself.
 256          */
 257         nvdimm_bus_lock(dev);
 258         wait_nvdimm_bus_probe_idle(dev);
 259         available = nd_region_available_dpa(nd_region);
 260         nvdimm_bus_unlock(dev);
 261
 262         return sprintf(buf, "%llu\n", available);
 263 }
 264 static DEVICE_ATTR_RO(available_size);
 265
 266 static ssize_t init_namespaces_show(struct device *dev,
 267                 struct device_attribute *attr, char *buf)
 268 {
 269         struct nd_region_namespaces *num_ns = dev_get_drvdata(dev);
 270         ssize_t rc;
 271
 272         nvdimm_bus_lock(dev);
 273         if (num_ns)
 274                 rc = sprintf(buf, "%d/%d\n", num_ns->active, num_ns->count);
 275         else
 276                 rc = -ENXIO;
 277         nvdimm_bus_unlock(dev);
 278
 279         return rc;
 280 }
 281 static DEVICE_ATTR_RO(init_namespaces);
 282
 283 static ssize_t namespace_seed_show(struct device *dev,
 284                 struct device_attribute *attr, char *buf)
 285 {
 286         struct nd_region *nd_region = to_nd_region(dev);
 287         ssize_t rc;
 288
 289         nvdimm_bus_lock(dev);
 290         if (nd_region->ns_seed)
 291                 rc = sprintf(buf, "%s\n", dev_name(nd_region->ns_seed));
 292         else
 293                 rc = sprintf(buf, "\n");
 294         nvdimm_bus_unlock(dev);
 295         return rc;
 296 }
 297 static DEVICE_ATTR_RO(namespace_seed);
 298
 299 static ssize_t btt_seed_show(struct device *dev,
 300                 struct device_attribute *attr, char *buf)
 301 {
 302         struct nd_region *nd_region = to_nd_region(dev);
 303         ssize_t rc;
 304
 305         nvdimm_bus_lock(dev);
 306         if (nd_region->btt_seed)
 307                 rc = sprintf(buf, "%s\n", dev_name(nd_region->btt_seed));
 308         else
 309                 rc = sprintf(buf, "\n");
 310         nvdimm_bus_unlock(dev);
 311
 312         return rc;
 313 }
 314 static DEVICE_ATTR_RO(btt_seed);
 315
 316 static struct attribute *nd_region_attributes[] = {
 317         &dev_attr_size.attr,
 318         &dev_attr_nstype.attr,
 319         &dev_attr_mappings.attr,
 320         &dev_attr_btt_seed.attr,
 321         &dev_attr_set_cookie.attr,
 322         &dev_attr_available_size.attr,
 323         &dev_attr_namespace_seed.attr,
 324         &dev_attr_init_namespaces.attr,
 325         NULL,
 326 };
 327
 328 static umode_t region_visible(struct kobject *kobj, struct attribute *a, int n)
 329 {
 330         struct device *dev = container_of(kobj, typeof(*dev), kobj);
 331         struct nd_region *nd_region = to_nd_region(dev);
 332         struct nd_interleave_set *nd_set = nd_region->nd_set;
 333         int type = nd_region_to_nstype(nd_region);
 334
 335         if (a != &dev_attr_set_cookie.attr
 336                         && a != &dev_attr_available_size.attr)
 337                 return a->mode;
 338
 339         if ((type == ND_DEVICE_NAMESPACE_PMEM
 340                                 || type == ND_DEVICE_NAMESPACE_BLK)
 341                         && a == &dev_attr_available_size.attr)
 342                 return a->mode;
 343         else if (is_nd_pmem(dev) && nd_set)
 344                 return a->mode;
 345
 346         return 0;
 347 }
 348
 349 struct attribute_group nd_region_attribute_group = {
 350         .attrs = nd_region_attributes,
 351         .is_visible = region_visible,
 352 };
 353 EXPORT_SYMBOL_GPL(nd_region_attribute_group);
 354
 355 u64 nd_region_interleave_set_cookie(struct nd_region *nd_region)
 356 {
 357         struct nd_interleave_set *nd_set = nd_region->nd_set;
 358
 359         if (nd_set)
 360                 return nd_set->cookie;
 361         return 0;
 362 }
 363
 364 /*
 365  * Upon successful probe/remove, take/release a reference on the
 366  * associated interleave set (if present), and plant new btt + namespace
 367  * seeds.
 368  */
 369 static void nd_region_notify_driver_action(struct nvdimm_bus *nvdimm_bus,
 370                 struct device *dev, bool probe)
 371 {
 372         struct nd_region *nd_region;
 373
 374         if (!probe && (is_nd_pmem(dev) || is_nd_blk(dev))) {
 375                 int i;
 376
 377                 nd_region = to_nd_region(dev);
 378                 for (i = 0; i < nd_region->ndr_mappings; i++) {
 379                         struct nd_mapping *nd_mapping = &nd_region->mapping[i];
 380                         struct nvdimm_drvdata *ndd = nd_mapping->ndd;
 381                         struct nvdimm *nvdimm = nd_mapping->nvdimm;
 382
 383                         kfree(nd_mapping->labels);
 384                         nd_mapping->labels = NULL;
 385                         put_ndd(ndd);
 386                         nd_mapping->ndd = NULL;
 387                         atomic_dec(&nvdimm->busy);
 388                 }
 389         }
 390         if (dev->parent && is_nd_blk(dev->parent) && probe) {
 391                 nd_region = to_nd_region(dev->parent);
 392                 nvdimm_bus_lock(dev);
 393                 if (nd_region->ns_seed == dev)
 394                         nd_region_create_blk_seed(nd_region);
 395                 nvdimm_bus_unlock(dev);
 396         }
 397         if (is_nd_btt(dev) && probe) {
 398                 nd_region = to_nd_region(dev->parent);
 399                 nvdimm_bus_lock(dev);
 400                 if (nd_region->btt_seed == dev)
 401                         nd_region_create_btt_seed(nd_region);
 402                 nvdimm_bus_unlock(dev);
 403         }
 404 }
 405
 406 void nd_region_probe_success(struct nvdimm_bus *nvdimm_bus, struct device *dev)
 407 {
 408         nd_region_notify_driver_action(nvdimm_bus, dev, true);
 409 }
 410
 411 void nd_region_disable(struct nvdimm_bus *nvdimm_bus, struct device *dev)
 412 {
 413         nd_region_notify_driver_action(nvdimm_bus, dev, false);
 414 }
 415
 416 static ssize_t mappingN(struct device *dev, char *buf, int n)
 417 {
 418         struct nd_region *nd_region = to_nd_region(dev);
 419         struct nd_mapping *nd_mapping;
 420         struct nvdimm *nvdimm;
 421
 422         if (n >= nd_region->ndr_mappings)
 423                 return -ENXIO;
 424         nd_mapping = &nd_region->mapping[n];
 425         nvdimm = nd_mapping->nvdimm;
 426
 427         return sprintf(buf, "%s,%llu,%llu\n", dev_name(&nvdimm->dev),
 428                         nd_mapping->start, nd_mapping->size);
 429 }
 430
 431 #define REGION_MAPPING(idx) \
 432 static ssize_t mapping##idx##_show(struct device *dev,          \
 433                 struct device_attribute *attr, char *buf)       \
 434 {                                                               \
 435         return mappingN(dev, buf, idx);                         \
 436 }                                                               \
 437 static DEVICE_ATTR_RO(mapping##idx)
 438
 439 /*
 440  * 32 should be enough for a while, even in the presence of socket
 441  * interleave a 32-way interleave set is a degenerate case.
 442  */
 443 REGION_MAPPING(0);
 444 REGION_MAPPING(1);
 445 REGION_MAPPING(2);
 446 REGION_MAPPING(3);
 447 REGION_MAPPING(4);
 448 REGION_MAPPING(5);
 449 REGION_MAPPING(6);
 450 REGION_MAPPING(7);
 451 REGION_MAPPING(8);
 452 REGION_MAPPING(9);
 453 REGION_MAPPING(10);
 454 REGION_MAPPING(11);
 455 REGION_MAPPING(12);
 456 REGION_MAPPING(13);
 457 REGION_MAPPING(14);
 458 REGION_MAPPING(15);
 459 REGION_MAPPING(16);
 460 REGION_MAPPING(17);
 461 REGION_MAPPING(18);
 462 REGION_MAPPING(19);
 463 REGION_MAPPING(20);
 464 REGION_MAPPING(21);
 465 REGION_MAPPING(22);
 466 REGION_MAPPING(23);
 467 REGION_MAPPING(24);
 468 REGION_MAPPING(25);
 469 REGION_MAPPING(26);
 470 REGION_MAPPING(27);
 471 REGION_MAPPING(28);
 472 REGION_MAPPING(29);
 473 REGION_MAPPING(30);
 474 REGION_MAPPING(31);
 475
 476 static umode_t mapping_visible(struct kobject *kobj, struct attribute *a, int n)
 477 {
 478         struct device *dev = container_of(kobj, struct device, kobj);
 479         struct nd_region *nd_region = to_nd_region(dev);
 480
 481         if (n < nd_region->ndr_mappings)
 482                 return a->mode;
 483         return 0;
 484 }
 485
 486 static struct attribute *mapping_attributes[] = {
 487         &dev_attr_mapping0.attr,
 488         &dev_attr_mapping1.attr,
 489         &dev_attr_mapping2.attr,
 490         &dev_attr_mapping3.attr,
 491         &dev_attr_mapping4.attr,
 492         &dev_attr_mapping5.attr,
 493         &dev_attr_mapping6.attr,
 494         &dev_attr_mapping7.attr,
 495         &dev_attr_mapping8.attr,
 496         &dev_attr_mapping9.attr,
 497         &dev_attr_mapping10.attr,
 498         &dev_attr_mapping11.attr,
 499         &dev_attr_mapping12.attr,
 500         &dev_attr_mapping13.attr,
 501         &dev_attr_mapping14.attr,
 502         &dev_attr_mapping15.attr,
 503         &dev_attr_mapping16.attr,
 504         &dev_attr_mapping17.attr,
 505         &dev_attr_mapping18.attr,
 506         &dev_attr_mapping19.attr,
 507         &dev_attr_mapping20.attr,
 508         &dev_attr_mapping21.attr,
 509         &dev_attr_mapping22.attr,
 510         &dev_attr_mapping23.attr,
 511         &dev_attr_mapping24.attr,
 512         &dev_attr_mapping25.attr,
 513         &dev_attr_mapping26.attr,
 514         &dev_attr_mapping27.attr,
 515         &dev_attr_mapping28.attr,
 516         &dev_attr_mapping29.attr,
 517         &dev_attr_mapping30.attr,
 518         &dev_attr_mapping31.attr,
 519         NULL,
 520 };
 521
 522 struct attribute_group nd_mapping_attribute_group = {
 523         .is_visible = mapping_visible,
 524         .attrs = mapping_attributes,
 525 };
 526 EXPORT_SYMBOL_GPL(nd_mapping_attribute_group);
 527
 528 void *nd_region_provider_data(struct nd_region *nd_region)
 529 {
 530         return nd_region->provider_data;
 531 }
 532 EXPORT_SYMBOL_GPL(nd_region_provider_data);
 533
 534 static struct nd_region *nd_region_create(struct nvdimm_bus *nvdimm_bus,
 535                 struct nd_region_desc *ndr_desc, struct device_type *dev_type,
 536                 const char *caller)
 537 {
 538         struct nd_region *nd_region;
 539         struct device *dev;
 540         u16 i;
 541
 542         for (i = 0; i < ndr_desc->num_mappings; i++) {
 543                 struct nd_mapping *nd_mapping = &ndr_desc->nd_mapping[i];
 544                 struct nvdimm *nvdimm = nd_mapping->nvdimm;
 545
 546                 if ((nd_mapping->start | nd_mapping->size) % SZ_4K) {
 547                         dev_err(&nvdimm_bus->dev, "%s: %s mapping%d is not 4K aligned\n",
 548                                         caller, dev_name(&nvdimm->dev), i);
 549
 550                         return NULL;
 551                 }
 552         }
 553
 554         nd_region = kzalloc(sizeof(struct nd_region)
 555                         + sizeof(struct nd_mapping) * ndr_desc->num_mappings,
 556                         GFP_KERNEL);
 557         if (!nd_region)
 558                 return NULL;
 559         nd_region->id = ida_simple_get(&region_ida, 0, 0, GFP_KERNEL);
 560         if (nd_region->id < 0) {
 561                 kfree(nd_region);
 562                 return NULL;
 563         }
 564
 565         memcpy(nd_region->mapping, ndr_desc->nd_mapping,
 566                         sizeof(struct nd_mapping) * ndr_desc->num_mappings);
 567         for (i = 0; i < ndr_desc->num_mappings; i++) {
 568                 struct nd_mapping *nd_mapping = &ndr_desc->nd_mapping[i];
 569                 struct nvdimm *nvdimm = nd_mapping->nvdimm;
 570
 571                 get_device(&nvdimm->dev);
 572         }
 573         nd_region->ndr_mappings = ndr_desc->num_mappings;
 574         nd_region->provider_data = ndr_desc->provider_data;
 575         nd_region->nd_set = ndr_desc->nd_set;
 576         ida_init(&nd_region->ns_ida);
 577         ida_init(&nd_region->btt_ida);
 578         dev = &nd_region->dev;
 579         dev_set_name(dev, "region%d", nd_region->id);
 580         dev->parent = &nvdimm_bus->dev;
 581         dev->type = dev_type;
 582         dev->groups = ndr_desc->attr_groups;
 583         nd_region->ndr_size = resource_size(ndr_desc->res);
 584         nd_region->ndr_start = ndr_desc->res->start;
 585         nd_device_register(dev);
 586
 587         return nd_region;
 588 }
 589
 590 struct nd_region *nvdimm_pmem_region_create(struct nvdimm_bus *nvdimm_bus,
 591                 struct nd_region_desc *ndr_desc)
 592 {
 593         return nd_region_create(nvdimm_bus, ndr_desc, &nd_pmem_device_type,
 594                         __func__);
 595 }
 596 EXPORT_SYMBOL_GPL(nvdimm_pmem_region_create);
 597
 598 struct nd_region *nvdimm_blk_region_create(struct nvdimm_bus *nvdimm_bus,
 599                 struct nd_region_desc *ndr_desc)
 600 {
 601         if (ndr_desc->num_mappings > 1)
 602                 return NULL;
 603         return nd_region_create(nvdimm_bus, ndr_desc, &nd_blk_device_type,
 604                         __func__);
 605 }
 606 EXPORT_SYMBOL_GPL(nvdimm_blk_region_create);
 607
 608 struct nd_region *nvdimm_volatile_region_create(struct nvdimm_bus *nvdimm_bus,
 609                 struct nd_region_desc *ndr_desc)
 610 {
 611         return nd_region_create(nvdimm_bus, ndr_desc, &nd_volatile_device_type,
 612                         __func__);
 613 }
 614 EXPORT_SYMBOL_GPL(nvdimm_volatile_region_create);