[linux-2.6-block.git] / net / 8021q / vlan_core.c

// SPDX-License-Identifier: GPL-2.0
#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;
	__be16 vlan_proto = skb->vlan_proto;
	u16 vlan_id = skb_vlan_tag_get_id(skb);
	struct net_device *vlan_dev;
	struct vlan_pcpu_stats *rx_stats;

	vlan_dev = vlan_find_dev(skb->dev, vlan_proto, vlan_id);
	if (!vlan_dev)
		return false;

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

	if (unlikely(!(vlan_dev->flags & IFF_UP))) {
		kfree_skb(skb);
		*skbp = NULL;
		return false;
	}

	skb->dev = vlan_dev;
	if (unlikely(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_64bits(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) &&
	    !netif_is_macvlan_port(vlan_dev) &&
	    !netif_is_bridge_port(vlan_dev)) {
		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_inner_tag(skb, skb->vlan_proto,
						    skb->vlan_tci, skb->mac_len);
		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_rcu(struct net_device *dev,
					__be16 vlan_proto, 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_proto, 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_rcu(upper_dev,
						    vlan_proto, vlan_id);
	}

	return NULL;
}
EXPORT_SYMBOL(__vlan_find_dev_deep_rcu);

struct net_device *vlan_dev_real_dev(const struct net_device *dev)
{
	struct net_device *ret = vlan_dev_priv(dev)->real_dev;

	while (is_vlan_dev(ret))
		ret = vlan_dev_priv(ret)->real_dev;

	return ret;
}
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);

__be16 vlan_dev_vlan_proto(const struct net_device *dev)
{
	return vlan_dev_priv(dev)->vlan_proto;
}
EXPORT_SYMBOL(vlan_dev_vlan_proto);

/*
 * vlan info and vid list
 */

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

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

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 bool vlan_hw_filter_capable(const struct net_device *dev, __be16 proto)
{
	if (proto == htons(ETH_P_8021Q) &&
	    dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
		return true;
	if (proto == htons(ETH_P_8021AD) &&
	    dev->features & NETIF_F_HW_VLAN_STAG_FILTER)
		return true;
	return false;
}

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_add_rx_filter_info(struct net_device *dev, __be16 proto, u16 vid)
{
	if (!vlan_hw_filter_capable(dev, proto))
		return 0;

	if (netif_device_present(dev))
		return dev->netdev_ops->ndo_vlan_rx_add_vid(dev, proto, vid);
	else
		return -ENODEV;
}

static int vlan_kill_rx_filter_info(struct net_device *dev, __be16 proto, u16 vid)
{
	if (!vlan_hw_filter_capable(dev, proto))
		return 0;

	if (netif_device_present(dev))
		return dev->netdev_ops->ndo_vlan_rx_kill_vid(dev, proto, vid);
	else
		return -ENODEV;
}

int vlan_filter_push_vids(struct vlan_info *vlan_info, __be16 proto)
{
	struct net_device *real_dev = vlan_info->real_dev;
	struct vlan_vid_info *vlan_vid_info;
	int err;

	list_for_each_entry(vlan_vid_info, &vlan_info->vid_list, list) {
		if (vlan_vid_info->proto == proto) {
			err = vlan_add_rx_filter_info(real_dev, proto,
						      vlan_vid_info->vid);
			if (err)
				goto unwind;
		}
	}

	return 0;

unwind:
	list_for_each_entry_continue_reverse(vlan_vid_info,
					     &vlan_info->vid_list, list) {
		if (vlan_vid_info->proto == proto)
			vlan_kill_rx_filter_info(real_dev, proto,
						 vlan_vid_info->vid);
	}

	return err;
}
EXPORT_SYMBOL(vlan_filter_push_vids);

void vlan_filter_drop_vids(struct vlan_info *vlan_info, __be16 proto)
{
	struct vlan_vid_info *vlan_vid_info;

	list_for_each_entry(vlan_vid_info, &vlan_info->vid_list, list)
		if (vlan_vid_info->proto == proto)
			vlan_kill_rx_filter_info(vlan_info->real_dev,
						 vlan_vid_info->proto,
						 vlan_vid_info->vid);
}
EXPORT_SYMBOL(vlan_filter_drop_vids);

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;
	struct vlan_vid_info *vid_info;
	int err;

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

	err = vlan_add_rx_filter_info(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;
	__be16 proto = vid_info->proto;
	u16 vid = vid_info->vid;
	int err;

	err = vlan_kill_rx_filter_info(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
b2441318	1	// SPDX-License-Identifier: GPL-2.0
7750f403 PM	2	#include <linux/skbuff.h>
	3	#include <linux/netdevice.h>
	4	#include <linux/if_vlan.h>
4ead4431	5	#include <linux/netpoll.h>
bc3b2d7f	6	#include <linux/export.h>
7750f403 PM	7	#include "vlan.h"
7750f403 PM	8
48cc32d3	9	bool vlan_do_receive(struct sk_buff **skbp)
7750f403	10	{
3701e513	11	struct sk_buff skb = skbp;
86a9bad3	12	__be16 vlan_proto = skb->vlan_proto;
df8a39de	13	u16 vlan_id = skb_vlan_tag_get_id(skb);
ad1afb00	14	struct net_device *vlan_dev;
4af429d2	15	struct vlan_pcpu_stats *rx_stats;
7750f403	16
86a9bad3	17	vlan_dev = vlan_find_dev(skb->dev, vlan_proto, vlan_id);
48cc32d3	18	if (!vlan_dev)
3701e513	19	return false;
9b22ea56	20
3701e513 JG	21	skb = *skbp = skb_share_check(skb, GFP_ATOMIC);
	22	if (unlikely(!skb))
	23	return false;
e769fcec VN	24
	25	if (unlikely(!(vlan_dev->flags & IFF_UP))) {
	26	kfree_skb(skb);
	27	*skbp = NULL;
	28	return false;
	29	}
e1c096e2	30
3701e513	31	skb->dev = vlan_dev;
375f67df	32	if (unlikely(skb->pkt_type == PACKET_OTHERHOST)) {
0b5c9db1 JP	33	/* Our lower layer thinks this is not local, let's make sure.
	34	* This allows the VLAN to have a different MAC than the
	35	* underlying device, and still route correctly. */
be14cc98	36	if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest, vlan_dev->dev_addr))
0b5c9db1 JP	37	skb->pkt_type = PACKET_HOST;
	38	}
	39
28f9ee22 VY	40	if (!(vlan_dev_priv(vlan_dev)->flags & VLAN_FLAG_REORDER_HDR) &&
	41	!netif_is_macvlan_port(vlan_dev) &&
	42	!netif_is_bridge_port(vlan_dev)) {
0b5c9db1 JP	43	unsigned int offset = skb->data - skb_mac_header(skb);
	44
	45	/*
	46	* vlan_insert_tag expect skb->data pointing to mac header.
	47	* So change skb->data before calling it and change back to
	48	* original position later
	49	*/
	50	skb_push(skb, offset);
cbe7128c TM	51	skb = *skbp = vlan_insert_inner_tag(skb, skb->vlan_proto,
cbe7128c TM	52	skb->vlan_tci, skb->mac_len);
0b5c9db1 JP	53	if (!skb)
	54	return false;
	55	skb_pull(skb, offset + VLAN_HLEN);
	56	skb_reset_mac_len(skb);
	57	}
	58
3701e513	59	skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci);
bc1d0411	60	skb->vlan_tci = 0;
7750f403	61
7da82c06	62	rx_stats = this_cpu_ptr(vlan_dev_priv(vlan_dev)->vlan_pcpu_stats);
9793241f	63
9618e2ff	64	u64_stats_update_begin(&rx_stats->syncp);
9793241f ED	65	rx_stats->rx_packets++;
9793241f ED	66	rx_stats->rx_bytes += skb->len;
0b5c9db1	67	if (skb->pkt_type == PACKET_MULTICAST)
9618e2ff	68	rx_stats->rx_multicast++;
9618e2ff	69	u64_stats_update_end(&rx_stats->syncp);
3701e513 JG	70
3701e513 JG	71	return true;
7750f403	72	}
22d1ba74	73
1cdfd72f	74	/* Must be invoked with rcu_read_lock. */
f06c7f9f	75	struct net_device __vlan_find_dev_deep_rcu(struct net_device dev,
1fd9b1fc	76	__be16 vlan_proto, u16 vlan_id)
cec9c133	77	{
1cdfd72f	78	struct vlan_info *vlan_info = rcu_dereference(dev->vlan_info);
cec9c133	79
5b9ea6e0	80	if (vlan_info) {
1fd9b1fc PM	81	return vlan_group_get_device(&vlan_info->grp,
1fd9b1fc PM	82	vlan_proto, vlan_id);
cec9c133 JP	83	} else {
cec9c133 JP	84	/*
1cdfd72f JP	85	* Lower devices of master uppers (bonding, team) do not have
	86	* grp assigned to themselves. Grp is assigned to upper device
	87	* instead.
cec9c133	88	*/
1cdfd72f JP	89	struct net_device *upper_dev;
	90
	91	upper_dev = netdev_master_upper_dev_get_rcu(dev);
	92	if (upper_dev)
f06c7f9f	93	return __vlan_find_dev_deep_rcu(upper_dev,
1fd9b1fc	94	vlan_proto, vlan_id);
cec9c133 JP	95	}
	96
	97	return NULL;
	98	}
f06c7f9f	99	EXPORT_SYMBOL(__vlan_find_dev_deep_rcu);
cec9c133	100
22d1ba74 PM	101	struct net_device vlan_dev_real_dev(const struct net_device dev)
22d1ba74 PM	102	{
0369722f	103	struct net_device *ret = vlan_dev_priv(dev)->real_dev;
	104
	105	while (is_vlan_dev(ret))
	106	ret = vlan_dev_priv(ret)->real_dev;
	107
	108	return ret;
22d1ba74	109	}
116cb428	110	EXPORT_SYMBOL(vlan_dev_real_dev);
22d1ba74 PM	111
	112	u16 vlan_dev_vlan_id(const struct net_device *dev)
	113	{
7da82c06	114	return vlan_dev_priv(dev)->vlan_id;
22d1ba74	115	}
116cb428	116	EXPORT_SYMBOL(vlan_dev_vlan_id);
e1c096e2	117
71e415e4	118	__be16 vlan_dev_vlan_proto(const struct net_device *dev)
	119	{
	120	return vlan_dev_priv(dev)->vlan_proto;
	121	}
	122	EXPORT_SYMBOL(vlan_dev_vlan_proto);
	123
5b9ea6e0 JP	124	/*
	125	* vlan info and vid list
	126	*/
	127
	128	static void vlan_group_free(struct vlan_group *grp)
	129	{
cf2c014a	130	int i, j;
5b9ea6e0	131
cf2c014a PM	132	for (i = 0; i < VLAN_PROTO_NUM; i++)
	133	for (j = 0; j < VLAN_GROUP_ARRAY_SPLIT_PARTS; j++)
	134	kfree(grp->vlan_devices_arrays[i][j]);
5b9ea6e0 JP	135	}
	136
	137	static void vlan_info_free(struct vlan_info *vlan_info)
	138	{
	139	vlan_group_free(&vlan_info->grp);
	140	kfree(vlan_info);
	141	}
	142
	143	static void vlan_info_rcu_free(struct rcu_head *rcu)
	144	{
	145	vlan_info_free(container_of(rcu, struct vlan_info, rcu));
	146	}
	147
	148	static struct vlan_info vlan_info_alloc(struct net_device dev)
	149	{
	150	struct vlan_info *vlan_info;
	151
	152	vlan_info = kzalloc(sizeof(struct vlan_info), GFP_KERNEL);
	153	if (!vlan_info)
	154	return NULL;
	155
	156	vlan_info->real_dev = dev;
	157	INIT_LIST_HEAD(&vlan_info->vid_list);
	158	return vlan_info;
	159	}
	160
	161	struct vlan_vid_info {
	162	struct list_head list;
80d5c368 PM	163	__be16 proto;
80d5c368 PM	164	u16 vid;
5b9ea6e0 JP	165	int refcount;
	166	};
	167
eeb0a2a5	168	static bool vlan_hw_filter_capable(const struct net_device *dev, __be16 proto)
8ad227ff	169	{
9daae9bd	170	if (proto == htons(ETH_P_8021Q) &&
8ad227ff PM	171	dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
8ad227ff PM	172	return true;
9daae9bd	173	if (proto == htons(ETH_P_8021AD) &&
8ad227ff PM	174	dev->features & NETIF_F_HW_VLAN_STAG_FILTER)
	175	return true;
	176	return false;
	177	}
	178
5b9ea6e0	179	static struct vlan_vid_info vlan_vid_info_get(struct vlan_info vlan_info,
80d5c368	180	__be16 proto, u16 vid)
5b9ea6e0 JP	181	{
	182	struct vlan_vid_info *vid_info;
	183
	184	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
80d5c368	185	if (vid_info->proto == proto && vid_info->vid == vid)
5b9ea6e0 JP	186	return vid_info;
	187	}
	188	return NULL;
	189	}
	190
80d5c368	191	static struct vlan_vid_info *vlan_vid_info_alloc(__be16 proto, u16 vid)
5b9ea6e0 JP	192	{
	193	struct vlan_vid_info *vid_info;
	194
	195	vid_info = kzalloc(sizeof(struct vlan_vid_info), GFP_KERNEL);
	196	if (!vid_info)
	197	return NULL;
80d5c368	198	vid_info->proto = proto;
5b9ea6e0 JP	199	vid_info->vid = vid;
	200
	201	return vid_info;
	202	}
	203
9daae9bd GP	204	static int vlan_add_rx_filter_info(struct net_device *dev, __be16 proto, u16 vid)
	205	{
	206	if (!vlan_hw_filter_capable(dev, proto))
	207	return 0;
	208
	209	if (netif_device_present(dev))
	210	return dev->netdev_ops->ndo_vlan_rx_add_vid(dev, proto, vid);
	211	else
	212	return -ENODEV;
	213	}
	214
	215	static int vlan_kill_rx_filter_info(struct net_device *dev, __be16 proto, u16 vid)
	216	{
	217	if (!vlan_hw_filter_capable(dev, proto))
	218	return 0;
	219
	220	if (netif_device_present(dev))
	221	return dev->netdev_ops->ndo_vlan_rx_kill_vid(dev, proto, vid);
	222	else
	223	return -ENODEV;
	224	}
	225
	226	int vlan_filter_push_vids(struct vlan_info *vlan_info, __be16 proto)
	227	{
	228	struct net_device *real_dev = vlan_info->real_dev;
	229	struct vlan_vid_info *vlan_vid_info;
	230	int err;
	231
	232	list_for_each_entry(vlan_vid_info, &vlan_info->vid_list, list) {
	233	if (vlan_vid_info->proto == proto) {
	234	err = vlan_add_rx_filter_info(real_dev, proto,
	235	vlan_vid_info->vid);
	236	if (err)
	237	goto unwind;
	238	}
	239	}
	240
	241	return 0;
	242
	243	unwind:
	244	list_for_each_entry_continue_reverse(vlan_vid_info,
	245	&vlan_info->vid_list, list) {
	246	if (vlan_vid_info->proto == proto)
	247	vlan_kill_rx_filter_info(real_dev, proto,
	248	vlan_vid_info->vid);
	249	}
	250
	251	return err;
	252	}
	253	EXPORT_SYMBOL(vlan_filter_push_vids);
	254
	255	void vlan_filter_drop_vids(struct vlan_info *vlan_info, __be16 proto)
	256	{
	257	struct vlan_vid_info *vlan_vid_info;
	258
	259	list_for_each_entry(vlan_vid_info, &vlan_info->vid_list, list)
	260	if (vlan_vid_info->proto == proto)
	261	vlan_kill_rx_filter_info(vlan_info->real_dev,
	262	vlan_vid_info->proto,
	263	vlan_vid_info->vid);
	264	}
	265	EXPORT_SYMBOL(vlan_filter_drop_vids);
	266
80d5c368	267	static int __vlan_vid_add(struct vlan_info *vlan_info, __be16 proto, u16 vid,
5b9ea6e0	268	struct vlan_vid_info **pvid_info)
87002b03	269	{
5b9ea6e0	270	struct net_device *dev = vlan_info->real_dev;
5b9ea6e0 JP	271	struct vlan_vid_info *vid_info;
	272	int err;
	273
80d5c368	274	vid_info = vlan_vid_info_alloc(proto, vid);
5b9ea6e0 JP	275	if (!vid_info)
5b9ea6e0 JP	276	return -ENOMEM;
87002b03	277
9daae9bd GP	278	err = vlan_add_rx_filter_info(dev, proto, vid);
	279	if (err) {
	280	kfree(vid_info);
	281	return err;
87002b03	282	}
9daae9bd	283
5b9ea6e0 JP	284	list_add(&vid_info->list, &vlan_info->vid_list);
	285	vlan_info->nr_vids++;
	286	*pvid_info = vid_info;
87002b03 JP	287	return 0;
87002b03 JP	288	}
5b9ea6e0	289
80d5c368	290	int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid)
5b9ea6e0 JP	291	{
	292	struct vlan_info *vlan_info;
	293	struct vlan_vid_info *vid_info;
	294	bool vlan_info_created = false;
	295	int err;
	296
	297	ASSERT_RTNL();
	298
	299	vlan_info = rtnl_dereference(dev->vlan_info);
	300	if (!vlan_info) {
	301	vlan_info = vlan_info_alloc(dev);
	302	if (!vlan_info)
	303	return -ENOMEM;
	304	vlan_info_created = true;
	305	}
80d5c368	306	vid_info = vlan_vid_info_get(vlan_info, proto, vid);
5b9ea6e0	307	if (!vid_info) {
80d5c368	308	err = __vlan_vid_add(vlan_info, proto, vid, &vid_info);
5b9ea6e0 JP	309	if (err)
	310	goto out_free_vlan_info;
	311	}
	312	vid_info->refcount++;
	313
	314	if (vlan_info_created)
	315	rcu_assign_pointer(dev->vlan_info, vlan_info);
	316
	317	return 0;
	318
	319	out_free_vlan_info:
	320	if (vlan_info_created)
	321	kfree(vlan_info);
	322	return err;
	323	}
87002b03 JP	324	EXPORT_SYMBOL(vlan_vid_add);
87002b03 JP	325
5b9ea6e0 JP	326	static void __vlan_vid_del(struct vlan_info *vlan_info,
5b9ea6e0 JP	327	struct vlan_vid_info *vid_info)
87002b03	328	{
5b9ea6e0	329	struct net_device *dev = vlan_info->real_dev;
80d5c368 PM	330	__be16 proto = vid_info->proto;
80d5c368 PM	331	u16 vid = vid_info->vid;
5b9ea6e0	332	int err;
87002b03	333
9daae9bd GP	334	err = vlan_kill_rx_filter_info(dev, proto, vid);
	335	if (err)
	336	pr_warn("failed to kill vid %04x/%d for device %s\n",
	337	proto, vid, dev->name);
	338
5b9ea6e0 JP	339	list_del(&vid_info->list);
	340	kfree(vid_info);
	341	vlan_info->nr_vids--;
	342	}
	343
80d5c368	344	void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid)
5b9ea6e0 JP	345	{
	346	struct vlan_info *vlan_info;
	347	struct vlan_vid_info *vid_info;
	348
	349	ASSERT_RTNL();
	350
	351	vlan_info = rtnl_dereference(dev->vlan_info);
	352	if (!vlan_info)
	353	return;
	354
80d5c368	355	vid_info = vlan_vid_info_get(vlan_info, proto, vid);
5b9ea6e0 JP	356	if (!vid_info)
	357	return;
	358	vid_info->refcount--;
	359	if (vid_info->refcount == 0) {
	360	__vlan_vid_del(vlan_info, vid_info);
	361	if (vlan_info->nr_vids == 0) {
	362	RCU_INIT_POINTER(dev->vlan_info, NULL);
	363	call_rcu(&vlan_info->rcu, vlan_info_rcu_free);
	364	}
87002b03 JP	365	}
	366	}
	367	EXPORT_SYMBOL(vlan_vid_del);
348a1443 JP	368
	369	int vlan_vids_add_by_dev(struct net_device *dev,
	370	const struct net_device *by_dev)
	371	{
	372	struct vlan_vid_info *vid_info;
f9586f79	373	struct vlan_info *vlan_info;
348a1443 JP	374	int err;
	375
	376	ASSERT_RTNL();
	377
f9586f79 DC	378	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	379	if (!vlan_info)
348a1443 JP	380	return 0;
348a1443 JP	381
f9586f79	382	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
80d5c368	383	err = vlan_vid_add(dev, vid_info->proto, vid_info->vid);
348a1443 JP	384	if (err)
	385	goto unwind;
	386	}
	387	return 0;
	388
	389	unwind:
	390	list_for_each_entry_continue_reverse(vid_info,
f9586f79	391	&vlan_info->vid_list,
348a1443	392	list) {
80d5c368	393	vlan_vid_del(dev, vid_info->proto, vid_info->vid);
348a1443 JP	394	}
	395
	396	return err;
	397	}
	398	EXPORT_SYMBOL(vlan_vids_add_by_dev);
	399
	400	void vlan_vids_del_by_dev(struct net_device *dev,
	401	const struct net_device *by_dev)
	402	{
	403	struct vlan_vid_info *vid_info;
f9586f79	404	struct vlan_info *vlan_info;
348a1443 JP	405
	406	ASSERT_RTNL();
	407
f9586f79 DC	408	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	409	if (!vlan_info)
348a1443 JP	410	return;
348a1443 JP	411
f9586f79	412	list_for_each_entry(vid_info, &vlan_info->vid_list, list)
80d5c368	413	vlan_vid_del(dev, vid_info->proto, vid_info->vid);
348a1443 JP	414	}
348a1443 JP	415	EXPORT_SYMBOL(vlan_vids_del_by_dev);
9b361c13 JP	416
	417	bool vlan_uses_dev(const struct net_device *dev)
	418	{
55462cf3 JP	419	struct vlan_info *vlan_info;
	420
	421	ASSERT_RTNL();
	422
	423	vlan_info = rtnl_dereference(dev->vlan_info);
	424	if (!vlan_info)
	425	return false;
	426	return vlan_info->grp.nr_vlan_devs ? true : false;
9b361c13 JP	427	}
9b361c13 JP	428	EXPORT_SYMBOL(vlan_uses_dev);