1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84#include <linux/module.h>
85#include <linux/types.h>
86#include <linux/kernel.h>
87#include <linux/errno.h>
88#include <linux/rtnetlink.h>
89#include <linux/skbuff.h>
90#include <net/pkt_cls.h>
91
92static LIST_HEAD(ematch_ops);
93static DEFINE_RWLOCK(ematch_mod_lock);
94
95static inline struct tcf_ematch_ops * tcf_em_lookup(u16 kind)
96{
97 struct tcf_ematch_ops *e = NULL;
98
99 read_lock(&ematch_mod_lock);
100 list_for_each_entry(e, &ematch_ops, link) {
101 if (kind == e->kind) {
102 if (!try_module_get(e->owner))
103 e = NULL;
104 read_unlock(&ematch_mod_lock);
105 return e;
106 }
107 }
108 read_unlock(&ematch_mod_lock);
109
110 return NULL;
111}
112
113
114
115
116
117
118
119
120
121
122
123
124
125int tcf_em_register(struct tcf_ematch_ops *ops)
126{
127 int err = -EEXIST;
128 struct tcf_ematch_ops *e;
129
130 if (ops->match == NULL)
131 return -EINVAL;
132
133 write_lock(&ematch_mod_lock);
134 list_for_each_entry(e, &ematch_ops, link)
135 if (ops->kind == e->kind)
136 goto errout;
137
138 list_add_tail(&ops->link, &ematch_ops);
139 err = 0;
140errout:
141 write_unlock(&ematch_mod_lock);
142 return err;
143}
144EXPORT_SYMBOL(tcf_em_register);
145
146
147
148
149
150
151
152
153
154
155
156
157void tcf_em_unregister(struct tcf_ematch_ops *ops)
158{
159 write_lock(&ematch_mod_lock);
160 list_del(&ops->link);
161 write_unlock(&ematch_mod_lock);
162}
163EXPORT_SYMBOL(tcf_em_unregister);
164
165static inline struct tcf_ematch * tcf_em_get_match(struct tcf_ematch_tree *tree,
166 int index)
167{
168 return &tree->matches[index];
169}
170
171
172static int tcf_em_validate(struct tcf_proto *tp,
173 struct tcf_ematch_tree_hdr *tree_hdr,
174 struct tcf_ematch *em, struct nlattr *nla, int idx)
175{
176 int err = -EINVAL;
177 struct tcf_ematch_hdr *em_hdr = nla_data(nla);
178 int data_len = nla_len(nla) - sizeof(*em_hdr);
179 void *data = (void *) em_hdr + sizeof(*em_hdr);
180
181 if (!TCF_EM_REL_VALID(em_hdr->flags))
182 goto errout;
183
184 if (em_hdr->kind == TCF_EM_CONTAINER) {
185
186
187 u32 ref;
188
189 if (data_len < sizeof(ref))
190 goto errout;
191 ref = *(u32 *) data;
192
193 if (ref >= tree_hdr->nmatches)
194 goto errout;
195
196
197
198 if (ref <= idx)
199 goto errout;
200
201
202 em->data = ref;
203 } else {
204
205
206
207
208
209
210
211 em->ops = tcf_em_lookup(em_hdr->kind);
212
213 if (em->ops == NULL) {
214 err = -ENOENT;
215#ifdef CONFIG_MODULES
216 __rtnl_unlock();
217 request_module("ematch-kind-%u", em_hdr->kind);
218 rtnl_lock();
219 em->ops = tcf_em_lookup(em_hdr->kind);
220 if (em->ops) {
221
222
223
224 module_put(em->ops->owner);
225 err = -EAGAIN;
226 }
227#endif
228 goto errout;
229 }
230
231
232
233 if (em->ops->datalen && data_len < em->ops->datalen)
234 goto errout;
235
236 if (em->ops->change) {
237 err = em->ops->change(tp, data, data_len, em);
238 if (err < 0)
239 goto errout;
240 } else if (data_len > 0) {
241
242
243
244
245
246
247
248
249 if (em_hdr->flags & TCF_EM_SIMPLE) {
250 if (data_len < sizeof(u32))
251 goto errout;
252 em->data = *(u32 *) data;
253 } else {
254 void *v = kmemdup(data, data_len, GFP_KERNEL);
255 if (v == NULL) {
256 err = -ENOBUFS;
257 goto errout;
258 }
259 em->data = (unsigned long) v;
260 }
261 }
262 }
263
264 em->matchid = em_hdr->matchid;
265 em->flags = em_hdr->flags;
266 em->datalen = data_len;
267
268 err = 0;
269errout:
270 return err;
271}
272
273static const struct nla_policy em_policy[TCA_EMATCH_TREE_MAX + 1] = {
274 [TCA_EMATCH_TREE_HDR] = { .len = sizeof(struct tcf_ematch_tree_hdr) },
275 [TCA_EMATCH_TREE_LIST] = { .type = NLA_NESTED },
276};
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294int tcf_em_tree_validate(struct tcf_proto *tp, struct nlattr *nla,
295 struct tcf_ematch_tree *tree)
296{
297 int idx, list_len, matches_len, err;
298 struct nlattr *tb[TCA_EMATCH_TREE_MAX + 1];
299 struct nlattr *rt_match, *rt_hdr, *rt_list;
300 struct tcf_ematch_tree_hdr *tree_hdr;
301 struct tcf_ematch *em;
302
303 memset(tree, 0, sizeof(*tree));
304 if (!nla)
305 return 0;
306
307 err = nla_parse_nested(tb, TCA_EMATCH_TREE_MAX, nla, em_policy);
308 if (err < 0)
309 goto errout;
310
311 err = -EINVAL;
312 rt_hdr = tb[TCA_EMATCH_TREE_HDR];
313 rt_list = tb[TCA_EMATCH_TREE_LIST];
314
315 if (rt_hdr == NULL || rt_list == NULL)
316 goto errout;
317
318 tree_hdr = nla_data(rt_hdr);
319 memcpy(&tree->hdr, tree_hdr, sizeof(*tree_hdr));
320
321 rt_match = nla_data(rt_list);
322 list_len = nla_len(rt_list);
323 matches_len = tree_hdr->nmatches * sizeof(*em);
324
325 tree->matches = kzalloc(matches_len, GFP_KERNEL);
326 if (tree->matches == NULL)
327 goto errout;
328
329
330
331
332
333
334
335
336
337 for (idx = 0; nla_ok(rt_match, list_len); idx++) {
338 err = -EINVAL;
339
340 if (rt_match->nla_type != (idx + 1))
341 goto errout_abort;
342
343 if (idx >= tree_hdr->nmatches)
344 goto errout_abort;
345
346 if (nla_len(rt_match) < sizeof(struct tcf_ematch_hdr))
347 goto errout_abort;
348
349 em = tcf_em_get_match(tree, idx);
350
351 err = tcf_em_validate(tp, tree_hdr, em, rt_match, idx);
352 if (err < 0)
353 goto errout_abort;
354
355 rt_match = nla_next(rt_match, &list_len);
356 }
357
358
359
360
361
362 if (idx != tree_hdr->nmatches) {
363 err = -EINVAL;
364 goto errout_abort;
365 }
366
367 err = 0;
368errout:
369 return err;
370
371errout_abort:
372 tcf_em_tree_destroy(tp, tree);
373 return err;
374}
375EXPORT_SYMBOL(tcf_em_tree_validate);
376
377
378
379
380
381
382
383
384
385
386
387void tcf_em_tree_destroy(struct tcf_proto *tp, struct tcf_ematch_tree *tree)
388{
389 int i;
390
391 if (tree->matches == NULL)
392 return;
393
394 for (i = 0; i < tree->hdr.nmatches; i++) {
395 struct tcf_ematch *em = tcf_em_get_match(tree, i);
396
397 if (em->ops) {
398 if (em->ops->destroy)
399 em->ops->destroy(tp, em);
400 else if (!tcf_em_is_simple(em))
401 kfree((void *) em->data);
402 module_put(em->ops->owner);
403 }
404 }
405
406 tree->hdr.nmatches = 0;
407 kfree(tree->matches);
408 tree->matches = NULL;
409}
410EXPORT_SYMBOL(tcf_em_tree_destroy);
411
412
413
414
415
416
417
418
419
420
421
422
423
424int tcf_em_tree_dump(struct sk_buff *skb, struct tcf_ematch_tree *tree, int tlv)
425{
426 int i;
427 u8 *tail;
428 struct nlattr *top_start;
429 struct nlattr *list_start;
430
431 top_start = nla_nest_start(skb, tlv);
432 if (top_start == NULL)
433 goto nla_put_failure;
434
435 NLA_PUT(skb, TCA_EMATCH_TREE_HDR, sizeof(tree->hdr), &tree->hdr);
436
437 list_start = nla_nest_start(skb, TCA_EMATCH_TREE_LIST);
438 if (list_start == NULL)
439 goto nla_put_failure;
440
441 tail = skb_tail_pointer(skb);
442 for (i = 0; i < tree->hdr.nmatches; i++) {
443 struct nlattr *match_start = (struct nlattr *)tail;
444 struct tcf_ematch *em = tcf_em_get_match(tree, i);
445 struct tcf_ematch_hdr em_hdr = {
446 .kind = em->ops ? em->ops->kind : TCF_EM_CONTAINER,
447 .matchid = em->matchid,
448 .flags = em->flags
449 };
450
451 NLA_PUT(skb, i+1, sizeof(em_hdr), &em_hdr);
452
453 if (em->ops && em->ops->dump) {
454 if (em->ops->dump(skb, em) < 0)
455 goto nla_put_failure;
456 } else if (tcf_em_is_container(em) || tcf_em_is_simple(em)) {
457 u32 u = em->data;
458 nla_put_nohdr(skb, sizeof(u), &u);
459 } else if (em->datalen > 0)
460 nla_put_nohdr(skb, em->datalen, (void *) em->data);
461
462 tail = skb_tail_pointer(skb);
463 match_start->nla_len = tail - (u8 *)match_start;
464 }
465
466 nla_nest_end(skb, list_start);
467 nla_nest_end(skb, top_start);
468
469 return 0;
470
471nla_put_failure:
472 return -1;
473}
474EXPORT_SYMBOL(tcf_em_tree_dump);
475
476static inline int tcf_em_match(struct sk_buff *skb, struct tcf_ematch *em,
477 struct tcf_pkt_info *info)
478{
479 int r = em->ops->match(skb, em, info);
480 return tcf_em_is_inverted(em) ? !r : r;
481}
482
483
484int __tcf_em_tree_match(struct sk_buff *skb, struct tcf_ematch_tree *tree,
485 struct tcf_pkt_info *info)
486{
487 int stackp = 0, match_idx = 0, res = 0;
488 struct tcf_ematch *cur_match;
489 int stack[CONFIG_NET_EMATCH_STACK];
490
491proceed:
492 while (match_idx < tree->hdr.nmatches) {
493 cur_match = tcf_em_get_match(tree, match_idx);
494
495 if (tcf_em_is_container(cur_match)) {
496 if (unlikely(stackp >= CONFIG_NET_EMATCH_STACK))
497 goto stack_overflow;
498
499 stack[stackp++] = match_idx;
500 match_idx = cur_match->data;
501 goto proceed;
502 }
503
504 res = tcf_em_match(skb, cur_match, info);
505
506 if (tcf_em_early_end(cur_match, res))
507 break;
508
509 match_idx++;
510 }
511
512pop_stack:
513 if (stackp > 0) {
514 match_idx = stack[--stackp];
515 cur_match = tcf_em_get_match(tree, match_idx);
516
517 if (tcf_em_early_end(cur_match, res))
518 goto pop_stack;
519 else {
520 match_idx++;
521 goto proceed;
522 }
523 }
524
525 return res;
526
527stack_overflow:
528 if (net_ratelimit())
529 printk("Local stack overflow, increase NET_EMATCH_STACK\n");
530 return -1;
531}
532EXPORT_SYMBOL(__tcf_em_tree_match);
533