1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/module.h>
34#include <linux/configfs.h>
35#include <rdma/ib_verbs.h>
36#include "core_priv.h"
37
38struct cma_device;
39
40struct cma_dev_group;
41
42struct cma_dev_port_group {
43 unsigned int port_num;
44 struct cma_dev_group *cma_dev_group;
45 struct config_group group;
46};
47
48struct cma_dev_group {
49 char name[IB_DEVICE_NAME_MAX];
50 struct config_group device_group;
51 struct config_group ports_group;
52 struct cma_dev_port_group *ports;
53};
54
55static struct cma_dev_port_group *to_dev_port_group(struct config_item *item)
56{
57 struct config_group *group;
58
59 if (!item)
60 return NULL;
61
62 group = container_of(item, struct config_group, cg_item);
63 return container_of(group, struct cma_dev_port_group, group);
64}
65
66static bool filter_by_name(struct ib_device *ib_dev, void *cookie)
67{
68 return !strcmp(ib_dev->name, cookie);
69}
70
71static int cma_configfs_params_get(struct config_item *item,
72 struct cma_device **pcma_dev,
73 struct cma_dev_port_group **pgroup)
74{
75 struct cma_dev_port_group *group = to_dev_port_group(item);
76 struct cma_device *cma_dev;
77
78 if (!group)
79 return -ENODEV;
80
81 cma_dev = cma_enum_devices_by_ibdev(filter_by_name,
82 group->cma_dev_group->name);
83 if (!cma_dev)
84 return -ENODEV;
85
86 *pcma_dev = cma_dev;
87 *pgroup = group;
88
89 return 0;
90}
91
92static void cma_configfs_params_put(struct cma_device *cma_dev)
93{
94 cma_deref_dev(cma_dev);
95}
96
97static ssize_t default_roce_mode_show(struct config_item *item,
98 char *buf)
99{
100 struct cma_device *cma_dev;
101 struct cma_dev_port_group *group;
102 int gid_type;
103 ssize_t ret;
104
105 ret = cma_configfs_params_get(item, &cma_dev, &group);
106 if (ret)
107 return ret;
108
109 gid_type = cma_get_default_gid_type(cma_dev, group->port_num);
110 cma_configfs_params_put(cma_dev);
111
112 if (gid_type < 0)
113 return gid_type;
114
115 return sprintf(buf, "%s\n", ib_cache_gid_type_str(gid_type));
116}
117
118static ssize_t default_roce_mode_store(struct config_item *item,
119 const char *buf, size_t count)
120{
121 struct cma_device *cma_dev;
122 struct cma_dev_port_group *group;
123 int gid_type = ib_cache_gid_parse_type_str(buf);
124 ssize_t ret;
125
126 if (gid_type < 0)
127 return -EINVAL;
128
129 ret = cma_configfs_params_get(item, &cma_dev, &group);
130 if (ret)
131 return ret;
132
133 ret = cma_set_default_gid_type(cma_dev, group->port_num, gid_type);
134
135 cma_configfs_params_put(cma_dev);
136
137 return !ret ? strnlen(buf, count) : ret;
138}
139
140CONFIGFS_ATTR(, default_roce_mode);
141
142static ssize_t default_roce_tos_show(struct config_item *item, char *buf)
143{
144 struct cma_device *cma_dev;
145 struct cma_dev_port_group *group;
146 ssize_t ret;
147 u8 tos;
148
149 ret = cma_configfs_params_get(item, &cma_dev, &group);
150 if (ret)
151 return ret;
152
153 tos = cma_get_default_roce_tos(cma_dev, group->port_num);
154 cma_configfs_params_put(cma_dev);
155
156 return sprintf(buf, "%u\n", tos);
157}
158
159static ssize_t default_roce_tos_store(struct config_item *item,
160 const char *buf, size_t count)
161{
162 struct cma_device *cma_dev;
163 struct cma_dev_port_group *group;
164 ssize_t ret;
165 u8 tos;
166
167 ret = kstrtou8(buf, 0, &tos);
168 if (ret)
169 return ret;
170
171 ret = cma_configfs_params_get(item, &cma_dev, &group);
172 if (ret)
173 return ret;
174
175 ret = cma_set_default_roce_tos(cma_dev, group->port_num, tos);
176 cma_configfs_params_put(cma_dev);
177
178 return ret ? ret : strnlen(buf, count);
179}
180
181CONFIGFS_ATTR(, default_roce_tos);
182
183static struct configfs_attribute *cma_configfs_attributes[] = {
184 &attr_default_roce_mode,
185 &attr_default_roce_tos,
186 NULL,
187};
188
189static struct config_item_type cma_port_group_type = {
190 .ct_attrs = cma_configfs_attributes,
191 .ct_owner = THIS_MODULE
192};
193
194static int make_cma_ports(struct cma_dev_group *cma_dev_group,
195 struct cma_device *cma_dev)
196{
197 struct ib_device *ibdev;
198 unsigned int i;
199 unsigned int ports_num;
200 struct cma_dev_port_group *ports;
201 int err;
202
203 ibdev = cma_get_ib_dev(cma_dev);
204
205 if (!ibdev)
206 return -ENODEV;
207
208 ports_num = ibdev->phys_port_cnt;
209 ports = kcalloc(ports_num, sizeof(*cma_dev_group->ports),
210 GFP_KERNEL);
211
212 if (!ports) {
213 err = -ENOMEM;
214 goto free;
215 }
216
217 for (i = 0; i < ports_num; i++) {
218 char port_str[10];
219
220 ports[i].port_num = i + 1;
221 snprintf(port_str, sizeof(port_str), "%u", i + 1);
222 ports[i].cma_dev_group = cma_dev_group;
223 config_group_init_type_name(&ports[i].group,
224 port_str,
225 &cma_port_group_type);
226 configfs_add_default_group(&ports[i].group,
227 &cma_dev_group->ports_group);
228
229 }
230 cma_dev_group->ports = ports;
231
232 return 0;
233free:
234 kfree(ports);
235 cma_dev_group->ports = NULL;
236 return err;
237}
238
239static void release_cma_dev(struct config_item *item)
240{
241 struct config_group *group = container_of(item, struct config_group,
242 cg_item);
243 struct cma_dev_group *cma_dev_group = container_of(group,
244 struct cma_dev_group,
245 device_group);
246
247 kfree(cma_dev_group);
248};
249
250static void release_cma_ports_group(struct config_item *item)
251{
252 struct config_group *group = container_of(item, struct config_group,
253 cg_item);
254 struct cma_dev_group *cma_dev_group = container_of(group,
255 struct cma_dev_group,
256 ports_group);
257
258 kfree(cma_dev_group->ports);
259 cma_dev_group->ports = NULL;
260};
261
262static struct configfs_item_operations cma_ports_item_ops = {
263 .release = release_cma_ports_group
264};
265
266static struct config_item_type cma_ports_group_type = {
267 .ct_item_ops = &cma_ports_item_ops,
268 .ct_owner = THIS_MODULE
269};
270
271static struct configfs_item_operations cma_device_item_ops = {
272 .release = release_cma_dev
273};
274
275static struct config_item_type cma_device_group_type = {
276 .ct_item_ops = &cma_device_item_ops,
277 .ct_owner = THIS_MODULE
278};
279
280static struct config_group *make_cma_dev(struct config_group *group,
281 const char *name)
282{
283 int err = -ENODEV;
284 struct cma_device *cma_dev = cma_enum_devices_by_ibdev(filter_by_name,
285 (void *)name);
286 struct cma_dev_group *cma_dev_group = NULL;
287
288 if (!cma_dev)
289 goto fail;
290
291 cma_dev_group = kzalloc(sizeof(*cma_dev_group), GFP_KERNEL);
292
293 if (!cma_dev_group) {
294 err = -ENOMEM;
295 goto fail;
296 }
297
298 strncpy(cma_dev_group->name, name, sizeof(cma_dev_group->name));
299
300 config_group_init_type_name(&cma_dev_group->ports_group, "ports",
301 &cma_ports_group_type);
302
303 err = make_cma_ports(cma_dev_group, cma_dev);
304 if (err)
305 goto fail;
306
307 config_group_init_type_name(&cma_dev_group->device_group, name,
308 &cma_device_group_type);
309 configfs_add_default_group(&cma_dev_group->ports_group,
310 &cma_dev_group->device_group);
311
312 cma_deref_dev(cma_dev);
313 return &cma_dev_group->device_group;
314
315fail:
316 if (cma_dev)
317 cma_deref_dev(cma_dev);
318 kfree(cma_dev_group);
319 return ERR_PTR(err);
320}
321
322static struct configfs_group_operations cma_subsys_group_ops = {
323 .make_group = make_cma_dev,
324};
325
326static struct config_item_type cma_subsys_type = {
327 .ct_group_ops = &cma_subsys_group_ops,
328 .ct_owner = THIS_MODULE,
329};
330
331static struct configfs_subsystem cma_subsys = {
332 .su_group = {
333 .cg_item = {
334 .ci_namebuf = "rdma_cm",
335 .ci_type = &cma_subsys_type,
336 },
337 },
338};
339
340int __init cma_configfs_init(void)
341{
342 config_group_init(&cma_subsys.su_group);
343 mutex_init(&cma_subsys.su_mutex);
344 return configfs_register_subsystem(&cma_subsys);
345}
346
347void __exit cma_configfs_exit(void)
348{
349 configfs_unregister_subsystem(&cma_subsys);
350}
351
