[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)
{
	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. */
struct net_device *__vlan_find_dev_deep(struct net_device *dev,
					u16 vlan_id)
{
	struct vlan_info *vlan_info = rcu_dereference(dev->vlan_info);

	if (vlan_info) {
		return vlan_group_get_device(&vlan_info->grp, vlan_id);
	} else {
		/*
		 * Lower devices of master uppers (bonding, team) do not have
		 * grp assigned to themselves. Grp is assigned to upper device
		 * instead.
		 */
		struct net_device *upper_dev;

		upper_dev = netdev_master_upper_dev_get_rcu(dev);
		if (upper_dev)
			return __vlan_find_dev_deep(upper_dev, 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;
}
EXPORT_SYMBOL(vlan_untag);


/*
 * 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;
	__be16 proto;
	u16 vid;
	int refcount;
};

static struct vlan_vid_info *vlan_vid_info_get(struct vlan_info *vlan_info,
					       __be16 proto, u16 vid)
{
	struct vlan_vid_info *vid_info;

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

static struct vlan_vid_info *vlan_vid_info_alloc(__be16 proto, u16 vid)
{
	struct vlan_vid_info *vid_info;

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

	return vid_info;
}

static int __vlan_vid_add(struct vlan_info *vlan_info, __be16 proto, u16 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(proto, vid);
	if (!vid_info)
		return -ENOMEM;

	if (proto == htons(ETH_P_8021Q) &&
	    dev->features & NETIF_F_HW_VLAN_CTAG_FILTER) {
		err =  ops->ndo_vlan_rx_add_vid(dev, proto, 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, __be16 proto, u16 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, proto, vid);
	if (!vid_info) {
		err = __vlan_vid_add(vlan_info, proto, 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;
	__be16 proto = vid_info->proto;
	u16 vid = vid_info->vid;
	int err;

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

void vlan_vid_del(struct net_device *dev, __be16 proto, u16 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, proto, 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->proto, 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->proto, 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->proto, vid_info->vid);
}
EXPORT_SYMBOL(vlan_vids_del_by_dev);

bool vlan_uses_dev(const struct net_device *dev)
{
	struct vlan_info *vlan_info;

	ASSERT_RTNL();

	vlan_info = rtnl_dereference(dev->vlan_info);
	if (!vlan_info)
		return false;
	return vlan_info->grp.nr_vlan_devs ? 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
1cdfd72f JP	63	/* Must be invoked with rcu_read_lock. */
1cdfd72f JP	64	struct net_device __vlan_find_dev_deep(struct net_device dev,
cec9c133 JP	65	u16 vlan_id)
cec9c133 JP	66	{
1cdfd72f	67	struct vlan_info *vlan_info = rcu_dereference(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 {
cec9c133 JP	72	/*
1cdfd72f JP	73	* Lower devices of master uppers (bonding, team) do not have
	74	* grp assigned to themselves. Grp is assigned to upper device
	75	* instead.
cec9c133	76	*/
1cdfd72f JP	77	struct net_device *upper_dev;
	78
	79	upper_dev = netdev_master_upper_dev_get_rcu(dev);
	80	if (upper_dev)
	81	return __vlan_find_dev_deep(upper_dev, vlan_id);
cec9c133 JP	82	}
	83
	84	return NULL;
	85	}
	86	EXPORT_SYMBOL(__vlan_find_dev_deep);
	87
22d1ba74 PM	88	struct net_device vlan_dev_real_dev(const struct net_device dev)
22d1ba74 PM	89	{
7da82c06	90	return vlan_dev_priv(dev)->real_dev;
22d1ba74	91	}
116cb428	92	EXPORT_SYMBOL(vlan_dev_real_dev);
22d1ba74 PM	93
	94	u16 vlan_dev_vlan_id(const struct net_device *dev)
	95	{
7da82c06	96	return vlan_dev_priv(dev)->vlan_id;
22d1ba74	97	}
116cb428	98	EXPORT_SYMBOL(vlan_dev_vlan_id);
e1c096e2	99
0b5c9db1	100	static struct sk_buff vlan_reorder_header(struct sk_buff skb)
bcc6d479	101	{
0b5c9db1 JP	102	if (skb_cow(skb, skb_headroom(skb)) < 0)
	103	return NULL;
	104	memmove(skb->data - ETH_HLEN, skb->data - VLAN_ETH_HLEN, 2 * ETH_ALEN);
	105	skb->mac_header += VLAN_HLEN;
bcc6d479 JP	106	return skb;
	107	}
	108
bcc6d479 JP	109	struct sk_buff vlan_untag(struct sk_buff skb)
	110	{
	111	struct vlan_hdr *vhdr;
	112	u16 vlan_tci;
	113
	114	if (unlikely(vlan_tx_tag_present(skb))) {
	115	/* vlan_tci is already set-up so leave this for another time */
	116	return skb;
	117	}
	118
	119	skb = skb_share_check(skb, GFP_ATOMIC);
	120	if (unlikely(!skb))
	121	goto err_free;
	122
	123	if (unlikely(!pskb_may_pull(skb, VLAN_HLEN)))
	124	goto err_free;
	125
	126	vhdr = (struct vlan_hdr *) skb->data;
	127	vlan_tci = ntohs(vhdr->h_vlan_TCI);
	128	__vlan_hwaccel_put_tag(skb, vlan_tci);
	129
	130	skb_pull_rcsum(skb, VLAN_HLEN);
	131	vlan_set_encap_proto(skb, vhdr);
	132
0b5c9db1	133	skb = vlan_reorder_header(skb);
bcc6d479 JP	134	if (unlikely(!skb))
	135	goto err_free;
	136
c5114cd5 JP	137	skb_reset_network_header(skb);
c5114cd5 JP	138	skb_reset_transport_header(skb);
5316cf9a AQ	139	skb_reset_mac_len(skb);
5316cf9a AQ	140
bcc6d479 JP	141	return skb;
	142
	143	err_free:
	144	kfree_skb(skb);
	145	return NULL;
	146	}
78851988	147	EXPORT_SYMBOL(vlan_untag);
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;
80d5c368 PM	188	__be16 proto;
80d5c368 PM	189	u16 vid;
5b9ea6e0 JP	190	int refcount;
	191	};
	192
	193	static struct vlan_vid_info vlan_vid_info_get(struct vlan_info vlan_info,
80d5c368	194	__be16 proto, u16 vid)
5b9ea6e0 JP	195	{
	196	struct vlan_vid_info *vid_info;
	197
	198	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
80d5c368	199	if (vid_info->proto == proto && vid_info->vid == vid)
5b9ea6e0 JP	200	return vid_info;
	201	}
	202	return NULL;
	203	}
	204
80d5c368	205	static struct vlan_vid_info *vlan_vid_info_alloc(__be16 proto, u16 vid)
5b9ea6e0 JP	206	{
	207	struct vlan_vid_info *vid_info;
	208
	209	vid_info = kzalloc(sizeof(struct vlan_vid_info), GFP_KERNEL);
	210	if (!vid_info)
	211	return NULL;
80d5c368	212	vid_info->proto = proto;
5b9ea6e0 JP	213	vid_info->vid = vid;
	214
	215	return vid_info;
	216	}
	217
80d5c368	218	static int __vlan_vid_add(struct vlan_info *vlan_info, __be16 proto, u16 vid,
5b9ea6e0	219	struct vlan_vid_info **pvid_info)
87002b03	220	{
5b9ea6e0	221	struct net_device *dev = vlan_info->real_dev;
87002b03	222	const struct net_device_ops *ops = dev->netdev_ops;
5b9ea6e0 JP	223	struct vlan_vid_info *vid_info;
	224	int err;
	225
80d5c368	226	vid_info = vlan_vid_info_alloc(proto, vid);
5b9ea6e0 JP	227	if (!vid_info)
5b9ea6e0 JP	228	return -ENOMEM;
87002b03	229
80d5c368 PM	230	if (proto == htons(ETH_P_8021Q) &&
	231	dev->features & NETIF_F_HW_VLAN_CTAG_FILTER) {
	232	err = ops->ndo_vlan_rx_add_vid(dev, proto, vid);
5b9ea6e0 JP	233	if (err) {
	234	kfree(vid_info);
	235	return err;
	236	}
87002b03	237	}
5b9ea6e0 JP	238	list_add(&vid_info->list, &vlan_info->vid_list);
	239	vlan_info->nr_vids++;
	240	*pvid_info = vid_info;
87002b03 JP	241	return 0;
87002b03 JP	242	}
5b9ea6e0	243
80d5c368	244	int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid)
5b9ea6e0 JP	245	{
	246	struct vlan_info *vlan_info;
	247	struct vlan_vid_info *vid_info;
	248	bool vlan_info_created = false;
	249	int err;
	250
	251	ASSERT_RTNL();
	252
	253	vlan_info = rtnl_dereference(dev->vlan_info);
	254	if (!vlan_info) {
	255	vlan_info = vlan_info_alloc(dev);
	256	if (!vlan_info)
	257	return -ENOMEM;
	258	vlan_info_created = true;
	259	}
80d5c368	260	vid_info = vlan_vid_info_get(vlan_info, proto, vid);
5b9ea6e0	261	if (!vid_info) {
80d5c368	262	err = __vlan_vid_add(vlan_info, proto, vid, &vid_info);
5b9ea6e0 JP	263	if (err)
	264	goto out_free_vlan_info;
	265	}
	266	vid_info->refcount++;
	267
	268	if (vlan_info_created)
	269	rcu_assign_pointer(dev->vlan_info, vlan_info);
	270
	271	return 0;
	272
	273	out_free_vlan_info:
	274	if (vlan_info_created)
	275	kfree(vlan_info);
	276	return err;
	277	}
87002b03 JP	278	EXPORT_SYMBOL(vlan_vid_add);
87002b03 JP	279
5b9ea6e0 JP	280	static void __vlan_vid_del(struct vlan_info *vlan_info,
5b9ea6e0 JP	281	struct vlan_vid_info *vid_info)
87002b03	282	{
5b9ea6e0	283	struct net_device *dev = vlan_info->real_dev;
87002b03	284	const struct net_device_ops *ops = dev->netdev_ops;
80d5c368 PM	285	__be16 proto = vid_info->proto;
80d5c368 PM	286	u16 vid = vid_info->vid;
5b9ea6e0	287	int err;
87002b03	288
80d5c368 PM	289	if (proto == htons(ETH_P_8021Q) &&
	290	dev->features & NETIF_F_HW_VLAN_CTAG_FILTER) {
	291	err = ops->ndo_vlan_rx_kill_vid(dev, proto, vid);
5b9ea6e0	292	if (err) {
80d5c368 PM	293	pr_warn("failed to kill vid %04x/%d for device %s\n",
80d5c368 PM	294	proto, vid, dev->name);
5b9ea6e0 JP	295	}
	296	}
	297	list_del(&vid_info->list);
	298	kfree(vid_info);
	299	vlan_info->nr_vids--;
	300	}
	301
80d5c368	302	void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid)
5b9ea6e0 JP	303	{
	304	struct vlan_info *vlan_info;
	305	struct vlan_vid_info *vid_info;
	306
	307	ASSERT_RTNL();
	308
	309	vlan_info = rtnl_dereference(dev->vlan_info);
	310	if (!vlan_info)
	311	return;
	312
80d5c368	313	vid_info = vlan_vid_info_get(vlan_info, proto, vid);
5b9ea6e0 JP	314	if (!vid_info)
	315	return;
	316	vid_info->refcount--;
	317	if (vid_info->refcount == 0) {
	318	__vlan_vid_del(vlan_info, vid_info);
	319	if (vlan_info->nr_vids == 0) {
	320	RCU_INIT_POINTER(dev->vlan_info, NULL);
	321	call_rcu(&vlan_info->rcu, vlan_info_rcu_free);
	322	}
87002b03 JP	323	}
	324	}
	325	EXPORT_SYMBOL(vlan_vid_del);
348a1443 JP	326
	327	int vlan_vids_add_by_dev(struct net_device *dev,
	328	const struct net_device *by_dev)
	329	{
	330	struct vlan_vid_info *vid_info;
f9586f79	331	struct vlan_info *vlan_info;
348a1443 JP	332	int err;
	333
	334	ASSERT_RTNL();
	335
f9586f79 DC	336	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	337	if (!vlan_info)
348a1443 JP	338	return 0;
348a1443 JP	339
f9586f79	340	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
80d5c368	341	err = vlan_vid_add(dev, vid_info->proto, vid_info->vid);
348a1443 JP	342	if (err)
	343	goto unwind;
	344	}
	345	return 0;
	346
	347	unwind:
	348	list_for_each_entry_continue_reverse(vid_info,
f9586f79	349	&vlan_info->vid_list,
348a1443	350	list) {
80d5c368	351	vlan_vid_del(dev, vid_info->proto, vid_info->vid);
348a1443 JP	352	}
	353
	354	return err;
	355	}
	356	EXPORT_SYMBOL(vlan_vids_add_by_dev);
	357
	358	void vlan_vids_del_by_dev(struct net_device *dev,
	359	const struct net_device *by_dev)
	360	{
	361	struct vlan_vid_info *vid_info;
f9586f79	362	struct vlan_info *vlan_info;
348a1443 JP	363
	364	ASSERT_RTNL();
	365
f9586f79 DC	366	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	367	if (!vlan_info)
348a1443 JP	368	return;
348a1443 JP	369
f9586f79	370	list_for_each_entry(vid_info, &vlan_info->vid_list, list)
80d5c368	371	vlan_vid_del(dev, vid_info->proto, vid_info->vid);
348a1443 JP	372	}
348a1443 JP	373	EXPORT_SYMBOL(vlan_vids_del_by_dev);
9b361c13 JP	374
	375	bool vlan_uses_dev(const struct net_device *dev)
	376	{
55462cf3 JP	377	struct vlan_info *vlan_info;
	378
	379	ASSERT_RTNL();
	380
	381	vlan_info = rtnl_dereference(dev->vlan_info);
	382	if (!vlan_info)
	383	return false;
	384	return vlan_info->grp.nr_vlan_devs ? true : false;
9b361c13 JP	385	}
9b361c13 JP	386	EXPORT_SYMBOL(vlan_uses_dev);