1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -*- linux-c -*-
3  * INET		802.1Q VLAN
4  *		Ethernet-type device handling.
5  *
6  * Authors:	Ben Greear <[email protected]>
7  *              Please send support related email to: [email protected]
8  *              VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
9  *
10  * Fixes:       Mar 22 2001: Martin Bokaemper <[email protected]>
11  *                - reset skb->pkt_type on incoming packets when MAC was changed
12  *                - see that changed MAC is saddr for outgoing packets
13  *              Oct 20, 2001:  Ard van Breeman:
14  *                - Fix MC-list, finally.
15  *                - Flush MC-list on VLAN destroy.
16  */
17 
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 
20 #include <linux/module.h>
21 #include <linux/slab.h>
22 #include <linux/skbuff.h>
23 #include <linux/netdevice.h>
24 #include <linux/net_tstamp.h>
25 #include <linux/etherdevice.h>
26 #include <linux/ethtool.h>
27 #include <linux/phy.h>
28 #include <net/arp.h>
29 #include <net/macsec.h>
30 
31 #include "vlan.h"
32 #include "vlanproc.h"
33 #include <linux/if_vlan.h>
34 #include <linux/netpoll.h>
35 
36 /*
37  *	Create the VLAN header for an arbitrary protocol layer
38  *
39  *	saddr=NULL	means use device source address
40  *	daddr=NULL	means leave destination address (eg unresolved arp)
41  *
42  *  This is called when the SKB is moving down the stack towards the
43  *  physical devices.
44  */
vlan_dev_hard_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned int len)45 static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,
46 				unsigned short type,
47 				const void *daddr, const void *saddr,
48 				unsigned int len)
49 {
50 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
51 	struct vlan_hdr *vhdr;
52 	unsigned int vhdrlen = 0;
53 	u16 vlan_tci = 0;
54 	int rc;
55 
56 	if (!(vlan->flags & VLAN_FLAG_REORDER_HDR)) {
57 		vhdr = skb_push(skb, VLAN_HLEN);
58 
59 		vlan_tci = vlan->vlan_id;
60 		vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb->priority);
61 		vhdr->h_vlan_TCI = htons(vlan_tci);
62 
63 		/*
64 		 *  Set the protocol type. For a packet of type ETH_P_802_3/2 we
65 		 *  put the length in here instead.
66 		 */
67 		if (type != ETH_P_802_3 && type != ETH_P_802_2)
68 			vhdr->h_vlan_encapsulated_proto = htons(type);
69 		else
70 			vhdr->h_vlan_encapsulated_proto = htons(len);
71 
72 		skb->protocol = vlan->vlan_proto;
73 		type = ntohs(vlan->vlan_proto);
74 		vhdrlen = VLAN_HLEN;
75 	}
76 
77 	/* Before delegating work to the lower layer, enter our MAC-address */
78 	if (saddr == NULL)
79 		saddr = dev->dev_addr;
80 
81 	/* Now make the underlying real hard header */
82 	dev = vlan->real_dev;
83 	rc = dev_hard_header(skb, dev, type, daddr, saddr, len + vhdrlen);
84 	if (rc > 0)
85 		rc += vhdrlen;
86 	return rc;
87 }
88 
vlan_netpoll_send_skb(struct vlan_dev_priv * vlan,struct sk_buff * skb)89 static inline netdev_tx_t vlan_netpoll_send_skb(struct vlan_dev_priv *vlan, struct sk_buff *skb)
90 {
91 #ifdef CONFIG_NET_POLL_CONTROLLER
92 	return netpoll_send_skb(vlan->netpoll, skb);
93 #else
94 	BUG();
95 	return NETDEV_TX_OK;
96 #endif
97 }
98 
vlan_dev_hard_start_xmit(struct sk_buff * skb,struct net_device * dev)99 static netdev_tx_t vlan_dev_hard_start_xmit(struct sk_buff *skb,
100 					    struct net_device *dev)
101 {
102 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
103 	struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);
104 	unsigned int len;
105 	int ret;
106 
107 	/* Handle non-VLAN frames if they are sent to us, for example by DHCP.
108 	 *
109 	 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING
110 	 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...
111 	 */
112 	if (vlan->flags & VLAN_FLAG_REORDER_HDR ||
113 	    veth->h_vlan_proto != vlan->vlan_proto) {
114 		u16 vlan_tci;
115 		vlan_tci = vlan->vlan_id;
116 		vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb->priority);
117 		__vlan_hwaccel_put_tag(skb, vlan->vlan_proto, vlan_tci);
118 	}
119 
120 	skb->dev = vlan->real_dev;
121 	len = skb->len;
122 	if (unlikely(netpoll_tx_running(dev)))
123 		return vlan_netpoll_send_skb(vlan, skb);
124 
125 	ret = dev_queue_xmit(skb);
126 
127 	if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
128 		struct vlan_pcpu_stats *stats;
129 
130 		stats = this_cpu_ptr(vlan->vlan_pcpu_stats);
131 		u64_stats_update_begin(&stats->syncp);
132 		u64_stats_inc(&stats->tx_packets);
133 		u64_stats_add(&stats->tx_bytes, len);
134 		u64_stats_update_end(&stats->syncp);
135 	} else {
136 		this_cpu_inc(vlan->vlan_pcpu_stats->tx_dropped);
137 	}
138 
139 	return ret;
140 }
141 
vlan_dev_change_mtu(struct net_device * dev,int new_mtu)142 static int vlan_dev_change_mtu(struct net_device *dev, int new_mtu)
143 {
144 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
145 	unsigned int max_mtu = real_dev->mtu;
146 
147 	if (netif_reduces_vlan_mtu(real_dev))
148 		max_mtu -= VLAN_HLEN;
149 	if (max_mtu < new_mtu)
150 		return -ERANGE;
151 
152 	WRITE_ONCE(dev->mtu, new_mtu);
153 
154 	return 0;
155 }
156 
vlan_dev_set_ingress_priority(const struct net_device * dev,u32 skb_prio,u16 vlan_prio)157 void vlan_dev_set_ingress_priority(const struct net_device *dev,
158 				   u32 skb_prio, u16 vlan_prio)
159 {
160 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
161 
162 	if (vlan->ingress_priority_map[vlan_prio & 0x7] && !skb_prio)
163 		vlan->nr_ingress_mappings--;
164 	else if (!vlan->ingress_priority_map[vlan_prio & 0x7] && skb_prio)
165 		vlan->nr_ingress_mappings++;
166 
167 	vlan->ingress_priority_map[vlan_prio & 0x7] = skb_prio;
168 }
169 
vlan_dev_set_egress_priority(const struct net_device * dev,u32 skb_prio,u16 vlan_prio)170 int vlan_dev_set_egress_priority(const struct net_device *dev,
171 				 u32 skb_prio, u16 vlan_prio)
172 {
173 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
174 	struct vlan_priority_tci_mapping *mp = NULL;
175 	struct vlan_priority_tci_mapping *np;
176 	u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK;
177 
178 	/* See if a priority mapping exists.. */
179 	mp = vlan->egress_priority_map[skb_prio & 0xF];
180 	while (mp) {
181 		if (mp->priority == skb_prio) {
182 			if (mp->vlan_qos && !vlan_qos)
183 				vlan->nr_egress_mappings--;
184 			else if (!mp->vlan_qos && vlan_qos)
185 				vlan->nr_egress_mappings++;
186 			mp->vlan_qos = vlan_qos;
187 			return 0;
188 		}
189 		mp = mp->next;
190 	}
191 
192 	/* Create a new mapping then. */
193 	mp = vlan->egress_priority_map[skb_prio & 0xF];
194 	np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL);
195 	if (!np)
196 		return -ENOBUFS;
197 
198 	np->next = mp;
199 	np->priority = skb_prio;
200 	np->vlan_qos = vlan_qos;
201 	/* Before inserting this element in hash table, make sure all its fields
202 	 * are committed to memory.
203 	 * coupled with smp_rmb() in vlan_dev_get_egress_qos_mask()
204 	 */
205 	smp_wmb();
206 	vlan->egress_priority_map[skb_prio & 0xF] = np;
207 	if (vlan_qos)
208 		vlan->nr_egress_mappings++;
209 	return 0;
210 }
211 
212 /* Flags are defined in the vlan_flags enum in
213  * include/uapi/linux/if_vlan.h file.
214  */
vlan_dev_change_flags(const struct net_device * dev,u32 flags,u32 mask)215 int vlan_dev_change_flags(const struct net_device *dev, u32 flags, u32 mask)
216 {
217 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
218 	u32 old_flags = vlan->flags;
219 
220 	if (mask & ~(VLAN_FLAG_REORDER_HDR | VLAN_FLAG_GVRP |
221 		     VLAN_FLAG_LOOSE_BINDING | VLAN_FLAG_MVRP |
222 		     VLAN_FLAG_BRIDGE_BINDING))
223 		return -EINVAL;
224 
225 	vlan->flags = (old_flags & ~mask) | (flags & mask);
226 
227 	if (netif_running(dev) && (vlan->flags ^ old_flags) & VLAN_FLAG_GVRP) {
228 		if (vlan->flags & VLAN_FLAG_GVRP)
229 			vlan_gvrp_request_join(dev);
230 		else
231 			vlan_gvrp_request_leave(dev);
232 	}
233 
234 	if (netif_running(dev) && (vlan->flags ^ old_flags) & VLAN_FLAG_MVRP) {
235 		if (vlan->flags & VLAN_FLAG_MVRP)
236 			vlan_mvrp_request_join(dev);
237 		else
238 			vlan_mvrp_request_leave(dev);
239 	}
240 	return 0;
241 }
242 
vlan_dev_get_realdev_name(const struct net_device * dev,char * result,size_t size)243 void vlan_dev_get_realdev_name(const struct net_device *dev, char *result, size_t size)
244 {
245 	strscpy_pad(result, vlan_dev_priv(dev)->real_dev->name, size);
246 }
247 
vlan_dev_inherit_address(struct net_device * dev,struct net_device * real_dev)248 bool vlan_dev_inherit_address(struct net_device *dev,
249 			      struct net_device *real_dev)
250 {
251 	if (dev->addr_assign_type != NET_ADDR_STOLEN)
252 		return false;
253 
254 	eth_hw_addr_set(dev, real_dev->dev_addr);
255 	call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
256 	return true;
257 }
258 
vlan_dev_open(struct net_device * dev)259 static int vlan_dev_open(struct net_device *dev)
260 {
261 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
262 	struct net_device *real_dev = vlan->real_dev;
263 	int err;
264 
265 	if (!(real_dev->flags & IFF_UP) &&
266 	    !(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
267 		return -ENETDOWN;
268 
269 	if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr) &&
270 	    !vlan_dev_inherit_address(dev, real_dev)) {
271 		err = dev_uc_add(real_dev, dev->dev_addr);
272 		if (err < 0)
273 			goto out;
274 	}
275 
276 	ether_addr_copy(vlan->real_dev_addr, real_dev->dev_addr);
277 
278 	if (vlan->flags & VLAN_FLAG_GVRP)
279 		vlan_gvrp_request_join(dev);
280 
281 	if (vlan->flags & VLAN_FLAG_MVRP)
282 		vlan_mvrp_request_join(dev);
283 
284 	if (netif_carrier_ok(real_dev) &&
285 	    !(vlan->flags & VLAN_FLAG_BRIDGE_BINDING))
286 		netif_carrier_on(dev);
287 	return 0;
288 
289 out:
290 	netif_carrier_off(dev);
291 	return err;
292 }
293 
vlan_dev_stop(struct net_device * dev)294 static int vlan_dev_stop(struct net_device *dev)
295 {
296 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
297 	struct net_device *real_dev = vlan->real_dev;
298 
299 	dev_mc_unsync(real_dev, dev);
300 	dev_uc_unsync(real_dev, dev);
301 
302 	if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
303 		dev_uc_del(real_dev, dev->dev_addr);
304 
305 	if (!(vlan->flags & VLAN_FLAG_BRIDGE_BINDING))
306 		netif_carrier_off(dev);
307 	return 0;
308 }
309 
vlan_dev_set_mac_address(struct net_device * dev,void * p)310 static int vlan_dev_set_mac_address(struct net_device *dev, void *p)
311 {
312 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
313 	struct sockaddr *addr = p;
314 	int err;
315 
316 	if (!is_valid_ether_addr(addr->sa_data))
317 		return -EADDRNOTAVAIL;
318 
319 	if (!(dev->flags & IFF_UP))
320 		goto out;
321 
322 	if (!ether_addr_equal(addr->sa_data, real_dev->dev_addr)) {
323 		err = dev_uc_add(real_dev, addr->sa_data);
324 		if (err < 0)
325 			return err;
326 	}
327 
328 	if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
329 		dev_uc_del(real_dev, dev->dev_addr);
330 
331 out:
332 	eth_hw_addr_set(dev, addr->sa_data);
333 	return 0;
334 }
335 
vlan_hwtstamp_get(struct net_device * dev,struct kernel_hwtstamp_config * cfg)336 static int vlan_hwtstamp_get(struct net_device *dev,
337 			     struct kernel_hwtstamp_config *cfg)
338 {
339 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
340 
341 	return generic_hwtstamp_get_lower(real_dev, cfg);
342 }
343 
vlan_hwtstamp_set(struct net_device * dev,struct kernel_hwtstamp_config * cfg,struct netlink_ext_ack * extack)344 static int vlan_hwtstamp_set(struct net_device *dev,
345 			     struct kernel_hwtstamp_config *cfg,
346 			     struct netlink_ext_ack *extack)
347 {
348 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
349 
350 	if (!net_eq(dev_net(dev), dev_net(real_dev)))
351 		return -EOPNOTSUPP;
352 
353 	return generic_hwtstamp_set_lower(real_dev, cfg, extack);
354 }
355 
vlan_dev_ioctl(struct net_device * dev,struct ifreq * ifr,int cmd)356 static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
357 {
358 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
359 	const struct net_device_ops *ops = real_dev->netdev_ops;
360 	struct ifreq ifrr;
361 	int err = -EOPNOTSUPP;
362 
363 	strscpy_pad(ifrr.ifr_name, real_dev->name, IFNAMSIZ);
364 	ifrr.ifr_ifru = ifr->ifr_ifru;
365 
366 	switch (cmd) {
367 	case SIOCGMIIPHY:
368 	case SIOCGMIIREG:
369 	case SIOCSMIIREG:
370 		if (netif_device_present(real_dev) && ops->ndo_eth_ioctl)
371 			err = ops->ndo_eth_ioctl(real_dev, &ifrr, cmd);
372 		break;
373 	}
374 
375 	if (!err)
376 		ifr->ifr_ifru = ifrr.ifr_ifru;
377 
378 	return err;
379 }
380 
vlan_dev_neigh_setup(struct net_device * dev,struct neigh_parms * pa)381 static int vlan_dev_neigh_setup(struct net_device *dev, struct neigh_parms *pa)
382 {
383 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
384 	const struct net_device_ops *ops = real_dev->netdev_ops;
385 	int err = 0;
386 
387 	if (netif_device_present(real_dev) && ops->ndo_neigh_setup)
388 		err = ops->ndo_neigh_setup(real_dev, pa);
389 
390 	return err;
391 }
392 
393 #if IS_ENABLED(CONFIG_FCOE)
vlan_dev_fcoe_ddp_setup(struct net_device * dev,u16 xid,struct scatterlist * sgl,unsigned int sgc)394 static int vlan_dev_fcoe_ddp_setup(struct net_device *dev, u16 xid,
395 				   struct scatterlist *sgl, unsigned int sgc)
396 {
397 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
398 	const struct net_device_ops *ops = real_dev->netdev_ops;
399 	int rc = 0;
400 
401 	if (ops->ndo_fcoe_ddp_setup)
402 		rc = ops->ndo_fcoe_ddp_setup(real_dev, xid, sgl, sgc);
403 
404 	return rc;
405 }
406 
vlan_dev_fcoe_ddp_done(struct net_device * dev,u16 xid)407 static int vlan_dev_fcoe_ddp_done(struct net_device *dev, u16 xid)
408 {
409 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
410 	const struct net_device_ops *ops = real_dev->netdev_ops;
411 	int len = 0;
412 
413 	if (ops->ndo_fcoe_ddp_done)
414 		len = ops->ndo_fcoe_ddp_done(real_dev, xid);
415 
416 	return len;
417 }
418 
vlan_dev_fcoe_enable(struct net_device * dev)419 static int vlan_dev_fcoe_enable(struct net_device *dev)
420 {
421 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
422 	const struct net_device_ops *ops = real_dev->netdev_ops;
423 	int rc = -EINVAL;
424 
425 	if (ops->ndo_fcoe_enable)
426 		rc = ops->ndo_fcoe_enable(real_dev);
427 	return rc;
428 }
429 
vlan_dev_fcoe_disable(struct net_device * dev)430 static int vlan_dev_fcoe_disable(struct net_device *dev)
431 {
432 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
433 	const struct net_device_ops *ops = real_dev->netdev_ops;
434 	int rc = -EINVAL;
435 
436 	if (ops->ndo_fcoe_disable)
437 		rc = ops->ndo_fcoe_disable(real_dev);
438 	return rc;
439 }
440 
vlan_dev_fcoe_ddp_target(struct net_device * dev,u16 xid,struct scatterlist * sgl,unsigned int sgc)441 static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid,
442 				    struct scatterlist *sgl, unsigned int sgc)
443 {
444 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
445 	const struct net_device_ops *ops = real_dev->netdev_ops;
446 	int rc = 0;
447 
448 	if (ops->ndo_fcoe_ddp_target)
449 		rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc);
450 
451 	return rc;
452 }
453 #endif
454 
455 #ifdef NETDEV_FCOE_WWNN
vlan_dev_fcoe_get_wwn(struct net_device * dev,u64 * wwn,int type)456 static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type)
457 {
458 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
459 	const struct net_device_ops *ops = real_dev->netdev_ops;
460 	int rc = -EINVAL;
461 
462 	if (ops->ndo_fcoe_get_wwn)
463 		rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type);
464 	return rc;
465 }
466 #endif
467 
vlan_dev_change_rx_flags(struct net_device * dev,int change)468 static void vlan_dev_change_rx_flags(struct net_device *dev, int change)
469 {
470 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
471 
472 	if (change & IFF_ALLMULTI)
473 		dev_set_allmulti(real_dev, dev->flags & IFF_ALLMULTI ? 1 : -1);
474 	if (change & IFF_PROMISC)
475 		dev_set_promiscuity(real_dev, dev->flags & IFF_PROMISC ? 1 : -1);
476 }
477 
vlan_dev_set_rx_mode(struct net_device * vlan_dev)478 static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)
479 {
480 	dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
481 	dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
482 }
483 
vlan_parse_protocol(const struct sk_buff * skb)484 static __be16 vlan_parse_protocol(const struct sk_buff *skb)
485 {
486 	struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);
487 
488 	return __vlan_get_protocol(skb, veth->h_vlan_proto, NULL);
489 }
490 
491 static const struct header_ops vlan_header_ops = {
492 	.create	 = vlan_dev_hard_header,
493 	.parse	 = eth_header_parse,
494 	.parse_protocol = vlan_parse_protocol,
495 };
496 
vlan_passthru_hard_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned int len)497 static int vlan_passthru_hard_header(struct sk_buff *skb, struct net_device *dev,
498 				     unsigned short type,
499 				     const void *daddr, const void *saddr,
500 				     unsigned int len)
501 {
502 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
503 	struct net_device *real_dev = vlan->real_dev;
504 
505 	if (saddr == NULL)
506 		saddr = dev->dev_addr;
507 
508 	return dev_hard_header(skb, real_dev, type, daddr, saddr, len);
509 }
510 
511 static const struct header_ops vlan_passthru_header_ops = {
512 	.create	 = vlan_passthru_hard_header,
513 	.parse	 = eth_header_parse,
514 	.parse_protocol = vlan_parse_protocol,
515 };
516 
517 static const struct device_type vlan_type = {
518 	.name	= "vlan",
519 };
520 
521 static const struct net_device_ops vlan_netdev_ops;
522 
vlan_dev_init(struct net_device * dev)523 static int vlan_dev_init(struct net_device *dev)
524 {
525 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
526 	struct net_device *real_dev = vlan->real_dev;
527 
528 	netif_carrier_off(dev);
529 
530 	/* IFF_BROADCAST|IFF_MULTICAST; ??? */
531 	dev->flags  = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
532 					  IFF_MASTER | IFF_SLAVE);
533 	dev->state  = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |
534 					  (1<<__LINK_STATE_DORMANT))) |
535 		      (1<<__LINK_STATE_PRESENT);
536 
537 	if (vlan->flags & VLAN_FLAG_BRIDGE_BINDING)
538 		dev->state |= (1 << __LINK_STATE_NOCARRIER);
539 
540 	dev->hw_features = NETIF_F_HW_CSUM | NETIF_F_SG |
541 			   NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE |
542 			   NETIF_F_GSO_ENCAP_ALL |
543 			   NETIF_F_HIGHDMA | NETIF_F_SCTP_CRC |
544 			   NETIF_F_FCOE_CRC | NETIF_F_FSO;
545 
546 	if (real_dev->vlan_features & NETIF_F_HW_MACSEC)
547 		dev->hw_features |= NETIF_F_HW_MACSEC;
548 
549 	dev->features |= dev->hw_features;
550 	dev->lltx = true;
551 	dev->fcoe_mtu = true;
552 	netif_inherit_tso_max(dev, real_dev);
553 	if (dev->features & NETIF_F_VLAN_FEATURES)
554 		netdev_warn(real_dev, "VLAN features are set incorrectly.  Q-in-Q configurations may not work correctly.\n");
555 
556 	dev->vlan_features = real_dev->vlan_features &
557 			     ~(NETIF_F_FCOE_CRC | NETIF_F_FSO);
558 	dev->hw_enc_features = vlan_tnl_features(real_dev);
559 	dev->mpls_features = real_dev->mpls_features;
560 
561 	/* ipv6 shared card related stuff */
562 	dev->dev_id = real_dev->dev_id;
563 
564 	if (is_zero_ether_addr(dev->dev_addr)) {
565 		eth_hw_addr_set(dev, real_dev->dev_addr);
566 		dev->addr_assign_type = NET_ADDR_STOLEN;
567 	}
568 	if (is_zero_ether_addr(dev->broadcast))
569 		memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len);
570 
571 #if IS_ENABLED(CONFIG_FCOE)
572 	dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid;
573 #endif
574 
575 	dev->needed_headroom = real_dev->needed_headroom;
576 	if (vlan_hw_offload_capable(real_dev->features, vlan->vlan_proto)) {
577 		dev->header_ops      = &vlan_passthru_header_ops;
578 		dev->hard_header_len = real_dev->hard_header_len;
579 	} else {
580 		dev->header_ops      = &vlan_header_ops;
581 		dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;
582 	}
583 
584 	dev->netdev_ops = &vlan_netdev_ops;
585 
586 	SET_NETDEV_DEVTYPE(dev, &vlan_type);
587 
588 	netdev_lockdep_set_classes(dev);
589 
590 	vlan->vlan_pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
591 	if (!vlan->vlan_pcpu_stats)
592 		return -ENOMEM;
593 
594 	/* Get vlan's reference to real_dev */
595 	netdev_hold(real_dev, &vlan->dev_tracker, GFP_KERNEL);
596 
597 	return 0;
598 }
599 
600 /* Note: this function might be called multiple times for the same device. */
vlan_dev_free_egress_priority(const struct net_device * dev)601 void vlan_dev_free_egress_priority(const struct net_device *dev)
602 {
603 	struct vlan_priority_tci_mapping *pm;
604 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
605 	int i;
606 
607 	for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) {
608 		while ((pm = vlan->egress_priority_map[i]) != NULL) {
609 			vlan->egress_priority_map[i] = pm->next;
610 			kfree(pm);
611 		}
612 	}
613 }
614 
vlan_dev_uninit(struct net_device * dev)615 static void vlan_dev_uninit(struct net_device *dev)
616 {
617 	vlan_dev_free_egress_priority(dev);
618 }
619 
vlan_dev_fix_features(struct net_device * dev,netdev_features_t features)620 static netdev_features_t vlan_dev_fix_features(struct net_device *dev,
621 	netdev_features_t features)
622 {
623 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
624 	netdev_features_t old_features = features;
625 	netdev_features_t lower_features;
626 
627 	lower_features = netdev_intersect_features((real_dev->vlan_features |
628 						    NETIF_F_RXCSUM),
629 						   real_dev->features);
630 
631 	/* Add HW_CSUM setting to preserve user ability to control
632 	 * checksum offload on the vlan device.
633 	 */
634 	if (lower_features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))
635 		lower_features |= NETIF_F_HW_CSUM;
636 	features = netdev_intersect_features(features, lower_features);
637 	features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_GSO_SOFTWARE);
638 
639 	return features;
640 }
641 
vlan_ethtool_get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * cmd)642 static int vlan_ethtool_get_link_ksettings(struct net_device *dev,
643 					   struct ethtool_link_ksettings *cmd)
644 {
645 	const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
646 
647 	return __ethtool_get_link_ksettings(vlan->real_dev, cmd);
648 }
649 
vlan_ethtool_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)650 static void vlan_ethtool_get_drvinfo(struct net_device *dev,
651 				     struct ethtool_drvinfo *info)
652 {
653 	strscpy(info->driver, vlan_fullname, sizeof(info->driver));
654 	strscpy(info->version, vlan_version, sizeof(info->version));
655 	strscpy(info->fw_version, "N/A", sizeof(info->fw_version));
656 }
657 
vlan_ethtool_get_ts_info(struct net_device * dev,struct kernel_ethtool_ts_info * info)658 static int vlan_ethtool_get_ts_info(struct net_device *dev,
659 				    struct kernel_ethtool_ts_info *info)
660 {
661 	const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
662 	return ethtool_get_ts_info_by_layer(vlan->real_dev, info);
663 }
664 
vlan_dev_get_stats64(struct net_device * dev,struct rtnl_link_stats64 * stats)665 static void vlan_dev_get_stats64(struct net_device *dev,
666 				 struct rtnl_link_stats64 *stats)
667 {
668 	struct vlan_pcpu_stats *p;
669 	u32 rx_errors = 0, tx_dropped = 0;
670 	int i;
671 
672 	for_each_possible_cpu(i) {
673 		u64 rxpackets, rxbytes, rxmulticast, txpackets, txbytes;
674 		unsigned int start;
675 
676 		p = per_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats, i);
677 		do {
678 			start = u64_stats_fetch_begin(&p->syncp);
679 			rxpackets	= u64_stats_read(&p->rx_packets);
680 			rxbytes		= u64_stats_read(&p->rx_bytes);
681 			rxmulticast	= u64_stats_read(&p->rx_multicast);
682 			txpackets	= u64_stats_read(&p->tx_packets);
683 			txbytes		= u64_stats_read(&p->tx_bytes);
684 		} while (u64_stats_fetch_retry(&p->syncp, start));
685 
686 		stats->rx_packets	+= rxpackets;
687 		stats->rx_bytes		+= rxbytes;
688 		stats->multicast	+= rxmulticast;
689 		stats->tx_packets	+= txpackets;
690 		stats->tx_bytes		+= txbytes;
691 		/* rx_errors & tx_dropped are u32 */
692 		rx_errors	+= READ_ONCE(p->rx_errors);
693 		tx_dropped	+= READ_ONCE(p->tx_dropped);
694 	}
695 	stats->rx_errors  = rx_errors;
696 	stats->tx_dropped = tx_dropped;
697 }
698 
699 #ifdef CONFIG_NET_POLL_CONTROLLER
vlan_dev_poll_controller(struct net_device * dev)700 static void vlan_dev_poll_controller(struct net_device *dev)
701 {
702 	return;
703 }
704 
vlan_dev_netpoll_setup(struct net_device * dev)705 static int vlan_dev_netpoll_setup(struct net_device *dev)
706 {
707 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
708 	struct net_device *real_dev = vlan->real_dev;
709 	struct netpoll *netpoll;
710 	int err = 0;
711 
712 	netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
713 	err = -ENOMEM;
714 	if (!netpoll)
715 		goto out;
716 
717 	err = __netpoll_setup(netpoll, real_dev);
718 	if (err) {
719 		kfree(netpoll);
720 		goto out;
721 	}
722 
723 	vlan->netpoll = netpoll;
724 
725 out:
726 	return err;
727 }
728 
vlan_dev_netpoll_cleanup(struct net_device * dev)729 static void vlan_dev_netpoll_cleanup(struct net_device *dev)
730 {
731 	struct vlan_dev_priv *vlan= vlan_dev_priv(dev);
732 	struct netpoll *netpoll = vlan->netpoll;
733 
734 	if (!netpoll)
735 		return;
736 
737 	vlan->netpoll = NULL;
738 	__netpoll_free(netpoll);
739 }
740 #endif /* CONFIG_NET_POLL_CONTROLLER */
741 
vlan_dev_get_iflink(const struct net_device * dev)742 static int vlan_dev_get_iflink(const struct net_device *dev)
743 {
744 	const struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
745 
746 	return READ_ONCE(real_dev->ifindex);
747 }
748 
vlan_dev_fill_forward_path(struct net_device_path_ctx * ctx,struct net_device_path * path)749 static int vlan_dev_fill_forward_path(struct net_device_path_ctx *ctx,
750 				      struct net_device_path *path)
751 {
752 	struct vlan_dev_priv *vlan = vlan_dev_priv(ctx->dev);
753 
754 	path->type = DEV_PATH_VLAN;
755 	path->encap.id = vlan->vlan_id;
756 	path->encap.proto = vlan->vlan_proto;
757 	path->dev = ctx->dev;
758 	ctx->dev = vlan->real_dev;
759 	if (ctx->num_vlans >= ARRAY_SIZE(ctx->vlan))
760 		return -ENOSPC;
761 
762 	ctx->vlan[ctx->num_vlans].id = vlan->vlan_id;
763 	ctx->vlan[ctx->num_vlans].proto = vlan->vlan_proto;
764 	ctx->num_vlans++;
765 
766 	return 0;
767 }
768 
769 #if IS_ENABLED(CONFIG_MACSEC)
770 
vlan_get_macsec_ops(const struct macsec_context * ctx)771 static const struct macsec_ops *vlan_get_macsec_ops(const struct macsec_context *ctx)
772 {
773 	return vlan_dev_priv(ctx->netdev)->real_dev->macsec_ops;
774 }
775 
vlan_macsec_offload(int (* const func)(struct macsec_context *),struct macsec_context * ctx)776 static int vlan_macsec_offload(int (* const func)(struct macsec_context *),
777 			       struct macsec_context *ctx)
778 {
779 	if (unlikely(!func))
780 		return 0;
781 
782 	return (*func)(ctx);
783 }
784 
vlan_macsec_dev_open(struct macsec_context * ctx)785 static int vlan_macsec_dev_open(struct macsec_context *ctx)
786 {
787 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
788 
789 	if (!ops)
790 		return -EOPNOTSUPP;
791 
792 	return vlan_macsec_offload(ops->mdo_dev_open, ctx);
793 }
794 
vlan_macsec_dev_stop(struct macsec_context * ctx)795 static int vlan_macsec_dev_stop(struct macsec_context *ctx)
796 {
797 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
798 
799 	if (!ops)
800 		return -EOPNOTSUPP;
801 
802 	return vlan_macsec_offload(ops->mdo_dev_stop, ctx);
803 }
804 
vlan_macsec_add_secy(struct macsec_context * ctx)805 static int vlan_macsec_add_secy(struct macsec_context *ctx)
806 {
807 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
808 
809 	if (!ops)
810 		return -EOPNOTSUPP;
811 
812 	return vlan_macsec_offload(ops->mdo_add_secy, ctx);
813 }
814 
vlan_macsec_upd_secy(struct macsec_context * ctx)815 static int vlan_macsec_upd_secy(struct macsec_context *ctx)
816 {
817 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
818 
819 	if (!ops)
820 		return -EOPNOTSUPP;
821 
822 	return vlan_macsec_offload(ops->mdo_upd_secy, ctx);
823 }
824 
vlan_macsec_del_secy(struct macsec_context * ctx)825 static int vlan_macsec_del_secy(struct macsec_context *ctx)
826 {
827 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
828 
829 	if (!ops)
830 		return -EOPNOTSUPP;
831 
832 	return vlan_macsec_offload(ops->mdo_del_secy, ctx);
833 }
834 
vlan_macsec_add_rxsc(struct macsec_context * ctx)835 static int vlan_macsec_add_rxsc(struct macsec_context *ctx)
836 {
837 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
838 
839 	if (!ops)
840 		return -EOPNOTSUPP;
841 
842 	return vlan_macsec_offload(ops->mdo_add_rxsc, ctx);
843 }
844 
vlan_macsec_upd_rxsc(struct macsec_context * ctx)845 static int vlan_macsec_upd_rxsc(struct macsec_context *ctx)
846 {
847 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
848 
849 	if (!ops)
850 		return -EOPNOTSUPP;
851 
852 	return vlan_macsec_offload(ops->mdo_upd_rxsc, ctx);
853 }
854 
vlan_macsec_del_rxsc(struct macsec_context * ctx)855 static int vlan_macsec_del_rxsc(struct macsec_context *ctx)
856 {
857 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
858 
859 	if (!ops)
860 		return -EOPNOTSUPP;
861 
862 	return vlan_macsec_offload(ops->mdo_del_rxsc, ctx);
863 }
864 
vlan_macsec_add_rxsa(struct macsec_context * ctx)865 static int vlan_macsec_add_rxsa(struct macsec_context *ctx)
866 {
867 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
868 
869 	if (!ops)
870 		return -EOPNOTSUPP;
871 
872 	return vlan_macsec_offload(ops->mdo_add_rxsa, ctx);
873 }
874 
vlan_macsec_upd_rxsa(struct macsec_context * ctx)875 static int vlan_macsec_upd_rxsa(struct macsec_context *ctx)
876 {
877 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
878 
879 	if (!ops)
880 		return -EOPNOTSUPP;
881 
882 	return vlan_macsec_offload(ops->mdo_upd_rxsa, ctx);
883 }
884 
vlan_macsec_del_rxsa(struct macsec_context * ctx)885 static int vlan_macsec_del_rxsa(struct macsec_context *ctx)
886 {
887 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
888 
889 	if (!ops)
890 		return -EOPNOTSUPP;
891 
892 	return vlan_macsec_offload(ops->mdo_del_rxsa, ctx);
893 }
894 
vlan_macsec_add_txsa(struct macsec_context * ctx)895 static int vlan_macsec_add_txsa(struct macsec_context *ctx)
896 {
897 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
898 
899 	if (!ops)
900 		return -EOPNOTSUPP;
901 
902 	return vlan_macsec_offload(ops->mdo_add_txsa, ctx);
903 }
904 
vlan_macsec_upd_txsa(struct macsec_context * ctx)905 static int vlan_macsec_upd_txsa(struct macsec_context *ctx)
906 {
907 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
908 
909 	if (!ops)
910 		return -EOPNOTSUPP;
911 
912 	return vlan_macsec_offload(ops->mdo_upd_txsa, ctx);
913 }
914 
vlan_macsec_del_txsa(struct macsec_context * ctx)915 static int vlan_macsec_del_txsa(struct macsec_context *ctx)
916 {
917 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
918 
919 	if (!ops)
920 		return -EOPNOTSUPP;
921 
922 	return vlan_macsec_offload(ops->mdo_del_txsa, ctx);
923 }
924 
vlan_macsec_get_dev_stats(struct macsec_context * ctx)925 static int vlan_macsec_get_dev_stats(struct macsec_context *ctx)
926 {
927 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
928 
929 	if (!ops)
930 		return -EOPNOTSUPP;
931 
932 	return vlan_macsec_offload(ops->mdo_get_dev_stats, ctx);
933 }
934 
vlan_macsec_get_tx_sc_stats(struct macsec_context * ctx)935 static int vlan_macsec_get_tx_sc_stats(struct macsec_context *ctx)
936 {
937 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
938 
939 	if (!ops)
940 		return -EOPNOTSUPP;
941 
942 	return vlan_macsec_offload(ops->mdo_get_tx_sc_stats, ctx);
943 }
944 
vlan_macsec_get_tx_sa_stats(struct macsec_context * ctx)945 static int vlan_macsec_get_tx_sa_stats(struct macsec_context *ctx)
946 {
947 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
948 
949 	if (!ops)
950 		return -EOPNOTSUPP;
951 
952 	return vlan_macsec_offload(ops->mdo_get_tx_sa_stats, ctx);
953 }
954 
vlan_macsec_get_rx_sc_stats(struct macsec_context * ctx)955 static int vlan_macsec_get_rx_sc_stats(struct macsec_context *ctx)
956 {
957 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
958 
959 	if (!ops)
960 		return -EOPNOTSUPP;
961 
962 	return vlan_macsec_offload(ops->mdo_get_rx_sc_stats, ctx);
963 }
964 
vlan_macsec_get_rx_sa_stats(struct macsec_context * ctx)965 static int vlan_macsec_get_rx_sa_stats(struct macsec_context *ctx)
966 {
967 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
968 
969 	if (!ops)
970 		return -EOPNOTSUPP;
971 
972 	return vlan_macsec_offload(ops->mdo_get_rx_sa_stats, ctx);
973 }
974 
975 static const struct macsec_ops macsec_offload_ops = {
976 	/* Device wide */
977 	.mdo_dev_open = vlan_macsec_dev_open,
978 	.mdo_dev_stop = vlan_macsec_dev_stop,
979 	/* SecY */
980 	.mdo_add_secy = vlan_macsec_add_secy,
981 	.mdo_upd_secy = vlan_macsec_upd_secy,
982 	.mdo_del_secy = vlan_macsec_del_secy,
983 	/* Security channels */
984 	.mdo_add_rxsc = vlan_macsec_add_rxsc,
985 	.mdo_upd_rxsc = vlan_macsec_upd_rxsc,
986 	.mdo_del_rxsc = vlan_macsec_del_rxsc,
987 	/* Security associations */
988 	.mdo_add_rxsa = vlan_macsec_add_rxsa,
989 	.mdo_upd_rxsa = vlan_macsec_upd_rxsa,
990 	.mdo_del_rxsa = vlan_macsec_del_rxsa,
991 	.mdo_add_txsa = vlan_macsec_add_txsa,
992 	.mdo_upd_txsa = vlan_macsec_upd_txsa,
993 	.mdo_del_txsa = vlan_macsec_del_txsa,
994 	/* Statistics */
995 	.mdo_get_dev_stats = vlan_macsec_get_dev_stats,
996 	.mdo_get_tx_sc_stats = vlan_macsec_get_tx_sc_stats,
997 	.mdo_get_tx_sa_stats = vlan_macsec_get_tx_sa_stats,
998 	.mdo_get_rx_sc_stats = vlan_macsec_get_rx_sc_stats,
999 	.mdo_get_rx_sa_stats = vlan_macsec_get_rx_sa_stats,
1000 };
1001 
1002 #endif
1003 
1004 static const struct ethtool_ops vlan_ethtool_ops = {
1005 	.get_link_ksettings	= vlan_ethtool_get_link_ksettings,
1006 	.get_drvinfo	        = vlan_ethtool_get_drvinfo,
1007 	.get_link		= ethtool_op_get_link,
1008 	.get_ts_info		= vlan_ethtool_get_ts_info,
1009 };
1010 
1011 static const struct net_device_ops vlan_netdev_ops = {
1012 	.ndo_change_mtu		= vlan_dev_change_mtu,
1013 	.ndo_init		= vlan_dev_init,
1014 	.ndo_uninit		= vlan_dev_uninit,
1015 	.ndo_open		= vlan_dev_open,
1016 	.ndo_stop		= vlan_dev_stop,
1017 	.ndo_start_xmit =  vlan_dev_hard_start_xmit,
1018 	.ndo_validate_addr	= eth_validate_addr,
1019 	.ndo_set_mac_address	= vlan_dev_set_mac_address,
1020 	.ndo_set_rx_mode	= vlan_dev_set_rx_mode,
1021 	.ndo_change_rx_flags	= vlan_dev_change_rx_flags,
1022 	.ndo_eth_ioctl		= vlan_dev_ioctl,
1023 	.ndo_neigh_setup	= vlan_dev_neigh_setup,
1024 	.ndo_get_stats64	= vlan_dev_get_stats64,
1025 #if IS_ENABLED(CONFIG_FCOE)
1026 	.ndo_fcoe_ddp_setup	= vlan_dev_fcoe_ddp_setup,
1027 	.ndo_fcoe_ddp_done	= vlan_dev_fcoe_ddp_done,
1028 	.ndo_fcoe_enable	= vlan_dev_fcoe_enable,
1029 	.ndo_fcoe_disable	= vlan_dev_fcoe_disable,
1030 	.ndo_fcoe_ddp_target	= vlan_dev_fcoe_ddp_target,
1031 #endif
1032 #ifdef NETDEV_FCOE_WWNN
1033 	.ndo_fcoe_get_wwn	= vlan_dev_fcoe_get_wwn,
1034 #endif
1035 #ifdef CONFIG_NET_POLL_CONTROLLER
1036 	.ndo_poll_controller	= vlan_dev_poll_controller,
1037 	.ndo_netpoll_setup	= vlan_dev_netpoll_setup,
1038 	.ndo_netpoll_cleanup	= vlan_dev_netpoll_cleanup,
1039 #endif
1040 	.ndo_fix_features	= vlan_dev_fix_features,
1041 	.ndo_get_iflink		= vlan_dev_get_iflink,
1042 	.ndo_fill_forward_path	= vlan_dev_fill_forward_path,
1043 	.ndo_hwtstamp_get	= vlan_hwtstamp_get,
1044 	.ndo_hwtstamp_set	= vlan_hwtstamp_set,
1045 };
1046 
vlan_dev_free(struct net_device * dev)1047 static void vlan_dev_free(struct net_device *dev)
1048 {
1049 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
1050 
1051 	free_percpu(vlan->vlan_pcpu_stats);
1052 	vlan->vlan_pcpu_stats = NULL;
1053 
1054 	/* Get rid of the vlan's reference to real_dev */
1055 	netdev_put(vlan->real_dev, &vlan->dev_tracker);
1056 }
1057 
vlan_setup(struct net_device * dev)1058 void vlan_setup(struct net_device *dev)
1059 {
1060 	ether_setup(dev);
1061 
1062 	dev->priv_flags		|= IFF_802_1Q_VLAN | IFF_NO_QUEUE;
1063 	dev->priv_flags		|= IFF_UNICAST_FLT;
1064 	dev->priv_flags		&= ~IFF_TX_SKB_SHARING;
1065 	netif_keep_dst(dev);
1066 
1067 	dev->netdev_ops		= &vlan_netdev_ops;
1068 	dev->needs_free_netdev	= true;
1069 	dev->priv_destructor	= vlan_dev_free;
1070 	dev->ethtool_ops	= &vlan_ethtool_ops;
1071 
1072 #if IS_ENABLED(CONFIG_MACSEC)
1073 	dev->macsec_ops		= &macsec_offload_ops;
1074 #endif
1075 	dev->min_mtu		= 0;
1076 	dev->max_mtu		= ETH_MAX_MTU;
1077 
1078 	eth_zero_addr(dev->broadcast);
1079 }
1080