3 * Ethernet-type device handling.
5 * Authors: Ben Greear <greearb@candelatech.com>
6 * Please send support related email to: vlan@scry.wanfear.com
7 * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
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.
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.
23 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <asm/uaccess.h> /* for copy_from_user */
28 #include <linux/skbuff.h>
29 #include <linux/netdevice.h>
30 #include <linux/etherdevice.h>
31 #include <net/datalink.h>
32 #include <net/p8022.h>
37 #include <linux/if_vlan.h>
41 * Rebuild the Ethernet MAC header. This is called after an ARP
42 * (or in future other address resolution) has completed on this
43 * sk_buff. We now let ARP fill in the other fields.
45 * This routine CANNOT use cached dst->neigh!
46 * Really, it is used only when dst->neigh is wrong.
48 * TODO: This needs a checkup, I'm ignorant here. --BLG
50 static int vlan_dev_rebuild_header(struct sk_buff
*skb
)
52 struct net_device
*dev
= skb
->dev
;
53 struct vlan_ethhdr
*veth
= (struct vlan_ethhdr
*)(skb
->data
);
55 switch (veth
->h_vlan_encapsulated_proto
) {
57 case __constant_htons(ETH_P_IP
):
59 /* TODO: Confirm this will work with VLAN headers... */
60 return arp_find(veth
->h_dest
, skb
);
64 "%s: unable to resolve type %X addresses.\n",
65 dev
->name
, ntohs(veth
->h_vlan_encapsulated_proto
));
67 memcpy(veth
->h_source
, dev
->dev_addr
, ETH_ALEN
);
74 static inline struct sk_buff
*vlan_check_reorder_header(struct sk_buff
*skb
)
76 if (VLAN_DEV_INFO(skb
->dev
)->flags
& VLAN_FLAG_REORDER_HDR
) {
77 if (skb_shared(skb
) || skb_cloned(skb
)) {
78 struct sk_buff
*nskb
= skb_copy(skb
, GFP_ATOMIC
);
83 /* Lifted from Gleb's VLAN code... */
84 memmove(skb
->data
- ETH_HLEN
,
85 skb
->data
- VLAN_ETH_HLEN
, 12);
86 skb
->mac_header
+= VLAN_HLEN
;
94 * Determine the packet's protocol ID. The rule here is that we
95 * assume 802.3 if the type field is short enough to be a length.
96 * This is normal practice and works for any 'now in use' protocol.
98 * Also, at this point we assume that we ARE dealing exclusively with
99 * VLAN packets, or packets that should be made into VLAN packets based
100 * on a default VLAN ID.
102 * NOTE: Should be similar to ethernet/eth.c.
104 * SANITY NOTE: This method is called when a packet is moving up the stack
105 * towards userland. To get here, it would have already passed
106 * through the ethernet/eth.c eth_type_trans() method.
107 * SANITY NOTE 2: We are referencing to the VLAN_HDR frields, which MAY be
108 * stored UNALIGNED in the memory. RISC systems don't like
109 * such cases very much...
110 * SANITY NOTE 2a: According to Dave Miller & Alexey, it will always be aligned,
111 * so there doesn't need to be any of the unaligned stuff. It has
112 * been commented out now... --Ben
115 int vlan_skb_recv(struct sk_buff
*skb
, struct net_device
*dev
,
116 struct packet_type
* ptype
, struct net_device
*orig_dev
)
118 unsigned char *rawp
= NULL
;
119 struct vlan_hdr
*vhdr
;
121 struct net_device_stats
*stats
;
122 unsigned short vlan_TCI
;
125 if (dev
->nd_net
!= &init_net
) {
130 if ((skb
= skb_share_check(skb
, GFP_ATOMIC
)) == NULL
)
133 if (unlikely(!pskb_may_pull(skb
, VLAN_HLEN
))) {
138 vhdr
= (struct vlan_hdr
*)(skb
->data
);
140 /* vlan_TCI = ntohs(get_unaligned(&vhdr->h_vlan_TCI)); */
141 vlan_TCI
= ntohs(vhdr
->h_vlan_TCI
);
143 vid
= (vlan_TCI
& VLAN_VID_MASK
);
146 printk(VLAN_DBG
"%s: skb: %p vlan_id: %hx\n",
147 __FUNCTION__
, skb
, vid
);
150 /* Ok, we will find the correct VLAN device, strip the header,
151 * and then go on as usual.
154 /* We have 12 bits of vlan ID.
156 * We must not drop allow preempt until we hold a
157 * reference to the device (netif_rx does that) or we
162 skb
->dev
= __find_vlan_dev(dev
, vid
);
167 printk(VLAN_DBG
"%s: ERROR: No net_device for VID: %i on dev: %s [%i]\n",
168 __FUNCTION__
, (unsigned int)(vid
), dev
->name
, dev
->ifindex
);
174 skb
->dev
->last_rx
= jiffies
;
176 /* Bump the rx counters for the VLAN device. */
177 stats
= &skb
->dev
->stats
;
179 stats
->rx_bytes
+= skb
->len
;
181 /* Take off the VLAN header (4 bytes currently) */
182 skb_pull_rcsum(skb
, VLAN_HLEN
);
184 /* Ok, lets check to make sure the device (dev) we
185 * came in on is what this VLAN is attached to.
188 if (dev
!= VLAN_DEV_INFO(skb
->dev
)->real_dev
) {
192 printk(VLAN_DBG
"%s: dropping skb: %p because came in on wrong device, dev: %s real_dev: %s, skb_dev: %s\n",
193 __FUNCTION__
, skb
, dev
->name
,
194 VLAN_DEV_INFO(skb
->dev
)->real_dev
->name
,
203 * Deal with ingress priority mapping.
205 skb
->priority
= vlan_get_ingress_priority(skb
->dev
, ntohs(vhdr
->h_vlan_TCI
));
208 printk(VLAN_DBG
"%s: priority: %lu for TCI: %hu (hbo)\n",
209 __FUNCTION__
, (unsigned long)(skb
->priority
),
210 ntohs(vhdr
->h_vlan_TCI
));
213 /* The ethernet driver already did the pkt_type calculations
216 switch (skb
->pkt_type
) {
217 case PACKET_BROADCAST
: /* Yeah, stats collect these together.. */
218 // stats->broadcast ++; // no such counter :-(
221 case PACKET_MULTICAST
:
225 case PACKET_OTHERHOST
:
226 /* Our lower layer thinks this is not local, let's make sure.
227 * This allows the VLAN to have a different MAC than the underlying
228 * device, and still route correctly.
230 if (!compare_ether_addr(eth_hdr(skb
)->h_dest
, skb
->dev
->dev_addr
)) {
231 /* It is for our (changed) MAC-address! */
232 skb
->pkt_type
= PACKET_HOST
;
239 /* Was a VLAN packet, grab the encapsulated protocol, which the layer
240 * three protocols care about.
242 /* proto = get_unaligned(&vhdr->h_vlan_encapsulated_proto); */
243 proto
= vhdr
->h_vlan_encapsulated_proto
;
245 skb
->protocol
= proto
;
246 if (ntohs(proto
) >= 1536) {
247 /* place it back on the queue to be handled by
248 * true layer 3 protocols.
251 /* See if we are configured to re-write the VLAN header
252 * to make it look like ethernet...
254 skb
= vlan_check_reorder_header(skb
);
256 /* Can be null if skb-clone fails when re-ordering */
260 /* TODO: Add a more specific counter here. */
270 * This is a magic hack to spot IPX packets. Older Novell breaks
271 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
272 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
273 * won't work for fault tolerant netware but does for the rest.
275 if (*(unsigned short *)rawp
== 0xFFFF) {
276 skb
->protocol
= htons(ETH_P_802_3
);
277 /* place it back on the queue to be handled by true layer 3 protocols.
280 /* See if we are configured to re-write the VLAN header
281 * to make it look like ethernet...
283 skb
= vlan_check_reorder_header(skb
);
285 /* Can be null if skb-clone fails when re-ordering */
289 /* TODO: Add a more specific counter here. */
299 skb
->protocol
= htons(ETH_P_802_2
);
300 /* place it back on the queue to be handled by upper layer protocols.
303 /* See if we are configured to re-write the VLAN header
304 * to make it look like ethernet...
306 skb
= vlan_check_reorder_header(skb
);
308 /* Can be null if skb-clone fails when re-ordering */
312 /* TODO: Add a more specific counter here. */
319 static inline unsigned short vlan_dev_get_egress_qos_mask(struct net_device
* dev
,
322 struct vlan_priority_tci_mapping
*mp
=
323 VLAN_DEV_INFO(dev
)->egress_priority_map
[(skb
->priority
& 0xF)];
326 if (mp
->priority
== skb
->priority
) {
327 return mp
->vlan_qos
; /* This should already be shifted to mask
328 * correctly with the VLAN's TCI
337 * Create the VLAN header for an arbitrary protocol layer
339 * saddr=NULL means use device source address
340 * daddr=NULL means leave destination address (eg unresolved arp)
342 * This is called when the SKB is moving down the stack towards the
345 static int vlan_dev_hard_header(struct sk_buff
*skb
, struct net_device
*dev
,
347 const void *daddr
, const void *saddr
,
350 struct vlan_hdr
*vhdr
;
351 unsigned short veth_TCI
= 0;
353 int build_vlan_header
= 0;
354 struct net_device
*vdev
= dev
; /* save this for the bottom of the method */
357 printk(VLAN_DBG
"%s: skb: %p type: %hx len: %x vlan_id: %hx, daddr: %p\n",
358 __FUNCTION__
, skb
, type
, len
, VLAN_DEV_INFO(dev
)->vlan_id
, daddr
);
361 /* build vlan header only if re_order_header flag is NOT set. This
362 * fixes some programs that get confused when they see a VLAN device
363 * sending a frame that is VLAN encoded (the consensus is that the VLAN
364 * device should look completely like an Ethernet device when the
365 * REORDER_HEADER flag is set) The drawback to this is some extra
366 * header shuffling in the hard_start_xmit. Users can turn off this
367 * REORDER behaviour with the vconfig tool.
369 if (!(VLAN_DEV_INFO(dev
)->flags
& VLAN_FLAG_REORDER_HDR
))
370 build_vlan_header
= 1;
372 if (build_vlan_header
) {
373 vhdr
= (struct vlan_hdr
*) skb_push(skb
, VLAN_HLEN
);
375 /* build the four bytes that make this a VLAN header. */
377 /* Now, construct the second two bytes. This field looks something
379 * usr_priority: 3 bits (high bits)
381 * VLAN ID 12 bits (low bits)
384 veth_TCI
= VLAN_DEV_INFO(dev
)->vlan_id
;
385 veth_TCI
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
387 vhdr
->h_vlan_TCI
= htons(veth_TCI
);
390 * Set the protocol type.
391 * For a packet of type ETH_P_802_3 we put the length in here instead.
392 * It is up to the 802.2 layer to carry protocol information.
395 if (type
!= ETH_P_802_3
) {
396 vhdr
->h_vlan_encapsulated_proto
= htons(type
);
398 vhdr
->h_vlan_encapsulated_proto
= htons(len
);
401 skb
->protocol
= htons(ETH_P_8021Q
);
402 skb_reset_network_header(skb
);
405 /* Before delegating work to the lower layer, enter our MAC-address */
407 saddr
= dev
->dev_addr
;
409 dev
= VLAN_DEV_INFO(dev
)->real_dev
;
411 /* MPLS can send us skbuffs w/out enough space. This check will grow the
412 * skb if it doesn't have enough headroom. Not a beautiful solution, so
413 * I'll tick a counter so that users can know it's happening... If they
417 /* NOTE: This may still break if the underlying device is not the final
418 * device (and thus there are more headers to add...) It should work for
419 * good-ole-ethernet though.
421 if (skb_headroom(skb
) < dev
->hard_header_len
) {
422 struct sk_buff
*sk_tmp
= skb
;
423 skb
= skb_realloc_headroom(sk_tmp
, dev
->hard_header_len
);
426 struct net_device_stats
*stats
= &vdev
->stats
;
430 VLAN_DEV_INFO(vdev
)->cnt_inc_headroom_on_tx
++;
432 printk(VLAN_DBG
"%s: %s: had to grow skb.\n", __FUNCTION__
, vdev
->name
);
436 if (build_vlan_header
) {
437 /* Now make the underlying real hard header */
438 rc
= dev_hard_header(skb
, dev
, ETH_P_8021Q
, daddr
, saddr
,
445 /* If here, then we'll just make a normal looking ethernet frame,
446 * but, the hard_start_xmit method will insert the tag (it has to
447 * be able to do this for bridged and other skbs that don't come
448 * down the protocol stack in an orderly manner.
450 rc
= dev_hard_header(skb
, dev
, type
, daddr
, saddr
, len
);
455 static int vlan_dev_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
457 struct net_device_stats
*stats
= &dev
->stats
;
458 struct vlan_ethhdr
*veth
= (struct vlan_ethhdr
*)(skb
->data
);
460 /* Handle non-VLAN frames if they are sent to us, for example by DHCP.
462 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING
463 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...
466 if (veth
->h_vlan_proto
!= htons(ETH_P_8021Q
) ||
467 VLAN_DEV_INFO(dev
)->flags
& VLAN_FLAG_REORDER_HDR
) {
468 int orig_headroom
= skb_headroom(skb
);
469 unsigned short veth_TCI
;
471 /* This is not a VLAN frame...but we can fix that! */
472 VLAN_DEV_INFO(dev
)->cnt_encap_on_xmit
++;
475 printk(VLAN_DBG
"%s: proto to encap: 0x%hx (hbo)\n",
476 __FUNCTION__
, htons(veth
->h_vlan_proto
));
478 /* Construct the second two bytes. This field looks something
480 * usr_priority: 3 bits (high bits)
482 * VLAN ID 12 bits (low bits)
484 veth_TCI
= VLAN_DEV_INFO(dev
)->vlan_id
;
485 veth_TCI
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
487 skb
= __vlan_put_tag(skb
, veth_TCI
);
493 if (orig_headroom
< VLAN_HLEN
) {
494 VLAN_DEV_INFO(dev
)->cnt_inc_headroom_on_tx
++;
499 printk(VLAN_DBG
"%s: about to send skb: %p to dev: %s\n",
500 __FUNCTION__
, skb
, skb
->dev
->name
);
501 printk(VLAN_DBG
" %2hx.%2hx.%2hx.%2xh.%2hx.%2hx %2hx.%2hx.%2hx.%2hx.%2hx.%2hx %4hx %4hx %4hx\n",
502 veth
->h_dest
[0], veth
->h_dest
[1], veth
->h_dest
[2], veth
->h_dest
[3], veth
->h_dest
[4], veth
->h_dest
[5],
503 veth
->h_source
[0], veth
->h_source
[1], veth
->h_source
[2], veth
->h_source
[3], veth
->h_source
[4], veth
->h_source
[5],
504 veth
->h_vlan_proto
, veth
->h_vlan_TCI
, veth
->h_vlan_encapsulated_proto
);
507 stats
->tx_packets
++; /* for statics only */
508 stats
->tx_bytes
+= skb
->len
;
510 skb
->dev
= VLAN_DEV_INFO(dev
)->real_dev
;
516 static int vlan_dev_hwaccel_hard_start_xmit(struct sk_buff
*skb
,
517 struct net_device
*dev
)
519 struct net_device_stats
*stats
= &dev
->stats
;
520 unsigned short veth_TCI
;
522 /* Construct the second two bytes. This field looks something
524 * usr_priority: 3 bits (high bits)
526 * VLAN ID 12 bits (low bits)
528 veth_TCI
= VLAN_DEV_INFO(dev
)->vlan_id
;
529 veth_TCI
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
530 skb
= __vlan_hwaccel_put_tag(skb
, veth_TCI
);
533 stats
->tx_bytes
+= skb
->len
;
535 skb
->dev
= VLAN_DEV_INFO(dev
)->real_dev
;
541 static int vlan_dev_change_mtu(struct net_device
*dev
, int new_mtu
)
543 /* TODO: gotta make sure the underlying layer can handle it,
544 * maybe an IFF_VLAN_CAPABLE flag for devices?
546 if (VLAN_DEV_INFO(dev
)->real_dev
->mtu
< new_mtu
)
554 void vlan_dev_set_ingress_priority(const struct net_device
*dev
,
555 u32 skb_prio
, short vlan_prio
)
557 struct vlan_dev_info
*vlan
= VLAN_DEV_INFO(dev
);
559 if (vlan
->ingress_priority_map
[vlan_prio
& 0x7] && !skb_prio
)
560 vlan
->nr_ingress_mappings
--;
561 else if (!vlan
->ingress_priority_map
[vlan_prio
& 0x7] && skb_prio
)
562 vlan
->nr_ingress_mappings
++;
564 vlan
->ingress_priority_map
[vlan_prio
& 0x7] = skb_prio
;
567 int vlan_dev_set_egress_priority(const struct net_device
*dev
,
568 u32 skb_prio
, short vlan_prio
)
570 struct vlan_dev_info
*vlan
= VLAN_DEV_INFO(dev
);
571 struct vlan_priority_tci_mapping
*mp
= NULL
;
572 struct vlan_priority_tci_mapping
*np
;
573 u32 vlan_qos
= (vlan_prio
<< 13) & 0xE000;
575 /* See if a priority mapping exists.. */
576 mp
= vlan
->egress_priority_map
[skb_prio
& 0xF];
578 if (mp
->priority
== skb_prio
) {
579 if (mp
->vlan_qos
&& !vlan_qos
)
580 vlan
->nr_egress_mappings
--;
581 else if (!mp
->vlan_qos
&& vlan_qos
)
582 vlan
->nr_egress_mappings
++;
583 mp
->vlan_qos
= vlan_qos
;
589 /* Create a new mapping then. */
590 mp
= vlan
->egress_priority_map
[skb_prio
& 0xF];
591 np
= kmalloc(sizeof(struct vlan_priority_tci_mapping
), GFP_KERNEL
);
596 np
->priority
= skb_prio
;
597 np
->vlan_qos
= vlan_qos
;
598 vlan
->egress_priority_map
[skb_prio
& 0xF] = np
;
600 vlan
->nr_egress_mappings
++;
604 /* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */
605 int vlan_dev_set_vlan_flag(const struct net_device
*dev
,
606 u32 flag
, short flag_val
)
608 /* verify flag is supported */
609 if (flag
== VLAN_FLAG_REORDER_HDR
) {
611 VLAN_DEV_INFO(dev
)->flags
|= VLAN_FLAG_REORDER_HDR
;
613 VLAN_DEV_INFO(dev
)->flags
&= ~VLAN_FLAG_REORDER_HDR
;
617 printk(KERN_ERR
"%s: flag %i is not valid.\n", __FUNCTION__
, flag
);
621 void vlan_dev_get_realdev_name(const struct net_device
*dev
, char *result
)
623 strncpy(result
, VLAN_DEV_INFO(dev
)->real_dev
->name
, 23);
626 void vlan_dev_get_vid(const struct net_device
*dev
, unsigned short *result
)
628 *result
= VLAN_DEV_INFO(dev
)->vlan_id
;
631 static int vlan_dev_open(struct net_device
*dev
)
633 struct vlan_dev_info
*vlan
= VLAN_DEV_INFO(dev
);
634 struct net_device
*real_dev
= vlan
->real_dev
;
637 if (!(real_dev
->flags
& IFF_UP
))
640 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
)) {
641 err
= dev_unicast_add(real_dev
, dev
->dev_addr
, ETH_ALEN
);
645 memcpy(vlan
->real_dev_addr
, real_dev
->dev_addr
, ETH_ALEN
);
647 if (dev
->flags
& IFF_ALLMULTI
)
648 dev_set_allmulti(real_dev
, 1);
649 if (dev
->flags
& IFF_PROMISC
)
650 dev_set_promiscuity(real_dev
, 1);
655 static int vlan_dev_stop(struct net_device
*dev
)
657 struct net_device
*real_dev
= VLAN_DEV_INFO(dev
)->real_dev
;
659 dev_mc_unsync(real_dev
, dev
);
660 if (dev
->flags
& IFF_ALLMULTI
)
661 dev_set_allmulti(real_dev
, -1);
662 if (dev
->flags
& IFF_PROMISC
)
663 dev_set_promiscuity(real_dev
, -1);
665 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
))
666 dev_unicast_delete(real_dev
, dev
->dev_addr
, dev
->addr_len
);
671 static int vlan_dev_set_mac_address(struct net_device
*dev
, void *p
)
673 struct net_device
*real_dev
= VLAN_DEV_INFO(dev
)->real_dev
;
674 struct sockaddr
*addr
= p
;
677 if (!is_valid_ether_addr(addr
->sa_data
))
678 return -EADDRNOTAVAIL
;
680 if (!(dev
->flags
& IFF_UP
))
683 if (compare_ether_addr(addr
->sa_data
, real_dev
->dev_addr
)) {
684 err
= dev_unicast_add(real_dev
, addr
->sa_data
, ETH_ALEN
);
689 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
))
690 dev_unicast_delete(real_dev
, dev
->dev_addr
, ETH_ALEN
);
693 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
697 static int vlan_dev_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
699 struct net_device
*real_dev
= VLAN_DEV_INFO(dev
)->real_dev
;
701 int err
= -EOPNOTSUPP
;
703 strncpy(ifrr
.ifr_name
, real_dev
->name
, IFNAMSIZ
);
704 ifrr
.ifr_ifru
= ifr
->ifr_ifru
;
710 if (real_dev
->do_ioctl
&& netif_device_present(real_dev
))
711 err
= real_dev
->do_ioctl(real_dev
, &ifrr
, cmd
);
716 ifr
->ifr_ifru
= ifrr
.ifr_ifru
;
721 static void vlan_dev_change_rx_flags(struct net_device
*dev
, int change
)
723 struct net_device
*real_dev
= VLAN_DEV_INFO(dev
)->real_dev
;
725 if (change
& IFF_ALLMULTI
)
726 dev_set_allmulti(real_dev
, dev
->flags
& IFF_ALLMULTI
? 1 : -1);
727 if (change
& IFF_PROMISC
)
728 dev_set_promiscuity(real_dev
, dev
->flags
& IFF_PROMISC
? 1 : -1);
731 static void vlan_dev_set_multicast_list(struct net_device
*vlan_dev
)
733 dev_mc_sync(VLAN_DEV_INFO(vlan_dev
)->real_dev
, vlan_dev
);
737 * vlan network devices have devices nesting below it, and are a special
738 * "super class" of normal network devices; split their locks off into a
739 * separate class since they always nest.
741 static struct lock_class_key vlan_netdev_xmit_lock_key
;
743 static const struct header_ops vlan_header_ops
= {
744 .create
= vlan_dev_hard_header
,
745 .rebuild
= vlan_dev_rebuild_header
,
746 .parse
= eth_header_parse
,
749 static int vlan_dev_init(struct net_device
*dev
)
751 struct net_device
*real_dev
= VLAN_DEV_INFO(dev
)->real_dev
;
754 /* IFF_BROADCAST|IFF_MULTICAST; ??? */
755 dev
->flags
= real_dev
->flags
& ~IFF_UP
;
756 dev
->iflink
= real_dev
->ifindex
;
757 dev
->state
= (real_dev
->state
& ((1<<__LINK_STATE_NOCARRIER
) |
758 (1<<__LINK_STATE_DORMANT
))) |
759 (1<<__LINK_STATE_PRESENT
);
761 /* ipv6 shared card related stuff */
762 dev
->dev_id
= real_dev
->dev_id
;
764 if (is_zero_ether_addr(dev
->dev_addr
))
765 memcpy(dev
->dev_addr
, real_dev
->dev_addr
, dev
->addr_len
);
766 if (is_zero_ether_addr(dev
->broadcast
))
767 memcpy(dev
->broadcast
, real_dev
->broadcast
, dev
->addr_len
);
769 if (real_dev
->features
& NETIF_F_HW_VLAN_TX
) {
770 dev
->header_ops
= real_dev
->header_ops
;
771 dev
->hard_header_len
= real_dev
->hard_header_len
;
772 dev
->hard_start_xmit
= vlan_dev_hwaccel_hard_start_xmit
;
774 dev
->header_ops
= &vlan_header_ops
;
775 dev
->hard_header_len
= real_dev
->hard_header_len
+ VLAN_HLEN
;
776 dev
->hard_start_xmit
= vlan_dev_hard_start_xmit
;
779 if (real_dev
->priv_flags
& IFF_802_1Q_VLAN
)
782 lockdep_set_class_and_subclass(&dev
->_xmit_lock
,
783 &vlan_netdev_xmit_lock_key
, subclass
);
787 void vlan_setup(struct net_device
*dev
)
791 dev
->priv_flags
|= IFF_802_1Q_VLAN
;
792 dev
->tx_queue_len
= 0;
794 dev
->change_mtu
= vlan_dev_change_mtu
;
795 dev
->init
= vlan_dev_init
;
796 dev
->open
= vlan_dev_open
;
797 dev
->stop
= vlan_dev_stop
;
798 dev
->set_mac_address
= vlan_dev_set_mac_address
;
799 dev
->set_multicast_list
= vlan_dev_set_multicast_list
;
800 dev
->change_rx_flags
= vlan_dev_change_rx_flags
;
801 dev
->do_ioctl
= vlan_dev_ioctl
;
802 dev
->destructor
= free_netdev
;
804 memset(dev
->broadcast
, 0, ETH_ALEN
);