Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
12static 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
27struct 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
33struct 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
48struct 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
54static 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
62static 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
84static 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
107static 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
129static 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
151static 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
186static 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
210int 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
219size_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
229static 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
292static 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
318static bool
319devlink_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
325static bool
326devlink_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
332static 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
367static int
368devlink_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
375static int
376devlink_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
383static int
384devlink_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
390static int
391devlink_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
397static 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
438static int
439devlink_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
450static int
451devlink_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
479out:
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
487static 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
540nla_put_failure_type_locked:
541 spin_unlock_bh(&devlink_port->type_lock);
542nla_put_failure:
543 genlmsg_cancel(msg, hdr);
544 return -EMSGSIZE;
545}
546
547static 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
575static 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
585void devlink_ports_notify_register(struct devlink *devlink)
586{
587 devlink_ports_notify(devlink, DEVLINK_CMD_PORT_NEW);
588}
589
590void devlink_ports_notify_unregister(struct devlink *devlink)
591{
592 devlink_ports_notify(devlink, DEVLINK_CMD_PORT_DEL);
593}
594
595int 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
616static int
617devlink_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
640int 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
645static 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
666static 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
694static 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
704static 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
779static 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
831int 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
857int 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
888int 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
898int 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
955err_out_msg_free:
956 nlmsg_free(msg);
957err_out_port_del:
958 devlink_port->ops->port_del(devlink, devlink_port, NULL);
959 return err;
960}
961
962int 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
974static 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
982static 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
992static 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
1003static 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 */
1021void 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}
1031EXPORT_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 */
1043void 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}
1048EXPORT_SYMBOL_GPL(devlink_port_fini);
1049
1050static 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 */
1066int 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}
1094EXPORT_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 */
1112int 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}
1125EXPORT_SYMBOL_GPL(devlink_port_register_with_ops);
1126
1127/**
1128 * devl_port_unregister() - Unregister devlink port
1129 *
1130 * @devlink_port: devlink port
1131 */
1132void 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}
1143EXPORT_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 */
1152void 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}
1160EXPORT_SYMBOL_GPL(devlink_port_unregister);
1161
1162static 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
1199static 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 */
1245void 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}
1252EXPORT_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 */
1260void 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}
1265EXPORT_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 */
1275void 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}
1283EXPORT_SYMBOL_GPL(devlink_port_type_clear);
1284
1285int 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
1339static 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 */
1361void 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}
1370EXPORT_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 */
1380void 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}
1392EXPORT_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 */
1404void 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}
1417EXPORT_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 */
1428void 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}
1441EXPORT_SYMBOL_GPL(devlink_port_attrs_pci_sf_set);
1442
1443static 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
1453static 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 */
1469int 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}
1485EXPORT_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 */
1493void 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}
1500EXPORT_SYMBOL_GPL(devlink_port_linecard_set);
1501
1502static 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
1573int 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
1591int 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}