blob: 17c5dfc673209d68670aee8bfb5cbf099a4f0a51 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sched/cls_u32.c Ugly (or Universal) 32bit key 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: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
11 * The filters are packed to hash tables of key nodes
12 * with a set of 32bit key/mask pairs at every node.
13 * Nodes reference next level hash tables etc.
14 *
15 * This scheme is the best universal classifier I managed to
16 * invent; it is not super-fast, but it is not slow (provided you
17 * program it correctly), and general enough. And its relative
18 * speed grows as the number of rules becomes larger.
19 *
20 * It seems that it represents the best middle point between
21 * speed and manageability both by human and by machine.
22 *
23 * It is especially useful for link sharing combined with QoS;
24 * pure RSVP doesn't need such a general approach and can use
25 * much simpler (and faster) schemes, sort of cls_rsvp.c.
26 *
27 * JHS: We should remove the CONFIG_NET_CLS_IND from here
28 * eventually when the meta match extension is made available
29 *
30 * nfmark match added by Catalin(ux aka Dino) BOIE <catab at umbrella.ro>
31 */
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/types.h>
36#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/skbuff.h>
Patrick McHardy0ba48052007-07-02 22:49:07 -070041#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <net/act_api.h>
43#include <net/pkt_cls.h>
44
45struct tc_u_knode
46{
47 struct tc_u_knode *next;
48 u32 handle;
49 struct tc_u_hnode *ht_up;
50 struct tcf_exts exts;
51#ifdef CONFIG_NET_CLS_IND
52 char indev[IFNAMSIZ];
53#endif
54 u8 fshift;
55 struct tcf_result res;
56 struct tc_u_hnode *ht_down;
57#ifdef CONFIG_CLS_U32_PERF
58 struct tc_u32_pcnt *pf;
59#endif
60#ifdef CONFIG_CLS_U32_MARK
61 struct tc_u32_mark mark;
62#endif
63 struct tc_u32_sel sel;
64};
65
66struct tc_u_hnode
67{
68 struct tc_u_hnode *next;
69 u32 handle;
70 u32 prio;
71 struct tc_u_common *tp_c;
72 int refcnt;
73 unsigned divisor;
74 struct tc_u_knode *ht[1];
75};
76
77struct tc_u_common
78{
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 struct tc_u_hnode *hlist;
80 struct Qdisc *q;
81 int refcnt;
82 u32 hgenerator;
83};
84
Patrick McHardy52390082008-01-31 18:36:18 -080085static const struct tcf_ext_map u32_ext_map = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 .action = TCA_U32_ACT,
87 .police = TCA_U32_POLICE
88};
89
Al Viro0382b9c2008-03-17 22:46:46 -070090static __inline__ unsigned u32_hash_fold(__be32 key, struct tc_u32_sel *sel, u8 fshift)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Radu Rendec543821c2007-11-07 01:20:12 -080092 unsigned h = ntohl(key & sel->hmask)>>fshift;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 return h;
95}
96
97static int u32_classify(struct sk_buff *skb, struct tcf_proto *tp, struct tcf_result *res)
98{
99 struct {
100 struct tc_u_knode *knode;
101 u8 *ptr;
102 } stack[TC_U32_MAXDEPTH];
103
104 struct tc_u_hnode *ht = (struct tc_u_hnode*)tp->root;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700105 u8 *ptr = skb_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 struct tc_u_knode *n;
107 int sdepth = 0;
108 int off2 = 0;
109 int sel = 0;
110#ifdef CONFIG_CLS_U32_PERF
111 int j;
112#endif
113 int i, r;
114
115next_ht:
116 n = ht->ht[sel];
117
118next_knode:
119 if (n) {
120 struct tc_u32_key *key = n->sel.keys;
121
122#ifdef CONFIG_CLS_U32_PERF
123 n->pf->rcnt +=1;
124 j = 0;
125#endif
126
127#ifdef CONFIG_CLS_U32_MARK
Thomas Graf82e91ff2006-11-09 15:19:14 -0800128 if ((skb->mark & n->mark.mask) != n->mark.val) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 n = n->next;
130 goto next_knode;
131 } else {
132 n->mark.success++;
133 }
134#endif
135
136 for (i = n->sel.nkeys; i>0; i--, key++) {
137
Al Viro0382b9c2008-03-17 22:46:46 -0700138 if ((*(__be32*)(ptr+key->off+(off2&key->offmask))^key->val)&key->mask) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 n = n->next;
140 goto next_knode;
141 }
142#ifdef CONFIG_CLS_U32_PERF
143 n->pf->kcnts[j] +=1;
144 j++;
145#endif
146 }
147 if (n->ht_down == NULL) {
148check_terminal:
149 if (n->sel.flags&TC_U32_TERMINAL) {
150
151 *res = n->res;
152#ifdef CONFIG_NET_CLS_IND
153 if (!tcf_match_indev(skb, n->indev)) {
154 n = n->next;
155 goto next_knode;
156 }
157#endif
158#ifdef CONFIG_CLS_U32_PERF
159 n->pf->rhit +=1;
160#endif
161 r = tcf_exts_exec(skb, &n->exts, res);
162 if (r < 0) {
163 n = n->next;
164 goto next_knode;
165 }
166
167 return r;
168 }
169 n = n->next;
170 goto next_knode;
171 }
172
173 /* PUSH */
174 if (sdepth >= TC_U32_MAXDEPTH)
175 goto deadloop;
176 stack[sdepth].knode = n;
177 stack[sdepth].ptr = ptr;
178 sdepth++;
179
180 ht = n->ht_down;
181 sel = 0;
182 if (ht->divisor)
Al Viro0382b9c2008-03-17 22:46:46 -0700183 sel = ht->divisor&u32_hash_fold(*(__be32*)(ptr+n->sel.hoff), &n->sel,n->fshift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185 if (!(n->sel.flags&(TC_U32_VAROFFSET|TC_U32_OFFSET|TC_U32_EAT)))
186 goto next_ht;
187
188 if (n->sel.flags&(TC_U32_OFFSET|TC_U32_VAROFFSET)) {
189 off2 = n->sel.off + 3;
190 if (n->sel.flags&TC_U32_VAROFFSET)
Al Viro0382b9c2008-03-17 22:46:46 -0700191 off2 += ntohs(n->sel.offmask & *(__be16*)(ptr+n->sel.offoff)) >>n->sel.offshift;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 off2 &= ~3;
193 }
194 if (n->sel.flags&TC_U32_EAT) {
195 ptr += off2;
196 off2 = 0;
197 }
198
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700199 if (ptr < skb_tail_pointer(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 goto next_ht;
201 }
202
203 /* POP */
204 if (sdepth--) {
205 n = stack[sdepth].knode;
206 ht = n->ht_up;
207 ptr = stack[sdepth].ptr;
208 goto check_terminal;
209 }
210 return -1;
211
212deadloop:
213 if (net_ratelimit())
214 printk("cls_u32: dead loop\n");
215 return -1;
216}
217
218static __inline__ struct tc_u_hnode *
219u32_lookup_ht(struct tc_u_common *tp_c, u32 handle)
220{
221 struct tc_u_hnode *ht;
222
223 for (ht = tp_c->hlist; ht; ht = ht->next)
224 if (ht->handle == handle)
225 break;
226
227 return ht;
228}
229
230static __inline__ struct tc_u_knode *
231u32_lookup_key(struct tc_u_hnode *ht, u32 handle)
232{
233 unsigned sel;
234 struct tc_u_knode *n = NULL;
235
236 sel = TC_U32_HASH(handle);
237 if (sel > ht->divisor)
238 goto out;
239
240 for (n = ht->ht[sel]; n; n = n->next)
241 if (n->handle == handle)
242 break;
243out:
244 return n;
245}
246
247
248static unsigned long u32_get(struct tcf_proto *tp, u32 handle)
249{
250 struct tc_u_hnode *ht;
251 struct tc_u_common *tp_c = tp->data;
252
253 if (TC_U32_HTID(handle) == TC_U32_ROOT)
254 ht = tp->root;
255 else
256 ht = u32_lookup_ht(tp_c, TC_U32_HTID(handle));
257
258 if (!ht)
259 return 0;
260
261 if (TC_U32_KEY(handle) == 0)
262 return (unsigned long)ht;
263
264 return (unsigned long)u32_lookup_key(ht, handle);
265}
266
267static void u32_put(struct tcf_proto *tp, unsigned long f)
268{
269}
270
271static u32 gen_new_htid(struct tc_u_common *tp_c)
272{
273 int i = 0x800;
274
275 do {
276 if (++tp_c->hgenerator == 0x7FF)
277 tp_c->hgenerator = 1;
278 } while (--i>0 && u32_lookup_ht(tp_c, (tp_c->hgenerator|0x800)<<20));
279
280 return i > 0 ? (tp_c->hgenerator|0x800)<<20 : 0;
281}
282
283static int u32_init(struct tcf_proto *tp)
284{
285 struct tc_u_hnode *root_ht;
286 struct tc_u_common *tp_c;
287
David S. Miller72b25a92008-07-18 20:54:17 -0700288 tp_c = tp->q->u32_node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700290 root_ht = kzalloc(sizeof(*root_ht), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 if (root_ht == NULL)
292 return -ENOBUFS;
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 root_ht->divisor = 0;
295 root_ht->refcnt++;
296 root_ht->handle = tp_c ? gen_new_htid(tp_c) : 0x80000000;
297 root_ht->prio = tp->prio;
298
299 if (tp_c == NULL) {
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700300 tp_c = kzalloc(sizeof(*tp_c), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 if (tp_c == NULL) {
302 kfree(root_ht);
303 return -ENOBUFS;
304 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 tp_c->q = tp->q;
David S. Miller72b25a92008-07-18 20:54:17 -0700306 tp->q->u32_node = tp_c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 }
308
309 tp_c->refcnt++;
310 root_ht->next = tp_c->hlist;
311 tp_c->hlist = root_ht;
312 root_ht->tp_c = tp_c;
313
314 tp->root = root_ht;
315 tp->data = tp_c;
316 return 0;
317}
318
319static int u32_destroy_key(struct tcf_proto *tp, struct tc_u_knode *n)
320{
321 tcf_unbind_filter(tp, &n->res);
322 tcf_exts_destroy(tp, &n->exts);
323 if (n->ht_down)
324 n->ht_down->refcnt--;
325#ifdef CONFIG_CLS_U32_PERF
Patrick McHardy1ae39a42006-03-23 01:16:48 -0800326 kfree(n->pf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327#endif
328 kfree(n);
329 return 0;
330}
331
332static int u32_delete_key(struct tcf_proto *tp, struct tc_u_knode* key)
333{
334 struct tc_u_knode **kp;
335 struct tc_u_hnode *ht = key->ht_up;
336
337 if (ht) {
338 for (kp = &ht->ht[TC_U32_HASH(key->handle)]; *kp; kp = &(*kp)->next) {
339 if (*kp == key) {
340 tcf_tree_lock(tp);
341 *kp = key->next;
342 tcf_tree_unlock(tp);
343
344 u32_destroy_key(tp, key);
345 return 0;
346 }
347 }
348 }
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700349 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return 0;
351}
352
353static void u32_clear_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht)
354{
355 struct tc_u_knode *n;
356 unsigned h;
357
358 for (h=0; h<=ht->divisor; h++) {
359 while ((n = ht->ht[h]) != NULL) {
360 ht->ht[h] = n->next;
361
362 u32_destroy_key(tp, n);
363 }
364 }
365}
366
367static int u32_destroy_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht)
368{
369 struct tc_u_common *tp_c = tp->data;
370 struct tc_u_hnode **hn;
371
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700372 WARN_ON(ht->refcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
374 u32_clear_hnode(tp, ht);
375
376 for (hn = &tp_c->hlist; *hn; hn = &(*hn)->next) {
377 if (*hn == ht) {
378 *hn = ht->next;
379 kfree(ht);
380 return 0;
381 }
382 }
383
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700384 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 return -ENOENT;
386}
387
388static void u32_destroy(struct tcf_proto *tp)
389{
390 struct tc_u_common *tp_c = tp->data;
Patrick McHardy47a1a1d2008-11-19 08:03:09 +0000391 struct tc_u_hnode *root_ht = tp->root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700393 WARN_ON(root_ht == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 if (root_ht && --root_ht->refcnt == 0)
396 u32_destroy_hnode(tp, root_ht);
397
398 if (--tp_c->refcnt == 0) {
399 struct tc_u_hnode *ht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
David S. Miller72b25a92008-07-18 20:54:17 -0700401 tp->q->u32_node = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Jarek Poplawskie56cfad2008-04-12 18:37:13 -0700403 for (ht = tp_c->hlist; ht; ht = ht->next) {
404 ht->refcnt--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 u32_clear_hnode(tp, ht);
Jarek Poplawskie56cfad2008-04-12 18:37:13 -0700406 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
408 while ((ht = tp_c->hlist) != NULL) {
409 tp_c->hlist = ht->next;
410
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700411 WARN_ON(ht->refcnt != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 kfree(ht);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700414 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
416 kfree(tp_c);
417 }
418
419 tp->data = NULL;
420}
421
422static int u32_delete(struct tcf_proto *tp, unsigned long arg)
423{
424 struct tc_u_hnode *ht = (struct tc_u_hnode*)arg;
425
426 if (ht == NULL)
427 return 0;
428
429 if (TC_U32_KEY(ht->handle))
430 return u32_delete_key(tp, (struct tc_u_knode*)ht);
431
432 if (tp->root == ht)
433 return -EINVAL;
434
Jarek Poplawskie56cfad2008-04-12 18:37:13 -0700435 if (ht->refcnt == 1) {
436 ht->refcnt--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 u32_destroy_hnode(tp, ht);
Jarek Poplawskie56cfad2008-04-12 18:37:13 -0700438 } else {
439 return -EBUSY;
440 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 return 0;
443}
444
445static u32 gen_new_kid(struct tc_u_hnode *ht, u32 handle)
446{
447 struct tc_u_knode *n;
448 unsigned i = 0x7FF;
449
450 for (n=ht->ht[TC_U32_HASH(handle)]; n; n = n->next)
451 if (i < TC_U32_NODE(n->handle))
452 i = TC_U32_NODE(n->handle);
453 i++;
454
455 return handle|(i>0xFFF ? 0xFFF : i);
456}
457
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800458static const struct nla_policy u32_policy[TCA_U32_MAX + 1] = {
459 [TCA_U32_CLASSID] = { .type = NLA_U32 },
460 [TCA_U32_HASH] = { .type = NLA_U32 },
461 [TCA_U32_LINK] = { .type = NLA_U32 },
462 [TCA_U32_DIVISOR] = { .type = NLA_U32 },
463 [TCA_U32_SEL] = { .len = sizeof(struct tc_u32_sel) },
464 [TCA_U32_INDEV] = { .type = NLA_STRING, .len = IFNAMSIZ },
465 [TCA_U32_MARK] = { .len = sizeof(struct tc_u32_mark) },
466};
467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468static int u32_set_parms(struct tcf_proto *tp, unsigned long base,
469 struct tc_u_hnode *ht,
Patrick McHardyadd93b62008-01-22 22:11:33 -0800470 struct tc_u_knode *n, struct nlattr **tb,
471 struct nlattr *est)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472{
473 int err;
474 struct tcf_exts e;
475
476 err = tcf_exts_validate(tp, tb, est, &e, &u32_ext_map);
477 if (err < 0)
478 return err;
479
480 err = -EINVAL;
Patrick McHardyadd93b62008-01-22 22:11:33 -0800481 if (tb[TCA_U32_LINK]) {
Patrick McHardy1587bac2008-01-23 20:35:03 -0800482 u32 handle = nla_get_u32(tb[TCA_U32_LINK]);
Patrick McHardy47a1a1d2008-11-19 08:03:09 +0000483 struct tc_u_hnode *ht_down = NULL, *ht_old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 if (TC_U32_KEY(handle))
486 goto errout;
487
488 if (handle) {
489 ht_down = u32_lookup_ht(ht->tp_c, handle);
490
491 if (ht_down == NULL)
492 goto errout;
493 ht_down->refcnt++;
494 }
495
496 tcf_tree_lock(tp);
Patrick McHardy47a1a1d2008-11-19 08:03:09 +0000497 ht_old = n->ht_down;
498 n->ht_down = ht_down;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 tcf_tree_unlock(tp);
500
Patrick McHardy47a1a1d2008-11-19 08:03:09 +0000501 if (ht_old)
502 ht_old->refcnt--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 }
Patrick McHardyadd93b62008-01-22 22:11:33 -0800504 if (tb[TCA_U32_CLASSID]) {
Patrick McHardy1587bac2008-01-23 20:35:03 -0800505 n->res.classid = nla_get_u32(tb[TCA_U32_CLASSID]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 tcf_bind_filter(tp, &n->res, base);
507 }
508
509#ifdef CONFIG_NET_CLS_IND
Patrick McHardyadd93b62008-01-22 22:11:33 -0800510 if (tb[TCA_U32_INDEV]) {
511 err = tcf_change_indev(tp, n->indev, tb[TCA_U32_INDEV]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 if (err < 0)
513 goto errout;
514 }
515#endif
516 tcf_exts_change(tp, &n->exts, &e);
517
518 return 0;
519errout:
520 tcf_exts_destroy(tp, &e);
521 return err;
522}
523
524static int u32_change(struct tcf_proto *tp, unsigned long base, u32 handle,
Patrick McHardyadd93b62008-01-22 22:11:33 -0800525 struct nlattr **tca,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 unsigned long *arg)
527{
528 struct tc_u_common *tp_c = tp->data;
529 struct tc_u_hnode *ht;
530 struct tc_u_knode *n;
531 struct tc_u32_sel *s;
Patrick McHardyadd93b62008-01-22 22:11:33 -0800532 struct nlattr *opt = tca[TCA_OPTIONS];
533 struct nlattr *tb[TCA_U32_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 u32 htid;
535 int err;
536
537 if (opt == NULL)
538 return handle ? -EINVAL : 0;
539
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800540 err = nla_parse_nested(tb, TCA_U32_MAX, opt, u32_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800541 if (err < 0)
542 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
544 if ((n = (struct tc_u_knode*)*arg) != NULL) {
545 if (TC_U32_KEY(n->handle) == 0)
546 return -EINVAL;
547
Patrick McHardyadd93b62008-01-22 22:11:33 -0800548 return u32_set_parms(tp, base, n->ht_up, n, tb, tca[TCA_RATE]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
550
Patrick McHardyadd93b62008-01-22 22:11:33 -0800551 if (tb[TCA_U32_DIVISOR]) {
Patrick McHardy1587bac2008-01-23 20:35:03 -0800552 unsigned divisor = nla_get_u32(tb[TCA_U32_DIVISOR]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554 if (--divisor > 0x100)
555 return -EINVAL;
556 if (TC_U32_KEY(handle))
557 return -EINVAL;
558 if (handle == 0) {
559 handle = gen_new_htid(tp->data);
560 if (handle == 0)
561 return -ENOMEM;
562 }
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700563 ht = kzalloc(sizeof(*ht) + divisor*sizeof(void*), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 if (ht == NULL)
565 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 ht->tp_c = tp_c;
Jarek Poplawskie56cfad2008-04-12 18:37:13 -0700567 ht->refcnt = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 ht->divisor = divisor;
569 ht->handle = handle;
570 ht->prio = tp->prio;
571 ht->next = tp_c->hlist;
572 tp_c->hlist = ht;
573 *arg = (unsigned long)ht;
574 return 0;
575 }
576
Patrick McHardyadd93b62008-01-22 22:11:33 -0800577 if (tb[TCA_U32_HASH]) {
Patrick McHardy1587bac2008-01-23 20:35:03 -0800578 htid = nla_get_u32(tb[TCA_U32_HASH]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 if (TC_U32_HTID(htid) == TC_U32_ROOT) {
580 ht = tp->root;
581 htid = ht->handle;
582 } else {
583 ht = u32_lookup_ht(tp->data, TC_U32_HTID(htid));
584 if (ht == NULL)
585 return -EINVAL;
586 }
587 } else {
588 ht = tp->root;
589 htid = ht->handle;
590 }
591
592 if (ht->divisor < TC_U32_HASH(htid))
593 return -EINVAL;
594
595 if (handle) {
596 if (TC_U32_HTID(handle) && TC_U32_HTID(handle^htid))
597 return -EINVAL;
598 handle = htid | TC_U32_NODE(handle);
599 } else
600 handle = gen_new_kid(ht, htid);
601
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800602 if (tb[TCA_U32_SEL] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 return -EINVAL;
604
Patrick McHardyadd93b62008-01-22 22:11:33 -0800605 s = nla_data(tb[TCA_U32_SEL]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700607 n = kzalloc(sizeof(*n) + s->nkeys*sizeof(struct tc_u32_key), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 if (n == NULL)
609 return -ENOBUFS;
610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611#ifdef CONFIG_CLS_U32_PERF
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700612 n->pf = kzalloc(sizeof(struct tc_u32_pcnt) + s->nkeys*sizeof(u64), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 if (n->pf == NULL) {
614 kfree(n);
615 return -ENOBUFS;
616 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617#endif
618
619 memcpy(&n->sel, s, sizeof(*s) + s->nkeys*sizeof(struct tc_u32_key));
620 n->ht_up = ht;
621 n->handle = handle;
Radu Rendecb2268012007-11-10 21:54:50 -0800622 n->fshift = s->hmask ? ffs(ntohl(s->hmask)) - 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
624#ifdef CONFIG_CLS_U32_MARK
Patrick McHardyadd93b62008-01-22 22:11:33 -0800625 if (tb[TCA_U32_MARK]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 struct tc_u32_mark *mark;
627
Patrick McHardyadd93b62008-01-22 22:11:33 -0800628 mark = nla_data(tb[TCA_U32_MARK]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 memcpy(&n->mark, mark, sizeof(struct tc_u32_mark));
630 n->mark.success = 0;
631 }
632#endif
633
Patrick McHardyadd93b62008-01-22 22:11:33 -0800634 err = u32_set_parms(tp, base, ht, n, tb, tca[TCA_RATE]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 if (err == 0) {
636 struct tc_u_knode **ins;
637 for (ins = &ht->ht[TC_U32_HASH(handle)]; *ins; ins = &(*ins)->next)
638 if (TC_U32_NODE(handle) < TC_U32_NODE((*ins)->handle))
639 break;
640
641 n->next = *ins;
Jarek Poplawski6f573212009-01-05 18:14:19 -0800642 tcf_tree_lock(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 *ins = n;
Jarek Poplawski6f573212009-01-05 18:14:19 -0800644 tcf_tree_unlock(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 *arg = (unsigned long)n;
647 return 0;
648 }
649#ifdef CONFIG_CLS_U32_PERF
Patrick McHardy1ae39a42006-03-23 01:16:48 -0800650 kfree(n->pf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651#endif
652 kfree(n);
653 return err;
654}
655
656static void u32_walk(struct tcf_proto *tp, struct tcf_walker *arg)
657{
658 struct tc_u_common *tp_c = tp->data;
659 struct tc_u_hnode *ht;
660 struct tc_u_knode *n;
661 unsigned h;
662
663 if (arg->stop)
664 return;
665
666 for (ht = tp_c->hlist; ht; ht = ht->next) {
667 if (ht->prio != tp->prio)
668 continue;
669 if (arg->count >= arg->skip) {
670 if (arg->fn(tp, (unsigned long)ht, arg) < 0) {
671 arg->stop = 1;
672 return;
673 }
674 }
675 arg->count++;
676 for (h = 0; h <= ht->divisor; h++) {
677 for (n = ht->ht[h]; n; n = n->next) {
678 if (arg->count < arg->skip) {
679 arg->count++;
680 continue;
681 }
682 if (arg->fn(tp, (unsigned long)n, arg) < 0) {
683 arg->stop = 1;
684 return;
685 }
686 arg->count++;
687 }
688 }
689 }
690}
691
692static int u32_dump(struct tcf_proto *tp, unsigned long fh,
693 struct sk_buff *skb, struct tcmsg *t)
694{
695 struct tc_u_knode *n = (struct tc_u_knode*)fh;
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800696 struct nlattr *nest;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 if (n == NULL)
699 return skb->len;
700
701 t->tcm_handle = n->handle;
702
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800703 nest = nla_nest_start(skb, TCA_OPTIONS);
704 if (nest == NULL)
705 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
707 if (TC_U32_KEY(n->handle) == 0) {
708 struct tc_u_hnode *ht = (struct tc_u_hnode*)fh;
709 u32 divisor = ht->divisor+1;
Patrick McHardy24beeab2008-01-23 20:34:48 -0800710 NLA_PUT_U32(skb, TCA_U32_DIVISOR, divisor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 } else {
Patrick McHardyadd93b62008-01-22 22:11:33 -0800712 NLA_PUT(skb, TCA_U32_SEL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 sizeof(n->sel) + n->sel.nkeys*sizeof(struct tc_u32_key),
714 &n->sel);
715 if (n->ht_up) {
716 u32 htid = n->handle & 0xFFFFF000;
Patrick McHardy24beeab2008-01-23 20:34:48 -0800717 NLA_PUT_U32(skb, TCA_U32_HASH, htid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 }
719 if (n->res.classid)
Patrick McHardy24beeab2008-01-23 20:34:48 -0800720 NLA_PUT_U32(skb, TCA_U32_CLASSID, n->res.classid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 if (n->ht_down)
Patrick McHardy24beeab2008-01-23 20:34:48 -0800722 NLA_PUT_U32(skb, TCA_U32_LINK, n->ht_down->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724#ifdef CONFIG_CLS_U32_MARK
725 if (n->mark.val || n->mark.mask)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800726 NLA_PUT(skb, TCA_U32_MARK, sizeof(n->mark), &n->mark);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727#endif
728
729 if (tcf_exts_dump(skb, &n->exts, &u32_ext_map) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800730 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
732#ifdef CONFIG_NET_CLS_IND
733 if(strlen(n->indev))
Patrick McHardy57e1c482008-01-23 20:34:28 -0800734 NLA_PUT_STRING(skb, TCA_U32_INDEV, n->indev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735#endif
736#ifdef CONFIG_CLS_U32_PERF
Patrick McHardyadd93b62008-01-22 22:11:33 -0800737 NLA_PUT(skb, TCA_U32_PCNT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 sizeof(struct tc_u32_pcnt) + n->sel.nkeys*sizeof(u64),
739 n->pf);
740#endif
741 }
742
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800743 nla_nest_end(skb, nest);
744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 if (TC_U32_KEY(n->handle))
746 if (tcf_exts_dump_stats(skb, &n->exts, &u32_ext_map) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800747 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 return skb->len;
749
Patrick McHardyadd93b62008-01-22 22:11:33 -0800750nla_put_failure:
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800751 nla_nest_cancel(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 return -1;
753}
754
Patrick McHardy2eb9d752008-01-22 22:10:42 -0800755static struct tcf_proto_ops cls_u32_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 .kind = "u32",
757 .classify = u32_classify,
758 .init = u32_init,
759 .destroy = u32_destroy,
760 .get = u32_get,
761 .put = u32_put,
762 .change = u32_change,
763 .delete = u32_delete,
764 .walk = u32_walk,
765 .dump = u32_dump,
766 .owner = THIS_MODULE,
767};
768
769static int __init init_u32(void)
770{
771 printk("u32 classifier\n");
772#ifdef CONFIG_CLS_U32_PERF
Ralf Hildebrandtc0956bd2006-08-15 02:12:43 -0700773 printk(" Performance counters on\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775#ifdef CONFIG_NET_CLS_IND
776 printk(" input device check on \n");
777#endif
778#ifdef CONFIG_NET_CLS_ACT
779 printk(" Actions configured \n");
780#endif
781 return register_tcf_proto_ops(&cls_u32_ops);
782}
783
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900784static void __exit exit_u32(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
786 unregister_tcf_proto_ops(&cls_u32_ops);
787}
788
789module_init(init_u32)
790module_exit(exit_u32)
791MODULE_LICENSE("GPL");