1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * net/sched/act_gact.c Generic actions
5 * copyright Jamal Hadi Salim (2002-4)
8 #include <linux/types.h>
9 #include <linux/kernel.h>
10 #include <linux/string.h>
11 #include <linux/errno.h>
12 #include <linux/skbuff.h>
13 #include <linux/rtnetlink.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <net/netlink.h>
17 #include <net/pkt_sched.h>
18 #include <net/pkt_cls.h>
19 #include <linux/tc_act/tc_gact.h>
20 #include <net/tc_act/tc_gact.h>
22 static unsigned int gact_net_id
;
23 static struct tc_action_ops act_gact_ops
;
25 #ifdef CONFIG_GACT_PROB
26 static int gact_net_rand(struct tcf_gact
*gact
)
28 smp_rmb(); /* coupled with smp_wmb() in tcf_gact_init() */
29 if (prandom_u32() % gact
->tcfg_pval
)
30 return gact
->tcf_action
;
31 return gact
->tcfg_paction
;
34 static int gact_determ(struct tcf_gact
*gact
)
36 u32 pack
= atomic_inc_return(&gact
->packets
);
38 smp_rmb(); /* coupled with smp_wmb() in tcf_gact_init() */
39 if (pack
% gact
->tcfg_pval
)
40 return gact
->tcf_action
;
41 return gact
->tcfg_paction
;
44 typedef int (*g_rand
)(struct tcf_gact
*gact
);
45 static g_rand gact_rand
[MAX_RAND
] = { NULL
, gact_net_rand
, gact_determ
};
46 #endif /* CONFIG_GACT_PROB */
48 static const struct nla_policy gact_policy
[TCA_GACT_MAX
+ 1] = {
49 [TCA_GACT_PARMS
] = { .len
= sizeof(struct tc_gact
) },
50 [TCA_GACT_PROB
] = { .len
= sizeof(struct tc_gact_p
) },
53 static int tcf_gact_init(struct net
*net
, struct nlattr
*nla
,
54 struct nlattr
*est
, struct tc_action
**a
,
55 int ovr
, int bind
, bool rtnl_held
,
56 struct tcf_proto
*tp
, struct netlink_ext_ack
*extack
)
58 struct tc_action_net
*tn
= net_generic(net
, gact_net_id
);
59 struct nlattr
*tb
[TCA_GACT_MAX
+ 1];
60 struct tcf_chain
*goto_ch
= NULL
;
62 struct tcf_gact
*gact
;
65 #ifdef CONFIG_GACT_PROB
66 struct tc_gact_p
*p_parm
= NULL
;
72 err
= nla_parse_nested_deprecated(tb
, TCA_GACT_MAX
, nla
, gact_policy
,
77 if (tb
[TCA_GACT_PARMS
] == NULL
)
79 parm
= nla_data(tb
[TCA_GACT_PARMS
]);
81 #ifndef CONFIG_GACT_PROB
82 if (tb
[TCA_GACT_PROB
] != NULL
)
85 if (tb
[TCA_GACT_PROB
]) {
86 p_parm
= nla_data(tb
[TCA_GACT_PROB
]);
87 if (p_parm
->ptype
>= MAX_RAND
)
89 if (TC_ACT_EXT_CMP(p_parm
->paction
, TC_ACT_GOTO_CHAIN
)) {
90 NL_SET_ERR_MSG(extack
,
91 "goto chain not allowed on fallback");
97 err
= tcf_idr_check_alloc(tn
, &parm
->index
, a
, bind
);
99 ret
= tcf_idr_create(tn
, parm
->index
, est
, a
,
100 &act_gact_ops
, bind
, true);
102 tcf_idr_cleanup(tn
, parm
->index
);
106 } else if (err
> 0) {
107 if (bind
)/* dont override defaults */
110 tcf_idr_release(*a
, bind
);
117 err
= tcf_action_check_ctrlact(parm
->action
, tp
, &goto_ch
, extack
);
122 spin_lock_bh(&gact
->tcf_lock
);
123 goto_ch
= tcf_action_set_ctrlact(*a
, parm
->action
, goto_ch
);
124 #ifdef CONFIG_GACT_PROB
126 gact
->tcfg_paction
= p_parm
->paction
;
127 gact
->tcfg_pval
= max_t(u16
, 1, p_parm
->pval
);
128 /* Make sure tcfg_pval is written before tcfg_ptype
129 * coupled with smp_rmb() in gact_net_rand() & gact_determ()
132 gact
->tcfg_ptype
= p_parm
->ptype
;
135 spin_unlock_bh(&gact
->tcf_lock
);
138 tcf_chain_put_by_act(goto_ch
);
140 if (ret
== ACT_P_CREATED
)
141 tcf_idr_insert(tn
, *a
);
144 tcf_idr_release(*a
, bind
);
148 static int tcf_gact_act(struct sk_buff
*skb
, const struct tc_action
*a
,
149 struct tcf_result
*res
)
151 struct tcf_gact
*gact
= to_gact(a
);
152 int action
= READ_ONCE(gact
->tcf_action
);
154 #ifdef CONFIG_GACT_PROB
156 u32 ptype
= READ_ONCE(gact
->tcfg_ptype
);
159 action
= gact_rand
[ptype
](gact
);
162 bstats_cpu_update(this_cpu_ptr(gact
->common
.cpu_bstats
), skb
);
163 if (action
== TC_ACT_SHOT
)
164 qstats_drop_inc(this_cpu_ptr(gact
->common
.cpu_qstats
));
166 tcf_lastuse_update(&gact
->tcf_tm
);
171 static void tcf_gact_stats_update(struct tc_action
*a
, u64 bytes
, u32 packets
,
172 u64 lastuse
, bool hw
)
174 struct tcf_gact
*gact
= to_gact(a
);
175 int action
= READ_ONCE(gact
->tcf_action
);
176 struct tcf_t
*tm
= &gact
->tcf_tm
;
178 _bstats_cpu_update(this_cpu_ptr(gact
->common
.cpu_bstats
), bytes
,
180 if (action
== TC_ACT_SHOT
)
181 this_cpu_ptr(gact
->common
.cpu_qstats
)->drops
+= packets
;
184 _bstats_cpu_update(this_cpu_ptr(gact
->common
.cpu_bstats_hw
),
187 tm
->lastuse
= max_t(u64
, tm
->lastuse
, lastuse
);
190 static int tcf_gact_dump(struct sk_buff
*skb
, struct tc_action
*a
,
193 unsigned char *b
= skb_tail_pointer(skb
);
194 struct tcf_gact
*gact
= to_gact(a
);
195 struct tc_gact opt
= {
196 .index
= gact
->tcf_index
,
197 .refcnt
= refcount_read(&gact
->tcf_refcnt
) - ref
,
198 .bindcnt
= atomic_read(&gact
->tcf_bindcnt
) - bind
,
202 spin_lock_bh(&gact
->tcf_lock
);
203 opt
.action
= gact
->tcf_action
;
204 if (nla_put(skb
, TCA_GACT_PARMS
, sizeof(opt
), &opt
))
205 goto nla_put_failure
;
206 #ifdef CONFIG_GACT_PROB
207 if (gact
->tcfg_ptype
) {
208 struct tc_gact_p p_opt
= {
209 .paction
= gact
->tcfg_paction
,
210 .pval
= gact
->tcfg_pval
,
211 .ptype
= gact
->tcfg_ptype
,
214 if (nla_put(skb
, TCA_GACT_PROB
, sizeof(p_opt
), &p_opt
))
215 goto nla_put_failure
;
218 tcf_tm_dump(&t
, &gact
->tcf_tm
);
219 if (nla_put_64bit(skb
, TCA_GACT_TM
, sizeof(t
), &t
, TCA_GACT_PAD
))
220 goto nla_put_failure
;
221 spin_unlock_bh(&gact
->tcf_lock
);
226 spin_unlock_bh(&gact
->tcf_lock
);
231 static int tcf_gact_walker(struct net
*net
, struct sk_buff
*skb
,
232 struct netlink_callback
*cb
, int type
,
233 const struct tc_action_ops
*ops
,
234 struct netlink_ext_ack
*extack
)
236 struct tc_action_net
*tn
= net_generic(net
, gact_net_id
);
238 return tcf_generic_walker(tn
, skb
, cb
, type
, ops
, extack
);
241 static int tcf_gact_search(struct net
*net
, struct tc_action
**a
, u32 index
)
243 struct tc_action_net
*tn
= net_generic(net
, gact_net_id
);
245 return tcf_idr_search(tn
, a
, index
);
248 static size_t tcf_gact_get_fill_size(const struct tc_action
*act
)
250 size_t sz
= nla_total_size(sizeof(struct tc_gact
)); /* TCA_GACT_PARMS */
252 #ifdef CONFIG_GACT_PROB
253 if (to_gact(act
)->tcfg_ptype
)
255 sz
+= nla_total_size(sizeof(struct tc_gact_p
));
261 static struct tc_action_ops act_gact_ops
= {
264 .owner
= THIS_MODULE
,
266 .stats_update
= tcf_gact_stats_update
,
267 .dump
= tcf_gact_dump
,
268 .init
= tcf_gact_init
,
269 .walk
= tcf_gact_walker
,
270 .lookup
= tcf_gact_search
,
271 .get_fill_size
= tcf_gact_get_fill_size
,
272 .size
= sizeof(struct tcf_gact
),
275 static __net_init
int gact_init_net(struct net
*net
)
277 struct tc_action_net
*tn
= net_generic(net
, gact_net_id
);
279 return tc_action_net_init(tn
, &act_gact_ops
);
282 static void __net_exit
gact_exit_net(struct list_head
*net_list
)
284 tc_action_net_exit(net_list
, gact_net_id
);
287 static struct pernet_operations gact_net_ops
= {
288 .init
= gact_init_net
,
289 .exit_batch
= gact_exit_net
,
291 .size
= sizeof(struct tc_action_net
),
294 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
295 MODULE_DESCRIPTION("Generic Classifier actions");
296 MODULE_LICENSE("GPL");
298 static int __init
gact_init_module(void)
300 #ifdef CONFIG_GACT_PROB
301 pr_info("GACT probability on\n");
303 pr_info("GACT probability NOT on\n");
306 return tcf_register_action(&act_gact_ops
, &gact_net_ops
);
309 static void __exit
gact_cleanup_module(void)
311 tcf_unregister_action(&act_gact_ops
, &gact_net_ops
);
314 module_init(gact_init_module
);
315 module_exit(gact_cleanup_module
);