xref: /openbmc/linux/net/8021q/vlan_dev.c (revision 65c9fde1)
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 <greearb@candelatech.com>
7  *              Please send support related email to: netdev@vger.kernel.org
8  *              VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
9  *
10  * Fixes:       Mar 22 2001: Martin Bokaemper <mbokaemper@unispherenetworks.com>
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 	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 	if (dev->flags & IFF_ALLMULTI) {
277 		err = dev_set_allmulti(real_dev, 1);
278 		if (err < 0)
279 			goto del_unicast;
280 	}
281 	if (dev->flags & IFF_PROMISC) {
282 		err = dev_set_promiscuity(real_dev, 1);
283 		if (err < 0)
284 			goto clear_allmulti;
285 	}
286 
287 	ether_addr_copy(vlan->real_dev_addr, real_dev->dev_addr);
288 
289 	if (vlan->flags & VLAN_FLAG_GVRP)
290 		vlan_gvrp_request_join(dev);
291 
292 	if (vlan->flags & VLAN_FLAG_MVRP)
293 		vlan_mvrp_request_join(dev);
294 
295 	if (netif_carrier_ok(real_dev) &&
296 	    !(vlan->flags & VLAN_FLAG_BRIDGE_BINDING))
297 		netif_carrier_on(dev);
298 	return 0;
299 
300 clear_allmulti:
301 	if (dev->flags & IFF_ALLMULTI)
302 		dev_set_allmulti(real_dev, -1);
303 del_unicast:
304 	if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
305 		dev_uc_del(real_dev, dev->dev_addr);
306 out:
307 	netif_carrier_off(dev);
308 	return err;
309 }
310 
vlan_dev_stop(struct net_device * dev)311 static int vlan_dev_stop(struct net_device *dev)
312 {
313 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
314 	struct net_device *real_dev = vlan->real_dev;
315 
316 	dev_mc_unsync(real_dev, dev);
317 	dev_uc_unsync(real_dev, dev);
318 	if (dev->flags & IFF_ALLMULTI)
319 		dev_set_allmulti(real_dev, -1);
320 	if (dev->flags & IFF_PROMISC)
321 		dev_set_promiscuity(real_dev, -1);
322 
323 	if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
324 		dev_uc_del(real_dev, dev->dev_addr);
325 
326 	if (!(vlan->flags & VLAN_FLAG_BRIDGE_BINDING))
327 		netif_carrier_off(dev);
328 	return 0;
329 }
330 
vlan_dev_set_mac_address(struct net_device * dev,void * p)331 static int vlan_dev_set_mac_address(struct net_device *dev, void *p)
332 {
333 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
334 	struct sockaddr *addr = p;
335 	int err;
336 
337 	if (!is_valid_ether_addr(addr->sa_data))
338 		return -EADDRNOTAVAIL;
339 
340 	if (!(dev->flags & IFF_UP))
341 		goto out;
342 
343 	if (!ether_addr_equal(addr->sa_data, real_dev->dev_addr)) {
344 		err = dev_uc_add(real_dev, addr->sa_data);
345 		if (err < 0)
346 			return err;
347 	}
348 
349 	if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
350 		dev_uc_del(real_dev, dev->dev_addr);
351 
352 out:
353 	eth_hw_addr_set(dev, addr->sa_data);
354 	return 0;
355 }
356 
vlan_hwtstamp_get(struct net_device * dev,struct kernel_hwtstamp_config * cfg)357 static int vlan_hwtstamp_get(struct net_device *dev,
358 			     struct kernel_hwtstamp_config *cfg)
359 {
360 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
361 
362 	return generic_hwtstamp_get_lower(real_dev, cfg);
363 }
364 
vlan_hwtstamp_set(struct net_device * dev,struct kernel_hwtstamp_config * cfg,struct netlink_ext_ack * extack)365 static int vlan_hwtstamp_set(struct net_device *dev,
366 			     struct kernel_hwtstamp_config *cfg,
367 			     struct netlink_ext_ack *extack)
368 {
369 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
370 
371 	if (!net_eq(dev_net(dev), dev_net(real_dev)))
372 		return -EOPNOTSUPP;
373 
374 	return generic_hwtstamp_set_lower(real_dev, cfg, extack);
375 }
376 
vlan_dev_ioctl(struct net_device * dev,struct ifreq * ifr,int cmd)377 static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
378 {
379 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
380 	const struct net_device_ops *ops = real_dev->netdev_ops;
381 	struct ifreq ifrr;
382 	int err = -EOPNOTSUPP;
383 
384 	strscpy_pad(ifrr.ifr_name, real_dev->name, IFNAMSIZ);
385 	ifrr.ifr_ifru = ifr->ifr_ifru;
386 
387 	switch (cmd) {
388 	case SIOCGMIIPHY:
389 	case SIOCGMIIREG:
390 	case SIOCSMIIREG:
391 		if (netif_device_present(real_dev) && ops->ndo_eth_ioctl)
392 			err = ops->ndo_eth_ioctl(real_dev, &ifrr, cmd);
393 		break;
394 	}
395 
396 	if (!err)
397 		ifr->ifr_ifru = ifrr.ifr_ifru;
398 
399 	return err;
400 }
401 
vlan_dev_neigh_setup(struct net_device * dev,struct neigh_parms * pa)402 static int vlan_dev_neigh_setup(struct net_device *dev, struct neigh_parms *pa)
403 {
404 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
405 	const struct net_device_ops *ops = real_dev->netdev_ops;
406 	int err = 0;
407 
408 	if (netif_device_present(real_dev) && ops->ndo_neigh_setup)
409 		err = ops->ndo_neigh_setup(real_dev, pa);
410 
411 	return err;
412 }
413 
414 #if IS_ENABLED(CONFIG_FCOE)
vlan_dev_fcoe_ddp_setup(struct net_device * dev,u16 xid,struct scatterlist * sgl,unsigned int sgc)415 static int vlan_dev_fcoe_ddp_setup(struct net_device *dev, u16 xid,
416 				   struct scatterlist *sgl, unsigned int sgc)
417 {
418 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
419 	const struct net_device_ops *ops = real_dev->netdev_ops;
420 	int rc = 0;
421 
422 	if (ops->ndo_fcoe_ddp_setup)
423 		rc = ops->ndo_fcoe_ddp_setup(real_dev, xid, sgl, sgc);
424 
425 	return rc;
426 }
427 
vlan_dev_fcoe_ddp_done(struct net_device * dev,u16 xid)428 static int vlan_dev_fcoe_ddp_done(struct net_device *dev, u16 xid)
429 {
430 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
431 	const struct net_device_ops *ops = real_dev->netdev_ops;
432 	int len = 0;
433 
434 	if (ops->ndo_fcoe_ddp_done)
435 		len = ops->ndo_fcoe_ddp_done(real_dev, xid);
436 
437 	return len;
438 }
439 
vlan_dev_fcoe_enable(struct net_device * dev)440 static int vlan_dev_fcoe_enable(struct net_device *dev)
441 {
442 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
443 	const struct net_device_ops *ops = real_dev->netdev_ops;
444 	int rc = -EINVAL;
445 
446 	if (ops->ndo_fcoe_enable)
447 		rc = ops->ndo_fcoe_enable(real_dev);
448 	return rc;
449 }
450 
vlan_dev_fcoe_disable(struct net_device * dev)451 static int vlan_dev_fcoe_disable(struct net_device *dev)
452 {
453 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
454 	const struct net_device_ops *ops = real_dev->netdev_ops;
455 	int rc = -EINVAL;
456 
457 	if (ops->ndo_fcoe_disable)
458 		rc = ops->ndo_fcoe_disable(real_dev);
459 	return rc;
460 }
461 
vlan_dev_fcoe_ddp_target(struct net_device * dev,u16 xid,struct scatterlist * sgl,unsigned int sgc)462 static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid,
463 				    struct scatterlist *sgl, unsigned int sgc)
464 {
465 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
466 	const struct net_device_ops *ops = real_dev->netdev_ops;
467 	int rc = 0;
468 
469 	if (ops->ndo_fcoe_ddp_target)
470 		rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc);
471 
472 	return rc;
473 }
474 #endif
475 
476 #ifdef NETDEV_FCOE_WWNN
vlan_dev_fcoe_get_wwn(struct net_device * dev,u64 * wwn,int type)477 static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type)
478 {
479 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
480 	const struct net_device_ops *ops = real_dev->netdev_ops;
481 	int rc = -EINVAL;
482 
483 	if (ops->ndo_fcoe_get_wwn)
484 		rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type);
485 	return rc;
486 }
487 #endif
488 
vlan_dev_change_rx_flags(struct net_device * dev,int change)489 static void vlan_dev_change_rx_flags(struct net_device *dev, int change)
490 {
491 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
492 
493 	if (dev->flags & IFF_UP) {
494 		if (change & IFF_ALLMULTI)
495 			dev_set_allmulti(real_dev, dev->flags & IFF_ALLMULTI ? 1 : -1);
496 		if (change & IFF_PROMISC)
497 			dev_set_promiscuity(real_dev, dev->flags & IFF_PROMISC ? 1 : -1);
498 	}
499 }
500 
vlan_dev_set_rx_mode(struct net_device * vlan_dev)501 static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)
502 {
503 	dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
504 	dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
505 }
506 
507 /*
508  * vlan network devices have devices nesting below it, and are a special
509  * "super class" of normal network devices; split their locks off into a
510  * separate class since they always nest.
511  */
512 static struct lock_class_key vlan_netdev_xmit_lock_key;
513 static struct lock_class_key vlan_netdev_addr_lock_key;
514 
vlan_dev_set_lockdep_one(struct net_device * dev,struct netdev_queue * txq,void * unused)515 static void vlan_dev_set_lockdep_one(struct net_device *dev,
516 				     struct netdev_queue *txq,
517 				     void *unused)
518 {
519 	lockdep_set_class(&txq->_xmit_lock, &vlan_netdev_xmit_lock_key);
520 }
521 
vlan_dev_set_lockdep_class(struct net_device * dev)522 static void vlan_dev_set_lockdep_class(struct net_device *dev)
523 {
524 	lockdep_set_class(&dev->addr_list_lock,
525 			  &vlan_netdev_addr_lock_key);
526 	netdev_for_each_tx_queue(dev, vlan_dev_set_lockdep_one, NULL);
527 }
528 
vlan_parse_protocol(const struct sk_buff * skb)529 static __be16 vlan_parse_protocol(const struct sk_buff *skb)
530 {
531 	struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);
532 
533 	return __vlan_get_protocol(skb, veth->h_vlan_proto, NULL);
534 }
535 
536 static const struct header_ops vlan_header_ops = {
537 	.create	 = vlan_dev_hard_header,
538 	.parse	 = eth_header_parse,
539 	.parse_protocol = vlan_parse_protocol,
540 };
541 
vlan_passthru_hard_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned int len)542 static int vlan_passthru_hard_header(struct sk_buff *skb, struct net_device *dev,
543 				     unsigned short type,
544 				     const void *daddr, const void *saddr,
545 				     unsigned int len)
546 {
547 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
548 	struct net_device *real_dev = vlan->real_dev;
549 
550 	if (saddr == NULL)
551 		saddr = dev->dev_addr;
552 
553 	return dev_hard_header(skb, real_dev, type, daddr, saddr, len);
554 }
555 
556 static const struct header_ops vlan_passthru_header_ops = {
557 	.create	 = vlan_passthru_hard_header,
558 	.parse	 = eth_header_parse,
559 	.parse_protocol = vlan_parse_protocol,
560 };
561 
562 static struct device_type vlan_type = {
563 	.name	= "vlan",
564 };
565 
566 static const struct net_device_ops vlan_netdev_ops;
567 
vlan_dev_init(struct net_device * dev)568 static int vlan_dev_init(struct net_device *dev)
569 {
570 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
571 	struct net_device *real_dev = vlan->real_dev;
572 
573 	netif_carrier_off(dev);
574 
575 	/* IFF_BROADCAST|IFF_MULTICAST; ??? */
576 	dev->flags  = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
577 					  IFF_MASTER | IFF_SLAVE);
578 	dev->state  = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |
579 					  (1<<__LINK_STATE_DORMANT))) |
580 		      (1<<__LINK_STATE_PRESENT);
581 
582 	if (vlan->flags & VLAN_FLAG_BRIDGE_BINDING)
583 		dev->state |= (1 << __LINK_STATE_NOCARRIER);
584 
585 	dev->hw_features = NETIF_F_HW_CSUM | NETIF_F_SG |
586 			   NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE |
587 			   NETIF_F_GSO_ENCAP_ALL |
588 			   NETIF_F_HIGHDMA | NETIF_F_SCTP_CRC |
589 			   NETIF_F_ALL_FCOE;
590 
591 	if (real_dev->vlan_features & NETIF_F_HW_MACSEC)
592 		dev->hw_features |= NETIF_F_HW_MACSEC;
593 
594 	dev->features |= dev->hw_features | NETIF_F_LLTX;
595 	netif_inherit_tso_max(dev, real_dev);
596 	if (dev->features & NETIF_F_VLAN_FEATURES)
597 		netdev_warn(real_dev, "VLAN features are set incorrectly.  Q-in-Q configurations may not work correctly.\n");
598 
599 	dev->vlan_features = real_dev->vlan_features & ~NETIF_F_ALL_FCOE;
600 	dev->hw_enc_features = vlan_tnl_features(real_dev);
601 	dev->mpls_features = real_dev->mpls_features;
602 
603 	/* ipv6 shared card related stuff */
604 	dev->dev_id = real_dev->dev_id;
605 
606 	if (is_zero_ether_addr(dev->dev_addr)) {
607 		eth_hw_addr_set(dev, real_dev->dev_addr);
608 		dev->addr_assign_type = NET_ADDR_STOLEN;
609 	}
610 	if (is_zero_ether_addr(dev->broadcast))
611 		memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len);
612 
613 #if IS_ENABLED(CONFIG_FCOE)
614 	dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid;
615 #endif
616 
617 	dev->needed_headroom = real_dev->needed_headroom;
618 	if (vlan_hw_offload_capable(real_dev->features, vlan->vlan_proto)) {
619 		dev->header_ops      = &vlan_passthru_header_ops;
620 		dev->hard_header_len = real_dev->hard_header_len;
621 	} else {
622 		dev->header_ops      = &vlan_header_ops;
623 		dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;
624 	}
625 
626 	dev->netdev_ops = &vlan_netdev_ops;
627 
628 	SET_NETDEV_DEVTYPE(dev, &vlan_type);
629 
630 	vlan_dev_set_lockdep_class(dev);
631 
632 	vlan->vlan_pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
633 	if (!vlan->vlan_pcpu_stats)
634 		return -ENOMEM;
635 
636 	/* Get vlan's reference to real_dev */
637 	netdev_hold(real_dev, &vlan->dev_tracker, GFP_KERNEL);
638 
639 	return 0;
640 }
641 
642 /* Note: this function might be called multiple times for the same device. */
vlan_dev_free_egress_priority(const struct net_device * dev)643 void vlan_dev_free_egress_priority(const struct net_device *dev)
644 {
645 	struct vlan_priority_tci_mapping *pm;
646 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
647 	int i;
648 
649 	for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) {
650 		while ((pm = vlan->egress_priority_map[i]) != NULL) {
651 			vlan->egress_priority_map[i] = pm->next;
652 			kfree(pm);
653 		}
654 	}
655 }
656 
vlan_dev_uninit(struct net_device * dev)657 static void vlan_dev_uninit(struct net_device *dev)
658 {
659 	vlan_dev_free_egress_priority(dev);
660 }
661 
vlan_dev_fix_features(struct net_device * dev,netdev_features_t features)662 static netdev_features_t vlan_dev_fix_features(struct net_device *dev,
663 	netdev_features_t features)
664 {
665 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
666 	netdev_features_t old_features = features;
667 	netdev_features_t lower_features;
668 
669 	lower_features = netdev_intersect_features((real_dev->vlan_features |
670 						    NETIF_F_RXCSUM),
671 						   real_dev->features);
672 
673 	/* Add HW_CSUM setting to preserve user ability to control
674 	 * checksum offload on the vlan device.
675 	 */
676 	if (lower_features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))
677 		lower_features |= NETIF_F_HW_CSUM;
678 	features = netdev_intersect_features(features, lower_features);
679 	features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_GSO_SOFTWARE);
680 	features |= NETIF_F_LLTX;
681 
682 	return features;
683 }
684 
vlan_ethtool_get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * cmd)685 static int vlan_ethtool_get_link_ksettings(struct net_device *dev,
686 					   struct ethtool_link_ksettings *cmd)
687 {
688 	const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
689 
690 	return __ethtool_get_link_ksettings(vlan->real_dev, cmd);
691 }
692 
vlan_ethtool_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)693 static void vlan_ethtool_get_drvinfo(struct net_device *dev,
694 				     struct ethtool_drvinfo *info)
695 {
696 	strscpy(info->driver, vlan_fullname, sizeof(info->driver));
697 	strscpy(info->version, vlan_version, sizeof(info->version));
698 	strscpy(info->fw_version, "N/A", sizeof(info->fw_version));
699 }
700 
vlan_ethtool_get_ts_info(struct net_device * dev,struct ethtool_ts_info * info)701 static int vlan_ethtool_get_ts_info(struct net_device *dev,
702 				    struct ethtool_ts_info *info)
703 {
704 	const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
705 	const struct ethtool_ops *ops = vlan->real_dev->ethtool_ops;
706 	struct phy_device *phydev = vlan->real_dev->phydev;
707 
708 	if (phy_has_tsinfo(phydev)) {
709 		return phy_ts_info(phydev, info);
710 	} else if (ops->get_ts_info) {
711 		return ops->get_ts_info(vlan->real_dev, info);
712 	} else {
713 		info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
714 			SOF_TIMESTAMPING_SOFTWARE;
715 		info->phc_index = -1;
716 	}
717 
718 	return 0;
719 }
720 
vlan_dev_get_stats64(struct net_device * dev,struct rtnl_link_stats64 * stats)721 static void vlan_dev_get_stats64(struct net_device *dev,
722 				 struct rtnl_link_stats64 *stats)
723 {
724 	struct vlan_pcpu_stats *p;
725 	u32 rx_errors = 0, tx_dropped = 0;
726 	int i;
727 
728 	for_each_possible_cpu(i) {
729 		u64 rxpackets, rxbytes, rxmulticast, txpackets, txbytes;
730 		unsigned int start;
731 
732 		p = per_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats, i);
733 		do {
734 			start = u64_stats_fetch_begin(&p->syncp);
735 			rxpackets	= u64_stats_read(&p->rx_packets);
736 			rxbytes		= u64_stats_read(&p->rx_bytes);
737 			rxmulticast	= u64_stats_read(&p->rx_multicast);
738 			txpackets	= u64_stats_read(&p->tx_packets);
739 			txbytes		= u64_stats_read(&p->tx_bytes);
740 		} while (u64_stats_fetch_retry(&p->syncp, start));
741 
742 		stats->rx_packets	+= rxpackets;
743 		stats->rx_bytes		+= rxbytes;
744 		stats->multicast	+= rxmulticast;
745 		stats->tx_packets	+= txpackets;
746 		stats->tx_bytes		+= txbytes;
747 		/* rx_errors & tx_dropped are u32 */
748 		rx_errors	+= READ_ONCE(p->rx_errors);
749 		tx_dropped	+= READ_ONCE(p->tx_dropped);
750 	}
751 	stats->rx_errors  = rx_errors;
752 	stats->tx_dropped = tx_dropped;
753 }
754 
755 #ifdef CONFIG_NET_POLL_CONTROLLER
vlan_dev_poll_controller(struct net_device * dev)756 static void vlan_dev_poll_controller(struct net_device *dev)
757 {
758 	return;
759 }
760 
vlan_dev_netpoll_setup(struct net_device * dev,struct netpoll_info * npinfo)761 static int vlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo)
762 {
763 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
764 	struct net_device *real_dev = vlan->real_dev;
765 	struct netpoll *netpoll;
766 	int err = 0;
767 
768 	netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
769 	err = -ENOMEM;
770 	if (!netpoll)
771 		goto out;
772 
773 	err = __netpoll_setup(netpoll, real_dev);
774 	if (err) {
775 		kfree(netpoll);
776 		goto out;
777 	}
778 
779 	vlan->netpoll = netpoll;
780 
781 out:
782 	return err;
783 }
784 
vlan_dev_netpoll_cleanup(struct net_device * dev)785 static void vlan_dev_netpoll_cleanup(struct net_device *dev)
786 {
787 	struct vlan_dev_priv *vlan= vlan_dev_priv(dev);
788 	struct netpoll *netpoll = vlan->netpoll;
789 
790 	if (!netpoll)
791 		return;
792 
793 	vlan->netpoll = NULL;
794 	__netpoll_free(netpoll);
795 }
796 #endif /* CONFIG_NET_POLL_CONTROLLER */
797 
vlan_dev_get_iflink(const struct net_device * dev)798 static int vlan_dev_get_iflink(const struct net_device *dev)
799 {
800 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
801 
802 	return real_dev->ifindex;
803 }
804 
vlan_dev_fill_forward_path(struct net_device_path_ctx * ctx,struct net_device_path * path)805 static int vlan_dev_fill_forward_path(struct net_device_path_ctx *ctx,
806 				      struct net_device_path *path)
807 {
808 	struct vlan_dev_priv *vlan = vlan_dev_priv(ctx->dev);
809 
810 	path->type = DEV_PATH_VLAN;
811 	path->encap.id = vlan->vlan_id;
812 	path->encap.proto = vlan->vlan_proto;
813 	path->dev = ctx->dev;
814 	ctx->dev = vlan->real_dev;
815 	if (ctx->num_vlans >= ARRAY_SIZE(ctx->vlan))
816 		return -ENOSPC;
817 
818 	ctx->vlan[ctx->num_vlans].id = vlan->vlan_id;
819 	ctx->vlan[ctx->num_vlans].proto = vlan->vlan_proto;
820 	ctx->num_vlans++;
821 
822 	return 0;
823 }
824 
825 #if IS_ENABLED(CONFIG_MACSEC)
826 
vlan_get_macsec_ops(const struct macsec_context * ctx)827 static const struct macsec_ops *vlan_get_macsec_ops(const struct macsec_context *ctx)
828 {
829 	return vlan_dev_priv(ctx->netdev)->real_dev->macsec_ops;
830 }
831 
vlan_macsec_offload(int (* const func)(struct macsec_context *),struct macsec_context * ctx)832 static int vlan_macsec_offload(int (* const func)(struct macsec_context *),
833 			       struct macsec_context *ctx)
834 {
835 	if (unlikely(!func))
836 		return 0;
837 
838 	return (*func)(ctx);
839 }
840 
vlan_macsec_dev_open(struct macsec_context * ctx)841 static int vlan_macsec_dev_open(struct macsec_context *ctx)
842 {
843 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
844 
845 	if (!ops)
846 		return -EOPNOTSUPP;
847 
848 	return vlan_macsec_offload(ops->mdo_dev_open, ctx);
849 }
850 
vlan_macsec_dev_stop(struct macsec_context * ctx)851 static int vlan_macsec_dev_stop(struct macsec_context *ctx)
852 {
853 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
854 
855 	if (!ops)
856 		return -EOPNOTSUPP;
857 
858 	return vlan_macsec_offload(ops->mdo_dev_stop, ctx);
859 }
860 
vlan_macsec_add_secy(struct macsec_context * ctx)861 static int vlan_macsec_add_secy(struct macsec_context *ctx)
862 {
863 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
864 
865 	if (!ops)
866 		return -EOPNOTSUPP;
867 
868 	return vlan_macsec_offload(ops->mdo_add_secy, ctx);
869 }
870 
vlan_macsec_upd_secy(struct macsec_context * ctx)871 static int vlan_macsec_upd_secy(struct macsec_context *ctx)
872 {
873 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
874 
875 	if (!ops)
876 		return -EOPNOTSUPP;
877 
878 	return vlan_macsec_offload(ops->mdo_upd_secy, ctx);
879 }
880 
vlan_macsec_del_secy(struct macsec_context * ctx)881 static int vlan_macsec_del_secy(struct macsec_context *ctx)
882 {
883 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
884 
885 	if (!ops)
886 		return -EOPNOTSUPP;
887 
888 	return vlan_macsec_offload(ops->mdo_del_secy, ctx);
889 }
890 
vlan_macsec_add_rxsc(struct macsec_context * ctx)891 static int vlan_macsec_add_rxsc(struct macsec_context *ctx)
892 {
893 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
894 
895 	if (!ops)
896 		return -EOPNOTSUPP;
897 
898 	return vlan_macsec_offload(ops->mdo_add_rxsc, ctx);
899 }
900 
vlan_macsec_upd_rxsc(struct macsec_context * ctx)901 static int vlan_macsec_upd_rxsc(struct macsec_context *ctx)
902 {
903 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
904 
905 	if (!ops)
906 		return -EOPNOTSUPP;
907 
908 	return vlan_macsec_offload(ops->mdo_upd_rxsc, ctx);
909 }
910 
vlan_macsec_del_rxsc(struct macsec_context * ctx)911 static int vlan_macsec_del_rxsc(struct macsec_context *ctx)
912 {
913 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
914 
915 	if (!ops)
916 		return -EOPNOTSUPP;
917 
918 	return vlan_macsec_offload(ops->mdo_del_rxsc, ctx);
919 }
920 
vlan_macsec_add_rxsa(struct macsec_context * ctx)921 static int vlan_macsec_add_rxsa(struct macsec_context *ctx)
922 {
923 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
924 
925 	if (!ops)
926 		return -EOPNOTSUPP;
927 
928 	return vlan_macsec_offload(ops->mdo_add_rxsa, ctx);
929 }
930 
vlan_macsec_upd_rxsa(struct macsec_context * ctx)931 static int vlan_macsec_upd_rxsa(struct macsec_context *ctx)
932 {
933 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
934 
935 	if (!ops)
936 		return -EOPNOTSUPP;
937 
938 	return vlan_macsec_offload(ops->mdo_upd_rxsa, ctx);
939 }
940 
vlan_macsec_del_rxsa(struct macsec_context * ctx)941 static int vlan_macsec_del_rxsa(struct macsec_context *ctx)
942 {
943 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
944 
945 	if (!ops)
946 		return -EOPNOTSUPP;
947 
948 	return vlan_macsec_offload(ops->mdo_del_rxsa, ctx);
949 }
950 
vlan_macsec_add_txsa(struct macsec_context * ctx)951 static int vlan_macsec_add_txsa(struct macsec_context *ctx)
952 {
953 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
954 
955 	if (!ops)
956 		return -EOPNOTSUPP;
957 
958 	return vlan_macsec_offload(ops->mdo_add_txsa, ctx);
959 }
960 
vlan_macsec_upd_txsa(struct macsec_context * ctx)961 static int vlan_macsec_upd_txsa(struct macsec_context *ctx)
962 {
963 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
964 
965 	if (!ops)
966 		return -EOPNOTSUPP;
967 
968 	return vlan_macsec_offload(ops->mdo_upd_txsa, ctx);
969 }
970 
vlan_macsec_del_txsa(struct macsec_context * ctx)971 static int vlan_macsec_del_txsa(struct macsec_context *ctx)
972 {
973 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
974 
975 	if (!ops)
976 		return -EOPNOTSUPP;
977 
978 	return vlan_macsec_offload(ops->mdo_del_txsa, ctx);
979 }
980 
vlan_macsec_get_dev_stats(struct macsec_context * ctx)981 static int vlan_macsec_get_dev_stats(struct macsec_context *ctx)
982 {
983 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
984 
985 	if (!ops)
986 		return -EOPNOTSUPP;
987 
988 	return vlan_macsec_offload(ops->mdo_get_dev_stats, ctx);
989 }
990 
vlan_macsec_get_tx_sc_stats(struct macsec_context * ctx)991 static int vlan_macsec_get_tx_sc_stats(struct macsec_context *ctx)
992 {
993 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
994 
995 	if (!ops)
996 		return -EOPNOTSUPP;
997 
998 	return vlan_macsec_offload(ops->mdo_get_tx_sc_stats, ctx);
999 }
1000 
vlan_macsec_get_tx_sa_stats(struct macsec_context * ctx)1001 static int vlan_macsec_get_tx_sa_stats(struct macsec_context *ctx)
1002 {
1003 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
1004 
1005 	if (!ops)
1006 		return -EOPNOTSUPP;
1007 
1008 	return vlan_macsec_offload(ops->mdo_get_tx_sa_stats, ctx);
1009 }
1010 
vlan_macsec_get_rx_sc_stats(struct macsec_context * ctx)1011 static int vlan_macsec_get_rx_sc_stats(struct macsec_context *ctx)
1012 {
1013 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
1014 
1015 	if (!ops)
1016 		return -EOPNOTSUPP;
1017 
1018 	return vlan_macsec_offload(ops->mdo_get_rx_sc_stats, ctx);
1019 }
1020 
vlan_macsec_get_rx_sa_stats(struct macsec_context * ctx)1021 static int vlan_macsec_get_rx_sa_stats(struct macsec_context *ctx)
1022 {
1023 	const struct macsec_ops *ops = vlan_get_macsec_ops(ctx);
1024 
1025 	if (!ops)
1026 		return -EOPNOTSUPP;
1027 
1028 	return vlan_macsec_offload(ops->mdo_get_rx_sa_stats, ctx);
1029 }
1030 
1031 static const struct macsec_ops macsec_offload_ops = {
1032 	/* Device wide */
1033 	.mdo_dev_open = vlan_macsec_dev_open,
1034 	.mdo_dev_stop = vlan_macsec_dev_stop,
1035 	/* SecY */
1036 	.mdo_add_secy = vlan_macsec_add_secy,
1037 	.mdo_upd_secy = vlan_macsec_upd_secy,
1038 	.mdo_del_secy = vlan_macsec_del_secy,
1039 	/* Security channels */
1040 	.mdo_add_rxsc = vlan_macsec_add_rxsc,
1041 	.mdo_upd_rxsc = vlan_macsec_upd_rxsc,
1042 	.mdo_del_rxsc = vlan_macsec_del_rxsc,
1043 	/* Security associations */
1044 	.mdo_add_rxsa = vlan_macsec_add_rxsa,
1045 	.mdo_upd_rxsa = vlan_macsec_upd_rxsa,
1046 	.mdo_del_rxsa = vlan_macsec_del_rxsa,
1047 	.mdo_add_txsa = vlan_macsec_add_txsa,
1048 	.mdo_upd_txsa = vlan_macsec_upd_txsa,
1049 	.mdo_del_txsa = vlan_macsec_del_txsa,
1050 	/* Statistics */
1051 	.mdo_get_dev_stats = vlan_macsec_get_dev_stats,
1052 	.mdo_get_tx_sc_stats = vlan_macsec_get_tx_sc_stats,
1053 	.mdo_get_tx_sa_stats = vlan_macsec_get_tx_sa_stats,
1054 	.mdo_get_rx_sc_stats = vlan_macsec_get_rx_sc_stats,
1055 	.mdo_get_rx_sa_stats = vlan_macsec_get_rx_sa_stats,
1056 };
1057 
1058 #endif
1059 
1060 static const struct ethtool_ops vlan_ethtool_ops = {
1061 	.get_link_ksettings	= vlan_ethtool_get_link_ksettings,
1062 	.get_drvinfo	        = vlan_ethtool_get_drvinfo,
1063 	.get_link		= ethtool_op_get_link,
1064 	.get_ts_info		= vlan_ethtool_get_ts_info,
1065 };
1066 
1067 static const struct net_device_ops vlan_netdev_ops = {
1068 	.ndo_change_mtu		= vlan_dev_change_mtu,
1069 	.ndo_init		= vlan_dev_init,
1070 	.ndo_uninit		= vlan_dev_uninit,
1071 	.ndo_open		= vlan_dev_open,
1072 	.ndo_stop		= vlan_dev_stop,
1073 	.ndo_start_xmit =  vlan_dev_hard_start_xmit,
1074 	.ndo_validate_addr	= eth_validate_addr,
1075 	.ndo_set_mac_address	= vlan_dev_set_mac_address,
1076 	.ndo_set_rx_mode	= vlan_dev_set_rx_mode,
1077 	.ndo_change_rx_flags	= vlan_dev_change_rx_flags,
1078 	.ndo_eth_ioctl		= vlan_dev_ioctl,
1079 	.ndo_neigh_setup	= vlan_dev_neigh_setup,
1080 	.ndo_get_stats64	= vlan_dev_get_stats64,
1081 #if IS_ENABLED(CONFIG_FCOE)
1082 	.ndo_fcoe_ddp_setup	= vlan_dev_fcoe_ddp_setup,
1083 	.ndo_fcoe_ddp_done	= vlan_dev_fcoe_ddp_done,
1084 	.ndo_fcoe_enable	= vlan_dev_fcoe_enable,
1085 	.ndo_fcoe_disable	= vlan_dev_fcoe_disable,
1086 	.ndo_fcoe_ddp_target	= vlan_dev_fcoe_ddp_target,
1087 #endif
1088 #ifdef NETDEV_FCOE_WWNN
1089 	.ndo_fcoe_get_wwn	= vlan_dev_fcoe_get_wwn,
1090 #endif
1091 #ifdef CONFIG_NET_POLL_CONTROLLER
1092 	.ndo_poll_controller	= vlan_dev_poll_controller,
1093 	.ndo_netpoll_setup	= vlan_dev_netpoll_setup,
1094 	.ndo_netpoll_cleanup	= vlan_dev_netpoll_cleanup,
1095 #endif
1096 	.ndo_fix_features	= vlan_dev_fix_features,
1097 	.ndo_get_iflink		= vlan_dev_get_iflink,
1098 	.ndo_fill_forward_path	= vlan_dev_fill_forward_path,
1099 	.ndo_hwtstamp_get	= vlan_hwtstamp_get,
1100 	.ndo_hwtstamp_set	= vlan_hwtstamp_set,
1101 };
1102 
vlan_dev_free(struct net_device * dev)1103 static void vlan_dev_free(struct net_device *dev)
1104 {
1105 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
1106 
1107 	free_percpu(vlan->vlan_pcpu_stats);
1108 	vlan->vlan_pcpu_stats = NULL;
1109 
1110 	/* Get rid of the vlan's reference to real_dev */
1111 	netdev_put(vlan->real_dev, &vlan->dev_tracker);
1112 }
1113 
vlan_setup(struct net_device * dev)1114 void vlan_setup(struct net_device *dev)
1115 {
1116 	ether_setup(dev);
1117 
1118 	dev->priv_flags		|= IFF_802_1Q_VLAN | IFF_NO_QUEUE;
1119 	dev->priv_flags		|= IFF_UNICAST_FLT;
1120 	dev->priv_flags		&= ~IFF_TX_SKB_SHARING;
1121 	netif_keep_dst(dev);
1122 
1123 	dev->netdev_ops		= &vlan_netdev_ops;
1124 	dev->needs_free_netdev	= true;
1125 	dev->priv_destructor	= vlan_dev_free;
1126 	dev->ethtool_ops	= &vlan_ethtool_ops;
1127 
1128 #if IS_ENABLED(CONFIG_MACSEC)
1129 	dev->macsec_ops		= &macsec_offload_ops;
1130 #endif
1131 	dev->min_mtu		= 0;
1132 	dev->max_mtu		= ETH_MAX_MTU;
1133 
1134 	eth_zero_addr(dev->broadcast);
1135 }
1136