]>
git.proxmox.com Git - mirror_ubuntu-artful-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 <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 static void free_tcf(struct rcu_head
*head
)
32 struct tc_action
*p
= container_of(head
, struct tc_action
, tcfa_rcu
);
34 free_percpu(p
->cpu_bstats
);
35 free_percpu(p
->cpu_qstats
);
39 static void tcf_hash_destroy(struct tcf_hashinfo
*hinfo
, struct tc_action
*p
)
41 spin_lock_bh(&hinfo
->lock
);
42 hlist_del(&p
->tcfa_head
);
43 spin_unlock_bh(&hinfo
->lock
);
44 gen_kill_estimator(&p
->tcfa_bstats
,
47 * gen_estimator est_timer() might access p->tcfa_lock
48 * or bstats, wait a RCU grace period before freeing p
50 call_rcu(&p
->tcfa_rcu
, free_tcf
);
53 int __tcf_hash_release(struct tc_action
*p
, bool bind
, bool strict
)
60 else if (strict
&& p
->tcfa_bindcnt
> 0)
64 if (p
->tcfa_bindcnt
<= 0 && p
->tcfa_refcnt
<= 0) {
66 p
->ops
->cleanup(p
, bind
);
67 tcf_hash_destroy(p
->hinfo
, p
);
74 EXPORT_SYMBOL(__tcf_hash_release
);
76 static int tcf_dump_walker(struct tcf_hashinfo
*hinfo
, struct sk_buff
*skb
,
77 struct netlink_callback
*cb
)
79 int err
= 0, index
= -1, i
= 0, s_i
= 0, n_i
= 0;
82 spin_lock_bh(&hinfo
->lock
);
86 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
87 struct hlist_head
*head
;
90 head
= &hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
92 hlist_for_each_entry_rcu(p
, head
, tcfa_head
) {
97 nest
= nla_nest_start(skb
, n_i
);
100 err
= tcf_action_dump_1(skb
, p
, 0, 0);
103 nlmsg_trim(skb
, nest
);
106 nla_nest_end(skb
, nest
);
108 if (n_i
>= TCA_ACT_MAX_PRIO
)
113 spin_unlock_bh(&hinfo
->lock
);
119 nla_nest_cancel(skb
, nest
);
123 static int tcf_del_walker(struct tcf_hashinfo
*hinfo
, struct sk_buff
*skb
,
124 const struct tc_action_ops
*ops
)
130 nest
= nla_nest_start(skb
, 0);
132 goto nla_put_failure
;
133 if (nla_put_string(skb
, TCA_KIND
, ops
->kind
))
134 goto nla_put_failure
;
135 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
136 struct hlist_head
*head
;
137 struct hlist_node
*n
;
140 head
= &hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
141 hlist_for_each_entry_safe(p
, n
, head
, tcfa_head
) {
142 ret
= __tcf_hash_release(p
, false, true);
143 if (ret
== ACT_P_DELETED
) {
144 module_put(p
->ops
->owner
);
147 goto nla_put_failure
;
150 if (nla_put_u32(skb
, TCA_FCNT
, n_i
))
151 goto nla_put_failure
;
152 nla_nest_end(skb
, nest
);
156 nla_nest_cancel(skb
, nest
);
160 int tcf_generic_walker(struct tc_action_net
*tn
, struct sk_buff
*skb
,
161 struct netlink_callback
*cb
, int type
,
162 const struct tc_action_ops
*ops
)
164 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
166 if (type
== RTM_DELACTION
) {
167 return tcf_del_walker(hinfo
, skb
, ops
);
168 } else if (type
== RTM_GETACTION
) {
169 return tcf_dump_walker(hinfo
, skb
, cb
);
171 WARN(1, "tcf_generic_walker: unknown action %d\n", type
);
175 EXPORT_SYMBOL(tcf_generic_walker
);
177 static struct tc_action
*tcf_hash_lookup(u32 index
, struct tcf_hashinfo
*hinfo
)
179 struct tc_action
*p
= NULL
;
180 struct hlist_head
*head
;
182 spin_lock_bh(&hinfo
->lock
);
183 head
= &hinfo
->htab
[tcf_hash(index
, hinfo
->hmask
)];
184 hlist_for_each_entry_rcu(p
, head
, tcfa_head
)
185 if (p
->tcfa_index
== index
)
187 spin_unlock_bh(&hinfo
->lock
);
192 u32
tcf_hash_new_index(struct tc_action_net
*tn
)
194 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
195 u32 val
= hinfo
->index
;
200 } while (tcf_hash_lookup(val
, hinfo
));
205 EXPORT_SYMBOL(tcf_hash_new_index
);
207 int tcf_hash_search(struct tc_action_net
*tn
, struct tc_action
**a
, u32 index
)
209 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
210 struct tc_action
*p
= tcf_hash_lookup(index
, hinfo
);
218 EXPORT_SYMBOL(tcf_hash_search
);
220 bool tcf_hash_check(struct tc_action_net
*tn
, u32 index
, struct tc_action
**a
,
223 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
224 struct tc_action
*p
= NULL
;
226 if (index
&& (p
= tcf_hash_lookup(index
, hinfo
)) != NULL
) {
235 EXPORT_SYMBOL(tcf_hash_check
);
237 void tcf_hash_cleanup(struct tc_action
*a
, struct nlattr
*est
)
240 gen_kill_estimator(&a
->tcfa_bstats
,
242 call_rcu(&a
->tcfa_rcu
, free_tcf
);
244 EXPORT_SYMBOL(tcf_hash_cleanup
);
246 int tcf_hash_create(struct tc_action_net
*tn
, u32 index
, struct nlattr
*est
,
247 struct tc_action
**a
, const struct tc_action_ops
*ops
,
248 int bind
, bool cpustats
)
250 struct tc_action
*p
= kzalloc(ops
->size
, GFP_KERNEL
);
251 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
261 p
->cpu_bstats
= netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu
);
262 if (!p
->cpu_bstats
) {
267 p
->cpu_qstats
= alloc_percpu(struct gnet_stats_queue
);
268 if (!p
->cpu_qstats
) {
270 free_percpu(p
->cpu_bstats
);
274 spin_lock_init(&p
->tcfa_lock
);
275 INIT_HLIST_NODE(&p
->tcfa_head
);
276 p
->tcfa_index
= index
? index
: tcf_hash_new_index(tn
);
277 p
->tcfa_tm
.install
= jiffies
;
278 p
->tcfa_tm
.lastuse
= jiffies
;
279 p
->tcfa_tm
.firstuse
= 0;
281 err
= gen_new_estimator(&p
->tcfa_bstats
, p
->cpu_bstats
,
283 &p
->tcfa_lock
, NULL
, est
);
285 free_percpu(p
->cpu_qstats
);
292 INIT_LIST_HEAD(&p
->list
);
296 EXPORT_SYMBOL(tcf_hash_create
);
298 void tcf_hash_insert(struct tc_action_net
*tn
, struct tc_action
*a
)
300 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
301 unsigned int h
= tcf_hash(a
->tcfa_index
, hinfo
->hmask
);
303 spin_lock_bh(&hinfo
->lock
);
304 hlist_add_head(&a
->tcfa_head
, &hinfo
->htab
[h
]);
305 spin_unlock_bh(&hinfo
->lock
);
307 EXPORT_SYMBOL(tcf_hash_insert
);
309 void tcf_hashinfo_destroy(const struct tc_action_ops
*ops
,
310 struct tcf_hashinfo
*hinfo
)
314 for (i
= 0; i
< hinfo
->hmask
+ 1; i
++) {
316 struct hlist_node
*n
;
318 hlist_for_each_entry_safe(p
, n
, &hinfo
->htab
[i
], tcfa_head
) {
321 ret
= __tcf_hash_release(p
, false, true);
322 if (ret
== ACT_P_DELETED
)
323 module_put(ops
->owner
);
330 EXPORT_SYMBOL(tcf_hashinfo_destroy
);
332 static LIST_HEAD(act_base
);
333 static DEFINE_RWLOCK(act_mod_lock
);
335 int tcf_register_action(struct tc_action_ops
*act
,
336 struct pernet_operations
*ops
)
338 struct tc_action_ops
*a
;
341 if (!act
->act
|| !act
->dump
|| !act
->init
|| !act
->walk
|| !act
->lookup
)
344 write_lock(&act_mod_lock
);
345 list_for_each_entry(a
, &act_base
, head
) {
346 if (act
->type
== a
->type
|| (strcmp(act
->kind
, a
->kind
) == 0)) {
347 write_unlock(&act_mod_lock
);
351 list_add_tail(&act
->head
, &act_base
);
352 write_unlock(&act_mod_lock
);
354 ret
= register_pernet_subsys(ops
);
356 tcf_unregister_action(act
, ops
);
362 EXPORT_SYMBOL(tcf_register_action
);
364 int tcf_unregister_action(struct tc_action_ops
*act
,
365 struct pernet_operations
*ops
)
367 struct tc_action_ops
*a
;
370 unregister_pernet_subsys(ops
);
372 write_lock(&act_mod_lock
);
373 list_for_each_entry(a
, &act_base
, head
) {
375 list_del(&act
->head
);
380 write_unlock(&act_mod_lock
);
383 EXPORT_SYMBOL(tcf_unregister_action
);
386 static struct tc_action_ops
*tc_lookup_action_n(char *kind
)
388 struct tc_action_ops
*a
, *res
= NULL
;
391 read_lock(&act_mod_lock
);
392 list_for_each_entry(a
, &act_base
, head
) {
393 if (strcmp(kind
, a
->kind
) == 0) {
394 if (try_module_get(a
->owner
))
399 read_unlock(&act_mod_lock
);
404 /* lookup by nlattr */
405 static struct tc_action_ops
*tc_lookup_action(struct nlattr
*kind
)
407 struct tc_action_ops
*a
, *res
= NULL
;
410 read_lock(&act_mod_lock
);
411 list_for_each_entry(a
, &act_base
, head
) {
412 if (nla_strcmp(kind
, a
->kind
) == 0) {
413 if (try_module_get(a
->owner
))
418 read_unlock(&act_mod_lock
);
423 int tcf_action_exec(struct sk_buff
*skb
, const struct list_head
*actions
,
424 struct tcf_result
*res
)
426 const struct tc_action
*a
;
429 if (skb
->tc_verd
& TC_NCLS
) {
430 skb
->tc_verd
= CLR_TC_NCLS(skb
->tc_verd
);
434 list_for_each_entry(a
, actions
, list
) {
436 ret
= a
->ops
->act(skb
, a
, res
);
437 if (ret
== TC_ACT_REPEAT
)
438 goto repeat
; /* we need a ttl - JHS */
439 if (ret
!= TC_ACT_PIPE
)
445 EXPORT_SYMBOL(tcf_action_exec
);
447 int tcf_action_destroy(struct list_head
*actions
, int bind
)
449 struct tc_action
*a
, *tmp
;
452 list_for_each_entry_safe(a
, tmp
, actions
, list
) {
453 ret
= __tcf_hash_release(a
, bind
, true);
454 if (ret
== ACT_P_DELETED
)
455 module_put(a
->ops
->owner
);
463 tcf_action_dump_old(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
465 return a
->ops
->dump(skb
, a
, bind
, ref
);
469 tcf_action_dump_1(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
472 unsigned char *b
= skb_tail_pointer(skb
);
475 if (nla_put_string(skb
, TCA_KIND
, a
->ops
->kind
))
476 goto nla_put_failure
;
477 if (tcf_action_copy_stats(skb
, a
, 0))
478 goto nla_put_failure
;
479 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
481 goto nla_put_failure
;
482 err
= tcf_action_dump_old(skb
, a
, bind
, ref
);
484 nla_nest_end(skb
, nest
);
492 EXPORT_SYMBOL(tcf_action_dump_1
);
494 int tcf_action_dump(struct sk_buff
*skb
, struct list_head
*actions
,
501 list_for_each_entry(a
, actions
, list
) {
502 nest
= nla_nest_start(skb
, a
->order
);
504 goto nla_put_failure
;
505 err
= tcf_action_dump_1(skb
, a
, bind
, ref
);
508 nla_nest_end(skb
, nest
);
516 nla_nest_cancel(skb
, nest
);
520 struct tc_action
*tcf_action_init_1(struct net
*net
, struct nlattr
*nla
,
521 struct nlattr
*est
, char *name
, int ovr
,
525 struct tc_action_ops
*a_o
;
526 char act_name
[IFNAMSIZ
];
527 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
532 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
536 kind
= tb
[TCA_ACT_KIND
];
539 if (nla_strlcpy(act_name
, kind
, IFNAMSIZ
) >= IFNAMSIZ
)
543 if (strlcpy(act_name
, name
, IFNAMSIZ
) >= IFNAMSIZ
)
547 a_o
= tc_lookup_action_n(act_name
);
549 #ifdef CONFIG_MODULES
551 request_module("act_%s", act_name
);
554 a_o
= tc_lookup_action_n(act_name
);
556 /* We dropped the RTNL semaphore in order to
557 * perform the module load. So, even if we
558 * succeeded in loading the module we have to
559 * tell the caller to replay the request. We
560 * indicate this using -EAGAIN.
571 /* backward compatibility for policer */
573 err
= a_o
->init(net
, tb
[TCA_ACT_OPTIONS
], est
, &a
, ovr
, bind
);
575 err
= a_o
->init(net
, nla
, est
, &a
, ovr
, bind
);
579 /* module count goes up only when brand new policy is created
580 * if it exists and is only bound to in a_o->init() then
581 * ACT_P_CREATED is not returned (a zero is).
583 if (err
!= ACT_P_CREATED
)
584 module_put(a_o
->owner
);
589 module_put(a_o
->owner
);
594 int tcf_action_init(struct net
*net
, struct nlattr
*nla
,
595 struct nlattr
*est
, char *name
, int ovr
,
596 int bind
, struct list_head
*actions
)
598 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
599 struct tc_action
*act
;
603 err
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
);
607 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
608 act
= tcf_action_init_1(net
, tb
[i
], est
, name
, ovr
, bind
);
614 list_add_tail(&act
->list
, actions
);
619 tcf_action_destroy(actions
, bind
);
623 int tcf_action_copy_stats(struct sk_buff
*skb
, struct tc_action
*p
,
632 /* compat_mode being true specifies a call that is supposed
633 * to add additional backward compatibility statistic TLVs.
636 if (p
->type
== TCA_OLD_COMPAT
)
637 err
= gnet_stats_start_copy_compat(skb
, 0,
645 err
= gnet_stats_start_copy(skb
, TCA_ACT_STATS
,
646 &p
->tcfa_lock
, &d
, TCA_ACT_PAD
);
651 if (gnet_stats_copy_basic(NULL
, &d
, p
->cpu_bstats
, &p
->tcfa_bstats
) < 0 ||
652 gnet_stats_copy_rate_est(&d
, &p
->tcfa_bstats
,
653 &p
->tcfa_rate_est
) < 0 ||
654 gnet_stats_copy_queue(&d
, p
->cpu_qstats
,
656 p
->tcfa_qstats
.qlen
) < 0)
659 if (gnet_stats_finish_copy(&d
) < 0)
668 static int tca_get_fill(struct sk_buff
*skb
, struct list_head
*actions
,
669 u32 portid
, u32 seq
, u16 flags
, int event
, int bind
,
673 struct nlmsghdr
*nlh
;
674 unsigned char *b
= skb_tail_pointer(skb
);
677 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*t
), flags
);
681 t
->tca_family
= AF_UNSPEC
;
685 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
689 if (tcf_action_dump(skb
, actions
, bind
, ref
) < 0)
692 nla_nest_end(skb
, nest
);
694 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
703 act_get_notify(struct net
*net
, u32 portid
, struct nlmsghdr
*n
,
704 struct list_head
*actions
, int event
)
708 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
711 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, 0, event
,
717 return rtnl_unicast(skb
, net
, portid
);
720 static struct tc_action
*tcf_action_get_1(struct net
*net
, struct nlattr
*nla
,
721 struct nlmsghdr
*n
, u32 portid
)
723 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
724 const struct tc_action_ops
*ops
;
729 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
734 if (tb
[TCA_ACT_INDEX
] == NULL
||
735 nla_len(tb
[TCA_ACT_INDEX
]) < sizeof(index
))
737 index
= nla_get_u32(tb
[TCA_ACT_INDEX
]);
740 ops
= tc_lookup_action(tb
[TCA_ACT_KIND
]);
741 if (!ops
) /* could happen in batch of actions */
744 if (ops
->lookup(net
, &a
, index
) == 0)
747 module_put(ops
->owner
);
751 module_put(ops
->owner
);
756 static int tca_action_flush(struct net
*net
, struct nlattr
*nla
,
757 struct nlmsghdr
*n
, u32 portid
)
761 struct nlmsghdr
*nlh
;
763 struct netlink_callback dcb
;
765 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
766 const struct tc_action_ops
*ops
;
770 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
772 pr_debug("tca_action_flush: failed skb alloc\n");
776 b
= skb_tail_pointer(skb
);
778 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
);
783 kind
= tb
[TCA_ACT_KIND
];
784 ops
= tc_lookup_action(kind
);
785 if (!ops
) /*some idjot trying to flush unknown action */
788 nlh
= nlmsg_put(skb
, portid
, n
->nlmsg_seq
, RTM_DELACTION
,
793 t
->tca_family
= AF_UNSPEC
;
797 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
801 err
= ops
->walk(net
, skb
, &dcb
, RTM_DELACTION
, ops
);
807 nla_nest_end(skb
, nest
);
809 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
810 nlh
->nlmsg_flags
|= NLM_F_ROOT
;
811 module_put(ops
->owner
);
812 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
813 n
->nlmsg_flags
& NLM_F_ECHO
);
820 module_put(ops
->owner
);
828 tcf_del_notify(struct net
*net
, struct nlmsghdr
*n
, struct list_head
*actions
,
834 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
838 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, 0, RTM_DELACTION
,
844 /* now do the delete */
845 ret
= tcf_action_destroy(actions
, 0);
851 ret
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
852 n
->nlmsg_flags
& NLM_F_ECHO
);
859 tca_action_gd(struct net
*net
, struct nlattr
*nla
, struct nlmsghdr
*n
,
860 u32 portid
, int event
)
863 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
864 struct tc_action
*act
;
867 ret
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
);
871 if (event
== RTM_DELACTION
&& n
->nlmsg_flags
& NLM_F_ROOT
) {
873 return tca_action_flush(net
, tb
[1], n
, portid
);
878 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
879 act
= tcf_action_get_1(net
, tb
[i
], n
, portid
);
885 list_add_tail(&act
->list
, &actions
);
888 if (event
== RTM_GETACTION
)
889 ret
= act_get_notify(net
, portid
, n
, &actions
, event
);
891 ret
= tcf_del_notify(net
, n
, &actions
, portid
);
897 tcf_action_destroy(&actions
, 0);
902 tcf_add_notify(struct net
*net
, struct nlmsghdr
*n
, struct list_head
*actions
,
908 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
912 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, n
->nlmsg_flags
,
913 RTM_NEWACTION
, 0, 0) <= 0) {
918 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
919 n
->nlmsg_flags
& NLM_F_ECHO
);
926 tcf_action_add(struct net
*net
, struct nlattr
*nla
, struct nlmsghdr
*n
,
932 ret
= tcf_action_init(net
, nla
, NULL
, NULL
, ovr
, 0, &actions
);
936 return tcf_add_notify(net
, n
, &actions
, portid
);
939 static int tc_ctl_action(struct sk_buff
*skb
, struct nlmsghdr
*n
)
941 struct net
*net
= sock_net(skb
->sk
);
942 struct nlattr
*tca
[TCA_ACT_MAX
+ 1];
943 u32 portid
= skb
? NETLINK_CB(skb
).portid
: 0;
944 int ret
= 0, ovr
= 0;
946 if ((n
->nlmsg_type
!= RTM_GETACTION
) &&
947 !netlink_capable(skb
, CAP_NET_ADMIN
))
950 ret
= nlmsg_parse(n
, sizeof(struct tcamsg
), tca
, TCA_ACT_MAX
, NULL
);
954 if (tca
[TCA_ACT_TAB
] == NULL
) {
955 pr_notice("tc_ctl_action: received NO action attribs\n");
959 /* n->nlmsg_flags & NLM_F_CREATE */
960 switch (n
->nlmsg_type
) {
962 /* we are going to assume all other flags
963 * imply create only if it doesn't exist
964 * Note that CREATE | EXCL implies that
965 * but since we want avoid ambiguity (eg when flags
966 * is zero) then just set this
968 if (n
->nlmsg_flags
& NLM_F_REPLACE
)
971 ret
= tcf_action_add(net
, tca
[TCA_ACT_TAB
], n
, portid
, ovr
);
976 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
977 portid
, RTM_DELACTION
);
980 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
981 portid
, RTM_GETACTION
);
990 static struct nlattr
*
991 find_dump_kind(const struct nlmsghdr
*n
)
993 struct nlattr
*tb1
, *tb2
[TCA_ACT_MAX
+ 1];
994 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
995 struct nlattr
*nla
[TCAA_MAX
+ 1];
998 if (nlmsg_parse(n
, sizeof(struct tcamsg
), nla
, TCAA_MAX
, NULL
) < 0)
1000 tb1
= nla
[TCA_ACT_TAB
];
1004 if (nla_parse(tb
, TCA_ACT_MAX_PRIO
, nla_data(tb1
),
1005 NLMSG_ALIGN(nla_len(tb1
)), NULL
) < 0)
1010 if (nla_parse(tb2
, TCA_ACT_MAX
, nla_data(tb
[1]),
1011 nla_len(tb
[1]), NULL
) < 0)
1013 kind
= tb2
[TCA_ACT_KIND
];
1019 tc_dump_action(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1021 struct net
*net
= sock_net(skb
->sk
);
1022 struct nlmsghdr
*nlh
;
1023 unsigned char *b
= skb_tail_pointer(skb
);
1024 struct nlattr
*nest
;
1025 struct tc_action_ops
*a_o
;
1027 struct tcamsg
*t
= (struct tcamsg
*) nlmsg_data(cb
->nlh
);
1028 struct nlattr
*kind
= find_dump_kind(cb
->nlh
);
1031 pr_info("tc_dump_action: action bad kind\n");
1035 a_o
= tc_lookup_action(kind
);
1039 nlh
= nlmsg_put(skb
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
1040 cb
->nlh
->nlmsg_type
, sizeof(*t
), 0);
1042 goto out_module_put
;
1043 t
= nlmsg_data(nlh
);
1044 t
->tca_family
= AF_UNSPEC
;
1048 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
1050 goto out_module_put
;
1052 ret
= a_o
->walk(net
, skb
, cb
, RTM_GETACTION
, a_o
);
1054 goto out_module_put
;
1057 nla_nest_end(skb
, nest
);
1062 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
1063 if (NETLINK_CB(cb
->skb
).portid
&& ret
)
1064 nlh
->nlmsg_flags
|= NLM_F_MULTI
;
1065 module_put(a_o
->owner
);
1069 module_put(a_o
->owner
);
1074 static int __init
tc_action_init(void)
1076 rtnl_register(PF_UNSPEC
, RTM_NEWACTION
, tc_ctl_action
, NULL
, NULL
);
1077 rtnl_register(PF_UNSPEC
, RTM_DELACTION
, tc_ctl_action
, NULL
, NULL
);
1078 rtnl_register(PF_UNSPEC
, RTM_GETACTION
, tc_ctl_action
, tc_dump_action
,
1084 subsys_initcall(tc_action_init
);