URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [net/] [sched/] [sch_prio.c] - Blame information for rev 17

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * net/sched/sch_prio.c Simple 3-band priority "scheduler".
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 * Fixes:       19990609: J Hadi Salim <hadi@nortelnetworks.com>:
 *              Init --  EINVAL when opt undefined
 */
 
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
#include <net/netlink.h>
#include <net/pkt_sched.h>
 
 
struct prio_sched_data
{
        int bands;
        int curband; /* for round-robin */
        struct tcf_proto *filter_list;
        u8  prio2band[TC_PRIO_MAX+1];
        struct Qdisc *queues[TCQ_PRIO_BANDS];
        int mq;
};
 
 
static struct Qdisc *
prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        u32 band = skb->priority;
        struct tcf_result res;
        int err;
 
        *qerr = NET_XMIT_BYPASS;
        if (TC_H_MAJ(skb->priority) != sch->handle) {
                err = tc_classify(skb, q->filter_list, &res);
#ifdef CONFIG_NET_CLS_ACT
                switch (err) {
                case TC_ACT_STOLEN:
                case TC_ACT_QUEUED:
                        *qerr = NET_XMIT_SUCCESS;
                case TC_ACT_SHOT:
                        return NULL;
                }
#endif
                if (!q->filter_list || err < 0) {
                        if (TC_H_MAJ(band))
                                band = 0;
                        band = q->prio2band[band&TC_PRIO_MAX];
                        goto out;
                }
                band = res.classid;
        }
        band = TC_H_MIN(band) - 1;
        if (band >= q->bands)
                band = q->prio2band[0];
out:
        if (q->mq)
                skb_set_queue_mapping(skb, band);
        return q->queues[band];
}
 
static int
prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
{
        struct Qdisc *qdisc;
        int ret;
 
        qdisc = prio_classify(skb, sch, &ret);
#ifdef CONFIG_NET_CLS_ACT
        if (qdisc == NULL) {
 
                if (ret == NET_XMIT_BYPASS)
                        sch->qstats.drops++;
                kfree_skb(skb);
                return ret;
        }
#endif
 
        if ((ret = qdisc->enqueue(skb, qdisc)) == NET_XMIT_SUCCESS) {
                sch->bstats.bytes += skb->len;
                sch->bstats.packets++;
                sch->q.qlen++;
                return NET_XMIT_SUCCESS;
        }
        sch->qstats.drops++;
        return ret;
}
 
 
static int
prio_requeue(struct sk_buff *skb, struct Qdisc* sch)
{
        struct Qdisc *qdisc;
        int ret;
 
        qdisc = prio_classify(skb, sch, &ret);
#ifdef CONFIG_NET_CLS_ACT
        if (qdisc == NULL) {
                if (ret == NET_XMIT_BYPASS)
                        sch->qstats.drops++;
                kfree_skb(skb);
                return ret;
        }
#endif
 
        if ((ret = qdisc->ops->requeue(skb, qdisc)) == NET_XMIT_SUCCESS) {
                sch->q.qlen++;
                sch->qstats.requeues++;
                return 0;
        }
        sch->qstats.drops++;
        return NET_XMIT_DROP;
}
 
 
static struct sk_buff *
prio_dequeue(struct Qdisc* sch)
{
        struct sk_buff *skb;
        struct prio_sched_data *q = qdisc_priv(sch);
        int prio;
        struct Qdisc *qdisc;
 
        for (prio = 0; prio < q->bands; prio++) {
                /* Check if the target subqueue is available before
                 * pulling an skb.  This way we avoid excessive requeues
                 * for slower queues.
                 */
                if (!__netif_subqueue_stopped(sch->dev, (q->mq ? prio : 0))) {
                        qdisc = q->queues[prio];
                        skb = qdisc->dequeue(qdisc);
                        if (skb) {
                                sch->q.qlen--;
                                return skb;
                        }
                }
        }
        return NULL;
 
}
 
static struct sk_buff *rr_dequeue(struct Qdisc* sch)
{
        struct sk_buff *skb;
        struct prio_sched_data *q = qdisc_priv(sch);
        struct Qdisc *qdisc;
        int bandcount;
 
        /* Only take one pass through the queues.  If nothing is available,
         * return nothing.
         */
        for (bandcount = 0; bandcount < q->bands; bandcount++) {
                /* Check if the target subqueue is available before
                 * pulling an skb.  This way we avoid excessive requeues
                 * for slower queues.  If the queue is stopped, try the
                 * next queue.
                 */
                if (!__netif_subqueue_stopped(sch->dev,
                                            (q->mq ? q->curband : 0))) {
                        qdisc = q->queues[q->curband];
                        skb = qdisc->dequeue(qdisc);
                        if (skb) {
                                sch->q.qlen--;
                                q->curband++;
                                if (q->curband >= q->bands)
                                        q->curband = 0;
                                return skb;
                        }
                }
                q->curband++;
                if (q->curband >= q->bands)
                        q->curband = 0;
        }
        return NULL;
}
 
static unsigned int prio_drop(struct Qdisc* sch)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        int prio;
        unsigned int len;
        struct Qdisc *qdisc;
 
        for (prio = q->bands-1; prio >= 0; prio--) {
                qdisc = q->queues[prio];
                if (qdisc->ops->drop && (len = qdisc->ops->drop(qdisc)) != 0) {
                        sch->q.qlen--;
                        return len;
                }
        }
        return 0;
}
 
 
static void
prio_reset(struct Qdisc* sch)
{
        int prio;
        struct prio_sched_data *q = qdisc_priv(sch);
 
        for (prio=0; prio<q->bands; prio++)
                qdisc_reset(q->queues[prio]);
        sch->q.qlen = 0;
}
 
static void
prio_destroy(struct Qdisc* sch)
{
        int prio;
        struct prio_sched_data *q = qdisc_priv(sch);
 
        tcf_destroy_chain(q->filter_list);
        for (prio=0; prio<q->bands; prio++)
                qdisc_destroy(q->queues[prio]);
}
 
static int prio_tune(struct Qdisc *sch, struct rtattr *opt)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        struct tc_prio_qopt *qopt;
        struct rtattr *tb[TCA_PRIO_MAX];
        int i;
 
        if (rtattr_parse_nested_compat(tb, TCA_PRIO_MAX, opt, qopt,
                                       sizeof(*qopt)))
                return -EINVAL;
        q->bands = qopt->bands;
        /* If we're multiqueue, make sure the number of incoming bands
         * matches the number of queues on the device we're associating with.
         * If the number of bands requested is zero, then set q->bands to
         * dev->egress_subqueue_count.  Also, the root qdisc must be the
         * only one that is enabled for multiqueue, since it's the only one
         * that interacts with the underlying device.
         */
        q->mq = RTA_GET_FLAG(tb[TCA_PRIO_MQ - 1]);
        if (q->mq) {
                if (sch->parent != TC_H_ROOT)
                        return -EINVAL;
                if (netif_is_multiqueue(sch->dev)) {
                        if (q->bands == 0)
                                q->bands = sch->dev->egress_subqueue_count;
                        else if (q->bands != sch->dev->egress_subqueue_count)
                                return -EINVAL;
                } else
                        return -EOPNOTSUPP;
        }
 
        if (q->bands > TCQ_PRIO_BANDS || q->bands < 2)
                return -EINVAL;
 
        for (i=0; i<=TC_PRIO_MAX; i++) {
                if (qopt->priomap[i] >= q->bands)
                        return -EINVAL;
        }
 
        sch_tree_lock(sch);
        memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
 
        for (i=q->bands; i<TCQ_PRIO_BANDS; i++) {
                struct Qdisc *child = xchg(&q->queues[i], &noop_qdisc);
                if (child != &noop_qdisc) {
                        qdisc_tree_decrease_qlen(child, child->q.qlen);
                        qdisc_destroy(child);
                }
        }
        sch_tree_unlock(sch);
 
        for (i=0; i<q->bands; i++) {
                if (q->queues[i] == &noop_qdisc) {
                        struct Qdisc *child;
                        child = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops,
                                                  TC_H_MAKE(sch->handle, i + 1));
                        if (child) {
                                sch_tree_lock(sch);
                                child = xchg(&q->queues[i], child);
 
                                if (child != &noop_qdisc) {
                                        qdisc_tree_decrease_qlen(child,
                                                                 child->q.qlen);
                                        qdisc_destroy(child);
                                }
                                sch_tree_unlock(sch);
                        }
                }
        }
        return 0;
}
 
static int prio_init(struct Qdisc *sch, struct rtattr *opt)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        int i;
 
        for (i=0; i<TCQ_PRIO_BANDS; i++)
                q->queues[i] = &noop_qdisc;
 
        if (opt == NULL) {
                return -EINVAL;
        } else {
                int err;
 
                if ((err= prio_tune(sch, opt)) != 0)
                        return err;
        }
        return 0;
}
 
static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        unsigned char *b = skb_tail_pointer(skb);
        struct rtattr *nest;
        struct tc_prio_qopt opt;
 
        opt.bands = q->bands;
        memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX+1);
 
        nest = RTA_NEST_COMPAT(skb, TCA_OPTIONS, sizeof(opt), &opt);
        if (q->mq)
                RTA_PUT_FLAG(skb, TCA_PRIO_MQ);
        RTA_NEST_COMPAT_END(skb, nest);
 
        return skb->len;
 
rtattr_failure:
        nlmsg_trim(skb, b);
        return -1;
}
 
static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
                      struct Qdisc **old)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        unsigned long band = arg - 1;
 
        if (band >= q->bands)
                return -EINVAL;
 
        if (new == NULL)
                new = &noop_qdisc;
 
        sch_tree_lock(sch);
        *old = q->queues[band];
        q->queues[band] = new;
        qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
        qdisc_reset(*old);
        sch_tree_unlock(sch);
 
        return 0;
}
 
static struct Qdisc *
prio_leaf(struct Qdisc *sch, unsigned long arg)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        unsigned long band = arg - 1;
 
        if (band >= q->bands)
                return NULL;
 
        return q->queues[band];
}
 
static unsigned long prio_get(struct Qdisc *sch, u32 classid)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        unsigned long band = TC_H_MIN(classid);
 
        if (band - 1 >= q->bands)
                return 0;
        return band;
}
 
static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
{
        return prio_get(sch, classid);
}
 
 
static void prio_put(struct Qdisc *q, unsigned long cl)
{
        return;
}
 
static int prio_change(struct Qdisc *sch, u32 handle, u32 parent, struct rtattr **tca, unsigned long *arg)
{
        unsigned long cl = *arg;
        struct prio_sched_data *q = qdisc_priv(sch);
 
        if (cl - 1 > q->bands)
                return -ENOENT;
        return 0;
}
 
static int prio_delete(struct Qdisc *sch, unsigned long cl)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        if (cl - 1 > q->bands)
                return -ENOENT;
        return 0;
}
 
 
static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,
                           struct tcmsg *tcm)
{
        struct prio_sched_data *q = qdisc_priv(sch);
 
        if (cl - 1 > q->bands)
                return -ENOENT;
        tcm->tcm_handle |= TC_H_MIN(cl);
        if (q->queues[cl-1])
                tcm->tcm_info = q->queues[cl-1]->handle;
        return 0;
}
 
static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
                                 struct gnet_dump *d)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        struct Qdisc *cl_q;
 
        cl_q = q->queues[cl - 1];
        if (gnet_stats_copy_basic(d, &cl_q->bstats) < 0 ||
            gnet_stats_copy_queue(d, &cl_q->qstats) < 0)
                return -1;
 
        return 0;
}
 
static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
{
        struct prio_sched_data *q = qdisc_priv(sch);
        int prio;
 
        if (arg->stop)
                return;
 
        for (prio = 0; prio < q->bands; prio++) {
                if (arg->count < arg->skip) {
                        arg->count++;
                        continue;
                }
                if (arg->fn(sch, prio+1, arg) < 0) {
                        arg->stop = 1;
                        break;
                }
                arg->count++;
        }
}
 
static struct tcf_proto ** prio_find_tcf(struct Qdisc *sch, unsigned long cl)
{
        struct prio_sched_data *q = qdisc_priv(sch);
 
        if (cl)
                return NULL;
        return &q->filter_list;
}
 
static struct Qdisc_class_ops prio_class_ops = {
        .graft          =       prio_graft,
        .leaf           =       prio_leaf,
        .get            =       prio_get,
        .put            =       prio_put,
        .change         =       prio_change,
        .delete         =       prio_delete,
        .walk           =       prio_walk,
        .tcf_chain      =       prio_find_tcf,
        .bind_tcf       =       prio_bind,
        .unbind_tcf     =       prio_put,
        .dump           =       prio_dump_class,
        .dump_stats     =       prio_dump_class_stats,
};
 
static struct Qdisc_ops prio_qdisc_ops = {
        .next           =       NULL,
        .cl_ops         =       &prio_class_ops,
        .id             =       "prio",
        .priv_size      =       sizeof(struct prio_sched_data),
        .enqueue        =       prio_enqueue,
        .dequeue        =       prio_dequeue,
        .requeue        =       prio_requeue,
        .drop           =       prio_drop,
        .init           =       prio_init,
        .reset          =       prio_reset,
        .destroy        =       prio_destroy,
        .change         =       prio_tune,
        .dump           =       prio_dump,
        .owner          =       THIS_MODULE,
};
 
static struct Qdisc_ops rr_qdisc_ops = {
        .next           =       NULL,
        .cl_ops         =       &prio_class_ops,
        .id             =       "rr",
        .priv_size      =       sizeof(struct prio_sched_data),
        .enqueue        =       prio_enqueue,
        .dequeue        =       rr_dequeue,
        .requeue        =       prio_requeue,
        .drop           =       prio_drop,
        .init           =       prio_init,
        .reset          =       prio_reset,
        .destroy        =       prio_destroy,
        .change         =       prio_tune,
        .dump           =       prio_dump,
        .owner          =       THIS_MODULE,
};
 
static int __init prio_module_init(void)
{
        int err;
 
        err = register_qdisc(&prio_qdisc_ops);
        if (err < 0)
                return err;
        err = register_qdisc(&rr_qdisc_ops);
        if (err < 0)
                unregister_qdisc(&prio_qdisc_ops);
        return err;
}
 
static void __exit prio_module_exit(void)
{
        unregister_qdisc(&prio_qdisc_ops);
        unregister_qdisc(&rr_qdisc_ops);
}
 
module_init(prio_module_init)
module_exit(prio_module_exit)
 
MODULE_LICENSE("GPL");
MODULE_ALIAS("sch_rr");

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [net/] [sched/] [sch_prio.c] - Blame information for rev 17

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
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/types.h>`
16			`#include <linux/kernel.h>`
17			`#include <linux/string.h>`
18			`#include <linux/errno.h>`
19			`#include <linux/skbuff.h>`
20			`#include <net/netlink.h>`
21			`#include <net/pkt_sched.h>`
22
23
24			`struct prio_sched_data`
25			`{`
26			`int bands;`
27			`int curband; /* for round-robin */`
28			`struct tcf_proto *filter_list;`
29			`u8 prio2band[TC_PRIO_MAX+1];`
30			`struct Qdisc *queues[TCQ_PRIO_BANDS];`
31			`int mq;`
32			`};`
33
34
35			`static struct Qdisc *`
36			`prio_classify(struct sk_buff skb, struct Qdisc sch, int *qerr)`
37			`{`
38			`struct prio_sched_data *q = qdisc_priv(sch);`
39			`u32 band = skb->priority;`
40			`struct tcf_result res;`
41			`int err;`
42
43			`*qerr = NET_XMIT_BYPASS;`
44			`if (TC_H_MAJ(skb->priority) != sch->handle) {`
45			`err = tc_classify(skb, q->filter_list, &res);`
46			`#ifdef CONFIG_NET_CLS_ACT`
47			`switch (err) {`
48			`case TC_ACT_STOLEN:`
49			`case TC_ACT_QUEUED:`
50			`*qerr = NET_XMIT_SUCCESS;`
51			`case TC_ACT_SHOT:`
52			`return NULL;`
53			`}`
54			`#endif`
55			`if (!q->filter_list \|\| err < 0) {`
56			`if (TC_H_MAJ(band))`
57			`band = 0;`
58			`band = q->prio2band[band&TC_PRIO_MAX];`
59			`goto out;`
60			`}`
61			`band = res.classid;`
62			`}`
63			`band = TC_H_MIN(band) - 1;`
64			`if (band >= q->bands)`
65			`band = q->prio2band[0];`
66			`out:`
67			`if (q->mq)`
68			`skb_set_queue_mapping(skb, band);`
69			`return q->queues[band];`
70			`}`
71
72			`static int`
73			`prio_enqueue(struct sk_buff skb, struct Qdisc sch)`
74			`{`
75			`struct Qdisc *qdisc;`
76			`int ret;`
77
78			`qdisc = prio_classify(skb, sch, &ret);`
79			`#ifdef CONFIG_NET_CLS_ACT`
80			`if (qdisc == NULL) {`
81
82			`if (ret == NET_XMIT_BYPASS)`
83			`sch->qstats.drops++;`
84			`kfree_skb(skb);`
85			`return ret;`
86			`}`
87			`#endif`
88
89			`if ((ret = qdisc->enqueue(skb, qdisc)) == NET_XMIT_SUCCESS) {`
90			`sch->bstats.bytes += skb->len;`
91			`sch->bstats.packets++;`
92			`sch->q.qlen++;`
93			`return NET_XMIT_SUCCESS;`
94			`}`
95			`sch->qstats.drops++;`
96			`return ret;`
97			`}`
98
99
100			`static int`
101			`prio_requeue(struct sk_buff skb, struct Qdisc sch)`
102			`{`
103			`struct Qdisc *qdisc;`
104			`int ret;`
105
106			`qdisc = prio_classify(skb, sch, &ret);`
107			`#ifdef CONFIG_NET_CLS_ACT`
108			`if (qdisc == NULL) {`
109			`if (ret == NET_XMIT_BYPASS)`
110			`sch->qstats.drops++;`
111			`kfree_skb(skb);`
112			`return ret;`
113			`}`
114			`#endif`
115
116			`if ((ret = qdisc->ops->requeue(skb, qdisc)) == NET_XMIT_SUCCESS) {`
117			`sch->q.qlen++;`
118			`sch->qstats.requeues++;`
119			`return 0;`
120			`}`
121			`sch->qstats.drops++;`
122			`return NET_XMIT_DROP;`
123			`}`
124
125
126			`static struct sk_buff *`
127			`prio_dequeue(struct Qdisc* sch)`
128			`{`
129			`struct sk_buff *skb;`
130			`struct prio_sched_data *q = qdisc_priv(sch);`
131			`int prio;`
132			`struct Qdisc *qdisc;`
133
134			`for (prio = 0; prio < q->bands; prio++) {`
135			`/* Check if the target subqueue is available before`
136			`* pulling an skb. This way we avoid excessive requeues`
137			`* for slower queues.`
138			`*/`
139			`if (!__netif_subqueue_stopped(sch->dev, (q->mq ? prio : 0))) {`
140			`qdisc = q->queues[prio];`
141			`skb = qdisc->dequeue(qdisc);`
142			`if (skb) {`
143			`sch->q.qlen--;`
144			`return skb;`
145			`}`
146			`}`
147			`}`
148			`return NULL;`
149
150			`}`
151
152			`static struct sk_buff rr_dequeue(struct Qdisc sch)`
153			`{`
154			`struct sk_buff *skb;`
155			`struct prio_sched_data *q = qdisc_priv(sch);`
156			`struct Qdisc *qdisc;`
157			`int bandcount;`
158
159			`/* Only take one pass through the queues. If nothing is available,`
160			`* return nothing.`
161			`*/`
162			`for (bandcount = 0; bandcount < q->bands; bandcount++) {`
163			`/* Check if the target subqueue is available before`
164			`* pulling an skb. This way we avoid excessive requeues`
165			`* for slower queues. If the queue is stopped, try the`
166			`* next queue.`
167			`*/`
168			`if (!__netif_subqueue_stopped(sch->dev,`
169			`(q->mq ? q->curband : 0))) {`
170			`qdisc = q->queues[q->curband];`
171			`skb = qdisc->dequeue(qdisc);`
172			`if (skb) {`
173			`sch->q.qlen--;`
174			`q->curband++;`
175			`if (q->curband >= q->bands)`
176			`q->curband = 0;`
177			`return skb;`
178			`}`
179			`}`
180			`q->curband++;`
181			`if (q->curband >= q->bands)`
182			`q->curband = 0;`
183			`}`
184			`return NULL;`
185			`}`
186
187			`static unsigned int prio_drop(struct Qdisc* sch)`
188			`{`
189			`struct prio_sched_data *q = qdisc_priv(sch);`
190			`int prio;`
191			`unsigned int len;`
192			`struct Qdisc *qdisc;`
193
194			`for (prio = q->bands-1; prio >= 0; prio--) {`
195			`qdisc = q->queues[prio];`
196			`if (qdisc->ops->drop && (len = qdisc->ops->drop(qdisc)) != 0) {`
197			`sch->q.qlen--;`
198			`return len;`
199			`}`
200			`}`
201			`return 0;`
202			`}`
203
204
205			`static void`
206			`prio_reset(struct Qdisc* sch)`
207			`{`
208			`int prio;`
209			`struct prio_sched_data *q = qdisc_priv(sch);`
210
211			`for (prio=0; prio<q->bands; prio++)`
212			`qdisc_reset(q->queues[prio]);`
213			`sch->q.qlen = 0;`
214			`}`
215
216			`static void`
217			`prio_destroy(struct Qdisc* sch)`
218			`{`
219			`int prio;`
220			`struct prio_sched_data *q = qdisc_priv(sch);`
221
222			`tcf_destroy_chain(q->filter_list);`
223			`for (prio=0; prio<q->bands; prio++)`
224			`qdisc_destroy(q->queues[prio]);`
225			`}`
226
227			`static int prio_tune(struct Qdisc sch, struct rtattr opt)`
228			`{`
229			`struct prio_sched_data *q = qdisc_priv(sch);`
230			`struct tc_prio_qopt *qopt;`
231			`struct rtattr *tb[TCA_PRIO_MAX];`
232			`int i;`
233
234			`if (rtattr_parse_nested_compat(tb, TCA_PRIO_MAX, opt, qopt,`
235			`sizeof(*qopt)))`
236			`return -EINVAL;`
237			`q->bands = qopt->bands;`
238			`/* If we're multiqueue, make sure the number of incoming bands`
239			`* matches the number of queues on the device we're associating with.`
240			`* If the number of bands requested is zero, then set q->bands to`
241			`* dev->egress_subqueue_count. Also, the root qdisc must be the`
242			`* only one that is enabled for multiqueue, since it's the only one`
243			`* that interacts with the underlying device.`
244			`*/`
245			`q->mq = RTA_GET_FLAG(tb[TCA_PRIO_MQ - 1]);`
246			`if (q->mq) {`
247			`if (sch->parent != TC_H_ROOT)`
248			`return -EINVAL;`
249			`if (netif_is_multiqueue(sch->dev)) {`
250			`if (q->bands == 0)`
251			`q->bands = sch->dev->egress_subqueue_count;`
252			`else if (q->bands != sch->dev->egress_subqueue_count)`
253			`return -EINVAL;`
254			`} else`
255			`return -EOPNOTSUPP;`
256			`}`
257
258			`if (q->bands > TCQ_PRIO_BANDS \|\| q->bands < 2)`
259			`return -EINVAL;`
260
261			`for (i=0; i<=TC_PRIO_MAX; i++) {`
262			`if (qopt->priomap[i] >= q->bands)`
263			`return -EINVAL;`
264			`}`
265
266			`sch_tree_lock(sch);`
267			`memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);`
268
269			`for (i=q->bands; i<TCQ_PRIO_BANDS; i++) {`
270			`struct Qdisc *child = xchg(&q->queues[i], &noop_qdisc);`
271			`if (child != &noop_qdisc) {`
272			`qdisc_tree_decrease_qlen(child, child->q.qlen);`
273			`qdisc_destroy(child);`
274			`}`
275			`}`
276			`sch_tree_unlock(sch);`
277
278			`for (i=0; i<q->bands; i++) {`
279			`if (q->queues[i] == &noop_qdisc) {`
280			`struct Qdisc *child;`
281			`child = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops,`
282			`TC_H_MAKE(sch->handle, i + 1));`
283			`if (child) {`
284			`sch_tree_lock(sch);`
285			`child = xchg(&q->queues[i], child);`
286
287			`if (child != &noop_qdisc) {`
288			`qdisc_tree_decrease_qlen(child,`
289			`child->q.qlen);`
290			`qdisc_destroy(child);`
291			`}`
292			`sch_tree_unlock(sch);`
293			`}`
294			`}`
295			`}`
296			`return 0;`
297			`}`
298
299			`static int prio_init(struct Qdisc sch, struct rtattr opt)`
300			`{`
301			`struct prio_sched_data *q = qdisc_priv(sch);`
302			`int i;`
303
304			`for (i=0; i<TCQ_PRIO_BANDS; i++)`
305			`q->queues[i] = &noop_qdisc;`
306
307			`if (opt == NULL) {`
308			`return -EINVAL;`
309			`} else {`
310			`int err;`
311
312			`if ((err= prio_tune(sch, opt)) != 0)`
313			`return err;`
314			`}`
315			`return 0;`
316			`}`
317
318			`static int prio_dump(struct Qdisc sch, struct sk_buff skb)`
319			`{`
320			`struct prio_sched_data *q = qdisc_priv(sch);`
321			`unsigned char *b = skb_tail_pointer(skb);`
322			`struct rtattr *nest;`
323			`struct tc_prio_qopt opt;`
324
325			`opt.bands = q->bands;`
326			`memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX+1);`
327
328			`nest = RTA_NEST_COMPAT(skb, TCA_OPTIONS, sizeof(opt), &opt);`
329			`if (q->mq)`
330			`RTA_PUT_FLAG(skb, TCA_PRIO_MQ);`
331			`RTA_NEST_COMPAT_END(skb, nest);`
332
333			`return skb->len;`
334
335			`rtattr_failure:`
336			`nlmsg_trim(skb, b);`
337			`return -1;`
338			`}`
339
340			`static int prio_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,`
341			`struct Qdisc **old)`
342			`{`
343			`struct prio_sched_data *q = qdisc_priv(sch);`
344			`unsigned long band = arg - 1;`
345
346			`if (band >= q->bands)`
347			`return -EINVAL;`
348
349			`if (new == NULL)`
350			`new = &noop_qdisc;`
351
352			`sch_tree_lock(sch);`
353			`*old = q->queues[band];`
354			`q->queues[band] = new;`
355			`qdisc_tree_decrease_qlen(old, (old)->q.qlen);`
356			`qdisc_reset(*old);`
357			`sch_tree_unlock(sch);`
358
359			`return 0;`
360			`}`
361
362			`static struct Qdisc *`
363			`prio_leaf(struct Qdisc *sch, unsigned long arg)`
364			`{`
365			`struct prio_sched_data *q = qdisc_priv(sch);`
366			`unsigned long band = arg - 1;`
367
368			`if (band >= q->bands)`
369			`return NULL;`
370
371			`return q->queues[band];`
372			`}`
373
374			`static unsigned long prio_get(struct Qdisc *sch, u32 classid)`
375			`{`
376			`struct prio_sched_data *q = qdisc_priv(sch);`
377			`unsigned long band = TC_H_MIN(classid);`
378
379			`if (band - 1 >= q->bands)`
380			`return 0;`
381			`return band;`
382			`}`
383
384			`static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)`
385			`{`
386			`return prio_get(sch, classid);`
387			`}`
388
389
390			`static void prio_put(struct Qdisc *q, unsigned long cl)`
391			`{`
392			`return;`
393			`}`
394
395			`static int prio_change(struct Qdisc sch, u32 handle, u32 parent, struct rtattr tca, unsigned long arg)`
396			`{`
397			`unsigned long cl = *arg;`
398			`struct prio_sched_data *q = qdisc_priv(sch);`
399
400			`if (cl - 1 > q->bands)`
401			`return -ENOENT;`
402			`return 0;`
403			`}`
404
405			`static int prio_delete(struct Qdisc *sch, unsigned long cl)`
406			`{`
407			`struct prio_sched_data *q = qdisc_priv(sch);`
408			`if (cl - 1 > q->bands)`
409			`return -ENOENT;`
410			`return 0;`
411			`}`
412
413
414			`static int prio_dump_class(struct Qdisc sch, unsigned long cl, struct sk_buff skb,`
415			`struct tcmsg *tcm)`
416			`{`
417			`struct prio_sched_data *q = qdisc_priv(sch);`
418
419			`if (cl - 1 > q->bands)`
420			`return -ENOENT;`
421			`tcm->tcm_handle \|= TC_H_MIN(cl);`
422			`if (q->queues[cl-1])`
423			`tcm->tcm_info = q->queues[cl-1]->handle;`
424			`return 0;`
425			`}`
426
427			`static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,`
428			`struct gnet_dump *d)`
429			`{`
430			`struct prio_sched_data *q = qdisc_priv(sch);`
431			`struct Qdisc *cl_q;`
432
433			`cl_q = q->queues[cl - 1];`
434			`if (gnet_stats_copy_basic(d, &cl_q->bstats) < 0 \|\|`
435			`gnet_stats_copy_queue(d, &cl_q->qstats) < 0)`
436			`return -1;`
437
438			`return 0;`
439			`}`
440
441			`static void prio_walk(struct Qdisc sch, struct qdisc_walker arg)`
442			`{`
443			`struct prio_sched_data *q = qdisc_priv(sch);`
444			`int prio;`
445
446			`if (arg->stop)`
447			`return;`
448
449			`for (prio = 0; prio < q->bands; prio++) {`
450			`if (arg->count < arg->skip) {`
451			`arg->count++;`
452			`continue;`
453			`}`
454			`if (arg->fn(sch, prio+1, arg) < 0) {`
455			`arg->stop = 1;`
456			`break;`
457			`}`
458			`arg->count++;`
459			`}`
460			`}`
461
462			`static struct tcf_proto ** prio_find_tcf(struct Qdisc *sch, unsigned long cl)`
463			`{`
464			`struct prio_sched_data *q = qdisc_priv(sch);`
465
466			`if (cl)`
467			`return NULL;`
468			`return &q->filter_list;`
469			`}`
470
471			`static struct Qdisc_class_ops prio_class_ops = {`
472			`.graft = prio_graft,`
473			`.leaf = prio_leaf,`
474			`.get = prio_get,`
475			`.put = prio_put,`
476			`.change = prio_change,`
477			`.delete = prio_delete,`
478			`.walk = prio_walk,`
479			`.tcf_chain = prio_find_tcf,`
480			`.bind_tcf = prio_bind,`
481			`.unbind_tcf = prio_put,`
482			`.dump = prio_dump_class,`
483			`.dump_stats = prio_dump_class_stats,`
484			`};`
485
486			`static struct Qdisc_ops prio_qdisc_ops = {`
487			`.next = NULL,`
488			`.cl_ops = &prio_class_ops,`
489			`.id = "prio",`
490			`.priv_size = sizeof(struct prio_sched_data),`
491			`.enqueue = prio_enqueue,`
492			`.dequeue = prio_dequeue,`
493			`.requeue = prio_requeue,`
494			`.drop = prio_drop,`
495			`.init = prio_init,`
496			`.reset = prio_reset,`
497			`.destroy = prio_destroy,`
498			`.change = prio_tune,`
499			`.dump = prio_dump,`
500			`.owner = THIS_MODULE,`
501			`};`
502
503			`static struct Qdisc_ops rr_qdisc_ops = {`
504			`.next = NULL,`
505			`.cl_ops = &prio_class_ops,`
506			`.id = "rr",`
507			`.priv_size = sizeof(struct prio_sched_data),`
508			`.enqueue = prio_enqueue,`
509			`.dequeue = rr_dequeue,`
510			`.requeue = prio_requeue,`
511			`.drop = prio_drop,`
512			`.init = prio_init,`
513			`.reset = prio_reset,`
514			`.destroy = prio_destroy,`
515			`.change = prio_tune,`
516			`.dump = prio_dump,`
517			`.owner = THIS_MODULE,`
518			`};`
519
520			`static int __init prio_module_init(void)`
521			`{`
522			`int err;`
523
524			`err = register_qdisc(&prio_qdisc_ops);`
525			`if (err < 0)`
526			`return err;`
527			`err = register_qdisc(&rr_qdisc_ops);`
528			`if (err < 0)`
529			`unregister_qdisc(&prio_qdisc_ops);`
530			`return err;`
531			`}`
532
533			`static void __exit prio_module_exit(void)`
534			`{`
535			`unregister_qdisc(&prio_qdisc_ops);`
536			`unregister_qdisc(&rr_qdisc_ops);`
537			`}`
538
539			`module_init(prio_module_init)`
540			`module_exit(prio_module_exit)`
541
542			`MODULE_LICENSE("GPL");`
543			`MODULE_ALIAS("sch_rr");`