source: src/linux/universal/linux-4.9/drivers/nvdimm/namespace_devs.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 8 days ago

use new squashfs in all kernels

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