1 | /* |
2 | * Copyright (c) 2015, Mellanox Technologies inc. All rights reserved. |
3 | * |
4 | * This software is available to you under a choice of one of two |
5 | * licenses. You may choose to be licensed under the terms of the GNU |
6 | * General Public License (GPL) Version 2, available from the file |
7 | * COPYING in the main directory of this source tree, or the |
8 | * OpenIB.org BSD license below: |
9 | * |
10 | * Redistribution and use in source and binary forms, with or |
11 | * without modification, are permitted provided that the following |
12 | * conditions are met: |
13 | * |
14 | * - Redistributions of source code must retain the above |
15 | * copyright notice, this list of conditions and the following |
16 | * disclaimer. |
17 | * |
18 | * - Redistributions in binary form must reproduce the above |
19 | * copyright notice, this list of conditions and the following |
20 | * disclaimer in the documentation and/or other materials |
21 | * provided with the distribution. |
22 | * |
23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
25 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
27 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
28 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
29 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
30 | * SOFTWARE. |
31 | */ |
32 | |
33 | #include <linux/configfs.h> |
34 | #include <rdma/ib_verbs.h> |
35 | #include <rdma/rdma_cm.h> |
36 | |
37 | #include "core_priv.h" |
38 | #include "cma_priv.h" |
39 | |
40 | struct cma_device; |
41 | |
42 | struct cma_dev_group; |
43 | |
44 | struct cma_dev_port_group { |
45 | u32 port_num; |
46 | struct cma_dev_group *cma_dev_group; |
47 | struct config_group group; |
48 | }; |
49 | |
50 | struct cma_dev_group { |
51 | char name[IB_DEVICE_NAME_MAX]; |
52 | struct config_group device_group; |
53 | struct config_group ports_group; |
54 | struct cma_dev_port_group *ports; |
55 | }; |
56 | |
57 | static struct cma_dev_port_group *to_dev_port_group(struct config_item *item) |
58 | { |
59 | struct config_group *group; |
60 | |
61 | if (!item) |
62 | return NULL; |
63 | |
64 | group = container_of(item, struct config_group, cg_item); |
65 | return container_of(group, struct cma_dev_port_group, group); |
66 | } |
67 | |
68 | static bool filter_by_name(struct ib_device *ib_dev, void *cookie) |
69 | { |
70 | return !strcmp(dev_name(dev: &ib_dev->dev), cookie); |
71 | } |
72 | |
73 | static int cma_configfs_params_get(struct config_item *item, |
74 | struct cma_device **pcma_dev, |
75 | struct cma_dev_port_group **pgroup) |
76 | { |
77 | struct cma_dev_port_group *group = to_dev_port_group(item); |
78 | struct cma_device *cma_dev; |
79 | |
80 | if (!group) |
81 | return -ENODEV; |
82 | |
83 | cma_dev = cma_enum_devices_by_ibdev(filter: filter_by_name, |
84 | cookie: group->cma_dev_group->name); |
85 | if (!cma_dev) |
86 | return -ENODEV; |
87 | |
88 | *pcma_dev = cma_dev; |
89 | *pgroup = group; |
90 | |
91 | return 0; |
92 | } |
93 | |
94 | static void cma_configfs_params_put(struct cma_device *cma_dev) |
95 | { |
96 | cma_dev_put(dev: cma_dev); |
97 | } |
98 | |
99 | static ssize_t default_roce_mode_show(struct config_item *item, |
100 | char *buf) |
101 | { |
102 | struct cma_device *cma_dev; |
103 | struct cma_dev_port_group *group; |
104 | int gid_type; |
105 | ssize_t ret; |
106 | |
107 | ret = cma_configfs_params_get(item, pcma_dev: &cma_dev, pgroup: &group); |
108 | if (ret) |
109 | return ret; |
110 | |
111 | gid_type = cma_get_default_gid_type(dev: cma_dev, port: group->port_num); |
112 | cma_configfs_params_put(cma_dev); |
113 | |
114 | if (gid_type < 0) |
115 | return gid_type; |
116 | |
117 | return sysfs_emit(buf, fmt: "%s\n" , ib_cache_gid_type_str(gid_type)); |
118 | } |
119 | |
120 | static ssize_t default_roce_mode_store(struct config_item *item, |
121 | const char *buf, size_t count) |
122 | { |
123 | struct cma_device *cma_dev; |
124 | struct cma_dev_port_group *group; |
125 | int gid_type; |
126 | ssize_t ret; |
127 | |
128 | ret = cma_configfs_params_get(item, pcma_dev: &cma_dev, pgroup: &group); |
129 | if (ret) |
130 | return ret; |
131 | |
132 | gid_type = ib_cache_gid_parse_type_str(buf); |
133 | if (gid_type < 0) { |
134 | cma_configfs_params_put(cma_dev); |
135 | return -EINVAL; |
136 | } |
137 | |
138 | ret = cma_set_default_gid_type(dev: cma_dev, port: group->port_num, default_gid_type: gid_type); |
139 | |
140 | cma_configfs_params_put(cma_dev); |
141 | |
142 | return !ret ? strnlen(p: buf, maxlen: count) : ret; |
143 | } |
144 | |
145 | CONFIGFS_ATTR(, default_roce_mode); |
146 | |
147 | static ssize_t default_roce_tos_show(struct config_item *item, char *buf) |
148 | { |
149 | struct cma_device *cma_dev; |
150 | struct cma_dev_port_group *group; |
151 | ssize_t ret; |
152 | u8 tos; |
153 | |
154 | ret = cma_configfs_params_get(item, pcma_dev: &cma_dev, pgroup: &group); |
155 | if (ret) |
156 | return ret; |
157 | |
158 | tos = cma_get_default_roce_tos(dev: cma_dev, port: group->port_num); |
159 | cma_configfs_params_put(cma_dev); |
160 | |
161 | return sysfs_emit(buf, fmt: "%u\n" , tos); |
162 | } |
163 | |
164 | static ssize_t default_roce_tos_store(struct config_item *item, |
165 | const char *buf, size_t count) |
166 | { |
167 | struct cma_device *cma_dev; |
168 | struct cma_dev_port_group *group; |
169 | ssize_t ret; |
170 | u8 tos; |
171 | |
172 | ret = kstrtou8(s: buf, base: 0, res: &tos); |
173 | if (ret) |
174 | return ret; |
175 | |
176 | ret = cma_configfs_params_get(item, pcma_dev: &cma_dev, pgroup: &group); |
177 | if (ret) |
178 | return ret; |
179 | |
180 | ret = cma_set_default_roce_tos(dev: cma_dev, port: group->port_num, default_roce_tos: tos); |
181 | cma_configfs_params_put(cma_dev); |
182 | |
183 | return ret ? ret : strnlen(p: buf, maxlen: count); |
184 | } |
185 | |
186 | CONFIGFS_ATTR(, default_roce_tos); |
187 | |
188 | static struct configfs_attribute *cma_configfs_attributes[] = { |
189 | &attr_default_roce_mode, |
190 | &attr_default_roce_tos, |
191 | NULL, |
192 | }; |
193 | |
194 | static const struct config_item_type cma_port_group_type = { |
195 | .ct_attrs = cma_configfs_attributes, |
196 | .ct_owner = THIS_MODULE |
197 | }; |
198 | |
199 | static int make_cma_ports(struct cma_dev_group *cma_dev_group, |
200 | struct cma_device *cma_dev) |
201 | { |
202 | struct cma_dev_port_group *ports; |
203 | struct ib_device *ibdev; |
204 | u32 ports_num; |
205 | u32 i; |
206 | |
207 | ibdev = cma_get_ib_dev(dev: cma_dev); |
208 | |
209 | if (!ibdev) |
210 | return -ENODEV; |
211 | |
212 | ports_num = ibdev->phys_port_cnt; |
213 | ports = kcalloc(n: ports_num, size: sizeof(*cma_dev_group->ports), |
214 | GFP_KERNEL); |
215 | |
216 | if (!ports) |
217 | return -ENOMEM; |
218 | |
219 | for (i = 0; i < ports_num; i++) { |
220 | char port_str[11]; |
221 | |
222 | ports[i].port_num = i + 1; |
223 | snprintf(buf: port_str, size: sizeof(port_str), fmt: "%u" , i + 1); |
224 | ports[i].cma_dev_group = cma_dev_group; |
225 | config_group_init_type_name(group: &ports[i].group, |
226 | name: port_str, |
227 | type: &cma_port_group_type); |
228 | configfs_add_default_group(new_group: &ports[i].group, |
229 | group: &cma_dev_group->ports_group); |
230 | |
231 | } |
232 | cma_dev_group->ports = ports; |
233 | return 0; |
234 | } |
235 | |
236 | static void release_cma_dev(struct config_item *item) |
237 | { |
238 | struct config_group *group = container_of(item, struct config_group, |
239 | cg_item); |
240 | struct cma_dev_group *cma_dev_group = container_of(group, |
241 | struct cma_dev_group, |
242 | device_group); |
243 | |
244 | kfree(objp: cma_dev_group); |
245 | }; |
246 | |
247 | static void release_cma_ports_group(struct config_item *item) |
248 | { |
249 | struct config_group *group = container_of(item, struct config_group, |
250 | cg_item); |
251 | struct cma_dev_group *cma_dev_group = container_of(group, |
252 | struct cma_dev_group, |
253 | ports_group); |
254 | |
255 | kfree(objp: cma_dev_group->ports); |
256 | cma_dev_group->ports = NULL; |
257 | }; |
258 | |
259 | static struct configfs_item_operations cma_ports_item_ops = { |
260 | .release = release_cma_ports_group |
261 | }; |
262 | |
263 | static const struct config_item_type cma_ports_group_type = { |
264 | .ct_item_ops = &cma_ports_item_ops, |
265 | .ct_owner = THIS_MODULE |
266 | }; |
267 | |
268 | static struct configfs_item_operations cma_device_item_ops = { |
269 | .release = release_cma_dev |
270 | }; |
271 | |
272 | static const struct config_item_type cma_device_group_type = { |
273 | .ct_item_ops = &cma_device_item_ops, |
274 | .ct_owner = THIS_MODULE |
275 | }; |
276 | |
277 | static struct config_group *make_cma_dev(struct config_group *group, |
278 | const char *name) |
279 | { |
280 | int err = -ENODEV; |
281 | struct cma_device *cma_dev = cma_enum_devices_by_ibdev(filter: filter_by_name, |
282 | cookie: (void *)name); |
283 | struct cma_dev_group *cma_dev_group = NULL; |
284 | |
285 | if (!cma_dev) |
286 | goto fail; |
287 | |
288 | cma_dev_group = kzalloc(size: sizeof(*cma_dev_group), GFP_KERNEL); |
289 | |
290 | if (!cma_dev_group) { |
291 | err = -ENOMEM; |
292 | goto fail; |
293 | } |
294 | |
295 | strscpy(cma_dev_group->name, name, sizeof(cma_dev_group->name)); |
296 | |
297 | config_group_init_type_name(group: &cma_dev_group->ports_group, name: "ports" , |
298 | type: &cma_ports_group_type); |
299 | |
300 | err = make_cma_ports(cma_dev_group, cma_dev); |
301 | if (err) |
302 | goto fail; |
303 | |
304 | config_group_init_type_name(group: &cma_dev_group->device_group, name, |
305 | type: &cma_device_group_type); |
306 | configfs_add_default_group(new_group: &cma_dev_group->ports_group, |
307 | group: &cma_dev_group->device_group); |
308 | |
309 | cma_dev_put(dev: cma_dev); |
310 | return &cma_dev_group->device_group; |
311 | |
312 | fail: |
313 | if (cma_dev) |
314 | cma_dev_put(dev: cma_dev); |
315 | kfree(objp: cma_dev_group); |
316 | return ERR_PTR(error: err); |
317 | } |
318 | |
319 | static void drop_cma_dev(struct config_group *cgroup, struct config_item *item) |
320 | { |
321 | struct config_group *group = |
322 | container_of(item, struct config_group, cg_item); |
323 | struct cma_dev_group *cma_dev_group = |
324 | container_of(group, struct cma_dev_group, device_group); |
325 | |
326 | configfs_remove_default_groups(group: &cma_dev_group->ports_group); |
327 | configfs_remove_default_groups(group: &cma_dev_group->device_group); |
328 | config_item_put(item); |
329 | } |
330 | |
331 | static struct configfs_group_operations cma_subsys_group_ops = { |
332 | .make_group = make_cma_dev, |
333 | .drop_item = drop_cma_dev, |
334 | }; |
335 | |
336 | static const struct config_item_type cma_subsys_type = { |
337 | .ct_group_ops = &cma_subsys_group_ops, |
338 | .ct_owner = THIS_MODULE, |
339 | }; |
340 | |
341 | static struct configfs_subsystem cma_subsys = { |
342 | .su_group = { |
343 | .cg_item = { |
344 | .ci_namebuf = "rdma_cm" , |
345 | .ci_type = &cma_subsys_type, |
346 | }, |
347 | }, |
348 | }; |
349 | |
350 | int __init cma_configfs_init(void) |
351 | { |
352 | int ret; |
353 | |
354 | config_group_init(group: &cma_subsys.su_group); |
355 | mutex_init(&cma_subsys.su_mutex); |
356 | ret = configfs_register_subsystem(subsys: &cma_subsys); |
357 | if (ret) |
358 | mutex_destroy(lock: &cma_subsys.su_mutex); |
359 | return ret; |
360 | } |
361 | |
362 | void __exit cma_configfs_exit(void) |
363 | { |
364 | configfs_unregister_subsystem(subsys: &cma_subsys); |
365 | mutex_destroy(lock: &cma_subsys.su_mutex); |
366 | } |
367 | |