「十一」HTB源码分析2 HTB结构

static struct Qdisc_ops htb_qdisc_ops = {  
 .next  = NULL,  
 .cl_ops  = &htb_class_ops,  
 .id  = "htb",  
 .priv_size = sizeof(struct htb_sched),  
 .enqueue = htb_enqueue,  
 .dequeue = htb_dequeue,  
 .requeue = htb_requeue,  
 .drop  = htb_drop,  
 .init  = htb_init,  
 .reset  = htb_reset,  
 .destroy = htb_destroy,  
// 更改操作为空  
 .change  = NULL /* htb_change */,  
 .dump  = htb_dump,  
 .owner  = THIS_MODULE,  
}; 

static struct Qdisc_class_ops htb_class_ops = {  
 .graft  = htb_graft,  
 .leaf  = htb_leaf,  
 .get  = htb_get,  
 .put  = htb_put,  
 .change  = htb_change_class,  
 .delete  = htb_delete,  
 .walk  = htb_walk,  
 .tcf_chain = htb_find_tcf,  
 .bind_tcf = htb_bind_filter,  
 .unbind_tcf = htb_unbind_filter,  
 .dump  = htb_dump_class,  
 .dump_stats = htb_dump_class_stats,  
}; 

static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch)  
{
	int ret;
	// HTB私有数据结构  
	struct htb_sched *q = qdisc_priv(sch);
	/** 对数据包进行分类
	  * NULL，数据包drop
	  * -1，数据包直接发送，下文中#define HTB_DIRECT (struct htb_class*)-1
	  * leaf class,其他情况
	  */
	struct htb_class *cl = htb_classify(skb, sch, &ret);
	if (cl == HTB_DIRECT) {
	// 分类结果是直接发送
		/* enqueue to helper queue */
		// 如果直接发送队列中的数据包长度小于直接发送队列长度最大值, 将数据包添加到队列末尾
		if (q->direct_queue.qlen < q->direct_qlen) {
			__skb_queue_tail(&q->direct_queue, skb);
			q->direct_pkts++;
		} else {
			// 否则丢弃数据包
			kfree_skb(skb);
			sch->qstats.drops++;
			return NET_XMIT_DROP;
		}
#ifdef CONFIG_NET_CLS_ACT
	// 定义了NET_CLS_ACT的情况(支持分类动作)
	} else if (!cl) {
		// 分类没有结果, 丢包
		if (ret == NET_XMIT_BYPASS)
			sch->qstats.drops++;
		kfree_skb(skb);
		return ret;
#endif
	// 有分类结果, 进行分类相关的叶子节点流控结构（是指3.4中为叶子节点设置的流控，例如pfifo）的入队操作
	} else if (cl->un.leaf.q->enqueue(skb, cl->un.leaf.q) !=
		   NET_XMIT_SUCCESS) {
		// 入队不成功的话丢包
		sch->qstats.drops++;
		cl->qstats.drops++;
		return NET_XMIT_DROP;
	} else {
		// 入队成功, 分类结构的包数字节数的统计数增加
		cl->bstats.packets++;
		cl->bstats.bytes += skb->len;
		// 激活HTB类别, 建立该类别的数据提供树, 这样dequeue时可以从中取数据包
		// 只有类别节点的模式是可发送和可租借的情况下才会激活, 如果节点是阻塞模式, 则不会被激活
		htb_activate(q, cl);
	}
	// HTB流控结构统计数更新, 入队成功
	sch->q.qlen++;
	sch->bstats.packets++;
	sch->bstats.bytes += skb->len;
	return NET_XMIT_SUCCESS;
}

/** 
 * htb_activate - 将叶子节点cl插入适合的active self feed中 
 * 
 * Routine学习(新的)叶子节点优先级，并根据优先级激活feed chain。它可以安全地调用已经激活的叶子
 * 它也可以将叶子节点添加到droplist中
 * 激活类别结构, 将该类别节点作为数据包提供者, 而数据类别表提供是一个有序表, 以RB树形式实现
 */ 
static inline void htb_activate(struct htb_sched *q, struct htb_class *cl)
{
	BUG_TRAP(!cl->level && cl->un.leaf.q && cl->un.leaf.q->q.qlen);
	// 如果类别的prio_activity参数为0才进行操作, 非0表示已经激活了
	// leaf.aprio保存当前的leaf.prio
	if (!cl->prio_activity) {
	// prio_activity是通过叶子节点的prio值来设置的, 至少是1, 最大是1<<7, 非0值
		cl->prio_activity = 1 << (cl->un.leaf.aprio = cl->un.leaf.prio);
		// 进行实际的激活操作
		htb_activate_prios(q, cl);
		// 根据leaf.aprio添加到指定的优先权位置的丢包链表
		list_add_tail(&cl->un.leaf.drop_list,
			      q->drops + cl->un.leaf.aprio);
	}
}

/** 
 * htb_activate_prios - 创建active class的feed chain 
 * 
 * 这里的class必须是根据优先级连接到祖先节点的inner self或者合适的rows（self feed）。
 * cl->cmode必须是new (activated) mode。
 * 如果cl->prio_activity == 0,就是一个空函数， 不过从前面看prio_activity似乎是不会为0的
 * 激活操作, 建立数据提供树
 */  
static void htb_activate_prios(struct htb_sched *q, struct htb_class *cl)
{	
	// 父节点
	struct htb_class *p = cl->parent;
	// prio_activity是作为一个掩码, 应该只有一位为1
	long m, mask = cl->prio_activity;
	// 在当前模式是HTB_MAY_BORROW情况下进入循环, 某些情况下这些类别是可以激活的
	// 绝大多数情况p和mask的初始值应该都是非0值
	while (cl->cmode == HTB_MAY_BORROW && p && mask) {
		// 备份mask值
		m = mask;
		while (m) {
			// 掩码取反, 找第一个0位的位置（从0开始计数）, 也就是原来最低为1的位的位置
			// prio越小, 等级越高, 取数据包也是先从prio值小的节点取
			int prio = ffz(~m);
			// 清除该位
			m &= ~(1 << prio);
			// p是父节点, 所以inner结构肯定有效, 不会使用leaf结构的
			// 如果父节点的prio优先权的数据包的提供树已经存在, 在掩码中去掉该位
			if (p->un.inner.feed[prio].rb_node)
				/* parent already has its feed in use so that
				   reset bit in mask as parent is already ok */
				mask &= ~(1 << prio);
			// 将该类别加到父节点的prio优先权提供数据包的节点树中，
			// 即由于子class是yellow，所以将其按优先级添加到父class的inner feed中
			htb_add_to_id_tree(p->un.inner.feed + prio, cl, prio);
		}
		// 父节点的prio_activity或上mask中的置1位, 某位为1表示该位对应的优先权的数据可用
		// 表示inner feed中与该子class的连线
		p->prio_activity |= mask;
		// 循环到上一层, 当前类别更新父节点, 父节点更新为祖父节点 
		// 如果父节点也变yellow，需要将父节点也添加到祖父节点的inner feed中
		cl = p;
		p = cl->parent;
	}
	// 如果cl是HTB_CAN_SEND模式, 将该类别添加到合适的ROW（self feed）中
	// 此时的cl可能已经不是原来的cl了,而是原cl的长辈节点了
	if (cl->cmode == HTB_CAN_SEND && mask)
		htb_add_class_to_row(q, cl, mask);
}

/** 
 * htb_add_to_id_tree - 将class添加到父class的inner feed中 
 * 
 * Routine 将class添加到根据classid存储的list中（实际上是一棵树）
 * 确保给定优先级的class之前没有存储在该list中 
 * @root: 传入的是p->un.inner.feed + prio，inner.feed是rb_boot数组，struct rb_root feed[TC_HTB_NUMPRIO]，
 * +prio表示获得prio优先级对应的feed[]数组元素
 * @cl: 要加入rb数的子节点
 * @prio: 子节点的优先级
 */  
static void htb_add_to_id_tree(struct rb_root *root,
			       struct htb_class *cl, int prio)
{
	struct rb_node **p = &root->rb_node, *parent = NULL;
	// RB树是有序表, 根据类别ID排序, 值大的到右节点, 小的到左节点
	// 循环, 查找树中合适的位置插入类别节点cl
	while (*p) {
		struct htb_class *c;
		parent = *p;
		c = rb_entry(parent, struct htb_class, node[prio]);

		if (cl->classid > c->classid)
			p = &parent->rb_right;
		else
			p = &parent->rb_left;
	}
	// 进行RB树的插入操作, RB树标准函数操作
	rb_link_node(&cl->node[prio], parent, p);
	rb_insert_color(&cl->node[prio], root);
}

/** 
 * htb_add_class_to_row - 将class添加到它所在level的self feed 
 * 
 * 根据优先级掩码，将class添加到它所在level的row，即self feed 
 * 如果mask==0,将什么也不做
 */ 
static inline void htb_add_class_to_row(struct htb_sched *q,
					struct htb_class *cl, int mask)
{
	//htb_sched的row_mask表示该层的哪些优先权值的树有效
	// 将cl层次对应的ROW的row_mask或上新的mask, 表示有对应prio的数据了 
	q->row_mask[cl->level] |= mask;
	// 循环mask, 将cl插入mask每一位对应的prio的树中 
	while (mask) {
		// prio是mask中最低为1的位的位置 
		int prio = ffz(~mask);
		// 清除该位
		mask &= ~(1 << prio);
		// 添加到具体的RB树中，即cl所在层次的self feed对应优先级的RB树
		htb_add_to_id_tree(q->row[cl->level] + prio, cl, prio);
	}
}

static struct sk_buff *htb_dequeue(struct Qdisc *sch)
{
	struct sk_buff *skb = NULL;
	// HTB私有数据结构
	struct htb_sched *q = qdisc_priv(sch);
	int level;
	long min_delay;
	// 保存当前时间滴答数
	q->jiffies = jiffies;
	/* try to dequeue direct packets as high prio (!) to minimize cpu work */
	// 先从当前直接发送队列取数据包, 直接发送队列中的数据有最高优先级, 可以说没有流量限制 
	skb = __skb_dequeue(&q->direct_queue);
	if (skb != NULL) {
		// 从直接发送队列中取到数据包, 更新参数, 非阻塞, 返回数据包  
		sch->flags &= ~TCQ_F_THROTTLED;
		//sch->q 数据包链表头
		sch->q.qlen--;
		return skb;
	}
	// 如果HTB流控结构队列长度为0, 返回空
	if (!sch->q.qlen)
		goto fin;
	// 获取当前有效时间值
	PSCHED_GET_TIME(q->now);
	// 最小延迟值初始化为最大整数
	min_delay = LONG_MAX;
	q->nwc_hit = 0;
	// 遍历节点树（静态）的所有层次, 从叶子节点开始
	for (level = 0; level < TC_HTB_MAXDEPTH; level++) {
		/* common case optimization - skip event handler quickly */
		int m;
		long delay;
		// 计算延迟值, 是取数据包失败的情况下更新HTB定时器的延迟时间 
		// 比较ROW树中该层节点最近的事件定时时间是否已经到了
		if (time_after_eq(q->jiffies, q->near_ev_cache[level])) {
			// 时间到了, 处理HTB事件, 返回值是下一个事件的延迟时间
			//对第level号等待树的类别节点进行模式调整，即white slot里面的class，一会再详细看
			delay = htb_do_events(q, level);
			// 更新本层最近定时时间,HZ表示1秒钟
			q->near_ev_cache[level] =
			    q->jiffies + (delay ? delay : HZ);
		} else
			// 时间还没到, 计算两者时间差
			delay = q->near_ev_cache[level] - q->jiffies;
		// 更新最小延迟值, 注意这是在循环里面进行更新的, 循环找出最小的延迟时间
		if (delay && min_delay > delay)
			min_delay = delay;
		// 该层次的row_mask取反, 实际是为找到row_mask[level]中为1的位, 为1表示该树有数据包可用
		// row中的节点都是green，也就是CAN_SEND
		m = ~q->row_mask[level];
		while (m != (int)(-1)) {
			// m的数据位中第一个0位的位置作为优先级值, 从低位开始找, 也就是prio越小, 实际数据的优先权越大, 越先出队
			// 找出同一层取优先级高的
			int prio = ffz(m);
			// 将该0位设置为1, 也就是清除该位
			m |= 1 << prio;
			// 从该优先权值的流控树中进行出队操作
			skb = htb_dequeue_tree(q, prio, level);
			if (likely(skb != NULL)) {
				// 数据包出队成功, 更新参数, 退出循环, 返回数据包
				// 取数据包成功就要去掉流控节点的阻塞标志
				sch->q.qlen--;
				sch->flags &= ~TCQ_F_THROTTLED;
				goto fin;
			}
		}
	}
	// 循环结束也没取到数据包, 队列长度非0却不能取出数据包, 表示流控节点阻塞
	// 进行阻塞处理, 调整HTB定时器, 最大延迟5秒
	htb_delay_by(sch, min_delay > 5 * HZ ? 5 * HZ : min_delay);
fin:
	return skb;
}

/** 
 * htb_do_events - 对第level号等待树的类别节点进行模式调整 
 * 
 * 扫描event队列,发现pending event然后应用它们。
 * 返回下一个pending event的时间jiffies，如果pq没有event，则返回0
 */  
//  
static long htb_do_events(struct htb_sched *q, int level)
{
	int i;
	// 循环500次, 为什么是500? 表示树里最多有500个节点? 对应500个事件
	for (i = 0; i < 500; i++) {
		struct htb_class *cl;
		long diff;
		//q->wait_pq[]：等待队列，用来挂载哪些带宽超出限制的节点
		// 取等待rb树第一个节点, 每次循环都从树中删除一个节点  
		struct rb_node *p = rb_first(&q->wait_pq[level]);
		// 没节点, 事件空, 返回0表示没延迟
		if (!p)
			return 0;
		// 获取该节点对应的HTB类别
		cl = rb_entry(p, struct htb_class, pq_node);
		// 该类别延迟处理时间是在当前时间后面, 返回时间差作为延迟值
		if (time_after(cl->pq_key, q->jiffies)) {
			return cl->pq_key - q->jiffies;
		}
		// 时间小于当前时间了, 已经超时了
		// 安全地将该节点p从等待RB树中断开
		htb_safe_rb_erase(p, q->wait_pq + level);
		// 当前时间和检查点时间的差值
		// 根据当前时间和上次流控计算时间的时间差来计算可用的令牌量
		// 计算从上次发送数据包到现在的时间里生成的令牌数，然后把diff加上原先桶中的令牌数就为总的令牌数，当然总的
令牌数是不能比桶大的
		diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32) cl->mbuffer);
		// 根据时间差值更改该类别模式
		htb_change_class_mode(q, cl, &diff);
		// 如果不是可发送模式, 重新插入回等待树 
		if (cl->cmode != HTB_CAN_SEND)
			htb_add_to_wait_tree(q, cl, diff);
	}
	// 超过500个事件
	if (net_ratelimit())
		printk(KERN_WARNING "htb: too many events !\n");
	// 返回0.1秒的延迟 
	return HZ / 10;
}

/** 
 * htb_change_class_mode - 调整类别节点的发送模式  
 *  
 * 这个函数应该是在正常情况下唯一的改变class发送模式的方法。R
 * outine会更新self feed list连接关系，改变class的模式或将class添加到合适的wait event队列中。
 *  新模式应该与旧模式不一样，而且如果改变后的模式不是HTB_CAN_SEND（看htb_add_to_wait_tree），那么cl->pq_key必须有效
 */  
static void
htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, long *diff)
{	
	// 根据变化值计算新模式
	enum htb_cmode new_mode = htb_class_mode(cl, diff);
	// 模式没变, 返回
	if (new_mode == cl->cmode)
		return;
	// cl->prio_activity非0表示是活动的节点, 需要停止后再更新模式 
	if (cl->prio_activity) {	/* not necessary: speed optimization */
		// 如原来的模式为可发送数据, 先停该节点
		if (cl->cmode != HTB_CANT_SEND)
			htb_deactivate_prios(q, cl);
		// 更新模式
		cl->cmode = new_mode;
		// 如果新模式不是禁止发送, 重新激活节点 
		if (new_mode != HTB_CANT_SEND)
			htb_activate_prios(q, cl);
	} else
		// 非活动类别节点, 直接更新模式值
		cl->cmode = new_mode;
}

/** 
 * htb_class_mode - 计算并返回类节点的模式 
 * 
 * 该函数根据cl->tc+diff（tc为检查时间点）计算class的模式。如果模式不是HTB_CAN_SEND，那么cl->pq_key更新为现在时间和class改变状态时间的差
 * class模式不是简单地改变 cl->{c,}tokens == 0，而是滞后地改为0..-cl->{c,}的缓存范围
 * 这意味着限制单位时间内模式改变的次数，速度的增加大概是1/6
 */
static inline enum htb_cmode
htb_class_mode(struct htb_class *cl, long *diff)
{
	long toks;
	/* 计算类别的Ceil令牌，tokens表示当前令牌数，ctokens表示峰值令牌数
	 * htb_lowater():如果cmode是HTB_CANT_SEND,返回0，否则返回 -cl->cbuffer
     * 这里ctokens是租借模式下令牌数，经过一段时间后令牌数就会进行补充。
     * 待补充后仍然小于低水位线，则状态变为HTB_CANT_SEND（不能进行发送），
     * 这里htb_lowater低水位线根据当前类的模式不同而不同，如果当前类模式
     * 为HTB_CANT_SEND，则低水位线的值为-cl->cbuffer，也
     * 就是租借模式下单包最大可传达数据所需要的ticket，其它模块下低水位线的值为0
     */
	if ((toks = (cl->ctokens + *diff)) < htb_lowater(cl)) {
		//返回还需要多少令牌
		*diff = -toks;
		// 如果令牌小于低限, 模式为不可发送
		return HTB_CANT_SEND;
	}
	/* 计算类别的普通令牌
	 * 如果令牌大于高限, 模式为可发送
	 * htb_hiwater():如果cmode是HTB_CAN_SEND，返回-cl->buffer，否则0
	 * 这里tokens是非租借模式下令牌数，经过一段时间补充后，如果高于高水位线，则状态变为HTB_CAN_SEND（可以发送）
	if ((toks = (cl->tokens + *diff)) >= htb_hiwater(cl))
		return HTB_CAN_SEND;
	// 否则模式为可借，返回还需要多少令牌 
	*diff = -toks;
	return HTB_MAY_BORROW;
}

/* 从指定层次和优先级的RB数节点中取数据包
 * 只有在确定该level该优先级可以active时才调用该函数
 */
static struct sk_buff *htb_dequeue_tree(struct htb_sched *q, int prio,
					int level)
{
	struct sk_buff *skb = NULL;
	//cl用于循环中做temp，start是记录首个循环的节点，用来结束循环
	struct htb_class *cl, *start;
	/* look initial class up in the row 
	 * 根据层次和优先权值查找起始类别节点
	 * 找到该level 该priority下的一个leafclass
	 * 如果这个节点是叶子节点，那么它必然是green的
	 * 如果这个节点是inner class，那么它是green的，就会找它的子孙叶子节点，而这个叶子节点必然是yellow的，
	 * 该inner class可以向它的子孙叶子节点“借”出带宽。
     */
	start = cl = htb_lookup_leaf(q->row[level] + prio, prio,
				     q->ptr[level] + prio,
				     q->last_ptr_id[level] + prio);

	do {
next:
		BUG_TRAP(cl);
		// 如果类别为空, 返回数据包为空
		if (!cl)
			return NULL;

		/* 
		 * class队列可以是空的---如果叶子节点的qdisc在入队时就drop掉数据包
		 * 或者如果someone在上一次dequeue时候对叶子节点使用graft操作（）
		 * 如果遇到class队列为空，则deactivate或skip
		 * 如果队列长度为0, 队列空的情况, 可能性较小  
		 */
		if (unlikely(cl->un.leaf.q->q.qlen == 0)) {
			struct htb_class *next;
			// 该类别队列中没数据包了, 停止该类别结构 
			htb_deactivate(q, cl);

			/* row/level might become empty */
			// 掩码该位为0， 表示该层该prio的rb树为空, 没有数据提供树， 返回数据包为空
			// 即该level的self feed的该prio为空
			if ((q->row_mask[level] & (1 << prio)) == 0)
				return NULL;
			// 否则重新查找该层该优先权的RB树节点class，同层级同优先级可以有多个class
			next = htb_lookup_leaf(q->row[level] + prio,
					       prio, q->ptr[level] + prio,
					       q->last_ptr_id[level] + prio);
			// 从新找到的这个类别结构cl开始循环, 找队列非空的节点
			if (cl == start)	/* fix start if we just deleted it */
				start = next;
			cl = next;
			// 这个goto形成了大循环中的小循环, 找队列长度非空的类别节点
			goto next;
		}
		// 以下是队列长度非空的情况, 运行该类别结构的内部流控节点的出队操作,
		// 这主要看该节点使用那种流控算法了, 如tbf之类就可以实现流量限制
		skb = cl->un.leaf.q->dequeue(cl->un.leaf.q);
		// 取得数据包, 中断循环准备返回
		if (likely(skb != NULL))
			break;
		// 没取得数据包, 打印警告信息, 该信息在循环中只打印一次 
		if (!cl->warned) {
			printk(KERN_WARNING
			       "htb: class %X isn't work conserving ?!\n",
			       cl->classid);
			// 作为已经打印了警告信息的标志
			cl->warned = 1;
		}
		// 取到空包计数增加, 表示从非工作类别中取数据包的异常情况次数
		q->nwc_hit++;
		/* 更新到下一个rb树节点，即查找下一个该层级该优先级的节点
         * 如果现在level!=0，就说明进行dequeue_tree操作的是个inner class，那么cl就是这个inner class的子孙叶子节点，
         * 所以传入的是cl父节点的inner class所在的rb数指针
         * level=0则就是叶子节点，传入的是叶子节点所在rb树的指针
         */
		htb_next_rb_node((level ? cl->parent->un.inner.ptr : q->
				  ptr[0]) + prio);
		// 继续查找该层该优先权另一个class的RB树中找叶子类别节点, 循环
		cl = htb_lookup_leaf(q->row[level] + prio, prio,
				     q->ptr[level] + prio,
				     q->last_ptr_id[level] + prio);

	} while (cl != start);
	// 找到数据包的情况, 可能性很大
	if (likely(skb != NULL)) {
		//deficit[level] 扣掉该包的byte数
		// 计算赤字deficit, 减数据包长度, 而deficit是初始化为0的
		//当出队一个数据包时,类对应的deficit[level]扣减包的byte数,
		//当deficit[level]<0时说明该类已经发送了quantum.于是虽然再次给deficit[level]加了quantum,
		//但是htb_next_rb_node((level ? cl->parent->un.inner.ptr : q->ptr[0]) + prio)已经将该
		//层该优先级的出包类指针指向下一个类了.下发出包,将会出另一个类.
		if ((cl->un.leaf.deficit[level] -= skb->len) < 0) {
			// 如果该类别节点的赤字为负, 增加一个定额量, 缺省是物理网卡的队列长度
			cl->un.leaf.deficit[level] += cl->un.leaf.quantum;
			//当deficit[level]<0时说明该类已经发送了quantum.需要发送同层级同优先级的下一个类了.
			//同上，更新到下一个rb树节点，即查找下一个该层级该优先级的节点
			htb_next_rb_node((level ? cl->parent->un.inner.ptr : q->
					  ptr[0]) + prio);
		}
		// 如果赤字为正就不会进行RB数节点的更换 
		/* this used to be after charge_class but this constelation
		   gives us slightly better performance */
		// 如果队列空了, 停止该类别 
		if (!cl->un.leaf.q->q.qlen)
			htb_deactivate(q, cl);
		// 更新令牌.
		// 处理该流控节点以及其所有父节点的令牌情况, 调整该类别的模式cmode 
		htb_charge_class(q, cl, level, skb->len);
	}
	return skb;
}

//当htb_dequeue循环结束也没取到数据包, 队列长度非0却不能取出数据包, 表示流控节点阻塞  
// 进行阻塞处理, 调整HTB定时器, 最大延迟5秒 
// HTB延迟处理
static void htb_delay_by(struct Qdisc *sch, long delay)
{
	struct htb_sched *q = qdisc_priv(sch);
	// 延迟至少是1个时间片, 1/HZ秒  
	if (delay <= 0)
		delay = 1;
	// 延迟最大是5秒
	if (unlikely(delay > 5 * HZ)) {
		if (net_ratelimit())
			printk(KERN_INFO "HTB delay %ld > 5sec\n", delay);
		delay = 5 * HZ;
	}
	/* why don't use jiffies here ? because expires can be in past */
	// 修改定时器 
	mod_timer(&q->timer, q->jiffies + delay);
	// 设置阻塞标志
	sch->flags |= TCQ_F_THROTTLED;
	// 流量溢出统计增加 
	sch->qstats.overlimits++;
}