2 * net/sched/sch_prio.c Simple 3-band priority "scheduler".
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.
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 * Fixes: 19990609: J Hadi Salim <hadi@nortelnetworks.com>:
11 * Init -- EINVAL when opt undefined
14 #include <linux/config.h>
15 #include <linux/module.h>
16 #include <asm/uaccess.h>
17 #include <asm/system.h>
18 #include <linux/bitops.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/string.h>
24 #include <linux/socket.h>
25 #include <linux/sockios.h>
27 #include <linux/errno.h>
28 #include <linux/interrupt.h>
29 #include <linux/if_ether.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/etherdevice.h>
33 #include <linux/notifier.h>
35 #include <net/route.h>
36 #include <linux/skbuff.h>
38 #include <net/pkt_sched.h>
41 struct prio_sched_data
44 struct tcf_proto
*filter_list
;
45 u8 prio2band
[TC_PRIO_MAX
+1];
46 struct Qdisc
*queues
[TCQ_PRIO_BANDS
];
51 prio_classify(struct sk_buff
*skb
, struct Qdisc
*sch
, int *qerr
)
53 struct prio_sched_data
*q
= qdisc_priv(sch
);
54 u32 band
= skb
->priority
;
55 struct tcf_result res
;
57 *qerr
= NET_XMIT_DROP
;
58 if (TC_H_MAJ(skb
->priority
) != sch
->handle
) {
59 #ifdef CONFIG_NET_CLS_ACT
60 switch (tc_classify(skb
, q
->filter_list
, &res
)) {
63 *qerr
= NET_XMIT_SUCCESS
;
68 if (!q
->filter_list
) {
70 if (!q
->filter_list
|| tc_classify(skb
, q
->filter_list
, &res
)) {
74 return q
->queues
[q
->prio2band
[band
&TC_PRIO_MAX
]];
78 band
= TC_H_MIN(band
) - 1;
80 return q
->queues
[q
->prio2band
[0]];
82 return q
->queues
[band
];
86 prio_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
91 qdisc
= prio_classify(skb
, sch
, &ret
);
92 #ifdef CONFIG_NET_CLS_ACT
94 if (ret
== NET_XMIT_DROP
)
101 if ((ret
= qdisc
->enqueue(skb
, qdisc
)) == NET_XMIT_SUCCESS
) {
102 sch
->bstats
.bytes
+= skb
->len
;
103 sch
->bstats
.packets
++;
105 return NET_XMIT_SUCCESS
;
113 prio_requeue(struct sk_buff
*skb
, struct Qdisc
* sch
)
118 qdisc
= prio_classify(skb
, sch
, &ret
);
119 #ifdef CONFIG_NET_CLS_ACT
121 if (ret
== NET_XMIT_DROP
)
128 if ((ret
= qdisc
->ops
->requeue(skb
, qdisc
)) == NET_XMIT_SUCCESS
) {
130 sch
->qstats
.requeues
++;
134 return NET_XMIT_DROP
;
138 static struct sk_buff
*
139 prio_dequeue(struct Qdisc
* sch
)
142 struct prio_sched_data
*q
= qdisc_priv(sch
);
146 for (prio
= 0; prio
< q
->bands
; prio
++) {
147 qdisc
= q
->queues
[prio
];
148 skb
= qdisc
->dequeue(qdisc
);
158 static unsigned int prio_drop(struct Qdisc
* sch
)
160 struct prio_sched_data
*q
= qdisc_priv(sch
);
165 for (prio
= q
->bands
-1; prio
>= 0; prio
--) {
166 qdisc
= q
->queues
[prio
];
167 if ((len
= qdisc
->ops
->drop(qdisc
)) != 0) {
177 prio_reset(struct Qdisc
* sch
)
180 struct prio_sched_data
*q
= qdisc_priv(sch
);
182 for (prio
=0; prio
<q
->bands
; prio
++)
183 qdisc_reset(q
->queues
[prio
]);
188 prio_destroy(struct Qdisc
* sch
)
191 struct prio_sched_data
*q
= qdisc_priv(sch
);
192 struct tcf_proto
*tp
;
194 while ((tp
= q
->filter_list
) != NULL
) {
195 q
->filter_list
= tp
->next
;
199 for (prio
=0; prio
<q
->bands
; prio
++)
200 qdisc_destroy(q
->queues
[prio
]);
203 static int prio_tune(struct Qdisc
*sch
, struct rtattr
*opt
)
205 struct prio_sched_data
*q
= qdisc_priv(sch
);
206 struct tc_prio_qopt
*qopt
= RTA_DATA(opt
);
209 if (opt
->rta_len
< RTA_LENGTH(sizeof(*qopt
)))
211 if (qopt
->bands
> TCQ_PRIO_BANDS
|| qopt
->bands
< 2)
214 for (i
=0; i
<=TC_PRIO_MAX
; i
++) {
215 if (qopt
->priomap
[i
] >= qopt
->bands
)
220 q
->bands
= qopt
->bands
;
221 memcpy(q
->prio2band
, qopt
->priomap
, TC_PRIO_MAX
+1);
223 for (i
=q
->bands
; i
<TCQ_PRIO_BANDS
; i
++) {
224 struct Qdisc
*child
= xchg(&q
->queues
[i
], &noop_qdisc
);
225 if (child
!= &noop_qdisc
)
226 qdisc_destroy(child
);
228 sch_tree_unlock(sch
);
230 for (i
=0; i
<=TC_PRIO_MAX
; i
++) {
231 int band
= q
->prio2band
[i
];
232 if (q
->queues
[band
] == &noop_qdisc
) {
234 child
= qdisc_create_dflt(sch
->dev
, &pfifo_qdisc_ops
);
237 child
= xchg(&q
->queues
[band
], child
);
239 if (child
!= &noop_qdisc
)
240 qdisc_destroy(child
);
241 sch_tree_unlock(sch
);
248 static int prio_init(struct Qdisc
*sch
, struct rtattr
*opt
)
250 struct prio_sched_data
*q
= qdisc_priv(sch
);
253 for (i
=0; i
<TCQ_PRIO_BANDS
; i
++)
254 q
->queues
[i
] = &noop_qdisc
;
261 if ((err
= prio_tune(sch
, opt
)) != 0)
267 static int prio_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
269 struct prio_sched_data
*q
= qdisc_priv(sch
);
270 unsigned char *b
= skb
->tail
;
271 struct tc_prio_qopt opt
;
273 opt
.bands
= q
->bands
;
274 memcpy(&opt
.priomap
, q
->prio2band
, TC_PRIO_MAX
+1);
275 RTA_PUT(skb
, TCA_OPTIONS
, sizeof(opt
), &opt
);
279 skb_trim(skb
, b
- skb
->data
);
283 static int prio_graft(struct Qdisc
*sch
, unsigned long arg
, struct Qdisc
*new,
286 struct prio_sched_data
*q
= qdisc_priv(sch
);
287 unsigned long band
= arg
- 1;
289 if (band
>= q
->bands
)
296 *old
= q
->queues
[band
];
297 q
->queues
[band
] = new;
298 sch
->q
.qlen
-= (*old
)->q
.qlen
;
300 sch_tree_unlock(sch
);
305 static struct Qdisc
*
306 prio_leaf(struct Qdisc
*sch
, unsigned long arg
)
308 struct prio_sched_data
*q
= qdisc_priv(sch
);
309 unsigned long band
= arg
- 1;
311 if (band
>= q
->bands
)
314 return q
->queues
[band
];
317 static unsigned long prio_get(struct Qdisc
*sch
, u32 classid
)
319 struct prio_sched_data
*q
= qdisc_priv(sch
);
320 unsigned long band
= TC_H_MIN(classid
);
322 if (band
- 1 >= q
->bands
)
327 static unsigned long prio_bind(struct Qdisc
*sch
, unsigned long parent
, u32 classid
)
329 return prio_get(sch
, classid
);
333 static void prio_put(struct Qdisc
*q
, unsigned long cl
)
338 static int prio_change(struct Qdisc
*sch
, u32 handle
, u32 parent
, struct rtattr
**tca
, unsigned long *arg
)
340 unsigned long cl
= *arg
;
341 struct prio_sched_data
*q
= qdisc_priv(sch
);
343 if (cl
- 1 > q
->bands
)
348 static int prio_delete(struct Qdisc
*sch
, unsigned long cl
)
350 struct prio_sched_data
*q
= qdisc_priv(sch
);
351 if (cl
- 1 > q
->bands
)
357 static int prio_dump_class(struct Qdisc
*sch
, unsigned long cl
, struct sk_buff
*skb
,
360 struct prio_sched_data
*q
= qdisc_priv(sch
);
362 if (cl
- 1 > q
->bands
)
364 tcm
->tcm_handle
|= TC_H_MIN(cl
);
366 tcm
->tcm_info
= q
->queues
[cl
-1]->handle
;
370 static void prio_walk(struct Qdisc
*sch
, struct qdisc_walker
*arg
)
372 struct prio_sched_data
*q
= qdisc_priv(sch
);
378 for (prio
= 0; prio
< q
->bands
; prio
++) {
379 if (arg
->count
< arg
->skip
) {
383 if (arg
->fn(sch
, prio
+1, arg
) < 0) {
391 static struct tcf_proto
** prio_find_tcf(struct Qdisc
*sch
, unsigned long cl
)
393 struct prio_sched_data
*q
= qdisc_priv(sch
);
397 return &q
->filter_list
;
400 static struct Qdisc_class_ops prio_class_ops
= {
405 .change
= prio_change
,
406 .delete = prio_delete
,
408 .tcf_chain
= prio_find_tcf
,
409 .bind_tcf
= prio_bind
,
410 .unbind_tcf
= prio_put
,
411 .dump
= prio_dump_class
,
414 static struct Qdisc_ops prio_qdisc_ops
= {
416 .cl_ops
= &prio_class_ops
,
418 .priv_size
= sizeof(struct prio_sched_data
),
419 .enqueue
= prio_enqueue
,
420 .dequeue
= prio_dequeue
,
421 .requeue
= prio_requeue
,
425 .destroy
= prio_destroy
,
428 .owner
= THIS_MODULE
,
431 static int __init
prio_module_init(void)
433 return register_qdisc(&prio_qdisc_ops
);
436 static void __exit
prio_module_exit(void)
438 unregister_qdisc(&prio_qdisc_ops
);
441 module_init(prio_module_init
)
442 module_exit(prio_module_exit
)
444 MODULE_LICENSE("GPL");