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 devlink_port->initialized = true; 1029 } 1030 EXPORT_SYMBOL_GPL(devlink_port_init); 1031 1032 /** 1033 * devlink_port_fini() - Deinitialize devlink port 1034 * 1035 * @devlink_port: devlink port 1036 * 1037 * Deinitialize essential stuff that is in use for functions 1038 * that may be called after devlink port unregistration. 1039 * Call to this function is optional and not needed 1040 * in case the driver does not use such functions. 1041 */ 1042 void devlink_port_fini(struct devlink_port *devlink_port) 1043 { 1044 WARN_ON(!list_empty(&devlink_port->region_list)); 1045 } 1046 EXPORT_SYMBOL_GPL(devlink_port_fini); 1047 1048 static const struct devlink_port_ops devlink_port_dummy_ops = {}; 1049 1050 /** 1051 * devl_port_register_with_ops() - Register devlink port 1052 * 1053 * @devlink: devlink 1054 * @devlink_port: devlink port 1055 * @port_index: driver-specific numerical identifier of the port 1056 * @ops: port ops 1057 * 1058 * Register devlink port with provided port index. User can use 1059 * any indexing, even hw-related one. devlink_port structure 1060 * is convenient to be embedded inside user driver private structure. 1061 * Note that the caller should take care of zeroing the devlink_port 1062 * structure. 1063 */ 1064 int devl_port_register_with_ops(struct devlink *devlink, 1065 struct devlink_port *devlink_port, 1066 unsigned int port_index, 1067 const struct devlink_port_ops *ops) 1068 { 1069 int err; 1070 1071 devl_assert_locked(devlink); 1072 1073 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1074 1075 devlink_port_init(devlink, devlink_port); 1076 devlink_port->registered = true; 1077 devlink_port->index = port_index; 1078 devlink_port->ops = ops ? ops : &devlink_port_dummy_ops; 1079 spin_lock_init(&devlink_port->type_lock); 1080 INIT_LIST_HEAD(&devlink_port->reporter_list); 1081 err = xa_insert(&devlink->ports, port_index, devlink_port, GFP_KERNEL); 1082 if (err) { 1083 devlink_port->registered = false; 1084 return err; 1085 } 1086 1087 INIT_DELAYED_WORK(&devlink_port->type_warn_dw, &devlink_port_type_warn); 1088 devlink_port_type_warn_schedule(devlink_port); 1089 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW); 1090 return 0; 1091 } 1092 EXPORT_SYMBOL_GPL(devl_port_register_with_ops); 1093 1094 /** 1095 * devlink_port_register_with_ops - Register devlink port 1096 * 1097 * @devlink: devlink 1098 * @devlink_port: devlink port 1099 * @port_index: driver-specific numerical identifier of the port 1100 * @ops: port ops 1101 * 1102 * Register devlink port with provided port index. User can use 1103 * any indexing, even hw-related one. devlink_port structure 1104 * is convenient to be embedded inside user driver private structure. 1105 * Note that the caller should take care of zeroing the devlink_port 1106 * structure. 1107 * 1108 * Context: Takes and release devlink->lock <mutex>. 1109 */ 1110 int devlink_port_register_with_ops(struct devlink *devlink, 1111 struct devlink_port *devlink_port, 1112 unsigned int port_index, 1113 const struct devlink_port_ops *ops) 1114 { 1115 int err; 1116 1117 devl_lock(devlink); 1118 err = devl_port_register_with_ops(devlink, devlink_port, 1119 port_index, ops); 1120 devl_unlock(devlink); 1121 return err; 1122 } 1123 EXPORT_SYMBOL_GPL(devlink_port_register_with_ops); 1124 1125 /** 1126 * devl_port_unregister() - Unregister devlink port 1127 * 1128 * @devlink_port: devlink port 1129 */ 1130 void devl_port_unregister(struct devlink_port *devlink_port) 1131 { 1132 lockdep_assert_held(&devlink_port->devlink->lock); 1133 WARN_ON(devlink_port->type != DEVLINK_PORT_TYPE_NOTSET); 1134 1135 devlink_port_type_warn_cancel(devlink_port); 1136 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_DEL); 1137 xa_erase(&devlink_port->devlink->ports, devlink_port->index); 1138 WARN_ON(!list_empty(&devlink_port->reporter_list)); 1139 devlink_port->registered = false; 1140 } 1141 EXPORT_SYMBOL_GPL(devl_port_unregister); 1142 1143 /** 1144 * devlink_port_unregister - Unregister devlink port 1145 * 1146 * @devlink_port: devlink port 1147 * 1148 * Context: Takes and release devlink->lock <mutex>. 1149 */ 1150 void devlink_port_unregister(struct devlink_port *devlink_port) 1151 { 1152 struct devlink *devlink = devlink_port->devlink; 1153 1154 devl_lock(devlink); 1155 devl_port_unregister(devlink_port); 1156 devl_unlock(devlink); 1157 } 1158 EXPORT_SYMBOL_GPL(devlink_port_unregister); 1159 1160 static void devlink_port_type_netdev_checks(struct devlink_port *devlink_port, 1161 struct net_device *netdev) 1162 { 1163 const struct net_device_ops *ops = netdev->netdev_ops; 1164 1165 /* If driver registers devlink port, it should set devlink port 1166 * attributes accordingly so the compat functions are called 1167 * and the original ops are not used. 1168 */ 1169 if (ops->ndo_get_phys_port_name) { 1170 /* Some drivers use the same set of ndos for netdevs 1171 * that have devlink_port registered and also for 1172 * those who don't. Make sure that ndo_get_phys_port_name 1173 * returns -EOPNOTSUPP here in case it is defined. 1174 * Warn if not. 1175 */ 1176 char name[IFNAMSIZ]; 1177 int err; 1178 1179 err = ops->ndo_get_phys_port_name(netdev, name, sizeof(name)); 1180 WARN_ON(err != -EOPNOTSUPP); 1181 } 1182 if (ops->ndo_get_port_parent_id) { 1183 /* Some drivers use the same set of ndos for netdevs 1184 * that have devlink_port registered and also for 1185 * those who don't. Make sure that ndo_get_port_parent_id 1186 * returns -EOPNOTSUPP here in case it is defined. 1187 * Warn if not. 1188 */ 1189 struct netdev_phys_item_id ppid; 1190 int err; 1191 1192 err = ops->ndo_get_port_parent_id(netdev, &ppid); 1193 WARN_ON(err != -EOPNOTSUPP); 1194 } 1195 } 1196 1197 static void __devlink_port_type_set(struct devlink_port *devlink_port, 1198 enum devlink_port_type type, 1199 void *type_dev) 1200 { 1201 struct net_device *netdev = type_dev; 1202 1203 ASSERT_DEVLINK_PORT_REGISTERED(devlink_port); 1204 1205 if (type == DEVLINK_PORT_TYPE_NOTSET) { 1206 devlink_port_type_warn_schedule(devlink_port); 1207 } else { 1208 devlink_port_type_warn_cancel(devlink_port); 1209 if (type == DEVLINK_PORT_TYPE_ETH && netdev) 1210 devlink_port_type_netdev_checks(devlink_port, netdev); 1211 } 1212 1213 spin_lock_bh(&devlink_port->type_lock); 1214 devlink_port->type = type; 1215 switch (type) { 1216 case DEVLINK_PORT_TYPE_ETH: 1217 devlink_port->type_eth.netdev = netdev; 1218 if (netdev) { 1219 ASSERT_RTNL(); 1220 devlink_port->type_eth.ifindex = netdev->ifindex; 1221 BUILD_BUG_ON(sizeof(devlink_port->type_eth.ifname) != 1222 sizeof(netdev->name)); 1223 strcpy(devlink_port->type_eth.ifname, netdev->name); 1224 } 1225 break; 1226 case DEVLINK_PORT_TYPE_IB: 1227 devlink_port->type_ib.ibdev = type_dev; 1228 break; 1229 default: 1230 break; 1231 } 1232 spin_unlock_bh(&devlink_port->type_lock); 1233 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW); 1234 } 1235 1236 /** 1237 * devlink_port_type_eth_set - Set port type to Ethernet 1238 * 1239 * @devlink_port: devlink port 1240 * 1241 * If driver is calling this, most likely it is doing something wrong. 1242 */ 1243 void devlink_port_type_eth_set(struct devlink_port *devlink_port) 1244 { 1245 devl_warn(devlink_port->devlink, 1246 "devlink port type for port %d set to Ethernet without a software interface reference, device type not supported by the kernel?\n", 1247 devlink_port->index); 1248 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, NULL); 1249 } 1250 EXPORT_SYMBOL_GPL(devlink_port_type_eth_set); 1251 1252 /** 1253 * devlink_port_type_ib_set - Set port type to InfiniBand 1254 * 1255 * @devlink_port: devlink port 1256 * @ibdev: related IB device 1257 */ 1258 void devlink_port_type_ib_set(struct devlink_port *devlink_port, 1259 struct ib_device *ibdev) 1260 { 1261 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_IB, ibdev); 1262 } 1263 EXPORT_SYMBOL_GPL(devlink_port_type_ib_set); 1264 1265 /** 1266 * devlink_port_type_clear - Clear port type 1267 * 1268 * @devlink_port: devlink port 1269 * 1270 * If driver is calling this for clearing Ethernet type, most likely 1271 * it is doing something wrong. 1272 */ 1273 void devlink_port_type_clear(struct devlink_port *devlink_port) 1274 { 1275 if (devlink_port->type == DEVLINK_PORT_TYPE_ETH) 1276 devl_warn(devlink_port->devlink, 1277 "devlink port type for port %d cleared without a software interface reference, device type not supported by the kernel?\n", 1278 devlink_port->index); 1279 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, NULL); 1280 } 1281 EXPORT_SYMBOL_GPL(devlink_port_type_clear); 1282 1283 int devlink_port_netdevice_event(struct notifier_block *nb, 1284 unsigned long event, void *ptr) 1285 { 1286 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 1287 struct devlink_port *devlink_port = netdev->devlink_port; 1288 struct devlink *devlink; 1289 1290 if (!devlink_port) 1291 return NOTIFY_OK; 1292 devlink = devlink_port->devlink; 1293 1294 switch (event) { 1295 case NETDEV_POST_INIT: 1296 /* Set the type but not netdev pointer. It is going to be set 1297 * later on by NETDEV_REGISTER event. Happens once during 1298 * netdevice register 1299 */ 1300 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_ETH, 1301 NULL); 1302 break; 1303 case NETDEV_REGISTER: 1304 case NETDEV_CHANGENAME: 1305 if (devlink_net(devlink) != dev_net(netdev)) 1306 return NOTIFY_OK; 1307 /* Set the netdev on top of previously set type. Note this 1308 * event happens also during net namespace change so here 1309 * we take into account netdev pointer appearing in this 1310 * namespace. 1311 */ 1312 __devlink_port_type_set(devlink_port, devlink_port->type, 1313 netdev); 1314 break; 1315 case NETDEV_UNREGISTER: 1316 if (devlink_net(devlink) != dev_net(netdev)) 1317 return NOTIFY_OK; 1318 /* Clear netdev pointer, but not the type. This event happens 1319 * also during net namespace change so we need to clear 1320 * pointer to netdev that is going to another net namespace. 1321 */ 1322 __devlink_port_type_set(devlink_port, devlink_port->type, 1323 NULL); 1324 break; 1325 case NETDEV_PRE_UNINIT: 1326 /* Clear the type and the netdev pointer. Happens one during 1327 * netdevice unregister. 1328 */ 1329 __devlink_port_type_set(devlink_port, DEVLINK_PORT_TYPE_NOTSET, 1330 NULL); 1331 break; 1332 } 1333 1334 return NOTIFY_OK; 1335 } 1336 1337 static void __devlink_port_attrs_set(struct devlink_port *devlink_port, 1338 enum devlink_port_flavour flavour) 1339 { 1340 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1341 1342 devlink_port->attrs_set = true; 1343 attrs->flavour = flavour; 1344 if (attrs->switch_id.id_len) { 1345 devlink_port->switch_port = true; 1346 if (WARN_ON(attrs->switch_id.id_len > MAX_PHYS_ITEM_ID_LEN)) 1347 attrs->switch_id.id_len = MAX_PHYS_ITEM_ID_LEN; 1348 } else { 1349 devlink_port->switch_port = false; 1350 } 1351 } 1352 1353 /** 1354 * devlink_port_attrs_set - Set port attributes 1355 * 1356 * @devlink_port: devlink port 1357 * @attrs: devlink port attrs 1358 */ 1359 void devlink_port_attrs_set(struct devlink_port *devlink_port, 1360 const struct devlink_port_attrs *attrs) 1361 { 1362 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1363 WARN_ON(attrs->splittable && attrs->split); 1364 1365 devlink_port->attrs = *attrs; 1366 __devlink_port_attrs_set(devlink_port, attrs->flavour); 1367 } 1368 EXPORT_SYMBOL_GPL(devlink_port_attrs_set); 1369 1370 /** 1371 * devlink_port_attrs_pci_pf_set - Set PCI PF port attributes 1372 * 1373 * @devlink_port: devlink port 1374 * @controller: associated controller number for the devlink port instance 1375 * @pf: associated PCI function number for the devlink port instance 1376 * @external: indicates if the port is for an external controller 1377 */ 1378 void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port, u32 controller, 1379 u16 pf, bool external) 1380 { 1381 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1382 1383 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1384 1385 __devlink_port_attrs_set(devlink_port, DEVLINK_PORT_FLAVOUR_PCI_PF); 1386 attrs->pci_pf.controller = controller; 1387 attrs->pci_pf.pf = pf; 1388 attrs->pci_pf.external = external; 1389 } 1390 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_pf_set); 1391 1392 /** 1393 * devlink_port_attrs_pci_vf_set - Set PCI VF port attributes 1394 * 1395 * @devlink_port: devlink port 1396 * @controller: associated controller number for the devlink port instance 1397 * @pf: associated PCI function number for the devlink port instance 1398 * @vf: associated PCI VF number of a PF for the devlink port instance; 1399 * VF number starts from 0 for the first PCI virtual function 1400 * @external: indicates if the port is for an external controller 1401 */ 1402 void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port, u32 controller, 1403 u16 pf, u16 vf, bool external) 1404 { 1405 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1406 1407 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1408 1409 __devlink_port_attrs_set(devlink_port, DEVLINK_PORT_FLAVOUR_PCI_VF); 1410 attrs->pci_vf.controller = controller; 1411 attrs->pci_vf.pf = pf; 1412 attrs->pci_vf.vf = vf; 1413 attrs->pci_vf.external = external; 1414 } 1415 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_vf_set); 1416 1417 /** 1418 * devlink_port_attrs_pci_sf_set - Set PCI SF port attributes 1419 * 1420 * @devlink_port: devlink port 1421 * @controller: associated controller number for the devlink port instance 1422 * @pf: associated PCI function number for the devlink port instance 1423 * @sf: associated SF number of a PF for the devlink port instance 1424 * @external: indicates if the port is for an external controller 1425 */ 1426 void devlink_port_attrs_pci_sf_set(struct devlink_port *devlink_port, u32 controller, 1427 u16 pf, u32 sf, bool external) 1428 { 1429 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1430 1431 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1432 1433 __devlink_port_attrs_set(devlink_port, DEVLINK_PORT_FLAVOUR_PCI_SF); 1434 attrs->pci_sf.controller = controller; 1435 attrs->pci_sf.pf = pf; 1436 attrs->pci_sf.sf = sf; 1437 attrs->pci_sf.external = external; 1438 } 1439 EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_sf_set); 1440 1441 static void devlink_port_rel_notify_cb(struct devlink *devlink, u32 port_index) 1442 { 1443 struct devlink_port *devlink_port; 1444 1445 devlink_port = devlink_port_get_by_index(devlink, port_index); 1446 if (!devlink_port) 1447 return; 1448 devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW); 1449 } 1450 1451 static void devlink_port_rel_cleanup_cb(struct devlink *devlink, u32 port_index, 1452 u32 rel_index) 1453 { 1454 struct devlink_port *devlink_port; 1455 1456 devlink_port = devlink_port_get_by_index(devlink, port_index); 1457 if (devlink_port && devlink_port->rel_index == rel_index) 1458 devlink_port->rel_index = 0; 1459 } 1460 1461 /** 1462 * devl_port_fn_devlink_set - Attach peer devlink 1463 * instance to port function. 1464 * @devlink_port: devlink port 1465 * @fn_devlink: devlink instance to attach 1466 */ 1467 int devl_port_fn_devlink_set(struct devlink_port *devlink_port, 1468 struct devlink *fn_devlink) 1469 { 1470 ASSERT_DEVLINK_PORT_REGISTERED(devlink_port); 1471 1472 if (WARN_ON(devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_PCI_SF || 1473 devlink_port->attrs.pci_sf.external)) 1474 return -EINVAL; 1475 1476 return devlink_rel_nested_in_add(&devlink_port->rel_index, 1477 devlink_port->devlink->index, 1478 devlink_port->index, 1479 devlink_port_rel_notify_cb, 1480 devlink_port_rel_cleanup_cb, 1481 fn_devlink); 1482 } 1483 EXPORT_SYMBOL_GPL(devl_port_fn_devlink_set); 1484 1485 /** 1486 * devlink_port_linecard_set - Link port with a linecard 1487 * 1488 * @devlink_port: devlink port 1489 * @linecard: devlink linecard 1490 */ 1491 void devlink_port_linecard_set(struct devlink_port *devlink_port, 1492 struct devlink_linecard *linecard) 1493 { 1494 ASSERT_DEVLINK_PORT_NOT_REGISTERED(devlink_port); 1495 1496 devlink_port->linecard = linecard; 1497 } 1498 EXPORT_SYMBOL_GPL(devlink_port_linecard_set); 1499 1500 static int __devlink_port_phys_port_name_get(struct devlink_port *devlink_port, 1501 char *name, size_t len) 1502 { 1503 struct devlink_port_attrs *attrs = &devlink_port->attrs; 1504 int n = 0; 1505 1506 if (!devlink_port->attrs_set || devlink_port->attrs.no_phys_port_name) 1507 return -EOPNOTSUPP; 1508 1509 switch (attrs->flavour) { 1510 case DEVLINK_PORT_FLAVOUR_PHYSICAL: 1511 if (devlink_port->linecard) 1512 n = snprintf(name, len, "l%u", 1513 devlink_linecard_index(devlink_port->linecard)); 1514 if (n < len) 1515 n += snprintf(name + n, len - n, "p%u", 1516 attrs->phys.port_number); 1517 if (n < len && attrs->split) 1518 n += snprintf(name + n, len - n, "s%u", 1519 attrs->phys.split_subport_number); 1520 break; 1521 case DEVLINK_PORT_FLAVOUR_CPU: 1522 case DEVLINK_PORT_FLAVOUR_DSA: 1523 case DEVLINK_PORT_FLAVOUR_UNUSED: 1524 /* As CPU and DSA ports do not have a netdevice associated 1525 * case should not ever happen. 1526 */ 1527 WARN_ON(1); 1528 return -EINVAL; 1529 case DEVLINK_PORT_FLAVOUR_PCI_PF: 1530 if (attrs->pci_pf.external) { 1531 n = snprintf(name, len, "c%u", attrs->pci_pf.controller); 1532 if (n >= len) 1533 return -EINVAL; 1534 len -= n; 1535 name += n; 1536 } 1537 n = snprintf(name, len, "pf%u", attrs->pci_pf.pf); 1538 break; 1539 case DEVLINK_PORT_FLAVOUR_PCI_VF: 1540 if (attrs->pci_vf.external) { 1541 n = snprintf(name, len, "c%u", attrs->pci_vf.controller); 1542 if (n >= len) 1543 return -EINVAL; 1544 len -= n; 1545 name += n; 1546 } 1547 n = snprintf(name, len, "pf%uvf%u", 1548 attrs->pci_vf.pf, attrs->pci_vf.vf); 1549 break; 1550 case DEVLINK_PORT_FLAVOUR_PCI_SF: 1551 if (attrs->pci_sf.external) { 1552 n = snprintf(name, len, "c%u", attrs->pci_sf.controller); 1553 if (n >= len) 1554 return -EINVAL; 1555 len -= n; 1556 name += n; 1557 } 1558 n = snprintf(name, len, "pf%usf%u", attrs->pci_sf.pf, 1559 attrs->pci_sf.sf); 1560 break; 1561 case DEVLINK_PORT_FLAVOUR_VIRTUAL: 1562 return -EOPNOTSUPP; 1563 } 1564 1565 if (n >= len) 1566 return -EINVAL; 1567 1568 return 0; 1569 } 1570 1571 int devlink_compat_phys_port_name_get(struct net_device *dev, 1572 char *name, size_t len) 1573 { 1574 struct devlink_port *devlink_port; 1575 1576 /* RTNL mutex is held here which ensures that devlink_port 1577 * instance cannot disappear in the middle. No need to take 1578 * any devlink lock as only permanent values are accessed. 1579 */ 1580 ASSERT_RTNL(); 1581 1582 devlink_port = dev->devlink_port; 1583 if (!devlink_port) 1584 return -EOPNOTSUPP; 1585 1586 return __devlink_port_phys_port_name_get(devlink_port, name, len); 1587 } 1588 1589 int devlink_compat_switch_id_get(struct net_device *dev, 1590 struct netdev_phys_item_id *ppid) 1591 { 1592 struct devlink_port *devlink_port; 1593 1594 /* Caller must hold RTNL mutex or reference to dev, which ensures that 1595 * devlink_port instance cannot disappear in the middle. No need to take 1596 * any devlink lock as only permanent values are accessed. 1597 */ 1598 devlink_port = dev->devlink_port; 1599 if (!devlink_port || !devlink_port->switch_port) 1600 return -EOPNOTSUPP; 1601 1602 memcpy(ppid, &devlink_port->attrs.switch_id, sizeof(*ppid)); 1603 1604 return 0; 1605 } 1606