net/devlink/port.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 <jiri@mellanox.com>
   5  */
   6
   7 #include "devl_internal.h"
   8
   9 #define DEVLINK_PORT_FN_CAPS_VALID_MASK \
  10         (_BITUL(__DEVLINK_PORT_FN_ATTR_CAPS_MAX) - 1)
  11
  12 static const struct nla_policy devlink_function_nl_policy[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1] = {
  13         [DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] = { .type = NLA_BINARY },
  14         [DEVLINK_PORT_FN_ATTR_STATE] =
  15                 NLA_POLICY_RANGE(NLA_U8, DEVLINK_PORT_FN_STATE_INACTIVE,
  16                                  DEVLINK_PORT_FN_STATE_ACTIVE),
  17         [DEVLINK_PORT_FN_ATTR_CAPS] =
  18                 NLA_POLICY_BITFIELD32(DEVLINK_PORT_FN_CAPS_VALID_MASK),
  19 };
  20
  21 #define ASSERT_DEVLINK_PORT_REGISTERED(devlink_port)                            \
  22         WARN_ON_ONCE(!(devlink_port)->registered)
  23 #define ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port)                        \
  24         WARN_ON_ONCE((devlink_port)->registered)
  25
  26 struct devlink_port *devlink_port_get_by_index(struct devlink *devlink,
  27                                                unsigned int port_index)
  28 {
  29         return xa_load(&devlink->ports, port_index);
  30 }
  31
  32 struct devlink_port *devlink_port_get_from_attrs(struct devlink *devlink,
  33                                                  struct nlattr **attrs)
  34 {
  35         if (attrs[DEVLINK_ATTR_PORT_INDEX]) {
  36                 u32 port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
  37                 struct devlink_port *devlink_port;
  38
  39                 devlink_port = devlink_port_get_by_index(devlink, port_index);
  40                 if (!devlink_port)
  41                         return ERR_PTR(-ENODEV);
  42                 return devlink_port;
  43         }
  44         return ERR_PTR(-EINVAL);
  45 }
  46
  47 struct devlink_port *devlink_port_get_from_info(struct devlink *devlink,
  48                                                 struct genl_info *info)
  49 {
  50         return devlink_port_get_from_attrs(devlink, info->attrs);
  51 }
  52
  53 static void devlink_port_fn_cap_fill(struct nla_bitfield32 *caps,
  54                                      u32 cap, bool is_enable)
  55 {
  56         caps->selector |= cap;
  57         if (is_enable)
  58                 caps->value |= cap;
  59 }
  60
  61 static int devlink_port_fn_roce_fill(struct devlink_port *devlink_port,
  62                                      struct nla_bitfield32 *caps,
  63                                      struct netlink_ext_ack *extack)
  64 {
  65         bool is_enable;
  66         int err;
  67
  68         if (!devlink_port->ops->port_fn_roce_get)
  69                 return 0;
  70
  71         err = devlink_port->ops->port_fn_roce_get(devlink_port, &is_enable,
  72                                                   extack);
  73         if (err) {
  74                 if (err == -EOPNOTSUPP)
  75                         return 0;
  76                 return err;
  77         }
  78
  79         devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_ROCE, is_enable);
  80         return 0;
  81 }
  82
  83 static int devlink_port_fn_migratable_fill(struct devlink_port *devlink_port,
  84                                            struct nla_bitfield32 *caps,
  85                                            struct netlink_ext_ack *extack)
  86 {
  87         bool is_enable;
  88         int err;
  89
  90         if (!devlink_port->ops->port_fn_migratable_get ||
  91             devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF)
  92                 return 0;
  93
  94         err = devlink_port->ops->port_fn_migratable_get(devlink_port,
  95                                                         &is_enable, extack);
  96         if (err) {
  97                 if (err == -EOPNOTSUPP)
  98                         return 0;
  99                 return err;
 100         }
 101
 102         devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_MIGRATABLE, is_enable);
 103         return 0;
 104 }
 105
 106 static int devlink_port_fn_ipsec_crypto_fill(struct devlink_port *devlink_port,
 107                                              struct nla_bitfield32 *caps,
 108                                              struct netlink_ext_ack *extack)
 109 {
 110         bool is_enable;
 111         int err;
 112
 113         if (!devlink_port->ops->port_fn_ipsec_crypto_get ||
 114             devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF)
 115                 return 0;
 116
 117         err = devlink_port->ops->port_fn_ipsec_crypto_get(devlink_port, &is_enable, extack);
 118         if (err) {
 119                 if (err == -EOPNOTSUPP)
 120                         return 0;
 121                 return err;
 122         }
 123
 124         devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO, is_enable);
 125         return 0;
 126 }
 127
 128 static int devlink_port_fn_ipsec_packet_fill(struct devlink_port *devlink_port,
 129                                              struct nla_bitfield32 *caps,
 130                                              struct netlink_ext_ack *extack)
 131 {
 132         bool is_enable;
 133         int err;
 134
 135         if (!devlink_port->ops->port_fn_ipsec_packet_get ||
 136             devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF)
 137                 return 0;
 138
 139         err = devlink_port->ops->port_fn_ipsec_packet_get(devlink_port, &is_enable, extack);
 140         if (err) {
 141                 if (err == -EOPNOTSUPP)
 142                         return 0;
 143                 return err;
 144         }
 145
 146         devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_IPSEC_PACKET, is_enable);
 147         return 0;
 148 }
 149
 150 static int devlink_port_fn_caps_fill(struct devlink_port *devlink_port,
 151                                      struct sk_buff *msg,
 152                                      struct netlink_ext_ack *extack,
 153                                      bool *msg_updated)
 154 {
 155         struct nla_bitfield32 caps = {};
 156         int err;
 157
 158         err = devlink_port_fn_roce_fill(devlink_port, &caps, extack);
 159         if (err)
 160                 return err;
 161
 162         err = devlink_port_fn_migratable_fill(devlink_port, &caps, extack);
 163         if (err)
 164                 return err;
 165
 166         err = devlink_port_fn_ipsec_crypto_fill(devlink_port, &caps, extack);
 167         if (err)
 168                 return err;
 169
 170         err = devlink_port_fn_ipsec_packet_fill(devlink_port, &caps, extack);
 171         if (err)
 172                 return err;
 173
 174         if (!caps.selector)
 175                 return 0;
 176         err = nla_put_bitfield32(msg, DEVLINK_PORT_FN_ATTR_CAPS, caps.value,
 177                                  caps.selector);
 178         if (err)
 179                 return err;
 180
 181         *msg_updated = true;
 182         return 0;
 183 }
 184
 185 int devlink_nl_port_handle_fill(struct sk_buff *msg, struct devlink_port *devlink_port)
 186 {
 187         if (devlink_nl_put_handle(msg, devlink_port->devlink))
 188                 return -EMSGSIZE;
 189         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
 190                 return -EMSGSIZE;
 191         return 0;
 192 }
 193
 194 size_t devlink_nl_port_handle_size(struct devlink_port *devlink_port)
 195 {
 196         struct devlink *devlink = devlink_port->devlink;
 197
 198         return nla_total_size(strlen(devlink->dev->bus->name) + 1) /* DEVLINK_ATTR_BUS_NAME */
 199              + nla_total_size(strlen(dev_name(devlink->dev)) + 1) /* DEVLINK_ATTR_DEV_NAME */
 200              + nla_total_size(4); /* DEVLINK_ATTR_PORT_INDEX */
 201 }
 202
 203 static int devlink_nl_port_attrs_put(struct sk_buff *msg,
 204                                      struct devlink_port *devlink_port)
 205 {
 206         struct devlink_port_attrs *attrs = &devlink_port->attrs;
 207
 208         if (!devlink_port->attrs_set)
 209                 return 0;
 210         if (attrs->lanes) {
 211                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_LANES, attrs->lanes))
 212                         return -EMSGSIZE;
 213         }
 214         if (nla_put_u8(msg, DEVLINK_ATTR_PORT_SPLITTABLE, attrs->splittable))
 215                 return -EMSGSIZE;
 216         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_FLAVOUR, attrs->flavour))
 217                 return -EMSGSIZE;
 218         switch (devlink_port->attrs.flavour) {
 219         case DEVLINK_PORT_FLAVOUR_PCI_PF:
 220                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
 221                                 attrs->pci_pf.controller) ||
 222                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_pf.pf))
 223                         return -EMSGSIZE;
 224                 if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_pf.external))
 225                         return -EMSGSIZE;
 226                 break;
 227         case DEVLINK_PORT_FLAVOUR_PCI_VF:
 228                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
 229                                 attrs->pci_vf.controller) ||
 230                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_vf.pf) ||
 231                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_VF_NUMBER, attrs->pci_vf.vf))
 232                         return -EMSGSIZE;
 233                 if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_vf.external))
 234                         return -EMSGSIZE;
 235                 break;
 236         case DEVLINK_PORT_FLAVOUR_PCI_SF:
 237                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER,
 238                                 attrs->pci_sf.controller) ||
 239                     nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER,
 240                                 attrs->pci_sf.pf) ||
 241                     nla_put_u32(msg, DEVLINK_ATTR_PORT_PCI_SF_NUMBER,
 242                                 attrs->pci_sf.sf))
 243                         return -EMSGSIZE;
 244                 break;
 245         case DEVLINK_PORT_FLAVOUR_PHYSICAL:
 246         case DEVLINK_PORT_FLAVOUR_CPU:
 247         case DEVLINK_PORT_FLAVOUR_DSA:
 248                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_NUMBER,
 249                                 attrs->phys.port_number))
 250                         return -EMSGSIZE;
 251                 if (!attrs->split)
 252                         return 0;
 253                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP,
 254                                 attrs->phys.port_number))
 255                         return -EMSGSIZE;
 256                 if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER,
 257                                 attrs->phys.split_subport_number))
 258                         return -EMSGSIZE;
 259                 break;
 260         default:
 261                 break;
 262         }
 263         return 0;
 264 }
 265
 266 static int devlink_port_fn_hw_addr_fill(struct devlink_port *port,
 267                                         struct sk_buff *msg,
 268                                         struct netlink_ext_ack *extack,
 269                                         bool *msg_updated)
 270 {
 271         u8 hw_addr[MAX_ADDR_LEN];
 272         int hw_addr_len;
 273         int err;
 274
 275         if (!port->ops->port_fn_hw_addr_get)
 276                 return 0;
 277
 278         err = port->ops->port_fn_hw_addr_get(port, hw_addr, &hw_addr_len,
 279                                              extack);
 280         if (err) {
 281                 if (err == -EOPNOTSUPP)
 282                         return 0;
 283                 return err;
 284         }
 285         err = nla_put(msg, DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR, hw_addr_len, hw_addr);
 286         if (err)
 287                 return err;
 288         *msg_updated = true;
 289         return 0;
 290 }
 291
 292 static bool
 293 devlink_port_fn_state_valid(enum devlink_port_fn_state state)
 294 {
 295         return state == DEVLINK_PORT_FN_STATE_INACTIVE ||
 296                state == DEVLINK_PORT_FN_STATE_ACTIVE;
 297 }
 298
 299 static bool
 300 devlink_port_fn_opstate_valid(enum devlink_port_fn_opstate opstate)
 301 {
 302         return opstate == DEVLINK_PORT_FN_OPSTATE_DETACHED ||
 303                opstate == DEVLINK_PORT_FN_OPSTATE_ATTACHED;
 304 }
 305
 306 static int devlink_port_fn_state_fill(struct devlink_port *port,
 307                                       struct sk_buff *msg,
 308                                       struct netlink_ext_ack *extack,
 309                                       bool *msg_updated)
 310 {
 311         enum devlink_port_fn_opstate opstate;
 312         enum devlink_port_fn_state state;
 313         int err;
 314
 315         if (!port->ops->port_fn_state_get)
 316                 return 0;
 317
 318         err = port->ops->port_fn_state_get(port, &state, &opstate, extack);
 319         if (err) {
 320                 if (err == -EOPNOTSUPP)
 321                         return 0;
 322                 return err;
 323         }
 324         if (!devlink_port_fn_state_valid(state)) {
 325                 WARN_ON_ONCE(1);
 326                 NL_SET_ERR_MSG(extack, "Invalid state read from driver");
 327                 return -EINVAL;
 328         }
 329         if (!devlink_port_fn_opstate_valid(opstate)) {
 330                 WARN_ON_ONCE(1);
 331                 NL_SET_ERR_MSG(extack, "Invalid operational state read from driver");
 332                 return -EINVAL;
 333         }
 334         if (nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_STATE, state) ||
 335             nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_OPSTATE, opstate))
 336                 return -EMSGSIZE;
 337         *msg_updated = true;
 338         return 0;
 339 }
 340
 341 static int
 342 devlink_port_fn_mig_set(struct devlink_port *devlink_port, bool enable,
 343                         struct netlink_ext_ack *extack)
 344 {
 345         return devlink_port->ops->port_fn_migratable_set(devlink_port, enable,
 346                                                          extack);
 347 }
 348
 349 static int
 350 devlink_port_fn_roce_set(struct devlink_port *devlink_port, bool enable,
 351                          struct netlink_ext_ack *extack)
 352 {
 353         return devlink_port->ops->port_fn_roce_set(devlink_port, enable,
 354                                                    extack);
 355 }
 356
 357 static int
 358 devlink_port_fn_ipsec_crypto_set(struct devlink_port *devlink_port, bool enable,
 359                                  struct netlink_ext_ack *extack)
 360 {
 361         return devlink_port->ops->port_fn_ipsec_crypto_set(devlink_port, enable, extack);
 362 }
 363
 364 static int
 365 devlink_port_fn_ipsec_packet_set(struct devlink_port *devlink_port, bool enable,
 366                                  struct netlink_ext_ack *extack)
 367 {
 368         return devlink_port->ops->port_fn_ipsec_packet_set(devlink_port, enable, extack);
 369 }
 370
 371 static int devlink_port_fn_caps_set(struct devlink_port *devlink_port,
 372                                     const struct nlattr *attr,
 373                                     struct netlink_ext_ack *extack)
 374 {
 375         struct nla_bitfield32 caps;
 376         u32 caps_value;
 377         int err;
 378
 379         caps = nla_get_bitfield32(attr);
 380         caps_value = caps.value & caps.selector;
 381         if (caps.selector & DEVLINK_PORT_FN_CAP_ROCE) {
 382                 err = devlink_port_fn_roce_set(devlink_port,
 383                                                caps_value & DEVLINK_PORT_FN_CAP_ROCE,
 384                                                extack);
 385                 if (err)
 386                         return err;
 387         }
 388         if (caps.selector & DEVLINK_PORT_FN_CAP_MIGRATABLE) {
 389                 err = devlink_port_fn_mig_set(devlink_port, caps_value &
 390                                               DEVLINK_PORT_FN_CAP_MIGRATABLE,
 391                                               extack);
 392                 if (err)
 393                         return err;
 394         }
 395         if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO) {
 396                 err = devlink_port_fn_ipsec_crypto_set(devlink_port, caps_value &
 397                                                        DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO,
 398                                                        extack);
 399                 if (err)
 400                         return err;
 401         }
 402         if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_PACKET) {
 403                 err = devlink_port_fn_ipsec_packet_set(devlink_port, caps_value &
 404                                                        DEVLINK_PORT_FN_CAP_IPSEC_PACKET,
 405                                                        extack);
 406                 if (err)
 407                         return err;
 408         }
 409         return 0;
 410 }
 411
 412 static int
 413 devlink_nl_port_function_attrs_put(struct sk_buff *msg, struct devlink_port *port,
 414                                    struct netlink_ext_ack *extack)
 415 {
 416         struct nlattr *function_attr;
 417         bool msg_updated = false;
 418         int err;
 419
 420         function_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PORT_FUNCTION);
 421         if (!function_attr)
 422                 return -EMSGSIZE;
 423
 424         err = devlink_port_fn_hw_addr_fill(port, msg, extack, &msg_updated);
 425         if (err)
 426                 goto out;
 427         err = devlink_port_fn_caps_fill(port, msg, extack, &msg_updated);
 428         if (err)
 429                 goto out;
 430         err = devlink_port_fn_state_fill(port, msg, extack, &msg_updated);
 431         if (err)
 432                 goto out;
 433         err = devlink_rel_devlink_handle_put(msg, port->devlink,
 434                                              port->rel_index,
 435                                              DEVLINK_PORT_FN_ATTR_DEVLINK,
 436                                              &msg_updated);
 437
 438 out:
 439         if (err || !msg_updated)
 440                 nla_nest_cancel(msg, function_attr);
 441         else
 442                 nla_nest_end(msg, function_attr);
 443         return err;
 444 }
 445
 446 static int devlink_nl_port_fill(struct sk_buff *msg,
 447                                 struct devlink_port *devlink_port,
 448                                 enum devlink_command cmd, u32 portid, u32 seq,
 449                                 int flags, struct netlink_ext_ack *extack)
 450 {
 451         struct devlink *devlink = devlink_port->devlink;
 452         void *hdr;
 453
 454         hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
 455         if (!hdr)
 456                 return -EMSGSIZE;
 457
 458         if (devlink_nl_put_handle(msg, devlink))
 459                 goto nla_put_failure;
 460         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
 461                 goto nla_put_failure;
 462
 463         spin_lock_bh(&devlink_port->type_lock);
 464         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
 465                 goto nla_put_failure_type_locked;
 466         if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
 467             nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE,
 468                         devlink_port->desired_type))
 469                 goto nla_put_failure_type_locked;
 470         if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) {
 471                 if (devlink_port->type_eth.netdev &&
 472                     (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX,
 473                                  devlink_port->type_eth.ifindex) ||
 474                      nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME,
 475                                     devlink_port->type_eth.ifname)))
 476                         goto nla_put_failure_type_locked;
 477         }
 478         if (devlink_port->type == DEVLINK_PORT_TYPE_IB) {
 479                 struct ib_device *ibdev = devlink_port->type_ib.ibdev;
 480
 481                 if (ibdev &&
 482                     nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME,
 483                                    ibdev->name))
 484                         goto nla_put_failure_type_locked;
 485         }
 486         spin_unlock_bh(&devlink_port->type_lock);
 487         if (devlink_nl_port_attrs_put(msg, devlink_port))
 488                 goto nla_put_failure;
 489         if (devlink_nl_port_function_attrs_put(msg, devlink_port, extack))
 490                 goto nla_put_failure;
 491         if (devlink_port->linecard &&
 492             nla_put_u32(msg, DEVLINK_ATTR_LINECARD_INDEX,
 493                         devlink_linecard_index(devlink_port->linecard)))
 494                 goto nla_put_failure;
 495
 496         genlmsg_end(msg, hdr);
 497         return 0;
 498
 499 nla_put_failure_type_locked:
 500         spin_unlock_bh(&devlink_port->type_lock);
 501 nla_put_failure:
 502         genlmsg_cancel(msg, hdr);
 503         return -EMSGSIZE;
 504 }
 505
 506 static void devlink_port_notify(struct devlink_port *devlink_port,
 507                                 enum devlink_command cmd)
 508 {
 509         struct devlink *devlink = devlink_port->devlink;
 510         struct devlink_obj_desc desc;
 511         struct sk_buff *msg;
 512         int err;
 513
 514         WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL);
 515
 516         if (!__devl_is_registered(devlink) || !devlink_nl_notify_need(devlink))
 517                 return;
 518
 519         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 520         if (!msg)
 521                 return;
 522
 523         err = devlink_nl_port_fill(msg, devlink_port, cmd, 0, 0, 0, NULL);
 524         if (err) {
 525                 nlmsg_free(msg);
 526                 return;
 527         }
 528
 529         devlink_nl_obj_desc_init(&desc, devlink);
 530         devlink_nl_obj_desc_port_set(&desc, devlink_port);
 531         devlink_nl_notify_send_desc(devlink, msg, &desc);
 532 }
 533
 534 static void devlink_ports_notify(struct devlink *devlink,
 535                                  enum devlink_command cmd)
 536 {
 537         struct devlink_port *devlink_port;
 538         unsigned long port_index;
 539
 540         xa_for_each(&devlink->ports, port_index, devlink_port)
 541                 devlink_port_notify(devlink_port, cmd);
 542 }
 543
 544 void devlink_ports_notify_register(struct devlink *devlink)
 545 {
 546         devlink_ports_notify(devlink, DEVLINK_CMD_PORT_NEW);
 547 }
 548
 549 void devlink_ports_notify_unregister(struct devlink *devlink)
 550 {
 551         devlink_ports_notify(devlink, DEVLINK_CMD_PORT_DEL);
 552 }
 553
 554 int devlink_nl_port_get_doit(struct sk_buff *skb, struct genl_info *info)
 555 {
 556         struct devlink_port *devlink_port = info->user_ptr[1];
 557         struct sk_buff *msg;
 558         int err;
 559
 560         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 561         if (!msg)
 562                 return -ENOMEM;
 563
 564         err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_PORT_NEW,
 565                                    info->snd_portid, info->snd_seq, 0,
 566                                    info->extack);
 567         if (err) {
 568                 nlmsg_free(msg);
 569                 return err;
 570         }
 571
 572         return genlmsg_reply(msg, info);
 573 }
 574
 575 static int
 576 devlink_nl_port_get_dump_one(struct sk_buff *msg, struct devlink *devlink,
 577                              struct netlink_callback *cb, int flags)
 578 {
 579         struct devlink_nl_dump_state *state = devlink_dump_state(cb);
 580         struct devlink_port *devlink_port;
 581         unsigned long port_index;
 582         int err = 0;
 583
 584         xa_for_each_start(&devlink->ports, port_index, devlink_port, state->idx) {
 585                 err = devlink_nl_port_fill(msg, devlink_port,
 586                                            DEVLINK_CMD_PORT_NEW,
 587                                            NETLINK_CB(cb->skb).portid,
 588                                            cb->nlh->nlmsg_seq, flags,
 589                                            cb->extack);
 590                 if (err) {
 591                         state->idx = port_index;
 592                         break;
 593                 }
 594         }
 595
 596         return err;
 597 }
 598
 599 int devlink_nl_port_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
 600 {
 601         return devlink_nl_dumpit(skb, cb, devlink_nl_port_get_dump_one);
 602 }
 603
 604 static int devlink_port_type_set(struct devlink_port *devlink_port,
 605                                  enum devlink_port_type port_type)
 606
 607 {
 608         int err;
 609
 610         if (!devlink_port->ops->port_type_set)
 611                 return -EOPNOTSUPP;
 612
 613         if (port_type == devlink_port->type)
 614                 return 0;
 615
 616         err = devlink_port->ops->port_type_set(devlink_port, port_type);
 617         if (err)
 618                 return err;
 619
 620         devlink_port->desired_type = port_type;
 621         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
 622         return 0;
 623 }
 624
 625 static int devlink_port_function_hw_addr_set(struct devlink_port *port,
 626                                              const struct nlattr *attr,
 627                                              struct netlink_ext_ack *extack)
 628 {
 629         const u8 *hw_addr;
 630         int hw_addr_len;
 631
 632         hw_addr = nla_data(attr);
 633         hw_addr_len = nla_len(attr);
 634         if (hw_addr_len > MAX_ADDR_LEN) {
 635                 NL_SET_ERR_MSG(extack, "Port function hardware address too long");
 636                 return -EINVAL;
 637         }
 638         if (port->type == DEVLINK_PORT_TYPE_ETH) {
 639                 if (hw_addr_len != ETH_ALEN) {
 640                         NL_SET_ERR_MSG(extack, "Address must be 6 bytes for Ethernet device");
 641                         return -EINVAL;
 642                 }
 643                 if (!is_unicast_ether_addr(hw_addr)) {
 644                         NL_SET_ERR_MSG(extack, "Non-unicast hardware address unsupported");
 645                         return -EINVAL;
 646                 }
 647         }
 648
 649         return port->ops->port_fn_hw_addr_set(port, hw_addr, hw_addr_len,
 650                                               extack);
 651 }
 652
 653 static int devlink_port_fn_state_set(struct devlink_port *port,
 654                                      const struct nlattr *attr,
 655                                      struct netlink_ext_ack *extack)
 656 {
 657         enum devlink_port_fn_state state;
 658
 659         state = nla_get_u8(attr);
 660         return port->ops->port_fn_state_set(port, state, extack);
 661 }
 662
 663 static int devlink_port_function_validate(struct devlink_port *devlink_port,
 664                                           struct nlattr **tb,
 665                                           struct netlink_ext_ack *extack)
 666 {
 667         const struct devlink_port_ops *ops = devlink_port->ops;
 668         struct nlattr *attr;
 669
 670         if (tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] &&
 671             !ops->port_fn_hw_addr_set) {
 672                 NL_SET_ERR_MSG_ATTR(extack, tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR],
 673                                     "Port doesn't support function attributes");
 674                 return -EOPNOTSUPP;
 675         }
 676         if (tb[DEVLINK_PORT_FN_ATTR_STATE] && !ops->port_fn_state_set) {
 677                 NL_SET_ERR_MSG_ATTR(extack, tb[DEVLINK_PORT_FN_ATTR_STATE],
 678                                     "Function does not support state setting");
 679                 return -EOPNOTSUPP;
 680         }
 681         attr = tb[DEVLINK_PORT_FN_ATTR_CAPS];
 682         if (attr) {
 683                 struct nla_bitfield32 caps;
 684
 685                 caps = nla_get_bitfield32(attr);
 686                 if (caps.selector & DEVLINK_PORT_FN_CAP_ROCE &&
 687                     !ops->port_fn_roce_set) {
 688                         NL_SET_ERR_MSG_ATTR(extack, attr,
 689                                             "Port doesn't support RoCE function attribute");
 690                         return -EOPNOTSUPP;
 691                 }
 692                 if (caps.selector & DEVLINK_PORT_FN_CAP_MIGRATABLE) {
 693                         if (!ops->port_fn_migratable_set) {
 694                                 NL_SET_ERR_MSG_ATTR(extack, attr,
 695                                                     "Port doesn't support migratable function attribute");
 696                                 return -EOPNOTSUPP;
 697                         }
 698                         if (devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) {
 699                                 NL_SET_ERR_MSG_ATTR(extack, attr,
 700                                                     "migratable function attribute supported for VFs only");
 701                                 return -EOPNOTSUPP;
 702                         }
 703                 }
 704                 if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO) {
 705                         if (!ops->port_fn_ipsec_crypto_set) {
 706                                 NL_SET_ERR_MSG_ATTR(extack, attr,
 707                                                     "Port doesn't support ipsec_crypto function attribute");
 708                                 return -EOPNOTSUPP;
 709                         }
 710                         if (devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) {
 711                                 NL_SET_ERR_MSG_ATTR(extack, attr,
 712                                                     "ipsec_crypto function attribute supported for VFs only");
 713                                 return -EOPNOTSUPP;
 714                         }
 715                 }
 716                 if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_PACKET) {
 717                         if (!ops->port_fn_ipsec_packet_set) {
 718                                 NL_SET_ERR_MSG_ATTR(extack, attr,
 719                                                     "Port doesn't support ipsec_packet function attribute");
 720                                 return -EOPNOTSUPP;
 721                         }
 722                         if (devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) {
 723                                 NL_SET_ERR_MSG_ATTR(extack, attr,
 724                                                     "ipsec_packet function attribute supported for VFs only");
 725                                 return -EOPNOTSUPP;
 726                         }
 727                 }
 728         }
 729         return 0;
 730 }
 731
 732 static int devlink_port_function_set(struct devlink_port *port,
 733                                      const struct nlattr *attr,
 734                                      struct netlink_ext_ack *extack)
 735 {
 736         struct nlattr *tb[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1];
 737         int err;
 738
 739         err = nla_parse_nested(tb, DEVLINK_PORT_FUNCTION_ATTR_MAX, attr,
 740                                devlink_function_nl_policy, extack);
 741         if (err < 0) {
 742                 NL_SET_ERR_MSG(extack, "Fail to parse port function attributes");
 743                 return err;
 744         }
 745
 746         err = devlink_port_function_validate(port, tb, extack);
 747         if (err)
 748                 return err;
 749
 750         attr = tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR];
 751         if (attr) {
 752                 err = devlink_port_function_hw_addr_set(port, attr, extack);
 753                 if (err)
 754                         return err;
 755         }
 756
 757         attr = tb[DEVLINK_PORT_FN_ATTR_CAPS];
 758         if (attr) {
 759                 err = devlink_port_fn_caps_set(port, attr, extack);
 760                 if (err)
 761                         return err;
 762         }
 763
 764         /* Keep this as the last function attribute set, so that when
 765          * multiple port function attributes are set along with state,
 766          * Those can be applied first before activating the state.
 767          */
 768         attr = tb[DEVLINK_PORT_FN_ATTR_STATE];
 769         if (attr)
 770                 err = devlink_port_fn_state_set(port, attr, extack);
 771
 772         if (!err)
 773                 devlink_port_notify(port, DEVLINK_CMD_PORT_NEW);
 774         return err;
 775 }
 776
 777 int devlink_nl_port_set_doit(struct sk_buff *skb, struct genl_info *info)
 778 {
 779         struct devlink_port *devlink_port = info->user_ptr[1];
 780         int err;
 781
 782         if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) {
 783                 enum devlink_port_type port_type;
 784
 785                 port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]);
 786                 err = devlink_port_type_set(devlink_port, port_type);
 787                 if (err)
 788                         return err;
 789         }
 790
 791         if (info->attrs[DEVLINK_ATTR_PORT_FUNCTION]) {
 792                 struct nlattr *attr = info->attrs[DEVLINK_ATTR_PORT_FUNCTION];
 793                 struct netlink_ext_ack *extack = info->extack;
 794
 795                 err = devlink_port_function_set(devlink_port, attr, extack);
 796                 if (err)
 797                         return err;
 798         }
 799
 800         return 0;
 801 }
 802
 803 int devlink_nl_port_split_doit(struct sk_buff *skb, struct genl_info *info)
 804 {
 805         struct devlink_port *devlink_port = info->user_ptr[1];
 806         struct devlink *devlink = info->user_ptr[0];
 807         u32 count;
 808
 809         if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_PORT_SPLIT_COUNT))
 810                 return -EINVAL;
 811         if (!devlink_port->ops->port_split)
 812                 return -EOPNOTSUPP;
 813
 814         count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]);
 815
 816         if (!devlink_port->attrs.splittable) {
 817                 /* Split ports cannot be split. */
 818                 if (devlink_port->attrs.split)
 819                         NL_SET_ERR_MSG(info->extack, "Port cannot be split further");
 820                 else
 821                         NL_SET_ERR_MSG(info->extack, "Port cannot be split");
 822                 return -EINVAL;
 823         }
 824
 825         if (count < 2 || !is_power_of_2(count) || count > devlink_port->attrs.lanes) {
 826                 NL_SET_ERR_MSG(info->extack, "Invalid split count");
 827                 return -EINVAL;
 828         }
 829
 830         return devlink_port->ops->port_split(devlink, devlink_port, count,
 831                                              info->extack);
 832 }
 833
 834 int devlink_nl_port_unsplit_doit(struct sk_buff *skb, struct genl_info *info)
 835 {
 836         struct devlink_port *devlink_port = info->user_ptr[1];
 837         struct devlink *devlink = info->user_ptr[0];
 838
 839         if (!devlink_port->ops->port_unsplit)
 840                 return -EOPNOTSUPP;
 841         return devlink_port->ops->port_unsplit(devlink, devlink_port, info->extack);
 842 }
 843
 844 int devlink_nl_port_new_doit(struct sk_buff *skb, struct genl_info *info)
 845 {
 846         struct netlink_ext_ack *extack = info->extack;
 847         struct devlink_port_new_attrs new_attrs = {};
 848         struct devlink *devlink = info->user_ptr[0];
 849         struct devlink_port *devlink_port;
 850         struct sk_buff *msg;
 851         int err;
 852
 853         if (!devlink->ops->port_new)
 854                 return -EOPNOTSUPP;
 855
 856         if (!info->attrs[DEVLINK_ATTR_PORT_FLAVOUR] ||
 857             !info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]) {
 858                 NL_SET_ERR_MSG(extack, "Port flavour or PCI PF are not specified");
 859                 return -EINVAL;
 860         }
 861         new_attrs.flavour = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_FLAVOUR]);
 862         new_attrs.pfnum =
 863                 nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]);
 864
 865         if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) {
 866                 /* Port index of the new port being created by driver. */
 867                 new_attrs.port_index =
 868                         nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]);
 869                 new_attrs.port_index_valid = true;
 870         }
 871         if (info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]) {
 872                 new_attrs.controller =
 873                         nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]);
 874                 new_attrs.controller_valid = true;
 875         }
 876         if (new_attrs.flavour == DEVLINK_PORT_FLAVOUR_PCI_SF &&
 877             info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]) {
 878                 new_attrs.sfnum = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]);
 879                 new_attrs.sfnum_valid = true;
 880         }
 881
 882         err = devlink->ops->port_new(devlink, &new_attrs,
 883                                      extack, &devlink_port);
 884         if (err)
 885                 return err;
 886
 887         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 888         if (!msg) {
 889                 err = -ENOMEM;
 890                 goto err_out_port_del;
 891         }
 892         err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_PORT_NEW,
 893                                    info->snd_portid, info->snd_seq, 0, NULL);
 894         if (WARN_ON_ONCE(err))
 895                 goto err_out_msg_free;
 896         err = genlmsg_reply(msg, info);
 897         if (err)
 898                 goto err_out_port_del;
 899         return 0;
 900
 901 err_out_msg_free:
 902         nlmsg_free(msg);
 903 err_out_port_del:
 904         devlink_port->ops->port_del(devlink, devlink_port, NULL);
 905         return err;
 906 }
 907
 908 int devlink_nl_port_del_doit(struct sk_buff *skb, struct genl_info *info)
 909 {
 910         struct devlink_port *devlink_port = info->user_ptr[1];
 911         struct netlink_ext_ack *extack = info->extack;
 912         struct devlink *devlink = info->user_ptr[0];
 913
 914         if (!devlink_port->ops->port_del)
 915                 return -EOPNOTSUPP;
 916
 917         return devlink_port->ops->port_del(devlink, devlink_port, extack);
 918 }
 919
 920 static void devlink_port_type_warn(struct work_struct *work)
 921 {
 922         struct devlink_port *port = container_of(to_delayed_work(work),
 923                                                  struct devlink_port,
 924                                                  type_warn_dw);
 925         dev_warn(port->devlink->dev, "Type was not set for devlink port.");
 926 }
 927
 928 static bool devlink_port_type_should_warn(struct devlink_port *devlink_port)
 929 {
 930         /* Ignore CPU and DSA flavours. */
 931         return devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_CPU &&
 932                devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA &&
 933                devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_UNUSED;
 934 }
 935
 936 #define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 3600)
 937
 938 static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)
 939 {
 940         if (!devlink_port_type_should_warn(devlink_port))
 941                 return;
 942         /* Schedule a work to WARN in case driver does not set port
 943          * type within timeout.
 944          */
 945         schedule_delayed_work(&devlink_port->type_warn_dw,
 946                               DEVLINK_PORT_TYPE_WARN_TIMEOUT);
 947 }
 948
 949 static void devlink_port_type_warn_cancel(struct devlink_port *devlink_port)
 950 {
 951         if (!devlink_port_type_should_warn(devlink_port))
 952                 return;
 953         cancel_delayed_work_sync(&devlink_port->type_warn_dw);
 954 }
 955
 956 /**
 957  * devlink_port_init() - Init devlink port
 958  *
 959  * @devlink: devlink
 960  * @devlink_port: devlink port
 961  *
 962  * Initialize essential stuff that is needed for functions
 963  * that may be called before devlink port registration.
 964  * Call to this function is optional and not needed
 965  * in case the driver does not use such functions.
 966  */
 967 void devlink_port_init(struct devlink *devlink,
 968                        struct devlink_port *devlink_port)
 969 {
 970         if (devlink_port->initialized)
 971                 return;
 972         devlink_port->devlink = devlink;
 973         INIT_LIST_HEAD(&devlink_port->region_list);
 974         devlink_port->initialized = true;
 975 }
 976 EXPORT_SYMBOL_GPL(devlink_port_init);
 977
 978 /**
 979  * devlink_port_fini() - Deinitialize devlink port
 980  *
 981  * @devlink_port: devlink port
 982  *
 983  * Deinitialize essential stuff that is in use for functions
 984  * that may be called after devlink port unregistration.
 985  * Call to this function is optional and not needed
 986  * in case the driver does not use such functions.
 987  */
 988 void devlink_port_fini(struct devlink_port *devlink_port)
 989 {
 990         WARN_ON(!list_empty(&devlink_port->region_list));
 991 }
 992 EXPORT_SYMBOL_GPL(devlink_port_fini);
 993
 994 static const struct devlink_port_ops devlink_port_dummy_ops = {};
 995
 996 /**
 997  * devl_port_register_with_ops() - Register devlink port
 998  *
 999  * @devlink: devlink
1000  * @devlink_port: devlink port
1001  * @port_index: driver-specific numerical identifier of the port
1002  * @ops: port ops
1003  *
1004  * Register devlink port with provided port index. User can use
1005  * any indexing, even hw-related one. devlink_port structure
1006  * is convenient to be embedded inside user driver private structure.
1007  * Note that the caller should take care of zeroing the devlink_port
1008  * structure.
1009  */
1010 int devl_port_register_with_ops(struct devlink *devlink,
1011                                 struct devlink_port *devlink_port,
1012                                 unsigned int port_index,
1013                                 const struct devlink_port_ops *ops)
1014 {
1015         int err;
1016
1017         devl_assert_locked(devlink);
1018
1019         ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port);
1020
1021         devlink_port_init(devlink, devlink_port);
1022         devlink_port->registered = true;
1023         devlink_port->index = port_index;
1024         devlink_port->ops = ops ? ops : &devlink_port_dummy_ops;
1025         spin_lock_init(&devlink_port->type_lock);
1026         INIT_LIST_HEAD(&devlink_port->reporter_list);
1027         err = xa_insert(&devlink->ports, port_index, devlink_port, GFP_KERNEL);
1028         if (err) {
1029                 devlink_port->registered = false;
1030                 return err;
1031         }
1032
1033         INIT_DELAYED_WORK(&devlink_port->type_warn_dw, &devlink_port_type_warn);
1034         devlink_port_type_warn_schedule(devlink_port);
1035         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
1036         return 0;
1037 }
1038 EXPORT_SYMBOL_GPL(devl_port_register_with_ops);
1039
1040 /**
1041  *      devlink_port_register_with_ops - Register devlink port
1042  *
1043  *      @devlink: devlink
1044  *      @devlink_port: devlink port
1045  *      @port_index: driver-specific numerical identifier of the port
1046  *      @ops: port ops
1047  *
1048  *      Register devlink port with provided port index. User can use
1049  *      any indexing, even hw-related one. devlink_port structure
1050  *      is convenient to be embedded inside user driver private structure.
1051  *      Note that the caller should take care of zeroing the devlink_port
1052  *      structure.
1053  *
1054  *      Context: Takes and release devlink->lock <mutex>.
1055  */
1056 int devlink_port_register_with_ops(struct devlink *devlink,
1057                                    struct devlink_port *devlink_port,
1058                                    unsigned int port_index,
1059                                    const struct devlink_port_ops *ops)
1060 {
1061         int err;
1062
1063         devl_lock(devlink);
1064         err = devl_port_register_with_ops(devlink, devlink_port,
1065                                           port_index, ops);
1066         devl_unlock(devlink);
1067         return err;
1068 }
1069 EXPORT_SYMBOL_GPL(devlink_port_register_with_ops);
1070
1071 /**
1072  * devl_port_unregister() - Unregister devlink port
1073  *
1074  * @devlink_port: devlink port
1075  */
1076 void devl_port_unregister(struct devlink_port *devlink_port)
1077 {
1078         lockdep_assert_held(&devlink_port->devlink->lock);
1079         WARN_ON(devlink_port->type != DEVLINK_PORT_TYPE_NOTSET);
1080
1081         devlink_port_type_warn_cancel(devlink_port);
1082         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL);
1083         xa_erase(&devlink_port->devlink->ports, devlink_port->index);
1084         WARN_ON(!list_empty(&devlink_port->reporter_list));
1085         devlink_port->registered = false;
1086 }
1087 EXPORT_SYMBOL_GPL(devl_port_unregister);
1088
1089 /**
1090  *      devlink_port_unregister - Unregister devlink port
1091  *
1092  *      @devlink_port: devlink port
1093  *
1094  *      Context: Takes and release devlink->lock <mutex>.
1095  */
1096 void devlink_port_unregister(struct devlink_port *devlink_port)
1097 {
1098         struct devlink *devlink = devlink_port->devlink;
1099
1100         devl_lock(devlink);
1101         devl_port_unregister(devlink_port);
1102         devl_unlock(devlink);
1103 }
1104 EXPORT_SYMBOL_GPL(devlink_port_unregister);
1105
1106 static void devlink_port_type_netdev_checks(struct devlink_port *devlink_port,
1107                                             struct net_device *netdev)
1108 {
1109         const struct net_device_ops *ops = netdev->netdev_ops;
1110
1111         /* If driver registers devlink port, it should set devlink port
1112          * attributes accordingly so the compat functions are called
1113          * and the original ops are not used.
1114          */
1115         if (ops->ndo_get_phys_port_name) {
1116                 /* Some drivers use the same set of ndos for netdevs
1117                  * that have devlink_port registered and also for
1118                  * those who don't. Make sure that ndo_get_phys_port_name
1119                  * returns -EOPNOTSUPP here in case it is defined.
1120                  * Warn if not.
1121                  */
1122                 char name[IFNAMSIZ];
1123                 int err;
1124
1125                 err = ops->ndo_get_phys_port_name(netdev, name, sizeof(name));
1126                 WARN_ON(err != -EOPNOTSUPP);
1127         }
1128         if (ops->ndo_get_port_parent_id) {
1129                 /* Some drivers use the same set of ndos for netdevs
1130                  * that have devlink_port registered and also for
1131                  * those who don't. Make sure that ndo_get_port_parent_id
1132                  * returns -EOPNOTSUPP here in case it is defined.
1133                  * Warn if not.
1134                  */
1135                 struct netdev_phys_item_id ppid;
1136                 int err;
1137
1138                 err = ops->ndo_get_port_parent_id(netdev, &ppid);
1139                 WARN_ON(err != -EOPNOTSUPP);
1140         }
1141 }
1142
1143 static void __devlink_port_type_set(struct devlink_port *devlink_port,
1144                                     enum devlink_port_type type,
1145                                     void *type_dev)
1146 {
1147         struct net_device *netdev = type_dev;
1148
1149         ASSERT_DEVLINK_PORT_REGISTERED(devlink_port);
1150
1151         if (type == DEVLINK_PORT_TYPE_NOTSET) {
1152                 devlink_port_type_warn_schedule(devlink_port);
1153         } else {
1154                 devlink_port_type_warn_cancel(devlink_port);
1155                 if (type == DEVLINK_PORT_TYPE_ETH && netdev)
1156                         devlink_port_type_netdev_checks(devlink_port, netdev);
1157         }
1158
1159         spin_lock_bh(&devlink_port->type_lock);
1160         devlink_port->type = type;
1161         switch (type) {
1162         case DEVLINK_PORT_TYPE_ETH:
1163                 devlink_port->type_eth.netdev = netdev;
1164                 if (netdev) {
1165                         ASSERT_RTNL();
1166                         devlink_port->type_eth.ifindex = netdev->ifindex;
1167                         BUILD_BUG_ON(sizeof(devlink_port->type_eth.ifname) !=
1168                                      sizeof(netdev->name));
1169                         strcpy(devlink_port->type_eth.ifname, netdev->name);
1170                 }
1171                 break;
1172         case DEVLINK_PORT_TYPE_IB:
1173                 devlink_port->type_ib.ibdev = type_dev;
1174                 break;
1175         default:
1176                 break;
1177         }
1178         spin_unlock_bh(&devlink_port->type_lock);
1179         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
1180 }
1181
1182 /**
1183  *      devlink_port_type_eth_set - Set port type to Ethernet
1184  *
1185  *      @devlink_port: devlink port
1186  *
1187  *      If driver is calling this, most likely it is doing something wrong.
1188  */
1189 void devlink_port_type_eth_set(struct devlink_port *devlink_port)
1190 {
1191         dev_warn(devlink_port->devlink->dev,
1192                  "devlink port type for port %d set to Ethernet without a software interface reference, device type not supported by the kernel?\n",
1193                  devlink_port->index);
1194         __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, NULL);
1195 }
1196 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set);
1197
1198 /**
1199  *      devlink_port_type_ib_set - Set port type to InfiniBand
1200  *
1201  *      @devlink_port: devlink port
1202  *      @ibdev: related IB device
1203  */
1204 void devlink_port_type_ib_set(struct devlink_port *devlink_port,
1205                               struct ib_device *ibdev)
1206 {
1207         __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_IB, ibdev);
1208 }
1209 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set);
1210
1211 /**
1212  *      devlink_port_type_clear - Clear port type
1213  *
1214  *      @devlink_port: devlink port
1215  *
1216  *      If driver is calling this for clearing Ethernet type, most likely
1217  *      it is doing something wrong.
1218  */
1219 void devlink_port_type_clear(struct devlink_port *devlink_port)
1220 {
1221         if (devlink_port->type == DEVLINK_PORT_TYPE_ETH)
1222                 dev_warn(devlink_port->devlink->dev,
1223                          "devlink port type for port %d cleared without a software interface reference, device type not supported by the kernel?\n",
1224                          devlink_port->index);
1225         __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, NULL);
1226 }
1227 EXPORT_SYMBOL_GPL(devlink_port_type_clear);
1228
1229 int devlink_port_netdevice_event(struct notifier_block *nb,
1230                                  unsigned long event, void *ptr)
1231 {
1232         struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
1233         struct devlink_port *devlink_port = netdev->devlink_port;
1234         struct devlink *devlink;
1235
1236         if (!devlink_port)
1237                 return NOTIFY_OK;
1238         devlink = devlink_port->devlink;
1239
1240         switch (event) {
1241         case NETDEV_POST_INIT:
1242                 /* Set the type but not netdev pointer. It is going to be set
1243                  * later on by NETDEV_REGISTER event. Happens once during
1244                  * netdevice register
1245                  */
1246                 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH,
1247                                         NULL);
1248                 break;
1249         case NETDEV_REGISTER:
1250         case NETDEV_CHANGENAME:
1251                 if (devlink_net(devlink) != dev_net(netdev))
1252                         return NOTIFY_OK;
1253                 /* Set the netdev on top of previously set type. Note this
1254                  * event happens also during net namespace change so here
1255                  * we take into account netdev pointer appearing in this
1256                  * namespace.
1257                  */
1258                 __devlink_port_type_set(devlink_port, devlink_port->type,
1259                                         netdev);
1260                 break;
1261         case NETDEV_UNREGISTER:
1262                 if (devlink_net(devlink) != dev_net(netdev))
1263                         return NOTIFY_OK;
1264                 /* Clear netdev pointer, but not the type. This event happens
1265                  * also during net namespace change so we need to clear
1266                  * pointer to netdev that is going to another net namespace.
1267                  */
1268                 __devlink_port_type_set(devlink_port, devlink_port->type,
1269                                         NULL);
1270                 break;
1271         case NETDEV_PRE_UNINIT:
1272                 /* Clear the type and the netdev pointer. Happens one during
1273                  * netdevice unregister.
1274                  */
1275                 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET,
1276                                         NULL);
1277                 break;
1278         }
1279
1280         return NOTIFY_OK;
1281 }
1282
1283 static int __devlink_port_attrs_set(struct devlink_port *devlink_port,
1284                                     enum devlink_port_flavour flavour)
1285 {
1286         struct devlink_port_attrs *attrs = &devlink_port->attrs;
1287
1288         devlink_port->attrs_set = true;
1289         attrs->flavour = flavour;
1290         if (attrs->switch_id.id_len) {
1291                 devlink_port->switch_port = true;
1292                 if (WARN_ON(attrs->switch_id.id_len > MAX_PHYS_ITEM_ID_LEN))
1293                         attrs->switch_id.id_len = MAX_PHYS_ITEM_ID_LEN;
1294         } else {
1295                 devlink_port->switch_port = false;
1296         }
1297         return 0;
1298 }
1299
1300 /**
1301  *      devlink_port_attrs_set - Set port attributes
1302  *
1303  *      @devlink_port: devlink port
1304  *      @attrs: devlink port attrs
1305  */
1306 void devlink_port_attrs_set(struct devlink_port *devlink_port,
1307                             struct devlink_port_attrs *attrs)
1308 {
1309         int ret;
1310
1311         ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port);
1312
1313         devlink_port->attrs = *attrs;
1314         ret = __devlink_port_attrs_set(devlink_port, attrs->flavour);
1315         if (ret)
1316                 return;
1317         WARN_ON(attrs->splittable && attrs->split);
1318 }
1319 EXPORT_SYMBOL_GPL(devlink_port_attrs_set);
1320
1321 /**
1322  *      devlink_port_attrs_pci_pf_set - Set PCI PF port attributes
1323  *
1324  *      @devlink_port: devlink port
1325  *      @controller: associated controller number for the devlink port instance
1326  *      @pf: associated PF for the devlink port instance
1327  *      @external: indicates if the port is for an external controller
1328  */
1329 void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port, u32 controller,
1330                                    u16 pf, bool external)
1331 {
1332         struct devlink_port_attrs *attrs = &devlink_port->attrs;
1333         int ret;
1334
1335         ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port);
1336
1337         ret = __devlink_port_attrs_set(devlink_port,
1338                                        DEVLINK_PORT_FLAVOUR_PCI_PF);
1339         if (ret)
1340                 return;
1341         attrs->pci_pf.controller = controller;
1342         attrs->pci_pf.pf = pf;
1343         attrs->pci_pf.external = external;
1344 }
1345 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_pf_set);
1346
1347 /**
1348  *      devlink_port_attrs_pci_vf_set - Set PCI VF port attributes
1349  *
1350  *      @devlink_port: devlink port
1351  *      @controller: associated controller number for the devlink port instance
1352  *      @pf: associated PF for the devlink port instance
1353  *      @vf: associated VF of a PF for the devlink port instance
1354  *      @external: indicates if the port is for an external controller
1355  */
1356 void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port, u32 controller,
1357                                    u16 pf, u16 vf, bool external)
1358 {
1359         struct devlink_port_attrs *attrs = &devlink_port->attrs;
1360         int ret;
1361
1362         ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port);
1363
1364         ret = __devlink_port_attrs_set(devlink_port,
1365                                        DEVLINK_PORT_FLAVOUR_PCI_VF);
1366         if (ret)
1367                 return;
1368         attrs->pci_vf.controller = controller;
1369         attrs->pci_vf.pf = pf;
1370         attrs->pci_vf.vf = vf;
1371         attrs->pci_vf.external = external;
1372 }
1373 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_vf_set);
1374
1375 /**
1376  *      devlink_port_attrs_pci_sf_set - Set PCI SF port attributes
1377  *
1378  *      @devlink_port: devlink port
1379  *      @controller: associated controller number for the devlink port instance
1380  *      @pf: associated PF for the devlink port instance
1381  *      @sf: associated SF of a PF for the devlink port instance
1382  *      @external: indicates if the port is for an external controller
1383  */
1384 void devlink_port_attrs_pci_sf_set(struct devlink_port *devlink_port, u32 controller,
1385                                    u16 pf, u32 sf, bool external)
1386 {
1387         struct devlink_port_attrs *attrs = &devlink_port->attrs;
1388         int ret;
1389
1390         ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port);
1391
1392         ret = __devlink_port_attrs_set(devlink_port,
1393                                        DEVLINK_PORT_FLAVOUR_PCI_SF);
1394         if (ret)
1395                 return;
1396         attrs->pci_sf.controller = controller;
1397         attrs->pci_sf.pf = pf;
1398         attrs->pci_sf.sf = sf;
1399         attrs->pci_sf.external = external;
1400 }
1401 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_sf_set);
1402
1403 static void devlink_port_rel_notify_cb(struct devlink *devlink, u32 port_index)
1404 {
1405         struct devlink_port *devlink_port;
1406
1407         devlink_port = devlink_port_get_by_index(devlink, port_index);
1408         if (!devlink_port)
1409                 return;
1410         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
1411 }
1412
1413 static void devlink_port_rel_cleanup_cb(struct devlink *devlink, u32 port_index,
1414                                         u32 rel_index)
1415 {
1416         struct devlink_port *devlink_port;
1417
1418         devlink_port = devlink_port_get_by_index(devlink, port_index);
1419         if (devlink_port && devlink_port->rel_index == rel_index)
1420                 devlink_port->rel_index = 0;
1421 }
1422
1423 /**
1424  * devl_port_fn_devlink_set - Attach peer devlink
1425  *                            instance to port function.
1426  * @devlink_port: devlink port
1427  * @fn_devlink: devlink instance to attach
1428  */
1429 int devl_port_fn_devlink_set(struct devlink_port *devlink_port,
1430                              struct devlink *fn_devlink)
1431 {
1432         ASSERT_DEVLINK_PORT_REGISTERED(devlink_port);
1433
1434         if (WARN_ON(devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_SF ||
1435                     devlink_port->attrs.pci_sf.external))
1436                 return -EINVAL;
1437
1438         return devlink_rel_nested_in_add(&devlink_port->rel_index,
1439                                          devlink_port->devlink->index,
1440                                          devlink_port->index,
1441                                          devlink_port_rel_notify_cb,
1442                                          devlink_port_rel_cleanup_cb,
1443                                          fn_devlink);
1444 }
1445 EXPORT_SYMBOL_GPL(devl_port_fn_devlink_set);
1446
1447 /**
1448  *      devlink_port_linecard_set - Link port with a linecard
1449  *
1450  *      @devlink_port: devlink port
1451  *      @linecard: devlink linecard
1452  */
1453 void devlink_port_linecard_set(struct devlink_port *devlink_port,
1454                                struct devlink_linecard *linecard)
1455 {
1456         ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port);
1457
1458         devlink_port->linecard = linecard;
1459 }
1460 EXPORT_SYMBOL_GPL(devlink_port_linecard_set);
1461
1462 static int __devlink_port_phys_port_name_get(struct devlink_port *devlink_port,
1463                                              char *name, size_t len)
1464 {
1465         struct devlink_port_attrs *attrs = &devlink_port->attrs;
1466         int n = 0;
1467
1468         if (!devlink_port->attrs_set)
1469                 return -EOPNOTSUPP;
1470
1471         switch (attrs->flavour) {
1472         case DEVLINK_PORT_FLAVOUR_PHYSICAL:
1473                 if (devlink_port->linecard)
1474                         n = snprintf(name, len, "l%u",
1475                                      devlink_linecard_index(devlink_port->linecard));
1476                 if (n < len)
1477                         n += snprintf(name + n, len - n, "p%u",
1478                                       attrs->phys.port_number);
1479                 if (n < len && attrs->split)
1480                         n += snprintf(name + n, len - n, "s%u",
1481                                       attrs->phys.split_subport_number);
1482                 break;
1483         case DEVLINK_PORT_FLAVOUR_CPU:
1484         case DEVLINK_PORT_FLAVOUR_DSA:
1485         case DEVLINK_PORT_FLAVOUR_UNUSED:
1486                 /* As CPU and DSA ports do not have a netdevice associated
1487                  * case should not ever happen.
1488                  */
1489                 WARN_ON(1);
1490                 return -EINVAL;
1491         case DEVLINK_PORT_FLAVOUR_PCI_PF:
1492                 if (attrs->pci_pf.external) {
1493                         n = snprintf(name, len, "c%u", attrs->pci_pf.controller);
1494                         if (n >= len)
1495                                 return -EINVAL;
1496                         len -= n;
1497                         name += n;
1498                 }
1499                 n = snprintf(name, len, "pf%u", attrs->pci_pf.pf);
1500                 break;
1501         case DEVLINK_PORT_FLAVOUR_PCI_VF:
1502                 if (attrs->pci_vf.external) {
1503                         n = snprintf(name, len, "c%u", attrs->pci_vf.controller);
1504                         if (n >= len)
1505                                 return -EINVAL;
1506                         len -= n;
1507                         name += n;
1508                 }
1509                 n = snprintf(name, len, "pf%uvf%u",
1510                              attrs->pci_vf.pf, attrs->pci_vf.vf);
1511                 break;
1512         case DEVLINK_PORT_FLAVOUR_PCI_SF:
1513                 if (attrs->pci_sf.external) {
1514                         n = snprintf(name, len, "c%u", attrs->pci_sf.controller);
1515                         if (n >= len)
1516                                 return -EINVAL;
1517                         len -= n;
1518                         name += n;
1519                 }
1520                 n = snprintf(name, len, "pf%usf%u", attrs->pci_sf.pf,
1521                              attrs->pci_sf.sf);
1522                 break;
1523         case DEVLINK_PORT_FLAVOUR_VIRTUAL:
1524                 return -EOPNOTSUPP;
1525         }
1526
1527         if (n >= len)
1528                 return -EINVAL;
1529
1530         return 0;
1531 }
1532
1533 int devlink_compat_phys_port_name_get(struct net_device *dev,
1534                                       char *name, size_t len)
1535 {
1536         struct devlink_port *devlink_port;
1537
1538         /* RTNL mutex is held here which ensures that devlink_port
1539          * instance cannot disappear in the middle. No need to take
1540          * any devlink lock as only permanent values are accessed.
1541          */
1542         ASSERT_RTNL();
1543
1544         devlink_port = dev->devlink_port;
1545         if (!devlink_port)
1546                 return -EOPNOTSUPP;
1547
1548         return __devlink_port_phys_port_name_get(devlink_port, name, len);
1549 }
1550
1551 int devlink_compat_switch_id_get(struct net_device *dev,
1552                                  struct netdev_phys_item_id *ppid)
1553 {
1554         struct devlink_port *devlink_port;
1555
1556         /* Caller must hold RTNL mutex or reference to dev, which ensures that
1557          * devlink_port instance cannot disappear in the middle. No need to take
1558          * any devlink lock as only permanent values are accessed.
1559          */
1560         devlink_port = dev->devlink_port;
1561         if (!devlink_port || !devlink_port->switch_port)
1562                 return -EOPNOTSUPP;
1563
1564         memcpy(ppid, &devlink_port->attrs.switch_id, sizeof(*ppid));
1565
1566         return 0;
1567 }