blob: 25927b6c4436775a0d80747f7171ddc3d6896dfd [file] [log] [blame]
Jiri Pirkobf3994d2016-07-21 12:03:11 +02001/*
2 * net/sched/cls_matchll.c Match-all classifier
3 *
4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 */
11
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/module.h>
15
16#include <net/sch_generic.h>
17#include <net/pkt_cls.h>
18
19struct cls_mall_filter {
20 struct tcf_exts exts;
21 struct tcf_result res;
22 u32 handle;
23 struct rcu_head rcu;
Yotam Gigib87f7932016-07-21 12:03:12 +020024 u32 flags;
Jiri Pirkobf3994d2016-07-21 12:03:11 +020025};
26
27struct cls_mall_head {
28 struct cls_mall_filter *filter;
29 struct rcu_head rcu;
30};
31
32static int mall_classify(struct sk_buff *skb, const struct tcf_proto *tp,
33 struct tcf_result *res)
34{
35 struct cls_mall_head *head = rcu_dereference_bh(tp->root);
36 struct cls_mall_filter *f = head->filter;
37
Yotam Gigib87f7932016-07-21 12:03:12 +020038 if (tc_skip_sw(f->flags))
39 return -1;
40
Jiri Pirkobf3994d2016-07-21 12:03:11 +020041 return tcf_exts_exec(skb, &f->exts, res);
42}
43
44static int mall_init(struct tcf_proto *tp)
45{
46 struct cls_mall_head *head;
47
48 head = kzalloc(sizeof(*head), GFP_KERNEL);
49 if (!head)
50 return -ENOBUFS;
51
52 rcu_assign_pointer(tp->root, head);
53
54 return 0;
55}
56
57static void mall_destroy_filter(struct rcu_head *head)
58{
59 struct cls_mall_filter *f = container_of(head, struct cls_mall_filter, rcu);
60
61 tcf_exts_destroy(&f->exts);
Yotam Gigib87f7932016-07-21 12:03:12 +020062
Jiri Pirkobf3994d2016-07-21 12:03:11 +020063 kfree(f);
64}
65
Yotam Gigib87f7932016-07-21 12:03:12 +020066static int mall_replace_hw_filter(struct tcf_proto *tp,
67 struct cls_mall_filter *f,
68 unsigned long cookie)
69{
70 struct net_device *dev = tp->q->dev_queue->dev;
71 struct tc_to_netdev offload;
72 struct tc_cls_matchall_offload mall_offload = {0};
73
74 offload.type = TC_SETUP_MATCHALL;
75 offload.cls_mall = &mall_offload;
76 offload.cls_mall->command = TC_CLSMATCHALL_REPLACE;
77 offload.cls_mall->exts = &f->exts;
78 offload.cls_mall->cookie = cookie;
79
80 return dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle, tp->protocol,
81 &offload);
82}
83
84static void mall_destroy_hw_filter(struct tcf_proto *tp,
85 struct cls_mall_filter *f,
86 unsigned long cookie)
87{
88 struct net_device *dev = tp->q->dev_queue->dev;
89 struct tc_to_netdev offload;
90 struct tc_cls_matchall_offload mall_offload = {0};
91
92 offload.type = TC_SETUP_MATCHALL;
93 offload.cls_mall = &mall_offload;
94 offload.cls_mall->command = TC_CLSMATCHALL_DESTROY;
95 offload.cls_mall->exts = NULL;
96 offload.cls_mall->cookie = cookie;
97
98 dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle, tp->protocol,
99 &offload);
100}
101
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200102static bool mall_destroy(struct tcf_proto *tp, bool force)
103{
104 struct cls_mall_head *head = rtnl_dereference(tp->root);
Yotam Gigib87f7932016-07-21 12:03:12 +0200105 struct net_device *dev = tp->q->dev_queue->dev;
106 struct cls_mall_filter *f = head->filter;
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200107
Yotam Gigib87f7932016-07-21 12:03:12 +0200108 if (!force && f)
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200109 return false;
110
Yotam Gigib87f7932016-07-21 12:03:12 +0200111 if (f) {
112 if (tc_should_offload(dev, tp, f->flags))
113 mall_destroy_hw_filter(tp, f, (unsigned long) f);
114
115 call_rcu(&f->rcu, mall_destroy_filter);
116 }
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200117 RCU_INIT_POINTER(tp->root, NULL);
118 kfree_rcu(head, rcu);
119 return true;
120}
121
122static unsigned long mall_get(struct tcf_proto *tp, u32 handle)
123{
124 struct cls_mall_head *head = rtnl_dereference(tp->root);
125 struct cls_mall_filter *f = head->filter;
126
127 if (f && f->handle == handle)
128 return (unsigned long) f;
129 return 0;
130}
131
132static const struct nla_policy mall_policy[TCA_MATCHALL_MAX + 1] = {
133 [TCA_MATCHALL_UNSPEC] = { .type = NLA_UNSPEC },
134 [TCA_MATCHALL_CLASSID] = { .type = NLA_U32 },
135};
136
137static int mall_set_parms(struct net *net, struct tcf_proto *tp,
138 struct cls_mall_filter *f,
139 unsigned long base, struct nlattr **tb,
140 struct nlattr *est, bool ovr)
141{
142 struct tcf_exts e;
143 int err;
144
145 tcf_exts_init(&e, TCA_MATCHALL_ACT, 0);
146 err = tcf_exts_validate(net, tp, tb, est, &e, ovr);
147 if (err < 0)
148 return err;
149
150 if (tb[TCA_MATCHALL_CLASSID]) {
151 f->res.classid = nla_get_u32(tb[TCA_MATCHALL_CLASSID]);
152 tcf_bind_filter(tp, &f->res, base);
153 }
154
155 tcf_exts_change(tp, &f->exts, &e);
156
157 return 0;
158}
159
160static int mall_change(struct net *net, struct sk_buff *in_skb,
161 struct tcf_proto *tp, unsigned long base,
162 u32 handle, struct nlattr **tca,
163 unsigned long *arg, bool ovr)
164{
165 struct cls_mall_head *head = rtnl_dereference(tp->root);
166 struct cls_mall_filter *fold = (struct cls_mall_filter *) *arg;
Yotam Gigib87f7932016-07-21 12:03:12 +0200167 struct net_device *dev = tp->q->dev_queue->dev;
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200168 struct cls_mall_filter *f;
169 struct nlattr *tb[TCA_MATCHALL_MAX + 1];
Yotam Gigib87f7932016-07-21 12:03:12 +0200170 u32 flags = 0;
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200171 int err;
172
173 if (!tca[TCA_OPTIONS])
174 return -EINVAL;
175
176 if (head->filter)
177 return -EBUSY;
178
179 if (fold)
180 return -EINVAL;
181
182 err = nla_parse_nested(tb, TCA_MATCHALL_MAX,
183 tca[TCA_OPTIONS], mall_policy);
184 if (err < 0)
185 return err;
186
Yotam Gigib87f7932016-07-21 12:03:12 +0200187 if (tb[TCA_MATCHALL_FLAGS]) {
188 flags = nla_get_u32(tb[TCA_MATCHALL_FLAGS]);
189 if (!tc_flags_valid(flags))
190 return -EINVAL;
191 }
192
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200193 f = kzalloc(sizeof(*f), GFP_KERNEL);
194 if (!f)
195 return -ENOBUFS;
196
197 tcf_exts_init(&f->exts, TCA_MATCHALL_ACT, 0);
198
199 if (!handle)
200 handle = 1;
201 f->handle = handle;
Yotam Gigib87f7932016-07-21 12:03:12 +0200202 f->flags = flags;
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200203
204 err = mall_set_parms(net, tp, f, base, tb, tca[TCA_RATE], ovr);
205 if (err)
206 goto errout;
207
Yotam Gigib87f7932016-07-21 12:03:12 +0200208 if (tc_should_offload(dev, tp, flags)) {
209 err = mall_replace_hw_filter(tp, f, (unsigned long) f);
210 if (err) {
211 if (tc_skip_sw(flags))
212 goto errout;
213 else
214 err = 0;
215 }
216 }
217
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200218 *arg = (unsigned long) f;
219 rcu_assign_pointer(head->filter, f);
220
221 return 0;
222
223errout:
224 kfree(f);
225 return err;
226}
227
228static int mall_delete(struct tcf_proto *tp, unsigned long arg)
229{
230 struct cls_mall_head *head = rtnl_dereference(tp->root);
231 struct cls_mall_filter *f = (struct cls_mall_filter *) arg;
Yotam Gigib87f7932016-07-21 12:03:12 +0200232 struct net_device *dev = tp->q->dev_queue->dev;
233
234 if (tc_should_offload(dev, tp, f->flags))
235 mall_destroy_hw_filter(tp, f, (unsigned long) f);
Jiri Pirkobf3994d2016-07-21 12:03:11 +0200236
237 RCU_INIT_POINTER(head->filter, NULL);
238 tcf_unbind_filter(tp, &f->res);
239 call_rcu(&f->rcu, mall_destroy_filter);
240 return 0;
241}
242
243static void mall_walk(struct tcf_proto *tp, struct tcf_walker *arg)
244{
245 struct cls_mall_head *head = rtnl_dereference(tp->root);
246 struct cls_mall_filter *f = head->filter;
247
248 if (arg->count < arg->skip)
249 goto skip;
250 if (arg->fn(tp, (unsigned long) f, arg) < 0)
251 arg->stop = 1;
252skip:
253 arg->count++;
254}
255
256static int mall_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
257 struct sk_buff *skb, struct tcmsg *t)
258{
259 struct cls_mall_filter *f = (struct cls_mall_filter *) fh;
260 struct nlattr *nest;
261
262 if (!f)
263 return skb->len;
264
265 t->tcm_handle = f->handle;
266
267 nest = nla_nest_start(skb, TCA_OPTIONS);
268 if (!nest)
269 goto nla_put_failure;
270
271 if (f->res.classid &&
272 nla_put_u32(skb, TCA_MATCHALL_CLASSID, f->res.classid))
273 goto nla_put_failure;
274
275 if (tcf_exts_dump(skb, &f->exts))
276 goto nla_put_failure;
277
278 nla_nest_end(skb, nest);
279
280 if (tcf_exts_dump_stats(skb, &f->exts) < 0)
281 goto nla_put_failure;
282
283 return skb->len;
284
285nla_put_failure:
286 nla_nest_cancel(skb, nest);
287 return -1;
288}
289
290static struct tcf_proto_ops cls_mall_ops __read_mostly = {
291 .kind = "matchall",
292 .classify = mall_classify,
293 .init = mall_init,
294 .destroy = mall_destroy,
295 .get = mall_get,
296 .change = mall_change,
297 .delete = mall_delete,
298 .walk = mall_walk,
299 .dump = mall_dump,
300 .owner = THIS_MODULE,
301};
302
303static int __init cls_mall_init(void)
304{
305 return register_tcf_proto_ops(&cls_mall_ops);
306}
307
308static void __exit cls_mall_exit(void)
309{
310 unregister_tcf_proto_ops(&cls_mall_ops);
311}
312
313module_init(cls_mall_init);
314module_exit(cls_mall_exit);
315
316MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
317MODULE_DESCRIPTION("Match-all classifier");
318MODULE_LICENSE("GPL v2");