1
2
3
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
27
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
60
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;
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
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
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
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
329
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 nvdimm_drvdata *ndd, char *buf)
339{
340 struct device *dev;
341 ssize_t rc;
342 u32 nfree;
343
344 if (!ndd)
345 return -ENXIO;
346
347 dev = ndd->dev;
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}
359
360static ssize_t available_slots_show(struct device *dev,
361 struct device_attribute *attr, char *buf)
362{
363 ssize_t rc;
364
365 nd_device_lock(dev);
366 rc = __available_slots_show(dev_get_drvdata(dev), buf);
367 nd_device_unlock(dev);
368
369 return rc;
370}
371static DEVICE_ATTR_RO(available_slots);
372
373__weak ssize_t security_show(struct device *dev,
374 struct device_attribute *attr, char *buf)
375{
376 struct nvdimm *nvdimm = to_nvdimm(dev);
377
378 if (test_bit(NVDIMM_SECURITY_OVERWRITE, &nvdimm->sec.flags))
379 return sprintf(buf, "overwrite\n");
380 if (test_bit(NVDIMM_SECURITY_DISABLED, &nvdimm->sec.flags))
381 return sprintf(buf, "disabled\n");
382 if (test_bit(NVDIMM_SECURITY_UNLOCKED, &nvdimm->sec.flags))
383 return sprintf(buf, "unlocked\n");
384 if (test_bit(NVDIMM_SECURITY_LOCKED, &nvdimm->sec.flags))
385 return sprintf(buf, "locked\n");
386 return -ENOTTY;
387}
388
389static ssize_t frozen_show(struct device *dev,
390 struct device_attribute *attr, char *buf)
391{
392 struct nvdimm *nvdimm = to_nvdimm(dev);
393
394 return sprintf(buf, "%d\n", test_bit(NVDIMM_SECURITY_FROZEN,
395 &nvdimm->sec.flags));
396}
397static DEVICE_ATTR_RO(frozen);
398
399static ssize_t security_store(struct device *dev,
400 struct device_attribute *attr, const char *buf, size_t len)
401
402{
403 ssize_t rc;
404
405
406
407
408
409
410 nd_device_lock(dev);
411 nvdimm_bus_lock(dev);
412 wait_nvdimm_bus_probe_idle(dev);
413 rc = nvdimm_security_store(dev, buf, len);
414 nvdimm_bus_unlock(dev);
415 nd_device_unlock(dev);
416
417 return rc;
418}
419static DEVICE_ATTR_RW(security);
420
421static struct attribute *nvdimm_attributes[] = {
422 &dev_attr_state.attr,
423 &dev_attr_flags.attr,
424 &dev_attr_commands.attr,
425 &dev_attr_available_slots.attr,
426 &dev_attr_security.attr,
427 &dev_attr_frozen.attr,
428 NULL,
429};
430
431static umode_t nvdimm_visible(struct kobject *kobj, struct attribute *a, int n)
432{
433 struct device *dev = container_of(kobj, typeof(*dev), kobj);
434 struct nvdimm *nvdimm = to_nvdimm(dev);
435
436 if (a != &dev_attr_security.attr && a != &dev_attr_frozen.attr)
437 return a->mode;
438 if (!nvdimm->sec.flags)
439 return 0;
440
441 if (a == &dev_attr_security.attr) {
442
443 if (nvdimm->sec.ops->freeze || nvdimm->sec.ops->disable
444 || nvdimm->sec.ops->change_key
445 || nvdimm->sec.ops->erase
446 || nvdimm->sec.ops->overwrite)
447 return a->mode;
448 return 0444;
449 }
450
451 if (nvdimm->sec.ops->freeze)
452 return a->mode;
453 return 0;
454}
455
456static const struct attribute_group nvdimm_attribute_group = {
457 .attrs = nvdimm_attributes,
458 .is_visible = nvdimm_visible,
459};
460
461static ssize_t result_show(struct device *dev, struct device_attribute *attr, char *buf)
462{
463 struct nvdimm *nvdimm = to_nvdimm(dev);
464 enum nvdimm_fwa_result result;
465
466 if (!nvdimm->fw_ops)
467 return -EOPNOTSUPP;
468
469 nvdimm_bus_lock(dev);
470 result = nvdimm->fw_ops->activate_result(nvdimm);
471 nvdimm_bus_unlock(dev);
472
473 switch (result) {
474 case NVDIMM_FWA_RESULT_NONE:
475 return sprintf(buf, "none\n");
476 case NVDIMM_FWA_RESULT_SUCCESS:
477 return sprintf(buf, "success\n");
478 case NVDIMM_FWA_RESULT_FAIL:
479 return sprintf(buf, "fail\n");
480 case NVDIMM_FWA_RESULT_NOTSTAGED:
481 return sprintf(buf, "not_staged\n");
482 case NVDIMM_FWA_RESULT_NEEDRESET:
483 return sprintf(buf, "need_reset\n");
484 default:
485 return -ENXIO;
486 }
487}
488static DEVICE_ATTR_ADMIN_RO(result);
489
490static ssize_t activate_show(struct device *dev, struct device_attribute *attr, char *buf)
491{
492 struct nvdimm *nvdimm = to_nvdimm(dev);
493 enum nvdimm_fwa_state state;
494
495 if (!nvdimm->fw_ops)
496 return -EOPNOTSUPP;
497
498 nvdimm_bus_lock(dev);
499 state = nvdimm->fw_ops->activate_state(nvdimm);
500 nvdimm_bus_unlock(dev);
501
502 switch (state) {
503 case NVDIMM_FWA_IDLE:
504 return sprintf(buf, "idle\n");
505 case NVDIMM_FWA_BUSY:
506 return sprintf(buf, "busy\n");
507 case NVDIMM_FWA_ARMED:
508 return sprintf(buf, "armed\n");
509 default:
510 return -ENXIO;
511 }
512}
513
514static ssize_t activate_store(struct device *dev, struct device_attribute *attr,
515 const char *buf, size_t len)
516{
517 struct nvdimm *nvdimm = to_nvdimm(dev);
518 enum nvdimm_fwa_trigger arg;
519 int rc;
520
521 if (!nvdimm->fw_ops)
522 return -EOPNOTSUPP;
523
524 if (sysfs_streq(buf, "arm"))
525 arg = NVDIMM_FWA_ARM;
526 else if (sysfs_streq(buf, "disarm"))
527 arg = NVDIMM_FWA_DISARM;
528 else
529 return -EINVAL;
530
531 nvdimm_bus_lock(dev);
532 rc = nvdimm->fw_ops->arm(nvdimm, arg);
533 nvdimm_bus_unlock(dev);
534
535 if (rc < 0)
536 return rc;
537 return len;
538}
539static DEVICE_ATTR_ADMIN_RW(activate);
540
541static struct attribute *nvdimm_firmware_attributes[] = {
542 &dev_attr_activate.attr,
543 &dev_attr_result.attr,
544 NULL,
545};
546
547static umode_t nvdimm_firmware_visible(struct kobject *kobj, struct attribute *a, int n)
548{
549 struct device *dev = container_of(kobj, typeof(*dev), kobj);
550 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
551 struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
552 struct nvdimm *nvdimm = to_nvdimm(dev);
553 enum nvdimm_fwa_capability cap;
554
555 if (!nd_desc->fw_ops)
556 return 0;
557 if (!nvdimm->fw_ops)
558 return 0;
559
560 nvdimm_bus_lock(dev);
561 cap = nd_desc->fw_ops->capability(nd_desc);
562 nvdimm_bus_unlock(dev);
563
564 if (cap < NVDIMM_FWA_CAP_QUIESCE)
565 return 0;
566
567 return a->mode;
568}
569
570static const struct attribute_group nvdimm_firmware_attribute_group = {
571 .name = "firmware",
572 .attrs = nvdimm_firmware_attributes,
573 .is_visible = nvdimm_firmware_visible,
574};
575
576static const struct attribute_group *nvdimm_attribute_groups[] = {
577 &nd_device_attribute_group,
578 &nvdimm_attribute_group,
579 &nvdimm_firmware_attribute_group,
580 NULL,
581};
582
583static const struct device_type nvdimm_device_type = {
584 .name = "nvdimm",
585 .release = nvdimm_release,
586 .groups = nvdimm_attribute_groups,
587};
588
589bool is_nvdimm(struct device *dev)
590{
591 return dev->type == &nvdimm_device_type;
592}
593
594struct nvdimm *__nvdimm_create(struct nvdimm_bus *nvdimm_bus,
595 void *provider_data, const struct attribute_group **groups,
596 unsigned long flags, unsigned long cmd_mask, int num_flush,
597 struct resource *flush_wpq, const char *dimm_id,
598 const struct nvdimm_security_ops *sec_ops,
599 const struct nvdimm_fw_ops *fw_ops)
600{
601 struct nvdimm *nvdimm = kzalloc(sizeof(*nvdimm), GFP_KERNEL);
602 struct device *dev;
603
604 if (!nvdimm)
605 return NULL;
606
607 nvdimm->id = ida_simple_get(&dimm_ida, 0, 0, GFP_KERNEL);
608 if (nvdimm->id < 0) {
609 kfree(nvdimm);
610 return NULL;
611 }
612
613 nvdimm->dimm_id = dimm_id;
614 nvdimm->provider_data = provider_data;
615 if (noblk)
616 flags |= 1 << NDD_NOBLK;
617 nvdimm->flags = flags;
618 nvdimm->cmd_mask = cmd_mask;
619 nvdimm->num_flush = num_flush;
620 nvdimm->flush_wpq = flush_wpq;
621 atomic_set(&nvdimm->busy, 0);
622 dev = &nvdimm->dev;
623 dev_set_name(dev, "nmem%d", nvdimm->id);
624 dev->parent = &nvdimm_bus->dev;
625 dev->type = &nvdimm_device_type;
626 dev->devt = MKDEV(nvdimm_major, nvdimm->id);
627 dev->groups = groups;
628 nvdimm->sec.ops = sec_ops;
629 nvdimm->fw_ops = fw_ops;
630 nvdimm->sec.overwrite_tmo = 0;
631 INIT_DELAYED_WORK(&nvdimm->dwork, nvdimm_security_overwrite_query);
632
633
634
635
636
637 nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
638 nvdimm->sec.ext_flags = nvdimm_security_flags(nvdimm, NVDIMM_MASTER);
639 nd_device_register(dev);
640
641 return nvdimm;
642}
643EXPORT_SYMBOL_GPL(__nvdimm_create);
644
645static void shutdown_security_notify(void *data)
646{
647 struct nvdimm *nvdimm = data;
648
649 sysfs_put(nvdimm->sec.overwrite_state);
650}
651
652int nvdimm_security_setup_events(struct device *dev)
653{
654 struct nvdimm *nvdimm = to_nvdimm(dev);
655
656 if (!nvdimm->sec.flags || !nvdimm->sec.ops
657 || !nvdimm->sec.ops->overwrite)
658 return 0;
659 nvdimm->sec.overwrite_state = sysfs_get_dirent(dev->kobj.sd, "security");
660 if (!nvdimm->sec.overwrite_state)
661 return -ENOMEM;
662
663 return devm_add_action_or_reset(dev, shutdown_security_notify, nvdimm);
664}
665EXPORT_SYMBOL_GPL(nvdimm_security_setup_events);
666
667int nvdimm_in_overwrite(struct nvdimm *nvdimm)
668{
669 return test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags);
670}
671EXPORT_SYMBOL_GPL(nvdimm_in_overwrite);
672
673int nvdimm_security_freeze(struct nvdimm *nvdimm)
674{
675 int rc;
676
677 WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm->dev));
678
679 if (!nvdimm->sec.ops || !nvdimm->sec.ops->freeze)
680 return -EOPNOTSUPP;
681
682 if (!nvdimm->sec.flags)
683 return -EIO;
684
685 if (test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags)) {
686 dev_warn(&nvdimm->dev, "Overwrite operation in progress.\n");
687 return -EBUSY;
688 }
689
690 rc = nvdimm->sec.ops->freeze(nvdimm);
691 nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
692
693 return rc;
694}
695
696static unsigned long dpa_align(struct nd_region *nd_region)
697{
698 struct device *dev = &nd_region->dev;
699
700 if (dev_WARN_ONCE(dev, !is_nvdimm_bus_locked(dev),
701 "bus lock required for capacity provision\n"))
702 return 0;
703 if (dev_WARN_ONCE(dev, !nd_region->ndr_mappings || nd_region->align
704 % nd_region->ndr_mappings,
705 "invalid region align %#lx mappings: %d\n",
706 nd_region->align, nd_region->ndr_mappings))
707 return 0;
708 return nd_region->align / nd_region->ndr_mappings;
709}
710
711int alias_dpa_busy(struct device *dev, void *data)
712{
713 resource_size_t map_end, blk_start, new;
714 struct blk_alloc_info *info = data;
715 struct nd_mapping *nd_mapping;
716 struct nd_region *nd_region;
717 struct nvdimm_drvdata *ndd;
718 struct resource *res;
719 unsigned long align;
720 int i;
721
722 if (!is_memory(dev))
723 return 0;
724
725 nd_region = to_nd_region(dev);
726 for (i = 0; i < nd_region->ndr_mappings; i++) {
727 nd_mapping = &nd_region->mapping[i];
728 if (nd_mapping->nvdimm == info->nd_mapping->nvdimm)
729 break;
730 }
731
732 if (i >= nd_region->ndr_mappings)
733 return 0;
734
735 ndd = to_ndd(nd_mapping);
736 map_end = nd_mapping->start + nd_mapping->size - 1;
737 blk_start = nd_mapping->start;
738
739
740
741
742
743
744 if (info->res) {
745 if (info->res->start >= nd_mapping->start
746 && info->res->start < map_end)
747 ;
748 else
749 return 0;
750 }
751
752 retry:
753
754
755
756
757 align = dpa_align(nd_region);
758 if (!align)
759 return 0;
760
761 for_each_dpa_resource(ndd, res) {
762 resource_size_t start, end;
763
764 if (strncmp(res->name, "pmem", 4) != 0)
765 continue;
766
767 start = ALIGN_DOWN(res->start, align);
768 end = ALIGN(res->end + 1, align) - 1;
769 if ((start >= blk_start && start < map_end)
770 || (end >= blk_start && end <= map_end)) {
771 new = max(blk_start, min(map_end, end) + 1);
772 if (new != blk_start) {
773 blk_start = new;
774 goto retry;
775 }
776 }
777 }
778
779
780 if (info->res && blk_start > info->res->start) {
781 info->res->start = max(info->res->start, blk_start);
782 if (info->res->start > info->res->end)
783 info->res->end = info->res->start - 1;
784 return 1;
785 }
786
787 info->available -= blk_start - nd_mapping->start;
788
789 return 0;
790}
791
792
793
794
795
796
797
798
799
800resource_size_t nd_blk_available_dpa(struct nd_region *nd_region)
801{
802 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
803 struct nd_mapping *nd_mapping = &nd_region->mapping[0];
804 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
805 struct blk_alloc_info info = {
806 .nd_mapping = nd_mapping,
807 .available = nd_mapping->size,
808 .res = NULL,
809 };
810 struct resource *res;
811 unsigned long align;
812
813 if (!ndd)
814 return 0;
815
816 device_for_each_child(&nvdimm_bus->dev, &info, alias_dpa_busy);
817
818
819 align = dpa_align(nd_region);
820 if (!align)
821 return 0;
822 for_each_dpa_resource(ndd, res) {
823 resource_size_t start, end, size;
824
825 if (strncmp(res->name, "blk", 3) != 0)
826 continue;
827 start = ALIGN_DOWN(res->start, align);
828 end = ALIGN(res->end + 1, align) - 1;
829 size = end - start + 1;
830 if (size >= info.available)
831 return 0;
832 info.available -= size;
833 }
834
835 return info.available;
836}
837
838
839
840
841
842
843
844resource_size_t nd_pmem_max_contiguous_dpa(struct nd_region *nd_region,
845 struct nd_mapping *nd_mapping)
846{
847 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
848 struct nvdimm_bus *nvdimm_bus;
849 resource_size_t max = 0;
850 struct resource *res;
851 unsigned long align;
852
853
854 if (!ndd)
855 return 0;
856
857 align = dpa_align(nd_region);
858 if (!align)
859 return 0;
860
861 nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
862 if (__reserve_free_pmem(&nd_region->dev, nd_mapping->nvdimm))
863 return 0;
864 for_each_dpa_resource(ndd, res) {
865 resource_size_t start, end;
866
867 if (strcmp(res->name, "pmem-reserve") != 0)
868 continue;
869
870 start = ALIGN(res->start, align);
871 end = ALIGN_DOWN(res->end + 1, align) - 1;
872 if (end < start)
873 continue;
874 if (end - start + 1 > max)
875 max = end - start + 1;
876 }
877 release_free_pmem(nvdimm_bus, nd_mapping);
878 return max;
879}
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896resource_size_t nd_pmem_available_dpa(struct nd_region *nd_region,
897 struct nd_mapping *nd_mapping, resource_size_t *overlap)
898{
899 resource_size_t map_start, map_end, busy = 0, available, blk_start;
900 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
901 struct resource *res;
902 const char *reason;
903 unsigned long align;
904
905 if (!ndd)
906 return 0;
907
908 align = dpa_align(nd_region);
909 if (!align)
910 return 0;
911
912 map_start = nd_mapping->start;
913 map_end = map_start + nd_mapping->size - 1;
914 blk_start = max(map_start, map_end + 1 - *overlap);
915 for_each_dpa_resource(ndd, res) {
916 resource_size_t start, end;
917
918 start = ALIGN_DOWN(res->start, align);
919 end = ALIGN(res->end + 1, align) - 1;
920 if (start >= map_start && start < map_end) {
921 if (strncmp(res->name, "blk", 3) == 0)
922 blk_start = min(blk_start,
923 max(map_start, start));
924 else if (end > map_end) {
925 reason = "misaligned to iset";
926 goto err;
927 } else
928 busy += end - start + 1;
929 } else if (end >= map_start && end <= map_end) {
930 if (strncmp(res->name, "blk", 3) == 0) {
931
932
933
934
935
936 blk_start = map_start;
937 } else
938 busy += end - start + 1;
939 } else if (map_start > start && map_start < end) {
940
941 busy += nd_mapping->size;
942 blk_start = map_start;
943 }
944 }
945
946 *overlap = map_end + 1 - blk_start;
947 available = blk_start - map_start;
948 if (busy < available)
949 return ALIGN_DOWN(available - busy, align);
950 return 0;
951
952 err:
953 nd_dbg_dpa(nd_region, ndd, res, "%s\n", reason);
954 return 0;
955}
956
957void nvdimm_free_dpa(struct nvdimm_drvdata *ndd, struct resource *res)
958{
959 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
960 kfree(res->name);
961 __release_region(&ndd->dpa, res->start, resource_size(res));
962}
963
964struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
965 struct nd_label_id *label_id, resource_size_t start,
966 resource_size_t n)
967{
968 char *name = kmemdup(label_id, sizeof(*label_id), GFP_KERNEL);
969 struct resource *res;
970
971 if (!name)
972 return NULL;
973
974 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
975 res = __request_region(&ndd->dpa, start, n, name, 0);
976 if (!res)
977 kfree(name);
978 return res;
979}
980
981
982
983
984
985
986resource_size_t nvdimm_allocated_dpa(struct nvdimm_drvdata *ndd,
987 struct nd_label_id *label_id)
988{
989 resource_size_t allocated = 0;
990 struct resource *res;
991
992 for_each_dpa_resource(ndd, res)
993 if (strcmp(res->name, label_id->id) == 0)
994 allocated += resource_size(res);
995
996 return allocated;
997}
998
999static int count_dimms(struct device *dev, void *c)
1000{
1001 int *count = c;
1002
1003 if (is_nvdimm(dev))
1004 (*count)++;
1005 return 0;
1006}
1007
1008int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count)
1009{
1010 int count = 0;
1011
1012 nd_synchronize();
1013
1014 device_for_each_child(&nvdimm_bus->dev, &count, count_dimms);
1015 dev_dbg(&nvdimm_bus->dev, "count: %d\n", count);
1016 if (count != dimm_count)
1017 return -ENXIO;
1018 return 0;
1019}
1020EXPORT_SYMBOL_GPL(nvdimm_bus_check_dimm_count);
1021
1022void __exit nvdimm_devs_exit(void)
1023{
1024 ida_destroy(&dimm_ida);
1025}
1026