11da177e4SLinus Torvalds /* -*- linux-c -*- 21da177e4SLinus Torvalds * INET 802.1Q VLAN 31da177e4SLinus Torvalds * Ethernet-type device handling. 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Authors: Ben Greear <greearb@candelatech.com> 6ad712087SPatrick McHardy * Please send support related email to: netdev@vger.kernel.org 71da177e4SLinus Torvalds * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * Fixes: Mar 22 2001: Martin Bokaemper <mbokaemper@unispherenetworks.com> 101da177e4SLinus Torvalds * - reset skb->pkt_type on incoming packets when MAC was changed 111da177e4SLinus Torvalds * - see that changed MAC is saddr for outgoing packets 121da177e4SLinus Torvalds * Oct 20, 2001: Ard van Breeman: 131da177e4SLinus Torvalds * - Fix MC-list, finally. 141da177e4SLinus Torvalds * - Flush MC-list on VLAN destroy. 151da177e4SLinus Torvalds * 161da177e4SLinus Torvalds * 171da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 181da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 191da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 201da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 211da177e4SLinus Torvalds */ 221da177e4SLinus Torvalds 23afab2d29SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24afab2d29SJoe Perches 251da177e4SLinus Torvalds #include <linux/module.h> 265a0e3ad6STejun Heo #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/skbuff.h> 281da177e4SLinus Torvalds #include <linux/netdevice.h> 291da177e4SLinus Torvalds #include <linux/etherdevice.h> 3075b8846aSPatrick McHardy #include <linux/ethtool.h> 311da177e4SLinus Torvalds #include <net/arp.h> 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds #include "vlan.h" 341da177e4SLinus Torvalds #include "vlanproc.h" 351da177e4SLinus Torvalds #include <linux/if_vlan.h> 366d4cdf47SBenjamin LaHaise #include <linux/netpoll.h> 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds /* 391da177e4SLinus Torvalds * Rebuild the Ethernet MAC header. This is called after an ARP 401da177e4SLinus Torvalds * (or in future other address resolution) has completed on this 411da177e4SLinus Torvalds * sk_buff. We now let ARP fill in the other fields. 421da177e4SLinus Torvalds * 431da177e4SLinus Torvalds * This routine CANNOT use cached dst->neigh! 441da177e4SLinus Torvalds * Really, it is used only when dst->neigh is wrong. 451da177e4SLinus Torvalds * 461da177e4SLinus Torvalds * TODO: This needs a checkup, I'm ignorant here. --BLG 471da177e4SLinus Torvalds */ 48ef3eb3e5SPatrick McHardy static int vlan_dev_rebuild_header(struct sk_buff *skb) 491da177e4SLinus Torvalds { 501da177e4SLinus Torvalds struct net_device *dev = skb->dev; 511da177e4SLinus Torvalds struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds switch (veth->h_vlan_encapsulated_proto) { 541da177e4SLinus Torvalds #ifdef CONFIG_INET 5560678040SArnaldo Carvalho de Melo case htons(ETH_P_IP): 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds /* TODO: Confirm this will work with VLAN headers... */ 581da177e4SLinus Torvalds return arp_find(veth->h_dest, skb); 591da177e4SLinus Torvalds #endif 601da177e4SLinus Torvalds default: 61afab2d29SJoe Perches pr_debug("%s: unable to resolve type %X addresses\n", 62d136fe72SAlexey Dobriyan dev->name, ntohs(veth->h_vlan_encapsulated_proto)); 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds memcpy(veth->h_source, dev->dev_addr, ETH_ALEN); 651da177e4SLinus Torvalds break; 663ff50b79SStephen Hemminger } 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds return 0; 691da177e4SLinus Torvalds } 701da177e4SLinus Torvalds 719bb8582eSPatrick McHardy static inline u16 722029cc2cSPatrick McHardy vlan_dev_get_egress_qos_mask(struct net_device *dev, struct sk_buff *skb) 731da177e4SLinus Torvalds { 742029cc2cSPatrick McHardy struct vlan_priority_tci_mapping *mp; 751da177e4SLinus Torvalds 767da82c06SJiri Pirko mp = vlan_dev_priv(dev)->egress_priority_map[(skb->priority & 0xF)]; 771da177e4SLinus Torvalds while (mp) { 781da177e4SLinus Torvalds if (mp->priority == skb->priority) { 792029cc2cSPatrick McHardy return mp->vlan_qos; /* This should already be shifted 802029cc2cSPatrick McHardy * to mask correctly with the 812029cc2cSPatrick McHardy * VLAN's TCI */ 821da177e4SLinus Torvalds } 831da177e4SLinus Torvalds mp = mp->next; 841da177e4SLinus Torvalds } 851da177e4SLinus Torvalds return 0; 861da177e4SLinus Torvalds } 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds /* 891da177e4SLinus Torvalds * Create the VLAN header for an arbitrary protocol layer 901da177e4SLinus Torvalds * 911da177e4SLinus Torvalds * saddr=NULL means use device source address 921da177e4SLinus Torvalds * daddr=NULL means leave destination address (eg unresolved arp) 931da177e4SLinus Torvalds * 941da177e4SLinus Torvalds * This is called when the SKB is moving down the stack towards the 951da177e4SLinus Torvalds * physical devices. 961da177e4SLinus Torvalds */ 97ef3eb3e5SPatrick McHardy static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev, 983b04dddeSStephen Hemminger unsigned short type, 99ef3eb3e5SPatrick McHardy const void *daddr, const void *saddr, 100ef3eb3e5SPatrick McHardy unsigned int len) 1011da177e4SLinus Torvalds { 1021da177e4SLinus Torvalds struct vlan_hdr *vhdr; 1031349fe9aSPatrick McHardy unsigned int vhdrlen = 0; 1049bb8582eSPatrick McHardy u16 vlan_tci = 0; 1051349fe9aSPatrick McHardy int rc; 1061da177e4SLinus Torvalds 1077da82c06SJiri Pirko if (!(vlan_dev_priv(dev)->flags & VLAN_FLAG_REORDER_HDR)) { 1081da177e4SLinus Torvalds vhdr = (struct vlan_hdr *) skb_push(skb, VLAN_HLEN); 1091da177e4SLinus Torvalds 1107da82c06SJiri Pirko vlan_tci = vlan_dev_priv(dev)->vlan_id; 1119bb8582eSPatrick McHardy vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb); 1129bb8582eSPatrick McHardy vhdr->h_vlan_TCI = htons(vlan_tci); 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds /* 115bf9ae538SOctavian Purdila * Set the protocol type. For a packet of type ETH_P_802_3/2 we 116bf9ae538SOctavian Purdila * put the length in here instead. 1171da177e4SLinus Torvalds */ 118bf9ae538SOctavian Purdila if (type != ETH_P_802_3 && type != ETH_P_802_2) 1191da177e4SLinus Torvalds vhdr->h_vlan_encapsulated_proto = htons(type); 1202029cc2cSPatrick McHardy else 1211da177e4SLinus Torvalds vhdr->h_vlan_encapsulated_proto = htons(len); 122279e172aSJerome Borsboom 123279e172aSJerome Borsboom skb->protocol = htons(ETH_P_8021Q); 1241349fe9aSPatrick McHardy type = ETH_P_8021Q; 1251349fe9aSPatrick McHardy vhdrlen = VLAN_HLEN; 1261da177e4SLinus Torvalds } 1271da177e4SLinus Torvalds 1281da177e4SLinus Torvalds /* Before delegating work to the lower layer, enter our MAC-address */ 1291da177e4SLinus Torvalds if (saddr == NULL) 1301da177e4SLinus Torvalds saddr = dev->dev_addr; 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds /* Now make the underlying real hard header */ 1337da82c06SJiri Pirko dev = vlan_dev_priv(dev)->real_dev; 1341349fe9aSPatrick McHardy rc = dev_hard_header(skb, dev, type, daddr, saddr, len + vhdrlen); 1350c4e8581SStephen Hemminger if (rc > 0) 1361349fe9aSPatrick McHardy rc += vhdrlen; 1371da177e4SLinus Torvalds return rc; 1381da177e4SLinus Torvalds } 1391da177e4SLinus Torvalds 1406fef4c0cSStephen Hemminger static netdev_tx_t vlan_dev_hard_start_xmit(struct sk_buff *skb, 1416fef4c0cSStephen Hemminger struct net_device *dev) 1421da177e4SLinus Torvalds { 1431da177e4SLinus Torvalds struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data); 1441a123a31SEric Dumazet unsigned int len; 1451a123a31SEric Dumazet int ret; 14655b01e86SDavid S. Miller 1471da177e4SLinus Torvalds /* Handle non-VLAN frames if they are sent to us, for example by DHCP. 1481da177e4SLinus Torvalds * 1491da177e4SLinus Torvalds * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING 1501da177e4SLinus Torvalds * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs... 1511da177e4SLinus Torvalds */ 1526ab3b487SJoonwoo Park if (veth->h_vlan_proto != htons(ETH_P_8021Q) || 1537da82c06SJiri Pirko vlan_dev_priv(dev)->flags & VLAN_FLAG_REORDER_HDR) { 1549bb8582eSPatrick McHardy u16 vlan_tci; 1557da82c06SJiri Pirko vlan_tci = vlan_dev_priv(dev)->vlan_id; 1569bb8582eSPatrick McHardy vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb); 1579bb8582eSPatrick McHardy skb = __vlan_hwaccel_put_tag(skb, vlan_tci); 158636e19a3SJohn Fastabend } 1591da177e4SLinus Torvalds 16059b9997bSDavid S. Miller skb->dev = vlan_dev_priv(dev)->real_dev; 1611a123a31SEric Dumazet len = skb->len; 1626d4cdf47SBenjamin LaHaise if (netpoll_tx_running(dev)) 1636d4cdf47SBenjamin LaHaise return skb->dev->netdev_ops->ndo_start_xmit(skb, skb->dev); 1641a123a31SEric Dumazet ret = dev_queue_xmit(skb); 1651a123a31SEric Dumazet 1662d6c9ffcSEric Dumazet if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) { 1674af429d2SEric Dumazet struct vlan_pcpu_stats *stats; 1684af429d2SEric Dumazet 1697da82c06SJiri Pirko stats = this_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats); 1704af429d2SEric Dumazet u64_stats_update_begin(&stats->syncp); 1714af429d2SEric Dumazet stats->tx_packets++; 1724af429d2SEric Dumazet stats->tx_bytes += len; 173307f73dfSWei Yongjun u64_stats_update_end(&stats->syncp); 1744af429d2SEric Dumazet } else { 1757da82c06SJiri Pirko this_cpu_inc(vlan_dev_priv(dev)->vlan_pcpu_stats->tx_dropped); 1764af429d2SEric Dumazet } 1771a123a31SEric Dumazet 178cbbef5e1SPatrick McHardy return ret; 1791da177e4SLinus Torvalds } 1801da177e4SLinus Torvalds 181ef3eb3e5SPatrick McHardy static int vlan_dev_change_mtu(struct net_device *dev, int new_mtu) 1821da177e4SLinus Torvalds { 1831da177e4SLinus Torvalds /* TODO: gotta make sure the underlying layer can handle it, 1841da177e4SLinus Torvalds * maybe an IFF_VLAN_CAPABLE flag for devices? 1851da177e4SLinus Torvalds */ 1867da82c06SJiri Pirko if (vlan_dev_priv(dev)->real_dev->mtu < new_mtu) 1871da177e4SLinus Torvalds return -ERANGE; 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds dev->mtu = new_mtu; 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds return 0; 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds 194c17d8874SPatrick McHardy void vlan_dev_set_ingress_priority(const struct net_device *dev, 1959bb8582eSPatrick McHardy u32 skb_prio, u16 vlan_prio) 1961da177e4SLinus Torvalds { 1977da82c06SJiri Pirko struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 198b020cb48SPatrick McHardy 199b020cb48SPatrick McHardy if (vlan->ingress_priority_map[vlan_prio & 0x7] && !skb_prio) 200b020cb48SPatrick McHardy vlan->nr_ingress_mappings--; 201b020cb48SPatrick McHardy else if (!vlan->ingress_priority_map[vlan_prio & 0x7] && skb_prio) 202b020cb48SPatrick McHardy vlan->nr_ingress_mappings++; 203b020cb48SPatrick McHardy 204b020cb48SPatrick McHardy vlan->ingress_priority_map[vlan_prio & 0x7] = skb_prio; 2051da177e4SLinus Torvalds } 2061da177e4SLinus Torvalds 207c17d8874SPatrick McHardy int vlan_dev_set_egress_priority(const struct net_device *dev, 2089bb8582eSPatrick McHardy u32 skb_prio, u16 vlan_prio) 2091da177e4SLinus Torvalds { 2107da82c06SJiri Pirko struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 2111da177e4SLinus Torvalds struct vlan_priority_tci_mapping *mp = NULL; 2121da177e4SLinus Torvalds struct vlan_priority_tci_mapping *np; 21305423b24SEric Dumazet u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK; 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds /* See if a priority mapping exists.. */ 216b020cb48SPatrick McHardy mp = vlan->egress_priority_map[skb_prio & 0xF]; 2171da177e4SLinus Torvalds while (mp) { 2181da177e4SLinus Torvalds if (mp->priority == skb_prio) { 219b020cb48SPatrick McHardy if (mp->vlan_qos && !vlan_qos) 220b020cb48SPatrick McHardy vlan->nr_egress_mappings--; 221b020cb48SPatrick McHardy else if (!mp->vlan_qos && vlan_qos) 222b020cb48SPatrick McHardy vlan->nr_egress_mappings++; 223b020cb48SPatrick McHardy mp->vlan_qos = vlan_qos; 2241da177e4SLinus Torvalds return 0; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds mp = mp->next; 2271da177e4SLinus Torvalds } 2281da177e4SLinus Torvalds 2291da177e4SLinus Torvalds /* Create a new mapping then. */ 230b020cb48SPatrick McHardy mp = vlan->egress_priority_map[skb_prio & 0xF]; 2311da177e4SLinus Torvalds np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL); 232c17d8874SPatrick McHardy if (!np) 233c17d8874SPatrick McHardy return -ENOBUFS; 234c17d8874SPatrick McHardy 2351da177e4SLinus Torvalds np->next = mp; 2361da177e4SLinus Torvalds np->priority = skb_prio; 237b020cb48SPatrick McHardy np->vlan_qos = vlan_qos; 238b020cb48SPatrick McHardy vlan->egress_priority_map[skb_prio & 0xF] = np; 239b020cb48SPatrick McHardy if (vlan_qos) 240b020cb48SPatrick McHardy vlan->nr_egress_mappings++; 2411da177e4SLinus Torvalds return 0; 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds 244a4bf3af4SPatrick McHardy /* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */ 245b3ce0325SPatrick McHardy int vlan_dev_change_flags(const struct net_device *dev, u32 flags, u32 mask) 2461da177e4SLinus Torvalds { 2477da82c06SJiri Pirko struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 248b3ce0325SPatrick McHardy u32 old_flags = vlan->flags; 249b3ce0325SPatrick McHardy 2505e756593SPatrick McHardy if (mask & ~(VLAN_FLAG_REORDER_HDR | VLAN_FLAG_GVRP | 2515e756593SPatrick McHardy VLAN_FLAG_LOOSE_BINDING)) 2521da177e4SLinus Torvalds return -EINVAL; 253b3ce0325SPatrick McHardy 254b3ce0325SPatrick McHardy vlan->flags = (old_flags & ~mask) | (flags & mask); 25570c03b49SPatrick McHardy 25670c03b49SPatrick McHardy if (netif_running(dev) && (vlan->flags ^ old_flags) & VLAN_FLAG_GVRP) { 25770c03b49SPatrick McHardy if (vlan->flags & VLAN_FLAG_GVRP) 25870c03b49SPatrick McHardy vlan_gvrp_request_join(dev); 25970c03b49SPatrick McHardy else 26070c03b49SPatrick McHardy vlan_gvrp_request_leave(dev); 26170c03b49SPatrick McHardy } 262b3ce0325SPatrick McHardy return 0; 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds 265c17d8874SPatrick McHardy void vlan_dev_get_realdev_name(const struct net_device *dev, char *result) 2661da177e4SLinus Torvalds { 2677da82c06SJiri Pirko strncpy(result, vlan_dev_priv(dev)->real_dev->name, 23); 2681da177e4SLinus Torvalds } 2691da177e4SLinus Torvalds 270ef3eb3e5SPatrick McHardy static int vlan_dev_open(struct net_device *dev) 2711da177e4SLinus Torvalds { 2727da82c06SJiri Pirko struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 2738c979c26SPatrick McHardy struct net_device *real_dev = vlan->real_dev; 2748c979c26SPatrick McHardy int err; 2758c979c26SPatrick McHardy 2765e756593SPatrick McHardy if (!(real_dev->flags & IFF_UP) && 2775e756593SPatrick McHardy !(vlan->flags & VLAN_FLAG_LOOSE_BINDING)) 2781da177e4SLinus Torvalds return -ENETDOWN; 2791da177e4SLinus Torvalds 28053a2b3a1SJoe Perches if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr)) { 281a748ee24SJiri Pirko err = dev_uc_add(real_dev, dev->dev_addr); 2828c979c26SPatrick McHardy if (err < 0) 28389146504SWang Chen goto out; 2848c979c26SPatrick McHardy } 2858c979c26SPatrick McHardy 28689146504SWang Chen if (dev->flags & IFF_ALLMULTI) { 28789146504SWang Chen err = dev_set_allmulti(real_dev, 1); 28889146504SWang Chen if (err < 0) 28989146504SWang Chen goto del_unicast; 29089146504SWang Chen } 29189146504SWang Chen if (dev->flags & IFF_PROMISC) { 29289146504SWang Chen err = dev_set_promiscuity(real_dev, 1); 29389146504SWang Chen if (err < 0) 29489146504SWang Chen goto clear_allmulti; 29589146504SWang Chen } 29689146504SWang Chen 29789146504SWang Chen memcpy(vlan->real_dev_addr, real_dev->dev_addr, ETH_ALEN); 2986c78dcbdSPatrick McHardy 29970c03b49SPatrick McHardy if (vlan->flags & VLAN_FLAG_GVRP) 30070c03b49SPatrick McHardy vlan_gvrp_request_join(dev); 30170c03b49SPatrick McHardy 3020ac820eeSPhil Oester if (netif_carrier_ok(real_dev)) 303adc667e8SJay Vosburgh netif_carrier_on(dev); 3041da177e4SLinus Torvalds return 0; 30589146504SWang Chen 30689146504SWang Chen clear_allmulti: 30789146504SWang Chen if (dev->flags & IFF_ALLMULTI) 30889146504SWang Chen dev_set_allmulti(real_dev, -1); 30989146504SWang Chen del_unicast: 31053a2b3a1SJoe Perches if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr)) 311a748ee24SJiri Pirko dev_uc_del(real_dev, dev->dev_addr); 31289146504SWang Chen out: 313adc667e8SJay Vosburgh netif_carrier_off(dev); 31489146504SWang Chen return err; 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds 317ef3eb3e5SPatrick McHardy static int vlan_dev_stop(struct net_device *dev) 3181da177e4SLinus Torvalds { 3197da82c06SJiri Pirko struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 32070c03b49SPatrick McHardy struct net_device *real_dev = vlan->real_dev; 32170c03b49SPatrick McHardy 32256addd6eSPatrick McHardy dev_mc_unsync(real_dev, dev); 323a748ee24SJiri Pirko dev_uc_unsync(real_dev, dev); 3246c78dcbdSPatrick McHardy if (dev->flags & IFF_ALLMULTI) 3256c78dcbdSPatrick McHardy dev_set_allmulti(real_dev, -1); 3266c78dcbdSPatrick McHardy if (dev->flags & IFF_PROMISC) 3276c78dcbdSPatrick McHardy dev_set_promiscuity(real_dev, -1); 3286c78dcbdSPatrick McHardy 32953a2b3a1SJoe Perches if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr)) 330a748ee24SJiri Pirko dev_uc_del(real_dev, dev->dev_addr); 3318c979c26SPatrick McHardy 332adc667e8SJay Vosburgh netif_carrier_off(dev); 3331da177e4SLinus Torvalds return 0; 3341da177e4SLinus Torvalds } 3351da177e4SLinus Torvalds 336ef3eb3e5SPatrick McHardy static int vlan_dev_set_mac_address(struct net_device *dev, void *p) 33739aaac11SPatrick McHardy { 3387da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 33939aaac11SPatrick McHardy struct sockaddr *addr = p; 34039aaac11SPatrick McHardy int err; 34139aaac11SPatrick McHardy 34239aaac11SPatrick McHardy if (!is_valid_ether_addr(addr->sa_data)) 34339aaac11SPatrick McHardy return -EADDRNOTAVAIL; 34439aaac11SPatrick McHardy 34539aaac11SPatrick McHardy if (!(dev->flags & IFF_UP)) 34639aaac11SPatrick McHardy goto out; 34739aaac11SPatrick McHardy 34853a2b3a1SJoe Perches if (!ether_addr_equal(addr->sa_data, real_dev->dev_addr)) { 349a748ee24SJiri Pirko err = dev_uc_add(real_dev, addr->sa_data); 35039aaac11SPatrick McHardy if (err < 0) 35139aaac11SPatrick McHardy return err; 35239aaac11SPatrick McHardy } 35339aaac11SPatrick McHardy 35453a2b3a1SJoe Perches if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr)) 355a748ee24SJiri Pirko dev_uc_del(real_dev, dev->dev_addr); 35639aaac11SPatrick McHardy 35739aaac11SPatrick McHardy out: 35839aaac11SPatrick McHardy memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 35939aaac11SPatrick McHardy return 0; 36039aaac11SPatrick McHardy } 36139aaac11SPatrick McHardy 362ef3eb3e5SPatrick McHardy static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 3631da177e4SLinus Torvalds { 3647da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 365656299f7SStephen Hemminger const struct net_device_ops *ops = real_dev->netdev_ops; 3661da177e4SLinus Torvalds struct ifreq ifrr; 3671da177e4SLinus Torvalds int err = -EOPNOTSUPP; 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds strncpy(ifrr.ifr_name, real_dev->name, IFNAMSIZ); 3701da177e4SLinus Torvalds ifrr.ifr_ifru = ifr->ifr_ifru; 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds switch (cmd) { 3731da177e4SLinus Torvalds case SIOCGMIIPHY: 3741da177e4SLinus Torvalds case SIOCGMIIREG: 3751da177e4SLinus Torvalds case SIOCSMIIREG: 376656299f7SStephen Hemminger if (netif_device_present(real_dev) && ops->ndo_do_ioctl) 377656299f7SStephen Hemminger err = ops->ndo_do_ioctl(real_dev, &ifrr, cmd); 3781da177e4SLinus Torvalds break; 3791da177e4SLinus Torvalds } 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds if (!err) 3821da177e4SLinus Torvalds ifr->ifr_ifru = ifrr.ifr_ifru; 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds return err; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 387cc883d16SFrank Blaschka static int vlan_dev_neigh_setup(struct net_device *dev, struct neigh_parms *pa) 388cc883d16SFrank Blaschka { 3897da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 390cc883d16SFrank Blaschka const struct net_device_ops *ops = real_dev->netdev_ops; 391cc883d16SFrank Blaschka int err = 0; 392cc883d16SFrank Blaschka 393cc883d16SFrank Blaschka if (netif_device_present(real_dev) && ops->ndo_neigh_setup) 3949d40bbdaSDavid S. Miller err = ops->ndo_neigh_setup(real_dev, pa); 395cc883d16SFrank Blaschka 396cc883d16SFrank Blaschka return err; 397cc883d16SFrank Blaschka } 398cc883d16SFrank Blaschka 399b85daa53SVasu Dev #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 400b85daa53SVasu Dev static int vlan_dev_fcoe_ddp_setup(struct net_device *dev, u16 xid, 401b85daa53SVasu Dev struct scatterlist *sgl, unsigned int sgc) 402b85daa53SVasu Dev { 4037da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 404b85daa53SVasu Dev const struct net_device_ops *ops = real_dev->netdev_ops; 405b85daa53SVasu Dev int rc = 0; 406b85daa53SVasu Dev 407b85daa53SVasu Dev if (ops->ndo_fcoe_ddp_setup) 408b85daa53SVasu Dev rc = ops->ndo_fcoe_ddp_setup(real_dev, xid, sgl, sgc); 409b85daa53SVasu Dev 410b85daa53SVasu Dev return rc; 411b85daa53SVasu Dev } 412b85daa53SVasu Dev 413b85daa53SVasu Dev static int vlan_dev_fcoe_ddp_done(struct net_device *dev, u16 xid) 414b85daa53SVasu Dev { 4157da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 416b85daa53SVasu Dev const struct net_device_ops *ops = real_dev->netdev_ops; 417b85daa53SVasu Dev int len = 0; 418b85daa53SVasu Dev 419b85daa53SVasu Dev if (ops->ndo_fcoe_ddp_done) 420b85daa53SVasu Dev len = ops->ndo_fcoe_ddp_done(real_dev, xid); 421b85daa53SVasu Dev 422b85daa53SVasu Dev return len; 423b85daa53SVasu Dev } 4240af46d99SYi Zou 4250af46d99SYi Zou static int vlan_dev_fcoe_enable(struct net_device *dev) 4260af46d99SYi Zou { 4277da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 4280af46d99SYi Zou const struct net_device_ops *ops = real_dev->netdev_ops; 4290af46d99SYi Zou int rc = -EINVAL; 4300af46d99SYi Zou 4310af46d99SYi Zou if (ops->ndo_fcoe_enable) 4320af46d99SYi Zou rc = ops->ndo_fcoe_enable(real_dev); 4330af46d99SYi Zou return rc; 4340af46d99SYi Zou } 4350af46d99SYi Zou 4360af46d99SYi Zou static int vlan_dev_fcoe_disable(struct net_device *dev) 4370af46d99SYi Zou { 4387da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 4390af46d99SYi Zou const struct net_device_ops *ops = real_dev->netdev_ops; 4400af46d99SYi Zou int rc = -EINVAL; 4410af46d99SYi Zou 4420af46d99SYi Zou if (ops->ndo_fcoe_disable) 4430af46d99SYi Zou rc = ops->ndo_fcoe_disable(real_dev); 4440af46d99SYi Zou return rc; 4450af46d99SYi Zou } 446d6534799SYi Zou 447d6534799SYi Zou static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type) 448d6534799SYi Zou { 4497da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 450d6534799SYi Zou const struct net_device_ops *ops = real_dev->netdev_ops; 451d6534799SYi Zou int rc = -EINVAL; 452d6534799SYi Zou 453d6534799SYi Zou if (ops->ndo_fcoe_get_wwn) 454d6534799SYi Zou rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type); 455d6534799SYi Zou return rc; 456d6534799SYi Zou } 4574ea09c9cSYi Zou 4584ea09c9cSYi Zou static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid, 4594ea09c9cSYi Zou struct scatterlist *sgl, unsigned int sgc) 4604ea09c9cSYi Zou { 4617da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 4624ea09c9cSYi Zou const struct net_device_ops *ops = real_dev->netdev_ops; 4634ea09c9cSYi Zou int rc = 0; 4644ea09c9cSYi Zou 4654ea09c9cSYi Zou if (ops->ndo_fcoe_ddp_target) 4664ea09c9cSYi Zou rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc); 4674ea09c9cSYi Zou 4684ea09c9cSYi Zou return rc; 4694ea09c9cSYi Zou } 470b85daa53SVasu Dev #endif 471b85daa53SVasu Dev 472ef3eb3e5SPatrick McHardy static void vlan_dev_change_rx_flags(struct net_device *dev, int change) 4736c78dcbdSPatrick McHardy { 4747da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 4756c78dcbdSPatrick McHardy 476deede2faSMatthijs Kooijman if (dev->flags & IFF_UP) { 4776c78dcbdSPatrick McHardy if (change & IFF_ALLMULTI) 4786c78dcbdSPatrick McHardy dev_set_allmulti(real_dev, dev->flags & IFF_ALLMULTI ? 1 : -1); 4796c78dcbdSPatrick McHardy if (change & IFF_PROMISC) 4806c78dcbdSPatrick McHardy dev_set_promiscuity(real_dev, dev->flags & IFF_PROMISC ? 1 : -1); 4816c78dcbdSPatrick McHardy } 482deede2faSMatthijs Kooijman } 4836c78dcbdSPatrick McHardy 484e83a2ea8SChris Leech static void vlan_dev_set_rx_mode(struct net_device *vlan_dev) 4851da177e4SLinus Torvalds { 4867da82c06SJiri Pirko dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev); 4877da82c06SJiri Pirko dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev); 4881da177e4SLinus Torvalds } 489ef3eb3e5SPatrick McHardy 490ef3eb3e5SPatrick McHardy /* 491ef3eb3e5SPatrick McHardy * vlan network devices have devices nesting below it, and are a special 492ef3eb3e5SPatrick McHardy * "super class" of normal network devices; split their locks off into a 493ef3eb3e5SPatrick McHardy * separate class since they always nest. 494ef3eb3e5SPatrick McHardy */ 495ef3eb3e5SPatrick McHardy static struct lock_class_key vlan_netdev_xmit_lock_key; 496cf508b12SDavid S. Miller static struct lock_class_key vlan_netdev_addr_lock_key; 497ef3eb3e5SPatrick McHardy 498e8a0464cSDavid S. Miller static void vlan_dev_set_lockdep_one(struct net_device *dev, 499e8a0464cSDavid S. Miller struct netdev_queue *txq, 500e8a0464cSDavid S. Miller void *_subclass) 501c773e847SDavid S. Miller { 502c773e847SDavid S. Miller lockdep_set_class_and_subclass(&txq->_xmit_lock, 503e8a0464cSDavid S. Miller &vlan_netdev_xmit_lock_key, 504e8a0464cSDavid S. Miller *(int *)_subclass); 505c773e847SDavid S. Miller } 506c773e847SDavid S. Miller 507c773e847SDavid S. Miller static void vlan_dev_set_lockdep_class(struct net_device *dev, int subclass) 508c773e847SDavid S. Miller { 509cf508b12SDavid S. Miller lockdep_set_class_and_subclass(&dev->addr_list_lock, 510cf508b12SDavid S. Miller &vlan_netdev_addr_lock_key, 511cf508b12SDavid S. Miller subclass); 512e8a0464cSDavid S. Miller netdev_for_each_tx_queue(dev, vlan_dev_set_lockdep_one, &subclass); 513c773e847SDavid S. Miller } 514c773e847SDavid S. Miller 515ef3eb3e5SPatrick McHardy static const struct header_ops vlan_header_ops = { 516ef3eb3e5SPatrick McHardy .create = vlan_dev_hard_header, 517ef3eb3e5SPatrick McHardy .rebuild = vlan_dev_rebuild_header, 518ef3eb3e5SPatrick McHardy .parse = eth_header_parse, 519ef3eb3e5SPatrick McHardy }; 520ef3eb3e5SPatrick McHardy 521213b15caSEric Dumazet static const struct net_device_ops vlan_netdev_ops; 522f7d1b9f5SEric Dumazet 523ef3eb3e5SPatrick McHardy static int vlan_dev_init(struct net_device *dev) 524ef3eb3e5SPatrick McHardy { 5257da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 526ef3eb3e5SPatrick McHardy int subclass = 0; 527ef3eb3e5SPatrick McHardy 528adc667e8SJay Vosburgh netif_carrier_off(dev); 529adc667e8SJay Vosburgh 530ef3eb3e5SPatrick McHardy /* IFF_BROADCAST|IFF_MULTICAST; ??? */ 531194dbcc8SJohn Fastabend dev->flags = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI | 532194dbcc8SJohn Fastabend IFF_MASTER | IFF_SLAVE); 533ef3eb3e5SPatrick McHardy dev->iflink = real_dev->ifindex; 534ef3eb3e5SPatrick McHardy dev->state = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) | 535ef3eb3e5SPatrick McHardy (1<<__LINK_STATE_DORMANT))) | 536ef3eb3e5SPatrick McHardy (1<<__LINK_STATE_PRESENT); 537ef3eb3e5SPatrick McHardy 53862f2a3a4SMichał Mirosław dev->hw_features = NETIF_F_ALL_CSUM | NETIF_F_SG | 53962f2a3a4SMichał Mirosław NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | 54062f2a3a4SMichał Mirosław NETIF_F_HIGHDMA | NETIF_F_SCTP_CSUM | 54162f2a3a4SMichał Mirosław NETIF_F_ALL_FCOE; 54262f2a3a4SMichał Mirosław 5438a0427bbSMichał Mirosław dev->features |= real_dev->vlan_features | NETIF_F_LLTX; 5441ae4be22SAlexander Duyck dev->gso_max_size = real_dev->gso_max_size; 5455fb13570SPatrick McHardy 546ef3eb3e5SPatrick McHardy /* ipv6 shared card related stuff */ 547ef3eb3e5SPatrick McHardy dev->dev_id = real_dev->dev_id; 548ef3eb3e5SPatrick McHardy 549ef3eb3e5SPatrick McHardy if (is_zero_ether_addr(dev->dev_addr)) 550ef3eb3e5SPatrick McHardy memcpy(dev->dev_addr, real_dev->dev_addr, dev->addr_len); 551ef3eb3e5SPatrick McHardy if (is_zero_ether_addr(dev->broadcast)) 552ef3eb3e5SPatrick McHardy memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len); 553ef3eb3e5SPatrick McHardy 554b85daa53SVasu Dev #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 555b85daa53SVasu Dev dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid; 556b85daa53SVasu Dev #endif 557b85daa53SVasu Dev 558d870bfb9SEric Dumazet dev->needed_headroom = real_dev->needed_headroom; 559ef3eb3e5SPatrick McHardy if (real_dev->features & NETIF_F_HW_VLAN_TX) { 560ef3eb3e5SPatrick McHardy dev->header_ops = real_dev->header_ops; 561ef3eb3e5SPatrick McHardy dev->hard_header_len = real_dev->hard_header_len; 562ef3eb3e5SPatrick McHardy } else { 563ef3eb3e5SPatrick McHardy dev->header_ops = &vlan_header_ops; 564ef3eb3e5SPatrick McHardy dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN; 565636e19a3SJohn Fastabend } 566636e19a3SJohn Fastabend 567f7d1b9f5SEric Dumazet dev->netdev_ops = &vlan_netdev_ops; 568ef3eb3e5SPatrick McHardy 56926a25239SJoonwoo Park if (is_vlan_dev(real_dev)) 570ef3eb3e5SPatrick McHardy subclass = 1; 571ef3eb3e5SPatrick McHardy 572c773e847SDavid S. Miller vlan_dev_set_lockdep_class(dev, subclass); 5739793241fSEric Dumazet 5747da82c06SJiri Pirko vlan_dev_priv(dev)->vlan_pcpu_stats = alloc_percpu(struct vlan_pcpu_stats); 5757da82c06SJiri Pirko if (!vlan_dev_priv(dev)->vlan_pcpu_stats) 5769793241fSEric Dumazet return -ENOMEM; 5779793241fSEric Dumazet 578ef3eb3e5SPatrick McHardy return 0; 579ef3eb3e5SPatrick McHardy } 580ef3eb3e5SPatrick McHardy 58123556323SPavel Emelyanov static void vlan_dev_uninit(struct net_device *dev) 58223556323SPavel Emelyanov { 58323556323SPavel Emelyanov struct vlan_priority_tci_mapping *pm; 5847da82c06SJiri Pirko struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 58523556323SPavel Emelyanov int i; 58623556323SPavel Emelyanov 5874af429d2SEric Dumazet free_percpu(vlan->vlan_pcpu_stats); 5884af429d2SEric Dumazet vlan->vlan_pcpu_stats = NULL; 58923556323SPavel Emelyanov for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) { 59023556323SPavel Emelyanov while ((pm = vlan->egress_priority_map[i]) != NULL) { 59123556323SPavel Emelyanov vlan->egress_priority_map[i] = pm->next; 59223556323SPavel Emelyanov kfree(pm); 59323556323SPavel Emelyanov } 59423556323SPavel Emelyanov } 59523556323SPavel Emelyanov } 59623556323SPavel Emelyanov 597c8f44affSMichał Mirosław static netdev_features_t vlan_dev_fix_features(struct net_device *dev, 598c8f44affSMichał Mirosław netdev_features_t features) 5998a0427bbSMichał Mirosław { 6007da82c06SJiri Pirko struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; 601712ae51aSShan Wei u32 old_features = features; 6028a0427bbSMichał Mirosław 603f0a619ccSMichał Mirosław features &= real_dev->vlan_features; 604bc5787c6SMichał Mirosław features |= NETIF_F_RXCSUM; 605bc5787c6SMichał Mirosław features &= real_dev->features; 606712ae51aSShan Wei 607712ae51aSShan Wei features |= old_features & NETIF_F_SOFT_FEATURES; 608f0a619ccSMichał Mirosław features |= NETIF_F_LLTX; 6098a0427bbSMichał Mirosław 6108a0427bbSMichał Mirosław return features; 6118a0427bbSMichał Mirosław } 6128a0427bbSMichał Mirosław 613b3020061SStephen Hemminger static int vlan_ethtool_get_settings(struct net_device *dev, 614b3020061SStephen Hemminger struct ethtool_cmd *cmd) 615b3020061SStephen Hemminger { 6167da82c06SJiri Pirko const struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 6174bc71cb9SJiri Pirko 6184bc71cb9SJiri Pirko return __ethtool_get_settings(vlan->real_dev, cmd); 619b3020061SStephen Hemminger } 620b3020061SStephen Hemminger 621b3020061SStephen Hemminger static void vlan_ethtool_get_drvinfo(struct net_device *dev, 622b3020061SStephen Hemminger struct ethtool_drvinfo *info) 623b3020061SStephen Hemminger { 624b3020061SStephen Hemminger strcpy(info->driver, vlan_fullname); 625b3020061SStephen Hemminger strcpy(info->version, vlan_version); 626b3020061SStephen Hemminger strcpy(info->fw_version, "N/A"); 627b3020061SStephen Hemminger } 628b3020061SStephen Hemminger 62928172739SEric Dumazet static struct rtnl_link_stats64 *vlan_dev_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 6309793241fSEric Dumazet { 6319793241fSEric Dumazet 6327da82c06SJiri Pirko if (vlan_dev_priv(dev)->vlan_pcpu_stats) { 6334af429d2SEric Dumazet struct vlan_pcpu_stats *p; 6344af429d2SEric Dumazet u32 rx_errors = 0, tx_dropped = 0; 6359793241fSEric Dumazet int i; 6369793241fSEric Dumazet 6379793241fSEric Dumazet for_each_possible_cpu(i) { 6384af429d2SEric Dumazet u64 rxpackets, rxbytes, rxmulticast, txpackets, txbytes; 6399618e2ffSEric Dumazet unsigned int start; 6409618e2ffSEric Dumazet 6417da82c06SJiri Pirko p = per_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats, i); 6429618e2ffSEric Dumazet do { 6439618e2ffSEric Dumazet start = u64_stats_fetch_begin_bh(&p->syncp); 6449618e2ffSEric Dumazet rxpackets = p->rx_packets; 6459618e2ffSEric Dumazet rxbytes = p->rx_bytes; 6469618e2ffSEric Dumazet rxmulticast = p->rx_multicast; 6474af429d2SEric Dumazet txpackets = p->tx_packets; 6484af429d2SEric Dumazet txbytes = p->tx_bytes; 6499618e2ffSEric Dumazet } while (u64_stats_fetch_retry_bh(&p->syncp, start)); 6504af429d2SEric Dumazet 6514af429d2SEric Dumazet stats->rx_packets += rxpackets; 6524af429d2SEric Dumazet stats->rx_bytes += rxbytes; 6534af429d2SEric Dumazet stats->multicast += rxmulticast; 6544af429d2SEric Dumazet stats->tx_packets += txpackets; 6554af429d2SEric Dumazet stats->tx_bytes += txbytes; 6564af429d2SEric Dumazet /* rx_errors & tx_dropped are u32 */ 6574af429d2SEric Dumazet rx_errors += p->rx_errors; 6584af429d2SEric Dumazet tx_dropped += p->tx_dropped; 6599793241fSEric Dumazet } 6604af429d2SEric Dumazet stats->rx_errors = rx_errors; 6614af429d2SEric Dumazet stats->tx_dropped = tx_dropped; 6629793241fSEric Dumazet } 6639793241fSEric Dumazet return stats; 6649793241fSEric Dumazet } 6659793241fSEric Dumazet 6666d4cdf47SBenjamin LaHaise #ifdef CONFIG_NET_POLL_CONTROLLER 667de93cb2eSEric Dumazet static void vlan_dev_poll_controller(struct net_device *dev) 6686d4cdf47SBenjamin LaHaise { 6696d4cdf47SBenjamin LaHaise return; 6706d4cdf47SBenjamin LaHaise } 6716d4cdf47SBenjamin LaHaise 67247be03a2SAmerigo Wang static int vlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo, 67347be03a2SAmerigo Wang gfp_t gfp) 6746d4cdf47SBenjamin LaHaise { 6756d4cdf47SBenjamin LaHaise struct vlan_dev_priv *info = vlan_dev_priv(dev); 6766d4cdf47SBenjamin LaHaise struct net_device *real_dev = info->real_dev; 6776d4cdf47SBenjamin LaHaise struct netpoll *netpoll; 6786d4cdf47SBenjamin LaHaise int err = 0; 6796d4cdf47SBenjamin LaHaise 68047be03a2SAmerigo Wang netpoll = kzalloc(sizeof(*netpoll), gfp); 6816d4cdf47SBenjamin LaHaise err = -ENOMEM; 6826d4cdf47SBenjamin LaHaise if (!netpoll) 6836d4cdf47SBenjamin LaHaise goto out; 6846d4cdf47SBenjamin LaHaise 68547be03a2SAmerigo Wang err = __netpoll_setup(netpoll, real_dev, gfp); 6866d4cdf47SBenjamin LaHaise if (err) { 6876d4cdf47SBenjamin LaHaise kfree(netpoll); 6886d4cdf47SBenjamin LaHaise goto out; 6896d4cdf47SBenjamin LaHaise } 6906d4cdf47SBenjamin LaHaise 6916d4cdf47SBenjamin LaHaise info->netpoll = netpoll; 6926d4cdf47SBenjamin LaHaise 6936d4cdf47SBenjamin LaHaise out: 6946d4cdf47SBenjamin LaHaise return err; 6956d4cdf47SBenjamin LaHaise } 6966d4cdf47SBenjamin LaHaise 697de93cb2eSEric Dumazet static void vlan_dev_netpoll_cleanup(struct net_device *dev) 6986d4cdf47SBenjamin LaHaise { 6996d4cdf47SBenjamin LaHaise struct vlan_dev_priv *info = vlan_dev_priv(dev); 7006d4cdf47SBenjamin LaHaise struct netpoll *netpoll = info->netpoll; 7016d4cdf47SBenjamin LaHaise 7026d4cdf47SBenjamin LaHaise if (!netpoll) 7036d4cdf47SBenjamin LaHaise return; 7046d4cdf47SBenjamin LaHaise 7056d4cdf47SBenjamin LaHaise info->netpoll = NULL; 7066d4cdf47SBenjamin LaHaise 7076d4cdf47SBenjamin LaHaise /* Wait for transmitting packets to finish before freeing. */ 7086d4cdf47SBenjamin LaHaise synchronize_rcu_bh(); 7096d4cdf47SBenjamin LaHaise 7106d4cdf47SBenjamin LaHaise __netpoll_cleanup(netpoll); 7116d4cdf47SBenjamin LaHaise kfree(netpoll); 7126d4cdf47SBenjamin LaHaise } 7136d4cdf47SBenjamin LaHaise #endif /* CONFIG_NET_POLL_CONTROLLER */ 7146d4cdf47SBenjamin LaHaise 71575b8846aSPatrick McHardy static const struct ethtool_ops vlan_ethtool_ops = { 716b3020061SStephen Hemminger .get_settings = vlan_ethtool_get_settings, 717b3020061SStephen Hemminger .get_drvinfo = vlan_ethtool_get_drvinfo, 71875b8846aSPatrick McHardy .get_link = ethtool_op_get_link, 71975b8846aSPatrick McHardy }; 72075b8846aSPatrick McHardy 721656299f7SStephen Hemminger static const struct net_device_ops vlan_netdev_ops = { 722656299f7SStephen Hemminger .ndo_change_mtu = vlan_dev_change_mtu, 723656299f7SStephen Hemminger .ndo_init = vlan_dev_init, 724656299f7SStephen Hemminger .ndo_uninit = vlan_dev_uninit, 725656299f7SStephen Hemminger .ndo_open = vlan_dev_open, 726656299f7SStephen Hemminger .ndo_stop = vlan_dev_stop, 727f7d1b9f5SEric Dumazet .ndo_start_xmit = vlan_dev_hard_start_xmit, 728f7d1b9f5SEric Dumazet .ndo_validate_addr = eth_validate_addr, 729f7d1b9f5SEric Dumazet .ndo_set_mac_address = vlan_dev_set_mac_address, 730f7d1b9f5SEric Dumazet .ndo_set_rx_mode = vlan_dev_set_rx_mode, 731f7d1b9f5SEric Dumazet .ndo_change_rx_flags = vlan_dev_change_rx_flags, 732f7d1b9f5SEric Dumazet .ndo_do_ioctl = vlan_dev_ioctl, 733cc883d16SFrank Blaschka .ndo_neigh_setup = vlan_dev_neigh_setup, 7349618e2ffSEric Dumazet .ndo_get_stats64 = vlan_dev_get_stats64, 735b85daa53SVasu Dev #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 736b85daa53SVasu Dev .ndo_fcoe_ddp_setup = vlan_dev_fcoe_ddp_setup, 737b85daa53SVasu Dev .ndo_fcoe_ddp_done = vlan_dev_fcoe_ddp_done, 7380af46d99SYi Zou .ndo_fcoe_enable = vlan_dev_fcoe_enable, 7390af46d99SYi Zou .ndo_fcoe_disable = vlan_dev_fcoe_disable, 740d6534799SYi Zou .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn, 7414ea09c9cSYi Zou .ndo_fcoe_ddp_target = vlan_dev_fcoe_ddp_target, 742b85daa53SVasu Dev #endif 7436d4cdf47SBenjamin LaHaise #ifdef CONFIG_NET_POLL_CONTROLLER 7446d4cdf47SBenjamin LaHaise .ndo_poll_controller = vlan_dev_poll_controller, 7456d4cdf47SBenjamin LaHaise .ndo_netpoll_setup = vlan_dev_netpoll_setup, 7466d4cdf47SBenjamin LaHaise .ndo_netpoll_cleanup = vlan_dev_netpoll_cleanup, 7476d4cdf47SBenjamin LaHaise #endif 7488a0427bbSMichał Mirosław .ndo_fix_features = vlan_dev_fix_features, 749f7d1b9f5SEric Dumazet }; 750f7d1b9f5SEric Dumazet 751ef3eb3e5SPatrick McHardy void vlan_setup(struct net_device *dev) 752ef3eb3e5SPatrick McHardy { 753ef3eb3e5SPatrick McHardy ether_setup(dev); 754ef3eb3e5SPatrick McHardy 755ef3eb3e5SPatrick McHardy dev->priv_flags |= IFF_802_1Q_VLAN; 756550fd08cSNeil Horman dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING); 757ef3eb3e5SPatrick McHardy dev->tx_queue_len = 0; 758ef3eb3e5SPatrick McHardy 759656299f7SStephen Hemminger dev->netdev_ops = &vlan_netdev_ops; 760ef3eb3e5SPatrick McHardy dev->destructor = free_netdev; 76175b8846aSPatrick McHardy dev->ethtool_ops = &vlan_ethtool_ops; 762ef3eb3e5SPatrick McHardy 763ef3eb3e5SPatrick McHardy memset(dev->broadcast, 0, ETH_ALEN); 764ef3eb3e5SPatrick McHardy } 765