projects/linux·blob v6.5 · refs

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