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 <linux/rhashtable.h>
25 #include <linux/list.h>
26 #include <net/net_namespace.h>
28 #include <net/sch_generic.h>
29 #include <net/pkt_cls.h>
30 #include <net/act_api.h>
31 #include <net/netlink.h>
33 static int tcf_action_goto_chain_init(struct tc_action
*a
, struct tcf_proto
*tp
)
35 u32 chain_index
= a
->tcfa_action
& TC_ACT_EXT_VAL_MASK
;
39 a
->goto_chain
= tcf_chain_get(tp
->chain
->block
, chain_index
, true);
45 static void tcf_action_goto_chain_fini(struct tc_action
*a
)
47 tcf_chain_put(a
->goto_chain
);
50 static void tcf_action_goto_chain_exec(const struct tc_action
*a
,
51 struct tcf_result
*res
)
53 const struct tcf_chain
*chain
= a
->goto_chain
;
55 res
->goto_tp
= rcu_dereference_bh(chain
->filter_chain
);
58 /* XXX: For standalone actions, we don't need a RCU grace period either, because
59 * actions are always connected to filters and filters are already destroyed in
60 * RCU callbacks, so after a RCU grace period actions are already disconnected
61 * from filters. Readers later can not find us.
63 static void free_tcf(struct tc_action
*p
)
65 free_percpu(p
->cpu_bstats
);
66 free_percpu(p
->cpu_qstats
);
69 kfree(p
->act_cookie
->data
);
73 tcf_action_goto_chain_fini(p
);
78 static void tcf_idr_remove(struct tcf_idrinfo
*idrinfo
, struct tc_action
*p
)
80 spin_lock_bh(&idrinfo
->lock
);
81 idr_remove_ext(&idrinfo
->action_idr
, p
->tcfa_index
);
82 spin_unlock_bh(&idrinfo
->lock
);
83 gen_kill_estimator(&p
->tcfa_rate_est
);
87 int __tcf_idr_release(struct tc_action
*p
, bool bind
, bool strict
)
96 else if (strict
&& p
->tcfa_bindcnt
> 0)
100 if (p
->tcfa_bindcnt
<= 0 && p
->tcfa_refcnt
<= 0) {
102 p
->ops
->cleanup(p
, bind
);
103 tcf_idr_remove(p
->idrinfo
, p
);
110 EXPORT_SYMBOL(__tcf_idr_release
);
112 static int tcf_dump_walker(struct tcf_idrinfo
*idrinfo
, struct sk_buff
*skb
,
113 struct netlink_callback
*cb
)
115 int err
= 0, index
= -1, s_i
= 0, n_i
= 0;
116 u32 act_flags
= cb
->args
[2];
117 unsigned long jiffy_since
= cb
->args
[3];
119 struct idr
*idr
= &idrinfo
->action_idr
;
121 unsigned long id
= 1;
123 spin_lock_bh(&idrinfo
->lock
);
127 idr_for_each_entry_ext(idr
, p
, id
) {
133 time_after(jiffy_since
,
134 (unsigned long)p
->tcfa_tm
.lastuse
))
137 nest
= nla_nest_start(skb
, n_i
);
140 goto nla_put_failure
;
142 err
= tcf_action_dump_1(skb
, p
, 0, 0);
145 nlmsg_trim(skb
, nest
);
148 nla_nest_end(skb
, nest
);
150 if (!(act_flags
& TCA_FLAG_LARGE_DUMP_ON
) &&
151 n_i
>= TCA_ACT_MAX_PRIO
)
156 cb
->args
[0] = index
+ 1;
158 spin_unlock_bh(&idrinfo
->lock
);
160 if (act_flags
& TCA_FLAG_LARGE_DUMP_ON
)
166 nla_nest_cancel(skb
, nest
);
170 static int tcf_del_walker(struct tcf_idrinfo
*idrinfo
, struct sk_buff
*skb
,
171 const struct tc_action_ops
*ops
)
176 struct idr
*idr
= &idrinfo
->action_idr
;
178 unsigned long id
= 1;
180 nest
= nla_nest_start(skb
, 0);
182 goto nla_put_failure
;
183 if (nla_put_string(skb
, TCA_KIND
, ops
->kind
))
184 goto nla_put_failure
;
186 idr_for_each_entry_ext(idr
, p
, id
) {
187 ret
= __tcf_idr_release(p
, false, true);
188 if (ret
== ACT_P_DELETED
) {
189 module_put(ops
->owner
);
191 } else if (ret
< 0) {
192 goto nla_put_failure
;
195 if (nla_put_u32(skb
, TCA_FCNT
, n_i
))
196 goto nla_put_failure
;
197 nla_nest_end(skb
, nest
);
201 nla_nest_cancel(skb
, nest
);
205 int tcf_generic_walker(struct tc_action_net
*tn
, struct sk_buff
*skb
,
206 struct netlink_callback
*cb
, int type
,
207 const struct tc_action_ops
*ops
)
209 struct tcf_idrinfo
*idrinfo
= tn
->idrinfo
;
211 if (type
== RTM_DELACTION
) {
212 return tcf_del_walker(idrinfo
, skb
, ops
);
213 } else if (type
== RTM_GETACTION
) {
214 return tcf_dump_walker(idrinfo
, skb
, cb
);
216 WARN(1, "tcf_generic_walker: unknown action %d\n", type
);
220 EXPORT_SYMBOL(tcf_generic_walker
);
222 static struct tc_action
*tcf_idr_lookup(u32 index
, struct tcf_idrinfo
*idrinfo
)
224 struct tc_action
*p
= NULL
;
226 spin_lock_bh(&idrinfo
->lock
);
227 p
= idr_find_ext(&idrinfo
->action_idr
, index
);
228 spin_unlock_bh(&idrinfo
->lock
);
233 int tcf_idr_search(struct tc_action_net
*tn
, struct tc_action
**a
, u32 index
)
235 struct tcf_idrinfo
*idrinfo
= tn
->idrinfo
;
236 struct tc_action
*p
= tcf_idr_lookup(index
, idrinfo
);
244 EXPORT_SYMBOL(tcf_idr_search
);
246 bool tcf_idr_check(struct tc_action_net
*tn
, u32 index
, struct tc_action
**a
,
249 struct tcf_idrinfo
*idrinfo
= tn
->idrinfo
;
250 struct tc_action
*p
= tcf_idr_lookup(index
, idrinfo
);
261 EXPORT_SYMBOL(tcf_idr_check
);
263 void tcf_idr_cleanup(struct tc_action
*a
, struct nlattr
*est
)
266 gen_kill_estimator(&a
->tcfa_rate_est
);
269 EXPORT_SYMBOL(tcf_idr_cleanup
);
271 int tcf_idr_create(struct tc_action_net
*tn
, u32 index
, struct nlattr
*est
,
272 struct tc_action
**a
, const struct tc_action_ops
*ops
,
273 int bind
, bool cpustats
)
275 struct tc_action
*p
= kzalloc(ops
->size
, GFP_KERNEL
);
276 struct tcf_idrinfo
*idrinfo
= tn
->idrinfo
;
277 struct idr
*idr
= &idrinfo
->action_idr
;
279 unsigned long idr_index
;
288 p
->cpu_bstats
= netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu
);
289 if (!p
->cpu_bstats
) {
294 p
->cpu_qstats
= alloc_percpu(struct gnet_stats_queue
);
295 if (!p
->cpu_qstats
) {
297 free_percpu(p
->cpu_bstats
);
301 spin_lock_init(&p
->tcfa_lock
);
302 /* user doesn't specify an index */
304 idr_preload(GFP_KERNEL
);
305 spin_lock_bh(&idrinfo
->lock
);
306 err
= idr_alloc_ext(idr
, NULL
, &idr_index
, 1, 0,
308 spin_unlock_bh(&idrinfo
->lock
);
312 free_percpu(p
->cpu_qstats
);
315 p
->tcfa_index
= idr_index
;
317 idr_preload(GFP_KERNEL
);
318 spin_lock_bh(&idrinfo
->lock
);
319 err
= idr_alloc_ext(idr
, NULL
, NULL
, index
, index
+ 1,
321 spin_unlock_bh(&idrinfo
->lock
);
325 p
->tcfa_index
= index
;
328 p
->tcfa_tm
.install
= jiffies
;
329 p
->tcfa_tm
.lastuse
= jiffies
;
330 p
->tcfa_tm
.firstuse
= 0;
332 err
= gen_new_estimator(&p
->tcfa_bstats
, p
->cpu_bstats
,
334 &p
->tcfa_lock
, NULL
, est
);
340 p
->idrinfo
= idrinfo
;
342 INIT_LIST_HEAD(&p
->list
);
346 EXPORT_SYMBOL(tcf_idr_create
);
348 void tcf_idr_insert(struct tc_action_net
*tn
, struct tc_action
*a
)
350 struct tcf_idrinfo
*idrinfo
= tn
->idrinfo
;
352 spin_lock_bh(&idrinfo
->lock
);
353 idr_replace_ext(&idrinfo
->action_idr
, a
, a
->tcfa_index
);
354 spin_unlock_bh(&idrinfo
->lock
);
356 EXPORT_SYMBOL(tcf_idr_insert
);
358 void tcf_idrinfo_destroy(const struct tc_action_ops
*ops
,
359 struct tcf_idrinfo
*idrinfo
)
361 struct idr
*idr
= &idrinfo
->action_idr
;
364 unsigned long id
= 1;
366 idr_for_each_entry_ext(idr
, p
, id
) {
367 ret
= __tcf_idr_release(p
, false, true);
368 if (ret
== ACT_P_DELETED
)
369 module_put(ops
->owner
);
373 idr_destroy(&idrinfo
->action_idr
);
375 EXPORT_SYMBOL(tcf_idrinfo_destroy
);
377 static LIST_HEAD(act_base
);
378 static DEFINE_RWLOCK(act_mod_lock
);
380 int tcf_register_action(struct tc_action_ops
*act
,
381 struct pernet_operations
*ops
)
383 struct tc_action_ops
*a
;
386 if (!act
->act
|| !act
->dump
|| !act
->init
|| !act
->walk
|| !act
->lookup
)
389 /* We have to register pernet ops before making the action ops visible,
390 * otherwise tcf_action_init_1() could get a partially initialized
393 ret
= register_pernet_subsys(ops
);
397 write_lock(&act_mod_lock
);
398 list_for_each_entry(a
, &act_base
, head
) {
399 if (act
->type
== a
->type
|| (strcmp(act
->kind
, a
->kind
) == 0)) {
400 write_unlock(&act_mod_lock
);
401 unregister_pernet_subsys(ops
);
405 list_add_tail(&act
->head
, &act_base
);
406 write_unlock(&act_mod_lock
);
410 EXPORT_SYMBOL(tcf_register_action
);
412 int tcf_unregister_action(struct tc_action_ops
*act
,
413 struct pernet_operations
*ops
)
415 struct tc_action_ops
*a
;
418 write_lock(&act_mod_lock
);
419 list_for_each_entry(a
, &act_base
, head
) {
421 list_del(&act
->head
);
426 write_unlock(&act_mod_lock
);
428 unregister_pernet_subsys(ops
);
431 EXPORT_SYMBOL(tcf_unregister_action
);
434 static struct tc_action_ops
*tc_lookup_action_n(char *kind
)
436 struct tc_action_ops
*a
, *res
= NULL
;
439 read_lock(&act_mod_lock
);
440 list_for_each_entry(a
, &act_base
, head
) {
441 if (strcmp(kind
, a
->kind
) == 0) {
442 if (try_module_get(a
->owner
))
447 read_unlock(&act_mod_lock
);
452 /* lookup by nlattr */
453 static struct tc_action_ops
*tc_lookup_action(struct nlattr
*kind
)
455 struct tc_action_ops
*a
, *res
= NULL
;
458 read_lock(&act_mod_lock
);
459 list_for_each_entry(a
, &act_base
, head
) {
460 if (nla_strcmp(kind
, a
->kind
) == 0) {
461 if (try_module_get(a
->owner
))
466 read_unlock(&act_mod_lock
);
471 /*TCA_ACT_MAX_PRIO is 32, there count upto 32 */
472 #define TCA_ACT_MAX_PRIO_MASK 0x1FF
473 int tcf_action_exec(struct sk_buff
*skb
, struct tc_action
**actions
,
474 int nr_actions
, struct tcf_result
*res
)
477 u32 jmp_ttl
= TCA_ACT_MAX_PRIO
; /*matches actions per filter */
481 if (skb_skip_tc_classify(skb
))
485 for (i
= 0; i
< nr_actions
; i
++) {
486 const struct tc_action
*a
= actions
[i
];
488 if (jmp_prgcnt
> 0) {
493 ret
= a
->ops
->act(skb
, a
, res
);
494 if (ret
== TC_ACT_REPEAT
)
495 goto repeat
; /* we need a ttl - JHS */
497 if (TC_ACT_EXT_CMP(ret
, TC_ACT_JUMP
)) {
498 jmp_prgcnt
= ret
& TCA_ACT_MAX_PRIO_MASK
;
499 if (!jmp_prgcnt
|| (jmp_prgcnt
> nr_actions
)) {
500 /* faulty opcode, stop pipeline */
505 goto restart_act_graph
;
506 else /* faulty graph, stop pipeline */
509 } else if (TC_ACT_EXT_CMP(ret
, TC_ACT_GOTO_CHAIN
)) {
510 tcf_action_goto_chain_exec(a
, res
);
513 if (ret
!= TC_ACT_PIPE
)
519 EXPORT_SYMBOL(tcf_action_exec
);
521 int tcf_action_destroy(struct list_head
*actions
, int bind
)
523 const struct tc_action_ops
*ops
;
524 struct tc_action
*a
, *tmp
;
527 list_for_each_entry_safe(a
, tmp
, actions
, list
) {
529 ret
= __tcf_idr_release(a
, bind
, true);
530 if (ret
== ACT_P_DELETED
)
531 module_put(ops
->owner
);
539 tcf_action_dump_old(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
541 return a
->ops
->dump(skb
, a
, bind
, ref
);
545 tcf_action_dump_1(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
548 unsigned char *b
= skb_tail_pointer(skb
);
551 if (nla_put_string(skb
, TCA_KIND
, a
->ops
->kind
))
552 goto nla_put_failure
;
553 if (tcf_action_copy_stats(skb
, a
, 0))
554 goto nla_put_failure
;
556 if (nla_put(skb
, TCA_ACT_COOKIE
, a
->act_cookie
->len
,
557 a
->act_cookie
->data
))
558 goto nla_put_failure
;
561 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
563 goto nla_put_failure
;
564 err
= tcf_action_dump_old(skb
, a
, bind
, ref
);
566 nla_nest_end(skb
, nest
);
574 EXPORT_SYMBOL(tcf_action_dump_1
);
576 int tcf_action_dump(struct sk_buff
*skb
, struct list_head
*actions
,
583 list_for_each_entry(a
, actions
, list
) {
584 nest
= nla_nest_start(skb
, a
->order
);
586 goto nla_put_failure
;
587 err
= tcf_action_dump_1(skb
, a
, bind
, ref
);
590 nla_nest_end(skb
, nest
);
598 nla_nest_cancel(skb
, nest
);
602 static struct tc_cookie
*nla_memdup_cookie(struct nlattr
**tb
)
604 struct tc_cookie
*c
= kzalloc(sizeof(*c
), GFP_KERNEL
);
608 c
->data
= nla_memdup(tb
[TCA_ACT_COOKIE
], GFP_KERNEL
);
613 c
->len
= nla_len(tb
[TCA_ACT_COOKIE
]);
618 struct tc_action
*tcf_action_init_1(struct net
*net
, struct tcf_proto
*tp
,
619 struct nlattr
*nla
, struct nlattr
*est
,
620 char *name
, int ovr
, int bind
)
623 struct tc_action_ops
*a_o
;
624 struct tc_cookie
*cookie
= NULL
;
625 char act_name
[IFNAMSIZ
];
626 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
631 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
, NULL
);
635 kind
= tb
[TCA_ACT_KIND
];
638 if (nla_strlcpy(act_name
, kind
, IFNAMSIZ
) >= IFNAMSIZ
)
640 if (tb
[TCA_ACT_COOKIE
]) {
641 int cklen
= nla_len(tb
[TCA_ACT_COOKIE
]);
643 if (cklen
> TC_COOKIE_MAX_SIZE
)
646 cookie
= nla_memdup_cookie(tb
);
654 if (strlcpy(act_name
, name
, IFNAMSIZ
) >= IFNAMSIZ
)
658 a_o
= tc_lookup_action_n(act_name
);
660 #ifdef CONFIG_MODULES
662 request_module("act_%s", act_name
);
665 a_o
= tc_lookup_action_n(act_name
);
667 /* We dropped the RTNL semaphore in order to
668 * perform the module load. So, even if we
669 * succeeded in loading the module we have to
670 * tell the caller to replay the request. We
671 * indicate this using -EAGAIN.
682 /* backward compatibility for policer */
684 err
= a_o
->init(net
, tb
[TCA_ACT_OPTIONS
], est
, &a
, ovr
, bind
);
686 err
= a_o
->init(net
, nla
, est
, &a
, ovr
, bind
);
690 if (name
== NULL
&& tb
[TCA_ACT_COOKIE
]) {
692 kfree(a
->act_cookie
->data
);
693 kfree(a
->act_cookie
);
695 a
->act_cookie
= cookie
;
698 /* module count goes up only when brand new policy is created
699 * if it exists and is only bound to in a_o->init() then
700 * ACT_P_CREATED is not returned (a zero is).
702 if (err
!= ACT_P_CREATED
)
703 module_put(a_o
->owner
);
705 if (TC_ACT_EXT_CMP(a
->tcfa_action
, TC_ACT_GOTO_CHAIN
)) {
706 err
= tcf_action_goto_chain_init(a
, tp
);
710 list_add_tail(&a
->list
, &actions
);
711 tcf_action_destroy(&actions
, bind
);
719 module_put(a_o
->owner
);
728 static void cleanup_a(struct list_head
*actions
, int ovr
)
735 list_for_each_entry(a
, actions
, list
)
739 int tcf_action_init(struct net
*net
, struct tcf_proto
*tp
, struct nlattr
*nla
,
740 struct nlattr
*est
, char *name
, int ovr
, int bind
,
741 struct list_head
*actions
)
743 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
744 struct tc_action
*act
;
748 err
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
, NULL
);
752 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
753 act
= tcf_action_init_1(net
, tp
, tb
[i
], est
, name
, ovr
, bind
);
761 list_add_tail(&act
->list
, actions
);
764 /* Remove the temp refcnt which was necessary to protect against
765 * destroying an existing action which was being replaced
767 cleanup_a(actions
, ovr
);
771 tcf_action_destroy(actions
, bind
);
775 int tcf_action_copy_stats(struct sk_buff
*skb
, struct tc_action
*p
,
784 /* compat_mode being true specifies a call that is supposed
785 * to add additional backward compatibility statistic TLVs.
788 if (p
->type
== TCA_OLD_COMPAT
)
789 err
= gnet_stats_start_copy_compat(skb
, 0,
797 err
= gnet_stats_start_copy(skb
, TCA_ACT_STATS
,
798 &p
->tcfa_lock
, &d
, TCA_ACT_PAD
);
803 if (gnet_stats_copy_basic(NULL
, &d
, p
->cpu_bstats
, &p
->tcfa_bstats
) < 0 ||
804 gnet_stats_copy_rate_est(&d
, &p
->tcfa_rate_est
) < 0 ||
805 gnet_stats_copy_queue(&d
, p
->cpu_qstats
,
807 p
->tcfa_qstats
.qlen
) < 0)
810 if (gnet_stats_finish_copy(&d
) < 0)
819 static int tca_get_fill(struct sk_buff
*skb
, struct list_head
*actions
,
820 u32 portid
, u32 seq
, u16 flags
, int event
, int bind
,
824 struct nlmsghdr
*nlh
;
825 unsigned char *b
= skb_tail_pointer(skb
);
828 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*t
), flags
);
832 t
->tca_family
= AF_UNSPEC
;
836 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
840 if (tcf_action_dump(skb
, actions
, bind
, ref
) < 0)
843 nla_nest_end(skb
, nest
);
845 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
854 tcf_get_notify(struct net
*net
, u32 portid
, struct nlmsghdr
*n
,
855 struct list_head
*actions
, int event
)
859 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
862 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, 0, event
,
868 return rtnl_unicast(skb
, net
, portid
);
871 static struct tc_action
*tcf_action_get_1(struct net
*net
, struct nlattr
*nla
,
872 struct nlmsghdr
*n
, u32 portid
)
874 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
875 const struct tc_action_ops
*ops
;
880 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
, NULL
);
885 if (tb
[TCA_ACT_INDEX
] == NULL
||
886 nla_len(tb
[TCA_ACT_INDEX
]) < sizeof(index
))
888 index
= nla_get_u32(tb
[TCA_ACT_INDEX
]);
891 ops
= tc_lookup_action(tb
[TCA_ACT_KIND
]);
892 if (!ops
) /* could happen in batch of actions */
895 if (ops
->lookup(net
, &a
, index
) == 0)
898 module_put(ops
->owner
);
902 module_put(ops
->owner
);
907 static int tca_action_flush(struct net
*net
, struct nlattr
*nla
,
908 struct nlmsghdr
*n
, u32 portid
)
912 struct nlmsghdr
*nlh
;
914 struct netlink_callback dcb
;
916 struct nlattr
*tb
[TCA_ACT_MAX
+ 1];
917 const struct tc_action_ops
*ops
;
921 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
923 pr_debug("tca_action_flush: failed skb alloc\n");
927 b
= skb_tail_pointer(skb
);
929 err
= nla_parse_nested(tb
, TCA_ACT_MAX
, nla
, NULL
, NULL
);
934 kind
= tb
[TCA_ACT_KIND
];
935 ops
= tc_lookup_action(kind
);
936 if (!ops
) /*some idjot trying to flush unknown action */
939 nlh
= nlmsg_put(skb
, portid
, n
->nlmsg_seq
, RTM_DELACTION
,
944 t
->tca_family
= AF_UNSPEC
;
948 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
952 err
= ops
->walk(net
, skb
, &dcb
, RTM_DELACTION
, ops
);
956 nla_nest_end(skb
, nest
);
958 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
959 nlh
->nlmsg_flags
|= NLM_F_ROOT
;
960 module_put(ops
->owner
);
961 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
962 n
->nlmsg_flags
& NLM_F_ECHO
);
969 module_put(ops
->owner
);
976 tcf_del_notify(struct net
*net
, struct nlmsghdr
*n
, struct list_head
*actions
,
982 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
986 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, 0, RTM_DELACTION
,
992 /* now do the delete */
993 ret
= tcf_action_destroy(actions
, 0);
999 ret
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
1000 n
->nlmsg_flags
& NLM_F_ECHO
);
1007 tca_action_gd(struct net
*net
, struct nlattr
*nla
, struct nlmsghdr
*n
,
1008 u32 portid
, int event
)
1011 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
1012 struct tc_action
*act
;
1015 ret
= nla_parse_nested(tb
, TCA_ACT_MAX_PRIO
, nla
, NULL
, NULL
);
1019 if (event
== RTM_DELACTION
&& n
->nlmsg_flags
& NLM_F_ROOT
) {
1021 return tca_action_flush(net
, tb
[1], n
, portid
);
1026 for (i
= 1; i
<= TCA_ACT_MAX_PRIO
&& tb
[i
]; i
++) {
1027 act
= tcf_action_get_1(net
, tb
[i
], n
, portid
);
1033 list_add_tail(&act
->list
, &actions
);
1036 if (event
== RTM_GETACTION
)
1037 ret
= tcf_get_notify(net
, portid
, n
, &actions
, event
);
1039 ret
= tcf_del_notify(net
, n
, &actions
, portid
);
1045 if (event
!= RTM_GETACTION
)
1046 tcf_action_destroy(&actions
, 0);
1051 tcf_add_notify(struct net
*net
, struct nlmsghdr
*n
, struct list_head
*actions
,
1054 struct sk_buff
*skb
;
1057 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
1061 if (tca_get_fill(skb
, actions
, portid
, n
->nlmsg_seq
, n
->nlmsg_flags
,
1062 RTM_NEWACTION
, 0, 0) <= 0) {
1067 err
= rtnetlink_send(skb
, net
, portid
, RTNLGRP_TC
,
1068 n
->nlmsg_flags
& NLM_F_ECHO
);
1074 static int tcf_action_add(struct net
*net
, struct nlattr
*nla
,
1075 struct nlmsghdr
*n
, u32 portid
, int ovr
)
1080 ret
= tcf_action_init(net
, NULL
, nla
, NULL
, NULL
, ovr
, 0, &actions
);
1084 return tcf_add_notify(net
, n
, &actions
, portid
);
1087 static u32 tcaa_root_flags_allowed
= TCA_FLAG_LARGE_DUMP_ON
;
1088 static const struct nla_policy tcaa_policy
[TCA_ROOT_MAX
+ 1] = {
1089 [TCA_ROOT_FLAGS
] = { .type
= NLA_BITFIELD32
,
1090 .validation_data
= &tcaa_root_flags_allowed
},
1091 [TCA_ROOT_TIME_DELTA
] = { .type
= NLA_U32
},
1094 static int tc_ctl_action(struct sk_buff
*skb
, struct nlmsghdr
*n
,
1095 struct netlink_ext_ack
*extack
)
1097 struct net
*net
= sock_net(skb
->sk
);
1098 struct nlattr
*tca
[TCA_ROOT_MAX
+ 1];
1099 u32 portid
= skb
? NETLINK_CB(skb
).portid
: 0;
1100 int ret
= 0, ovr
= 0;
1102 if ((n
->nlmsg_type
!= RTM_GETACTION
) &&
1103 !netlink_capable(skb
, CAP_NET_ADMIN
))
1106 ret
= nlmsg_parse(n
, sizeof(struct tcamsg
), tca
, TCA_ROOT_MAX
, NULL
,
1111 if (tca
[TCA_ACT_TAB
] == NULL
) {
1112 pr_notice("tc_ctl_action: received NO action attribs\n");
1116 /* n->nlmsg_flags & NLM_F_CREATE */
1117 switch (n
->nlmsg_type
) {
1119 /* we are going to assume all other flags
1120 * imply create only if it doesn't exist
1121 * Note that CREATE | EXCL implies that
1122 * but since we want avoid ambiguity (eg when flags
1123 * is zero) then just set this
1125 if (n
->nlmsg_flags
& NLM_F_REPLACE
)
1128 ret
= tcf_action_add(net
, tca
[TCA_ACT_TAB
], n
, portid
, ovr
);
1133 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
1134 portid
, RTM_DELACTION
);
1137 ret
= tca_action_gd(net
, tca
[TCA_ACT_TAB
], n
,
1138 portid
, RTM_GETACTION
);
1147 static struct nlattr
*find_dump_kind(struct nlattr
**nla
)
1149 struct nlattr
*tb1
, *tb2
[TCA_ACT_MAX
+ 1];
1150 struct nlattr
*tb
[TCA_ACT_MAX_PRIO
+ 1];
1151 struct nlattr
*kind
;
1153 tb1
= nla
[TCA_ACT_TAB
];
1157 if (nla_parse(tb
, TCA_ACT_MAX_PRIO
, nla_data(tb1
),
1158 NLMSG_ALIGN(nla_len(tb1
)), NULL
, NULL
) < 0)
1163 if (nla_parse_nested(tb2
, TCA_ACT_MAX
, tb
[1], NULL
, NULL
) < 0)
1165 kind
= tb2
[TCA_ACT_KIND
];
1170 static int tc_dump_action(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1172 struct net
*net
= sock_net(skb
->sk
);
1173 struct nlmsghdr
*nlh
;
1174 unsigned char *b
= skb_tail_pointer(skb
);
1175 struct nlattr
*nest
;
1176 struct tc_action_ops
*a_o
;
1178 struct tcamsg
*t
= (struct tcamsg
*) nlmsg_data(cb
->nlh
);
1179 struct nlattr
*tb
[TCA_ROOT_MAX
+ 1];
1180 struct nlattr
*count_attr
= NULL
;
1181 unsigned long jiffy_since
= 0;
1182 struct nlattr
*kind
= NULL
;
1183 struct nla_bitfield32 bf
;
1184 u32 msecs_since
= 0;
1187 ret
= nlmsg_parse(cb
->nlh
, sizeof(struct tcamsg
), tb
, TCA_ROOT_MAX
,
1192 kind
= find_dump_kind(tb
);
1194 pr_info("tc_dump_action: action bad kind\n");
1198 a_o
= tc_lookup_action(kind
);
1203 if (tb
[TCA_ROOT_FLAGS
]) {
1204 bf
= nla_get_bitfield32(tb
[TCA_ROOT_FLAGS
]);
1205 cb
->args
[2] = bf
.value
;
1208 if (tb
[TCA_ROOT_TIME_DELTA
]) {
1209 msecs_since
= nla_get_u32(tb
[TCA_ROOT_TIME_DELTA
]);
1212 nlh
= nlmsg_put(skb
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
1213 cb
->nlh
->nlmsg_type
, sizeof(*t
), 0);
1215 goto out_module_put
;
1218 jiffy_since
= jiffies
- msecs_to_jiffies(msecs_since
);
1220 t
= nlmsg_data(nlh
);
1221 t
->tca_family
= AF_UNSPEC
;
1224 cb
->args
[3] = jiffy_since
;
1225 count_attr
= nla_reserve(skb
, TCA_ROOT_COUNT
, sizeof(u32
));
1227 goto out_module_put
;
1229 nest
= nla_nest_start(skb
, TCA_ACT_TAB
);
1231 goto out_module_put
;
1233 ret
= a_o
->walk(net
, skb
, cb
, RTM_GETACTION
, a_o
);
1235 goto out_module_put
;
1238 nla_nest_end(skb
, nest
);
1240 act_count
= cb
->args
[1];
1241 memcpy(nla_data(count_attr
), &act_count
, sizeof(u32
));
1246 nlh
->nlmsg_len
= skb_tail_pointer(skb
) - b
;
1247 if (NETLINK_CB(cb
->skb
).portid
&& ret
)
1248 nlh
->nlmsg_flags
|= NLM_F_MULTI
;
1249 module_put(a_o
->owner
);
1253 module_put(a_o
->owner
);
1258 struct tcf_action_net
{
1259 struct rhashtable egdev_ht
;
1262 static unsigned int tcf_action_net_id
;
1264 struct tcf_action_egdev_cb
{
1265 struct list_head list
;
1270 struct tcf_action_egdev
{
1271 struct rhash_head ht_node
;
1272 const struct net_device
*dev
;
1273 unsigned int refcnt
;
1274 struct list_head cb_list
;
1277 static const struct rhashtable_params tcf_action_egdev_ht_params
= {
1278 .key_offset
= offsetof(struct tcf_action_egdev
, dev
),
1279 .head_offset
= offsetof(struct tcf_action_egdev
, ht_node
),
1280 .key_len
= sizeof(const struct net_device
*),
1283 static struct tcf_action_egdev
*
1284 tcf_action_egdev_lookup(const struct net_device
*dev
)
1286 struct net
*net
= dev_net(dev
);
1287 struct tcf_action_net
*tan
= net_generic(net
, tcf_action_net_id
);
1289 return rhashtable_lookup_fast(&tan
->egdev_ht
, &dev
,
1290 tcf_action_egdev_ht_params
);
1293 static struct tcf_action_egdev
*
1294 tcf_action_egdev_get(const struct net_device
*dev
)
1296 struct tcf_action_egdev
*egdev
;
1297 struct tcf_action_net
*tan
;
1299 egdev
= tcf_action_egdev_lookup(dev
);
1303 egdev
= kzalloc(sizeof(*egdev
), GFP_KERNEL
);
1306 INIT_LIST_HEAD(&egdev
->cb_list
);
1308 tan
= net_generic(dev_net(dev
), tcf_action_net_id
);
1309 rhashtable_insert_fast(&tan
->egdev_ht
, &egdev
->ht_node
,
1310 tcf_action_egdev_ht_params
);
1317 static void tcf_action_egdev_put(struct tcf_action_egdev
*egdev
)
1319 struct tcf_action_net
*tan
;
1321 if (--egdev
->refcnt
)
1323 tan
= net_generic(dev_net(egdev
->dev
), tcf_action_net_id
);
1324 rhashtable_remove_fast(&tan
->egdev_ht
, &egdev
->ht_node
,
1325 tcf_action_egdev_ht_params
);
1329 static struct tcf_action_egdev_cb
*
1330 tcf_action_egdev_cb_lookup(struct tcf_action_egdev
*egdev
,
1331 tc_setup_cb_t
*cb
, void *cb_priv
)
1333 struct tcf_action_egdev_cb
*egdev_cb
;
1335 list_for_each_entry(egdev_cb
, &egdev
->cb_list
, list
)
1336 if (egdev_cb
->cb
== cb
&& egdev_cb
->cb_priv
== cb_priv
)
1341 static int tcf_action_egdev_cb_call(struct tcf_action_egdev
*egdev
,
1342 enum tc_setup_type type
,
1343 void *type_data
, bool err_stop
)
1345 struct tcf_action_egdev_cb
*egdev_cb
;
1349 list_for_each_entry(egdev_cb
, &egdev
->cb_list
, list
) {
1350 err
= egdev_cb
->cb(type
, type_data
, egdev_cb
->cb_priv
);
1361 static int tcf_action_egdev_cb_add(struct tcf_action_egdev
*egdev
,
1362 tc_setup_cb_t
*cb
, void *cb_priv
)
1364 struct tcf_action_egdev_cb
*egdev_cb
;
1366 egdev_cb
= tcf_action_egdev_cb_lookup(egdev
, cb
, cb_priv
);
1367 if (WARN_ON(egdev_cb
))
1369 egdev_cb
= kzalloc(sizeof(*egdev_cb
), GFP_KERNEL
);
1373 egdev_cb
->cb_priv
= cb_priv
;
1374 list_add(&egdev_cb
->list
, &egdev
->cb_list
);
1378 static void tcf_action_egdev_cb_del(struct tcf_action_egdev
*egdev
,
1379 tc_setup_cb_t
*cb
, void *cb_priv
)
1381 struct tcf_action_egdev_cb
*egdev_cb
;
1383 egdev_cb
= tcf_action_egdev_cb_lookup(egdev
, cb
, cb_priv
);
1384 if (WARN_ON(!egdev_cb
))
1386 list_del(&egdev_cb
->list
);
1390 static int __tc_setup_cb_egdev_register(const struct net_device
*dev
,
1391 tc_setup_cb_t
*cb
, void *cb_priv
)
1393 struct tcf_action_egdev
*egdev
= tcf_action_egdev_get(dev
);
1398 err
= tcf_action_egdev_cb_add(egdev
, cb
, cb_priv
);
1404 tcf_action_egdev_put(egdev
);
1407 int tc_setup_cb_egdev_register(const struct net_device
*dev
,
1408 tc_setup_cb_t
*cb
, void *cb_priv
)
1413 err
= __tc_setup_cb_egdev_register(dev
, cb
, cb_priv
);
1417 EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_register
);
1419 static void __tc_setup_cb_egdev_unregister(const struct net_device
*dev
,
1420 tc_setup_cb_t
*cb
, void *cb_priv
)
1422 struct tcf_action_egdev
*egdev
= tcf_action_egdev_lookup(dev
);
1424 if (WARN_ON(!egdev
))
1426 tcf_action_egdev_cb_del(egdev
, cb
, cb_priv
);
1427 tcf_action_egdev_put(egdev
);
1429 void tc_setup_cb_egdev_unregister(const struct net_device
*dev
,
1430 tc_setup_cb_t
*cb
, void *cb_priv
)
1433 __tc_setup_cb_egdev_unregister(dev
, cb
, cb_priv
);
1436 EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_unregister
);
1438 int tc_setup_cb_egdev_call(const struct net_device
*dev
,
1439 enum tc_setup_type type
, void *type_data
,
1442 struct tcf_action_egdev
*egdev
= tcf_action_egdev_lookup(dev
);
1446 return tcf_action_egdev_cb_call(egdev
, type
, type_data
, err_stop
);
1448 EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_call
);
1450 static __net_init
int tcf_action_net_init(struct net
*net
)
1452 struct tcf_action_net
*tan
= net_generic(net
, tcf_action_net_id
);
1454 return rhashtable_init(&tan
->egdev_ht
, &tcf_action_egdev_ht_params
);
1457 static void __net_exit
tcf_action_net_exit(struct net
*net
)
1459 struct tcf_action_net
*tan
= net_generic(net
, tcf_action_net_id
);
1461 rhashtable_destroy(&tan
->egdev_ht
);
1464 static struct pernet_operations tcf_action_net_ops
= {
1465 .init
= tcf_action_net_init
,
1466 .exit
= tcf_action_net_exit
,
1467 .id
= &tcf_action_net_id
,
1468 .size
= sizeof(struct tcf_action_net
),
1471 static int __init
tc_action_init(void)
1475 err
= register_pernet_subsys(&tcf_action_net_ops
);
1479 rtnl_register(PF_UNSPEC
, RTM_NEWACTION
, tc_ctl_action
, NULL
, 0);
1480 rtnl_register(PF_UNSPEC
, RTM_DELACTION
, tc_ctl_action
, NULL
, 0);
1481 rtnl_register(PF_UNSPEC
, RTM_GETACTION
, tc_ctl_action
, tc_dump_action
,
1487 subsys_initcall(tc_action_init
);