[linux-2.6-block.git] / net / sched / act_vlan.c

/*
 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/if_vlan.h>
#include <net/netlink.h>
#include <net/pkt_sched.h>

#include <linux/tc_act/tc_vlan.h>
#include <net/tc_act/tc_vlan.h>

static unsigned int vlan_net_id;
static struct tc_action_ops act_vlan_ops;

static int tcf_vlan(struct sk_buff *skb, const struct tc_action *a,
		    struct tcf_result *res)
{
	struct tcf_vlan *v = to_vlan(a);
	int action;
	int err;
	u16 tci;

	spin_lock(&v->tcf_lock);
	tcf_lastuse_update(&v->tcf_tm);
	bstats_update(&v->tcf_bstats, skb);
	action = v->tcf_action;

	/* Ensure 'data' points at mac_header prior calling vlan manipulating
	 * functions.
	 */
	if (skb_at_tc_ingress(skb))
		skb_push_rcsum(skb, skb->mac_len);

	switch (v->tcfv_action) {
	case TCA_VLAN_ACT_POP:
		err = skb_vlan_pop(skb);
		if (err)
			goto drop;
		break;
	case TCA_VLAN_ACT_PUSH:
		err = skb_vlan_push(skb, v->tcfv_push_proto, v->tcfv_push_vid |
				    (v->tcfv_push_prio << VLAN_PRIO_SHIFT));
		if (err)
			goto drop;
		break;
	case TCA_VLAN_ACT_MODIFY:
		/* No-op if no vlan tag (either hw-accel or in-payload) */
		if (!skb_vlan_tagged(skb))
			goto unlock;
		/* extract existing tag (and guarantee no hw-accel tag) */
		if (skb_vlan_tag_present(skb)) {
			tci = skb_vlan_tag_get(skb);
			skb->vlan_tci = 0;
		} else {
			/* in-payload vlan tag, pop it */
			err = __skb_vlan_pop(skb, &tci);
			if (err)
				goto drop;
		}
		/* replace the vid */
		tci = (tci & ~VLAN_VID_MASK) | v->tcfv_push_vid;
		/* replace prio bits, if tcfv_push_prio specified */
		if (v->tcfv_push_prio) {
			tci &= ~VLAN_PRIO_MASK;
			tci |= v->tcfv_push_prio << VLAN_PRIO_SHIFT;
		}
		/* put updated tci as hwaccel tag */
		__vlan_hwaccel_put_tag(skb, v->tcfv_push_proto, tci);
		break;
	default:
		BUG();
	}

	goto unlock;

drop:
	action = TC_ACT_SHOT;
	v->tcf_qstats.drops++;
unlock:
	if (skb_at_tc_ingress(skb))
		skb_pull_rcsum(skb, skb->mac_len);

	spin_unlock(&v->tcf_lock);
	return action;
}

static const struct nla_policy vlan_policy[TCA_VLAN_MAX + 1] = {
	[TCA_VLAN_PARMS]		= { .len = sizeof(struct tc_vlan) },
	[TCA_VLAN_PUSH_VLAN_ID]		= { .type = NLA_U16 },
	[TCA_VLAN_PUSH_VLAN_PROTOCOL]	= { .type = NLA_U16 },
	[TCA_VLAN_PUSH_VLAN_PRIORITY]	= { .type = NLA_U8 },
};

static int tcf_vlan_init(struct net *net, struct nlattr *nla,
			 struct nlattr *est, struct tc_action **a,
			 int ovr, int bind)
{
	struct tc_action_net *tn = net_generic(net, vlan_net_id);
	struct nlattr *tb[TCA_VLAN_MAX + 1];
	struct tc_vlan *parm;
	struct tcf_vlan *v;
	int action;
	__be16 push_vid = 0;
	__be16 push_proto = 0;
	u8 push_prio = 0;
	bool exists = false;
	int ret = 0, err;

	if (!nla)
		return -EINVAL;

	err = nla_parse_nested(tb, TCA_VLAN_MAX, nla, vlan_policy, NULL);
	if (err < 0)
		return err;

	if (!tb[TCA_VLAN_PARMS])
		return -EINVAL;
	parm = nla_data(tb[TCA_VLAN_PARMS]);
	exists = tcf_idr_check(tn, parm->index, a, bind);
	if (exists && bind)
		return 0;

	switch (parm->v_action) {
	case TCA_VLAN_ACT_POP:
		break;
	case TCA_VLAN_ACT_PUSH:
	case TCA_VLAN_ACT_MODIFY:
		if (!tb[TCA_VLAN_PUSH_VLAN_ID]) {
			if (exists)
				tcf_idr_release(*a, bind);
			return -EINVAL;
		}
		push_vid = nla_get_u16(tb[TCA_VLAN_PUSH_VLAN_ID]);
		if (push_vid >= VLAN_VID_MASK) {
			if (exists)
				tcf_idr_release(*a, bind);
			return -ERANGE;
		}

		if (tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]) {
			push_proto = nla_get_be16(tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]);
			switch (push_proto) {
			case htons(ETH_P_8021Q):
			case htons(ETH_P_8021AD):
				break;
			default:
				return -EPROTONOSUPPORT;
			}
		} else {
			push_proto = htons(ETH_P_8021Q);
		}

		if (tb[TCA_VLAN_PUSH_VLAN_PRIORITY])
			push_prio = nla_get_u8(tb[TCA_VLAN_PUSH_VLAN_PRIORITY]);
		break;
	default:
		if (exists)
			tcf_idr_release(*a, bind);
		return -EINVAL;
	}
	action = parm->v_action;

	if (!exists) {
		ret = tcf_idr_create(tn, parm->index, est, a,
				     &act_vlan_ops, bind, false);
		if (ret)
			return ret;

		ret = ACT_P_CREATED;
	} else {
		tcf_idr_release(*a, bind);
		if (!ovr)
			return -EEXIST;
	}

	v = to_vlan(*a);

	spin_lock_bh(&v->tcf_lock);

	v->tcfv_action = action;
	v->tcfv_push_vid = push_vid;
	v->tcfv_push_prio = push_prio;
	v->tcfv_push_proto = push_proto;

	v->tcf_action = parm->action;

	spin_unlock_bh(&v->tcf_lock);

	if (ret == ACT_P_CREATED)
		tcf_idr_insert(tn, *a);
	return ret;
}

static int tcf_vlan_dump(struct sk_buff *skb, struct tc_action *a,
			 int bind, int ref)
{
	unsigned char *b = skb_tail_pointer(skb);
	struct tcf_vlan *v = to_vlan(a);
	struct tc_vlan opt = {
		.index    = v->tcf_index,
		.refcnt   = v->tcf_refcnt - ref,
		.bindcnt  = v->tcf_bindcnt - bind,
		.action   = v->tcf_action,
		.v_action = v->tcfv_action,
	};
	struct tcf_t t;

	if (nla_put(skb, TCA_VLAN_PARMS, sizeof(opt), &opt))
		goto nla_put_failure;

	if ((v->tcfv_action == TCA_VLAN_ACT_PUSH ||
	     v->tcfv_action == TCA_VLAN_ACT_MODIFY) &&
	    (nla_put_u16(skb, TCA_VLAN_PUSH_VLAN_ID, v->tcfv_push_vid) ||
	     nla_put_be16(skb, TCA_VLAN_PUSH_VLAN_PROTOCOL,
			  v->tcfv_push_proto) ||
	     (nla_put_u8(skb, TCA_VLAN_PUSH_VLAN_PRIORITY,
					      v->tcfv_push_prio))))
		goto nla_put_failure;

	tcf_tm_dump(&t, &v->tcf_tm);
	if (nla_put_64bit(skb, TCA_VLAN_TM, sizeof(t), &t, TCA_VLAN_PAD))
		goto nla_put_failure;
	return skb->len;

nla_put_failure:
	nlmsg_trim(skb, b);
	return -1;
}

static int tcf_vlan_walker(struct net *net, struct sk_buff *skb,
			   struct netlink_callback *cb, int type,
			   const struct tc_action_ops *ops)
{
	struct tc_action_net *tn = net_generic(net, vlan_net_id);

	return tcf_generic_walker(tn, skb, cb, type, ops);
}

static int tcf_vlan_search(struct net *net, struct tc_action **a, u32 index)
{
	struct tc_action_net *tn = net_generic(net, vlan_net_id);

	return tcf_idr_search(tn, a, index);
}

static struct tc_action_ops act_vlan_ops = {
	.kind		=	"vlan",
	.type		=	TCA_ACT_VLAN,
	.owner		=	THIS_MODULE,
	.act		=	tcf_vlan,
	.dump		=	tcf_vlan_dump,
	.init		=	tcf_vlan_init,
	.walk		=	tcf_vlan_walker,
	.lookup		=	tcf_vlan_search,
	.size		=	sizeof(struct tcf_vlan),
};

static __net_init int vlan_init_net(struct net *net)
{
	struct tc_action_net *tn = net_generic(net, vlan_net_id);

	return tc_action_net_init(tn, &act_vlan_ops);
}

static void __net_exit vlan_exit_net(struct net *net)
{
	struct tc_action_net *tn = net_generic(net, vlan_net_id);

	tc_action_net_exit(tn);
}

static struct pernet_operations vlan_net_ops = {
	.init = vlan_init_net,
	.exit = vlan_exit_net,
	.id   = &vlan_net_id,
	.size = sizeof(struct tc_action_net),
};

static int __init vlan_init_module(void)
{
	return tcf_register_action(&act_vlan_ops, &vlan_net_ops);
}

static void __exit vlan_cleanup_module(void)
{
	tcf_unregister_action(&act_vlan_ops, &vlan_net_ops);
}

module_init(vlan_init_module);
module_exit(vlan_cleanup_module);

MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
MODULE_DESCRIPTION("vlan manipulation actions");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
c7e2b968 JP	1	/*
	2	* Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/kernel.h>
	13	#include <linux/skbuff.h>
	14	#include <linux/rtnetlink.h>
	15	#include <linux/if_vlan.h>
	16	#include <net/netlink.h>
	17	#include <net/pkt_sched.h>
	18
	19	#include <linux/tc_act/tc_vlan.h>
	20	#include <net/tc_act/tc_vlan.h>
	21
c7d03a00	22	static unsigned int vlan_net_id;
a85a970a	23	static struct tc_action_ops act_vlan_ops;
ddf97ccd	24
c7e2b968 JP	25	static int tcf_vlan(struct sk_buff skb, const struct tc_action a,
	26	struct tcf_result *res)
	27	{
a85a970a	28	struct tcf_vlan *v = to_vlan(a);
c7e2b968 JP	29	int action;
c7e2b968 JP	30	int err;
45a497f2	31	u16 tci;
c7e2b968 JP	32
c7e2b968 JP	33	spin_lock(&v->tcf_lock);
9c4a4e48	34	tcf_lastuse_update(&v->tcf_tm);
c7e2b968 JP	35	bstats_update(&v->tcf_bstats, skb);
	36	action = v->tcf_action;
	37
f39acc84 SL	38	/* Ensure 'data' points at mac_header prior calling vlan manipulating
	39	* functions.
	40	*/
	41	if (skb_at_tc_ingress(skb))
	42	skb_push_rcsum(skb, skb->mac_len);
	43
c7e2b968 JP	44	switch (v->tcfv_action) {
	45	case TCA_VLAN_ACT_POP:
	46	err = skb_vlan_pop(skb);
	47	if (err)
	48	goto drop;
	49	break;
	50	case TCA_VLAN_ACT_PUSH:
956af371 HHZ	51	err = skb_vlan_push(skb, v->tcfv_push_proto, v->tcfv_push_vid \|
956af371 HHZ	52	(v->tcfv_push_prio << VLAN_PRIO_SHIFT));
c7e2b968 JP	53	if (err)
	54	goto drop;
	55	break;
45a497f2 SL	56	case TCA_VLAN_ACT_MODIFY:
	57	/* No-op if no vlan tag (either hw-accel or in-payload) */
	58	if (!skb_vlan_tagged(skb))
	59	goto unlock;
	60	/* extract existing tag (and guarantee no hw-accel tag) */
	61	if (skb_vlan_tag_present(skb)) {
	62	tci = skb_vlan_tag_get(skb);
	63	skb->vlan_tci = 0;
	64	} else {
	65	/* in-payload vlan tag, pop it */
	66	err = __skb_vlan_pop(skb, &tci);
	67	if (err)
	68	goto drop;
	69	}
	70	/* replace the vid */
	71	tci = (tci & ~VLAN_VID_MASK) \| v->tcfv_push_vid;
	72	/* replace prio bits, if tcfv_push_prio specified */
	73	if (v->tcfv_push_prio) {
	74	tci &= ~VLAN_PRIO_MASK;
	75	tci \|= v->tcfv_push_prio << VLAN_PRIO_SHIFT;
	76	}
	77	/* put updated tci as hwaccel tag */
	78	__vlan_hwaccel_put_tag(skb, v->tcfv_push_proto, tci);
	79	break;
c7e2b968 JP	80	default:
	81	BUG();
	82	}
	83
	84	goto unlock;
	85
	86	drop:
	87	action = TC_ACT_SHOT;
	88	v->tcf_qstats.drops++;
	89	unlock:
f39acc84 SL	90	if (skb_at_tc_ingress(skb))
	91	skb_pull_rcsum(skb, skb->mac_len);
	92
c7e2b968 JP	93	spin_unlock(&v->tcf_lock);
	94	return action;
	95	}
	96
	97	static const struct nla_policy vlan_policy[TCA_VLAN_MAX + 1] = {
	98	[TCA_VLAN_PARMS] = { .len = sizeof(struct tc_vlan) },
	99	[TCA_VLAN_PUSH_VLAN_ID] = { .type = NLA_U16 },
	100	[TCA_VLAN_PUSH_VLAN_PROTOCOL] = { .type = NLA_U16 },
956af371	101	[TCA_VLAN_PUSH_VLAN_PRIORITY] = { .type = NLA_U8 },
c7e2b968 JP	102	};
	103
	104	static int tcf_vlan_init(struct net net, struct nlattr nla,
a85a970a	105	struct nlattr est, struct tc_action *a,
c7e2b968 JP	106	int ovr, int bind)
c7e2b968 JP	107	{
ddf97ccd	108	struct tc_action_net *tn = net_generic(net, vlan_net_id);
c7e2b968 JP	109	struct nlattr *tb[TCA_VLAN_MAX + 1];
	110	struct tc_vlan *parm;
	111	struct tcf_vlan *v;
	112	int action;
	113	__be16 push_vid = 0;
	114	__be16 push_proto = 0;
956af371	115	u8 push_prio = 0;
b2313077 WC	116	bool exists = false;
b2313077 WC	117	int ret = 0, err;
c7e2b968 JP	118
	119	if (!nla)
	120	return -EINVAL;
	121
fceb6435	122	err = nla_parse_nested(tb, TCA_VLAN_MAX, nla, vlan_policy, NULL);
c7e2b968 JP	123	if (err < 0)
	124	return err;
	125
	126	if (!tb[TCA_VLAN_PARMS])
	127	return -EINVAL;
	128	parm = nla_data(tb[TCA_VLAN_PARMS]);
65a206c0	129	exists = tcf_idr_check(tn, parm->index, a, bind);
5026c9b1 JHS	130	if (exists && bind)
	131	return 0;
	132
c7e2b968 JP	133	switch (parm->v_action) {
	134	case TCA_VLAN_ACT_POP:
	135	break;
	136	case TCA_VLAN_ACT_PUSH:
45a497f2	137	case TCA_VLAN_ACT_MODIFY:
5026c9b1 JHS	138	if (!tb[TCA_VLAN_PUSH_VLAN_ID]) {
5026c9b1 JHS	139	if (exists)
65a206c0	140	tcf_idr_release(*a, bind);
c7e2b968	141	return -EINVAL;
5026c9b1	142	}
c7e2b968	143	push_vid = nla_get_u16(tb[TCA_VLAN_PUSH_VLAN_ID]);
5026c9b1 JHS	144	if (push_vid >= VLAN_VID_MASK) {
5026c9b1 JHS	145	if (exists)
65a206c0	146	tcf_idr_release(*a, bind);
c7e2b968	147	return -ERANGE;
5026c9b1	148	}
c7e2b968 JP	149
	150	if (tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]) {
	151	push_proto = nla_get_be16(tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]);
	152	switch (push_proto) {
	153	case htons(ETH_P_8021Q):
	154	case htons(ETH_P_8021AD):
	155	break;
	156	default:
	157	return -EPROTONOSUPPORT;
	158	}
	159	} else {
	160	push_proto = htons(ETH_P_8021Q);
	161	}
956af371 HHZ	162
	163	if (tb[TCA_VLAN_PUSH_VLAN_PRIORITY])
	164	push_prio = nla_get_u8(tb[TCA_VLAN_PUSH_VLAN_PRIORITY]);
c7e2b968 JP	165	break;
c7e2b968 JP	166	default:
5026c9b1	167	if (exists)
65a206c0	168	tcf_idr_release(*a, bind);
c7e2b968 JP	169	return -EINVAL;
	170	}
	171	action = parm->v_action;
	172
5026c9b1	173	if (!exists) {
65a206c0 CM	174	ret = tcf_idr_create(tn, parm->index, est, a,
65a206c0 CM	175	&act_vlan_ops, bind, false);
c7e2b968 JP	176	if (ret)
	177	return ret;
	178
	179	ret = ACT_P_CREATED;
	180	} else {
65a206c0	181	tcf_idr_release(*a, bind);
c7e2b968 JP	182	if (!ovr)
	183	return -EEXIST;
	184	}
	185
a85a970a	186	v = to_vlan(*a);
c7e2b968 JP	187
	188	spin_lock_bh(&v->tcf_lock);
	189
	190	v->tcfv_action = action;
	191	v->tcfv_push_vid = push_vid;
956af371	192	v->tcfv_push_prio = push_prio;
c7e2b968 JP	193	v->tcfv_push_proto = push_proto;
	194
	195	v->tcf_action = parm->action;
	196
	197	spin_unlock_bh(&v->tcf_lock);
	198
	199	if (ret == ACT_P_CREATED)
65a206c0	200	tcf_idr_insert(tn, *a);
c7e2b968 JP	201	return ret;
	202	}
	203
	204	static int tcf_vlan_dump(struct sk_buff skb, struct tc_action a,
	205	int bind, int ref)
	206	{
	207	unsigned char *b = skb_tail_pointer(skb);
a85a970a	208	struct tcf_vlan *v = to_vlan(a);
c7e2b968 JP	209	struct tc_vlan opt = {
	210	.index = v->tcf_index,
	211	.refcnt = v->tcf_refcnt - ref,
	212	.bindcnt = v->tcf_bindcnt - bind,
	213	.action = v->tcf_action,
	214	.v_action = v->tcfv_action,
	215	};
	216	struct tcf_t t;
	217
	218	if (nla_put(skb, TCA_VLAN_PARMS, sizeof(opt), &opt))
	219	goto nla_put_failure;
	220
45a497f2 SL	221	if ((v->tcfv_action == TCA_VLAN_ACT_PUSH \|\|
45a497f2 SL	222	v->tcfv_action == TCA_VLAN_ACT_MODIFY) &&
c7e2b968	223	(nla_put_u16(skb, TCA_VLAN_PUSH_VLAN_ID, v->tcfv_push_vid) \|\|
0b0f43fe	224	nla_put_be16(skb, TCA_VLAN_PUSH_VLAN_PROTOCOL,
956af371 HHZ	225	v->tcfv_push_proto) \|\|
	226	(nla_put_u8(skb, TCA_VLAN_PUSH_VLAN_PRIORITY,
	227	v->tcfv_push_prio))))
c7e2b968 JP	228	goto nla_put_failure;
c7e2b968 JP	229
48d8ee16	230	tcf_tm_dump(&t, &v->tcf_tm);
9854518e	231	if (nla_put_64bit(skb, TCA_VLAN_TM, sizeof(t), &t, TCA_VLAN_PAD))
c7e2b968 JP	232	goto nla_put_failure;
	233	return skb->len;
	234
	235	nla_put_failure:
	236	nlmsg_trim(skb, b);
	237	return -1;
	238	}
	239
ddf97ccd WC	240	static int tcf_vlan_walker(struct net net, struct sk_buff skb,
ddf97ccd WC	241	struct netlink_callback *cb, int type,
a85a970a	242	const struct tc_action_ops *ops)
ddf97ccd WC	243	{
	244	struct tc_action_net *tn = net_generic(net, vlan_net_id);
	245
a85a970a	246	return tcf_generic_walker(tn, skb, cb, type, ops);
ddf97ccd WC	247	}
ddf97ccd WC	248
a85a970a	249	static int tcf_vlan_search(struct net net, struct tc_action *a, u32 index)
ddf97ccd WC	250	{
	251	struct tc_action_net *tn = net_generic(net, vlan_net_id);
	252
65a206c0	253	return tcf_idr_search(tn, a, index);
ddf97ccd WC	254	}
ddf97ccd WC	255
c7e2b968 JP	256	static struct tc_action_ops act_vlan_ops = {
	257	.kind = "vlan",
	258	.type = TCA_ACT_VLAN,
	259	.owner = THIS_MODULE,
	260	.act = tcf_vlan,
	261	.dump = tcf_vlan_dump,
	262	.init = tcf_vlan_init,
ddf97ccd WC	263	.walk = tcf_vlan_walker,
ddf97ccd WC	264	.lookup = tcf_vlan_search,
a85a970a	265	.size = sizeof(struct tcf_vlan),
ddf97ccd WC	266	};
	267
	268	static __net_init int vlan_init_net(struct net *net)
	269	{
	270	struct tc_action_net *tn = net_generic(net, vlan_net_id);
	271
65a206c0	272	return tc_action_net_init(tn, &act_vlan_ops);
ddf97ccd WC	273	}
	274
	275	static void __net_exit vlan_exit_net(struct net *net)
	276	{
	277	struct tc_action_net *tn = net_generic(net, vlan_net_id);
	278
	279	tc_action_net_exit(tn);
	280	}
	281
	282	static struct pernet_operations vlan_net_ops = {
	283	.init = vlan_init_net,
	284	.exit = vlan_exit_net,
	285	.id = &vlan_net_id,
	286	.size = sizeof(struct tc_action_net),
c7e2b968 JP	287	};
	288
	289	static int __init vlan_init_module(void)
	290	{
ddf97ccd	291	return tcf_register_action(&act_vlan_ops, &vlan_net_ops);
c7e2b968 JP	292	}
	293
	294	static void __exit vlan_cleanup_module(void)
	295	{
ddf97ccd	296	tcf_unregister_action(&act_vlan_ops, &vlan_net_ops);
c7e2b968 JP	297	}
	298
	299	module_init(vlan_init_module);
	300	module_exit(vlan_cleanup_module);
	301
	302	MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
	303	MODULE_DESCRIPTION("vlan manipulation actions");
	304	MODULE_LICENSE("GPL v2");