2 * net/sched/act_api.c Packet action API.
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.
9 * Author: Jamal Hadi Salim
14 #include <asm/uaccess.h>
15 #include <asm/system.h>
16 #include <linux/bitops.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/string.h>
22 #include <linux/socket.h>
23 #include <linux/sockios.h>
25 #include <linux/errno.h>
26 #include <linux/interrupt.h>
27 #include <linux/netdevice.h>
28 #include <linux/skbuff.h>
29 #include <linux/rtnetlink.h>
30 #include <linux/init.h>
31 #include <linux/kmod.h>
33 #include <net/sch_generic.h>
34 #include <net/act_api.h>
37 #define DPRINTK(format, args...) printk(KERN_DEBUG format, ##args)
39 #define DPRINTK(format, args...)
42 #define D2PRINTK(format, args...) printk(KERN_DEBUG format, ##args)
44 #define D2PRINTK(format, args...)
47 static struct tc_action_ops
*act_base
= NULL
;
48 static DEFINE_RWLOCK(act_mod_lock
);
50 int tcf_register_action(struct tc_action_ops
*act
)
52 struct tc_action_ops
*a
, **ap
;
54 write_lock(&act_mod_lock
);
55 for (ap
= &act_base
; (a
= *ap
) != NULL
; ap
= &a
->next
) {
56 if (act
->type
== a
->type
|| (strcmp(act
->kind
, a
->kind
) == 0)) {
57 write_unlock(&act_mod_lock
);
63 write_unlock(&act_mod_lock
);
67 int tcf_unregister_action(struct tc_action_ops
*act
)
69 struct tc_action_ops
*a
, **ap
;
72 write_lock(&act_mod_lock
);
73 for (ap
= &act_base
; (a
= *ap
) != NULL
; ap
= &a
->next
)
81 write_unlock(&act_mod_lock
);
86 static struct tc_action_ops
*tc_lookup_action_n(char *kind
)
88 struct tc_action_ops
*a
= NULL
;
91 read_lock(&act_mod_lock
);
92 for (a
= act_base
; a
; a
= a
->next
) {
93 if (strcmp(kind
, a
->kind
) == 0) {
94 if (!try_module_get(a
->owner
)) {
95 read_unlock(&act_mod_lock
);
101 read_unlock(&act_mod_lock
);
106 /* lookup by rtattr */
107 static struct tc_action_ops
*tc_lookup_action(struct rtattr
*kind
)
109 struct tc_action_ops
*a
= NULL
;
112 read_lock(&act_mod_lock
);
113 for (a
= act_base
; a
; a
= a
->next
) {
114 if (rtattr_strcmp(kind
, a
->kind
) == 0) {
115 if (!try_module_get(a
->owner
)) {
116 read_unlock(&act_mod_lock
);
122 read_unlock(&act_mod_lock
);
129 static struct tc_action_ops
*tc_lookup_action_id(u32 type
)
131 struct tc_action_ops
*a
= NULL
;
134 read_lock(&act_mod_lock
);
135 for (a
= act_base
; a
; a
= a
->next
) {
136 if (a
->type
== type
) {
137 if (!try_module_get(a
->owner
)) {
138 read_unlock(&act_mod_lock
);
144 read_unlock(&act_mod_lock
);
150 int tcf_action_exec(struct sk_buff
*skb
, struct tc_action
*act
,
151 struct tcf_result
*res
)
156 if (skb
->tc_verd
& TC_NCLS
) {
157 skb
->tc_verd
= CLR_TC_NCLS(skb
->tc_verd
);
158 D2PRINTK("(%p)tcf_action_exec: cleared TC_NCLS in %s out %s\n",
159 skb
, skb
->input_dev
? skb
->input_dev
->name
: "xxx",
164 while ((a
= act
) != NULL
) {
166 if (a
->ops
&& a
->ops
->act
) {
167 ret
= a
->ops
->act(skb
, a
, res
);
168 if (TC_MUNGED
& skb
->tc_verd
) {
169 /* copied already, allow trampling */
170 skb
->tc_verd
= SET_TC_OK2MUNGE(skb
->tc_verd
);
171 skb
->tc_verd
= CLR_TC_MUNGED(skb
->tc_verd
);
173 if (ret
== TC_ACT_REPEAT
)
174 goto repeat
; /* we need a ttl - JHS */
175 if (ret
!= TC_ACT_PIPE
)
184 void tcf_action_destroy(struct tc_action
*act
, int bind
)
188 for (a
= act
; a
; a
= act
) {
189 if (a
->ops
&& a
->ops
->cleanup
) {
190 DPRINTK("tcf_action_destroy destroying %p next %p\n",
192 if (a
->ops
->cleanup(a
, bind
) == ACT_P_DELETED
)
193 module_put(a
->ops
->owner
);
196 } else { /*FIXME: Remove later - catch insertion bugs*/
197 printk("tcf_action_destroy: BUG? destroying NULL ops\n");
205 tcf_action_dump_old(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
209 if (a
->ops
== NULL
|| a
->ops
->dump
== NULL
)
211 return a
->ops
->dump(skb
, a
, bind
, ref
);
215 tcf_action_dump_1(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
218 unsigned char *b
= skb
->tail
;
221 if (a
->ops
== NULL
|| a
->ops
->dump
== NULL
)
224 RTA_PUT(skb
, TCA_KIND
, IFNAMSIZ
, a
->ops
->kind
);
225 if (tcf_action_copy_stats(skb
, a
, 0))
227 r
= (struct rtattr
*) skb
->tail
;
228 RTA_PUT(skb
, TCA_OPTIONS
, 0, NULL
);
229 if ((err
= tcf_action_dump_old(skb
, a
, bind
, ref
)) > 0) {
230 r
->rta_len
= skb
->tail
- (u8
*)r
;
235 skb_trim(skb
, b
- skb
->data
);
240 tcf_action_dump(struct sk_buff
*skb
, struct tc_action
*act
, int bind
, int ref
)
244 unsigned char *b
= skb
->tail
;
247 while ((a
= act
) != NULL
) {
248 r
= (struct rtattr
*) skb
->tail
;
250 RTA_PUT(skb
, a
->order
, 0, NULL
);
251 err
= tcf_action_dump_1(skb
, a
, bind
, ref
);
254 r
->rta_len
= skb
->tail
- (u8
*)r
;
262 skb_trim(skb
, b
- skb
->data
);
266 struct tc_action
*tcf_action_init_1(struct rtattr
*rta
, struct rtattr
*est
,
267 char *name
, int ovr
, int bind
, int *err
)
270 struct tc_action_ops
*a_o
;
271 char act_name
[IFNAMSIZ
];
272 struct rtattr
*tb
[TCA_ACT_MAX
+1];
278 if (rtattr_parse_nested(tb
, TCA_ACT_MAX
, rta
) < 0)
280 kind
= tb
[TCA_ACT_KIND
-1];
283 if (rtattr_strlcpy(act_name
, kind
, IFNAMSIZ
) >= IFNAMSIZ
)
286 if (strlcpy(act_name
, name
, IFNAMSIZ
) >= IFNAMSIZ
)
290 a_o
= tc_lookup_action_n(act_name
);
294 request_module("act_%s", act_name
);
297 a_o
= tc_lookup_action_n(act_name
);
299 /* We dropped the RTNL semaphore in order to
300 * perform the module load. So, even if we
301 * succeeded in loading the module we have to
302 * tell the caller to replay the request. We
303 * indicate this using -EAGAIN.
315 a
= kmalloc(sizeof(*a
), GFP_KERNEL
);
318 memset(a
, 0, sizeof(*a
));
320 /* backward compatibility for policer */
322 *err
= a_o
->init(tb
[TCA_ACT_OPTIONS
-1], est
, a
, ovr
, bind
);
324 *err
= a_o
->init(rta
, est
, a
, ovr
, bind
);
328 /* module count goes up only when brand new policy is created
329 if it exists and is only bound to in a_o->init() then
330 ACT_P_CREATED is not returned (a zero is).
332 if (*err
!= ACT_P_CREATED
)
333 module_put(a_o
->owner
);
335 DPRINTK("tcf_action_init_1: successfull %s\n", act_name
);
343 module_put(a_o
->owner
);
348 struct tc_action
*tcf_action_init(struct rtattr
*rta
, struct rtattr
*est
,
349 char *name
, int ovr
, int bind
, int *err
)
351 struct rtattr
*tb
[TCA_ACT_MAX_PRIO
+1];
352 struct tc_action
*head
= NULL
, *act
, *act_prev
= NULL
;
355 if (rtattr_parse_nested(tb
, TCA_ACT_MAX_PRIO
, rta
) < 0) {
360 for (i
=0; i
< TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
361 act
= tcf_action_init_1(tb
[i
], est
, name
, ovr
, bind
, err
);
369 act_prev
->next
= act
;
376 tcf_action_destroy(head
, bind
);
380 int tcf_action_copy_stats(struct sk_buff
*skb
, struct tc_action
*a
,
385 struct tcf_act_hdr
*h
= a
->priv
;
390 /* compat_mode being true specifies a call that is supposed
391 * to add additional backward compatiblity statistic TLVs.
394 if (a
->type
== TCA_OLD_COMPAT
)
395 err
= gnet_stats_start_copy_compat(skb
, 0,
396 TCA_STATS
, TCA_XSTATS
, h
->stats_lock
, &d
);
400 err
= gnet_stats_start_copy(skb
, TCA_ACT_STATS
,
406 if (a
->ops
!= NULL
&& a
->ops
->get_stats
!= NULL
)
407 if (a
->ops
->get_stats(skb
, a
) < 0)
410 if (gnet_stats_copy_basic(&d
, &h
->bstats
) < 0 ||
411 #ifdef CONFIG_NET_ESTIMATOR
412 gnet_stats_copy_rate_est(&d
, &h
->rate_est
) < 0 ||
414 gnet_stats_copy_queue(&d
, &h
->qstats
) < 0)
417 if (gnet_stats_finish_copy(&d
) < 0)
427 tca_get_fill(struct sk_buff
*skb
, struct tc_action
*a
, u32 pid
, u32 seq
,
428 u16 flags
, int event
, int bind
, int ref
)
431 struct nlmsghdr
*nlh
;
432 unsigned char *b
= skb
->tail
;
435 nlh
= NLMSG_NEW(skb
, pid
, seq
, event
, sizeof(*t
), flags
);
438 t
->tca_family
= AF_UNSPEC
;
442 x
= (struct rtattr
*) skb
->tail
;
443 RTA_PUT(skb
, TCA_ACT_TAB
, 0, NULL
);
445 if (tcf_action_dump(skb
, a
, bind
, ref
) < 0)
448 x
->rta_len
= skb
->tail
- (u8
*)x
;
450 nlh
->nlmsg_len
= skb
->tail
- b
;
455 skb_trim(skb
, b
- skb
->data
);
460 act_get_notify(u32 pid
, struct nlmsghdr
*n
, struct tc_action
*a
, int event
)
465 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
468 if (tca_get_fill(skb
, a
, pid
, n
->nlmsg_seq
, 0, event
, 0, 0) <= 0) {
472 err
= netlink_unicast(rtnl
, skb
, pid
, MSG_DONTWAIT
);
478 static struct tc_action
*
479 tcf_action_get_1(struct rtattr
*rta
, struct nlmsghdr
*n
, u32 pid
, int *err
)
481 struct rtattr
*tb
[TCA_ACT_MAX
+1];
486 if (rtattr_parse_nested(tb
, TCA_ACT_MAX
, rta
) < 0)
489 if (tb
[TCA_ACT_INDEX
- 1] == NULL
||
490 RTA_PAYLOAD(tb
[TCA_ACT_INDEX
- 1]) < sizeof(index
))
492 index
= *(int *)RTA_DATA(tb
[TCA_ACT_INDEX
- 1]);
495 a
= kmalloc(sizeof(struct tc_action
), GFP_KERNEL
);
498 memset(a
, 0, sizeof(struct tc_action
));
501 a
->ops
= tc_lookup_action(tb
[TCA_ACT_KIND
- 1]);
504 if (a
->ops
->lookup
== NULL
)
507 if (a
->ops
->lookup(a
, index
) == 0)
510 module_put(a
->ops
->owner
);
514 module_put(a
->ops
->owner
);
520 static void cleanup_a(struct tc_action
*act
)
524 for (a
= act
; a
; a
= act
) {
530 static struct tc_action
*create_a(int i
)
532 struct tc_action
*act
;
534 act
= kmalloc(sizeof(*act
), GFP_KERNEL
);
536 printk("create_a: failed to alloc!\n");
539 memset(act
, 0, sizeof(*act
));
544 static int tca_action_flush(struct rtattr
*rta
, struct nlmsghdr
*n
, u32 pid
)
548 struct nlmsghdr
*nlh
;
550 struct netlink_callback dcb
;
552 struct rtattr
*tb
[TCA_ACT_MAX
+1];
554 struct tc_action
*a
= create_a(0);
558 printk("tca_action_flush: couldnt create tc_action\n");
562 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
564 printk("tca_action_flush: failed skb alloc\n");
569 b
= (unsigned char *)skb
->tail
;
571 if (rtattr_parse_nested(tb
, TCA_ACT_MAX
, rta
) < 0)
574 kind
= tb
[TCA_ACT_KIND
-1];
575 a
->ops
= tc_lookup_action(kind
);
579 nlh
= NLMSG_PUT(skb
, pid
, n
->nlmsg_seq
, RTM_DELACTION
, sizeof(*t
));
581 t
->tca_family
= AF_UNSPEC
;
585 x
= (struct rtattr
*) skb
->tail
;
586 RTA_PUT(skb
, TCA_ACT_TAB
, 0, NULL
);
588 err
= a
->ops
->walk(skb
, &dcb
, RTM_DELACTION
, a
);
592 x
->rta_len
= skb
->tail
- (u8
*) x
;
594 nlh
->nlmsg_len
= skb
->tail
- b
;
595 nlh
->nlmsg_flags
|= NLM_F_ROOT
;
596 module_put(a
->ops
->owner
);
598 err
= rtnetlink_send(skb
, pid
, RTNLGRP_TC
, n
->nlmsg_flags
&NLM_F_ECHO
);
606 module_put(a
->ops
->owner
);
614 tca_action_gd(struct rtattr
*rta
, struct nlmsghdr
*n
, u32 pid
, int event
)
617 struct rtattr
*tb
[TCA_ACT_MAX_PRIO
+1];
618 struct tc_action
*head
= NULL
, *act
, *act_prev
= NULL
;
620 if (rtattr_parse_nested(tb
, TCA_ACT_MAX_PRIO
, rta
) < 0)
623 if (event
== RTM_DELACTION
&& n
->nlmsg_flags
&NLM_F_ROOT
) {
624 if (tb
[0] != NULL
&& tb
[1] == NULL
)
625 return tca_action_flush(tb
[0], n
, pid
);
628 for (i
=0; i
< TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
629 act
= tcf_action_get_1(tb
[i
], n
, pid
, &ret
);
637 act_prev
->next
= act
;
641 if (event
== RTM_GETACTION
)
642 ret
= act_get_notify(pid
, n
, head
, event
);
646 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
652 if (tca_get_fill(skb
, head
, pid
, n
->nlmsg_seq
, 0, event
,
659 /* now do the delete */
660 tcf_action_destroy(head
, 0);
661 ret
= rtnetlink_send(skb
, pid
, RTNLGRP_TC
,
662 n
->nlmsg_flags
&NLM_F_ECHO
);
672 static int tcf_add_notify(struct tc_action
*a
, u32 pid
, u32 seq
, int event
,
676 struct nlmsghdr
*nlh
;
682 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
686 b
= (unsigned char *)skb
->tail
;
688 nlh
= NLMSG_NEW(skb
, pid
, seq
, event
, sizeof(*t
), flags
);
690 t
->tca_family
= AF_UNSPEC
;
694 x
= (struct rtattr
*) skb
->tail
;
695 RTA_PUT(skb
, TCA_ACT_TAB
, 0, NULL
);
697 if (tcf_action_dump(skb
, a
, 0, 0) < 0)
700 x
->rta_len
= skb
->tail
- (u8
*)x
;
702 nlh
->nlmsg_len
= skb
->tail
- b
;
703 NETLINK_CB(skb
).dst_group
= RTNLGRP_TC
;
705 err
= rtnetlink_send(skb
, pid
, RTNLGRP_TC
, flags
&NLM_F_ECHO
);
718 tcf_action_add(struct rtattr
*rta
, struct nlmsghdr
*n
, u32 pid
, int ovr
)
721 struct tc_action
*act
;
723 u32 seq
= n
->nlmsg_seq
;
725 act
= tcf_action_init(rta
, NULL
, NULL
, ovr
, 0, &ret
);
729 /* dump then free all the actions after update; inserted policy
732 ret
= tcf_add_notify(act
, pid
, seq
, RTM_NEWACTION
, n
->nlmsg_flags
);
733 for (a
= act
; a
; a
= act
) {
741 static int tc_ctl_action(struct sk_buff
*skb
, struct nlmsghdr
*n
, void *arg
)
743 struct rtattr
**tca
= arg
;
744 u32 pid
= skb
? NETLINK_CB(skb
).pid
: 0;
745 int ret
= 0, ovr
= 0;
747 if (tca
[TCA_ACT_TAB
-1] == NULL
) {
748 printk("tc_ctl_action: received NO action attribs\n");
752 /* n->nlmsg_flags&NLM_F_CREATE
754 switch (n
->nlmsg_type
) {
756 /* we are going to assume all other flags
757 * imply create only if it doesnt exist
758 * Note that CREATE | EXCL implies that
759 * but since we want avoid ambiguity (eg when flags
760 * is zero) then just set this
762 if (n
->nlmsg_flags
&NLM_F_REPLACE
)
765 ret
= tcf_action_add(tca
[TCA_ACT_TAB
-1], n
, pid
, ovr
);
770 ret
= tca_action_gd(tca
[TCA_ACT_TAB
-1], n
, pid
, RTM_DELACTION
);
773 ret
= tca_action_gd(tca
[TCA_ACT_TAB
-1], n
, pid
, RTM_GETACTION
);
782 static struct rtattr
*
783 find_dump_kind(struct nlmsghdr
*n
)
785 struct rtattr
*tb1
, *tb2
[TCA_ACT_MAX
+1];
786 struct rtattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
787 struct rtattr
*rta
[TCAA_MAX
+ 1];
789 int min_len
= NLMSG_LENGTH(sizeof(struct tcamsg
));
790 int attrlen
= n
->nlmsg_len
- NLMSG_ALIGN(min_len
);
791 struct rtattr
*attr
= (void *) n
+ NLMSG_ALIGN(min_len
);
793 if (rtattr_parse(rta
, TCAA_MAX
, attr
, attrlen
) < 0)
795 tb1
= rta
[TCA_ACT_TAB
- 1];
799 if (rtattr_parse(tb
, TCA_ACT_MAX_PRIO
, RTA_DATA(tb1
),
800 NLMSG_ALIGN(RTA_PAYLOAD(tb1
))) < 0)
805 if (rtattr_parse(tb2
, TCA_ACT_MAX
, RTA_DATA(tb
[0]),
806 RTA_PAYLOAD(tb
[0])) < 0)
808 kind
= tb2
[TCA_ACT_KIND
-1];
814 tc_dump_action(struct sk_buff
*skb
, struct netlink_callback
*cb
)
816 struct nlmsghdr
*nlh
;
817 unsigned char *b
= skb
->tail
;
819 struct tc_action_ops
*a_o
;
822 struct tcamsg
*t
= (struct tcamsg
*) NLMSG_DATA(cb
->nlh
);
823 struct rtattr
*kind
= find_dump_kind(cb
->nlh
);
826 printk("tc_dump_action: action bad kind\n");
830 a_o
= tc_lookup_action(kind
);
835 memset(&a
, 0, sizeof(struct tc_action
));
838 if (a_o
->walk
== NULL
) {
839 printk("tc_dump_action: %s !capable of dumping table\n", a_o
->kind
);
843 nlh
= NLMSG_PUT(skb
, NETLINK_CB(cb
->skb
).pid
, cb
->nlh
->nlmsg_seq
,
844 cb
->nlh
->nlmsg_type
, sizeof(*t
));
846 t
->tca_family
= AF_UNSPEC
;
850 x
= (struct rtattr
*) skb
->tail
;
851 RTA_PUT(skb
, TCA_ACT_TAB
, 0, NULL
);
853 ret
= a_o
->walk(skb
, cb
, RTM_GETACTION
, &a
);
858 x
->rta_len
= skb
->tail
- (u8
*) x
;
861 skb_trim(skb
, (u8
*)x
- skb
->data
);
863 nlh
->nlmsg_len
= skb
->tail
- b
;
864 if (NETLINK_CB(cb
->skb
).pid
&& ret
)
865 nlh
->nlmsg_flags
|= NLM_F_MULTI
;
866 module_put(a_o
->owner
);
871 module_put(a_o
->owner
);
872 skb_trim(skb
, b
- skb
->data
);
876 static int __init
tc_action_init(void)
878 struct rtnetlink_link
*link_p
= rtnetlink_links
[PF_UNSPEC
];
881 link_p
[RTM_NEWACTION
-RTM_BASE
].doit
= tc_ctl_action
;
882 link_p
[RTM_DELACTION
-RTM_BASE
].doit
= tc_ctl_action
;
883 link_p
[RTM_GETACTION
-RTM_BASE
].doit
= tc_ctl_action
;
884 link_p
[RTM_GETACTION
-RTM_BASE
].dumpit
= tc_dump_action
;
890 subsys_initcall(tc_action_init
);
892 EXPORT_SYMBOL(tcf_register_action
);
893 EXPORT_SYMBOL(tcf_unregister_action
);
894 EXPORT_SYMBOL(tcf_action_exec
);
895 EXPORT_SYMBOL(tcf_action_dump_1
);
This page took 0.04861 seconds and 5 git commands to generate.