1/*
2 * net/sched/cls_basic.c	Basic Packet Classifier.
3 *
4 *		This program is free software; you can redistribute it and/or
5 *		modify it under the terms of the GNU General Public License
6 *		as published by the Free Software Foundation; either version
7 *		2 of the License, or (at your option) any later version.
8 *
9 * Authors:	Thomas Graf <tgraf@suug.ch>
10 */
11
12#include <linux/module.h>
13#include <linux/slab.h>
14#include <linux/types.h>
15#include <linux/kernel.h>
16#include <linux/string.h>
17#include <linux/errno.h>
18#include <linux/rtnetlink.h>
19#include <linux/skbuff.h>
20#include <net/netlink.h>
21#include <net/act_api.h>
22#include <net/pkt_cls.h>
23
24struct basic_head {
25	u32			hgenerator;
26	struct list_head	flist;
27	struct rcu_head		rcu;
28};
29
30struct basic_filter {
31	u32			handle;
32	struct tcf_exts		exts;
33	struct tcf_ematch_tree	ematches;
34	struct tcf_result	res;
35	struct tcf_proto	*tp;
36	struct list_head	link;
37	struct rcu_head		rcu;
38};
39
40static int basic_classify(struct sk_buff *skb, const struct tcf_proto *tp,
41			  struct tcf_result *res)
42{
43	int r;
44	struct basic_head *head = rcu_dereference_bh(tp->root);
45	struct basic_filter *f;
46
47	list_for_each_entry_rcu(f, &head->flist, link) {
48		if (!tcf_em_tree_match(skb, &f->ematches, NULL))
49			continue;
50		*res = f->res;
51		r = tcf_exts_exec(skb, &f->exts, res);
52		if (r < 0)
53			continue;
54		return r;
55	}
56	return -1;
57}
58
59static unsigned long basic_get(struct tcf_proto *tp, u32 handle)
60{
61	unsigned long l = 0UL;
62	struct basic_head *head = rtnl_dereference(tp->root);
63	struct basic_filter *f;
64
65	if (head == NULL)
66		return 0UL;
67
68	list_for_each_entry(f, &head->flist, link) {
69		if (f->handle == handle) {
70			l = (unsigned long) f;
71			break;
72		}
73	}
74
75	return l;
76}
77
78static int basic_init(struct tcf_proto *tp)
79{
80	struct basic_head *head;
81
82	head = kzalloc(sizeof(*head), GFP_KERNEL);
83	if (head == NULL)
84		return -ENOBUFS;
85	INIT_LIST_HEAD(&head->flist);
86	rcu_assign_pointer(tp->root, head);
87	return 0;
88}
89
90static void basic_delete_filter(struct rcu_head *head)
91{
92	struct basic_filter *f = container_of(head, struct basic_filter, rcu);
93
94	tcf_exts_destroy(&f->exts);
95	tcf_em_tree_destroy(&f->ematches);
96	kfree(f);
97}
98
99static bool basic_destroy(struct tcf_proto *tp, bool force)
100{
101	struct basic_head *head = rtnl_dereference(tp->root);
102	struct basic_filter *f, *n;
103
104	if (!force && !list_empty(&head->flist))
105		return false;
106
107	list_for_each_entry_safe(f, n, &head->flist, link) {
108		list_del_rcu(&f->link);
109		tcf_unbind_filter(tp, &f->res);
110		call_rcu(&f->rcu, basic_delete_filter);
111	}
112	RCU_INIT_POINTER(tp->root, NULL);
113	kfree_rcu(head, rcu);
114	return true;
115}
116
117static int basic_delete(struct tcf_proto *tp, unsigned long arg)
118{
119	struct basic_filter *f = (struct basic_filter *) arg;
120
121	list_del_rcu(&f->link);
122	tcf_unbind_filter(tp, &f->res);
123	call_rcu(&f->rcu, basic_delete_filter);
124	return 0;
125}
126
127static const struct nla_policy basic_policy[TCA_BASIC_MAX + 1] = {
128	[TCA_BASIC_CLASSID]	= { .type = NLA_U32 },
129	[TCA_BASIC_EMATCHES]	= { .type = NLA_NESTED },
130};
131
132static int basic_set_parms(struct net *net, struct tcf_proto *tp,
133			   struct basic_filter *f, unsigned long base,
134			   struct nlattr **tb,
135			   struct nlattr *est, bool ovr)
136{
137	int err;
138	struct tcf_exts e;
139	struct tcf_ematch_tree t;
140
141	tcf_exts_init(&e, TCA_BASIC_ACT, TCA_BASIC_POLICE);
142	err = tcf_exts_validate(net, tp, tb, est, &e, ovr);
143	if (err < 0)
144		return err;
145
146	err = tcf_em_tree_validate(tp, tb[TCA_BASIC_EMATCHES], &t);
147	if (err < 0)
148		goto errout;
149
150	if (tb[TCA_BASIC_CLASSID]) {
151		f->res.classid = nla_get_u32(tb[TCA_BASIC_CLASSID]);
152		tcf_bind_filter(tp, &f->res, base);
153	}
154
155	tcf_exts_change(tp, &f->exts, &e);
156	tcf_em_tree_change(tp, &f->ematches, &t);
157	f->tp = tp;
158
159	return 0;
160errout:
161	tcf_exts_destroy(&e);
162	return err;
163}
164
165static int basic_change(struct net *net, struct sk_buff *in_skb,
166			struct tcf_proto *tp, unsigned long base, u32 handle,
167			struct nlattr **tca, unsigned long *arg, bool ovr)
168{
169	int err;
170	struct basic_head *head = rtnl_dereference(tp->root);
171	struct nlattr *tb[TCA_BASIC_MAX + 1];
172	struct basic_filter *fold = (struct basic_filter *) *arg;
173	struct basic_filter *fnew;
174
175	if (tca[TCA_OPTIONS] == NULL)
176		return -EINVAL;
177
178	err = nla_parse_nested(tb, TCA_BASIC_MAX, tca[TCA_OPTIONS],
179			       basic_policy);
180	if (err < 0)
181		return err;
182
183	if (fold != NULL) {
184		if (handle && fold->handle != handle)
185			return -EINVAL;
186	}
187
188	fnew = kzalloc(sizeof(*fnew), GFP_KERNEL);
189	if (!fnew)
190		return -ENOBUFS;
191
192	tcf_exts_init(&fnew->exts, TCA_BASIC_ACT, TCA_BASIC_POLICE);
193	err = -EINVAL;
194	if (handle) {
195		fnew->handle = handle;
196	} else if (fold) {
197		fnew->handle = fold->handle;
198	} else {
199		unsigned int i = 0x80000000;
200		do {
201			if (++head->hgenerator == 0x7FFFFFFF)
202				head->hgenerator = 1;
203		} while (--i > 0 && basic_get(tp, head->hgenerator));
204
205		if (i <= 0) {
206			pr_err("Insufficient number of handles\n");
207			goto errout;
208		}
209
210		fnew->handle = head->hgenerator;
211	}
212
213	err = basic_set_parms(net, tp, fnew, base, tb, tca[TCA_RATE], ovr);
214	if (err < 0)
215		goto errout;
216
217	*arg = (unsigned long)fnew;
218
219	if (fold) {
220		list_replace_rcu(&fold->link, &fnew->link);
221		tcf_unbind_filter(tp, &fold->res);
222		call_rcu(&fold->rcu, basic_delete_filter);
223	} else {
224		list_add_rcu(&fnew->link, &head->flist);
225	}
226
227	return 0;
228errout:
229	kfree(fnew);
230	return err;
231}
232
233static void basic_walk(struct tcf_proto *tp, struct tcf_walker *arg)
234{
235	struct basic_head *head = rtnl_dereference(tp->root);
236	struct basic_filter *f;
237
238	list_for_each_entry(f, &head->flist, link) {
239		if (arg->count < arg->skip)
240			goto skip;
241
242		if (arg->fn(tp, (unsigned long) f, arg) < 0) {
243			arg->stop = 1;
244			break;
245		}
246skip:
247		arg->count++;
248	}
249}
250
251static int basic_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
252		      struct sk_buff *skb, struct tcmsg *t)
253{
254	struct basic_filter *f = (struct basic_filter *) fh;
255	struct nlattr *nest;
256
257	if (f == NULL)
258		return skb->len;
259
260	t->tcm_handle = f->handle;
261
262	nest = nla_nest_start(skb, TCA_OPTIONS);
263	if (nest == NULL)
264		goto nla_put_failure;
265
266	if (f->res.classid &&
267	    nla_put_u32(skb, TCA_BASIC_CLASSID, f->res.classid))
268		goto nla_put_failure;
269
270	if (tcf_exts_dump(skb, &f->exts) < 0 ||
271	    tcf_em_tree_dump(skb, &f->ematches, TCA_BASIC_EMATCHES) < 0)
272		goto nla_put_failure;
273
274	nla_nest_end(skb, nest);
275
276	if (tcf_exts_dump_stats(skb, &f->exts) < 0)
277		goto nla_put_failure;
278
279	return skb->len;
280
281nla_put_failure:
282	nla_nest_cancel(skb, nest);
283	return -1;
284}
285
286static struct tcf_proto_ops cls_basic_ops __read_mostly = {
287	.kind		=	"basic",
288	.classify	=	basic_classify,
289	.init		=	basic_init,
290	.destroy	=	basic_destroy,
291	.get		=	basic_get,
292	.change		=	basic_change,
293	.delete		=	basic_delete,
294	.walk		=	basic_walk,
295	.dump		=	basic_dump,
296	.owner		=	THIS_MODULE,
297};
298
299static int __init init_basic(void)
300{
301	return register_tcf_proto_ops(&cls_basic_ops);
302}
303
304static void __exit exit_basic(void)
305{
306	unregister_tcf_proto_ops(&cls_basic_ops);
307}
308
309module_init(init_basic)
310module_exit(exit_basic)
311MODULE_LICENSE("GPL");
312
313