]>
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/pkt_cls.h>
28 #include <net/act_api.h>
29 #include <net/netlink.h>
31 static int tcf_action_goto_chain_init(struct tc_action
*a
, struct tcf_proto
*tp
)
33 u32 chain_index
= a
->tcfa_action
& TC_ACT_EXT_VAL_MASK
;
37 a
->goto_chain
= tcf_chain_get(tp
->chain
->block
, chain_index
, true);
43 static void tcf_action_goto_chain_fini(struct tc_action
*a
)
45 tcf_chain_put(a
->goto_chain
);
48 static void tcf_action_goto_chain_exec(const struct tc_action
*a
,
49 struct tcf_result
*res
)
51 const struct tcf_chain
*chain
= a
->goto_chain
;
53 res
->goto_tp
= rcu_dereference_bh(chain
->filter_chain
);
56 static void free_tcf(struct rcu_head
*head
)
58 struct tc_action
*p
= container_of(head
, struct tc_action
, tcfa_rcu
);
60 free_percpu(p
->cpu_bstats
);
61 free_percpu(p
->cpu_qstats
);
64 kfree(p
->act_cookie
->data
);
68 tcf_action_goto_chain_fini(p
);
73 static void tcf_hash_destroy(struct tcf_hashinfo
*hinfo
, struct tc_action
*p
)
75 spin_lock_bh(&hinfo
->lock
);
76 hlist_del(&p
->tcfa_head
);
77 spin_unlock_bh(&hinfo
->lock
);
78 gen_kill_estimator(&p
->tcfa_rate_est
);
80 * gen_estimator est_timer() might access p->tcfa_lock
81 * or bstats, wait a RCU grace period before freeing p
83 call_rcu(&p
->tcfa_rcu
, free_tcf
);
86 int __tcf_hash_release(struct tc_action
*p
, bool bind
, bool strict
)
93 else if (strict
&& p
->tcfa_bindcnt
> 0)
97 if (p
->tcfa_bindcnt
<= 0 && p
->tcfa_refcnt
<= 0) {
99 p
->ops
->cleanup(p
, bind
);
100 tcf_hash_destroy(p
->hinfo
, p
);
107 EXPORT_SYMBOL(__tcf_hash_release
);
109 static int tcf_dump_walker(struct tcf_hashinfo
*hinfo
, struct sk_buff
*skb
,
110 struct netlink_callback
*cb
)
112 int err
= 0, index
= -1, i
= 0, s_i
= 0, n_i
= 0;
115 spin_lock_bh(&hinfo
->lock
);
119 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
120 struct hlist_head
*head
;
123 head
= &hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
125 hlist_for_each_entry_rcu(p
, head
, tcfa_head
) {
130 nest
= nla_nest_start(skb
, n_i
);
132 goto nla_put_failure
;
133 err
= tcf_action_dump_1(skb
, p
, 0, 0);
136 nlmsg_trim(skb
, nest
);
139 nla_nest_end(skb
, nest
);
141 if (n_i
>= TCA_ACT_MAX_PRIO
)
146 spin_unlock_bh(&hinfo
->lock
);
152 nla_nest_cancel(skb
, nest
);
156 static int tcf_del_walker(struct tcf_hashinfo
*hinfo
, struct sk_buff
*skb
,
157 const struct tc_action_ops
*ops
)
163 nest
= nla_nest_start(skb
, 0);
165 goto nla_put_failure
;
166 if (nla_put_string(skb
, TCA_KIND
, ops
->kind
))
167 goto nla_put_failure
;
168 for (i
= 0; i
< (hinfo
->hmask
+ 1); i
++) {
169 struct hlist_head
*head
;
170 struct hlist_node
*n
;
173 head
= &hinfo
->htab
[tcf_hash(i
, hinfo
->hmask
)];
174 hlist_for_each_entry_safe(p
, n
, head
, tcfa_head
) {
175 ret
= __tcf_hash_release(p
, false, true);
176 if (ret
== ACT_P_DELETED
) {
177 module_put(ops
->owner
);
180 goto nla_put_failure
;
183 if (nla_put_u32(skb
, TCA_FCNT
, n_i
))
184 goto nla_put_failure
;
185 nla_nest_end(skb
, nest
);
189 nla_nest_cancel(skb
, nest
);
193 int tcf_generic_walker(struct tc_action_net
*tn
, struct sk_buff
*skb
,
194 struct netlink_callback
*cb
, int type
,
195 const struct tc_action_ops
*ops
)
197 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
199 if (type
== RTM_DELACTION
) {
200 return tcf_del_walker(hinfo
, skb
, ops
);
201 } else if (type
== RTM_GETACTION
) {
202 return tcf_dump_walker(hinfo
, skb
, cb
);
204 WARN(1, "tcf_generic_walker: unknown action %d\n", type
);
208 EXPORT_SYMBOL(tcf_generic_walker
);
210 static struct tc_action
*tcf_hash_lookup(u32 index
, struct tcf_hashinfo
*hinfo
)
212 struct tc_action
*p
= NULL
;
213 struct hlist_head
*head
;
215 spin_lock_bh(&hinfo
->lock
);
216 head
= &hinfo
->htab
[tcf_hash(index
, hinfo
->hmask
)];
217 hlist_for_each_entry_rcu(p
, head
, tcfa_head
)
218 if (p
->tcfa_index
== index
)
220 spin_unlock_bh(&hinfo
->lock
);
225 u32
tcf_hash_new_index(struct tc_action_net
*tn
)
227 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
228 u32 val
= hinfo
->index
;
233 } while (tcf_hash_lookup(val
, hinfo
));
238 EXPORT_SYMBOL(tcf_hash_new_index
);
240 int tcf_hash_search(struct tc_action_net
*tn
, struct tc_action
**a
, u32 index
)
242 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
243 struct tc_action
*p
= tcf_hash_lookup(index
, hinfo
);
251 EXPORT_SYMBOL(tcf_hash_search
);
253 bool tcf_hash_check(struct tc_action_net
*tn
, u32 index
, struct tc_action
**a
,
256 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
257 struct tc_action
*p
= NULL
;
259 if (index
&& (p
= tcf_hash_lookup(index
, hinfo
)) != NULL
) {
268 EXPORT_SYMBOL(tcf_hash_check
);
270 void tcf_hash_cleanup(struct tc_action
*a
, struct nlattr
*est
)
273 gen_kill_estimator(&a
->tcfa_rate_est
);
274 call_rcu(&a
->tcfa_rcu
, free_tcf
);
276 EXPORT_SYMBOL(tcf_hash_cleanup
);
278 int tcf_hash_create(struct tc_action_net
*tn
, u32 index
, struct nlattr
*est
,
279 struct tc_action
**a
, const struct tc_action_ops
*ops
,
280 int bind
, bool cpustats
)
282 struct tc_action
*p
= kzalloc(ops
->size
, GFP_KERNEL
);
283 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
293 p
->cpu_bstats
= netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu
);
294 if (!p
->cpu_bstats
) {
299 p
->cpu_qstats
= alloc_percpu(struct gnet_stats_queue
);
300 if (!p
->cpu_qstats
) {
302 free_percpu(p
->cpu_bstats
);
306 spin_lock_init(&p
->tcfa_lock
);
307 INIT_HLIST_NODE(&p
->tcfa_head
);
308 p
->tcfa_index
= index
? index
: tcf_hash_new_index(tn
);
309 p
->tcfa_tm
.install
= jiffies
;
310 p
->tcfa_tm
.lastuse
= jiffies
;
311 p
->tcfa_tm
.firstuse
= 0;
313 err
= gen_new_estimator(&p
->tcfa_bstats
, p
->cpu_bstats
,
315 &p
->tcfa_lock
, NULL
, est
);
317 free_percpu(p
->cpu_qstats
);
324 INIT_LIST_HEAD(&p
->list
);
328 EXPORT_SYMBOL(tcf_hash_create
);
330 void tcf_hash_insert(struct tc_action_net
*tn
, struct tc_action
*a
)
332 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
333 unsigned int h
= tcf_hash(a
->tcfa_index
, hinfo
->hmask
);
335 spin_lock_bh(&hinfo
->lock
);
336 hlist_add_head(&a
->tcfa_head
, &hinfo
->htab
[h
]);
337 spin_unlock_bh(&hinfo
->lock
);
339 EXPORT_SYMBOL(tcf_hash_insert
);
341 void tcf_hashinfo_destroy(const struct tc_action_ops
*ops
,
342 struct tcf_hashinfo
*hinfo
)
346 for (i
= 0; i
< hinfo
->hmask
+ 1; i
++) {
348 struct hlist_node
*n
;
350 hlist_for_each_entry_safe(p
, n
, &hinfo
->htab
[i
], tcfa_head
) {
353 ret
= __tcf_hash_release(p
, false, true);
354 if (ret
== ACT_P_DELETED
)
355 module_put(ops
->owner
);
362 EXPORT_SYMBOL(tcf_hashinfo_destroy
);
364 static LIST_HEAD(act_base
);
365 static DEFINE_RWLOCK(act_mod_lock
);
367 int tcf_register_action(struct tc_action_ops
*act
,
368 struct pernet_operations
*ops
)
370 struct tc_action_ops
*a
;
373 if (!act
->act
|| !act
->dump
|| !act
->init
|| !act
->walk
|| !act
->lookup
)
376 /* We have to register pernet ops before making the action ops visible,
377 * otherwise tcf_action_init_1() could get a partially initialized
380 ret
= register_pernet_subsys(ops
);
384 write_lock(&act_mod_lock
);
385 list_for_each_entry(a
, &act_base
, head
) {
386 if (act
->type
== a
->type
|| (strcmp(act
->kind
, a
->kind
) == 0)) {
387 write_unlock(&act_mod_lock
);
388 unregister_pernet_subsys(ops
);
392 list_add_tail(&act
->head
, &act_base
);
393 write_unlock(&act_mod_lock
);
397 EXPORT_SYMBOL(tcf_register_action
);
399 int tcf_unregister_action(struct tc_action_ops
*act
,
400 struct pernet_operations
*ops
)
402 struct tc_action_ops
*a
;
405 write_lock(&act_mod_lock
);
406 list_for_each_entry(a
, &act_base
, head
) {
408 list_del(&act
->head
);
413 write_unlock(&act_mod_lock
);
415 unregister_pernet_subsys(ops
);
418 EXPORT_SYMBOL(tcf_unregister_action
);
421 static struct tc_action_ops
*tc_lookup_action_n(char *kind
)
423 struct tc_action_ops
*a
, *res
= NULL
;
426 read_lock(&act_mod_lock
);
427 list_for_each_entry(a
, &act_base
, head
) {
428 if (strcmp(kind
, a
->kind
) == 0) {
429 if (try_module_get(a
->owner
))
434 read_unlock(&act_mod_lock
);
439 /* lookup by nlattr */
440 static struct tc_action_ops
*tc_lookup_action(struct nlattr
*kind
)
442 struct tc_action_ops
*a
, *res
= NULL
;
445 read_lock(&act_mod_lock
);
446 list_for_each_entry(a
, &act_base
, head
) {
447 if (nla_strcmp(kind
, a
->kind
) == 0) {
448 if (try_module_get(a
->owner
))
453 read_unlock(&act_mod_lock
);
458 /*TCA_ACT_MAX_PRIO is 32, there count upto 32 */
459 #define TCA_ACT_MAX_PRIO_MASK 0x1FF
460 int tcf_action_exec(struct sk_buff
*skb
, struct tc_action
**actions
,
461 int nr_actions
, struct tcf_result
*res
)
465 u32 jmp_ttl
= TCA_ACT_MAX_PRIO
; /*matches actions per filter */
467 if (skb_skip_tc_classify(skb
))
471 for (i
= 0; i
< nr_actions
; i
++) {
472 const struct tc_action
*a
= actions
[i
];
474 if (jmp_prgcnt
> 0) {
479 ret
= a
->ops
->act(skb
, a
, res
);
480 if (ret
== TC_ACT_REPEAT
)
481 goto repeat
; /* we need a ttl - JHS */
483 if (TC_ACT_EXT_CMP(ret
, TC_ACT_JUMP
)) {
484 jmp_prgcnt
= ret
& TCA_ACT_MAX_PRIO_MASK
;
485 if (!jmp_prgcnt
|| (jmp_prgcnt
> nr_actions
)) {
486 /* faulty opcode, stop pipeline */
491 goto restart_act_graph
;
492 else /* faulty graph, stop pipeline */
495 } else if (TC_ACT_EXT_CMP(ret
, TC_ACT_GOTO_CHAIN
)) {
496 tcf_action_goto_chain_exec(a
, res
);
499 if (ret
!= TC_ACT_PIPE
)
505 EXPORT_SYMBOL(tcf_action_exec
);
507 int tcf_action_destroy(struct list_head
*actions
, int bind
)
509 const struct tc_action_ops
*ops
;
510 struct tc_action
*a
, *tmp
;
513 list_for_each_entry_safe(a
, tmp
, actions
, list
) {
515 ret
= __tcf_hash_release(a
, bind
, true);
516 if (ret
== ACT_P_DELETED
)
517 module_put(ops
->owner
);
525 tcf_action_dump_old(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
527 return a
->ops
->dump(skb
, a
, bind
, ref
);
531 tcf_action_dump_1(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
534 unsigned char *b
= skb_tail_pointer(skb
);
537 if (nla_put_string(skb
, TCA_KIND
, a
->ops
->kind
))
538 goto nla_put_failure
;
539 if (tcf_action_copy_stats(skb
, a
, 0))
540 goto nla_put_failure
;
542 if (nla_put(skb
, TCA_ACT_COOKIE
, a
->act_cookie
->len
,
543 a
->act_cookie
->data
))
544 goto nla_put_failure
;
547 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
549 goto nla_put_failure
;
550 err
= tcf_action_dump_old(skb
, a
, bind
, ref
);
552 nla_nest_end(skb
, nest
);
560 EXPORT_SYMBOL(tcf_action_dump_1
);
562 int tcf_action_dump(struct sk_buff
*skb
, struct list_head
*actions
,
569 list_for_each_entry(a
, actions
, list
) {
570 nest
= nla_nest_start(skb
, a
->order
);
572 goto nla_put_failure
;
573 err
= tcf_action_dump_1(skb
, a
, bind
, ref
);
576 nla_nest_end(skb
, nest
);
584 nla_nest_cancel(skb
, nest
);
588 static struct tc_cookie
*nla_memdup_cookie(struct nlattr
**tb
)
590 struct tc_cookie
*c
= kzalloc(sizeof(*c
), GFP_KERNEL
);
594 c
->data
= nla_memdup(tb
[TCA_ACT_COOKIE
], GFP_KERNEL
);
599 c
->len
= nla_len(tb
[TCA_ACT_COOKIE
]);
604 struct tc_action
*tcf_action_init_1(struct net
*net
, struct tcf_proto
*tp
,
605 struct nlattr
*nla
, struct nlattr
*est
,
606 char *name
, int ovr
, int bind
)
609 struct tc_action_ops
*a_o
;
610 struct tc_cookie
*cookie
= NULL
;
611 char act_name
[IFNAMSIZ
];
612 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
617 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
, NULL
);
621 kind
= tb
[TCA_ACT_KIND
];
624 if (nla_strlcpy(act_name
, kind
, IFNAMSIZ
) >= IFNAMSIZ
)
626 if (tb
[TCA_ACT_COOKIE
]) {
627 int cklen
= nla_len(tb
[TCA_ACT_COOKIE
]);
629 if (cklen
> TC_COOKIE_MAX_SIZE
)
632 cookie
= nla_memdup_cookie(tb
);
640 if (strlcpy(act_name
, name
, IFNAMSIZ
) >= IFNAMSIZ
)
644 a_o
= tc_lookup_action_n(act_name
);
646 #ifdef CONFIG_MODULES
648 request_module("act_%s", act_name
);
651 a_o
= tc_lookup_action_n(act_name
);
653 /* We dropped the RTNL semaphore in order to
654 * perform the module load. So, even if we
655 * succeeded in loading the module we have to
656 * tell the caller to replay the request. We
657 * indicate this using -EAGAIN.
668 /* backward compatibility for policer */
670 err
= a_o
->init(net
, tb
[TCA_ACT_OPTIONS
], est
, &a
, ovr
, bind
);
672 err
= a_o
->init(net
, nla
, est
, &a
, ovr
, bind
);
676 if (name
== NULL
&& tb
[TCA_ACT_COOKIE
]) {
678 kfree(a
->act_cookie
->data
);
679 kfree(a
->act_cookie
);
681 a
->act_cookie
= cookie
;
684 /* module count goes up only when brand new policy is created
685 * if it exists and is only bound to in a_o->init() then
686 * ACT_P_CREATED is not returned (a zero is).
688 if (err
!= ACT_P_CREATED
)
689 module_put(a_o
->owner
);
691 if (TC_ACT_EXT_CMP(a
->tcfa_action
, TC_ACT_GOTO_CHAIN
)) {
692 err
= tcf_action_goto_chain_init(a
, tp
);
696 list_add_tail(&a
->list
, &actions
);
697 tcf_action_destroy(&actions
, bind
);
705 module_put(a_o
->owner
);
714 static void cleanup_a(struct list_head
*actions
, int ovr
)
721 list_for_each_entry(a
, actions
, list
)
725 int tcf_action_init(struct net
*net
, struct tcf_proto
*tp
, struct nlattr
*nla
,
726 struct nlattr
*est
, char *name
, int ovr
, int bind
,
727 struct list_head
*actions
)
729 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
730 struct tc_action
*act
;
734 err
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
, NULL
);
738 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
739 act
= tcf_action_init_1(net
, tp
, tb
[i
], est
, name
, ovr
, bind
);
747 list_add_tail(&act
->list
, actions
);
750 /* Remove the temp refcnt which was necessary to protect against
751 * destroying an existing action which was being replaced
753 cleanup_a(actions
, ovr
);
757 tcf_action_destroy(actions
, bind
);
761 int tcf_action_copy_stats(struct sk_buff
*skb
, struct tc_action
*p
,
770 /* compat_mode being true specifies a call that is supposed
771 * to add additional backward compatibility statistic TLVs.
774 if (p
->type
== TCA_OLD_COMPAT
)
775 err
= gnet_stats_start_copy_compat(skb
, 0,
783 err
= gnet_stats_start_copy(skb
, TCA_ACT_STATS
,
784 &p
->tcfa_lock
, &d
, TCA_ACT_PAD
);
789 if (gnet_stats_copy_basic(NULL
, &d
, p
->cpu_bstats
, &p
->tcfa_bstats
) < 0 ||
790 gnet_stats_copy_rate_est(&d
, &p
->tcfa_rate_est
) < 0 ||
791 gnet_stats_copy_queue(&d
, p
->cpu_qstats
,
793 p
->tcfa_qstats
.qlen
) < 0)
796 if (gnet_stats_finish_copy(&d
) < 0)
805 static int tca_get_fill(struct sk_buff
*skb
, struct list_head
*actions
,
806 u32 portid
, u32 seq
, u16 flags
, int event
, int bind
,
810 struct nlmsghdr
*nlh
;
811 unsigned char *b
= skb_tail_pointer(skb
);
814 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*t
), flags
);
818 t
->tca_family
= AF_UNSPEC
;
822 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
826 if (tcf_action_dump(skb
, actions
, bind
, ref
) < 0)
829 nla_nest_end(skb
, nest
);
831 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
840 tcf_get_notify(struct net
*net
, u32 portid
, struct nlmsghdr
*n
,
841 struct list_head
*actions
, int event
)
845 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
848 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, 0, event
,
854 return rtnl_unicast(skb
, net
, portid
);
857 static struct tc_action
*tcf_action_get_1(struct net
*net
, struct nlattr
*nla
,
858 struct nlmsghdr
*n
, u32 portid
)
860 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
861 const struct tc_action_ops
*ops
;
866 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
, NULL
);
871 if (tb
[TCA_ACT_INDEX
] == NULL
||
872 nla_len(tb
[TCA_ACT_INDEX
]) < sizeof(index
))
874 index
= nla_get_u32(tb
[TCA_ACT_INDEX
]);
877 ops
= tc_lookup_action(tb
[TCA_ACT_KIND
]);
878 if (!ops
) /* could happen in batch of actions */
881 if (ops
->lookup(net
, &a
, index
) == 0)
884 module_put(ops
->owner
);
888 module_put(ops
->owner
);
893 static int tca_action_flush(struct net
*net
, struct nlattr
*nla
,
894 struct nlmsghdr
*n
, u32 portid
)
898 struct nlmsghdr
*nlh
;
900 struct netlink_callback dcb
;
902 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
903 const struct tc_action_ops
*ops
;
907 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
909 pr_debug("tca_action_flush: failed skb alloc\n");
913 b
= skb_tail_pointer(skb
);
915 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
, NULL
);
920 kind
= tb
[TCA_ACT_KIND
];
921 ops
= tc_lookup_action(kind
);
922 if (!ops
) /*some idjot trying to flush unknown action */
925 nlh
= nlmsg_put(skb
, portid
, n
->nlmsg_seq
, RTM_DELACTION
,
930 t
->tca_family
= AF_UNSPEC
;
934 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
938 err
= ops
->walk(net
, skb
, &dcb
, RTM_DELACTION
, ops
);
942 nla_nest_end(skb
, nest
);
944 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
945 nlh
->nlmsg_flags
|= NLM_F_ROOT
;
946 module_put(ops
->owner
);
947 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
948 n
->nlmsg_flags
& NLM_F_ECHO
);
955 module_put(ops
->owner
);
962 tcf_del_notify(struct net
*net
, struct nlmsghdr
*n
, struct list_head
*actions
,
968 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
972 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, 0, RTM_DELACTION
,
978 /* now do the delete */
979 ret
= tcf_action_destroy(actions
, 0);
985 ret
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
986 n
->nlmsg_flags
& NLM_F_ECHO
);
993 tca_action_gd(struct net
*net
, struct nlattr
*nla
, struct nlmsghdr
*n
,
994 u32 portid
, int event
)
997 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
998 struct tc_action
*act
;
1001 ret
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
, NULL
);
1005 if (event
== RTM_DELACTION
&& n
->nlmsg_flags
& NLM_F_ROOT
) {
1007 return tca_action_flush(net
, tb
[1], n
, portid
);
1012 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
1013 act
= tcf_action_get_1(net
, tb
[i
], n
, portid
);
1019 list_add_tail(&act
->list
, &actions
);
1022 if (event
== RTM_GETACTION
)
1023 ret
= tcf_get_notify(net
, portid
, n
, &actions
, event
);
1025 ret
= tcf_del_notify(net
, n
, &actions
, portid
);
1031 if (event
!= RTM_GETACTION
)
1032 tcf_action_destroy(&actions
, 0);
1037 tcf_add_notify(struct net
*net
, struct nlmsghdr
*n
, struct list_head
*actions
,
1040 struct sk_buff
*skb
;
1043 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
1047 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, n
->nlmsg_flags
,
1048 RTM_NEWACTION
, 0, 0) <= 0) {
1053 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
1054 n
->nlmsg_flags
& NLM_F_ECHO
);
1060 static int tcf_action_add(struct net
*net
, struct nlattr
*nla
,
1061 struct nlmsghdr
*n
, u32 portid
, int ovr
)
1066 ret
= tcf_action_init(net
, NULL
, nla
, NULL
, NULL
, ovr
, 0, &actions
);
1070 return tcf_add_notify(net
, n
, &actions
, portid
);
1073 static int tc_ctl_action(struct sk_buff
*skb
, struct nlmsghdr
*n
,
1074 struct netlink_ext_ack
*extack
)
1076 struct net
*net
= sock_net(skb
->sk
);
1077 struct nlattr
*tca
[TCA_ACT_MAX
+ 1];
1078 u32 portid
= skb
? NETLINK_CB(skb
).portid
: 0;
1079 int ret
= 0, ovr
= 0;
1081 if ((n
->nlmsg_type
!= RTM_GETACTION
) &&
1082 !netlink_capable(skb
, CAP_NET_ADMIN
))
1085 ret
= nlmsg_parse(n
, sizeof(struct tcamsg
), tca
, TCA_ACT_MAX
, NULL
,
1090 if (tca
[TCA_ACT_TAB
] == NULL
) {
1091 pr_notice("tc_ctl_action: received NO action attribs\n");
1095 /* n->nlmsg_flags & NLM_F_CREATE */
1096 switch (n
->nlmsg_type
) {
1098 /* we are going to assume all other flags
1099 * imply create only if it doesn't exist
1100 * Note that CREATE | EXCL implies that
1101 * but since we want avoid ambiguity (eg when flags
1102 * is zero) then just set this
1104 if (n
->nlmsg_flags
& NLM_F_REPLACE
)
1107 ret
= tcf_action_add(net
, tca
[TCA_ACT_TAB
], n
, portid
, ovr
);
1112 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
1113 portid
, RTM_DELACTION
);
1116 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
1117 portid
, RTM_GETACTION
);
1126 static struct nlattr
*find_dump_kind(const struct nlmsghdr
*n
)
1128 struct nlattr
*tb1
, *tb2
[TCA_ACT_MAX
+ 1];
1129 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
1130 struct nlattr
*nla
[TCAA_MAX
+ 1];
1131 struct nlattr
*kind
;
1133 if (nlmsg_parse(n
, sizeof(struct tcamsg
), nla
, TCAA_MAX
,
1136 tb1
= nla
[TCA_ACT_TAB
];
1140 if (nla_parse(tb
, TCA_ACT_MAX_PRIO
, nla_data(tb1
),
1141 NLMSG_ALIGN(nla_len(tb1
)), NULL
, NULL
) < 0)
1146 if (nla_parse_nested(tb2
, TCA_ACT_MAX
, tb
[1], NULL
, NULL
) < 0)
1148 kind
= tb2
[TCA_ACT_KIND
];
1153 static int tc_dump_action(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1155 struct net
*net
= sock_net(skb
->sk
);
1156 struct nlmsghdr
*nlh
;
1157 unsigned char *b
= skb_tail_pointer(skb
);
1158 struct nlattr
*nest
;
1159 struct tc_action_ops
*a_o
;
1161 struct tcamsg
*t
= (struct tcamsg
*) nlmsg_data(cb
->nlh
);
1162 struct nlattr
*kind
= find_dump_kind(cb
->nlh
);
1165 pr_info("tc_dump_action: action bad kind\n");
1169 a_o
= tc_lookup_action(kind
);
1173 nlh
= nlmsg_put(skb
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
1174 cb
->nlh
->nlmsg_type
, sizeof(*t
), 0);
1176 goto out_module_put
;
1177 t
= nlmsg_data(nlh
);
1178 t
->tca_family
= AF_UNSPEC
;
1182 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
1184 goto out_module_put
;
1186 ret
= a_o
->walk(net
, skb
, cb
, RTM_GETACTION
, a_o
);
1188 goto out_module_put
;
1191 nla_nest_end(skb
, nest
);
1196 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
1197 if (NETLINK_CB(cb
->skb
).portid
&& ret
)
1198 nlh
->nlmsg_flags
|= NLM_F_MULTI
;
1199 module_put(a_o
->owner
);
1203 module_put(a_o
->owner
);
1208 static int __init
tc_action_init(void)
1210 rtnl_register(PF_UNSPEC
, RTM_NEWACTION
, tc_ctl_action
, NULL
, NULL
);
1211 rtnl_register(PF_UNSPEC
, RTM_DELACTION
, tc_ctl_action
, NULL
, NULL
);
1212 rtnl_register(PF_UNSPEC
, RTM_GETACTION
, tc_ctl_action
, tc_dump_action
,
1218 subsys_initcall(tc_action_init
);