xref: /openbmc/linux/net/sched/act_sample.c (revision 68198dca)
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)
41 {
42 	struct tc_action_net *tn = net_generic(net, sample_net_id);
43 	struct nlattr *tb[TCA_SAMPLE_MAX + 1];
44 	struct psample_group *psample_group;
45 	struct tc_sample *parm;
46 	struct tcf_sample *s;
47 	bool exists = false;
48 	int ret;
49 
50 	if (!nla)
51 		return -EINVAL;
52 	ret = nla_parse_nested(tb, TCA_SAMPLE_MAX, nla, sample_policy, NULL);
53 	if (ret < 0)
54 		return ret;
55 	if (!tb[TCA_SAMPLE_PARMS] || !tb[TCA_SAMPLE_RATE] ||
56 	    !tb[TCA_SAMPLE_PSAMPLE_GROUP])
57 		return -EINVAL;
58 
59 	parm = nla_data(tb[TCA_SAMPLE_PARMS]);
60 
61 	exists = tcf_idr_check(tn, parm->index, a, bind);
62 	if (exists && bind)
63 		return 0;
64 
65 	if (!exists) {
66 		ret = tcf_idr_create(tn, parm->index, est, a,
67 				     &act_sample_ops, bind, false);
68 		if (ret)
69 			return ret;
70 		ret = ACT_P_CREATED;
71 	} else {
72 		tcf_idr_release(*a, bind);
73 		if (!ovr)
74 			return -EEXIST;
75 	}
76 	s = to_sample(*a);
77 
78 	s->tcf_action = parm->action;
79 	s->rate = nla_get_u32(tb[TCA_SAMPLE_RATE]);
80 	s->psample_group_num = nla_get_u32(tb[TCA_SAMPLE_PSAMPLE_GROUP]);
81 	psample_group = psample_group_get(net, s->psample_group_num);
82 	if (!psample_group) {
83 		if (ret == ACT_P_CREATED)
84 			tcf_idr_release(*a, bind);
85 		return -ENOMEM;
86 	}
87 	RCU_INIT_POINTER(s->psample_group, psample_group);
88 
89 	if (tb[TCA_SAMPLE_TRUNC_SIZE]) {
90 		s->truncate = true;
91 		s->trunc_size = nla_get_u32(tb[TCA_SAMPLE_TRUNC_SIZE]);
92 	}
93 
94 	if (ret == ACT_P_CREATED)
95 		tcf_idr_insert(tn, *a);
96 	return ret;
97 }
98 
99 static void tcf_sample_cleanup(struct tc_action *a, int bind)
100 {
101 	struct tcf_sample *s = to_sample(a);
102 	struct psample_group *psample_group;
103 
104 	psample_group = rtnl_dereference(s->psample_group);
105 	RCU_INIT_POINTER(s->psample_group, NULL);
106 	psample_group_put(psample_group);
107 }
108 
109 static bool tcf_sample_dev_ok_push(struct net_device *dev)
110 {
111 	switch (dev->type) {
112 	case ARPHRD_TUNNEL:
113 	case ARPHRD_TUNNEL6:
114 	case ARPHRD_SIT:
115 	case ARPHRD_IPGRE:
116 	case ARPHRD_VOID:
117 	case ARPHRD_NONE:
118 		return false;
119 	default:
120 		return true;
121 	}
122 }
123 
124 static int tcf_sample_act(struct sk_buff *skb, const struct tc_action *a,
125 			  struct tcf_result *res)
126 {
127 	struct tcf_sample *s = to_sample(a);
128 	struct psample_group *psample_group;
129 	int retval;
130 	int size;
131 	int iif;
132 	int oif;
133 
134 	tcf_lastuse_update(&s->tcf_tm);
135 	bstats_cpu_update(this_cpu_ptr(s->common.cpu_bstats), skb);
136 	retval = READ_ONCE(s->tcf_action);
137 
138 	rcu_read_lock();
139 	psample_group = rcu_dereference(s->psample_group);
140 
141 	/* randomly sample packets according to rate */
142 	if (psample_group && (prandom_u32() % s->rate == 0)) {
143 		if (!skb_at_tc_ingress(skb)) {
144 			iif = skb->skb_iif;
145 			oif = skb->dev->ifindex;
146 		} else {
147 			iif = skb->dev->ifindex;
148 			oif = 0;
149 		}
150 
151 		/* on ingress, the mac header gets popped, so push it back */
152 		if (skb_at_tc_ingress(skb) && tcf_sample_dev_ok_push(skb->dev))
153 			skb_push(skb, skb->mac_len);
154 
155 		size = s->truncate ? s->trunc_size : skb->len;
156 		psample_sample_packet(psample_group, skb, size, iif, oif,
157 				      s->rate);
158 
159 		if (skb_at_tc_ingress(skb) && tcf_sample_dev_ok_push(skb->dev))
160 			skb_pull(skb, skb->mac_len);
161 	}
162 
163 	rcu_read_unlock();
164 	return retval;
165 }
166 
167 static int tcf_sample_dump(struct sk_buff *skb, struct tc_action *a,
168 			   int bind, int ref)
169 {
170 	unsigned char *b = skb_tail_pointer(skb);
171 	struct tcf_sample *s = to_sample(a);
172 	struct tc_sample opt = {
173 		.index      = s->tcf_index,
174 		.action     = s->tcf_action,
175 		.refcnt     = s->tcf_refcnt - ref,
176 		.bindcnt    = s->tcf_bindcnt - bind,
177 	};
178 	struct tcf_t t;
179 
180 	if (nla_put(skb, TCA_SAMPLE_PARMS, sizeof(opt), &opt))
181 		goto nla_put_failure;
182 
183 	tcf_tm_dump(&t, &s->tcf_tm);
184 	if (nla_put_64bit(skb, TCA_SAMPLE_TM, sizeof(t), &t, TCA_SAMPLE_PAD))
185 		goto nla_put_failure;
186 
187 	if (nla_put_u32(skb, TCA_SAMPLE_RATE, s->rate))
188 		goto nla_put_failure;
189 
190 	if (s->truncate)
191 		if (nla_put_u32(skb, TCA_SAMPLE_TRUNC_SIZE, s->trunc_size))
192 			goto nla_put_failure;
193 
194 	if (nla_put_u32(skb, TCA_SAMPLE_PSAMPLE_GROUP, s->psample_group_num))
195 		goto nla_put_failure;
196 	return skb->len;
197 
198 nla_put_failure:
199 	nlmsg_trim(skb, b);
200 	return -1;
201 }
202 
203 static int tcf_sample_walker(struct net *net, struct sk_buff *skb,
204 			     struct netlink_callback *cb, int type,
205 			     const struct tc_action_ops *ops)
206 {
207 	struct tc_action_net *tn = net_generic(net, sample_net_id);
208 
209 	return tcf_generic_walker(tn, skb, cb, type, ops);
210 }
211 
212 static int tcf_sample_search(struct net *net, struct tc_action **a, u32 index)
213 {
214 	struct tc_action_net *tn = net_generic(net, sample_net_id);
215 
216 	return tcf_idr_search(tn, a, index);
217 }
218 
219 static struct tc_action_ops act_sample_ops = {
220 	.kind	  = "sample",
221 	.type	  = TCA_ACT_SAMPLE,
222 	.owner	  = THIS_MODULE,
223 	.act	  = tcf_sample_act,
224 	.dump	  = tcf_sample_dump,
225 	.init	  = tcf_sample_init,
226 	.cleanup  = tcf_sample_cleanup,
227 	.walk	  = tcf_sample_walker,
228 	.lookup	  = tcf_sample_search,
229 	.size	  = sizeof(struct tcf_sample),
230 };
231 
232 static __net_init int sample_init_net(struct net *net)
233 {
234 	struct tc_action_net *tn = net_generic(net, sample_net_id);
235 
236 	return tc_action_net_init(tn, &act_sample_ops);
237 }
238 
239 static void __net_exit sample_exit_net(struct net *net)
240 {
241 	struct tc_action_net *tn = net_generic(net, sample_net_id);
242 
243 	tc_action_net_exit(tn);
244 }
245 
246 static struct pernet_operations sample_net_ops = {
247 	.init = sample_init_net,
248 	.exit = sample_exit_net,
249 	.id   = &sample_net_id,
250 	.size = sizeof(struct tc_action_net),
251 };
252 
253 static int __init sample_init_module(void)
254 {
255 	return tcf_register_action(&act_sample_ops, &sample_net_ops);
256 }
257 
258 static void __exit sample_cleanup_module(void)
259 {
260 	tcf_unregister_action(&act_sample_ops, &sample_net_ops);
261 }
262 
263 module_init(sample_init_module);
264 module_exit(sample_cleanup_module);
265 
266 MODULE_AUTHOR("Yotam Gigi <yotam.gi@gmail.com>");
267 MODULE_DESCRIPTION("Packet sampling action");
268 MODULE_LICENSE("GPL v2");
269