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