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