[deliverable/linux.git] / net / 8021q / vlan_core.c

#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/if_vlan.h>
#include <linux/netpoll.h>
#include <linux/export.h>
#include "vlan.h"

bool vlan_do_receive(struct sk_buff **skbp, bool last_handler)
{
	struct sk_buff *skb = *skbp;
	u16 vlan_id = skb->vlan_tci & VLAN_VID_MASK;
	struct net_device *vlan_dev;
	struct vlan_pcpu_stats *rx_stats;

	vlan_dev = vlan_find_dev(skb->dev, vlan_id);
	if (!vlan_dev) {
		/* Only the last call to vlan_do_receive() should change
		 * pkt_type to PACKET_OTHERHOST
		 */
		if (vlan_id && last_handler)
			skb->pkt_type = PACKET_OTHERHOST;
		return false;
	}

	skb = *skbp = skb_share_check(skb, GFP_ATOMIC);
	if (unlikely(!skb))
		return false;

	skb->dev = vlan_dev;
	if (skb->pkt_type == PACKET_OTHERHOST) {
		/* Our lower layer thinks this is not local, let's make sure.
		 * This allows the VLAN to have a different MAC than the
		 * underlying device, and still route correctly. */
		if (ether_addr_equal(eth_hdr(skb)->h_dest, vlan_dev->dev_addr))
			skb->pkt_type = PACKET_HOST;
	}

	if (!(vlan_dev_priv(vlan_dev)->flags & VLAN_FLAG_REORDER_HDR)) {
		unsigned int offset = skb->data - skb_mac_header(skb);

		/*
		 * vlan_insert_tag expect skb->data pointing to mac header.
		 * So change skb->data before calling it and change back to
		 * original position later
		 */
		skb_push(skb, offset);
		skb = *skbp = vlan_insert_tag(skb, skb->vlan_tci);
		if (!skb)
			return false;
		skb_pull(skb, offset + VLAN_HLEN);
		skb_reset_mac_len(skb);
	}

	skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci);
	skb->vlan_tci = 0;

	rx_stats = this_cpu_ptr(vlan_dev_priv(vlan_dev)->vlan_pcpu_stats);

	u64_stats_update_begin(&rx_stats->syncp);
	rx_stats->rx_packets++;
	rx_stats->rx_bytes += skb->len;
	if (skb->pkt_type == PACKET_MULTICAST)
		rx_stats->rx_multicast++;
	u64_stats_update_end(&rx_stats->syncp);

	return true;
}

/* Must be invoked with rcu_read_lock or with RTNL. */
struct net_device *__vlan_find_dev_deep(struct net_device *real_dev,
					u16 vlan_id)
{
	struct vlan_info *vlan_info = rcu_dereference_rtnl(real_dev->vlan_info);

	if (vlan_info) {
		return vlan_group_get_device(&vlan_info->grp, vlan_id);
	} else {
		/*
		 * Bonding slaves do not have grp assigned to themselves.
		 * Grp is assigned to bonding master instead.
		 */
		if (netif_is_bond_slave(real_dev))
			return __vlan_find_dev_deep(real_dev->master, vlan_id);
	}

	return NULL;
}
EXPORT_SYMBOL(__vlan_find_dev_deep);

struct net_device *vlan_dev_real_dev(const struct net_device *dev)
{
	return vlan_dev_priv(dev)->real_dev;
}
EXPORT_SYMBOL(vlan_dev_real_dev);

u16 vlan_dev_vlan_id(const struct net_device *dev)
{
	return vlan_dev_priv(dev)->vlan_id;
}
EXPORT_SYMBOL(vlan_dev_vlan_id);

static struct sk_buff *vlan_reorder_header(struct sk_buff *skb)
{
	if (skb_cow(skb, skb_headroom(skb)) < 0)
		return NULL;
	memmove(skb->data - ETH_HLEN, skb->data - VLAN_ETH_HLEN, 2 * ETH_ALEN);
	skb->mac_header += VLAN_HLEN;
	skb_reset_mac_len(skb);
	return skb;
}

struct sk_buff *vlan_untag(struct sk_buff *skb)
{
	struct vlan_hdr *vhdr;
	u16 vlan_tci;

	if (unlikely(vlan_tx_tag_present(skb))) {
		/* vlan_tci is already set-up so leave this for another time */
		return skb;
	}

	skb = skb_share_check(skb, GFP_ATOMIC);
	if (unlikely(!skb))
		goto err_free;

	if (unlikely(!pskb_may_pull(skb, VLAN_HLEN)))
		goto err_free;

	vhdr = (struct vlan_hdr *) skb->data;
	vlan_tci = ntohs(vhdr->h_vlan_TCI);
	__vlan_hwaccel_put_tag(skb, vlan_tci);

	skb_pull_rcsum(skb, VLAN_HLEN);
	vlan_set_encap_proto(skb, vhdr);

	skb = vlan_reorder_header(skb);
	if (unlikely(!skb))
		goto err_free;

	skb_reset_network_header(skb);
	skb_reset_transport_header(skb);
	return skb;

err_free:
	kfree_skb(skb);
	return NULL;
}


/*
 * vlan info and vid list
 */

static void vlan_group_free(struct vlan_group *grp)
{
	int i;

	for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
		kfree(grp->vlan_devices_arrays[i]);
}

static void vlan_info_free(struct vlan_info *vlan_info)
{
	vlan_group_free(&vlan_info->grp);
	kfree(vlan_info);
}

static void vlan_info_rcu_free(struct rcu_head *rcu)
{
	vlan_info_free(container_of(rcu, struct vlan_info, rcu));
}

static struct vlan_info *vlan_info_alloc(struct net_device *dev)
{
	struct vlan_info *vlan_info;

	vlan_info = kzalloc(sizeof(struct vlan_info), GFP_KERNEL);
	if (!vlan_info)
		return NULL;

	vlan_info->real_dev = dev;
	INIT_LIST_HEAD(&vlan_info->vid_list);
	return vlan_info;
}

struct vlan_vid_info {
	struct list_head list;
	unsigned short vid;
	int refcount;
};

static struct vlan_vid_info *vlan_vid_info_get(struct vlan_info *vlan_info,
					       unsigned short vid)
{
	struct vlan_vid_info *vid_info;

	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
		if (vid_info->vid == vid)
			return vid_info;
	}
	return NULL;
}

static struct vlan_vid_info *vlan_vid_info_alloc(unsigned short vid)
{
	struct vlan_vid_info *vid_info;

	vid_info = kzalloc(sizeof(struct vlan_vid_info), GFP_KERNEL);
	if (!vid_info)
		return NULL;
	vid_info->vid = vid;

	return vid_info;
}

static int __vlan_vid_add(struct vlan_info *vlan_info, unsigned short vid,
			  struct vlan_vid_info **pvid_info)
{
	struct net_device *dev = vlan_info->real_dev;
	const struct net_device_ops *ops = dev->netdev_ops;
	struct vlan_vid_info *vid_info;
	int err;

	vid_info = vlan_vid_info_alloc(vid);
	if (!vid_info)
		return -ENOMEM;

	if ((dev->features & NETIF_F_HW_VLAN_FILTER) &&
	    ops->ndo_vlan_rx_add_vid) {
		err =  ops->ndo_vlan_rx_add_vid(dev, vid);
		if (err) {
			kfree(vid_info);
			return err;
		}
	}
	list_add(&vid_info->list, &vlan_info->vid_list);
	vlan_info->nr_vids++;
	*pvid_info = vid_info;
	return 0;
}

int vlan_vid_add(struct net_device *dev, unsigned short vid)
{
	struct vlan_info *vlan_info;
	struct vlan_vid_info *vid_info;
	bool vlan_info_created = false;
	int err;

	ASSERT_RTNL();

	vlan_info = rtnl_dereference(dev->vlan_info);
	if (!vlan_info) {
		vlan_info = vlan_info_alloc(dev);
		if (!vlan_info)
			return -ENOMEM;
		vlan_info_created = true;
	}
	vid_info = vlan_vid_info_get(vlan_info, vid);
	if (!vid_info) {
		err = __vlan_vid_add(vlan_info, vid, &vid_info);
		if (err)
			goto out_free_vlan_info;
	}
	vid_info->refcount++;

	if (vlan_info_created)
		rcu_assign_pointer(dev->vlan_info, vlan_info);

	return 0;

out_free_vlan_info:
	if (vlan_info_created)
		kfree(vlan_info);
	return err;
}
EXPORT_SYMBOL(vlan_vid_add);

static void __vlan_vid_del(struct vlan_info *vlan_info,
			   struct vlan_vid_info *vid_info)
{
	struct net_device *dev = vlan_info->real_dev;
	const struct net_device_ops *ops = dev->netdev_ops;
	unsigned short vid = vid_info->vid;
	int err;

	if ((dev->features & NETIF_F_HW_VLAN_FILTER) &&
	     ops->ndo_vlan_rx_kill_vid) {
		err = ops->ndo_vlan_rx_kill_vid(dev, vid);
		if (err) {
			pr_warn("failed to kill vid %d for device %s\n",
				vid, dev->name);
		}
	}
	list_del(&vid_info->list);
	kfree(vid_info);
	vlan_info->nr_vids--;
}

void vlan_vid_del(struct net_device *dev, unsigned short vid)
{
	struct vlan_info *vlan_info;
	struct vlan_vid_info *vid_info;

	ASSERT_RTNL();

	vlan_info = rtnl_dereference(dev->vlan_info);
	if (!vlan_info)
		return;

	vid_info = vlan_vid_info_get(vlan_info, vid);
	if (!vid_info)
		return;
	vid_info->refcount--;
	if (vid_info->refcount == 0) {
		__vlan_vid_del(vlan_info, vid_info);
		if (vlan_info->nr_vids == 0) {
			RCU_INIT_POINTER(dev->vlan_info, NULL);
			call_rcu(&vlan_info->rcu, vlan_info_rcu_free);
		}
	}
}
EXPORT_SYMBOL(vlan_vid_del);

int vlan_vids_add_by_dev(struct net_device *dev,
			 const struct net_device *by_dev)
{
	struct vlan_vid_info *vid_info;
	struct vlan_info *vlan_info;
	int err;

	ASSERT_RTNL();

	vlan_info = rtnl_dereference(by_dev->vlan_info);
	if (!vlan_info)
		return 0;

	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
		err = vlan_vid_add(dev, vid_info->vid);
		if (err)
			goto unwind;
	}
	return 0;

unwind:
	list_for_each_entry_continue_reverse(vid_info,
					     &vlan_info->vid_list,
					     list) {
		vlan_vid_del(dev, vid_info->vid);
	}

	return err;
}
EXPORT_SYMBOL(vlan_vids_add_by_dev);

void vlan_vids_del_by_dev(struct net_device *dev,
			  const struct net_device *by_dev)
{
	struct vlan_vid_info *vid_info;
	struct vlan_info *vlan_info;

	ASSERT_RTNL();

	vlan_info = rtnl_dereference(by_dev->vlan_info);
	if (!vlan_info)
		return;

	list_for_each_entry(vid_info, &vlan_info->vid_list, list)
		vlan_vid_del(dev, vid_info->vid);
}
EXPORT_SYMBOL(vlan_vids_del_by_dev);
Commit	Line	Data
7750f403 PM	1	#include <linux/skbuff.h>
	2	#include <linux/netdevice.h>
	3	#include <linux/if_vlan.h>
4ead4431	4	#include <linux/netpoll.h>
bc3b2d7f	5	#include <linux/export.h>
7750f403 PM	6	#include "vlan.h"
7750f403 PM	7
6a32e4f9	8	bool vlan_do_receive(struct sk_buff **skbp, bool last_handler)
7750f403	9	{
3701e513 JG	10	struct sk_buff skb = skbp;
3701e513 JG	11	u16 vlan_id = skb->vlan_tci & VLAN_VID_MASK;
ad1afb00	12	struct net_device *vlan_dev;
4af429d2	13	struct vlan_pcpu_stats *rx_stats;
7750f403	14
3701e513 JG	15	vlan_dev = vlan_find_dev(skb->dev, vlan_id);
3701e513 JG	16	if (!vlan_dev) {
6a32e4f9 ED	17	/* Only the last call to vlan_do_receive() should change
	18	* pkt_type to PACKET_OTHERHOST
	19	*/
	20	if (vlan_id && last_handler)
3701e513 JG	21	skb->pkt_type = PACKET_OTHERHOST;
3701e513 JG	22	return false;
173e79fb	23	}
9b22ea56	24
3701e513 JG	25	skb = *skbp = skb_share_check(skb, GFP_ATOMIC);
	26	if (unlikely(!skb))
	27	return false;
e1c096e2	28
3701e513	29	skb->dev = vlan_dev;
0b5c9db1 JP	30	if (skb->pkt_type == PACKET_OTHERHOST) {
	31	/* Our lower layer thinks this is not local, let's make sure.
	32	* This allows the VLAN to have a different MAC than the
	33	* underlying device, and still route correctly. */
53a2b3a1	34	if (ether_addr_equal(eth_hdr(skb)->h_dest, vlan_dev->dev_addr))
0b5c9db1 JP	35	skb->pkt_type = PACKET_HOST;
	36	}
	37
7da82c06	38	if (!(vlan_dev_priv(vlan_dev)->flags & VLAN_FLAG_REORDER_HDR)) {
0b5c9db1 JP	39	unsigned int offset = skb->data - skb_mac_header(skb);
	40
	41	/*
	42	* vlan_insert_tag expect skb->data pointing to mac header.
	43	* So change skb->data before calling it and change back to
	44	* original position later
	45	*/
	46	skb_push(skb, offset);
	47	skb = *skbp = vlan_insert_tag(skb, skb->vlan_tci);
	48	if (!skb)
	49	return false;
	50	skb_pull(skb, offset + VLAN_HLEN);
	51	skb_reset_mac_len(skb);
	52	}
	53
3701e513	54	skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci);
bc1d0411	55	skb->vlan_tci = 0;
7750f403	56
7da82c06	57	rx_stats = this_cpu_ptr(vlan_dev_priv(vlan_dev)->vlan_pcpu_stats);
9793241f	58
9618e2ff	59	u64_stats_update_begin(&rx_stats->syncp);
9793241f ED	60	rx_stats->rx_packets++;
9793241f ED	61	rx_stats->rx_bytes += skb->len;
0b5c9db1	62	if (skb->pkt_type == PACKET_MULTICAST)
9618e2ff	63	rx_stats->rx_multicast++;
9618e2ff	64	u64_stats_update_end(&rx_stats->syncp);
3701e513 JG	65
3701e513 JG	66	return true;
7750f403	67	}
22d1ba74	68
cec9c133 JP	69	/* Must be invoked with rcu_read_lock or with RTNL. */
	70	struct net_device __vlan_find_dev_deep(struct net_device real_dev,
	71	u16 vlan_id)
	72	{
5b9ea6e0	73	struct vlan_info *vlan_info = rcu_dereference_rtnl(real_dev->vlan_info);
cec9c133	74
5b9ea6e0 JP	75	if (vlan_info) {
5b9ea6e0 JP	76	return vlan_group_get_device(&vlan_info->grp, vlan_id);
cec9c133 JP	77	} else {
	78	/*
	79	* Bonding slaves do not have grp assigned to themselves.
	80	* Grp is assigned to bonding master instead.
	81	*/
	82	if (netif_is_bond_slave(real_dev))
	83	return __vlan_find_dev_deep(real_dev->master, vlan_id);
	84	}
	85
	86	return NULL;
	87	}
	88	EXPORT_SYMBOL(__vlan_find_dev_deep);
	89
22d1ba74 PM	90	struct net_device vlan_dev_real_dev(const struct net_device dev)
22d1ba74 PM	91	{
7da82c06	92	return vlan_dev_priv(dev)->real_dev;
22d1ba74	93	}
116cb428	94	EXPORT_SYMBOL(vlan_dev_real_dev);
22d1ba74 PM	95
	96	u16 vlan_dev_vlan_id(const struct net_device *dev)
	97	{
7da82c06	98	return vlan_dev_priv(dev)->vlan_id;
22d1ba74	99	}
116cb428	100	EXPORT_SYMBOL(vlan_dev_vlan_id);
e1c096e2	101
0b5c9db1	102	static struct sk_buff vlan_reorder_header(struct sk_buff skb)
bcc6d479	103	{
0b5c9db1 JP	104	if (skb_cow(skb, skb_headroom(skb)) < 0)
	105	return NULL;
	106	memmove(skb->data - ETH_HLEN, skb->data - VLAN_ETH_HLEN, 2 * ETH_ALEN);
	107	skb->mac_header += VLAN_HLEN;
	108	skb_reset_mac_len(skb);
bcc6d479 JP	109	return skb;
	110	}
	111
bcc6d479 JP	112	struct sk_buff vlan_untag(struct sk_buff skb)
	113	{
	114	struct vlan_hdr *vhdr;
	115	u16 vlan_tci;
	116
	117	if (unlikely(vlan_tx_tag_present(skb))) {
	118	/* vlan_tci is already set-up so leave this for another time */
	119	return skb;
	120	}
	121
	122	skb = skb_share_check(skb, GFP_ATOMIC);
	123	if (unlikely(!skb))
	124	goto err_free;
	125
	126	if (unlikely(!pskb_may_pull(skb, VLAN_HLEN)))
	127	goto err_free;
	128
	129	vhdr = (struct vlan_hdr *) skb->data;
	130	vlan_tci = ntohs(vhdr->h_vlan_TCI);
	131	__vlan_hwaccel_put_tag(skb, vlan_tci);
	132
	133	skb_pull_rcsum(skb, VLAN_HLEN);
	134	vlan_set_encap_proto(skb, vhdr);
	135
0b5c9db1	136	skb = vlan_reorder_header(skb);
bcc6d479 JP	137	if (unlikely(!skb))
	138	goto err_free;
	139
c5114cd5 JP	140	skb_reset_network_header(skb);
c5114cd5 JP	141	skb_reset_transport_header(skb);
bcc6d479 JP	142	return skb;
	143
	144	err_free:
	145	kfree_skb(skb);
	146	return NULL;
	147	}
87002b03	148
5b9ea6e0 JP	149
	150	/*
	151	* vlan info and vid list
	152	*/
	153
	154	static void vlan_group_free(struct vlan_group *grp)
	155	{
	156	int i;
	157
	158	for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
	159	kfree(grp->vlan_devices_arrays[i]);
	160	}
	161
	162	static void vlan_info_free(struct vlan_info *vlan_info)
	163	{
	164	vlan_group_free(&vlan_info->grp);
	165	kfree(vlan_info);
	166	}
	167
	168	static void vlan_info_rcu_free(struct rcu_head *rcu)
	169	{
	170	vlan_info_free(container_of(rcu, struct vlan_info, rcu));
	171	}
	172
	173	static struct vlan_info vlan_info_alloc(struct net_device dev)
	174	{
	175	struct vlan_info *vlan_info;
	176
	177	vlan_info = kzalloc(sizeof(struct vlan_info), GFP_KERNEL);
	178	if (!vlan_info)
	179	return NULL;
	180
	181	vlan_info->real_dev = dev;
	182	INIT_LIST_HEAD(&vlan_info->vid_list);
	183	return vlan_info;
	184	}
	185
	186	struct vlan_vid_info {
	187	struct list_head list;
	188	unsigned short vid;
	189	int refcount;
	190	};
	191
	192	static struct vlan_vid_info vlan_vid_info_get(struct vlan_info vlan_info,
	193	unsigned short vid)
	194	{
	195	struct vlan_vid_info *vid_info;
	196
	197	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
	198	if (vid_info->vid == vid)
	199	return vid_info;
	200	}
	201	return NULL;
	202	}
	203
	204	static struct vlan_vid_info *vlan_vid_info_alloc(unsigned short vid)
	205	{
	206	struct vlan_vid_info *vid_info;
	207
	208	vid_info = kzalloc(sizeof(struct vlan_vid_info), GFP_KERNEL);
	209	if (!vid_info)
	210	return NULL;
	211	vid_info->vid = vid;
	212
213	return vid_info;
214	}
215
216	static int __vlan_vid_add(struct vlan_info *vlan_info, unsigned short vid,
217	struct vlan_vid_info **pvid_info)
87002b03	218	{
5b9ea6e0	219	struct net_device *dev = vlan_info->real_dev;
87002b03	220	const struct net_device_ops *ops = dev->netdev_ops;
5b9ea6e0 JP	221	struct vlan_vid_info *vid_info;
	222	int err;
	223
	224	vid_info = vlan_vid_info_alloc(vid);
	225	if (!vid_info)
	226	return -ENOMEM;
87002b03 JP	227
87002b03 JP	228	if ((dev->features & NETIF_F_HW_VLAN_FILTER) &&
5b9ea6e0 JP	229	ops->ndo_vlan_rx_add_vid) {
	230	err = ops->ndo_vlan_rx_add_vid(dev, vid);
	231	if (err) {
	232	kfree(vid_info);
	233	return err;
	234	}
87002b03	235	}
5b9ea6e0 JP	236	list_add(&vid_info->list, &vlan_info->vid_list);
	237	vlan_info->nr_vids++;
	238	*pvid_info = vid_info;
87002b03 JP	239	return 0;
87002b03 JP	240	}
5b9ea6e0 JP	241
	242	int vlan_vid_add(struct net_device *dev, unsigned short vid)
	243	{
	244	struct vlan_info *vlan_info;
	245	struct vlan_vid_info *vid_info;
	246	bool vlan_info_created = false;
	247	int err;
	248
	249	ASSERT_RTNL();
	250
	251	vlan_info = rtnl_dereference(dev->vlan_info);
	252	if (!vlan_info) {
	253	vlan_info = vlan_info_alloc(dev);
	254	if (!vlan_info)
	255	return -ENOMEM;
	256	vlan_info_created = true;
	257	}
	258	vid_info = vlan_vid_info_get(vlan_info, vid);
	259	if (!vid_info) {
	260	err = __vlan_vid_add(vlan_info, vid, &vid_info);
	261	if (err)
	262	goto out_free_vlan_info;
	263	}
	264	vid_info->refcount++;
	265
	266	if (vlan_info_created)
	267	rcu_assign_pointer(dev->vlan_info, vlan_info);
	268
	269	return 0;
	270
	271	out_free_vlan_info:
	272	if (vlan_info_created)
	273	kfree(vlan_info);
	274	return err;
	275	}
87002b03 JP	276	EXPORT_SYMBOL(vlan_vid_add);
87002b03 JP	277
5b9ea6e0 JP	278	static void __vlan_vid_del(struct vlan_info *vlan_info,
5b9ea6e0 JP	279	struct vlan_vid_info *vid_info)
87002b03	280	{
5b9ea6e0	281	struct net_device *dev = vlan_info->real_dev;
87002b03	282	const struct net_device_ops *ops = dev->netdev_ops;
5b9ea6e0 JP	283	unsigned short vid = vid_info->vid;
5b9ea6e0 JP	284	int err;
87002b03 JP	285
	286	if ((dev->features & NETIF_F_HW_VLAN_FILTER) &&
	287	ops->ndo_vlan_rx_kill_vid) {
5b9ea6e0 JP	288	err = ops->ndo_vlan_rx_kill_vid(dev, vid);
	289	if (err) {
	290	pr_warn("failed to kill vid %d for device %s\n",
	291	vid, dev->name);
	292	}
	293	}
	294	list_del(&vid_info->list);
	295	kfree(vid_info);
	296	vlan_info->nr_vids--;
	297	}
	298
	299	void vlan_vid_del(struct net_device *dev, unsigned short vid)
	300	{
	301	struct vlan_info *vlan_info;
	302	struct vlan_vid_info *vid_info;
	303
	304	ASSERT_RTNL();
	305
	306	vlan_info = rtnl_dereference(dev->vlan_info);
	307	if (!vlan_info)
	308	return;
	309
	310	vid_info = vlan_vid_info_get(vlan_info, vid);
	311	if (!vid_info)
	312	return;
	313	vid_info->refcount--;
	314	if (vid_info->refcount == 0) {
	315	__vlan_vid_del(vlan_info, vid_info);
	316	if (vlan_info->nr_vids == 0) {
	317	RCU_INIT_POINTER(dev->vlan_info, NULL);
	318	call_rcu(&vlan_info->rcu, vlan_info_rcu_free);
	319	}
87002b03 JP	320	}
	321	}
	322	EXPORT_SYMBOL(vlan_vid_del);
348a1443 JP	323
	324	int vlan_vids_add_by_dev(struct net_device *dev,
	325	const struct net_device *by_dev)
	326	{
	327	struct vlan_vid_info *vid_info;
f9586f79	328	struct vlan_info *vlan_info;
348a1443 JP	329	int err;
	330
	331	ASSERT_RTNL();
	332
f9586f79 DC	333	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	334	if (!vlan_info)
348a1443 JP	335	return 0;
348a1443 JP	336
f9586f79	337	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
348a1443 JP	338	err = vlan_vid_add(dev, vid_info->vid);
	339	if (err)
	340	goto unwind;
	341	}
	342	return 0;
	343
	344	unwind:
	345	list_for_each_entry_continue_reverse(vid_info,
f9586f79	346	&vlan_info->vid_list,
348a1443 JP	347	list) {
	348	vlan_vid_del(dev, vid_info->vid);
	349	}
	350
	351	return err;
	352	}
	353	EXPORT_SYMBOL(vlan_vids_add_by_dev);
	354
	355	void vlan_vids_del_by_dev(struct net_device *dev,
	356	const struct net_device *by_dev)
	357	{
	358	struct vlan_vid_info *vid_info;
f9586f79	359	struct vlan_info *vlan_info;
348a1443 JP	360
	361	ASSERT_RTNL();
	362
f9586f79 DC	363	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	364	if (!vlan_info)
348a1443 JP	365	return;
348a1443 JP	366
f9586f79	367	list_for_each_entry(vid_info, &vlan_info->vid_list, list)
348a1443 JP	368	vlan_vid_del(dev, vid_info->vid);
	369	}
	370	EXPORT_SYMBOL(vlan_vids_del_by_dev);