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/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>
25 struct prio_sched_data
{
27 struct tcf_proto __rcu
*filter_list
;
28 struct tcf_block
*block
;
29 u8 prio2band
[TC_PRIO_MAX
+1];
30 struct Qdisc
*queues
[TCQ_PRIO_BANDS
];
35 prio_classify(struct sk_buff
*skb
, struct Qdisc
*sch
, int *qerr
)
37 struct prio_sched_data
*q
= qdisc_priv(sch
);
38 u32 band
= skb
->priority
;
39 struct tcf_result res
;
43 *qerr
= NET_XMIT_SUCCESS
| __NET_XMIT_BYPASS
;
44 if (TC_H_MAJ(skb
->priority
) != sch
->handle
) {
45 fl
= rcu_dereference_bh(q
->filter_list
);
46 err
= tcf_classify(skb
, fl
, &res
, false);
47 #ifdef CONFIG_NET_CLS_ACT
52 *qerr
= NET_XMIT_SUCCESS
| __NET_XMIT_STOLEN
;
61 return q
->queues
[q
->prio2band
[band
& TC_PRIO_MAX
]];
65 band
= TC_H_MIN(band
) - 1;
67 return q
->queues
[q
->prio2band
[0]];
69 return q
->queues
[band
];
73 prio_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
, struct sk_buff
**to_free
)
75 unsigned int len
= qdisc_pkt_len(skb
);
79 qdisc
= prio_classify(skb
, sch
, &ret
);
80 #ifdef CONFIG_NET_CLS_ACT
83 if (ret
& __NET_XMIT_BYPASS
)
84 qdisc_qstats_drop(sch
);
85 __qdisc_drop(skb
, to_free
);
90 ret
= qdisc_enqueue(skb
, qdisc
, to_free
);
91 if (ret
== NET_XMIT_SUCCESS
) {
92 sch
->qstats
.backlog
+= len
;
94 return NET_XMIT_SUCCESS
;
96 if (net_xmit_drop_count(ret
))
97 qdisc_qstats_drop(sch
);
101 static struct sk_buff
*prio_peek(struct Qdisc
*sch
)
103 struct prio_sched_data
*q
= qdisc_priv(sch
);
106 for (prio
= 0; prio
< q
->bands
; prio
++) {
107 struct Qdisc
*qdisc
= q
->queues
[prio
];
108 struct sk_buff
*skb
= qdisc
->ops
->peek(qdisc
);
115 static struct sk_buff
*prio_dequeue(struct Qdisc
*sch
)
117 struct prio_sched_data
*q
= qdisc_priv(sch
);
120 for (prio
= 0; prio
< q
->bands
; prio
++) {
121 struct Qdisc
*qdisc
= q
->queues
[prio
];
122 struct sk_buff
*skb
= qdisc_dequeue_peeked(qdisc
);
124 qdisc_bstats_update(sch
, skb
);
125 qdisc_qstats_backlog_dec(sch
, skb
);
135 prio_reset(struct Qdisc
*sch
)
138 struct prio_sched_data
*q
= qdisc_priv(sch
);
140 for (prio
= 0; prio
< q
->bands
; prio
++)
141 qdisc_reset(q
->queues
[prio
]);
142 sch
->qstats
.backlog
= 0;
146 static int prio_offload(struct Qdisc
*sch
, struct tc_prio_qopt
*qopt
)
148 struct net_device
*dev
= qdisc_dev(sch
);
149 struct tc_prio_qopt_offload opt
= {
150 .handle
= sch
->handle
,
151 .parent
= sch
->parent
,
154 if (!tc_can_offload(dev
) || !dev
->netdev_ops
->ndo_setup_tc
)
158 opt
.command
= TC_PRIO_REPLACE
;
159 opt
.replace_params
.bands
= qopt
->bands
;
160 memcpy(&opt
.replace_params
.priomap
, qopt
->priomap
,
162 opt
.replace_params
.qstats
= &sch
->qstats
;
164 opt
.command
= TC_PRIO_DESTROY
;
167 return dev
->netdev_ops
->ndo_setup_tc(dev
, TC_SETUP_QDISC_PRIO
, &opt
);
171 prio_destroy(struct Qdisc
*sch
)
174 struct prio_sched_data
*q
= qdisc_priv(sch
);
176 tcf_block_put(q
->block
);
177 prio_offload(sch
, NULL
);
178 for (prio
= 0; prio
< q
->bands
; prio
++)
179 qdisc_put(q
->queues
[prio
]);
182 static int prio_tune(struct Qdisc
*sch
, struct nlattr
*opt
,
183 struct netlink_ext_ack
*extack
)
185 struct prio_sched_data
*q
= qdisc_priv(sch
);
186 struct Qdisc
*queues
[TCQ_PRIO_BANDS
];
187 int oldbands
= q
->bands
, i
;
188 struct tc_prio_qopt
*qopt
;
190 if (nla_len(opt
) < sizeof(*qopt
))
192 qopt
= nla_data(opt
);
194 if (qopt
->bands
> TCQ_PRIO_BANDS
|| qopt
->bands
< 2)
197 for (i
= 0; i
<= TC_PRIO_MAX
; i
++) {
198 if (qopt
->priomap
[i
] >= qopt
->bands
)
202 /* Before commit, make sure we can allocate all new qdiscs */
203 for (i
= oldbands
; i
< qopt
->bands
; i
++) {
204 queues
[i
] = qdisc_create_dflt(sch
->dev_queue
, &pfifo_qdisc_ops
,
205 TC_H_MAKE(sch
->handle
, i
+ 1),
209 qdisc_put(queues
[--i
]);
214 prio_offload(sch
, qopt
);
216 q
->bands
= qopt
->bands
;
217 memcpy(q
->prio2band
, qopt
->priomap
, TC_PRIO_MAX
+1);
219 for (i
= q
->bands
; i
< oldbands
; i
++)
220 qdisc_tree_flush_backlog(q
->queues
[i
]);
222 for (i
= oldbands
; i
< q
->bands
; i
++) {
223 q
->queues
[i
] = queues
[i
];
224 if (q
->queues
[i
] != &noop_qdisc
)
225 qdisc_hash_add(q
->queues
[i
], true);
228 sch_tree_unlock(sch
);
230 for (i
= q
->bands
; i
< oldbands
; i
++)
231 qdisc_put(q
->queues
[i
]);
235 static int prio_init(struct Qdisc
*sch
, struct nlattr
*opt
,
236 struct netlink_ext_ack
*extack
)
238 struct prio_sched_data
*q
= qdisc_priv(sch
);
244 err
= tcf_block_get(&q
->block
, &q
->filter_list
, sch
, extack
);
248 return prio_tune(sch
, opt
, extack
);
251 static int prio_dump_offload(struct Qdisc
*sch
)
253 struct tc_prio_qopt_offload hw_stats
= {
254 .command
= TC_PRIO_STATS
,
255 .handle
= sch
->handle
,
256 .parent
= sch
->parent
,
259 .bstats
= &sch
->bstats
,
260 .qstats
= &sch
->qstats
,
265 return qdisc_offload_dump_helper(sch
, TC_SETUP_QDISC_PRIO
, &hw_stats
);
268 static int prio_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
270 struct prio_sched_data
*q
= qdisc_priv(sch
);
271 unsigned char *b
= skb_tail_pointer(skb
);
272 struct tc_prio_qopt opt
;
275 opt
.bands
= q
->bands
;
276 memcpy(&opt
.priomap
, q
->prio2band
, TC_PRIO_MAX
+ 1);
278 err
= prio_dump_offload(sch
);
280 goto nla_put_failure
;
282 if (nla_put(skb
, TCA_OPTIONS
, sizeof(opt
), &opt
))
283 goto nla_put_failure
;
292 static int prio_graft(struct Qdisc
*sch
, unsigned long arg
, struct Qdisc
*new,
293 struct Qdisc
**old
, struct netlink_ext_ack
*extack
)
295 struct prio_sched_data
*q
= qdisc_priv(sch
);
296 struct tc_prio_qopt_offload graft_offload
;
297 unsigned long band
= arg
- 1;
302 *old
= qdisc_replace(sch
, new, &q
->queues
[band
]);
304 graft_offload
.handle
= sch
->handle
;
305 graft_offload
.parent
= sch
->parent
;
306 graft_offload
.graft_params
.band
= band
;
307 graft_offload
.graft_params
.child_handle
= new->handle
;
308 graft_offload
.command
= TC_PRIO_GRAFT
;
310 qdisc_offload_graft_helper(qdisc_dev(sch
), sch
, new, *old
,
311 TC_SETUP_QDISC_PRIO
, &graft_offload
,
316 static struct Qdisc
*
317 prio_leaf(struct Qdisc
*sch
, unsigned long arg
)
319 struct prio_sched_data
*q
= qdisc_priv(sch
);
320 unsigned long band
= arg
- 1;
322 return q
->queues
[band
];
325 static unsigned long prio_find(struct Qdisc
*sch
, u32 classid
)
327 struct prio_sched_data
*q
= qdisc_priv(sch
);
328 unsigned long band
= TC_H_MIN(classid
);
330 if (band
- 1 >= q
->bands
)
335 static unsigned long prio_bind(struct Qdisc
*sch
, unsigned long parent
, u32 classid
)
337 return prio_find(sch
, classid
);
341 static void prio_unbind(struct Qdisc
*q
, unsigned long cl
)
345 static int prio_dump_class(struct Qdisc
*sch
, unsigned long cl
, struct sk_buff
*skb
,
348 struct prio_sched_data
*q
= qdisc_priv(sch
);
350 tcm
->tcm_handle
|= TC_H_MIN(cl
);
351 tcm
->tcm_info
= q
->queues
[cl
-1]->handle
;
355 static int prio_dump_class_stats(struct Qdisc
*sch
, unsigned long cl
,
358 struct prio_sched_data
*q
= qdisc_priv(sch
);
361 cl_q
= q
->queues
[cl
- 1];
362 if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch
),
363 d
, NULL
, &cl_q
->bstats
) < 0 ||
364 qdisc_qstats_copy(d
, cl_q
) < 0)
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_block
*prio_tcf_block(struct Qdisc
*sch
, unsigned long cl
,
392 struct netlink_ext_ack
*extack
)
394 struct prio_sched_data
*q
= qdisc_priv(sch
);
401 static const struct Qdisc_class_ops prio_class_ops
= {
406 .tcf_block
= prio_tcf_block
,
407 .bind_tcf
= prio_bind
,
408 .unbind_tcf
= prio_unbind
,
409 .dump
= prio_dump_class
,
410 .dump_stats
= prio_dump_class_stats
,
413 static struct Qdisc_ops prio_qdisc_ops __read_mostly
= {
415 .cl_ops
= &prio_class_ops
,
417 .priv_size
= sizeof(struct prio_sched_data
),
418 .enqueue
= prio_enqueue
,
419 .dequeue
= prio_dequeue
,
423 .destroy
= prio_destroy
,
426 .owner
= THIS_MODULE
,
429 static int __init
prio_module_init(void)
431 return register_qdisc(&prio_qdisc_ops
);
434 static void __exit
prio_module_exit(void)
436 unregister_qdisc(&prio_qdisc_ops
);
439 module_init(prio_module_init
)
440 module_exit(prio_module_exit
)
442 MODULE_LICENSE("GPL");