1/*
2 * net/sched/cls_fw.c	Classifier mapping ipchains' fwmark to traffic class.
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:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
11 * Changes:
12 * Karlis Peisenieks <karlis@mt.lv> : 990415 : fw_walk off by one
13 * Karlis Peisenieks <karlis@mt.lv> : 990415 : fw_delete killed all the filter (and kernel).
14 * Alex <alex@pilotsoft.com> : 2004xxyy: Added Action extension
15 *
16 * JHS: We should remove the CONFIG_NET_CLS_IND from here
17 * eventually when the meta match extension is made available
18 *
19 */
20
21#include <linux/module.h>
22#include <linux/slab.h>
23#include <linux/types.h>
24#include <linux/kernel.h>
25#include <linux/string.h>
26#include <linux/errno.h>
27#include <linux/skbuff.h>
28#include <net/netlink.h>
29#include <net/act_api.h>
30#include <net/pkt_cls.h>
31
32#define HTSIZE 256
33
34struct fw_head {
35	u32			mask;
36	struct fw_filter __rcu	*ht[HTSIZE];
37	struct rcu_head		rcu;
38};
39
40struct fw_filter {
41	struct fw_filter __rcu	*next;
42	u32			id;
43	struct tcf_result	res;
44#ifdef CONFIG_NET_CLS_IND
45	int			ifindex;
46#endif /* CONFIG_NET_CLS_IND */
47	struct tcf_exts		exts;
48	struct tcf_proto	*tp;
49	struct rcu_head		rcu;
50};
51
52static u32 fw_hash(u32 handle)
53{
54	handle ^= (handle >> 16);
55	handle ^= (handle >> 8);
56	return handle % HTSIZE;
57}
58
59static int fw_classify(struct sk_buff *skb, const struct tcf_proto *tp,
60			  struct tcf_result *res)
61{
62	struct fw_head *head = rcu_dereference_bh(tp->root);
63	struct fw_filter *f;
64	int r;
65	u32 id = skb->mark;
66
67	if (head != NULL) {
68		id &= head->mask;
69
70		for (f = rcu_dereference_bh(head->ht[fw_hash(id)]); f;
71		     f = rcu_dereference_bh(f->next)) {
72			if (f->id == id) {
73				*res = f->res;
74#ifdef CONFIG_NET_CLS_IND
75				if (!tcf_match_indev(skb, f->ifindex))
76					continue;
77#endif /* CONFIG_NET_CLS_IND */
78				r = tcf_exts_exec(skb, &f->exts, res);
79				if (r < 0)
80					continue;
81
82				return r;
83			}
84		}
85	} else {
86		/* Old method: classify the packet using its skb mark. */
87		if (id && (TC_H_MAJ(id) == 0 ||
88			   !(TC_H_MAJ(id ^ tp->q->handle)))) {
89			res->classid = id;
90			res->class = 0;
91			return 0;
92		}
93	}
94
95	return -1;
96}
97
98static unsigned long fw_get(struct tcf_proto *tp, u32 handle)
99{
100	struct fw_head *head = rtnl_dereference(tp->root);
101	struct fw_filter *f;
102
103	if (head == NULL)
104		return 0;
105
106	f = rtnl_dereference(head->ht[fw_hash(handle)]);
107	for (; f; f = rtnl_dereference(f->next)) {
108		if (f->id == handle)
109			return (unsigned long)f;
110	}
111	return 0;
112}
113
114static int fw_init(struct tcf_proto *tp)
115{
116	/* We don't allocate fw_head here, because in the old method
117	 * we don't need it at all.
118	 */
119	return 0;
120}
121
122static void fw_delete_filter(struct rcu_head *head)
123{
124	struct fw_filter *f = container_of(head, struct fw_filter, rcu);
125
126	tcf_exts_destroy(&f->exts);
127	kfree(f);
128}
129
130static bool fw_destroy(struct tcf_proto *tp, bool force)
131{
132	struct fw_head *head = rtnl_dereference(tp->root);
133	struct fw_filter *f;
134	int h;
135
136	if (head == NULL)
137		return true;
138
139	if (!force) {
140		for (h = 0; h < HTSIZE; h++)
141			if (rcu_access_pointer(head->ht[h]))
142				return false;
143	}
144
145	for (h = 0; h < HTSIZE; h++) {
146		while ((f = rtnl_dereference(head->ht[h])) != NULL) {
147			RCU_INIT_POINTER(head->ht[h],
148					 rtnl_dereference(f->next));
149			tcf_unbind_filter(tp, &f->res);
150			call_rcu(&f->rcu, fw_delete_filter);
151		}
152	}
153	RCU_INIT_POINTER(tp->root, NULL);
154	kfree_rcu(head, rcu);
155	return true;
156}
157
158static int fw_delete(struct tcf_proto *tp, unsigned long arg)
159{
160	struct fw_head *head = rtnl_dereference(tp->root);
161	struct fw_filter *f = (struct fw_filter *)arg;
162	struct fw_filter __rcu **fp;
163	struct fw_filter *pfp;
164
165	if (head == NULL || f == NULL)
166		goto out;
167
168	fp = &head->ht[fw_hash(f->id)];
169
170	for (pfp = rtnl_dereference(*fp); pfp;
171	     fp = &pfp->next, pfp = rtnl_dereference(*fp)) {
172		if (pfp == f) {
173			RCU_INIT_POINTER(*fp, rtnl_dereference(f->next));
174			tcf_unbind_filter(tp, &f->res);
175			call_rcu(&f->rcu, fw_delete_filter);
176			return 0;
177		}
178	}
179out:
180	return -EINVAL;
181}
182
183static const struct nla_policy fw_policy[TCA_FW_MAX + 1] = {
184	[TCA_FW_CLASSID]	= { .type = NLA_U32 },
185	[TCA_FW_INDEV]		= { .type = NLA_STRING, .len = IFNAMSIZ },
186	[TCA_FW_MASK]		= { .type = NLA_U32 },
187};
188
189static int
190fw_change_attrs(struct net *net, struct tcf_proto *tp, struct fw_filter *f,
191	struct nlattr **tb, struct nlattr **tca, unsigned long base, bool ovr)
192{
193	struct fw_head *head = rtnl_dereference(tp->root);
194	struct tcf_exts e;
195	u32 mask;
196	int err;
197
198	tcf_exts_init(&e, TCA_FW_ACT, TCA_FW_POLICE);
199	err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, ovr);
200	if (err < 0)
201		return err;
202
203	if (tb[TCA_FW_CLASSID]) {
204		f->res.classid = nla_get_u32(tb[TCA_FW_CLASSID]);
205		tcf_bind_filter(tp, &f->res, base);
206	}
207
208#ifdef CONFIG_NET_CLS_IND
209	if (tb[TCA_FW_INDEV]) {
210		int ret;
211		ret = tcf_change_indev(net, tb[TCA_FW_INDEV]);
212		if (ret < 0) {
213			err = ret;
214			goto errout;
215		}
216		f->ifindex = ret;
217	}
218#endif /* CONFIG_NET_CLS_IND */
219
220	err = -EINVAL;
221	if (tb[TCA_FW_MASK]) {
222		mask = nla_get_u32(tb[TCA_FW_MASK]);
223		if (mask != head->mask)
224			goto errout;
225	} else if (head->mask != 0xFFFFFFFF)
226		goto errout;
227
228	tcf_exts_change(tp, &f->exts, &e);
229
230	return 0;
231errout:
232	tcf_exts_destroy(&e);
233	return err;
234}
235
236static int fw_change(struct net *net, struct sk_buff *in_skb,
237		     struct tcf_proto *tp, unsigned long base,
238		     u32 handle,
239		     struct nlattr **tca,
240		     unsigned long *arg, bool ovr)
241{
242	struct fw_head *head = rtnl_dereference(tp->root);
243	struct fw_filter *f = (struct fw_filter *) *arg;
244	struct nlattr *opt = tca[TCA_OPTIONS];
245	struct nlattr *tb[TCA_FW_MAX + 1];
246	int err;
247
248	if (!opt)
249		return handle ? -EINVAL : 0; /* Succeed if it is old method. */
250
251	err = nla_parse_nested(tb, TCA_FW_MAX, opt, fw_policy);
252	if (err < 0)
253		return err;
254
255	if (f) {
256		struct fw_filter *pfp, *fnew;
257		struct fw_filter __rcu **fp;
258
259		if (f->id != handle && handle)
260			return -EINVAL;
261
262		fnew = kzalloc(sizeof(struct fw_filter), GFP_KERNEL);
263		if (!fnew)
264			return -ENOBUFS;
265
266		fnew->id = f->id;
267		fnew->res = f->res;
268#ifdef CONFIG_NET_CLS_IND
269		fnew->ifindex = f->ifindex;
270#endif /* CONFIG_NET_CLS_IND */
271		fnew->tp = f->tp;
272
273		tcf_exts_init(&fnew->exts, TCA_FW_ACT, TCA_FW_POLICE);
274
275		err = fw_change_attrs(net, tp, fnew, tb, tca, base, ovr);
276		if (err < 0) {
277			kfree(fnew);
278			return err;
279		}
280
281		fp = &head->ht[fw_hash(fnew->id)];
282		for (pfp = rtnl_dereference(*fp); pfp;
283		     fp = &pfp->next, pfp = rtnl_dereference(*fp))
284			if (pfp == f)
285				break;
286
287		RCU_INIT_POINTER(fnew->next, rtnl_dereference(pfp->next));
288		rcu_assign_pointer(*fp, fnew);
289		tcf_unbind_filter(tp, &f->res);
290		call_rcu(&f->rcu, fw_delete_filter);
291
292		*arg = (unsigned long)fnew;
293		return err;
294	}
295
296	if (!handle)
297		return -EINVAL;
298
299	if (!head) {
300		u32 mask = 0xFFFFFFFF;
301		if (tb[TCA_FW_MASK])
302			mask = nla_get_u32(tb[TCA_FW_MASK]);
303
304		head = kzalloc(sizeof(*head), GFP_KERNEL);
305		if (!head)
306			return -ENOBUFS;
307		head->mask = mask;
308
309		rcu_assign_pointer(tp->root, head);
310	}
311
312	f = kzalloc(sizeof(struct fw_filter), GFP_KERNEL);
313	if (f == NULL)
314		return -ENOBUFS;
315
316	tcf_exts_init(&f->exts, TCA_FW_ACT, TCA_FW_POLICE);
317	f->id = handle;
318	f->tp = tp;
319
320	err = fw_change_attrs(net, tp, f, tb, tca, base, ovr);
321	if (err < 0)
322		goto errout;
323
324	RCU_INIT_POINTER(f->next, head->ht[fw_hash(handle)]);
325	rcu_assign_pointer(head->ht[fw_hash(handle)], f);
326
327	*arg = (unsigned long)f;
328	return 0;
329
330errout:
331	kfree(f);
332	return err;
333}
334
335static void fw_walk(struct tcf_proto *tp, struct tcf_walker *arg)
336{
337	struct fw_head *head = rtnl_dereference(tp->root);
338	int h;
339
340	if (head == NULL)
341		arg->stop = 1;
342
343	if (arg->stop)
344		return;
345
346	for (h = 0; h < HTSIZE; h++) {
347		struct fw_filter *f;
348
349		for (f = rtnl_dereference(head->ht[h]); f;
350		     f = rtnl_dereference(f->next)) {
351			if (arg->count < arg->skip) {
352				arg->count++;
353				continue;
354			}
355			if (arg->fn(tp, (unsigned long)f, arg) < 0) {
356				arg->stop = 1;
357				return;
358			}
359			arg->count++;
360		}
361	}
362}
363
364static int fw_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
365		   struct sk_buff *skb, struct tcmsg *t)
366{
367	struct fw_head *head = rtnl_dereference(tp->root);
368	struct fw_filter *f = (struct fw_filter *)fh;
369	struct nlattr *nest;
370
371	if (f == NULL)
372		return skb->len;
373
374	t->tcm_handle = f->id;
375
376	if (!f->res.classid && !tcf_exts_is_available(&f->exts))
377		return skb->len;
378
379	nest = nla_nest_start(skb, TCA_OPTIONS);
380	if (nest == NULL)
381		goto nla_put_failure;
382
383	if (f->res.classid &&
384	    nla_put_u32(skb, TCA_FW_CLASSID, f->res.classid))
385		goto nla_put_failure;
386#ifdef CONFIG_NET_CLS_IND
387	if (f->ifindex) {
388		struct net_device *dev;
389		dev = __dev_get_by_index(net, f->ifindex);
390		if (dev && nla_put_string(skb, TCA_FW_INDEV, dev->name))
391			goto nla_put_failure;
392	}
393#endif /* CONFIG_NET_CLS_IND */
394	if (head->mask != 0xFFFFFFFF &&
395	    nla_put_u32(skb, TCA_FW_MASK, head->mask))
396		goto nla_put_failure;
397
398	if (tcf_exts_dump(skb, &f->exts) < 0)
399		goto nla_put_failure;
400
401	nla_nest_end(skb, nest);
402
403	if (tcf_exts_dump_stats(skb, &f->exts) < 0)
404		goto nla_put_failure;
405
406	return skb->len;
407
408nla_put_failure:
409	nla_nest_cancel(skb, nest);
410	return -1;
411}
412
413static struct tcf_proto_ops cls_fw_ops __read_mostly = {
414	.kind		=	"fw",
415	.classify	=	fw_classify,
416	.init		=	fw_init,
417	.destroy	=	fw_destroy,
418	.get		=	fw_get,
419	.change		=	fw_change,
420	.delete		=	fw_delete,
421	.walk		=	fw_walk,
422	.dump		=	fw_dump,
423	.owner		=	THIS_MODULE,
424};
425
426static int __init init_fw(void)
427{
428	return register_tcf_proto_ops(&cls_fw_ops);
429}
430
431static void __exit exit_fw(void)
432{
433	unregister_tcf_proto_ops(&cls_fw_ops);
434}
435
436module_init(init_fw)
437module_exit(exit_fw)
438MODULE_LICENSE("GPL");
439