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