GNU Linux-libre 4.19.211-gnu1
[releases.git] / net / sched / act_sample.c
1 /*
2  * net/sched/act_sample.c - Packet sampling tc action
3  * Copyright (c) 2017 Yotam Gigi <yotamg@mellanox.com>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9
10 #include <linux/types.h>
11 #include <linux/kernel.h>
12 #include <linux/string.h>
13 #include <linux/errno.h>
14 #include <linux/skbuff.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/gfp.h>
19 #include <net/net_namespace.h>
20 #include <net/netlink.h>
21 #include <net/pkt_sched.h>
22 #include <linux/tc_act/tc_sample.h>
23 #include <net/tc_act/tc_sample.h>
24 #include <net/psample.h>
25
26 #include <linux/if_arp.h>
27
28 static unsigned int sample_net_id;
29 static struct tc_action_ops act_sample_ops;
30
31 static const struct nla_policy sample_policy[TCA_SAMPLE_MAX + 1] = {
32         [TCA_SAMPLE_PARMS]              = { .len = sizeof(struct tc_sample) },
33         [TCA_SAMPLE_RATE]               = { .type = NLA_U32 },
34         [TCA_SAMPLE_TRUNC_SIZE]         = { .type = NLA_U32 },
35         [TCA_SAMPLE_PSAMPLE_GROUP]      = { .type = NLA_U32 },
36 };
37
38 static int tcf_sample_init(struct net *net, struct nlattr *nla,
39                            struct nlattr *est, struct tc_action **a, int ovr,
40                            int bind, bool rtnl_held,
41                            struct netlink_ext_ack *extack)
42 {
43         struct tc_action_net *tn = net_generic(net, sample_net_id);
44         struct nlattr *tb[TCA_SAMPLE_MAX + 1];
45         struct psample_group *psample_group;
46         u32 psample_group_num, rate, index;
47         struct tc_sample *parm;
48         struct tcf_sample *s;
49         bool exists = false;
50         int ret, err;
51
52         if (!nla)
53                 return -EINVAL;
54         ret = nla_parse_nested(tb, TCA_SAMPLE_MAX, nla, sample_policy, NULL);
55         if (ret < 0)
56                 return ret;
57         if (!tb[TCA_SAMPLE_PARMS] || !tb[TCA_SAMPLE_RATE] ||
58             !tb[TCA_SAMPLE_PSAMPLE_GROUP])
59                 return -EINVAL;
60
61         parm = nla_data(tb[TCA_SAMPLE_PARMS]);
62         index = parm->index;
63         err = tcf_idr_check_alloc(tn, &index, a, bind);
64         if (err < 0)
65                 return err;
66         exists = err;
67         if (exists && bind)
68                 return 0;
69
70         if (!exists) {
71                 ret = tcf_idr_create(tn, index, est, a,
72                                      &act_sample_ops, bind, true);
73                 if (ret) {
74                         tcf_idr_cleanup(tn, index);
75                         return ret;
76                 }
77                 ret = ACT_P_CREATED;
78         } else if (!ovr) {
79                 tcf_idr_release(*a, bind);
80                 return -EEXIST;
81         }
82
83         rate = nla_get_u32(tb[TCA_SAMPLE_RATE]);
84         if (!rate) {
85                 NL_SET_ERR_MSG(extack, "invalid sample rate");
86                 tcf_idr_release(*a, bind);
87                 return -EINVAL;
88         }
89         psample_group_num = nla_get_u32(tb[TCA_SAMPLE_PSAMPLE_GROUP]);
90         psample_group = psample_group_get(net, psample_group_num);
91         if (!psample_group) {
92                 tcf_idr_release(*a, bind);
93                 return -ENOMEM;
94         }
95
96         s = to_sample(*a);
97
98         spin_lock_bh(&s->tcf_lock);
99         s->tcf_action = parm->action;
100         s->rate = rate;
101         s->psample_group_num = psample_group_num;
102         rcu_swap_protected(s->psample_group, psample_group,
103                            lockdep_is_held(&s->tcf_lock));
104
105         if (tb[TCA_SAMPLE_TRUNC_SIZE]) {
106                 s->truncate = true;
107                 s->trunc_size = nla_get_u32(tb[TCA_SAMPLE_TRUNC_SIZE]);
108         }
109         spin_unlock_bh(&s->tcf_lock);
110
111         if (psample_group)
112                 psample_group_put(psample_group);
113         if (ret == ACT_P_CREATED)
114                 tcf_idr_insert(tn, *a);
115         return ret;
116 }
117
118 static void tcf_sample_cleanup(struct tc_action *a)
119 {
120         struct tcf_sample *s = to_sample(a);
121         struct psample_group *psample_group;
122
123         /* last reference to action, no need to lock */
124         psample_group = rcu_dereference_protected(s->psample_group, 1);
125         RCU_INIT_POINTER(s->psample_group, NULL);
126         if (psample_group)
127                 psample_group_put(psample_group);
128 }
129
130 static bool tcf_sample_dev_ok_push(struct net_device *dev)
131 {
132         switch (dev->type) {
133         case ARPHRD_TUNNEL:
134         case ARPHRD_TUNNEL6:
135         case ARPHRD_SIT:
136         case ARPHRD_IPGRE:
137         case ARPHRD_IP6GRE:
138         case ARPHRD_VOID:
139         case ARPHRD_NONE:
140                 return false;
141         default:
142                 return true;
143         }
144 }
145
146 static int tcf_sample_act(struct sk_buff *skb, const struct tc_action *a,
147                           struct tcf_result *res)
148 {
149         struct tcf_sample *s = to_sample(a);
150         struct psample_group *psample_group;
151         int retval;
152         int size;
153         int iif;
154         int oif;
155
156         tcf_lastuse_update(&s->tcf_tm);
157         bstats_cpu_update(this_cpu_ptr(s->common.cpu_bstats), skb);
158         retval = READ_ONCE(s->tcf_action);
159
160         psample_group = rcu_dereference_bh(s->psample_group);
161
162         /* randomly sample packets according to rate */
163         if (psample_group && (prandom_u32() % s->rate == 0)) {
164                 if (!skb_at_tc_ingress(skb)) {
165                         iif = skb->skb_iif;
166                         oif = skb->dev->ifindex;
167                 } else {
168                         iif = skb->dev->ifindex;
169                         oif = 0;
170                 }
171
172                 /* on ingress, the mac header gets popped, so push it back */
173                 if (skb_at_tc_ingress(skb) && tcf_sample_dev_ok_push(skb->dev))
174                         skb_push(skb, skb->mac_len);
175
176                 size = s->truncate ? s->trunc_size : skb->len;
177                 psample_sample_packet(psample_group, skb, size, iif, oif,
178                                       s->rate);
179
180                 if (skb_at_tc_ingress(skb) && tcf_sample_dev_ok_push(skb->dev))
181                         skb_pull(skb, skb->mac_len);
182         }
183
184         return retval;
185 }
186
187 static int tcf_sample_dump(struct sk_buff *skb, struct tc_action *a,
188                            int bind, int ref)
189 {
190         unsigned char *b = skb_tail_pointer(skb);
191         struct tcf_sample *s = to_sample(a);
192         struct tc_sample opt = {
193                 .index      = s->tcf_index,
194                 .refcnt     = refcount_read(&s->tcf_refcnt) - ref,
195                 .bindcnt    = atomic_read(&s->tcf_bindcnt) - bind,
196         };
197         struct tcf_t t;
198
199         spin_lock_bh(&s->tcf_lock);
200         opt.action = s->tcf_action;
201         if (nla_put(skb, TCA_SAMPLE_PARMS, sizeof(opt), &opt))
202                 goto nla_put_failure;
203
204         tcf_tm_dump(&t, &s->tcf_tm);
205         if (nla_put_64bit(skb, TCA_SAMPLE_TM, sizeof(t), &t, TCA_SAMPLE_PAD))
206                 goto nla_put_failure;
207
208         if (nla_put_u32(skb, TCA_SAMPLE_RATE, s->rate))
209                 goto nla_put_failure;
210
211         if (s->truncate)
212                 if (nla_put_u32(skb, TCA_SAMPLE_TRUNC_SIZE, s->trunc_size))
213                         goto nla_put_failure;
214
215         if (nla_put_u32(skb, TCA_SAMPLE_PSAMPLE_GROUP, s->psample_group_num))
216                 goto nla_put_failure;
217         spin_unlock_bh(&s->tcf_lock);
218
219         return skb->len;
220
221 nla_put_failure:
222         spin_unlock_bh(&s->tcf_lock);
223         nlmsg_trim(skb, b);
224         return -1;
225 }
226
227 static int tcf_sample_walker(struct net *net, struct sk_buff *skb,
228                              struct netlink_callback *cb, int type,
229                              const struct tc_action_ops *ops,
230                              struct netlink_ext_ack *extack)
231 {
232         struct tc_action_net *tn = net_generic(net, sample_net_id);
233
234         return tcf_generic_walker(tn, skb, cb, type, ops, extack);
235 }
236
237 static int tcf_sample_search(struct net *net, struct tc_action **a, u32 index,
238                              struct netlink_ext_ack *extack)
239 {
240         struct tc_action_net *tn = net_generic(net, sample_net_id);
241
242         return tcf_idr_search(tn, a, index);
243 }
244
245 static struct tc_action_ops act_sample_ops = {
246         .kind     = "sample",
247         .type     = TCA_ACT_SAMPLE,
248         .owner    = THIS_MODULE,
249         .act      = tcf_sample_act,
250         .dump     = tcf_sample_dump,
251         .init     = tcf_sample_init,
252         .cleanup  = tcf_sample_cleanup,
253         .walk     = tcf_sample_walker,
254         .lookup   = tcf_sample_search,
255         .size     = sizeof(struct tcf_sample),
256 };
257
258 static __net_init int sample_init_net(struct net *net)
259 {
260         struct tc_action_net *tn = net_generic(net, sample_net_id);
261
262         return tc_action_net_init(net, tn, &act_sample_ops);
263 }
264
265 static void __net_exit sample_exit_net(struct list_head *net_list)
266 {
267         tc_action_net_exit(net_list, sample_net_id);
268 }
269
270 static struct pernet_operations sample_net_ops = {
271         .init = sample_init_net,
272         .exit_batch = sample_exit_net,
273         .id   = &sample_net_id,
274         .size = sizeof(struct tc_action_net),
275 };
276
277 static int __init sample_init_module(void)
278 {
279         return tcf_register_action(&act_sample_ops, &sample_net_ops);
280 }
281
282 static void __exit sample_cleanup_module(void)
283 {
284         tcf_unregister_action(&act_sample_ops, &sample_net_ops);
285 }
286
287 module_init(sample_init_module);
288 module_exit(sample_cleanup_module);
289
290 MODULE_AUTHOR("Yotam Gigi <yotam.gi@gmail.com>");
291 MODULE_DESCRIPTION("Packet sampling action");
292 MODULE_LICENSE("GPL v2");