Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/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 
 34 #include "vlan.h"
 35 #include "vlanproc.h"
 36 #include <linux/if_vlan.h>
 37 #include <linux/netpoll.h>
 38 
 39 /*
 40  *      Create the VLAN header for an arbitrary protocol layer
 41  *
 42  *      saddr=NULL      means use device source address
 43  *      daddr=NULL      means leave destination address (eg unresolved arp)
 44  *
 45  *  This is called when the SKB is moving down the stack towards the
 46  *  physical devices.
 47  */
 48 static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,
 49                                 unsigned short type,
 50                                 const void *daddr, const void *saddr,
 51                                 unsigned int len)
 52 {
 53         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
 54         struct vlan_hdr *vhdr;
 55         unsigned int vhdrlen = 0;
 56         u16 vlan_tci = 0;
 57         int rc;
 58 
 59         if (!(vlan->flags & VLAN_FLAG_REORDER_HDR)) {
 60                 vhdr = (struct vlan_hdr *) skb_push(skb, VLAN_HLEN);
 61 
 62                 vlan_tci = vlan->vlan_id;
 63                 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb->priority);
 64                 vhdr->h_vlan_TCI = htons(vlan_tci);
 65 
 66                 /*
 67                  *  Set the protocol type. For a packet of type ETH_P_802_3/2 we
 68                  *  put the length in here instead.
 69                  */
 70                 if (type != ETH_P_802_3 && type != ETH_P_802_2)
 71                         vhdr->h_vlan_encapsulated_proto = htons(type);
 72                 else
 73                         vhdr->h_vlan_encapsulated_proto = htons(len);
 74 
 75                 skb->protocol = vlan->vlan_proto;
 76                 type = ntohs(vlan->vlan_proto);
 77                 vhdrlen = VLAN_HLEN;
 78         }
 79 
 80         /* Before delegating work to the lower layer, enter our MAC-address */
 81         if (saddr == NULL)
 82                 saddr = dev->dev_addr;
 83 
 84         /* Now make the underlying real hard header */
 85         dev = vlan->real_dev;
 86         rc = dev_hard_header(skb, dev, type, daddr, saddr, len + vhdrlen);
 87         if (rc > 0)
 88                 rc += vhdrlen;
 89         return rc;
 90 }
 91 
 92 static inline netdev_tx_t vlan_netpoll_send_skb(struct vlan_dev_priv *vlan, struct sk_buff *skb)
 93 {
 94 #ifdef CONFIG_NET_POLL_CONTROLLER
 95         if (vlan->netpoll)
 96                 netpoll_send_skb(vlan->netpoll, skb);
 97 #else
 98         BUG();
 99 #endif
100         return NETDEV_TX_OK;
101 }
102 
103 static netdev_tx_t vlan_dev_hard_start_xmit(struct sk_buff *skb,
104                                             struct net_device *dev)
105 {
106         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
107         struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);
108         unsigned int len;
109         int ret;
110 
111         /* Handle non-VLAN frames if they are sent to us, for example by DHCP.
112          *
113          * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING
114          * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...
115          */
116         if (veth->h_vlan_proto != vlan->vlan_proto ||
117             vlan->flags & VLAN_FLAG_REORDER_HDR) {
118                 u16 vlan_tci;
119                 vlan_tci = vlan->vlan_id;
120                 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb->priority);
121                 __vlan_hwaccel_put_tag(skb, vlan->vlan_proto, vlan_tci);
122         }
123 
124         skb->dev = vlan->real_dev;
125         len = skb->len;
126         if (unlikely(netpoll_tx_running(dev)))
127                 return vlan_netpoll_send_skb(vlan, skb);
128 
129         ret = dev_queue_xmit(skb);
130 
131         if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
132                 struct vlan_pcpu_stats *stats;
133 
134                 stats = this_cpu_ptr(vlan->vlan_pcpu_stats);
135                 u64_stats_update_begin(&stats->syncp);
136                 stats->tx_packets++;
137                 stats->tx_bytes += len;
138                 u64_stats_update_end(&stats->syncp);
139         } else {
140                 this_cpu_inc(vlan->vlan_pcpu_stats->tx_dropped);
141         }
142 
143         return ret;
144 }
145 
146 static int vlan_dev_change_mtu(struct net_device *dev, int new_mtu)
147 {
148         /* TODO: gotta make sure the underlying layer can handle it,
149          * maybe an IFF_VLAN_CAPABLE flag for devices?
150          */
151         if (vlan_dev_priv(dev)->real_dev->mtu < new_mtu)
152                 return -ERANGE;
153 
154         dev->mtu = new_mtu;
155 
156         return 0;
157 }
158 
159 void vlan_dev_set_ingress_priority(const struct net_device *dev,
160                                    u32 skb_prio, u16 vlan_prio)
161 {
162         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
163 
164         if (vlan->ingress_priority_map[vlan_prio & 0x7] && !skb_prio)
165                 vlan->nr_ingress_mappings--;
166         else if (!vlan->ingress_priority_map[vlan_prio & 0x7] && skb_prio)
167                 vlan->nr_ingress_mappings++;
168 
169         vlan->ingress_priority_map[vlan_prio & 0x7] = skb_prio;
170 }
171 
172 int vlan_dev_set_egress_priority(const struct net_device *dev,
173                                  u32 skb_prio, u16 vlan_prio)
174 {
175         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
176         struct vlan_priority_tci_mapping *mp = NULL;
177         struct vlan_priority_tci_mapping *np;
178         u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK;
179 
180         /* See if a priority mapping exists.. */
181         mp = vlan->egress_priority_map[skb_prio & 0xF];
182         while (mp) {
183                 if (mp->priority == skb_prio) {
184                         if (mp->vlan_qos && !vlan_qos)
185                                 vlan->nr_egress_mappings--;
186                         else if (!mp->vlan_qos && vlan_qos)
187                                 vlan->nr_egress_mappings++;
188                         mp->vlan_qos = vlan_qos;
189                         return 0;
190                 }
191                 mp = mp->next;
192         }
193 
194         /* Create a new mapping then. */
195         mp = vlan->egress_priority_map[skb_prio & 0xF];
196         np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL);
197         if (!np)
198                 return -ENOBUFS;
199 
200         np->next = mp;
201         np->priority = skb_prio;
202         np->vlan_qos = vlan_qos;
203         /* Before inserting this element in hash table, make sure all its fields
204          * are committed to memory.
205          * coupled with smp_rmb() in vlan_dev_get_egress_qos_mask()
206          */
207         smp_wmb();
208         vlan->egress_priority_map[skb_prio & 0xF] = np;
209         if (vlan_qos)
210                 vlan->nr_egress_mappings++;
211         return 0;
212 }
213 
214 /* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */
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                 return -EINVAL;
223 
224         vlan->flags = (old_flags & ~mask) | (flags & mask);
225 
226         if (netif_running(dev) && (vlan->flags ^ old_flags) & VLAN_FLAG_GVRP) {
227                 if (vlan->flags & VLAN_FLAG_GVRP)
228                         vlan_gvrp_request_join(dev);
229                 else
230                         vlan_gvrp_request_leave(dev);
231         }
232 
233         if (netif_running(dev) && (vlan->flags ^ old_flags) & VLAN_FLAG_MVRP) {
234                 if (vlan->flags & VLAN_FLAG_MVRP)
235                         vlan_mvrp_request_join(dev);
236                 else
237                         vlan_mvrp_request_leave(dev);
238         }
239         return 0;
240 }
241 
242 void vlan_dev_get_realdev_name(const struct net_device *dev, char *result)
243 {
244         strncpy(result, vlan_dev_priv(dev)->real_dev->name, 23);
245 }
246 
247 static int vlan_dev_open(struct net_device *dev)
248 {
249         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
250         struct net_device *real_dev = vlan->real_dev;
251         int err;
252 
253         if (!(real_dev->flags & IFF_UP) &&
254             !(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
255                 return -ENETDOWN;
256 
257         if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr)) {
258                 err = dev_uc_add(real_dev, dev->dev_addr);
259                 if (err < 0)
260                         goto out;
261         }
262 
263         if (dev->flags & IFF_ALLMULTI) {
264                 err = dev_set_allmulti(real_dev, 1);
265                 if (err < 0)
266                         goto del_unicast;
267         }
268         if (dev->flags & IFF_PROMISC) {
269                 err = dev_set_promiscuity(real_dev, 1);
270                 if (err < 0)
271                         goto clear_allmulti;
272         }
273 
274         ether_addr_copy(vlan->real_dev_addr, real_dev->dev_addr);
275 
276         if (vlan->flags & VLAN_FLAG_GVRP)
277                 vlan_gvrp_request_join(dev);
278 
279         if (vlan->flags & VLAN_FLAG_MVRP)
280                 vlan_mvrp_request_join(dev);
281 
282         if (netif_carrier_ok(real_dev))
283                 netif_carrier_on(dev);
284         return 0;
285 
286 clear_allmulti:
287         if (dev->flags & IFF_ALLMULTI)
288                 dev_set_allmulti(real_dev, -1);
289 del_unicast:
290         if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
291                 dev_uc_del(real_dev, dev->dev_addr);
292 out:
293         netif_carrier_off(dev);
294         return err;
295 }
296 
297 static int vlan_dev_stop(struct net_device *dev)
298 {
299         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
300         struct net_device *real_dev = vlan->real_dev;
301 
302         dev_mc_unsync(real_dev, dev);
303         dev_uc_unsync(real_dev, dev);
304         if (dev->flags & IFF_ALLMULTI)
305                 dev_set_allmulti(real_dev, -1);
306         if (dev->flags & IFF_PROMISC)
307                 dev_set_promiscuity(real_dev, -1);
308 
309         if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
310                 dev_uc_del(real_dev, dev->dev_addr);
311 
312         netif_carrier_off(dev);
313         return 0;
314 }
315 
316 static int vlan_dev_set_mac_address(struct net_device *dev, void *p)
317 {
318         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
319         struct sockaddr *addr = p;
320         int err;
321 
322         if (!is_valid_ether_addr(addr->sa_data))
323                 return -EADDRNOTAVAIL;
324 
325         if (!(dev->flags & IFF_UP))
326                 goto out;
327 
328         if (!ether_addr_equal(addr->sa_data, real_dev->dev_addr)) {
329                 err = dev_uc_add(real_dev, addr->sa_data);
330                 if (err < 0)
331                         return err;
332         }
333 
334         if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))
335                 dev_uc_del(real_dev, dev->dev_addr);
336 
337 out:
338         ether_addr_copy(dev->dev_addr, addr->sa_data);
339         return 0;
340 }
341 
342 static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
343 {
344         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
345         const struct net_device_ops *ops = real_dev->netdev_ops;
346         struct ifreq ifrr;
347         int err = -EOPNOTSUPP;
348 
349         strncpy(ifrr.ifr_name, real_dev->name, IFNAMSIZ);
350         ifrr.ifr_ifru = ifr->ifr_ifru;
351 
352         switch (cmd) {
353         case SIOCGMIIPHY:
354         case SIOCGMIIREG:
355         case SIOCSMIIREG:
356         case SIOCSHWTSTAMP:
357         case SIOCGHWTSTAMP:
358                 if (netif_device_present(real_dev) && ops->ndo_do_ioctl)
359                         err = ops->ndo_do_ioctl(real_dev, &ifrr, cmd);
360                 break;
361         }
362 
363         if (!err)
364                 ifr->ifr_ifru = ifrr.ifr_ifru;
365 
366         return err;
367 }
368 
369 static int vlan_dev_neigh_setup(struct net_device *dev, struct neigh_parms *pa)
370 {
371         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
372         const struct net_device_ops *ops = real_dev->netdev_ops;
373         int err = 0;
374 
375         if (netif_device_present(real_dev) && ops->ndo_neigh_setup)
376                 err = ops->ndo_neigh_setup(real_dev, pa);
377 
378         return err;
379 }
380 
381 #if IS_ENABLED(CONFIG_FCOE)
382 static int vlan_dev_fcoe_ddp_setup(struct net_device *dev, u16 xid,
383                                    struct scatterlist *sgl, unsigned int sgc)
384 {
385         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
386         const struct net_device_ops *ops = real_dev->netdev_ops;
387         int rc = 0;
388 
389         if (ops->ndo_fcoe_ddp_setup)
390                 rc = ops->ndo_fcoe_ddp_setup(real_dev, xid, sgl, sgc);
391 
392         return rc;
393 }
394 
395 static int vlan_dev_fcoe_ddp_done(struct net_device *dev, u16 xid)
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 len = 0;
400 
401         if (ops->ndo_fcoe_ddp_done)
402                 len = ops->ndo_fcoe_ddp_done(real_dev, xid);
403 
404         return len;
405 }
406 
407 static int vlan_dev_fcoe_enable(struct net_device *dev)
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 rc = -EINVAL;
412 
413         if (ops->ndo_fcoe_enable)
414                 rc = ops->ndo_fcoe_enable(real_dev);
415         return rc;
416 }
417 
418 static int vlan_dev_fcoe_disable(struct net_device *dev)
419 {
420         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
421         const struct net_device_ops *ops = real_dev->netdev_ops;
422         int rc = -EINVAL;
423 
424         if (ops->ndo_fcoe_disable)
425                 rc = ops->ndo_fcoe_disable(real_dev);
426         return rc;
427 }
428 
429 static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type)
430 {
431         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
432         const struct net_device_ops *ops = real_dev->netdev_ops;
433         int rc = -EINVAL;
434 
435         if (ops->ndo_fcoe_get_wwn)
436                 rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type);
437         return rc;
438 }
439 
440 static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid,
441                                     struct scatterlist *sgl, unsigned int sgc)
442 {
443         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
444         const struct net_device_ops *ops = real_dev->netdev_ops;
445         int rc = 0;
446 
447         if (ops->ndo_fcoe_ddp_target)
448                 rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc);
449 
450         return rc;
451 }
452 #endif
453 
454 static void vlan_dev_change_rx_flags(struct net_device *dev, int change)
455 {
456         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
457 
458         if (dev->flags & IFF_UP) {
459                 if (change & IFF_ALLMULTI)
460                         dev_set_allmulti(real_dev, dev->flags & IFF_ALLMULTI ? 1 : -1);
461                 if (change & IFF_PROMISC)
462                         dev_set_promiscuity(real_dev, dev->flags & IFF_PROMISC ? 1 : -1);
463         }
464 }
465 
466 static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)
467 {
468         dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
469         dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);
470 }
471 
472 /*
473  * vlan network devices have devices nesting below it, and are a special
474  * "super class" of normal network devices; split their locks off into a
475  * separate class since they always nest.
476  */
477 static struct lock_class_key vlan_netdev_xmit_lock_key;
478 static struct lock_class_key vlan_netdev_addr_lock_key;
479 
480 static void vlan_dev_set_lockdep_one(struct net_device *dev,
481                                      struct netdev_queue *txq,
482                                      void *_subclass)
483 {
484         lockdep_set_class_and_subclass(&txq->_xmit_lock,
485                                        &vlan_netdev_xmit_lock_key,
486                                        *(int *)_subclass);
487 }
488 
489 static void vlan_dev_set_lockdep_class(struct net_device *dev, int subclass)
490 {
491         lockdep_set_class_and_subclass(&dev->addr_list_lock,
492                                        &vlan_netdev_addr_lock_key,
493                                        subclass);
494         netdev_for_each_tx_queue(dev, vlan_dev_set_lockdep_one, &subclass);
495 }
496 
497 static int vlan_dev_get_lock_subclass(struct net_device *dev)
498 {
499         return vlan_dev_priv(dev)->nest_level;
500 }
501 
502 static const struct header_ops vlan_header_ops = {
503         .create  = vlan_dev_hard_header,
504         .parse   = eth_header_parse,
505 };
506 
507 static int vlan_passthru_hard_header(struct sk_buff *skb, struct net_device *dev,
508                                      unsigned short type,
509                                      const void *daddr, const void *saddr,
510                                      unsigned int len)
511 {
512         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
513         struct net_device *real_dev = vlan->real_dev;
514 
515         if (saddr == NULL)
516                 saddr = dev->dev_addr;
517 
518         return dev_hard_header(skb, real_dev, type, daddr, saddr, len);
519 }
520 
521 static const struct header_ops vlan_passthru_header_ops = {
522         .create  = vlan_passthru_hard_header,
523         .parse   = eth_header_parse,
524 };
525 
526 static struct device_type vlan_type = {
527         .name   = "vlan",
528 };
529 
530 static const struct net_device_ops vlan_netdev_ops;
531 
532 static int vlan_dev_init(struct net_device *dev)
533 {
534         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
535 
536         netif_carrier_off(dev);
537 
538         /* IFF_BROADCAST|IFF_MULTICAST; ??? */
539         dev->flags  = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
540                                           IFF_MASTER | IFF_SLAVE);
541         dev->state  = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |
542                                           (1<<__LINK_STATE_DORMANT))) |
543                       (1<<__LINK_STATE_PRESENT);
544 
545         dev->hw_features = NETIF_F_ALL_CSUM | NETIF_F_SG |
546                            NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE |
547                            NETIF_F_HIGHDMA | NETIF_F_SCTP_CSUM |
548                            NETIF_F_ALL_FCOE;
549 
550         dev->features |= real_dev->vlan_features | NETIF_F_LLTX |
551                          NETIF_F_GSO_SOFTWARE;
552         dev->gso_max_size = real_dev->gso_max_size;
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 & ~NETIF_F_ALL_FCOE;
557 
558         /* ipv6 shared card related stuff */
559         dev->dev_id = real_dev->dev_id;
560 
561         if (is_zero_ether_addr(dev->dev_addr))
562                 eth_hw_addr_inherit(dev, real_dev);
563         if (is_zero_ether_addr(dev->broadcast))
564                 memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len);
565 
566 #if IS_ENABLED(CONFIG_FCOE)
567         dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid;
568 #endif
569 
570         dev->needed_headroom = real_dev->needed_headroom;
571         if (vlan_hw_offload_capable(real_dev->features,
572                                     vlan_dev_priv(dev)->vlan_proto)) {
573                 dev->header_ops      = &vlan_passthru_header_ops;
574                 dev->hard_header_len = real_dev->hard_header_len;
575         } else {
576                 dev->header_ops      = &vlan_header_ops;
577                 dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;
578         }
579 
580         dev->netdev_ops = &vlan_netdev_ops;
581 
582         SET_NETDEV_DEVTYPE(dev, &vlan_type);
583 
584         vlan_dev_set_lockdep_class(dev, vlan_dev_get_lock_subclass(dev));
585 
586         vlan_dev_priv(dev)->vlan_pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
587         if (!vlan_dev_priv(dev)->vlan_pcpu_stats)
588                 return -ENOMEM;
589 
590         return 0;
591 }
592 
593 static void vlan_dev_uninit(struct net_device *dev)
594 {
595         struct vlan_priority_tci_mapping *pm;
596         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
597         int i;
598 
599         for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) {
600                 while ((pm = vlan->egress_priority_map[i]) != NULL) {
601                         vlan->egress_priority_map[i] = pm->next;
602                         kfree(pm);
603                 }
604         }
605 }
606 
607 static netdev_features_t vlan_dev_fix_features(struct net_device *dev,
608         netdev_features_t features)
609 {
610         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
611         netdev_features_t old_features = features;
612 
613         features = netdev_intersect_features(features, real_dev->vlan_features);
614         features |= NETIF_F_RXCSUM;
615         features = netdev_intersect_features(features, real_dev->features);
616 
617         features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_GSO_SOFTWARE);
618         features |= NETIF_F_LLTX;
619 
620         return features;
621 }
622 
623 static int vlan_ethtool_get_settings(struct net_device *dev,
624                                      struct ethtool_cmd *cmd)
625 {
626         const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
627 
628         return __ethtool_get_settings(vlan->real_dev, cmd);
629 }
630 
631 static void vlan_ethtool_get_drvinfo(struct net_device *dev,
632                                      struct ethtool_drvinfo *info)
633 {
634         strlcpy(info->driver, vlan_fullname, sizeof(info->driver));
635         strlcpy(info->version, vlan_version, sizeof(info->version));
636         strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
637 }
638 
639 static int vlan_ethtool_get_ts_info(struct net_device *dev,
640                                     struct ethtool_ts_info *info)
641 {
642         const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
643         const struct ethtool_ops *ops = vlan->real_dev->ethtool_ops;
644 
645         if (ops->get_ts_info) {
646                 return ops->get_ts_info(vlan->real_dev, info);
647         } else {
648                 info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
649                         SOF_TIMESTAMPING_SOFTWARE;
650                 info->phc_index = -1;
651         }
652 
653         return 0;
654 }
655 
656 static struct rtnl_link_stats64 *vlan_dev_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
657 {
658         struct vlan_pcpu_stats *p;
659         u32 rx_errors = 0, tx_dropped = 0;
660         int i;
661 
662         for_each_possible_cpu(i) {
663                 u64 rxpackets, rxbytes, rxmulticast, txpackets, txbytes;
664                 unsigned int start;
665 
666                 p = per_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats, i);
667                 do {
668                         start = u64_stats_fetch_begin_irq(&p->syncp);
669                         rxpackets       = p->rx_packets;
670                         rxbytes         = p->rx_bytes;
671                         rxmulticast     = p->rx_multicast;
672                         txpackets       = p->tx_packets;
673                         txbytes         = p->tx_bytes;
674                 } while (u64_stats_fetch_retry_irq(&p->syncp, start));
675 
676                 stats->rx_packets       += rxpackets;
677                 stats->rx_bytes         += rxbytes;
678                 stats->multicast        += rxmulticast;
679                 stats->tx_packets       += txpackets;
680                 stats->tx_bytes         += txbytes;
681                 /* rx_errors & tx_dropped are u32 */
682                 rx_errors       += p->rx_errors;
683                 tx_dropped      += p->tx_dropped;
684         }
685         stats->rx_errors  = rx_errors;
686         stats->tx_dropped = tx_dropped;
687 
688         return stats;
689 }
690 
691 #ifdef CONFIG_NET_POLL_CONTROLLER
692 static void vlan_dev_poll_controller(struct net_device *dev)
693 {
694         return;
695 }
696 
697 static int vlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo)
698 {
699         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
700         struct net_device *real_dev = vlan->real_dev;
701         struct netpoll *netpoll;
702         int err = 0;
703 
704         netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
705         err = -ENOMEM;
706         if (!netpoll)
707                 goto out;
708 
709         err = __netpoll_setup(netpoll, real_dev);
710         if (err) {
711                 kfree(netpoll);
712                 goto out;
713         }
714 
715         vlan->netpoll = netpoll;
716 
717 out:
718         return err;
719 }
720 
721 static void vlan_dev_netpoll_cleanup(struct net_device *dev)
722 {
723         struct vlan_dev_priv *vlan= vlan_dev_priv(dev);
724         struct netpoll *netpoll = vlan->netpoll;
725 
726         if (!netpoll)
727                 return;
728 
729         vlan->netpoll = NULL;
730 
731         __netpoll_free_async(netpoll);
732 }
733 #endif /* CONFIG_NET_POLL_CONTROLLER */
734 
735 static int vlan_dev_get_iflink(const struct net_device *dev)
736 {
737         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
738 
739         return real_dev->ifindex;
740 }
741 
742 static const struct ethtool_ops vlan_ethtool_ops = {
743         .get_settings           = vlan_ethtool_get_settings,
744         .get_drvinfo            = vlan_ethtool_get_drvinfo,
745         .get_link               = ethtool_op_get_link,
746         .get_ts_info            = vlan_ethtool_get_ts_info,
747 };
748 
749 static const struct net_device_ops vlan_netdev_ops = {
750         .ndo_change_mtu         = vlan_dev_change_mtu,
751         .ndo_init               = vlan_dev_init,
752         .ndo_uninit             = vlan_dev_uninit,
753         .ndo_open               = vlan_dev_open,
754         .ndo_stop               = vlan_dev_stop,
755         .ndo_start_xmit =  vlan_dev_hard_start_xmit,
756         .ndo_validate_addr      = eth_validate_addr,
757         .ndo_set_mac_address    = vlan_dev_set_mac_address,
758         .ndo_set_rx_mode        = vlan_dev_set_rx_mode,
759         .ndo_change_rx_flags    = vlan_dev_change_rx_flags,
760         .ndo_do_ioctl           = vlan_dev_ioctl,
761         .ndo_neigh_setup        = vlan_dev_neigh_setup,
762         .ndo_get_stats64        = vlan_dev_get_stats64,
763 #if IS_ENABLED(CONFIG_FCOE)
764         .ndo_fcoe_ddp_setup     = vlan_dev_fcoe_ddp_setup,
765         .ndo_fcoe_ddp_done      = vlan_dev_fcoe_ddp_done,
766         .ndo_fcoe_enable        = vlan_dev_fcoe_enable,
767         .ndo_fcoe_disable       = vlan_dev_fcoe_disable,
768         .ndo_fcoe_get_wwn       = vlan_dev_fcoe_get_wwn,
769         .ndo_fcoe_ddp_target    = vlan_dev_fcoe_ddp_target,
770 #endif
771 #ifdef CONFIG_NET_POLL_CONTROLLER
772         .ndo_poll_controller    = vlan_dev_poll_controller,
773         .ndo_netpoll_setup      = vlan_dev_netpoll_setup,
774         .ndo_netpoll_cleanup    = vlan_dev_netpoll_cleanup,
775 #endif
776         .ndo_fix_features       = vlan_dev_fix_features,
777         .ndo_get_lock_subclass  = vlan_dev_get_lock_subclass,
778         .ndo_get_iflink         = vlan_dev_get_iflink,
779 };
780 
781 static void vlan_dev_free(struct net_device *dev)
782 {
783         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
784 
785         free_percpu(vlan->vlan_pcpu_stats);
786         vlan->vlan_pcpu_stats = NULL;
787         free_netdev(dev);
788 }
789 
790 void vlan_setup(struct net_device *dev)
791 {
792         ether_setup(dev);
793 
794         dev->priv_flags         |= IFF_802_1Q_VLAN;
795         dev->priv_flags         &= ~IFF_TX_SKB_SHARING;
796         netif_keep_dst(dev);
797         dev->tx_queue_len       = 0;
798 
799         dev->netdev_ops         = &vlan_netdev_ops;
800         dev->destructor         = vlan_dev_free;
801         dev->ethtool_ops        = &vlan_ethtool_ops;
802 
803         eth_zero_addr(dev->broadcast);
804 }
805 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us