[GitHub/mt8127/android_kernel_alcatel_ttab.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)
{
	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)
		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;
	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);
	skb_reset_mac_len(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);

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