2 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
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.
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.
13 #include <linux/module.h>
14 #include <linux/device.h>
15 #include <linux/sort.h>
16 #include <linux/slab.h>
17 #include <linux/list.h>
23 static void namespace_io_release(struct device
*dev
)
25 struct nd_namespace_io
*nsio
= to_nd_namespace_io(dev
);
30 static void namespace_pmem_release(struct device
*dev
)
32 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
33 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
36 ida_simple_remove(&nd_region
->ns_ida
, nspm
->id
);
37 kfree(nspm
->alt_name
);
42 static void namespace_blk_release(struct device
*dev
)
44 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
45 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
48 ida_simple_remove(&nd_region
->ns_ida
, nsblk
->id
);
49 kfree(nsblk
->alt_name
);
55 static const struct device_type namespace_io_device_type
= {
56 .name
= "nd_namespace_io",
57 .release
= namespace_io_release
,
60 static const struct device_type namespace_pmem_device_type
= {
61 .name
= "nd_namespace_pmem",
62 .release
= namespace_pmem_release
,
65 static const struct device_type namespace_blk_device_type
= {
66 .name
= "nd_namespace_blk",
67 .release
= namespace_blk_release
,
70 static bool is_namespace_pmem(const struct device
*dev
)
72 return dev
? dev
->type
== &namespace_pmem_device_type
: false;
75 static bool is_namespace_blk(const struct device
*dev
)
77 return dev
? dev
->type
== &namespace_blk_device_type
: false;
80 static bool is_namespace_io(const struct device
*dev
)
82 return dev
? dev
->type
== &namespace_io_device_type
: false;
85 static int is_uuid_busy(struct device
*dev
, void *data
)
87 u8
*uuid1
= data
, *uuid2
= NULL
;
89 if (is_namespace_pmem(dev
)) {
90 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
93 } else if (is_namespace_blk(dev
)) {
94 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
97 } else if (is_nd_btt(dev
)) {
98 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
100 uuid2
= nd_btt
->uuid
;
101 } else if (is_nd_pfn(dev
)) {
102 struct nd_pfn
*nd_pfn
= to_nd_pfn(dev
);
104 uuid2
= nd_pfn
->uuid
;
107 if (uuid2
&& memcmp(uuid1
, uuid2
, NSLABEL_UUID_LEN
) == 0)
113 static int is_namespace_uuid_busy(struct device
*dev
, void *data
)
115 if (is_nd_region(dev
))
116 return device_for_each_child(dev
, data
, is_uuid_busy
);
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
125 bool nd_is_uuid_unique(struct device
*dev
, u8
*uuid
)
127 struct nvdimm_bus
*nvdimm_bus
= walk_to_nvdimm_bus(dev
);
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)
138 bool pmem_should_map_pages(struct device
*dev
)
140 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
141 struct nd_namespace_io
*nsio
;
143 if (!IS_ENABLED(CONFIG_ZONE_DEVICE
))
146 if (!test_bit(ND_REGION_PAGEMAP
, &nd_region
->flags
))
149 if (is_nd_pfn(dev
) || is_nd_btt(dev
))
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
)
158 return ARCH_MEMREMAP_PMEM
== MEMREMAP_WB
;
160 EXPORT_SYMBOL(pmem_should_map_pages
);
162 unsigned int pmem_sector_size(struct nd_namespace_common
*ndns
)
164 if (is_namespace_pmem(&ndns
->dev
)) {
165 struct nd_namespace_pmem
*nspm
;
167 nspm
= to_nd_namespace_pmem(&ndns
->dev
);
168 if (nspm
->lbasize
== 0 || nspm
->lbasize
== 512)
170 else if (nspm
->lbasize
== 4096)
173 dev_WARN(&ndns
->dev
, "unsupported sector size: %ld\n",
178 * There is no namespace label (is_namespace_io()), or the label
179 * indicates the default sector size.
183 EXPORT_SYMBOL(pmem_sector_size
);
185 const char *nvdimm_namespace_disk_name(struct nd_namespace_common
*ndns
,
188 struct nd_region
*nd_region
= to_nd_region(ndns
->dev
.parent
);
189 const char *suffix
= NULL
;
191 if (ndns
->claim
&& is_nd_btt(ndns
->claim
))
194 if (is_namespace_pmem(&ndns
->dev
) || is_namespace_io(&ndns
->dev
)) {
197 if (is_namespace_pmem(&ndns
->dev
)) {
198 struct nd_namespace_pmem
*nspm
;
200 nspm
= to_nd_namespace_pmem(&ndns
->dev
);
205 sprintf(name
, "pmem%d.%d%s", nd_region
->id
, nsidx
,
206 suffix
? suffix
: "");
208 sprintf(name
, "pmem%d%s", nd_region
->id
,
209 suffix
? suffix
: "");
210 } else if (is_namespace_blk(&ndns
->dev
)) {
211 struct nd_namespace_blk
*nsblk
;
213 nsblk
= to_nd_namespace_blk(&ndns
->dev
);
214 sprintf(name
, "ndblk%d.%d%s", nd_region
->id
, nsblk
->id
,
215 suffix
? suffix
: "");
222 EXPORT_SYMBOL(nvdimm_namespace_disk_name
);
224 const u8
*nd_dev_to_uuid(struct device
*dev
)
226 static const u8 null_uuid
[16];
231 if (is_namespace_pmem(dev
)) {
232 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
235 } else if (is_namespace_blk(dev
)) {
236 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
242 EXPORT_SYMBOL(nd_dev_to_uuid
);
244 static ssize_t
nstype_show(struct device
*dev
,
245 struct device_attribute
*attr
, char *buf
)
247 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
249 return sprintf(buf
, "%d\n", nd_region_to_nstype(nd_region
));
251 static DEVICE_ATTR_RO(nstype
);
253 static ssize_t
__alt_name_store(struct device
*dev
, const char *buf
,
256 char *input
, *pos
, *alt_name
, **ns_altname
;
259 if (is_namespace_pmem(dev
)) {
260 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
262 ns_altname
= &nspm
->alt_name
;
263 } else if (is_namespace_blk(dev
)) {
264 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
266 ns_altname
= &nsblk
->alt_name
;
270 if (dev
->driver
|| to_ndns(dev
)->claim
)
273 input
= kmemdup(buf
, len
+ 1, GFP_KERNEL
);
279 if (strlen(pos
) + 1 > NSLABEL_NAME_LEN
) {
284 alt_name
= kzalloc(NSLABEL_NAME_LEN
, GFP_KERNEL
);
290 *ns_altname
= alt_name
;
291 sprintf(*ns_altname
, "%s", pos
);
299 static resource_size_t
nd_namespace_blk_size(struct nd_namespace_blk
*nsblk
)
301 struct nd_region
*nd_region
= to_nd_region(nsblk
->common
.dev
.parent
);
302 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[0];
303 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
304 struct nd_label_id label_id
;
305 resource_size_t size
= 0;
306 struct resource
*res
;
310 nd_label_gen_id(&label_id
, nsblk
->uuid
, NSLABEL_FLAG_LOCAL
);
311 for_each_dpa_resource(ndd
, res
)
312 if (strcmp(res
->name
, label_id
.id
) == 0)
313 size
+= resource_size(res
);
317 static bool __nd_namespace_blk_validate(struct nd_namespace_blk
*nsblk
)
319 struct nd_region
*nd_region
= to_nd_region(nsblk
->common
.dev
.parent
);
320 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[0];
321 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
322 struct nd_label_id label_id
;
323 struct resource
*res
;
326 if (!nsblk
->uuid
|| !nsblk
->lbasize
|| !ndd
)
330 nd_label_gen_id(&label_id
, nsblk
->uuid
, NSLABEL_FLAG_LOCAL
);
331 for_each_dpa_resource(ndd
, res
) {
332 if (strcmp(res
->name
, label_id
.id
) != 0)
335 * Resources with unacknowledged adjustments indicate a
336 * failure to update labels
338 if (res
->flags
& DPA_RESOURCE_ADJUSTED
)
343 /* These values match after a successful label update */
344 if (count
!= nsblk
->num_resources
)
347 for (i
= 0; i
< nsblk
->num_resources
; i
++) {
348 struct resource
*found
= NULL
;
350 for_each_dpa_resource(ndd
, res
)
351 if (res
== nsblk
->res
[i
]) {
363 resource_size_t
nd_namespace_blk_validate(struct nd_namespace_blk
*nsblk
)
365 resource_size_t size
;
367 nvdimm_bus_lock(&nsblk
->common
.dev
);
368 size
= __nd_namespace_blk_validate(nsblk
);
369 nvdimm_bus_unlock(&nsblk
->common
.dev
);
373 EXPORT_SYMBOL(nd_namespace_blk_validate
);
376 static int nd_namespace_label_update(struct nd_region
*nd_region
,
379 dev_WARN_ONCE(dev
, dev
->driver
|| to_ndns(dev
)->claim
,
380 "namespace must be idle during label update\n");
381 if (dev
->driver
|| to_ndns(dev
)->claim
)
385 * Only allow label writes that will result in a valid namespace
386 * or deletion of an existing namespace.
388 if (is_namespace_pmem(dev
)) {
389 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
390 resource_size_t size
= resource_size(&nspm
->nsio
.res
);
392 if (size
== 0 && nspm
->uuid
)
393 /* delete allocation */;
394 else if (!nspm
->uuid
)
397 return nd_pmem_namespace_label_update(nd_region
, nspm
, size
);
398 } else if (is_namespace_blk(dev
)) {
399 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
400 resource_size_t size
= nd_namespace_blk_size(nsblk
);
402 if (size
== 0 && nsblk
->uuid
)
403 /* delete allocation */;
404 else if (!nsblk
->uuid
|| !nsblk
->lbasize
)
407 return nd_blk_namespace_label_update(nd_region
, nsblk
, size
);
412 static ssize_t
alt_name_store(struct device
*dev
,
413 struct device_attribute
*attr
, const char *buf
, size_t len
)
415 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
419 nvdimm_bus_lock(dev
);
420 wait_nvdimm_bus_probe_idle(dev
);
421 rc
= __alt_name_store(dev
, buf
, len
);
423 rc
= nd_namespace_label_update(nd_region
, dev
);
424 dev_dbg(dev
, "%s: %s(%zd)\n", __func__
, rc
< 0 ? "fail " : "", rc
);
425 nvdimm_bus_unlock(dev
);
428 return rc
< 0 ? rc
: len
;
431 static ssize_t
alt_name_show(struct device
*dev
,
432 struct device_attribute
*attr
, char *buf
)
436 if (is_namespace_pmem(dev
)) {
437 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
439 ns_altname
= nspm
->alt_name
;
440 } else if (is_namespace_blk(dev
)) {
441 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
443 ns_altname
= nsblk
->alt_name
;
447 return sprintf(buf
, "%s\n", ns_altname
? ns_altname
: "");
449 static DEVICE_ATTR_RW(alt_name
);
451 static int scan_free(struct nd_region
*nd_region
,
452 struct nd_mapping
*nd_mapping
, struct nd_label_id
*label_id
,
455 bool is_blk
= strncmp(label_id
->id
, "blk", 3) == 0;
456 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
460 struct resource
*res
, *last
;
461 resource_size_t new_start
;
464 for_each_dpa_resource(ndd
, res
)
465 if (strcmp(res
->name
, label_id
->id
) == 0)
471 if (n
>= resource_size(res
)) {
472 n
-= resource_size(res
);
473 nd_dbg_dpa(nd_region
, ndd
, res
, "delete %d\n", rc
);
474 nvdimm_free_dpa(ndd
, res
);
475 /* retry with last resource deleted */
480 * Keep BLK allocations relegated to high DPA as much as
484 new_start
= res
->start
+ n
;
486 new_start
= res
->start
;
488 rc
= adjust_resource(res
, new_start
, resource_size(res
) - n
);
490 res
->flags
|= DPA_RESOURCE_ADJUSTED
;
491 nd_dbg_dpa(nd_region
, ndd
, res
, "shrink %d\n", rc
);
499 * shrink_dpa_allocation - for each dimm in region free n bytes for label_id
500 * @nd_region: the set of dimms to reclaim @n bytes from
501 * @label_id: unique identifier for the namespace consuming this dpa range
502 * @n: number of bytes per-dimm to release
504 * Assumes resources are ordered. Starting from the end try to
505 * adjust_resource() the allocation to @n, but if @n is larger than the
506 * allocation delete it and find the 'new' last allocation in the label
509 static int shrink_dpa_allocation(struct nd_region
*nd_region
,
510 struct nd_label_id
*label_id
, resource_size_t n
)
514 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
515 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
518 rc
= scan_free(nd_region
, nd_mapping
, label_id
, n
);
526 static resource_size_t
init_dpa_allocation(struct nd_label_id
*label_id
,
527 struct nd_region
*nd_region
, struct nd_mapping
*nd_mapping
,
530 bool is_blk
= strncmp(label_id
->id
, "blk", 3) == 0;
531 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
532 resource_size_t first_dpa
;
533 struct resource
*res
;
536 /* allocate blk from highest dpa first */
538 first_dpa
= nd_mapping
->start
+ nd_mapping
->size
- n
;
540 first_dpa
= nd_mapping
->start
;
542 /* first resource allocation for this label-id or dimm */
543 res
= nvdimm_allocate_dpa(ndd
, label_id
, first_dpa
, n
);
547 nd_dbg_dpa(nd_region
, ndd
, res
, "init %d\n", rc
);
553 * space_valid() - validate free dpa space against constraints
554 * @nd_region: hosting region of the free space
555 * @ndd: dimm device data for debug
556 * @label_id: namespace id to allocate space
557 * @prev: potential allocation that precedes free space
558 * @next: allocation that follows the given free space range
559 * @exist: first allocation with same id in the mapping
560 * @n: range that must satisfied for pmem allocations
561 * @valid: free space range to validate
563 * BLK-space is valid as long as it does not precede a PMEM
564 * allocation in a given region. PMEM-space must be contiguous
565 * and adjacent to an existing existing allocation (if one
566 * exists). If reserving PMEM any space is valid.
568 static void space_valid(struct nd_region
*nd_region
, struct nvdimm_drvdata
*ndd
,
569 struct nd_label_id
*label_id
, struct resource
*prev
,
570 struct resource
*next
, struct resource
*exist
,
571 resource_size_t n
, struct resource
*valid
)
573 bool is_reserve
= strcmp(label_id
->id
, "pmem-reserve") == 0;
574 bool is_pmem
= strncmp(label_id
->id
, "pmem", 4) == 0;
576 if (valid
->start
>= valid
->end
)
583 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[0];
584 struct nvdimm_bus
*nvdimm_bus
;
585 struct blk_alloc_info info
= {
586 .nd_mapping
= nd_mapping
,
587 .available
= nd_mapping
->size
,
591 WARN_ON(!is_nd_blk(&nd_region
->dev
));
592 nvdimm_bus
= walk_to_nvdimm_bus(&nd_region
->dev
);
593 device_for_each_child(&nvdimm_bus
->dev
, &info
, alias_dpa_busy
);
597 /* allocation needs to be contiguous, so this is all or nothing */
598 if (resource_size(valid
) < n
)
601 /* we've got all the space we need and no existing allocation */
605 /* allocation needs to be contiguous with the existing namespace */
606 if (valid
->start
== exist
->end
+ 1
607 || valid
->end
== exist
->start
- 1)
611 /* truncate @valid size to 0 */
612 valid
->end
= valid
->start
- 1;
616 ALLOC_ERR
= 0, ALLOC_BEFORE
, ALLOC_MID
, ALLOC_AFTER
,
619 static resource_size_t
scan_allocate(struct nd_region
*nd_region
,
620 struct nd_mapping
*nd_mapping
, struct nd_label_id
*label_id
,
623 resource_size_t mapping_end
= nd_mapping
->start
+ nd_mapping
->size
- 1;
624 bool is_pmem
= strncmp(label_id
->id
, "pmem", 4) == 0;
625 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
626 struct resource
*res
, *exist
= NULL
, valid
;
627 const resource_size_t to_allocate
= n
;
630 for_each_dpa_resource(ndd
, res
)
631 if (strcmp(label_id
->id
, res
->name
) == 0)
634 valid
.start
= nd_mapping
->start
;
635 valid
.end
= mapping_end
;
636 valid
.name
= "free space";
639 for_each_dpa_resource(ndd
, res
) {
640 struct resource
*next
= res
->sibling
, *new_res
= NULL
;
641 resource_size_t allocate
, available
= 0;
642 enum alloc_loc loc
= ALLOC_ERR
;
646 /* ignore resources outside this nd_mapping */
647 if (res
->start
> mapping_end
)
649 if (res
->end
< nd_mapping
->start
)
652 /* space at the beginning of the mapping */
653 if (!first
++ && res
->start
> nd_mapping
->start
) {
654 valid
.start
= nd_mapping
->start
;
655 valid
.end
= res
->start
- 1;
656 space_valid(nd_region
, ndd
, label_id
, NULL
, next
, exist
,
657 to_allocate
, &valid
);
658 available
= resource_size(&valid
);
663 /* space between allocations */
665 valid
.start
= res
->start
+ resource_size(res
);
666 valid
.end
= min(mapping_end
, next
->start
- 1);
667 space_valid(nd_region
, ndd
, label_id
, res
, next
, exist
,
668 to_allocate
, &valid
);
669 available
= resource_size(&valid
);
674 /* space at the end of the mapping */
676 valid
.start
= res
->start
+ resource_size(res
);
677 valid
.end
= mapping_end
;
678 space_valid(nd_region
, ndd
, label_id
, res
, next
, exist
,
679 to_allocate
, &valid
);
680 available
= resource_size(&valid
);
685 if (!loc
|| !available
)
687 allocate
= min(available
, n
);
690 if (strcmp(res
->name
, label_id
->id
) == 0) {
691 /* adjust current resource up */
692 rc
= adjust_resource(res
, res
->start
- allocate
,
693 resource_size(res
) + allocate
);
694 action
= "cur grow up";
699 if (strcmp(next
->name
, label_id
->id
) == 0) {
700 /* adjust next resource up */
701 rc
= adjust_resource(next
, next
->start
702 - allocate
, resource_size(next
)
705 action
= "next grow up";
706 } else if (strcmp(res
->name
, label_id
->id
) == 0) {
707 action
= "grow down";
712 if (strcmp(res
->name
, label_id
->id
) == 0)
713 action
= "grow down";
721 if (strcmp(action
, "allocate") == 0) {
722 /* BLK allocate bottom up */
724 valid
.start
+= available
- allocate
;
726 new_res
= nvdimm_allocate_dpa(ndd
, label_id
,
727 valid
.start
, allocate
);
730 } else if (strcmp(action
, "grow down") == 0) {
731 /* adjust current resource down */
732 rc
= adjust_resource(res
, res
->start
, resource_size(res
)
735 res
->flags
|= DPA_RESOURCE_ADJUSTED
;
741 nd_dbg_dpa(nd_region
, ndd
, new_res
, "%s(%d) %d\n",
750 * Retry scan with newly inserted resources.
751 * For example, if we did an ALLOC_BEFORE
752 * insertion there may also have been space
753 * available for an ALLOC_AFTER insertion, so we
754 * need to check this same resource again
762 * If we allocated nothing in the BLK case it may be because we are in
763 * an initial "pmem-reserve pass". Only do an initial BLK allocation
764 * when none of the DPA space is reserved.
766 if ((is_pmem
|| !ndd
->dpa
.child
) && n
== to_allocate
)
767 return init_dpa_allocation(label_id
, nd_region
, nd_mapping
, n
);
771 static int merge_dpa(struct nd_region
*nd_region
,
772 struct nd_mapping
*nd_mapping
, struct nd_label_id
*label_id
)
774 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
775 struct resource
*res
;
777 if (strncmp("pmem", label_id
->id
, 4) == 0)
780 for_each_dpa_resource(ndd
, res
) {
782 struct resource
*next
= res
->sibling
;
783 resource_size_t end
= res
->start
+ resource_size(res
);
785 if (!next
|| strcmp(res
->name
, label_id
->id
) != 0
786 || strcmp(next
->name
, label_id
->id
) != 0
787 || end
!= next
->start
)
789 end
+= resource_size(next
);
790 nvdimm_free_dpa(ndd
, next
);
791 rc
= adjust_resource(res
, res
->start
, end
- res
->start
);
792 nd_dbg_dpa(nd_region
, ndd
, res
, "merge %d\n", rc
);
795 res
->flags
|= DPA_RESOURCE_ADJUSTED
;
802 static int __reserve_free_pmem(struct device
*dev
, void *data
)
804 struct nvdimm
*nvdimm
= data
;
805 struct nd_region
*nd_region
;
806 struct nd_label_id label_id
;
812 nd_region
= to_nd_region(dev
);
813 if (nd_region
->ndr_mappings
== 0)
816 memset(&label_id
, 0, sizeof(label_id
));
817 strcat(label_id
.id
, "pmem-reserve");
818 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
819 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
820 resource_size_t n
, rem
= 0;
822 if (nd_mapping
->nvdimm
!= nvdimm
)
825 n
= nd_pmem_available_dpa(nd_region
, nd_mapping
, &rem
);
828 rem
= scan_allocate(nd_region
, nd_mapping
, &label_id
, n
);
829 dev_WARN_ONCE(&nd_region
->dev
, rem
,
830 "pmem reserve underrun: %#llx of %#llx bytes\n",
831 (unsigned long long) n
- rem
,
832 (unsigned long long) n
);
833 return rem
? -ENXIO
: 0;
839 static void release_free_pmem(struct nvdimm_bus
*nvdimm_bus
,
840 struct nd_mapping
*nd_mapping
)
842 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
843 struct resource
*res
, *_res
;
845 for_each_dpa_resource_safe(ndd
, res
, _res
)
846 if (strcmp(res
->name
, "pmem-reserve") == 0)
847 nvdimm_free_dpa(ndd
, res
);
850 static int reserve_free_pmem(struct nvdimm_bus
*nvdimm_bus
,
851 struct nd_mapping
*nd_mapping
)
853 struct nvdimm
*nvdimm
= nd_mapping
->nvdimm
;
856 rc
= device_for_each_child(&nvdimm_bus
->dev
, nvdimm
,
857 __reserve_free_pmem
);
859 release_free_pmem(nvdimm_bus
, nd_mapping
);
864 * grow_dpa_allocation - for each dimm allocate n bytes for @label_id
865 * @nd_region: the set of dimms to allocate @n more bytes from
866 * @label_id: unique identifier for the namespace consuming this dpa range
867 * @n: number of bytes per-dimm to add to the existing allocation
869 * Assumes resources are ordered. For BLK regions, first consume
870 * BLK-only available DPA free space, then consume PMEM-aliased DPA
871 * space starting at the highest DPA. For PMEM regions start
872 * allocations from the start of an interleave set and end at the first
873 * BLK allocation or the end of the interleave set, whichever comes
876 static int grow_dpa_allocation(struct nd_region
*nd_region
,
877 struct nd_label_id
*label_id
, resource_size_t n
)
879 struct nvdimm_bus
*nvdimm_bus
= walk_to_nvdimm_bus(&nd_region
->dev
);
880 bool is_pmem
= strncmp(label_id
->id
, "pmem", 4) == 0;
883 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
884 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
885 resource_size_t rem
= n
;
889 * In the BLK case try once with all unallocated PMEM
890 * reserved, and once without
892 for (j
= is_pmem
; j
< 2; j
++) {
893 bool blk_only
= j
== 0;
896 rc
= reserve_free_pmem(nvdimm_bus
, nd_mapping
);
900 rem
= scan_allocate(nd_region
, nd_mapping
,
903 release_free_pmem(nvdimm_bus
, nd_mapping
);
905 /* try again and allow encroachments into PMEM */
910 dev_WARN_ONCE(&nd_region
->dev
, rem
,
911 "allocation underrun: %#llx of %#llx bytes\n",
912 (unsigned long long) n
- rem
,
913 (unsigned long long) n
);
917 rc
= merge_dpa(nd_region
, nd_mapping
, label_id
);
925 static void nd_namespace_pmem_set_resource(struct nd_region
*nd_region
,
926 struct nd_namespace_pmem
*nspm
, resource_size_t size
)
928 struct resource
*res
= &nspm
->nsio
.res
;
929 resource_size_t offset
= 0;
931 if (size
&& !nspm
->uuid
) {
936 if (size
&& nspm
->uuid
) {
937 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[0];
938 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
939 struct nd_label_id label_id
;
940 struct resource
*res
;
947 nd_label_gen_id(&label_id
, nspm
->uuid
, 0);
949 /* calculate a spa offset from the dpa allocation offset */
950 for_each_dpa_resource(ndd
, res
)
951 if (strcmp(res
->name
, label_id
.id
) == 0) {
952 offset
= (res
->start
- nd_mapping
->start
)
953 * nd_region
->ndr_mappings
;
962 res
->start
= nd_region
->ndr_start
+ offset
;
963 res
->end
= res
->start
+ size
- 1;
966 static bool uuid_not_set(const u8
*uuid
, struct device
*dev
, const char *where
)
969 dev_dbg(dev
, "%s: uuid not set\n", where
);
975 static ssize_t
__size_store(struct device
*dev
, unsigned long long val
)
977 resource_size_t allocated
= 0, available
= 0;
978 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
979 struct nd_namespace_common
*ndns
= to_ndns(dev
);
980 struct nd_mapping
*nd_mapping
;
981 struct nvdimm_drvdata
*ndd
;
982 struct nd_label_id label_id
;
983 u32 flags
= 0, remainder
;
987 if (dev
->driver
|| ndns
->claim
)
990 if (is_namespace_pmem(dev
)) {
991 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
995 } else if (is_namespace_blk(dev
)) {
996 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
999 flags
= NSLABEL_FLAG_LOCAL
;
1004 * We need a uuid for the allocation-label and dimm(s) on which
1005 * to store the label.
1007 if (uuid_not_set(uuid
, dev
, __func__
))
1009 if (nd_region
->ndr_mappings
== 0) {
1010 dev_dbg(dev
, "%s: not associated with dimm(s)\n", __func__
);
1014 div_u64_rem(val
, SZ_4K
* nd_region
->ndr_mappings
, &remainder
);
1016 dev_dbg(dev
, "%llu is not %dK aligned\n", val
,
1017 (SZ_4K
* nd_region
->ndr_mappings
) / SZ_1K
);
1021 nd_label_gen_id(&label_id
, uuid
, flags
);
1022 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1023 nd_mapping
= &nd_region
->mapping
[i
];
1024 ndd
= to_ndd(nd_mapping
);
1027 * All dimms in an interleave set, or the base dimm for a blk
1028 * region, need to be enabled for the size to be changed.
1033 allocated
+= nvdimm_allocated_dpa(ndd
, &label_id
);
1035 available
= nd_region_available_dpa(nd_region
);
1037 if (val
> available
+ allocated
)
1040 if (val
== allocated
)
1043 val
= div_u64(val
, nd_region
->ndr_mappings
);
1044 allocated
= div_u64(allocated
, nd_region
->ndr_mappings
);
1045 if (val
< allocated
)
1046 rc
= shrink_dpa_allocation(nd_region
, &label_id
,
1049 rc
= grow_dpa_allocation(nd_region
, &label_id
, val
- allocated
);
1054 if (is_namespace_pmem(dev
)) {
1055 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1057 nd_namespace_pmem_set_resource(nd_region
, nspm
,
1058 val
* nd_region
->ndr_mappings
);
1062 * Try to delete the namespace if we deleted all of its
1063 * allocation, this is not the seed or 0th device for the
1064 * region, and it is not actively claimed by a btt, pfn, or dax
1067 if (val
== 0 && id
!= 0 && nd_region
->ns_seed
!= dev
&& !ndns
->claim
)
1068 nd_device_unregister(dev
, ND_ASYNC
);
1073 static ssize_t
size_store(struct device
*dev
,
1074 struct device_attribute
*attr
, const char *buf
, size_t len
)
1076 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
1077 unsigned long long val
;
1081 rc
= kstrtoull(buf
, 0, &val
);
1086 nvdimm_bus_lock(dev
);
1087 wait_nvdimm_bus_probe_idle(dev
);
1088 rc
= __size_store(dev
, val
);
1090 rc
= nd_namespace_label_update(nd_region
, dev
);
1092 if (is_namespace_pmem(dev
)) {
1093 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1096 } else if (is_namespace_blk(dev
)) {
1097 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
1099 uuid
= &nsblk
->uuid
;
1102 if (rc
== 0 && val
== 0 && uuid
) {
1103 /* setting size zero == 'delete namespace' */
1108 dev_dbg(dev
, "%s: %llx %s (%d)\n", __func__
, val
, rc
< 0
1109 ? "fail" : "success", rc
);
1111 nvdimm_bus_unlock(dev
);
1114 return rc
< 0 ? rc
: len
;
1117 resource_size_t
__nvdimm_namespace_capacity(struct nd_namespace_common
*ndns
)
1119 struct device
*dev
= &ndns
->dev
;
1121 if (is_namespace_pmem(dev
)) {
1122 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1124 return resource_size(&nspm
->nsio
.res
);
1125 } else if (is_namespace_blk(dev
)) {
1126 return nd_namespace_blk_size(to_nd_namespace_blk(dev
));
1127 } else if (is_namespace_io(dev
)) {
1128 struct nd_namespace_io
*nsio
= to_nd_namespace_io(dev
);
1130 return resource_size(&nsio
->res
);
1132 WARN_ONCE(1, "unknown namespace type\n");
1136 resource_size_t
nvdimm_namespace_capacity(struct nd_namespace_common
*ndns
)
1138 resource_size_t size
;
1140 nvdimm_bus_lock(&ndns
->dev
);
1141 size
= __nvdimm_namespace_capacity(ndns
);
1142 nvdimm_bus_unlock(&ndns
->dev
);
1146 EXPORT_SYMBOL(nvdimm_namespace_capacity
);
1148 static ssize_t
size_show(struct device
*dev
,
1149 struct device_attribute
*attr
, char *buf
)
1151 return sprintf(buf
, "%llu\n", (unsigned long long)
1152 nvdimm_namespace_capacity(to_ndns(dev
)));
1154 static DEVICE_ATTR(size
, 0444, size_show
, size_store
);
1156 static u8
*namespace_to_uuid(struct device
*dev
)
1158 if (is_namespace_pmem(dev
)) {
1159 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1162 } else if (is_namespace_blk(dev
)) {
1163 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
1167 return ERR_PTR(-ENXIO
);
1170 static ssize_t
uuid_show(struct device
*dev
,
1171 struct device_attribute
*attr
, char *buf
)
1173 u8
*uuid
= namespace_to_uuid(dev
);
1176 return PTR_ERR(uuid
);
1178 return sprintf(buf
, "%pUb\n", uuid
);
1179 return sprintf(buf
, "\n");
1183 * namespace_update_uuid - check for a unique uuid and whether we're "renaming"
1184 * @nd_region: parent region so we can updates all dimms in the set
1185 * @dev: namespace type for generating label_id
1186 * @new_uuid: incoming uuid
1187 * @old_uuid: reference to the uuid storage location in the namespace object
1189 static int namespace_update_uuid(struct nd_region
*nd_region
,
1190 struct device
*dev
, u8
*new_uuid
, u8
**old_uuid
)
1192 u32 flags
= is_namespace_blk(dev
) ? NSLABEL_FLAG_LOCAL
: 0;
1193 struct nd_label_id old_label_id
;
1194 struct nd_label_id new_label_id
;
1197 if (!nd_is_uuid_unique(dev
, new_uuid
))
1200 if (*old_uuid
== NULL
)
1204 * If we've already written a label with this uuid, then it's
1205 * too late to rename because we can't reliably update the uuid
1206 * without losing the old namespace. Userspace must delete this
1207 * namespace to abandon the old uuid.
1209 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1210 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
1213 * This check by itself is sufficient because old_uuid
1214 * would be NULL above if this uuid did not exist in the
1215 * currently written set.
1217 * FIXME: can we delete uuid with zero dpa allocated?
1219 if (list_empty(&nd_mapping
->labels
))
1223 nd_label_gen_id(&old_label_id
, *old_uuid
, flags
);
1224 nd_label_gen_id(&new_label_id
, new_uuid
, flags
);
1225 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1226 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
1227 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
1228 struct resource
*res
;
1230 for_each_dpa_resource(ndd
, res
)
1231 if (strcmp(res
->name
, old_label_id
.id
) == 0)
1232 sprintf((void *) res
->name
, "%s",
1237 *old_uuid
= new_uuid
;
1241 static ssize_t
uuid_store(struct device
*dev
,
1242 struct device_attribute
*attr
, const char *buf
, size_t len
)
1244 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
1249 if (is_namespace_pmem(dev
)) {
1250 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1252 ns_uuid
= &nspm
->uuid
;
1253 } else if (is_namespace_blk(dev
)) {
1254 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
1256 ns_uuid
= &nsblk
->uuid
;
1261 nvdimm_bus_lock(dev
);
1262 wait_nvdimm_bus_probe_idle(dev
);
1263 if (to_ndns(dev
)->claim
)
1266 rc
= nd_uuid_store(dev
, &uuid
, buf
, len
);
1268 rc
= namespace_update_uuid(nd_region
, dev
, uuid
, ns_uuid
);
1270 rc
= nd_namespace_label_update(nd_region
, dev
);
1273 dev_dbg(dev
, "%s: result: %zd wrote: %s%s", __func__
,
1274 rc
, buf
, buf
[len
- 1] == '\n' ? "" : "\n");
1275 nvdimm_bus_unlock(dev
);
1278 return rc
< 0 ? rc
: len
;
1280 static DEVICE_ATTR_RW(uuid
);
1282 static ssize_t
resource_show(struct device
*dev
,
1283 struct device_attribute
*attr
, char *buf
)
1285 struct resource
*res
;
1287 if (is_namespace_pmem(dev
)) {
1288 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1290 res
= &nspm
->nsio
.res
;
1291 } else if (is_namespace_io(dev
)) {
1292 struct nd_namespace_io
*nsio
= to_nd_namespace_io(dev
);
1298 /* no address to convey if the namespace has no allocation */
1299 if (resource_size(res
) == 0)
1301 return sprintf(buf
, "%#llx\n", (unsigned long long) res
->start
);
1303 static DEVICE_ATTR_RO(resource
);
1305 static const unsigned long blk_lbasize_supported
[] = { 512, 520, 528,
1306 4096, 4104, 4160, 4224, 0 };
1308 static const unsigned long pmem_lbasize_supported
[] = { 512, 4096, 0 };
1310 static ssize_t
sector_size_show(struct device
*dev
,
1311 struct device_attribute
*attr
, char *buf
)
1313 if (is_namespace_blk(dev
)) {
1314 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
1316 return nd_size_select_show(nsblk
->lbasize
,
1317 blk_lbasize_supported
, buf
);
1320 if (is_namespace_pmem(dev
)) {
1321 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1323 return nd_size_select_show(nspm
->lbasize
,
1324 pmem_lbasize_supported
, buf
);
1329 static ssize_t
sector_size_store(struct device
*dev
,
1330 struct device_attribute
*attr
, const char *buf
, size_t len
)
1332 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
1333 const unsigned long *supported
;
1334 unsigned long *lbasize
;
1337 if (is_namespace_blk(dev
)) {
1338 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
1340 lbasize
= &nsblk
->lbasize
;
1341 supported
= blk_lbasize_supported
;
1342 } else if (is_namespace_pmem(dev
)) {
1343 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1345 lbasize
= &nspm
->lbasize
;
1346 supported
= pmem_lbasize_supported
;
1351 nvdimm_bus_lock(dev
);
1352 if (to_ndns(dev
)->claim
)
1355 rc
= nd_size_select_store(dev
, buf
, lbasize
, supported
);
1357 rc
= nd_namespace_label_update(nd_region
, dev
);
1358 dev_dbg(dev
, "%s: result: %zd %s: %s%s", __func__
,
1359 rc
, rc
< 0 ? "tried" : "wrote", buf
,
1360 buf
[len
- 1] == '\n' ? "" : "\n");
1361 nvdimm_bus_unlock(dev
);
1364 return rc
? rc
: len
;
1366 static DEVICE_ATTR_RW(sector_size
);
1368 static ssize_t
dpa_extents_show(struct device
*dev
,
1369 struct device_attribute
*attr
, char *buf
)
1371 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
1372 struct nd_label_id label_id
;
1377 nvdimm_bus_lock(dev
);
1378 if (is_namespace_pmem(dev
)) {
1379 struct nd_namespace_pmem
*nspm
= to_nd_namespace_pmem(dev
);
1383 } else if (is_namespace_blk(dev
)) {
1384 struct nd_namespace_blk
*nsblk
= to_nd_namespace_blk(dev
);
1387 flags
= NSLABEL_FLAG_LOCAL
;
1393 nd_label_gen_id(&label_id
, uuid
, flags
);
1394 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1395 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
1396 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
1397 struct resource
*res
;
1399 for_each_dpa_resource(ndd
, res
)
1400 if (strcmp(res
->name
, label_id
.id
) == 0)
1404 nvdimm_bus_unlock(dev
);
1406 return sprintf(buf
, "%d\n", count
);
1408 static DEVICE_ATTR_RO(dpa_extents
);
1410 static int btt_claim_class(struct device
*dev
)
1412 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
1413 int i
, loop_bitmask
= 0;
1415 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1416 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
1417 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
1418 struct nd_namespace_index
*nsindex
;
1421 * If any of the DIMMs do not support labels the only
1422 * possible BTT format is v1.
1429 nsindex
= to_namespace_index(ndd
, ndd
->ns_current
);
1430 if (nsindex
== NULL
)
1433 /* check whether existing labels are v1.1 or v1.2 */
1434 if (__le16_to_cpu(nsindex
->major
) == 1
1435 && __le16_to_cpu(nsindex
->minor
) == 1)
1442 * If nsindex is null loop_bitmask's bit 0 will be set, and if an index
1443 * block is found, a v1.1 label for any mapping will set bit 1, and a
1444 * v1.2 label will set bit 2.
1446 * At the end of the loop, at most one of the three bits must be set.
1447 * If multiple bits were set, it means the different mappings disagree
1448 * about their labels, and this must be cleaned up first.
1450 * If all the label index blocks are found to agree, nsindex of NULL
1451 * implies labels haven't been initialized yet, and when they will,
1452 * they will be of the 1.2 format, so we can assume BTT2.0
1454 * If 1.1 labels are found, we enforce BTT1.1, and if 1.2 labels are
1455 * found, we enforce BTT2.0
1457 * If the loop was never entered, default to BTT1.1 (legacy namespaces)
1459 switch (loop_bitmask
) {
1462 return NVDIMM_CCLASS_BTT
;
1465 return NVDIMM_CCLASS_BTT2
;
1471 static ssize_t
holder_show(struct device
*dev
,
1472 struct device_attribute
*attr
, char *buf
)
1474 struct nd_namespace_common
*ndns
= to_ndns(dev
);
1478 rc
= sprintf(buf
, "%s\n", ndns
->claim
? dev_name(ndns
->claim
) : "");
1483 static DEVICE_ATTR_RO(holder
);
1485 static ssize_t
__holder_class_store(struct device
*dev
, const char *buf
)
1487 struct nd_namespace_common
*ndns
= to_ndns(dev
);
1489 if (dev
->driver
|| ndns
->claim
)
1492 if (strcmp(buf
, "btt") == 0 || strcmp(buf
, "btt\n") == 0)
1493 ndns
->claim_class
= btt_claim_class(dev
);
1494 else if (strcmp(buf
, "pfn") == 0 || strcmp(buf
, "pfn\n") == 0)
1495 ndns
->claim_class
= NVDIMM_CCLASS_PFN
;
1496 else if (strcmp(buf
, "dax") == 0 || strcmp(buf
, "dax\n") == 0)
1497 ndns
->claim_class
= NVDIMM_CCLASS_DAX
;
1498 else if (strcmp(buf
, "") == 0 || strcmp(buf
, "\n") == 0)
1499 ndns
->claim_class
= NVDIMM_CCLASS_NONE
;
1503 /* btt_claim_class() could've returned an error */
1504 if (ndns
->claim_class
< 0)
1505 return ndns
->claim_class
;
1510 static ssize_t
holder_class_store(struct device
*dev
,
1511 struct device_attribute
*attr
, const char *buf
, size_t len
)
1513 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
1517 nvdimm_bus_lock(dev
);
1518 wait_nvdimm_bus_probe_idle(dev
);
1519 rc
= __holder_class_store(dev
, buf
);
1521 rc
= nd_namespace_label_update(nd_region
, dev
);
1522 dev_dbg(dev
, "%s: %s(%zd)\n", __func__
, rc
< 0 ? "fail " : "", rc
);
1523 nvdimm_bus_unlock(dev
);
1526 return rc
< 0 ? rc
: len
;
1529 static ssize_t
holder_class_show(struct device
*dev
,
1530 struct device_attribute
*attr
, char *buf
)
1532 struct nd_namespace_common
*ndns
= to_ndns(dev
);
1536 if (ndns
->claim_class
== NVDIMM_CCLASS_NONE
)
1537 rc
= sprintf(buf
, "\n");
1538 else if ((ndns
->claim_class
== NVDIMM_CCLASS_BTT
) ||
1539 (ndns
->claim_class
== NVDIMM_CCLASS_BTT2
))
1540 rc
= sprintf(buf
, "btt\n");
1541 else if (ndns
->claim_class
== NVDIMM_CCLASS_PFN
)
1542 rc
= sprintf(buf
, "pfn\n");
1543 else if (ndns
->claim_class
== NVDIMM_CCLASS_DAX
)
1544 rc
= sprintf(buf
, "dax\n");
1546 rc
= sprintf(buf
, "<unknown>\n");
1551 static DEVICE_ATTR_RW(holder_class
);
1553 static ssize_t
mode_show(struct device
*dev
,
1554 struct device_attribute
*attr
, char *buf
)
1556 struct nd_namespace_common
*ndns
= to_ndns(dev
);
1557 struct device
*claim
;
1562 claim
= ndns
->claim
;
1563 if (claim
&& is_nd_btt(claim
))
1565 else if (claim
&& is_nd_pfn(claim
))
1567 else if (claim
&& is_nd_dax(claim
))
1569 else if (!claim
&& pmem_should_map_pages(dev
))
1573 rc
= sprintf(buf
, "%s\n", mode
);
1578 static DEVICE_ATTR_RO(mode
);
1580 static ssize_t
force_raw_store(struct device
*dev
,
1581 struct device_attribute
*attr
, const char *buf
, size_t len
)
1584 int rc
= strtobool(buf
, &force_raw
);
1589 to_ndns(dev
)->force_raw
= force_raw
;
1593 static ssize_t
force_raw_show(struct device
*dev
,
1594 struct device_attribute
*attr
, char *buf
)
1596 return sprintf(buf
, "%d\n", to_ndns(dev
)->force_raw
);
1598 static DEVICE_ATTR_RW(force_raw
);
1600 static struct attribute
*nd_namespace_attributes
[] = {
1601 &dev_attr_nstype
.attr
,
1602 &dev_attr_size
.attr
,
1603 &dev_attr_mode
.attr
,
1604 &dev_attr_uuid
.attr
,
1605 &dev_attr_holder
.attr
,
1606 &dev_attr_resource
.attr
,
1607 &dev_attr_alt_name
.attr
,
1608 &dev_attr_force_raw
.attr
,
1609 &dev_attr_sector_size
.attr
,
1610 &dev_attr_dpa_extents
.attr
,
1611 &dev_attr_holder_class
.attr
,
1615 static umode_t
namespace_visible(struct kobject
*kobj
,
1616 struct attribute
*a
, int n
)
1618 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1620 if (a
== &dev_attr_resource
.attr
) {
1621 if (is_namespace_blk(dev
))
1626 if (is_namespace_pmem(dev
) || is_namespace_blk(dev
)) {
1627 if (a
== &dev_attr_size
.attr
)
1633 if (a
== &dev_attr_nstype
.attr
|| a
== &dev_attr_size
.attr
1634 || a
== &dev_attr_holder
.attr
1635 || a
== &dev_attr_holder_class
.attr
1636 || a
== &dev_attr_force_raw
.attr
1637 || a
== &dev_attr_mode
.attr
)
1643 static struct attribute_group nd_namespace_attribute_group
= {
1644 .attrs
= nd_namespace_attributes
,
1645 .is_visible
= namespace_visible
,
1648 static const struct attribute_group
*nd_namespace_attribute_groups
[] = {
1649 &nd_device_attribute_group
,
1650 &nd_namespace_attribute_group
,
1651 &nd_numa_attribute_group
,
1655 struct nd_namespace_common
*nvdimm_namespace_common_probe(struct device
*dev
)
1657 struct nd_btt
*nd_btt
= is_nd_btt(dev
) ? to_nd_btt(dev
) : NULL
;
1658 struct nd_pfn
*nd_pfn
= is_nd_pfn(dev
) ? to_nd_pfn(dev
) : NULL
;
1659 struct nd_dax
*nd_dax
= is_nd_dax(dev
) ? to_nd_dax(dev
) : NULL
;
1660 struct nd_namespace_common
*ndns
= NULL
;
1661 resource_size_t size
;
1663 if (nd_btt
|| nd_pfn
|| nd_dax
) {
1665 ndns
= nd_btt
->ndns
;
1667 ndns
= nd_pfn
->ndns
;
1669 ndns
= nd_dax
->nd_pfn
.ndns
;
1672 return ERR_PTR(-ENODEV
);
1675 * Flush any in-progess probes / removals in the driver
1676 * for the raw personality of this namespace.
1678 device_lock(&ndns
->dev
);
1679 device_unlock(&ndns
->dev
);
1680 if (ndns
->dev
.driver
) {
1681 dev_dbg(&ndns
->dev
, "is active, can't bind %s\n",
1683 return ERR_PTR(-EBUSY
);
1685 if (dev_WARN_ONCE(&ndns
->dev
, ndns
->claim
!= dev
,
1686 "host (%s) vs claim (%s) mismatch\n",
1688 dev_name(ndns
->claim
)))
1689 return ERR_PTR(-ENXIO
);
1691 ndns
= to_ndns(dev
);
1693 dev_dbg(dev
, "claimed by %s, failing probe\n",
1694 dev_name(ndns
->claim
));
1696 return ERR_PTR(-ENXIO
);
1700 size
= nvdimm_namespace_capacity(ndns
);
1701 if (size
< ND_MIN_NAMESPACE_SIZE
) {
1702 dev_dbg(&ndns
->dev
, "%pa, too small must be at least %#x\n",
1703 &size
, ND_MIN_NAMESPACE_SIZE
);
1704 return ERR_PTR(-ENODEV
);
1707 if (is_namespace_pmem(&ndns
->dev
)) {
1708 struct nd_namespace_pmem
*nspm
;
1710 nspm
= to_nd_namespace_pmem(&ndns
->dev
);
1711 if (uuid_not_set(nspm
->uuid
, &ndns
->dev
, __func__
))
1712 return ERR_PTR(-ENODEV
);
1713 } else if (is_namespace_blk(&ndns
->dev
)) {
1714 struct nd_namespace_blk
*nsblk
;
1716 nsblk
= to_nd_namespace_blk(&ndns
->dev
);
1717 if (uuid_not_set(nsblk
->uuid
, &ndns
->dev
, __func__
))
1718 return ERR_PTR(-ENODEV
);
1719 if (!nsblk
->lbasize
) {
1720 dev_dbg(&ndns
->dev
, "%s: sector size not set\n",
1722 return ERR_PTR(-ENODEV
);
1724 if (!nd_namespace_blk_validate(nsblk
))
1725 return ERR_PTR(-ENODEV
);
1730 EXPORT_SYMBOL(nvdimm_namespace_common_probe
);
1732 static struct device
**create_namespace_io(struct nd_region
*nd_region
)
1734 struct nd_namespace_io
*nsio
;
1735 struct device
*dev
, **devs
;
1736 struct resource
*res
;
1738 nsio
= kzalloc(sizeof(*nsio
), GFP_KERNEL
);
1742 devs
= kcalloc(2, sizeof(struct device
*), GFP_KERNEL
);
1748 dev
= &nsio
->common
.dev
;
1749 dev
->type
= &namespace_io_device_type
;
1750 dev
->parent
= &nd_region
->dev
;
1752 res
->name
= dev_name(&nd_region
->dev
);
1753 res
->flags
= IORESOURCE_MEM
;
1754 res
->start
= nd_region
->ndr_start
;
1755 res
->end
= res
->start
+ nd_region
->ndr_size
- 1;
1761 static bool has_uuid_at_pos(struct nd_region
*nd_region
, u8
*uuid
,
1762 u64 cookie
, u16 pos
)
1764 struct nd_namespace_label
*found
= NULL
;
1767 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1768 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
1769 struct nd_interleave_set
*nd_set
= nd_region
->nd_set
;
1770 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
1771 struct nd_label_ent
*label_ent
;
1772 bool found_uuid
= false;
1774 list_for_each_entry(label_ent
, &nd_mapping
->labels
, list
) {
1775 struct nd_namespace_label
*nd_label
= label_ent
->label
;
1776 u16 position
, nlabel
;
1781 isetcookie
= __le64_to_cpu(nd_label
->isetcookie
);
1782 position
= __le16_to_cpu(nd_label
->position
);
1783 nlabel
= __le16_to_cpu(nd_label
->nlabel
);
1785 if (isetcookie
!= cookie
)
1788 if (memcmp(nd_label
->uuid
, uuid
, NSLABEL_UUID_LEN
) != 0)
1791 if (namespace_label_has(ndd
, type_guid
)
1792 && !guid_equal(&nd_set
->type_guid
,
1793 &nd_label
->type_guid
)) {
1794 dev_dbg(ndd
->dev
, "expect type_guid %pUb got %pUb\n",
1795 nd_set
->type_guid
.b
,
1796 nd_label
->type_guid
.b
);
1802 "%s duplicate entry for uuid\n",
1807 if (nlabel
!= nd_region
->ndr_mappings
)
1809 if (position
!= pos
)
1817 return found
!= NULL
;
1820 static int select_pmem_id(struct nd_region
*nd_region
, u8
*pmem_id
)
1827 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1828 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
1829 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
1830 struct nd_namespace_label
*nd_label
= NULL
;
1831 u64 hw_start
, hw_end
, pmem_start
, pmem_end
;
1832 struct nd_label_ent
*label_ent
;
1834 lockdep_assert_held(&nd_mapping
->lock
);
1835 list_for_each_entry(label_ent
, &nd_mapping
->labels
, list
) {
1836 nd_label
= label_ent
->label
;
1839 if (memcmp(nd_label
->uuid
, pmem_id
, NSLABEL_UUID_LEN
) == 0)
1850 * Check that this label is compliant with the dpa
1851 * range published in NFIT
1853 hw_start
= nd_mapping
->start
;
1854 hw_end
= hw_start
+ nd_mapping
->size
;
1855 pmem_start
= __le64_to_cpu(nd_label
->dpa
);
1856 pmem_end
= pmem_start
+ __le64_to_cpu(nd_label
->rawsize
);
1857 if (pmem_start
>= hw_start
&& pmem_start
< hw_end
1858 && pmem_end
<= hw_end
&& pmem_end
> hw_start
)
1861 dev_dbg(&nd_region
->dev
, "%s invalid label for %pUb\n",
1862 dev_name(ndd
->dev
), nd_label
->uuid
);
1866 /* move recently validated label to the front of the list */
1867 list_move(&label_ent
->list
, &nd_mapping
->labels
);
1873 * create_namespace_pmem - validate interleave set labelling, retrieve label0
1874 * @nd_region: region with mappings to validate
1875 * @nspm: target namespace to create
1876 * @nd_label: target pmem namespace label to evaluate
1878 static struct device
*create_namespace_pmem(struct nd_region
*nd_region
,
1879 struct nd_namespace_index
*nsindex
,
1880 struct nd_namespace_label
*nd_label
)
1882 u64 cookie
= nd_region_interleave_set_cookie(nd_region
, nsindex
);
1883 u64 altcookie
= nd_region_interleave_set_altcookie(nd_region
);
1884 struct nd_label_ent
*label_ent
;
1885 struct nd_namespace_pmem
*nspm
;
1886 struct nd_mapping
*nd_mapping
;
1887 resource_size_t size
= 0;
1888 struct resource
*res
;
1894 dev_dbg(&nd_region
->dev
, "invalid interleave-set-cookie\n");
1895 return ERR_PTR(-ENXIO
);
1898 if (__le64_to_cpu(nd_label
->isetcookie
) != cookie
) {
1899 dev_dbg(&nd_region
->dev
, "invalid cookie in label: %pUb\n",
1901 if (__le64_to_cpu(nd_label
->isetcookie
) != altcookie
)
1902 return ERR_PTR(-EAGAIN
);
1904 dev_dbg(&nd_region
->dev
, "valid altcookie in label: %pUb\n",
1908 nspm
= kzalloc(sizeof(*nspm
), GFP_KERNEL
);
1910 return ERR_PTR(-ENOMEM
);
1913 dev
= &nspm
->nsio
.common
.dev
;
1914 dev
->type
= &namespace_pmem_device_type
;
1915 dev
->parent
= &nd_region
->dev
;
1916 res
= &nspm
->nsio
.res
;
1917 res
->name
= dev_name(&nd_region
->dev
);
1918 res
->flags
= IORESOURCE_MEM
;
1920 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1921 if (has_uuid_at_pos(nd_region
, nd_label
->uuid
, cookie
, i
))
1923 if (has_uuid_at_pos(nd_region
, nd_label
->uuid
, altcookie
, i
))
1928 if (i
< nd_region
->ndr_mappings
) {
1929 struct nvdimm
*nvdimm
= nd_region
->mapping
[i
].nvdimm
;
1932 * Give up if we don't find an instance of a uuid at each
1933 * position (from 0 to nd_region->ndr_mappings - 1), or if we
1934 * find a dimm with two instances of the same uuid.
1936 dev_err(&nd_region
->dev
, "%s missing label for %pUb\n",
1937 nvdimm_name(nvdimm
), nd_label
->uuid
);
1943 * Fix up each mapping's 'labels' to have the validated pmem label for
1944 * that position at labels[0], and NULL at labels[1]. In the process,
1945 * check that the namespace aligns with interleave-set. We know
1946 * that it does not overlap with any blk namespaces by virtue of
1947 * the dimm being enabled (i.e. nd_label_reserve_dpa()
1950 rc
= select_pmem_id(nd_region
, nd_label
->uuid
);
1954 /* Calculate total size and populate namespace properties from label0 */
1955 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
1956 struct nd_namespace_label
*label0
;
1957 struct nvdimm_drvdata
*ndd
;
1959 nd_mapping
= &nd_region
->mapping
[i
];
1960 label_ent
= list_first_entry_or_null(&nd_mapping
->labels
,
1961 typeof(*label_ent
), list
);
1962 label0
= label_ent
? label_ent
->label
: 0;
1969 size
+= __le64_to_cpu(label0
->rawsize
);
1970 if (__le16_to_cpu(label0
->position
) != 0)
1972 WARN_ON(nspm
->alt_name
|| nspm
->uuid
);
1973 nspm
->alt_name
= kmemdup((void __force
*) label0
->name
,
1974 NSLABEL_NAME_LEN
, GFP_KERNEL
);
1975 nspm
->uuid
= kmemdup((void __force
*) label0
->uuid
,
1976 NSLABEL_UUID_LEN
, GFP_KERNEL
);
1977 nspm
->lbasize
= __le64_to_cpu(label0
->lbasize
);
1978 ndd
= to_ndd(nd_mapping
);
1979 if (namespace_label_has(ndd
, abstraction_guid
))
1980 nspm
->nsio
.common
.claim_class
1981 = to_nvdimm_cclass(&label0
->abstraction_guid
);
1985 if (!nspm
->alt_name
|| !nspm
->uuid
) {
1990 nd_namespace_pmem_set_resource(nd_region
, nspm
, size
);
1994 namespace_pmem_release(dev
);
1997 dev_dbg(&nd_region
->dev
, "%s: invalid label(s)\n", __func__
);
2000 dev_dbg(&nd_region
->dev
, "%s: label not found\n", __func__
);
2003 dev_dbg(&nd_region
->dev
, "%s: unexpected err: %d\n",
2010 struct resource
*nsblk_add_resource(struct nd_region
*nd_region
,
2011 struct nvdimm_drvdata
*ndd
, struct nd_namespace_blk
*nsblk
,
2012 resource_size_t start
)
2014 struct nd_label_id label_id
;
2015 struct resource
*res
;
2017 nd_label_gen_id(&label_id
, nsblk
->uuid
, NSLABEL_FLAG_LOCAL
);
2018 res
= krealloc(nsblk
->res
,
2019 sizeof(void *) * (nsblk
->num_resources
+ 1),
2023 nsblk
->res
= (struct resource
**) res
;
2024 for_each_dpa_resource(ndd
, res
)
2025 if (strcmp(res
->name
, label_id
.id
) == 0
2026 && res
->start
== start
) {
2027 nsblk
->res
[nsblk
->num_resources
++] = res
;
2033 static struct device
*nd_namespace_blk_create(struct nd_region
*nd_region
)
2035 struct nd_namespace_blk
*nsblk
;
2038 if (!is_nd_blk(&nd_region
->dev
))
2041 nsblk
= kzalloc(sizeof(*nsblk
), GFP_KERNEL
);
2045 dev
= &nsblk
->common
.dev
;
2046 dev
->type
= &namespace_blk_device_type
;
2047 nsblk
->id
= ida_simple_get(&nd_region
->ns_ida
, 0, 0, GFP_KERNEL
);
2048 if (nsblk
->id
< 0) {
2052 dev_set_name(dev
, "namespace%d.%d", nd_region
->id
, nsblk
->id
);
2053 dev
->parent
= &nd_region
->dev
;
2054 dev
->groups
= nd_namespace_attribute_groups
;
2056 return &nsblk
->common
.dev
;
2059 static struct device
*nd_namespace_pmem_create(struct nd_region
*nd_region
)
2061 struct nd_namespace_pmem
*nspm
;
2062 struct resource
*res
;
2065 if (!is_memory(&nd_region
->dev
))
2068 nspm
= kzalloc(sizeof(*nspm
), GFP_KERNEL
);
2072 dev
= &nspm
->nsio
.common
.dev
;
2073 dev
->type
= &namespace_pmem_device_type
;
2074 dev
->parent
= &nd_region
->dev
;
2075 res
= &nspm
->nsio
.res
;
2076 res
->name
= dev_name(&nd_region
->dev
);
2077 res
->flags
= IORESOURCE_MEM
;
2079 nspm
->id
= ida_simple_get(&nd_region
->ns_ida
, 0, 0, GFP_KERNEL
);
2084 dev_set_name(dev
, "namespace%d.%d", nd_region
->id
, nspm
->id
);
2085 dev
->parent
= &nd_region
->dev
;
2086 dev
->groups
= nd_namespace_attribute_groups
;
2087 nd_namespace_pmem_set_resource(nd_region
, nspm
, 0);
2092 void nd_region_create_ns_seed(struct nd_region
*nd_region
)
2094 WARN_ON(!is_nvdimm_bus_locked(&nd_region
->dev
));
2096 if (nd_region_to_nstype(nd_region
) == ND_DEVICE_NAMESPACE_IO
)
2099 if (is_nd_blk(&nd_region
->dev
))
2100 nd_region
->ns_seed
= nd_namespace_blk_create(nd_region
);
2102 nd_region
->ns_seed
= nd_namespace_pmem_create(nd_region
);
2105 * Seed creation failures are not fatal, provisioning is simply
2106 * disabled until memory becomes available
2108 if (!nd_region
->ns_seed
)
2109 dev_err(&nd_region
->dev
, "failed to create %s namespace\n",
2110 is_nd_blk(&nd_region
->dev
) ? "blk" : "pmem");
2112 nd_device_register(nd_region
->ns_seed
);
2115 void nd_region_create_dax_seed(struct nd_region
*nd_region
)
2117 WARN_ON(!is_nvdimm_bus_locked(&nd_region
->dev
));
2118 nd_region
->dax_seed
= nd_dax_create(nd_region
);
2120 * Seed creation failures are not fatal, provisioning is simply
2121 * disabled until memory becomes available
2123 if (!nd_region
->dax_seed
)
2124 dev_err(&nd_region
->dev
, "failed to create dax namespace\n");
2127 void nd_region_create_pfn_seed(struct nd_region
*nd_region
)
2129 WARN_ON(!is_nvdimm_bus_locked(&nd_region
->dev
));
2130 nd_region
->pfn_seed
= nd_pfn_create(nd_region
);
2132 * Seed creation failures are not fatal, provisioning is simply
2133 * disabled until memory becomes available
2135 if (!nd_region
->pfn_seed
)
2136 dev_err(&nd_region
->dev
, "failed to create pfn namespace\n");
2139 void nd_region_create_btt_seed(struct nd_region
*nd_region
)
2141 WARN_ON(!is_nvdimm_bus_locked(&nd_region
->dev
));
2142 nd_region
->btt_seed
= nd_btt_create(nd_region
);
2144 * Seed creation failures are not fatal, provisioning is simply
2145 * disabled until memory becomes available
2147 if (!nd_region
->btt_seed
)
2148 dev_err(&nd_region
->dev
, "failed to create btt namespace\n");
2151 static int add_namespace_resource(struct nd_region
*nd_region
,
2152 struct nd_namespace_label
*nd_label
, struct device
**devs
,
2155 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[0];
2156 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
2159 for (i
= 0; i
< count
; i
++) {
2160 u8
*uuid
= namespace_to_uuid(devs
[i
]);
2161 struct resource
*res
;
2163 if (IS_ERR_OR_NULL(uuid
)) {
2168 if (memcmp(uuid
, nd_label
->uuid
, NSLABEL_UUID_LEN
) != 0)
2170 if (is_namespace_blk(devs
[i
])) {
2171 res
= nsblk_add_resource(nd_region
, ndd
,
2172 to_nd_namespace_blk(devs
[i
]),
2173 __le64_to_cpu(nd_label
->dpa
));
2176 nd_dbg_dpa(nd_region
, ndd
, res
, "%d assign\n", count
);
2178 dev_err(&nd_region
->dev
,
2179 "error: conflicting extents for uuid: %pUb\n",
2189 static struct device
*create_namespace_blk(struct nd_region
*nd_region
,
2190 struct nd_namespace_label
*nd_label
, int count
)
2193 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[0];
2194 struct nd_interleave_set
*nd_set
= nd_region
->nd_set
;
2195 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
2196 struct nd_namespace_blk
*nsblk
;
2197 char name
[NSLABEL_NAME_LEN
];
2198 struct device
*dev
= NULL
;
2199 struct resource
*res
;
2201 if (namespace_label_has(ndd
, type_guid
)) {
2202 if (!guid_equal(&nd_set
->type_guid
, &nd_label
->type_guid
)) {
2203 dev_dbg(ndd
->dev
, "expect type_guid %pUb got %pUb\n",
2204 nd_set
->type_guid
.b
,
2205 nd_label
->type_guid
.b
);
2206 return ERR_PTR(-EAGAIN
);
2209 if (nd_label
->isetcookie
!= __cpu_to_le64(nd_set
->cookie2
)) {
2210 dev_dbg(ndd
->dev
, "expect cookie %#llx got %#llx\n",
2212 __le64_to_cpu(nd_label
->isetcookie
));
2213 return ERR_PTR(-EAGAIN
);
2217 nsblk
= kzalloc(sizeof(*nsblk
), GFP_KERNEL
);
2219 return ERR_PTR(-ENOMEM
);
2220 dev
= &nsblk
->common
.dev
;
2221 dev
->type
= &namespace_blk_device_type
;
2222 dev
->parent
= &nd_region
->dev
;
2224 nsblk
->lbasize
= __le64_to_cpu(nd_label
->lbasize
);
2225 nsblk
->uuid
= kmemdup(nd_label
->uuid
, NSLABEL_UUID_LEN
,
2227 if (namespace_label_has(ndd
, abstraction_guid
))
2228 nsblk
->common
.claim_class
2229 = to_nvdimm_cclass(&nd_label
->abstraction_guid
);
2232 memcpy(name
, nd_label
->name
, NSLABEL_NAME_LEN
);
2234 nsblk
->alt_name
= kmemdup(name
, NSLABEL_NAME_LEN
,
2236 res
= nsblk_add_resource(nd_region
, ndd
, nsblk
,
2237 __le64_to_cpu(nd_label
->dpa
));
2240 nd_dbg_dpa(nd_region
, ndd
, res
, "%d: assign\n", count
);
2243 namespace_blk_release(dev
);
2244 return ERR_PTR(-ENXIO
);
2247 static int cmp_dpa(const void *a
, const void *b
)
2249 const struct device
*dev_a
= *(const struct device
**) a
;
2250 const struct device
*dev_b
= *(const struct device
**) b
;
2251 struct nd_namespace_blk
*nsblk_a
, *nsblk_b
;
2252 struct nd_namespace_pmem
*nspm_a
, *nspm_b
;
2254 if (is_namespace_io(dev_a
))
2257 if (is_namespace_blk(dev_a
)) {
2258 nsblk_a
= to_nd_namespace_blk(dev_a
);
2259 nsblk_b
= to_nd_namespace_blk(dev_b
);
2261 return memcmp(&nsblk_a
->res
[0]->start
, &nsblk_b
->res
[0]->start
,
2262 sizeof(resource_size_t
));
2265 nspm_a
= to_nd_namespace_pmem(dev_a
);
2266 nspm_b
= to_nd_namespace_pmem(dev_b
);
2268 return memcmp(&nspm_a
->nsio
.res
.start
, &nspm_b
->nsio
.res
.start
,
2269 sizeof(resource_size_t
));
2272 static struct device
**scan_labels(struct nd_region
*nd_region
)
2275 struct device
*dev
, **devs
= NULL
;
2276 struct nd_label_ent
*label_ent
, *e
;
2277 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[0];
2278 resource_size_t map_end
= nd_mapping
->start
+ nd_mapping
->size
- 1;
2280 /* "safe" because create_namespace_pmem() might list_move() label_ent */
2281 list_for_each_entry_safe(label_ent
, e
, &nd_mapping
->labels
, list
) {
2282 struct nd_namespace_label
*nd_label
= label_ent
->label
;
2283 struct device
**__devs
;
2288 flags
= __le32_to_cpu(nd_label
->flags
);
2289 if (is_nd_blk(&nd_region
->dev
)
2290 == !!(flags
& NSLABEL_FLAG_LOCAL
))
2291 /* pass, region matches label type */;
2295 /* skip labels that describe extents outside of the region */
2296 if (nd_label
->dpa
< nd_mapping
->start
|| nd_label
->dpa
> map_end
)
2299 i
= add_namespace_resource(nd_region
, nd_label
, devs
, count
);
2304 __devs
= kcalloc(count
+ 2, sizeof(dev
), GFP_KERNEL
);
2307 memcpy(__devs
, devs
, sizeof(dev
) * count
);
2311 if (is_nd_blk(&nd_region
->dev
))
2312 dev
= create_namespace_blk(nd_region
, nd_label
, count
);
2314 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
2315 struct nd_namespace_index
*nsindex
;
2317 nsindex
= to_namespace_index(ndd
, ndd
->ns_current
);
2318 dev
= create_namespace_pmem(nd_region
, nsindex
, nd_label
);
2322 switch (PTR_ERR(dev
)) {
2324 /* skip invalid labels */
2327 /* fallthrough to seed creation */
2333 devs
[count
++] = dev
;
2337 dev_dbg(&nd_region
->dev
, "%s: discovered %d %s namespace%s\n",
2338 __func__
, count
, is_nd_blk(&nd_region
->dev
)
2339 ? "blk" : "pmem", count
== 1 ? "" : "s");
2342 /* Publish a zero-sized namespace for userspace to configure. */
2343 nd_mapping_free_labels(nd_mapping
);
2345 devs
= kcalloc(2, sizeof(dev
), GFP_KERNEL
);
2348 if (is_nd_blk(&nd_region
->dev
)) {
2349 struct nd_namespace_blk
*nsblk
;
2351 nsblk
= kzalloc(sizeof(*nsblk
), GFP_KERNEL
);
2354 dev
= &nsblk
->common
.dev
;
2355 dev
->type
= &namespace_blk_device_type
;
2357 struct nd_namespace_pmem
*nspm
;
2359 nspm
= kzalloc(sizeof(*nspm
), GFP_KERNEL
);
2362 dev
= &nspm
->nsio
.common
.dev
;
2363 dev
->type
= &namespace_pmem_device_type
;
2364 nd_namespace_pmem_set_resource(nd_region
, nspm
, 0);
2366 dev
->parent
= &nd_region
->dev
;
2367 devs
[count
++] = dev
;
2368 } else if (is_memory(&nd_region
->dev
)) {
2369 /* clean unselected labels */
2370 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
2371 struct list_head
*l
, *e
;
2375 nd_mapping
= &nd_region
->mapping
[i
];
2376 if (list_empty(&nd_mapping
->labels
)) {
2382 list_for_each_safe(l
, e
, &nd_mapping
->labels
) {
2385 list_move_tail(l
, &list
);
2387 nd_mapping_free_labels(nd_mapping
);
2388 list_splice_init(&list
, &nd_mapping
->labels
);
2393 sort(devs
, count
, sizeof(struct device
*), cmp_dpa
, NULL
);
2399 for (i
= 0; devs
[i
]; i
++)
2400 if (is_nd_blk(&nd_region
->dev
))
2401 namespace_blk_release(devs
[i
]);
2403 namespace_pmem_release(devs
[i
]);
2409 static struct device
**create_namespaces(struct nd_region
*nd_region
)
2411 struct nd_mapping
*nd_mapping
;
2412 struct device
**devs
;
2415 if (nd_region
->ndr_mappings
== 0)
2418 /* lock down all mappings while we scan labels */
2419 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
2420 nd_mapping
= &nd_region
->mapping
[i
];
2421 mutex_lock_nested(&nd_mapping
->lock
, i
);
2424 devs
= scan_labels(nd_region
);
2426 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
2427 int reverse
= nd_region
->ndr_mappings
- 1 - i
;
2429 nd_mapping
= &nd_region
->mapping
[reverse
];
2430 mutex_unlock(&nd_mapping
->lock
);
2436 static int init_active_labels(struct nd_region
*nd_region
)
2440 for (i
= 0; i
< nd_region
->ndr_mappings
; i
++) {
2441 struct nd_mapping
*nd_mapping
= &nd_region
->mapping
[i
];
2442 struct nvdimm_drvdata
*ndd
= to_ndd(nd_mapping
);
2443 struct nvdimm
*nvdimm
= nd_mapping
->nvdimm
;
2444 struct nd_label_ent
*label_ent
;
2448 * If the dimm is disabled then we may need to prevent
2449 * the region from being activated.
2452 if (test_bit(NDD_LOCKED
, &nvdimm
->flags
))
2453 /* fail, label data may be unreadable */;
2454 else if (test_bit(NDD_ALIASING
, &nvdimm
->flags
))
2455 /* fail, labels needed to disambiguate dpa */;
2459 dev_err(&nd_region
->dev
, "%s: is %s, failing probe\n",
2460 dev_name(&nd_mapping
->nvdimm
->dev
),
2461 test_bit(NDD_LOCKED
, &nvdimm
->flags
)
2462 ? "locked" : "disabled");
2465 nd_mapping
->ndd
= ndd
;
2466 atomic_inc(&nvdimm
->busy
);
2469 count
= nd_label_active_count(ndd
);
2470 dev_dbg(ndd
->dev
, "%s: %d\n", __func__
, count
);
2473 for (j
= 0; j
< count
; j
++) {
2474 struct nd_namespace_label
*label
;
2476 label_ent
= kzalloc(sizeof(*label_ent
), GFP_KERNEL
);
2479 label
= nd_label_active(ndd
, j
);
2480 label_ent
->label
= label
;
2482 mutex_lock(&nd_mapping
->lock
);
2483 list_add_tail(&label_ent
->list
, &nd_mapping
->labels
);
2484 mutex_unlock(&nd_mapping
->lock
);
2490 mutex_lock(&nd_mapping
->lock
);
2491 nd_mapping_free_labels(nd_mapping
);
2492 mutex_unlock(&nd_mapping
->lock
);
2499 int nd_region_register_namespaces(struct nd_region
*nd_region
, int *err
)
2501 struct device
**devs
= NULL
;
2502 int i
, rc
= 0, type
;
2505 nvdimm_bus_lock(&nd_region
->dev
);
2506 rc
= init_active_labels(nd_region
);
2508 nvdimm_bus_unlock(&nd_region
->dev
);
2512 type
= nd_region_to_nstype(nd_region
);
2514 case ND_DEVICE_NAMESPACE_IO
:
2515 devs
= create_namespace_io(nd_region
);
2517 case ND_DEVICE_NAMESPACE_PMEM
:
2518 case ND_DEVICE_NAMESPACE_BLK
:
2519 devs
= create_namespaces(nd_region
);
2524 nvdimm_bus_unlock(&nd_region
->dev
);
2529 for (i
= 0; devs
[i
]; i
++) {
2530 struct device
*dev
= devs
[i
];
2533 if (type
== ND_DEVICE_NAMESPACE_BLK
) {
2534 struct nd_namespace_blk
*nsblk
;
2536 nsblk
= to_nd_namespace_blk(dev
);
2537 id
= ida_simple_get(&nd_region
->ns_ida
, 0, 0,
2540 } else if (type
== ND_DEVICE_NAMESPACE_PMEM
) {
2541 struct nd_namespace_pmem
*nspm
;
2543 nspm
= to_nd_namespace_pmem(dev
);
2544 id
= ida_simple_get(&nd_region
->ns_ida
, 0, 0,
2552 dev_set_name(dev
, "namespace%d.%d", nd_region
->id
, id
);
2553 dev
->groups
= nd_namespace_attribute_groups
;
2554 nd_device_register(dev
);
2557 nd_region
->ns_seed
= devs
[0];
2562 for (j
= i
; devs
[j
]; j
++) {
2563 struct device
*dev
= devs
[j
];
2565 device_initialize(dev
);
2570 * All of the namespaces we tried to register failed, so
2571 * fail region activation.