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  
namespace_io_release(struct device * dev)17  static void namespace_io_release(struct device *dev)
18  {
19  	struct nd_namespace_io *nsio = to_nd_namespace_io(dev);
20  
21  	kfree(nsio);
22  }
23  
namespace_pmem_release(struct device * dev)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->parent);
28  
29  	if (nspm->id >= 0)
30  		ida_free(&nd_region->ns_ida, nspm->id);
31  	kfree(nspm->alt_name);
32  	kfree(nspm->uuid);
33  	kfree(nspm);
34  }
35  
36  static bool is_namespace_pmem(const struct device *dev);
37  static bool is_namespace_io(const struct device *dev);
38  
is_uuid_busy(struct device * dev,void * data)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(uuid1, uuid2))
58  		return -EBUSY;
59  
60  	return 0;
61  }
62  
is_namespace_uuid_busy(struct device * dev,void * data)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, 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   */
nd_is_uuid_unique(struct device * dev,uuid_t * uuid)77  bool nd_is_uuid_unique(struct device *dev, uuid_t *uuid)
78  {
79  	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(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(&nvdimm_bus->dev, uuid,
85  				is_namespace_uuid_busy) != 0)
86  		return false;
87  	return true;
88  }
89  
pmem_should_map_pages(struct device * dev)90  bool pmem_should_map_pages(struct device *dev)
91  {
92  	struct nd_region *nd_region = to_nd_region(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(nsio->res.start, resource_size(&nsio->res),
110  				IORESOURCE_SYSTEM_RAM,
111  				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  
pmem_sector_size(struct nd_namespace_common * ndns)118  unsigned int pmem_sector_size(struct nd_namespace_common *ndns)
119  {
120  	if (is_namespace_pmem(&ndns->dev)) {
121  		struct nd_namespace_pmem *nspm;
122  
123  		nspm = to_nd_namespace_pmem(&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  
nvdimm_namespace_disk_name(struct nd_namespace_common * ndns,char * name)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(ndns->dev.parent);
145  	const char *suffix = NULL;
146  
147  	if (ndns->claim && is_nd_btt(ndns->claim))
148  		suffix = "s";
149  
150  	if (is_namespace_pmem(&ndns->dev) || is_namespace_io(&ndns->dev)) {
151  		int nsidx = 0;
152  
153  		if (is_namespace_pmem(&ndns->dev)) {
154  			struct nd_namespace_pmem *nspm;
155  
156  			nspm = to_nd_namespace_pmem(&ndns->dev);
157  			nsidx = nspm->id;
158  		}
159  
160  		if (nsidx)
161  			sprintf(name, "pmem%d.%d%s", nd_region->id, nsidx,
162  					suffix ? suffix : "");
163  		else
164  			sprintf(name, "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  
nd_dev_to_uuid(struct device * dev)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  
nstype_show(struct device * dev,struct device_attribute * attr,char * buf)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->parent);
189  
190  	return sprintf(buf, "%d\n", nd_region_to_nstype(nd_region));
191  }
192  static DEVICE_ATTR_RO(nstype);
193  
__alt_name_store(struct device * dev,const char * buf,const size_t len)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(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(NSLABEL_NAME_LEN, GFP_KERNEL);
221  	if (!alt_name) {
222  		rc = -ENOMEM;
223  		goto out;
224  	}
225  	kfree(*ns_altname);
226  	*ns_altname = alt_name;
227  	sprintf(*ns_altname, "%s", pos);
228  	rc = len;
229  
230  out:
231  	kfree(input);
232  	return rc;
233  }
234  
nd_namespace_label_update(struct nd_region * nd_region,struct device * dev)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(&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  
alt_name_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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->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  
alt_name_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n", ns_altname ? ns_altname : "");
293  }
294  static DEVICE_ATTR_RW(alt_name);
295  
scan_free(struct nd_region * nd_region,struct nd_mapping * nd_mapping,struct nd_label_id * label_id,resource_size_t n)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, res->start, 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   */
shrink_dpa_allocation(struct nd_region * nd_region,struct nd_label_id * label_id,resource_size_t n)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  
init_dpa_allocation(struct nd_label_id * label_id,struct nd_region * nd_region,struct nd_mapping * nd_mapping,resource_size_t n)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, 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   */
space_valid(struct nd_region * nd_region,struct nvdimm_drvdata * ndd,struct nd_label_id * label_id,struct resource * prev,struct resource * next,struct resource * exist,resource_size_t n,struct resource * valid)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(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  
scan_allocate(struct nd_region * nd_region,struct nd_mapping * nd_mapping,struct nd_label_id * label_id,resource_size_t n)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  					to_allocate, &valid);
474  			available = resource_size(&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, res, next, exist,
484  					to_allocate, &valid);
485  			available = resource_size(&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, res, next, exist,
495  					to_allocate, &valid);
496  			available = resource_size(&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, res->start - allocate,
509  						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(next, next->start
518  						- allocate, resource_size(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  					valid.start, 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, res->start, 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  
merge_dpa(struct nd_region * nd_region,struct nd_mapping * nd_mapping,struct nd_label_id * label_id)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(next);
597  		nvdimm_free_dpa(ndd, next);
598  		rc = adjust_resource(res, res->start, 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  
__reserve_free_pmem(struct device * dev,void * data)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(label_id.id, "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, 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  
release_free_pmem(struct nvdimm_bus * nvdimm_bus,struct nd_mapping * nd_mapping)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   */
grow_dpa_allocation(struct nd_region * nd_region,struct nd_label_id * label_id,resource_size_t n)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, 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  
nd_namespace_pmem_set_resource(struct nd_region * nd_region,struct nd_namespace_pmem * nspm,resource_size_t size)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, nspm->uuid, 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  
uuid_not_set(const uuid_t * uuid,struct device * dev,const char * where)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  
__size_store(struct device * dev,unsigned long long val)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->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, __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(val, nd_region->align, &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, 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);
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(val, nd_region->ndr_mappings);
812  	allocated = div_u64(allocated, nd_region->ndr_mappings);
813  	if (val < allocated)
814  		rc = shrink_dpa_allocation(nd_region, &label_id,
815  				allocated - val);
816  	else
817  		rc = grow_dpa_allocation(nd_region, &label_id, 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  				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, ND_ASYNC);
837  
838  	return rc;
839  }
840  
size_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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->parent);
845  	unsigned long long val;
846  	int rc;
847  
848  	rc = kstrtoull(buf, 0, &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(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  
__nvdimm_namespace_capacity(struct nd_namespace_common * ndns)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(&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(&nsio->res);
887  	} else
888  		WARN_ONCE(1, "unknown namespace type\n");
889  	return 0;
890  }
891  
nvdimm_namespace_capacity(struct nd_namespace_common * ndns)892  resource_size_t nvdimm_namespace_capacity(struct nd_namespace_common *ndns)
893  {
894  	resource_size_t size;
895  
896  	nvdimm_bus_lock(&ndns->dev);
897  	size = __nvdimm_namespace_capacity(ndns);
898  	nvdimm_bus_unlock(&ndns->dev);
899  
900  	return size;
901  }
902  EXPORT_SYMBOL(nvdimm_namespace_capacity);
903  
nvdimm_namespace_locked(struct nd_namespace_common * ndns)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->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  
size_show(struct device * dev,struct device_attribute * attr,char * buf)924  static ssize_t size_show(struct device *dev,
925  		struct device_attribute *attr, char *buf)
926  {
927  	return sprintf(buf, "%llu\n", (unsigned long long)
928  			nvdimm_namespace_capacity(to_ndns(dev)));
929  }
930  static DEVICE_ATTR(size, 0444, size_show, size_store);
931  
namespace_to_uuid(struct device * dev)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(-ENXIO);
940  }
941  
uuid_show(struct device * dev,struct device_attribute * attr,char * buf)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(uuid))
948  		return PTR_ERR(uuid);
949  	if (uuid)
950  		return sprintf(buf, "%pUb\n", uuid);
951  	return sprintf(buf, "\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   */
namespace_update_uuid(struct nd_region * nd_region,struct device * dev,uuid_t * new_uuid,uuid_t ** old_uuid)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, 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(&nd_mapping->labels))
994  			return -EBUSY;
995  	}
996  
997  	nd_label_gen_id(&old_label_id, *old_uuid, 0);
998  	nd_label_gen_id(&new_label_id, new_uuid, 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((void *) res->name, "%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);
1019  			nd_label_gen_id(&label_id, &uuid,
1020  					nsl_get_flags(ndd, nd_label));
1021  			if (strcmp(old_label_id.id, label_id.id) == 0)
1022  				set_bit(ND_LABEL_REAP, &label_ent->flags);
1023  		}
1024  		mutex_unlock(&nd_mapping->lock);
1025  	}
1026  	kfree(*old_uuid);
1027   out:
1028  	*old_uuid = new_uuid;
1029  	return 0;
1030  }
1031  
uuid_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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->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, buf, len);
1054  	if (rc >= 0)
1055  		rc = namespace_update_uuid(nd_region, dev, uuid, ns_uuid);
1056  	if (rc >= 0)
1057  		rc = nd_namespace_label_update(nd_region, dev);
1058  	else
1059  		kfree(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  
resource_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%#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  
sector_size_show(struct device * dev,struct device_attribute * attr,char * buf)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(nspm->lbasize,
1101  				pmem_lbasize_supported, buf);
1102  	}
1103  	return -ENXIO;
1104  }
1105  
sector_size_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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->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, 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  
dpa_extents_show(struct device * dev,struct device_attribute * attr,char * buf)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->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, 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, "%d\n", count);
1173  }
1174  static DEVICE_ATTR_RO(dpa_extents);
1175  
btt_claim_class(struct device * dev)1176  static int btt_claim_class(struct device *dev)
1177  {
1178  	struct nd_region *nd_region = to_nd_region(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, 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  
holder_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n", ndns->claim ? dev_name(ndns->claim) : "");
1245  	device_unlock(dev);
1246  
1247  	return rc;
1248  }
1249  static DEVICE_ATTR_RO(holder);
1250  
__holder_class_store(struct device * dev,const char * buf)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(buf, "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(buf, "pfn"))
1265  		ndns->claim_class = NVDIMM_CCLASS_PFN;
1266  	else if (sysfs_streq(buf, "dax"))
1267  		ndns->claim_class = NVDIMM_CCLASS_DAX;
1268  	else if (sysfs_streq(buf, ""))
1269  		ndns->claim_class = NVDIMM_CCLASS_NONE;
1270  	else
1271  		return -EINVAL;
1272  
1273  	return 0;
1274  }
1275  
holder_class_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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->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  
holder_class_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1304  	else if ((ndns->claim_class == NVDIMM_CCLASS_BTT) ||
1305  			(ndns->claim_class == NVDIMM_CCLASS_BTT2))
1306  		rc = sprintf(buf, "btt\n");
1307  	else if (ndns->claim_class == NVDIMM_CCLASS_PFN)
1308  		rc = sprintf(buf, "pfn\n");
1309  	else if (ndns->claim_class == NVDIMM_CCLASS_DAX)
1310  		rc = sprintf(buf, "dax\n");
1311  	else
1312  		rc = sprintf(buf, "<unknown>\n");
1313  	device_unlock(dev);
1314  
1315  	return rc;
1316  }
1317  static DEVICE_ATTR_RW(holder_class);
1318  
mode_show(struct device * dev,struct device_attribute * attr,char * buf)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(claim))
1330  		mode = "safe";
1331  	else if (claim && is_nd_pfn(claim))
1332  		mode = "memory";
1333  	else if (claim && is_nd_dax(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, "%s\n", mode);
1340  	device_unlock(dev);
1341  
1342  	return rc;
1343  }
1344  static DEVICE_ATTR_RO(mode);
1345  
force_raw_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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(buf, &force_raw);
1351  
1352  	if (rc)
1353  		return rc;
1354  
1355  	to_ndns(dev)->force_raw = force_raw;
1356  	return len;
1357  }
1358  
force_raw_show(struct device * dev,struct device_attribute * attr,char * buf)1359  static ssize_t force_raw_show(struct device *dev,
1360  		struct device_attribute *attr, char *buf)
1361  {
1362  	return sprintf(buf, "%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  
namespace_visible(struct kobject * kobj,struct attribute * a,int n)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  
is_namespace_pmem(const struct device * dev)1427  static bool is_namespace_pmem(const struct device *dev)
1428  {
1429  	return dev ? dev->type == &namespace_pmem_device_type : false;
1430  }
1431  
is_namespace_io(const struct device * dev)1432  static bool is_namespace_io(const struct device *dev)
1433  {
1434  	return dev ? dev->type == &namespace_io_device_type : false;
1435  }
1436  
nvdimm_namespace_common_probe(struct device * dev)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(-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(&ndns->dev);
1461  		device_unlock(&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(-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(-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(-ENXIO);
1479  		}
1480  	}
1481  
1482  	if (nvdimm_namespace_locked(ndns))
1483  		return ERR_PTR(-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(-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(&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(-EOPNOTSUPP);
1505  		}
1506  	}
1507  
1508  	if (is_namespace_pmem(&ndns->dev)) {
1509  		struct nd_namespace_pmem *nspm;
1510  
1511  		nspm = to_nd_namespace_pmem(&ndns->dev);
1512  		if (uuid_not_set(nspm->uuid, &ndns->dev, __func__))
1513  			return ERR_PTR(-ENODEV);
1514  	}
1515  
1516  	return ndns;
1517  }
1518  EXPORT_SYMBOL(nvdimm_namespace_common_probe);
1519  
devm_namespace_enable(struct device * dev,struct nd_namespace_common * ndns,resource_size_t size)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, to_nd_namespace_io(&ndns->dev), size);
1524  }
1525  EXPORT_SYMBOL_GPL(devm_namespace_enable);
1526  
devm_namespace_disable(struct device * dev,struct nd_namespace_common * ndns)1527  void devm_namespace_disable(struct device *dev, struct nd_namespace_common *ndns)
1528  {
1529  	devm_nsio_disable(dev, to_nd_namespace_io(&ndns->dev));
1530  }
1531  EXPORT_SYMBOL_GPL(devm_namespace_disable);
1532  
create_namespace_io(struct nd_region * nd_region)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(sizeof(*nsio), GFP_KERNEL);
1540  	if (!nsio)
1541  		return NULL;
1542  
1543  	devs = kcalloc(2, sizeof(struct device *), GFP_KERNEL);
1544  	if (!devs) {
1545  		kfree(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(&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  
has_uuid_at_pos(struct nd_region * nd_region,const uuid_t * uuid,u64 cookie,u16 pos)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  						    &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  
select_pmem_id(struct nd_region * nd_region,const uuid_t * pmem_id)1611  static int select_pmem_id(struct nd_region *nd_region, const uuid_t *pmem_id)
1612  {
1613  	int i;
1614  
1615  	for (i = 0; i < nd_region->ndr_mappings; i++) {
1616  		struct nd_mapping *nd_mapping = &nd_region->mapping[i];
1617  		struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
1618  		struct nd_namespace_label *nd_label = NULL;
1619  		u64 hw_start, hw_end, pmem_start, pmem_end;
1620  		struct nd_label_ent *label_ent;
1621  
1622  		lockdep_assert_held(&nd_mapping->lock);
1623  		list_for_each_entry(label_ent, &nd_mapping->labels, list) {
1624  			nd_label = label_ent->label;
1625  			if (!nd_label)
1626  				continue;
1627  			if (nsl_uuid_equal(ndd, nd_label, pmem_id))
1628  				break;
1629  			nd_label = NULL;
1630  		}
1631  
1632  		if (!nd_label) {
1633  			WARN_ON(1);
1634  			return -EINVAL;
1635  		}
1636  
1637  		/*
1638  		 * Check that this label is compliant with the dpa
1639  		 * range published in NFIT
1640  		 */
1641  		hw_start = nd_mapping->start;
1642  		hw_end = hw_start + nd_mapping->size;
1643  		pmem_start = nsl_get_dpa(ndd, nd_label);
1644  		pmem_end = pmem_start + nsl_get_rawsize(ndd, nd_label);
1645  		if (pmem_start >= hw_start && pmem_start < hw_end
1646  				&& pmem_end <= hw_end && pmem_end > hw_start)
1647  			/* pass */;
1648  		else {
1649  			dev_dbg(&nd_region->dev, "%s invalid label for %pUb\n",
1650  				dev_name(ndd->dev),
1651  				nsl_uuid_raw(ndd, nd_label));
1652  			return -EINVAL;
1653  		}
1654  
1655  		/* move recently validated label to the front of the list */
1656  		list_move(&label_ent->list, &nd_mapping->labels);
1657  	}
1658  	return 0;
1659  }
1660  
1661  /**
1662   * create_namespace_pmem - validate interleave set labelling, retrieve label0
1663   * @nd_region: region with mappings to validate
1664   * @nd_mapping: container of dpa-resource-root + labels
1665   * @nd_label: target pmem namespace label to evaluate
1666   *
1667   * Returns: the created &struct device on success or ERR_PTR(-errno) on error
1668   */
create_namespace_pmem(struct nd_region * nd_region,struct nd_mapping * nd_mapping,struct nd_namespace_label * nd_label)1669  static struct device *create_namespace_pmem(struct nd_region *nd_region,
1670  					    struct nd_mapping *nd_mapping,
1671  					    struct nd_namespace_label *nd_label)
1672  {
1673  	struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
1674  	struct nd_namespace_index *nsindex =
1675  		to_namespace_index(ndd, ndd->ns_current);
1676  	u64 cookie = nd_region_interleave_set_cookie(nd_region, nsindex);
1677  	u64 altcookie = nd_region_interleave_set_altcookie(nd_region);
1678  	struct nd_label_ent *label_ent;
1679  	struct nd_namespace_pmem *nspm;
1680  	resource_size_t size = 0;
1681  	struct resource *res;
1682  	struct device *dev;
1683  	uuid_t uuid;
1684  	int rc = 0;
1685  	u16 i;
1686  
1687  	if (cookie == 0) {
1688  		dev_dbg(&nd_region->dev, "invalid interleave-set-cookie\n");
1689  		return ERR_PTR(-ENXIO);
1690  	}
1691  
1692  	if (!nsl_validate_isetcookie(ndd, nd_label, cookie)) {
1693  		dev_dbg(&nd_region->dev, "invalid cookie in label: %pUb\n",
1694  			nsl_uuid_raw(ndd, nd_label));
1695  		if (!nsl_validate_isetcookie(ndd, nd_label, altcookie))
1696  			return ERR_PTR(-EAGAIN);
1697  
1698  		dev_dbg(&nd_region->dev, "valid altcookie in label: %pUb\n",
1699  			nsl_uuid_raw(ndd, nd_label));
1700  	}
1701  
1702  	nspm = kzalloc(sizeof(*nspm), GFP_KERNEL);
1703  	if (!nspm)
1704  		return ERR_PTR(-ENOMEM);
1705  
1706  	nspm->id = -1;
1707  	dev = &nspm->nsio.common.dev;
1708  	dev->type = &namespace_pmem_device_type;
1709  	dev->parent = &nd_region->dev;
1710  	res = &nspm->nsio.res;
1711  	res->name = dev_name(&nd_region->dev);
1712  	res->flags = IORESOURCE_MEM;
1713  
1714  	for (i = 0; i < nd_region->ndr_mappings; i++) {
1715  		nsl_get_uuid(ndd, nd_label, &uuid);
1716  		if (has_uuid_at_pos(nd_region, &uuid, cookie, i))
1717  			continue;
1718  		if (has_uuid_at_pos(nd_region, &uuid, altcookie, i))
1719  			continue;
1720  		break;
1721  	}
1722  
1723  	if (i < nd_region->ndr_mappings) {
1724  		struct nvdimm *nvdimm = nd_region->mapping[i].nvdimm;
1725  
1726  		/*
1727  		 * Give up if we don't find an instance of a uuid at each
1728  		 * position (from 0 to nd_region->ndr_mappings - 1), or if we
1729  		 * find a dimm with two instances of the same uuid.
1730  		 */
1731  		dev_err(&nd_region->dev, "%s missing label for %pUb\n",
1732  			nvdimm_name(nvdimm), nsl_uuid_raw(ndd, nd_label));
1733  		rc = -EINVAL;
1734  		goto err;
1735  	}
1736  
1737  	/*
1738  	 * Fix up each mapping's 'labels' to have the validated pmem label for
1739  	 * that position at labels[0], and NULL at labels[1].  In the process,
1740  	 * check that the namespace aligns with interleave-set.
1741  	 */
1742  	nsl_get_uuid(ndd, nd_label, &uuid);
1743  	rc = select_pmem_id(nd_region, &uuid);
1744  	if (rc)
1745  		goto err;
1746  
1747  	/* Calculate total size and populate namespace properties from label0 */
1748  	for (i = 0; i < nd_region->ndr_mappings; i++) {
1749  		struct nd_namespace_label *label0;
1750  		struct nvdimm_drvdata *ndd;
1751  
1752  		nd_mapping = &nd_region->mapping[i];
1753  		label_ent = list_first_entry_or_null(&nd_mapping->labels,
1754  				typeof(*label_ent), list);
1755  		label0 = label_ent ? label_ent->label : NULL;
1756  
1757  		if (!label0) {
1758  			WARN_ON(1);
1759  			continue;
1760  		}
1761  
1762  		ndd = to_ndd(nd_mapping);
1763  		size += nsl_get_rawsize(ndd, label0);
1764  		if (nsl_get_position(ndd, label0) != 0)
1765  			continue;
1766  		WARN_ON(nspm->alt_name || nspm->uuid);
1767  		nspm->alt_name = kmemdup(nsl_ref_name(ndd, label0),
1768  					 NSLABEL_NAME_LEN, GFP_KERNEL);
1769  		nsl_get_uuid(ndd, label0, &uuid);
1770  		nspm->uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL);
1771  		nspm->lbasize = nsl_get_lbasize(ndd, label0);
1772  		nspm->nsio.common.claim_class =
1773  			nsl_get_claim_class(ndd, label0);
1774  	}
1775  
1776  	if (!nspm->alt_name || !nspm->uuid) {
1777  		rc = -ENOMEM;
1778  		goto err;
1779  	}
1780  
1781  	nd_namespace_pmem_set_resource(nd_region, nspm, size);
1782  
1783  	return dev;
1784   err:
1785  	namespace_pmem_release(dev);
1786  	switch (rc) {
1787  	case -EINVAL:
1788  		dev_dbg(&nd_region->dev, "invalid label(s)\n");
1789  		break;
1790  	default:
1791  		dev_dbg(&nd_region->dev, "unexpected err: %d\n", rc);
1792  		break;
1793  	}
1794  	return ERR_PTR(rc);
1795  }
1796  
nd_namespace_pmem_create(struct nd_region * nd_region)1797  static struct device *nd_namespace_pmem_create(struct nd_region *nd_region)
1798  {
1799  	struct nd_namespace_pmem *nspm;
1800  	struct resource *res;
1801  	struct device *dev;
1802  
1803  	if (!is_memory(&nd_region->dev))
1804  		return NULL;
1805  
1806  	nspm = kzalloc(sizeof(*nspm), GFP_KERNEL);
1807  	if (!nspm)
1808  		return NULL;
1809  
1810  	dev = &nspm->nsio.common.dev;
1811  	dev->type = &namespace_pmem_device_type;
1812  	dev->parent = &nd_region->dev;
1813  	res = &nspm->nsio.res;
1814  	res->name = dev_name(&nd_region->dev);
1815  	res->flags = IORESOURCE_MEM;
1816  
1817  	nspm->id = ida_alloc(&nd_region->ns_ida, GFP_KERNEL);
1818  	if (nspm->id < 0) {
1819  		kfree(nspm);
1820  		return NULL;
1821  	}
1822  	dev_set_name(dev, "namespace%d.%d", nd_region->id, nspm->id);
1823  	nd_namespace_pmem_set_resource(nd_region, nspm, 0);
1824  
1825  	return dev;
1826  }
1827  
1828  static struct lock_class_key nvdimm_namespace_key;
1829  
nd_region_create_ns_seed(struct nd_region * nd_region)1830  void nd_region_create_ns_seed(struct nd_region *nd_region)
1831  {
1832  	WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev));
1833  
1834  	if (nd_region_to_nstype(nd_region) == ND_DEVICE_NAMESPACE_IO)
1835  		return;
1836  
1837  	nd_region->ns_seed = nd_namespace_pmem_create(nd_region);
1838  
1839  	/*
1840  	 * Seed creation failures are not fatal, provisioning is simply
1841  	 * disabled until memory becomes available
1842  	 */
1843  	if (!nd_region->ns_seed)
1844  		dev_err(&nd_region->dev, "failed to create namespace\n");
1845  	else {
1846  		device_initialize(nd_region->ns_seed);
1847  		lockdep_set_class(&nd_region->ns_seed->mutex,
1848  				  &nvdimm_namespace_key);
1849  		nd_device_register(nd_region->ns_seed);
1850  	}
1851  }
1852  
nd_region_create_dax_seed(struct nd_region * nd_region)1853  void nd_region_create_dax_seed(struct nd_region *nd_region)
1854  {
1855  	WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev));
1856  	nd_region->dax_seed = nd_dax_create(nd_region);
1857  	/*
1858  	 * Seed creation failures are not fatal, provisioning is simply
1859  	 * disabled until memory becomes available
1860  	 */
1861  	if (!nd_region->dax_seed)
1862  		dev_err(&nd_region->dev, "failed to create dax namespace\n");
1863  }
1864  
nd_region_create_pfn_seed(struct nd_region * nd_region)1865  void nd_region_create_pfn_seed(struct nd_region *nd_region)
1866  {
1867  	WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev));
1868  	nd_region->pfn_seed = nd_pfn_create(nd_region);
1869  	/*
1870  	 * Seed creation failures are not fatal, provisioning is simply
1871  	 * disabled until memory becomes available
1872  	 */
1873  	if (!nd_region->pfn_seed)
1874  		dev_err(&nd_region->dev, "failed to create pfn namespace\n");
1875  }
1876  
nd_region_create_btt_seed(struct nd_region * nd_region)1877  void nd_region_create_btt_seed(struct nd_region *nd_region)
1878  {
1879  	WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev));
1880  	nd_region->btt_seed = nd_btt_create(nd_region);
1881  	/*
1882  	 * Seed creation failures are not fatal, provisioning is simply
1883  	 * disabled until memory becomes available
1884  	 */
1885  	if (!nd_region->btt_seed)
1886  		dev_err(&nd_region->dev, "failed to create btt namespace\n");
1887  }
1888  
add_namespace_resource(struct nd_region * nd_region,struct nd_namespace_label * nd_label,struct device ** devs,int count)1889  static int add_namespace_resource(struct nd_region *nd_region,
1890  		struct nd_namespace_label *nd_label, struct device **devs,
1891  		int count)
1892  {
1893  	struct nd_mapping *nd_mapping = &nd_region->mapping[0];
1894  	struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
1895  	int i;
1896  
1897  	for (i = 0; i < count; i++) {
1898  		uuid_t *uuid = namespace_to_uuid(devs[i]);
1899  
1900  		if (IS_ERR(uuid)) {
1901  			WARN_ON(1);
1902  			continue;
1903  		}
1904  
1905  		if (!nsl_uuid_equal(ndd, nd_label, uuid))
1906  			continue;
1907  		dev_err(&nd_region->dev,
1908  			"error: conflicting extents for uuid: %pUb\n", uuid);
1909  		return -ENXIO;
1910  	}
1911  
1912  	return i;
1913  }
1914  
cmp_dpa(const void * a,const void * b)1915  static int cmp_dpa(const void *a, const void *b)
1916  {
1917  	const struct device *dev_a = *(const struct device **) a;
1918  	const struct device *dev_b = *(const struct device **) b;
1919  	struct nd_namespace_pmem *nspm_a, *nspm_b;
1920  
1921  	if (is_namespace_io(dev_a))
1922  		return 0;
1923  
1924  	nspm_a = to_nd_namespace_pmem(dev_a);
1925  	nspm_b = to_nd_namespace_pmem(dev_b);
1926  
1927  	return memcmp(&nspm_a->nsio.res.start, &nspm_b->nsio.res.start,
1928  			sizeof(resource_size_t));
1929  }
1930  
scan_labels(struct nd_region * nd_region)1931  static struct device **scan_labels(struct nd_region *nd_region)
1932  {
1933  	int i, count = 0;
1934  	struct device *dev, **devs;
1935  	struct nd_label_ent *label_ent, *e;
1936  	struct nd_mapping *nd_mapping = &nd_region->mapping[0];
1937  	struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
1938  	resource_size_t map_end = nd_mapping->start + nd_mapping->size - 1;
1939  
1940  	devs = kcalloc(2, sizeof(dev), GFP_KERNEL);
1941  	if (!devs)
1942  		return NULL;
1943  
1944  	/* "safe" because create_namespace_pmem() might list_move() label_ent */
1945  	list_for_each_entry_safe(label_ent, e, &nd_mapping->labels, list) {
1946  		struct nd_namespace_label *nd_label = label_ent->label;
1947  		struct device **__devs;
1948  
1949  		if (!nd_label)
1950  			continue;
1951  
1952  		/* skip labels that describe extents outside of the region */
1953  		if (nsl_get_dpa(ndd, nd_label) < nd_mapping->start ||
1954  		    nsl_get_dpa(ndd, nd_label) > map_end)
1955  			continue;
1956  
1957  		i = add_namespace_resource(nd_region, nd_label, devs, count);
1958  		if (i < 0)
1959  			goto err;
1960  		if (i < count)
1961  			continue;
1962  		if (count) {
1963  			__devs = kcalloc(count + 2, sizeof(dev), GFP_KERNEL);
1964  			if (!__devs)
1965  				goto err;
1966  			memcpy(__devs, devs, sizeof(dev) * count);
1967  			kfree(devs);
1968  			devs = __devs;
1969  		}
1970  
1971  		dev = create_namespace_pmem(nd_region, nd_mapping, nd_label);
1972  		if (IS_ERR(dev)) {
1973  			switch (PTR_ERR(dev)) {
1974  			case -EAGAIN:
1975  				/* skip invalid labels */
1976  				continue;
1977  			default:
1978  				goto err;
1979  			}
1980  		} else
1981  			devs[count++] = dev;
1982  
1983  	}
1984  
1985  	dev_dbg(&nd_region->dev, "discovered %d namespace%s\n", count,
1986  		count == 1 ? "" : "s");
1987  
1988  	if (count == 0) {
1989  		struct nd_namespace_pmem *nspm;
1990  
1991  		/* Publish a zero-sized namespace for userspace to configure. */
1992  		nd_mapping_free_labels(nd_mapping);
1993  		nspm = kzalloc(sizeof(*nspm), GFP_KERNEL);
1994  		if (!nspm)
1995  			goto err;
1996  		dev = &nspm->nsio.common.dev;
1997  		dev->type = &namespace_pmem_device_type;
1998  		nd_namespace_pmem_set_resource(nd_region, nspm, 0);
1999  		dev->parent = &nd_region->dev;
2000  		devs[count++] = dev;
2001  	} else if (is_memory(&nd_region->dev)) {
2002  		/* clean unselected labels */
2003  		for (i = 0; i < nd_region->ndr_mappings; i++) {
2004  			struct list_head *l, *e;
2005  			LIST_HEAD(list);
2006  			int j;
2007  
2008  			nd_mapping = &nd_region->mapping[i];
2009  			if (list_empty(&nd_mapping->labels)) {
2010  				WARN_ON(1);
2011  				continue;
2012  			}
2013  
2014  			j = count;
2015  			list_for_each_safe(l, e, &nd_mapping->labels) {
2016  				if (!j--)
2017  					break;
2018  				list_move_tail(l, &list);
2019  			}
2020  			nd_mapping_free_labels(nd_mapping);
2021  			list_splice_init(&list, &nd_mapping->labels);
2022  		}
2023  	}
2024  
2025  	if (count > 1)
2026  		sort(devs, count, sizeof(struct device *), cmp_dpa, NULL);
2027  
2028  	return devs;
2029  
2030   err:
2031  	for (i = 0; devs[i]; i++)
2032  		namespace_pmem_release(devs[i]);
2033  	kfree(devs);
2034  
2035  	return NULL;
2036  }
2037  
create_namespaces(struct nd_region * nd_region)2038  static struct device **create_namespaces(struct nd_region *nd_region)
2039  {
2040  	struct nd_mapping *nd_mapping;
2041  	struct device **devs;
2042  	int i;
2043  
2044  	if (nd_region->ndr_mappings == 0)
2045  		return NULL;
2046  
2047  	/* lock down all mappings while we scan labels */
2048  	for (i = 0; i < nd_region->ndr_mappings; i++) {
2049  		nd_mapping = &nd_region->mapping[i];
2050  		mutex_lock_nested(&nd_mapping->lock, i);
2051  	}
2052  
2053  	devs = scan_labels(nd_region);
2054  
2055  	for (i = 0; i < nd_region->ndr_mappings; i++) {
2056  		int reverse = nd_region->ndr_mappings - 1 - i;
2057  
2058  		nd_mapping = &nd_region->mapping[reverse];
2059  		mutex_unlock(&nd_mapping->lock);
2060  	}
2061  
2062  	return devs;
2063  }
2064  
deactivate_labels(void * region)2065  static void deactivate_labels(void *region)
2066  {
2067  	struct nd_region *nd_region = region;
2068  	int i;
2069  
2070  	for (i = 0; i < nd_region->ndr_mappings; i++) {
2071  		struct nd_mapping *nd_mapping = &nd_region->mapping[i];
2072  		struct nvdimm_drvdata *ndd = nd_mapping->ndd;
2073  		struct nvdimm *nvdimm = nd_mapping->nvdimm;
2074  
2075  		mutex_lock(&nd_mapping->lock);
2076  		nd_mapping_free_labels(nd_mapping);
2077  		mutex_unlock(&nd_mapping->lock);
2078  
2079  		put_ndd(ndd);
2080  		nd_mapping->ndd = NULL;
2081  		if (ndd)
2082  			atomic_dec(&nvdimm->busy);
2083  	}
2084  }
2085  
init_active_labels(struct nd_region * nd_region)2086  static int init_active_labels(struct nd_region *nd_region)
2087  {
2088  	int i, rc = 0;
2089  
2090  	for (i = 0; i < nd_region->ndr_mappings; i++) {
2091  		struct nd_mapping *nd_mapping = &nd_region->mapping[i];
2092  		struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
2093  		struct nvdimm *nvdimm = nd_mapping->nvdimm;
2094  		struct nd_label_ent *label_ent;
2095  		int count, j;
2096  
2097  		/*
2098  		 * If the dimm is disabled then we may need to prevent
2099  		 * the region from being activated.
2100  		 */
2101  		if (!ndd) {
2102  			if (test_bit(NDD_LOCKED, &nvdimm->flags))
2103  				/* fail, label data may be unreadable */;
2104  			else if (test_bit(NDD_LABELING, &nvdimm->flags))
2105  				/* fail, labels needed to disambiguate dpa */;
2106  			else
2107  				continue;
2108  
2109  			dev_err(&nd_region->dev, "%s: is %s, failing probe\n",
2110  					dev_name(&nd_mapping->nvdimm->dev),
2111  					test_bit(NDD_LOCKED, &nvdimm->flags)
2112  					? "locked" : "disabled");
2113  			rc = -ENXIO;
2114  			goto out;
2115  		}
2116  		nd_mapping->ndd = ndd;
2117  		atomic_inc(&nvdimm->busy);
2118  		get_ndd(ndd);
2119  
2120  		count = nd_label_active_count(ndd);
2121  		dev_dbg(ndd->dev, "count: %d\n", count);
2122  		if (!count)
2123  			continue;
2124  		for (j = 0; j < count; j++) {
2125  			struct nd_namespace_label *label;
2126  
2127  			label_ent = kzalloc(sizeof(*label_ent), GFP_KERNEL);
2128  			if (!label_ent)
2129  				break;
2130  			label = nd_label_active(ndd, j);
2131  			label_ent->label = label;
2132  
2133  			mutex_lock(&nd_mapping->lock);
2134  			list_add_tail(&label_ent->list, &nd_mapping->labels);
2135  			mutex_unlock(&nd_mapping->lock);
2136  		}
2137  
2138  		if (j < count)
2139  			break;
2140  	}
2141  
2142  	if (i < nd_region->ndr_mappings)
2143  		rc = -ENOMEM;
2144  
2145  out:
2146  	if (rc) {
2147  		deactivate_labels(nd_region);
2148  		return rc;
2149  	}
2150  
2151  	return devm_add_action_or_reset(&nd_region->dev, deactivate_labels,
2152  					nd_region);
2153  }
2154  
nd_region_register_namespaces(struct nd_region * nd_region,int * err)2155  int nd_region_register_namespaces(struct nd_region *nd_region, int *err)
2156  {
2157  	struct device **devs = NULL;
2158  	int i, rc = 0, type;
2159  
2160  	*err = 0;
2161  	nvdimm_bus_lock(&nd_region->dev);
2162  	rc = init_active_labels(nd_region);
2163  	if (rc) {
2164  		nvdimm_bus_unlock(&nd_region->dev);
2165  		return rc;
2166  	}
2167  
2168  	type = nd_region_to_nstype(nd_region);
2169  	switch (type) {
2170  	case ND_DEVICE_NAMESPACE_IO:
2171  		devs = create_namespace_io(nd_region);
2172  		break;
2173  	case ND_DEVICE_NAMESPACE_PMEM:
2174  		devs = create_namespaces(nd_region);
2175  		break;
2176  	default:
2177  		break;
2178  	}
2179  	nvdimm_bus_unlock(&nd_region->dev);
2180  
2181  	if (!devs)
2182  		return -ENODEV;
2183  
2184  	for (i = 0; devs[i]; i++) {
2185  		struct device *dev = devs[i];
2186  		int id;
2187  
2188  		if (type == ND_DEVICE_NAMESPACE_PMEM) {
2189  			struct nd_namespace_pmem *nspm;
2190  
2191  			nspm = to_nd_namespace_pmem(dev);
2192  			id = ida_alloc(&nd_region->ns_ida, GFP_KERNEL);
2193  			nspm->id = id;
2194  		} else
2195  			id = i;
2196  
2197  		if (id < 0)
2198  			break;
2199  		dev_set_name(dev, "namespace%d.%d", nd_region->id, id);
2200  		device_initialize(dev);
2201  		lockdep_set_class(&dev->mutex, &nvdimm_namespace_key);
2202  		nd_device_register(dev);
2203  	}
2204  	if (i)
2205  		nd_region->ns_seed = devs[0];
2206  
2207  	if (devs[i]) {
2208  		int j;
2209  
2210  		for (j = i; devs[j]; j++) {
2211  			struct device *dev = devs[j];
2212  
2213  			device_initialize(dev);
2214  			put_device(dev);
2215  		}
2216  		*err = j - i;
2217  		/*
2218  		 * All of the namespaces we tried to register failed, so
2219  		 * fail region activation.
2220  		 */
2221  		if (*err == 0)
2222  			rc = -ENODEV;
2223  	}
2224  	kfree(devs);
2225  
2226  	if (rc == -ENODEV)
2227  		return rc;
2228  
2229  	return i;
2230  }
2231