Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
4 */
5#include <linux/cpumask.h>
6#include <linux/module.h>
7#include <linux/device.h>
8#include <linux/nd.h>
9#include "nd-core.h"
10#include "nd.h"
11
12static int nd_region_probe(struct device *dev)
13{
14 int err, rc;
15 static unsigned long once;
16 struct nd_region_data *ndrd;
17 struct nd_region *nd_region = to_nd_region(dev);
18
19 if (nd_region->num_lanes > num_online_cpus()
20 && nd_region->num_lanes < num_possible_cpus()
21 && !test_and_set_bit(0, &once)) {
22 dev_dbg(dev, "online cpus (%d) < concurrent i/o lanes (%d) < possible cpus (%d)\n",
23 num_online_cpus(), nd_region->num_lanes,
24 num_possible_cpus());
25 dev_dbg(dev, "setting nr_cpus=%d may yield better libnvdimm device performance\n",
26 nd_region->num_lanes);
27 }
28
29 rc = nd_region_activate(nd_region);
30 if (rc)
31 return rc;
32
33 rc = nd_blk_region_init(nd_region);
34 if (rc)
35 return rc;
36
37 if (is_memory(&nd_region->dev)) {
38 struct resource ndr_res;
39
40 if (devm_init_badblocks(dev, &nd_region->bb))
41 return -ENODEV;
42 nd_region->bb_state = sysfs_get_dirent(nd_region->dev.kobj.sd,
43 "badblocks");
44 if (!nd_region->bb_state)
45 dev_warn(&nd_region->dev,
46 "'badblocks' notification disabled\n");
47 ndr_res.start = nd_region->ndr_start;
48 ndr_res.end = nd_region->ndr_start + nd_region->ndr_size - 1;
49 nvdimm_badblocks_populate(nd_region, &nd_region->bb, &ndr_res);
50 }
51
52 rc = nd_region_register_namespaces(nd_region, &err);
53 if (rc < 0)
54 return rc;
55
56 ndrd = dev_get_drvdata(dev);
57 ndrd->ns_active = rc;
58 ndrd->ns_count = rc + err;
59
60 if (rc && err && rc == err)
61 return -ENODEV;
62
63 nd_region->btt_seed = nd_btt_create(nd_region);
64 nd_region->pfn_seed = nd_pfn_create(nd_region);
65 nd_region->dax_seed = nd_dax_create(nd_region);
66 if (err == 0)
67 return 0;
68
69 /*
70 * Given multiple namespaces per region, we do not want to
71 * disable all the successfully registered peer namespaces upon
72 * a single registration failure. If userspace is missing a
73 * namespace that it expects it can disable/re-enable the region
74 * to retry discovery after correcting the failure.
75 * <regionX>/namespaces returns the current
76 * "<async-registered>/<total>" namespace count.
77 */
78 dev_err(dev, "failed to register %d namespace%s, continuing...\n",
79 err, err == 1 ? "" : "s");
80 return 0;
81}
82
83static int child_unregister(struct device *dev, void *data)
84{
85 nd_device_unregister(dev, ND_SYNC);
86 return 0;
87}
88
89static int nd_region_remove(struct device *dev)
90{
91 struct nd_region *nd_region = to_nd_region(dev);
92
93 device_for_each_child(dev, NULL, child_unregister);
94
95 /* flush attribute readers and disable */
96 nvdimm_bus_lock(dev);
97 nd_region->ns_seed = NULL;
98 nd_region->btt_seed = NULL;
99 nd_region->pfn_seed = NULL;
100 nd_region->dax_seed = NULL;
101 dev_set_drvdata(dev, NULL);
102 nvdimm_bus_unlock(dev);
103
104 /*
105 * Note, this assumes nd_device_lock() context to not race
106 * nd_region_notify()
107 */
108 sysfs_put(nd_region->bb_state);
109 nd_region->bb_state = NULL;
110
111 return 0;
112}
113
114static int child_notify(struct device *dev, void *data)
115{
116 nd_device_notify(dev, *(enum nvdimm_event *) data);
117 return 0;
118}
119
120static void nd_region_notify(struct device *dev, enum nvdimm_event event)
121{
122 if (event == NVDIMM_REVALIDATE_POISON) {
123 struct nd_region *nd_region = to_nd_region(dev);
124 struct resource res;
125
126 if (is_memory(&nd_region->dev)) {
127 res.start = nd_region->ndr_start;
128 res.end = nd_region->ndr_start +
129 nd_region->ndr_size - 1;
130 nvdimm_badblocks_populate(nd_region,
131 &nd_region->bb, &res);
132 if (nd_region->bb_state)
133 sysfs_notify_dirent(nd_region->bb_state);
134 }
135 }
136 device_for_each_child(dev, &event, child_notify);
137}
138
139static struct nd_device_driver nd_region_driver = {
140 .probe = nd_region_probe,
141 .remove = nd_region_remove,
142 .notify = nd_region_notify,
143 .drv = {
144 .name = "nd_region",
145 },
146 .type = ND_DRIVER_REGION_BLK | ND_DRIVER_REGION_PMEM,
147};
148
149int __init nd_region_init(void)
150{
151 return nd_driver_register(&nd_region_driver);
152}
153
154void nd_region_exit(void)
155{
156 driver_unregister(&nd_region_driver.drv);
157}
158
159MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_PMEM);
160MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_BLK);
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#include <linux/cpumask.h>
14#include <linux/module.h>
15#include <linux/device.h>
16#include <linux/nd.h>
17#include "nd.h"
18
19static int nd_region_probe(struct device *dev)
20{
21 int err, rc;
22 static unsigned long once;
23 struct nd_region_data *ndrd;
24 struct nd_region *nd_region = to_nd_region(dev);
25
26 if (nd_region->num_lanes > num_online_cpus()
27 && nd_region->num_lanes < num_possible_cpus()
28 && !test_and_set_bit(0, &once)) {
29 dev_info(dev, "online cpus (%d) < concurrent i/o lanes (%d) < possible cpus (%d)\n",
30 num_online_cpus(), nd_region->num_lanes,
31 num_possible_cpus());
32 dev_info(dev, "setting nr_cpus=%d may yield better libnvdimm device performance\n",
33 nd_region->num_lanes);
34 }
35
36 rc = nd_region_activate(nd_region);
37 if (rc)
38 return rc;
39
40 rc = nd_blk_region_init(nd_region);
41 if (rc)
42 return rc;
43
44 rc = nd_region_register_namespaces(nd_region, &err);
45 if (rc < 0)
46 return rc;
47
48 ndrd = dev_get_drvdata(dev);
49 ndrd->ns_active = rc;
50 ndrd->ns_count = rc + err;
51
52 if (rc && err && rc == err)
53 return -ENODEV;
54
55 nd_region->btt_seed = nd_btt_create(nd_region);
56 nd_region->pfn_seed = nd_pfn_create(nd_region);
57 nd_region->dax_seed = nd_dax_create(nd_region);
58 if (err == 0)
59 return 0;
60
61 /*
62 * Given multiple namespaces per region, we do not want to
63 * disable all the successfully registered peer namespaces upon
64 * a single registration failure. If userspace is missing a
65 * namespace that it expects it can disable/re-enable the region
66 * to retry discovery after correcting the failure.
67 * <regionX>/namespaces returns the current
68 * "<async-registered>/<total>" namespace count.
69 */
70 dev_err(dev, "failed to register %d namespace%s, continuing...\n",
71 err, err == 1 ? "" : "s");
72 return 0;
73}
74
75static int child_unregister(struct device *dev, void *data)
76{
77 nd_device_unregister(dev, ND_SYNC);
78 return 0;
79}
80
81static int nd_region_remove(struct device *dev)
82{
83 struct nd_region *nd_region = to_nd_region(dev);
84
85 device_for_each_child(dev, NULL, child_unregister);
86
87 /* flush attribute readers and disable */
88 nvdimm_bus_lock(dev);
89 nd_region->ns_seed = NULL;
90 nd_region->btt_seed = NULL;
91 nd_region->pfn_seed = NULL;
92 nd_region->dax_seed = NULL;
93 dev_set_drvdata(dev, NULL);
94 nvdimm_bus_unlock(dev);
95
96 return 0;
97}
98
99static int child_notify(struct device *dev, void *data)
100{
101 nd_device_notify(dev, *(enum nvdimm_event *) data);
102 return 0;
103}
104
105static void nd_region_notify(struct device *dev, enum nvdimm_event event)
106{
107 device_for_each_child(dev, &event, child_notify);
108}
109
110static struct nd_device_driver nd_region_driver = {
111 .probe = nd_region_probe,
112 .remove = nd_region_remove,
113 .notify = nd_region_notify,
114 .drv = {
115 .name = "nd_region",
116 },
117 .type = ND_DRIVER_REGION_BLK | ND_DRIVER_REGION_PMEM,
118};
119
120int __init nd_region_init(void)
121{
122 return nd_driver_register(&nd_region_driver);
123}
124
125void nd_region_exit(void)
126{
127 driver_unregister(&nd_region_driver.drv);
128}
129
130MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_PMEM);
131MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_BLK);