[NET_SCHED]: ingress: switch back to using ingress_lock
[linux-2.6.git] / net / sched / cls_route.c
1 /*
2  * net/sched/cls_route.c        ROUTE4 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
12 #include <linux/module.h>
13 #include <asm/uaccess.h>
14 #include <asm/system.h>
15 #include <linux/bitops.h>
16 #include <linux/types.h>
17 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include <linux/mm.h>
20 #include <linux/socket.h>
21 #include <linux/sockios.h>
22 #include <linux/in.h>
23 #include <linux/errno.h>
24 #include <linux/interrupt.h>
25 #include <linux/if_ether.h>
26 #include <linux/inet.h>
27 #include <linux/netdevice.h>
28 #include <linux/etherdevice.h>
29 #include <linux/notifier.h>
30 #include <net/ip.h>
31 #include <net/netlink.h>
32 #include <net/route.h>
33 #include <linux/skbuff.h>
34 #include <net/sock.h>
35 #include <net/act_api.h>
36 #include <net/pkt_cls.h>
37
38 /*
39    1. For now we assume that route tags < 256.
40       It allows to use direct table lookups, instead of hash tables.
41    2. For now we assume that "from TAG" and "fromdev DEV" statements
42       are mutually  exclusive.
43    3. "to TAG from ANY" has higher priority, than "to ANY from XXX"
44  */
45
46 struct route4_fastmap
47 {
48         struct route4_filter    *filter;
49         u32                     id;
50         int                     iif;
51 };
52
53 struct route4_head
54 {
55         struct route4_fastmap   fastmap[16];
56         struct route4_bucket    *table[256+1];
57 };
58
59 struct route4_bucket
60 {
61         /* 16 FROM buckets + 16 IIF buckets + 1 wildcard bucket */
62         struct route4_filter    *ht[16+16+1];
63 };
64
65 struct route4_filter
66 {
67         struct route4_filter    *next;
68         u32                     id;
69         int                     iif;
70
71         struct tcf_result       res;
72         struct tcf_exts         exts;
73         u32                     handle;
74         struct route4_bucket    *bkt;
75 };
76
77 #define ROUTE4_FAILURE ((struct route4_filter*)(-1L))
78
79 static struct tcf_ext_map route_ext_map = {
80         .police = TCA_ROUTE4_POLICE,
81         .action = TCA_ROUTE4_ACT
82 };
83
84 static __inline__ int route4_fastmap_hash(u32 id, int iif)
85 {
86         return id&0xF;
87 }
88
89 static inline
90 void route4_reset_fastmap(struct net_device *dev, struct route4_head *head, u32 id)
91 {
92         qdisc_lock_tree(dev);
93         memset(head->fastmap, 0, sizeof(head->fastmap));
94         qdisc_unlock_tree(dev);
95 }
96
97 static inline void
98 route4_set_fastmap(struct route4_head *head, u32 id, int iif,
99                    struct route4_filter *f)
100 {
101         int h = route4_fastmap_hash(id, iif);
102         head->fastmap[h].id = id;
103         head->fastmap[h].iif = iif;
104         head->fastmap[h].filter = f;
105 }
106
107 static __inline__ int route4_hash_to(u32 id)
108 {
109         return id&0xFF;
110 }
111
112 static __inline__ int route4_hash_from(u32 id)
113 {
114         return (id>>16)&0xF;
115 }
116
117 static __inline__ int route4_hash_iif(int iif)
118 {
119         return 16 + ((iif>>16)&0xF);
120 }
121
122 static __inline__ int route4_hash_wild(void)
123 {
124         return 32;
125 }
126
127 #define ROUTE4_APPLY_RESULT()                                   \
128 {                                                               \
129         *res = f->res;                                          \
130         if (tcf_exts_is_available(&f->exts)) {                  \
131                 int r = tcf_exts_exec(skb, &f->exts, res);      \
132                 if (r < 0) {                                    \
133                         dont_cache = 1;                         \
134                         continue;                               \
135                 }                                               \
136                 return r;                                       \
137         } else if (!dont_cache)                                 \
138                 route4_set_fastmap(head, id, iif, f);           \
139         return 0;                                               \
140 }
141
142 static int route4_classify(struct sk_buff *skb, struct tcf_proto *tp,
143                            struct tcf_result *res)
144 {
145         struct route4_head *head = (struct route4_head*)tp->root;
146         struct dst_entry *dst;
147         struct route4_bucket *b;
148         struct route4_filter *f;
149         u32 id, h;
150         int iif, dont_cache = 0;
151
152         if ((dst = skb->dst) == NULL)
153                 goto failure;
154
155         id = dst->tclassid;
156         if (head == NULL)
157                 goto old_method;
158
159         iif = ((struct rtable*)dst)->fl.iif;
160
161         h = route4_fastmap_hash(id, iif);
162         if (id == head->fastmap[h].id &&
163             iif == head->fastmap[h].iif &&
164             (f = head->fastmap[h].filter) != NULL) {
165                 if (f == ROUTE4_FAILURE)
166                         goto failure;
167
168                 *res = f->res;
169                 return 0;
170         }
171
172         h = route4_hash_to(id);
173
174 restart:
175         if ((b = head->table[h]) != NULL) {
176                 for (f = b->ht[route4_hash_from(id)]; f; f = f->next)
177                         if (f->id == id)
178                                 ROUTE4_APPLY_RESULT();
179
180                 for (f = b->ht[route4_hash_iif(iif)]; f; f = f->next)
181                         if (f->iif == iif)
182                                 ROUTE4_APPLY_RESULT();
183
184                 for (f = b->ht[route4_hash_wild()]; f; f = f->next)
185                         ROUTE4_APPLY_RESULT();
186
187         }
188         if (h < 256) {
189                 h = 256;
190                 id &= ~0xFFFF;
191                 goto restart;
192         }
193
194         if (!dont_cache)
195                 route4_set_fastmap(head, id, iif, ROUTE4_FAILURE);
196 failure:
197         return -1;
198
199 old_method:
200         if (id && (TC_H_MAJ(id) == 0 ||
201                    !(TC_H_MAJ(id^tp->q->handle)))) {
202                 res->classid = id;
203                 res->class = 0;
204                 return 0;
205         }
206         return -1;
207 }
208
209 static inline u32 to_hash(u32 id)
210 {
211         u32 h = id&0xFF;
212         if (id&0x8000)
213                 h += 256;
214         return h;
215 }
216
217 static inline u32 from_hash(u32 id)
218 {
219         id &= 0xFFFF;
220         if (id == 0xFFFF)
221                 return 32;
222         if (!(id & 0x8000)) {
223                 if (id > 255)
224                         return 256;
225                 return id&0xF;
226         }
227         return 16 + (id&0xF);
228 }
229
230 static unsigned long route4_get(struct tcf_proto *tp, u32 handle)
231 {
232         struct route4_head *head = (struct route4_head*)tp->root;
233         struct route4_bucket *b;
234         struct route4_filter *f;
235         unsigned h1, h2;
236
237         if (!head)
238                 return 0;
239
240         h1 = to_hash(handle);
241         if (h1 > 256)
242                 return 0;
243
244         h2 = from_hash(handle>>16);
245         if (h2 > 32)
246                 return 0;
247
248         if ((b = head->table[h1]) != NULL) {
249                 for (f = b->ht[h2]; f; f = f->next)
250                         if (f->handle == handle)
251                                 return (unsigned long)f;
252         }
253         return 0;
254 }
255
256 static void route4_put(struct tcf_proto *tp, unsigned long f)
257 {
258 }
259
260 static int route4_init(struct tcf_proto *tp)
261 {
262         return 0;
263 }
264
265 static inline void
266 route4_delete_filter(struct tcf_proto *tp, struct route4_filter *f)
267 {
268         tcf_unbind_filter(tp, &f->res);
269         tcf_exts_destroy(tp, &f->exts);
270         kfree(f);
271 }
272
273 static void route4_destroy(struct tcf_proto *tp)
274 {
275         struct route4_head *head = xchg(&tp->root, NULL);
276         int h1, h2;
277
278         if (head == NULL)
279                 return;
280
281         for (h1=0; h1<=256; h1++) {
282                 struct route4_bucket *b;
283
284                 if ((b = head->table[h1]) != NULL) {
285                         for (h2=0; h2<=32; h2++) {
286                                 struct route4_filter *f;
287
288                                 while ((f = b->ht[h2]) != NULL) {
289                                         b->ht[h2] = f->next;
290                                         route4_delete_filter(tp, f);
291                                 }
292                         }
293                         kfree(b);
294                 }
295         }
296         kfree(head);
297 }
298
299 static int route4_delete(struct tcf_proto *tp, unsigned long arg)
300 {
301         struct route4_head *head = (struct route4_head*)tp->root;
302         struct route4_filter **fp, *f = (struct route4_filter*)arg;
303         unsigned h = 0;
304         struct route4_bucket *b;
305         int i;
306
307         if (!head || !f)
308                 return -EINVAL;
309
310         h = f->handle;
311         b = f->bkt;
312
313         for (fp = &b->ht[from_hash(h>>16)]; *fp; fp = &(*fp)->next) {
314                 if (*fp == f) {
315                         tcf_tree_lock(tp);
316                         *fp = f->next;
317                         tcf_tree_unlock(tp);
318
319                         route4_reset_fastmap(tp->q->dev, head, f->id);
320                         route4_delete_filter(tp, f);
321
322                         /* Strip tree */
323
324                         for (i=0; i<=32; i++)
325                                 if (b->ht[i])
326                                         return 0;
327
328                         /* OK, session has no flows */
329                         tcf_tree_lock(tp);
330                         head->table[to_hash(h)] = NULL;
331                         tcf_tree_unlock(tp);
332
333                         kfree(b);
334                         return 0;
335                 }
336         }
337         return 0;
338 }
339
340 static int route4_set_parms(struct tcf_proto *tp, unsigned long base,
341         struct route4_filter *f, u32 handle, struct route4_head *head,
342         struct rtattr **tb, struct rtattr *est, int new)
343 {
344         int err;
345         u32 id = 0, to = 0, nhandle = 0x8000;
346         struct route4_filter *fp;
347         unsigned int h1;
348         struct route4_bucket *b;
349         struct tcf_exts e;
350
351         err = tcf_exts_validate(tp, tb, est, &e, &route_ext_map);
352         if (err < 0)
353                 return err;
354
355         err = -EINVAL;
356         if (tb[TCA_ROUTE4_CLASSID-1])
357                 if (RTA_PAYLOAD(tb[TCA_ROUTE4_CLASSID-1]) < sizeof(u32))
358                         goto errout;
359
360         if (tb[TCA_ROUTE4_TO-1]) {
361                 if (new && handle & 0x8000)
362                         goto errout;
363                 if (RTA_PAYLOAD(tb[TCA_ROUTE4_TO-1]) < sizeof(u32))
364                         goto errout;
365                 to = *(u32*)RTA_DATA(tb[TCA_ROUTE4_TO-1]);
366                 if (to > 0xFF)
367                         goto errout;
368                 nhandle = to;
369         }
370
371         if (tb[TCA_ROUTE4_FROM-1]) {
372                 if (tb[TCA_ROUTE4_IIF-1])
373                         goto errout;
374                 if (RTA_PAYLOAD(tb[TCA_ROUTE4_FROM-1]) < sizeof(u32))
375                         goto errout;
376                 id = *(u32*)RTA_DATA(tb[TCA_ROUTE4_FROM-1]);
377                 if (id > 0xFF)
378                         goto errout;
379                 nhandle |= id << 16;
380         } else if (tb[TCA_ROUTE4_IIF-1]) {
381                 if (RTA_PAYLOAD(tb[TCA_ROUTE4_IIF-1]) < sizeof(u32))
382                         goto errout;
383                 id = *(u32*)RTA_DATA(tb[TCA_ROUTE4_IIF-1]);
384                 if (id > 0x7FFF)
385                         goto errout;
386                 nhandle |= (id | 0x8000) << 16;
387         } else
388                 nhandle |= 0xFFFF << 16;
389
390         if (handle && new) {
391                 nhandle |= handle & 0x7F00;
392                 if (nhandle != handle)
393                         goto errout;
394         }
395
396         h1 = to_hash(nhandle);
397         if ((b = head->table[h1]) == NULL) {
398                 err = -ENOBUFS;
399                 b = kzalloc(sizeof(struct route4_bucket), GFP_KERNEL);
400                 if (b == NULL)
401                         goto errout;
402
403                 tcf_tree_lock(tp);
404                 head->table[h1] = b;
405                 tcf_tree_unlock(tp);
406         } else {
407                 unsigned int h2 = from_hash(nhandle >> 16);
408                 err = -EEXIST;
409                 for (fp = b->ht[h2]; fp; fp = fp->next)
410                         if (fp->handle == f->handle)
411                                 goto errout;
412         }
413
414         tcf_tree_lock(tp);
415         if (tb[TCA_ROUTE4_TO-1])
416                 f->id = to;
417
418         if (tb[TCA_ROUTE4_FROM-1])
419                 f->id = to | id<<16;
420         else if (tb[TCA_ROUTE4_IIF-1])
421                 f->iif = id;
422
423         f->handle = nhandle;
424         f->bkt = b;
425         tcf_tree_unlock(tp);
426
427         if (tb[TCA_ROUTE4_CLASSID-1]) {
428                 f->res.classid = *(u32*)RTA_DATA(tb[TCA_ROUTE4_CLASSID-1]);
429                 tcf_bind_filter(tp, &f->res, base);
430         }
431
432         tcf_exts_change(tp, &f->exts, &e);
433
434         return 0;
435 errout:
436         tcf_exts_destroy(tp, &e);
437         return err;
438 }
439
440 static int route4_change(struct tcf_proto *tp, unsigned long base,
441                        u32 handle,
442                        struct rtattr **tca,
443                        unsigned long *arg)
444 {
445         struct route4_head *head = tp->root;
446         struct route4_filter *f, *f1, **fp;
447         struct route4_bucket *b;
448         struct rtattr *opt = tca[TCA_OPTIONS-1];
449         struct rtattr *tb[TCA_ROUTE4_MAX];
450         unsigned int h, th;
451         u32 old_handle = 0;
452         int err;
453
454         if (opt == NULL)
455                 return handle ? -EINVAL : 0;
456
457         if (rtattr_parse_nested(tb, TCA_ROUTE4_MAX, opt) < 0)
458                 return -EINVAL;
459
460         if ((f = (struct route4_filter*)*arg) != NULL) {
461                 if (f->handle != handle && handle)
462                         return -EINVAL;
463
464                 if (f->bkt)
465                         old_handle = f->handle;
466
467                 err = route4_set_parms(tp, base, f, handle, head, tb,
468                         tca[TCA_RATE-1], 0);
469                 if (err < 0)
470                         return err;
471
472                 goto reinsert;
473         }
474
475         err = -ENOBUFS;
476         if (head == NULL) {
477                 head = kzalloc(sizeof(struct route4_head), GFP_KERNEL);
478                 if (head == NULL)
479                         goto errout;
480
481                 tcf_tree_lock(tp);
482                 tp->root = head;
483                 tcf_tree_unlock(tp);
484         }
485
486         f = kzalloc(sizeof(struct route4_filter), GFP_KERNEL);
487         if (f == NULL)
488                 goto errout;
489
490         err = route4_set_parms(tp, base, f, handle, head, tb,
491                 tca[TCA_RATE-1], 1);
492         if (err < 0)
493                 goto errout;
494
495 reinsert:
496         h = from_hash(f->handle >> 16);
497         for (fp = &f->bkt->ht[h]; (f1=*fp) != NULL; fp = &f1->next)
498                 if (f->handle < f1->handle)
499                         break;
500
501         f->next = f1;
502         tcf_tree_lock(tp);
503         *fp = f;
504
505         if (old_handle && f->handle != old_handle) {
506                 th = to_hash(old_handle);
507                 h = from_hash(old_handle >> 16);
508                 if ((b = head->table[th]) != NULL) {
509                         for (fp = &b->ht[h]; *fp; fp = &(*fp)->next) {
510                                 if (*fp == f) {
511                                         *fp = f->next;
512                                         break;
513                                 }
514                         }
515                 }
516         }
517         tcf_tree_unlock(tp);
518
519         route4_reset_fastmap(tp->q->dev, head, f->id);
520         *arg = (unsigned long)f;
521         return 0;
522
523 errout:
524         kfree(f);
525         return err;
526 }
527
528 static void route4_walk(struct tcf_proto *tp, struct tcf_walker *arg)
529 {
530         struct route4_head *head = tp->root;
531         unsigned h, h1;
532
533         if (head == NULL)
534                 arg->stop = 1;
535
536         if (arg->stop)
537                 return;
538
539         for (h = 0; h <= 256; h++) {
540                 struct route4_bucket *b = head->table[h];
541
542                 if (b) {
543                         for (h1 = 0; h1 <= 32; h1++) {
544                                 struct route4_filter *f;
545
546                                 for (f = b->ht[h1]; f; f = f->next) {
547                                         if (arg->count < arg->skip) {
548                                                 arg->count++;
549                                                 continue;
550                                         }
551                                         if (arg->fn(tp, (unsigned long)f, arg) < 0) {
552                                                 arg->stop = 1;
553                                                 return;
554                                         }
555                                         arg->count++;
556                                 }
557                         }
558                 }
559         }
560 }
561
562 static int route4_dump(struct tcf_proto *tp, unsigned long fh,
563                        struct sk_buff *skb, struct tcmsg *t)
564 {
565         struct route4_filter *f = (struct route4_filter*)fh;
566         unsigned char *b = skb_tail_pointer(skb);
567         struct rtattr *rta;
568         u32 id;
569
570         if (f == NULL)
571                 return skb->len;
572
573         t->tcm_handle = f->handle;
574
575         rta = (struct rtattr*)b;
576         RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
577
578         if (!(f->handle&0x8000)) {
579                 id = f->id&0xFF;
580                 RTA_PUT(skb, TCA_ROUTE4_TO, sizeof(id), &id);
581         }
582         if (f->handle&0x80000000) {
583                 if ((f->handle>>16) != 0xFFFF)
584                         RTA_PUT(skb, TCA_ROUTE4_IIF, sizeof(f->iif), &f->iif);
585         } else {
586                 id = f->id>>16;
587                 RTA_PUT(skb, TCA_ROUTE4_FROM, sizeof(id), &id);
588         }
589         if (f->res.classid)
590                 RTA_PUT(skb, TCA_ROUTE4_CLASSID, 4, &f->res.classid);
591
592         if (tcf_exts_dump(skb, &f->exts, &route_ext_map) < 0)
593                 goto rtattr_failure;
594
595         rta->rta_len = skb_tail_pointer(skb) - b;
596
597         if (tcf_exts_dump_stats(skb, &f->exts, &route_ext_map) < 0)
598                 goto rtattr_failure;
599
600         return skb->len;
601
602 rtattr_failure:
603         nlmsg_trim(skb, b);
604         return -1;
605 }
606
607 static struct tcf_proto_ops cls_route4_ops = {
608         .next           =       NULL,
609         .kind           =       "route",
610         .classify       =       route4_classify,
611         .init           =       route4_init,
612         .destroy        =       route4_destroy,
613         .get            =       route4_get,
614         .put            =       route4_put,
615         .change         =       route4_change,
616         .delete         =       route4_delete,
617         .walk           =       route4_walk,
618         .dump           =       route4_dump,
619         .owner          =       THIS_MODULE,
620 };
621
622 static int __init init_route4(void)
623 {
624         return register_tcf_proto_ops(&cls_route4_ops);
625 }
626
627 static void __exit exit_route4(void)
628 {
629         unregister_tcf_proto_ops(&cls_route4_ops);
630 }
631
632 module_init(init_route4)
633 module_exit(exit_route4)
634 MODULE_LICENSE("GPL");