xref: /openbmc/linux/net/sched/sch_prio.c (revision 0984d159)
1 /*
2  * net/sched/sch_prio.c	Simple 3-band priority "scheduler".
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:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10  * Fixes:       19990609: J Hadi Salim <hadi@nortelnetworks.com>:
11  *              Init --  EINVAL when opt undefined
12  */
13 
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/types.h>
17 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include <linux/errno.h>
20 #include <linux/skbuff.h>
21 #include <net/netlink.h>
22 #include <net/pkt_sched.h>
23 
24 
25 struct prio_sched_data {
26 	int bands;
27 	struct tcf_proto __rcu *filter_list;
28 	u8  prio2band[TC_PRIO_MAX+1];
29 	struct Qdisc *queues[TCQ_PRIO_BANDS];
30 };
31 
32 
33 static struct Qdisc *
34 prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
35 {
36 	struct prio_sched_data *q = qdisc_priv(sch);
37 	u32 band = skb->priority;
38 	struct tcf_result res;
39 	struct tcf_proto *fl;
40 	int err;
41 
42 	*qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
43 	if (TC_H_MAJ(skb->priority) != sch->handle) {
44 		fl = rcu_dereference_bh(q->filter_list);
45 		err = tc_classify(skb, fl, &res, false);
46 #ifdef CONFIG_NET_CLS_ACT
47 		switch (err) {
48 		case TC_ACT_STOLEN:
49 		case TC_ACT_QUEUED:
50 			*qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
51 		case TC_ACT_SHOT:
52 			return NULL;
53 		}
54 #endif
55 		if (!fl || err < 0) {
56 			if (TC_H_MAJ(band))
57 				band = 0;
58 			return q->queues[q->prio2band[band & TC_PRIO_MAX]];
59 		}
60 		band = res.classid;
61 	}
62 	band = TC_H_MIN(band) - 1;
63 	if (band >= q->bands)
64 		return q->queues[q->prio2band[0]];
65 
66 	return q->queues[band];
67 }
68 
69 static int
70 prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
71 {
72 	struct Qdisc *qdisc;
73 	int ret;
74 
75 	qdisc = prio_classify(skb, sch, &ret);
76 #ifdef CONFIG_NET_CLS_ACT
77 	if (qdisc == NULL) {
78 
79 		if (ret & __NET_XMIT_BYPASS)
80 			qdisc_qstats_drop(sch);
81 		kfree_skb(skb);
82 		return ret;
83 	}
84 #endif
85 
86 	ret = qdisc_enqueue(skb, qdisc);
87 	if (ret == NET_XMIT_SUCCESS) {
88 		qdisc_qstats_backlog_inc(sch, skb);
89 		sch->q.qlen++;
90 		return NET_XMIT_SUCCESS;
91 	}
92 	if (net_xmit_drop_count(ret))
93 		qdisc_qstats_drop(sch);
94 	return ret;
95 }
96 
97 static struct sk_buff *prio_peek(struct Qdisc *sch)
98 {
99 	struct prio_sched_data *q = qdisc_priv(sch);
100 	int prio;
101 
102 	for (prio = 0; prio < q->bands; prio++) {
103 		struct Qdisc *qdisc = q->queues[prio];
104 		struct sk_buff *skb = qdisc->ops->peek(qdisc);
105 		if (skb)
106 			return skb;
107 	}
108 	return NULL;
109 }
110 
111 static struct sk_buff *prio_dequeue(struct Qdisc *sch)
112 {
113 	struct prio_sched_data *q = qdisc_priv(sch);
114 	int prio;
115 
116 	for (prio = 0; prio < q->bands; prio++) {
117 		struct Qdisc *qdisc = q->queues[prio];
118 		struct sk_buff *skb = qdisc_dequeue_peeked(qdisc);
119 		if (skb) {
120 			qdisc_bstats_update(sch, skb);
121 			qdisc_qstats_backlog_dec(sch, skb);
122 			sch->q.qlen--;
123 			return skb;
124 		}
125 	}
126 	return NULL;
127 
128 }
129 
130 static unsigned int prio_drop(struct Qdisc *sch)
131 {
132 	struct prio_sched_data *q = qdisc_priv(sch);
133 	int prio;
134 	unsigned int len;
135 	struct Qdisc *qdisc;
136 
137 	for (prio = q->bands-1; prio >= 0; prio--) {
138 		qdisc = q->queues[prio];
139 		if (qdisc->ops->drop && (len = qdisc->ops->drop(qdisc)) != 0) {
140 			sch->qstats.backlog -= len;
141 			sch->q.qlen--;
142 			return len;
143 		}
144 	}
145 	return 0;
146 }
147 
148 
149 static void
150 prio_reset(struct Qdisc *sch)
151 {
152 	int prio;
153 	struct prio_sched_data *q = qdisc_priv(sch);
154 
155 	for (prio = 0; prio < q->bands; prio++)
156 		qdisc_reset(q->queues[prio]);
157 	sch->qstats.backlog = 0;
158 	sch->q.qlen = 0;
159 }
160 
161 static void
162 prio_destroy(struct Qdisc *sch)
163 {
164 	int prio;
165 	struct prio_sched_data *q = qdisc_priv(sch);
166 
167 	tcf_destroy_chain(&q->filter_list);
168 	for (prio = 0; prio < q->bands; prio++)
169 		qdisc_destroy(q->queues[prio]);
170 }
171 
172 static int prio_tune(struct Qdisc *sch, struct nlattr *opt)
173 {
174 	struct prio_sched_data *q = qdisc_priv(sch);
175 	struct Qdisc *queues[TCQ_PRIO_BANDS];
176 	int oldbands = q->bands, i;
177 	struct tc_prio_qopt *qopt;
178 
179 	if (nla_len(opt) < sizeof(*qopt))
180 		return -EINVAL;
181 	qopt = nla_data(opt);
182 
183 	if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2)
184 		return -EINVAL;
185 
186 	for (i = 0; i <= TC_PRIO_MAX; i++) {
187 		if (qopt->priomap[i] >= qopt->bands)
188 			return -EINVAL;
189 	}
190 
191 	/* Before commit, make sure we can allocate all new qdiscs */
192 	for (i = oldbands; i < qopt->bands; i++) {
193 		queues[i] = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,
194 					      TC_H_MAKE(sch->handle, i + 1));
195 		if (!queues[i]) {
196 			while (i > oldbands)
197 				qdisc_destroy(queues[--i]);
198 			return -ENOMEM;
199 		}
200 	}
201 
202 	sch_tree_lock(sch);
203 	q->bands = qopt->bands;
204 	memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
205 
206 	for (i = q->bands; i < oldbands; i++) {
207 		struct Qdisc *child = q->queues[i];
208 
209 		qdisc_tree_reduce_backlog(child, child->q.qlen,
210 					  child->qstats.backlog);
211 		qdisc_destroy(child);
212 	}
213 
214 	for (i = oldbands; i < q->bands; i++)
215 		q->queues[i] = queues[i];
216 
217 	sch_tree_unlock(sch);
218 	return 0;
219 }
220 
221 static int prio_init(struct Qdisc *sch, struct nlattr *opt)
222 {
223 	if (!opt)
224 		return -EINVAL;
225 
226 	return prio_tune(sch, opt);
227 }
228 
229 static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
230 {
231 	struct prio_sched_data *q = qdisc_priv(sch);
232 	unsigned char *b = skb_tail_pointer(skb);
233 	struct tc_prio_qopt opt;
234 
235 	opt.bands = q->bands;
236 	memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX + 1);
237 
238 	if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
239 		goto nla_put_failure;
240 
241 	return skb->len;
242 
243 nla_put_failure:
244 	nlmsg_trim(skb, b);
245 	return -1;
246 }
247 
248 static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
249 		      struct Qdisc **old)
250 {
251 	struct prio_sched_data *q = qdisc_priv(sch);
252 	unsigned long band = arg - 1;
253 
254 	if (new == NULL)
255 		new = &noop_qdisc;
256 
257 	*old = qdisc_replace(sch, new, &q->queues[band]);
258 	return 0;
259 }
260 
261 static struct Qdisc *
262 prio_leaf(struct Qdisc *sch, unsigned long arg)
263 {
264 	struct prio_sched_data *q = qdisc_priv(sch);
265 	unsigned long band = arg - 1;
266 
267 	return q->queues[band];
268 }
269 
270 static unsigned long prio_get(struct Qdisc *sch, u32 classid)
271 {
272 	struct prio_sched_data *q = qdisc_priv(sch);
273 	unsigned long band = TC_H_MIN(classid);
274 
275 	if (band - 1 >= q->bands)
276 		return 0;
277 	return band;
278 }
279 
280 static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
281 {
282 	return prio_get(sch, classid);
283 }
284 
285 
286 static void prio_put(struct Qdisc *q, unsigned long cl)
287 {
288 }
289 
290 static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,
291 			   struct tcmsg *tcm)
292 {
293 	struct prio_sched_data *q = qdisc_priv(sch);
294 
295 	tcm->tcm_handle |= TC_H_MIN(cl);
296 	tcm->tcm_info = q->queues[cl-1]->handle;
297 	return 0;
298 }
299 
300 static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
301 				 struct gnet_dump *d)
302 {
303 	struct prio_sched_data *q = qdisc_priv(sch);
304 	struct Qdisc *cl_q;
305 
306 	cl_q = q->queues[cl - 1];
307 	if (gnet_stats_copy_basic(d, NULL, &cl_q->bstats) < 0 ||
308 	    gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0)
309 		return -1;
310 
311 	return 0;
312 }
313 
314 static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
315 {
316 	struct prio_sched_data *q = qdisc_priv(sch);
317 	int prio;
318 
319 	if (arg->stop)
320 		return;
321 
322 	for (prio = 0; prio < q->bands; prio++) {
323 		if (arg->count < arg->skip) {
324 			arg->count++;
325 			continue;
326 		}
327 		if (arg->fn(sch, prio + 1, arg) < 0) {
328 			arg->stop = 1;
329 			break;
330 		}
331 		arg->count++;
332 	}
333 }
334 
335 static struct tcf_proto __rcu **prio_find_tcf(struct Qdisc *sch,
336 					      unsigned long cl)
337 {
338 	struct prio_sched_data *q = qdisc_priv(sch);
339 
340 	if (cl)
341 		return NULL;
342 	return &q->filter_list;
343 }
344 
345 static const struct Qdisc_class_ops prio_class_ops = {
346 	.graft		=	prio_graft,
347 	.leaf		=	prio_leaf,
348 	.get		=	prio_get,
349 	.put		=	prio_put,
350 	.walk		=	prio_walk,
351 	.tcf_chain	=	prio_find_tcf,
352 	.bind_tcf	=	prio_bind,
353 	.unbind_tcf	=	prio_put,
354 	.dump		=	prio_dump_class,
355 	.dump_stats	=	prio_dump_class_stats,
356 };
357 
358 static struct Qdisc_ops prio_qdisc_ops __read_mostly = {
359 	.next		=	NULL,
360 	.cl_ops		=	&prio_class_ops,
361 	.id		=	"prio",
362 	.priv_size	=	sizeof(struct prio_sched_data),
363 	.enqueue	=	prio_enqueue,
364 	.dequeue	=	prio_dequeue,
365 	.peek		=	prio_peek,
366 	.drop		=	prio_drop,
367 	.init		=	prio_init,
368 	.reset		=	prio_reset,
369 	.destroy	=	prio_destroy,
370 	.change		=	prio_tune,
371 	.dump		=	prio_dump,
372 	.owner		=	THIS_MODULE,
373 };
374 
375 static int __init prio_module_init(void)
376 {
377 	return register_qdisc(&prio_qdisc_ops);
378 }
379 
380 static void __exit prio_module_exit(void)
381 {
382 	unregister_qdisc(&prio_qdisc_ops);
383 }
384 
385 module_init(prio_module_init)
386 module_exit(prio_module_exit)
387 
388 MODULE_LICENSE("GPL");
389