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
;
66 #ifdef CONFIG_GACT_PROB
67 struct tc_gact_p
*p_parm
= NULL
;
73 err
= nla_parse_nested_deprecated(tb
, TCA_GACT_MAX
, nla
, gact_policy
,
78 if (tb
[TCA_GACT_PARMS
] == NULL
)
80 parm
= nla_data(tb
[TCA_GACT_PARMS
]);
83 #ifndef CONFIG_GACT_PROB
84 if (tb
[TCA_GACT_PROB
] != NULL
)
87 if (tb
[TCA_GACT_PROB
]) {
88 p_parm
= nla_data(tb
[TCA_GACT_PROB
]);
89 if (p_parm
->ptype
>= MAX_RAND
)
91 if (TC_ACT_EXT_CMP(p_parm
->paction
, TC_ACT_GOTO_CHAIN
)) {
92 NL_SET_ERR_MSG(extack
,
93 "goto chain not allowed on fallback");
99 err
= tcf_idr_check_alloc(tn
, &index
, a
, bind
);
101 ret
= tcf_idr_create(tn
, index
, est
, a
,
102 &act_gact_ops
, bind
, true);
104 tcf_idr_cleanup(tn
, index
);
108 } else if (err
> 0) {
109 if (bind
)/* dont override defaults */
112 tcf_idr_release(*a
, bind
);
119 err
= tcf_action_check_ctrlact(parm
->action
, tp
, &goto_ch
, extack
);
124 spin_lock_bh(&gact
->tcf_lock
);
125 goto_ch
= tcf_action_set_ctrlact(*a
, parm
->action
, goto_ch
);
126 #ifdef CONFIG_GACT_PROB
128 gact
->tcfg_paction
= p_parm
->paction
;
129 gact
->tcfg_pval
= max_t(u16
, 1, p_parm
->pval
);
130 /* Make sure tcfg_pval is written before tcfg_ptype
131 * coupled with smp_rmb() in gact_net_rand() & gact_determ()
134 gact
->tcfg_ptype
= p_parm
->ptype
;
137 spin_unlock_bh(&gact
->tcf_lock
);
140 tcf_chain_put_by_act(goto_ch
);
142 if (ret
== ACT_P_CREATED
)
143 tcf_idr_insert(tn
, *a
);
146 tcf_idr_release(*a
, bind
);
150 static int tcf_gact_act(struct sk_buff
*skb
, const struct tc_action
*a
,
151 struct tcf_result
*res
)
153 struct tcf_gact
*gact
= to_gact(a
);
154 int action
= READ_ONCE(gact
->tcf_action
);
156 #ifdef CONFIG_GACT_PROB
158 u32 ptype
= READ_ONCE(gact
->tcfg_ptype
);
161 action
= gact_rand
[ptype
](gact
);
164 bstats_cpu_update(this_cpu_ptr(gact
->common
.cpu_bstats
), skb
);
165 if (action
== TC_ACT_SHOT
)
166 qstats_drop_inc(this_cpu_ptr(gact
->common
.cpu_qstats
));
168 tcf_lastuse_update(&gact
->tcf_tm
);
173 static void tcf_gact_stats_update(struct tc_action
*a
, u64 bytes
, u32 packets
,
174 u64 lastuse
, bool hw
)
176 struct tcf_gact
*gact
= to_gact(a
);
177 int action
= READ_ONCE(gact
->tcf_action
);
178 struct tcf_t
*tm
= &gact
->tcf_tm
;
180 _bstats_cpu_update(this_cpu_ptr(gact
->common
.cpu_bstats
), bytes
,
182 if (action
== TC_ACT_SHOT
)
183 this_cpu_ptr(gact
->common
.cpu_qstats
)->drops
+= packets
;
186 _bstats_cpu_update(this_cpu_ptr(gact
->common
.cpu_bstats_hw
),
189 tm
->lastuse
= max_t(u64
, tm
->lastuse
, lastuse
);
192 static int tcf_gact_dump(struct sk_buff
*skb
, struct tc_action
*a
,
195 unsigned char *b
= skb_tail_pointer(skb
);
196 struct tcf_gact
*gact
= to_gact(a
);
197 struct tc_gact opt
= {
198 .index
= gact
->tcf_index
,
199 .refcnt
= refcount_read(&gact
->tcf_refcnt
) - ref
,
200 .bindcnt
= atomic_read(&gact
->tcf_bindcnt
) - bind
,
204 spin_lock_bh(&gact
->tcf_lock
);
205 opt
.action
= gact
->tcf_action
;
206 if (nla_put(skb
, TCA_GACT_PARMS
, sizeof(opt
), &opt
))
207 goto nla_put_failure
;
208 #ifdef CONFIG_GACT_PROB
209 if (gact
->tcfg_ptype
) {
210 struct tc_gact_p p_opt
= {
211 .paction
= gact
->tcfg_paction
,
212 .pval
= gact
->tcfg_pval
,
213 .ptype
= gact
->tcfg_ptype
,
216 if (nla_put(skb
, TCA_GACT_PROB
, sizeof(p_opt
), &p_opt
))
217 goto nla_put_failure
;
220 tcf_tm_dump(&t
, &gact
->tcf_tm
);
221 if (nla_put_64bit(skb
, TCA_GACT_TM
, sizeof(t
), &t
, TCA_GACT_PAD
))
222 goto nla_put_failure
;
223 spin_unlock_bh(&gact
->tcf_lock
);
228 spin_unlock_bh(&gact
->tcf_lock
);
233 static int tcf_gact_walker(struct net
*net
, struct sk_buff
*skb
,
234 struct netlink_callback
*cb
, int type
,
235 const struct tc_action_ops
*ops
,
236 struct netlink_ext_ack
*extack
)
238 struct tc_action_net
*tn
= net_generic(net
, gact_net_id
);
240 return tcf_generic_walker(tn
, skb
, cb
, type
, ops
, extack
);
243 static int tcf_gact_search(struct net
*net
, struct tc_action
**a
, u32 index
)
245 struct tc_action_net
*tn
= net_generic(net
, gact_net_id
);
247 return tcf_idr_search(tn
, a
, index
);
250 static size_t tcf_gact_get_fill_size(const struct tc_action
*act
)
252 size_t sz
= nla_total_size(sizeof(struct tc_gact
)); /* TCA_GACT_PARMS */
254 #ifdef CONFIG_GACT_PROB
255 if (to_gact(act
)->tcfg_ptype
)
257 sz
+= nla_total_size(sizeof(struct tc_gact_p
));
263 static struct tc_action_ops act_gact_ops
= {
266 .owner
= THIS_MODULE
,
268 .stats_update
= tcf_gact_stats_update
,
269 .dump
= tcf_gact_dump
,
270 .init
= tcf_gact_init
,
271 .walk
= tcf_gact_walker
,
272 .lookup
= tcf_gact_search
,
273 .get_fill_size
= tcf_gact_get_fill_size
,
274 .size
= sizeof(struct tcf_gact
),
277 static __net_init
int gact_init_net(struct net
*net
)
279 struct tc_action_net
*tn
= net_generic(net
, gact_net_id
);
281 return tc_action_net_init(tn
, &act_gact_ops
);
284 static void __net_exit
gact_exit_net(struct list_head
*net_list
)
286 tc_action_net_exit(net_list
, gact_net_id
);
289 static struct pernet_operations gact_net_ops
= {
290 .init
= gact_init_net
,
291 .exit_batch
= gact_exit_net
,
293 .size
= sizeof(struct tc_action_net
),
296 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
297 MODULE_DESCRIPTION("Generic Classifier actions");
298 MODULE_LICENSE("GPL");
300 static int __init
gact_init_module(void)
302 #ifdef CONFIG_GACT_PROB
303 pr_info("GACT probability on\n");
305 pr_info("GACT probability NOT on\n");
308 return tcf_register_action(&act_gact_ops
, &gact_net_ops
);
311 static void __exit
gact_cleanup_module(void)
313 tcf_unregister_action(&act_gact_ops
, &gact_net_ops
);
316 module_init(gact_init_module
);
317 module_exit(gact_cleanup_module
);