1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Copyright (c) 2016 Mellanox Technologies. All rights reserved. |
4 | * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com> |
5 | */ |
6 | |
7 | #include "devl_internal.h" |
8 | |
9 | static const struct devlink_param devlink_param_generic[] = { |
10 | { |
11 | .id = DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET, |
12 | .name = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_NAME, |
13 | .type = DEVLINK_PARAM_GENERIC_INT_ERR_RESET_TYPE, |
14 | }, |
15 | { |
16 | .id = DEVLINK_PARAM_GENERIC_ID_MAX_MACS, |
17 | .name = DEVLINK_PARAM_GENERIC_MAX_MACS_NAME, |
18 | .type = DEVLINK_PARAM_GENERIC_MAX_MACS_TYPE, |
19 | }, |
20 | { |
21 | .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV, |
22 | .name = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_NAME, |
23 | .type = DEVLINK_PARAM_GENERIC_ENABLE_SRIOV_TYPE, |
24 | }, |
25 | { |
26 | .id = DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT, |
27 | .name = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_NAME, |
28 | .type = DEVLINK_PARAM_GENERIC_REGION_SNAPSHOT_TYPE, |
29 | }, |
30 | { |
31 | .id = DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI, |
32 | .name = DEVLINK_PARAM_GENERIC_IGNORE_ARI_NAME, |
33 | .type = DEVLINK_PARAM_GENERIC_IGNORE_ARI_TYPE, |
34 | }, |
35 | { |
36 | .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX, |
37 | .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_NAME, |
38 | .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MAX_TYPE, |
39 | }, |
40 | { |
41 | .id = DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN, |
42 | .name = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_NAME, |
43 | .type = DEVLINK_PARAM_GENERIC_MSIX_VEC_PER_PF_MIN_TYPE, |
44 | }, |
45 | { |
46 | .id = DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY, |
47 | .name = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_NAME, |
48 | .type = DEVLINK_PARAM_GENERIC_FW_LOAD_POLICY_TYPE, |
49 | }, |
50 | { |
51 | .id = DEVLINK_PARAM_GENERIC_ID_RESET_DEV_ON_DRV_PROBE, |
52 | .name = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_NAME, |
53 | .type = DEVLINK_PARAM_GENERIC_RESET_DEV_ON_DRV_PROBE_TYPE, |
54 | }, |
55 | { |
56 | .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE, |
57 | .name = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_NAME, |
58 | .type = DEVLINK_PARAM_GENERIC_ENABLE_ROCE_TYPE, |
59 | }, |
60 | { |
61 | .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_REMOTE_DEV_RESET, |
62 | .name = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_NAME, |
63 | .type = DEVLINK_PARAM_GENERIC_ENABLE_REMOTE_DEV_RESET_TYPE, |
64 | }, |
65 | { |
66 | .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_ETH, |
67 | .name = DEVLINK_PARAM_GENERIC_ENABLE_ETH_NAME, |
68 | .type = DEVLINK_PARAM_GENERIC_ENABLE_ETH_TYPE, |
69 | }, |
70 | { |
71 | .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_RDMA, |
72 | .name = DEVLINK_PARAM_GENERIC_ENABLE_RDMA_NAME, |
73 | .type = DEVLINK_PARAM_GENERIC_ENABLE_RDMA_TYPE, |
74 | }, |
75 | { |
76 | .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_VNET, |
77 | .name = DEVLINK_PARAM_GENERIC_ENABLE_VNET_NAME, |
78 | .type = DEVLINK_PARAM_GENERIC_ENABLE_VNET_TYPE, |
79 | }, |
80 | { |
81 | .id = DEVLINK_PARAM_GENERIC_ID_ENABLE_IWARP, |
82 | .name = DEVLINK_PARAM_GENERIC_ENABLE_IWARP_NAME, |
83 | .type = DEVLINK_PARAM_GENERIC_ENABLE_IWARP_TYPE, |
84 | }, |
85 | { |
86 | .id = DEVLINK_PARAM_GENERIC_ID_IO_EQ_SIZE, |
87 | .name = DEVLINK_PARAM_GENERIC_IO_EQ_SIZE_NAME, |
88 | .type = DEVLINK_PARAM_GENERIC_IO_EQ_SIZE_TYPE, |
89 | }, |
90 | { |
91 | .id = DEVLINK_PARAM_GENERIC_ID_EVENT_EQ_SIZE, |
92 | .name = DEVLINK_PARAM_GENERIC_EVENT_EQ_SIZE_NAME, |
93 | .type = DEVLINK_PARAM_GENERIC_EVENT_EQ_SIZE_TYPE, |
94 | }, |
95 | }; |
96 | |
97 | static int devlink_param_generic_verify(const struct devlink_param *param) |
98 | { |
99 | /* verify it match generic parameter by id and name */ |
100 | if (param->id > DEVLINK_PARAM_GENERIC_ID_MAX) |
101 | return -EINVAL; |
102 | if (strcmp(param->name, devlink_param_generic[param->id].name)) |
103 | return -ENOENT; |
104 | |
105 | WARN_ON(param->type != devlink_param_generic[param->id].type); |
106 | |
107 | return 0; |
108 | } |
109 | |
110 | static int devlink_param_driver_verify(const struct devlink_param *param) |
111 | { |
112 | int i; |
113 | |
114 | if (param->id <= DEVLINK_PARAM_GENERIC_ID_MAX) |
115 | return -EINVAL; |
116 | /* verify no such name in generic params */ |
117 | for (i = 0; i <= DEVLINK_PARAM_GENERIC_ID_MAX; i++) |
118 | if (!strcmp(param->name, devlink_param_generic[i].name)) |
119 | return -EEXIST; |
120 | |
121 | return 0; |
122 | } |
123 | |
124 | static struct devlink_param_item * |
125 | devlink_param_find_by_name(struct xarray *params, const char *param_name) |
126 | { |
127 | struct devlink_param_item *param_item; |
128 | unsigned long param_id; |
129 | |
130 | xa_for_each(params, param_id, param_item) { |
131 | if (!strcmp(param_item->param->name, param_name)) |
132 | return param_item; |
133 | } |
134 | return NULL; |
135 | } |
136 | |
137 | static struct devlink_param_item * |
138 | devlink_param_find_by_id(struct xarray *params, u32 param_id) |
139 | { |
140 | return xa_load(params, index: param_id); |
141 | } |
142 | |
143 | static bool |
144 | devlink_param_cmode_is_supported(const struct devlink_param *param, |
145 | enum devlink_param_cmode cmode) |
146 | { |
147 | return test_bit(cmode, ¶m->supported_cmodes); |
148 | } |
149 | |
150 | static int devlink_param_get(struct devlink *devlink, |
151 | const struct devlink_param *param, |
152 | struct devlink_param_gset_ctx *ctx) |
153 | { |
154 | if (!param->get) |
155 | return -EOPNOTSUPP; |
156 | return param->get(devlink, param->id, ctx); |
157 | } |
158 | |
159 | static int devlink_param_set(struct devlink *devlink, |
160 | const struct devlink_param *param, |
161 | struct devlink_param_gset_ctx *ctx) |
162 | { |
163 | if (!param->set) |
164 | return -EOPNOTSUPP; |
165 | return param->set(devlink, param->id, ctx); |
166 | } |
167 | |
168 | static int |
169 | devlink_param_type_to_nla_type(enum devlink_param_type param_type) |
170 | { |
171 | switch (param_type) { |
172 | case DEVLINK_PARAM_TYPE_U8: |
173 | return NLA_U8; |
174 | case DEVLINK_PARAM_TYPE_U16: |
175 | return NLA_U16; |
176 | case DEVLINK_PARAM_TYPE_U32: |
177 | return NLA_U32; |
178 | case DEVLINK_PARAM_TYPE_STRING: |
179 | return NLA_STRING; |
180 | case DEVLINK_PARAM_TYPE_BOOL: |
181 | return NLA_FLAG; |
182 | default: |
183 | return -EINVAL; |
184 | } |
185 | } |
186 | |
187 | static int |
188 | devlink_nl_param_value_fill_one(struct sk_buff *msg, |
189 | enum devlink_param_type type, |
190 | enum devlink_param_cmode cmode, |
191 | union devlink_param_value val) |
192 | { |
193 | struct nlattr *param_value_attr; |
194 | |
195 | param_value_attr = nla_nest_start_noflag(skb: msg, |
196 | attrtype: DEVLINK_ATTR_PARAM_VALUE); |
197 | if (!param_value_attr) |
198 | goto nla_put_failure; |
199 | |
200 | if (nla_put_u8(skb: msg, attrtype: DEVLINK_ATTR_PARAM_VALUE_CMODE, value: cmode)) |
201 | goto value_nest_cancel; |
202 | |
203 | switch (type) { |
204 | case DEVLINK_PARAM_TYPE_U8: |
205 | if (nla_put_u8(skb: msg, attrtype: DEVLINK_ATTR_PARAM_VALUE_DATA, value: val.vu8)) |
206 | goto value_nest_cancel; |
207 | break; |
208 | case DEVLINK_PARAM_TYPE_U16: |
209 | if (nla_put_u16(skb: msg, attrtype: DEVLINK_ATTR_PARAM_VALUE_DATA, value: val.vu16)) |
210 | goto value_nest_cancel; |
211 | break; |
212 | case DEVLINK_PARAM_TYPE_U32: |
213 | if (nla_put_u32(skb: msg, attrtype: DEVLINK_ATTR_PARAM_VALUE_DATA, value: val.vu32)) |
214 | goto value_nest_cancel; |
215 | break; |
216 | case DEVLINK_PARAM_TYPE_STRING: |
217 | if (nla_put_string(skb: msg, attrtype: DEVLINK_ATTR_PARAM_VALUE_DATA, |
218 | str: val.vstr)) |
219 | goto value_nest_cancel; |
220 | break; |
221 | case DEVLINK_PARAM_TYPE_BOOL: |
222 | if (val.vbool && |
223 | nla_put_flag(skb: msg, attrtype: DEVLINK_ATTR_PARAM_VALUE_DATA)) |
224 | goto value_nest_cancel; |
225 | break; |
226 | } |
227 | |
228 | nla_nest_end(skb: msg, start: param_value_attr); |
229 | return 0; |
230 | |
231 | value_nest_cancel: |
232 | nla_nest_cancel(skb: msg, start: param_value_attr); |
233 | nla_put_failure: |
234 | return -EMSGSIZE; |
235 | } |
236 | |
237 | static int devlink_nl_param_fill(struct sk_buff *msg, struct devlink *devlink, |
238 | unsigned int port_index, |
239 | struct devlink_param_item *param_item, |
240 | enum devlink_command cmd, |
241 | u32 portid, u32 seq, int flags) |
242 | { |
243 | union devlink_param_value param_value[DEVLINK_PARAM_CMODE_MAX + 1]; |
244 | bool param_value_set[DEVLINK_PARAM_CMODE_MAX + 1] = {}; |
245 | const struct devlink_param *param = param_item->param; |
246 | struct devlink_param_gset_ctx ctx; |
247 | struct nlattr *param_values_list; |
248 | struct nlattr *param_attr; |
249 | int nla_type; |
250 | void *hdr; |
251 | int err; |
252 | int i; |
253 | |
254 | /* Get value from driver part to driverinit configuration mode */ |
255 | for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) { |
256 | if (!devlink_param_cmode_is_supported(param, cmode: i)) |
257 | continue; |
258 | if (i == DEVLINK_PARAM_CMODE_DRIVERINIT) { |
259 | if (param_item->driverinit_value_new_valid) |
260 | param_value[i] = param_item->driverinit_value_new; |
261 | else if (param_item->driverinit_value_valid) |
262 | param_value[i] = param_item->driverinit_value; |
263 | else |
264 | return -EOPNOTSUPP; |
265 | } else { |
266 | ctx.cmode = i; |
267 | err = devlink_param_get(devlink, param, ctx: &ctx); |
268 | if (err) |
269 | return err; |
270 | param_value[i] = ctx.val; |
271 | } |
272 | param_value_set[i] = true; |
273 | } |
274 | |
275 | hdr = genlmsg_put(skb: msg, portid, seq, family: &devlink_nl_family, flags, cmd); |
276 | if (!hdr) |
277 | return -EMSGSIZE; |
278 | |
279 | if (devlink_nl_put_handle(msg, devlink)) |
280 | goto genlmsg_cancel; |
281 | |
282 | if (cmd == DEVLINK_CMD_PORT_PARAM_GET || |
283 | cmd == DEVLINK_CMD_PORT_PARAM_NEW || |
284 | cmd == DEVLINK_CMD_PORT_PARAM_DEL) |
285 | if (nla_put_u32(skb: msg, attrtype: DEVLINK_ATTR_PORT_INDEX, value: port_index)) |
286 | goto genlmsg_cancel; |
287 | |
288 | param_attr = nla_nest_start_noflag(skb: msg, attrtype: DEVLINK_ATTR_PARAM); |
289 | if (!param_attr) |
290 | goto genlmsg_cancel; |
291 | if (nla_put_string(skb: msg, attrtype: DEVLINK_ATTR_PARAM_NAME, str: param->name)) |
292 | goto param_nest_cancel; |
293 | if (param->generic && nla_put_flag(skb: msg, attrtype: DEVLINK_ATTR_PARAM_GENERIC)) |
294 | goto param_nest_cancel; |
295 | |
296 | nla_type = devlink_param_type_to_nla_type(param_type: param->type); |
297 | if (nla_type < 0) |
298 | goto param_nest_cancel; |
299 | if (nla_put_u8(skb: msg, attrtype: DEVLINK_ATTR_PARAM_TYPE, value: nla_type)) |
300 | goto param_nest_cancel; |
301 | |
302 | param_values_list = nla_nest_start_noflag(skb: msg, |
303 | attrtype: DEVLINK_ATTR_PARAM_VALUES_LIST); |
304 | if (!param_values_list) |
305 | goto param_nest_cancel; |
306 | |
307 | for (i = 0; i <= DEVLINK_PARAM_CMODE_MAX; i++) { |
308 | if (!param_value_set[i]) |
309 | continue; |
310 | err = devlink_nl_param_value_fill_one(msg, type: param->type, |
311 | cmode: i, val: param_value[i]); |
312 | if (err) |
313 | goto values_list_nest_cancel; |
314 | } |
315 | |
316 | nla_nest_end(skb: msg, start: param_values_list); |
317 | nla_nest_end(skb: msg, start: param_attr); |
318 | genlmsg_end(skb: msg, hdr); |
319 | return 0; |
320 | |
321 | values_list_nest_cancel: |
322 | nla_nest_end(skb: msg, start: param_values_list); |
323 | param_nest_cancel: |
324 | nla_nest_cancel(skb: msg, start: param_attr); |
325 | genlmsg_cancel: |
326 | genlmsg_cancel(skb: msg, hdr); |
327 | return -EMSGSIZE; |
328 | } |
329 | |
330 | static void devlink_param_notify(struct devlink *devlink, |
331 | unsigned int port_index, |
332 | struct devlink_param_item *param_item, |
333 | enum devlink_command cmd) |
334 | { |
335 | struct sk_buff *msg; |
336 | int err; |
337 | |
338 | WARN_ON(cmd != DEVLINK_CMD_PARAM_NEW && cmd != DEVLINK_CMD_PARAM_DEL && |
339 | cmd != DEVLINK_CMD_PORT_PARAM_NEW && |
340 | cmd != DEVLINK_CMD_PORT_PARAM_DEL); |
341 | |
342 | /* devlink_notify_register() / devlink_notify_unregister() |
343 | * will replay the notifications if the params are added/removed |
344 | * outside of the lifetime of the instance. |
345 | */ |
346 | if (!devl_is_registered(devlink)) |
347 | return; |
348 | |
349 | msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); |
350 | if (!msg) |
351 | return; |
352 | err = devlink_nl_param_fill(msg, devlink, port_index, param_item, cmd, |
353 | portid: 0, seq: 0, flags: 0); |
354 | if (err) { |
355 | nlmsg_free(skb: msg); |
356 | return; |
357 | } |
358 | |
359 | genlmsg_multicast_netns(family: &devlink_nl_family, net: devlink_net(devlink), |
360 | skb: msg, portid: 0, group: DEVLINK_MCGRP_CONFIG, GFP_KERNEL); |
361 | } |
362 | |
363 | static void devlink_params_notify(struct devlink *devlink, |
364 | enum devlink_command cmd) |
365 | { |
366 | struct devlink_param_item *param_item; |
367 | unsigned long param_id; |
368 | |
369 | xa_for_each(&devlink->params, param_id, param_item) |
370 | devlink_param_notify(devlink, port_index: 0, param_item, cmd); |
371 | } |
372 | |
373 | void devlink_params_notify_register(struct devlink *devlink) |
374 | { |
375 | devlink_params_notify(devlink, cmd: DEVLINK_CMD_PARAM_NEW); |
376 | } |
377 | |
378 | void devlink_params_notify_unregister(struct devlink *devlink) |
379 | { |
380 | devlink_params_notify(devlink, cmd: DEVLINK_CMD_PARAM_DEL); |
381 | } |
382 | |
383 | static int devlink_nl_param_get_dump_one(struct sk_buff *msg, |
384 | struct devlink *devlink, |
385 | struct netlink_callback *cb, |
386 | int flags) |
387 | { |
388 | struct devlink_nl_dump_state *state = devlink_dump_state(cb); |
389 | struct devlink_param_item *param_item; |
390 | unsigned long param_id; |
391 | int err = 0; |
392 | |
393 | xa_for_each_start(&devlink->params, param_id, param_item, state->idx) { |
394 | err = devlink_nl_param_fill(msg, devlink, port_index: 0, param_item, |
395 | cmd: DEVLINK_CMD_PARAM_GET, |
396 | NETLINK_CB(cb->skb).portid, |
397 | seq: cb->nlh->nlmsg_seq, flags); |
398 | if (err == -EOPNOTSUPP) { |
399 | err = 0; |
400 | } else if (err) { |
401 | state->idx = param_id; |
402 | break; |
403 | } |
404 | } |
405 | |
406 | return err; |
407 | } |
408 | |
409 | int devlink_nl_param_get_dumpit(struct sk_buff *skb, |
410 | struct netlink_callback *cb) |
411 | { |
412 | return devlink_nl_dumpit(msg: skb, cb, dump_one: devlink_nl_param_get_dump_one); |
413 | } |
414 | |
415 | static int |
416 | devlink_param_type_get_from_info(struct genl_info *info, |
417 | enum devlink_param_type *param_type) |
418 | { |
419 | if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_PARAM_TYPE)) |
420 | return -EINVAL; |
421 | |
422 | switch (nla_get_u8(nla: info->attrs[DEVLINK_ATTR_PARAM_TYPE])) { |
423 | case NLA_U8: |
424 | *param_type = DEVLINK_PARAM_TYPE_U8; |
425 | break; |
426 | case NLA_U16: |
427 | *param_type = DEVLINK_PARAM_TYPE_U16; |
428 | break; |
429 | case NLA_U32: |
430 | *param_type = DEVLINK_PARAM_TYPE_U32; |
431 | break; |
432 | case NLA_STRING: |
433 | *param_type = DEVLINK_PARAM_TYPE_STRING; |
434 | break; |
435 | case NLA_FLAG: |
436 | *param_type = DEVLINK_PARAM_TYPE_BOOL; |
437 | break; |
438 | default: |
439 | return -EINVAL; |
440 | } |
441 | |
442 | return 0; |
443 | } |
444 | |
445 | static int |
446 | devlink_param_value_get_from_info(const struct devlink_param *param, |
447 | struct genl_info *info, |
448 | union devlink_param_value *value) |
449 | { |
450 | struct nlattr *param_data; |
451 | int len; |
452 | |
453 | param_data = info->attrs[DEVLINK_ATTR_PARAM_VALUE_DATA]; |
454 | |
455 | if (param->type != DEVLINK_PARAM_TYPE_BOOL && !param_data) |
456 | return -EINVAL; |
457 | |
458 | switch (param->type) { |
459 | case DEVLINK_PARAM_TYPE_U8: |
460 | if (nla_len(nla: param_data) != sizeof(u8)) |
461 | return -EINVAL; |
462 | value->vu8 = nla_get_u8(nla: param_data); |
463 | break; |
464 | case DEVLINK_PARAM_TYPE_U16: |
465 | if (nla_len(nla: param_data) != sizeof(u16)) |
466 | return -EINVAL; |
467 | value->vu16 = nla_get_u16(nla: param_data); |
468 | break; |
469 | case DEVLINK_PARAM_TYPE_U32: |
470 | if (nla_len(nla: param_data) != sizeof(u32)) |
471 | return -EINVAL; |
472 | value->vu32 = nla_get_u32(nla: param_data); |
473 | break; |
474 | case DEVLINK_PARAM_TYPE_STRING: |
475 | len = strnlen(p: nla_data(nla: param_data), maxlen: nla_len(nla: param_data)); |
476 | if (len == nla_len(nla: param_data) || |
477 | len >= __DEVLINK_PARAM_MAX_STRING_VALUE) |
478 | return -EINVAL; |
479 | strcpy(p: value->vstr, q: nla_data(nla: param_data)); |
480 | break; |
481 | case DEVLINK_PARAM_TYPE_BOOL: |
482 | if (param_data && nla_len(nla: param_data)) |
483 | return -EINVAL; |
484 | value->vbool = nla_get_flag(nla: param_data); |
485 | break; |
486 | } |
487 | return 0; |
488 | } |
489 | |
490 | static struct devlink_param_item * |
491 | devlink_param_get_from_info(struct xarray *params, struct genl_info *info) |
492 | { |
493 | char *param_name; |
494 | |
495 | if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_PARAM_NAME)) |
496 | return NULL; |
497 | |
498 | param_name = nla_data(nla: info->attrs[DEVLINK_ATTR_PARAM_NAME]); |
499 | return devlink_param_find_by_name(params, param_name); |
500 | } |
501 | |
502 | int devlink_nl_param_get_doit(struct sk_buff *skb, |
503 | struct genl_info *info) |
504 | { |
505 | struct devlink *devlink = info->user_ptr[0]; |
506 | struct devlink_param_item *param_item; |
507 | struct sk_buff *msg; |
508 | int err; |
509 | |
510 | param_item = devlink_param_get_from_info(params: &devlink->params, info); |
511 | if (!param_item) |
512 | return -EINVAL; |
513 | |
514 | msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); |
515 | if (!msg) |
516 | return -ENOMEM; |
517 | |
518 | err = devlink_nl_param_fill(msg, devlink, port_index: 0, param_item, |
519 | cmd: DEVLINK_CMD_PARAM_GET, |
520 | portid: info->snd_portid, seq: info->snd_seq, flags: 0); |
521 | if (err) { |
522 | nlmsg_free(skb: msg); |
523 | return err; |
524 | } |
525 | |
526 | return genlmsg_reply(skb: msg, info); |
527 | } |
528 | |
529 | static int __devlink_nl_cmd_param_set_doit(struct devlink *devlink, |
530 | unsigned int port_index, |
531 | struct xarray *params, |
532 | struct genl_info *info, |
533 | enum devlink_command cmd) |
534 | { |
535 | enum devlink_param_type param_type; |
536 | struct devlink_param_gset_ctx ctx; |
537 | enum devlink_param_cmode cmode; |
538 | struct devlink_param_item *param_item; |
539 | const struct devlink_param *param; |
540 | union devlink_param_value value; |
541 | int err = 0; |
542 | |
543 | param_item = devlink_param_get_from_info(params, info); |
544 | if (!param_item) |
545 | return -EINVAL; |
546 | param = param_item->param; |
547 | err = devlink_param_type_get_from_info(info, param_type: ¶m_type); |
548 | if (err) |
549 | return err; |
550 | if (param_type != param->type) |
551 | return -EINVAL; |
552 | err = devlink_param_value_get_from_info(param, info, value: &value); |
553 | if (err) |
554 | return err; |
555 | if (param->validate) { |
556 | err = param->validate(devlink, param->id, value, info->extack); |
557 | if (err) |
558 | return err; |
559 | } |
560 | |
561 | if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_PARAM_VALUE_CMODE)) |
562 | return -EINVAL; |
563 | cmode = nla_get_u8(nla: info->attrs[DEVLINK_ATTR_PARAM_VALUE_CMODE]); |
564 | if (!devlink_param_cmode_is_supported(param, cmode)) |
565 | return -EOPNOTSUPP; |
566 | |
567 | if (cmode == DEVLINK_PARAM_CMODE_DRIVERINIT) { |
568 | param_item->driverinit_value_new = value; |
569 | param_item->driverinit_value_new_valid = true; |
570 | } else { |
571 | if (!param->set) |
572 | return -EOPNOTSUPP; |
573 | ctx.val = value; |
574 | ctx.cmode = cmode; |
575 | err = devlink_param_set(devlink, param, ctx: &ctx); |
576 | if (err) |
577 | return err; |
578 | } |
579 | |
580 | devlink_param_notify(devlink, port_index, param_item, cmd); |
581 | return 0; |
582 | } |
583 | |
584 | int devlink_nl_param_set_doit(struct sk_buff *skb, struct genl_info *info) |
585 | { |
586 | struct devlink *devlink = info->user_ptr[0]; |
587 | |
588 | return __devlink_nl_cmd_param_set_doit(devlink, port_index: 0, params: &devlink->params, |
589 | info, cmd: DEVLINK_CMD_PARAM_NEW); |
590 | } |
591 | |
592 | int devlink_nl_port_param_get_dumpit(struct sk_buff *msg, |
593 | struct netlink_callback *cb) |
594 | { |
595 | NL_SET_ERR_MSG(cb->extack, "Port params are not supported" ); |
596 | return msg->len; |
597 | } |
598 | |
599 | int devlink_nl_port_param_get_doit(struct sk_buff *skb, |
600 | struct genl_info *info) |
601 | { |
602 | NL_SET_ERR_MSG(info->extack, "Port params are not supported" ); |
603 | return -EINVAL; |
604 | } |
605 | |
606 | int devlink_nl_port_param_set_doit(struct sk_buff *skb, |
607 | struct genl_info *info) |
608 | { |
609 | NL_SET_ERR_MSG(info->extack, "Port params are not supported" ); |
610 | return -EINVAL; |
611 | } |
612 | |
613 | static int devlink_param_verify(const struct devlink_param *param) |
614 | { |
615 | if (!param || !param->name || !param->supported_cmodes) |
616 | return -EINVAL; |
617 | if (param->generic) |
618 | return devlink_param_generic_verify(param); |
619 | else |
620 | return devlink_param_driver_verify(param); |
621 | } |
622 | |
623 | static int devlink_param_register(struct devlink *devlink, |
624 | const struct devlink_param *param) |
625 | { |
626 | struct devlink_param_item *param_item; |
627 | int err; |
628 | |
629 | WARN_ON(devlink_param_verify(param)); |
630 | WARN_ON(devlink_param_find_by_name(&devlink->params, param->name)); |
631 | |
632 | if (param->supported_cmodes == BIT(DEVLINK_PARAM_CMODE_DRIVERINIT)) |
633 | WARN_ON(param->get || param->set); |
634 | else |
635 | WARN_ON(!param->get || !param->set); |
636 | |
637 | param_item = kzalloc(size: sizeof(*param_item), GFP_KERNEL); |
638 | if (!param_item) |
639 | return -ENOMEM; |
640 | |
641 | param_item->param = param; |
642 | |
643 | err = xa_insert(xa: &devlink->params, index: param->id, entry: param_item, GFP_KERNEL); |
644 | if (err) |
645 | goto err_xa_insert; |
646 | |
647 | devlink_param_notify(devlink, port_index: 0, param_item, cmd: DEVLINK_CMD_PARAM_NEW); |
648 | return 0; |
649 | |
650 | err_xa_insert: |
651 | kfree(objp: param_item); |
652 | return err; |
653 | } |
654 | |
655 | static void devlink_param_unregister(struct devlink *devlink, |
656 | const struct devlink_param *param) |
657 | { |
658 | struct devlink_param_item *param_item; |
659 | |
660 | param_item = devlink_param_find_by_id(params: &devlink->params, param_id: param->id); |
661 | if (WARN_ON(!param_item)) |
662 | return; |
663 | devlink_param_notify(devlink, port_index: 0, param_item, cmd: DEVLINK_CMD_PARAM_DEL); |
664 | xa_erase(&devlink->params, index: param->id); |
665 | kfree(objp: param_item); |
666 | } |
667 | |
668 | /** |
669 | * devl_params_register - register configuration parameters |
670 | * |
671 | * @devlink: devlink |
672 | * @params: configuration parameters array |
673 | * @params_count: number of parameters provided |
674 | * |
675 | * Register the configuration parameters supported by the driver. |
676 | */ |
677 | int devl_params_register(struct devlink *devlink, |
678 | const struct devlink_param *params, |
679 | size_t params_count) |
680 | { |
681 | const struct devlink_param *param = params; |
682 | int i, err; |
683 | |
684 | lockdep_assert_held(&devlink->lock); |
685 | |
686 | for (i = 0; i < params_count; i++, param++) { |
687 | err = devlink_param_register(devlink, param); |
688 | if (err) |
689 | goto rollback; |
690 | } |
691 | return 0; |
692 | |
693 | rollback: |
694 | if (!i) |
695 | return err; |
696 | |
697 | for (param--; i > 0; i--, param--) |
698 | devlink_param_unregister(devlink, param); |
699 | return err; |
700 | } |
701 | EXPORT_SYMBOL_GPL(devl_params_register); |
702 | |
703 | int devlink_params_register(struct devlink *devlink, |
704 | const struct devlink_param *params, |
705 | size_t params_count) |
706 | { |
707 | int err; |
708 | |
709 | devl_lock(devlink); |
710 | err = devl_params_register(devlink, params, params_count); |
711 | devl_unlock(devlink); |
712 | return err; |
713 | } |
714 | EXPORT_SYMBOL_GPL(devlink_params_register); |
715 | |
716 | /** |
717 | * devl_params_unregister - unregister configuration parameters |
718 | * @devlink: devlink |
719 | * @params: configuration parameters to unregister |
720 | * @params_count: number of parameters provided |
721 | */ |
722 | void devl_params_unregister(struct devlink *devlink, |
723 | const struct devlink_param *params, |
724 | size_t params_count) |
725 | { |
726 | const struct devlink_param *param = params; |
727 | int i; |
728 | |
729 | lockdep_assert_held(&devlink->lock); |
730 | |
731 | for (i = 0; i < params_count; i++, param++) |
732 | devlink_param_unregister(devlink, param); |
733 | } |
734 | EXPORT_SYMBOL_GPL(devl_params_unregister); |
735 | |
736 | void devlink_params_unregister(struct devlink *devlink, |
737 | const struct devlink_param *params, |
738 | size_t params_count) |
739 | { |
740 | devl_lock(devlink); |
741 | devl_params_unregister(devlink, params, params_count); |
742 | devl_unlock(devlink); |
743 | } |
744 | EXPORT_SYMBOL_GPL(devlink_params_unregister); |
745 | |
746 | /** |
747 | * devl_param_driverinit_value_get - get configuration parameter |
748 | * value for driver initializing |
749 | * |
750 | * @devlink: devlink |
751 | * @param_id: parameter ID |
752 | * @val: pointer to store the value of parameter in driverinit |
753 | * configuration mode |
754 | * |
755 | * This function should be used by the driver to get driverinit |
756 | * configuration for initialization after reload command. |
757 | * |
758 | * Note that lockless call of this function relies on the |
759 | * driver to maintain following basic sane behavior: |
760 | * 1) Driver ensures a call to this function cannot race with |
761 | * registering/unregistering the parameter with the same parameter ID. |
762 | * 2) Driver ensures a call to this function cannot race with |
763 | * devl_param_driverinit_value_set() call with the same parameter ID. |
764 | * 3) Driver ensures a call to this function cannot race with |
765 | * reload operation. |
766 | * If the driver is not able to comply, it has to take the devlink->lock |
767 | * while calling this. |
768 | */ |
769 | int devl_param_driverinit_value_get(struct devlink *devlink, u32 param_id, |
770 | union devlink_param_value *val) |
771 | { |
772 | struct devlink_param_item *param_item; |
773 | |
774 | if (WARN_ON(!devlink_reload_supported(devlink->ops))) |
775 | return -EOPNOTSUPP; |
776 | |
777 | param_item = devlink_param_find_by_id(params: &devlink->params, param_id); |
778 | if (!param_item) |
779 | return -EINVAL; |
780 | |
781 | if (!param_item->driverinit_value_valid) |
782 | return -EOPNOTSUPP; |
783 | |
784 | if (WARN_ON(!devlink_param_cmode_is_supported(param_item->param, |
785 | DEVLINK_PARAM_CMODE_DRIVERINIT))) |
786 | return -EOPNOTSUPP; |
787 | |
788 | *val = param_item->driverinit_value; |
789 | |
790 | return 0; |
791 | } |
792 | EXPORT_SYMBOL_GPL(devl_param_driverinit_value_get); |
793 | |
794 | /** |
795 | * devl_param_driverinit_value_set - set value of configuration |
796 | * parameter for driverinit |
797 | * configuration mode |
798 | * |
799 | * @devlink: devlink |
800 | * @param_id: parameter ID |
801 | * @init_val: value of parameter to set for driverinit configuration mode |
802 | * |
803 | * This function should be used by the driver to set driverinit |
804 | * configuration mode default value. |
805 | */ |
806 | void devl_param_driverinit_value_set(struct devlink *devlink, u32 param_id, |
807 | union devlink_param_value init_val) |
808 | { |
809 | struct devlink_param_item *param_item; |
810 | |
811 | devl_assert_locked(devlink); |
812 | |
813 | param_item = devlink_param_find_by_id(params: &devlink->params, param_id); |
814 | if (WARN_ON(!param_item)) |
815 | return; |
816 | |
817 | if (WARN_ON(!devlink_param_cmode_is_supported(param_item->param, |
818 | DEVLINK_PARAM_CMODE_DRIVERINIT))) |
819 | return; |
820 | |
821 | param_item->driverinit_value = init_val; |
822 | param_item->driverinit_value_valid = true; |
823 | |
824 | devlink_param_notify(devlink, port_index: 0, param_item, cmd: DEVLINK_CMD_PARAM_NEW); |
825 | } |
826 | EXPORT_SYMBOL_GPL(devl_param_driverinit_value_set); |
827 | |
828 | void devlink_params_driverinit_load_new(struct devlink *devlink) |
829 | { |
830 | struct devlink_param_item *param_item; |
831 | unsigned long param_id; |
832 | |
833 | xa_for_each(&devlink->params, param_id, param_item) { |
834 | if (!devlink_param_cmode_is_supported(param: param_item->param, |
835 | cmode: DEVLINK_PARAM_CMODE_DRIVERINIT) || |
836 | !param_item->driverinit_value_new_valid) |
837 | continue; |
838 | param_item->driverinit_value = param_item->driverinit_value_new; |
839 | param_item->driverinit_value_valid = true; |
840 | param_item->driverinit_value_new_valid = false; |
841 | } |
842 | } |
843 | |
844 | /** |
845 | * devl_param_value_changed - notify devlink on a parameter's value |
846 | * change. Should be called by the driver |
847 | * right after the change. |
848 | * |
849 | * @devlink: devlink |
850 | * @param_id: parameter ID |
851 | * |
852 | * This function should be used by the driver to notify devlink on value |
853 | * change, excluding driverinit configuration mode. |
854 | * For driverinit configuration mode driver should use the function |
855 | */ |
856 | void devl_param_value_changed(struct devlink *devlink, u32 param_id) |
857 | { |
858 | struct devlink_param_item *param_item; |
859 | |
860 | param_item = devlink_param_find_by_id(params: &devlink->params, param_id); |
861 | WARN_ON(!param_item); |
862 | |
863 | devlink_param_notify(devlink, port_index: 0, param_item, cmd: DEVLINK_CMD_PARAM_NEW); |
864 | } |
865 | EXPORT_SYMBOL_GPL(devl_param_value_changed); |
866 | |