1169695Skan// SPDX-License-Identifier: GPL-2.0-or-later 2169695Skan/* 3169695Skan * Copyright (c) 2016 Mellanox Technologies. All rights reserved. 4169695Skan * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com> 5169695Skan */ 6169695Skan 7169695Skan#include "devl_internal.h" 8169695Skan 9169695Skan#define DEVLINK_PORT_FN_CAPS_VALID_MASK \ 10169695Skan (_BITUL(__DEVLINK_PORT_FN_ATTR_CAPS_MAX) - 1) 11169695Skan 12169695Skanstatic const struct nla_policy devlink_function_nl_policy[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1] = { 13169695Skan [DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] = { .type = NLA_BINARY }, 14169695Skan [DEVLINK_PORT_FN_ATTR_STATE] = 15169695Skan NLA_POLICY_RANGE(NLA_U8, DEVLINK_PORT_FN_STATE_INACTIVE, 16169695Skan DEVLINK_PORT_FN_STATE_ACTIVE), 17169695Skan [DEVLINK_PORT_FN_ATTR_CAPS] = 18169695Skan NLA_POLICY_BITFIELD32(DEVLINK_PORT_FN_CAPS_VALID_MASK), 19169695Skan [DEVLINK_PORT_FN_ATTR_MAX_IO_EQS] = { .type = NLA_U32 }, 20169695Skan}; 21169695Skan 22169695Skan#define ASSERT_DEVLINK_PORT_REGISTERED(devlink_port) \ 23169695Skan WARN_ON_ONCE(!(devlink_port)->registered) 24169695Skan#define ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port) \ 25169695Skan WARN_ON_ONCE((devlink_port)->registered) 26169695Skan 27169695Skanstruct devlink_port *devlink_port_get_by_index(struct devlink *devlink, 28169695Skan unsigned int port_index) 29169695Skan{ 30169695Skan return xa_load(&devlink->ports, port_index); 31169695Skan} 32169695Skan 33169695Skanstruct devlink_port *devlink_port_get_from_attrs(struct devlink *devlink, 34169695Skan struct nlattr **attrs) 35169695Skan{ 36169695Skan if (attrs[DEVLINK_ATTR_PORT_INDEX]) { 37169695Skan u32 port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]); 38169695Skan struct devlink_port *devlink_port; 39169695Skan 40169695Skan devlink_port = devlink_port_get_by_index(devlink, port_index); 41169695Skan if (!devlink_port) 42169695Skan return ERR_PTR(-ENODEV); 43169695Skan return devlink_port; 44169695Skan } 45169695Skan return ERR_PTR(-EINVAL); 46169695Skan} 47169695Skan 48169695Skanstruct devlink_port *devlink_port_get_from_info(struct devlink *devlink, 49169695Skan struct genl_info *info) 50169695Skan{ 51169695Skan return devlink_port_get_from_attrs(devlink, info->attrs); 52169695Skan} 53169695Skan 54169695Skanstatic void devlink_port_fn_cap_fill(struct nla_bitfield32 *caps, 55169695Skan u32 cap, bool is_enable) 56169695Skan{ 57169695Skan caps->selector |= cap; 58169695Skan if (is_enable) 59169695Skan caps->value |= cap; 60169695Skan} 61169695Skan 62169695Skanstatic int devlink_port_fn_roce_fill(struct devlink_port *devlink_port, 63169695Skan struct nla_bitfield32 *caps, 64169695Skan struct netlink_ext_ack *extack) 65169695Skan{ 66169695Skan bool is_enable; 67169695Skan int err; 68169695Skan 69169695Skan if (!devlink_port->ops->port_fn_roce_get) 70169695Skan return 0; 71169695Skan 72169695Skan err = devlink_port->ops->port_fn_roce_get(devlink_port, &is_enable, 73169695Skan extack); 74169695Skan if (err) { 75169695Skan if (err == -EOPNOTSUPP) 76169695Skan return 0; 77169695Skan return err; 78169695Skan } 79169695Skan 80169695Skan devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_ROCE, is_enable); 81169695Skan return 0; 82169695Skan} 83169695Skan 84169695Skanstatic int devlink_port_fn_migratable_fill(struct devlink_port *devlink_port, 85169695Skan struct nla_bitfield32 *caps, 86169695Skan struct netlink_ext_ack *extack) 87169695Skan{ 88169695Skan bool is_enable; 89169695Skan int err; 90169695Skan 91169695Skan if (!devlink_port->ops->port_fn_migratable_get || 92169695Skan devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) 93169695Skan return 0; 94169695Skan 95169695Skan err = devlink_port->ops->port_fn_migratable_get(devlink_port, 96169695Skan &is_enable, extack); 97169695Skan if (err) { 98169695Skan if (err == -EOPNOTSUPP) 99169695Skan return 0; 100169695Skan return err; 101169695Skan } 102169695Skan 103169695Skan devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_MIGRATABLE, is_enable); 104169695Skan return 0; 105169695Skan} 106169695Skan 107169695Skanstatic int devlink_port_fn_ipsec_crypto_fill(struct devlink_port *devlink_port, 108169695Skan struct nla_bitfield32 *caps, 109169695Skan struct netlink_ext_ack *extack) 110169695Skan{ 111169695Skan bool is_enable; 112169695Skan int err; 113169695Skan 114169695Skan if (!devlink_port->ops->port_fn_ipsec_crypto_get || 115169695Skan devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) 116169695Skan return 0; 117169695Skan 118169695Skan err = devlink_port->ops->port_fn_ipsec_crypto_get(devlink_port, &is_enable, extack); 119169695Skan if (err) { 120169695Skan if (err == -EOPNOTSUPP) 121169695Skan return 0; 122169695Skan return err; 123169695Skan } 124169695Skan 125169695Skan devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO, is_enable); 126169695Skan return 0; 127169695Skan} 128169695Skan 129169695Skanstatic int devlink_port_fn_ipsec_packet_fill(struct devlink_port *devlink_port, 130169695Skan struct nla_bitfield32 *caps, 131169695Skan struct netlink_ext_ack *extack) 132169695Skan{ 133169695Skan bool is_enable; 134169695Skan int err; 135169695Skan 136169695Skan if (!devlink_port->ops->port_fn_ipsec_packet_get || 137169695Skan devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) 138169695Skan return 0; 139169695Skan 140169695Skan err = devlink_port->ops->port_fn_ipsec_packet_get(devlink_port, &is_enable, extack); 141169695Skan if (err) { 142169695Skan if (err == -EOPNOTSUPP) 143169695Skan return 0; 144169695Skan return err; 145169695Skan } 146169695Skan 147169695Skan devlink_port_fn_cap_fill(caps, DEVLINK_PORT_FN_CAP_IPSEC_PACKET, is_enable); 148169695Skan return 0; 149169695Skan} 150169695Skan 151169695Skanstatic int devlink_port_fn_caps_fill(struct devlink_port *devlink_port, 152169695Skan struct sk_buff *msg, 153169695Skan struct netlink_ext_ack *extack, 154169695Skan bool *msg_updated) 155169695Skan{ 156169695Skan struct nla_bitfield32 caps = {}; 157169695Skan int err; 158169695Skan 159169695Skan err = devlink_port_fn_roce_fill(devlink_port, &caps, extack); 160169695Skan if (err) 161169695Skan return err; 162169695Skan 163169695Skan err = devlink_port_fn_migratable_fill(devlink_port, &caps, extack); 164169695Skan if (err) 165169695Skan return err; 166169695Skan 167169695Skan err = devlink_port_fn_ipsec_crypto_fill(devlink_port, &caps, extack); 168169695Skan if (err) 169169695Skan return err; 170169695Skan 171169695Skan err = devlink_port_fn_ipsec_packet_fill(devlink_port, &caps, extack); 172169695Skan if (err) 173169695Skan return err; 174169695Skan 175169695Skan if (!caps.selector) 176169695Skan return 0; 177169695Skan err = nla_put_bitfield32(msg, DEVLINK_PORT_FN_ATTR_CAPS, caps.value, 178169695Skan caps.selector); 179169695Skan if (err) 180169695Skan return err; 181169695Skan 182169695Skan *msg_updated = true; 183169695Skan return 0; 184169695Skan} 185169695Skan 186169695Skanstatic int devlink_port_fn_max_io_eqs_fill(struct devlink_port *port, 187169695Skan struct sk_buff *msg, 188169695Skan struct netlink_ext_ack *extack, 189169695Skan bool *msg_updated) 190169695Skan{ 191169695Skan u32 max_io_eqs; 192169695Skan int err; 193169695Skan 194169695Skan if (!port->ops->port_fn_max_io_eqs_get) 195169695Skan return 0; 196169695Skan 197169695Skan err = port->ops->port_fn_max_io_eqs_get(port, &max_io_eqs, extack); 198169695Skan if (err) { 199169695Skan if (err == -EOPNOTSUPP) 200169695Skan return 0; 201169695Skan return err; 202169695Skan } 203169695Skan err = nla_put_u32(msg, DEVLINK_PORT_FN_ATTR_MAX_IO_EQS, max_io_eqs); 204169695Skan if (err) 205169695Skan return err; 206169695Skan *msg_updated = true; 207169695Skan return 0; 208169695Skan} 209169695Skan 210169695Skanint devlink_nl_port_handle_fill(struct sk_buff *msg, struct devlink_port *devlink_port) 211169695Skan{ 212169695Skan if (devlink_nl_put_handle(msg, devlink_port->devlink)) 213169695Skan return -EMSGSIZE; 214169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index)) 215169695Skan return -EMSGSIZE; 216169695Skan return 0; 217169695Skan} 218169695Skan 219169695Skansize_t devlink_nl_port_handle_size(struct devlink_port *devlink_port) 220169695Skan{ 221169695Skan struct devlink *devlink = devlink_port->devlink; 222169695Skan 223169695Skan return nla_total_size(strlen(devlink->dev->bus->name) + 1) /* DEVLINK_ATTR_BUS_NAME */ 224169695Skan + nla_total_size(strlen(dev_name(devlink->dev)) + 1) /* DEVLINK_ATTR_DEV_NAME */ 225169695Skan + nla_total_size(4); /* DEVLINK_ATTR_PORT_INDEX */ 226169695Skan} 227169695Skan 228169695Skanstatic int devlink_nl_port_attrs_put(struct sk_buff *msg, 229169695Skan struct devlink_port *devlink_port) 230169695Skan{ 231169695Skan struct devlink_port_attrs *attrs = &devlink_port->attrs; 232169695Skan 233169695Skan if (!devlink_port->attrs_set) 234169695Skan return 0; 235169695Skan if (attrs->lanes) { 236169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_LANES, attrs->lanes)) 237169695Skan return -EMSGSIZE; 238169695Skan } 239169695Skan if (nla_put_u8(msg, DEVLINK_ATTR_PORT_SPLITTABLE, attrs->splittable)) 240169695Skan return -EMSGSIZE; 241169695Skan if (nla_put_u16(msg, DEVLINK_ATTR_PORT_FLAVOUR, attrs->flavour)) 242169695Skan return -EMSGSIZE; 243169695Skan switch (devlink_port->attrs.flavour) { 244169695Skan case DEVLINK_PORT_FLAVOUR_PCI_PF: 245169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER, 246169695Skan attrs->pci_pf.controller) || 247169695Skan nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_pf.pf)) 248169695Skan return -EMSGSIZE; 249169695Skan if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_pf.external)) 250169695Skan return -EMSGSIZE; 251169695Skan break; 252169695Skan case DEVLINK_PORT_FLAVOUR_PCI_VF: 253169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER, 254169695Skan attrs->pci_vf.controller) || 255169695Skan nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, attrs->pci_vf.pf) || 256169695Skan nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_VF_NUMBER, attrs->pci_vf.vf)) 257169695Skan return -EMSGSIZE; 258169695Skan if (nla_put_u8(msg, DEVLINK_ATTR_PORT_EXTERNAL, attrs->pci_vf.external)) 259169695Skan return -EMSGSIZE; 260169695Skan break; 261169695Skan case DEVLINK_PORT_FLAVOUR_PCI_SF: 262169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER, 263169695Skan attrs->pci_sf.controller) || 264169695Skan nla_put_u16(msg, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, 265169695Skan attrs->pci_sf.pf) || 266169695Skan nla_put_u32(msg, DEVLINK_ATTR_PORT_PCI_SF_NUMBER, 267169695Skan attrs->pci_sf.sf)) 268169695Skan return -EMSGSIZE; 269169695Skan break; 270169695Skan case DEVLINK_PORT_FLAVOUR_PHYSICAL: 271169695Skan case DEVLINK_PORT_FLAVOUR_CPU: 272169695Skan case DEVLINK_PORT_FLAVOUR_DSA: 273169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_NUMBER, 274169695Skan attrs->phys.port_number)) 275169695Skan return -EMSGSIZE; 276169695Skan if (!attrs->split) 277169695Skan return 0; 278169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_GROUP, 279169695Skan attrs->phys.port_number)) 280169695Skan return -EMSGSIZE; 281169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER, 282169695Skan attrs->phys.split_subport_number)) 283169695Skan return -EMSGSIZE; 284169695Skan break; 285169695Skan default: 286169695Skan break; 287169695Skan } 288169695Skan return 0; 289169695Skan} 290169695Skan 291169695Skanstatic int devlink_port_fn_hw_addr_fill(struct devlink_port *port, 292169695Skan struct sk_buff *msg, 293169695Skan struct netlink_ext_ack *extack, 294169695Skan bool *msg_updated) 295169695Skan{ 296169695Skan u8 hw_addr[MAX_ADDR_LEN]; 297169695Skan int hw_addr_len; 298169695Skan int err; 299169695Skan 300169695Skan if (!port->ops->port_fn_hw_addr_get) 301169695Skan return 0; 302169695Skan 303169695Skan err = port->ops->port_fn_hw_addr_get(port, hw_addr, &hw_addr_len, 304169695Skan extack); 305169695Skan if (err) { 306169695Skan if (err == -EOPNOTSUPP) 307169695Skan return 0; 308169695Skan return err; 309169695Skan } 310169695Skan err = nla_put(msg, DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR, hw_addr_len, hw_addr); 311169695Skan if (err) 312169695Skan return err; 313169695Skan *msg_updated = true; 314169695Skan return 0; 315169695Skan} 316169695Skan 317169695Skanstatic bool 318169695Skandevlink_port_fn_state_valid(enum devlink_port_fn_state state) 319169695Skan{ 320169695Skan return state == DEVLINK_PORT_FN_STATE_INACTIVE || 321169695Skan state == DEVLINK_PORT_FN_STATE_ACTIVE; 322169695Skan} 323169695Skan 324169695Skanstatic bool 325169695Skandevlink_port_fn_opstate_valid(enum devlink_port_fn_opstate opstate) 326169695Skan{ 327169695Skan return opstate == DEVLINK_PORT_FN_OPSTATE_DETACHED || 328169695Skan opstate == DEVLINK_PORT_FN_OPSTATE_ATTACHED; 329169695Skan} 330169695Skan 331169695Skanstatic int devlink_port_fn_state_fill(struct devlink_port *port, 332169695Skan struct sk_buff *msg, 333169695Skan struct netlink_ext_ack *extack, 334169695Skan bool *msg_updated) 335169695Skan{ 336169695Skan enum devlink_port_fn_opstate opstate; 337169695Skan enum devlink_port_fn_state state; 338169695Skan int err; 339169695Skan 340169695Skan if (!port->ops->port_fn_state_get) 341169695Skan return 0; 342169695Skan 343169695Skan err = port->ops->port_fn_state_get(port, &state, &opstate, extack); 344169695Skan if (err) { 345169695Skan if (err == -EOPNOTSUPP) 346169695Skan return 0; 347169695Skan return err; 348169695Skan } 349169695Skan if (!devlink_port_fn_state_valid(state)) { 350169695Skan WARN_ON_ONCE(1); 351169695Skan NL_SET_ERR_MSG(extack, "Invalid state read from driver"); 352169695Skan return -EINVAL; 353169695Skan } 354169695Skan if (!devlink_port_fn_opstate_valid(opstate)) { 355169695Skan WARN_ON_ONCE(1); 356169695Skan NL_SET_ERR_MSG(extack, "Invalid operational state read from driver"); 357169695Skan return -EINVAL; 358169695Skan } 359169695Skan if (nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_STATE, state) || 360169695Skan nla_put_u8(msg, DEVLINK_PORT_FN_ATTR_OPSTATE, opstate)) 361169695Skan return -EMSGSIZE; 362169695Skan *msg_updated = true; 363169695Skan return 0; 364169695Skan} 365169695Skan 366169695Skanstatic int 367169695Skandevlink_port_fn_mig_set(struct devlink_port *devlink_port, bool enable, 368169695Skan struct netlink_ext_ack *extack) 369169695Skan{ 370169695Skan return devlink_port->ops->port_fn_migratable_set(devlink_port, enable, 371169695Skan extack); 372169695Skan} 373169695Skan 374169695Skanstatic int 375169695Skandevlink_port_fn_roce_set(struct devlink_port *devlink_port, bool enable, 376169695Skan struct netlink_ext_ack *extack) 377169695Skan{ 378169695Skan return devlink_port->ops->port_fn_roce_set(devlink_port, enable, 379169695Skan extack); 380169695Skan} 381169695Skan 382169695Skanstatic int 383169695Skandevlink_port_fn_ipsec_crypto_set(struct devlink_port *devlink_port, bool enable, 384169695Skan struct netlink_ext_ack *extack) 385169695Skan{ 386169695Skan return devlink_port->ops->port_fn_ipsec_crypto_set(devlink_port, enable, extack); 387169695Skan} 388169695Skan 389169695Skanstatic int 390169695Skandevlink_port_fn_ipsec_packet_set(struct devlink_port *devlink_port, bool enable, 391169695Skan struct netlink_ext_ack *extack) 392169695Skan{ 393169695Skan return devlink_port->ops->port_fn_ipsec_packet_set(devlink_port, enable, extack); 394169695Skan} 395169695Skan 396169695Skanstatic int devlink_port_fn_caps_set(struct devlink_port *devlink_port, 397169695Skan const struct nlattr *attr, 398169695Skan struct netlink_ext_ack *extack) 399169695Skan{ 400169695Skan struct nla_bitfield32 caps; 401169695Skan u32 caps_value; 402169695Skan int err; 403169695Skan 404169695Skan caps = nla_get_bitfield32(attr); 405169695Skan caps_value = caps.value & caps.selector; 406169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_ROCE) { 407169695Skan err = devlink_port_fn_roce_set(devlink_port, 408169695Skan caps_value & DEVLINK_PORT_FN_CAP_ROCE, 409169695Skan extack); 410169695Skan if (err) 411169695Skan return err; 412169695Skan } 413169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_MIGRATABLE) { 414169695Skan err = devlink_port_fn_mig_set(devlink_port, caps_value & 415169695Skan DEVLINK_PORT_FN_CAP_MIGRATABLE, 416169695Skan extack); 417169695Skan if (err) 418169695Skan return err; 419169695Skan } 420169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO) { 421169695Skan err = devlink_port_fn_ipsec_crypto_set(devlink_port, caps_value & 422169695Skan DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO, 423169695Skan extack); 424169695Skan if (err) 425169695Skan return err; 426169695Skan } 427169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_PACKET) { 428169695Skan err = devlink_port_fn_ipsec_packet_set(devlink_port, caps_value & 429169695Skan DEVLINK_PORT_FN_CAP_IPSEC_PACKET, 430169695Skan extack); 431169695Skan if (err) 432169695Skan return err; 433169695Skan } 434169695Skan return 0; 435169695Skan} 436169695Skan 437169695Skanstatic int 438169695Skandevlink_port_fn_max_io_eqs_set(struct devlink_port *devlink_port, 439169695Skan const struct nlattr *attr, 440169695Skan struct netlink_ext_ack *extack) 441169695Skan{ 442169695Skan u32 max_io_eqs; 443169695Skan 444169695Skan max_io_eqs = nla_get_u32(attr); 445169695Skan return devlink_port->ops->port_fn_max_io_eqs_set(devlink_port, 446169695Skan max_io_eqs, extack); 447169695Skan} 448169695Skan 449169695Skanstatic int 450169695Skandevlink_nl_port_function_attrs_put(struct sk_buff *msg, struct devlink_port *port, 451169695Skan struct netlink_ext_ack *extack) 452169695Skan{ 453169695Skan struct nlattr *function_attr; 454169695Skan bool msg_updated = false; 455169695Skan int err; 456169695Skan 457169695Skan function_attr = nla_nest_start_noflag(msg, DEVLINK_ATTR_PORT_FUNCTION); 458169695Skan if (!function_attr) 459169695Skan return -EMSGSIZE; 460169695Skan 461169695Skan err = devlink_port_fn_hw_addr_fill(port, msg, extack, &msg_updated); 462169695Skan if (err) 463169695Skan goto out; 464169695Skan err = devlink_port_fn_caps_fill(port, msg, extack, &msg_updated); 465169695Skan if (err) 466169695Skan goto out; 467169695Skan err = devlink_port_fn_state_fill(port, msg, extack, &msg_updated); 468169695Skan if (err) 469169695Skan goto out; 470169695Skan err = devlink_port_fn_max_io_eqs_fill(port, msg, extack, &msg_updated); 471169695Skan if (err) 472169695Skan goto out; 473169695Skan err = devlink_rel_devlink_handle_put(msg, port->devlink, 474169695Skan port->rel_index, 475169695Skan DEVLINK_PORT_FN_ATTR_DEVLINK, 476169695Skan &msg_updated); 477169695Skan 478169695Skanout: 479169695Skan if (err || !msg_updated) 480169695Skan nla_nest_cancel(msg, function_attr); 481169695Skan else 482169695Skan nla_nest_end(msg, function_attr); 483169695Skan return err; 484169695Skan} 485169695Skan 486169695Skanstatic int devlink_nl_port_fill(struct sk_buff *msg, 487169695Skan struct devlink_port *devlink_port, 488169695Skan enum devlink_command cmd, u32 portid, u32 seq, 489169695Skan int flags, struct netlink_ext_ack *extack) 490169695Skan{ 491169695Skan struct devlink *devlink = devlink_port->devlink; 492169695Skan void *hdr; 493169695Skan 494169695Skan hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd); 495169695Skan if (!hdr) 496169695Skan return -EMSGSIZE; 497169695Skan 498169695Skan if (devlink_nl_put_handle(msg, devlink)) 499169695Skan goto nla_put_failure; 500169695Skan if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index)) 501169695Skan goto nla_put_failure; 502169695Skan 503169695Skan spin_lock_bh(&devlink_port->type_lock); 504169695Skan if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type)) 505169695Skan goto nla_put_failure_type_locked; 506169695Skan if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET && 507169695Skan nla_put_u16(msg, DEVLINK_ATTR_PORT_DESIRED_TYPE, 508169695Skan devlink_port->desired_type)) 509169695Skan goto nla_put_failure_type_locked; 510169695Skan if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) { 511169695Skan if (devlink_port->type_eth.netdev && 512169695Skan (nla_put_u32(msg, DEVLINK_ATTR_PORT_NETDEV_IFINDEX, 513169695Skan devlink_port->type_eth.ifindex) || 514169695Skan nla_put_string(msg, DEVLINK_ATTR_PORT_NETDEV_NAME, 515169695Skan devlink_port->type_eth.ifname))) 516169695Skan goto nla_put_failure_type_locked; 517169695Skan } 518169695Skan if (devlink_port->type == DEVLINK_PORT_TYPE_IB) { 519169695Skan struct ib_device *ibdev = devlink_port->type_ib.ibdev; 520169695Skan 521169695Skan if (ibdev && 522169695Skan nla_put_string(msg, DEVLINK_ATTR_PORT_IBDEV_NAME, 523169695Skan ibdev->name)) 524169695Skan goto nla_put_failure_type_locked; 525169695Skan } 526169695Skan spin_unlock_bh(&devlink_port->type_lock); 527169695Skan if (devlink_nl_port_attrs_put(msg, devlink_port)) 528169695Skan goto nla_put_failure; 529169695Skan if (devlink_nl_port_function_attrs_put(msg, devlink_port, extack)) 530169695Skan goto nla_put_failure; 531169695Skan if (devlink_port->linecard && 532169695Skan nla_put_u32(msg, DEVLINK_ATTR_LINECARD_INDEX, 533169695Skan devlink_linecard_index(devlink_port->linecard))) 534169695Skan goto nla_put_failure; 535169695Skan 536169695Skan genlmsg_end(msg, hdr); 537169695Skan return 0; 538169695Skan 539169695Skannla_put_failure_type_locked: 540169695Skan spin_unlock_bh(&devlink_port->type_lock); 541169695Skannla_put_failure: 542169695Skan genlmsg_cancel(msg, hdr); 543169695Skan return -EMSGSIZE; 544169695Skan} 545169695Skan 546169695Skanstatic void devlink_port_notify(struct devlink_port *devlink_port, 547169695Skan enum devlink_command cmd) 548169695Skan{ 549169695Skan struct devlink *devlink = devlink_port->devlink; 550169695Skan struct devlink_obj_desc desc; 551169695Skan struct sk_buff *msg; 552169695Skan int err; 553169695Skan 554169695Skan WARN_ON(cmd != DEVLINK_CMD_PORT_NEW && cmd != DEVLINK_CMD_PORT_DEL); 555169695Skan 556169695Skan if (!__devl_is_registered(devlink) || !devlink_nl_notify_need(devlink)) 557169695Skan return; 558169695Skan 559169695Skan msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 560169695Skan if (!msg) 561169695Skan return; 562169695Skan 563169695Skan err = devlink_nl_port_fill(msg, devlink_port, cmd, 0, 0, 0, NULL); 564169695Skan if (err) { 565169695Skan nlmsg_free(msg); 566169695Skan return; 567169695Skan } 568169695Skan 569169695Skan devlink_nl_obj_desc_init(&desc, devlink); 570169695Skan devlink_nl_obj_desc_port_set(&desc, devlink_port); 571169695Skan devlink_nl_notify_send_desc(devlink, msg, &desc); 572169695Skan} 573169695Skan 574169695Skanstatic void devlink_ports_notify(struct devlink *devlink, 575169695Skan enum devlink_command cmd) 576169695Skan{ 577169695Skan struct devlink_port *devlink_port; 578169695Skan unsigned long port_index; 579169695Skan 580169695Skan xa_for_each(&devlink->ports, port_index, devlink_port) 581169695Skan devlink_port_notify(devlink_port, cmd); 582169695Skan} 583169695Skan 584169695Skanvoid devlink_ports_notify_register(struct devlink *devlink) 585169695Skan{ 586169695Skan devlink_ports_notify(devlink, DEVLINK_CMD_PORT_NEW); 587169695Skan} 588169695Skan 589169695Skanvoid devlink_ports_notify_unregister(struct devlink *devlink) 590169695Skan{ 591169695Skan devlink_ports_notify(devlink, DEVLINK_CMD_PORT_DEL); 592169695Skan} 593169695Skan 594169695Skanint devlink_nl_port_get_doit(struct sk_buff *skb, struct genl_info *info) 595169695Skan{ 596169695Skan struct devlink_port *devlink_port = info->user_ptr[1]; 597169695Skan struct sk_buff *msg; 598169695Skan int err; 599169695Skan 600169695Skan msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 601169695Skan if (!msg) 602169695Skan return -ENOMEM; 603169695Skan 604169695Skan err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_PORT_NEW, 605169695Skan info->snd_portid, info->snd_seq, 0, 606169695Skan info->extack); 607169695Skan if (err) { 608169695Skan nlmsg_free(msg); 609169695Skan return err; 610169695Skan } 611169695Skan 612169695Skan return genlmsg_reply(msg, info); 613169695Skan} 614169695Skan 615169695Skanstatic int 616169695Skandevlink_nl_port_get_dump_one(struct sk_buff *msg, struct devlink *devlink, 617169695Skan struct netlink_callback *cb, int flags) 618169695Skan{ 619169695Skan struct devlink_nl_dump_state *state = devlink_dump_state(cb); 620169695Skan struct devlink_port *devlink_port; 621169695Skan unsigned long port_index; 622169695Skan int err = 0; 623169695Skan 624169695Skan xa_for_each_start(&devlink->ports, port_index, devlink_port, state->idx) { 625169695Skan err = devlink_nl_port_fill(msg, devlink_port, 626169695Skan DEVLINK_CMD_PORT_NEW, 627169695Skan NETLINK_CB(cb->skb).portid, 628169695Skan cb->nlh->nlmsg_seq, flags, 629169695Skan cb->extack); 630169695Skan if (err) { 631169695Skan state->idx = port_index; 632169695Skan break; 633169695Skan } 634169695Skan } 635169695Skan 636169695Skan return err; 637169695Skan} 638169695Skan 639169695Skanint devlink_nl_port_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 640169695Skan{ 641169695Skan return devlink_nl_dumpit(skb, cb, devlink_nl_port_get_dump_one); 642169695Skan} 643169695Skan 644169695Skanstatic int devlink_port_type_set(struct devlink_port *devlink_port, 645169695Skan enum devlink_port_type port_type) 646169695Skan 647169695Skan{ 648169695Skan int err; 649169695Skan 650169695Skan if (!devlink_port->ops->port_type_set) 651169695Skan return -EOPNOTSUPP; 652169695Skan 653169695Skan if (port_type == devlink_port->type) 654169695Skan return 0; 655169695Skan 656169695Skan err = devlink_port->ops->port_type_set(devlink_port, port_type); 657169695Skan if (err) 658169695Skan return err; 659169695Skan 660169695Skan devlink_port->desired_type = port_type; 661169695Skan devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW); 662169695Skan return 0; 663169695Skan} 664169695Skan 665169695Skanstatic int devlink_port_function_hw_addr_set(struct devlink_port *port, 666169695Skan const struct nlattr *attr, 667169695Skan struct netlink_ext_ack *extack) 668169695Skan{ 669169695Skan const u8 *hw_addr; 670169695Skan int hw_addr_len; 671169695Skan 672169695Skan hw_addr = nla_data(attr); 673169695Skan hw_addr_len = nla_len(attr); 674169695Skan if (hw_addr_len > MAX_ADDR_LEN) { 675169695Skan NL_SET_ERR_MSG(extack, "Port function hardware address too long"); 676169695Skan return -EINVAL; 677169695Skan } 678169695Skan if (port->type == DEVLINK_PORT_TYPE_ETH) { 679169695Skan if (hw_addr_len != ETH_ALEN) { 680169695Skan NL_SET_ERR_MSG(extack, "Address must be 6 bytes for Ethernet device"); 681169695Skan return -EINVAL; 682169695Skan } 683169695Skan if (!is_unicast_ether_addr(hw_addr)) { 684169695Skan NL_SET_ERR_MSG(extack, "Non-unicast hardware address unsupported"); 685169695Skan return -EINVAL; 686169695Skan } 687169695Skan } 688169695Skan 689169695Skan return port->ops->port_fn_hw_addr_set(port, hw_addr, hw_addr_len, 690169695Skan extack); 691169695Skan} 692169695Skan 693169695Skanstatic int devlink_port_fn_state_set(struct devlink_port *port, 694169695Skan const struct nlattr *attr, 695169695Skan struct netlink_ext_ack *extack) 696169695Skan{ 697169695Skan enum devlink_port_fn_state state; 698169695Skan 699169695Skan state = nla_get_u8(attr); 700169695Skan return port->ops->port_fn_state_set(port, state, extack); 701169695Skan} 702169695Skan 703169695Skanstatic int devlink_port_function_validate(struct devlink_port *devlink_port, 704169695Skan struct nlattr **tb, 705169695Skan struct netlink_ext_ack *extack) 706169695Skan{ 707169695Skan const struct devlink_port_ops *ops = devlink_port->ops; 708169695Skan struct nlattr *attr; 709169695Skan 710169695Skan if (tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] && 711169695Skan !ops->port_fn_hw_addr_set) { 712169695Skan NL_SET_ERR_MSG_ATTR(extack, tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR], 713169695Skan "Port doesn't support function attributes"); 714169695Skan return -EOPNOTSUPP; 715169695Skan } 716169695Skan if (tb[DEVLINK_PORT_FN_ATTR_STATE] && !ops->port_fn_state_set) { 717169695Skan NL_SET_ERR_MSG_ATTR(extack, tb[DEVLINK_PORT_FN_ATTR_STATE], 718169695Skan "Function does not support state setting"); 719169695Skan return -EOPNOTSUPP; 720169695Skan } 721169695Skan attr = tb[DEVLINK_PORT_FN_ATTR_CAPS]; 722169695Skan if (attr) { 723169695Skan struct nla_bitfield32 caps; 724169695Skan 725169695Skan caps = nla_get_bitfield32(attr); 726169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_ROCE && 727169695Skan !ops->port_fn_roce_set) { 728169695Skan NL_SET_ERR_MSG_ATTR(extack, attr, 729169695Skan "Port doesn't support RoCE function attribute"); 730169695Skan return -EOPNOTSUPP; 731169695Skan } 732169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_MIGRATABLE) { 733169695Skan if (!ops->port_fn_migratable_set) { 734169695Skan NL_SET_ERR_MSG_ATTR(extack, attr, 735169695Skan "Port doesn't support migratable function attribute"); 736169695Skan return -EOPNOTSUPP; 737169695Skan } 738169695Skan if (devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) { 739169695Skan NL_SET_ERR_MSG_ATTR(extack, attr, 740169695Skan "migratable function attribute supported for VFs only"); 741169695Skan return -EOPNOTSUPP; 742169695Skan } 743169695Skan } 744169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO) { 745169695Skan if (!ops->port_fn_ipsec_crypto_set) { 746169695Skan NL_SET_ERR_MSG_ATTR(extack, attr, 747169695Skan "Port doesn't support ipsec_crypto function attribute"); 748169695Skan return -EOPNOTSUPP; 749169695Skan } 750169695Skan if (devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) { 751169695Skan NL_SET_ERR_MSG_ATTR(extack, attr, 752169695Skan "ipsec_crypto function attribute supported for VFs only"); 753169695Skan return -EOPNOTSUPP; 754169695Skan } 755169695Skan } 756169695Skan if (caps.selector & DEVLINK_PORT_FN_CAP_IPSEC_PACKET) { 757169695Skan if (!ops->port_fn_ipsec_packet_set) { 758169695Skan NL_SET_ERR_MSG_ATTR(extack, attr, 759169695Skan "Port doesn't support ipsec_packet function attribute"); 760169695Skan return -EOPNOTSUPP; 761169695Skan } 762169695Skan if (devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_VF) { 763169695Skan NL_SET_ERR_MSG_ATTR(extack, attr, 764169695Skan "ipsec_packet function attribute supported for VFs only"); 765169695Skan return -EOPNOTSUPP; 766169695Skan } 767169695Skan } 768169695Skan } 769169695Skan if (tb[DEVLINK_PORT_FN_ATTR_MAX_IO_EQS] && 770169695Skan !ops->port_fn_max_io_eqs_set) { 771169695Skan NL_SET_ERR_MSG_ATTR(extack, tb[DEVLINK_PORT_FN_ATTR_MAX_IO_EQS], 772169695Skan "Function does not support max_io_eqs setting"); 773169695Skan return -EOPNOTSUPP; 774169695Skan } 775169695Skan return 0; 776169695Skan} 777169695Skan 778169695Skanstatic int devlink_port_function_set(struct devlink_port *port, 779169695Skan const struct nlattr *attr, 780169695Skan struct netlink_ext_ack *extack) 781169695Skan{ 782169695Skan struct nlattr *tb[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1]; 783169695Skan int err; 784169695Skan 785169695Skan err = nla_parse_nested(tb, DEVLINK_PORT_FUNCTION_ATTR_MAX, attr, 786169695Skan devlink_function_nl_policy, extack); 787169695Skan if (err < 0) { 788169695Skan NL_SET_ERR_MSG(extack, "Fail to parse port function attributes"); 789169695Skan return err; 790169695Skan } 791169695Skan 792169695Skan err = devlink_port_function_validate(port, tb, extack); 793169695Skan if (err) 794169695Skan return err; 795169695Skan 796169695Skan attr = tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR]; 797169695Skan if (attr) { 798169695Skan err = devlink_port_function_hw_addr_set(port, attr, extack); 799169695Skan if (err) 800169695Skan return err; 801169695Skan } 802169695Skan 803169695Skan attr = tb[DEVLINK_PORT_FN_ATTR_CAPS]; 804169695Skan if (attr) { 805169695Skan err = devlink_port_fn_caps_set(port, attr, extack); 806169695Skan if (err) 807169695Skan return err; 808169695Skan } 809169695Skan 810169695Skan attr = tb[DEVLINK_PORT_FN_ATTR_MAX_IO_EQS]; 811169695Skan if (attr) { 812169695Skan err = devlink_port_fn_max_io_eqs_set(port, attr, extack); 813169695Skan if (err) 814169695Skan return err; 815169695Skan } 816169695Skan 817169695Skan /* Keep this as the last function attribute set, so that when 818169695Skan * multiple port function attributes are set along with state, 819169695Skan * Those can be applied first before activating the state. 820169695Skan */ 821169695Skan attr = tb[DEVLINK_PORT_FN_ATTR_STATE]; 822169695Skan if (attr) 823169695Skan err = devlink_port_fn_state_set(port, attr, extack); 824169695Skan 825169695Skan if (!err) 826169695Skan devlink_port_notify(port, DEVLINK_CMD_PORT_NEW); 827169695Skan return err; 828169695Skan} 829169695Skan 830169695Skanint devlink_nl_port_set_doit(struct sk_buff *skb, struct genl_info *info) 831169695Skan{ 832169695Skan struct devlink_port *devlink_port = info->user_ptr[1]; 833169695Skan int err; 834169695Skan 835169695Skan if (info->attrs[DEVLINK_ATTR_PORT_TYPE]) { 836169695Skan enum devlink_port_type port_type; 837169695Skan 838169695Skan port_type = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_TYPE]); 839169695Skan err = devlink_port_type_set(devlink_port, port_type); 840169695Skan if (err) 841169695Skan return err; 842169695Skan } 843169695Skan 844169695Skan if (info->attrs[DEVLINK_ATTR_PORT_FUNCTION]) { 845169695Skan struct nlattr *attr = info->attrs[DEVLINK_ATTR_PORT_FUNCTION]; 846169695Skan struct netlink_ext_ack *extack = info->extack; 847169695Skan 848169695Skan err = devlink_port_function_set(devlink_port, attr, extack); 849169695Skan if (err) 850169695Skan return err; 851169695Skan } 852169695Skan 853169695Skan return 0; 854169695Skan} 855169695Skan 856169695Skanint devlink_nl_port_split_doit(struct sk_buff *skb, struct genl_info *info) 857169695Skan{ 858169695Skan struct devlink_port *devlink_port = info->user_ptr[1]; 859169695Skan struct devlink *devlink = info->user_ptr[0]; 860169695Skan u32 count; 861169695Skan 862169695Skan if (GENL_REQ_ATTR_CHECK(info, DEVLINK_ATTR_PORT_SPLIT_COUNT)) 863169695Skan return -EINVAL; 864169695Skan if (!devlink_port->ops->port_split) 865169695Skan return -EOPNOTSUPP; 866169695Skan 867169695Skan count = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_SPLIT_COUNT]); 868169695Skan 869169695Skan if (!devlink_port->attrs.splittable) { 870169695Skan /* Split ports cannot be split. */ 871169695Skan if (devlink_port->attrs.split) 872169695Skan NL_SET_ERR_MSG(info->extack, "Port cannot be split further"); 873169695Skan else 874169695Skan NL_SET_ERR_MSG(info->extack, "Port cannot be split"); 875169695Skan return -EINVAL; 876169695Skan } 877169695Skan 878169695Skan if (count < 2 || !is_power_of_2(count) || count > devlink_port->attrs.lanes) { 879169695Skan NL_SET_ERR_MSG(info->extack, "Invalid split count"); 880169695Skan return -EINVAL; 881169695Skan } 882169695Skan 883169695Skan return devlink_port->ops->port_split(devlink, devlink_port, count, 884169695Skan info->extack); 885169695Skan} 886169695Skan 887169695Skanint devlink_nl_port_unsplit_doit(struct sk_buff *skb, struct genl_info *info) 888169695Skan{ 889 struct devlink_port *devlink_port = info->user_ptr[1]; 890 struct devlink *devlink = info->user_ptr[0]; 891 892 if (!devlink_port->ops->port_unsplit) 893 return -EOPNOTSUPP; 894 return devlink_port->ops->port_unsplit(devlink, devlink_port, info->extack); 895} 896 897int devlink_nl_port_new_doit(struct sk_buff *skb, struct genl_info *info) 898{ 899 struct netlink_ext_ack *extack = info->extack; 900 struct devlink_port_new_attrs new_attrs = {}; 901 struct devlink *devlink = info->user_ptr[0]; 902 struct devlink_port *devlink_port; 903 struct sk_buff *msg; 904 int err; 905 906 if (!devlink->ops->port_new) 907 return -EOPNOTSUPP; 908 909 if (!info->attrs[DEVLINK_ATTR_PORT_FLAVOUR] || 910 !info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]) { 911 NL_SET_ERR_MSG(extack, "Port flavour or PCI PF are not specified"); 912 return -EINVAL; 913 } 914 new_attrs.flavour = nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_FLAVOUR]); 915 new_attrs.pfnum = 916 nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]); 917 918 if (info->attrs[DEVLINK_ATTR_PORT_INDEX]) { 919 /* Port index of the new port being created by driver. */ 920 new_attrs.port_index = 921 nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_INDEX]); 922 new_attrs.port_index_valid = true; 923 } 924 if (info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]) { 925 new_attrs.controller = 926 nla_get_u16(info->attrs[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER]); 927 new_attrs.controller_valid = true; 928 } 929 if (new_attrs.flavour == DEVLINK_PORT_FLAVOUR_PCI_SF && 930 info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]) { 931 new_attrs.sfnum = nla_get_u32(info->attrs[DEVLINK_ATTR_PORT_PCI_SF_NUMBER]); 932 new_attrs.sfnum_valid = true; 933 } 934 935 err = devlink->ops->port_new(devlink, &new_attrs, 936 extack, &devlink_port); 937 if (err) 938 return err; 939 940 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 941 if (!msg) { 942 err = -ENOMEM; 943 goto err_out_port_del; 944 } 945 err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_PORT_NEW, 946 info->snd_portid, info->snd_seq, 0, NULL); 947 if (WARN_ON_ONCE(err)) 948 goto err_out_msg_free; 949 err = genlmsg_reply(msg, info); 950 if (err) 951 goto err_out_port_del; 952 return 0; 953 954err_out_msg_free: 955 nlmsg_free(msg); 956err_out_port_del: 957 devlink_port->ops->port_del(devlink, devlink_port, NULL); 958 return err; 959} 960 961int devlink_nl_port_del_doit(struct sk_buff *skb, struct genl_info *info) 962{ 963 struct devlink_port *devlink_port = info->user_ptr[1]; 964 struct netlink_ext_ack *extack = info->extack; 965 struct devlink *devlink = info->user_ptr[0]; 966 967 if (!devlink_port->ops->port_del) 968 return -EOPNOTSUPP; 969 970 return devlink_port->ops->port_del(devlink, devlink_port, extack); 971} 972 973static void devlink_port_type_warn(struct work_struct *work) 974{ 975 struct devlink_port *port = container_of(to_delayed_work(work), 976 struct devlink_port, 977 type_warn_dw); 978 dev_warn(port->devlink->dev, "Type was not set for devlink port."); 979} 980 981static bool devlink_port_type_should_warn(struct devlink_port *devlink_port) 982{ 983 /* Ignore CPU and DSA flavours. */ 984 return devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_CPU && 985 devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA && 986 devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_UNUSED; 987} 988 989#define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 3600) 990 991static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port) 992{ 993 if (!devlink_port_type_should_warn(devlink_port)) 994 return; 995 /* Schedule a work to WARN in case driver does not set port 996 * type within timeout. 997 */ 998 schedule_delayed_work(&devlink_port->type_warn_dw, 999 DEVLINK_PORT_TYPE_WARN_TIMEOUT); 1000} 1001 1002static void devlink_port_type_warn_cancel(struct devlink_port *devlink_port) 1003{ 1004 if (!devlink_port_type_should_warn(devlink_port)) 1005 return; 1006 cancel_delayed_work_sync(&devlink_port->type_warn_dw); 1007} 1008 1009/** 1010 * devlink_port_init() - Init devlink port 1011 * 1012 * @devlink: devlink 1013 * @devlink_port: devlink port 1014 * 1015 * Initialize essential stuff that is needed for functions 1016 * that may be called before devlink port registration. 1017 * Call to this function is optional and not needed 1018 * in case the driver does not use such functions. 1019 */ 1020void devlink_port_init(struct devlink *devlink, 1021 struct devlink_port *devlink_port) 1022{ 1023 if (devlink_port->initialized) 1024 return; 1025 devlink_port->devlink = devlink; 1026 INIT_LIST_HEAD(&devlink_port->region_list); 1027 devlink_port->initialized = true; 1028} 1029EXPORT_SYMBOL_GPL(devlink_port_init); 1030 1031/** 1032 * devlink_port_fini() - Deinitialize devlink port 1033 * 1034 * @devlink_port: devlink port 1035 * 1036 * Deinitialize essential stuff that is in use for functions 1037 * that may be called after devlink port unregistration. 1038 * Call to this function is optional and not needed 1039 * in case the driver does not use such functions. 1040 */ 1041void devlink_port_fini(struct devlink_port *devlink_port) 1042{ 1043 WARN_ON(!list_empty(&devlink_port->region_list)); 1044} 1045EXPORT_SYMBOL_GPL(devlink_port_fini); 1046 1047static const struct devlink_port_ops devlink_port_dummy_ops = {}; 1048 1049/** 1050 * devl_port_register_with_ops() - Register devlink port 1051 * 1052 * @devlink: devlink 1053 * @devlink_port: devlink port 1054 * @port_index: driver-specific numerical identifier of the port 1055 * @ops: port ops 1056 * 1057 * Register devlink port with provided port index. User can use 1058 * any indexing, even hw-related one. devlink_port structure 1059 * is convenient to be embedded inside user driver private structure. 1060 * Note that the caller should take care of zeroing the devlink_port 1061 * structure. 1062 */ 1063int devl_port_register_with_ops(struct devlink *devlink, 1064 struct devlink_port *devlink_port, 1065 unsigned int port_index, 1066 const struct devlink_port_ops *ops) 1067{ 1068 int err; 1069 1070 devl_assert_locked(devlink); 1071 1072 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1073 1074 devlink_port_init(devlink, devlink_port); 1075 devlink_port->registered = true; 1076 devlink_port->index = port_index; 1077 devlink_port->ops = ops ? ops : &devlink_port_dummy_ops; 1078 spin_lock_init(&devlink_port->type_lock); 1079 INIT_LIST_HEAD(&devlink_port->reporter_list); 1080 err = xa_insert(&devlink->ports, port_index, devlink_port, GFP_KERNEL); 1081 if (err) { 1082 devlink_port->registered = false; 1083 return err; 1084 } 1085 1086 INIT_DELAYED_WORK(&devlink_port->type_warn_dw, &devlink_port_type_warn); 1087 devlink_port_type_warn_schedule(devlink_port); 1088 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW); 1089 return 0; 1090} 1091EXPORT_SYMBOL_GPL(devl_port_register_with_ops); 1092 1093/** 1094 * devlink_port_register_with_ops - Register devlink port 1095 * 1096 * @devlink: devlink 1097 * @devlink_port: devlink port 1098 * @port_index: driver-specific numerical identifier of the port 1099 * @ops: port ops 1100 * 1101 * Register devlink port with provided port index. User can use 1102 * any indexing, even hw-related one. devlink_port structure 1103 * is convenient to be embedded inside user driver private structure. 1104 * Note that the caller should take care of zeroing the devlink_port 1105 * structure. 1106 * 1107 * Context: Takes and release devlink->lock <mutex>. 1108 */ 1109int devlink_port_register_with_ops(struct devlink *devlink, 1110 struct devlink_port *devlink_port, 1111 unsigned int port_index, 1112 const struct devlink_port_ops *ops) 1113{ 1114 int err; 1115 1116 devl_lock(devlink); 1117 err = devl_port_register_with_ops(devlink, devlink_port, 1118 port_index, ops); 1119 devl_unlock(devlink); 1120 return err; 1121} 1122EXPORT_SYMBOL_GPL(devlink_port_register_with_ops); 1123 1124/** 1125 * devl_port_unregister() - Unregister devlink port 1126 * 1127 * @devlink_port: devlink port 1128 */ 1129void devl_port_unregister(struct devlink_port *devlink_port) 1130{ 1131 lockdep_assert_held(&devlink_port->devlink->lock); 1132 WARN_ON(devlink_port->type != DEVLINK_PORT_TYPE_NOTSET); 1133 1134 devlink_port_type_warn_cancel(devlink_port); 1135 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL); 1136 xa_erase(&devlink_port->devlink->ports, devlink_port->index); 1137 WARN_ON(!list_empty(&devlink_port->reporter_list)); 1138 devlink_port->registered = false; 1139} 1140EXPORT_SYMBOL_GPL(devl_port_unregister); 1141 1142/** 1143 * devlink_port_unregister - Unregister devlink port 1144 * 1145 * @devlink_port: devlink port 1146 * 1147 * Context: Takes and release devlink->lock <mutex>. 1148 */ 1149void devlink_port_unregister(struct devlink_port *devlink_port) 1150{ 1151 struct devlink *devlink = devlink_port->devlink; 1152 1153 devl_lock(devlink); 1154 devl_port_unregister(devlink_port); 1155 devl_unlock(devlink); 1156} 1157EXPORT_SYMBOL_GPL(devlink_port_unregister); 1158 1159static void devlink_port_type_netdev_checks(struct devlink_port *devlink_port, 1160 struct net_device *netdev) 1161{ 1162 const struct net_device_ops *ops = netdev->netdev_ops; 1163 1164 /* If driver registers devlink port, it should set devlink port 1165 * attributes accordingly so the compat functions are called 1166 * and the original ops are not used. 1167 */ 1168 if (ops->ndo_get_phys_port_name) { 1169 /* Some drivers use the same set of ndos for netdevs 1170 * that have devlink_port registered and also for 1171 * those who don't. Make sure that ndo_get_phys_port_name 1172 * returns -EOPNOTSUPP here in case it is defined. 1173 * Warn if not. 1174 */ 1175 char name[IFNAMSIZ]; 1176 int err; 1177 1178 err = ops->ndo_get_phys_port_name(netdev, name, sizeof(name)); 1179 WARN_ON(err != -EOPNOTSUPP); 1180 } 1181 if (ops->ndo_get_port_parent_id) { 1182 /* Some drivers use the same set of ndos for netdevs 1183 * that have devlink_port registered and also for 1184 * those who don't. Make sure that ndo_get_port_parent_id 1185 * returns -EOPNOTSUPP here in case it is defined. 1186 * Warn if not. 1187 */ 1188 struct netdev_phys_item_id ppid; 1189 int err; 1190 1191 err = ops->ndo_get_port_parent_id(netdev, &ppid); 1192 WARN_ON(err != -EOPNOTSUPP); 1193 } 1194} 1195 1196static void __devlink_port_type_set(struct devlink_port *devlink_port, 1197 enum devlink_port_type type, 1198 void *type_dev) 1199{ 1200 struct net_device *netdev = type_dev; 1201 1202 ASSERT_DEVLINK_PORT_REGISTERED(devlink_port); 1203 1204 if (type == DEVLINK_PORT_TYPE_NOTSET) { 1205 devlink_port_type_warn_schedule(devlink_port); 1206 } else { 1207 devlink_port_type_warn_cancel(devlink_port); 1208 if (type == DEVLINK_PORT_TYPE_ETH && netdev) 1209 devlink_port_type_netdev_checks(devlink_port, netdev); 1210 } 1211 1212 spin_lock_bh(&devlink_port->type_lock); 1213 devlink_port->type = type; 1214 switch (type) { 1215 case DEVLINK_PORT_TYPE_ETH: 1216 devlink_port->type_eth.netdev = netdev; 1217 if (netdev) { 1218 ASSERT_RTNL(); 1219 devlink_port->type_eth.ifindex = netdev->ifindex; 1220 BUILD_BUG_ON(sizeof(devlink_port->type_eth.ifname) != 1221 sizeof(netdev->name)); 1222 strcpy(devlink_port->type_eth.ifname, netdev->name); 1223 } 1224 break; 1225 case DEVLINK_PORT_TYPE_IB: 1226 devlink_port->type_ib.ibdev = type_dev; 1227 break; 1228 default: 1229 break; 1230 } 1231 spin_unlock_bh(&devlink_port->type_lock); 1232 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW); 1233} 1234 1235/** 1236 * devlink_port_type_eth_set - Set port type to Ethernet 1237 * 1238 * @devlink_port: devlink port 1239 * 1240 * If driver is calling this, most likely it is doing something wrong. 1241 */ 1242void devlink_port_type_eth_set(struct devlink_port *devlink_port) 1243{ 1244 dev_warn(devlink_port->devlink->dev, 1245 "devlink port type for port %d set to Ethernet without a software interface reference, device type not supported by the kernel?\n", 1246 devlink_port->index); 1247 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, NULL); 1248} 1249EXPORT_SYMBOL_GPL(devlink_port_type_eth_set); 1250 1251/** 1252 * devlink_port_type_ib_set - Set port type to InfiniBand 1253 * 1254 * @devlink_port: devlink port 1255 * @ibdev: related IB device 1256 */ 1257void devlink_port_type_ib_set(struct devlink_port *devlink_port, 1258 struct ib_device *ibdev) 1259{ 1260 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_IB, ibdev); 1261} 1262EXPORT_SYMBOL_GPL(devlink_port_type_ib_set); 1263 1264/** 1265 * devlink_port_type_clear - Clear port type 1266 * 1267 * @devlink_port: devlink port 1268 * 1269 * If driver is calling this for clearing Ethernet type, most likely 1270 * it is doing something wrong. 1271 */ 1272void devlink_port_type_clear(struct devlink_port *devlink_port) 1273{ 1274 if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) 1275 dev_warn(devlink_port->devlink->dev, 1276 "devlink port type for port %d cleared without a software interface reference, device type not supported by the kernel?\n", 1277 devlink_port->index); 1278 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, NULL); 1279} 1280EXPORT_SYMBOL_GPL(devlink_port_type_clear); 1281 1282int devlink_port_netdevice_event(struct notifier_block *nb, 1283 unsigned long event, void *ptr) 1284{ 1285 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 1286 struct devlink_port *devlink_port = netdev->devlink_port; 1287 struct devlink *devlink; 1288 1289 if (!devlink_port) 1290 return NOTIFY_OK; 1291 devlink = devlink_port->devlink; 1292 1293 switch (event) { 1294 case NETDEV_POST_INIT: 1295 /* Set the type but not netdev pointer. It is going to be set 1296 * later on by NETDEV_REGISTER event. Happens once during 1297 * netdevice register 1298 */ 1299 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, 1300 NULL); 1301 break; 1302 case NETDEV_REGISTER: 1303 case NETDEV_CHANGENAME: 1304 if (devlink_net(devlink) != dev_net(netdev)) 1305 return NOTIFY_OK; 1306 /* Set the netdev on top of previously set type. Note this 1307 * event happens also during net namespace change so here 1308 * we take into account netdev pointer appearing in this 1309 * namespace. 1310 */ 1311 __devlink_port_type_set(devlink_port, devlink_port->type, 1312 netdev); 1313 break; 1314 case NETDEV_UNREGISTER: 1315 if (devlink_net(devlink) != dev_net(netdev)) 1316 return NOTIFY_OK; 1317 /* Clear netdev pointer, but not the type. This event happens 1318 * also during net namespace change so we need to clear 1319 * pointer to netdev that is going to another net namespace. 1320 */ 1321 __devlink_port_type_set(devlink_port, devlink_port->type, 1322 NULL); 1323 break; 1324 case NETDEV_PRE_UNINIT: 1325 /* Clear the type and the netdev pointer. Happens one during 1326 * netdevice unregister. 1327 */ 1328 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, 1329 NULL); 1330 break; 1331 } 1332 1333 return NOTIFY_OK; 1334} 1335 1336static int __devlink_port_attrs_set(struct devlink_port *devlink_port, 1337 enum devlink_port_flavour flavour) 1338{ 1339 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1340 1341 devlink_port->attrs_set = true; 1342 attrs->flavour = flavour; 1343 if (attrs->switch_id.id_len) { 1344 devlink_port->switch_port = true; 1345 if (WARN_ON(attrs->switch_id.id_len > MAX_PHYS_ITEM_ID_LEN)) 1346 attrs->switch_id.id_len = MAX_PHYS_ITEM_ID_LEN; 1347 } else { 1348 devlink_port->switch_port = false; 1349 } 1350 return 0; 1351} 1352 1353/** 1354 * devlink_port_attrs_set - Set port attributes 1355 * 1356 * @devlink_port: devlink port 1357 * @attrs: devlink port attrs 1358 */ 1359void devlink_port_attrs_set(struct devlink_port *devlink_port, 1360 struct devlink_port_attrs *attrs) 1361{ 1362 int ret; 1363 1364 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1365 1366 devlink_port->attrs = *attrs; 1367 ret = __devlink_port_attrs_set(devlink_port, attrs->flavour); 1368 if (ret) 1369 return; 1370 WARN_ON(attrs->splittable && attrs->split); 1371} 1372EXPORT_SYMBOL_GPL(devlink_port_attrs_set); 1373 1374/** 1375 * devlink_port_attrs_pci_pf_set - Set PCI PF port attributes 1376 * 1377 * @devlink_port: devlink port 1378 * @controller: associated controller number for the devlink port instance 1379 * @pf: associated PF for the devlink port instance 1380 * @external: indicates if the port is for an external controller 1381 */ 1382void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port, u32 controller, 1383 u16 pf, bool external) 1384{ 1385 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1386 int ret; 1387 1388 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1389 1390 ret = __devlink_port_attrs_set(devlink_port, 1391 DEVLINK_PORT_FLAVOUR_PCI_PF); 1392 if (ret) 1393 return; 1394 attrs->pci_pf.controller = controller; 1395 attrs->pci_pf.pf = pf; 1396 attrs->pci_pf.external = external; 1397} 1398EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_pf_set); 1399 1400/** 1401 * devlink_port_attrs_pci_vf_set - Set PCI VF port attributes 1402 * 1403 * @devlink_port: devlink port 1404 * @controller: associated controller number for the devlink port instance 1405 * @pf: associated PF for the devlink port instance 1406 * @vf: associated VF of a PF for the devlink port instance 1407 * @external: indicates if the port is for an external controller 1408 */ 1409void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port, u32 controller, 1410 u16 pf, u16 vf, bool external) 1411{ 1412 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1413 int ret; 1414 1415 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1416 1417 ret = __devlink_port_attrs_set(devlink_port, 1418 DEVLINK_PORT_FLAVOUR_PCI_VF); 1419 if (ret) 1420 return; 1421 attrs->pci_vf.controller = controller; 1422 attrs->pci_vf.pf = pf; 1423 attrs->pci_vf.vf = vf; 1424 attrs->pci_vf.external = external; 1425} 1426EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_vf_set); 1427 1428/** 1429 * devlink_port_attrs_pci_sf_set - Set PCI SF port attributes 1430 * 1431 * @devlink_port: devlink port 1432 * @controller: associated controller number for the devlink port instance 1433 * @pf: associated PF for the devlink port instance 1434 * @sf: associated SF of a PF for the devlink port instance 1435 * @external: indicates if the port is for an external controller 1436 */ 1437void devlink_port_attrs_pci_sf_set(struct devlink_port *devlink_port, u32 controller, 1438 u16 pf, u32 sf, bool external) 1439{ 1440 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1441 int ret; 1442 1443 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1444 1445 ret = __devlink_port_attrs_set(devlink_port, 1446 DEVLINK_PORT_FLAVOUR_PCI_SF); 1447 if (ret) 1448 return; 1449 attrs->pci_sf.controller = controller; 1450 attrs->pci_sf.pf = pf; 1451 attrs->pci_sf.sf = sf; 1452 attrs->pci_sf.external = external; 1453} 1454EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_sf_set); 1455 1456static void devlink_port_rel_notify_cb(struct devlink *devlink, u32 port_index) 1457{ 1458 struct devlink_port *devlink_port; 1459 1460 devlink_port = devlink_port_get_by_index(devlink, port_index); 1461 if (!devlink_port) 1462 return; 1463 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW); 1464} 1465 1466static void devlink_port_rel_cleanup_cb(struct devlink *devlink, u32 port_index, 1467 u32 rel_index) 1468{ 1469 struct devlink_port *devlink_port; 1470 1471 devlink_port = devlink_port_get_by_index(devlink, port_index); 1472 if (devlink_port && devlink_port->rel_index == rel_index) 1473 devlink_port->rel_index = 0; 1474} 1475 1476/** 1477 * devl_port_fn_devlink_set - Attach peer devlink 1478 * instance to port function. 1479 * @devlink_port: devlink port 1480 * @fn_devlink: devlink instance to attach 1481 */ 1482int devl_port_fn_devlink_set(struct devlink_port *devlink_port, 1483 struct devlink *fn_devlink) 1484{ 1485 ASSERT_DEVLINK_PORT_REGISTERED(devlink_port); 1486 1487 if (WARN_ON(devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_SF || 1488 devlink_port->attrs.pci_sf.external)) 1489 return -EINVAL; 1490 1491 return devlink_rel_nested_in_add(&devlink_port->rel_index, 1492 devlink_port->devlink->index, 1493 devlink_port->index, 1494 devlink_port_rel_notify_cb, 1495 devlink_port_rel_cleanup_cb, 1496 fn_devlink); 1497} 1498EXPORT_SYMBOL_GPL(devl_port_fn_devlink_set); 1499 1500/** 1501 * devlink_port_linecard_set - Link port with a linecard 1502 * 1503 * @devlink_port: devlink port 1504 * @linecard: devlink linecard 1505 */ 1506void devlink_port_linecard_set(struct devlink_port *devlink_port, 1507 struct devlink_linecard *linecard) 1508{ 1509 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1510 1511 devlink_port->linecard = linecard; 1512} 1513EXPORT_SYMBOL_GPL(devlink_port_linecard_set); 1514 1515static int __devlink_port_phys_port_name_get(struct devlink_port *devlink_port, 1516 char *name, size_t len) 1517{ 1518 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1519 int n = 0; 1520 1521 if (!devlink_port->attrs_set) 1522 return -EOPNOTSUPP; 1523 1524 switch (attrs->flavour) { 1525 case DEVLINK_PORT_FLAVOUR_PHYSICAL: 1526 if (devlink_port->linecard) 1527 n = snprintf(name, len, "l%u", 1528 devlink_linecard_index(devlink_port->linecard)); 1529 if (n < len) 1530 n += snprintf(name + n, len - n, "p%u", 1531 attrs->phys.port_number); 1532 if (n < len && attrs->split) 1533 n += snprintf(name + n, len - n, "s%u", 1534 attrs->phys.split_subport_number); 1535 break; 1536 case DEVLINK_PORT_FLAVOUR_CPU: 1537 case DEVLINK_PORT_FLAVOUR_DSA: 1538 case DEVLINK_PORT_FLAVOUR_UNUSED: 1539 /* As CPU and DSA ports do not have a netdevice associated 1540 * case should not ever happen. 1541 */ 1542 WARN_ON(1); 1543 return -EINVAL; 1544 case DEVLINK_PORT_FLAVOUR_PCI_PF: 1545 if (attrs->pci_pf.external) { 1546 n = snprintf(name, len, "c%u", attrs->pci_pf.controller); 1547 if (n >= len) 1548 return -EINVAL; 1549 len -= n; 1550 name += n; 1551 } 1552 n = snprintf(name, len, "pf%u", attrs->pci_pf.pf); 1553 break; 1554 case DEVLINK_PORT_FLAVOUR_PCI_VF: 1555 if (attrs->pci_vf.external) { 1556 n = snprintf(name, len, "c%u", attrs->pci_vf.controller); 1557 if (n >= len) 1558 return -EINVAL; 1559 len -= n; 1560 name += n; 1561 } 1562 n = snprintf(name, len, "pf%uvf%u", 1563 attrs->pci_vf.pf, attrs->pci_vf.vf); 1564 break; 1565 case DEVLINK_PORT_FLAVOUR_PCI_SF: 1566 if (attrs->pci_sf.external) { 1567 n = snprintf(name, len, "c%u", attrs->pci_sf.controller); 1568 if (n >= len) 1569 return -EINVAL; 1570 len -= n; 1571 name += n; 1572 } 1573 n = snprintf(name, len, "pf%usf%u", attrs->pci_sf.pf, 1574 attrs->pci_sf.sf); 1575 break; 1576 case DEVLINK_PORT_FLAVOUR_VIRTUAL: 1577 return -EOPNOTSUPP; 1578 } 1579 1580 if (n >= len) 1581 return -EINVAL; 1582 1583 return 0; 1584} 1585 1586int devlink_compat_phys_port_name_get(struct net_device *dev, 1587 char *name, size_t len) 1588{ 1589 struct devlink_port *devlink_port; 1590 1591 /* RTNL mutex is held here which ensures that devlink_port 1592 * instance cannot disappear in the middle. No need to take 1593 * any devlink lock as only permanent values are accessed. 1594 */ 1595 ASSERT_RTNL(); 1596 1597 devlink_port = dev->devlink_port; 1598 if (!devlink_port) 1599 return -EOPNOTSUPP; 1600 1601 return __devlink_port_phys_port_name_get(devlink_port, name, len); 1602} 1603 1604int devlink_compat_switch_id_get(struct net_device *dev, 1605 struct netdev_phys_item_id *ppid) 1606{ 1607 struct devlink_port *devlink_port; 1608 1609 /* Caller must hold RTNL mutex or reference to dev, which ensures that 1610 * devlink_port instance cannot disappear in the middle. No need to take 1611 * any devlink lock as only permanent values are accessed. 1612 */ 1613 devlink_port = dev->devlink_port; 1614 if (!devlink_port || !devlink_port->switch_port) 1615 return -EOPNOTSUPP; 1616 1617 memcpy(ppid, &devlink_port->attrs.switch_id, sizeof(*ppid)); 1618 1619 return 0; 1620} 1621