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 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
= (struct vlan_hdr
*)(skb
->data
);
121 struct net_device_stats
*stats
;
122 unsigned short vlan_TCI
;
125 /* vlan_TCI = ntohs(get_unaligned(&vhdr->h_vlan_TCI)); */
126 vlan_TCI
= ntohs(vhdr
->h_vlan_TCI
);
128 vid
= (vlan_TCI
& VLAN_VID_MASK
);
131 printk(VLAN_DBG
"%s: skb: %p vlan_id: %hx\n",
132 __FUNCTION__
, skb
, vid
);
135 /* Ok, we will find the correct VLAN device, strip the header,
136 * and then go on as usual.
139 /* We have 12 bits of vlan ID.
141 * We must not drop allow preempt until we hold a
142 * reference to the device (netif_rx does that) or we
147 skb
->dev
= __find_vlan_dev(dev
, vid
);
152 printk(VLAN_DBG
"%s: ERROR: No net_device for VID: %i on dev: %s [%i]\n",
153 __FUNCTION__
, (unsigned int)(vid
), dev
->name
, dev
->ifindex
);
159 skb
->dev
->last_rx
= jiffies
;
161 /* Bump the rx counters for the VLAN device. */
162 stats
= vlan_dev_get_stats(skb
->dev
);
164 stats
->rx_bytes
+= skb
->len
;
166 /* Take off the VLAN header (4 bytes currently) */
167 skb_pull_rcsum(skb
, VLAN_HLEN
);
169 /* Ok, lets check to make sure the device (dev) we
170 * came in on is what this VLAN is attached to.
173 if (dev
!= VLAN_DEV_INFO(skb
->dev
)->real_dev
) {
177 printk(VLAN_DBG
"%s: dropping skb: %p because came in on wrong device, dev: %s real_dev: %s, skb_dev: %s\n",
178 __FUNCTION__
, skb
, dev
->name
,
179 VLAN_DEV_INFO(skb
->dev
)->real_dev
->name
,
188 * Deal with ingress priority mapping.
190 skb
->priority
= vlan_get_ingress_priority(skb
->dev
, ntohs(vhdr
->h_vlan_TCI
));
193 printk(VLAN_DBG
"%s: priority: %lu for TCI: %hu (hbo)\n",
194 __FUNCTION__
, (unsigned long)(skb
->priority
),
195 ntohs(vhdr
->h_vlan_TCI
));
198 /* The ethernet driver already did the pkt_type calculations
201 switch (skb
->pkt_type
) {
202 case PACKET_BROADCAST
: /* Yeah, stats collect these together.. */
203 // stats->broadcast ++; // no such counter :-(
206 case PACKET_MULTICAST
:
210 case PACKET_OTHERHOST
:
211 /* Our lower layer thinks this is not local, let's make sure.
212 * This allows the VLAN to have a different MAC than the underlying
213 * device, and still route correctly.
215 if (!compare_ether_addr(eth_hdr(skb
)->h_dest
, skb
->dev
->dev_addr
)) {
216 /* It is for our (changed) MAC-address! */
217 skb
->pkt_type
= PACKET_HOST
;
224 /* Was a VLAN packet, grab the encapsulated protocol, which the layer
225 * three protocols care about.
227 /* proto = get_unaligned(&vhdr->h_vlan_encapsulated_proto); */
228 proto
= vhdr
->h_vlan_encapsulated_proto
;
230 skb
->protocol
= proto
;
231 if (ntohs(proto
) >= 1536) {
232 /* place it back on the queue to be handled by
233 * true layer 3 protocols.
236 /* See if we are configured to re-write the VLAN header
237 * to make it look like ethernet...
239 skb
= vlan_check_reorder_header(skb
);
241 /* Can be null if skb-clone fails when re-ordering */
245 /* TODO: Add a more specific counter here. */
255 * This is a magic hack to spot IPX packets. Older Novell breaks
256 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
257 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
258 * won't work for fault tolerant netware but does for the rest.
260 if (*(unsigned short *)rawp
== 0xFFFF) {
261 skb
->protocol
= htons(ETH_P_802_3
);
262 /* place it back on the queue to be handled by true layer 3 protocols.
265 /* See if we are configured to re-write the VLAN header
266 * to make it look like ethernet...
268 skb
= vlan_check_reorder_header(skb
);
270 /* Can be null if skb-clone fails when re-ordering */
274 /* TODO: Add a more specific counter here. */
284 skb
->protocol
= htons(ETH_P_802_2
);
285 /* place it back on the queue to be handled by upper layer protocols.
288 /* See if we are configured to re-write the VLAN header
289 * to make it look like ethernet...
291 skb
= vlan_check_reorder_header(skb
);
293 /* Can be null if skb-clone fails when re-ordering */
297 /* TODO: Add a more specific counter here. */
304 static inline unsigned short vlan_dev_get_egress_qos_mask(struct net_device
* dev
,
307 struct vlan_priority_tci_mapping
*mp
=
308 VLAN_DEV_INFO(dev
)->egress_priority_map
[(skb
->priority
& 0xF)];
311 if (mp
->priority
== skb
->priority
) {
312 return mp
->vlan_qos
; /* This should already be shifted to mask
313 * correctly with the VLAN's TCI
322 * Create the VLAN header for an arbitrary protocol layer
324 * saddr=NULL means use device source address
325 * daddr=NULL means leave destination address (eg unresolved arp)
327 * This is called when the SKB is moving down the stack towards the
330 int vlan_dev_hard_header(struct sk_buff
*skb
, struct net_device
*dev
,
331 unsigned short type
, void *daddr
, void *saddr
,
334 struct vlan_hdr
*vhdr
;
335 unsigned short veth_TCI
= 0;
337 int build_vlan_header
= 0;
338 struct net_device
*vdev
= dev
; /* save this for the bottom of the method */
341 printk(VLAN_DBG
"%s: skb: %p type: %hx len: %x vlan_id: %hx, daddr: %p\n",
342 __FUNCTION__
, skb
, type
, len
, VLAN_DEV_INFO(dev
)->vlan_id
, daddr
);
345 /* build vlan header only if re_order_header flag is NOT set. This
346 * fixes some programs that get confused when they see a VLAN device
347 * sending a frame that is VLAN encoded (the consensus is that the VLAN
348 * device should look completely like an Ethernet device when the
349 * REORDER_HEADER flag is set) The drawback to this is some extra
350 * header shuffling in the hard_start_xmit. Users can turn off this
351 * REORDER behaviour with the vconfig tool.
353 if (!(VLAN_DEV_INFO(dev
)->flags
& VLAN_FLAG_REORDER_HDR
))
354 build_vlan_header
= 1;
356 if (build_vlan_header
) {
357 vhdr
= (struct vlan_hdr
*) skb_push(skb
, VLAN_HLEN
);
359 /* build the four bytes that make this a VLAN header. */
361 /* Now, construct the second two bytes. This field looks something
363 * usr_priority: 3 bits (high bits)
365 * VLAN ID 12 bits (low bits)
368 veth_TCI
= VLAN_DEV_INFO(dev
)->vlan_id
;
369 veth_TCI
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
371 vhdr
->h_vlan_TCI
= htons(veth_TCI
);
374 * Set the protocol type.
375 * For a packet of type ETH_P_802_3 we put the length in here instead.
376 * It is up to the 802.2 layer to carry protocol information.
379 if (type
!= ETH_P_802_3
) {
380 vhdr
->h_vlan_encapsulated_proto
= htons(type
);
382 vhdr
->h_vlan_encapsulated_proto
= htons(len
);
385 skb
->protocol
= htons(ETH_P_8021Q
);
386 skb_reset_network_header(skb
);
389 /* Before delegating work to the lower layer, enter our MAC-address */
391 saddr
= dev
->dev_addr
;
393 dev
= VLAN_DEV_INFO(dev
)->real_dev
;
395 /* MPLS can send us skbuffs w/out enough space. This check will grow the
396 * skb if it doesn't have enough headroom. Not a beautiful solution, so
397 * I'll tick a counter so that users can know it's happening... If they
401 /* NOTE: This may still break if the underlying device is not the final
402 * device (and thus there are more headers to add...) It should work for
403 * good-ole-ethernet though.
405 if (skb_headroom(skb
) < dev
->hard_header_len
) {
406 struct sk_buff
*sk_tmp
= skb
;
407 skb
= skb_realloc_headroom(sk_tmp
, dev
->hard_header_len
);
410 struct net_device_stats
*stats
= vlan_dev_get_stats(vdev
);
414 VLAN_DEV_INFO(vdev
)->cnt_inc_headroom_on_tx
++;
416 printk(VLAN_DBG
"%s: %s: had to grow skb.\n", __FUNCTION__
, vdev
->name
);
420 if (build_vlan_header
) {
421 /* Now make the underlying real hard header */
422 rc
= dev
->hard_header(skb
, dev
, ETH_P_8021Q
, daddr
, saddr
, len
+ VLAN_HLEN
);
430 /* If here, then we'll just make a normal looking ethernet frame,
431 * but, the hard_start_xmit method will insert the tag (it has to
432 * be able to do this for bridged and other skbs that don't come
433 * down the protocol stack in an orderly manner.
435 rc
= dev
->hard_header(skb
, dev
, type
, daddr
, saddr
, len
);
441 int vlan_dev_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
443 struct net_device_stats
*stats
= vlan_dev_get_stats(dev
);
444 struct vlan_ethhdr
*veth
= (struct vlan_ethhdr
*)(skb
->data
);
446 /* Handle non-VLAN frames if they are sent to us, for example by DHCP.
448 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING
449 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...
452 if (veth
->h_vlan_proto
!= htons(ETH_P_8021Q
)) {
453 int orig_headroom
= skb_headroom(skb
);
454 unsigned short veth_TCI
;
456 /* This is not a VLAN frame...but we can fix that! */
457 VLAN_DEV_INFO(dev
)->cnt_encap_on_xmit
++;
460 printk(VLAN_DBG
"%s: proto to encap: 0x%hx (hbo)\n",
461 __FUNCTION__
, htons(veth
->h_vlan_proto
));
463 /* Construct the second two bytes. This field looks something
465 * usr_priority: 3 bits (high bits)
467 * VLAN ID 12 bits (low bits)
469 veth_TCI
= VLAN_DEV_INFO(dev
)->vlan_id
;
470 veth_TCI
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
472 skb
= __vlan_put_tag(skb
, veth_TCI
);
478 if (orig_headroom
< VLAN_HLEN
) {
479 VLAN_DEV_INFO(dev
)->cnt_inc_headroom_on_tx
++;
484 printk(VLAN_DBG
"%s: about to send skb: %p to dev: %s\n",
485 __FUNCTION__
, skb
, skb
->dev
->name
);
486 printk(VLAN_DBG
" %2hx.%2hx.%2hx.%2xh.%2hx.%2hx %2hx.%2hx.%2hx.%2hx.%2hx.%2hx %4hx %4hx %4hx\n",
487 veth
->h_dest
[0], veth
->h_dest
[1], veth
->h_dest
[2], veth
->h_dest
[3], veth
->h_dest
[4], veth
->h_dest
[5],
488 veth
->h_source
[0], veth
->h_source
[1], veth
->h_source
[2], veth
->h_source
[3], veth
->h_source
[4], veth
->h_source
[5],
489 veth
->h_vlan_proto
, veth
->h_vlan_TCI
, veth
->h_vlan_encapsulated_proto
);
492 stats
->tx_packets
++; /* for statics only */
493 stats
->tx_bytes
+= skb
->len
;
495 skb
->dev
= VLAN_DEV_INFO(dev
)->real_dev
;
501 int vlan_dev_hwaccel_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
503 struct net_device_stats
*stats
= vlan_dev_get_stats(dev
);
504 unsigned short veth_TCI
;
506 /* Construct the second two bytes. This field looks something
508 * usr_priority: 3 bits (high bits)
510 * VLAN ID 12 bits (low bits)
512 veth_TCI
= VLAN_DEV_INFO(dev
)->vlan_id
;
513 veth_TCI
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
514 skb
= __vlan_hwaccel_put_tag(skb
, veth_TCI
);
517 stats
->tx_bytes
+= skb
->len
;
519 skb
->dev
= VLAN_DEV_INFO(dev
)->real_dev
;
525 int vlan_dev_change_mtu(struct net_device
*dev
, int new_mtu
)
527 /* TODO: gotta make sure the underlying layer can handle it,
528 * maybe an IFF_VLAN_CAPABLE flag for devices?
530 if (VLAN_DEV_INFO(dev
)->real_dev
->mtu
< new_mtu
)
538 void vlan_dev_set_ingress_priority(const struct net_device
*dev
,
539 u32 skb_prio
, short vlan_prio
)
541 struct vlan_dev_info
*vlan
= VLAN_DEV_INFO(dev
);
543 if (vlan
->ingress_priority_map
[vlan_prio
& 0x7] && !skb_prio
)
544 vlan
->nr_ingress_mappings
--;
545 else if (!vlan
->ingress_priority_map
[vlan_prio
& 0x7] && skb_prio
)
546 vlan
->nr_ingress_mappings
++;
548 vlan
->ingress_priority_map
[vlan_prio
& 0x7] = skb_prio
;
551 int vlan_dev_set_egress_priority(const struct net_device
*dev
,
552 u32 skb_prio
, short vlan_prio
)
554 struct vlan_dev_info
*vlan
= VLAN_DEV_INFO(dev
);
555 struct vlan_priority_tci_mapping
*mp
= NULL
;
556 struct vlan_priority_tci_mapping
*np
;
557 u32 vlan_qos
= (vlan_prio
<< 13) & 0xE000;
559 /* See if a priority mapping exists.. */
560 mp
= vlan
->egress_priority_map
[skb_prio
& 0xF];
562 if (mp
->priority
== skb_prio
) {
563 if (mp
->vlan_qos
&& !vlan_qos
)
564 vlan
->nr_egress_mappings
--;
565 else if (!mp
->vlan_qos
&& vlan_qos
)
566 vlan
->nr_egress_mappings
++;
567 mp
->vlan_qos
= vlan_qos
;
573 /* Create a new mapping then. */
574 mp
= vlan
->egress_priority_map
[skb_prio
& 0xF];
575 np
= kmalloc(sizeof(struct vlan_priority_tci_mapping
), GFP_KERNEL
);
580 np
->priority
= skb_prio
;
581 np
->vlan_qos
= vlan_qos
;
582 vlan
->egress_priority_map
[skb_prio
& 0xF] = np
;
584 vlan
->nr_egress_mappings
++;
588 /* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */
589 int vlan_dev_set_vlan_flag(const struct net_device
*dev
,
590 u32 flag
, short flag_val
)
592 /* verify flag is supported */
593 if (flag
== VLAN_FLAG_REORDER_HDR
) {
595 VLAN_DEV_INFO(dev
)->flags
|= VLAN_FLAG_REORDER_HDR
;
597 VLAN_DEV_INFO(dev
)->flags
&= ~VLAN_FLAG_REORDER_HDR
;
601 printk(KERN_ERR
"%s: flag %i is not valid.\n", __FUNCTION__
, flag
);
605 void vlan_dev_get_realdev_name(const struct net_device
*dev
, char *result
)
607 strncpy(result
, VLAN_DEV_INFO(dev
)->real_dev
->name
, 23);
610 void vlan_dev_get_vid(const struct net_device
*dev
, unsigned short *result
)
612 *result
= VLAN_DEV_INFO(dev
)->vlan_id
;
615 static inline int vlan_dmi_equals(struct dev_mc_list
*dmi1
,
616 struct dev_mc_list
*dmi2
)
618 return ((dmi1
->dmi_addrlen
== dmi2
->dmi_addrlen
) &&
619 (memcmp(dmi1
->dmi_addr
, dmi2
->dmi_addr
, dmi1
->dmi_addrlen
) == 0));
622 /** dmi is a single entry into a dev_mc_list, a single node. mc_list is
623 * an entire list, and we'll iterate through it.
625 static int vlan_should_add_mc(struct dev_mc_list
*dmi
, struct dev_mc_list
*mc_list
)
627 struct dev_mc_list
*idmi
;
629 for (idmi
= mc_list
; idmi
!= NULL
; ) {
630 if (vlan_dmi_equals(dmi
, idmi
)) {
631 if (dmi
->dmi_users
> idmi
->dmi_users
)
643 static inline void vlan_destroy_mc_list(struct dev_mc_list
*mc_list
)
645 struct dev_mc_list
*dmi
= mc_list
;
646 struct dev_mc_list
*next
;
655 static void vlan_copy_mc_list(struct dev_mc_list
*mc_list
, struct vlan_dev_info
*vlan_info
)
657 struct dev_mc_list
*dmi
, *new_dmi
;
659 vlan_destroy_mc_list(vlan_info
->old_mc_list
);
660 vlan_info
->old_mc_list
= NULL
;
662 for (dmi
= mc_list
; dmi
!= NULL
; dmi
= dmi
->next
) {
663 new_dmi
= kmalloc(sizeof(*new_dmi
), GFP_ATOMIC
);
664 if (new_dmi
== NULL
) {
665 printk(KERN_ERR
"vlan: cannot allocate memory. "
666 "Multicast may not work properly from now.\n");
670 /* Copy whole structure, then make new 'next' pointer */
672 new_dmi
->next
= vlan_info
->old_mc_list
;
673 vlan_info
->old_mc_list
= new_dmi
;
677 static void vlan_flush_mc_list(struct net_device
*dev
)
679 struct dev_mc_list
*dmi
= dev
->mc_list
;
682 printk(KERN_DEBUG
"%s: del %.2x:%.2x:%.2x:%.2x:%.2x:%.2x mcast address from vlan interface\n",
690 dev_mc_delete(dev
, dmi
->dmi_addr
, dmi
->dmi_addrlen
, 0);
694 /* dev->mc_list is NULL by the time we get here. */
695 vlan_destroy_mc_list(VLAN_DEV_INFO(dev
)->old_mc_list
);
696 VLAN_DEV_INFO(dev
)->old_mc_list
= NULL
;
699 int vlan_dev_open(struct net_device
*dev
)
701 struct vlan_dev_info
*vlan
= VLAN_DEV_INFO(dev
);
702 struct net_device
*real_dev
= vlan
->real_dev
;
705 if (!(real_dev
->flags
& IFF_UP
))
708 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
)) {
709 err
= dev_unicast_add(real_dev
, dev
->dev_addr
, ETH_ALEN
);
713 memcpy(vlan
->real_dev_addr
, real_dev
->dev_addr
, ETH_ALEN
);
718 int vlan_dev_stop(struct net_device
*dev
)
720 struct net_device
*real_dev
= VLAN_DEV_INFO(dev
)->real_dev
;
722 vlan_flush_mc_list(dev
);
724 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
))
725 dev_unicast_delete(real_dev
, dev
->dev_addr
, dev
->addr_len
);
730 int vlan_dev_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
732 struct net_device
*real_dev
= VLAN_DEV_INFO(dev
)->real_dev
;
734 int err
= -EOPNOTSUPP
;
736 strncpy(ifrr
.ifr_name
, real_dev
->name
, IFNAMSIZ
);
737 ifrr
.ifr_ifru
= ifr
->ifr_ifru
;
743 if (real_dev
->do_ioctl
&& netif_device_present(real_dev
))
744 err
= real_dev
->do_ioctl(real_dev
, &ifrr
, cmd
);
748 err
= dev_ethtool(&ifrr
);
752 ifr
->ifr_ifru
= ifrr
.ifr_ifru
;
757 /** Taken from Gleb + Lennert's VLAN code, and modified... */
758 void vlan_dev_set_multicast_list(struct net_device
*vlan_dev
)
760 struct dev_mc_list
*dmi
;
761 struct net_device
*real_dev
;
764 if (vlan_dev
&& (vlan_dev
->priv_flags
& IFF_802_1Q_VLAN
)) {
765 /* Then it's a real vlan device, as far as we can tell.. */
766 real_dev
= VLAN_DEV_INFO(vlan_dev
)->real_dev
;
768 /* compare the current promiscuity to the last promisc we had.. */
769 inc
= vlan_dev
->promiscuity
- VLAN_DEV_INFO(vlan_dev
)->old_promiscuity
;
771 printk(KERN_INFO
"%s: dev_set_promiscuity(master, %d)\n",
772 vlan_dev
->name
, inc
);
773 dev_set_promiscuity(real_dev
, inc
); /* found in dev.c */
774 VLAN_DEV_INFO(vlan_dev
)->old_promiscuity
= vlan_dev
->promiscuity
;
777 inc
= vlan_dev
->allmulti
- VLAN_DEV_INFO(vlan_dev
)->old_allmulti
;
779 printk(KERN_INFO
"%s: dev_set_allmulti(master, %d)\n",
780 vlan_dev
->name
, inc
);
781 dev_set_allmulti(real_dev
, inc
); /* dev.c */
782 VLAN_DEV_INFO(vlan_dev
)->old_allmulti
= vlan_dev
->allmulti
;
785 /* looking for addresses to add to master's list */
786 for (dmi
= vlan_dev
->mc_list
; dmi
!= NULL
; dmi
= dmi
->next
) {
787 if (vlan_should_add_mc(dmi
, VLAN_DEV_INFO(vlan_dev
)->old_mc_list
)) {
788 dev_mc_add(real_dev
, dmi
->dmi_addr
, dmi
->dmi_addrlen
, 0);
789 printk(KERN_DEBUG
"%s: add %.2x:%.2x:%.2x:%.2x:%.2x:%.2x mcast address to master interface\n",
800 /* looking for addresses to delete from master's list */
801 for (dmi
= VLAN_DEV_INFO(vlan_dev
)->old_mc_list
; dmi
!= NULL
; dmi
= dmi
->next
) {
802 if (vlan_should_add_mc(dmi
, vlan_dev
->mc_list
)) {
803 /* if we think we should add it to the new list, then we should really
804 * delete it from the real list on the underlying device.
806 dev_mc_delete(real_dev
, dmi
->dmi_addr
, dmi
->dmi_addrlen
, 0);
807 printk(KERN_DEBUG
"%s: del %.2x:%.2x:%.2x:%.2x:%.2x:%.2x mcast address from master interface\n",
818 /* save multicast list */
819 vlan_copy_mc_list(vlan_dev
->mc_list
, VLAN_DEV_INFO(vlan_dev
));