/* * 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, * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* 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< 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<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)<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; iflow + 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; iflow + 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");