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