xref: /openbmc/linux/net/sched/cls_basic.c (revision a2cce7a9) 
1 /*
2  * net/sched/cls_basic.c	Basic Packet Classifier.
3  *
4  *		This program is free software; you can redistribute it and/or
5  *		modify it under the terms of the GNU General Public License
6  *		as published by the Free Software Foundation; either version
7  *		2 of the License, or (at your option) any later version.
8  *
9  * Authors:	Thomas Graf <tgraf@suug.ch>
10  */
11 
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/skbuff.h>
20 #include <net/netlink.h>
21 #include <net/act_api.h>
22 #include <net/pkt_cls.h>
23 
24 struct basic_head {
25 	u32			hgenerator;
26 	struct list_head	flist;
27 	struct rcu_head		rcu;
28 };
29 
30 struct basic_filter {
31 	u32			handle;
32 	struct tcf_exts		exts;
33 	struct tcf_ematch_tree	ematches;
34 	struct tcf_result	res;
35 	struct tcf_proto	*tp;
36 	struct list_head	link;
37 	struct rcu_head		rcu;
38 };
39 
40 static int basic_classify(struct sk_buff *skb, const struct tcf_proto *tp,
41 			  struct tcf_result *res)
42 {
43 	int r;
44 	struct basic_head *head = rcu_dereference_bh(tp->root);
45 	struct basic_filter *f;
46 
47 	list_for_each_entry_rcu(f, &head->flist, link) {
48 		if (!tcf_em_tree_match(skb, &f->ematches, NULL))
49 			continue;
50 		*res = f->res;
51 		r = tcf_exts_exec(skb, &f->exts, res);
52 		if (r < 0)
53 			continue;
54 		return r;
55 	}
56 	return -1;
57 }
58 
59 static unsigned long basic_get(struct tcf_proto *tp, u32 handle)
60 {
61 	unsigned long l = 0UL;
62 	struct basic_head *head = rtnl_dereference(tp->root);
63 	struct basic_filter *f;
64 
65 	if (head == NULL)
66 		return 0UL;
67 
68 	list_for_each_entry(f, &head->flist, link) {
69 		if (f->handle == handle) {
70 			l = (unsigned long) f;
71 			break;
72 		}
73 	}
74 
75 	return l;
76 }
77 
78 static int basic_init(struct tcf_proto *tp)
79 {
80 	struct basic_head *head;
81 
82 	head = kzalloc(sizeof(*head), GFP_KERNEL);
83 	if (head == NULL)
84 		return -ENOBUFS;
85 	INIT_LIST_HEAD(&head->flist);
86 	rcu_assign_pointer(tp->root, head);
87 	return 0;
88 }
89 
90 static void basic_delete_filter(struct rcu_head *head)
91 {
92 	struct basic_filter *f = container_of(head, struct basic_filter, rcu);
93 
94 	tcf_exts_destroy(&f->exts);
95 	tcf_em_tree_destroy(&f->ematches);
96 	kfree(f);
97 }
98 
99 static bool basic_destroy(struct tcf_proto *tp, bool force)
100 {
101 	struct basic_head *head = rtnl_dereference(tp->root);
102 	struct basic_filter *f, *n;
103 
104 	if (!force && !list_empty(&head->flist))
105 		return false;
106 
107 	list_for_each_entry_safe(f, n, &head->flist, link) {
108 		list_del_rcu(&f->link);
109 		tcf_unbind_filter(tp, &f->res);
110 		call_rcu(&f->rcu, basic_delete_filter);
111 	}
112 	RCU_INIT_POINTER(tp->root, NULL);
113 	kfree_rcu(head, rcu);
114 	return true;
115 }
116 
117 static int basic_delete(struct tcf_proto *tp, unsigned long arg)
118 {
119 	struct basic_filter *f = (struct basic_filter *) arg;
120 
121 	list_del_rcu(&f->link);
122 	tcf_unbind_filter(tp, &f->res);
123 	call_rcu(&f->rcu, basic_delete_filter);
124 	return 0;
125 }
126 
127 static const struct nla_policy basic_policy[TCA_BASIC_MAX + 1] = {
128 	[TCA_BASIC_CLASSID]	= { .type = NLA_U32 },
129 	[TCA_BASIC_EMATCHES]	= { .type = NLA_NESTED },
130 };
131 
132 static int basic_set_parms(struct net *net, struct tcf_proto *tp,
133 			   struct basic_filter *f, unsigned long base,
134 			   struct nlattr **tb,
135 			   struct nlattr *est, bool ovr)
136 {
137 	int err;
138 	struct tcf_exts e;
139 	struct tcf_ematch_tree t;
140 
141 	tcf_exts_init(&e, TCA_BASIC_ACT, TCA_BASIC_POLICE);
142 	err = tcf_exts_validate(net, tp, tb, est, &e, ovr);
143 	if (err < 0)
144 		return err;
145 
146 	err = tcf_em_tree_validate(tp, tb[TCA_BASIC_EMATCHES], &t);
147 	if (err < 0)
148 		goto errout;
149 
150 	if (tb[TCA_BASIC_CLASSID]) {
151 		f->res.classid = nla_get_u32(tb[TCA_BASIC_CLASSID]);
152 		tcf_bind_filter(tp, &f->res, base);
153 	}
154 
155 	tcf_exts_change(tp, &f->exts, &e);
156 	tcf_em_tree_change(tp, &f->ematches, &t);
157 	f->tp = tp;
158 
159 	return 0;
160 errout:
161 	tcf_exts_destroy(&e);
162 	return err;
163 }
164 
165 static int basic_change(struct net *net, struct sk_buff *in_skb,
166 			struct tcf_proto *tp, unsigned long base, u32 handle,
167 			struct nlattr **tca, unsigned long *arg, bool ovr)
168 {
169 	int err;
170 	struct basic_head *head = rtnl_dereference(tp->root);
171 	struct nlattr *tb[TCA_BASIC_MAX + 1];
172 	struct basic_filter *fold = (struct basic_filter *) *arg;
173 	struct basic_filter *fnew;
174 
175 	if (tca[TCA_OPTIONS] == NULL)
176 		return -EINVAL;
177 
178 	err = nla_parse_nested(tb, TCA_BASIC_MAX, tca[TCA_OPTIONS],
179 			       basic_policy);
180 	if (err < 0)
181 		return err;
182 
183 	if (fold != NULL) {
184 		if (handle && fold->handle != handle)
185 			return -EINVAL;
186 	}
187 
188 	fnew = kzalloc(sizeof(*fnew), GFP_KERNEL);
189 	if (!fnew)
190 		return -ENOBUFS;
191 
192 	tcf_exts_init(&fnew->exts, TCA_BASIC_ACT, TCA_BASIC_POLICE);
193 	err = -EINVAL;
194 	if (handle) {
195 		fnew->handle = handle;
196 	} else if (fold) {
197 		fnew->handle = fold->handle;
198 	} else {
199 		unsigned int i = 0x80000000;
200 		do {
201 			if (++head->hgenerator == 0x7FFFFFFF)
202 				head->hgenerator = 1;
203 		} while (--i > 0 && basic_get(tp, head->hgenerator));
204 
205 		if (i <= 0) {
206 			pr_err("Insufficient number of handles\n");
207 			goto errout;
208 		}
209 
210 		fnew->handle = head->hgenerator;
211 	}
212 
213 	err = basic_set_parms(net, tp, fnew, base, tb, tca[TCA_RATE], ovr);
214 	if (err < 0)
215 		goto errout;
216 
217 	*arg = (unsigned long)fnew;
218 
219 	if (fold) {
220 		list_replace_rcu(&fold->link, &fnew->link);
221 		tcf_unbind_filter(tp, &fold->res);
222 		call_rcu(&fold->rcu, basic_delete_filter);
223 	} else {
224 		list_add_rcu(&fnew->link, &head->flist);
225 	}
226 
227 	return 0;
228 errout:
229 	kfree(fnew);
230 	return err;
231 }
232 
233 static void basic_walk(struct tcf_proto *tp, struct tcf_walker *arg)
234 {
235 	struct basic_head *head = rtnl_dereference(tp->root);
236 	struct basic_filter *f;
237 
238 	list_for_each_entry(f, &head->flist, link) {
239 		if (arg->count < arg->skip)
240 			goto skip;
241 
242 		if (arg->fn(tp, (unsigned long) f, arg) < 0) {
243 			arg->stop = 1;
244 			break;
245 		}
246 skip:
247 		arg->count++;
248 	}
249 }
250 
251 static int basic_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
252 		      struct sk_buff *skb, struct tcmsg *t)
253 {
254 	struct basic_filter *f = (struct basic_filter *) fh;
255 	struct nlattr *nest;
256 
257 	if (f == NULL)
258 		return skb->len;
259 
260 	t->tcm_handle = f->handle;
261 
262 	nest = nla_nest_start(skb, TCA_OPTIONS);
263 	if (nest == NULL)
264 		goto nla_put_failure;
265 
266 	if (f->res.classid &&
267 	    nla_put_u32(skb, TCA_BASIC_CLASSID, f->res.classid))
268 		goto nla_put_failure;
269 
270 	if (tcf_exts_dump(skb, &f->exts) < 0 ||
271 	    tcf_em_tree_dump(skb, &f->ematches, TCA_BASIC_EMATCHES) < 0)
272 		goto nla_put_failure;
273 
274 	nla_nest_end(skb, nest);
275 
276 	if (tcf_exts_dump_stats(skb, &f->exts) < 0)
277 		goto nla_put_failure;
278 
279 	return skb->len;
280 
281 nla_put_failure:
282 	nla_nest_cancel(skb, nest);
283 	return -1;
284 }
285 
286 static struct tcf_proto_ops cls_basic_ops __read_mostly = {
287 	.kind		=	"basic",
288 	.classify	=	basic_classify,
289 	.init		=	basic_init,
290 	.destroy	=	basic_destroy,
291 	.get		=	basic_get,
292 	.change		=	basic_change,
293 	.delete		=	basic_delete,
294 	.walk		=	basic_walk,
295 	.dump		=	basic_dump,
296 	.owner		=	THIS_MODULE,
297 };
298 
299 static int __init init_basic(void)
300 {
301 	return register_tcf_proto_ops(&cls_basic_ops);
302 }
303 
304 static void __exit exit_basic(void)
305 {
306 	unregister_tcf_proto_ops(&cls_basic_ops);
307 }
308 
309 module_init(init_basic)
310 module_exit(exit_basic)
311 MODULE_LICENSE("GPL");
312 
313