Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
4 */
5#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
6#include <linux/moduleparam.h>
7#include <linux/vmalloc.h>
8#include <linux/device.h>
9#include <linux/ndctl.h>
10#include <linux/slab.h>
11#include <linux/io.h>
12#include <linux/fs.h>
13#include <linux/mm.h>
14#include "nd-core.h"
15#include "label.h"
16#include "pmem.h"
17#include "nd.h"
18
19static DEFINE_IDA(dimm_ida);
20
21static bool noblk;
22module_param(noblk, bool, 0444);
23MODULE_PARM_DESC(noblk, "force disable BLK / local alias support");
24
25/*
26 * Retrieve bus and dimm handle and return if this bus supports
27 * get_config_data commands
28 */
29int nvdimm_check_config_data(struct device *dev)
30{
31 struct nvdimm *nvdimm = to_nvdimm(dev);
32
33 if (!nvdimm->cmd_mask ||
34 !test_bit(ND_CMD_GET_CONFIG_DATA, &nvdimm->cmd_mask)) {
35 if (test_bit(NDD_LABELING, &nvdimm->flags))
36 return -ENXIO;
37 else
38 return -ENOTTY;
39 }
40
41 return 0;
42}
43
44static int validate_dimm(struct nvdimm_drvdata *ndd)
45{
46 int rc;
47
48 if (!ndd)
49 return -EINVAL;
50
51 rc = nvdimm_check_config_data(ndd->dev);
52 if (rc)
53 dev_dbg(ndd->dev, "%ps: %s error: %d\n",
54 __builtin_return_address(0), __func__, rc);
55 return rc;
56}
57
58/**
59 * nvdimm_init_nsarea - determine the geometry of a dimm's namespace area
60 * @nvdimm: dimm to initialize
61 */
62int nvdimm_init_nsarea(struct nvdimm_drvdata *ndd)
63{
64 struct nd_cmd_get_config_size *cmd = &ndd->nsarea;
65 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
66 struct nvdimm_bus_descriptor *nd_desc;
67 int rc = validate_dimm(ndd);
68 int cmd_rc = 0;
69
70 if (rc)
71 return rc;
72
73 if (cmd->config_size)
74 return 0; /* already valid */
75
76 memset(cmd, 0, sizeof(*cmd));
77 nd_desc = nvdimm_bus->nd_desc;
78 rc = nd_desc->ndctl(nd_desc, to_nvdimm(ndd->dev),
79 ND_CMD_GET_CONFIG_SIZE, cmd, sizeof(*cmd), &cmd_rc);
80 if (rc < 0)
81 return rc;
82 return cmd_rc;
83}
84
85int nvdimm_get_config_data(struct nvdimm_drvdata *ndd, void *buf,
86 size_t offset, size_t len)
87{
88 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
89 struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
90 int rc = validate_dimm(ndd), cmd_rc = 0;
91 struct nd_cmd_get_config_data_hdr *cmd;
92 size_t max_cmd_size, buf_offset;
93
94 if (rc)
95 return rc;
96
97 if (offset + len > ndd->nsarea.config_size)
98 return -ENXIO;
99
100 max_cmd_size = min_t(u32, len, ndd->nsarea.max_xfer);
101 cmd = kvzalloc(max_cmd_size + sizeof(*cmd), GFP_KERNEL);
102 if (!cmd)
103 return -ENOMEM;
104
105 for (buf_offset = 0; len;
106 len -= cmd->in_length, buf_offset += cmd->in_length) {
107 size_t cmd_size;
108
109 cmd->in_offset = offset + buf_offset;
110 cmd->in_length = min(max_cmd_size, len);
111
112 cmd_size = sizeof(*cmd) + cmd->in_length;
113
114 rc = nd_desc->ndctl(nd_desc, to_nvdimm(ndd->dev),
115 ND_CMD_GET_CONFIG_DATA, cmd, cmd_size, &cmd_rc);
116 if (rc < 0)
117 break;
118 if (cmd_rc < 0) {
119 rc = cmd_rc;
120 break;
121 }
122
123 /* out_buf should be valid, copy it into our output buffer */
124 memcpy(buf + buf_offset, cmd->out_buf, cmd->in_length);
125 }
126 kvfree(cmd);
127
128 return rc;
129}
130
131int nvdimm_set_config_data(struct nvdimm_drvdata *ndd, size_t offset,
132 void *buf, size_t len)
133{
134 size_t max_cmd_size, buf_offset;
135 struct nd_cmd_set_config_hdr *cmd;
136 int rc = validate_dimm(ndd), cmd_rc = 0;
137 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
138 struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
139
140 if (rc)
141 return rc;
142
143 if (offset + len > ndd->nsarea.config_size)
144 return -ENXIO;
145
146 max_cmd_size = min_t(u32, len, ndd->nsarea.max_xfer);
147 cmd = kvzalloc(max_cmd_size + sizeof(*cmd) + sizeof(u32), GFP_KERNEL);
148 if (!cmd)
149 return -ENOMEM;
150
151 for (buf_offset = 0; len; len -= cmd->in_length,
152 buf_offset += cmd->in_length) {
153 size_t cmd_size;
154
155 cmd->in_offset = offset + buf_offset;
156 cmd->in_length = min(max_cmd_size, len);
157 memcpy(cmd->in_buf, buf + buf_offset, cmd->in_length);
158
159 /* status is output in the last 4-bytes of the command buffer */
160 cmd_size = sizeof(*cmd) + cmd->in_length + sizeof(u32);
161
162 rc = nd_desc->ndctl(nd_desc, to_nvdimm(ndd->dev),
163 ND_CMD_SET_CONFIG_DATA, cmd, cmd_size, &cmd_rc);
164 if (rc < 0)
165 break;
166 if (cmd_rc < 0) {
167 rc = cmd_rc;
168 break;
169 }
170 }
171 kvfree(cmd);
172
173 return rc;
174}
175
176void nvdimm_set_labeling(struct device *dev)
177{
178 struct nvdimm *nvdimm = to_nvdimm(dev);
179
180 set_bit(NDD_LABELING, &nvdimm->flags);
181}
182
183void nvdimm_set_locked(struct device *dev)
184{
185 struct nvdimm *nvdimm = to_nvdimm(dev);
186
187 set_bit(NDD_LOCKED, &nvdimm->flags);
188}
189
190void nvdimm_clear_locked(struct device *dev)
191{
192 struct nvdimm *nvdimm = to_nvdimm(dev);
193
194 clear_bit(NDD_LOCKED, &nvdimm->flags);
195}
196
197static void nvdimm_release(struct device *dev)
198{
199 struct nvdimm *nvdimm = to_nvdimm(dev);
200
201 ida_simple_remove(&dimm_ida, nvdimm->id);
202 kfree(nvdimm);
203}
204
205struct nvdimm *to_nvdimm(struct device *dev)
206{
207 struct nvdimm *nvdimm = container_of(dev, struct nvdimm, dev);
208
209 WARN_ON(!is_nvdimm(dev));
210 return nvdimm;
211}
212EXPORT_SYMBOL_GPL(to_nvdimm);
213
214struct nvdimm *nd_blk_region_to_dimm(struct nd_blk_region *ndbr)
215{
216 struct nd_region *nd_region = &ndbr->nd_region;
217 struct nd_mapping *nd_mapping = &nd_region->mapping[0];
218
219 return nd_mapping->nvdimm;
220}
221EXPORT_SYMBOL_GPL(nd_blk_region_to_dimm);
222
223unsigned long nd_blk_memremap_flags(struct nd_blk_region *ndbr)
224{
225 /* pmem mapping properties are private to libnvdimm */
226 return ARCH_MEMREMAP_PMEM;
227}
228EXPORT_SYMBOL_GPL(nd_blk_memremap_flags);
229
230struct nvdimm_drvdata *to_ndd(struct nd_mapping *nd_mapping)
231{
232 struct nvdimm *nvdimm = nd_mapping->nvdimm;
233
234 WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm->dev));
235
236 return dev_get_drvdata(&nvdimm->dev);
237}
238EXPORT_SYMBOL(to_ndd);
239
240void nvdimm_drvdata_release(struct kref *kref)
241{
242 struct nvdimm_drvdata *ndd = container_of(kref, typeof(*ndd), kref);
243 struct device *dev = ndd->dev;
244 struct resource *res, *_r;
245
246 dev_dbg(dev, "trace\n");
247 nvdimm_bus_lock(dev);
248 for_each_dpa_resource_safe(ndd, res, _r)
249 nvdimm_free_dpa(ndd, res);
250 nvdimm_bus_unlock(dev);
251
252 kvfree(ndd->data);
253 kfree(ndd);
254 put_device(dev);
255}
256
257void get_ndd(struct nvdimm_drvdata *ndd)
258{
259 kref_get(&ndd->kref);
260}
261
262void put_ndd(struct nvdimm_drvdata *ndd)
263{
264 if (ndd)
265 kref_put(&ndd->kref, nvdimm_drvdata_release);
266}
267
268const char *nvdimm_name(struct nvdimm *nvdimm)
269{
270 return dev_name(&nvdimm->dev);
271}
272EXPORT_SYMBOL_GPL(nvdimm_name);
273
274struct kobject *nvdimm_kobj(struct nvdimm *nvdimm)
275{
276 return &nvdimm->dev.kobj;
277}
278EXPORT_SYMBOL_GPL(nvdimm_kobj);
279
280unsigned long nvdimm_cmd_mask(struct nvdimm *nvdimm)
281{
282 return nvdimm->cmd_mask;
283}
284EXPORT_SYMBOL_GPL(nvdimm_cmd_mask);
285
286void *nvdimm_provider_data(struct nvdimm *nvdimm)
287{
288 if (nvdimm)
289 return nvdimm->provider_data;
290 return NULL;
291}
292EXPORT_SYMBOL_GPL(nvdimm_provider_data);
293
294static ssize_t commands_show(struct device *dev,
295 struct device_attribute *attr, char *buf)
296{
297 struct nvdimm *nvdimm = to_nvdimm(dev);
298 int cmd, len = 0;
299
300 if (!nvdimm->cmd_mask)
301 return sprintf(buf, "\n");
302
303 for_each_set_bit(cmd, &nvdimm->cmd_mask, BITS_PER_LONG)
304 len += sprintf(buf + len, "%s ", nvdimm_cmd_name(cmd));
305 len += sprintf(buf + len, "\n");
306 return len;
307}
308static DEVICE_ATTR_RO(commands);
309
310static ssize_t flags_show(struct device *dev,
311 struct device_attribute *attr, char *buf)
312{
313 struct nvdimm *nvdimm = to_nvdimm(dev);
314
315 return sprintf(buf, "%s%s%s\n",
316 test_bit(NDD_ALIASING, &nvdimm->flags) ? "alias " : "",
317 test_bit(NDD_LABELING, &nvdimm->flags) ? "label " : "",
318 test_bit(NDD_LOCKED, &nvdimm->flags) ? "lock " : "");
319}
320static DEVICE_ATTR_RO(flags);
321
322static ssize_t state_show(struct device *dev, struct device_attribute *attr,
323 char *buf)
324{
325 struct nvdimm *nvdimm = to_nvdimm(dev);
326
327 /*
328 * The state may be in the process of changing, userspace should
329 * quiesce probing if it wants a static answer
330 */
331 nvdimm_bus_lock(dev);
332 nvdimm_bus_unlock(dev);
333 return sprintf(buf, "%s\n", atomic_read(&nvdimm->busy)
334 ? "active" : "idle");
335}
336static DEVICE_ATTR_RO(state);
337
338static ssize_t available_slots_show(struct device *dev,
339 struct device_attribute *attr, char *buf)
340{
341 struct nvdimm_drvdata *ndd = dev_get_drvdata(dev);
342 ssize_t rc;
343 u32 nfree;
344
345 if (!ndd)
346 return -ENXIO;
347
348 nvdimm_bus_lock(dev);
349 nfree = nd_label_nfree(ndd);
350 if (nfree - 1 > nfree) {
351 dev_WARN_ONCE(dev, 1, "we ate our last label?\n");
352 nfree = 0;
353 } else
354 nfree--;
355 rc = sprintf(buf, "%d\n", nfree);
356 nvdimm_bus_unlock(dev);
357 return rc;
358}
359static DEVICE_ATTR_RO(available_slots);
360
361__weak ssize_t security_show(struct device *dev,
362 struct device_attribute *attr, char *buf)
363{
364 struct nvdimm *nvdimm = to_nvdimm(dev);
365
366 if (test_bit(NVDIMM_SECURITY_OVERWRITE, &nvdimm->sec.flags))
367 return sprintf(buf, "overwrite\n");
368 if (test_bit(NVDIMM_SECURITY_DISABLED, &nvdimm->sec.flags))
369 return sprintf(buf, "disabled\n");
370 if (test_bit(NVDIMM_SECURITY_UNLOCKED, &nvdimm->sec.flags))
371 return sprintf(buf, "unlocked\n");
372 if (test_bit(NVDIMM_SECURITY_LOCKED, &nvdimm->sec.flags))
373 return sprintf(buf, "locked\n");
374 return -ENOTTY;
375}
376
377static ssize_t frozen_show(struct device *dev,
378 struct device_attribute *attr, char *buf)
379{
380 struct nvdimm *nvdimm = to_nvdimm(dev);
381
382 return sprintf(buf, "%d\n", test_bit(NVDIMM_SECURITY_FROZEN,
383 &nvdimm->sec.flags));
384}
385static DEVICE_ATTR_RO(frozen);
386
387static ssize_t security_store(struct device *dev,
388 struct device_attribute *attr, const char *buf, size_t len)
389
390{
391 ssize_t rc;
392
393 /*
394 * Require all userspace triggered security management to be
395 * done while probing is idle and the DIMM is not in active use
396 * in any region.
397 */
398 nd_device_lock(dev);
399 nvdimm_bus_lock(dev);
400 wait_nvdimm_bus_probe_idle(dev);
401 rc = nvdimm_security_store(dev, buf, len);
402 nvdimm_bus_unlock(dev);
403 nd_device_unlock(dev);
404
405 return rc;
406}
407static DEVICE_ATTR_RW(security);
408
409static struct attribute *nvdimm_attributes[] = {
410 &dev_attr_state.attr,
411 &dev_attr_flags.attr,
412 &dev_attr_commands.attr,
413 &dev_attr_available_slots.attr,
414 &dev_attr_security.attr,
415 &dev_attr_frozen.attr,
416 NULL,
417};
418
419static umode_t nvdimm_visible(struct kobject *kobj, struct attribute *a, int n)
420{
421 struct device *dev = container_of(kobj, typeof(*dev), kobj);
422 struct nvdimm *nvdimm = to_nvdimm(dev);
423
424 if (a != &dev_attr_security.attr && a != &dev_attr_frozen.attr)
425 return a->mode;
426 if (!nvdimm->sec.flags)
427 return 0;
428
429 if (a == &dev_attr_security.attr) {
430 /* Are there any state mutation ops (make writable)? */
431 if (nvdimm->sec.ops->freeze || nvdimm->sec.ops->disable
432 || nvdimm->sec.ops->change_key
433 || nvdimm->sec.ops->erase
434 || nvdimm->sec.ops->overwrite)
435 return a->mode;
436 return 0444;
437 }
438
439 if (nvdimm->sec.ops->freeze)
440 return a->mode;
441 return 0;
442}
443
444static const struct attribute_group nvdimm_attribute_group = {
445 .attrs = nvdimm_attributes,
446 .is_visible = nvdimm_visible,
447};
448
449static ssize_t result_show(struct device *dev, struct device_attribute *attr, char *buf)
450{
451 struct nvdimm *nvdimm = to_nvdimm(dev);
452 enum nvdimm_fwa_result result;
453
454 if (!nvdimm->fw_ops)
455 return -EOPNOTSUPP;
456
457 nvdimm_bus_lock(dev);
458 result = nvdimm->fw_ops->activate_result(nvdimm);
459 nvdimm_bus_unlock(dev);
460
461 switch (result) {
462 case NVDIMM_FWA_RESULT_NONE:
463 return sprintf(buf, "none\n");
464 case NVDIMM_FWA_RESULT_SUCCESS:
465 return sprintf(buf, "success\n");
466 case NVDIMM_FWA_RESULT_FAIL:
467 return sprintf(buf, "fail\n");
468 case NVDIMM_FWA_RESULT_NOTSTAGED:
469 return sprintf(buf, "not_staged\n");
470 case NVDIMM_FWA_RESULT_NEEDRESET:
471 return sprintf(buf, "need_reset\n");
472 default:
473 return -ENXIO;
474 }
475}
476static DEVICE_ATTR_ADMIN_RO(result);
477
478static ssize_t activate_show(struct device *dev, struct device_attribute *attr, char *buf)
479{
480 struct nvdimm *nvdimm = to_nvdimm(dev);
481 enum nvdimm_fwa_state state;
482
483 if (!nvdimm->fw_ops)
484 return -EOPNOTSUPP;
485
486 nvdimm_bus_lock(dev);
487 state = nvdimm->fw_ops->activate_state(nvdimm);
488 nvdimm_bus_unlock(dev);
489
490 switch (state) {
491 case NVDIMM_FWA_IDLE:
492 return sprintf(buf, "idle\n");
493 case NVDIMM_FWA_BUSY:
494 return sprintf(buf, "busy\n");
495 case NVDIMM_FWA_ARMED:
496 return sprintf(buf, "armed\n");
497 default:
498 return -ENXIO;
499 }
500}
501
502static ssize_t activate_store(struct device *dev, struct device_attribute *attr,
503 const char *buf, size_t len)
504{
505 struct nvdimm *nvdimm = to_nvdimm(dev);
506 enum nvdimm_fwa_trigger arg;
507 int rc;
508
509 if (!nvdimm->fw_ops)
510 return -EOPNOTSUPP;
511
512 if (sysfs_streq(buf, "arm"))
513 arg = NVDIMM_FWA_ARM;
514 else if (sysfs_streq(buf, "disarm"))
515 arg = NVDIMM_FWA_DISARM;
516 else
517 return -EINVAL;
518
519 nvdimm_bus_lock(dev);
520 rc = nvdimm->fw_ops->arm(nvdimm, arg);
521 nvdimm_bus_unlock(dev);
522
523 if (rc < 0)
524 return rc;
525 return len;
526}
527static DEVICE_ATTR_ADMIN_RW(activate);
528
529static struct attribute *nvdimm_firmware_attributes[] = {
530 &dev_attr_activate.attr,
531 &dev_attr_result.attr,
532 NULL,
533};
534
535static umode_t nvdimm_firmware_visible(struct kobject *kobj, struct attribute *a, int n)
536{
537 struct device *dev = container_of(kobj, typeof(*dev), kobj);
538 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
539 struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
540 struct nvdimm *nvdimm = to_nvdimm(dev);
541 enum nvdimm_fwa_capability cap;
542
543 if (!nd_desc->fw_ops)
544 return 0;
545 if (!nvdimm->fw_ops)
546 return 0;
547
548 nvdimm_bus_lock(dev);
549 cap = nd_desc->fw_ops->capability(nd_desc);
550 nvdimm_bus_unlock(dev);
551
552 if (cap < NVDIMM_FWA_CAP_QUIESCE)
553 return 0;
554
555 return a->mode;
556}
557
558static const struct attribute_group nvdimm_firmware_attribute_group = {
559 .name = "firmware",
560 .attrs = nvdimm_firmware_attributes,
561 .is_visible = nvdimm_firmware_visible,
562};
563
564static const struct attribute_group *nvdimm_attribute_groups[] = {
565 &nd_device_attribute_group,
566 &nvdimm_attribute_group,
567 &nvdimm_firmware_attribute_group,
568 NULL,
569};
570
571static const struct device_type nvdimm_device_type = {
572 .name = "nvdimm",
573 .release = nvdimm_release,
574 .groups = nvdimm_attribute_groups,
575};
576
577bool is_nvdimm(struct device *dev)
578{
579 return dev->type == &nvdimm_device_type;
580}
581
582struct nvdimm *__nvdimm_create(struct nvdimm_bus *nvdimm_bus,
583 void *provider_data, const struct attribute_group **groups,
584 unsigned long flags, unsigned long cmd_mask, int num_flush,
585 struct resource *flush_wpq, const char *dimm_id,
586 const struct nvdimm_security_ops *sec_ops,
587 const struct nvdimm_fw_ops *fw_ops)
588{
589 struct nvdimm *nvdimm = kzalloc(sizeof(*nvdimm), GFP_KERNEL);
590 struct device *dev;
591
592 if (!nvdimm)
593 return NULL;
594
595 nvdimm->id = ida_simple_get(&dimm_ida, 0, 0, GFP_KERNEL);
596 if (nvdimm->id < 0) {
597 kfree(nvdimm);
598 return NULL;
599 }
600
601 nvdimm->dimm_id = dimm_id;
602 nvdimm->provider_data = provider_data;
603 if (noblk)
604 flags |= 1 << NDD_NOBLK;
605 nvdimm->flags = flags;
606 nvdimm->cmd_mask = cmd_mask;
607 nvdimm->num_flush = num_flush;
608 nvdimm->flush_wpq = flush_wpq;
609 atomic_set(&nvdimm->busy, 0);
610 dev = &nvdimm->dev;
611 dev_set_name(dev, "nmem%d", nvdimm->id);
612 dev->parent = &nvdimm_bus->dev;
613 dev->type = &nvdimm_device_type;
614 dev->devt = MKDEV(nvdimm_major, nvdimm->id);
615 dev->groups = groups;
616 nvdimm->sec.ops = sec_ops;
617 nvdimm->fw_ops = fw_ops;
618 nvdimm->sec.overwrite_tmo = 0;
619 INIT_DELAYED_WORK(&nvdimm->dwork, nvdimm_security_overwrite_query);
620 /*
621 * Security state must be initialized before device_add() for
622 * attribute visibility.
623 */
624 /* get security state and extended (master) state */
625 nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
626 nvdimm->sec.ext_flags = nvdimm_security_flags(nvdimm, NVDIMM_MASTER);
627 nd_device_register(dev);
628
629 return nvdimm;
630}
631EXPORT_SYMBOL_GPL(__nvdimm_create);
632
633static void shutdown_security_notify(void *data)
634{
635 struct nvdimm *nvdimm = data;
636
637 sysfs_put(nvdimm->sec.overwrite_state);
638}
639
640int nvdimm_security_setup_events(struct device *dev)
641{
642 struct nvdimm *nvdimm = to_nvdimm(dev);
643
644 if (!nvdimm->sec.flags || !nvdimm->sec.ops
645 || !nvdimm->sec.ops->overwrite)
646 return 0;
647 nvdimm->sec.overwrite_state = sysfs_get_dirent(dev->kobj.sd, "security");
648 if (!nvdimm->sec.overwrite_state)
649 return -ENOMEM;
650
651 return devm_add_action_or_reset(dev, shutdown_security_notify, nvdimm);
652}
653EXPORT_SYMBOL_GPL(nvdimm_security_setup_events);
654
655int nvdimm_in_overwrite(struct nvdimm *nvdimm)
656{
657 return test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags);
658}
659EXPORT_SYMBOL_GPL(nvdimm_in_overwrite);
660
661int nvdimm_security_freeze(struct nvdimm *nvdimm)
662{
663 int rc;
664
665 WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm->dev));
666
667 if (!nvdimm->sec.ops || !nvdimm->sec.ops->freeze)
668 return -EOPNOTSUPP;
669
670 if (!nvdimm->sec.flags)
671 return -EIO;
672
673 if (test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags)) {
674 dev_warn(&nvdimm->dev, "Overwrite operation in progress.\n");
675 return -EBUSY;
676 }
677
678 rc = nvdimm->sec.ops->freeze(nvdimm);
679 nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
680
681 return rc;
682}
683
684static unsigned long dpa_align(struct nd_region *nd_region)
685{
686 struct device *dev = &nd_region->dev;
687
688 if (dev_WARN_ONCE(dev, !is_nvdimm_bus_locked(dev),
689 "bus lock required for capacity provision\n"))
690 return 0;
691 if (dev_WARN_ONCE(dev, !nd_region->ndr_mappings || nd_region->align
692 % nd_region->ndr_mappings,
693 "invalid region align %#lx mappings: %d\n",
694 nd_region->align, nd_region->ndr_mappings))
695 return 0;
696 return nd_region->align / nd_region->ndr_mappings;
697}
698
699int alias_dpa_busy(struct device *dev, void *data)
700{
701 resource_size_t map_end, blk_start, new;
702 struct blk_alloc_info *info = data;
703 struct nd_mapping *nd_mapping;
704 struct nd_region *nd_region;
705 struct nvdimm_drvdata *ndd;
706 struct resource *res;
707 unsigned long align;
708 int i;
709
710 if (!is_memory(dev))
711 return 0;
712
713 nd_region = to_nd_region(dev);
714 for (i = 0; i < nd_region->ndr_mappings; i++) {
715 nd_mapping = &nd_region->mapping[i];
716 if (nd_mapping->nvdimm == info->nd_mapping->nvdimm)
717 break;
718 }
719
720 if (i >= nd_region->ndr_mappings)
721 return 0;
722
723 ndd = to_ndd(nd_mapping);
724 map_end = nd_mapping->start + nd_mapping->size - 1;
725 blk_start = nd_mapping->start;
726
727 /*
728 * In the allocation case ->res is set to free space that we are
729 * looking to validate against PMEM aliasing collision rules
730 * (i.e. BLK is allocated after all aliased PMEM).
731 */
732 if (info->res) {
733 if (info->res->start >= nd_mapping->start
734 && info->res->start < map_end)
735 /* pass */;
736 else
737 return 0;
738 }
739
740 retry:
741 /*
742 * Find the free dpa from the end of the last pmem allocation to
743 * the end of the interleave-set mapping.
744 */
745 align = dpa_align(nd_region);
746 if (!align)
747 return 0;
748
749 for_each_dpa_resource(ndd, res) {
750 resource_size_t start, end;
751
752 if (strncmp(res->name, "pmem", 4) != 0)
753 continue;
754
755 start = ALIGN_DOWN(res->start, align);
756 end = ALIGN(res->end + 1, align) - 1;
757 if ((start >= blk_start && start < map_end)
758 || (end >= blk_start && end <= map_end)) {
759 new = max(blk_start, min(map_end, end) + 1);
760 if (new != blk_start) {
761 blk_start = new;
762 goto retry;
763 }
764 }
765 }
766
767 /* update the free space range with the probed blk_start */
768 if (info->res && blk_start > info->res->start) {
769 info->res->start = max(info->res->start, blk_start);
770 if (info->res->start > info->res->end)
771 info->res->end = info->res->start - 1;
772 return 1;
773 }
774
775 info->available -= blk_start - nd_mapping->start;
776
777 return 0;
778}
779
780/**
781 * nd_blk_available_dpa - account the unused dpa of BLK region
782 * @nd_mapping: container of dpa-resource-root + labels
783 *
784 * Unlike PMEM, BLK namespaces can occupy discontiguous DPA ranges, but
785 * we arrange for them to never start at an lower dpa than the last
786 * PMEM allocation in an aliased region.
787 */
788resource_size_t nd_blk_available_dpa(struct nd_region *nd_region)
789{
790 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
791 struct nd_mapping *nd_mapping = &nd_region->mapping[0];
792 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
793 struct blk_alloc_info info = {
794 .nd_mapping = nd_mapping,
795 .available = nd_mapping->size,
796 .res = NULL,
797 };
798 struct resource *res;
799 unsigned long align;
800
801 if (!ndd)
802 return 0;
803
804 device_for_each_child(&nvdimm_bus->dev, &info, alias_dpa_busy);
805
806 /* now account for busy blk allocations in unaliased dpa */
807 align = dpa_align(nd_region);
808 if (!align)
809 return 0;
810 for_each_dpa_resource(ndd, res) {
811 resource_size_t start, end, size;
812
813 if (strncmp(res->name, "blk", 3) != 0)
814 continue;
815 start = ALIGN_DOWN(res->start, align);
816 end = ALIGN(res->end + 1, align) - 1;
817 size = end - start + 1;
818 if (size >= info.available)
819 return 0;
820 info.available -= size;
821 }
822
823 return info.available;
824}
825
826/**
827 * nd_pmem_max_contiguous_dpa - For the given dimm+region, return the max
828 * contiguous unallocated dpa range.
829 * @nd_region: constrain available space check to this reference region
830 * @nd_mapping: container of dpa-resource-root + labels
831 */
832resource_size_t nd_pmem_max_contiguous_dpa(struct nd_region *nd_region,
833 struct nd_mapping *nd_mapping)
834{
835 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
836 struct nvdimm_bus *nvdimm_bus;
837 resource_size_t max = 0;
838 struct resource *res;
839 unsigned long align;
840
841 /* if a dimm is disabled the available capacity is zero */
842 if (!ndd)
843 return 0;
844
845 align = dpa_align(nd_region);
846 if (!align)
847 return 0;
848
849 nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
850 if (__reserve_free_pmem(&nd_region->dev, nd_mapping->nvdimm))
851 return 0;
852 for_each_dpa_resource(ndd, res) {
853 resource_size_t start, end;
854
855 if (strcmp(res->name, "pmem-reserve") != 0)
856 continue;
857 /* trim free space relative to current alignment setting */
858 start = ALIGN(res->start, align);
859 end = ALIGN_DOWN(res->end + 1, align) - 1;
860 if (end < start)
861 continue;
862 if (end - start + 1 > max)
863 max = end - start + 1;
864 }
865 release_free_pmem(nvdimm_bus, nd_mapping);
866 return max;
867}
868
869/**
870 * nd_pmem_available_dpa - for the given dimm+region account unallocated dpa
871 * @nd_mapping: container of dpa-resource-root + labels
872 * @nd_region: constrain available space check to this reference region
873 * @overlap: calculate available space assuming this level of overlap
874 *
875 * Validate that a PMEM label, if present, aligns with the start of an
876 * interleave set and truncate the available size at the lowest BLK
877 * overlap point.
878 *
879 * The expectation is that this routine is called multiple times as it
880 * probes for the largest BLK encroachment for any single member DIMM of
881 * the interleave set. Once that value is determined the PMEM-limit for
882 * the set can be established.
883 */
884resource_size_t nd_pmem_available_dpa(struct nd_region *nd_region,
885 struct nd_mapping *nd_mapping, resource_size_t *overlap)
886{
887 resource_size_t map_start, map_end, busy = 0, available, blk_start;
888 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
889 struct resource *res;
890 const char *reason;
891 unsigned long align;
892
893 if (!ndd)
894 return 0;
895
896 align = dpa_align(nd_region);
897 if (!align)
898 return 0;
899
900 map_start = nd_mapping->start;
901 map_end = map_start + nd_mapping->size - 1;
902 blk_start = max(map_start, map_end + 1 - *overlap);
903 for_each_dpa_resource(ndd, res) {
904 resource_size_t start, end;
905
906 start = ALIGN_DOWN(res->start, align);
907 end = ALIGN(res->end + 1, align) - 1;
908 if (start >= map_start && start < map_end) {
909 if (strncmp(res->name, "blk", 3) == 0)
910 blk_start = min(blk_start,
911 max(map_start, start));
912 else if (end > map_end) {
913 reason = "misaligned to iset";
914 goto err;
915 } else
916 busy += end - start + 1;
917 } else if (end >= map_start && end <= map_end) {
918 if (strncmp(res->name, "blk", 3) == 0) {
919 /*
920 * If a BLK allocation overlaps the start of
921 * PMEM the entire interleave set may now only
922 * be used for BLK.
923 */
924 blk_start = map_start;
925 } else
926 busy += end - start + 1;
927 } else if (map_start > start && map_start < end) {
928 /* total eclipse of the mapping */
929 busy += nd_mapping->size;
930 blk_start = map_start;
931 }
932 }
933
934 *overlap = map_end + 1 - blk_start;
935 available = blk_start - map_start;
936 if (busy < available)
937 return ALIGN_DOWN(available - busy, align);
938 return 0;
939
940 err:
941 nd_dbg_dpa(nd_region, ndd, res, "%s\n", reason);
942 return 0;
943}
944
945void nvdimm_free_dpa(struct nvdimm_drvdata *ndd, struct resource *res)
946{
947 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
948 kfree(res->name);
949 __release_region(&ndd->dpa, res->start, resource_size(res));
950}
951
952struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
953 struct nd_label_id *label_id, resource_size_t start,
954 resource_size_t n)
955{
956 char *name = kmemdup(label_id, sizeof(*label_id), GFP_KERNEL);
957 struct resource *res;
958
959 if (!name)
960 return NULL;
961
962 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
963 res = __request_region(&ndd->dpa, start, n, name, 0);
964 if (!res)
965 kfree(name);
966 return res;
967}
968
969/**
970 * nvdimm_allocated_dpa - sum up the dpa currently allocated to this label_id
971 * @nvdimm: container of dpa-resource-root + labels
972 * @label_id: dpa resource name of the form {pmem|blk}-<human readable uuid>
973 */
974resource_size_t nvdimm_allocated_dpa(struct nvdimm_drvdata *ndd,
975 struct nd_label_id *label_id)
976{
977 resource_size_t allocated = 0;
978 struct resource *res;
979
980 for_each_dpa_resource(ndd, res)
981 if (strcmp(res->name, label_id->id) == 0)
982 allocated += resource_size(res);
983
984 return allocated;
985}
986
987static int count_dimms(struct device *dev, void *c)
988{
989 int *count = c;
990
991 if (is_nvdimm(dev))
992 (*count)++;
993 return 0;
994}
995
996int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count)
997{
998 int count = 0;
999 /* Flush any possible dimm registration failures */
1000 nd_synchronize();
1001
1002 device_for_each_child(&nvdimm_bus->dev, &count, count_dimms);
1003 dev_dbg(&nvdimm_bus->dev, "count: %d\n", count);
1004 if (count != dimm_count)
1005 return -ENXIO;
1006 return 0;
1007}
1008EXPORT_SYMBOL_GPL(nvdimm_bus_check_dimm_count);
1009
1010void __exit nvdimm_devs_exit(void)
1011{
1012 ida_destroy(&dimm_ida);
1013}
1/*
2 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 */
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14#include <linux/vmalloc.h>
15#include <linux/device.h>
16#include <linux/ndctl.h>
17#include <linux/slab.h>
18#include <linux/io.h>
19#include <linux/fs.h>
20#include <linux/mm.h>
21#include "nd-core.h"
22#include "label.h"
23#include "nd.h"
24
25static DEFINE_IDA(dimm_ida);
26
27/*
28 * Retrieve bus and dimm handle and return if this bus supports
29 * get_config_data commands
30 */
31static int __validate_dimm(struct nvdimm_drvdata *ndd)
32{
33 struct nvdimm *nvdimm;
34
35 if (!ndd)
36 return -EINVAL;
37
38 nvdimm = to_nvdimm(ndd->dev);
39
40 if (!nvdimm->dsm_mask)
41 return -ENXIO;
42 if (!test_bit(ND_CMD_GET_CONFIG_DATA, nvdimm->dsm_mask))
43 return -ENXIO;
44
45 return 0;
46}
47
48static int validate_dimm(struct nvdimm_drvdata *ndd)
49{
50 int rc = __validate_dimm(ndd);
51
52 if (rc && ndd)
53 dev_dbg(ndd->dev, "%pf: %s error: %d\n",
54 __builtin_return_address(0), __func__, rc);
55 return rc;
56}
57
58/**
59 * nvdimm_init_nsarea - determine the geometry of a dimm's namespace area
60 * @nvdimm: dimm to initialize
61 */
62int nvdimm_init_nsarea(struct nvdimm_drvdata *ndd)
63{
64 struct nd_cmd_get_config_size *cmd = &ndd->nsarea;
65 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
66 struct nvdimm_bus_descriptor *nd_desc;
67 int rc = validate_dimm(ndd);
68
69 if (rc)
70 return rc;
71
72 if (cmd->config_size)
73 return 0; /* already valid */
74
75 memset(cmd, 0, sizeof(*cmd));
76 nd_desc = nvdimm_bus->nd_desc;
77 return nd_desc->ndctl(nd_desc, to_nvdimm(ndd->dev),
78 ND_CMD_GET_CONFIG_SIZE, cmd, sizeof(*cmd), NULL);
79}
80
81int nvdimm_init_config_data(struct nvdimm_drvdata *ndd)
82{
83 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
84 struct nd_cmd_get_config_data_hdr *cmd;
85 struct nvdimm_bus_descriptor *nd_desc;
86 int rc = validate_dimm(ndd);
87 u32 max_cmd_size, config_size;
88 size_t offset;
89
90 if (rc)
91 return rc;
92
93 if (ndd->data)
94 return 0;
95
96 if (ndd->nsarea.status || ndd->nsarea.max_xfer == 0
97 || ndd->nsarea.config_size < ND_LABEL_MIN_SIZE) {
98 dev_dbg(ndd->dev, "failed to init config data area: (%d:%d)\n",
99 ndd->nsarea.max_xfer, ndd->nsarea.config_size);
100 return -ENXIO;
101 }
102
103 ndd->data = kmalloc(ndd->nsarea.config_size, GFP_KERNEL);
104 if (!ndd->data)
105 ndd->data = vmalloc(ndd->nsarea.config_size);
106
107 if (!ndd->data)
108 return -ENOMEM;
109
110 max_cmd_size = min_t(u32, PAGE_SIZE, ndd->nsarea.max_xfer);
111 cmd = kzalloc(max_cmd_size + sizeof(*cmd), GFP_KERNEL);
112 if (!cmd)
113 return -ENOMEM;
114
115 nd_desc = nvdimm_bus->nd_desc;
116 for (config_size = ndd->nsarea.config_size, offset = 0;
117 config_size; config_size -= cmd->in_length,
118 offset += cmd->in_length) {
119 cmd->in_length = min(config_size, max_cmd_size);
120 cmd->in_offset = offset;
121 rc = nd_desc->ndctl(nd_desc, to_nvdimm(ndd->dev),
122 ND_CMD_GET_CONFIG_DATA, cmd,
123 cmd->in_length + sizeof(*cmd), NULL);
124 if (rc || cmd->status) {
125 rc = -ENXIO;
126 break;
127 }
128 memcpy(ndd->data + offset, cmd->out_buf, cmd->in_length);
129 }
130 dev_dbg(ndd->dev, "%s: len: %zu rc: %d\n", __func__, offset, rc);
131 kfree(cmd);
132
133 return rc;
134}
135
136int nvdimm_set_config_data(struct nvdimm_drvdata *ndd, size_t offset,
137 void *buf, size_t len)
138{
139 int rc = validate_dimm(ndd);
140 size_t max_cmd_size, buf_offset;
141 struct nd_cmd_set_config_hdr *cmd;
142 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
143 struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
144
145 if (rc)
146 return rc;
147
148 if (!ndd->data)
149 return -ENXIO;
150
151 if (offset + len > ndd->nsarea.config_size)
152 return -ENXIO;
153
154 max_cmd_size = min_t(u32, PAGE_SIZE, len);
155 max_cmd_size = min_t(u32, max_cmd_size, ndd->nsarea.max_xfer);
156 cmd = kzalloc(max_cmd_size + sizeof(*cmd) + sizeof(u32), GFP_KERNEL);
157 if (!cmd)
158 return -ENOMEM;
159
160 for (buf_offset = 0; len; len -= cmd->in_length,
161 buf_offset += cmd->in_length) {
162 size_t cmd_size;
163 u32 *status;
164
165 cmd->in_offset = offset + buf_offset;
166 cmd->in_length = min(max_cmd_size, len);
167 memcpy(cmd->in_buf, buf + buf_offset, cmd->in_length);
168
169 /* status is output in the last 4-bytes of the command buffer */
170 cmd_size = sizeof(*cmd) + cmd->in_length + sizeof(u32);
171 status = ((void *) cmd) + cmd_size - sizeof(u32);
172
173 rc = nd_desc->ndctl(nd_desc, to_nvdimm(ndd->dev),
174 ND_CMD_SET_CONFIG_DATA, cmd, cmd_size, NULL);
175 if (rc || *status) {
176 rc = rc ? rc : -ENXIO;
177 break;
178 }
179 }
180 kfree(cmd);
181
182 return rc;
183}
184
185static void nvdimm_release(struct device *dev)
186{
187 struct nvdimm *nvdimm = to_nvdimm(dev);
188
189 ida_simple_remove(&dimm_ida, nvdimm->id);
190 kfree(nvdimm);
191}
192
193static struct device_type nvdimm_device_type = {
194 .name = "nvdimm",
195 .release = nvdimm_release,
196};
197
198bool is_nvdimm(struct device *dev)
199{
200 return dev->type == &nvdimm_device_type;
201}
202
203struct nvdimm *to_nvdimm(struct device *dev)
204{
205 struct nvdimm *nvdimm = container_of(dev, struct nvdimm, dev);
206
207 WARN_ON(!is_nvdimm(dev));
208 return nvdimm;
209}
210EXPORT_SYMBOL_GPL(to_nvdimm);
211
212struct nvdimm *nd_blk_region_to_dimm(struct nd_blk_region *ndbr)
213{
214 struct nd_region *nd_region = &ndbr->nd_region;
215 struct nd_mapping *nd_mapping = &nd_region->mapping[0];
216
217 return nd_mapping->nvdimm;
218}
219EXPORT_SYMBOL_GPL(nd_blk_region_to_dimm);
220
221struct nvdimm_drvdata *to_ndd(struct nd_mapping *nd_mapping)
222{
223 struct nvdimm *nvdimm = nd_mapping->nvdimm;
224
225 WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm->dev));
226
227 return dev_get_drvdata(&nvdimm->dev);
228}
229EXPORT_SYMBOL(to_ndd);
230
231void nvdimm_drvdata_release(struct kref *kref)
232{
233 struct nvdimm_drvdata *ndd = container_of(kref, typeof(*ndd), kref);
234 struct device *dev = ndd->dev;
235 struct resource *res, *_r;
236
237 dev_dbg(dev, "%s\n", __func__);
238
239 nvdimm_bus_lock(dev);
240 for_each_dpa_resource_safe(ndd, res, _r)
241 nvdimm_free_dpa(ndd, res);
242 nvdimm_bus_unlock(dev);
243
244 kvfree(ndd->data);
245 kfree(ndd);
246 put_device(dev);
247}
248
249void get_ndd(struct nvdimm_drvdata *ndd)
250{
251 kref_get(&ndd->kref);
252}
253
254void put_ndd(struct nvdimm_drvdata *ndd)
255{
256 if (ndd)
257 kref_put(&ndd->kref, nvdimm_drvdata_release);
258}
259
260const char *nvdimm_name(struct nvdimm *nvdimm)
261{
262 return dev_name(&nvdimm->dev);
263}
264EXPORT_SYMBOL_GPL(nvdimm_name);
265
266void *nvdimm_provider_data(struct nvdimm *nvdimm)
267{
268 if (nvdimm)
269 return nvdimm->provider_data;
270 return NULL;
271}
272EXPORT_SYMBOL_GPL(nvdimm_provider_data);
273
274static ssize_t commands_show(struct device *dev,
275 struct device_attribute *attr, char *buf)
276{
277 struct nvdimm *nvdimm = to_nvdimm(dev);
278 int cmd, len = 0;
279
280 if (!nvdimm->dsm_mask)
281 return sprintf(buf, "\n");
282
283 for_each_set_bit(cmd, nvdimm->dsm_mask, BITS_PER_LONG)
284 len += sprintf(buf + len, "%s ", nvdimm_cmd_name(cmd));
285 len += sprintf(buf + len, "\n");
286 return len;
287}
288static DEVICE_ATTR_RO(commands);
289
290static ssize_t state_show(struct device *dev, struct device_attribute *attr,
291 char *buf)
292{
293 struct nvdimm *nvdimm = to_nvdimm(dev);
294
295 /*
296 * The state may be in the process of changing, userspace should
297 * quiesce probing if it wants a static answer
298 */
299 nvdimm_bus_lock(dev);
300 nvdimm_bus_unlock(dev);
301 return sprintf(buf, "%s\n", atomic_read(&nvdimm->busy)
302 ? "active" : "idle");
303}
304static DEVICE_ATTR_RO(state);
305
306static ssize_t available_slots_show(struct device *dev,
307 struct device_attribute *attr, char *buf)
308{
309 struct nvdimm_drvdata *ndd = dev_get_drvdata(dev);
310 ssize_t rc;
311 u32 nfree;
312
313 if (!ndd)
314 return -ENXIO;
315
316 nvdimm_bus_lock(dev);
317 nfree = nd_label_nfree(ndd);
318 if (nfree - 1 > nfree) {
319 dev_WARN_ONCE(dev, 1, "we ate our last label?\n");
320 nfree = 0;
321 } else
322 nfree--;
323 rc = sprintf(buf, "%d\n", nfree);
324 nvdimm_bus_unlock(dev);
325 return rc;
326}
327static DEVICE_ATTR_RO(available_slots);
328
329static struct attribute *nvdimm_attributes[] = {
330 &dev_attr_state.attr,
331 &dev_attr_commands.attr,
332 &dev_attr_available_slots.attr,
333 NULL,
334};
335
336struct attribute_group nvdimm_attribute_group = {
337 .attrs = nvdimm_attributes,
338};
339EXPORT_SYMBOL_GPL(nvdimm_attribute_group);
340
341struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
342 const struct attribute_group **groups, unsigned long flags,
343 unsigned long *dsm_mask)
344{
345 struct nvdimm *nvdimm = kzalloc(sizeof(*nvdimm), GFP_KERNEL);
346 struct device *dev;
347
348 if (!nvdimm)
349 return NULL;
350
351 nvdimm->id = ida_simple_get(&dimm_ida, 0, 0, GFP_KERNEL);
352 if (nvdimm->id < 0) {
353 kfree(nvdimm);
354 return NULL;
355 }
356 nvdimm->provider_data = provider_data;
357 nvdimm->flags = flags;
358 nvdimm->dsm_mask = dsm_mask;
359 atomic_set(&nvdimm->busy, 0);
360 dev = &nvdimm->dev;
361 dev_set_name(dev, "nmem%d", nvdimm->id);
362 dev->parent = &nvdimm_bus->dev;
363 dev->type = &nvdimm_device_type;
364 dev->devt = MKDEV(nvdimm_major, nvdimm->id);
365 dev->groups = groups;
366 nd_device_register(dev);
367
368 return nvdimm;
369}
370EXPORT_SYMBOL_GPL(nvdimm_create);
371
372/**
373 * nd_blk_available_dpa - account the unused dpa of BLK region
374 * @nd_mapping: container of dpa-resource-root + labels
375 *
376 * Unlike PMEM, BLK namespaces can occupy discontiguous DPA ranges.
377 */
378resource_size_t nd_blk_available_dpa(struct nd_mapping *nd_mapping)
379{
380 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
381 resource_size_t map_end, busy = 0, available;
382 struct resource *res;
383
384 if (!ndd)
385 return 0;
386
387 map_end = nd_mapping->start + nd_mapping->size - 1;
388 for_each_dpa_resource(ndd, res)
389 if (res->start >= nd_mapping->start && res->start < map_end) {
390 resource_size_t end = min(map_end, res->end);
391
392 busy += end - res->start + 1;
393 } else if (res->end >= nd_mapping->start
394 && res->end <= map_end) {
395 busy += res->end - nd_mapping->start;
396 } else if (nd_mapping->start > res->start
397 && nd_mapping->start < res->end) {
398 /* total eclipse of the BLK region mapping */
399 busy += nd_mapping->size;
400 }
401
402 available = map_end - nd_mapping->start + 1;
403 if (busy < available)
404 return available - busy;
405 return 0;
406}
407
408/**
409 * nd_pmem_available_dpa - for the given dimm+region account unallocated dpa
410 * @nd_mapping: container of dpa-resource-root + labels
411 * @nd_region: constrain available space check to this reference region
412 * @overlap: calculate available space assuming this level of overlap
413 *
414 * Validate that a PMEM label, if present, aligns with the start of an
415 * interleave set and truncate the available size at the lowest BLK
416 * overlap point.
417 *
418 * The expectation is that this routine is called multiple times as it
419 * probes for the largest BLK encroachment for any single member DIMM of
420 * the interleave set. Once that value is determined the PMEM-limit for
421 * the set can be established.
422 */
423resource_size_t nd_pmem_available_dpa(struct nd_region *nd_region,
424 struct nd_mapping *nd_mapping, resource_size_t *overlap)
425{
426 resource_size_t map_start, map_end, busy = 0, available, blk_start;
427 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
428 struct resource *res;
429 const char *reason;
430
431 if (!ndd)
432 return 0;
433
434 map_start = nd_mapping->start;
435 map_end = map_start + nd_mapping->size - 1;
436 blk_start = max(map_start, map_end + 1 - *overlap);
437 for_each_dpa_resource(ndd, res)
438 if (res->start >= map_start && res->start < map_end) {
439 if (strncmp(res->name, "blk", 3) == 0)
440 blk_start = min(blk_start, res->start);
441 else if (res->start != map_start) {
442 reason = "misaligned to iset";
443 goto err;
444 } else {
445 if (busy) {
446 reason = "duplicate overlapping PMEM reservations?";
447 goto err;
448 }
449 busy += resource_size(res);
450 continue;
451 }
452 } else if (res->end >= map_start && res->end <= map_end) {
453 if (strncmp(res->name, "blk", 3) == 0) {
454 /*
455 * If a BLK allocation overlaps the start of
456 * PMEM the entire interleave set may now only
457 * be used for BLK.
458 */
459 blk_start = map_start;
460 } else {
461 reason = "misaligned to iset";
462 goto err;
463 }
464 } else if (map_start > res->start && map_start < res->end) {
465 /* total eclipse of the mapping */
466 busy += nd_mapping->size;
467 blk_start = map_start;
468 }
469
470 *overlap = map_end + 1 - blk_start;
471 available = blk_start - map_start;
472 if (busy < available)
473 return available - busy;
474 return 0;
475
476 err:
477 /*
478 * Something is wrong, PMEM must align with the start of the
479 * interleave set, and there can only be one allocation per set.
480 */
481 nd_dbg_dpa(nd_region, ndd, res, "%s\n", reason);
482 return 0;
483}
484
485void nvdimm_free_dpa(struct nvdimm_drvdata *ndd, struct resource *res)
486{
487 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
488 kfree(res->name);
489 __release_region(&ndd->dpa, res->start, resource_size(res));
490}
491
492struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
493 struct nd_label_id *label_id, resource_size_t start,
494 resource_size_t n)
495{
496 char *name = kmemdup(label_id, sizeof(*label_id), GFP_KERNEL);
497 struct resource *res;
498
499 if (!name)
500 return NULL;
501
502 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
503 res = __request_region(&ndd->dpa, start, n, name, 0);
504 if (!res)
505 kfree(name);
506 return res;
507}
508
509/**
510 * nvdimm_allocated_dpa - sum up the dpa currently allocated to this label_id
511 * @nvdimm: container of dpa-resource-root + labels
512 * @label_id: dpa resource name of the form {pmem|blk}-<human readable uuid>
513 */
514resource_size_t nvdimm_allocated_dpa(struct nvdimm_drvdata *ndd,
515 struct nd_label_id *label_id)
516{
517 resource_size_t allocated = 0;
518 struct resource *res;
519
520 for_each_dpa_resource(ndd, res)
521 if (strcmp(res->name, label_id->id) == 0)
522 allocated += resource_size(res);
523
524 return allocated;
525}
526
527static int count_dimms(struct device *dev, void *c)
528{
529 int *count = c;
530
531 if (is_nvdimm(dev))
532 (*count)++;
533 return 0;
534}
535
536int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count)
537{
538 int count = 0;
539 /* Flush any possible dimm registration failures */
540 nd_synchronize();
541
542 device_for_each_child(&nvdimm_bus->dev, &count, count_dimms);
543 dev_dbg(&nvdimm_bus->dev, "%s: count: %d\n", __func__, count);
544 if (count != dimm_count)
545 return -ENXIO;
546 return 0;
547}
548EXPORT_SYMBOL_GPL(nvdimm_bus_check_dimm_count);