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 <net/genetlink.h> 8 #include <net/sock.h> 9 #include "devl_internal.h" 10 11 struct 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 19 struct devlink_reload_combination { 20 enum devlink_reload_action action; 21 enum devlink_reload_limit limit; 22 }; 23 24 static 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 32 static bool 33 devlink_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 45 static bool 46 devlink_reload_action_is_supported(struct devlink *devlink, enum devlink_reload_action action) 47 { 48 return test_bit(action, &devlink->ops->reload_actions); 49 } 50 51 static bool 52 devlink_reload_limit_is_supported(struct devlink *devlink, enum devlink_reload_limit limit) 53 { 54 return test_bit(limit, &devlink->ops->reload_limits); 55 } 56 57 static 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 72 nla_put_failure: 73 nla_nest_cancel(msg, reload_stats_entry); 74 return -EMSGSIZE; 75 } 76 77 static int 78 devlink_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 132 action_stats_nest_cancel: 133 nla_nest_cancel(msg, act_stats); 134 action_info_nest_cancel: 135 nla_nest_cancel(msg, act_info); 136 nla_put_failure: 137 nla_nest_cancel(msg, reload_stats_attr); 138 return -EMSGSIZE; 139 } 140 141 static 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 170 dev_stats_nest_cancel: 171 nla_nest_cancel(msg, dev_stats); 172 nla_put_failure: 173 genlmsg_cancel(msg, hdr); 174 return -EMSGSIZE; 175 } 176 177 void 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 199 int 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 219 static int 220 devlink_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 228 const struct devlink_cmd devl_cmd_get = { 229 .dump_one = devlink_nl_cmd_get_dump_one, 230 }; 231 232 static 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 241 bool devlink_is_reload_failed(const struct devlink *devlink) 242 { 243 return devlink->reload_failed; 244 } 245 EXPORT_SYMBOL_GPL(devlink_is_reload_failed); 246 247 static 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 262 static void 263 devlink_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 */ 284 void 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 } 297 EXPORT_SYMBOL_GPL(devlink_remote_reload_actions_performed); 298 299 static 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_MOD(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_MOD(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 336 static 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 move_netdevice_notifier_net(curr_net, dest_net, 347 &devlink->netdevice_nb); 348 write_pnet(&devlink->_net, dest_net); 349 devlink_notify_register(devlink); 350 } 351 352 int devlink_reload(struct devlink *devlink, struct net *dest_net, 353 enum devlink_reload_action action, 354 enum devlink_reload_limit limit, 355 u32 *actions_performed, struct netlink_ext_ack *extack) 356 { 357 u32 remote_reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE]; 358 struct net *curr_net; 359 int err; 360 361 memcpy(remote_reload_stats, devlink->stats.remote_reload_stats, 362 sizeof(remote_reload_stats)); 363 364 err = devlink->ops->reload_down(devlink, !!dest_net, action, limit, extack); 365 if (err) 366 return err; 367 368 curr_net = devlink_net(devlink); 369 if (dest_net && !net_eq(dest_net, curr_net)) 370 devlink_reload_netns_change(devlink, curr_net, dest_net); 371 372 err = devlink->ops->reload_up(devlink, action, limit, actions_performed, extack); 373 devlink_reload_failed_set(devlink, !!err); 374 if (err) 375 return err; 376 377 WARN_ON(!(*actions_performed & BIT(action))); 378 /* Catch driver on updating the remote action within devlink reload */ 379 WARN_ON(memcmp(remote_reload_stats, devlink->stats.remote_reload_stats, 380 sizeof(remote_reload_stats))); 381 devlink_reload_stats_update(devlink, limit, *actions_performed); 382 return 0; 383 } 384 385 static int 386 devlink_nl_reload_actions_performed_snd(struct devlink *devlink, u32 actions_performed, 387 enum devlink_command cmd, struct genl_info *info) 388 { 389 struct sk_buff *msg; 390 void *hdr; 391 392 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 393 if (!msg) 394 return -ENOMEM; 395 396 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, &devlink_nl_family, 0, cmd); 397 if (!hdr) 398 goto free_msg; 399 400 if (devlink_nl_put_handle(msg, devlink)) 401 goto nla_put_failure; 402 403 if (nla_put_bitfield32(msg, DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED, actions_performed, 404 actions_performed)) 405 goto nla_put_failure; 406 genlmsg_end(msg, hdr); 407 408 return genlmsg_reply(msg, info); 409 410 nla_put_failure: 411 genlmsg_cancel(msg, hdr); 412 free_msg: 413 nlmsg_free(msg); 414 return -EMSGSIZE; 415 } 416 417 int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info) 418 { 419 struct devlink *devlink = info->user_ptr[0]; 420 enum devlink_reload_action action; 421 enum devlink_reload_limit limit; 422 struct net *dest_net = NULL; 423 u32 actions_performed; 424 int err; 425 426 err = devlink_resources_validate(devlink, NULL, info); 427 if (err) { 428 NL_SET_ERR_MSG_MOD(info->extack, "resources size validation failed"); 429 return err; 430 } 431 432 if (info->attrs[DEVLINK_ATTR_RELOAD_ACTION]) 433 action = nla_get_u8(info->attrs[DEVLINK_ATTR_RELOAD_ACTION]); 434 else 435 action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT; 436 437 if (!devlink_reload_action_is_supported(devlink, action)) { 438 NL_SET_ERR_MSG_MOD(info->extack, 439 "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_MOD(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_MOD(info->extack, 460 "Multiselection of limit is not supported"); 461 return -EOPNOTSUPP; 462 } 463 if (!devlink_reload_limit_is_supported(devlink, limit)) { 464 NL_SET_ERR_MSG_MOD(info->extack, 465 "Requested limit is not supported by the driver"); 466 return -EOPNOTSUPP; 467 } 468 if (devlink_reload_combination_is_invalid(action, limit)) { 469 NL_SET_ERR_MSG_MOD(info->extack, 470 "Requested limit is invalid for this action"); 471 return -EINVAL; 472 } 473 } 474 if (info->attrs[DEVLINK_ATTR_NETNS_PID] || 475 info->attrs[DEVLINK_ATTR_NETNS_FD] || 476 info->attrs[DEVLINK_ATTR_NETNS_ID]) { 477 dest_net = devlink_netns_get(skb, info); 478 if (IS_ERR(dest_net)) 479 return PTR_ERR(dest_net); 480 } 481 482 err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack); 483 484 if (dest_net) 485 put_net(dest_net); 486 487 if (err) 488 return err; 489 /* For backward compatibility generate reply only if attributes used by user */ 490 if (!info->attrs[DEVLINK_ATTR_RELOAD_ACTION] && !info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]) 491 return 0; 492 493 return devlink_nl_reload_actions_performed_snd(devlink, actions_performed, 494 DEVLINK_CMD_RELOAD, info); 495 } 496 497 bool devlink_reload_actions_valid(const struct devlink_ops *ops) 498 { 499 const struct devlink_reload_combination *comb; 500 int i; 501 502 if (!devlink_reload_supported(ops)) { 503 if (WARN_ON(ops->reload_actions)) 504 return false; 505 return true; 506 } 507 508 if (WARN_ON(!ops->reload_actions || 509 ops->reload_actions & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) || 510 ops->reload_actions >= BIT(__DEVLINK_RELOAD_ACTION_MAX))) 511 return false; 512 513 if (WARN_ON(ops->reload_limits & BIT(DEVLINK_RELOAD_LIMIT_UNSPEC) || 514 ops->reload_limits >= BIT(__DEVLINK_RELOAD_LIMIT_MAX))) 515 return false; 516 517 for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++) { 518 comb = &devlink_reload_invalid_combinations[i]; 519 if (ops->reload_actions == BIT(comb->action) && 520 ops->reload_limits == BIT(comb->limit)) 521 return false; 522 } 523 return true; 524 } 525 526 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink, 527 enum devlink_command cmd, u32 portid, 528 u32 seq, int flags) 529 { 530 const struct devlink_ops *ops = devlink->ops; 531 enum devlink_eswitch_encap_mode encap_mode; 532 u8 inline_mode; 533 void *hdr; 534 int err = 0; 535 u16 mode; 536 537 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd); 538 if (!hdr) 539 return -EMSGSIZE; 540 541 err = devlink_nl_put_handle(msg, devlink); 542 if (err) 543 goto nla_put_failure; 544 545 if (ops->eswitch_mode_get) { 546 err = ops->eswitch_mode_get(devlink, &mode); 547 if (err) 548 goto nla_put_failure; 549 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode); 550 if (err) 551 goto nla_put_failure; 552 } 553 554 if (ops->eswitch_inline_mode_get) { 555 err = ops->eswitch_inline_mode_get(devlink, &inline_mode); 556 if (err) 557 goto nla_put_failure; 558 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE, 559 inline_mode); 560 if (err) 561 goto nla_put_failure; 562 } 563 564 if (ops->eswitch_encap_mode_get) { 565 err = ops->eswitch_encap_mode_get(devlink, &encap_mode); 566 if (err) 567 goto nla_put_failure; 568 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode); 569 if (err) 570 goto nla_put_failure; 571 } 572 573 genlmsg_end(msg, hdr); 574 return 0; 575 576 nla_put_failure: 577 genlmsg_cancel(msg, hdr); 578 return err; 579 } 580 581 int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb, struct genl_info *info) 582 { 583 struct devlink *devlink = info->user_ptr[0]; 584 struct sk_buff *msg; 585 int err; 586 587 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 588 if (!msg) 589 return -ENOMEM; 590 591 err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET, 592 info->snd_portid, info->snd_seq, 0); 593 594 if (err) { 595 nlmsg_free(msg); 596 return err; 597 } 598 599 return genlmsg_reply(msg, info); 600 } 601 602 int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb, struct genl_info *info) 603 { 604 struct devlink *devlink = info->user_ptr[0]; 605 const struct devlink_ops *ops = devlink->ops; 606 enum devlink_eswitch_encap_mode encap_mode; 607 u8 inline_mode; 608 int err = 0; 609 u16 mode; 610 611 if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) { 612 if (!ops->eswitch_mode_set) 613 return -EOPNOTSUPP; 614 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]); 615 err = devlink_rate_nodes_check(devlink, mode, info->extack); 616 if (err) 617 return err; 618 err = ops->eswitch_mode_set(devlink, mode, info->extack); 619 if (err) 620 return err; 621 } 622 623 if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) { 624 if (!ops->eswitch_inline_mode_set) 625 return -EOPNOTSUPP; 626 inline_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]); 627 err = ops->eswitch_inline_mode_set(devlink, inline_mode, 628 info->extack); 629 if (err) 630 return err; 631 } 632 633 if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) { 634 if (!ops->eswitch_encap_mode_set) 635 return -EOPNOTSUPP; 636 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]); 637 err = ops->eswitch_encap_mode_set(devlink, encap_mode, 638 info->extack); 639 if (err) 640 return err; 641 } 642 643 return 0; 644 } 645 646 int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn) 647 { 648 if (!req->msg) 649 return 0; 650 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_SERIAL_NUMBER, sn); 651 } 652 EXPORT_SYMBOL_GPL(devlink_info_serial_number_put); 653 654 int devlink_info_board_serial_number_put(struct devlink_info_req *req, 655 const char *bsn) 656 { 657 if (!req->msg) 658 return 0; 659 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER, 660 bsn); 661 } 662 EXPORT_SYMBOL_GPL(devlink_info_board_serial_number_put); 663 664 static int devlink_info_version_put(struct devlink_info_req *req, int attr, 665 const char *version_name, 666 const char *version_value, 667 enum devlink_info_version_type version_type) 668 { 669 struct nlattr *nest; 670 int err; 671 672 if (req->version_cb) 673 req->version_cb(version_name, version_type, 674 req->version_cb_priv); 675 676 if (!req->msg) 677 return 0; 678 679 nest = nla_nest_start_noflag(req->msg, attr); 680 if (!nest) 681 return -EMSGSIZE; 682 683 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_NAME, 684 version_name); 685 if (err) 686 goto nla_put_failure; 687 688 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_VALUE, 689 version_value); 690 if (err) 691 goto nla_put_failure; 692 693 nla_nest_end(req->msg, nest); 694 695 return 0; 696 697 nla_put_failure: 698 nla_nest_cancel(req->msg, nest); 699 return err; 700 } 701 702 int devlink_info_version_fixed_put(struct devlink_info_req *req, 703 const char *version_name, 704 const char *version_value) 705 { 706 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_FIXED, 707 version_name, version_value, 708 DEVLINK_INFO_VERSION_TYPE_NONE); 709 } 710 EXPORT_SYMBOL_GPL(devlink_info_version_fixed_put); 711 712 int devlink_info_version_stored_put(struct devlink_info_req *req, 713 const char *version_name, 714 const char *version_value) 715 { 716 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED, 717 version_name, version_value, 718 DEVLINK_INFO_VERSION_TYPE_NONE); 719 } 720 EXPORT_SYMBOL_GPL(devlink_info_version_stored_put); 721 722 int devlink_info_version_stored_put_ext(struct devlink_info_req *req, 723 const char *version_name, 724 const char *version_value, 725 enum devlink_info_version_type version_type) 726 { 727 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED, 728 version_name, version_value, 729 version_type); 730 } 731 EXPORT_SYMBOL_GPL(devlink_info_version_stored_put_ext); 732 733 int devlink_info_version_running_put(struct devlink_info_req *req, 734 const char *version_name, 735 const char *version_value) 736 { 737 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING, 738 version_name, version_value, 739 DEVLINK_INFO_VERSION_TYPE_NONE); 740 } 741 EXPORT_SYMBOL_GPL(devlink_info_version_running_put); 742 743 int devlink_info_version_running_put_ext(struct devlink_info_req *req, 744 const char *version_name, 745 const char *version_value, 746 enum devlink_info_version_type version_type) 747 { 748 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING, 749 version_name, version_value, 750 version_type); 751 } 752 EXPORT_SYMBOL_GPL(devlink_info_version_running_put_ext); 753 754 static int devlink_nl_driver_info_get(struct device_driver *drv, 755 struct devlink_info_req *req) 756 { 757 if (!drv) 758 return 0; 759 760 if (drv->name[0]) 761 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_DRIVER_NAME, 762 drv->name); 763 764 return 0; 765 } 766 767 static int 768 devlink_nl_info_fill(struct sk_buff *msg, struct devlink *devlink, 769 enum devlink_command cmd, u32 portid, 770 u32 seq, int flags, struct netlink_ext_ack *extack) 771 { 772 struct device *dev = devlink_to_dev(devlink); 773 struct devlink_info_req req = {}; 774 void *hdr; 775 int err; 776 777 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd); 778 if (!hdr) 779 return -EMSGSIZE; 780 781 err = -EMSGSIZE; 782 if (devlink_nl_put_handle(msg, devlink)) 783 goto err_cancel_msg; 784 785 req.msg = msg; 786 if (devlink->ops->info_get) { 787 err = devlink->ops->info_get(devlink, &req, extack); 788 if (err) 789 goto err_cancel_msg; 790 } 791 792 err = devlink_nl_driver_info_get(dev->driver, &req); 793 if (err) 794 goto err_cancel_msg; 795 796 genlmsg_end(msg, hdr); 797 return 0; 798 799 err_cancel_msg: 800 genlmsg_cancel(msg, hdr); 801 return err; 802 } 803 804 int devlink_nl_cmd_info_get_doit(struct sk_buff *skb, struct genl_info *info) 805 { 806 struct devlink *devlink = info->user_ptr[0]; 807 struct sk_buff *msg; 808 int err; 809 810 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 811 if (!msg) 812 return -ENOMEM; 813 814 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET, 815 info->snd_portid, info->snd_seq, 0, 816 info->extack); 817 if (err) { 818 nlmsg_free(msg); 819 return err; 820 } 821 822 return genlmsg_reply(msg, info); 823 } 824 825 static int 826 devlink_nl_cmd_info_get_dump_one(struct sk_buff *msg, struct devlink *devlink, 827 struct netlink_callback *cb) 828 { 829 int err; 830 831 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET, 832 NETLINK_CB(cb->skb).portid, 833 cb->nlh->nlmsg_seq, NLM_F_MULTI, 834 cb->extack); 835 if (err == -EOPNOTSUPP) 836 err = 0; 837 return err; 838 } 839 840 const struct devlink_cmd devl_cmd_info_get = { 841 .dump_one = devlink_nl_cmd_info_get_dump_one, 842 }; 843 844 static int devlink_nl_flash_update_fill(struct sk_buff *msg, 845 struct devlink *devlink, 846 enum devlink_command cmd, 847 struct devlink_flash_notify *params) 848 { 849 void *hdr; 850 851 hdr = genlmsg_put(msg, 0, 0, &devlink_nl_family, 0, cmd); 852 if (!hdr) 853 return -EMSGSIZE; 854 855 if (devlink_nl_put_handle(msg, devlink)) 856 goto nla_put_failure; 857 858 if (cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS) 859 goto out; 860 861 if (params->status_msg && 862 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG, 863 params->status_msg)) 864 goto nla_put_failure; 865 if (params->component && 866 nla_put_string(msg, DEVLINK_ATTR_FLASH_UPDATE_COMPONENT, 867 params->component)) 868 goto nla_put_failure; 869 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE, 870 params->done, DEVLINK_ATTR_PAD)) 871 goto nla_put_failure; 872 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL, 873 params->total, DEVLINK_ATTR_PAD)) 874 goto nla_put_failure; 875 if (nla_put_u64_64bit(msg, DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT, 876 params->timeout, DEVLINK_ATTR_PAD)) 877 goto nla_put_failure; 878 879 out: 880 genlmsg_end(msg, hdr); 881 return 0; 882 883 nla_put_failure: 884 genlmsg_cancel(msg, hdr); 885 return -EMSGSIZE; 886 } 887 888 static void __devlink_flash_update_notify(struct devlink *devlink, 889 enum devlink_command cmd, 890 struct devlink_flash_notify *params) 891 { 892 struct sk_buff *msg; 893 int err; 894 895 WARN_ON(cmd != DEVLINK_CMD_FLASH_UPDATE && 896 cmd != DEVLINK_CMD_FLASH_UPDATE_END && 897 cmd != DEVLINK_CMD_FLASH_UPDATE_STATUS); 898 899 if (!xa_get_mark(&devlinks, devlink->index, DEVLINK_REGISTERED)) 900 return; 901 902 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 903 if (!msg) 904 return; 905 906 err = devlink_nl_flash_update_fill(msg, devlink, cmd, params); 907 if (err) 908 goto out_free_msg; 909 910 genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink), 911 msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL); 912 return; 913 914 out_free_msg: 915 nlmsg_free(msg); 916 } 917 918 static void devlink_flash_update_begin_notify(struct devlink *devlink) 919 { 920 struct devlink_flash_notify params = {}; 921 922 __devlink_flash_update_notify(devlink, 923 DEVLINK_CMD_FLASH_UPDATE, 924 ¶ms); 925 } 926 927 static void devlink_flash_update_end_notify(struct devlink *devlink) 928 { 929 struct devlink_flash_notify params = {}; 930 931 __devlink_flash_update_notify(devlink, 932 DEVLINK_CMD_FLASH_UPDATE_END, 933 ¶ms); 934 } 935 936 void devlink_flash_update_status_notify(struct devlink *devlink, 937 const char *status_msg, 938 const char *component, 939 unsigned long done, 940 unsigned long total) 941 { 942 struct devlink_flash_notify params = { 943 .status_msg = status_msg, 944 .component = component, 945 .done = done, 946 .total = total, 947 }; 948 949 __devlink_flash_update_notify(devlink, 950 DEVLINK_CMD_FLASH_UPDATE_STATUS, 951 ¶ms); 952 } 953 EXPORT_SYMBOL_GPL(devlink_flash_update_status_notify); 954 955 void devlink_flash_update_timeout_notify(struct devlink *devlink, 956 const char *status_msg, 957 const char *component, 958 unsigned long timeout) 959 { 960 struct devlink_flash_notify params = { 961 .status_msg = status_msg, 962 .component = component, 963 .timeout = timeout, 964 }; 965 966 __devlink_flash_update_notify(devlink, 967 DEVLINK_CMD_FLASH_UPDATE_STATUS, 968 ¶ms); 969 } 970 EXPORT_SYMBOL_GPL(devlink_flash_update_timeout_notify); 971 972 struct devlink_flash_component_lookup_ctx { 973 const char *lookup_name; 974 bool lookup_name_found; 975 }; 976 977 static void 978 devlink_flash_component_lookup_cb(const char *version_name, 979 enum devlink_info_version_type version_type, 980 void *version_cb_priv) 981 { 982 struct devlink_flash_component_lookup_ctx *lookup_ctx = version_cb_priv; 983 984 if (version_type != DEVLINK_INFO_VERSION_TYPE_COMPONENT || 985 lookup_ctx->lookup_name_found) 986 return; 987 988 lookup_ctx->lookup_name_found = 989 !strcmp(lookup_ctx->lookup_name, version_name); 990 } 991 992 static int devlink_flash_component_get(struct devlink *devlink, 993 struct nlattr *nla_component, 994 const char **p_component, 995 struct netlink_ext_ack *extack) 996 { 997 struct devlink_flash_component_lookup_ctx lookup_ctx = {}; 998 struct devlink_info_req req = {}; 999 const char *component; 1000 int ret; 1001 1002 if (!nla_component) 1003 return 0; 1004 1005 component = nla_data(nla_component); 1006 1007 if (!devlink->ops->info_get) { 1008 NL_SET_ERR_MSG_ATTR(extack, nla_component, 1009 "component update is not supported by this device"); 1010 return -EOPNOTSUPP; 1011 } 1012 1013 lookup_ctx.lookup_name = component; 1014 req.version_cb = devlink_flash_component_lookup_cb; 1015 req.version_cb_priv = &lookup_ctx; 1016 1017 ret = devlink->ops->info_get(devlink, &req, NULL); 1018 if (ret) 1019 return ret; 1020 1021 if (!lookup_ctx.lookup_name_found) { 1022 NL_SET_ERR_MSG_ATTR(extack, nla_component, 1023 "selected component is not supported by this device"); 1024 return -EINVAL; 1025 } 1026 *p_component = component; 1027 return 0; 1028 } 1029 1030 int devlink_nl_cmd_flash_update(struct sk_buff *skb, struct genl_info *info) 1031 { 1032 struct nlattr *nla_overwrite_mask, *nla_file_name; 1033 struct devlink_flash_update_params params = {}; 1034 struct devlink *devlink = info->user_ptr[0]; 1035 const char *file_name; 1036 u32 supported_params; 1037 int ret; 1038 1039 if (!devlink->ops->flash_update) 1040 return -EOPNOTSUPP; 1041 1042 if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME)) 1043 return -EINVAL; 1044 1045 ret = devlink_flash_component_get(devlink, 1046 info->attrs[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT], 1047 ¶ms.component, info->extack); 1048 if (ret) 1049 return ret; 1050 1051 supported_params = devlink->ops->supported_flash_update_params; 1052 1053 nla_overwrite_mask = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK]; 1054 if (nla_overwrite_mask) { 1055 struct nla_bitfield32 sections; 1056 1057 if (!(supported_params & DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK)) { 1058 NL_SET_ERR_MSG_ATTR(info->extack, nla_overwrite_mask, 1059 "overwrite settings are not supported by this device"); 1060 return -EOPNOTSUPP; 1061 } 1062 sections = nla_get_bitfield32(nla_overwrite_mask); 1063 params.overwrite_mask = sections.value & sections.selector; 1064 } 1065 1066 nla_file_name = info->attrs[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME]; 1067 file_name = nla_data(nla_file_name); 1068 ret = request_firmware(¶ms.fw, file_name, devlink->dev); 1069 if (ret) { 1070 NL_SET_ERR_MSG_ATTR(info->extack, nla_file_name, 1071 "failed to locate the requested firmware file"); 1072 return ret; 1073 } 1074 1075 devlink_flash_update_begin_notify(devlink); 1076 ret = devlink->ops->flash_update(devlink, ¶ms, info->extack); 1077 devlink_flash_update_end_notify(devlink); 1078 1079 release_firmware(params.fw); 1080 1081 return ret; 1082 } 1083 1084 static void __devlink_compat_running_version(struct devlink *devlink, 1085 char *buf, size_t len) 1086 { 1087 struct devlink_info_req req = {}; 1088 const struct nlattr *nlattr; 1089 struct sk_buff *msg; 1090 int rem, err; 1091 1092 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1093 if (!msg) 1094 return; 1095 1096 req.msg = msg; 1097 err = devlink->ops->info_get(devlink, &req, NULL); 1098 if (err) 1099 goto free_msg; 1100 1101 nla_for_each_attr(nlattr, (void *)msg->data, msg->len, rem) { 1102 const struct nlattr *kv; 1103 int rem_kv; 1104 1105 if (nla_type(nlattr) != DEVLINK_ATTR_INFO_VERSION_RUNNING) 1106 continue; 1107 1108 nla_for_each_nested(kv, nlattr, rem_kv) { 1109 if (nla_type(kv) != DEVLINK_ATTR_INFO_VERSION_VALUE) 1110 continue; 1111 1112 strlcat(buf, nla_data(kv), len); 1113 strlcat(buf, " ", len); 1114 } 1115 } 1116 free_msg: 1117 nlmsg_free(msg); 1118 } 1119 1120 void devlink_compat_running_version(struct devlink *devlink, 1121 char *buf, size_t len) 1122 { 1123 if (!devlink->ops->info_get) 1124 return; 1125 1126 devl_lock(devlink); 1127 if (devl_is_registered(devlink)) 1128 __devlink_compat_running_version(devlink, buf, len); 1129 devl_unlock(devlink); 1130 } 1131 1132 int devlink_compat_flash_update(struct devlink *devlink, const char *file_name) 1133 { 1134 struct devlink_flash_update_params params = {}; 1135 int ret; 1136 1137 devl_lock(devlink); 1138 if (!devl_is_registered(devlink)) { 1139 ret = -ENODEV; 1140 goto out_unlock; 1141 } 1142 1143 if (!devlink->ops->flash_update) { 1144 ret = -EOPNOTSUPP; 1145 goto out_unlock; 1146 } 1147 1148 ret = request_firmware(¶ms.fw, file_name, devlink->dev); 1149 if (ret) 1150 goto out_unlock; 1151 1152 devlink_flash_update_begin_notify(devlink); 1153 ret = devlink->ops->flash_update(devlink, ¶ms, NULL); 1154 devlink_flash_update_end_notify(devlink); 1155 1156 release_firmware(params.fw); 1157 out_unlock: 1158 devl_unlock(devlink); 1159 1160 return ret; 1161 } 1162 1163 static int 1164 devlink_nl_selftests_fill(struct sk_buff *msg, struct devlink *devlink, 1165 u32 portid, u32 seq, int flags, 1166 struct netlink_ext_ack *extack) 1167 { 1168 struct nlattr *selftests; 1169 void *hdr; 1170 int err; 1171 int i; 1172 1173 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, 1174 DEVLINK_CMD_SELFTESTS_GET); 1175 if (!hdr) 1176 return -EMSGSIZE; 1177 1178 err = -EMSGSIZE; 1179 if (devlink_nl_put_handle(msg, devlink)) 1180 goto err_cancel_msg; 1181 1182 selftests = nla_nest_start(msg, DEVLINK_ATTR_SELFTESTS); 1183 if (!selftests) 1184 goto err_cancel_msg; 1185 1186 for (i = DEVLINK_ATTR_SELFTEST_ID_UNSPEC + 1; 1187 i <= DEVLINK_ATTR_SELFTEST_ID_MAX; i++) { 1188 if (devlink->ops->selftest_check(devlink, i, extack)) { 1189 err = nla_put_flag(msg, i); 1190 if (err) 1191 goto err_cancel_msg; 1192 } 1193 } 1194 1195 nla_nest_end(msg, selftests); 1196 genlmsg_end(msg, hdr); 1197 return 0; 1198 1199 err_cancel_msg: 1200 genlmsg_cancel(msg, hdr); 1201 return err; 1202 } 1203 1204 int devlink_nl_cmd_selftests_get_doit(struct sk_buff *skb, 1205 struct genl_info *info) 1206 { 1207 struct devlink *devlink = info->user_ptr[0]; 1208 struct sk_buff *msg; 1209 int err; 1210 1211 if (!devlink->ops->selftest_check) 1212 return -EOPNOTSUPP; 1213 1214 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1215 if (!msg) 1216 return -ENOMEM; 1217 1218 err = devlink_nl_selftests_fill(msg, devlink, info->snd_portid, 1219 info->snd_seq, 0, info->extack); 1220 if (err) { 1221 nlmsg_free(msg); 1222 return err; 1223 } 1224 1225 return genlmsg_reply(msg, info); 1226 } 1227 1228 static int 1229 devlink_nl_cmd_selftests_get_dump_one(struct sk_buff *msg, 1230 struct devlink *devlink, 1231 struct netlink_callback *cb) 1232 { 1233 if (!devlink->ops->selftest_check) 1234 return 0; 1235 1236 return devlink_nl_selftests_fill(msg, devlink, 1237 NETLINK_CB(cb->skb).portid, 1238 cb->nlh->nlmsg_seq, NLM_F_MULTI, 1239 cb->extack); 1240 } 1241 1242 const struct devlink_cmd devl_cmd_selftests_get = { 1243 .dump_one = devlink_nl_cmd_selftests_get_dump_one, 1244 }; 1245 1246 static int devlink_selftest_result_put(struct sk_buff *skb, unsigned int id, 1247 enum devlink_selftest_status test_status) 1248 { 1249 struct nlattr *result_attr; 1250 1251 result_attr = nla_nest_start(skb, DEVLINK_ATTR_SELFTEST_RESULT); 1252 if (!result_attr) 1253 return -EMSGSIZE; 1254 1255 if (nla_put_u32(skb, DEVLINK_ATTR_SELFTEST_RESULT_ID, id) || 1256 nla_put_u8(skb, DEVLINK_ATTR_SELFTEST_RESULT_STATUS, 1257 test_status)) 1258 goto nla_put_failure; 1259 1260 nla_nest_end(skb, result_attr); 1261 return 0; 1262 1263 nla_put_failure: 1264 nla_nest_cancel(skb, result_attr); 1265 return -EMSGSIZE; 1266 } 1267 1268 static const struct nla_policy devlink_selftest_nl_policy[DEVLINK_ATTR_SELFTEST_ID_MAX + 1] = { 1269 [DEVLINK_ATTR_SELFTEST_ID_FLASH] = { .type = NLA_FLAG }, 1270 }; 1271 1272 int devlink_nl_cmd_selftests_run(struct sk_buff *skb, struct genl_info *info) 1273 { 1274 struct nlattr *tb[DEVLINK_ATTR_SELFTEST_ID_MAX + 1]; 1275 struct devlink *devlink = info->user_ptr[0]; 1276 struct nlattr *attrs, *selftests; 1277 struct sk_buff *msg; 1278 void *hdr; 1279 int err; 1280 int i; 1281 1282 if (!devlink->ops->selftest_run || !devlink->ops->selftest_check) 1283 return -EOPNOTSUPP; 1284 1285 if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_SELFTESTS)) 1286 return -EINVAL; 1287 1288 attrs = info->attrs[DEVLINK_ATTR_SELFTESTS]; 1289 1290 err = nla_parse_nested(tb, DEVLINK_ATTR_SELFTEST_ID_MAX, attrs, 1291 devlink_selftest_nl_policy, info->extack); 1292 if (err < 0) 1293 return err; 1294 1295 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1296 if (!msg) 1297 return -ENOMEM; 1298 1299 err = -EMSGSIZE; 1300 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, 1301 &devlink_nl_family, 0, DEVLINK_CMD_SELFTESTS_RUN); 1302 if (!hdr) 1303 goto free_msg; 1304 1305 if (devlink_nl_put_handle(msg, devlink)) 1306 goto genlmsg_cancel; 1307 1308 selftests = nla_nest_start(msg, DEVLINK_ATTR_SELFTESTS); 1309 if (!selftests) 1310 goto genlmsg_cancel; 1311 1312 for (i = DEVLINK_ATTR_SELFTEST_ID_UNSPEC + 1; 1313 i <= DEVLINK_ATTR_SELFTEST_ID_MAX; i++) { 1314 enum devlink_selftest_status test_status; 1315 1316 if (nla_get_flag(tb[i])) { 1317 if (!devlink->ops->selftest_check(devlink, i, 1318 info->extack)) { 1319 if (devlink_selftest_result_put(msg, i, 1320 DEVLINK_SELFTEST_STATUS_SKIP)) 1321 goto selftests_nest_cancel; 1322 continue; 1323 } 1324 1325 test_status = devlink->ops->selftest_run(devlink, i, 1326 info->extack); 1327 if (devlink_selftest_result_put(msg, i, test_status)) 1328 goto selftests_nest_cancel; 1329 } 1330 } 1331 1332 nla_nest_end(msg, selftests); 1333 genlmsg_end(msg, hdr); 1334 return genlmsg_reply(msg, info); 1335 1336 selftests_nest_cancel: 1337 nla_nest_cancel(msg, selftests); 1338 genlmsg_cancel: 1339 genlmsg_cancel(msg, hdr); 1340 free_msg: 1341 nlmsg_free(msg); 1342 return err; 1343 } 1344