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_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_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 int devlink_nl_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb) 229 { 230 return devlink_nl_dumpit(msg, cb, devlink_nl_get_dump_one); 231 } 232 233 static void devlink_reload_failed_set(struct devlink *devlink, 234 bool reload_failed) 235 { 236 if (devlink->reload_failed == reload_failed) 237 return; 238 devlink->reload_failed = reload_failed; 239 devlink_notify(devlink, DEVLINK_CMD_NEW); 240 } 241 242 bool devlink_is_reload_failed(const struct devlink *devlink) 243 { 244 return devlink->reload_failed; 245 } 246 EXPORT_SYMBOL_GPL(devlink_is_reload_failed); 247 248 static void 249 __devlink_reload_stats_update(struct devlink *devlink, u32 *reload_stats, 250 enum devlink_reload_limit limit, u32 actions_performed) 251 { 252 unsigned long actions = actions_performed; 253 int stat_idx; 254 int action; 255 256 for_each_set_bit(action, &actions, __DEVLINK_RELOAD_ACTION_MAX) { 257 stat_idx = limit * __DEVLINK_RELOAD_ACTION_MAX + action; 258 reload_stats[stat_idx]++; 259 } 260 devlink_notify(devlink, DEVLINK_CMD_NEW); 261 } 262 263 static void 264 devlink_reload_stats_update(struct devlink *devlink, enum devlink_reload_limit limit, 265 u32 actions_performed) 266 { 267 __devlink_reload_stats_update(devlink, devlink->stats.reload_stats, limit, 268 actions_performed); 269 } 270 271 /** 272 * devlink_remote_reload_actions_performed - Update devlink on reload actions 273 * performed which are not a direct result of devlink reload call. 274 * 275 * This should be called by a driver after performing reload actions in case it was not 276 * a result of devlink reload call. For example fw_activate was performed as a result 277 * of devlink reload triggered fw_activate on another host. 278 * The motivation for this function is to keep data on reload actions performed on this 279 * function whether it was done due to direct devlink reload call or not. 280 * 281 * @devlink: devlink 282 * @limit: reload limit 283 * @actions_performed: bitmask of actions performed 284 */ 285 void devlink_remote_reload_actions_performed(struct devlink *devlink, 286 enum devlink_reload_limit limit, 287 u32 actions_performed) 288 { 289 if (WARN_ON(!actions_performed || 290 actions_performed & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) || 291 actions_performed >= BIT(__DEVLINK_RELOAD_ACTION_MAX) || 292 limit > DEVLINK_RELOAD_LIMIT_MAX)) 293 return; 294 295 __devlink_reload_stats_update(devlink, devlink->stats.remote_reload_stats, limit, 296 actions_performed); 297 } 298 EXPORT_SYMBOL_GPL(devlink_remote_reload_actions_performed); 299 300 static struct net *devlink_netns_get(struct sk_buff *skb, 301 struct genl_info *info) 302 { 303 struct nlattr *netns_pid_attr = info->attrs[DEVLINK_ATTR_NETNS_PID]; 304 struct nlattr *netns_fd_attr = info->attrs[DEVLINK_ATTR_NETNS_FD]; 305 struct nlattr *netns_id_attr = info->attrs[DEVLINK_ATTR_NETNS_ID]; 306 struct net *net; 307 308 if (!!netns_pid_attr + !!netns_fd_attr + !!netns_id_attr > 1) { 309 NL_SET_ERR_MSG(info->extack, "multiple netns identifying attributes specified"); 310 return ERR_PTR(-EINVAL); 311 } 312 313 if (netns_pid_attr) { 314 net = get_net_ns_by_pid(nla_get_u32(netns_pid_attr)); 315 } else if (netns_fd_attr) { 316 net = get_net_ns_by_fd(nla_get_u32(netns_fd_attr)); 317 } else if (netns_id_attr) { 318 net = get_net_ns_by_id(sock_net(skb->sk), 319 nla_get_u32(netns_id_attr)); 320 if (!net) 321 net = ERR_PTR(-EINVAL); 322 } else { 323 WARN_ON(1); 324 net = ERR_PTR(-EINVAL); 325 } 326 if (IS_ERR(net)) { 327 NL_SET_ERR_MSG(info->extack, "Unknown network namespace"); 328 return ERR_PTR(-EINVAL); 329 } 330 if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) { 331 put_net(net); 332 return ERR_PTR(-EPERM); 333 } 334 return net; 335 } 336 337 static void devlink_reload_netns_change(struct devlink *devlink, 338 struct net *curr_net, 339 struct net *dest_net) 340 { 341 /* Userspace needs to be notified about devlink objects 342 * removed from original and entering new network namespace. 343 * The rest of the devlink objects are re-created during 344 * reload process so the notifications are generated separatelly. 345 */ 346 devlink_notify_unregister(devlink); 347 write_pnet(&devlink->_net, dest_net); 348 devlink_notify_register(devlink); 349 } 350 351 int devlink_reload(struct devlink *devlink, struct net *dest_net, 352 enum devlink_reload_action action, 353 enum devlink_reload_limit limit, 354 u32 *actions_performed, struct netlink_ext_ack *extack) 355 { 356 u32 remote_reload_stats[DEVLINK_RELOAD_STATS_ARRAY_SIZE]; 357 struct net *curr_net; 358 int err; 359 360 memcpy(remote_reload_stats, devlink->stats.remote_reload_stats, 361 sizeof(remote_reload_stats)); 362 363 err = devlink->ops->reload_down(devlink, !!dest_net, action, limit, extack); 364 if (err) 365 return err; 366 367 curr_net = devlink_net(devlink); 368 if (dest_net && !net_eq(dest_net, curr_net)) 369 devlink_reload_netns_change(devlink, curr_net, dest_net); 370 371 if (action == DEVLINK_RELOAD_ACTION_DRIVER_REINIT) 372 devlink_params_driverinit_load_new(devlink); 373 374 err = devlink->ops->reload_up(devlink, action, limit, actions_performed, extack); 375 devlink_reload_failed_set(devlink, !!err); 376 if (err) 377 return err; 378 379 WARN_ON(!(*actions_performed & BIT(action))); 380 /* Catch driver on updating the remote action within devlink reload */ 381 WARN_ON(memcmp(remote_reload_stats, devlink->stats.remote_reload_stats, 382 sizeof(remote_reload_stats))); 383 devlink_reload_stats_update(devlink, limit, *actions_performed); 384 return 0; 385 } 386 387 static int 388 devlink_nl_reload_actions_performed_snd(struct devlink *devlink, u32 actions_performed, 389 enum devlink_command cmd, struct genl_info *info) 390 { 391 struct sk_buff *msg; 392 void *hdr; 393 394 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 395 if (!msg) 396 return -ENOMEM; 397 398 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, &devlink_nl_family, 0, cmd); 399 if (!hdr) 400 goto free_msg; 401 402 if (devlink_nl_put_handle(msg, devlink)) 403 goto nla_put_failure; 404 405 if (nla_put_bitfield32(msg, DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED, actions_performed, 406 actions_performed)) 407 goto nla_put_failure; 408 genlmsg_end(msg, hdr); 409 410 return genlmsg_reply(msg, info); 411 412 nla_put_failure: 413 genlmsg_cancel(msg, hdr); 414 free_msg: 415 nlmsg_free(msg); 416 return -EMSGSIZE; 417 } 418 419 int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info) 420 { 421 struct devlink *devlink = info->user_ptr[0]; 422 enum devlink_reload_action action; 423 enum devlink_reload_limit limit; 424 struct net *dest_net = NULL; 425 u32 actions_performed; 426 int err; 427 428 err = devlink_resources_validate(devlink, NULL, info); 429 if (err) { 430 NL_SET_ERR_MSG(info->extack, "resources size validation failed"); 431 return err; 432 } 433 434 if (info->attrs[DEVLINK_ATTR_RELOAD_ACTION]) 435 action = nla_get_u8(info->attrs[DEVLINK_ATTR_RELOAD_ACTION]); 436 else 437 action = DEVLINK_RELOAD_ACTION_DRIVER_REINIT; 438 439 if (!devlink_reload_action_is_supported(devlink, action)) { 440 NL_SET_ERR_MSG(info->extack, "Requested reload action is not supported by the driver"); 441 return -EOPNOTSUPP; 442 } 443 444 limit = DEVLINK_RELOAD_LIMIT_UNSPEC; 445 if (info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]) { 446 struct nla_bitfield32 limits; 447 u32 limits_selected; 448 449 limits = nla_get_bitfield32(info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]); 450 limits_selected = limits.value & limits.selector; 451 if (!limits_selected) { 452 NL_SET_ERR_MSG(info->extack, "Invalid limit selected"); 453 return -EINVAL; 454 } 455 for (limit = 0 ; limit <= DEVLINK_RELOAD_LIMIT_MAX ; limit++) 456 if (limits_selected & BIT(limit)) 457 break; 458 /* UAPI enables multiselection, but currently it is not used */ 459 if (limits_selected != BIT(limit)) { 460 NL_SET_ERR_MSG(info->extack, "Multiselection of limit is not supported"); 461 return -EOPNOTSUPP; 462 } 463 if (!devlink_reload_limit_is_supported(devlink, limit)) { 464 NL_SET_ERR_MSG(info->extack, "Requested limit is not supported by the driver"); 465 return -EOPNOTSUPP; 466 } 467 if (devlink_reload_combination_is_invalid(action, limit)) { 468 NL_SET_ERR_MSG(info->extack, "Requested limit is invalid for this action"); 469 return -EINVAL; 470 } 471 } 472 if (info->attrs[DEVLINK_ATTR_NETNS_PID] || 473 info->attrs[DEVLINK_ATTR_NETNS_FD] || 474 info->attrs[DEVLINK_ATTR_NETNS_ID]) { 475 dest_net = devlink_netns_get(skb, info); 476 if (IS_ERR(dest_net)) 477 return PTR_ERR(dest_net); 478 if (!net_eq(dest_net, devlink_net(devlink)) && 479 action != DEVLINK_RELOAD_ACTION_DRIVER_REINIT) { 480 NL_SET_ERR_MSG_MOD(info->extack, 481 "Changing namespace is only supported for reinit action"); 482 return -EOPNOTSUPP; 483 } 484 } 485 486 err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack); 487 488 if (dest_net) 489 put_net(dest_net); 490 491 if (err) 492 return err; 493 /* For backward compatibility generate reply only if attributes used by user */ 494 if (!info->attrs[DEVLINK_ATTR_RELOAD_ACTION] && !info->attrs[DEVLINK_ATTR_RELOAD_LIMITS]) 495 return 0; 496 497 return devlink_nl_reload_actions_performed_snd(devlink, actions_performed, 498 DEVLINK_CMD_RELOAD, info); 499 } 500 501 bool devlink_reload_actions_valid(const struct devlink_ops *ops) 502 { 503 const struct devlink_reload_combination *comb; 504 int i; 505 506 if (!devlink_reload_supported(ops)) { 507 if (WARN_ON(ops->reload_actions)) 508 return false; 509 return true; 510 } 511 512 if (WARN_ON(!ops->reload_actions || 513 ops->reload_actions & BIT(DEVLINK_RELOAD_ACTION_UNSPEC) || 514 ops->reload_actions >= BIT(__DEVLINK_RELOAD_ACTION_MAX))) 515 return false; 516 517 if (WARN_ON(ops->reload_limits & BIT(DEVLINK_RELOAD_LIMIT_UNSPEC) || 518 ops->reload_limits >= BIT(__DEVLINK_RELOAD_LIMIT_MAX))) 519 return false; 520 521 for (i = 0; i < ARRAY_SIZE(devlink_reload_invalid_combinations); i++) { 522 comb = &devlink_reload_invalid_combinations[i]; 523 if (ops->reload_actions == BIT(comb->action) && 524 ops->reload_limits == BIT(comb->limit)) 525 return false; 526 } 527 return true; 528 } 529 530 static int devlink_nl_eswitch_fill(struct sk_buff *msg, struct devlink *devlink, 531 enum devlink_command cmd, u32 portid, 532 u32 seq, int flags) 533 { 534 const struct devlink_ops *ops = devlink->ops; 535 enum devlink_eswitch_encap_mode encap_mode; 536 u8 inline_mode; 537 void *hdr; 538 int err = 0; 539 u16 mode; 540 541 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd); 542 if (!hdr) 543 return -EMSGSIZE; 544 545 err = devlink_nl_put_handle(msg, devlink); 546 if (err) 547 goto nla_put_failure; 548 549 if (ops->eswitch_mode_get) { 550 err = ops->eswitch_mode_get(devlink, &mode); 551 if (err) 552 goto nla_put_failure; 553 err = nla_put_u16(msg, DEVLINK_ATTR_ESWITCH_MODE, mode); 554 if (err) 555 goto nla_put_failure; 556 } 557 558 if (ops->eswitch_inline_mode_get) { 559 err = ops->eswitch_inline_mode_get(devlink, &inline_mode); 560 if (err) 561 goto nla_put_failure; 562 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_INLINE_MODE, 563 inline_mode); 564 if (err) 565 goto nla_put_failure; 566 } 567 568 if (ops->eswitch_encap_mode_get) { 569 err = ops->eswitch_encap_mode_get(devlink, &encap_mode); 570 if (err) 571 goto nla_put_failure; 572 err = nla_put_u8(msg, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, encap_mode); 573 if (err) 574 goto nla_put_failure; 575 } 576 577 genlmsg_end(msg, hdr); 578 return 0; 579 580 nla_put_failure: 581 genlmsg_cancel(msg, hdr); 582 return err; 583 } 584 585 int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb, struct genl_info *info) 586 { 587 struct devlink *devlink = info->user_ptr[0]; 588 struct sk_buff *msg; 589 int err; 590 591 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 592 if (!msg) 593 return -ENOMEM; 594 595 err = devlink_nl_eswitch_fill(msg, devlink, DEVLINK_CMD_ESWITCH_GET, 596 info->snd_portid, info->snd_seq, 0); 597 598 if (err) { 599 nlmsg_free(msg); 600 return err; 601 } 602 603 return genlmsg_reply(msg, info); 604 } 605 606 int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb, struct genl_info *info) 607 { 608 struct devlink *devlink = info->user_ptr[0]; 609 const struct devlink_ops *ops = devlink->ops; 610 enum devlink_eswitch_encap_mode encap_mode; 611 u8 inline_mode; 612 int err = 0; 613 u16 mode; 614 615 if (info->attrs[DEVLINK_ATTR_ESWITCH_MODE]) { 616 if (!ops->eswitch_mode_set) 617 return -EOPNOTSUPP; 618 mode = nla_get_u16(info->attrs[DEVLINK_ATTR_ESWITCH_MODE]); 619 err = devlink_rate_nodes_check(devlink, mode, info->extack); 620 if (err) 621 return err; 622 err = ops->eswitch_mode_set(devlink, mode, info->extack); 623 if (err) 624 return err; 625 } 626 627 if (info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) { 628 if (!ops->eswitch_inline_mode_set) 629 return -EOPNOTSUPP; 630 inline_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_INLINE_MODE]); 631 err = ops->eswitch_inline_mode_set(devlink, inline_mode, 632 info->extack); 633 if (err) 634 return err; 635 } 636 637 if (info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) { 638 if (!ops->eswitch_encap_mode_set) 639 return -EOPNOTSUPP; 640 encap_mode = nla_get_u8(info->attrs[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]); 641 err = ops->eswitch_encap_mode_set(devlink, encap_mode, 642 info->extack); 643 if (err) 644 return err; 645 } 646 647 return 0; 648 } 649 650 int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn) 651 { 652 if (!req->msg) 653 return 0; 654 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_SERIAL_NUMBER, sn); 655 } 656 EXPORT_SYMBOL_GPL(devlink_info_serial_number_put); 657 658 int devlink_info_board_serial_number_put(struct devlink_info_req *req, 659 const char *bsn) 660 { 661 if (!req->msg) 662 return 0; 663 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER, 664 bsn); 665 } 666 EXPORT_SYMBOL_GPL(devlink_info_board_serial_number_put); 667 668 static int devlink_info_version_put(struct devlink_info_req *req, int attr, 669 const char *version_name, 670 const char *version_value, 671 enum devlink_info_version_type version_type) 672 { 673 struct nlattr *nest; 674 int err; 675 676 if (req->version_cb) 677 req->version_cb(version_name, version_type, 678 req->version_cb_priv); 679 680 if (!req->msg) 681 return 0; 682 683 nest = nla_nest_start_noflag(req->msg, attr); 684 if (!nest) 685 return -EMSGSIZE; 686 687 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_NAME, 688 version_name); 689 if (err) 690 goto nla_put_failure; 691 692 err = nla_put_string(req->msg, DEVLINK_ATTR_INFO_VERSION_VALUE, 693 version_value); 694 if (err) 695 goto nla_put_failure; 696 697 nla_nest_end(req->msg, nest); 698 699 return 0; 700 701 nla_put_failure: 702 nla_nest_cancel(req->msg, nest); 703 return err; 704 } 705 706 int devlink_info_version_fixed_put(struct devlink_info_req *req, 707 const char *version_name, 708 const char *version_value) 709 { 710 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_FIXED, 711 version_name, version_value, 712 DEVLINK_INFO_VERSION_TYPE_NONE); 713 } 714 EXPORT_SYMBOL_GPL(devlink_info_version_fixed_put); 715 716 int devlink_info_version_stored_put(struct devlink_info_req *req, 717 const char *version_name, 718 const char *version_value) 719 { 720 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED, 721 version_name, version_value, 722 DEVLINK_INFO_VERSION_TYPE_NONE); 723 } 724 EXPORT_SYMBOL_GPL(devlink_info_version_stored_put); 725 726 int devlink_info_version_stored_put_ext(struct devlink_info_req *req, 727 const char *version_name, 728 const char *version_value, 729 enum devlink_info_version_type version_type) 730 { 731 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_STORED, 732 version_name, version_value, 733 version_type); 734 } 735 EXPORT_SYMBOL_GPL(devlink_info_version_stored_put_ext); 736 737 int devlink_info_version_running_put(struct devlink_info_req *req, 738 const char *version_name, 739 const char *version_value) 740 { 741 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING, 742 version_name, version_value, 743 DEVLINK_INFO_VERSION_TYPE_NONE); 744 } 745 EXPORT_SYMBOL_GPL(devlink_info_version_running_put); 746 747 int devlink_info_version_running_put_ext(struct devlink_info_req *req, 748 const char *version_name, 749 const char *version_value, 750 enum devlink_info_version_type version_type) 751 { 752 return devlink_info_version_put(req, DEVLINK_ATTR_INFO_VERSION_RUNNING, 753 version_name, version_value, 754 version_type); 755 } 756 EXPORT_SYMBOL_GPL(devlink_info_version_running_put_ext); 757 758 static int devlink_nl_driver_info_get(struct device_driver *drv, 759 struct devlink_info_req *req) 760 { 761 if (!drv) 762 return 0; 763 764 if (drv->name[0]) 765 return nla_put_string(req->msg, DEVLINK_ATTR_INFO_DRIVER_NAME, 766 drv->name); 767 768 return 0; 769 } 770 771 static int 772 devlink_nl_info_fill(struct sk_buff *msg, struct devlink *devlink, 773 enum devlink_command cmd, u32 portid, 774 u32 seq, int flags, struct netlink_ext_ack *extack) 775 { 776 struct device *dev = devlink_to_dev(devlink); 777 struct devlink_info_req req = {}; 778 void *hdr; 779 int err; 780 781 hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd); 782 if (!hdr) 783 return -EMSGSIZE; 784 785 err = -EMSGSIZE; 786 if (devlink_nl_put_handle(msg, devlink)) 787 goto err_cancel_msg; 788 789 req.msg = msg; 790 if (devlink->ops->info_get) { 791 err = devlink->ops->info_get(devlink, &req, extack); 792 if (err) 793 goto err_cancel_msg; 794 } 795 796 err = devlink_nl_driver_info_get(dev->driver, &req); 797 if (err) 798 goto err_cancel_msg; 799 800 genlmsg_end(msg, hdr); 801 return 0; 802 803 err_cancel_msg: 804 genlmsg_cancel(msg, hdr); 805 return err; 806 } 807 808 int devlink_nl_info_get_doit(struct sk_buff *skb, struct genl_info *info) 809 { 810 struct devlink *devlink = info->user_ptr[0]; 811 struct sk_buff *msg; 812 int err; 813 814 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 815 if (!msg) 816 return -ENOMEM; 817 818 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET, 819 info->snd_portid, info->snd_seq, 0, 820 info->extack); 821 if (err) { 822 nlmsg_free(msg); 823 return err; 824 } 825 826 return genlmsg_reply(msg, info); 827 } 828 829 static int 830 devlink_nl_info_get_dump_one(struct sk_buff *msg, struct devlink *devlink, 831 struct netlink_callback *cb) 832 { 833 int err; 834 835 err = devlink_nl_info_fill(msg, devlink, DEVLINK_CMD_INFO_GET, 836 NETLINK_CB(cb->skb).portid, 837 cb->nlh->nlmsg_seq, NLM_F_MULTI, 838 cb->extack); 839 if (err == -EOPNOTSUPP) 840 err = 0; 841 return err; 842 } 843 844 int devlink_nl_info_get_dumpit(struct sk_buff *msg, struct netlink_callback *cb) 845 { 846 return devlink_nl_dumpit(msg, cb, devlink_nl_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