aboutsummaryrefslogtreecommitdiffstats
path: root/net/sched/sch_htb.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/sched/sch_htb.c')
-rw-r--r--net/sched/sch_htb.c1363
1 files changed, 605 insertions, 758 deletions
diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index 880a3394a51f..bb3ddd4784b1 100644
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -1,4 +1,4 @@
1/* vim: ts=8 sw=8 1/*
2 * net/sched/sch_htb.c Hierarchical token bucket, feed tree version 2 * net/sched/sch_htb.c Hierarchical token bucket, feed tree version
3 * 3 *
4 * This program is free software; you can redistribute it and/or 4 * This program is free software; you can redistribute it and/or
@@ -68,218 +68,165 @@
68 one less than their parent. 68 one less than their parent.
69*/ 69*/
70 70
71#define HTB_HSIZE 16 /* classid hash size */ 71#define HTB_HSIZE 16 /* classid hash size */
72#define HTB_EWMAC 2 /* rate average over HTB_EWMAC*HTB_HSIZE sec */ 72#define HTB_EWMAC 2 /* rate average over HTB_EWMAC*HTB_HSIZE sec */
73#undef HTB_DEBUG /* compile debugging support (activated by tc tool) */ 73#define HTB_RATECM 1 /* whether to use rate computer */
74#define HTB_RATECM 1 /* whether to use rate computer */ 74#define HTB_HYSTERESIS 1 /* whether to use mode hysteresis for speedup */
75#define HTB_HYSTERESIS 1/* whether to use mode hysteresis for speedup */ 75#define HTB_VER 0x30011 /* major must be matched with number suplied by TC as version */
76#define HTB_QLOCK(S) spin_lock_bh(&(S)->dev->queue_lock)
77#define HTB_QUNLOCK(S) spin_unlock_bh(&(S)->dev->queue_lock)
78#define HTB_VER 0x30011 /* major must be matched with number suplied by TC as version */
79 76
80#if HTB_VER >> 16 != TC_HTB_PROTOVER 77#if HTB_VER >> 16 != TC_HTB_PROTOVER
81#error "Mismatched sch_htb.c and pkt_sch.h" 78#error "Mismatched sch_htb.c and pkt_sch.h"
82#endif 79#endif
83 80
84/* debugging support; S is subsystem, these are defined:
85 0 - netlink messages
86 1 - enqueue
87 2 - drop & requeue
88 3 - dequeue main
89 4 - dequeue one prio DRR part
90 5 - dequeue class accounting
91 6 - class overlimit status computation
92 7 - hint tree
93 8 - event queue
94 10 - rate estimator
95 11 - classifier
96 12 - fast dequeue cache
97
98 L is level; 0 = none, 1 = basic info, 2 = detailed, 3 = full
99 q->debug uint32 contains 16 2-bit fields one for subsystem starting
100 from LSB
101 */
102#ifdef HTB_DEBUG
103#define HTB_DBG_COND(S,L) (((q->debug>>(2*S))&3) >= L)
104#define HTB_DBG(S,L,FMT,ARG...) if (HTB_DBG_COND(S,L)) \
105 printk(KERN_DEBUG FMT,##ARG)
106#define HTB_CHCL(cl) BUG_TRAP((cl)->magic == HTB_CMAGIC)
107#define HTB_PASSQ q,
108#define HTB_ARGQ struct htb_sched *q,
109#define static
110#undef __inline__
111#define __inline__
112#undef inline
113#define inline
114#define HTB_CMAGIC 0xFEFAFEF1
115#define htb_safe_rb_erase(N,R) do { BUG_TRAP((N)->rb_color != -1); \
116 if ((N)->rb_color == -1) break; \
117 rb_erase(N,R); \
118 (N)->rb_color = -1; } while (0)
119#else
120#define HTB_DBG_COND(S,L) (0)
121#define HTB_DBG(S,L,FMT,ARG...)
122#define HTB_PASSQ
123#define HTB_ARGQ
124#define HTB_CHCL(cl)
125#define htb_safe_rb_erase(N,R) rb_erase(N,R)
126#endif
127
128
129/* used internaly to keep status of single class */ 81/* used internaly to keep status of single class */
130enum htb_cmode { 82enum htb_cmode {
131 HTB_CANT_SEND, /* class can't send and can't borrow */ 83 HTB_CANT_SEND, /* class can't send and can't borrow */
132 HTB_MAY_BORROW, /* class can't send but may borrow */ 84 HTB_MAY_BORROW, /* class can't send but may borrow */
133 HTB_CAN_SEND /* class can send */ 85 HTB_CAN_SEND /* class can send */
134}; 86};
135 87
136/* interior & leaf nodes; props specific to leaves are marked L: */ 88/* interior & leaf nodes; props specific to leaves are marked L: */
137struct htb_class 89struct htb_class {
138{ 90 /* general class parameters */
139#ifdef HTB_DEBUG 91 u32 classid;
140 unsigned magic; 92 struct gnet_stats_basic bstats;
141#endif 93 struct gnet_stats_queue qstats;
142 /* general class parameters */ 94 struct gnet_stats_rate_est rate_est;
143 u32 classid; 95 struct tc_htb_xstats xstats; /* our special stats */
144 struct gnet_stats_basic bstats; 96 int refcnt; /* usage count of this class */
145 struct gnet_stats_queue qstats;
146 struct gnet_stats_rate_est rate_est;
147 struct tc_htb_xstats xstats;/* our special stats */
148 int refcnt; /* usage count of this class */
149 97
150#ifdef HTB_RATECM 98#ifdef HTB_RATECM
151 /* rate measurement counters */ 99 /* rate measurement counters */
152 unsigned long rate_bytes,sum_bytes; 100 unsigned long rate_bytes, sum_bytes;
153 unsigned long rate_packets,sum_packets; 101 unsigned long rate_packets, sum_packets;
154#endif 102#endif
155 103
156 /* topology */ 104 /* topology */
157 int level; /* our level (see above) */ 105 int level; /* our level (see above) */
158 struct htb_class *parent; /* parent class */ 106 struct htb_class *parent; /* parent class */
159 struct list_head hlist; /* classid hash list item */ 107 struct hlist_node hlist; /* classid hash list item */
160 struct list_head sibling; /* sibling list item */ 108 struct list_head sibling; /* sibling list item */
161 struct list_head children; /* children list */ 109 struct list_head children; /* children list */
162 110
163 union { 111 union {
164 struct htb_class_leaf { 112 struct htb_class_leaf {
165 struct Qdisc *q; 113 struct Qdisc *q;
166 int prio; 114 int prio;
167 int aprio; 115 int aprio;
168 int quantum; 116 int quantum;
169 int deficit[TC_HTB_MAXDEPTH]; 117 int deficit[TC_HTB_MAXDEPTH];
170 struct list_head drop_list; 118 struct list_head drop_list;
171 } leaf; 119 } leaf;
172 struct htb_class_inner { 120 struct htb_class_inner {
173 struct rb_root feed[TC_HTB_NUMPRIO]; /* feed trees */ 121 struct rb_root feed[TC_HTB_NUMPRIO]; /* feed trees */
174 struct rb_node *ptr[TC_HTB_NUMPRIO]; /* current class ptr */ 122 struct rb_node *ptr[TC_HTB_NUMPRIO]; /* current class ptr */
175 /* When class changes from state 1->2 and disconnects from 123 /* When class changes from state 1->2 and disconnects from
176 parent's feed then we lost ptr value and start from the 124 parent's feed then we lost ptr value and start from the
177 first child again. Here we store classid of the 125 first child again. Here we store classid of the
178 last valid ptr (used when ptr is NULL). */ 126 last valid ptr (used when ptr is NULL). */
179 u32 last_ptr_id[TC_HTB_NUMPRIO]; 127 u32 last_ptr_id[TC_HTB_NUMPRIO];
180 } inner; 128 } inner;
181 } un; 129 } un;
182 struct rb_node node[TC_HTB_NUMPRIO]; /* node for self or feed tree */ 130 struct rb_node node[TC_HTB_NUMPRIO]; /* node for self or feed tree */
183 struct rb_node pq_node; /* node for event queue */ 131 struct rb_node pq_node; /* node for event queue */
184 unsigned long pq_key; /* the same type as jiffies global */ 132 unsigned long pq_key; /* the same type as jiffies global */
185 133
186 int prio_activity; /* for which prios are we active */ 134 int prio_activity; /* for which prios are we active */
187 enum htb_cmode cmode; /* current mode of the class */ 135 enum htb_cmode cmode; /* current mode of the class */
188 136
189 /* class attached filters */ 137 /* class attached filters */
190 struct tcf_proto *filter_list; 138 struct tcf_proto *filter_list;
191 int filter_cnt; 139 int filter_cnt;
192 140
193 int warned; /* only one warning about non work conserving .. */ 141 int warned; /* only one warning about non work conserving .. */
194 142
195 /* token bucket parameters */ 143 /* token bucket parameters */
196 struct qdisc_rate_table *rate; /* rate table of the class itself */ 144 struct qdisc_rate_table *rate; /* rate table of the class itself */
197 struct qdisc_rate_table *ceil; /* ceiling rate (limits borrows too) */ 145 struct qdisc_rate_table *ceil; /* ceiling rate (limits borrows too) */
198 long buffer,cbuffer; /* token bucket depth/rate */ 146 long buffer, cbuffer; /* token bucket depth/rate */
199 psched_tdiff_t mbuffer; /* max wait time */ 147 psched_tdiff_t mbuffer; /* max wait time */
200 long tokens,ctokens; /* current number of tokens */ 148 long tokens, ctokens; /* current number of tokens */
201 psched_time_t t_c; /* checkpoint time */ 149 psched_time_t t_c; /* checkpoint time */
202}; 150};
203 151
204/* TODO: maybe compute rate when size is too large .. or drop ? */ 152/* TODO: maybe compute rate when size is too large .. or drop ? */
205static __inline__ long L2T(struct htb_class *cl,struct qdisc_rate_table *rate, 153static inline long L2T(struct htb_class *cl, struct qdisc_rate_table *rate,
206 int size) 154 int size)
207{ 155{
208 int slot = size >> rate->rate.cell_log; 156 int slot = size >> rate->rate.cell_log;
209 if (slot > 255) { 157 if (slot > 255) {
210 cl->xstats.giants++; 158 cl->xstats.giants++;
211 slot = 255; 159 slot = 255;
212 } 160 }
213 return rate->data[slot]; 161 return rate->data[slot];
214} 162}
215 163
216struct htb_sched 164struct htb_sched {
217{ 165 struct list_head root; /* root classes list */
218 struct list_head root; /* root classes list */ 166 struct hlist_head hash[HTB_HSIZE]; /* hashed by classid */
219 struct list_head hash[HTB_HSIZE]; /* hashed by classid */ 167 struct list_head drops[TC_HTB_NUMPRIO];/* active leaves (for drops) */
220 struct list_head drops[TC_HTB_NUMPRIO]; /* active leaves (for drops) */ 168
221 169 /* self list - roots of self generating tree */
222 /* self list - roots of self generating tree */ 170 struct rb_root row[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO];
223 struct rb_root row[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO]; 171 int row_mask[TC_HTB_MAXDEPTH];
224 int row_mask[TC_HTB_MAXDEPTH]; 172 struct rb_node *ptr[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO];
225 struct rb_node *ptr[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO]; 173 u32 last_ptr_id[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO];
226 u32 last_ptr_id[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO]; 174
227 175 /* self wait list - roots of wait PQs per row */
228 /* self wait list - roots of wait PQs per row */ 176 struct rb_root wait_pq[TC_HTB_MAXDEPTH];
229 struct rb_root wait_pq[TC_HTB_MAXDEPTH]; 177
230 178 /* time of nearest event per level (row) */
231 /* time of nearest event per level (row) */ 179 unsigned long near_ev_cache[TC_HTB_MAXDEPTH];
232 unsigned long near_ev_cache[TC_HTB_MAXDEPTH]; 180
233 181 /* cached value of jiffies in dequeue */
234 /* cached value of jiffies in dequeue */ 182 unsigned long jiffies;
235 unsigned long jiffies; 183
236 184 /* whether we hit non-work conserving class during this dequeue; we use */
237 /* whether we hit non-work conserving class during this dequeue; we use */ 185 int nwc_hit; /* this to disable mindelay complaint in dequeue */
238 int nwc_hit; /* this to disable mindelay complaint in dequeue */ 186
239 187 int defcls; /* class where unclassified flows go to */
240 int defcls; /* class where unclassified flows go to */ 188
241 u32 debug; /* subsystem debug levels */ 189 /* filters for qdisc itself */
242 190 struct tcf_proto *filter_list;
243 /* filters for qdisc itself */ 191 int filter_cnt;
244 struct tcf_proto *filter_list; 192
245 int filter_cnt; 193 int rate2quantum; /* quant = rate / rate2quantum */
246 194 psched_time_t now; /* cached dequeue time */
247 int rate2quantum; /* quant = rate / rate2quantum */ 195 struct timer_list timer; /* send delay timer */
248 psched_time_t now; /* cached dequeue time */
249 struct timer_list timer; /* send delay timer */
250#ifdef HTB_RATECM 196#ifdef HTB_RATECM
251 struct timer_list rttim; /* rate computer timer */ 197 struct timer_list rttim; /* rate computer timer */
252 int recmp_bucket; /* which hash bucket to recompute next */ 198 int recmp_bucket; /* which hash bucket to recompute next */
253#endif 199#endif
254
255 /* non shaped skbs; let them go directly thru */
256 struct sk_buff_head direct_queue;
257 int direct_qlen; /* max qlen of above */
258 200
259 long direct_pkts; 201 /* non shaped skbs; let them go directly thru */
202 struct sk_buff_head direct_queue;
203 int direct_qlen; /* max qlen of above */
204
205 long direct_pkts;
260}; 206};
261 207
262/* compute hash of size HTB_HSIZE for given handle */ 208/* compute hash of size HTB_HSIZE for given handle */
263static __inline__ int htb_hash(u32 h) 209static inline int htb_hash(u32 h)
264{ 210{
265#if HTB_HSIZE != 16 211#if HTB_HSIZE != 16
266 #error "Declare new hash for your HTB_HSIZE" 212#error "Declare new hash for your HTB_HSIZE"
267#endif 213#endif
268 h ^= h>>8; /* stolen from cbq_hash */ 214 h ^= h >> 8; /* stolen from cbq_hash */
269 h ^= h>>4; 215 h ^= h >> 4;
270 return h & 0xf; 216 return h & 0xf;
271} 217}
272 218
273/* find class in global hash table using given handle */ 219/* find class in global hash table using given handle */
274static __inline__ struct htb_class *htb_find(u32 handle, struct Qdisc *sch) 220static inline struct htb_class *htb_find(u32 handle, struct Qdisc *sch)
275{ 221{
276 struct htb_sched *q = qdisc_priv(sch); 222 struct htb_sched *q = qdisc_priv(sch);
277 struct list_head *p; 223 struct hlist_node *p;
278 if (TC_H_MAJ(handle) != sch->handle) 224 struct htb_class *cl;
225
226 if (TC_H_MAJ(handle) != sch->handle)
279 return NULL; 227 return NULL;
280 228
281 list_for_each (p,q->hash+htb_hash(handle)) { 229 hlist_for_each_entry(cl, p, q->hash + htb_hash(handle), hlist) {
282 struct htb_class *cl = list_entry(p,struct htb_class,hlist);
283 if (cl->classid == handle) 230 if (cl->classid == handle)
284 return cl; 231 return cl;
285 } 232 }
@@ -304,7 +251,8 @@ static inline u32 htb_classid(struct htb_class *cl)
304 return (cl && cl != HTB_DIRECT) ? cl->classid : TC_H_UNSPEC; 251 return (cl && cl != HTB_DIRECT) ? cl->classid : TC_H_UNSPEC;
305} 252}
306 253
307static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) 254static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch,
255 int *qerr)
308{ 256{
309 struct htb_sched *q = qdisc_priv(sch); 257 struct htb_sched *q = qdisc_priv(sch);
310 struct htb_class *cl; 258 struct htb_class *cl;
@@ -316,8 +264,8 @@ static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch, in
316 note that nfmark can be used too by attaching filter fw with no 264 note that nfmark can be used too by attaching filter fw with no
317 rules in it */ 265 rules in it */
318 if (skb->priority == sch->handle) 266 if (skb->priority == sch->handle)
319 return HTB_DIRECT; /* X:0 (direct flow) selected */ 267 return HTB_DIRECT; /* X:0 (direct flow) selected */
320 if ((cl = htb_find(skb->priority,sch)) != NULL && cl->level == 0) 268 if ((cl = htb_find(skb->priority, sch)) != NULL && cl->level == 0)
321 return cl; 269 return cl;
322 270
323 *qerr = NET_XMIT_BYPASS; 271 *qerr = NET_XMIT_BYPASS;
@@ -326,7 +274,7 @@ static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch, in
326#ifdef CONFIG_NET_CLS_ACT 274#ifdef CONFIG_NET_CLS_ACT
327 switch (result) { 275 switch (result) {
328 case TC_ACT_QUEUED: 276 case TC_ACT_QUEUED:
329 case TC_ACT_STOLEN: 277 case TC_ACT_STOLEN:
330 *qerr = NET_XMIT_SUCCESS; 278 *qerr = NET_XMIT_SUCCESS;
331 case TC_ACT_SHOT: 279 case TC_ACT_SHOT:
332 return NULL; 280 return NULL;
@@ -335,97 +283,44 @@ static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch, in
335 if (result == TC_POLICE_SHOT) 283 if (result == TC_POLICE_SHOT)
336 return HTB_DIRECT; 284 return HTB_DIRECT;
337#endif 285#endif
338 if ((cl = (void*)res.class) == NULL) { 286 if ((cl = (void *)res.class) == NULL) {
339 if (res.classid == sch->handle) 287 if (res.classid == sch->handle)
340 return HTB_DIRECT; /* X:0 (direct flow) */ 288 return HTB_DIRECT; /* X:0 (direct flow) */
341 if ((cl = htb_find(res.classid,sch)) == NULL) 289 if ((cl = htb_find(res.classid, sch)) == NULL)
342 break; /* filter selected invalid classid */ 290 break; /* filter selected invalid classid */
343 } 291 }
344 if (!cl->level) 292 if (!cl->level)
345 return cl; /* we hit leaf; return it */ 293 return cl; /* we hit leaf; return it */
346 294
347 /* we have got inner class; apply inner filter chain */ 295 /* we have got inner class; apply inner filter chain */
348 tcf = cl->filter_list; 296 tcf = cl->filter_list;
349 } 297 }
350 /* classification failed; try to use default class */ 298 /* classification failed; try to use default class */
351 cl = htb_find(TC_H_MAKE(TC_H_MAJ(sch->handle),q->defcls),sch); 299 cl = htb_find(TC_H_MAKE(TC_H_MAJ(sch->handle), q->defcls), sch);
352 if (!cl || cl->level) 300 if (!cl || cl->level)
353 return HTB_DIRECT; /* bad default .. this is safe bet */ 301 return HTB_DIRECT; /* bad default .. this is safe bet */
354 return cl; 302 return cl;
355} 303}
356 304
357#ifdef HTB_DEBUG
358static void htb_next_rb_node(struct rb_node **n);
359#define HTB_DUMTREE(root,memb) if(root) { \
360 struct rb_node *n = (root)->rb_node; \
361 while (n->rb_left) n = n->rb_left; \
362 while (n) { \
363 struct htb_class *cl = rb_entry(n, struct htb_class, memb); \
364 printk(" %x",cl->classid); htb_next_rb_node (&n); \
365 } }
366
367static void htb_debug_dump (struct htb_sched *q)
368{
369 int i,p;
370 printk(KERN_DEBUG "htb*g j=%lu lj=%lu\n",jiffies,q->jiffies);
371 /* rows */
372 for (i=TC_HTB_MAXDEPTH-1;i>=0;i--) {
373 printk(KERN_DEBUG "htb*r%d m=%x",i,q->row_mask[i]);
374 for (p=0;p<TC_HTB_NUMPRIO;p++) {
375 if (!q->row[i][p].rb_node) continue;
376 printk(" p%d:",p);
377 HTB_DUMTREE(q->row[i]+p,node[p]);
378 }
379 printk("\n");
380 }
381 /* classes */
382 for (i = 0; i < HTB_HSIZE; i++) {
383 struct list_head *l;
384 list_for_each (l,q->hash+i) {
385 struct htb_class *cl = list_entry(l,struct htb_class,hlist);
386 long diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32)cl->mbuffer);
387 printk(KERN_DEBUG "htb*c%x m=%d t=%ld c=%ld pq=%lu df=%ld ql=%d "
388 "pa=%x f:",
389 cl->classid,cl->cmode,cl->tokens,cl->ctokens,
390 cl->pq_node.rb_color==-1?0:cl->pq_key,diff,
391 cl->level?0:cl->un.leaf.q->q.qlen,cl->prio_activity);
392 if (cl->level)
393 for (p=0;p<TC_HTB_NUMPRIO;p++) {
394 if (!cl->un.inner.feed[p].rb_node) continue;
395 printk(" p%d a=%x:",p,cl->un.inner.ptr[p]?rb_entry(cl->un.inner.ptr[p], struct htb_class,node[p])->classid:0);
396 HTB_DUMTREE(cl->un.inner.feed+p,node[p]);
397 }
398 printk("\n");
399 }
400 }
401}
402#endif
403/** 305/**
404 * htb_add_to_id_tree - adds class to the round robin list 306 * htb_add_to_id_tree - adds class to the round robin list
405 * 307 *
406 * Routine adds class to the list (actually tree) sorted by classid. 308 * Routine adds class to the list (actually tree) sorted by classid.
407 * Make sure that class is not already on such list for given prio. 309 * Make sure that class is not already on such list for given prio.
408 */ 310 */
409static void htb_add_to_id_tree (HTB_ARGQ struct rb_root *root, 311static void htb_add_to_id_tree(struct rb_root *root,
410 struct htb_class *cl,int prio) 312 struct htb_class *cl, int prio)
411{ 313{
412 struct rb_node **p = &root->rb_node, *parent = NULL; 314 struct rb_node **p = &root->rb_node, *parent = NULL;
413 HTB_DBG(7,3,"htb_add_id_tree cl=%X prio=%d\n",cl->classid,prio); 315
414#ifdef HTB_DEBUG
415 if (cl->node[prio].rb_color != -1) { BUG_TRAP(0); return; }
416 HTB_CHCL(cl);
417 if (*p) {
418 struct htb_class *x = rb_entry(*p,struct htb_class,node[prio]);
419 HTB_CHCL(x);
420 }
421#endif
422 while (*p) { 316 while (*p) {
423 struct htb_class *c; parent = *p; 317 struct htb_class *c;
318 parent = *p;
424 c = rb_entry(parent, struct htb_class, node[prio]); 319 c = rb_entry(parent, struct htb_class, node[prio]);
425 HTB_CHCL(c); 320
426 if (cl->classid > c->classid) 321 if (cl->classid > c->classid)
427 p = &parent->rb_right; 322 p = &parent->rb_right;
428 else 323 else
429 p = &parent->rb_left; 324 p = &parent->rb_left;
430 } 325 }
431 rb_link_node(&cl->node[prio], parent, p); 326 rb_link_node(&cl->node[prio], parent, p);
@@ -439,17 +334,11 @@ static void htb_add_to_id_tree (HTB_ARGQ struct rb_root *root,
439 * change its mode in cl->pq_key microseconds. Make sure that class is not 334 * change its mode in cl->pq_key microseconds. Make sure that class is not
440 * already in the queue. 335 * already in the queue.
441 */ 336 */
442static void htb_add_to_wait_tree (struct htb_sched *q, 337static void htb_add_to_wait_tree(struct htb_sched *q,
443 struct htb_class *cl,long delay,int debug_hint) 338 struct htb_class *cl, long delay)
444{ 339{
445 struct rb_node **p = &q->wait_pq[cl->level].rb_node, *parent = NULL; 340 struct rb_node **p = &q->wait_pq[cl->level].rb_node, *parent = NULL;
446 HTB_DBG(7,3,"htb_add_wt cl=%X key=%lu\n",cl->classid,cl->pq_key); 341
447#ifdef HTB_DEBUG
448 if (cl->pq_node.rb_color != -1) { BUG_TRAP(0); return; }
449 HTB_CHCL(cl);
450 if ((delay <= 0 || delay > cl->mbuffer) && net_ratelimit())
451 printk(KERN_ERR "HTB: suspicious delay in wait_tree d=%ld cl=%X h=%d\n",delay,cl->classid,debug_hint);
452#endif
453 cl->pq_key = q->jiffies + PSCHED_US2JIFFIE(delay); 342 cl->pq_key = q->jiffies + PSCHED_US2JIFFIE(delay);
454 if (cl->pq_key == q->jiffies) 343 if (cl->pq_key == q->jiffies)
455 cl->pq_key++; 344 cl->pq_key++;
@@ -457,13 +346,14 @@ static void htb_add_to_wait_tree (struct htb_sched *q,
457 /* update the nearest event cache */ 346 /* update the nearest event cache */
458 if (time_after(q->near_ev_cache[cl->level], cl->pq_key)) 347 if (time_after(q->near_ev_cache[cl->level], cl->pq_key))
459 q->near_ev_cache[cl->level] = cl->pq_key; 348 q->near_ev_cache[cl->level] = cl->pq_key;
460 349
461 while (*p) { 350 while (*p) {
462 struct htb_class *c; parent = *p; 351 struct htb_class *c;
352 parent = *p;
463 c = rb_entry(parent, struct htb_class, pq_node); 353 c = rb_entry(parent, struct htb_class, pq_node);
464 if (time_after_eq(cl->pq_key, c->pq_key)) 354 if (time_after_eq(cl->pq_key, c->pq_key))
465 p = &parent->rb_right; 355 p = &parent->rb_right;
466 else 356 else
467 p = &parent->rb_left; 357 p = &parent->rb_left;
468 } 358 }
469 rb_link_node(&cl->pq_node, parent, p); 359 rb_link_node(&cl->pq_node, parent, p);
@@ -476,7 +366,7 @@ static void htb_add_to_wait_tree (struct htb_sched *q,
476 * When we are past last key we return NULL. 366 * When we are past last key we return NULL.
477 * Average complexity is 2 steps per call. 367 * Average complexity is 2 steps per call.
478 */ 368 */
479static void htb_next_rb_node(struct rb_node **n) 369static inline void htb_next_rb_node(struct rb_node **n)
480{ 370{
481 *n = rb_next(*n); 371 *n = rb_next(*n);
482} 372}
@@ -487,42 +377,51 @@ static void htb_next_rb_node(struct rb_node **n)
487 * The class is added to row at priorities marked in mask. 377 * The class is added to row at priorities marked in mask.
488 * It does nothing if mask == 0. 378 * It does nothing if mask == 0.
489 */ 379 */
490static inline void htb_add_class_to_row(struct htb_sched *q, 380static inline void htb_add_class_to_row(struct htb_sched *q,
491 struct htb_class *cl,int mask) 381 struct htb_class *cl, int mask)
492{ 382{
493 HTB_DBG(7,2,"htb_addrow cl=%X mask=%X rmask=%X\n",
494 cl->classid,mask,q->row_mask[cl->level]);
495 HTB_CHCL(cl);
496 q->row_mask[cl->level] |= mask; 383 q->row_mask[cl->level] |= mask;
497 while (mask) { 384 while (mask) {
498 int prio = ffz(~mask); 385 int prio = ffz(~mask);
499 mask &= ~(1 << prio); 386 mask &= ~(1 << prio);
500 htb_add_to_id_tree(HTB_PASSQ q->row[cl->level]+prio,cl,prio); 387 htb_add_to_id_tree(q->row[cl->level] + prio, cl, prio);
388 }
389}
390
391/* If this triggers, it is a bug in this code, but it need not be fatal */
392static void htb_safe_rb_erase(struct rb_node *rb, struct rb_root *root)
393{
394 if (RB_EMPTY_NODE(rb)) {
395 WARN_ON(1);
396 } else {
397 rb_erase(rb, root);
398 RB_CLEAR_NODE(rb);
501 } 399 }
502} 400}
503 401
402
504/** 403/**
505 * htb_remove_class_from_row - removes class from its row 404 * htb_remove_class_from_row - removes class from its row
506 * 405 *
507 * The class is removed from row at priorities marked in mask. 406 * The class is removed from row at priorities marked in mask.
508 * It does nothing if mask == 0. 407 * It does nothing if mask == 0.
509 */ 408 */
510static __inline__ void htb_remove_class_from_row(struct htb_sched *q, 409static inline void htb_remove_class_from_row(struct htb_sched *q,
511 struct htb_class *cl,int mask) 410 struct htb_class *cl, int mask)
512{ 411{
513 int m = 0; 412 int m = 0;
514 HTB_CHCL(cl); 413
515 while (mask) { 414 while (mask) {
516 int prio = ffz(~mask); 415 int prio = ffz(~mask);
416
517 mask &= ~(1 << prio); 417 mask &= ~(1 << prio);
518 if (q->ptr[cl->level][prio] == cl->node+prio) 418 if (q->ptr[cl->level][prio] == cl->node + prio)
519 htb_next_rb_node(q->ptr[cl->level]+prio); 419 htb_next_rb_node(q->ptr[cl->level] + prio);
520 htb_safe_rb_erase(cl->node + prio,q->row[cl->level]+prio); 420
521 if (!q->row[cl->level][prio].rb_node) 421 htb_safe_rb_erase(cl->node + prio, q->row[cl->level] + prio);
422 if (!q->row[cl->level][prio].rb_node)
522 m |= 1 << prio; 423 m |= 1 << prio;
523 } 424 }
524 HTB_DBG(7,2,"htb_delrow cl=%X mask=%X rmask=%X maskdel=%X\n",
525 cl->classid,mask,q->row_mask[cl->level],m);
526 q->row_mask[cl->level] &= ~m; 425 q->row_mask[cl->level] &= ~m;
527} 426}
528 427
@@ -533,34 +432,31 @@ static __inline__ void htb_remove_class_from_row(struct htb_sched *q,
533 * for priorities it is participating on. cl->cmode must be new 432 * for priorities it is participating on. cl->cmode must be new
534 * (activated) mode. It does nothing if cl->prio_activity == 0. 433 * (activated) mode. It does nothing if cl->prio_activity == 0.
535 */ 434 */
536static void htb_activate_prios(struct htb_sched *q,struct htb_class *cl) 435static void htb_activate_prios(struct htb_sched *q, struct htb_class *cl)
537{ 436{
538 struct htb_class *p = cl->parent; 437 struct htb_class *p = cl->parent;
539 long m,mask = cl->prio_activity; 438 long m, mask = cl->prio_activity;
540 HTB_DBG(7,2,"htb_act_prios cl=%X mask=%lX cmode=%d\n",cl->classid,mask,cl->cmode);
541 HTB_CHCL(cl);
542 439
543 while (cl->cmode == HTB_MAY_BORROW && p && mask) { 440 while (cl->cmode == HTB_MAY_BORROW && p && mask) {
544 HTB_CHCL(p); 441 m = mask;
545 m = mask; while (m) { 442 while (m) {
546 int prio = ffz(~m); 443 int prio = ffz(~m);
547 m &= ~(1 << prio); 444 m &= ~(1 << prio);
548 445
549 if (p->un.inner.feed[prio].rb_node) 446 if (p->un.inner.feed[prio].rb_node)
550 /* parent already has its feed in use so that 447 /* parent already has its feed in use so that
551 reset bit in mask as parent is already ok */ 448 reset bit in mask as parent is already ok */
552 mask &= ~(1 << prio); 449 mask &= ~(1 << prio);
553 450
554 htb_add_to_id_tree(HTB_PASSQ p->un.inner.feed+prio,cl,prio); 451 htb_add_to_id_tree(p->un.inner.feed + prio, cl, prio);
555 } 452 }
556 HTB_DBG(7,3,"htb_act_pr_aft p=%X pact=%X mask=%lX pmode=%d\n",
557 p->classid,p->prio_activity,mask,p->cmode);
558 p->prio_activity |= mask; 453 p->prio_activity |= mask;
559 cl = p; p = cl->parent; 454 cl = p;
560 HTB_CHCL(cl); 455 p = cl->parent;
456
561 } 457 }
562 if (cl->cmode == HTB_CAN_SEND && mask) 458 if (cl->cmode == HTB_CAN_SEND && mask)
563 htb_add_class_to_row(q,cl,mask); 459 htb_add_class_to_row(q, cl, mask);
564} 460}
565 461
566/** 462/**
@@ -573,39 +469,52 @@ static void htb_activate_prios(struct htb_sched *q,struct htb_class *cl)
573static void htb_deactivate_prios(struct htb_sched *q, struct htb_class *cl) 469static void htb_deactivate_prios(struct htb_sched *q, struct htb_class *cl)
574{ 470{
575 struct htb_class *p = cl->parent; 471 struct htb_class *p = cl->parent;
576 long m,mask = cl->prio_activity; 472 long m, mask = cl->prio_activity;
577 HTB_DBG(7,2,"htb_deact_prios cl=%X mask=%lX cmode=%d\n",cl->classid,mask,cl->cmode);
578 HTB_CHCL(cl);
579 473
580 while (cl->cmode == HTB_MAY_BORROW && p && mask) { 474 while (cl->cmode == HTB_MAY_BORROW && p && mask) {
581 m = mask; mask = 0; 475 m = mask;
476 mask = 0;
582 while (m) { 477 while (m) {
583 int prio = ffz(~m); 478 int prio = ffz(~m);
584 m &= ~(1 << prio); 479 m &= ~(1 << prio);
585 480
586 if (p->un.inner.ptr[prio] == cl->node+prio) { 481 if (p->un.inner.ptr[prio] == cl->node + prio) {
587 /* we are removing child which is pointed to from 482 /* we are removing child which is pointed to from
588 parent feed - forget the pointer but remember 483 parent feed - forget the pointer but remember
589 classid */ 484 classid */
590 p->un.inner.last_ptr_id[prio] = cl->classid; 485 p->un.inner.last_ptr_id[prio] = cl->classid;
591 p->un.inner.ptr[prio] = NULL; 486 p->un.inner.ptr[prio] = NULL;
592 } 487 }
593 488
594 htb_safe_rb_erase(cl->node + prio,p->un.inner.feed + prio); 489 htb_safe_rb_erase(cl->node + prio, p->un.inner.feed + prio);
595 490
596 if (!p->un.inner.feed[prio].rb_node) 491 if (!p->un.inner.feed[prio].rb_node)
597 mask |= 1 << prio; 492 mask |= 1 << prio;
598 } 493 }
599 HTB_DBG(7,3,"htb_deact_pr_aft p=%X pact=%X mask=%lX pmode=%d\n", 494
600 p->classid,p->prio_activity,mask,p->cmode);
601 p->prio_activity &= ~mask; 495 p->prio_activity &= ~mask;
602 cl = p; p = cl->parent; 496 cl = p;
603 HTB_CHCL(cl); 497 p = cl->parent;
498
604 } 499 }
605 if (cl->cmode == HTB_CAN_SEND && mask) 500 if (cl->cmode == HTB_CAN_SEND && mask)
606 htb_remove_class_from_row(q,cl,mask); 501 htb_remove_class_from_row(q, cl, mask);
607} 502}
608 503
504#if HTB_HYSTERESIS
505static inline long htb_lowater(const struct htb_class *cl)
506{
507 return cl->cmode != HTB_CANT_SEND ? -cl->cbuffer : 0;
508}
509static inline long htb_hiwater(const struct htb_class *cl)
510{
511 return cl->cmode == HTB_CAN_SEND ? -cl->buffer : 0;
512}
513#else
514#define htb_lowater(cl) (0)
515#define htb_hiwater(cl) (0)
516#endif
517
609/** 518/**
610 * htb_class_mode - computes and returns current class mode 519 * htb_class_mode - computes and returns current class mode
611 * 520 *
@@ -617,28 +526,21 @@ static void htb_deactivate_prios(struct htb_sched *q, struct htb_class *cl)
617 * 0 .. -cl->{c,}buffer range. It is meant to limit number of 526 * 0 .. -cl->{c,}buffer range. It is meant to limit number of
618 * mode transitions per time unit. The speed gain is about 1/6. 527 * mode transitions per time unit. The speed gain is about 1/6.
619 */ 528 */
620static __inline__ enum htb_cmode 529static inline enum htb_cmode
621htb_class_mode(struct htb_class *cl,long *diff) 530htb_class_mode(struct htb_class *cl, long *diff)
622{ 531{
623 long toks; 532 long toks;
624 533
625 if ((toks = (cl->ctokens + *diff)) < ( 534 if ((toks = (cl->ctokens + *diff)) < htb_lowater(cl)) {
626#if HTB_HYSTERESIS 535 *diff = -toks;
627 cl->cmode != HTB_CANT_SEND ? -cl->cbuffer : 536 return HTB_CANT_SEND;
628#endif 537 }
629 0)) { 538
630 *diff = -toks; 539 if ((toks = (cl->tokens + *diff)) >= htb_hiwater(cl))
631 return HTB_CANT_SEND; 540 return HTB_CAN_SEND;
632 }
633 if ((toks = (cl->tokens + *diff)) >= (
634#if HTB_HYSTERESIS
635 cl->cmode == HTB_CAN_SEND ? -cl->buffer :
636#endif
637 0))
638 return HTB_CAN_SEND;
639 541
640 *diff = -toks; 542 *diff = -toks;
641 return HTB_MAY_BORROW; 543 return HTB_MAY_BORROW;
642} 544}
643 545
644/** 546/**
@@ -650,24 +552,21 @@ htb_class_mode(struct htb_class *cl,long *diff)
650 * be different from old one and cl->pq_key has to be valid if changing 552 * be different from old one and cl->pq_key has to be valid if changing
651 * to mode other than HTB_CAN_SEND (see htb_add_to_wait_tree). 553 * to mode other than HTB_CAN_SEND (see htb_add_to_wait_tree).
652 */ 554 */
653static void 555static void
654htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, long *diff) 556htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, long *diff)
655{ 557{
656 enum htb_cmode new_mode = htb_class_mode(cl,diff); 558 enum htb_cmode new_mode = htb_class_mode(cl, diff);
657
658 HTB_CHCL(cl);
659 HTB_DBG(7,1,"htb_chging_clmode %d->%d cl=%X\n",cl->cmode,new_mode,cl->classid);
660 559
661 if (new_mode == cl->cmode) 560 if (new_mode == cl->cmode)
662 return; 561 return;
663 562
664 if (cl->prio_activity) { /* not necessary: speed optimization */ 563 if (cl->prio_activity) { /* not necessary: speed optimization */
665 if (cl->cmode != HTB_CANT_SEND) 564 if (cl->cmode != HTB_CANT_SEND)
666 htb_deactivate_prios(q,cl); 565 htb_deactivate_prios(q, cl);
667 cl->cmode = new_mode; 566 cl->cmode = new_mode;
668 if (new_mode != HTB_CANT_SEND) 567 if (new_mode != HTB_CANT_SEND)
669 htb_activate_prios(q,cl); 568 htb_activate_prios(q, cl);
670 } else 569 } else
671 cl->cmode = new_mode; 570 cl->cmode = new_mode;
672} 571}
673 572
@@ -678,14 +577,15 @@ htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, long *diff)
678 * for the prio. It can be called on already active leaf safely. 577 * for the prio. It can be called on already active leaf safely.
679 * It also adds leaf into droplist. 578 * It also adds leaf into droplist.
680 */ 579 */
681static __inline__ void htb_activate(struct htb_sched *q,struct htb_class *cl) 580static inline void htb_activate(struct htb_sched *q, struct htb_class *cl)
682{ 581{
683 BUG_TRAP(!cl->level && cl->un.leaf.q && cl->un.leaf.q->q.qlen); 582 BUG_TRAP(!cl->level && cl->un.leaf.q && cl->un.leaf.q->q.qlen);
684 HTB_CHCL(cl); 583
685 if (!cl->prio_activity) { 584 if (!cl->prio_activity) {
686 cl->prio_activity = 1 << (cl->un.leaf.aprio = cl->un.leaf.prio); 585 cl->prio_activity = 1 << (cl->un.leaf.aprio = cl->un.leaf.prio);
687 htb_activate_prios(q,cl); 586 htb_activate_prios(q, cl);
688 list_add_tail(&cl->un.leaf.drop_list,q->drops+cl->un.leaf.aprio); 587 list_add_tail(&cl->un.leaf.drop_list,
588 q->drops + cl->un.leaf.aprio);
689 } 589 }
690} 590}
691 591
@@ -695,120 +595,120 @@ static __inline__ void htb_activate(struct htb_sched *q,struct htb_class *cl)
695 * Make sure that leaf is active. In the other words it can't be called 595 * Make sure that leaf is active. In the other words it can't be called
696 * with non-active leaf. It also removes class from the drop list. 596 * with non-active leaf. It also removes class from the drop list.
697 */ 597 */
698static __inline__ void 598static inline void htb_deactivate(struct htb_sched *q, struct htb_class *cl)
699htb_deactivate(struct htb_sched *q,struct htb_class *cl)
700{ 599{
701 BUG_TRAP(cl->prio_activity); 600 BUG_TRAP(cl->prio_activity);
702 HTB_CHCL(cl); 601
703 htb_deactivate_prios(q,cl); 602 htb_deactivate_prios(q, cl);
704 cl->prio_activity = 0; 603 cl->prio_activity = 0;
705 list_del_init(&cl->un.leaf.drop_list); 604 list_del_init(&cl->un.leaf.drop_list);
706} 605}
707 606
708static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch) 607static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
709{ 608{
710 int ret; 609 int ret;
711 struct htb_sched *q = qdisc_priv(sch); 610 struct htb_sched *q = qdisc_priv(sch);
712 struct htb_class *cl = htb_classify(skb,sch,&ret); 611 struct htb_class *cl = htb_classify(skb, sch, &ret);
713 612
714 if (cl == HTB_DIRECT) { 613 if (cl == HTB_DIRECT) {
715 /* enqueue to helper queue */ 614 /* enqueue to helper queue */
716 if (q->direct_queue.qlen < q->direct_qlen) { 615 if (q->direct_queue.qlen < q->direct_qlen) {
717 __skb_queue_tail(&q->direct_queue, skb); 616 __skb_queue_tail(&q->direct_queue, skb);
718 q->direct_pkts++; 617 q->direct_pkts++;
719 } else { 618 } else {
720 kfree_skb(skb); 619 kfree_skb(skb);
721 sch->qstats.drops++; 620 sch->qstats.drops++;
722 return NET_XMIT_DROP; 621 return NET_XMIT_DROP;
723 } 622 }
724#ifdef CONFIG_NET_CLS_ACT 623#ifdef CONFIG_NET_CLS_ACT
725 } else if (!cl) { 624 } else if (!cl) {
726 if (ret == NET_XMIT_BYPASS) 625 if (ret == NET_XMIT_BYPASS)
727 sch->qstats.drops++; 626 sch->qstats.drops++;
728 kfree_skb (skb); 627 kfree_skb(skb);
729 return ret; 628 return ret;
730#endif 629#endif
731 } else if (cl->un.leaf.q->enqueue(skb, cl->un.leaf.q) != NET_XMIT_SUCCESS) { 630 } else if (cl->un.leaf.q->enqueue(skb, cl->un.leaf.q) !=
732 sch->qstats.drops++; 631 NET_XMIT_SUCCESS) {
733 cl->qstats.drops++; 632 sch->qstats.drops++;
734 return NET_XMIT_DROP; 633 cl->qstats.drops++;
735 } else { 634 return NET_XMIT_DROP;
736 cl->bstats.packets++; cl->bstats.bytes += skb->len; 635 } else {
737 htb_activate (q,cl); 636 cl->bstats.packets++;
738 } 637 cl->bstats.bytes += skb->len;
739 638 htb_activate(q, cl);
740 sch->q.qlen++; 639 }
741 sch->bstats.packets++; sch->bstats.bytes += skb->len; 640
742 HTB_DBG(1,1,"htb_enq_ok cl=%X skb=%p\n",(cl && cl != HTB_DIRECT)?cl->classid:0,skb); 641 sch->q.qlen++;
743 return NET_XMIT_SUCCESS; 642 sch->bstats.packets++;
643 sch->bstats.bytes += skb->len;
644 return NET_XMIT_SUCCESS;
744} 645}
745 646
746/* TODO: requeuing packet charges it to policers again !! */ 647/* TODO: requeuing packet charges it to policers again !! */
747static int htb_requeue(struct sk_buff *skb, struct Qdisc *sch) 648static int htb_requeue(struct sk_buff *skb, struct Qdisc *sch)
748{ 649{
749 struct htb_sched *q = qdisc_priv(sch); 650 struct htb_sched *q = qdisc_priv(sch);
750 int ret = NET_XMIT_SUCCESS; 651 int ret = NET_XMIT_SUCCESS;
751 struct htb_class *cl = htb_classify(skb,sch, &ret); 652 struct htb_class *cl = htb_classify(skb, sch, &ret);
752 struct sk_buff *tskb; 653 struct sk_buff *tskb;
753 654
754 if (cl == HTB_DIRECT || !cl) { 655 if (cl == HTB_DIRECT || !cl) {
755 /* enqueue to helper queue */ 656 /* enqueue to helper queue */
756 if (q->direct_queue.qlen < q->direct_qlen && cl) { 657 if (q->direct_queue.qlen < q->direct_qlen && cl) {
757 __skb_queue_head(&q->direct_queue, skb); 658 __skb_queue_head(&q->direct_queue, skb);
758 } else { 659 } else {
759 __skb_queue_head(&q->direct_queue, skb); 660 __skb_queue_head(&q->direct_queue, skb);
760 tskb = __skb_dequeue_tail(&q->direct_queue); 661 tskb = __skb_dequeue_tail(&q->direct_queue);
761 kfree_skb (tskb); 662 kfree_skb(tskb);
762 sch->qstats.drops++; 663 sch->qstats.drops++;
763 return NET_XMIT_CN; 664 return NET_XMIT_CN;
764 } 665 }
765 } else if (cl->un.leaf.q->ops->requeue(skb, cl->un.leaf.q) != NET_XMIT_SUCCESS) { 666 } else if (cl->un.leaf.q->ops->requeue(skb, cl->un.leaf.q) !=
766 sch->qstats.drops++; 667 NET_XMIT_SUCCESS) {
767 cl->qstats.drops++; 668 sch->qstats.drops++;
768 return NET_XMIT_DROP; 669 cl->qstats.drops++;
769 } else 670 return NET_XMIT_DROP;
770 htb_activate (q,cl); 671 } else
771 672 htb_activate(q, cl);
772 sch->q.qlen++; 673
773 sch->qstats.requeues++; 674 sch->q.qlen++;
774 HTB_DBG(1,1,"htb_req_ok cl=%X skb=%p\n",(cl && cl != HTB_DIRECT)?cl->classid:0,skb); 675 sch->qstats.requeues++;
775 return NET_XMIT_SUCCESS; 676 return NET_XMIT_SUCCESS;
776} 677}
777 678
778static void htb_timer(unsigned long arg) 679static void htb_timer(unsigned long arg)
779{ 680{
780 struct Qdisc *sch = (struct Qdisc*)arg; 681 struct Qdisc *sch = (struct Qdisc *)arg;
781 sch->flags &= ~TCQ_F_THROTTLED; 682 sch->flags &= ~TCQ_F_THROTTLED;
782 wmb(); 683 wmb();
783 netif_schedule(sch->dev); 684 netif_schedule(sch->dev);
784} 685}
785 686
786#ifdef HTB_RATECM 687#ifdef HTB_RATECM
787#define RT_GEN(D,R) R+=D-(R/HTB_EWMAC);D=0 688#define RT_GEN(D,R) R+=D-(R/HTB_EWMAC);D=0
788static void htb_rate_timer(unsigned long arg) 689static void htb_rate_timer(unsigned long arg)
789{ 690{
790 struct Qdisc *sch = (struct Qdisc*)arg; 691 struct Qdisc *sch = (struct Qdisc *)arg;
791 struct htb_sched *q = qdisc_priv(sch); 692 struct htb_sched *q = qdisc_priv(sch);
792 struct list_head *p; 693 struct hlist_node *p;
694 struct htb_class *cl;
695
793 696
794 /* lock queue so that we can muck with it */ 697 /* lock queue so that we can muck with it */
795 HTB_QLOCK(sch); 698 spin_lock_bh(&sch->dev->queue_lock);
796 HTB_DBG(10,1,"htb_rttmr j=%ld\n",jiffies);
797 699
798 q->rttim.expires = jiffies + HZ; 700 q->rttim.expires = jiffies + HZ;
799 add_timer(&q->rttim); 701 add_timer(&q->rttim);
800 702
801 /* scan and recompute one bucket at time */ 703 /* scan and recompute one bucket at time */
802 if (++q->recmp_bucket >= HTB_HSIZE) 704 if (++q->recmp_bucket >= HTB_HSIZE)
803 q->recmp_bucket = 0; 705 q->recmp_bucket = 0;
804 list_for_each (p,q->hash+q->recmp_bucket) { 706
805 struct htb_class *cl = list_entry(p,struct htb_class,hlist); 707 hlist_for_each_entry(cl,p, q->hash + q->recmp_bucket, hlist) {
806 HTB_DBG(10,2,"htb_rttmr_cl cl=%X sbyte=%lu spkt=%lu\n", 708 RT_GEN(cl->sum_bytes, cl->rate_bytes);
807 cl->classid,cl->sum_bytes,cl->sum_packets); 709 RT_GEN(cl->sum_packets, cl->rate_packets);
808 RT_GEN (cl->sum_bytes,cl->rate_bytes);
809 RT_GEN (cl->sum_packets,cl->rate_packets);
810 } 710 }
811 HTB_QUNLOCK(sch); 711 spin_unlock_bh(&sch->dev->queue_lock);
812} 712}
813#endif 713#endif
814 714
@@ -823,12 +723,11 @@ static void htb_rate_timer(unsigned long arg)
823 * CAN_SEND) because we can use more precise clock that event queue here. 723 * CAN_SEND) because we can use more precise clock that event queue here.
824 * In such case we remove class from event queue first. 724 * In such case we remove class from event queue first.
825 */ 725 */
826static void htb_charge_class(struct htb_sched *q,struct htb_class *cl, 726static void htb_charge_class(struct htb_sched *q, struct htb_class *cl,
827 int level,int bytes) 727 int level, int bytes)
828{ 728{
829 long toks,diff; 729 long toks, diff;
830 enum htb_cmode old_mode; 730 enum htb_cmode old_mode;
831 HTB_DBG(5,1,"htb_chrg_cl cl=%X lev=%d len=%d\n",cl->classid,level,bytes);
832 731
833#define HTB_ACCNT(T,B,R) toks = diff + cl->T; \ 732#define HTB_ACCNT(T,B,R) toks = diff + cl->T; \
834 if (toks > cl->B) toks = cl->B; \ 733 if (toks > cl->B) toks = cl->B; \
@@ -837,47 +736,31 @@ static void htb_charge_class(struct htb_sched *q,struct htb_class *cl,
837 cl->T = toks 736 cl->T = toks
838 737
839 while (cl) { 738 while (cl) {
840 HTB_CHCL(cl); 739 diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32) cl->mbuffer);
841 diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32)cl->mbuffer);
842#ifdef HTB_DEBUG
843 if (diff > cl->mbuffer || diff < 0 || PSCHED_TLESS(q->now, cl->t_c)) {
844 if (net_ratelimit())
845 printk(KERN_ERR "HTB: bad diff in charge, cl=%X diff=%lX now=%Lu then=%Lu j=%lu\n",
846 cl->classid, diff,
847#ifdef CONFIG_NET_SCH_CLK_GETTIMEOFDAY
848 q->now.tv_sec * 1000000ULL + q->now.tv_usec,
849 cl->t_c.tv_sec * 1000000ULL + cl->t_c.tv_usec,
850#else
851 (unsigned long long) q->now,
852 (unsigned long long) cl->t_c,
853#endif
854 q->jiffies);
855 diff = 1000;
856 }
857#endif
858 if (cl->level >= level) { 740 if (cl->level >= level) {
859 if (cl->level == level) cl->xstats.lends++; 741 if (cl->level == level)
860 HTB_ACCNT (tokens,buffer,rate); 742 cl->xstats.lends++;
743 HTB_ACCNT(tokens, buffer, rate);
861 } else { 744 } else {
862 cl->xstats.borrows++; 745 cl->xstats.borrows++;
863 cl->tokens += diff; /* we moved t_c; update tokens */ 746 cl->tokens += diff; /* we moved t_c; update tokens */
864 } 747 }
865 HTB_ACCNT (ctokens,cbuffer,ceil); 748 HTB_ACCNT(ctokens, cbuffer, ceil);
866 cl->t_c = q->now; 749 cl->t_c = q->now;
867 HTB_DBG(5,2,"htb_chrg_clp cl=%X diff=%ld tok=%ld ctok=%ld\n",cl->classid,diff,cl->tokens,cl->ctokens);
868 750
869 old_mode = cl->cmode; diff = 0; 751 old_mode = cl->cmode;
870 htb_change_class_mode(q,cl,&diff); 752 diff = 0;
753 htb_change_class_mode(q, cl, &diff);
871 if (old_mode != cl->cmode) { 754 if (old_mode != cl->cmode) {
872 if (old_mode != HTB_CAN_SEND) 755 if (old_mode != HTB_CAN_SEND)
873 htb_safe_rb_erase(&cl->pq_node,q->wait_pq+cl->level); 756 htb_safe_rb_erase(&cl->pq_node, q->wait_pq + cl->level);
874 if (cl->cmode != HTB_CAN_SEND) 757 if (cl->cmode != HTB_CAN_SEND)
875 htb_add_to_wait_tree (q,cl,diff,1); 758 htb_add_to_wait_tree(q, cl, diff);
876 } 759 }
877
878#ifdef HTB_RATECM 760#ifdef HTB_RATECM
879 /* update rate counters */ 761 /* update rate counters */
880 cl->sum_bytes += bytes; cl->sum_packets++; 762 cl->sum_bytes += bytes;
763 cl->sum_packets++;
881#endif 764#endif
882 765
883 /* update byte stats except for leaves which are already updated */ 766 /* update byte stats except for leaves which are already updated */
@@ -896,60 +779,46 @@ static void htb_charge_class(struct htb_sched *q,struct htb_class *cl,
896 * next pending event (0 for no event in pq). 779 * next pending event (0 for no event in pq).
897 * Note: Aplied are events whose have cl->pq_key <= jiffies. 780 * Note: Aplied are events whose have cl->pq_key <= jiffies.
898 */ 781 */
899static long htb_do_events(struct htb_sched *q,int level) 782static long htb_do_events(struct htb_sched *q, int level)
900{ 783{
901 int i; 784 int i;
902 HTB_DBG(8,1,"htb_do_events l=%d root=%p rmask=%X\n", 785
903 level,q->wait_pq[level].rb_node,q->row_mask[level]);
904 for (i = 0; i < 500; i++) { 786 for (i = 0; i < 500; i++) {
905 struct htb_class *cl; 787 struct htb_class *cl;
906 long diff; 788 long diff;
907 struct rb_node *p = q->wait_pq[level].rb_node; 789 struct rb_node *p = q->wait_pq[level].rb_node;
908 if (!p) return 0; 790 if (!p)
909 while (p->rb_left) p = p->rb_left; 791 return 0;
792 while (p->rb_left)
793 p = p->rb_left;
910 794
911 cl = rb_entry(p, struct htb_class, pq_node); 795 cl = rb_entry(p, struct htb_class, pq_node);
912 if (time_after(cl->pq_key, q->jiffies)) { 796 if (time_after(cl->pq_key, q->jiffies)) {
913 HTB_DBG(8,3,"htb_do_ev_ret delay=%ld\n",cl->pq_key - q->jiffies);
914 return cl->pq_key - q->jiffies; 797 return cl->pq_key - q->jiffies;
915 } 798 }
916 htb_safe_rb_erase(p,q->wait_pq+level); 799 htb_safe_rb_erase(p, q->wait_pq + level);
917 diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32)cl->mbuffer); 800 diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32) cl->mbuffer);
918#ifdef HTB_DEBUG 801 htb_change_class_mode(q, cl, &diff);
919 if (diff > cl->mbuffer || diff < 0 || PSCHED_TLESS(q->now, cl->t_c)) {
920 if (net_ratelimit())
921 printk(KERN_ERR "HTB: bad diff in events, cl=%X diff=%lX now=%Lu then=%Lu j=%lu\n",
922 cl->classid, diff,
923#ifdef CONFIG_NET_SCH_CLK_GETTIMEOFDAY
924 q->now.tv_sec * 1000000ULL + q->now.tv_usec,
925 cl->t_c.tv_sec * 1000000ULL + cl->t_c.tv_usec,
926#else
927 (unsigned long long) q->now,
928 (unsigned long long) cl->t_c,
929#endif
930 q->jiffies);
931 diff = 1000;
932 }
933#endif
934 htb_change_class_mode(q,cl,&diff);
935 if (cl->cmode != HTB_CAN_SEND) 802 if (cl->cmode != HTB_CAN_SEND)
936 htb_add_to_wait_tree (q,cl,diff,2); 803 htb_add_to_wait_tree(q, cl, diff);
937 } 804 }
938 if (net_ratelimit()) 805 if (net_ratelimit())
939 printk(KERN_WARNING "htb: too many events !\n"); 806 printk(KERN_WARNING "htb: too many events !\n");
940 return HZ/10; 807 return HZ / 10;
941} 808}
942 809
943/* Returns class->node+prio from id-tree where classe's id is >= id. NULL 810/* Returns class->node+prio from id-tree where classe's id is >= id. NULL
944 is no such one exists. */ 811 is no such one exists. */
945static struct rb_node * 812static struct rb_node *htb_id_find_next_upper(int prio, struct rb_node *n,
946htb_id_find_next_upper(int prio,struct rb_node *n,u32 id) 813 u32 id)
947{ 814{
948 struct rb_node *r = NULL; 815 struct rb_node *r = NULL;
949 while (n) { 816 while (n) {
950 struct htb_class *cl = rb_entry(n,struct htb_class,node[prio]); 817 struct htb_class *cl =
951 if (id == cl->classid) return n; 818 rb_entry(n, struct htb_class, node[prio]);
952 819 if (id == cl->classid)
820 return n;
821
953 if (id > cl->classid) { 822 if (id > cl->classid) {
954 n = n->rb_right; 823 n = n->rb_right;
955 } else { 824 } else {
@@ -965,49 +834,49 @@ htb_id_find_next_upper(int prio,struct rb_node *n,u32 id)
965 * 834 *
966 * Find leaf where current feed pointers points to. 835 * Find leaf where current feed pointers points to.
967 */ 836 */
968static struct htb_class * 837static struct htb_class *htb_lookup_leaf(struct rb_root *tree, int prio,
969htb_lookup_leaf(HTB_ARGQ struct rb_root *tree,int prio,struct rb_node **pptr,u32 *pid) 838 struct rb_node **pptr, u32 * pid)
970{ 839{
971 int i; 840 int i;
972 struct { 841 struct {
973 struct rb_node *root; 842 struct rb_node *root;
974 struct rb_node **pptr; 843 struct rb_node **pptr;
975 u32 *pid; 844 u32 *pid;
976 } stk[TC_HTB_MAXDEPTH],*sp = stk; 845 } stk[TC_HTB_MAXDEPTH], *sp = stk;
977 846
978 BUG_TRAP(tree->rb_node); 847 BUG_TRAP(tree->rb_node);
979 sp->root = tree->rb_node; 848 sp->root = tree->rb_node;
980 sp->pptr = pptr; 849 sp->pptr = pptr;
981 sp->pid = pid; 850 sp->pid = pid;
982 851
983 for (i = 0; i < 65535; i++) { 852 for (i = 0; i < 65535; i++) {
984 HTB_DBG(4,2,"htb_lleaf ptr=%p pid=%X\n",*sp->pptr,*sp->pid); 853 if (!*sp->pptr && *sp->pid) {
985
986 if (!*sp->pptr && *sp->pid) {
987 /* ptr was invalidated but id is valid - try to recover 854 /* ptr was invalidated but id is valid - try to recover
988 the original or next ptr */ 855 the original or next ptr */
989 *sp->pptr = htb_id_find_next_upper(prio,sp->root,*sp->pid); 856 *sp->pptr =
857 htb_id_find_next_upper(prio, sp->root, *sp->pid);
990 } 858 }
991 *sp->pid = 0; /* ptr is valid now so that remove this hint as it 859 *sp->pid = 0; /* ptr is valid now so that remove this hint as it
992 can become out of date quickly */ 860 can become out of date quickly */
993 if (!*sp->pptr) { /* we are at right end; rewind & go up */ 861 if (!*sp->pptr) { /* we are at right end; rewind & go up */
994 *sp->pptr = sp->root; 862 *sp->pptr = sp->root;
995 while ((*sp->pptr)->rb_left) 863 while ((*sp->pptr)->rb_left)
996 *sp->pptr = (*sp->pptr)->rb_left; 864 *sp->pptr = (*sp->pptr)->rb_left;
997 if (sp > stk) { 865 if (sp > stk) {
998 sp--; 866 sp--;
999 BUG_TRAP(*sp->pptr); if(!*sp->pptr) return NULL; 867 BUG_TRAP(*sp->pptr);
1000 htb_next_rb_node (sp->pptr); 868 if (!*sp->pptr)
869 return NULL;
870 htb_next_rb_node(sp->pptr);
1001 } 871 }
1002 } else { 872 } else {
1003 struct htb_class *cl; 873 struct htb_class *cl;
1004 cl = rb_entry(*sp->pptr,struct htb_class,node[prio]); 874 cl = rb_entry(*sp->pptr, struct htb_class, node[prio]);
1005 HTB_CHCL(cl); 875 if (!cl->level)
1006 if (!cl->level)
1007 return cl; 876 return cl;
1008 (++sp)->root = cl->un.inner.feed[prio].rb_node; 877 (++sp)->root = cl->un.inner.feed[prio].rb_node;
1009 sp->pptr = cl->un.inner.ptr+prio; 878 sp->pptr = cl->un.inner.ptr + prio;
1010 sp->pid = cl->un.inner.last_ptr_id+prio; 879 sp->pid = cl->un.inner.last_ptr_id + prio;
1011 } 880 }
1012 } 881 }
1013 BUG_TRAP(0); 882 BUG_TRAP(0);
@@ -1016,21 +885,21 @@ htb_lookup_leaf(HTB_ARGQ struct rb_root *tree,int prio,struct rb_node **pptr,u32
1016 885
1017/* dequeues packet at given priority and level; call only if 886/* dequeues packet at given priority and level; call only if
1018 you are sure that there is active class at prio/level */ 887 you are sure that there is active class at prio/level */
1019static struct sk_buff * 888static struct sk_buff *htb_dequeue_tree(struct htb_sched *q, int prio,
1020htb_dequeue_tree(struct htb_sched *q,int prio,int level) 889 int level)
1021{ 890{
1022 struct sk_buff *skb = NULL; 891 struct sk_buff *skb = NULL;
1023 struct htb_class *cl,*start; 892 struct htb_class *cl, *start;
1024 /* look initial class up in the row */ 893 /* look initial class up in the row */
1025 start = cl = htb_lookup_leaf (HTB_PASSQ q->row[level]+prio,prio, 894 start = cl = htb_lookup_leaf(q->row[level] + prio, prio,
1026 q->ptr[level]+prio,q->last_ptr_id[level]+prio); 895 q->ptr[level] + prio,
1027 896 q->last_ptr_id[level] + prio);
897
1028 do { 898 do {
1029next: 899next:
1030 BUG_TRAP(cl); 900 BUG_TRAP(cl);
1031 if (!cl) return NULL; 901 if (!cl)
1032 HTB_DBG(4,1,"htb_deq_tr prio=%d lev=%d cl=%X defic=%d\n", 902 return NULL;
1033 prio,level,cl->classid,cl->un.leaf.deficit[level]);
1034 903
1035 /* class can be empty - it is unlikely but can be true if leaf 904 /* class can be empty - it is unlikely but can be true if leaf
1036 qdisc drops packets in enqueue routine or if someone used 905 qdisc drops packets in enqueue routine or if someone used
@@ -1038,64 +907,69 @@ next:
1038 simply deactivate and skip such class */ 907 simply deactivate and skip such class */
1039 if (unlikely(cl->un.leaf.q->q.qlen == 0)) { 908 if (unlikely(cl->un.leaf.q->q.qlen == 0)) {
1040 struct htb_class *next; 909 struct htb_class *next;
1041 htb_deactivate(q,cl); 910 htb_deactivate(q, cl);
1042 911
1043 /* row/level might become empty */ 912 /* row/level might become empty */
1044 if ((q->row_mask[level] & (1 << prio)) == 0) 913 if ((q->row_mask[level] & (1 << prio)) == 0)
1045 return NULL; 914 return NULL;
1046 915
1047 next = htb_lookup_leaf (HTB_PASSQ q->row[level]+prio, 916 next = htb_lookup_leaf(q->row[level] + prio,
1048 prio,q->ptr[level]+prio,q->last_ptr_id[level]+prio); 917 prio, q->ptr[level] + prio,
918 q->last_ptr_id[level] + prio);
1049 919
1050 if (cl == start) /* fix start if we just deleted it */ 920 if (cl == start) /* fix start if we just deleted it */
1051 start = next; 921 start = next;
1052 cl = next; 922 cl = next;
1053 goto next; 923 goto next;
1054 } 924 }
1055 925
1056 if (likely((skb = cl->un.leaf.q->dequeue(cl->un.leaf.q)) != NULL)) 926 skb = cl->un.leaf.q->dequeue(cl->un.leaf.q);
927 if (likely(skb != NULL))
1057 break; 928 break;
1058 if (!cl->warned) { 929 if (!cl->warned) {
1059 printk(KERN_WARNING "htb: class %X isn't work conserving ?!\n",cl->classid); 930 printk(KERN_WARNING
931 "htb: class %X isn't work conserving ?!\n",
932 cl->classid);
1060 cl->warned = 1; 933 cl->warned = 1;
1061 } 934 }
1062 q->nwc_hit++; 935 q->nwc_hit++;
1063 htb_next_rb_node((level?cl->parent->un.inner.ptr:q->ptr[0])+prio); 936 htb_next_rb_node((level ? cl->parent->un.inner.ptr : q->
1064 cl = htb_lookup_leaf (HTB_PASSQ q->row[level]+prio,prio,q->ptr[level]+prio, 937 ptr[0]) + prio);
1065 q->last_ptr_id[level]+prio); 938 cl = htb_lookup_leaf(q->row[level] + prio, prio,
939 q->ptr[level] + prio,
940 q->last_ptr_id[level] + prio);
1066 941
1067 } while (cl != start); 942 } while (cl != start);
1068 943
1069 if (likely(skb != NULL)) { 944 if (likely(skb != NULL)) {
1070 if ((cl->un.leaf.deficit[level] -= skb->len) < 0) { 945 if ((cl->un.leaf.deficit[level] -= skb->len) < 0) {
1071 HTB_DBG(4,2,"htb_next_cl oldptr=%p quant_add=%d\n",
1072 level?cl->parent->un.inner.ptr[prio]:q->ptr[0][prio],cl->un.leaf.quantum);
1073 cl->un.leaf.deficit[level] += cl->un.leaf.quantum; 946 cl->un.leaf.deficit[level] += cl->un.leaf.quantum;
1074 htb_next_rb_node((level?cl->parent->un.inner.ptr:q->ptr[0])+prio); 947 htb_next_rb_node((level ? cl->parent->un.inner.ptr : q->
948 ptr[0]) + prio);
1075 } 949 }
1076 /* this used to be after charge_class but this constelation 950 /* this used to be after charge_class but this constelation
1077 gives us slightly better performance */ 951 gives us slightly better performance */
1078 if (!cl->un.leaf.q->q.qlen) 952 if (!cl->un.leaf.q->q.qlen)
1079 htb_deactivate (q,cl); 953 htb_deactivate(q, cl);
1080 htb_charge_class (q,cl,level,skb->len); 954 htb_charge_class(q, cl, level, skb->len);
1081 } 955 }
1082 return skb; 956 return skb;
1083} 957}
1084 958
1085static void htb_delay_by(struct Qdisc *sch,long delay) 959static void htb_delay_by(struct Qdisc *sch, long delay)
1086{ 960{
1087 struct htb_sched *q = qdisc_priv(sch); 961 struct htb_sched *q = qdisc_priv(sch);
1088 if (delay <= 0) delay = 1; 962 if (delay <= 0)
1089 if (unlikely(delay > 5*HZ)) { 963 delay = 1;
964 if (unlikely(delay > 5 * HZ)) {
1090 if (net_ratelimit()) 965 if (net_ratelimit())
1091 printk(KERN_INFO "HTB delay %ld > 5sec\n", delay); 966 printk(KERN_INFO "HTB delay %ld > 5sec\n", delay);
1092 delay = 5*HZ; 967 delay = 5 * HZ;
1093 } 968 }
1094 /* why don't use jiffies here ? because expires can be in past */ 969 /* why don't use jiffies here ? because expires can be in past */
1095 mod_timer(&q->timer, q->jiffies + delay); 970 mod_timer(&q->timer, q->jiffies + delay);
1096 sch->flags |= TCQ_F_THROTTLED; 971 sch->flags |= TCQ_F_THROTTLED;
1097 sch->qstats.overlimits++; 972 sch->qstats.overlimits++;
1098 HTB_DBG(3,1,"htb_deq t_delay=%ld\n",delay);
1099} 973}
1100 974
1101static struct sk_buff *htb_dequeue(struct Qdisc *sch) 975static struct sk_buff *htb_dequeue(struct Qdisc *sch)
@@ -1104,22 +978,19 @@ static struct sk_buff *htb_dequeue(struct Qdisc *sch)
1104 struct htb_sched *q = qdisc_priv(sch); 978 struct htb_sched *q = qdisc_priv(sch);
1105 int level; 979 int level;
1106 long min_delay; 980 long min_delay;
1107#ifdef HTB_DEBUG
1108 int evs_used = 0;
1109#endif
1110 981
1111 q->jiffies = jiffies; 982 q->jiffies = jiffies;
1112 HTB_DBG(3,1,"htb_deq dircnt=%d qlen=%d\n",skb_queue_len(&q->direct_queue),
1113 sch->q.qlen);
1114 983
1115 /* try to dequeue direct packets as high prio (!) to minimize cpu work */ 984 /* try to dequeue direct packets as high prio (!) to minimize cpu work */
1116 if ((skb = __skb_dequeue(&q->direct_queue)) != NULL) { 985 skb = __skb_dequeue(&q->direct_queue);
986 if (skb != NULL) {
1117 sch->flags &= ~TCQ_F_THROTTLED; 987 sch->flags &= ~TCQ_F_THROTTLED;
1118 sch->q.qlen--; 988 sch->q.qlen--;
1119 return skb; 989 return skb;
1120 } 990 }
1121 991
1122 if (!sch->q.qlen) goto fin; 992 if (!sch->q.qlen)
993 goto fin;
1123 PSCHED_GET_TIME(q->now); 994 PSCHED_GET_TIME(q->now);
1124 995
1125 min_delay = LONG_MAX; 996 min_delay = LONG_MAX;
@@ -1129,21 +1000,19 @@ static struct sk_buff *htb_dequeue(struct Qdisc *sch)
1129 int m; 1000 int m;
1130 long delay; 1001 long delay;
1131 if (time_after_eq(q->jiffies, q->near_ev_cache[level])) { 1002 if (time_after_eq(q->jiffies, q->near_ev_cache[level])) {
1132 delay = htb_do_events(q,level); 1003 delay = htb_do_events(q, level);
1133 q->near_ev_cache[level] = q->jiffies + (delay ? delay : HZ); 1004 q->near_ev_cache[level] =
1134#ifdef HTB_DEBUG 1005 q->jiffies + (delay ? delay : HZ);
1135 evs_used++;
1136#endif
1137 } else 1006 } else
1138 delay = q->near_ev_cache[level] - q->jiffies; 1007 delay = q->near_ev_cache[level] - q->jiffies;
1139 1008
1140 if (delay && min_delay > delay) 1009 if (delay && min_delay > delay)
1141 min_delay = delay; 1010 min_delay = delay;
1142 m = ~q->row_mask[level]; 1011 m = ~q->row_mask[level];
1143 while (m != (int)(-1)) { 1012 while (m != (int)(-1)) {
1144 int prio = ffz (m); 1013 int prio = ffz(m);
1145 m |= 1 << prio; 1014 m |= 1 << prio;
1146 skb = htb_dequeue_tree(q,prio,level); 1015 skb = htb_dequeue_tree(q, prio, level);
1147 if (likely(skb != NULL)) { 1016 if (likely(skb != NULL)) {
1148 sch->q.qlen--; 1017 sch->q.qlen--;
1149 sch->flags &= ~TCQ_F_THROTTLED; 1018 sch->flags &= ~TCQ_F_THROTTLED;
@@ -1151,40 +1020,28 @@ static struct sk_buff *htb_dequeue(struct Qdisc *sch)
1151 } 1020 }
1152 } 1021 }
1153 } 1022 }
1154#ifdef HTB_DEBUG 1023 htb_delay_by(sch, min_delay > 5 * HZ ? 5 * HZ : min_delay);
1155 if (!q->nwc_hit && min_delay >= 10*HZ && net_ratelimit()) {
1156 if (min_delay == LONG_MAX) {
1157 printk(KERN_ERR "HTB: dequeue bug (%d,%lu,%lu), report it please !\n",
1158 evs_used,q->jiffies,jiffies);
1159 htb_debug_dump(q);
1160 } else
1161 printk(KERN_WARNING "HTB: mindelay=%ld, some class has "
1162 "too small rate\n",min_delay);
1163 }
1164#endif
1165 htb_delay_by (sch,min_delay > 5*HZ ? 5*HZ : min_delay);
1166fin: 1024fin:
1167 HTB_DBG(3,1,"htb_deq_end %s j=%lu skb=%p\n",sch->dev->name,q->jiffies,skb);
1168 return skb; 1025 return skb;
1169} 1026}
1170 1027
1171/* try to drop from each class (by prio) until one succeed */ 1028/* try to drop from each class (by prio) until one succeed */
1172static unsigned int htb_drop(struct Qdisc* sch) 1029static unsigned int htb_drop(struct Qdisc *sch)
1173{ 1030{
1174 struct htb_sched *q = qdisc_priv(sch); 1031 struct htb_sched *q = qdisc_priv(sch);
1175 int prio; 1032 int prio;
1176 1033
1177 for (prio = TC_HTB_NUMPRIO - 1; prio >= 0; prio--) { 1034 for (prio = TC_HTB_NUMPRIO - 1; prio >= 0; prio--) {
1178 struct list_head *p; 1035 struct list_head *p;
1179 list_for_each (p,q->drops+prio) { 1036 list_for_each(p, q->drops + prio) {
1180 struct htb_class *cl = list_entry(p, struct htb_class, 1037 struct htb_class *cl = list_entry(p, struct htb_class,
1181 un.leaf.drop_list); 1038 un.leaf.drop_list);
1182 unsigned int len; 1039 unsigned int len;
1183 if (cl->un.leaf.q->ops->drop && 1040 if (cl->un.leaf.q->ops->drop &&
1184 (len = cl->un.leaf.q->ops->drop(cl->un.leaf.q))) { 1041 (len = cl->un.leaf.q->ops->drop(cl->un.leaf.q))) {
1185 sch->q.qlen--; 1042 sch->q.qlen--;
1186 if (!cl->un.leaf.q->q.qlen) 1043 if (!cl->un.leaf.q->q.qlen)
1187 htb_deactivate (q,cl); 1044 htb_deactivate(q, cl);
1188 return len; 1045 return len;
1189 } 1046 }
1190 } 1047 }
@@ -1194,29 +1051,25 @@ static unsigned int htb_drop(struct Qdisc* sch)
1194 1051
1195/* reset all classes */ 1052/* reset all classes */
1196/* always caled under BH & queue lock */ 1053/* always caled under BH & queue lock */
1197static void htb_reset(struct Qdisc* sch) 1054static void htb_reset(struct Qdisc *sch)
1198{ 1055{
1199 struct htb_sched *q = qdisc_priv(sch); 1056 struct htb_sched *q = qdisc_priv(sch);
1200 int i; 1057 int i;
1201 HTB_DBG(0,1,"htb_reset sch=%p, handle=%X\n",sch,sch->handle);
1202 1058
1203 for (i = 0; i < HTB_HSIZE; i++) { 1059 for (i = 0; i < HTB_HSIZE; i++) {
1204 struct list_head *p; 1060 struct hlist_node *p;
1205 list_for_each (p,q->hash+i) { 1061 struct htb_class *cl;
1206 struct htb_class *cl = list_entry(p,struct htb_class,hlist); 1062
1063 hlist_for_each_entry(cl, p, q->hash + i, hlist) {
1207 if (cl->level) 1064 if (cl->level)
1208 memset(&cl->un.inner,0,sizeof(cl->un.inner)); 1065 memset(&cl->un.inner, 0, sizeof(cl->un.inner));
1209 else { 1066 else {
1210 if (cl->un.leaf.q) 1067 if (cl->un.leaf.q)
1211 qdisc_reset(cl->un.leaf.q); 1068 qdisc_reset(cl->un.leaf.q);
1212 INIT_LIST_HEAD(&cl->un.leaf.drop_list); 1069 INIT_LIST_HEAD(&cl->un.leaf.drop_list);
1213 } 1070 }
1214 cl->prio_activity = 0; 1071 cl->prio_activity = 0;
1215 cl->cmode = HTB_CAN_SEND; 1072 cl->cmode = HTB_CAN_SEND;
1216#ifdef HTB_DEBUG
1217 cl->pq_node.rb_color = -1;
1218 memset(cl->node,255,sizeof(cl->node));
1219#endif
1220 1073
1221 } 1074 }
1222 } 1075 }
@@ -1224,12 +1077,12 @@ static void htb_reset(struct Qdisc* sch)
1224 del_timer(&q->timer); 1077 del_timer(&q->timer);
1225 __skb_queue_purge(&q->direct_queue); 1078 __skb_queue_purge(&q->direct_queue);
1226 sch->q.qlen = 0; 1079 sch->q.qlen = 0;
1227 memset(q->row,0,sizeof(q->row)); 1080 memset(q->row, 0, sizeof(q->row));
1228 memset(q->row_mask,0,sizeof(q->row_mask)); 1081 memset(q->row_mask, 0, sizeof(q->row_mask));
1229 memset(q->wait_pq,0,sizeof(q->wait_pq)); 1082 memset(q->wait_pq, 0, sizeof(q->wait_pq));
1230 memset(q->ptr,0,sizeof(q->ptr)); 1083 memset(q->ptr, 0, sizeof(q->ptr));
1231 for (i = 0; i < TC_HTB_NUMPRIO; i++) 1084 for (i = 0; i < TC_HTB_NUMPRIO; i++)
1232 INIT_LIST_HEAD(q->drops+i); 1085 INIT_LIST_HEAD(q->drops + i);
1233} 1086}
1234 1087
1235static int htb_init(struct Qdisc *sch, struct rtattr *opt) 1088static int htb_init(struct Qdisc *sch, struct rtattr *opt)
@@ -1238,36 +1091,31 @@ static int htb_init(struct Qdisc *sch, struct rtattr *opt)
1238 struct rtattr *tb[TCA_HTB_INIT]; 1091 struct rtattr *tb[TCA_HTB_INIT];
1239 struct tc_htb_glob *gopt; 1092 struct tc_htb_glob *gopt;
1240 int i; 1093 int i;
1241#ifdef HTB_DEBUG
1242 printk(KERN_INFO "HTB init, kernel part version %d.%d\n",
1243 HTB_VER >> 16,HTB_VER & 0xffff);
1244#endif
1245 if (!opt || rtattr_parse_nested(tb, TCA_HTB_INIT, opt) || 1094 if (!opt || rtattr_parse_nested(tb, TCA_HTB_INIT, opt) ||
1246 tb[TCA_HTB_INIT-1] == NULL || 1095 tb[TCA_HTB_INIT - 1] == NULL ||
1247 RTA_PAYLOAD(tb[TCA_HTB_INIT-1]) < sizeof(*gopt)) { 1096 RTA_PAYLOAD(tb[TCA_HTB_INIT - 1]) < sizeof(*gopt)) {
1248 printk(KERN_ERR "HTB: hey probably you have bad tc tool ?\n"); 1097 printk(KERN_ERR "HTB: hey probably you have bad tc tool ?\n");
1249 return -EINVAL; 1098 return -EINVAL;
1250 } 1099 }
1251 gopt = RTA_DATA(tb[TCA_HTB_INIT-1]); 1100 gopt = RTA_DATA(tb[TCA_HTB_INIT - 1]);
1252 if (gopt->version != HTB_VER >> 16) { 1101 if (gopt->version != HTB_VER >> 16) {
1253 printk(KERN_ERR "HTB: need tc/htb version %d (minor is %d), you have %d\n", 1102 printk(KERN_ERR
1254 HTB_VER >> 16,HTB_VER & 0xffff,gopt->version); 1103 "HTB: need tc/htb version %d (minor is %d), you have %d\n",
1104 HTB_VER >> 16, HTB_VER & 0xffff, gopt->version);
1255 return -EINVAL; 1105 return -EINVAL;
1256 } 1106 }
1257 q->debug = gopt->debug;
1258 HTB_DBG(0,1,"htb_init sch=%p handle=%X r2q=%d\n",sch,sch->handle,gopt->rate2quantum);
1259 1107
1260 INIT_LIST_HEAD(&q->root); 1108 INIT_LIST_HEAD(&q->root);
1261 for (i = 0; i < HTB_HSIZE; i++) 1109 for (i = 0; i < HTB_HSIZE; i++)
1262 INIT_LIST_HEAD(q->hash+i); 1110 INIT_HLIST_HEAD(q->hash + i);
1263 for (i = 0; i < TC_HTB_NUMPRIO; i++) 1111 for (i = 0; i < TC_HTB_NUMPRIO; i++)
1264 INIT_LIST_HEAD(q->drops+i); 1112 INIT_LIST_HEAD(q->drops + i);
1265 1113
1266 init_timer(&q->timer); 1114 init_timer(&q->timer);
1267 skb_queue_head_init(&q->direct_queue); 1115 skb_queue_head_init(&q->direct_queue);
1268 1116
1269 q->direct_qlen = sch->dev->tx_queue_len; 1117 q->direct_qlen = sch->dev->tx_queue_len;
1270 if (q->direct_qlen < 2) /* some devices have zero tx_queue_len */ 1118 if (q->direct_qlen < 2) /* some devices have zero tx_queue_len */
1271 q->direct_qlen = 2; 1119 q->direct_qlen = 2;
1272 q->timer.function = htb_timer; 1120 q->timer.function = htb_timer;
1273 q->timer.data = (unsigned long)sch; 1121 q->timer.data = (unsigned long)sch;
@@ -1289,80 +1137,72 @@ static int htb_init(struct Qdisc *sch, struct rtattr *opt)
1289static int htb_dump(struct Qdisc *sch, struct sk_buff *skb) 1137static int htb_dump(struct Qdisc *sch, struct sk_buff *skb)
1290{ 1138{
1291 struct htb_sched *q = qdisc_priv(sch); 1139 struct htb_sched *q = qdisc_priv(sch);
1292 unsigned char *b = skb->tail; 1140 unsigned char *b = skb->tail;
1293 struct rtattr *rta; 1141 struct rtattr *rta;
1294 struct tc_htb_glob gopt; 1142 struct tc_htb_glob gopt;
1295 HTB_DBG(0,1,"htb_dump sch=%p, handle=%X\n",sch,sch->handle); 1143 spin_lock_bh(&sch->dev->queue_lock);
1296 HTB_QLOCK(sch);
1297 gopt.direct_pkts = q->direct_pkts; 1144 gopt.direct_pkts = q->direct_pkts;
1298 1145
1299#ifdef HTB_DEBUG
1300 if (HTB_DBG_COND(0,2))
1301 htb_debug_dump(q);
1302#endif
1303 gopt.version = HTB_VER; 1146 gopt.version = HTB_VER;
1304 gopt.rate2quantum = q->rate2quantum; 1147 gopt.rate2quantum = q->rate2quantum;
1305 gopt.defcls = q->defcls; 1148 gopt.defcls = q->defcls;
1306 gopt.debug = q->debug; 1149 gopt.debug = 0;
1307 rta = (struct rtattr*)b; 1150 rta = (struct rtattr *)b;
1308 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 1151 RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
1309 RTA_PUT(skb, TCA_HTB_INIT, sizeof(gopt), &gopt); 1152 RTA_PUT(skb, TCA_HTB_INIT, sizeof(gopt), &gopt);
1310 rta->rta_len = skb->tail - b; 1153 rta->rta_len = skb->tail - b;
1311 HTB_QUNLOCK(sch); 1154 spin_unlock_bh(&sch->dev->queue_lock);
1312 return skb->len; 1155 return skb->len;
1313rtattr_failure: 1156rtattr_failure:
1314 HTB_QUNLOCK(sch); 1157 spin_unlock_bh(&sch->dev->queue_lock);
1315 skb_trim(skb, skb->tail - skb->data); 1158 skb_trim(skb, skb->tail - skb->data);
1316 return -1; 1159 return -1;
1317} 1160}
1318 1161
1319static int htb_dump_class(struct Qdisc *sch, unsigned long arg, 1162static int htb_dump_class(struct Qdisc *sch, unsigned long arg,
1320 struct sk_buff *skb, struct tcmsg *tcm) 1163 struct sk_buff *skb, struct tcmsg *tcm)
1321{ 1164{
1322#ifdef HTB_DEBUG 1165 struct htb_class *cl = (struct htb_class *)arg;
1323 struct htb_sched *q = qdisc_priv(sch); 1166 unsigned char *b = skb->tail;
1324#endif
1325 struct htb_class *cl = (struct htb_class*)arg;
1326 unsigned char *b = skb->tail;
1327 struct rtattr *rta; 1167 struct rtattr *rta;
1328 struct tc_htb_opt opt; 1168 struct tc_htb_opt opt;
1329 1169
1330 HTB_DBG(0,1,"htb_dump_class handle=%X clid=%X\n",sch->handle,cl->classid); 1170 spin_lock_bh(&sch->dev->queue_lock);
1331
1332 HTB_QLOCK(sch);
1333 tcm->tcm_parent = cl->parent ? cl->parent->classid : TC_H_ROOT; 1171 tcm->tcm_parent = cl->parent ? cl->parent->classid : TC_H_ROOT;
1334 tcm->tcm_handle = cl->classid; 1172 tcm->tcm_handle = cl->classid;
1335 if (!cl->level && cl->un.leaf.q) 1173 if (!cl->level && cl->un.leaf.q)
1336 tcm->tcm_info = cl->un.leaf.q->handle; 1174 tcm->tcm_info = cl->un.leaf.q->handle;
1337 1175
1338 rta = (struct rtattr*)b; 1176 rta = (struct rtattr *)b;
1339 RTA_PUT(skb, TCA_OPTIONS, 0, NULL); 1177 RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
1340 1178
1341 memset (&opt,0,sizeof(opt)); 1179 memset(&opt, 0, sizeof(opt));
1342 1180
1343 opt.rate = cl->rate->rate; opt.buffer = cl->buffer; 1181 opt.rate = cl->rate->rate;
1344 opt.ceil = cl->ceil->rate; opt.cbuffer = cl->cbuffer; 1182 opt.buffer = cl->buffer;
1345 opt.quantum = cl->un.leaf.quantum; opt.prio = cl->un.leaf.prio; 1183 opt.ceil = cl->ceil->rate;
1346 opt.level = cl->level; 1184 opt.cbuffer = cl->cbuffer;
1185 opt.quantum = cl->un.leaf.quantum;
1186 opt.prio = cl->un.leaf.prio;
1187 opt.level = cl->level;
1347 RTA_PUT(skb, TCA_HTB_PARMS, sizeof(opt), &opt); 1188 RTA_PUT(skb, TCA_HTB_PARMS, sizeof(opt), &opt);
1348 rta->rta_len = skb->tail - b; 1189 rta->rta_len = skb->tail - b;
1349 HTB_QUNLOCK(sch); 1190 spin_unlock_bh(&sch->dev->queue_lock);
1350 return skb->len; 1191 return skb->len;
1351rtattr_failure: 1192rtattr_failure:
1352 HTB_QUNLOCK(sch); 1193 spin_unlock_bh(&sch->dev->queue_lock);
1353 skb_trim(skb, b - skb->data); 1194 skb_trim(skb, b - skb->data);
1354 return -1; 1195 return -1;
1355} 1196}
1356 1197
1357static int 1198static int
1358htb_dump_class_stats(struct Qdisc *sch, unsigned long arg, 1199htb_dump_class_stats(struct Qdisc *sch, unsigned long arg, struct gnet_dump *d)
1359 struct gnet_dump *d)
1360{ 1200{
1361 struct htb_class *cl = (struct htb_class*)arg; 1201 struct htb_class *cl = (struct htb_class *)arg;
1362 1202
1363#ifdef HTB_RATECM 1203#ifdef HTB_RATECM
1364 cl->rate_est.bps = cl->rate_bytes/(HTB_EWMAC*HTB_HSIZE); 1204 cl->rate_est.bps = cl->rate_bytes / (HTB_EWMAC * HTB_HSIZE);
1365 cl->rate_est.pps = cl->rate_packets/(HTB_EWMAC*HTB_HSIZE); 1205 cl->rate_est.pps = cl->rate_packets / (HTB_EWMAC * HTB_HSIZE);
1366#endif 1206#endif
1367 1207
1368 if (!cl->level && cl->un.leaf.q) 1208 if (!cl->level && cl->un.leaf.q)
@@ -1379,21 +1219,22 @@ htb_dump_class_stats(struct Qdisc *sch, unsigned long arg,
1379} 1219}
1380 1220
1381static int htb_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new, 1221static int htb_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
1382 struct Qdisc **old) 1222 struct Qdisc **old)
1383{ 1223{
1384 struct htb_class *cl = (struct htb_class*)arg; 1224 struct htb_class *cl = (struct htb_class *)arg;
1385 1225
1386 if (cl && !cl->level) { 1226 if (cl && !cl->level) {
1387 if (new == NULL && (new = qdisc_create_dflt(sch->dev, 1227 if (new == NULL && (new = qdisc_create_dflt(sch->dev,
1388 &pfifo_qdisc_ops)) == NULL) 1228 &pfifo_qdisc_ops))
1389 return -ENOBUFS; 1229 == NULL)
1230 return -ENOBUFS;
1390 sch_tree_lock(sch); 1231 sch_tree_lock(sch);
1391 if ((*old = xchg(&cl->un.leaf.q, new)) != NULL) { 1232 if ((*old = xchg(&cl->un.leaf.q, new)) != NULL) {
1392 if (cl->prio_activity) 1233 if (cl->prio_activity)
1393 htb_deactivate (qdisc_priv(sch),cl); 1234 htb_deactivate(qdisc_priv(sch), cl);
1394 1235
1395 /* TODO: is it correct ? Why CBQ doesn't do it ? */ 1236 /* TODO: is it correct ? Why CBQ doesn't do it ? */
1396 sch->q.qlen -= (*old)->q.qlen; 1237 sch->q.qlen -= (*old)->q.qlen;
1397 qdisc_reset(*old); 1238 qdisc_reset(*old);
1398 } 1239 }
1399 sch_tree_unlock(sch); 1240 sch_tree_unlock(sch);
@@ -1402,20 +1243,16 @@ static int htb_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
1402 return -ENOENT; 1243 return -ENOENT;
1403} 1244}
1404 1245
1405static struct Qdisc * htb_leaf(struct Qdisc *sch, unsigned long arg) 1246static struct Qdisc *htb_leaf(struct Qdisc *sch, unsigned long arg)
1406{ 1247{
1407 struct htb_class *cl = (struct htb_class*)arg; 1248 struct htb_class *cl = (struct htb_class *)arg;
1408 return (cl && !cl->level) ? cl->un.leaf.q : NULL; 1249 return (cl && !cl->level) ? cl->un.leaf.q : NULL;
1409} 1250}
1410 1251
1411static unsigned long htb_get(struct Qdisc *sch, u32 classid) 1252static unsigned long htb_get(struct Qdisc *sch, u32 classid)
1412{ 1253{
1413#ifdef HTB_DEBUG 1254 struct htb_class *cl = htb_find(classid, sch);
1414 struct htb_sched *q = qdisc_priv(sch); 1255 if (cl)
1415#endif
1416 struct htb_class *cl = htb_find(classid,sch);
1417 HTB_DBG(0,1,"htb_get clid=%X q=%p cl=%p ref=%d\n",classid,q,cl,cl?cl->refcnt:0);
1418 if (cl)
1419 cl->refcnt++; 1256 cl->refcnt++;
1420 return (unsigned long)cl; 1257 return (unsigned long)cl;
1421} 1258}
@@ -1430,10 +1267,9 @@ static void htb_destroy_filters(struct tcf_proto **fl)
1430 } 1267 }
1431} 1268}
1432 1269
1433static void htb_destroy_class(struct Qdisc* sch,struct htb_class *cl) 1270static void htb_destroy_class(struct Qdisc *sch, struct htb_class *cl)
1434{ 1271{
1435 struct htb_sched *q = qdisc_priv(sch); 1272 struct htb_sched *q = qdisc_priv(sch);
1436 HTB_DBG(0,1,"htb_destrycls clid=%X ref=%d\n", cl?cl->classid:0,cl?cl->refcnt:0);
1437 if (!cl->level) { 1273 if (!cl->level) {
1438 BUG_TRAP(cl->un.leaf.q); 1274 BUG_TRAP(cl->un.leaf.q);
1439 sch->q.qlen -= cl->un.leaf.q->q.qlen; 1275 sch->q.qlen -= cl->un.leaf.q->q.qlen;
@@ -1441,45 +1277,45 @@ static void htb_destroy_class(struct Qdisc* sch,struct htb_class *cl)
1441 } 1277 }
1442 qdisc_put_rtab(cl->rate); 1278 qdisc_put_rtab(cl->rate);
1443 qdisc_put_rtab(cl->ceil); 1279 qdisc_put_rtab(cl->ceil);
1444 1280
1445 htb_destroy_filters (&cl->filter_list); 1281 htb_destroy_filters(&cl->filter_list);
1446 1282
1447 while (!list_empty(&cl->children)) 1283 while (!list_empty(&cl->children))
1448 htb_destroy_class (sch,list_entry(cl->children.next, 1284 htb_destroy_class(sch, list_entry(cl->children.next,
1449 struct htb_class,sibling)); 1285 struct htb_class, sibling));
1450 1286
1451 /* note: this delete may happen twice (see htb_delete) */ 1287 /* note: this delete may happen twice (see htb_delete) */
1452 list_del(&cl->hlist); 1288 if (!hlist_unhashed(&cl->hlist))
1289 hlist_del(&cl->hlist);
1453 list_del(&cl->sibling); 1290 list_del(&cl->sibling);
1454 1291
1455 if (cl->prio_activity) 1292 if (cl->prio_activity)
1456 htb_deactivate (q,cl); 1293 htb_deactivate(q, cl);
1457 1294
1458 if (cl->cmode != HTB_CAN_SEND) 1295 if (cl->cmode != HTB_CAN_SEND)
1459 htb_safe_rb_erase(&cl->pq_node,q->wait_pq+cl->level); 1296 htb_safe_rb_erase(&cl->pq_node, q->wait_pq + cl->level);
1460 1297
1461 kfree(cl); 1298 kfree(cl);
1462} 1299}
1463 1300
1464/* always caled under BH & queue lock */ 1301/* always caled under BH & queue lock */
1465static void htb_destroy(struct Qdisc* sch) 1302static void htb_destroy(struct Qdisc *sch)
1466{ 1303{
1467 struct htb_sched *q = qdisc_priv(sch); 1304 struct htb_sched *q = qdisc_priv(sch);
1468 HTB_DBG(0,1,"htb_destroy q=%p\n",q);
1469 1305
1470 del_timer_sync (&q->timer); 1306 del_timer_sync(&q->timer);
1471#ifdef HTB_RATECM 1307#ifdef HTB_RATECM
1472 del_timer_sync (&q->rttim); 1308 del_timer_sync(&q->rttim);
1473#endif 1309#endif
1474 /* This line used to be after htb_destroy_class call below 1310 /* This line used to be after htb_destroy_class call below
1475 and surprisingly it worked in 2.4. But it must precede it 1311 and surprisingly it worked in 2.4. But it must precede it
1476 because filter need its target class alive to be able to call 1312 because filter need its target class alive to be able to call
1477 unbind_filter on it (without Oops). */ 1313 unbind_filter on it (without Oops). */
1478 htb_destroy_filters(&q->filter_list); 1314 htb_destroy_filters(&q->filter_list);
1479 1315
1480 while (!list_empty(&q->root)) 1316 while (!list_empty(&q->root))
1481 htb_destroy_class (sch,list_entry(q->root.next, 1317 htb_destroy_class(sch, list_entry(q->root.next,
1482 struct htb_class,sibling)); 1318 struct htb_class, sibling));
1483 1319
1484 __skb_queue_purge(&q->direct_queue); 1320 __skb_queue_purge(&q->direct_queue);
1485} 1321}
@@ -1487,24 +1323,25 @@ static void htb_destroy(struct Qdisc* sch)
1487static int htb_delete(struct Qdisc *sch, unsigned long arg) 1323static int htb_delete(struct Qdisc *sch, unsigned long arg)
1488{ 1324{
1489 struct htb_sched *q = qdisc_priv(sch); 1325 struct htb_sched *q = qdisc_priv(sch);
1490 struct htb_class *cl = (struct htb_class*)arg; 1326 struct htb_class *cl = (struct htb_class *)arg;
1491 HTB_DBG(0,1,"htb_delete q=%p cl=%X ref=%d\n",q,cl?cl->classid:0,cl?cl->refcnt:0);
1492 1327
1493 // TODO: why don't allow to delete subtree ? references ? does 1328 // TODO: why don't allow to delete subtree ? references ? does
1494 // tc subsys quarantee us that in htb_destroy it holds no class 1329 // tc subsys quarantee us that in htb_destroy it holds no class
1495 // refs so that we can remove children safely there ? 1330 // refs so that we can remove children safely there ?
1496 if (!list_empty(&cl->children) || cl->filter_cnt) 1331 if (!list_empty(&cl->children) || cl->filter_cnt)
1497 return -EBUSY; 1332 return -EBUSY;
1498 1333
1499 sch_tree_lock(sch); 1334 sch_tree_lock(sch);
1500 1335
1501 /* delete from hash and active; remainder in destroy_class */ 1336 /* delete from hash and active; remainder in destroy_class */
1502 list_del_init(&cl->hlist); 1337 if (!hlist_unhashed(&cl->hlist))
1338 hlist_del(&cl->hlist);
1339
1503 if (cl->prio_activity) 1340 if (cl->prio_activity)
1504 htb_deactivate (q,cl); 1341 htb_deactivate(q, cl);
1505 1342
1506 if (--cl->refcnt == 0) 1343 if (--cl->refcnt == 0)
1507 htb_destroy_class(sch,cl); 1344 htb_destroy_class(sch, cl);
1508 1345
1509 sch_tree_unlock(sch); 1346 sch_tree_unlock(sch);
1510 return 0; 1347 return 0;
@@ -1512,45 +1349,46 @@ static int htb_delete(struct Qdisc *sch, unsigned long arg)
1512 1349
1513static void htb_put(struct Qdisc *sch, unsigned long arg) 1350static void htb_put(struct Qdisc *sch, unsigned long arg)
1514{ 1351{
1515#ifdef HTB_DEBUG 1352 struct htb_class *cl = (struct htb_class *)arg;
1516 struct htb_sched *q = qdisc_priv(sch);
1517#endif
1518 struct htb_class *cl = (struct htb_class*)arg;
1519 HTB_DBG(0,1,"htb_put q=%p cl=%X ref=%d\n",q,cl?cl->classid:0,cl?cl->refcnt:0);
1520 1353
1521 if (--cl->refcnt == 0) 1354 if (--cl->refcnt == 0)
1522 htb_destroy_class(sch,cl); 1355 htb_destroy_class(sch, cl);
1523} 1356}
1524 1357
1525static int htb_change_class(struct Qdisc *sch, u32 classid, 1358static int htb_change_class(struct Qdisc *sch, u32 classid,
1526 u32 parentid, struct rtattr **tca, unsigned long *arg) 1359 u32 parentid, struct rtattr **tca,
1360 unsigned long *arg)
1527{ 1361{
1528 int err = -EINVAL; 1362 int err = -EINVAL;
1529 struct htb_sched *q = qdisc_priv(sch); 1363 struct htb_sched *q = qdisc_priv(sch);
1530 struct htb_class *cl = (struct htb_class*)*arg,*parent; 1364 struct htb_class *cl = (struct htb_class *)*arg, *parent;
1531 struct rtattr *opt = tca[TCA_OPTIONS-1]; 1365 struct rtattr *opt = tca[TCA_OPTIONS - 1];
1532 struct qdisc_rate_table *rtab = NULL, *ctab = NULL; 1366 struct qdisc_rate_table *rtab = NULL, *ctab = NULL;
1533 struct rtattr *tb[TCA_HTB_RTAB]; 1367 struct rtattr *tb[TCA_HTB_RTAB];
1534 struct tc_htb_opt *hopt; 1368 struct tc_htb_opt *hopt;
1535 1369
1536 /* extract all subattrs from opt attr */ 1370 /* extract all subattrs from opt attr */
1537 if (!opt || rtattr_parse_nested(tb, TCA_HTB_RTAB, opt) || 1371 if (!opt || rtattr_parse_nested(tb, TCA_HTB_RTAB, opt) ||
1538 tb[TCA_HTB_PARMS-1] == NULL || 1372 tb[TCA_HTB_PARMS - 1] == NULL ||
1539 RTA_PAYLOAD(tb[TCA_HTB_PARMS-1]) < sizeof(*hopt)) 1373 RTA_PAYLOAD(tb[TCA_HTB_PARMS - 1]) < sizeof(*hopt))
1540 goto failure; 1374 goto failure;
1541
1542 parent = parentid == TC_H_ROOT ? NULL : htb_find (parentid,sch);
1543 1375
1544 hopt = RTA_DATA(tb[TCA_HTB_PARMS-1]); 1376 parent = parentid == TC_H_ROOT ? NULL : htb_find(parentid, sch);
1545 HTB_DBG(0,1,"htb_chg cl=%p(%X), clid=%X, parid=%X, opt/prio=%d, rate=%u, buff=%d, quant=%d\n", cl,cl?cl->classid:0,classid,parentid,(int)hopt->prio,hopt->rate.rate,hopt->buffer,hopt->quantum); 1377
1546 rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB-1]); 1378 hopt = RTA_DATA(tb[TCA_HTB_PARMS - 1]);
1547 ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB-1]); 1379
1548 if (!rtab || !ctab) goto failure; 1380 rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB - 1]);
1381 ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB - 1]);
1382 if (!rtab || !ctab)
1383 goto failure;
1549 1384
1550 if (!cl) { /* new class */ 1385 if (!cl) { /* new class */
1551 struct Qdisc *new_q; 1386 struct Qdisc *new_q;
1387 int prio;
1388
1552 /* check for valid classid */ 1389 /* check for valid classid */
1553 if (!classid || TC_H_MAJ(classid^sch->handle) || htb_find(classid,sch)) 1390 if (!classid || TC_H_MAJ(classid ^ sch->handle)
1391 || htb_find(classid, sch))
1554 goto failure; 1392 goto failure;
1555 1393
1556 /* check maximal depth */ 1394 /* check maximal depth */
@@ -1561,15 +1399,16 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
1561 err = -ENOBUFS; 1399 err = -ENOBUFS;
1562 if ((cl = kzalloc(sizeof(*cl), GFP_KERNEL)) == NULL) 1400 if ((cl = kzalloc(sizeof(*cl), GFP_KERNEL)) == NULL)
1563 goto failure; 1401 goto failure;
1564 1402
1565 cl->refcnt = 1; 1403 cl->refcnt = 1;
1566 INIT_LIST_HEAD(&cl->sibling); 1404 INIT_LIST_HEAD(&cl->sibling);
1567 INIT_LIST_HEAD(&cl->hlist); 1405 INIT_HLIST_NODE(&cl->hlist);
1568 INIT_LIST_HEAD(&cl->children); 1406 INIT_LIST_HEAD(&cl->children);
1569 INIT_LIST_HEAD(&cl->un.leaf.drop_list); 1407 INIT_LIST_HEAD(&cl->un.leaf.drop_list);
1570#ifdef HTB_DEBUG 1408 RB_CLEAR_NODE(&cl->pq_node);
1571 cl->magic = HTB_CMAGIC; 1409
1572#endif 1410 for (prio = 0; prio < TC_HTB_NUMPRIO; prio++)
1411 RB_CLEAR_NODE(&cl->node[prio]);
1573 1412
1574 /* create leaf qdisc early because it uses kmalloc(GFP_KERNEL) 1413 /* create leaf qdisc early because it uses kmalloc(GFP_KERNEL)
1575 so that can't be used inside of sch_tree_lock 1414 so that can't be used inside of sch_tree_lock
@@ -1579,53 +1418,53 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
1579 if (parent && !parent->level) { 1418 if (parent && !parent->level) {
1580 /* turn parent into inner node */ 1419 /* turn parent into inner node */
1581 sch->q.qlen -= parent->un.leaf.q->q.qlen; 1420 sch->q.qlen -= parent->un.leaf.q->q.qlen;
1582 qdisc_destroy (parent->un.leaf.q); 1421 qdisc_destroy(parent->un.leaf.q);
1583 if (parent->prio_activity) 1422 if (parent->prio_activity)
1584 htb_deactivate (q,parent); 1423 htb_deactivate(q, parent);
1585 1424
1586 /* remove from evt list because of level change */ 1425 /* remove from evt list because of level change */
1587 if (parent->cmode != HTB_CAN_SEND) { 1426 if (parent->cmode != HTB_CAN_SEND) {
1588 htb_safe_rb_erase(&parent->pq_node,q->wait_pq /*+0*/); 1427 htb_safe_rb_erase(&parent->pq_node, q->wait_pq);
1589 parent->cmode = HTB_CAN_SEND; 1428 parent->cmode = HTB_CAN_SEND;
1590 } 1429 }
1591 parent->level = (parent->parent ? parent->parent->level 1430 parent->level = (parent->parent ? parent->parent->level
1592 : TC_HTB_MAXDEPTH) - 1; 1431 : TC_HTB_MAXDEPTH) - 1;
1593 memset (&parent->un.inner,0,sizeof(parent->un.inner)); 1432 memset(&parent->un.inner, 0, sizeof(parent->un.inner));
1594 } 1433 }
1595 /* leaf (we) needs elementary qdisc */ 1434 /* leaf (we) needs elementary qdisc */
1596 cl->un.leaf.q = new_q ? new_q : &noop_qdisc; 1435 cl->un.leaf.q = new_q ? new_q : &noop_qdisc;
1597 1436
1598 cl->classid = classid; cl->parent = parent; 1437 cl->classid = classid;
1438 cl->parent = parent;
1599 1439
1600 /* set class to be in HTB_CAN_SEND state */ 1440 /* set class to be in HTB_CAN_SEND state */
1601 cl->tokens = hopt->buffer; 1441 cl->tokens = hopt->buffer;
1602 cl->ctokens = hopt->cbuffer; 1442 cl->ctokens = hopt->cbuffer;
1603 cl->mbuffer = PSCHED_JIFFIE2US(HZ*60); /* 1min */ 1443 cl->mbuffer = PSCHED_JIFFIE2US(HZ * 60); /* 1min */
1604 PSCHED_GET_TIME(cl->t_c); 1444 PSCHED_GET_TIME(cl->t_c);
1605 cl->cmode = HTB_CAN_SEND; 1445 cl->cmode = HTB_CAN_SEND;
1606 1446
1607 /* attach to the hash list and parent's family */ 1447 /* attach to the hash list and parent's family */
1608 list_add_tail(&cl->hlist, q->hash+htb_hash(classid)); 1448 hlist_add_head(&cl->hlist, q->hash + htb_hash(classid));
1609 list_add_tail(&cl->sibling, parent ? &parent->children : &q->root); 1449 list_add_tail(&cl->sibling,
1610#ifdef HTB_DEBUG 1450 parent ? &parent->children : &q->root);
1611 { 1451 } else
1612 int i; 1452 sch_tree_lock(sch);
1613 for (i = 0; i < TC_HTB_NUMPRIO; i++) cl->node[i].rb_color = -1;
1614 cl->pq_node.rb_color = -1;
1615 }
1616#endif
1617 } else sch_tree_lock(sch);
1618 1453
1619 /* it used to be a nasty bug here, we have to check that node 1454 /* it used to be a nasty bug here, we have to check that node
1620 is really leaf before changing cl->un.leaf ! */ 1455 is really leaf before changing cl->un.leaf ! */
1621 if (!cl->level) { 1456 if (!cl->level) {
1622 cl->un.leaf.quantum = rtab->rate.rate / q->rate2quantum; 1457 cl->un.leaf.quantum = rtab->rate.rate / q->rate2quantum;
1623 if (!hopt->quantum && cl->un.leaf.quantum < 1000) { 1458 if (!hopt->quantum && cl->un.leaf.quantum < 1000) {
1624 printk(KERN_WARNING "HTB: quantum of class %X is small. Consider r2q change.\n", cl->classid); 1459 printk(KERN_WARNING
1460 "HTB: quantum of class %X is small. Consider r2q change.\n",
1461 cl->classid);
1625 cl->un.leaf.quantum = 1000; 1462 cl->un.leaf.quantum = 1000;
1626 } 1463 }
1627 if (!hopt->quantum && cl->un.leaf.quantum > 200000) { 1464 if (!hopt->quantum && cl->un.leaf.quantum > 200000) {
1628 printk(KERN_WARNING "HTB: quantum of class %X is big. Consider r2q change.\n", cl->classid); 1465 printk(KERN_WARNING
1466 "HTB: quantum of class %X is big. Consider r2q change.\n",
1467 cl->classid);
1629 cl->un.leaf.quantum = 200000; 1468 cl->un.leaf.quantum = 200000;
1630 } 1469 }
1631 if (hopt->quantum) 1470 if (hopt->quantum)
@@ -1636,16 +1475,22 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
1636 1475
1637 cl->buffer = hopt->buffer; 1476 cl->buffer = hopt->buffer;
1638 cl->cbuffer = hopt->cbuffer; 1477 cl->cbuffer = hopt->cbuffer;
1639 if (cl->rate) qdisc_put_rtab(cl->rate); cl->rate = rtab; 1478 if (cl->rate)
1640 if (cl->ceil) qdisc_put_rtab(cl->ceil); cl->ceil = ctab; 1479 qdisc_put_rtab(cl->rate);
1480 cl->rate = rtab;
1481 if (cl->ceil)
1482 qdisc_put_rtab(cl->ceil);
1483 cl->ceil = ctab;
1641 sch_tree_unlock(sch); 1484 sch_tree_unlock(sch);
1642 1485
1643 *arg = (unsigned long)cl; 1486 *arg = (unsigned long)cl;
1644 return 0; 1487 return 0;
1645 1488
1646failure: 1489failure:
1647 if (rtab) qdisc_put_rtab(rtab); 1490 if (rtab)
1648 if (ctab) qdisc_put_rtab(ctab); 1491 qdisc_put_rtab(rtab);
1492 if (ctab)
1493 qdisc_put_rtab(ctab);
1649 return err; 1494 return err;
1650} 1495}
1651 1496
@@ -1654,28 +1499,28 @@ static struct tcf_proto **htb_find_tcf(struct Qdisc *sch, unsigned long arg)
1654 struct htb_sched *q = qdisc_priv(sch); 1499 struct htb_sched *q = qdisc_priv(sch);
1655 struct htb_class *cl = (struct htb_class *)arg; 1500 struct htb_class *cl = (struct htb_class *)arg;
1656 struct tcf_proto **fl = cl ? &cl->filter_list : &q->filter_list; 1501 struct tcf_proto **fl = cl ? &cl->filter_list : &q->filter_list;
1657 HTB_DBG(0,2,"htb_tcf q=%p clid=%X fref=%d fl=%p\n",q,cl?cl->classid:0,cl?cl->filter_cnt:q->filter_cnt,*fl); 1502
1658 return fl; 1503 return fl;
1659} 1504}
1660 1505
1661static unsigned long htb_bind_filter(struct Qdisc *sch, unsigned long parent, 1506static unsigned long htb_bind_filter(struct Qdisc *sch, unsigned long parent,
1662 u32 classid) 1507 u32 classid)
1663{ 1508{
1664 struct htb_sched *q = qdisc_priv(sch); 1509 struct htb_sched *q = qdisc_priv(sch);
1665 struct htb_class *cl = htb_find (classid,sch); 1510 struct htb_class *cl = htb_find(classid, sch);
1666 HTB_DBG(0,2,"htb_bind q=%p clid=%X cl=%p fref=%d\n",q,classid,cl,cl?cl->filter_cnt:q->filter_cnt); 1511
1667 /*if (cl && !cl->level) return 0; 1512 /*if (cl && !cl->level) return 0;
1668 The line above used to be there to prevent attaching filters to 1513 The line above used to be there to prevent attaching filters to
1669 leaves. But at least tc_index filter uses this just to get class 1514 leaves. But at least tc_index filter uses this just to get class
1670 for other reasons so that we have to allow for it. 1515 for other reasons so that we have to allow for it.
1671 ---- 1516 ----
1672 19.6.2002 As Werner explained it is ok - bind filter is just 1517 19.6.2002 As Werner explained it is ok - bind filter is just
1673 another way to "lock" the class - unlike "get" this lock can 1518 another way to "lock" the class - unlike "get" this lock can
1674 be broken by class during destroy IIUC. 1519 be broken by class during destroy IIUC.
1675 */ 1520 */
1676 if (cl) 1521 if (cl)
1677 cl->filter_cnt++; 1522 cl->filter_cnt++;
1678 else 1523 else
1679 q->filter_cnt++; 1524 q->filter_cnt++;
1680 return (unsigned long)cl; 1525 return (unsigned long)cl;
1681} 1526}
@@ -1684,10 +1529,10 @@ static void htb_unbind_filter(struct Qdisc *sch, unsigned long arg)
1684{ 1529{
1685 struct htb_sched *q = qdisc_priv(sch); 1530 struct htb_sched *q = qdisc_priv(sch);
1686 struct htb_class *cl = (struct htb_class *)arg; 1531 struct htb_class *cl = (struct htb_class *)arg;
1687 HTB_DBG(0,2,"htb_unbind q=%p cl=%p fref=%d\n",q,cl,cl?cl->filter_cnt:q->filter_cnt); 1532
1688 if (cl) 1533 if (cl)
1689 cl->filter_cnt--; 1534 cl->filter_cnt--;
1690 else 1535 else
1691 q->filter_cnt--; 1536 q->filter_cnt--;
1692} 1537}
1693 1538
@@ -1700,9 +1545,10 @@ static void htb_walk(struct Qdisc *sch, struct qdisc_walker *arg)
1700 return; 1545 return;
1701 1546
1702 for (i = 0; i < HTB_HSIZE; i++) { 1547 for (i = 0; i < HTB_HSIZE; i++) {
1703 struct list_head *p; 1548 struct hlist_node *p;
1704 list_for_each (p,q->hash+i) { 1549 struct htb_class *cl;
1705 struct htb_class *cl = list_entry(p,struct htb_class,hlist); 1550
1551 hlist_for_each_entry(cl, p, q->hash + i, hlist) {
1706 if (arg->count < arg->skip) { 1552 if (arg->count < arg->skip) {
1707 arg->count++; 1553 arg->count++;
1708 continue; 1554 continue;
@@ -1750,12 +1596,13 @@ static struct Qdisc_ops htb_qdisc_ops = {
1750 1596
1751static int __init htb_module_init(void) 1597static int __init htb_module_init(void)
1752{ 1598{
1753 return register_qdisc(&htb_qdisc_ops); 1599 return register_qdisc(&htb_qdisc_ops);
1754} 1600}
1755static void __exit htb_module_exit(void) 1601static void __exit htb_module_exit(void)
1756{ 1602{
1757 unregister_qdisc(&htb_qdisc_ops); 1603 unregister_qdisc(&htb_qdisc_ops);
1758} 1604}
1605
1759module_init(htb_module_init) 1606module_init(htb_module_init)
1760module_exit(htb_module_exit) 1607module_exit(htb_module_exit)
1761MODULE_LICENSE("GPL"); 1608MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-26 19:44:07 -0500