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