Loading...
Note: File does not exist in v3.1.
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 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 * Require all userspace triggered security management to be
407 * done while probing is idle and the DIMM is not in active use
408 * in any region.
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 /* Are there any state mutation ops (make writable)? */
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 * Security state must be initialized before device_add() for
634 * attribute visibility.
635 */
636 /* get security state and extended (master) state */
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
645void nvdimm_delete(struct nvdimm *nvdimm)
646{
647 struct device *dev = &nvdimm->dev;
648 bool dev_put = false;
649
650 /* We are shutting down. Make state frozen artificially. */
651 nvdimm_bus_lock(dev);
652 set_bit(NVDIMM_SECURITY_FROZEN, &nvdimm->sec.flags);
653 if (test_and_clear_bit(NDD_WORK_PENDING, &nvdimm->flags))
654 dev_put = true;
655 nvdimm_bus_unlock(dev);
656 cancel_delayed_work_sync(&nvdimm->dwork);
657 if (dev_put)
658 put_device(dev);
659 nd_device_unregister(dev, ND_SYNC);
660}
661EXPORT_SYMBOL_GPL(nvdimm_delete);
662
663static void shutdown_security_notify(void *data)
664{
665 struct nvdimm *nvdimm = data;
666
667 sysfs_put(nvdimm->sec.overwrite_state);
668}
669
670int nvdimm_security_setup_events(struct device *dev)
671{
672 struct nvdimm *nvdimm = to_nvdimm(dev);
673
674 if (!nvdimm->sec.flags || !nvdimm->sec.ops
675 || !nvdimm->sec.ops->overwrite)
676 return 0;
677 nvdimm->sec.overwrite_state = sysfs_get_dirent(dev->kobj.sd, "security");
678 if (!nvdimm->sec.overwrite_state)
679 return -ENOMEM;
680
681 return devm_add_action_or_reset(dev, shutdown_security_notify, nvdimm);
682}
683EXPORT_SYMBOL_GPL(nvdimm_security_setup_events);
684
685int nvdimm_in_overwrite(struct nvdimm *nvdimm)
686{
687 return test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags);
688}
689EXPORT_SYMBOL_GPL(nvdimm_in_overwrite);
690
691int nvdimm_security_freeze(struct nvdimm *nvdimm)
692{
693 int rc;
694
695 WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm->dev));
696
697 if (!nvdimm->sec.ops || !nvdimm->sec.ops->freeze)
698 return -EOPNOTSUPP;
699
700 if (!nvdimm->sec.flags)
701 return -EIO;
702
703 if (test_bit(NDD_SECURITY_OVERWRITE, &nvdimm->flags)) {
704 dev_warn(&nvdimm->dev, "Overwrite operation in progress.\n");
705 return -EBUSY;
706 }
707
708 rc = nvdimm->sec.ops->freeze(nvdimm);
709 nvdimm->sec.flags = nvdimm_security_flags(nvdimm, NVDIMM_USER);
710
711 return rc;
712}
713
714static unsigned long dpa_align(struct nd_region *nd_region)
715{
716 struct device *dev = &nd_region->dev;
717
718 if (dev_WARN_ONCE(dev, !is_nvdimm_bus_locked(dev),
719 "bus lock required for capacity provision\n"))
720 return 0;
721 if (dev_WARN_ONCE(dev, !nd_region->ndr_mappings || nd_region->align
722 % nd_region->ndr_mappings,
723 "invalid region align %#lx mappings: %d\n",
724 nd_region->align, nd_region->ndr_mappings))
725 return 0;
726 return nd_region->align / nd_region->ndr_mappings;
727}
728
729int alias_dpa_busy(struct device *dev, void *data)
730{
731 resource_size_t map_end, blk_start, new;
732 struct blk_alloc_info *info = data;
733 struct nd_mapping *nd_mapping;
734 struct nd_region *nd_region;
735 struct nvdimm_drvdata *ndd;
736 struct resource *res;
737 unsigned long align;
738 int i;
739
740 if (!is_memory(dev))
741 return 0;
742
743 nd_region = to_nd_region(dev);
744 for (i = 0; i < nd_region->ndr_mappings; i++) {
745 nd_mapping = &nd_region->mapping[i];
746 if (nd_mapping->nvdimm == info->nd_mapping->nvdimm)
747 break;
748 }
749
750 if (i >= nd_region->ndr_mappings)
751 return 0;
752
753 ndd = to_ndd(nd_mapping);
754 map_end = nd_mapping->start + nd_mapping->size - 1;
755 blk_start = nd_mapping->start;
756
757 /*
758 * In the allocation case ->res is set to free space that we are
759 * looking to validate against PMEM aliasing collision rules
760 * (i.e. BLK is allocated after all aliased PMEM).
761 */
762 if (info->res) {
763 if (info->res->start >= nd_mapping->start
764 && info->res->start < map_end)
765 /* pass */;
766 else
767 return 0;
768 }
769
770 retry:
771 /*
772 * Find the free dpa from the end of the last pmem allocation to
773 * the end of the interleave-set mapping.
774 */
775 align = dpa_align(nd_region);
776 if (!align)
777 return 0;
778
779 for_each_dpa_resource(ndd, res) {
780 resource_size_t start, end;
781
782 if (strncmp(res->name, "pmem", 4) != 0)
783 continue;
784
785 start = ALIGN_DOWN(res->start, align);
786 end = ALIGN(res->end + 1, align) - 1;
787 if ((start >= blk_start && start < map_end)
788 || (end >= blk_start && end <= map_end)) {
789 new = max(blk_start, min(map_end, end) + 1);
790 if (new != blk_start) {
791 blk_start = new;
792 goto retry;
793 }
794 }
795 }
796
797 /* update the free space range with the probed blk_start */
798 if (info->res && blk_start > info->res->start) {
799 info->res->start = max(info->res->start, blk_start);
800 if (info->res->start > info->res->end)
801 info->res->end = info->res->start - 1;
802 return 1;
803 }
804
805 info->available -= blk_start - nd_mapping->start;
806
807 return 0;
808}
809
810/**
811 * nd_blk_available_dpa - account the unused dpa of BLK region
812 * @nd_mapping: container of dpa-resource-root + labels
813 *
814 * Unlike PMEM, BLK namespaces can occupy discontiguous DPA ranges, but
815 * we arrange for them to never start at an lower dpa than the last
816 * PMEM allocation in an aliased region.
817 */
818resource_size_t nd_blk_available_dpa(struct nd_region *nd_region)
819{
820 struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
821 struct nd_mapping *nd_mapping = &nd_region->mapping[0];
822 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
823 struct blk_alloc_info info = {
824 .nd_mapping = nd_mapping,
825 .available = nd_mapping->size,
826 .res = NULL,
827 };
828 struct resource *res;
829 unsigned long align;
830
831 if (!ndd)
832 return 0;
833
834 device_for_each_child(&nvdimm_bus->dev, &info, alias_dpa_busy);
835
836 /* now account for busy blk allocations in unaliased dpa */
837 align = dpa_align(nd_region);
838 if (!align)
839 return 0;
840 for_each_dpa_resource(ndd, res) {
841 resource_size_t start, end, size;
842
843 if (strncmp(res->name, "blk", 3) != 0)
844 continue;
845 start = ALIGN_DOWN(res->start, align);
846 end = ALIGN(res->end + 1, align) - 1;
847 size = end - start + 1;
848 if (size >= info.available)
849 return 0;
850 info.available -= size;
851 }
852
853 return info.available;
854}
855
856/**
857 * nd_pmem_max_contiguous_dpa - For the given dimm+region, return the max
858 * contiguous unallocated dpa range.
859 * @nd_region: constrain available space check to this reference region
860 * @nd_mapping: container of dpa-resource-root + labels
861 */
862resource_size_t nd_pmem_max_contiguous_dpa(struct nd_region *nd_region,
863 struct nd_mapping *nd_mapping)
864{
865 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
866 struct nvdimm_bus *nvdimm_bus;
867 resource_size_t max = 0;
868 struct resource *res;
869 unsigned long align;
870
871 /* if a dimm is disabled the available capacity is zero */
872 if (!ndd)
873 return 0;
874
875 align = dpa_align(nd_region);
876 if (!align)
877 return 0;
878
879 nvdimm_bus = walk_to_nvdimm_bus(ndd->dev);
880 if (__reserve_free_pmem(&nd_region->dev, nd_mapping->nvdimm))
881 return 0;
882 for_each_dpa_resource(ndd, res) {
883 resource_size_t start, end;
884
885 if (strcmp(res->name, "pmem-reserve") != 0)
886 continue;
887 /* trim free space relative to current alignment setting */
888 start = ALIGN(res->start, align);
889 end = ALIGN_DOWN(res->end + 1, align) - 1;
890 if (end < start)
891 continue;
892 if (end - start + 1 > max)
893 max = end - start + 1;
894 }
895 release_free_pmem(nvdimm_bus, nd_mapping);
896 return max;
897}
898
899/**
900 * nd_pmem_available_dpa - for the given dimm+region account unallocated dpa
901 * @nd_mapping: container of dpa-resource-root + labels
902 * @nd_region: constrain available space check to this reference region
903 * @overlap: calculate available space assuming this level of overlap
904 *
905 * Validate that a PMEM label, if present, aligns with the start of an
906 * interleave set and truncate the available size at the lowest BLK
907 * overlap point.
908 *
909 * The expectation is that this routine is called multiple times as it
910 * probes for the largest BLK encroachment for any single member DIMM of
911 * the interleave set. Once that value is determined the PMEM-limit for
912 * the set can be established.
913 */
914resource_size_t nd_pmem_available_dpa(struct nd_region *nd_region,
915 struct nd_mapping *nd_mapping, resource_size_t *overlap)
916{
917 resource_size_t map_start, map_end, busy = 0, available, blk_start;
918 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
919 struct resource *res;
920 const char *reason;
921 unsigned long align;
922
923 if (!ndd)
924 return 0;
925
926 align = dpa_align(nd_region);
927 if (!align)
928 return 0;
929
930 map_start = nd_mapping->start;
931 map_end = map_start + nd_mapping->size - 1;
932 blk_start = max(map_start, map_end + 1 - *overlap);
933 for_each_dpa_resource(ndd, res) {
934 resource_size_t start, end;
935
936 start = ALIGN_DOWN(res->start, align);
937 end = ALIGN(res->end + 1, align) - 1;
938 if (start >= map_start && start < map_end) {
939 if (strncmp(res->name, "blk", 3) == 0)
940 blk_start = min(blk_start,
941 max(map_start, start));
942 else if (end > map_end) {
943 reason = "misaligned to iset";
944 goto err;
945 } else
946 busy += end - start + 1;
947 } else if (end >= map_start && end <= map_end) {
948 if (strncmp(res->name, "blk", 3) == 0) {
949 /*
950 * If a BLK allocation overlaps the start of
951 * PMEM the entire interleave set may now only
952 * be used for BLK.
953 */
954 blk_start = map_start;
955 } else
956 busy += end - start + 1;
957 } else if (map_start > start && map_start < end) {
958 /* total eclipse of the mapping */
959 busy += nd_mapping->size;
960 blk_start = map_start;
961 }
962 }
963
964 *overlap = map_end + 1 - blk_start;
965 available = blk_start - map_start;
966 if (busy < available)
967 return ALIGN_DOWN(available - busy, align);
968 return 0;
969
970 err:
971 nd_dbg_dpa(nd_region, ndd, res, "%s\n", reason);
972 return 0;
973}
974
975void nvdimm_free_dpa(struct nvdimm_drvdata *ndd, struct resource *res)
976{
977 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
978 kfree(res->name);
979 __release_region(&ndd->dpa, res->start, resource_size(res));
980}
981
982struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
983 struct nd_label_id *label_id, resource_size_t start,
984 resource_size_t n)
985{
986 char *name = kmemdup(label_id, sizeof(*label_id), GFP_KERNEL);
987 struct resource *res;
988
989 if (!name)
990 return NULL;
991
992 WARN_ON_ONCE(!is_nvdimm_bus_locked(ndd->dev));
993 res = __request_region(&ndd->dpa, start, n, name, 0);
994 if (!res)
995 kfree(name);
996 return res;
997}
998
999/**
1000 * nvdimm_allocated_dpa - sum up the dpa currently allocated to this label_id
1001 * @nvdimm: container of dpa-resource-root + labels
1002 * @label_id: dpa resource name of the form {pmem|blk}-<human readable uuid>
1003 */
1004resource_size_t nvdimm_allocated_dpa(struct nvdimm_drvdata *ndd,
1005 struct nd_label_id *label_id)
1006{
1007 resource_size_t allocated = 0;
1008 struct resource *res;
1009
1010 for_each_dpa_resource(ndd, res)
1011 if (strcmp(res->name, label_id->id) == 0)
1012 allocated += resource_size(res);
1013
1014 return allocated;
1015}
1016
1017static int count_dimms(struct device *dev, void *c)
1018{
1019 int *count = c;
1020
1021 if (is_nvdimm(dev))
1022 (*count)++;
1023 return 0;
1024}
1025
1026int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count)
1027{
1028 int count = 0;
1029 /* Flush any possible dimm registration failures */
1030 nd_synchronize();
1031
1032 device_for_each_child(&nvdimm_bus->dev, &count, count_dimms);
1033 dev_dbg(&nvdimm_bus->dev, "count: %d\n", count);
1034 if (count != dimm_count)
1035 return -ENXIO;
1036 return 0;
1037}
1038EXPORT_SYMBOL_GPL(nvdimm_bus_check_dimm_count);
1039
1040void __exit nvdimm_devs_exit(void)
1041{
1042 ida_destroy(&dimm_ida);
1043}