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