Viewing file:  sch_csz.c (24.73 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* net/sched/sch_csz.c Clark-Shenker-Zhang 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>
*
*/
#include <linux/config.h>
#include <linux/module.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/bitops.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/in.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/if_ether.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/notifier.h>
#include <net/ip.h>
#include <net/route.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <net/pkt_sched.h>
/* Clark-Shenker-Zhang algorithm.
=======================================
SOURCE.
David D. Clark, Scott Shenker and Lixia Zhang
"Supporting Real-Time Applications in an Integrated Services Packet
Network: Architecture and Mechanism".
CBQ presents a flexible universal algorithm for packet scheduling,
but it has pretty poor delay characteristics.
Round-robin scheduling and link-sharing goals
apparently contradict minimization of network delay and jitter.
Moreover, correct handling of predictive flows seems to be
impossible in CBQ.
CSZ presents a more precise but less flexible and less efficient
approach. As I understand it, the main idea is to create
WFQ flows for each guaranteed service and to allocate
the rest of bandwith to dummy flow-0. Flow-0 comprises
the predictive services and the best effort traffic;
it is handled by a priority scheduler with the highest
priority band allocated for predictive services, and the rest ---
to the best effort packets.
Note that in CSZ flows are NOT limited to their bandwidth. It
is supposed that the flow passed admission control at the edge
of the QoS network and it doesn't need further shaping. Any
attempt to improve the flow or to shape it to a token bucket
at intermediate hops will introduce undesired delays and raise
jitter.
At the moment CSZ is the only scheduler that provides
true guaranteed service. Another schemes (including CBQ)
do not provide guaranteed delay and randomize jitter.
There is a proof (Sally Floyd), that delay
can be estimated by a IntServ compliant formula.
This result is true formally, but it is wrong in principle.
It takes into account only round-robin delays,
ignoring delays introduced by link sharing i.e. overlimiting.
Note that temporary overlimits are inevitable because
real links are not ideal, and the real algorithm must take this
into account.
ALGORITHM.
--- Notations.
$B$ is link bandwidth (bits/sec).
$I$ is set of all flows, including flow $0$.
Every flow $a \in I$ has associated bandwidth slice $r_a < 1$ and
$\sum_{a \in I} r_a = 1$.
--- Flow model.
Let $m_a$ is the number of backlogged bits in flow $a$.
The flow is {\em active}, if $m_a > 0$.
This number is a discontinuous function of time;
when a packet $i$ arrives:
\[
m_a(t_i+0) - m_a(t_i-0) = L^i,
\]
where $L^i$ is the length of the arrived packet.
The flow queue is drained continuously until $m_a == 0$:
\[
{d m_a \over dt} = - { B r_a \over \sum_{b \in A} r_b}.
\]
I.e. flow rates are their allocated rates proportionally
scaled to take all available link bandwidth. Apparently,
it is not the only possible policy. F.e. CBQ classes
without borrowing would be modelled by:
\[
{d m_a \over dt} = - B r_a .
\]
More complicated hierarchical bandwidth allocation
policies are possible, but unfortunately, the basic
flow equations have a simple solution only for proportional
scaling.
--- Departure times.
We calculate the time until the last bit of packet is sent:
\[
E_a^i(t) = { m_a(t_i) - \delta_a(t) \over r_a },
\]
where $\delta_a(t)$ is number of bits drained since $t_i$.
We have to evaluate $E_a^i$ for all queued packets,
then find the packet with minimal $E_a^i$ and send it.
This sounds good, but direct implementation of the algorithm
is absolutely infeasible. Luckily, if flow rates
are scaled proportionally, the equations have a simple solution.
The differential equation for $E_a^i$ is
\[
{d E_a^i (t) \over dt } = - { d \delta_a(t) \over dt} { 1 \over r_a} =
{ B \over \sum_{b \in A} r_b}
\]
with initial condition
\[
E_a^i (t_i) = { m_a(t_i) \over r_a } .
\]
Let's introduce an auxiliary function $R(t)$:
--- Round number.
Consider the following model: we rotate over active flows,
sending $r_a B$ bits from every flow, so that we send
$B \sum_{a \in A} r_a$ bits per round, that takes
$\sum_{a \in A} r_a$ seconds.
Hence, $R(t)$ (round number) is a monotonically increasing
linear function of time when $A$ is not changed
\[
{ d R(t) \over dt } = { 1 \over \sum_{a \in A} r_a }
\]
and it is continuous when $A$ changes.
The central observation is that the quantity
$F_a^i = R(t) + E_a^i(t)/B$ does not depend on time at all!
$R(t)$ does not depend on flow, so that $F_a^i$ can be
calculated only once on packet arrival, and we need not
recalculate $E$ numbers and resorting queues.
The number $F_a^i$ is called finish number of the packet.
It is just the value of $R(t)$ when the last bit of packet
is sent out.
Maximal finish number on flow is called finish number of flow
and minimal one is "start number of flow".
Apparently, flow is active if and only if $F_a \leq R$.
When a packet of length $L_i$ bit arrives to flow $a$ at time $t_i$,
we calculate $F_a^i$ as:
If flow was inactive ($F_a < R$):
$F_a^i = R(t) + {L_i \over B r_a}$
otherwise
$F_a^i = F_a + {L_i \over B r_a}$
These equations complete the algorithm specification.
It looks pretty hairy, but there is a simple
procedure for solving these equations.
See procedure csz_update(), that is a generalization of
the algorithm from S. Keshav's thesis Chapter 3
"Efficient Implementation of Fair Queeing".
NOTES.
* We implement only the simplest variant of CSZ,
when flow-0 is a explicit 4band priority fifo.
This is bad, but we need a "peek" operation in addition
to "dequeue" to implement complete CSZ.
I do not want to do that, unless it is absolutely
necessary.
* A primitive support for token bucket filtering
presents itself too. It directly contradicts CSZ, but
even though the Internet is on the globe ... :-)
"the edges of the network" really exist.
BUGS.
* Fixed point arithmetic is overcomplicated, suboptimal and even
wrong. Check it later. */
/* This number is arbitrary */
#define CSZ_GUARANTEED 16
#define CSZ_FLOWS (CSZ_GUARANTEED+4)
struct csz_head
{
struct csz_head *snext;
struct csz_head *sprev;
struct csz_head *fnext;
struct csz_head *fprev;
};
struct csz_flow
{
struct csz_head *snext;
struct csz_head *sprev;
struct csz_head *fnext;
struct csz_head *fprev;
/* Parameters */
struct tc_ratespec rate;
struct tc_ratespec slice;
u32 *L_tab; /* Lookup table for L/(B*r_a) values */
unsigned long limit; /* Maximal length of queue */
#ifdef CSZ_PLUS_TBF
struct tc_ratespec peakrate;
__u32 buffer; /* Depth of token bucket, normalized
as L/(B*r_a) */
__u32 mtu;
#endif
/* Variables */
#ifdef CSZ_PLUS_TBF
unsigned long tokens; /* Tokens number: usecs */
psched_time_t t_tbf;
unsigned long R_tbf;
int throttled;
#endif
unsigned peeked;
unsigned long start; /* Finish number of the first skb */
unsigned long finish; /* Finish number of the flow */
struct sk_buff_head q; /* FIFO queue */
};
#define L2R(f,L) ((f)->L_tab[(L)>>(f)->slice.cell_log])
struct csz_sched_data
{
/* Parameters */
unsigned char rate_log; /* fixed point position for rate;
* really we need not it */
unsigned char R_log; /* fixed point position for round number */
unsigned char delta_log; /* 1<<delta_log is maximal timeout in usecs;
* 21 <-> 2.1sec is MAXIMAL value */
/* Variables */
struct tcf_proto *filter_list;
u8 prio2band[TC_PRIO_MAX+1];
#ifdef CSZ_PLUS_TBF
struct timer_list wd_timer;
long wd_expires;
#endif
psched_time_t t_c; /* Time check-point */
unsigned long R_c; /* R-number check-point */
unsigned long rate; /* Current sum of rates of active flows */
struct csz_head s; /* Flows sorted by "start" */
struct csz_head f; /* Flows sorted by "finish" */
struct sk_buff_head other[4];/* Predicted (0) and the best efforts
classes (1,2,3) */
struct csz_flow flow[CSZ_GUARANTEED]; /* Array of flows */
};
/* These routines (csz_insert_finish and csz_insert_start) are
the most time consuming part of all the algorithm.
We insert to sorted list, so that time
is linear with respect to number of active flows in the worst case.
Note that we have not very large number of guaranteed flows,
so that logarithmic algorithms (heap etc.) are useless,
they are slower than linear one when length of list <= 32.
Heap would take sence if we used WFQ for best efforts
flows, but SFQ is better choice in this case.
*/
/* Insert flow "this" to the list "b" before
flow with greater finish number.
*/
#if 0
/* Scan forward */
extern __inline__ void csz_insert_finish(struct csz_head *b,
struct csz_flow *this)
{
struct csz_head *f = b->fnext;
unsigned long finish = this->finish;
while (f != b) {
if (((struct csz_flow*)f)->finish - finish > 0)
break;
f = f->fnext;
}
this->fnext = f;
this->fprev = f->fprev;
this->fnext->fprev = this->fprev->fnext = (struct csz_head*)this;
}
#else
/* Scan backward */
extern __inline__ void csz_insert_finish(struct csz_head *b,
struct csz_flow *this)
{
struct csz_head *f = b->fprev;
unsigned long finish = this->finish;
while (f != b) {
if (((struct csz_flow*)f)->finish - finish <= 0)
break;
f = f->fprev;
}
this->fnext = f->fnext;
this->fprev = f;
this->fnext->fprev = this->fprev->fnext = (struct csz_head*)this;
}
#endif
/* Insert flow "this" to the list "b" before
flow with greater start number.
*/
extern __inline__ void csz_insert_start(struct csz_head *b,
struct csz_flow *this)
{
struct csz_head *f = b->snext;
unsigned long start = this->start;
while (f != b) {
if (((struct csz_flow*)f)->start - start > 0)
break;
f = f->snext;
}
this->snext = f;
this->sprev = f->sprev;
this->snext->sprev = this->sprev->snext = (struct csz_head*)this;
}
/* Calculate and return current round number.
It is another time consuming part, but
it is impossible to avoid it.
It costs O(N) that make all the algorithm useful only
to play with closest to ideal fluid model.
There exist less academic, but more practical modifications,
which might have even better characteristics (WF2Q+, HPFQ, HFSC)
*/
static unsigned long csz_update(struct Qdisc *sch)
{
struct csz_sched_data *q = (struct csz_sched_data*)sch->data;
struct csz_flow *a;
unsigned long F;
unsigned long tmp;
psched_time_t now;
unsigned long delay;
unsigned long R_c;
PSCHED_GET_TIME(now);
delay = PSCHED_TDIFF_SAFE(now, q->t_c, 0, goto do_reset);
if (delay>>q->delta_log) {
do_reset:
/* Delta is too large.
It is possible if MTU/BW > 1<<q->delta_log
(i.e. configuration error) or because of hardware
fault. We have no choice...
*/
qdisc_reset(sch);
return 0;
}
q->t_c = now;
for (;;) {
a = (struct csz_flow*)q->f.fnext;
/* No more active flows. Reset R and exit. */
if (a == (struct csz_flow*)&q->f) {
#ifdef CSZ_DEBUG
if (q->rate) {
printk("csz_update: rate!=0 on inactive csz\n");
q->rate = 0;
}
#endif
q->R_c = 0;
return 0;
}
F = a->finish;
#ifdef CSZ_DEBUG
if (q->rate == 0) {
printk("csz_update: rate=0 on active csz\n");
goto do_reset;
}
#endif
/*
* tmp = (t - q->t_c)/q->rate;
*/
tmp = ((delay<<(31-q->delta_log))/q->rate)>>(31-q->delta_log+q->R_log);
tmp += q->R_c;
/* OK, this flow (and all flows with greater
finish numbers) is still active */
if (F - tmp > 0)
break;
/* It is more not active */
a->fprev->fnext = a->fnext;
a->fnext->fprev = a->fprev;
/*
* q->t_c += (F - q->R_c)*q->rate
*/
tmp = ((F-q->R_c)*q->rate)<<q->R_log;
R_c = F;
q->rate -= a->slice.rate;
if ((long)(delay - tmp) >= 0) {
delay -= tmp;
continue;
}
delay = 0;
}
q->R_c = tmp;
return tmp;
}
unsigned csz_classify(struct sk_buff *skb, struct csz_sched_data *q)
{
return CSZ_GUARANTEED;
}
static int
csz_enqueue(struct sk_buff *skb, struct Qdisc* sch)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
unsigned flow_id = csz_classify(skb, q);
unsigned long R;
int prio = 0;
struct csz_flow *this;
if (flow_id >= CSZ_GUARANTEED) {
prio = flow_id - CSZ_GUARANTEED;
flow_id = 0;
}
this = &q->flow[flow_id];
if (this->q.qlen >= this->limit || this->L_tab == NULL) {
sch->stats.drops++;
kfree_skb(skb);
return NET_XMIT_DROP;
}
R = csz_update(sch);
if ((long)(this->finish - R) >= 0) {
/* It was active */
this->finish += L2R(this,skb->len);
} else {
/* It is inactive; activate it */
this->finish = R + L2R(this,skb->len);
q->rate += this->slice.rate;
csz_insert_finish(&q->f, this);
}
/* If this flow was empty, remember start number
and insert it into start queue */
if (this->q.qlen == 0) {
this->start = this->finish;
csz_insert_start(&q->s, this);
}
if (flow_id)
skb_queue_tail(&this->q, skb);
else
skb_queue_tail(&q->other[prio], skb);
sch->q.qlen++;
sch->stats.bytes += skb->len;
sch->stats.packets++;
return 0;
}
static __inline__ struct sk_buff *
skb_dequeue_best(struct csz_sched_data * q)
{
int i;
struct sk_buff *skb;
for (i=0; i<4; i++) {
skb = skb_dequeue(&q->other[i]);
if (skb) {
q->flow[0].q.qlen--;
return skb;
}
}
return NULL;
}
static __inline__ struct sk_buff *
skb_peek_best(struct csz_sched_data * q)
{
int i;
struct sk_buff *skb;
for (i=0; i<4; i++) {
skb = skb_peek(&q->other[i]);
if (skb)
return skb;
}
return NULL;
}
#ifdef CSZ_PLUS_TBF
static void csz_watchdog(unsigned long arg)
{
struct Qdisc *sch = (struct Qdisc*)arg;
qdisc_wakeup(sch->dev);
}
static __inline__ void
csz_move_queue(struct csz_flow *this, long delta)
{
this->fprev->fnext = this->fnext;
this->fnext->fprev = this->fprev;
this->start += delta;
this->finish += delta;
csz_insert_finish(this);
}
static __inline__ int csz_enough_tokens(struct csz_sched_data *q,
struct csz_flow *this,
struct sk_buff *skb)
{
long toks;
long shift;
psched_time_t now;
PSCHED_GET_TIME(now);
toks = PSCHED_TDIFF(now, t_tbf) + this->tokens - L2R(q,this,skb->len);
shift = 0;
if (this->throttled) {
/* Remember aposteriory delay */
unsigned long R = csz_update(q);
shift = R - this->R_tbf;
this->R_tbf = R;
}
if (toks >= 0) {
/* Now we have enough tokens to proceed */
this->tokens = toks <= this->depth ? toks : this->depth;
this->t_tbf = now;
if (!this->throttled)
return 1;
/* Flow was throttled. Update its start&finish numbers
with delay calculated aposteriori.
*/
this->throttled = 0;
if (shift > 0)
csz_move_queue(this, shift);
return 1;
}
if (!this->throttled) {
/* Flow has just been throttled; remember
current round number to calculate aposteriori delay
*/
this->throttled = 1;
this->R_tbf = csz_update(q);
}
/* Move all the queue to the time when it will be allowed to send.
We should translate time to round number, but it is impossible,
so that we made the most conservative estimate i.e. we suppose
that only this flow is active and, hence, R = t.
Really toks <= R <= toks/r_a.
This apriory shift in R will be adjusted later to reflect
real delay. We cannot avoid it because of:
- throttled flow continues to be active from the viewpoint
of CSZ, so that it would acquire the highest priority,
if you not adjusted start numbers.
- Eventually, finish number would become less than round
number and flow were declared inactive.
*/
toks = -toks;
/* Remeber, that we should start watchdog */
if (toks < q->wd_expires)
q->wd_expires = toks;
toks >>= q->R_log;
shift += toks;
if (shift > 0) {
this->R_tbf += toks;
csz_move_queue(this, shift);
}
csz_insert_start(this);
return 0;
}
#endif
static struct sk_buff *
csz_dequeue(struct Qdisc* sch)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
struct sk_buff *skb;
struct csz_flow *this;
#ifdef CSZ_PLUS_TBF
q->wd_expires = 0;
#endif
this = (struct csz_flow*)q->s.snext;
while (this != (struct csz_flow*)&q->s) {
/* First of all: unlink from start list */
this->sprev->snext = this->snext;
this->snext->sprev = this->sprev;
if (this != &q->flow[0]) { /* Guaranteed flow */
skb = __skb_dequeue(&this->q);
if (skb) {
#ifdef CSZ_PLUS_TBF
if (this->depth) {
if (!csz_enough_tokens(q, this, skb))
continue;
}
#endif
if (this->q.qlen) {
struct sk_buff *nskb = skb_peek(&this->q);
this->start += L2R(this,nskb->len);
csz_insert_start(&q->s, this);
}
sch->q.qlen--;
return skb;
}
} else { /* Predicted or best effort flow */
skb = skb_dequeue_best(q);
if (skb) {
unsigned peeked = this->peeked;
this->peeked = 0;
if (--this->q.qlen) {
struct sk_buff *nskb;
unsigned dequeued = L2R(this,skb->len);
/* We got not the same thing that
peeked earlier; adjust start number
*/
if (peeked != dequeued && peeked)
this->start += dequeued - peeked;
nskb = skb_peek_best(q);
peeked = L2R(this,nskb->len);
this->start += peeked;
this->peeked = peeked;
csz_insert_start(&q->s, this);
}
sch->q.qlen--;
return skb;
}
}
}
#ifdef CSZ_PLUS_TBF
/* We are about to return no skb.
Schedule watchdog timer, if it occurred because of shaping.
*/
if (q->wd_expires) {
unsigned long delay = PSCHED_US2JIFFIE(q->wd_expires);
del_timer(&q->wd_timer);
if (delay == 0)
delay = 1;
q->wd_timer.expires = jiffies + delay;
add_timer(&q->wd_timer);
sch->stats.overlimits++;
}
#endif
return NULL;
}
static void
csz_reset(struct Qdisc* sch)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
int i;
for (i=0; i<4; i++)
skb_queue_purge(&q->other[i]);
for (i=0; i<CSZ_GUARANTEED; i++) {
struct csz_flow *this = q->flow + i;
skb_queue_purge(&this->q);
this->snext = this->sprev =
this->fnext = this->fprev = (struct csz_head*)this;
this->start = this->finish = 0;
}
q->s.snext = q->s.sprev = &q->s;
q->f.fnext = q->f.fprev = &q->f;
q->R_c = 0;
#ifdef CSZ_PLUS_TBF
PSCHED_GET_TIME(&q->t_tbf);
q->tokens = q->depth;
del_timer(&q->wd_timer);
#endif
sch->q.qlen = 0;
}
static void
csz_destroy(struct Qdisc* sch)
{
MOD_DEC_USE_COUNT;
}
static int csz_init(struct Qdisc *sch, struct rtattr *opt)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
struct rtattr *tb[TCA_CSZ_PTAB];
struct tc_csz_qopt *qopt;
int i;
rtattr_parse(tb, TCA_CSZ_PTAB, RTA_DATA(opt), RTA_PAYLOAD(opt));
if (tb[TCA_CSZ_PARMS-1] == NULL ||
RTA_PAYLOAD(tb[TCA_CSZ_PARMS-1]) < sizeof(*qopt))
return -EINVAL;
qopt = RTA_DATA(tb[TCA_CSZ_PARMS-1]);
q->R_log = qopt->R_log;
q->delta_log = qopt->delta_log;
for (i=0; i<=TC_PRIO_MAX; i++) {
if (qopt->priomap[i] >= CSZ_FLOWS)
return -EINVAL;
q->prio2band[i] = qopt->priomap[i];
}
for (i=0; i<4; i++)
skb_queue_head_init(&q->other[i]);
for (i=0; i<CSZ_GUARANTEED; i++) {
struct csz_flow *this = q->flow + i;
skb_queue_head_init(&this->q);
this->snext = this->sprev =
this->fnext = this->fprev = (struct csz_head*)this;
this->start = this->finish = 0;
}
q->s.snext = q->s.sprev = &q->s;
q->f.fnext = q->f.fprev = &q->f;
q->R_c = 0;
#ifdef CSZ_PLUS_TBF
init_timer(&q->wd_timer);
q->wd_timer.data = (unsigned long)sch;
q->wd_timer.function = csz_watchdog;
#endif
MOD_INC_USE_COUNT;
return 0;
}
static int csz_dump(struct Qdisc *sch, struct sk_buff *skb)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
unsigned char *b = skb->tail;
struct rtattr *rta;
struct tc_csz_qopt opt;
rta = (struct rtattr*)b;
RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
opt.flows = CSZ_FLOWS;
memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX+1);
RTA_PUT(skb, TCA_CSZ_PARMS, sizeof(opt), &opt);
rta->rta_len = skb->tail - b;
return skb->len;
rtattr_failure:
skb_trim(skb, b - skb->data);
return -1;
}
static int csz_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new,
struct Qdisc **old)
{
return -EINVAL;
}
static struct Qdisc * csz_leaf(struct Qdisc *sch, unsigned long cl)
{
return NULL;
}
static unsigned long csz_get(struct Qdisc *sch, u32 classid)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
unsigned long band = TC_H_MIN(classid) - 1;
if (band >= CSZ_FLOWS)
return 0;
if (band < CSZ_GUARANTEED && q->flow[band].L_tab == NULL)
return 0;
return band+1;
}
static unsigned long csz_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
{
return csz_get(sch, classid);
}
static void csz_put(struct Qdisc *sch, unsigned long cl)
{
return;
}
static int csz_change(struct Qdisc *sch, u32 handle, u32 parent, struct rtattr **tca, unsigned long *arg)
{
unsigned long cl = *arg;
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
struct rtattr *opt = tca[TCA_OPTIONS-1];
struct rtattr *tb[TCA_CSZ_PTAB];
struct tc_csz_copt *copt;
rtattr_parse(tb, TCA_CSZ_PTAB, RTA_DATA(opt), RTA_PAYLOAD(opt));
if (tb[TCA_CSZ_PARMS-1] == NULL ||
RTA_PAYLOAD(tb[TCA_CSZ_PARMS-1]) < sizeof(*copt))
return -EINVAL;
copt = RTA_DATA(tb[TCA_CSZ_PARMS-1]);
if (tb[TCA_CSZ_RTAB-1] &&
RTA_PAYLOAD(tb[TCA_CSZ_RTAB-1]) < 1024)
return -EINVAL;
if (cl) {
struct csz_flow *a;
cl--;
if (cl >= CSZ_FLOWS)
return -ENOENT;
if (cl >= CSZ_GUARANTEED || q->flow[cl].L_tab == NULL)
return -EINVAL;
a = &q->flow[cl];
spin_lock_bh(&sch->dev->queue_lock);
#if 0
a->rate_log = copt->rate_log;
#endif
#ifdef CSZ_PLUS_TBF
a->limit = copt->limit;
a->rate = copt->rate;
a->buffer = copt->buffer;
a->mtu = copt->mtu;
#endif
if (tb[TCA_CSZ_RTAB-1])
memcpy(a->L_tab, RTA_DATA(tb[TCA_CSZ_RTAB-1]), 1024);
spin_unlock_bh(&sch->dev->queue_lock);
return 0;
}
/* NI */
return 0;
}
static int csz_delete(struct Qdisc *sch, unsigned long cl)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
struct csz_flow *a;
cl--;
if (cl >= CSZ_FLOWS)
return -ENOENT;
if (cl >= CSZ_GUARANTEED || q->flow[cl].L_tab == NULL)
return -EINVAL;
a = &q->flow[cl];
spin_lock_bh(&sch->dev->queue_lock);
a->fprev->fnext = a->fnext;
a->fnext->fprev = a->fprev;
a->sprev->snext = a->snext;
a->snext->sprev = a->sprev;
a->start = a->finish = 0;
kfree(xchg(&q->flow[cl].L_tab, NULL));
spin_unlock_bh(&sch->dev->queue_lock);
return 0;
}
static int csz_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb, struct tcmsg *tcm)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
unsigned char *b = skb->tail;
struct rtattr *rta;
struct tc_csz_copt opt;
tcm->tcm_handle = sch->handle|cl;
cl--;
if (cl > CSZ_FLOWS)
goto rtattr_failure;
if (cl < CSZ_GUARANTEED) {
struct csz_flow *f = &q->flow[cl];
if (f->L_tab == NULL)
goto rtattr_failure;
rta = (struct rtattr*)b;
RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
opt.limit = f->limit;
opt.rate = f->rate;
opt.slice = f->slice;
memset(&opt.peakrate, 0, sizeof(opt.peakrate));
#ifdef CSZ_PLUS_TBF
opt.buffer = f->buffer;
opt.mtu = f->mtu;
#else
opt.buffer = 0;
opt.mtu = 0;
#endif
RTA_PUT(skb, TCA_CSZ_PARMS, sizeof(opt), &opt);
rta->rta_len = skb->tail - b;
}
return skb->len;
rtattr_failure:
skb_trim(skb, b - skb->data);
return -1;
}
static void csz_walk(struct Qdisc *sch, struct qdisc_walker *arg)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
int prio = 0;
if (arg->stop)
return;
for (prio = 0; prio < CSZ_FLOWS; prio++) {
if (arg->count < arg->skip) {
arg->count++;
continue;
}
if (prio < CSZ_GUARANTEED && q->flow[prio].L_tab == NULL) {
arg->count++;
continue;
}
if (arg->fn(sch, prio+1, arg) < 0) {
arg->stop = 1;
break;
}
arg->count++;
}
}
static struct tcf_proto ** csz_find_tcf(struct Qdisc *sch, unsigned long cl)
{
struct csz_sched_data *q = (struct csz_sched_data *)sch->data;
if (cl)
return NULL;
return &q->filter_list;
}
struct Qdisc_class_ops csz_class_ops =
{
csz_graft,
csz_leaf,
csz_get,
csz_put,
csz_change,
csz_delete,
csz_walk,
csz_find_tcf,
csz_bind,
csz_put,
csz_dump_class,
};
struct Qdisc_ops csz_qdisc_ops =
{
NULL,
&csz_class_ops,
"csz",
sizeof(struct csz_sched_data),
csz_enqueue,
csz_dequeue,
NULL,
NULL,
csz_init,
csz_reset,
csz_destroy,
NULL /* csz_change */,
csz_dump,
};
#ifdef MODULE
int init_module(void)
{
return register_qdisc(&csz_qdisc_ops);
}
void cleanup_module(void)
{
unregister_qdisc(&csz_qdisc_ops);
}
#endif
MODULE_LICENSE("GPL");
|