1 // SPDX-License-Identifier: GPL-2.0-only
3 * net/sched/act_sample.c - Packet sampling tc action
4 * Copyright (c) 2017 Yotam Gigi <yotamg@mellanox.com>
7 #include <linux/types.h>
8 #include <linux/kernel.h>
9 #include <linux/string.h>
10 #include <linux/errno.h>
11 #include <linux/skbuff.h>
12 #include <linux/rtnetlink.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/gfp.h>
16 #include <net/net_namespace.h>
17 #include <net/netlink.h>
18 #include <net/pkt_sched.h>
19 #include <linux/tc_act/tc_sample.h>
20 #include <net/tc_act/tc_sample.h>
21 #include <net/psample.h>
22 #include <net/pkt_cls.h>
24 #include <linux/if_arp.h>
26 static unsigned int sample_net_id
;
27 static struct tc_action_ops act_sample_ops
;
29 static const struct nla_policy sample_policy
[TCA_SAMPLE_MAX
+ 1] = {
30 [TCA_SAMPLE_PARMS
] = { .len
= sizeof(struct tc_sample
) },
31 [TCA_SAMPLE_RATE
] = { .type
= NLA_U32
},
32 [TCA_SAMPLE_TRUNC_SIZE
] = { .type
= NLA_U32
},
33 [TCA_SAMPLE_PSAMPLE_GROUP
] = { .type
= NLA_U32
},
36 static int tcf_sample_init(struct net
*net
, struct nlattr
*nla
,
37 struct nlattr
*est
, struct tc_action
**a
, int ovr
,
38 int bind
, bool rtnl_held
, struct tcf_proto
*tp
,
39 struct netlink_ext_ack
*extack
)
41 struct tc_action_net
*tn
= net_generic(net
, sample_net_id
);
42 struct nlattr
*tb
[TCA_SAMPLE_MAX
+ 1];
43 struct psample_group
*psample_group
;
44 u32 psample_group_num
, rate
, index
;
45 struct tcf_chain
*goto_ch
= NULL
;
46 struct tc_sample
*parm
;
53 ret
= nla_parse_nested_deprecated(tb
, TCA_SAMPLE_MAX
, nla
,
57 if (!tb
[TCA_SAMPLE_PARMS
] || !tb
[TCA_SAMPLE_RATE
] ||
58 !tb
[TCA_SAMPLE_PSAMPLE_GROUP
])
61 parm
= nla_data(tb
[TCA_SAMPLE_PARMS
]);
63 err
= tcf_idr_check_alloc(tn
, &index
, a
, bind
);
71 ret
= tcf_idr_create(tn
, index
, est
, a
,
72 &act_sample_ops
, bind
, true);
74 tcf_idr_cleanup(tn
, index
);
79 tcf_idr_release(*a
, bind
);
82 err
= tcf_action_check_ctrlact(parm
->action
, tp
, &goto_ch
, extack
);
86 rate
= nla_get_u32(tb
[TCA_SAMPLE_RATE
]);
88 NL_SET_ERR_MSG(extack
, "invalid sample rate");
92 psample_group_num
= nla_get_u32(tb
[TCA_SAMPLE_PSAMPLE_GROUP
]);
93 psample_group
= psample_group_get(net
, psample_group_num
);
101 spin_lock_bh(&s
->tcf_lock
);
102 goto_ch
= tcf_action_set_ctrlact(*a
, parm
->action
, goto_ch
);
104 s
->psample_group_num
= psample_group_num
;
105 rcu_swap_protected(s
->psample_group
, psample_group
,
106 lockdep_is_held(&s
->tcf_lock
));
108 if (tb
[TCA_SAMPLE_TRUNC_SIZE
]) {
110 s
->trunc_size
= nla_get_u32(tb
[TCA_SAMPLE_TRUNC_SIZE
]);
112 spin_unlock_bh(&s
->tcf_lock
);
115 psample_group_put(psample_group
);
117 tcf_chain_put_by_act(goto_ch
);
119 if (ret
== ACT_P_CREATED
)
120 tcf_idr_insert(tn
, *a
);
124 tcf_chain_put_by_act(goto_ch
);
126 tcf_idr_release(*a
, bind
);
130 static void tcf_sample_cleanup(struct tc_action
*a
)
132 struct tcf_sample
*s
= to_sample(a
);
133 struct psample_group
*psample_group
;
135 /* last reference to action, no need to lock */
136 psample_group
= rcu_dereference_protected(s
->psample_group
, 1);
137 RCU_INIT_POINTER(s
->psample_group
, NULL
);
139 psample_group_put(psample_group
);
142 static bool tcf_sample_dev_ok_push(struct net_device
*dev
)
157 static int tcf_sample_act(struct sk_buff
*skb
, const struct tc_action
*a
,
158 struct tcf_result
*res
)
160 struct tcf_sample
*s
= to_sample(a
);
161 struct psample_group
*psample_group
;
167 tcf_lastuse_update(&s
->tcf_tm
);
168 bstats_cpu_update(this_cpu_ptr(s
->common
.cpu_bstats
), skb
);
169 retval
= READ_ONCE(s
->tcf_action
);
171 psample_group
= rcu_dereference_bh(s
->psample_group
);
173 /* randomly sample packets according to rate */
174 if (psample_group
&& (prandom_u32() % s
->rate
== 0)) {
175 if (!skb_at_tc_ingress(skb
)) {
177 oif
= skb
->dev
->ifindex
;
179 iif
= skb
->dev
->ifindex
;
183 /* on ingress, the mac header gets popped, so push it back */
184 if (skb_at_tc_ingress(skb
) && tcf_sample_dev_ok_push(skb
->dev
))
185 skb_push(skb
, skb
->mac_len
);
187 size
= s
->truncate
? s
->trunc_size
: skb
->len
;
188 psample_sample_packet(psample_group
, skb
, size
, iif
, oif
,
191 if (skb_at_tc_ingress(skb
) && tcf_sample_dev_ok_push(skb
->dev
))
192 skb_pull(skb
, skb
->mac_len
);
198 static int tcf_sample_dump(struct sk_buff
*skb
, struct tc_action
*a
,
201 unsigned char *b
= skb_tail_pointer(skb
);
202 struct tcf_sample
*s
= to_sample(a
);
203 struct tc_sample opt
= {
204 .index
= s
->tcf_index
,
205 .refcnt
= refcount_read(&s
->tcf_refcnt
) - ref
,
206 .bindcnt
= atomic_read(&s
->tcf_bindcnt
) - bind
,
210 spin_lock_bh(&s
->tcf_lock
);
211 opt
.action
= s
->tcf_action
;
212 if (nla_put(skb
, TCA_SAMPLE_PARMS
, sizeof(opt
), &opt
))
213 goto nla_put_failure
;
215 tcf_tm_dump(&t
, &s
->tcf_tm
);
216 if (nla_put_64bit(skb
, TCA_SAMPLE_TM
, sizeof(t
), &t
, TCA_SAMPLE_PAD
))
217 goto nla_put_failure
;
219 if (nla_put_u32(skb
, TCA_SAMPLE_RATE
, s
->rate
))
220 goto nla_put_failure
;
223 if (nla_put_u32(skb
, TCA_SAMPLE_TRUNC_SIZE
, s
->trunc_size
))
224 goto nla_put_failure
;
226 if (nla_put_u32(skb
, TCA_SAMPLE_PSAMPLE_GROUP
, s
->psample_group_num
))
227 goto nla_put_failure
;
228 spin_unlock_bh(&s
->tcf_lock
);
233 spin_unlock_bh(&s
->tcf_lock
);
238 static int tcf_sample_walker(struct net
*net
, struct sk_buff
*skb
,
239 struct netlink_callback
*cb
, int type
,
240 const struct tc_action_ops
*ops
,
241 struct netlink_ext_ack
*extack
)
243 struct tc_action_net
*tn
= net_generic(net
, sample_net_id
);
245 return tcf_generic_walker(tn
, skb
, cb
, type
, ops
, extack
);
248 static int tcf_sample_search(struct net
*net
, struct tc_action
**a
, u32 index
)
250 struct tc_action_net
*tn
= net_generic(net
, sample_net_id
);
252 return tcf_idr_search(tn
, a
, index
);
255 static void tcf_psample_group_put(void *priv
)
257 struct psample_group
*group
= priv
;
259 psample_group_put(group
);
262 static struct psample_group
*
263 tcf_sample_get_group(const struct tc_action
*a
,
264 tc_action_priv_destructor
*destructor
)
266 struct tcf_sample
*s
= to_sample(a
);
267 struct psample_group
*group
;
269 spin_lock_bh(&s
->tcf_lock
);
270 group
= rcu_dereference_protected(s
->psample_group
,
271 lockdep_is_held(&s
->tcf_lock
));
273 psample_group_take(group
);
274 *destructor
= tcf_psample_group_put
;
276 spin_unlock_bh(&s
->tcf_lock
);
281 static struct tc_action_ops act_sample_ops
= {
284 .owner
= THIS_MODULE
,
285 .act
= tcf_sample_act
,
286 .dump
= tcf_sample_dump
,
287 .init
= tcf_sample_init
,
288 .cleanup
= tcf_sample_cleanup
,
289 .walk
= tcf_sample_walker
,
290 .lookup
= tcf_sample_search
,
291 .get_psample_group
= tcf_sample_get_group
,
292 .size
= sizeof(struct tcf_sample
),
295 static __net_init
int sample_init_net(struct net
*net
)
297 struct tc_action_net
*tn
= net_generic(net
, sample_net_id
);
299 return tc_action_net_init(net
, tn
, &act_sample_ops
);
302 static void __net_exit
sample_exit_net(struct list_head
*net_list
)
304 tc_action_net_exit(net_list
, sample_net_id
);
307 static struct pernet_operations sample_net_ops
= {
308 .init
= sample_init_net
,
309 .exit_batch
= sample_exit_net
,
310 .id
= &sample_net_id
,
311 .size
= sizeof(struct tc_action_net
),
314 static int __init
sample_init_module(void)
316 return tcf_register_action(&act_sample_ops
, &sample_net_ops
);
319 static void __exit
sample_cleanup_module(void)
321 tcf_unregister_action(&act_sample_ops
, &sample_net_ops
);
324 module_init(sample_init_module
);
325 module_exit(sample_cleanup_module
);
327 MODULE_AUTHOR("Yotam Gigi <yotam.gi@gmail.com>");
328 MODULE_DESCRIPTION("Packet sampling action");
329 MODULE_LICENSE("GPL v2");