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