]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/sched/act_api.c
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 <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/slab.h>
19 #include <linux/skbuff.h>
20 #include <linux/init.h>
21 #include <linux/kmod.h>
22 #include <linux/err.h>
23 #include <net/net_namespace.h>
25 #include <net/sch_generic.h>
26 #include <net/act_api.h>
27 #include <net/netlink.h>
29 void tcf_hash_destroy(struct tcf_common
*p
, struct tcf_hashinfo
*hinfo
)
31 unsigned int h
= tcf_hash(p
->tcfc_index
, hinfo
->hmask
);
32 struct tcf_common
**p1p
;
34 for (p1p
= &hinfo
->htab
[h
]; *p1p
; p1p
= &(*p1p
)->tcfc_next
) {
36 write_lock_bh(hinfo
->lock
);
38 write_unlock_bh(hinfo
->lock
);
39 gen_kill_estimator(&p
->tcfc_bstats
,
47 EXPORT_SYMBOL(tcf_hash_destroy
);
49 int tcf_hash_release(struct tcf_common
*p
, int bind
,
50 struct tcf_hashinfo
*hinfo
)
59 if (p
->tcfc_bindcnt
<= 0 && p
->tcfc_refcnt
<= 0) {
60 tcf_hash_destroy(p
, hinfo
);
66 EXPORT_SYMBOL(tcf_hash_release
);
68 static int tcf_dump_walker(struct sk_buff
*skb
, struct netlink_callback
*cb
,
69 struct tc_action
*a
, struct tcf_hashinfo
*hinfo
)
72 int err
= 0, index
= -1,i
= 0, s_i
= 0, n_i
= 0;
75 read_lock_bh(hinfo
->lock
);
79 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
80 p
= hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
82 for (; p
; p
= p
->tcfc_next
) {
89 nest
= nla_nest_start(skb
, a
->order
);
92 err
= tcf_action_dump_1(skb
, a
, 0, 0);
95 nlmsg_trim(skb
, nest
);
98 nla_nest_end(skb
, nest
);
100 if (n_i
>= TCA_ACT_MAX_PRIO
)
105 read_unlock_bh(hinfo
->lock
);
111 nla_nest_cancel(skb
, nest
);
115 static int tcf_del_walker(struct sk_buff
*skb
, struct tc_action
*a
,
116 struct tcf_hashinfo
*hinfo
)
118 struct tcf_common
*p
, *s_p
;
122 nest
= nla_nest_start(skb
, a
->order
);
124 goto nla_put_failure
;
125 NLA_PUT_STRING(skb
, TCA_KIND
, a
->ops
->kind
);
126 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
127 p
= hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
131 if (ACT_P_DELETED
== tcf_hash_release(p
, 0, hinfo
))
132 module_put(a
->ops
->owner
);
137 NLA_PUT_U32(skb
, TCA_FCNT
, n_i
);
138 nla_nest_end(skb
, nest
);
142 nla_nest_cancel(skb
, nest
);
146 int tcf_generic_walker(struct sk_buff
*skb
, struct netlink_callback
*cb
,
147 int type
, struct tc_action
*a
)
149 struct tcf_hashinfo
*hinfo
= a
->ops
->hinfo
;
151 if (type
== RTM_DELACTION
) {
152 return tcf_del_walker(skb
, a
, hinfo
);
153 } else if (type
== RTM_GETACTION
) {
154 return tcf_dump_walker(skb
, cb
, a
, hinfo
);
156 printk("tcf_generic_walker: unknown action %d\n", type
);
160 EXPORT_SYMBOL(tcf_generic_walker
);
162 struct tcf_common
*tcf_hash_lookup(u32 index
, struct tcf_hashinfo
*hinfo
)
164 struct tcf_common
*p
;
166 read_lock_bh(hinfo
->lock
);
167 for (p
= hinfo
->htab
[tcf_hash(index
, hinfo
->hmask
)]; p
;
169 if (p
->tcfc_index
== index
)
172 read_unlock_bh(hinfo
->lock
);
176 EXPORT_SYMBOL(tcf_hash_lookup
);
178 u32
tcf_hash_new_index(u32
*idx_gen
, struct tcf_hashinfo
*hinfo
)
185 } while (tcf_hash_lookup(val
, hinfo
));
187 return (*idx_gen
= val
);
189 EXPORT_SYMBOL(tcf_hash_new_index
);
191 int tcf_hash_search(struct tc_action
*a
, u32 index
)
193 struct tcf_hashinfo
*hinfo
= a
->ops
->hinfo
;
194 struct tcf_common
*p
= tcf_hash_lookup(index
, hinfo
);
202 EXPORT_SYMBOL(tcf_hash_search
);
204 struct tcf_common
*tcf_hash_check(u32 index
, struct tc_action
*a
, int bind
,
205 struct tcf_hashinfo
*hinfo
)
207 struct tcf_common
*p
= NULL
;
208 if (index
&& (p
= tcf_hash_lookup(index
, hinfo
)) != NULL
) {
216 EXPORT_SYMBOL(tcf_hash_check
);
218 struct tcf_common
*tcf_hash_create(u32 index
, struct nlattr
*est
,
219 struct tc_action
*a
, int size
, int bind
,
220 u32
*idx_gen
, struct tcf_hashinfo
*hinfo
)
222 struct tcf_common
*p
= kzalloc(size
, GFP_KERNEL
);
225 return ERR_PTR(-ENOMEM
);
230 spin_lock_init(&p
->tcfc_lock
);
231 p
->tcfc_index
= index
? index
: tcf_hash_new_index(idx_gen
, hinfo
);
232 p
->tcfc_tm
.install
= jiffies
;
233 p
->tcfc_tm
.lastuse
= jiffies
;
235 int err
= gen_new_estimator(&p
->tcfc_bstats
, &p
->tcfc_rate_est
,
243 a
->priv
= (void *) p
;
246 EXPORT_SYMBOL(tcf_hash_create
);
248 void tcf_hash_insert(struct tcf_common
*p
, struct tcf_hashinfo
*hinfo
)
250 unsigned int h
= tcf_hash(p
->tcfc_index
, hinfo
->hmask
);
252 write_lock_bh(hinfo
->lock
);
253 p
->tcfc_next
= hinfo
->htab
[h
];
255 write_unlock_bh(hinfo
->lock
);
257 EXPORT_SYMBOL(tcf_hash_insert
);
259 static struct tc_action_ops
*act_base
= NULL
;
260 static DEFINE_RWLOCK(act_mod_lock
);
262 int tcf_register_action(struct tc_action_ops
*act
)
264 struct tc_action_ops
*a
, **ap
;
266 write_lock(&act_mod_lock
);
267 for (ap
= &act_base
; (a
= *ap
) != NULL
; ap
= &a
->next
) {
268 if (act
->type
== a
->type
|| (strcmp(act
->kind
, a
->kind
) == 0)) {
269 write_unlock(&act_mod_lock
);
275 write_unlock(&act_mod_lock
);
278 EXPORT_SYMBOL(tcf_register_action
);
280 int tcf_unregister_action(struct tc_action_ops
*act
)
282 struct tc_action_ops
*a
, **ap
;
285 write_lock(&act_mod_lock
);
286 for (ap
= &act_base
; (a
= *ap
) != NULL
; ap
= &a
->next
)
294 write_unlock(&act_mod_lock
);
297 EXPORT_SYMBOL(tcf_unregister_action
);
300 static struct tc_action_ops
*tc_lookup_action_n(char *kind
)
302 struct tc_action_ops
*a
= NULL
;
305 read_lock(&act_mod_lock
);
306 for (a
= act_base
; a
; a
= a
->next
) {
307 if (strcmp(kind
, a
->kind
) == 0) {
308 if (!try_module_get(a
->owner
)) {
309 read_unlock(&act_mod_lock
);
315 read_unlock(&act_mod_lock
);
320 /* lookup by nlattr */
321 static struct tc_action_ops
*tc_lookup_action(struct nlattr
*kind
)
323 struct tc_action_ops
*a
= NULL
;
326 read_lock(&act_mod_lock
);
327 for (a
= act_base
; a
; a
= a
->next
) {
328 if (nla_strcmp(kind
, a
->kind
) == 0) {
329 if (!try_module_get(a
->owner
)) {
330 read_unlock(&act_mod_lock
);
336 read_unlock(&act_mod_lock
);
343 static struct tc_action_ops
*tc_lookup_action_id(u32 type
)
345 struct tc_action_ops
*a
= NULL
;
348 read_lock(&act_mod_lock
);
349 for (a
= act_base
; a
; a
= a
->next
) {
350 if (a
->type
== type
) {
351 if (!try_module_get(a
->owner
)) {
352 read_unlock(&act_mod_lock
);
358 read_unlock(&act_mod_lock
);
364 int tcf_action_exec(struct sk_buff
*skb
, struct tc_action
*act
,
365 struct tcf_result
*res
)
370 if (skb
->tc_verd
& TC_NCLS
) {
371 skb
->tc_verd
= CLR_TC_NCLS(skb
->tc_verd
);
375 while ((a
= act
) != NULL
) {
377 if (a
->ops
&& a
->ops
->act
) {
378 ret
= a
->ops
->act(skb
, a
, res
);
379 if (TC_MUNGED
& skb
->tc_verd
) {
380 /* copied already, allow trampling */
381 skb
->tc_verd
= SET_TC_OK2MUNGE(skb
->tc_verd
);
382 skb
->tc_verd
= CLR_TC_MUNGED(skb
->tc_verd
);
384 if (ret
== TC_ACT_REPEAT
)
385 goto repeat
; /* we need a ttl - JHS */
386 if (ret
!= TC_ACT_PIPE
)
394 EXPORT_SYMBOL(tcf_action_exec
);
396 void tcf_action_destroy(struct tc_action
*act
, int bind
)
400 for (a
= act
; a
; a
= act
) {
401 if (a
->ops
&& a
->ops
->cleanup
) {
402 if (a
->ops
->cleanup(a
, bind
) == ACT_P_DELETED
)
403 module_put(a
->ops
->owner
);
406 } else { /*FIXME: Remove later - catch insertion bugs*/
407 printk("tcf_action_destroy: BUG? destroying NULL ops\n");
415 tcf_action_dump_old(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
419 if (a
->ops
== NULL
|| a
->ops
->dump
== NULL
)
421 return a
->ops
->dump(skb
, a
, bind
, ref
);
425 tcf_action_dump_1(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
428 unsigned char *b
= skb_tail_pointer(skb
);
431 if (a
->ops
== NULL
|| a
->ops
->dump
== NULL
)
434 NLA_PUT_STRING(skb
, TCA_KIND
, a
->ops
->kind
);
435 if (tcf_action_copy_stats(skb
, a
, 0))
436 goto nla_put_failure
;
437 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
439 goto nla_put_failure
;
440 if ((err
= tcf_action_dump_old(skb
, a
, bind
, ref
)) > 0) {
441 nla_nest_end(skb
, nest
);
449 EXPORT_SYMBOL(tcf_action_dump_1
);
452 tcf_action_dump(struct sk_buff
*skb
, struct tc_action
*act
, int bind
, int ref
)
458 while ((a
= act
) != NULL
) {
460 nest
= nla_nest_start(skb
, a
->order
);
462 goto nla_put_failure
;
463 err
= tcf_action_dump_1(skb
, a
, bind
, ref
);
466 nla_nest_end(skb
, nest
);
474 nla_nest_cancel(skb
, nest
);
478 struct tc_action
*tcf_action_init_1(struct nlattr
*nla
, struct nlattr
*est
,
479 char *name
, int ovr
, int bind
)
482 struct tc_action_ops
*a_o
;
483 char act_name
[IFNAMSIZ
];
484 struct nlattr
*tb
[TCA_ACT_MAX
+1];
489 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
493 kind
= tb
[TCA_ACT_KIND
];
496 if (nla_strlcpy(act_name
, kind
, IFNAMSIZ
) >= IFNAMSIZ
)
500 if (strlcpy(act_name
, name
, IFNAMSIZ
) >= IFNAMSIZ
)
504 a_o
= tc_lookup_action_n(act_name
);
506 #ifdef CONFIG_MODULES
508 request_module("act_%s", act_name
);
511 a_o
= tc_lookup_action_n(act_name
);
513 /* We dropped the RTNL semaphore in order to
514 * perform the module load. So, even if we
515 * succeeded in loading the module we have to
516 * tell the caller to replay the request. We
517 * indicate this using -EAGAIN.
529 a
= kzalloc(sizeof(*a
), GFP_KERNEL
);
533 /* backward compatibility for policer */
535 err
= a_o
->init(tb
[TCA_ACT_OPTIONS
], est
, a
, ovr
, bind
);
537 err
= a_o
->init(nla
, est
, a
, ovr
, bind
);
541 /* module count goes up only when brand new policy is created
542 if it exists and is only bound to in a_o->init() then
543 ACT_P_CREATED is not returned (a zero is).
545 if (err
!= ACT_P_CREATED
)
546 module_put(a_o
->owner
);
554 module_put(a_o
->owner
);
559 struct tc_action
*tcf_action_init(struct nlattr
*nla
, struct nlattr
*est
,
560 char *name
, int ovr
, int bind
)
562 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+1];
563 struct tc_action
*head
= NULL
, *act
, *act_prev
= NULL
;
567 err
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
);
571 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
572 act
= tcf_action_init_1(tb
[i
], est
, name
, ovr
, bind
);
580 act_prev
->next
= act
;
587 tcf_action_destroy(head
, bind
);
591 int tcf_action_copy_stats(struct sk_buff
*skb
, struct tc_action
*a
,
596 struct tcf_act_hdr
*h
= a
->priv
;
601 /* compat_mode being true specifies a call that is supposed
602 * to add additional backward compatibility statistic TLVs.
605 if (a
->type
== TCA_OLD_COMPAT
)
606 err
= gnet_stats_start_copy_compat(skb
, 0,
607 TCA_STATS
, TCA_XSTATS
, &h
->tcf_lock
, &d
);
611 err
= gnet_stats_start_copy(skb
, TCA_ACT_STATS
,
617 if (a
->ops
!= NULL
&& a
->ops
->get_stats
!= NULL
)
618 if (a
->ops
->get_stats(skb
, a
) < 0)
621 if (gnet_stats_copy_basic(&d
, &h
->tcf_bstats
) < 0 ||
622 gnet_stats_copy_rate_est(&d
, &h
->tcf_bstats
,
623 &h
->tcf_rate_est
) < 0 ||
624 gnet_stats_copy_queue(&d
, &h
->tcf_qstats
) < 0)
627 if (gnet_stats_finish_copy(&d
) < 0)
637 tca_get_fill(struct sk_buff
*skb
, struct tc_action
*a
, u32 pid
, u32 seq
,
638 u16 flags
, int event
, int bind
, int ref
)
641 struct nlmsghdr
*nlh
;
642 unsigned char *b
= skb_tail_pointer(skb
);
645 nlh
= NLMSG_NEW(skb
, pid
, seq
, event
, sizeof(*t
), flags
);
648 t
->tca_family
= AF_UNSPEC
;
652 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
654 goto nla_put_failure
;
656 if (tcf_action_dump(skb
, a
, bind
, ref
) < 0)
657 goto nla_put_failure
;
659 nla_nest_end(skb
, nest
);
661 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
671 act_get_notify(u32 pid
, struct nlmsghdr
*n
, struct tc_action
*a
, int event
)
675 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
678 if (tca_get_fill(skb
, a
, pid
, n
->nlmsg_seq
, 0, event
, 0, 0) <= 0) {
683 return rtnl_unicast(skb
, &init_net
, pid
);
686 static struct tc_action
*
687 tcf_action_get_1(struct nlattr
*nla
, struct nlmsghdr
*n
, u32 pid
)
689 struct nlattr
*tb
[TCA_ACT_MAX
+1];
694 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
699 if (tb
[TCA_ACT_INDEX
] == NULL
||
700 nla_len(tb
[TCA_ACT_INDEX
]) < sizeof(index
))
702 index
= nla_get_u32(tb
[TCA_ACT_INDEX
]);
705 a
= kzalloc(sizeof(struct tc_action
), GFP_KERNEL
);
710 a
->ops
= tc_lookup_action(tb
[TCA_ACT_KIND
]);
713 if (a
->ops
->lookup
== NULL
)
716 if (a
->ops
->lookup(a
, index
) == 0)
719 module_put(a
->ops
->owner
);
723 module_put(a
->ops
->owner
);
730 static void cleanup_a(struct tc_action
*act
)
734 for (a
= act
; a
; a
= act
) {
740 static struct tc_action
*create_a(int i
)
742 struct tc_action
*act
;
744 act
= kzalloc(sizeof(*act
), GFP_KERNEL
);
746 printk("create_a: failed to alloc!\n");
753 static int tca_action_flush(struct nlattr
*nla
, struct nlmsghdr
*n
, u32 pid
)
757 struct nlmsghdr
*nlh
;
759 struct netlink_callback dcb
;
761 struct nlattr
*tb
[TCA_ACT_MAX
+1];
763 struct tc_action
*a
= create_a(0);
767 printk("tca_action_flush: couldnt create tc_action\n");
771 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
773 printk("tca_action_flush: failed skb alloc\n");
778 b
= skb_tail_pointer(skb
);
780 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
785 kind
= tb
[TCA_ACT_KIND
];
786 a
->ops
= tc_lookup_action(kind
);
790 nlh
= NLMSG_PUT(skb
, pid
, n
->nlmsg_seq
, RTM_DELACTION
, sizeof(*t
));
792 t
->tca_family
= AF_UNSPEC
;
796 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
798 goto nla_put_failure
;
800 err
= a
->ops
->walk(skb
, &dcb
, RTM_DELACTION
, a
);
802 goto nla_put_failure
;
806 nla_nest_end(skb
, nest
);
808 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
809 nlh
->nlmsg_flags
|= NLM_F_ROOT
;
810 module_put(a
->ops
->owner
);
812 err
= rtnetlink_send(skb
, &init_net
, pid
, RTNLGRP_TC
, n
->nlmsg_flags
&NLM_F_ECHO
);
820 module_put(a
->ops
->owner
);
829 tca_action_gd(struct nlattr
*nla
, struct nlmsghdr
*n
, u32 pid
, int event
)
832 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+1];
833 struct tc_action
*head
= NULL
, *act
, *act_prev
= NULL
;
835 ret
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
);
839 if (event
== RTM_DELACTION
&& n
->nlmsg_flags
&NLM_F_ROOT
) {
841 return tca_action_flush(tb
[1], n
, pid
);
846 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
847 act
= tcf_action_get_1(tb
[i
], n
, pid
);
857 act_prev
->next
= act
;
861 if (event
== RTM_GETACTION
)
862 ret
= act_get_notify(pid
, n
, head
, event
);
866 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
872 if (tca_get_fill(skb
, head
, pid
, n
->nlmsg_seq
, 0, event
,
879 /* now do the delete */
880 tcf_action_destroy(head
, 0);
881 ret
= rtnetlink_send(skb
, &init_net
, pid
, RTNLGRP_TC
,
882 n
->nlmsg_flags
&NLM_F_ECHO
);
892 static int tcf_add_notify(struct tc_action
*a
, u32 pid
, u32 seq
, int event
,
896 struct nlmsghdr
*nlh
;
902 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
906 b
= skb_tail_pointer(skb
);
908 nlh
= NLMSG_NEW(skb
, pid
, seq
, event
, sizeof(*t
), flags
);
910 t
->tca_family
= AF_UNSPEC
;
914 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
916 goto nla_put_failure
;
918 if (tcf_action_dump(skb
, a
, 0, 0) < 0)
919 goto nla_put_failure
;
921 nla_nest_end(skb
, nest
);
923 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
924 NETLINK_CB(skb
).dst_group
= RTNLGRP_TC
;
926 err
= rtnetlink_send(skb
, &init_net
, pid
, RTNLGRP_TC
, flags
&NLM_F_ECHO
);
939 tcf_action_add(struct nlattr
*nla
, struct nlmsghdr
*n
, u32 pid
, int ovr
)
942 struct tc_action
*act
;
944 u32 seq
= n
->nlmsg_seq
;
946 act
= tcf_action_init(nla
, NULL
, NULL
, ovr
, 0);
954 /* dump then free all the actions after update; inserted policy
957 ret
= tcf_add_notify(act
, pid
, seq
, RTM_NEWACTION
, n
->nlmsg_flags
);
958 for (a
= act
; a
; a
= act
) {
966 static int tc_ctl_action(struct sk_buff
*skb
, struct nlmsghdr
*n
, void *arg
)
968 struct net
*net
= sock_net(skb
->sk
);
969 struct nlattr
*tca
[TCA_ACT_MAX
+ 1];
970 u32 pid
= skb
? NETLINK_CB(skb
).pid
: 0;
971 int ret
= 0, ovr
= 0;
973 if (!net_eq(net
, &init_net
))
976 ret
= nlmsg_parse(n
, sizeof(struct tcamsg
), tca
, TCA_ACT_MAX
, NULL
);
980 if (tca
[TCA_ACT_TAB
] == NULL
) {
981 printk("tc_ctl_action: received NO action attribs\n");
985 /* n->nlmsg_flags&NLM_F_CREATE
987 switch (n
->nlmsg_type
) {
989 /* we are going to assume all other flags
990 * imply create only if it doesnt exist
991 * Note that CREATE | EXCL implies that
992 * but since we want avoid ambiguity (eg when flags
993 * is zero) then just set this
995 if (n
->nlmsg_flags
&NLM_F_REPLACE
)
998 ret
= tcf_action_add(tca
[TCA_ACT_TAB
], n
, pid
, ovr
);
1003 ret
= tca_action_gd(tca
[TCA_ACT_TAB
], n
, pid
, RTM_DELACTION
);
1006 ret
= tca_action_gd(tca
[TCA_ACT_TAB
], n
, pid
, RTM_GETACTION
);
1015 static struct nlattr
*
1016 find_dump_kind(const struct nlmsghdr
*n
)
1018 struct nlattr
*tb1
, *tb2
[TCA_ACT_MAX
+1];
1019 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
1020 struct nlattr
*nla
[TCAA_MAX
+ 1];
1021 struct nlattr
*kind
;
1023 if (nlmsg_parse(n
, sizeof(struct tcamsg
), nla
, TCAA_MAX
, NULL
) < 0)
1025 tb1
= nla
[TCA_ACT_TAB
];
1029 if (nla_parse(tb
, TCA_ACT_MAX_PRIO
, nla_data(tb1
),
1030 NLMSG_ALIGN(nla_len(tb1
)), NULL
) < 0)
1035 if (nla_parse(tb2
, TCA_ACT_MAX
, nla_data(tb
[1]),
1036 nla_len(tb
[1]), NULL
) < 0)
1038 kind
= tb2
[TCA_ACT_KIND
];
1044 tc_dump_action(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1046 struct net
*net
= sock_net(skb
->sk
);
1047 struct nlmsghdr
*nlh
;
1048 unsigned char *b
= skb_tail_pointer(skb
);
1049 struct nlattr
*nest
;
1050 struct tc_action_ops
*a_o
;
1053 struct tcamsg
*t
= (struct tcamsg
*) NLMSG_DATA(cb
->nlh
);
1054 struct nlattr
*kind
= find_dump_kind(cb
->nlh
);
1056 if (!net_eq(net
, &init_net
))
1060 printk("tc_dump_action: action bad kind\n");
1064 a_o
= tc_lookup_action(kind
);
1069 memset(&a
, 0, sizeof(struct tc_action
));
1072 if (a_o
->walk
== NULL
) {
1073 printk("tc_dump_action: %s !capable of dumping table\n", a_o
->kind
);
1074 goto nla_put_failure
;
1077 nlh
= NLMSG_PUT(skb
, NETLINK_CB(cb
->skb
).pid
, cb
->nlh
->nlmsg_seq
,
1078 cb
->nlh
->nlmsg_type
, sizeof(*t
));
1079 t
= NLMSG_DATA(nlh
);
1080 t
->tca_family
= AF_UNSPEC
;
1084 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
1086 goto nla_put_failure
;
1088 ret
= a_o
->walk(skb
, cb
, RTM_GETACTION
, &a
);
1090 goto nla_put_failure
;
1093 nla_nest_end(skb
, nest
);
1096 nla_nest_cancel(skb
, nest
);
1098 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
1099 if (NETLINK_CB(cb
->skb
).pid
&& ret
)
1100 nlh
->nlmsg_flags
|= NLM_F_MULTI
;
1101 module_put(a_o
->owner
);
1106 module_put(a_o
->owner
);
1111 static int __init
tc_action_init(void)
1113 rtnl_register(PF_UNSPEC
, RTM_NEWACTION
, tc_ctl_action
, NULL
);
1114 rtnl_register(PF_UNSPEC
, RTM_DELACTION
, tc_ctl_action
, NULL
);
1115 rtnl_register(PF_UNSPEC
, RTM_GETACTION
, tc_ctl_action
, tc_dump_action
);
1120 subsys_initcall(tc_action_init
);