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