[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>

#define VLAN_TAB_MASK     15

static int tcf_vlan(struct sk_buff *skb, const struct tc_action *a,
		    struct tcf_result *res)
{
	struct tcf_vlan *v = a->priv;
	int action;
	int err;

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

	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);
		if (err)
			goto drop;
		break;
	default:
		BUG();
	}

	goto unlock;

drop:
	action = TC_ACT_SHOT;
	v->tcf_qstats.drops++;
unlock:
	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 },
};

static int tcf_vlan_init(struct net *net, struct nlattr *nla,
			 struct nlattr *est, struct tc_action *a,
			 int ovr, int bind)
{
	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;
	int ret = 0;
	int err;

	if (!nla)
		return -EINVAL;

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

	if (!tb[TCA_VLAN_PARMS])
		return -EINVAL;
	parm = nla_data(tb[TCA_VLAN_PARMS]);
	switch (parm->v_action) {
	case TCA_VLAN_ACT_POP:
		break;
	case TCA_VLAN_ACT_PUSH:
		if (!tb[TCA_VLAN_PUSH_VLAN_ID])
			return -EINVAL;
		push_vid = nla_get_u16(tb[TCA_VLAN_PUSH_VLAN_ID]);
		if (push_vid >= VLAN_VID_MASK)
			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);
		}
		break;
	default:
		return -EINVAL;
	}
	action = parm->v_action;

	if (!tcf_hash_check(parm->index, a, bind)) {
		ret = tcf_hash_create(parm->index, est, a, sizeof(*v),
				      bind, false);
		if (ret)
			return ret;

		ret = ACT_P_CREATED;
	} else {
		if (bind)
			return 0;
		tcf_hash_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_proto = push_proto;

	v->tcf_action = parm->action;

	spin_unlock_bh(&v->tcf_lock);

	if (ret == ACT_P_CREATED)
		tcf_hash_insert(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 = a->priv;
	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 &&
	    (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)))
		goto nla_put_failure;

	t.install = jiffies_to_clock_t(jiffies - v->tcf_tm.install);
	t.lastuse = jiffies_to_clock_t(jiffies - v->tcf_tm.lastuse);
	t.expires = jiffies_to_clock_t(v->tcf_tm.expires);
	if (nla_put(skb, TCA_VLAN_TM, sizeof(t), &t))
		goto nla_put_failure;
	return skb->len;

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

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,
};

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

static void __exit vlan_cleanup_module(void)
{
	tcf_unregister_action(&act_vlan_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
	22	#define VLAN_TAB_MASK 15
	23
	24	static int tcf_vlan(struct sk_buff skb, const struct tc_action a,
	25	struct tcf_result *res)
	26	{
	27	struct tcf_vlan *v = a->priv;
	28	int action;
	29	int err;
	30
	31	spin_lock(&v->tcf_lock);
	32	v->tcf_tm.lastuse = jiffies;
	33	bstats_update(&v->tcf_bstats, skb);
	34	action = v->tcf_action;
	35
	36	switch (v->tcfv_action) {
	37	case TCA_VLAN_ACT_POP:
	38	err = skb_vlan_pop(skb);
	39	if (err)
	40	goto drop;
	41	break;
	42	case TCA_VLAN_ACT_PUSH:
	43	err = skb_vlan_push(skb, v->tcfv_push_proto, v->tcfv_push_vid);
	44	if (err)
	45	goto drop;
	46	break;
	47	default:
	48	BUG();
	49	}
	50
	51	goto unlock;
	52
	53	drop:
	54	action = TC_ACT_SHOT;
	55	v->tcf_qstats.drops++;
	56	unlock:
	57	spin_unlock(&v->tcf_lock);
	58	return action;
	59	}
	60
	61	static const struct nla_policy vlan_policy[TCA_VLAN_MAX + 1] = {
	62	[TCA_VLAN_PARMS] = { .len = sizeof(struct tc_vlan) },
	63	[TCA_VLAN_PUSH_VLAN_ID] = { .type = NLA_U16 },
	64	[TCA_VLAN_PUSH_VLAN_PROTOCOL] = { .type = NLA_U16 },
65	};
66
67	static int tcf_vlan_init(struct net net, struct nlattr nla,
68	struct nlattr est, struct tc_action a,
69	int ovr, int bind)
70	{
71	struct nlattr *tb[TCA_VLAN_MAX + 1];
72	struct tc_vlan *parm;
73	struct tcf_vlan *v;
74	int action;
75	__be16 push_vid = 0;
76	__be16 push_proto = 0;
77	int ret = 0;
78	int err;
79
80	if (!nla)
81	return -EINVAL;
82
83	err = nla_parse_nested(tb, TCA_VLAN_MAX, nla, vlan_policy);
84	if (err < 0)
85	return err;
86
87	if (!tb[TCA_VLAN_PARMS])
88	return -EINVAL;
89	parm = nla_data(tb[TCA_VLAN_PARMS]);
90	switch (parm->v_action) {
91	case TCA_VLAN_ACT_POP:
92	break;
93	case TCA_VLAN_ACT_PUSH:
94	if (!tb[TCA_VLAN_PUSH_VLAN_ID])
95	return -EINVAL;
96	push_vid = nla_get_u16(tb[TCA_VLAN_PUSH_VLAN_ID]);
97	if (push_vid >= VLAN_VID_MASK)
98	return -ERANGE;
99
100	if (tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]) {
101	push_proto = nla_get_be16(tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]);
102	switch (push_proto) {
103	case htons(ETH_P_8021Q):
104	case htons(ETH_P_8021AD):
105	break;
106	default:
107	return -EPROTONOSUPPORT;
108	}
109	} else {
110	push_proto = htons(ETH_P_8021Q);
111	}
112	break;
113	default:
114	return -EINVAL;
115	}
116	action = parm->v_action;
117
118	if (!tcf_hash_check(parm->index, a, bind)) {
519c818e ED	119	ret = tcf_hash_create(parm->index, est, a, sizeof(*v),
519c818e ED	120	bind, false);
c7e2b968 JP	121	if (ret)
	122	return ret;
	123
	124	ret = ACT_P_CREATED;
	125	} else {
	126	if (bind)
	127	return 0;
	128	tcf_hash_release(a, bind);
	129	if (!ovr)
	130	return -EEXIST;
	131	}
	132
	133	v = to_vlan(a);
	134
	135	spin_lock_bh(&v->tcf_lock);
	136
	137	v->tcfv_action = action;
	138	v->tcfv_push_vid = push_vid;
	139	v->tcfv_push_proto = push_proto;
	140
	141	v->tcf_action = parm->action;
	142
	143	spin_unlock_bh(&v->tcf_lock);
	144
	145	if (ret == ACT_P_CREATED)
	146	tcf_hash_insert(a);
	147	return ret;
	148	}
	149
	150	static int tcf_vlan_dump(struct sk_buff skb, struct tc_action a,
	151	int bind, int ref)
	152	{
	153	unsigned char *b = skb_tail_pointer(skb);
	154	struct tcf_vlan *v = a->priv;
	155	struct tc_vlan opt = {
	156	.index = v->tcf_index,
	157	.refcnt = v->tcf_refcnt - ref,
	158	.bindcnt = v->tcf_bindcnt - bind,
	159	.action = v->tcf_action,
	160	.v_action = v->tcfv_action,
	161	};
	162	struct tcf_t t;
	163
	164	if (nla_put(skb, TCA_VLAN_PARMS, sizeof(opt), &opt))
	165	goto nla_put_failure;
	166
	167	if (v->tcfv_action == TCA_VLAN_ACT_PUSH &&
	168	(nla_put_u16(skb, TCA_VLAN_PUSH_VLAN_ID, v->tcfv_push_vid) \|\|
	169	nla_put_be16(skb, TCA_VLAN_PUSH_VLAN_PROTOCOL, v->tcfv_push_proto)))
	170	goto nla_put_failure;
	171
	172	t.install = jiffies_to_clock_t(jiffies - v->tcf_tm.install);
	173	t.lastuse = jiffies_to_clock_t(jiffies - v->tcf_tm.lastuse);
	174	t.expires = jiffies_to_clock_t(v->tcf_tm.expires);
	175	if (nla_put(skb, TCA_VLAN_TM, sizeof(t), &t))
	176	goto nla_put_failure;
	177	return skb->len;
	178
	179	nla_put_failure:
	180	nlmsg_trim(skb, b);
	181	return -1;
	182	}
	183
	184	static struct tc_action_ops act_vlan_ops = {
185	.kind = "vlan",
186	.type = TCA_ACT_VLAN,
187	.owner = THIS_MODULE,
188	.act = tcf_vlan,
189	.dump = tcf_vlan_dump,
190	.init = tcf_vlan_init,
191	};
192
193	static int __init vlan_init_module(void)
194	{
195	return tcf_register_action(&act_vlan_ops, VLAN_TAB_MASK);
196	}
197
198	static void __exit vlan_cleanup_module(void)
199	{
200	tcf_unregister_action(&act_vlan_ops);
201	}
202
203	module_init(vlan_init_module);
204	module_exit(vlan_cleanup_module);
205
206	MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
207	MODULE_DESCRIPTION("vlan manipulation actions");
208	MODULE_LICENSE("GPL v2");