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