[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 <net/gro.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);
	__vlan_hwaccel_clear_tag(skb);

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

	u64_stats_update_begin(&rx_stats->syncp);
	u64_stats_inc(&rx_stats->rx_packets);
	u64_stats_add(&rx_stats->rx_bytes, skb->len);
	if (skb->pkt_type == PACKET_MULTICAST)
		u64_stats_inc(&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_for_each(struct net_device *dev,
		  int (*action)(struct net_device *dev, int vid, void *arg),
		  void *arg)
{
	struct vlan_vid_info *vid_info;
	struct vlan_info *vlan_info;
	struct net_device *vdev;
	int ret;

	ASSERT_RTNL();

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

	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
		vdev = vlan_group_get_device(&vlan_info->grp, vid_info->proto,
					     vid_info->vid);
		ret = action(vdev, vid_info->vid, arg);
		if (ret)
			return ret;
	}

	return 0;
}
EXPORT_SYMBOL(vlan_for_each);

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 && dev->reg_state != NETREG_UNREGISTERING)
		netdev_warn(dev, "failed to kill vid %04x/%d\n", proto, vid);

	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);

static struct sk_buff *vlan_gro_receive(struct list_head *head,
					struct sk_buff *skb)
{
	const struct packet_offload *ptype;
	unsigned int hlen, off_vlan;
	struct sk_buff *pp = NULL;
	struct vlan_hdr *vhdr;
	struct sk_buff *p;
	__be16 type;
	int flush = 1;

	off_vlan = skb_gro_offset(skb);
	hlen = off_vlan + sizeof(*vhdr);
	vhdr = skb_gro_header(skb, hlen, off_vlan);
	if (unlikely(!vhdr))
		goto out;

	type = vhdr->h_vlan_encapsulated_proto;

	ptype = gro_find_receive_by_type(type);
	if (!ptype)
		goto out;

	flush = 0;

	list_for_each_entry(p, head, list) {
		struct vlan_hdr *vhdr2;

		if (!NAPI_GRO_CB(p)->same_flow)
			continue;

		vhdr2 = (struct vlan_hdr *)(p->data + off_vlan);
		if (compare_vlan_header(vhdr, vhdr2))
			NAPI_GRO_CB(p)->same_flow = 0;
	}

	skb_gro_pull(skb, sizeof(*vhdr));
	skb_gro_postpull_rcsum(skb, vhdr, sizeof(*vhdr));

	pp = indirect_call_gro_receive_inet(ptype->callbacks.gro_receive,
					    ipv6_gro_receive, inet_gro_receive,
					    head, skb);

out:
	skb_gro_flush_final(skb, pp, flush);

	return pp;
}

static int vlan_gro_complete(struct sk_buff *skb, int nhoff)
{
	struct vlan_hdr *vhdr = (struct vlan_hdr *)(skb->data + nhoff);
	__be16 type = vhdr->h_vlan_encapsulated_proto;
	struct packet_offload *ptype;
	int err = -ENOENT;

	ptype = gro_find_complete_by_type(type);
	if (ptype)
		err = INDIRECT_CALL_INET(ptype->callbacks.gro_complete,
					 ipv6_gro_complete, inet_gro_complete,
					 skb, nhoff + sizeof(*vhdr));

	return err;
}

static struct packet_offload vlan_packet_offloads[] __read_mostly = {
	{
		.type = cpu_to_be16(ETH_P_8021Q),
		.priority = 10,
		.callbacks = {
			.gro_receive = vlan_gro_receive,
			.gro_complete = vlan_gro_complete,
		},
	},
	{
		.type = cpu_to_be16(ETH_P_8021AD),
		.priority = 10,
		.callbacks = {
			.gro_receive = vlan_gro_receive,
			.gro_complete = vlan_gro_complete,
		},
	},
};

static int __init vlan_offload_init(void)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(vlan_packet_offloads); i++)
		dev_add_offload(&vlan_packet_offloads[i]);

	return 0;
}

fs_initcall(vlan_offload_init);
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>
4a6e7ec9	7	#include <net/gro.h>
7750f403 PM	8	#include "vlan.h"
7750f403 PM	9
48cc32d3	10	bool vlan_do_receive(struct sk_buff **skbp)
7750f403	11	{
3701e513	12	struct sk_buff skb = skbp;
86a9bad3	13	__be16 vlan_proto = skb->vlan_proto;
df8a39de	14	u16 vlan_id = skb_vlan_tag_get_id(skb);
ad1afb00	15	struct net_device *vlan_dev;
4af429d2	16	struct vlan_pcpu_stats *rx_stats;
7750f403	17
86a9bad3	18	vlan_dev = vlan_find_dev(skb->dev, vlan_proto, vlan_id);
48cc32d3	19	if (!vlan_dev)
3701e513	20	return false;
9b22ea56	21
3701e513 JG	22	skb = *skbp = skb_share_check(skb, GFP_ATOMIC);
	23	if (unlikely(!skb))
	24	return false;
e769fcec VN	25
	26	if (unlikely(!(vlan_dev->flags & IFF_UP))) {
	27	kfree_skb(skb);
	28	*skbp = NULL;
	29	return false;
	30	}
e1c096e2	31
3701e513	32	skb->dev = vlan_dev;
375f67df	33	if (unlikely(skb->pkt_type == PACKET_OTHERHOST)) {
0b5c9db1 JP	34	/* Our lower layer thinks this is not local, let's make sure.
	35	* This allows the VLAN to have a different MAC than the
	36	* underlying device, and still route correctly. */
be14cc98	37	if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest, vlan_dev->dev_addr))
0b5c9db1 JP	38	skb->pkt_type = PACKET_HOST;
	39	}
	40
28f9ee22 VY	41	if (!(vlan_dev_priv(vlan_dev)->flags & VLAN_FLAG_REORDER_HDR) &&
	42	!netif_is_macvlan_port(vlan_dev) &&
	43	!netif_is_bridge_port(vlan_dev)) {
0b5c9db1 JP	44	unsigned int offset = skb->data - skb_mac_header(skb);
	45
	46	/*
	47	* vlan_insert_tag expect skb->data pointing to mac header.
	48	* So change skb->data before calling it and change back to
	49	* original position later
	50	*/
	51	skb_push(skb, offset);
cbe7128c TM	52	skb = *skbp = vlan_insert_inner_tag(skb, skb->vlan_proto,
cbe7128c TM	53	skb->vlan_tci, skb->mac_len);
0b5c9db1 JP	54	if (!skb)
	55	return false;
	56	skb_pull(skb, offset + VLAN_HLEN);
	57	skb_reset_mac_len(skb);
	58	}
	59
3701e513	60	skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci);
418a976d	61	__vlan_hwaccel_clear_tag(skb);
7750f403	62
7da82c06	63	rx_stats = this_cpu_ptr(vlan_dev_priv(vlan_dev)->vlan_pcpu_stats);
9793241f	64
9618e2ff	65	u64_stats_update_begin(&rx_stats->syncp);
09cca53c ED	66	u64_stats_inc(&rx_stats->rx_packets);
09cca53c ED	67	u64_stats_add(&rx_stats->rx_bytes, skb->len);
0b5c9db1	68	if (skb->pkt_type == PACKET_MULTICAST)
09cca53c	69	u64_stats_inc(&rx_stats->rx_multicast);
9618e2ff	70	u64_stats_update_end(&rx_stats->syncp);
3701e513 JG	71
3701e513 JG	72	return true;
7750f403	73	}
22d1ba74	74
1cdfd72f	75	/* Must be invoked with rcu_read_lock. */
f06c7f9f	76	struct net_device __vlan_find_dev_deep_rcu(struct net_device dev,
1fd9b1fc	77	__be16 vlan_proto, u16 vlan_id)
cec9c133	78	{
1cdfd72f	79	struct vlan_info *vlan_info = rcu_dereference(dev->vlan_info);
cec9c133	80
5b9ea6e0	81	if (vlan_info) {
1fd9b1fc PM	82	return vlan_group_get_device(&vlan_info->grp,
1fd9b1fc PM	83	vlan_proto, vlan_id);
cec9c133 JP	84	} else {
cec9c133 JP	85	/*
1cdfd72f JP	86	* Lower devices of master uppers (bonding, team) do not have
	87	* grp assigned to themselves. Grp is assigned to upper device
	88	* instead.
cec9c133	89	*/
1cdfd72f JP	90	struct net_device *upper_dev;
	91
	92	upper_dev = netdev_master_upper_dev_get_rcu(dev);
	93	if (upper_dev)
f06c7f9f	94	return __vlan_find_dev_deep_rcu(upper_dev,
1fd9b1fc	95	vlan_proto, vlan_id);
cec9c133 JP	96	}
	97
	98	return NULL;
	99	}
f06c7f9f	100	EXPORT_SYMBOL(__vlan_find_dev_deep_rcu);
cec9c133	101
22d1ba74 PM	102	struct net_device vlan_dev_real_dev(const struct net_device dev)
22d1ba74 PM	103	{
0369722f	104	struct net_device *ret = vlan_dev_priv(dev)->real_dev;
	105
	106	while (is_vlan_dev(ret))
	107	ret = vlan_dev_priv(ret)->real_dev;
	108
	109	return ret;
22d1ba74	110	}
116cb428	111	EXPORT_SYMBOL(vlan_dev_real_dev);
22d1ba74 PM	112
	113	u16 vlan_dev_vlan_id(const struct net_device *dev)
	114	{
7da82c06	115	return vlan_dev_priv(dev)->vlan_id;
22d1ba74	116	}
116cb428	117	EXPORT_SYMBOL(vlan_dev_vlan_id);
e1c096e2	118
71e415e4	119	__be16 vlan_dev_vlan_proto(const struct net_device *dev)
	120	{
	121	return vlan_dev_priv(dev)->vlan_proto;
	122	}
	123	EXPORT_SYMBOL(vlan_dev_vlan_proto);
	124
5b9ea6e0 JP	125	/*
	126	* vlan info and vid list
	127	*/
	128
	129	static void vlan_group_free(struct vlan_group *grp)
	130	{
cf2c014a	131	int i, j;
5b9ea6e0	132
cf2c014a PM	133	for (i = 0; i < VLAN_PROTO_NUM; i++)
	134	for (j = 0; j < VLAN_GROUP_ARRAY_SPLIT_PARTS; j++)
	135	kfree(grp->vlan_devices_arrays[i][j]);
5b9ea6e0 JP	136	}
	137
	138	static void vlan_info_free(struct vlan_info *vlan_info)
	139	{
	140	vlan_group_free(&vlan_info->grp);
	141	kfree(vlan_info);
	142	}
	143
	144	static void vlan_info_rcu_free(struct rcu_head *rcu)
	145	{
	146	vlan_info_free(container_of(rcu, struct vlan_info, rcu));
	147	}
	148
	149	static struct vlan_info vlan_info_alloc(struct net_device dev)
	150	{
	151	struct vlan_info *vlan_info;
	152
	153	vlan_info = kzalloc(sizeof(struct vlan_info), GFP_KERNEL);
	154	if (!vlan_info)
	155	return NULL;
	156
	157	vlan_info->real_dev = dev;
	158	INIT_LIST_HEAD(&vlan_info->vid_list);
	159	return vlan_info;
	160	}
	161
	162	struct vlan_vid_info {
	163	struct list_head list;
80d5c368 PM	164	__be16 proto;
80d5c368 PM	165	u16 vid;
5b9ea6e0 JP	166	int refcount;
	167	};
	168
eeb0a2a5	169	static bool vlan_hw_filter_capable(const struct net_device *dev, __be16 proto)
8ad227ff	170	{
9daae9bd	171	if (proto == htons(ETH_P_8021Q) &&
8ad227ff PM	172	dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
8ad227ff PM	173	return true;
9daae9bd	174	if (proto == htons(ETH_P_8021AD) &&
8ad227ff PM	175	dev->features & NETIF_F_HW_VLAN_STAG_FILTER)
	176	return true;
	177	return false;
	178	}
	179
5b9ea6e0	180	static struct vlan_vid_info vlan_vid_info_get(struct vlan_info vlan_info,
80d5c368	181	__be16 proto, u16 vid)
5b9ea6e0 JP	182	{
	183	struct vlan_vid_info *vid_info;
	184
	185	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
80d5c368	186	if (vid_info->proto == proto && vid_info->vid == vid)
5b9ea6e0 JP	187	return vid_info;
	188	}
	189	return NULL;
	190	}
	191
80d5c368	192	static struct vlan_vid_info *vlan_vid_info_alloc(__be16 proto, u16 vid)
5b9ea6e0 JP	193	{
	194	struct vlan_vid_info *vid_info;
	195
	196	vid_info = kzalloc(sizeof(struct vlan_vid_info), GFP_KERNEL);
	197	if (!vid_info)
	198	return NULL;
80d5c368	199	vid_info->proto = proto;
5b9ea6e0 JP	200	vid_info->vid = vid;
	201
	202	return vid_info;
	203	}
	204
9daae9bd GP	205	static int vlan_add_rx_filter_info(struct net_device *dev, __be16 proto, u16 vid)
	206	{
	207	if (!vlan_hw_filter_capable(dev, proto))
	208	return 0;
	209
	210	if (netif_device_present(dev))
	211	return dev->netdev_ops->ndo_vlan_rx_add_vid(dev, proto, vid);
	212	else
	213	return -ENODEV;
	214	}
	215
	216	static int vlan_kill_rx_filter_info(struct net_device *dev, __be16 proto, u16 vid)
	217	{
	218	if (!vlan_hw_filter_capable(dev, proto))
	219	return 0;
	220
	221	if (netif_device_present(dev))
	222	return dev->netdev_ops->ndo_vlan_rx_kill_vid(dev, proto, vid);
	223	else
	224	return -ENODEV;
	225	}
	226
960abf68 IK	227	int vlan_for_each(struct net_device *dev,
	228	int (action)(struct net_device dev, int vid, void *arg),
	229	void *arg)
	230	{
	231	struct vlan_vid_info *vid_info;
	232	struct vlan_info *vlan_info;
	233	struct net_device *vdev;
	234	int ret;
	235
	236	ASSERT_RTNL();
	237
	238	vlan_info = rtnl_dereference(dev->vlan_info);
	239	if (!vlan_info)
	240	return 0;
	241
	242	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
	243	vdev = vlan_group_get_device(&vlan_info->grp, vid_info->proto,
	244	vid_info->vid);
	245	ret = action(vdev, vid_info->vid, arg);
	246	if (ret)
	247	return ret;
	248	}
	249
	250	return 0;
	251	}
	252	EXPORT_SYMBOL(vlan_for_each);
	253
9daae9bd GP	254	int vlan_filter_push_vids(struct vlan_info *vlan_info, __be16 proto)
	255	{
	256	struct net_device *real_dev = vlan_info->real_dev;
	257	struct vlan_vid_info *vlan_vid_info;
	258	int err;
	259
	260	list_for_each_entry(vlan_vid_info, &vlan_info->vid_list, list) {
	261	if (vlan_vid_info->proto == proto) {
	262	err = vlan_add_rx_filter_info(real_dev, proto,
	263	vlan_vid_info->vid);
	264	if (err)
	265	goto unwind;
	266	}
	267	}
	268
	269	return 0;
	270
	271	unwind:
	272	list_for_each_entry_continue_reverse(vlan_vid_info,
	273	&vlan_info->vid_list, list) {
	274	if (vlan_vid_info->proto == proto)
	275	vlan_kill_rx_filter_info(real_dev, proto,
	276	vlan_vid_info->vid);
	277	}
	278
	279	return err;
	280	}
	281	EXPORT_SYMBOL(vlan_filter_push_vids);
	282
	283	void vlan_filter_drop_vids(struct vlan_info *vlan_info, __be16 proto)
	284	{
	285	struct vlan_vid_info *vlan_vid_info;
	286
	287	list_for_each_entry(vlan_vid_info, &vlan_info->vid_list, list)
	288	if (vlan_vid_info->proto == proto)
	289	vlan_kill_rx_filter_info(vlan_info->real_dev,
	290	vlan_vid_info->proto,
	291	vlan_vid_info->vid);
	292	}
	293	EXPORT_SYMBOL(vlan_filter_drop_vids);
	294
80d5c368	295	static int __vlan_vid_add(struct vlan_info *vlan_info, __be16 proto, u16 vid,
5b9ea6e0	296	struct vlan_vid_info **pvid_info)
87002b03	297	{
5b9ea6e0	298	struct net_device *dev = vlan_info->real_dev;
5b9ea6e0 JP	299	struct vlan_vid_info *vid_info;
	300	int err;
	301
80d5c368	302	vid_info = vlan_vid_info_alloc(proto, vid);
5b9ea6e0 JP	303	if (!vid_info)
5b9ea6e0 JP	304	return -ENOMEM;
87002b03	305
9daae9bd GP	306	err = vlan_add_rx_filter_info(dev, proto, vid);
	307	if (err) {
	308	kfree(vid_info);
	309	return err;
87002b03	310	}
9daae9bd	311
5b9ea6e0 JP	312	list_add(&vid_info->list, &vlan_info->vid_list);
	313	vlan_info->nr_vids++;
	314	*pvid_info = vid_info;
87002b03 JP	315	return 0;
87002b03 JP	316	}
5b9ea6e0	317
80d5c368	318	int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid)
5b9ea6e0 JP	319	{
	320	struct vlan_info *vlan_info;
	321	struct vlan_vid_info *vid_info;
	322	bool vlan_info_created = false;
	323	int err;
	324
	325	ASSERT_RTNL();
	326
	327	vlan_info = rtnl_dereference(dev->vlan_info);
	328	if (!vlan_info) {
	329	vlan_info = vlan_info_alloc(dev);
	330	if (!vlan_info)
	331	return -ENOMEM;
	332	vlan_info_created = true;
	333	}
80d5c368	334	vid_info = vlan_vid_info_get(vlan_info, proto, vid);
5b9ea6e0	335	if (!vid_info) {
80d5c368	336	err = __vlan_vid_add(vlan_info, proto, vid, &vid_info);
5b9ea6e0 JP	337	if (err)
	338	goto out_free_vlan_info;
	339	}
	340	vid_info->refcount++;
	341
	342	if (vlan_info_created)
	343	rcu_assign_pointer(dev->vlan_info, vlan_info);
	344
	345	return 0;
	346
	347	out_free_vlan_info:
	348	if (vlan_info_created)
	349	kfree(vlan_info);
	350	return err;
	351	}
87002b03 JP	352	EXPORT_SYMBOL(vlan_vid_add);
87002b03 JP	353
5b9ea6e0 JP	354	static void __vlan_vid_del(struct vlan_info *vlan_info,
5b9ea6e0 JP	355	struct vlan_vid_info *vid_info)
87002b03	356	{
5b9ea6e0	357	struct net_device *dev = vlan_info->real_dev;
80d5c368 PM	358	__be16 proto = vid_info->proto;
80d5c368 PM	359	u16 vid = vid_info->vid;
5b9ea6e0	360	int err;
87002b03	361
9daae9bd	362	err = vlan_kill_rx_filter_info(dev, proto, vid);
bd706ff8 JW	363	if (err && dev->reg_state != NETREG_UNREGISTERING)
bd706ff8 JW	364	netdev_warn(dev, "failed to kill vid %04x/%d\n", proto, vid);
9daae9bd	365
5b9ea6e0 JP	366	list_del(&vid_info->list);
	367	kfree(vid_info);
	368	vlan_info->nr_vids--;
	369	}
	370
80d5c368	371	void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid)
5b9ea6e0 JP	372	{
	373	struct vlan_info *vlan_info;
	374	struct vlan_vid_info *vid_info;
	375
	376	ASSERT_RTNL();
	377
	378	vlan_info = rtnl_dereference(dev->vlan_info);
	379	if (!vlan_info)
	380	return;
	381
80d5c368	382	vid_info = vlan_vid_info_get(vlan_info, proto, vid);
5b9ea6e0 JP	383	if (!vid_info)
	384	return;
	385	vid_info->refcount--;
	386	if (vid_info->refcount == 0) {
	387	__vlan_vid_del(vlan_info, vid_info);
	388	if (vlan_info->nr_vids == 0) {
	389	RCU_INIT_POINTER(dev->vlan_info, NULL);
	390	call_rcu(&vlan_info->rcu, vlan_info_rcu_free);
	391	}
87002b03 JP	392	}
	393	}
	394	EXPORT_SYMBOL(vlan_vid_del);
348a1443 JP	395
	396	int vlan_vids_add_by_dev(struct net_device *dev,
	397	const struct net_device *by_dev)
	398	{
	399	struct vlan_vid_info *vid_info;
f9586f79	400	struct vlan_info *vlan_info;
348a1443 JP	401	int err;
	402
	403	ASSERT_RTNL();
	404
f9586f79 DC	405	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	406	if (!vlan_info)
348a1443 JP	407	return 0;
348a1443 JP	408
f9586f79	409	list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
80d5c368	410	err = vlan_vid_add(dev, vid_info->proto, vid_info->vid);
348a1443 JP	411	if (err)
	412	goto unwind;
	413	}
	414	return 0;
	415
	416	unwind:
	417	list_for_each_entry_continue_reverse(vid_info,
f9586f79	418	&vlan_info->vid_list,
348a1443	419	list) {
80d5c368	420	vlan_vid_del(dev, vid_info->proto, vid_info->vid);
348a1443 JP	421	}
	422
	423	return err;
	424	}
	425	EXPORT_SYMBOL(vlan_vids_add_by_dev);
	426
	427	void vlan_vids_del_by_dev(struct net_device *dev,
	428	const struct net_device *by_dev)
	429	{
	430	struct vlan_vid_info *vid_info;
f9586f79	431	struct vlan_info *vlan_info;
348a1443 JP	432
	433	ASSERT_RTNL();
	434
f9586f79 DC	435	vlan_info = rtnl_dereference(by_dev->vlan_info);
f9586f79 DC	436	if (!vlan_info)
348a1443 JP	437	return;
348a1443 JP	438
f9586f79	439	list_for_each_entry(vid_info, &vlan_info->vid_list, list)
80d5c368	440	vlan_vid_del(dev, vid_info->proto, vid_info->vid);
348a1443 JP	441	}
348a1443 JP	442	EXPORT_SYMBOL(vlan_vids_del_by_dev);
9b361c13 JP	443
	444	bool vlan_uses_dev(const struct net_device *dev)
	445	{
55462cf3 JP	446	struct vlan_info *vlan_info;
	447
	448	ASSERT_RTNL();
	449
	450	vlan_info = rtnl_dereference(dev->vlan_info);
	451	if (!vlan_info)
	452	return false;
	453	return vlan_info->grp.nr_vlan_devs ? true : false;
9b361c13 JP	454	}
9b361c13 JP	455	EXPORT_SYMBOL(vlan_uses_dev);
32764c66 JP	456
	457	static struct sk_buff vlan_gro_receive(struct list_head head,
	458	struct sk_buff *skb)
	459	{
	460	const struct packet_offload *ptype;
	461	unsigned int hlen, off_vlan;
	462	struct sk_buff *pp = NULL;
	463	struct vlan_hdr *vhdr;
	464	struct sk_buff *p;
	465	__be16 type;
	466	int flush = 1;
	467
	468	off_vlan = skb_gro_offset(skb);
	469	hlen = off_vlan + sizeof(*vhdr);
35ffb665 RG	470	vhdr = skb_gro_header(skb, hlen, off_vlan);
	471	if (unlikely(!vhdr))
	472	goto out;
32764c66 JP	473
	474	type = vhdr->h_vlan_encapsulated_proto;
	475
32764c66 JP	476	ptype = gro_find_receive_by_type(type);
32764c66 JP	477	if (!ptype)
fc1ca334	478	goto out;
32764c66 JP	479
	480	flush = 0;
	481
	482	list_for_each_entry(p, head, list) {
	483	struct vlan_hdr *vhdr2;
	484
	485	if (!NAPI_GRO_CB(p)->same_flow)
	486	continue;
	487
	488	vhdr2 = (struct vlan_hdr *)(p->data + off_vlan);
	489	if (compare_vlan_header(vhdr, vhdr2))
	490	NAPI_GRO_CB(p)->same_flow = 0;
	491	}
	492
	493	skb_gro_pull(skb, sizeof(*vhdr));
	494	skb_gro_postpull_rcsum(skb, vhdr, sizeof(*vhdr));
4a6e7ec9 AL	495
	496	pp = indirect_call_gro_receive_inet(ptype->callbacks.gro_receive,
	497	ipv6_gro_receive, inet_gro_receive,
	498	head, skb);
32764c66	499
32764c66 JP	500	out:
	501	skb_gro_flush_final(skb, pp, flush);
	502
	503	return pp;
	504	}
	505
	506	static int vlan_gro_complete(struct sk_buff *skb, int nhoff)
	507	{
	508	struct vlan_hdr vhdr = (struct vlan_hdr )(skb->data + nhoff);
	509	__be16 type = vhdr->h_vlan_encapsulated_proto;
	510	struct packet_offload *ptype;
	511	int err = -ENOENT;
	512
32764c66 JP	513	ptype = gro_find_complete_by_type(type);
32764c66 JP	514	if (ptype)
4a6e7ec9 AL	515	err = INDIRECT_CALL_INET(ptype->callbacks.gro_complete,
	516	ipv6_gro_complete, inet_gro_complete,
	517	skb, nhoff + sizeof(*vhdr));
32764c66	518
32764c66 JP	519	return err;
	520	}
	521
	522	static struct packet_offload vlan_packet_offloads[] __read_mostly = {
	523	{
	524	.type = cpu_to_be16(ETH_P_8021Q),
	525	.priority = 10,
	526	.callbacks = {
	527	.gro_receive = vlan_gro_receive,
	528	.gro_complete = vlan_gro_complete,
	529	},
	530	},
	531	{
	532	.type = cpu_to_be16(ETH_P_8021AD),
	533	.priority = 10,
	534	.callbacks = {
	535	.gro_receive = vlan_gro_receive,
	536	.gro_complete = vlan_gro_complete,
	537	},
	538	},
	539	};
	540
	541	static int __init vlan_offload_init(void)
	542	{
	543	unsigned int i;
	544
	545	for (i = 0; i < ARRAY_SIZE(vlan_packet_offloads); i++)
	546	dev_add_offload(&vlan_packet_offloads[i]);
	547
	548	return 0;
	549	}
	550
	551	fs_initcall(vlan_offload_init);