xref: /linux/net/sched/sch_prio.c (revision e5c86679d5e864947a52fb31e45a425dea3e7fa9) 
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 #include <net/pkt_cls.h>
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, struct sk_buff **to_free)
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, to_free);
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 void
131 prio_reset(struct Qdisc *sch)
132 {
133 	int prio;
134 	struct prio_sched_data *q = qdisc_priv(sch);
135 
136 	for (prio = 0; prio < q->bands; prio++)
137 		qdisc_reset(q->queues[prio]);
138 	sch->qstats.backlog = 0;
139 	sch->q.qlen = 0;
140 }
141 
142 static void
143 prio_destroy(struct Qdisc *sch)
144 {
145 	int prio;
146 	struct prio_sched_data *q = qdisc_priv(sch);
147 
148 	tcf_destroy_chain(&q->filter_list);
149 	for (prio = 0; prio < q->bands; prio++)
150 		qdisc_destroy(q->queues[prio]);
151 }
152 
153 static int prio_tune(struct Qdisc *sch, struct nlattr *opt)
154 {
155 	struct prio_sched_data *q = qdisc_priv(sch);
156 	struct Qdisc *queues[TCQ_PRIO_BANDS];
157 	int oldbands = q->bands, i;
158 	struct tc_prio_qopt *qopt;
159 
160 	if (nla_len(opt) < sizeof(*qopt))
161 		return -EINVAL;
162 	qopt = nla_data(opt);
163 
164 	if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2)
165 		return -EINVAL;
166 
167 	for (i = 0; i <= TC_PRIO_MAX; i++) {
168 		if (qopt->priomap[i] >= qopt->bands)
169 			return -EINVAL;
170 	}
171 
172 	/* Before commit, make sure we can allocate all new qdiscs */
173 	for (i = oldbands; i < qopt->bands; i++) {
174 		queues[i] = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,
175 					      TC_H_MAKE(sch->handle, i + 1));
176 		if (!queues[i]) {
177 			while (i > oldbands)
178 				qdisc_destroy(queues[--i]);
179 			return -ENOMEM;
180 		}
181 	}
182 
183 	sch_tree_lock(sch);
184 	q->bands = qopt->bands;
185 	memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
186 
187 	for (i = q->bands; i < oldbands; i++) {
188 		struct Qdisc *child = q->queues[i];
189 
190 		qdisc_tree_reduce_backlog(child, child->q.qlen,
191 					  child->qstats.backlog);
192 		qdisc_destroy(child);
193 	}
194 
195 	for (i = oldbands; i < q->bands; i++)
196 		q->queues[i] = queues[i];
197 
198 	sch_tree_unlock(sch);
199 	return 0;
200 }
201 
202 static int prio_init(struct Qdisc *sch, struct nlattr *opt)
203 {
204 	if (!opt)
205 		return -EINVAL;
206 
207 	return prio_tune(sch, opt);
208 }
209 
210 static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
211 {
212 	struct prio_sched_data *q = qdisc_priv(sch);
213 	unsigned char *b = skb_tail_pointer(skb);
214 	struct tc_prio_qopt opt;
215 
216 	opt.bands = q->bands;
217 	memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX + 1);
218 
219 	if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
220 		goto nla_put_failure;
221 
222 	return skb->len;
223 
224 nla_put_failure:
225 	nlmsg_trim(skb, b);
226 	return -1;
227 }
228 
229 static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
230 		      struct Qdisc **old)
231 {
232 	struct prio_sched_data *q = qdisc_priv(sch);
233 	unsigned long band = arg - 1;
234 
235 	if (new == NULL)
236 		new = &noop_qdisc;
237 
238 	*old = qdisc_replace(sch, new, &q->queues[band]);
239 	return 0;
240 }
241 
242 static struct Qdisc *
243 prio_leaf(struct Qdisc *sch, unsigned long arg)
244 {
245 	struct prio_sched_data *q = qdisc_priv(sch);
246 	unsigned long band = arg - 1;
247 
248 	return q->queues[band];
249 }
250 
251 static unsigned long prio_get(struct Qdisc *sch, u32 classid)
252 {
253 	struct prio_sched_data *q = qdisc_priv(sch);
254 	unsigned long band = TC_H_MIN(classid);
255 
256 	if (band - 1 >= q->bands)
257 		return 0;
258 	return band;
259 }
260 
261 static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
262 {
263 	return prio_get(sch, classid);
264 }
265 
266 
267 static void prio_put(struct Qdisc *q, unsigned long cl)
268 {
269 }
270 
271 static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,
272 			   struct tcmsg *tcm)
273 {
274 	struct prio_sched_data *q = qdisc_priv(sch);
275 
276 	tcm->tcm_handle |= TC_H_MIN(cl);
277 	tcm->tcm_info = q->queues[cl-1]->handle;
278 	return 0;
279 }
280 
281 static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
282 				 struct gnet_dump *d)
283 {
284 	struct prio_sched_data *q = qdisc_priv(sch);
285 	struct Qdisc *cl_q;
286 
287 	cl_q = q->queues[cl - 1];
288 	if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch),
289 				  d, NULL, &cl_q->bstats) < 0 ||
290 	    gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0)
291 		return -1;
292 
293 	return 0;
294 }
295 
296 static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
297 {
298 	struct prio_sched_data *q = qdisc_priv(sch);
299 	int prio;
300 
301 	if (arg->stop)
302 		return;
303 
304 	for (prio = 0; prio < q->bands; prio++) {
305 		if (arg->count < arg->skip) {
306 			arg->count++;
307 			continue;
308 		}
309 		if (arg->fn(sch, prio + 1, arg) < 0) {
310 			arg->stop = 1;
311 			break;
312 		}
313 		arg->count++;
314 	}
315 }
316 
317 static struct tcf_proto __rcu **prio_find_tcf(struct Qdisc *sch,
318 					      unsigned long cl)
319 {
320 	struct prio_sched_data *q = qdisc_priv(sch);
321 
322 	if (cl)
323 		return NULL;
324 	return &q->filter_list;
325 }
326 
327 static const struct Qdisc_class_ops prio_class_ops = {
328 	.graft		=	prio_graft,
329 	.leaf		=	prio_leaf,
330 	.get		=	prio_get,
331 	.put		=	prio_put,
332 	.walk		=	prio_walk,
333 	.tcf_chain	=	prio_find_tcf,
334 	.bind_tcf	=	prio_bind,
335 	.unbind_tcf	=	prio_put,
336 	.dump		=	prio_dump_class,
337 	.dump_stats	=	prio_dump_class_stats,
338 };
339 
340 static struct Qdisc_ops prio_qdisc_ops __read_mostly = {
341 	.next		=	NULL,
342 	.cl_ops		=	&prio_class_ops,
343 	.id		=	"prio",
344 	.priv_size	=	sizeof(struct prio_sched_data),
345 	.enqueue	=	prio_enqueue,
346 	.dequeue	=	prio_dequeue,
347 	.peek		=	prio_peek,
348 	.init		=	prio_init,
349 	.reset		=	prio_reset,
350 	.destroy	=	prio_destroy,
351 	.change		=	prio_tune,
352 	.dump		=	prio_dump,
353 	.owner		=	THIS_MODULE,
354 };
355 
356 static int __init prio_module_init(void)
357 {
358 	return register_qdisc(&prio_qdisc_ops);
359 }
360 
361 static void __exit prio_module_exit(void)
362 {
363 	unregister_qdisc(&prio_qdisc_ops);
364 }
365 
366 module_init(prio_module_init)
367 module_exit(prio_module_exit)
368 
369 MODULE_LICENSE("GPL");
370