]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - net/8021q/vlan_dev.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph...
[mirror_ubuntu-focal-kernel.git] / net / 8021q / vlan_dev.c
1 /* -*- linux-c -*-
2 * INET 802.1Q VLAN
3 * Ethernet-type device handling.
4 *
5 * Authors: Ben Greear <greearb@candelatech.com>
6 * Please send support related email to: netdev@vger.kernel.org
7 * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
8 *
9 * Fixes: Mar 22 2001: Martin Bokaemper <mbokaemper@unispherenetworks.com>
10 * - reset skb->pkt_type on incoming packets when MAC was changed
11 * - see that changed MAC is saddr for outgoing packets
12 * Oct 20, 2001: Ard van Breeman:
13 * - Fix MC-list, finally.
14 * - Flush MC-list on VLAN destroy.
15 *
16 *
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License
19 * as published by the Free Software Foundation; either version
20 * 2 of the License, or (at your option) any later version.
21 */
22
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/skbuff.h>
28 #include <linux/netdevice.h>
29 #include <linux/net_tstamp.h>
30 #include <linux/etherdevice.h>
31 #include <linux/ethtool.h>
32 #include <net/arp.h>
33 #include <net/switchdev.h>
34
35 #include "vlan.h"
36 #include "vlanproc.h"
37 #include <linux/if_vlan.h>
38 #include <linux/netpoll.h>
39
40 /*
41 * Create the VLAN header for an arbitrary protocol layer
42 *
43 * saddr=NULL means use device source address
44 * daddr=NULL means leave destination address (eg unresolved arp)
45 *
46 * This is called when the SKB is moving down the stack towards the
47 * physical devices.
48 */
49 static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,
50 unsigned short type,
51 const void *daddr, const void *saddr,
52 unsigned int len)
53 {
54 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
55 struct vlan_hdr *vhdr;
56 unsigned int vhdrlen = 0;
57 u16 vlan_tci = 0;
58 int rc;
59
60 if (!(vlan->flags & VLAN_FLAG_REORDER_HDR)) {
61 vhdr = (struct vlan_hdr *) skb_push(skb, VLAN_HLEN);
62
63 vlan_tci = vlan->vlan_id;
64 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb->priority);
65 vhdr->h_vlan_TCI = htons(vlan_tci);
66
67 /*
68 * Set the protocol type. For a packet of type ETH_P_802_3/2 we
69 * put the length in here instead.
70 */
71 if (type != ETH_P_802_3 && type != ETH_P_802_2)
72 vhdr->h_vlan_encapsulated_proto = htons(type);
73 else
74 vhdr->h_vlan_encapsulated_proto = htons(len);
75
76 skb->protocol = vlan->vlan_proto;
77 type = ntohs(vlan->vlan_proto);
78 vhdrlen = VLAN_HLEN;
79 }
80
81 /* Before delegating work to the lower layer, enter our MAC-address */
82 if (saddr == NULL)
83 saddr = dev->dev_addr;
84
85 /* Now make the underlying real hard header */
86 dev = vlan->real_dev;
87 rc = dev_hard_header(skb, dev, type, daddr, saddr, len + vhdrlen);
88 if (rc > 0)
89 rc += vhdrlen;
90 return rc;
91 }
92
93 static inline netdev_tx_t vlan_netpoll_send_skb(struct vlan_dev_priv *vlan, struct sk_buff *skb)
94 {
95 #ifdef CONFIG_NET_POLL_CONTROLLER
96 if (vlan->netpoll)
97 netpoll_send_skb(vlan->netpoll, skb);
98 #else
99 BUG();
100 #endif
101 return NETDEV_TX_OK;
102 }
103
104 static netdev_tx_t vlan_dev_hard_start_xmit(struct sk_buff *skb,
105 struct net_device *dev)
106 {
107 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
108 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);
109 unsigned int len;
110 int ret;
111
112 /* Handle non-VLAN frames if they are sent to us, for example by DHCP.
113 *
114 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING
115 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...
116 */
117 if (veth->h_vlan_proto != vlan->vlan_proto ||
118 vlan->flags & VLAN_FLAG_REORDER_HDR) {
119 u16 vlan_tci;
120 vlan_tci = vlan->vlan_id;
121 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb->priority);
122 __vlan_hwaccel_put_tag(skb, vlan->vlan_proto, vlan_tci);
123 }
124
125 skb->dev = vlan->real_dev;
126 len = skb->len;
127 if (unlikely(netpoll_tx_running(dev)))
128 return vlan_netpoll_send_skb(vlan, skb);
129
130 ret = dev_queue_xmit(skb);
131
132 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
133 struct vlan_pcpu_stats *stats;
134
135 stats = this_cpu_ptr(vlan->vlan_pcpu_stats);
136 u64_stats_update_begin(&stats->syncp);
137 stats->tx_packets++;
138 stats->tx_bytes += len;
139 u64_stats_update_end(&stats->syncp);
140 } else {
141 this_cpu_inc(vlan->vlan_pcpu_stats->tx_dropped);
142 }
143
144 return ret;
145 }
146
147 static int vlan_dev_change_mtu(struct net_device *dev, int new_mtu)
148 {
149 /* TODO: gotta make sure the underlying layer can handle it,
150 * maybe an IFF_VLAN_CAPABLE flag for devices?
151 */
152 if (vlan_dev_priv(dev)->real_dev->mtu < new_mtu)
153 return -ERANGE;
154
155 dev->mtu = new_mtu;
156
157 return 0;
158 }
159
160 void vlan_dev_set_ingress_priority(const struct net_device *dev,
161 u32 skb_prio, u16 vlan_prio)
162 {
163 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
164
165 if (vlan->ingress_priority_map[vlan_prio & 0x7] && !skb_prio)
166 vlan->nr_ingress_mappings--;
167 else if (!vlan->ingress_priority_map[vlan_prio & 0x7] && skb_prio)
168 vlan->nr_ingress_mappings++;
169
170 vlan->ingress_priority_map[vlan_prio & 0x7] = skb_prio;
171 }
172
173 int vlan_dev_set_egress_priority(const struct net_device *dev,
174 u32 skb_prio, u16 vlan_prio)
175 {
176 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
177 struct vlan_priority_tci_mapping *mp = NULL;
178 struct vlan_priority_tci_mapping *np;
179 u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK;
180
181 /* See if a priority mapping exists.. */
182 mp = vlan->egress_priority_map[skb_prio & 0xF];
183 while (mp) {
184 if (mp->priority == skb_prio) {
185 if (mp->vlan_qos && !vlan_qos)
186 vlan->nr_egress_mappings--;
187 else if (!mp->vlan_qos && vlan_qos)
188 vlan->nr_egress_mappings++;
189 mp->vlan_qos = vlan_qos;
190 return 0;
191 }
192 mp = mp->next;
193 }
194
195 /* Create a new mapping then. */
196 mp = vlan->egress_priority_map[skb_prio & 0xF];
197 np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL);
198 if (!np)
199 return -ENOBUFS;
200
201 np->next = mp;
202 np->priority = skb_prio;
203 np->vlan_qos = vlan_qos;
204 /* Before inserting this element in hash table, make sure all its fields
205 * are committed to memory.
206 * coupled with smp_rmb() in vlan_dev_get_egress_qos_mask()
207 */
208 smp_wmb();
209 vlan->egress_priority_map[skb_prio & 0xF] = np;
210 if (vlan_qos)
211 vlan->nr_egress_mappings++;
212 return 0;
213 }
214
215 /* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */
216 int vlan_dev_change_flags(const struct net_device *dev, u32 flags, u32 mask)
217 {
218 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
219 u32 old_flags = vlan->flags;
220
221 if (mask & ~(VLAN_FLAG_REORDER_HDR | VLAN_FLAG_GVRP |
222 VLAN_FLAG_LOOSE_BINDING | VLAN_FLAG_MVRP))
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
243 void vlan_dev_get_realdev_name(const struct net_device *dev, char *result)
244 {
245 strncpy(result, vlan_dev_priv(dev)->real_dev->name, 23);
246 }
247
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 ether_addr_copy(dev->dev_addr, real_dev->dev_addr);
255 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
256 return true;
257 }
258
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 netif_carrier_on(dev);
297 return 0;
298
299 clear_allmulti:
300 if (dev->flags & IFF_ALLMULTI)
301 dev_set_allmulti(real_dev, -1);
302 del_unicast:
303 if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
304 dev_uc_del(real_dev, dev->dev_addr);
305 out:
306 netif_carrier_off(dev);
307 return err;
308 }
309
310 static int vlan_dev_stop(struct net_device *dev)
311 {
312 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
313 struct net_device *real_dev = vlan->real_dev;
314
315 dev_mc_unsync(real_dev, dev);
316 dev_uc_unsync(real_dev, dev);
317 if (dev->flags & IFF_ALLMULTI)
318 dev_set_allmulti(real_dev, -1);
319 if (dev->flags & IFF_PROMISC)
320 dev_set_promiscuity(real_dev, -1);
321
322 if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
323 dev_uc_del(real_dev, dev->dev_addr);
324
325 netif_carrier_off(dev);
326 return 0;
327 }
328
329 static int vlan_dev_set_mac_address(struct net_device *dev, void *p)
330 {
331 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
332 struct sockaddr *addr = p;
333 int err;
334
335 if (!is_valid_ether_addr(addr->sa_data))
336 return -EADDRNOTAVAIL;
337
338 if (!(dev->flags & IFF_UP))
339 goto out;
340
341 if (!ether_addr_equal(addr->sa_data, real_dev->dev_addr)) {
342 err = dev_uc_add(real_dev, addr->sa_data);
343 if (err < 0)
344 return err;
345 }
346
347 if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
348 dev_uc_del(real_dev, dev->dev_addr);
349
350 out:
351 ether_addr_copy(dev->dev_addr, addr->sa_data);
352 return 0;
353 }
354
355 static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
356 {
357 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
358 const struct net_device_ops *ops = real_dev->netdev_ops;
359 struct ifreq ifrr;
360 int err = -EOPNOTSUPP;
361
362 strncpy(ifrr.ifr_name, real_dev->name, IFNAMSIZ);
363 ifrr.ifr_ifru = ifr->ifr_ifru;
364
365 switch (cmd) {
366 case SIOCGMIIPHY:
367 case SIOCGMIIREG:
368 case SIOCSMIIREG:
369 case SIOCSHWTSTAMP:
370 case SIOCGHWTSTAMP:
371 if (netif_device_present(real_dev) && ops->ndo_do_ioctl)
372 err = ops->ndo_do_ioctl(real_dev, &ifrr, cmd);
373 break;
374 }
375
376 if (!err)
377 ifr->ifr_ifru = ifrr.ifr_ifru;
378
379 return err;
380 }
381
382 static int vlan_dev_neigh_setup(struct net_device *dev, struct neigh_parms *pa)
383 {
384 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
385 const struct net_device_ops *ops = real_dev->netdev_ops;
386 int err = 0;
387
388 if (netif_device_present(real_dev) && ops->ndo_neigh_setup)
389 err = ops->ndo_neigh_setup(real_dev, pa);
390
391 return err;
392 }
393
394 #if IS_ENABLED(CONFIG_FCOE)
395 static int vlan_dev_fcoe_ddp_setup(struct net_device *dev, u16 xid,
396 struct scatterlist *sgl, unsigned int sgc)
397 {
398 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
399 const struct net_device_ops *ops = real_dev->netdev_ops;
400 int rc = 0;
401
402 if (ops->ndo_fcoe_ddp_setup)
403 rc = ops->ndo_fcoe_ddp_setup(real_dev, xid, sgl, sgc);
404
405 return rc;
406 }
407
408 static int vlan_dev_fcoe_ddp_done(struct net_device *dev, u16 xid)
409 {
410 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
411 const struct net_device_ops *ops = real_dev->netdev_ops;
412 int len = 0;
413
414 if (ops->ndo_fcoe_ddp_done)
415 len = ops->ndo_fcoe_ddp_done(real_dev, xid);
416
417 return len;
418 }
419
420 static int vlan_dev_fcoe_enable(struct net_device *dev)
421 {
422 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
423 const struct net_device_ops *ops = real_dev->netdev_ops;
424 int rc = -EINVAL;
425
426 if (ops->ndo_fcoe_enable)
427 rc = ops->ndo_fcoe_enable(real_dev);
428 return rc;
429 }
430
431 static int vlan_dev_fcoe_disable(struct net_device *dev)
432 {
433 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
434 const struct net_device_ops *ops = real_dev->netdev_ops;
435 int rc = -EINVAL;
436
437 if (ops->ndo_fcoe_disable)
438 rc = ops->ndo_fcoe_disable(real_dev);
439 return rc;
440 }
441
442 static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type)
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 = -EINVAL;
447
448 if (ops->ndo_fcoe_get_wwn)
449 rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type);
450 return rc;
451 }
452
453 static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid,
454 struct scatterlist *sgl, unsigned int sgc)
455 {
456 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
457 const struct net_device_ops *ops = real_dev->netdev_ops;
458 int rc = 0;
459
460 if (ops->ndo_fcoe_ddp_target)
461 rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc);
462
463 return rc;
464 }
465 #endif
466
467 static void vlan_dev_change_rx_flags(struct net_device *dev, int change)
468 {
469 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
470
471 if (dev->flags & IFF_UP) {
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 }
478
479 static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)
480 {
481 dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
482 dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
483 }
484
485 /*
486 * vlan network devices have devices nesting below it, and are a special
487 * "super class" of normal network devices; split their locks off into a
488 * separate class since they always nest.
489 */
490 static struct lock_class_key vlan_netdev_xmit_lock_key;
491 static struct lock_class_key vlan_netdev_addr_lock_key;
492
493 static void vlan_dev_set_lockdep_one(struct net_device *dev,
494 struct netdev_queue *txq,
495 void *_subclass)
496 {
497 lockdep_set_class_and_subclass(&txq->_xmit_lock,
498 &vlan_netdev_xmit_lock_key,
499 *(int *)_subclass);
500 }
501
502 static void vlan_dev_set_lockdep_class(struct net_device *dev, int subclass)
503 {
504 lockdep_set_class_and_subclass(&dev->addr_list_lock,
505 &vlan_netdev_addr_lock_key,
506 subclass);
507 netdev_for_each_tx_queue(dev, vlan_dev_set_lockdep_one, &subclass);
508 }
509
510 static int vlan_dev_get_lock_subclass(struct net_device *dev)
511 {
512 return vlan_dev_priv(dev)->nest_level;
513 }
514
515 static const struct header_ops vlan_header_ops = {
516 .create = vlan_dev_hard_header,
517 .parse = eth_header_parse,
518 };
519
520 static int vlan_passthru_hard_header(struct sk_buff *skb, struct net_device *dev,
521 unsigned short type,
522 const void *daddr, const void *saddr,
523 unsigned int len)
524 {
525 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
526 struct net_device *real_dev = vlan->real_dev;
527
528 if (saddr == NULL)
529 saddr = dev->dev_addr;
530
531 return dev_hard_header(skb, real_dev, type, daddr, saddr, len);
532 }
533
534 static const struct header_ops vlan_passthru_header_ops = {
535 .create = vlan_passthru_hard_header,
536 .parse = eth_header_parse,
537 };
538
539 static struct device_type vlan_type = {
540 .name = "vlan",
541 };
542
543 static const struct net_device_ops vlan_netdev_ops;
544
545 static int vlan_dev_init(struct net_device *dev)
546 {
547 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
548
549 netif_carrier_off(dev);
550
551 /* IFF_BROADCAST|IFF_MULTICAST; ??? */
552 dev->flags = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
553 IFF_MASTER | IFF_SLAVE);
554 dev->state = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |
555 (1<<__LINK_STATE_DORMANT))) |
556 (1<<__LINK_STATE_PRESENT);
557
558 dev->hw_features = NETIF_F_HW_CSUM | NETIF_F_SG |
559 NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE |
560 NETIF_F_HIGHDMA | NETIF_F_SCTP_CRC |
561 NETIF_F_ALL_FCOE;
562
563 dev->features |= real_dev->vlan_features | NETIF_F_LLTX |
564 NETIF_F_GSO_SOFTWARE;
565 dev->gso_max_size = real_dev->gso_max_size;
566 dev->gso_max_segs = real_dev->gso_max_segs;
567 if (dev->features & NETIF_F_VLAN_FEATURES)
568 netdev_warn(real_dev, "VLAN features are set incorrectly. Q-in-Q configurations may not work correctly.\n");
569
570 dev->vlan_features = real_dev->vlan_features & ~NETIF_F_ALL_FCOE;
571
572 /* ipv6 shared card related stuff */
573 dev->dev_id = real_dev->dev_id;
574
575 if (is_zero_ether_addr(dev->dev_addr)) {
576 ether_addr_copy(dev->dev_addr, real_dev->dev_addr);
577 dev->addr_assign_type = NET_ADDR_STOLEN;
578 }
579 if (is_zero_ether_addr(dev->broadcast))
580 memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len);
581
582 #if IS_ENABLED(CONFIG_FCOE)
583 dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid;
584 #endif
585
586 dev->needed_headroom = real_dev->needed_headroom;
587 if (vlan_hw_offload_capable(real_dev->features,
588 vlan_dev_priv(dev)->vlan_proto)) {
589 dev->header_ops = &vlan_passthru_header_ops;
590 dev->hard_header_len = real_dev->hard_header_len;
591 } else {
592 dev->header_ops = &vlan_header_ops;
593 dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;
594 }
595
596 dev->netdev_ops = &vlan_netdev_ops;
597
598 SET_NETDEV_DEVTYPE(dev, &vlan_type);
599
600 vlan_dev_set_lockdep_class(dev, vlan_dev_get_lock_subclass(dev));
601
602 vlan_dev_priv(dev)->vlan_pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
603 if (!vlan_dev_priv(dev)->vlan_pcpu_stats)
604 return -ENOMEM;
605
606 return 0;
607 }
608
609 static void vlan_dev_uninit(struct net_device *dev)
610 {
611 struct vlan_priority_tci_mapping *pm;
612 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
613 int i;
614
615 for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) {
616 while ((pm = vlan->egress_priority_map[i]) != NULL) {
617 vlan->egress_priority_map[i] = pm->next;
618 kfree(pm);
619 }
620 }
621 }
622
623 static netdev_features_t vlan_dev_fix_features(struct net_device *dev,
624 netdev_features_t features)
625 {
626 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
627 netdev_features_t old_features = features;
628
629 features = netdev_intersect_features(features, real_dev->vlan_features);
630 features |= NETIF_F_RXCSUM;
631 features = netdev_intersect_features(features, real_dev->features);
632
633 features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_GSO_SOFTWARE);
634 features |= NETIF_F_LLTX;
635
636 return features;
637 }
638
639 static int vlan_ethtool_get_link_ksettings(struct net_device *dev,
640 struct ethtool_link_ksettings *cmd)
641 {
642 const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
643
644 return __ethtool_get_link_ksettings(vlan->real_dev, cmd);
645 }
646
647 static void vlan_ethtool_get_drvinfo(struct net_device *dev,
648 struct ethtool_drvinfo *info)
649 {
650 strlcpy(info->driver, vlan_fullname, sizeof(info->driver));
651 strlcpy(info->version, vlan_version, sizeof(info->version));
652 strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
653 }
654
655 static int vlan_ethtool_get_ts_info(struct net_device *dev,
656 struct ethtool_ts_info *info)
657 {
658 const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
659 const struct ethtool_ops *ops = vlan->real_dev->ethtool_ops;
660
661 if (ops->get_ts_info) {
662 return ops->get_ts_info(vlan->real_dev, info);
663 } else {
664 info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
665 SOF_TIMESTAMPING_SOFTWARE;
666 info->phc_index = -1;
667 }
668
669 return 0;
670 }
671
672 static struct rtnl_link_stats64 *vlan_dev_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
673 {
674 struct vlan_pcpu_stats *p;
675 u32 rx_errors = 0, tx_dropped = 0;
676 int i;
677
678 for_each_possible_cpu(i) {
679 u64 rxpackets, rxbytes, rxmulticast, txpackets, txbytes;
680 unsigned int start;
681
682 p = per_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats, i);
683 do {
684 start = u64_stats_fetch_begin_irq(&p->syncp);
685 rxpackets = p->rx_packets;
686 rxbytes = p->rx_bytes;
687 rxmulticast = p->rx_multicast;
688 txpackets = p->tx_packets;
689 txbytes = p->tx_bytes;
690 } while (u64_stats_fetch_retry_irq(&p->syncp, start));
691
692 stats->rx_packets += rxpackets;
693 stats->rx_bytes += rxbytes;
694 stats->multicast += rxmulticast;
695 stats->tx_packets += txpackets;
696 stats->tx_bytes += txbytes;
697 /* rx_errors & tx_dropped are u32 */
698 rx_errors += p->rx_errors;
699 tx_dropped += p->tx_dropped;
700 }
701 stats->rx_errors = rx_errors;
702 stats->tx_dropped = tx_dropped;
703
704 return stats;
705 }
706
707 #ifdef CONFIG_NET_POLL_CONTROLLER
708 static void vlan_dev_poll_controller(struct net_device *dev)
709 {
710 return;
711 }
712
713 static int vlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo)
714 {
715 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
716 struct net_device *real_dev = vlan->real_dev;
717 struct netpoll *netpoll;
718 int err = 0;
719
720 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
721 err = -ENOMEM;
722 if (!netpoll)
723 goto out;
724
725 err = __netpoll_setup(netpoll, real_dev);
726 if (err) {
727 kfree(netpoll);
728 goto out;
729 }
730
731 vlan->netpoll = netpoll;
732
733 out:
734 return err;
735 }
736
737 static void vlan_dev_netpoll_cleanup(struct net_device *dev)
738 {
739 struct vlan_dev_priv *vlan= vlan_dev_priv(dev);
740 struct netpoll *netpoll = vlan->netpoll;
741
742 if (!netpoll)
743 return;
744
745 vlan->netpoll = NULL;
746
747 __netpoll_free_async(netpoll);
748 }
749 #endif /* CONFIG_NET_POLL_CONTROLLER */
750
751 static int vlan_dev_get_iflink(const struct net_device *dev)
752 {
753 struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
754
755 return real_dev->ifindex;
756 }
757
758 static const struct ethtool_ops vlan_ethtool_ops = {
759 .get_link_ksettings = vlan_ethtool_get_link_ksettings,
760 .get_drvinfo = vlan_ethtool_get_drvinfo,
761 .get_link = ethtool_op_get_link,
762 .get_ts_info = vlan_ethtool_get_ts_info,
763 };
764
765 static const struct net_device_ops vlan_netdev_ops = {
766 .ndo_change_mtu = vlan_dev_change_mtu,
767 .ndo_init = vlan_dev_init,
768 .ndo_uninit = vlan_dev_uninit,
769 .ndo_open = vlan_dev_open,
770 .ndo_stop = vlan_dev_stop,
771 .ndo_start_xmit = vlan_dev_hard_start_xmit,
772 .ndo_validate_addr = eth_validate_addr,
773 .ndo_set_mac_address = vlan_dev_set_mac_address,
774 .ndo_set_rx_mode = vlan_dev_set_rx_mode,
775 .ndo_change_rx_flags = vlan_dev_change_rx_flags,
776 .ndo_do_ioctl = vlan_dev_ioctl,
777 .ndo_neigh_setup = vlan_dev_neigh_setup,
778 .ndo_get_stats64 = vlan_dev_get_stats64,
779 #if IS_ENABLED(CONFIG_FCOE)
780 .ndo_fcoe_ddp_setup = vlan_dev_fcoe_ddp_setup,
781 .ndo_fcoe_ddp_done = vlan_dev_fcoe_ddp_done,
782 .ndo_fcoe_enable = vlan_dev_fcoe_enable,
783 .ndo_fcoe_disable = vlan_dev_fcoe_disable,
784 .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn,
785 .ndo_fcoe_ddp_target = vlan_dev_fcoe_ddp_target,
786 #endif
787 #ifdef CONFIG_NET_POLL_CONTROLLER
788 .ndo_poll_controller = vlan_dev_poll_controller,
789 .ndo_netpoll_setup = vlan_dev_netpoll_setup,
790 .ndo_netpoll_cleanup = vlan_dev_netpoll_cleanup,
791 #endif
792 .ndo_fix_features = vlan_dev_fix_features,
793 .ndo_fdb_add = switchdev_port_fdb_add,
794 .ndo_fdb_del = switchdev_port_fdb_del,
795 .ndo_fdb_dump = switchdev_port_fdb_dump,
796 .ndo_bridge_setlink = switchdev_port_bridge_setlink,
797 .ndo_bridge_getlink = switchdev_port_bridge_getlink,
798 .ndo_bridge_dellink = switchdev_port_bridge_dellink,
799 .ndo_get_lock_subclass = vlan_dev_get_lock_subclass,
800 .ndo_get_iflink = vlan_dev_get_iflink,
801 };
802
803 static void vlan_dev_free(struct net_device *dev)
804 {
805 struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
806
807 free_percpu(vlan->vlan_pcpu_stats);
808 vlan->vlan_pcpu_stats = NULL;
809 free_netdev(dev);
810 }
811
812 void vlan_setup(struct net_device *dev)
813 {
814 ether_setup(dev);
815
816 dev->priv_flags |= IFF_802_1Q_VLAN | IFF_NO_QUEUE;
817 dev->priv_flags |= IFF_UNICAST_FLT;
818 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
819 netif_keep_dst(dev);
820
821 dev->netdev_ops = &vlan_netdev_ops;
822 dev->destructor = vlan_dev_free;
823 dev->ethtool_ops = &vlan_ethtool_ops;
824
825 eth_zero_addr(dev->broadcast);
826 }
Ubuntu Focal Linux kernel mirror