[TG3]: Convert to netdev_alloc_skb
[linux-2.6/zen-sources.git] / net / sched / sch_htb.c
blob880a3394a51fb6a6d093c54cb2318a58f6b7c38a
1 /* vim: ts=8 sw=8
2 * net/sched/sch_htb.c Hierarchical token bucket, feed tree version
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Authors: Martin Devera, <devik@cdi.cz>
11 * Credits (in time order) for older HTB versions:
12 * Stef Coene <stef.coene@docum.org>
13 * HTB support at LARTC mailing list
14 * Ondrej Kraus, <krauso@barr.cz>
15 * found missing INIT_QDISC(htb)
16 * Vladimir Smelhaus, Aamer Akhter, Bert Hubert
17 * helped a lot to locate nasty class stall bug
18 * Andi Kleen, Jamal Hadi, Bert Hubert
19 * code review and helpful comments on shaping
20 * Tomasz Wrona, <tw@eter.tym.pl>
21 * created test case so that I was able to fix nasty bug
22 * Wilfried Weissmann
23 * spotted bug in dequeue code and helped with fix
24 * Jiri Fojtasek
25 * fixed requeue routine
26 * and many others. thanks.
28 * $Id: sch_htb.c,v 1.25 2003/12/07 11:08:25 devik Exp devik $
30 #include <linux/module.h>
31 #include <asm/uaccess.h>
32 #include <asm/system.h>
33 #include <linux/bitops.h>
34 #include <linux/types.h>
35 #include <linux/kernel.h>
36 #include <linux/sched.h>
37 #include <linux/string.h>
38 #include <linux/mm.h>
39 #include <linux/socket.h>
40 #include <linux/sockios.h>
41 #include <linux/in.h>
42 #include <linux/errno.h>
43 #include <linux/interrupt.h>
44 #include <linux/if_ether.h>
45 #include <linux/inet.h>
46 #include <linux/netdevice.h>
47 #include <linux/etherdevice.h>
48 #include <linux/notifier.h>
49 #include <net/ip.h>
50 #include <net/route.h>
51 #include <linux/skbuff.h>
52 #include <linux/list.h>
53 #include <linux/compiler.h>
54 #include <net/sock.h>
55 #include <net/pkt_sched.h>
56 #include <linux/rbtree.h>
58 /* HTB algorithm.
59 Author: devik@cdi.cz
60 ========================================================================
61 HTB is like TBF with multiple classes. It is also similar to CBQ because
62 it allows to assign priority to each class in hierarchy.
63 In fact it is another implementation of Floyd's formal sharing.
65 Levels:
66 Each class is assigned level. Leaf has ALWAYS level 0 and root
67 classes have level TC_HTB_MAXDEPTH-1. Interior nodes has level
68 one less than their parent.
71 #define HTB_HSIZE 16 /* classid hash size */
72 #define HTB_EWMAC 2 /* rate average over HTB_EWMAC*HTB_HSIZE sec */
73 #undef HTB_DEBUG /* compile debugging support (activated by tc tool) */
74 #define HTB_RATECM 1 /* whether to use rate computer */
75 #define HTB_HYSTERESIS 1/* whether to use mode hysteresis for speedup */
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 */
80 #if HTB_VER >> 16 != TC_HTB_PROTOVER
81 #error "Mismatched sch_htb.c and pkt_sch.h"
82 #endif
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
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
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
129 /* used internaly to keep status of single class */
130 enum htb_cmode {
131 HTB_CANT_SEND, /* class can't send and can't borrow */
132 HTB_MAY_BORROW, /* class can't send but may borrow */
133 HTB_CAN_SEND /* class can send */
136 /* interior & leaf nodes; props specific to leaves are marked L: */
137 struct htb_class
139 #ifdef HTB_DEBUG
140 unsigned magic;
141 #endif
142 /* general class parameters */
143 u32 classid;
144 struct gnet_stats_basic bstats;
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 */
150 #ifdef HTB_RATECM
151 /* rate measurement counters */
152 unsigned long rate_bytes,sum_bytes;
153 unsigned long rate_packets,sum_packets;
154 #endif
156 /* topology */
157 int level; /* our level (see above) */
158 struct htb_class *parent; /* parent class */
159 struct list_head hlist; /* classid hash list item */
160 struct list_head sibling; /* sibling list item */
161 struct list_head children; /* children list */
163 union {
164 struct htb_class_leaf {
165 struct Qdisc *q;
166 int prio;
167 int aprio;
168 int quantum;
169 int deficit[TC_HTB_MAXDEPTH];
170 struct list_head drop_list;
171 } leaf;
172 struct htb_class_inner {
173 struct rb_root feed[TC_HTB_NUMPRIO]; /* feed trees */
174 struct rb_node *ptr[TC_HTB_NUMPRIO]; /* current class ptr */
175 /* When class changes from state 1->2 and disconnects from
176 parent's feed then we lost ptr value and start from the
177 first child again. Here we store classid of the
178 last valid ptr (used when ptr is NULL). */
179 u32 last_ptr_id[TC_HTB_NUMPRIO];
180 } inner;
181 } un;
182 struct rb_node node[TC_HTB_NUMPRIO]; /* node for self or feed tree */
183 struct rb_node pq_node; /* node for event queue */
184 unsigned long pq_key; /* the same type as jiffies global */
186 int prio_activity; /* for which prios are we active */
187 enum htb_cmode cmode; /* current mode of the class */
189 /* class attached filters */
190 struct tcf_proto *filter_list;
191 int filter_cnt;
193 int warned; /* only one warning about non work conserving .. */
195 /* token bucket parameters */
196 struct qdisc_rate_table *rate; /* rate table of the class itself */
197 struct qdisc_rate_table *ceil; /* ceiling rate (limits borrows too) */
198 long buffer,cbuffer; /* token bucket depth/rate */
199 psched_tdiff_t mbuffer; /* max wait time */
200 long tokens,ctokens; /* current number of tokens */
201 psched_time_t t_c; /* checkpoint time */
204 /* TODO: maybe compute rate when size is too large .. or drop ? */
205 static __inline__ long L2T(struct htb_class *cl,struct qdisc_rate_table *rate,
206 int size)
208 int slot = size >> rate->rate.cell_log;
209 if (slot > 255) {
210 cl->xstats.giants++;
211 slot = 255;
213 return rate->data[slot];
216 struct htb_sched
218 struct list_head root; /* root classes list */
219 struct list_head hash[HTB_HSIZE]; /* hashed by classid */
220 struct list_head drops[TC_HTB_NUMPRIO]; /* active leaves (for drops) */
222 /* self list - roots of self generating tree */
223 struct rb_root row[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO];
224 int row_mask[TC_HTB_MAXDEPTH];
225 struct rb_node *ptr[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO];
226 u32 last_ptr_id[TC_HTB_MAXDEPTH][TC_HTB_NUMPRIO];
228 /* self wait list - roots of wait PQs per row */
229 struct rb_root wait_pq[TC_HTB_MAXDEPTH];
231 /* time of nearest event per level (row) */
232 unsigned long near_ev_cache[TC_HTB_MAXDEPTH];
234 /* cached value of jiffies in dequeue */
235 unsigned long jiffies;
237 /* whether we hit non-work conserving class during this dequeue; we use */
238 int nwc_hit; /* this to disable mindelay complaint in dequeue */
240 int defcls; /* class where unclassified flows go to */
241 u32 debug; /* subsystem debug levels */
243 /* filters for qdisc itself */
244 struct tcf_proto *filter_list;
245 int filter_cnt;
247 int rate2quantum; /* quant = rate / rate2quantum */
248 psched_time_t now; /* cached dequeue time */
249 struct timer_list timer; /* send delay timer */
250 #ifdef HTB_RATECM
251 struct timer_list rttim; /* rate computer timer */
252 int recmp_bucket; /* which hash bucket to recompute next */
253 #endif
255 /* non shaped skbs; let them go directly thru */
256 struct sk_buff_head direct_queue;
257 int direct_qlen; /* max qlen of above */
259 long direct_pkts;
262 /* compute hash of size HTB_HSIZE for given handle */
263 static __inline__ int htb_hash(u32 h)
265 #if HTB_HSIZE != 16
266 #error "Declare new hash for your HTB_HSIZE"
267 #endif
268 h ^= h>>8; /* stolen from cbq_hash */
269 h ^= h>>4;
270 return h & 0xf;
273 /* find class in global hash table using given handle */
274 static __inline__ struct htb_class *htb_find(u32 handle, struct Qdisc *sch)
276 struct htb_sched *q = qdisc_priv(sch);
277 struct list_head *p;
278 if (TC_H_MAJ(handle) != sch->handle)
279 return NULL;
281 list_for_each (p,q->hash+htb_hash(handle)) {
282 struct htb_class *cl = list_entry(p,struct htb_class,hlist);
283 if (cl->classid == handle)
284 return cl;
286 return NULL;
290 * htb_classify - classify a packet into class
292 * It returns NULL if the packet should be dropped or -1 if the packet
293 * should be passed directly thru. In all other cases leaf class is returned.
294 * We allow direct class selection by classid in priority. The we examine
295 * filters in qdisc and in inner nodes (if higher filter points to the inner
296 * node). If we end up with classid MAJOR:0 we enqueue the skb into special
297 * internal fifo (direct). These packets then go directly thru. If we still
298 * have no valid leaf we try to use MAJOR:default leaf. It still unsuccessfull
299 * then finish and return direct queue.
301 #define HTB_DIRECT (struct htb_class*)-1
302 static inline u32 htb_classid(struct htb_class *cl)
304 return (cl && cl != HTB_DIRECT) ? cl->classid : TC_H_UNSPEC;
307 static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
309 struct htb_sched *q = qdisc_priv(sch);
310 struct htb_class *cl;
311 struct tcf_result res;
312 struct tcf_proto *tcf;
313 int result;
315 /* allow to select class by setting skb->priority to valid classid;
316 note that nfmark can be used too by attaching filter fw with no
317 rules in it */
318 if (skb->priority == sch->handle)
319 return HTB_DIRECT; /* X:0 (direct flow) selected */
320 if ((cl = htb_find(skb->priority,sch)) != NULL && cl->level == 0)
321 return cl;
323 *qerr = NET_XMIT_BYPASS;
324 tcf = q->filter_list;
325 while (tcf && (result = tc_classify(skb, tcf, &res)) >= 0) {
326 #ifdef CONFIG_NET_CLS_ACT
327 switch (result) {
328 case TC_ACT_QUEUED:
329 case TC_ACT_STOLEN:
330 *qerr = NET_XMIT_SUCCESS;
331 case TC_ACT_SHOT:
332 return NULL;
334 #elif defined(CONFIG_NET_CLS_POLICE)
335 if (result == TC_POLICE_SHOT)
336 return HTB_DIRECT;
337 #endif
338 if ((cl = (void*)res.class) == NULL) {
339 if (res.classid == sch->handle)
340 return HTB_DIRECT; /* X:0 (direct flow) */
341 if ((cl = htb_find(res.classid,sch)) == NULL)
342 break; /* filter selected invalid classid */
344 if (!cl->level)
345 return cl; /* we hit leaf; return it */
347 /* we have got inner class; apply inner filter chain */
348 tcf = cl->filter_list;
350 /* classification failed; try to use default class */
351 cl = htb_find(TC_H_MAKE(TC_H_MAJ(sch->handle),q->defcls),sch);
352 if (!cl || cl->level)
353 return HTB_DIRECT; /* bad default .. this is safe bet */
354 return cl;
357 #ifdef HTB_DEBUG
358 static 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); \
367 static void htb_debug_dump (struct htb_sched *q)
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]);
379 printk("\n");
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]);
398 printk("\n");
402 #endif
404 * htb_add_to_id_tree - adds class to the round robin list
406 * 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.
409 static void htb_add_to_id_tree (HTB_ARGQ struct rb_root *root,
410 struct htb_class *cl,int prio)
412 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);
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);
421 #endif
422 while (*p) {
423 struct htb_class *c; parent = *p;
424 c = rb_entry(parent, struct htb_class, node[prio]);
425 HTB_CHCL(c);
426 if (cl->classid > c->classid)
427 p = &parent->rb_right;
428 else
429 p = &parent->rb_left;
431 rb_link_node(&cl->node[prio], parent, p);
432 rb_insert_color(&cl->node[prio], root);
436 * htb_add_to_wait_tree - adds class to the event queue with delay
438 * The class is added to priority event queue to indicate that class will
439 * change its mode in cl->pq_key microseconds. Make sure that class is not
440 * already in the queue.
442 static void htb_add_to_wait_tree (struct htb_sched *q,
443 struct htb_class *cl,long delay,int debug_hint)
445 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);
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);
454 if (cl->pq_key == q->jiffies)
455 cl->pq_key++;
457 /* update the nearest event cache */
458 if (time_after(q->near_ev_cache[cl->level], cl->pq_key))
459 q->near_ev_cache[cl->level] = cl->pq_key;
461 while (*p) {
462 struct htb_class *c; parent = *p;
463 c = rb_entry(parent, struct htb_class, pq_node);
464 if (time_after_eq(cl->pq_key, c->pq_key))
465 p = &parent->rb_right;
466 else
467 p = &parent->rb_left;
469 rb_link_node(&cl->pq_node, parent, p);
470 rb_insert_color(&cl->pq_node, &q->wait_pq[cl->level]);
474 * htb_next_rb_node - finds next node in binary tree
476 * When we are past last key we return NULL.
477 * Average complexity is 2 steps per call.
479 static void htb_next_rb_node(struct rb_node **n)
481 *n = rb_next(*n);
485 * htb_add_class_to_row - add class to its row
487 * The class is added to row at priorities marked in mask.
488 * It does nothing if mask == 0.
490 static inline void htb_add_class_to_row(struct htb_sched *q,
491 struct htb_class *cl,int mask)
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;
497 while (mask) {
498 int prio = ffz(~mask);
499 mask &= ~(1 << prio);
500 htb_add_to_id_tree(HTB_PASSQ q->row[cl->level]+prio,cl,prio);
505 * htb_remove_class_from_row - removes class from its row
507 * The class is removed from row at priorities marked in mask.
508 * It does nothing if mask == 0.
510 static __inline__ void htb_remove_class_from_row(struct htb_sched *q,
511 struct htb_class *cl,int mask)
513 int m = 0;
514 HTB_CHCL(cl);
515 while (mask) {
516 int prio = ffz(~mask);
517 mask &= ~(1 << prio);
518 if (q->ptr[cl->level][prio] == cl->node+prio)
519 htb_next_rb_node(q->ptr[cl->level]+prio);
520 htb_safe_rb_erase(cl->node + prio,q->row[cl->level]+prio);
521 if (!q->row[cl->level][prio].rb_node)
522 m |= 1 << prio;
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;
530 * htb_activate_prios - creates active classe's feed chain
532 * The class is connected to ancestors and/or appropriate rows
533 * for priorities it is participating on. cl->cmode must be new
534 * (activated) mode. It does nothing if cl->prio_activity == 0.
536 static void htb_activate_prios(struct htb_sched *q,struct htb_class *cl)
538 struct htb_class *p = cl->parent;
539 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);
543 while (cl->cmode == HTB_MAY_BORROW && p && mask) {
544 HTB_CHCL(p);
545 m = mask; while (m) {
546 int prio = ffz(~m);
547 m &= ~(1 << prio);
549 if (p->un.inner.feed[prio].rb_node)
550 /* parent already has its feed in use so that
551 reset bit in mask as parent is already ok */
552 mask &= ~(1 << prio);
554 htb_add_to_id_tree(HTB_PASSQ p->un.inner.feed+prio,cl,prio);
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;
559 cl = p; p = cl->parent;
560 HTB_CHCL(cl);
562 if (cl->cmode == HTB_CAN_SEND && mask)
563 htb_add_class_to_row(q,cl,mask);
567 * htb_deactivate_prios - remove class from feed chain
569 * cl->cmode must represent old mode (before deactivation). It does
570 * nothing if cl->prio_activity == 0. Class is removed from all feed
571 * chains and rows.
573 static void htb_deactivate_prios(struct htb_sched *q, struct htb_class *cl)
575 struct htb_class *p = cl->parent;
576 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);
580 while (cl->cmode == HTB_MAY_BORROW && p && mask) {
581 m = mask; mask = 0;
582 while (m) {
583 int prio = ffz(~m);
584 m &= ~(1 << prio);
586 if (p->un.inner.ptr[prio] == cl->node+prio) {
587 /* we are removing child which is pointed to from
588 parent feed - forget the pointer but remember
589 classid */
590 p->un.inner.last_ptr_id[prio] = cl->classid;
591 p->un.inner.ptr[prio] = NULL;
594 htb_safe_rb_erase(cl->node + prio,p->un.inner.feed + prio);
596 if (!p->un.inner.feed[prio].rb_node)
597 mask |= 1 << prio;
599 HTB_DBG(7,3,"htb_deact_pr_aft p=%X pact=%X mask=%lX pmode=%d\n",
600 p->classid,p->prio_activity,mask,p->cmode);
601 p->prio_activity &= ~mask;
602 cl = p; p = cl->parent;
603 HTB_CHCL(cl);
605 if (cl->cmode == HTB_CAN_SEND && mask)
606 htb_remove_class_from_row(q,cl,mask);
610 * htb_class_mode - computes and returns current class mode
612 * It computes cl's mode at time cl->t_c+diff and returns it. If mode
613 * is not HTB_CAN_SEND then cl->pq_key is updated to time difference
614 * from now to time when cl will change its state.
615 * Also it is worth to note that class mode doesn't change simply
616 * at cl->{c,}tokens == 0 but there can rather be hysteresis of
617 * 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.
620 static __inline__ enum htb_cmode
621 htb_class_mode(struct htb_class *cl,long *diff)
623 long toks;
625 if ((toks = (cl->ctokens + *diff)) < (
626 #if HTB_HYSTERESIS
627 cl->cmode != HTB_CANT_SEND ? -cl->cbuffer :
628 #endif
629 0)) {
630 *diff = -toks;
631 return HTB_CANT_SEND;
633 if ((toks = (cl->tokens + *diff)) >= (
634 #if HTB_HYSTERESIS
635 cl->cmode == HTB_CAN_SEND ? -cl->buffer :
636 #endif
638 return HTB_CAN_SEND;
640 *diff = -toks;
641 return HTB_MAY_BORROW;
645 * htb_change_class_mode - changes classe's mode
647 * This should be the only way how to change classe's mode under normal
648 * cirsumstances. Routine will update feed lists linkage, change mode
649 * and add class to the wait event queue if appropriate. New mode should
650 * 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).
653 static void
654 htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, long *diff)
656 enum htb_cmode new_mode = htb_class_mode(cl,diff);
658 HTB_CHCL(cl);
659 HTB_DBG(7,1,"htb_chging_clmode %d->%d cl=%X\n",cl->cmode,new_mode,cl->classid);
661 if (new_mode == cl->cmode)
662 return;
664 if (cl->prio_activity) { /* not necessary: speed optimization */
665 if (cl->cmode != HTB_CANT_SEND)
666 htb_deactivate_prios(q,cl);
667 cl->cmode = new_mode;
668 if (new_mode != HTB_CANT_SEND)
669 htb_activate_prios(q,cl);
670 } else
671 cl->cmode = new_mode;
675 * htb_activate - inserts leaf cl into appropriate active feeds
677 * Routine learns (new) priority of leaf and activates feed chain
678 * for the prio. It can be called on already active leaf safely.
679 * It also adds leaf into droplist.
681 static __inline__ void htb_activate(struct htb_sched *q,struct htb_class *cl)
683 BUG_TRAP(!cl->level && cl->un.leaf.q && cl->un.leaf.q->q.qlen);
684 HTB_CHCL(cl);
685 if (!cl->prio_activity) {
686 cl->prio_activity = 1 << (cl->un.leaf.aprio = cl->un.leaf.prio);
687 htb_activate_prios(q,cl);
688 list_add_tail(&cl->un.leaf.drop_list,q->drops+cl->un.leaf.aprio);
693 * htb_deactivate - remove leaf cl from active feeds
695 * 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.
698 static __inline__ void
699 htb_deactivate(struct htb_sched *q,struct htb_class *cl)
701 BUG_TRAP(cl->prio_activity);
702 HTB_CHCL(cl);
703 htb_deactivate_prios(q,cl);
704 cl->prio_activity = 0;
705 list_del_init(&cl->un.leaf.drop_list);
708 static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch)
710 int ret;
711 struct htb_sched *q = qdisc_priv(sch);
712 struct htb_class *cl = htb_classify(skb,sch,&ret);
714 if (cl == HTB_DIRECT) {
715 /* enqueue to helper queue */
716 if (q->direct_queue.qlen < q->direct_qlen) {
717 __skb_queue_tail(&q->direct_queue, skb);
718 q->direct_pkts++;
719 } else {
720 kfree_skb(skb);
721 sch->qstats.drops++;
722 return NET_XMIT_DROP;
724 #ifdef CONFIG_NET_CLS_ACT
725 } else if (!cl) {
726 if (ret == NET_XMIT_BYPASS)
727 sch->qstats.drops++;
728 kfree_skb (skb);
729 return ret;
730 #endif
731 } else if (cl->un.leaf.q->enqueue(skb, cl->un.leaf.q) != NET_XMIT_SUCCESS) {
732 sch->qstats.drops++;
733 cl->qstats.drops++;
734 return NET_XMIT_DROP;
735 } else {
736 cl->bstats.packets++; cl->bstats.bytes += skb->len;
737 htb_activate (q,cl);
740 sch->q.qlen++;
741 sch->bstats.packets++; sch->bstats.bytes += skb->len;
742 HTB_DBG(1,1,"htb_enq_ok cl=%X skb=%p\n",(cl && cl != HTB_DIRECT)?cl->classid:0,skb);
743 return NET_XMIT_SUCCESS;
746 /* TODO: requeuing packet charges it to policers again !! */
747 static int htb_requeue(struct sk_buff *skb, struct Qdisc *sch)
749 struct htb_sched *q = qdisc_priv(sch);
750 int ret = NET_XMIT_SUCCESS;
751 struct htb_class *cl = htb_classify(skb,sch, &ret);
752 struct sk_buff *tskb;
754 if (cl == HTB_DIRECT || !cl) {
755 /* enqueue to helper queue */
756 if (q->direct_queue.qlen < q->direct_qlen && cl) {
757 __skb_queue_head(&q->direct_queue, skb);
758 } else {
759 __skb_queue_head(&q->direct_queue, skb);
760 tskb = __skb_dequeue_tail(&q->direct_queue);
761 kfree_skb (tskb);
762 sch->qstats.drops++;
763 return NET_XMIT_CN;
765 } else if (cl->un.leaf.q->ops->requeue(skb, cl->un.leaf.q) != NET_XMIT_SUCCESS) {
766 sch->qstats.drops++;
767 cl->qstats.drops++;
768 return NET_XMIT_DROP;
769 } else
770 htb_activate (q,cl);
772 sch->q.qlen++;
773 sch->qstats.requeues++;
774 HTB_DBG(1,1,"htb_req_ok cl=%X skb=%p\n",(cl && cl != HTB_DIRECT)?cl->classid:0,skb);
775 return NET_XMIT_SUCCESS;
778 static void htb_timer(unsigned long arg)
780 struct Qdisc *sch = (struct Qdisc*)arg;
781 sch->flags &= ~TCQ_F_THROTTLED;
782 wmb();
783 netif_schedule(sch->dev);
786 #ifdef HTB_RATECM
787 #define RT_GEN(D,R) R+=D-(R/HTB_EWMAC);D=0
788 static void htb_rate_timer(unsigned long arg)
790 struct Qdisc *sch = (struct Qdisc*)arg;
791 struct htb_sched *q = qdisc_priv(sch);
792 struct list_head *p;
794 /* lock queue so that we can muck with it */
795 HTB_QLOCK(sch);
796 HTB_DBG(10,1,"htb_rttmr j=%ld\n",jiffies);
798 q->rttim.expires = jiffies + HZ;
799 add_timer(&q->rttim);
801 /* scan and recompute one bucket at time */
802 if (++q->recmp_bucket >= HTB_HSIZE)
803 q->recmp_bucket = 0;
804 list_for_each (p,q->hash+q->recmp_bucket) {
805 struct htb_class *cl = list_entry(p,struct htb_class,hlist);
806 HTB_DBG(10,2,"htb_rttmr_cl cl=%X sbyte=%lu spkt=%lu\n",
807 cl->classid,cl->sum_bytes,cl->sum_packets);
808 RT_GEN (cl->sum_bytes,cl->rate_bytes);
809 RT_GEN (cl->sum_packets,cl->rate_packets);
811 HTB_QUNLOCK(sch);
813 #endif
816 * htb_charge_class - charges amount "bytes" to leaf and ancestors
818 * Routine assumes that packet "bytes" long was dequeued from leaf cl
819 * borrowing from "level". It accounts bytes to ceil leaky bucket for
820 * leaf and all ancestors and to rate bucket for ancestors at levels
821 * "level" and higher. It also handles possible change of mode resulting
822 * from the update. Note that mode can also increase here (MAY_BORROW to
823 * CAN_SEND) because we can use more precise clock that event queue here.
824 * In such case we remove class from event queue first.
826 static void htb_charge_class(struct htb_sched *q,struct htb_class *cl,
827 int level,int bytes)
829 long toks,diff;
830 enum htb_cmode old_mode;
831 HTB_DBG(5,1,"htb_chrg_cl cl=%X lev=%d len=%d\n",cl->classid,level,bytes);
833 #define HTB_ACCNT(T,B,R) toks = diff + cl->T; \
834 if (toks > cl->B) toks = cl->B; \
835 toks -= L2T(cl, cl->R, bytes); \
836 if (toks <= -cl->mbuffer) toks = 1-cl->mbuffer; \
837 cl->T = toks
839 while (cl) {
840 HTB_CHCL(cl);
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;
857 #endif
858 if (cl->level >= level) {
859 if (cl->level == level) cl->xstats.lends++;
860 HTB_ACCNT (tokens,buffer,rate);
861 } else {
862 cl->xstats.borrows++;
863 cl->tokens += diff; /* we moved t_c; update tokens */
865 HTB_ACCNT (ctokens,cbuffer,ceil);
866 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);
869 old_mode = cl->cmode; diff = 0;
870 htb_change_class_mode(q,cl,&diff);
871 if (old_mode != cl->cmode) {
872 if (old_mode != HTB_CAN_SEND)
873 htb_safe_rb_erase(&cl->pq_node,q->wait_pq+cl->level);
874 if (cl->cmode != HTB_CAN_SEND)
875 htb_add_to_wait_tree (q,cl,diff,1);
878 #ifdef HTB_RATECM
879 /* update rate counters */
880 cl->sum_bytes += bytes; cl->sum_packets++;
881 #endif
883 /* update byte stats except for leaves which are already updated */
884 if (cl->level) {
885 cl->bstats.bytes += bytes;
886 cl->bstats.packets++;
888 cl = cl->parent;
893 * htb_do_events - make mode changes to classes at the level
895 * Scans event queue for pending events and applies them. Returns jiffies to
896 * next pending event (0 for no event in pq).
897 * Note: Aplied are events whose have cl->pq_key <= jiffies.
899 static long htb_do_events(struct htb_sched *q,int level)
901 int i;
902 HTB_DBG(8,1,"htb_do_events l=%d root=%p rmask=%X\n",
903 level,q->wait_pq[level].rb_node,q->row_mask[level]);
904 for (i = 0; i < 500; i++) {
905 struct htb_class *cl;
906 long diff;
907 struct rb_node *p = q->wait_pq[level].rb_node;
908 if (!p) return 0;
909 while (p->rb_left) p = p->rb_left;
911 cl = rb_entry(p, struct htb_class, pq_node);
912 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;
916 htb_safe_rb_erase(p,q->wait_pq+level);
917 diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32)cl->mbuffer);
918 #ifdef HTB_DEBUG
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;
933 #endif
934 htb_change_class_mode(q,cl,&diff);
935 if (cl->cmode != HTB_CAN_SEND)
936 htb_add_to_wait_tree (q,cl,diff,2);
938 if (net_ratelimit())
939 printk(KERN_WARNING "htb: too many events !\n");
940 return HZ/10;
943 /* Returns class->node+prio from id-tree where classe's id is >= id. NULL
944 is no such one exists. */
945 static struct rb_node *
946 htb_id_find_next_upper(int prio,struct rb_node *n,u32 id)
948 struct rb_node *r = NULL;
949 while (n) {
950 struct htb_class *cl = rb_entry(n,struct htb_class,node[prio]);
951 if (id == cl->classid) return n;
953 if (id > cl->classid) {
954 n = n->rb_right;
955 } else {
956 r = n;
957 n = n->rb_left;
960 return r;
964 * htb_lookup_leaf - returns next leaf class in DRR order
966 * Find leaf where current feed pointers points to.
968 static struct htb_class *
969 htb_lookup_leaf(HTB_ARGQ struct rb_root *tree,int prio,struct rb_node **pptr,u32 *pid)
971 int i;
972 struct {
973 struct rb_node *root;
974 struct rb_node **pptr;
975 u32 *pid;
976 } stk[TC_HTB_MAXDEPTH],*sp = stk;
978 BUG_TRAP(tree->rb_node);
979 sp->root = tree->rb_node;
980 sp->pptr = pptr;
981 sp->pid = pid;
983 for (i = 0; i < 65535; i++) {
984 HTB_DBG(4,2,"htb_lleaf ptr=%p pid=%X\n",*sp->pptr,*sp->pid);
986 if (!*sp->pptr && *sp->pid) {
987 /* ptr was invalidated but id is valid - try to recover
988 the original or next ptr */
989 *sp->pptr = htb_id_find_next_upper(prio,sp->root,*sp->pid);
991 *sp->pid = 0; /* ptr is valid now so that remove this hint as it
992 can become out of date quickly */
993 if (!*sp->pptr) { /* we are at right end; rewind & go up */
994 *sp->pptr = sp->root;
995 while ((*sp->pptr)->rb_left)
996 *sp->pptr = (*sp->pptr)->rb_left;
997 if (sp > stk) {
998 sp--;
999 BUG_TRAP(*sp->pptr); if(!*sp->pptr) return NULL;
1000 htb_next_rb_node (sp->pptr);
1002 } else {
1003 struct htb_class *cl;
1004 cl = rb_entry(*sp->pptr,struct htb_class,node[prio]);
1005 HTB_CHCL(cl);
1006 if (!cl->level)
1007 return cl;
1008 (++sp)->root = cl->un.inner.feed[prio].rb_node;
1009 sp->pptr = cl->un.inner.ptr+prio;
1010 sp->pid = cl->un.inner.last_ptr_id+prio;
1013 BUG_TRAP(0);
1014 return NULL;
1017 /* dequeues packet at given priority and level; call only if
1018 you are sure that there is active class at prio/level */
1019 static struct sk_buff *
1020 htb_dequeue_tree(struct htb_sched *q,int prio,int level)
1022 struct sk_buff *skb = NULL;
1023 struct htb_class *cl,*start;
1024 /* look initial class up in the row */
1025 start = cl = htb_lookup_leaf (HTB_PASSQ q->row[level]+prio,prio,
1026 q->ptr[level]+prio,q->last_ptr_id[level]+prio);
1028 do {
1029 next:
1030 BUG_TRAP(cl);
1031 if (!cl) return NULL;
1032 HTB_DBG(4,1,"htb_deq_tr prio=%d lev=%d cl=%X defic=%d\n",
1033 prio,level,cl->classid,cl->un.leaf.deficit[level]);
1035 /* class can be empty - it is unlikely but can be true if leaf
1036 qdisc drops packets in enqueue routine or if someone used
1037 graft operation on the leaf since last dequeue;
1038 simply deactivate and skip such class */
1039 if (unlikely(cl->un.leaf.q->q.qlen == 0)) {
1040 struct htb_class *next;
1041 htb_deactivate(q,cl);
1043 /* row/level might become empty */
1044 if ((q->row_mask[level] & (1 << prio)) == 0)
1045 return NULL;
1047 next = htb_lookup_leaf (HTB_PASSQ q->row[level]+prio,
1048 prio,q->ptr[level]+prio,q->last_ptr_id[level]+prio);
1050 if (cl == start) /* fix start if we just deleted it */
1051 start = next;
1052 cl = next;
1053 goto next;
1056 if (likely((skb = cl->un.leaf.q->dequeue(cl->un.leaf.q)) != NULL))
1057 break;
1058 if (!cl->warned) {
1059 printk(KERN_WARNING "htb: class %X isn't work conserving ?!\n",cl->classid);
1060 cl->warned = 1;
1062 q->nwc_hit++;
1063 htb_next_rb_node((level?cl->parent->un.inner.ptr:q->ptr[0])+prio);
1064 cl = htb_lookup_leaf (HTB_PASSQ q->row[level]+prio,prio,q->ptr[level]+prio,
1065 q->last_ptr_id[level]+prio);
1067 } while (cl != start);
1069 if (likely(skb != NULL)) {
1070 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;
1074 htb_next_rb_node((level?cl->parent->un.inner.ptr:q->ptr[0])+prio);
1076 /* this used to be after charge_class but this constelation
1077 gives us slightly better performance */
1078 if (!cl->un.leaf.q->q.qlen)
1079 htb_deactivate (q,cl);
1080 htb_charge_class (q,cl,level,skb->len);
1082 return skb;
1085 static void htb_delay_by(struct Qdisc *sch,long delay)
1087 struct htb_sched *q = qdisc_priv(sch);
1088 if (delay <= 0) delay = 1;
1089 if (unlikely(delay > 5*HZ)) {
1090 if (net_ratelimit())
1091 printk(KERN_INFO "HTB delay %ld > 5sec\n", delay);
1092 delay = 5*HZ;
1094 /* why don't use jiffies here ? because expires can be in past */
1095 mod_timer(&q->timer, q->jiffies + delay);
1096 sch->flags |= TCQ_F_THROTTLED;
1097 sch->qstats.overlimits++;
1098 HTB_DBG(3,1,"htb_deq t_delay=%ld\n",delay);
1101 static struct sk_buff *htb_dequeue(struct Qdisc *sch)
1103 struct sk_buff *skb = NULL;
1104 struct htb_sched *q = qdisc_priv(sch);
1105 int level;
1106 long min_delay;
1107 #ifdef HTB_DEBUG
1108 int evs_used = 0;
1109 #endif
1111 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);
1115 /* try to dequeue direct packets as high prio (!) to minimize cpu work */
1116 if ((skb = __skb_dequeue(&q->direct_queue)) != NULL) {
1117 sch->flags &= ~TCQ_F_THROTTLED;
1118 sch->q.qlen--;
1119 return skb;
1122 if (!sch->q.qlen) goto fin;
1123 PSCHED_GET_TIME(q->now);
1125 min_delay = LONG_MAX;
1126 q->nwc_hit = 0;
1127 for (level = 0; level < TC_HTB_MAXDEPTH; level++) {
1128 /* common case optimization - skip event handler quickly */
1129 int m;
1130 long delay;
1131 if (time_after_eq(q->jiffies, q->near_ev_cache[level])) {
1132 delay = htb_do_events(q,level);
1133 q->near_ev_cache[level] = q->jiffies + (delay ? delay : HZ);
1134 #ifdef HTB_DEBUG
1135 evs_used++;
1136 #endif
1137 } else
1138 delay = q->near_ev_cache[level] - q->jiffies;
1140 if (delay && min_delay > delay)
1141 min_delay = delay;
1142 m = ~q->row_mask[level];
1143 while (m != (int)(-1)) {
1144 int prio = ffz (m);
1145 m |= 1 << prio;
1146 skb = htb_dequeue_tree(q,prio,level);
1147 if (likely(skb != NULL)) {
1148 sch->q.qlen--;
1149 sch->flags &= ~TCQ_F_THROTTLED;
1150 goto fin;
1154 #ifdef HTB_DEBUG
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);
1164 #endif
1165 htb_delay_by (sch,min_delay > 5*HZ ? 5*HZ : min_delay);
1166 fin:
1167 HTB_DBG(3,1,"htb_deq_end %s j=%lu skb=%p\n",sch->dev->name,q->jiffies,skb);
1168 return skb;
1171 /* try to drop from each class (by prio) until one succeed */
1172 static unsigned int htb_drop(struct Qdisc* sch)
1174 struct htb_sched *q = qdisc_priv(sch);
1175 int prio;
1177 for (prio = TC_HTB_NUMPRIO - 1; prio >= 0; prio--) {
1178 struct list_head *p;
1179 list_for_each (p,q->drops+prio) {
1180 struct htb_class *cl = list_entry(p, struct htb_class,
1181 un.leaf.drop_list);
1182 unsigned int len;
1183 if (cl->un.leaf.q->ops->drop &&
1184 (len = cl->un.leaf.q->ops->drop(cl->un.leaf.q))) {
1185 sch->q.qlen--;
1186 if (!cl->un.leaf.q->q.qlen)
1187 htb_deactivate (q,cl);
1188 return len;
1192 return 0;
1195 /* reset all classes */
1196 /* always caled under BH & queue lock */
1197 static void htb_reset(struct Qdisc* sch)
1199 struct htb_sched *q = qdisc_priv(sch);
1200 int i;
1201 HTB_DBG(0,1,"htb_reset sch=%p, handle=%X\n",sch,sch->handle);
1203 for (i = 0; i < HTB_HSIZE; i++) {
1204 struct list_head *p;
1205 list_for_each (p,q->hash+i) {
1206 struct htb_class *cl = list_entry(p,struct htb_class,hlist);
1207 if (cl->level)
1208 memset(&cl->un.inner,0,sizeof(cl->un.inner));
1209 else {
1210 if (cl->un.leaf.q)
1211 qdisc_reset(cl->un.leaf.q);
1212 INIT_LIST_HEAD(&cl->un.leaf.drop_list);
1214 cl->prio_activity = 0;
1215 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
1223 sch->flags &= ~TCQ_F_THROTTLED;
1224 del_timer(&q->timer);
1225 __skb_queue_purge(&q->direct_queue);
1226 sch->q.qlen = 0;
1227 memset(q->row,0,sizeof(q->row));
1228 memset(q->row_mask,0,sizeof(q->row_mask));
1229 memset(q->wait_pq,0,sizeof(q->wait_pq));
1230 memset(q->ptr,0,sizeof(q->ptr));
1231 for (i = 0; i < TC_HTB_NUMPRIO; i++)
1232 INIT_LIST_HEAD(q->drops+i);
1235 static int htb_init(struct Qdisc *sch, struct rtattr *opt)
1237 struct htb_sched *q = qdisc_priv(sch);
1238 struct rtattr *tb[TCA_HTB_INIT];
1239 struct tc_htb_glob *gopt;
1240 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) ||
1246 tb[TCA_HTB_INIT-1] == NULL ||
1247 RTA_PAYLOAD(tb[TCA_HTB_INIT-1]) < sizeof(*gopt)) {
1248 printk(KERN_ERR "HTB: hey probably you have bad tc tool ?\n");
1249 return -EINVAL;
1251 gopt = RTA_DATA(tb[TCA_HTB_INIT-1]);
1252 if (gopt->version != HTB_VER >> 16) {
1253 printk(KERN_ERR "HTB: need tc/htb version %d (minor is %d), you have %d\n",
1254 HTB_VER >> 16,HTB_VER & 0xffff,gopt->version);
1255 return -EINVAL;
1257 q->debug = gopt->debug;
1258 HTB_DBG(0,1,"htb_init sch=%p handle=%X r2q=%d\n",sch,sch->handle,gopt->rate2quantum);
1260 INIT_LIST_HEAD(&q->root);
1261 for (i = 0; i < HTB_HSIZE; i++)
1262 INIT_LIST_HEAD(q->hash+i);
1263 for (i = 0; i < TC_HTB_NUMPRIO; i++)
1264 INIT_LIST_HEAD(q->drops+i);
1266 init_timer(&q->timer);
1267 skb_queue_head_init(&q->direct_queue);
1269 q->direct_qlen = sch->dev->tx_queue_len;
1270 if (q->direct_qlen < 2) /* some devices have zero tx_queue_len */
1271 q->direct_qlen = 2;
1272 q->timer.function = htb_timer;
1273 q->timer.data = (unsigned long)sch;
1275 #ifdef HTB_RATECM
1276 init_timer(&q->rttim);
1277 q->rttim.function = htb_rate_timer;
1278 q->rttim.data = (unsigned long)sch;
1279 q->rttim.expires = jiffies + HZ;
1280 add_timer(&q->rttim);
1281 #endif
1282 if ((q->rate2quantum = gopt->rate2quantum) < 1)
1283 q->rate2quantum = 1;
1284 q->defcls = gopt->defcls;
1286 return 0;
1289 static int htb_dump(struct Qdisc *sch, struct sk_buff *skb)
1291 struct htb_sched *q = qdisc_priv(sch);
1292 unsigned char *b = skb->tail;
1293 struct rtattr *rta;
1294 struct tc_htb_glob gopt;
1295 HTB_DBG(0,1,"htb_dump sch=%p, handle=%X\n",sch,sch->handle);
1296 HTB_QLOCK(sch);
1297 gopt.direct_pkts = q->direct_pkts;
1299 #ifdef HTB_DEBUG
1300 if (HTB_DBG_COND(0,2))
1301 htb_debug_dump(q);
1302 #endif
1303 gopt.version = HTB_VER;
1304 gopt.rate2quantum = q->rate2quantum;
1305 gopt.defcls = q->defcls;
1306 gopt.debug = q->debug;
1307 rta = (struct rtattr*)b;
1308 RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
1309 RTA_PUT(skb, TCA_HTB_INIT, sizeof(gopt), &gopt);
1310 rta->rta_len = skb->tail - b;
1311 HTB_QUNLOCK(sch);
1312 return skb->len;
1313 rtattr_failure:
1314 HTB_QUNLOCK(sch);
1315 skb_trim(skb, skb->tail - skb->data);
1316 return -1;
1319 static int htb_dump_class(struct Qdisc *sch, unsigned long arg,
1320 struct sk_buff *skb, struct tcmsg *tcm)
1322 #ifdef HTB_DEBUG
1323 struct htb_sched *q = qdisc_priv(sch);
1324 #endif
1325 struct htb_class *cl = (struct htb_class*)arg;
1326 unsigned char *b = skb->tail;
1327 struct rtattr *rta;
1328 struct tc_htb_opt opt;
1330 HTB_DBG(0,1,"htb_dump_class handle=%X clid=%X\n",sch->handle,cl->classid);
1332 HTB_QLOCK(sch);
1333 tcm->tcm_parent = cl->parent ? cl->parent->classid : TC_H_ROOT;
1334 tcm->tcm_handle = cl->classid;
1335 if (!cl->level && cl->un.leaf.q)
1336 tcm->tcm_info = cl->un.leaf.q->handle;
1338 rta = (struct rtattr*)b;
1339 RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
1341 memset (&opt,0,sizeof(opt));
1343 opt.rate = cl->rate->rate; opt.buffer = cl->buffer;
1344 opt.ceil = cl->ceil->rate; opt.cbuffer = cl->cbuffer;
1345 opt.quantum = cl->un.leaf.quantum; opt.prio = cl->un.leaf.prio;
1346 opt.level = cl->level;
1347 RTA_PUT(skb, TCA_HTB_PARMS, sizeof(opt), &opt);
1348 rta->rta_len = skb->tail - b;
1349 HTB_QUNLOCK(sch);
1350 return skb->len;
1351 rtattr_failure:
1352 HTB_QUNLOCK(sch);
1353 skb_trim(skb, b - skb->data);
1354 return -1;
1357 static int
1358 htb_dump_class_stats(struct Qdisc *sch, unsigned long arg,
1359 struct gnet_dump *d)
1361 struct htb_class *cl = (struct htb_class*)arg;
1363 #ifdef HTB_RATECM
1364 cl->rate_est.bps = cl->rate_bytes/(HTB_EWMAC*HTB_HSIZE);
1365 cl->rate_est.pps = cl->rate_packets/(HTB_EWMAC*HTB_HSIZE);
1366 #endif
1368 if (!cl->level && cl->un.leaf.q)
1369 cl->qstats.qlen = cl->un.leaf.q->q.qlen;
1370 cl->xstats.tokens = cl->tokens;
1371 cl->xstats.ctokens = cl->ctokens;
1373 if (gnet_stats_copy_basic(d, &cl->bstats) < 0 ||
1374 gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 ||
1375 gnet_stats_copy_queue(d, &cl->qstats) < 0)
1376 return -1;
1378 return gnet_stats_copy_app(d, &cl->xstats, sizeof(cl->xstats));
1381 static int htb_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
1382 struct Qdisc **old)
1384 struct htb_class *cl = (struct htb_class*)arg;
1386 if (cl && !cl->level) {
1387 if (new == NULL && (new = qdisc_create_dflt(sch->dev,
1388 &pfifo_qdisc_ops)) == NULL)
1389 return -ENOBUFS;
1390 sch_tree_lock(sch);
1391 if ((*old = xchg(&cl->un.leaf.q, new)) != NULL) {
1392 if (cl->prio_activity)
1393 htb_deactivate (qdisc_priv(sch),cl);
1395 /* TODO: is it correct ? Why CBQ doesn't do it ? */
1396 sch->q.qlen -= (*old)->q.qlen;
1397 qdisc_reset(*old);
1399 sch_tree_unlock(sch);
1400 return 0;
1402 return -ENOENT;
1405 static struct Qdisc * htb_leaf(struct Qdisc *sch, unsigned long arg)
1407 struct htb_class *cl = (struct htb_class*)arg;
1408 return (cl && !cl->level) ? cl->un.leaf.q : NULL;
1411 static unsigned long htb_get(struct Qdisc *sch, u32 classid)
1413 #ifdef HTB_DEBUG
1414 struct htb_sched *q = qdisc_priv(sch);
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++;
1420 return (unsigned long)cl;
1423 static void htb_destroy_filters(struct tcf_proto **fl)
1425 struct tcf_proto *tp;
1427 while ((tp = *fl) != NULL) {
1428 *fl = tp->next;
1429 tcf_destroy(tp);
1433 static void htb_destroy_class(struct Qdisc* sch,struct htb_class *cl)
1435 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) {
1438 BUG_TRAP(cl->un.leaf.q);
1439 sch->q.qlen -= cl->un.leaf.q->q.qlen;
1440 qdisc_destroy(cl->un.leaf.q);
1442 qdisc_put_rtab(cl->rate);
1443 qdisc_put_rtab(cl->ceil);
1445 htb_destroy_filters (&cl->filter_list);
1447 while (!list_empty(&cl->children))
1448 htb_destroy_class (sch,list_entry(cl->children.next,
1449 struct htb_class,sibling));
1451 /* note: this delete may happen twice (see htb_delete) */
1452 list_del(&cl->hlist);
1453 list_del(&cl->sibling);
1455 if (cl->prio_activity)
1456 htb_deactivate (q,cl);
1458 if (cl->cmode != HTB_CAN_SEND)
1459 htb_safe_rb_erase(&cl->pq_node,q->wait_pq+cl->level);
1461 kfree(cl);
1464 /* always caled under BH & queue lock */
1465 static void htb_destroy(struct Qdisc* sch)
1467 struct htb_sched *q = qdisc_priv(sch);
1468 HTB_DBG(0,1,"htb_destroy q=%p\n",q);
1470 del_timer_sync (&q->timer);
1471 #ifdef HTB_RATECM
1472 del_timer_sync (&q->rttim);
1473 #endif
1474 /* This line used to be after htb_destroy_class call below
1475 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
1477 unbind_filter on it (without Oops). */
1478 htb_destroy_filters(&q->filter_list);
1480 while (!list_empty(&q->root))
1481 htb_destroy_class (sch,list_entry(q->root.next,
1482 struct htb_class,sibling));
1484 __skb_queue_purge(&q->direct_queue);
1487 static int htb_delete(struct Qdisc *sch, unsigned long arg)
1489 struct htb_sched *q = qdisc_priv(sch);
1490 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);
1493 // TODO: why don't allow to delete subtree ? references ? does
1494 // tc subsys quarantee us that in htb_destroy it holds no class
1495 // refs so that we can remove children safely there ?
1496 if (!list_empty(&cl->children) || cl->filter_cnt)
1497 return -EBUSY;
1499 sch_tree_lock(sch);
1501 /* delete from hash and active; remainder in destroy_class */
1502 list_del_init(&cl->hlist);
1503 if (cl->prio_activity)
1504 htb_deactivate (q,cl);
1506 if (--cl->refcnt == 0)
1507 htb_destroy_class(sch,cl);
1509 sch_tree_unlock(sch);
1510 return 0;
1513 static void htb_put(struct Qdisc *sch, unsigned long arg)
1515 #ifdef HTB_DEBUG
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);
1521 if (--cl->refcnt == 0)
1522 htb_destroy_class(sch,cl);
1525 static int htb_change_class(struct Qdisc *sch, u32 classid,
1526 u32 parentid, struct rtattr **tca, unsigned long *arg)
1528 int err = -EINVAL;
1529 struct htb_sched *q = qdisc_priv(sch);
1530 struct htb_class *cl = (struct htb_class*)*arg,*parent;
1531 struct rtattr *opt = tca[TCA_OPTIONS-1];
1532 struct qdisc_rate_table *rtab = NULL, *ctab = NULL;
1533 struct rtattr *tb[TCA_HTB_RTAB];
1534 struct tc_htb_opt *hopt;
1536 /* extract all subattrs from opt attr */
1537 if (!opt || rtattr_parse_nested(tb, TCA_HTB_RTAB, opt) ||
1538 tb[TCA_HTB_PARMS-1] == NULL ||
1539 RTA_PAYLOAD(tb[TCA_HTB_PARMS-1]) < sizeof(*hopt))
1540 goto failure;
1542 parent = parentid == TC_H_ROOT ? NULL : htb_find (parentid,sch);
1544 hopt = RTA_DATA(tb[TCA_HTB_PARMS-1]);
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);
1546 rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB-1]);
1547 ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB-1]);
1548 if (!rtab || !ctab) goto failure;
1550 if (!cl) { /* new class */
1551 struct Qdisc *new_q;
1552 /* check for valid classid */
1553 if (!classid || TC_H_MAJ(classid^sch->handle) || htb_find(classid,sch))
1554 goto failure;
1556 /* check maximal depth */
1557 if (parent && parent->parent && parent->parent->level < 2) {
1558 printk(KERN_ERR "htb: tree is too deep\n");
1559 goto failure;
1561 err = -ENOBUFS;
1562 if ((cl = kzalloc(sizeof(*cl), GFP_KERNEL)) == NULL)
1563 goto failure;
1565 cl->refcnt = 1;
1566 INIT_LIST_HEAD(&cl->sibling);
1567 INIT_LIST_HEAD(&cl->hlist);
1568 INIT_LIST_HEAD(&cl->children);
1569 INIT_LIST_HEAD(&cl->un.leaf.drop_list);
1570 #ifdef HTB_DEBUG
1571 cl->magic = HTB_CMAGIC;
1572 #endif
1574 /* create leaf qdisc early because it uses kmalloc(GFP_KERNEL)
1575 so that can't be used inside of sch_tree_lock
1576 -- thanks to Karlis Peisenieks */
1577 new_q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops);
1578 sch_tree_lock(sch);
1579 if (parent && !parent->level) {
1580 /* turn parent into inner node */
1581 sch->q.qlen -= parent->un.leaf.q->q.qlen;
1582 qdisc_destroy (parent->un.leaf.q);
1583 if (parent->prio_activity)
1584 htb_deactivate (q,parent);
1586 /* remove from evt list because of level change */
1587 if (parent->cmode != HTB_CAN_SEND) {
1588 htb_safe_rb_erase(&parent->pq_node,q->wait_pq /*+0*/);
1589 parent->cmode = HTB_CAN_SEND;
1591 parent->level = (parent->parent ? parent->parent->level
1592 : TC_HTB_MAXDEPTH) - 1;
1593 memset (&parent->un.inner,0,sizeof(parent->un.inner));
1595 /* leaf (we) needs elementary qdisc */
1596 cl->un.leaf.q = new_q ? new_q : &noop_qdisc;
1598 cl->classid = classid; cl->parent = parent;
1600 /* set class to be in HTB_CAN_SEND state */
1601 cl->tokens = hopt->buffer;
1602 cl->ctokens = hopt->cbuffer;
1603 cl->mbuffer = PSCHED_JIFFIE2US(HZ*60); /* 1min */
1604 PSCHED_GET_TIME(cl->t_c);
1605 cl->cmode = HTB_CAN_SEND;
1607 /* attach to the hash list and parent's family */
1608 list_add_tail(&cl->hlist, q->hash+htb_hash(classid));
1609 list_add_tail(&cl->sibling, parent ? &parent->children : &q->root);
1610 #ifdef HTB_DEBUG
1612 int i;
1613 for (i = 0; i < TC_HTB_NUMPRIO; i++) cl->node[i].rb_color = -1;
1614 cl->pq_node.rb_color = -1;
1616 #endif
1617 } else sch_tree_lock(sch);
1619 /* it used to be a nasty bug here, we have to check that node
1620 is really leaf before changing cl->un.leaf ! */
1621 if (!cl->level) {
1622 cl->un.leaf.quantum = rtab->rate.rate / q->rate2quantum;
1623 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);
1625 cl->un.leaf.quantum = 1000;
1627 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);
1629 cl->un.leaf.quantum = 200000;
1631 if (hopt->quantum)
1632 cl->un.leaf.quantum = hopt->quantum;
1633 if ((cl->un.leaf.prio = hopt->prio) >= TC_HTB_NUMPRIO)
1634 cl->un.leaf.prio = TC_HTB_NUMPRIO - 1;
1637 cl->buffer = hopt->buffer;
1638 cl->cbuffer = hopt->cbuffer;
1639 if (cl->rate) qdisc_put_rtab(cl->rate); cl->rate = rtab;
1640 if (cl->ceil) qdisc_put_rtab(cl->ceil); cl->ceil = ctab;
1641 sch_tree_unlock(sch);
1643 *arg = (unsigned long)cl;
1644 return 0;
1646 failure:
1647 if (rtab) qdisc_put_rtab(rtab);
1648 if (ctab) qdisc_put_rtab(ctab);
1649 return err;
1652 static struct tcf_proto **htb_find_tcf(struct Qdisc *sch, unsigned long arg)
1654 struct htb_sched *q = qdisc_priv(sch);
1655 struct htb_class *cl = (struct htb_class *)arg;
1656 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);
1658 return fl;
1661 static unsigned long htb_bind_filter(struct Qdisc *sch, unsigned long parent,
1662 u32 classid)
1664 struct htb_sched *q = qdisc_priv(sch);
1665 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);
1667 /*if (cl && !cl->level) return 0;
1668 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
1670 for other reasons so that we have to allow for it.
1671 ----
1672 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
1674 be broken by class during destroy IIUC.
1676 if (cl)
1677 cl->filter_cnt++;
1678 else
1679 q->filter_cnt++;
1680 return (unsigned long)cl;
1683 static void htb_unbind_filter(struct Qdisc *sch, unsigned long arg)
1685 struct htb_sched *q = qdisc_priv(sch);
1686 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);
1688 if (cl)
1689 cl->filter_cnt--;
1690 else
1691 q->filter_cnt--;
1694 static void htb_walk(struct Qdisc *sch, struct qdisc_walker *arg)
1696 struct htb_sched *q = qdisc_priv(sch);
1697 int i;
1699 if (arg->stop)
1700 return;
1702 for (i = 0; i < HTB_HSIZE; i++) {
1703 struct list_head *p;
1704 list_for_each (p,q->hash+i) {
1705 struct htb_class *cl = list_entry(p,struct htb_class,hlist);
1706 if (arg->count < arg->skip) {
1707 arg->count++;
1708 continue;
1710 if (arg->fn(sch, (unsigned long)cl, arg) < 0) {
1711 arg->stop = 1;
1712 return;
1714 arg->count++;
1719 static struct Qdisc_class_ops htb_class_ops = {
1720 .graft = htb_graft,
1721 .leaf = htb_leaf,
1722 .get = htb_get,
1723 .put = htb_put,
1724 .change = htb_change_class,
1725 .delete = htb_delete,
1726 .walk = htb_walk,
1727 .tcf_chain = htb_find_tcf,
1728 .bind_tcf = htb_bind_filter,
1729 .unbind_tcf = htb_unbind_filter,
1730 .dump = htb_dump_class,
1731 .dump_stats = htb_dump_class_stats,
1734 static struct Qdisc_ops htb_qdisc_ops = {
1735 .next = NULL,
1736 .cl_ops = &htb_class_ops,
1737 .id = "htb",
1738 .priv_size = sizeof(struct htb_sched),
1739 .enqueue = htb_enqueue,
1740 .dequeue = htb_dequeue,
1741 .requeue = htb_requeue,
1742 .drop = htb_drop,
1743 .init = htb_init,
1744 .reset = htb_reset,
1745 .destroy = htb_destroy,
1746 .change = NULL /* htb_change */,
1747 .dump = htb_dump,
1748 .owner = THIS_MODULE,
1751 static int __init htb_module_init(void)
1753 return register_qdisc(&htb_qdisc_ops);
1755 static void __exit htb_module_exit(void)
1757 unregister_qdisc(&htb_qdisc_ops);
1759 module_init(htb_module_init)
1760 module_exit(htb_module_exit)
1761 MODULE_LICENSE("GPL");