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