Commit 1d8ae3fd authored by David S. Miller's avatar David S. Miller

pkt_sched: Remove RR scheduler.

This actually fixes a bug added by the RR scheduler changes.  The
->bands and ->prio2band parameters were being set outside of the
sch_tree_lock() and thus could result in strange behavior and
inconsistencies.

It might be possible, in the new design (where there will be one qdisc
per device TX queue) to allow similar functionality via a TX hash
algorithm for RR but I really see no reason to export this aspect of
how these multiqueue cards actually implement the scheduling of the
the individual DMA TX rings and the single physical MAC/PHY port.
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 09e83b5d
...@@ -103,15 +103,6 @@ struct tc_prio_qopt ...@@ -103,15 +103,6 @@ struct tc_prio_qopt
__u8 priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */ __u8 priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */
}; };
enum
{
TCA_PRIO_UNSPEC,
TCA_PRIO_MQ,
__TCA_PRIO_MAX
};
#define TCA_PRIO_MAX (__TCA_PRIO_MAX - 1)
/* TBF section */ /* TBF section */
struct tc_tbf_qopt struct tc_tbf_qopt
......
...@@ -24,11 +24,9 @@ ...@@ -24,11 +24,9 @@
struct prio_sched_data struct prio_sched_data
{ {
int bands; int bands;
int curband; /* for round-robin */
struct tcf_proto *filter_list; struct tcf_proto *filter_list;
u8 prio2band[TC_PRIO_MAX+1]; u8 prio2band[TC_PRIO_MAX+1];
struct Qdisc *queues[TCQ_PRIO_BANDS]; struct Qdisc *queues[TCQ_PRIO_BANDS];
int mq;
}; };
...@@ -55,17 +53,14 @@ prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) ...@@ -55,17 +53,14 @@ prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
if (!q->filter_list || err < 0) { if (!q->filter_list || err < 0) {
if (TC_H_MAJ(band)) if (TC_H_MAJ(band))
band = 0; band = 0;
band = q->prio2band[band&TC_PRIO_MAX]; return q->queues[q->prio2band[band&TC_PRIO_MAX]];
goto out;
} }
band = res.classid; band = res.classid;
} }
band = TC_H_MIN(band) - 1; band = TC_H_MIN(band) - 1;
if (band >= q->bands) if (band >= q->bands)
band = q->prio2band[0]; return q->queues[q->prio2band[0]];
out:
if (q->mq)
skb_set_queue_mapping(skb, band);
return q->queues[band]; return q->queues[band];
} }
...@@ -123,68 +118,23 @@ prio_requeue(struct sk_buff *skb, struct Qdisc* sch) ...@@ -123,68 +118,23 @@ prio_requeue(struct sk_buff *skb, struct Qdisc* sch)
} }
static struct sk_buff * static struct sk_buff *prio_dequeue(struct Qdisc* sch)
prio_dequeue(struct Qdisc* sch)
{ {
struct sk_buff *skb;
struct prio_sched_data *q = qdisc_priv(sch); struct prio_sched_data *q = qdisc_priv(sch);
int prio; int prio;
struct Qdisc *qdisc;
for (prio = 0; prio < q->bands; prio++) { for (prio = 0; prio < q->bands; prio++) {
/* Check if the target subqueue is available before struct Qdisc *qdisc = q->queues[prio];
* pulling an skb. This way we avoid excessive requeues struct sk_buff *skb = qdisc->dequeue(qdisc);
* for slower queues. if (skb) {
*/ sch->q.qlen--;
if (!__netif_subqueue_stopped(qdisc_dev(sch), return skb;
(q->mq ? prio : 0))) {
qdisc = q->queues[prio];
skb = qdisc->dequeue(qdisc);
if (skb) {
sch->q.qlen--;
return skb;
}
} }
} }
return NULL; 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(qdisc_dev(sch),
(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) static unsigned int prio_drop(struct Qdisc* sch)
{ {
struct prio_sched_data *q = qdisc_priv(sch); struct prio_sched_data *q = qdisc_priv(sch);
...@@ -229,45 +179,22 @@ static int prio_tune(struct Qdisc *sch, struct nlattr *opt) ...@@ -229,45 +179,22 @@ static int prio_tune(struct Qdisc *sch, struct nlattr *opt)
{ {
struct prio_sched_data *q = qdisc_priv(sch); struct prio_sched_data *q = qdisc_priv(sch);
struct tc_prio_qopt *qopt; struct tc_prio_qopt *qopt;
struct nlattr *tb[TCA_PRIO_MAX + 1];
int err;
int i; int i;
err = nla_parse_nested_compat(tb, TCA_PRIO_MAX, opt, NULL, qopt, if (nla_len(opt) < sizeof(*qopt))
sizeof(*qopt)); return -EINVAL;
if (err < 0) qopt = nla_data(opt);
return err;
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 = nla_get_flag(tb[TCA_PRIO_MQ]);
if (q->mq) {
if (sch->parent != TC_H_ROOT)
return -EINVAL;
if (netif_is_multiqueue(qdisc_dev(sch))) {
if (q->bands == 0)
q->bands = qdisc_dev(sch)->egress_subqueue_count;
else if (q->bands != qdisc_dev(sch)->egress_subqueue_count)
return -EINVAL;
} else
return -EOPNOTSUPP;
}
if (q->bands > TCQ_PRIO_BANDS || q->bands < 2) if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2)
return -EINVAL; return -EINVAL;
for (i=0; i<=TC_PRIO_MAX; i++) { for (i=0; i<=TC_PRIO_MAX; i++) {
if (qopt->priomap[i] >= q->bands) if (qopt->priomap[i] >= qopt->bands)
return -EINVAL; return -EINVAL;
} }
sch_tree_lock(sch); sch_tree_lock(sch);
q->bands = qopt->bands;
memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1); memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
for (i=q->bands; i<TCQ_PRIO_BANDS; i++) { for (i=q->bands; i<TCQ_PRIO_BANDS; i++) {
...@@ -333,10 +260,6 @@ static int prio_dump(struct Qdisc *sch, struct sk_buff *skb) ...@@ -333,10 +260,6 @@ static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
nest = nla_nest_compat_start(skb, TCA_OPTIONS, sizeof(opt), &opt); nest = nla_nest_compat_start(skb, TCA_OPTIONS, sizeof(opt), &opt);
if (nest == NULL) if (nest == NULL)
goto nla_put_failure; goto nla_put_failure;
if (q->mq) {
if (nla_put_flag(skb, TCA_PRIO_MQ) < 0)
goto nla_put_failure;
}
nla_nest_compat_end(skb, nest); nla_nest_compat_end(skb, nest);
return skb->len; return skb->len;
...@@ -509,44 +432,17 @@ static struct Qdisc_ops prio_qdisc_ops __read_mostly = { ...@@ -509,44 +432,17 @@ static struct Qdisc_ops prio_qdisc_ops __read_mostly = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
static struct Qdisc_ops rr_qdisc_ops __read_mostly = {
.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) static int __init prio_module_init(void)
{ {
int err; return register_qdisc(&prio_qdisc_ops);
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) static void __exit prio_module_exit(void)
{ {
unregister_qdisc(&prio_qdisc_ops); unregister_qdisc(&prio_qdisc_ops);
unregister_qdisc(&rr_qdisc_ops);
} }
module_init(prio_module_init) module_init(prio_module_init)
module_exit(prio_module_exit) module_exit(prio_module_exit)
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_ALIAS("sch_rr");
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment