net/devlink/dev.c

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