618695e841901296c58284c84b8210a5f867e8b1
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 <linux/module.h>
24 #include <net/net_namespace.h>
26 #include <net/sch_generic.h>
27 #include <net/act_api.h>
28 #include <net/netlink.h>
30 void tcf_hash_destroy(struct tcf_common
*p
, struct tcf_hashinfo
*hinfo
)
32 unsigned int h
= tcf_hash(p
->tcfc_index
, hinfo
->hmask
);
33 struct tcf_common
**p1p
;
35 for (p1p
= &hinfo
->htab
[h
]; *p1p
; p1p
= &(*p1p
)->tcfc_next
) {
37 write_lock_bh(hinfo
->lock
);
39 write_unlock_bh(hinfo
->lock
);
40 gen_kill_estimator(&p
->tcfc_bstats
,
43 * gen_estimator est_timer() might access p->tcfc_lock
44 * or bstats, wait a RCU grace period before freeing p
46 kfree_rcu(p
, tcfc_rcu
);
52 EXPORT_SYMBOL(tcf_hash_destroy
);
54 int tcf_hash_release(struct tcf_common
*p
, int bind
,
55 struct tcf_hashinfo
*hinfo
)
64 if (p
->tcfc_bindcnt
<= 0 && p
->tcfc_refcnt
<= 0) {
65 tcf_hash_destroy(p
, hinfo
);
71 EXPORT_SYMBOL(tcf_hash_release
);
73 static int tcf_dump_walker(struct sk_buff
*skb
, struct netlink_callback
*cb
,
74 struct tc_action
*a
, struct tcf_hashinfo
*hinfo
)
77 int err
= 0, index
= -1, i
= 0, s_i
= 0, n_i
= 0;
80 read_lock_bh(hinfo
->lock
);
84 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
85 p
= hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
87 for (; p
; p
= p
->tcfc_next
) {
94 nest
= nla_nest_start(skb
, a
->order
);
97 err
= tcf_action_dump_1(skb
, a
, 0, 0);
100 nlmsg_trim(skb
, nest
);
103 nla_nest_end(skb
, nest
);
105 if (n_i
>= TCA_ACT_MAX_PRIO
)
110 read_unlock_bh(hinfo
->lock
);
116 nla_nest_cancel(skb
, nest
);
120 static int tcf_del_walker(struct sk_buff
*skb
, struct tc_action
*a
,
121 struct tcf_hashinfo
*hinfo
)
123 struct tcf_common
*p
, *s_p
;
127 nest
= nla_nest_start(skb
, a
->order
);
129 goto nla_put_failure
;
130 if (nla_put_string(skb
, TCA_KIND
, a
->ops
->kind
))
131 goto nla_put_failure
;
132 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
133 p
= hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
137 if (ACT_P_DELETED
== tcf_hash_release(p
, 0, hinfo
))
138 module_put(a
->ops
->owner
);
143 if (nla_put_u32(skb
, TCA_FCNT
, n_i
))
144 goto nla_put_failure
;
145 nla_nest_end(skb
, nest
);
149 nla_nest_cancel(skb
, nest
);
153 int tcf_generic_walker(struct sk_buff
*skb
, struct netlink_callback
*cb
,
154 int type
, struct tc_action
*a
)
156 struct tcf_hashinfo
*hinfo
= a
->ops
->hinfo
;
158 if (type
== RTM_DELACTION
) {
159 return tcf_del_walker(skb
, a
, hinfo
);
160 } else if (type
== RTM_GETACTION
) {
161 return tcf_dump_walker(skb
, cb
, a
, hinfo
);
163 WARN(1, "tcf_generic_walker: unknown action %d\n", type
);
167 EXPORT_SYMBOL(tcf_generic_walker
);
169 struct tcf_common
*tcf_hash_lookup(u32 index
, struct tcf_hashinfo
*hinfo
)
171 struct tcf_common
*p
;
173 read_lock_bh(hinfo
->lock
);
174 for (p
= hinfo
->htab
[tcf_hash(index
, hinfo
->hmask
)]; p
;
176 if (p
->tcfc_index
== index
)
179 read_unlock_bh(hinfo
->lock
);
183 EXPORT_SYMBOL(tcf_hash_lookup
);
185 u32
tcf_hash_new_index(u32
*idx_gen
, struct tcf_hashinfo
*hinfo
)
192 } while (tcf_hash_lookup(val
, hinfo
));
194 return (*idx_gen
= val
);
196 EXPORT_SYMBOL(tcf_hash_new_index
);
198 int tcf_hash_search(struct tc_action
*a
, u32 index
)
200 struct tcf_hashinfo
*hinfo
= a
->ops
->hinfo
;
201 struct tcf_common
*p
= tcf_hash_lookup(index
, hinfo
);
209 EXPORT_SYMBOL(tcf_hash_search
);
211 struct tcf_common
*tcf_hash_check(u32 index
, struct tc_action
*a
, int bind
,
212 struct tcf_hashinfo
*hinfo
)
214 struct tcf_common
*p
= NULL
;
215 if (index
&& (p
= tcf_hash_lookup(index
, hinfo
)) != NULL
) {
223 EXPORT_SYMBOL(tcf_hash_check
);
225 struct tcf_common
*tcf_hash_create(u32 index
, struct nlattr
*est
,
226 struct tc_action
*a
, int size
, int bind
,
227 u32
*idx_gen
, struct tcf_hashinfo
*hinfo
)
229 struct tcf_common
*p
= kzalloc(size
, GFP_KERNEL
);
232 return ERR_PTR(-ENOMEM
);
237 spin_lock_init(&p
->tcfc_lock
);
238 p
->tcfc_index
= index
? index
: tcf_hash_new_index(idx_gen
, hinfo
);
239 p
->tcfc_tm
.install
= jiffies
;
240 p
->tcfc_tm
.lastuse
= jiffies
;
242 int err
= gen_new_estimator(&p
->tcfc_bstats
, &p
->tcfc_rate_est
,
250 a
->priv
= (void *) p
;
253 EXPORT_SYMBOL(tcf_hash_create
);
255 void tcf_hash_insert(struct tcf_common
*p
, struct tcf_hashinfo
*hinfo
)
257 unsigned int h
= tcf_hash(p
->tcfc_index
, hinfo
->hmask
);
259 write_lock_bh(hinfo
->lock
);
260 p
->tcfc_next
= hinfo
->htab
[h
];
262 write_unlock_bh(hinfo
->lock
);
264 EXPORT_SYMBOL(tcf_hash_insert
);
266 static struct tc_action_ops
*act_base
= NULL
;
267 static DEFINE_RWLOCK(act_mod_lock
);
269 int tcf_register_action(struct tc_action_ops
*act
)
271 struct tc_action_ops
*a
, **ap
;
273 /* Must supply act, dump, cleanup and init */
274 if (!act
->act
|| !act
->dump
|| !act
->cleanup
|| !act
->init
)
277 write_lock(&act_mod_lock
);
278 for (ap
= &act_base
; (a
= *ap
) != NULL
; ap
= &a
->next
) {
279 if (act
->type
== a
->type
|| (strcmp(act
->kind
, a
->kind
) == 0)) {
280 write_unlock(&act_mod_lock
);
286 write_unlock(&act_mod_lock
);
289 EXPORT_SYMBOL(tcf_register_action
);
291 int tcf_unregister_action(struct tc_action_ops
*act
)
293 struct tc_action_ops
*a
, **ap
;
296 write_lock(&act_mod_lock
);
297 for (ap
= &act_base
; (a
= *ap
) != NULL
; ap
= &a
->next
)
305 write_unlock(&act_mod_lock
);
308 EXPORT_SYMBOL(tcf_unregister_action
);
311 static struct tc_action_ops
*tc_lookup_action_n(char *kind
)
313 struct tc_action_ops
*a
= NULL
;
316 read_lock(&act_mod_lock
);
317 for (a
= act_base
; a
; a
= a
->next
) {
318 if (strcmp(kind
, a
->kind
) == 0) {
319 if (!try_module_get(a
->owner
)) {
320 read_unlock(&act_mod_lock
);
326 read_unlock(&act_mod_lock
);
331 /* lookup by nlattr */
332 static struct tc_action_ops
*tc_lookup_action(struct nlattr
*kind
)
334 struct tc_action_ops
*a
= NULL
;
337 read_lock(&act_mod_lock
);
338 for (a
= act_base
; a
; a
= a
->next
) {
339 if (nla_strcmp(kind
, a
->kind
) == 0) {
340 if (!try_module_get(a
->owner
)) {
341 read_unlock(&act_mod_lock
);
347 read_unlock(&act_mod_lock
);
354 static struct tc_action_ops
*tc_lookup_action_id(u32 type
)
356 struct tc_action_ops
*a
= NULL
;
359 read_lock(&act_mod_lock
);
360 for (a
= act_base
; a
; a
= a
->next
) {
361 if (a
->type
== type
) {
362 if (!try_module_get(a
->owner
)) {
363 read_unlock(&act_mod_lock
);
369 read_unlock(&act_mod_lock
);
375 int tcf_action_exec(struct sk_buff
*skb
, const struct tc_action
*act
,
376 struct tcf_result
*res
)
378 const struct tc_action
*a
;
381 if (skb
->tc_verd
& TC_NCLS
) {
382 skb
->tc_verd
= CLR_TC_NCLS(skb
->tc_verd
);
386 while ((a
= act
) != NULL
) {
389 ret
= a
->ops
->act(skb
, a
, res
);
390 if (TC_MUNGED
& skb
->tc_verd
) {
391 /* copied already, allow trampling */
392 skb
->tc_verd
= SET_TC_OK2MUNGE(skb
->tc_verd
);
393 skb
->tc_verd
= CLR_TC_MUNGED(skb
->tc_verd
);
395 if (ret
== TC_ACT_REPEAT
)
396 goto repeat
; /* we need a ttl - JHS */
397 if (ret
!= TC_ACT_PIPE
)
405 EXPORT_SYMBOL(tcf_action_exec
);
407 void tcf_action_destroy(struct tc_action
*act
, int bind
)
411 for (a
= act
; a
; a
= act
) {
413 if (a
->ops
->cleanup(a
, bind
) == ACT_P_DELETED
)
414 module_put(a
->ops
->owner
);
418 /*FIXME: Remove later - catch insertion bugs*/
419 WARN(1, "tcf_action_destroy: BUG? destroying NULL ops\n");
427 tcf_action_dump_old(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
433 return a
->ops
->dump(skb
, a
, bind
, ref
);
437 tcf_action_dump_1(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
440 unsigned char *b
= skb_tail_pointer(skb
);
446 if (nla_put_string(skb
, TCA_KIND
, a
->ops
->kind
))
447 goto nla_put_failure
;
448 if (tcf_action_copy_stats(skb
, a
, 0))
449 goto nla_put_failure
;
450 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
452 goto nla_put_failure
;
453 err
= tcf_action_dump_old(skb
, a
, bind
, ref
);
455 nla_nest_end(skb
, nest
);
463 EXPORT_SYMBOL(tcf_action_dump_1
);
466 tcf_action_dump(struct sk_buff
*skb
, struct tc_action
*act
, int bind
, int ref
)
472 while ((a
= act
) != NULL
) {
474 nest
= nla_nest_start(skb
, a
->order
);
476 goto nla_put_failure
;
477 err
= tcf_action_dump_1(skb
, a
, bind
, ref
);
480 nla_nest_end(skb
, nest
);
488 nla_nest_cancel(skb
, nest
);
492 struct tc_action
*tcf_action_init_1(struct net
*net
, struct nlattr
*nla
,
493 struct nlattr
*est
, char *name
, int ovr
,
497 struct tc_action_ops
*a_o
;
498 char act_name
[IFNAMSIZ
];
499 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
504 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
508 kind
= tb
[TCA_ACT_KIND
];
511 if (nla_strlcpy(act_name
, kind
, IFNAMSIZ
) >= IFNAMSIZ
)
515 if (strlcpy(act_name
, name
, IFNAMSIZ
) >= IFNAMSIZ
)
519 a_o
= tc_lookup_action_n(act_name
);
521 #ifdef CONFIG_MODULES
523 request_module("act_%s", act_name
);
526 a_o
= tc_lookup_action_n(act_name
);
528 /* We dropped the RTNL semaphore in order to
529 * perform the module load. So, even if we
530 * succeeded in loading the module we have to
531 * tell the caller to replay the request. We
532 * indicate this using -EAGAIN.
544 a
= kzalloc(sizeof(*a
), GFP_KERNEL
);
548 /* backward compatibility for policer */
550 err
= a_o
->init(net
, tb
[TCA_ACT_OPTIONS
], est
, a
, ovr
, bind
);
552 err
= a_o
->init(net
, nla
, est
, a
, ovr
, bind
);
556 /* module count goes up only when brand new policy is created
557 * if it exists and is only bound to in a_o->init() then
558 * ACT_P_CREATED is not returned (a zero is).
560 if (err
!= ACT_P_CREATED
)
561 module_put(a_o
->owner
);
569 module_put(a_o
->owner
);
574 struct tc_action
*tcf_action_init(struct net
*net
, struct nlattr
*nla
,
575 struct nlattr
*est
, char *name
, int ovr
,
578 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
579 struct tc_action
*head
= NULL
, *act
, *act_prev
= NULL
;
583 err
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
);
587 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
588 act
= tcf_action_init_1(net
, tb
[i
], est
, name
, ovr
, bind
);
596 act_prev
->next
= act
;
603 tcf_action_destroy(head
, bind
);
607 int tcf_action_copy_stats(struct sk_buff
*skb
, struct tc_action
*a
,
612 struct tcf_act_hdr
*h
= a
->priv
;
617 /* compat_mode being true specifies a call that is supposed
618 * to add additional backward compatibility statistic TLVs.
621 if (a
->type
== TCA_OLD_COMPAT
)
622 err
= gnet_stats_start_copy_compat(skb
, 0,
623 TCA_STATS
, TCA_XSTATS
, &h
->tcf_lock
, &d
);
627 err
= gnet_stats_start_copy(skb
, TCA_ACT_STATS
,
633 if (a
->ops
!= NULL
&& a
->ops
->get_stats
!= NULL
)
634 if (a
->ops
->get_stats(skb
, a
) < 0)
637 if (gnet_stats_copy_basic(&d
, &h
->tcf_bstats
) < 0 ||
638 gnet_stats_copy_rate_est(&d
, &h
->tcf_bstats
,
639 &h
->tcf_rate_est
) < 0 ||
640 gnet_stats_copy_queue(&d
, &h
->tcf_qstats
) < 0)
643 if (gnet_stats_finish_copy(&d
) < 0)
653 tca_get_fill(struct sk_buff
*skb
, struct tc_action
*a
, u32 portid
, u32 seq
,
654 u16 flags
, int event
, int bind
, int ref
)
657 struct nlmsghdr
*nlh
;
658 unsigned char *b
= skb_tail_pointer(skb
);
661 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*t
), flags
);
665 t
->tca_family
= AF_UNSPEC
;
669 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
673 if (tcf_action_dump(skb
, a
, bind
, ref
) < 0)
676 nla_nest_end(skb
, nest
);
678 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
687 act_get_notify(struct net
*net
, u32 portid
, struct nlmsghdr
*n
,
688 struct tc_action
*a
, int event
)
692 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
695 if (tca_get_fill(skb
, a
, portid
, n
->nlmsg_seq
, 0, event
, 0, 0) <= 0) {
700 return rtnl_unicast(skb
, net
, portid
);
703 static struct tc_action
*
704 tcf_action_get_1(struct nlattr
*nla
, struct nlmsghdr
*n
, u32 portid
)
706 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
711 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
716 if (tb
[TCA_ACT_INDEX
] == NULL
||
717 nla_len(tb
[TCA_ACT_INDEX
]) < sizeof(index
))
719 index
= nla_get_u32(tb
[TCA_ACT_INDEX
]);
722 a
= kzalloc(sizeof(struct tc_action
), GFP_KERNEL
);
727 a
->ops
= tc_lookup_action(tb
[TCA_ACT_KIND
]);
730 if (a
->ops
->lookup
== NULL
)
733 if (a
->ops
->lookup(a
, index
) == 0)
736 module_put(a
->ops
->owner
);
740 module_put(a
->ops
->owner
);
747 static void cleanup_a(struct tc_action
*act
)
751 for (a
= act
; a
; a
= act
) {
757 static struct tc_action
*create_a(int i
)
759 struct tc_action
*act
;
761 act
= kzalloc(sizeof(*act
), GFP_KERNEL
);
763 pr_debug("create_a: failed to alloc!\n");
770 static int tca_action_flush(struct net
*net
, struct nlattr
*nla
,
771 struct nlmsghdr
*n
, u32 portid
)
775 struct nlmsghdr
*nlh
;
777 struct netlink_callback dcb
;
779 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
781 struct tc_action
*a
= create_a(0);
785 pr_debug("tca_action_flush: couldnt create tc_action\n");
789 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
791 pr_debug("tca_action_flush: failed skb alloc\n");
796 b
= skb_tail_pointer(skb
);
798 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
803 kind
= tb
[TCA_ACT_KIND
];
804 a
->ops
= tc_lookup_action(kind
);
808 nlh
= nlmsg_put(skb
, portid
, n
->nlmsg_seq
, RTM_DELACTION
, sizeof(*t
), 0);
812 t
->tca_family
= AF_UNSPEC
;
816 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
820 err
= a
->ops
->walk(skb
, &dcb
, RTM_DELACTION
, a
);
826 nla_nest_end(skb
, nest
);
828 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
829 nlh
->nlmsg_flags
|= NLM_F_ROOT
;
830 module_put(a
->ops
->owner
);
832 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
833 n
->nlmsg_flags
& NLM_F_ECHO
);
840 module_put(a
->ops
->owner
);
849 tca_action_gd(struct net
*net
, struct nlattr
*nla
, struct nlmsghdr
*n
,
850 u32 portid
, int event
)
853 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
854 struct tc_action
*head
= NULL
, *act
, *act_prev
= NULL
;
856 ret
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
);
860 if (event
== RTM_DELACTION
&& n
->nlmsg_flags
& NLM_F_ROOT
) {
862 return tca_action_flush(net
, tb
[1], n
, portid
);
867 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
868 act
= tcf_action_get_1(tb
[i
], n
, portid
);
878 act_prev
->next
= act
;
882 if (event
== RTM_GETACTION
)
883 ret
= act_get_notify(net
, portid
, n
, head
, event
);
887 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
893 if (tca_get_fill(skb
, head
, portid
, n
->nlmsg_seq
, 0, event
,
900 /* now do the delete */
901 tcf_action_destroy(head
, 0);
902 ret
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
903 n
->nlmsg_flags
& NLM_F_ECHO
);
913 static int tcf_add_notify(struct net
*net
, struct tc_action
*a
,
914 u32 portid
, u32 seq
, int event
, u16 flags
)
917 struct nlmsghdr
*nlh
;
923 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
927 b
= skb_tail_pointer(skb
);
929 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*t
), flags
);
933 t
->tca_family
= AF_UNSPEC
;
937 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
941 if (tcf_action_dump(skb
, a
, 0, 0) < 0)
944 nla_nest_end(skb
, nest
);
946 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
947 NETLINK_CB(skb
).dst_group
= RTNLGRP_TC
;
949 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
, flags
& NLM_F_ECHO
);
961 tcf_action_add(struct net
*net
, struct nlattr
*nla
, struct nlmsghdr
*n
,
965 struct tc_action
*act
;
967 u32 seq
= n
->nlmsg_seq
;
969 act
= tcf_action_init(net
, nla
, NULL
, NULL
, ovr
, 0);
977 /* dump then free all the actions after update; inserted policy
980 ret
= tcf_add_notify(net
, act
, portid
, seq
, RTM_NEWACTION
, n
->nlmsg_flags
);
981 for (a
= act
; a
; a
= act
) {
989 static int tc_ctl_action(struct sk_buff
*skb
, struct nlmsghdr
*n
)
991 struct net
*net
= sock_net(skb
->sk
);
992 struct nlattr
*tca
[TCA_ACT_MAX
+ 1];
993 u32 portid
= skb
? NETLINK_CB(skb
).portid
: 0;
994 int ret
= 0, ovr
= 0;
996 if ((n
->nlmsg_type
!= RTM_GETACTION
) && !capable(CAP_NET_ADMIN
))
999 ret
= nlmsg_parse(n
, sizeof(struct tcamsg
), tca
, TCA_ACT_MAX
, NULL
);
1003 if (tca
[TCA_ACT_TAB
] == NULL
) {
1004 pr_notice("tc_ctl_action: received NO action attribs\n");
1008 /* n->nlmsg_flags & NLM_F_CREATE */
1009 switch (n
->nlmsg_type
) {
1011 /* we are going to assume all other flags
1012 * imply create only if it doesn't exist
1013 * Note that CREATE | EXCL implies that
1014 * but since we want avoid ambiguity (eg when flags
1015 * is zero) then just set this
1017 if (n
->nlmsg_flags
& NLM_F_REPLACE
)
1020 ret
= tcf_action_add(net
, tca
[TCA_ACT_TAB
], n
, portid
, ovr
);
1025 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
1026 portid
, RTM_DELACTION
);
1029 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
1030 portid
, RTM_GETACTION
);
1039 static struct nlattr
*
1040 find_dump_kind(const struct nlmsghdr
*n
)
1042 struct nlattr
*tb1
, *tb2
[TCA_ACT_MAX
+ 1];
1043 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
1044 struct nlattr
*nla
[TCAA_MAX
+ 1];
1045 struct nlattr
*kind
;
1047 if (nlmsg_parse(n
, sizeof(struct tcamsg
), nla
, TCAA_MAX
, NULL
) < 0)
1049 tb1
= nla
[TCA_ACT_TAB
];
1053 if (nla_parse(tb
, TCA_ACT_MAX_PRIO
, nla_data(tb1
),
1054 NLMSG_ALIGN(nla_len(tb1
)), NULL
) < 0)
1059 if (nla_parse(tb2
, TCA_ACT_MAX
, nla_data(tb
[1]),
1060 nla_len(tb
[1]), NULL
) < 0)
1062 kind
= tb2
[TCA_ACT_KIND
];
1068 tc_dump_action(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1070 struct nlmsghdr
*nlh
;
1071 unsigned char *b
= skb_tail_pointer(skb
);
1072 struct nlattr
*nest
;
1073 struct tc_action_ops
*a_o
;
1076 struct tcamsg
*t
= (struct tcamsg
*) nlmsg_data(cb
->nlh
);
1077 struct nlattr
*kind
= find_dump_kind(cb
->nlh
);
1080 pr_info("tc_dump_action: action bad kind\n");
1084 a_o
= tc_lookup_action(kind
);
1088 memset(&a
, 0, sizeof(struct tc_action
));
1091 if (a_o
->walk
== NULL
) {
1092 WARN(1, "tc_dump_action: %s !capable of dumping table\n",
1094 goto out_module_put
;
1097 nlh
= nlmsg_put(skb
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
1098 cb
->nlh
->nlmsg_type
, sizeof(*t
), 0);
1100 goto out_module_put
;
1101 t
= nlmsg_data(nlh
);
1102 t
->tca_family
= AF_UNSPEC
;
1106 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
1108 goto out_module_put
;
1110 ret
= a_o
->walk(skb
, cb
, RTM_GETACTION
, &a
);
1112 goto out_module_put
;
1115 nla_nest_end(skb
, nest
);
1118 nla_nest_cancel(skb
, nest
);
1120 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
1121 if (NETLINK_CB(cb
->skb
).portid
&& ret
)
1122 nlh
->nlmsg_flags
|= NLM_F_MULTI
;
1123 module_put(a_o
->owner
);
1127 module_put(a_o
->owner
);
1132 static int __init
tc_action_init(void)
1134 rtnl_register(PF_UNSPEC
, RTM_NEWACTION
, tc_ctl_action
, NULL
, NULL
);
1135 rtnl_register(PF_UNSPEC
, RTM_DELACTION
, tc_ctl_action
, NULL
, NULL
);
1136 rtnl_register(PF_UNSPEC
, RTM_GETACTION
, tc_ctl_action
, tc_dump_action
,
1142 subsys_initcall(tc_action_init
);
This page took 0.088109 seconds and 4 git commands to generate.