projects/linux·blob v6.7 · refs

1425 lines · 37.2 KiB

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 <[email protected]>
5 */
6
7#include <net/genetlink.h>
8#include <net/sock.h>
9#include "devl_internal.h"
10
11struct devlink_info_req {
12 struct sk_buff *msg;
13 void (*version_cb)(const char *version_name,
14 enum devlink_info_version_type version_type,
15 void *version_cb_priv);
16 void *version_cb_priv;
17};
18
19struct devlink_reload_combination {
20 enum devlink_reload_action action;
21 enum devlink_reload_limit limit;
22};
23
24static const struct devlink_reload_combination devlink_reload_invalid_combinations[] = {
25 {
26 /* can't reinitialize driver with no down time */
27 .action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
28 .limit = DEVLINK_RELOAD_LIMIT_NO_RESET,
29 },
30};
31
32static bool
33devlink_reload_combination_is_invalid(enum devlink_reload_action action,
34 enum devlink_reload_limit limit)
35{
36 int i;
37
38 for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++)
39 if (devlink_reload_invalid_combinations[i].action == action &&
40 devlink_reload_invalid_combinations[i].limit == limit)
41 return true;
42 return false;
43}
44
45static bool
46devlink_reload_action_is_supported(struct devlink *devlink, enum devlink_reload_action action)
47{
48 return test_bit(action, &devlink->ops->reload_actions);
49}
50
51static bool
52devlink_reload_limit_is_supported(struct devlink *devlink, enum devlink_reload_limit limit)
53{
54 return test_bit(limit, &devlink->ops->reload_limits);
55}
56
57static int devlink_reload_stat_put(struct sk_buff *msg,
58 enum devlink_reload_limit limit, u32 value)
59{
60 struct nlattr *reload_stats_entry;
61
62 reload_stats_entry = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_STATS_ENTRY);
63 if (!reload_stats_entry)
64 return -EMSGSIZE;
65
66 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_STATS_LIMIT, limit) ||
67 nla_put_u32(msg, DEVLINK_ATTR_RELOAD_STATS_VALUE, value))
68 goto nla_put_failure;
69 nla_nest_end(msg, reload_stats_entry);
70 return 0;
71
72nla_put_failure:
73 nla_nest_cancel(msg, reload_stats_entry);
74 return -EMSGSIZE;
75}
76
77static int
78devlink_reload_stats_put(struct sk_buff *msg, struct devlink *devlink, bool is_remote)
79{
80 struct nlattr *reload_stats_attr, *act_info, *act_stats;
81 int i, j, stat_idx;
82 u32 value;
83
84 if (!is_remote)
85 reload_stats_attr = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_STATS);
86 else
87 reload_stats_attr = nla_nest_start(msg, DEVLINK_ATTR_REMOTE_RELOAD_STATS);
88
89 if (!reload_stats_attr)
90 return -EMSGSIZE;
91
92 for (i = 0; i <= DEVLINK_RELOAD_ACTION_MAX; i++) {
93 if ((!is_remote &&
94 !devlink_reload_action_is_supported(devlink, i)) ||
95 i == DEVLINK_RELOAD_ACTION_UNSPEC)
96 continue;
97 act_info = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_ACTION_INFO);
98 if (!act_info)
99 goto nla_put_failure;
100
101 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_ACTION, i))
102 goto action_info_nest_cancel;
103 act_stats = nla_nest_start(msg, DEVLINK_ATTR_RELOAD_ACTION_STATS);
104 if (!act_stats)
105 goto action_info_nest_cancel;
106
107 for (j = 0; j <= DEVLINK_RELOAD_LIMIT_MAX; j++) {
108 /* Remote stats are shown even if not locally supported.
109 * Stats of actions with unspecified limit are shown
110 * though drivers don't need to register unspecified
111 * limit.
112 */
113 if ((!is_remote && j != DEVLINK_RELOAD_LIMIT_UNSPEC &&
114 !devlink_reload_limit_is_supported(devlink, j)) ||
115 devlink_reload_combination_is_invalid(i, j))
116 continue;
117
118 stat_idx = j * __DEVLINK_RELOAD_ACTION_MAX + i;
119 if (!is_remote)
120 value = devlink->stats.reload_stats[stat_idx];
121 else
122 value = devlink->stats.remote_reload_stats[stat_idx];
123 if (devlink_reload_stat_put(msg, j, value))
124 goto action_stats_nest_cancel;
125 }
126 nla_nest_end(msg, act_stats);
127 nla_nest_end(msg, act_info);
128 }
129 nla_nest_end(msg, reload_stats_attr);
130 return 0;
131
132action_stats_nest_cancel:
133 nla_nest_cancel(msg, act_stats);
134action_info_nest_cancel:
135 nla_nest_cancel(msg, act_info);
136nla_put_failure:
137 nla_nest_cancel(msg, reload_stats_attr);
138 return -EMSGSIZE;
139}
140
141static int devlink_nl_nested_fill(struct sk_buff *msg, struct devlink *devlink)
142{
143 unsigned long rel_index;
144 void *unused;
145 int err;
146
147 xa_for_each(&devlink->nested_rels, rel_index, unused) {
148 err = devlink_rel_devlink_handle_put(msg, devlink,
149 rel_index,
150 DEVLINK_ATTR_NESTED_DEVLINK,
151 NULL);
152 if (err)
153 return err;
154 }
155 return 0;
156}
157
158static int devlink_nl_fill(struct sk_buff *msg, struct devlink *devlink,
159 enum devlink_command cmd, u32 portid,
160 u32 seq, int flags)
161{
162 struct nlattr *dev_stats;
163 void *hdr;
164
165 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
166 if (!hdr)
167 return -EMSGSIZE;
168
169 if (devlink_nl_put_handle(msg, devlink))
170 goto nla_put_failure;
171 if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_FAILED, devlink->reload_failed))
172 goto nla_put_failure;
173
174 dev_stats = nla_nest_start(msg, DEVLINK_ATTR_DEV_STATS);
175 if (!dev_stats)
176 goto nla_put_failure;
177
178 if (devlink_reload_stats_put(msg, devlink, false))
179 goto dev_stats_nest_cancel;
180 if (devlink_reload_stats_put(msg, devlink, true))
181 goto dev_stats_nest_cancel;
182
183 nla_nest_end(msg, dev_stats);
184
185 if (devlink_nl_nested_fill(msg, devlink))
186 goto nla_put_failure;
187
188 genlmsg_end(msg, hdr);
189 return 0;
190
191dev_stats_nest_cancel:
192 nla_nest_cancel(msg, dev_stats);
193nla_put_failure:
194 genlmsg_cancel(msg, hdr);
195 return -EMSGSIZE;
196}
197
198static void devlink_notify(struct devlink *devlink, enum devlink_command cmd)
199{
200 struct sk_buff *msg;
201 int err;
202
203 WARN_ON(cmd != DEVLINK_CMD_NEW && cmd != DEVLINK_CMD_DEL);
204 WARN_ON(!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED));
205
206 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
207 if (!msg)
208 return;
209
210 err = devlink_nl_fill(msg, devlink, cmd, 0, 0, 0);
211 if (err) {
212 nlmsg_free(msg);
213 return;
214 }
215
216 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
217 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
218}
219
220int devlink_nl_get_doit(struct sk_buff *skb, struct genl_info *info)
221{
222 struct devlink *devlink = info->user_ptr[0];
223 struct sk_buff *msg;
224 int err;
225
226 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
227 if (!msg)
228 return -ENOMEM;
229
230 err = devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
231 info->snd_portid, info->snd_seq, 0);
232 if (err) {
233 nlmsg_free(msg);
234 return err;
235 }
236
237 return genlmsg_reply(msg, info);
238}
239
240static int
241devlink_nl_get_dump_one(struct sk_buff *msg, struct devlink *devlink,
242 struct netlink_callback *cb, int flags)
243{
244 return devlink_nl_fill(msg, devlink, DEVLINK_CMD_NEW,
245 NETLINK_CB(cb->skb).portid,
246 cb->nlh->nlmsg_seq, flags);
247}
248
249int devlink_nl_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
250{
251 return devlink_nl_dumpit(msg, cb, devlink_nl_get_dump_one);
252}
253
254static void devlink_rel_notify_cb(struct devlink *devlink, u32 obj_index)
255{
256 devlink_notify(devlink, DEVLINK_CMD_NEW);
257}
258
259static void devlink_rel_cleanup_cb(struct devlink *devlink, u32 obj_index,
260 u32 rel_index)
261{
262 xa_erase(&devlink->nested_rels, rel_index);
263}
264
265int devl_nested_devlink_set(struct devlink *devlink,
266 struct devlink *nested_devlink)
267{
268 u32 rel_index;
269 int err;
270
271 err = devlink_rel_nested_in_add(&rel_index, devlink->index, 0,
272 devlink_rel_notify_cb,
273 devlink_rel_cleanup_cb,
274 nested_devlink);
275 if (err)
276 return err;
277 return xa_insert(&devlink->nested_rels, rel_index,
278 xa_mk_value(0), GFP_KERNEL);
279}
280EXPORT_SYMBOL_GPL(devl_nested_devlink_set);
281
282void devlink_notify_register(struct devlink *devlink)
283{
284 devlink_notify(devlink, DEVLINK_CMD_NEW);
285 devlink_linecards_notify_register(devlink);
286 devlink_ports_notify_register(devlink);
287 devlink_trap_policers_notify_register(devlink);
288 devlink_trap_groups_notify_register(devlink);
289 devlink_traps_notify_register(devlink);
290 devlink_rates_notify_register(devlink);
291 devlink_regions_notify_register(devlink);
292 devlink_params_notify_register(devlink);
293}
294
295void devlink_notify_unregister(struct devlink *devlink)
296{
297 devlink_params_notify_unregister(devlink);
298 devlink_regions_notify_unregister(devlink);
299 devlink_rates_notify_unregister(devlink);
300 devlink_traps_notify_unregister(devlink);
301 devlink_trap_groups_notify_unregister(devlink);
302 devlink_trap_policers_notify_unregister(devlink);
303 devlink_ports_notify_unregister(devlink);
304 devlink_linecards_notify_unregister(devlink);
305 devlink_notify(devlink, DEVLINK_CMD_DEL);
306}
307
308static void devlink_reload_failed_set(struct devlink *devlink,
309 bool reload_failed)
310{
311 if (devlink->reload_failed == reload_failed)
312 return;
313 devlink->reload_failed = reload_failed;
314 devlink_notify(devlink, DEVLINK_CMD_NEW);
315}
316
317bool devlink_is_reload_failed(const struct devlink *devlink)
318{
319 return devlink->reload_failed;
320}
321EXPORT_SYMBOL_GPL(devlink_is_reload_failed);
322
323static void
324__devlink_reload_stats_update(struct devlink *devlink, u32 *reload_stats,
325 enum devlink_reload_limit limit, u32 actions_performed)
326{
327 unsigned long actions = actions_performed;
328 int stat_idx;
329 int action;
330
331 for_each_set_bit(action, &actions, __DEVLINK_RELOAD_ACTION_MAX) {
332 stat_idx = limit * __DEVLINK_RELOAD_ACTION_MAX + action;
333 reload_stats[stat_idx]++;
334 }
335 devlink_notify(devlink, DEVLINK_CMD_NEW);
336}
337
338static void
339devlink_reload_stats_update(struct devlink *devlink, enum devlink_reload_limit limit,
340 u32 actions_performed)
341{
342 __devlink_reload_stats_update(devlink, devlink->stats.reload_stats, limit,
343 actions_performed);
344}
345
346/**
347 * devlink_remote_reload_actions_performed - Update devlink on reload actions
348 * performed which are not a direct result of devlink reload call.
349 *
350 * This should be called by a driver after performing reload actions in case it was not
351 * a result of devlink reload call. For example fw_activate was performed as a result
352 * of devlink reload triggered fw_activate on another host.
353 * The motivation for this function is to keep data on reload actions performed on this
354 * function whether it was done due to direct devlink reload call or not.
355 *
356 * @devlink: devlink
357 * @limit: reload limit
358 * @actions_performed: bitmask of actions performed
359 */
360void devlink_remote_reload_actions_performed(struct devlink *devlink,
361 enum devlink_reload_limit limit,
362 u32 actions_performed)
363{
364 if (WARN_ON(!actions_performed ||
365 actions_performed & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
366 actions_performed >= BIT(__DEVLINK_RELOAD_ACTION_MAX) ||
367 limit > DEVLINK_RELOAD_LIMIT_MAX))
368 return;
369
370 __devlink_reload_stats_update(devlink, devlink->stats.remote_reload_stats, limit,
371 actions_performed);
372}
373EXPORT_SYMBOL_GPL(devlink_remote_reload_actions_performed);
374
375static struct net *devlink_netns_get(struct sk_buff *skb,
376 struct genl_info *info)
377{
378 struct nlattr *netns_pid_attr = info->attrs[DEVLINK_ATTR_NETNS_PID];
379 struct nlattr *netns_fd_attr = info->attrs[DEVLINK_ATTR_NETNS_FD];
380 struct nlattr *netns_id_attr = info->attrs[DEVLINK_ATTR_NETNS_ID];
381 struct net *net;
382
383 if (!!netns_pid_attr + !!netns_fd_attr + !!netns_id_attr > 1) {
384 NL_SET_ERR_MSG(info->extack, "multiple netns identifying attributes specified");
385 return ERR_PTR(-EINVAL);
386 }
387
388 if (netns_pid_attr) {
389 net = get_net_ns_by_pid(nla_get_u32(netns_pid_attr));
390 } else if (netns_fd_attr) {
391 net = get_net_ns_by_fd(nla_get_u32(netns_fd_attr));
392 } else if (netns_id_attr) {
393 net = get_net_ns_by_id(sock_net(skb->sk),
394 nla_get_u32(netns_id_attr));
395 if (!net)
396 net = ERR_PTR(-EINVAL);
397 } else {
398 WARN_ON(1);
399 net = ERR_PTR(-EINVAL);
400 }
401 if (IS_ERR(net)) {
402 NL_SET_ERR_MSG(info->extack, "Unknown network namespace");
403 return ERR_PTR(-EINVAL);
404 }
405 if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
406 put_net(net);
407 return ERR_PTR(-EPERM);
408 }
409 return net;
410}
411
412static void devlink_reload_netns_change(struct devlink *devlink,
413 struct net *curr_net,
414 struct net *dest_net)
415{
416 /* Userspace needs to be notified about devlink objects
417 * removed from original and entering new network namespace.
418 * The rest of the devlink objects are re-created during
419 * reload process so the notifications are generated separatelly.
420 */
421 devlink_notify_unregister(devlink);
422 write_pnet(&devlink->_net, dest_net);
423 devlink_notify_register(devlink);
424 devlink_rel_nested_in_notify(devlink);
425}
426
427int devlink_reload(struct devlink *devlink, struct net *dest_net,
428 enum devlink_reload_action action,
429 enum devlink_reload_limit limit,
430 u32 *actions_performed, struct netlink_ext_ack *extack)
431{
432 u32 remote_reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE];
433 struct net *curr_net;
434 int err;
435
436 memcpy(remote_reload_stats, devlink->stats.remote_reload_stats,
437 sizeof(remote_reload_stats));
438
439 err = devlink->ops->reload_down(devlink, !!dest_net, action, limit, extack);
440 if (err)
441 return err;
442
443 curr_net = devlink_net(devlink);
444 if (dest_net && !net_eq(dest_net, curr_net))
445 devlink_reload_netns_change(devlink, curr_net, dest_net);
446
447 if (action == DEVLINK_RELOAD_ACTION_DRIVER_REINIT)
448 devlink_params_driverinit_load_new(devlink);
449
450 err = devlink->ops->reload_up(devlink, action, limit, actions_performed, extack);
451 devlink_reload_failed_set(devlink, !!err);
452 if (err)
453 return err;
454
455 WARN_ON(!(*actions_performed & BIT(action)));
456 /* Catch driver on updating the remote action within devlink reload */
457 WARN_ON(memcmp(remote_reload_stats, devlink->stats.remote_reload_stats,
458 sizeof(remote_reload_stats)));
459 devlink_reload_stats_update(devlink, limit, *actions_performed);
460 return 0;
461}
462
463static int
464devlink_nl_reload_actions_performed_snd(struct devlink *devlink, u32 actions_performed,
465 enum devlink_command cmd, struct genl_info *info)
466{
467 struct sk_buff *msg;
468 void *hdr;
469
470 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
471 if (!msg)
472 return -ENOMEM;
473
474 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, &devlink_nl_family, 0, cmd);
475 if (!hdr)
476 goto free_msg;
477
478 if (devlink_nl_put_handle(msg, devlink))
479 goto nla_put_failure;
480
481 if (nla_put_bitfield32(msg, DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED, actions_performed,
482 actions_performed))
483 goto nla_put_failure;
484 genlmsg_end(msg, hdr);
485
486 return genlmsg_reply(msg, info);
487
488nla_put_failure:
489 genlmsg_cancel(msg, hdr);
490free_msg:
491 nlmsg_free(msg);
492 return -EMSGSIZE;
493}
494
495int devlink_nl_reload_doit(struct sk_buff *skb, struct genl_info *info)
496{
497 struct devlink *devlink = info->user_ptr[0];
498 enum devlink_reload_action action;
499 enum devlink_reload_limit limit;
500 struct net *dest_net = NULL;
501 u32 actions_performed;
502 int err;
503
504 err = devlink_resources_validate(devlink, NULL, info);
505 if (err) {
506 NL_SET_ERR_MSG(info->extack, "resources size validation failed");
507 return err;
508 }
509
510 if (info->attrs[DEVLINK_ATTR_RELOAD_ACTION])
511 action = nla_get_u8(info->attrs[DEVLINK_ATTR_RELOAD_ACTION]);
512 else
513 action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT;
514
515 if (!devlink_reload_action_is_supported(devlink, action)) {
516 NL_SET_ERR_MSG(info->extack, "Requested reload action is not supported by the driver");
517 return -EOPNOTSUPP;
518 }
519
520 limit = DEVLINK_RELOAD_LIMIT_UNSPEC;
521 if (info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]) {
522 struct nla_bitfield32 limits;
523 u32 limits_selected;
524
525 limits = nla_get_bitfield32(info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]);
526 limits_selected = limits.value & limits.selector;
527 if (!limits_selected) {
528 NL_SET_ERR_MSG(info->extack, "Invalid limit selected");
529 return -EINVAL;
530 }
531 for (limit = 0 ; limit <= DEVLINK_RELOAD_LIMIT_MAX ; limit++)
532 if (limits_selected & BIT(limit))
533 break;
534 /* UAPI enables multiselection, but currently it is not used */
535 if (limits_selected != BIT(limit)) {
536 NL_SET_ERR_MSG(info->extack, "Multiselection of limit is not supported");
537 return -EOPNOTSUPP;
538 }
539 if (!devlink_reload_limit_is_supported(devlink, limit)) {
540 NL_SET_ERR_MSG(info->extack, "Requested limit is not supported by the driver");
541 return -EOPNOTSUPP;
542 }
543 if (devlink_reload_combination_is_invalid(action, limit)) {
544 NL_SET_ERR_MSG(info->extack, "Requested limit is invalid for this action");
545 return -EINVAL;
546 }
547 }
548 if (info->attrs[DEVLINK_ATTR_NETNS_PID] ||
549 info->attrs[DEVLINK_ATTR_NETNS_FD] ||
550 info->attrs[DEVLINK_ATTR_NETNS_ID]) {
551 dest_net = devlink_netns_get(skb, info);
552 if (IS_ERR(dest_net))
553 return PTR_ERR(dest_net);
554 if (!net_eq(dest_net, devlink_net(devlink)) &&
555 action != DEVLINK_RELOAD_ACTION_DRIVER_REINIT) {
556 NL_SET_ERR_MSG_MOD(info->extack,
557 "Changing namespace is only supported for reinit action");
558 return -EOPNOTSUPP;
559 }
560 }
561
562 err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack);
563
564 if (dest_net)
565 put_net(dest_net);
566
567 if (err)
568 return err;
569 /* For backward compatibility generate reply only if attributes used by user */
570 if (!info->attrs[DEVLINK_ATTR_RELOAD_ACTION] && !info->attrs[DEVLINK_ATTR_RELOAD_LIMITS])
571 return 0;
572
573 return devlink_nl_reload_actions_performed_snd(devlink, actions_performed,
574 DEVLINK_CMD_RELOAD, info);
575}
576
577bool devlink_reload_actions_valid(const struct devlink_ops *ops)
578{
579 const struct devlink_reload_combination *comb;
580 int i;
581
582 if (!devlink_reload_supported(ops)) {
583 if (WARN_ON(ops->reload_actions))
584 return false;
585 return true;
586 }
587
588 if (WARN_ON(!ops->reload_actions ||
589 ops->reload_actions & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) ||
590 ops->reload_actions >= BIT(__DEVLINK_RELOAD_ACTION_MAX)))
591 return false;
592
593 if (WARN_ON(ops->reload_limits & BIT(DEVLINK_RELOAD_LIMIT_UNSPEC) ||
594 ops->reload_limits >= BIT(__DEVLINK_RELOAD_LIMIT_MAX)))
595 return false;
596
597 for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++) {
598 comb = &devlink_reload_invalid_combinations[i];
599 if (ops->reload_actions == BIT(comb->action) &&
600 ops->reload_limits == BIT(comb->limit))
601 return false;
602 }
603 return true;
604}
605
606static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink,
607 enum devlink_command cmd, u32 portid,
608 u32 seq, int flags)
609{
610 const struct devlink_ops *ops = devlink->ops;
611 enum devlink_eswitch_encap_mode encap_mode;
612 u8 inline_mode;
613 void *hdr;
614 int err = 0;
615 u16 mode;
616
617 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
618 if (!hdr)
619 return -EMSGSIZE;
620
621 err = devlink_nl_put_handle(msg, devlink);
622 if (err)
623 goto nla_put_failure;
624
625 if (ops->eswitch_mode_get) {
626 err = ops->eswitch_mode_get(devlink, &mode);
627 if (err)
628 goto nla_put_failure;
629 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode);
630 if (err)
631 goto nla_put_failure;
632 }
633
634 if (ops->eswitch_inline_mode_get) {
635 err = ops->eswitch_inline_mode_get(devlink, &inline_mode);
636 if (err)
637 goto nla_put_failure;
638 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE,
639 inline_mode);
640 if (err)
641 goto nla_put_failure;
642 }
643
644 if (ops->eswitch_encap_mode_get) {
645 err = ops->eswitch_encap_mode_get(devlink, &encap_mode);
646 if (err)
647 goto nla_put_failure;
648 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode);
649 if (err)
650 goto nla_put_failure;
651 }
652
653 genlmsg_end(msg, hdr);
654 return 0;
655
656nla_put_failure:
657 genlmsg_cancel(msg, hdr);
658 return err;
659}
660
661int devlink_nl_eswitch_get_doit(struct sk_buff *skb, struct genl_info *info)
662{
663 struct devlink *devlink = info->user_ptr[0];
664 struct sk_buff *msg;
665 int err;
666
667 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
668 if (!msg)
669 return -ENOMEM;
670
671 err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET,
672 info->snd_portid, info->snd_seq, 0);
673
674 if (err) {
675 nlmsg_free(msg);
676 return err;
677 }
678
679 return genlmsg_reply(msg, info);
680}
681
682int devlink_nl_eswitch_set_doit(struct sk_buff *skb, struct genl_info *info)
683{
684 struct devlink *devlink = info->user_ptr[0];
685 const struct devlink_ops *ops = devlink->ops;
686 enum devlink_eswitch_encap_mode encap_mode;
687 u8 inline_mode;
688 int err = 0;
689 u16 mode;
690
691 if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) {
692 if (!ops->eswitch_mode_set)
693 return -EOPNOTSUPP;
694 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]);
695 err = devlink_rate_nodes_check(devlink, mode, info->extack);
696 if (err)
697 return err;
698 err = ops->eswitch_mode_set(devlink, mode, info->extack);
699 if (err)
700 return err;
701 }
702
703 if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
704 if (!ops->eswitch_inline_mode_set)
705 return -EOPNOTSUPP;
706 inline_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]);
707 err = ops->eswitch_inline_mode_set(devlink, inline_mode,
708 info->extack);
709 if (err)
710 return err;
711 }
712
713 if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
714 if (!ops->eswitch_encap_mode_set)
715 return -EOPNOTSUPP;
716 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
717 err = ops->eswitch_encap_mode_set(devlink, encap_mode,
718 info->extack);
719 if (err)
720 return err;
721 }
722
723 return 0;
724}
725
726int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn)
727{
728 if (!req->msg)
729 return 0;
730 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_SERIAL_NUMBER, sn);
731}
732EXPORT_SYMBOL_GPL(devlink_info_serial_number_put);
733
734int devlink_info_board_serial_number_put(struct devlink_info_req *req,
735 const char *bsn)
736{
737 if (!req->msg)
738 return 0;
739 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER,
740 bsn);
741}
742EXPORT_SYMBOL_GPL(devlink_info_board_serial_number_put);
743
744static int devlink_info_version_put(struct devlink_info_req *req, int attr,
745 const char *version_name,
746 const char *version_value,
747 enum devlink_info_version_type version_type)
748{
749 struct nlattr *nest;
750 int err;
751
752 if (req->version_cb)
753 req->version_cb(version_name, version_type,
754 req->version_cb_priv);
755
756 if (!req->msg)
757 return 0;
758
759 nest = nla_nest_start_noflag(req->msg, attr);
760 if (!nest)
761 return -EMSGSIZE;
762
763 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_NAME,
764 version_name);
765 if (err)
766 goto nla_put_failure;
767
768 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_VALUE,
769 version_value);
770 if (err)
771 goto nla_put_failure;
772
773 nla_nest_end(req->msg, nest);
774
775 return 0;
776
777nla_put_failure:
778 nla_nest_cancel(req->msg, nest);
779 return err;
780}
781
782int devlink_info_version_fixed_put(struct devlink_info_req *req,
783 const char *version_name,
784 const char *version_value)
785{
786 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_FIXED,
787 version_name, version_value,
788 DEVLINK_INFO_VERSION_TYPE_NONE);
789}
790EXPORT_SYMBOL_GPL(devlink_info_version_fixed_put);
791
792int devlink_info_version_stored_put(struct devlink_info_req *req,
793 const char *version_name,
794 const char *version_value)
795{
796 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED,
797 version_name, version_value,
798 DEVLINK_INFO_VERSION_TYPE_NONE);
799}
800EXPORT_SYMBOL_GPL(devlink_info_version_stored_put);
801
802int devlink_info_version_stored_put_ext(struct devlink_info_req *req,
803 const char *version_name,
804 const char *version_value,
805 enum devlink_info_version_type version_type)
806{
807 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED,
808 version_name, version_value,
809 version_type);
810}
811EXPORT_SYMBOL_GPL(devlink_info_version_stored_put_ext);
812
813int devlink_info_version_running_put(struct devlink_info_req *req,
814 const char *version_name,
815 const char *version_value)
816{
817 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING,
818 version_name, version_value,
819 DEVLINK_INFO_VERSION_TYPE_NONE);
820}
821EXPORT_SYMBOL_GPL(devlink_info_version_running_put);
822
823int devlink_info_version_running_put_ext(struct devlink_info_req *req,
824 const char *version_name,
825 const char *version_value,
826 enum devlink_info_version_type version_type)
827{
828 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING,
829 version_name, version_value,
830 version_type);
831}
832EXPORT_SYMBOL_GPL(devlink_info_version_running_put_ext);
833
834static int devlink_nl_driver_info_get(struct device_driver *drv,
835 struct devlink_info_req *req)
836{
837 if (!drv)
838 return 0;
839
840 if (drv->name[0])
841 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_DRIVER_NAME,
842 drv->name);
843
844 return 0;
845}
846
847static int
848devlink_nl_info_fill(struct sk_buff *msg, struct devlink *devlink,
849 enum devlink_command cmd, u32 portid,
850 u32 seq, int flags, struct netlink_ext_ack *extack)
851{
852 struct device *dev = devlink_to_dev(devlink);
853 struct devlink_info_req req = {};
854 void *hdr;
855 int err;
856
857 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
858 if (!hdr)
859 return -EMSGSIZE;
860
861 err = -EMSGSIZE;
862 if (devlink_nl_put_handle(msg, devlink))
863 goto err_cancel_msg;
864
865 req.msg = msg;
866 if (devlink->ops->info_get) {
867 err = devlink->ops->info_get(devlink, &req, extack);
868 if (err)
869 goto err_cancel_msg;
870 }
871
872 err = devlink_nl_driver_info_get(dev->driver, &req);
873 if (err)
874 goto err_cancel_msg;
875
876 genlmsg_end(msg, hdr);
877 return 0;
878
879err_cancel_msg:
880 genlmsg_cancel(msg, hdr);
881 return err;
882}
883
884int devlink_nl_info_get_doit(struct sk_buff *skb, struct genl_info *info)
885{
886 struct devlink *devlink = info->user_ptr[0];
887 struct sk_buff *msg;
888 int err;
889
890 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
891 if (!msg)
892 return -ENOMEM;
893
894 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
895 info->snd_portid, info->snd_seq, 0,
896 info->extack);
897 if (err) {
898 nlmsg_free(msg);
899 return err;
900 }
901
902 return genlmsg_reply(msg, info);
903}
904
905static int
906devlink_nl_info_get_dump_one(struct sk_buff *msg, struct devlink *devlink,
907 struct netlink_callback *cb, int flags)
908{
909 int err;
910
911 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET,
912 NETLINK_CB(cb->skb).portid,
913 cb->nlh->nlmsg_seq, flags,
914 cb->extack);
915 if (err == -EOPNOTSUPP)
916 err = 0;
917 return err;
918}
919
920int devlink_nl_info_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb)
921{
922 return devlink_nl_dumpit(msg, cb, devlink_nl_info_get_dump_one);
923}
924
925static int devlink_nl_flash_update_fill(struct sk_buff *msg,
926 struct devlink *devlink,
927 enum devlink_command cmd,
928 struct devlink_flash_notify *params)
929{
930 void *hdr;
931
932 hdr = genlmsg_put(msg, 0, 0, &devlink_nl_family, 0, cmd);
933 if (!hdr)
934 return -EMSGSIZE;
935
936 if (devlink_nl_put_handle(msg, devlink))
937 goto nla_put_failure;
938
939 if (cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS)
940 goto out;
941
942 if (params->status_msg &&
943 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG,
944 params->status_msg))
945 goto nla_put_failure;
946 if (params->component &&
947 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_COMPONENT,
948 params->component))
949 goto nla_put_failure;
950 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE,
951 params->done, DEVLINK_ATTR_PAD))
952 goto nla_put_failure;
953 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL,
954 params->total, DEVLINK_ATTR_PAD))
955 goto nla_put_failure;
956 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT,
957 params->timeout, DEVLINK_ATTR_PAD))
958 goto nla_put_failure;
959
960out:
961 genlmsg_end(msg, hdr);
962 return 0;
963
964nla_put_failure:
965 genlmsg_cancel(msg, hdr);
966 return -EMSGSIZE;
967}
968
969static void __devlink_flash_update_notify(struct devlink *devlink,
970 enum devlink_command cmd,
971 struct devlink_flash_notify *params)
972{
973 struct sk_buff *msg;
974 int err;
975
976 WARN_ON(cmd != DEVLINK_CMD_FLASH_UPDATE &&
977 cmd != DEVLINK_CMD_FLASH_UPDATE_END &&
978 cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS);
979
980 if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED))
981 return;
982
983 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
984 if (!msg)
985 return;
986
987 err = devlink_nl_flash_update_fill(msg, devlink, cmd, params);
988 if (err)
989 goto out_free_msg;
990
991 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
992 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
993 return;
994
995out_free_msg:
996 nlmsg_free(msg);
997}
998
999static void devlink_flash_update_begin_notify(struct devlink *devlink)
1000{
1001 struct devlink_flash_notify params = {};
1002
1003 __devlink_flash_update_notify(devlink,
1004 DEVLINK_CMD_FLASH_UPDATE,
1005 &params);
1006}
1007
1008static void devlink_flash_update_end_notify(struct devlink *devlink)
1009{
1010 struct devlink_flash_notify params = {};
1011
1012 __devlink_flash_update_notify(devlink,
1013 DEVLINK_CMD_FLASH_UPDATE_END,
1014 &params);
1015}
1016
1017void devlink_flash_update_status_notify(struct devlink *devlink,
1018 const char *status_msg,
1019 const char *component,
1020 unsigned long done,
1021 unsigned long total)
1022{
1023 struct devlink_flash_notify params = {
1024 .status_msg = status_msg,
1025 .component = component,
1026 .done = done,
1027 .total = total,
1028 };
1029
1030 __devlink_flash_update_notify(devlink,
1031 DEVLINK_CMD_FLASH_UPDATE_STATUS,
1032 &params);
1033}
1034EXPORT_SYMBOL_GPL(devlink_flash_update_status_notify);
1035
1036void devlink_flash_update_timeout_notify(struct devlink *devlink,
1037 const char *status_msg,
1038 const char *component,
1039 unsigned long timeout)
1040{
1041 struct devlink_flash_notify params = {
1042 .status_msg = status_msg,
1043 .component = component,
1044 .timeout = timeout,
1045 };
1046
1047 __devlink_flash_update_notify(devlink,
1048 DEVLINK_CMD_FLASH_UPDATE_STATUS,
1049 &params);
1050}
1051EXPORT_SYMBOL_GPL(devlink_flash_update_timeout_notify);
1052
1053struct devlink_flash_component_lookup_ctx {
1054 const char *lookup_name;
1055 bool lookup_name_found;
1056};
1057
1058static void
1059devlink_flash_component_lookup_cb(const char *version_name,
1060 enum devlink_info_version_type version_type,
1061 void *version_cb_priv)
1062{
1063 struct devlink_flash_component_lookup_ctx *lookup_ctx = version_cb_priv;
1064
1065 if (version_type != DEVLINK_INFO_VERSION_TYPE_COMPONENT ||
1066 lookup_ctx->lookup_name_found)
1067 return;
1068
1069 lookup_ctx->lookup_name_found =
1070 !strcmp(lookup_ctx->lookup_name, version_name);
1071}
1072
1073static int devlink_flash_component_get(struct devlink *devlink,
1074 struct nlattr *nla_component,
1075 const char **p_component,
1076 struct netlink_ext_ack *extack)
1077{
1078 struct devlink_flash_component_lookup_ctx lookup_ctx = {};
1079 struct devlink_info_req req = {};
1080 const char *component;
1081 int ret;
1082
1083 if (!nla_component)
1084 return 0;
1085
1086 component = nla_data(nla_component);
1087
1088 if (!devlink->ops->info_get) {
1089 NL_SET_ERR_MSG_ATTR(extack, nla_component,
1090 "component update is not supported by this device");
1091 return -EOPNOTSUPP;
1092 }
1093
1094 lookup_ctx.lookup_name = component;
1095 req.version_cb = devlink_flash_component_lookup_cb;
1096 req.version_cb_priv = &lookup_ctx;
1097
1098 ret = devlink->ops->info_get(devlink, &req, NULL);
1099 if (ret)
1100 return ret;
1101
1102 if (!lookup_ctx.lookup_name_found) {
1103 NL_SET_ERR_MSG_ATTR(extack, nla_component,
1104 "selected component is not supported by this device");
1105 return -EINVAL;
1106 }
1107 *p_component = component;
1108 return 0;
1109}
1110
1111int devlink_nl_flash_update_doit(struct sk_buff *skb, struct genl_info *info)
1112{
1113 struct nlattr *nla_overwrite_mask, *nla_file_name;
1114 struct devlink_flash_update_params params = {};
1115 struct devlink *devlink = info->user_ptr[0];
1116 const char *file_name;
1117 u32 supported_params;
1118 int ret;
1119
1120 if (!devlink->ops->flash_update)
1121 return -EOPNOTSUPP;
1122
1123 if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME))
1124 return -EINVAL;
1125
1126 ret = devlink_flash_component_get(devlink,
1127 info->attrs[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT],
1128 &params.component, info->extack);
1129 if (ret)
1130 return ret;
1131
1132 supported_params = devlink->ops->supported_flash_update_params;
1133
1134 nla_overwrite_mask = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK];
1135 if (nla_overwrite_mask) {
1136 struct nla_bitfield32 sections;
1137
1138 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK)) {
1139 NL_SET_ERR_MSG_ATTR(info->extack, nla_overwrite_mask,
1140 "overwrite settings are not supported by this device");
1141 return -EOPNOTSUPP;
1142 }
1143 sections = nla_get_bitfield32(nla_overwrite_mask);
1144 params.overwrite_mask = sections.value & sections.selector;
1145 }
1146
1147 nla_file_name = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME];
1148 file_name = nla_data(nla_file_name);
1149 ret = request_firmware(&params.fw, file_name, devlink->dev);
1150 if (ret) {
1151 NL_SET_ERR_MSG_ATTR(info->extack, nla_file_name,
1152 "failed to locate the requested firmware file");
1153 return ret;
1154 }
1155
1156 devlink_flash_update_begin_notify(devlink);
1157 ret = devlink->ops->flash_update(devlink, &params, info->extack);
1158 devlink_flash_update_end_notify(devlink);
1159
1160 release_firmware(params.fw);
1161
1162 return ret;
1163}
1164
1165static void __devlink_compat_running_version(struct devlink *devlink,
1166 char *buf, size_t len)
1167{
1168 struct devlink_info_req req = {};
1169 const struct nlattr *nlattr;
1170 struct sk_buff *msg;
1171 int rem, err;
1172
1173 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1174 if (!msg)
1175 return;
1176
1177 req.msg = msg;
1178 err = devlink->ops->info_get(devlink, &req, NULL);
1179 if (err)
1180 goto free_msg;
1181
1182 nla_for_each_attr(nlattr, (void *)msg->data, msg->len, rem) {
1183 const struct nlattr *kv;
1184 int rem_kv;
1185
1186 if (nla_type(nlattr) != DEVLINK_ATTR_INFO_VERSION_RUNNING)
1187 continue;
1188
1189 nla_for_each_nested(kv, nlattr, rem_kv) {
1190 if (nla_type(kv) != DEVLINK_ATTR_INFO_VERSION_VALUE)
1191 continue;
1192
1193 strlcat(buf, nla_data(kv), len);
1194 strlcat(buf, " ", len);
1195 }
1196 }
1197free_msg:
1198 nlmsg_free(msg);
1199}
1200
1201void devlink_compat_running_version(struct devlink *devlink,
1202 char *buf, size_t len)
1203{
1204 if (!devlink->ops->info_get)
1205 return;
1206
1207 devl_lock(devlink);
1208 if (devl_is_registered(devlink))
1209 __devlink_compat_running_version(devlink, buf, len);
1210 devl_unlock(devlink);
1211}
1212
1213int devlink_compat_flash_update(struct devlink *devlink, const char *file_name)
1214{
1215 struct devlink_flash_update_params params = {};
1216 int ret;
1217
1218 devl_lock(devlink);
1219 if (!devl_is_registered(devlink)) {
1220 ret = -ENODEV;
1221 goto out_unlock;
1222 }
1223
1224 if (!devlink->ops->flash_update) {
1225 ret = -EOPNOTSUPP;
1226 goto out_unlock;
1227 }
1228
1229 ret = request_firmware(&params.fw, file_name, devlink->dev);
1230 if (ret)
1231 goto out_unlock;
1232
1233 devlink_flash_update_begin_notify(devlink);
1234 ret = devlink->ops->flash_update(devlink, &params, NULL);
1235 devlink_flash_update_end_notify(devlink);
1236
1237 release_firmware(params.fw);
1238out_unlock:
1239 devl_unlock(devlink);
1240
1241 return ret;
1242}
1243
1244static int
1245devlink_nl_selftests_fill(struct sk_buff *msg, struct devlink *devlink,
1246 u32 portid, u32 seq, int flags,
1247 struct netlink_ext_ack *extack)
1248{
1249 struct nlattr *selftests;
1250 void *hdr;
1251 int err;
1252 int i;
1253
1254 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags,
1255 DEVLINK_CMD_SELFTESTS_GET);
1256 if (!hdr)
1257 return -EMSGSIZE;
1258
1259 err = -EMSGSIZE;
1260 if (devlink_nl_put_handle(msg, devlink))
1261 goto err_cancel_msg;
1262
1263 selftests = nla_nest_start(msg, DEVLINK_ATTR_SELFTESTS);
1264 if (!selftests)
1265 goto err_cancel_msg;
1266
1267 for (i = DEVLINK_ATTR_SELFTEST_ID_UNSPEC + 1;
1268 i <= DEVLINK_ATTR_SELFTEST_ID_MAX; i++) {
1269 if (devlink->ops->selftest_check(devlink, i, extack)) {
1270 err = nla_put_flag(msg, i);
1271 if (err)
1272 goto err_cancel_msg;
1273 }
1274 }
1275
1276 nla_nest_end(msg, selftests);
1277 genlmsg_end(msg, hdr);
1278 return 0;
1279
1280err_cancel_msg:
1281 genlmsg_cancel(msg, hdr);
1282 return err;
1283}
1284
1285int devlink_nl_selftests_get_doit(struct sk_buff *skb, struct genl_info *info)
1286{
1287 struct devlink *devlink = info->user_ptr[0];
1288 struct sk_buff *msg;
1289 int err;
1290
1291 if (!devlink->ops->selftest_check)
1292 return -EOPNOTSUPP;
1293
1294 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1295 if (!msg)
1296 return -ENOMEM;
1297
1298 err = devlink_nl_selftests_fill(msg, devlink, info->snd_portid,
1299 info->snd_seq, 0, info->extack);
1300 if (err) {
1301 nlmsg_free(msg);
1302 return err;
1303 }
1304
1305 return genlmsg_reply(msg, info);
1306}
1307
1308static int devlink_nl_selftests_get_dump_one(struct sk_buff *msg,
1309 struct devlink *devlink,
1310 struct netlink_callback *cb,
1311 int flags)
1312{
1313 if (!devlink->ops->selftest_check)
1314 return 0;
1315
1316 return devlink_nl_selftests_fill(msg, devlink,
1317 NETLINK_CB(cb->skb).portid,
1318 cb->nlh->nlmsg_seq, flags,
1319 cb->extack);
1320}
1321
1322int devlink_nl_selftests_get_dumpit(struct sk_buff *skb,
1323 struct netlink_callback *cb)
1324{
1325 return devlink_nl_dumpit(skb, cb, devlink_nl_selftests_get_dump_one);
1326}
1327
1328static int devlink_selftest_result_put(struct sk_buff *skb, unsigned int id,
1329 enum devlink_selftest_status test_status)
1330{
1331 struct nlattr *result_attr;
1332
1333 result_attr = nla_nest_start(skb, DEVLINK_ATTR_SELFTEST_RESULT);
1334 if (!result_attr)
1335 return -EMSGSIZE;
1336
1337 if (nla_put_u32(skb, DEVLINK_ATTR_SELFTEST_RESULT_ID, id) ||
1338 nla_put_u8(skb, DEVLINK_ATTR_SELFTEST_RESULT_STATUS,
1339 test_status))
1340 goto nla_put_failure;
1341
1342 nla_nest_end(skb, result_attr);
1343 return 0;
1344
1345nla_put_failure:
1346 nla_nest_cancel(skb, result_attr);
1347 return -EMSGSIZE;
1348}
1349
1350static const struct nla_policy devlink_selftest_nl_policy[DEVLINK_ATTR_SELFTEST_ID_MAX + 1] = {
1351 [DEVLINK_ATTR_SELFTEST_ID_FLASH] = { .type = NLA_FLAG },
1352};
1353
1354int devlink_nl_selftests_run_doit(struct sk_buff *skb, struct genl_info *info)
1355{
1356 struct nlattr *tb[DEVLINK_ATTR_SELFTEST_ID_MAX + 1];
1357 struct devlink *devlink = info->user_ptr[0];
1358 struct nlattr *attrs, *selftests;
1359 struct sk_buff *msg;
1360 void *hdr;
1361 int err;
1362 int i;
1363
1364 if (!devlink->ops->selftest_run || !devlink->ops->selftest_check)
1365 return -EOPNOTSUPP;
1366
1367 if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_SELFTESTS))
1368 return -EINVAL;
1369
1370 attrs = info->attrs[DEVLINK_ATTR_SELFTESTS];
1371
1372 err = nla_parse_nested(tb, DEVLINK_ATTR_SELFTEST_ID_MAX, attrs,
1373 devlink_selftest_nl_policy, info->extack);
1374 if (err < 0)
1375 return err;
1376
1377 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1378 if (!msg)
1379 return -ENOMEM;
1380
1381 err = -EMSGSIZE;
1382 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
1383 &devlink_nl_family, 0, DEVLINK_CMD_SELFTESTS_RUN);
1384 if (!hdr)
1385 goto free_msg;
1386
1387 if (devlink_nl_put_handle(msg, devlink))
1388 goto genlmsg_cancel;
1389
1390 selftests = nla_nest_start(msg, DEVLINK_ATTR_SELFTESTS);
1391 if (!selftests)
1392 goto genlmsg_cancel;
1393
1394 for (i = DEVLINK_ATTR_SELFTEST_ID_UNSPEC + 1;
1395 i <= DEVLINK_ATTR_SELFTEST_ID_MAX; i++) {
1396 enum devlink_selftest_status test_status;
1397
1398 if (nla_get_flag(tb[i])) {
1399 if (!devlink->ops->selftest_check(devlink, i,
1400 info->extack)) {
1401 if (devlink_selftest_result_put(msg, i,
1402 DEVLINK_SELFTEST_STATUS_SKIP))
1403 goto selftests_nest_cancel;
1404 continue;
1405 }
1406
1407 test_status = devlink->ops->selftest_run(devlink, i,
1408 info->extack);
1409 if (devlink_selftest_result_put(msg, i, test_status))
1410 goto selftests_nest_cancel;
1411 }
1412 }
1413
1414 nla_nest_end(msg, selftests);
1415 genlmsg_end(msg, hdr);
1416 return genlmsg_reply(msg, info);
1417
1418selftests_nest_cancel:
1419 nla_nest_cancel(msg, selftests);
1420genlmsg_cancel:
1421 genlmsg_cancel(msg, hdr);
1422free_msg:
1423 nlmsg_free(msg);
1424 return err;
1425}