HTB分层令牌桶排队规则分析--iproute-tc分析

 之前通过《默认FIFO_FAST出口排队规则分析》、《ingress入口排队规则分析》分析，已经对排队规则的基础架框有了简单的了解。那两种排队规则都是无类的，这里选出可以分类的HTB排队规则进行分析。


 "https://img-blog.csdn.net/20141214040026609?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbGl1amlhbmZlbmcxOTg0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />
 当前实例分析的基本对象关联图

 一、当前分析的配置范例
 //在eth0设备上创建一个根HTB排队规则，当未匹配任何过滤器时，将报文放入ID为20
 //的分类中
 tc qdisc add dev eth0 root handle 1: htb default 20

 //在根HTB排队规则上创建ID为1的分类
 tc class add dev eth0 parent 1: classid 1:1 htb rate 6mbit burst 15k

 //在ID为1的分类上分别创建两个ID为10、ID为20的分类
 tc class add dev eth0 parent 1:1 classid 1:10 htb rate 5mbit burst 15k
 tc class add dev eth0 parent 1:1 classid 1:20 htb rate 3mbit ceil 6mbit burst 15k

 //创建两个U32分类器
 U32="tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32"
 $U32 match ip dport 80 0xffff flowid 1:10
 $U32 match ip sport 25 0xffff flowid 1:20

 二、创建根HTB排队规则
 1、用户层分析
 //初始化，获取每纳秒对应多少TICKET
 tc_core_init();
 fp = fopen("/proc/net/psched", "r");
 fscanf(fp, "%08x%08x%08x", &t2us, &us2t, &clock_res);
 fclose(fp);

 if (clock_res == 1000000000)
 t2us = us2t;

 clock_factor  = (double)clock_res / TIME_UNITS_PER_SEC;
 tick_in_usec = (double)t2us / us2t * clock_factor;

 //创建一个ROUTE类型的netlink套接口
 rtnl_open(&rth, 0)
 rtnl_open_byproto(rth, subscriptions, NETLINK_ROUTE);
 rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol);
 setsockopt(rth->fd,SOL_SOCKET,SO_SNDBUF,&sndbuf,sizeof(sndbuf))
 setsockopt(rth->fd,SOL_SOCKET,SO_RCVBUF,&rcvbuf,sizeof(rcvbuf))
 rth->local.nl_family = AF_NETLINK;
 rth->local.nl_groups = subscriptions;    //0
 bind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local))
 rth->seq = time(NULL);

 do_cmd(argc-1, argv+1);
 if (matches(*argv, "qdisc") == 0)
 //执行设置排队规则的命令
 do_qdisc(argc-1, argv+1);
 if (matches(*argv, "add") == 0)
 tc_qdisc_modify(RTM_NEWQDISC, NLM_F_EXCL|NLM_F_CREATE,
 argc-1, argv+1);
 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg));
 req.n.nlmsg_flags = NLM_F_REQUEST|flags;
 req.n.nlmsg_type = cmd; //RTM_NEWQDISC
 req.t.tcm_family = AF_UNSPEC;

 while (argc > 0)
 if (strcmp(*argv, "dev") == 0)
 NEXT_ARG();
 strncpy(d, *argv, sizeof(d)-1);     //eth0
 else if (strcmp(*argv, "root") == 0)
 req.t.tcm_parent = TC_H_ROOT;
 else if (strcmp(*argv, "handle") == 0)
 NEXT_ARG();
 get_qdisc_handle(&handle, *argv)
 req.t.tcm_handle = handle;  //0x00010000
 else
 //如果有/usr/lib/tc/htb.so动态库中则从中获
 //取htb_qdisc_util符号结构，否则检测当前tc
 //程序是否有htb_qdisc_util符号结构则从中获取
 //，否则返回q 为空。
 q = get_qdisc_kind(k);

 //在消息尾部追加KIND属性
 //rta->rta_type = type;  //TCA_KIND
 //rta->rta_len = len;
 //属性值为 “htb”
 addattr_l(&req.n, sizeof(req), TCA_KIND, k, strlen(k)+1);

 //当前q为htb_qdisc_util，使用其中parse_qopt回调进行其它参数
 //解析，当前回调函数为htb_parse_opt
 q->parse_qopt(q, argc, argv, &req.n)
 htb_parse_opt
 //默认参数
 opt.rate2quantum = 10;
 opt.version = 3;

 while (argc > 0)
 if (matches(*argv, "default") == 0)
 NEXT_ARG();
 get_u32(&opt.defcls, *argv, 16) //20

 //添加扩展属性OPTIONS，标记后面都是htb的选项
 addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);

 //添加扩展属性HTB_INIT
 addattr_l(n, 2024, TCA_HTB_INIT, &opt,
 NLMSG_ALIGN(sizeof(opt)));

 //根据接口名获取接口索引
 if (d[0])
 idx = ll_name_to_index(d)
 req.t.tcm_ifindex = idx;

 //给内核发送该netlink消息
 rtnl_talk(&rth, &req.n, 0, 0, NULL)

 rtnl_close(&rth);

 2、内核层分析
 用户侧发出RTM_NEWQDISC套接口消息后，在内核侧对应的处理回调函数为tc_modify_qdisc，该函数是在pktsched_init中初始化的。

 tc_modify_qdisc
 tcm = NLMSG_DATA(n);
 clid = tcm->tcm_parent;  //当前用户侧传入值为  TC_H_ROOT

 //根据设备索引获取设备对象，上面用户侧传入设备名为eth0
 dev = __dev_get_by_index(tcm->tcm_ifindex)

 if (clid)
 if (clid != TC_H_ROOT)
 //当前为根排队规则，不走此流程
 else
 q = dev->qdisc_sleeping;

 //当前设备存储的是默认的排队规则，则忽略
 if (q && q->handle == 0)
 q = NULL;

 if (!q || !tcm->tcm_handle || q->handle != tcm->tcm_handle)
 if (tcm->tcm_handle) //用户侧传入为特定的0x1
 //当前设备的qdisc_list排队规则链表中不含有此规则，进行创建
 if ((q = qdisc_lookup(dev, tcm->tcm_handle)) == NULL)
 goto create_n_graft;

 create_n_graft:

 //创建排队规则
 q = qdisc_create(dev, tcm->tcm_handle, tca, &err);
 //从已经注册到qdisc_base链表中获取匹配排队规则，当前htb已经注册
 //，则ops = htb_qdisc_ops
 ops = qdisc_lookup_ops(kind);

 sch = qdisc_alloc(dev, ops);
 INIT_LIST_HEAD(&sch->list);
 skb_queue_head_init(&sch->q);    //初始化规则中的SKB队列
 sch->ops = ops;  //htb_qdisc_ops
 sch->enqueue = ops->enqueue;  //ingress_enqueue
 sch->dequeue = ops->dequeue;  //ingress_dequeue
 sch->dev = dev;              //eth0设备对象
 dev_hold(dev);              //设备对象引用递增
 sch->stats_lock = &dev->queue_lock;
 atomic_set(&sch->refcnt, 1);

 sch->handle = handle;                //0x00010000

 //使用排队规则中的初始化回调进行初始化，当前htb的回调函数为
 //htb_init
 ops->init(sch, tca[TCA_OPTIONS-1])
 htb_init(tca[TCA_OPTIONS-1])
 htb_sched *q = qdisc_priv(sch);

 //HTB_INIT属性
 gopt = RTA_DATA(tb[TCA_HTB_INIT - 1]);

 //初始化根类链表
 INIT_LIST_HEAD(&q->root);

 for (i = 0; i < HTB_HSIZE; i++)
 INIT_HLIST_HEAD(q->hash + i);

 for (i = 0; i < TC_HTB_NUMPRIO; i++)
 INIT_LIST_HEAD(q->drops + i);

 init_timer(&q->timer);
 skb_queue_head_init(&q->direct_queue);
 q->direct_qlen = sch->dev->tx_queue_len;
 if (q->direct_qlen < 2)
 q->direct_qlen = 2;
 q->timer.function = htb_timer;
 q->timer.data = (unsigned long)sch;

 //启动了速率定时器，每秒触发一下，其中htb_rate_timer函数在每秒
 //触发会都会根据q->recmp_bucket索引来获取q->hash中的一个
 //HASH链表，对该HASH链表所有条目进行速率计算，之后递增
 //q->recmp_bucket索引，准备下一秒后对下一个HASH链表进行速
 //率计算。当前计算方法也比较简单
 //#define RT_GEN(D,R) R+=D-(R/HTB_EWMAC);D=0
 //RT_GEN(cl->sum_bytes, cl->rate_bytes);
 //RT_GEN(cl->sum_packets, cl->rate_packets);
 init_timer(&q->rttim);
 q->rttim.function = htb_rate_timer;
 q->rttim.data = (unsigned long)sch;
 q->rttim.expires = jiffies + HZ;
 add_timer(&q->rttim);

 if ((q->rate2quantum = gopt->rate2quantum) < 1)    //用户默认值为10
 q->rate2quantum = 1;

 q->defcls = gopt->defcls;                 //20

 //将当前排队规则加入到设备的qdisc_list链表中
 qdisc_lock_tree(dev);
 list_add_tail(&sch->list, &dev->qdisc_list);
 qdisc_unlock_tree(dev);

 //排队规则嫁接处理
 qdisc_graft(dev, p, clid, q, &old_q);
 if (parent == NULL) //当前为根排队规则，未有父类
 dev_graft_qdisc(dev, new);
 //设备激活的情况下，先去激活
 if (dev->flags & IFF_UP)
 dev_deactivate(dev);

 oqdisc = dev->qdisc_sleeping;

 //假设当前仅使用的默认的fifo_fast排队规则，则当前这个老的排队规则
 //已经存在，需要将老的排队规则进行复位，这里fifo_fast的reset回调函
 //数为pfifo_fast_reset
 if (oqdisc && atomic_read(&oqdisc->refcnt) <= 1)
 qdisc_reset(oqdisc);
 pfifo_fast_reset
 //丢弃每个频道队列中的所有报文
 for (prio = 0; prio < PFIFO_FAST_BANDS; prio++)
 __qdisc_reset_queue(qdisc, list + prio);

 qdisc->qstats.backlog = 0;
 qdisc->q.qlen = 0;

 //将新建的排队规则设置到qdisc_sleeping，qdisc的当前规则指向空规则
 //noop_qdisc
 dev->qdisc_sleeping = qdisc;
 dev->qdisc = &noop_qdisc;

 if (dev->flags & IFF_UP)
 //设备激活
 dev_activate(dev);
 if (dev->qdisc_sleeping == &noop_qdisc)
 //当前已经有根排队规则，不走此流程

 //没有载波则直接返回
 if (!netif_carrier_ok(dev))
 return;

 //当前使用的排队规则设置为已经选择的根排队规则
 //启动看门狗。
 rcu_assign_pointer(dev->qdisc, dev->qdisc_sleeping);
 if (dev->qdisc != &noqueue_qdisc)
 dev->trans_start = jiffies;
 dev_watchdog_up(dev);

 //发送netlink消息，告知添加成功，并且老的已经删除
 qdisc_notify(skb, n, clid, old_q, q);

 //将老的排队规则去除
 qdisc_destroy(old_q);
 //属于内建规则，或者还有其它模块引用，则不进行去除。
 if (qdisc->flags & TCQ_F_BUILTIN || !atomic_dec_and_test(&qdisc->refcnt))
 return;

 //从设备的排队规则链表中去除
 list_del(&qdisc->list);

 //如果老的排队规则有reset、destroy回调，则进行处理
 if (ops->reset)
 ops->reset(qdisc);
 if (ops->destroy)
 ops->destroy(qdisc);

 //资源销毁
 module_put(ops->owner);
 dev_put(qdisc->dev);
 call_rcu(&qdisc->q_rcu, __qdisc_destroy);

 三、创建ID为1的分类
 1、用户层分析
 //初始化，获取每纳秒对应多少TICKET
 tc_core_init();
 fp = fopen("/proc/net/psched", "r");
 fscanf(fp, "%08x%08x%08x", &t2us, &us2t, &clock_res);
 fclose(fp);

 if (clock_res == 1000000000)
 t2us = us2t;

 clock_factor  = (double)clock_res / TIME_UNITS_PER_SEC;
 tick_in_usec = (double)t2us / us2t * clock_factor;

 //创建一个ROUTE类型的netlink套接口
 rtnl_open(&rth, 0)
 rtnl_open_byproto(rth, subscriptions, NETLINK_ROUTE);
 rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol);
 setsockopt(rth->fd,SOL_SOCKET,SO_SNDBUF,&sndbuf,sizeof(sndbuf))
 setsockopt(rth->fd,SOL_SOCKET,SO_RCVBUF,&rcvbuf,sizeof(rcvbuf))
 rth->local.nl_family = AF_NETLINK;
 rth->local.nl_groups = subscriptions;    //0
 bind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local))
 rth->seq = time(NULL);

 do_cmd(argc-1, argv+1);
 if (matches(*argv, "class") == 0)
 do_class(argc-1, argv+1);
 //创建新的类
 tc_class_modify(RTM_NEWTCLASS, NLM_F_EXCL|NLM_F_CREATE, argc-1,
 argv+1);
 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg));
 req.n.nlmsg_flags = NLM_F_REQUEST|flags;
 req.n.nlmsg_type = cmd;     //RTM_NEWTCLASS
 req.t.tcm_family = AF_UNSPEC;

 while (argc > 0)
 if (strcmp(*argv, "dev") == 0)
 NEXT_ARG();
 strncpy(d, *argv, sizeof(d)-1);         //eth0
 else if (strcmp(*argv, "parent") == 0)
 NEXT_ARG();
 get_tc_classid(&handle, *argv)
 req.t.tcm_parent = handle;          //0x00010000
 else if (strcmp(*argv, "classid") == 0)
 NEXT_ARG();
 get_tc_classid(&handle, *argv)
 req.t.tcm_handle = handle;          //0x00010001
 else
 //如果有/usr/lib/tc/htb.so动态库中则从中获取htb_qdisc_util符
 //号结构，否则检测当前tc程序是否有htb_qdisc_util符号结构则
 //从中获取，否则返回q 为空。
 q = get_qdisc_kind(k);

 //添加KIND属性项，当前值为“htb”
 addattr_l(&req.n, sizeof(req), TCA_KIND, k, strlen(k)+1);

 //使用当前扩展排队规则的parse_copt回调去解析后续命令字符，当前
 //htb的回调为htb_parse_class_opt
 q->parse_copt(q, argc, argv, &req.n)
 htb_parse_class_opt
 mtu = 1600;

 while (argc > 0)
 if (strcmp(*argv, "rate") == 0)
 NEXT_ARG();
 get_rate64(&rate64, *argv)  //6 * 1000000 / 8
 else if (matches(*argv, "burst") == 0)
 NEXT_ARG();
 //buffer = 15 * 1024
 //cell_log = -1
 get_size_and_cell(&buffer, &cell_log, *argv)
 if (!ceil64)
 ceil64 = rate64;

 //超出32位最大值，则转换为全1？
 opt.rate.rate = (rate64 >= (1ULL << 32)) ? ~0U : rate64;
 opt.ceil.rate = (ceil64 >= (1ULL << 32)) ? ~0U : ceil64;

 //如果cbuffer为设置，则取值为当前mtu值加上最大速率下
 //每ticket单位的比特数
 if (!cbuffer)
 cbuffer = ceil64 / get_hz() + mtu;

 opt.ceil.overhead = overhead;       //0
 opt.rate.overhead = overhead;       //0

 opt.ceil.mpu = mpu; //0
 opt.rate.mpu = mpu; //0

 //计算最小速率表
 //cell_log = -1
 //mtu = 1600
 //linklayer = LINKLAYER_ETHERNET
 tc_calc_rtable(&opt.rate, rtab, cell_log, mtu, linklayer)
 //根据最大传输单元计算需要多少槽我理解是不可能每个
 //字节都有准确速率，所以划定字节范围，从多少字节到
 //多少字节的速率相同。
 if (cell_log < 0)
 cell_log = 0;
 while ((mtu >> cell_log) > 255)
 cell_log++;

 for (i=0; i<256; i++)
 //校正当前槽位的字节大小。这个算法比较简单，当前
 //链路类型为以太网，则包根据原值处理，不会影响包
 //大小。Mpu为最小包大小，如果槽位字节小于mpu，
 //则校正为mpu的值。
 sz = tc_adjust_size((i + 1) << cell_log, mpu, linklayer);

 //根据当前槽位字节大小，及用户配置的速率，计算当
 //前槽位所需ticket时间
 rtab[i] = tc_calc_xmittime(bps, sz);

 r->cell_align=-1;
 r->cell_log=cell_log;
 r->linklayer = (linklayer & TC_LINKLAYER_MASK);

 //计算单包正常速率下的传送峰值，这里通过包大小转换成所
 //需要的ticket时间
 opt.buffer = tc_calc_xmittime(rate64, buffer);

 //计算最大速率表，仅在发包速率大于最小速率后，租借模式下
 //有效。
 tc_calc_rtable(&opt.ceil, ctab, ccell_log, mtu, linklayer)

 //计算单包在租借模速率作用下，传送的峰值。
 opt.cbuffer = tc_calc_xmittime(ceil64, cbuffer);

 //添加扩展属性OPTIONS，标记后面都是htb的选项
 addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);

 //超出32位，则添加扩展属性HTB_RATE64
 //超出32位，则添加扩展属性HTB_CEIL64
 if (rate64 >= (1ULL << 32))
 addattr_l(n, 1124, TCA_HTB_RATE64, &rate64,
 sizeof(rate64));
 if (ceil64 >= (1ULL << 32))
 addattr_l(n, 1224, TCA_HTB_CEIL64, &ceil64,
 sizeof(ceil64));

 //添加扩展属性HTB_PARMS
 addattr_l(n, 2024, TCA_HTB_PARMS, &opt, sizeof(opt));

 //添加扩展属性HTB_RTAB
 addattr_l(n, 3024, TCA_HTB_RTAB, rtab, 1024);

 //添加扩展属性HTB_CTAB
 addattr_l(n, 4024, TCA_HTB_CTAB, ctab, 1024);

 //根据接口名获取接口索引
 if (d[0])
 idx = ll_name_to_index(d)
 req.t.tcm_ifindex = idx;

 //给内核发送该netlink消息
 rtnl_talk(&rth, &req.n, 0, 0, NULL)

 rtnl_close(&rth);

 2、内核层分析
 用户侧发出RTM_NEWTCLASS套接口消息后，在内核侧对应的处理回调函数为tc_ctl_tclass，该函数是在pktsched_init中初始化的。

 tc_ctl_tclass
 pid = tcm->tcm_parent            //父类ID          0x00010000
 clid = tcm->tcm_handle;          //创建类ID     0x00010001
 qid = TC_H_MAJ(clid);           //队列ID          0x00010000

 //eth0设备对象
 dev = __dev_get_by_index(tcm->tcm_ifindex))

 if (pid != TC_H_ROOT)
 pid = TC_H_MAKE(qid, pid);  //0x00010000

 //从当前设备的qdisc_list链表中找到已经创建的排队规则，当前q为之前创建的HTB
 q = qdisc_lookup(dev, qid)

 //HTB的回调组为 cops = htb_class_ops
 cops = q->ops->cl_ops;

 clid = TC_H_MAKE(qid, clid);        //0x00010001

 //get的回调函数为htb_get
 cl = cops->get(q, clid);
 htb_get
 htb_class *cl = htb_find(classid, sch);
 //使用类ID做HASH KEY在当前队列的HASH链表中查找已经创建的类
 hlist_for_each_entry(cl, p, q->hash + htb_hash(handle), hlist)
 if (cl->classid == handle)
 return cl;
 return NULL;

 //如果找到则增加引用计数
 if (cl)
 cl->refcnt++;
 return (unsigned long)cl;

 //当前环境还没有该类存在，进行新类的属性设置
 new_cl = cl;
 //当前回调为 htb_change_class
 cops->change(q, clid, pid, tca, &new_cl);/
 htb_change_class
 //opt指向扩展属性基值索引，后续rtattr_parse_nested进行属性查找都从该
 //基值索引之外进行查找。
 rtattr *opt = tca[TCA_OPTIONS - 1];

 //查看枚举定义，TCA_HTB_RTAB值是最后一个，所以rtattr_parse_nested
 //函数会把用户设置的所有扩展参数存储到临时变量tb中。
 //enum
 //{
     //  TCA_HTB_UNSPEC,
     //  TCA_HTB_PARMS,
     //  TCA_HTB_INIT,
     //  TCA_HTB_CTAB,
 //  TCA_HTB_RTAB,
     //  __TCA_HTB_MAX,
 //};
 rtattr_parse_nested(tb, TCA_HTB_RTAB, opt)

 //parentid = 0x00010000
 //以类ID为HASH KEY向当前队规则的hash链表中查找父类，当前还未存在。
 parent = htb_find(parentid, sch);
 htb_sched *q = qdisc_priv(sch);
 hlist_for_each_entry(cl, p, q->hash + htb_hash(handle), hlist)
 if (cl->classid == handle)
 return cl;
 return NULL;

 //取用户配置工具设置的HTB参数属性
 hopt = RTA_DATA(tb[TCA_HTB_PARMS - 1]);

 //将最小速率表加入到全局qdisc_rtab_list链表中
 rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB - 1]);

 //将最大速率表加入到全局qdisc_rtab_list链表中
 ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB - 1]);

 //当前为新类进行创建
 if (!cl)
 cl = kzalloc(sizeof(*cl), GFP_KERNEL)
 cl->refcnt = 1;
 INIT_LIST_HEAD(&cl->sibling);
 INIT_HLIST_NODE(&cl->hlist);
 INIT_LIST_HEAD(&cl->children);
 INIT_LIST_HEAD(&cl->un.leaf.drop_list);
 RB_CLEAR_NODE(&cl->pq_node);

 for (prio = 0; prio < TC_HTB_NUMPRIO; prio++)
 RB_CLEAR_NODE(&cl->node[prio]);

 //创建默认的pfifo排队规则，同时将该排队规则的父亲设置为当前类
 //sch->parent = parentid;        0x00010001
 new_q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, classid);

 //当前新建的类的默认排队规则设置为pfifo
 cl->un.leaf.q = new_q;

 cl->classid = classid;               //0x00010001
 cl->parent = parent;                 //NULL

 cl->tokens = hopt->buffer;            //正常速率下单包峰值
 cl->ctokens = hopt->cbuffer;          //借用速率下单包峰值
 cl->mbuffer = PSCHED_JIFFIE2US(HZ * 60);
 PSCHED_GET_TIME(cl->t_c);
 cl->cmode = HTB_CAN_SEND;     //初始时可以发送报文

 //当新建的类加入到根排队规则的hash表中
 hlist_add_head(&cl->hlist, q->hash + htb_hash(classid));

 //将新建的类加入到根排队规则的root链表中
 list_add_tail(&cl->sibling, &q->root);

 if (!cl->level)
 //在htb_init时，rate2quantum值默认为1
 //设置quantum值，该值用于在进行带宽租借时的单位量
 cl->un.leaf.quantum = rtab->rate.rate / q->rate2quantum;
 if (!hopt->quantum && cl->un.leaf.quantum < 1000)
 cl->un.leaf.quantum = 1000;
 if (!hopt->quantum && cl->un.leaf.quantum > 200000)
 cl->un.leaf.quantum = 200000;

 cl->un.leaf.prio = hopt->prio;        //0

 cl->quantum = cl->un.leaf.quantum;
 cl->prio = cl->un.leaf.prio;

 cl->buffer = hopt->buffer;                //正常速率下单包峰值
 cl->cbuffer = hopt->cbuffer;              //借用速率下单包峰值

 //设置当前类的最小、最大速率表
 cl->rate = rtab;
 cl->ceil = ctab;

 //发送netlink消息，告知添加成功
 tclass_notify(skb, n, q, new_cl, RTM_NEWTCLASS);

 四、创建ID为20的分类
 1、用户层分析
 //初始化，获取每纳秒对应多少TICKET
 tc_core_init();
 fp = fopen("/proc/net/psched", "r");
 fscanf(fp, "%08x%08x%08x", &t2us, &us2t, &clock_res);
 fclose(fp);

 if (clock_res == 1000000000)
 t2us = us2t;

 clock_factor  = (double)clock_res / TIME_UNITS_PER_SEC;
 tick_in_usec = (double)t2us / us2t * clock_factor;

 //创建一个ROUTE类型的netlink套接口
 rtnl_open(&rth, 0)
 rtnl_open_byproto(rth, subscriptions, NETLINK_ROUTE);
 rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol);
 setsockopt(rth->fd,SOL_SOCKET,SO_SNDBUF,&sndbuf,sizeof(sndbuf))
 setsockopt(rth->fd,SOL_SOCKET,SO_RCVBUF,&rcvbuf,sizeof(rcvbuf))
 rth->local.nl_family = AF_NETLINK;
 rth->local.nl_groups = subscriptions;    //0
 bind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local))
 rth->seq = time(NULL);

 do_cmd(argc-1, argv+1);
 if (matches(*argv, "class") == 0)
 do_class(argc-1, argv+1);
 //创建新的类
 tc_class_modify(RTM_NEWTCLASS, NLM_F_EXCL|NLM_F_CREATE, argc-1,
 argv+1);
 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg));
 req.n.nlmsg_flags = NLM_F_REQUEST|flags;
 req.n.nlmsg_type = cmd;     //RTM_NEWTCLASS
 req.t.tcm_family = AF_UNSPEC;

 while (argc > 0)
 if (strcmp(*argv, "dev") == 0)
 NEXT_ARG();
 strncpy(d, *argv, sizeof(d)-1);         //eth0
 else if (strcmp(*argv, "parent") == 0)
 NEXT_ARG();
 get_tc_classid(&handle, *argv)
 req.t.tcm_parent = handle;          //0x00010001
 else if (strcmp(*argv, "classid") == 0)
 NEXT_ARG();
 get_tc_classid(&handle, *argv)
 req.t.tcm_handle = handle;          //0x00010014 (0x14 = 20)
 else
 //如果有/usr/lib/tc/htb.so动态库中则从中获取htb_qdisc_util符
 //号结构，否则检测当前tc程序是否有htb_qdisc_util符号结构则
 //从中获取，否则返回q 为空。
 q = get_qdisc_kind(k);

 //添加KIND属性项，当前值为“htb”
 addattr_l(&req.n, sizeof(req), TCA_KIND, k, strlen(k)+1);

 //使用当前扩展排队规则的parse_copt回调去解析后续命令字符，当前
 //htb的回调为htb_parse_class_opt
 q->parse_copt(q, argc, argv, &req.n)
 htb_parse_class_opt
 mtu = 1600;

 while (argc > 0)
 if (strcmp(*argv, "rate") == 0)
 NEXT_ARG();
 get_rate64(&rate64, *argv)  //3 * 1000000 / 8
 else if (matches(*argv, "burst") == 0)
 NEXT_ARG();
 //buffer = 15 * 1024
 //cell_log = -1
 get_size_and_cell(&buffer, &cell_log, *argv)
 else if (strcmp(*argv, "ceil") == 0)
 NEXT_ARG();
 get_rate64(&ceil64, *argv); //6 * 1000000 / 8

 //超出32位最大值，则转换为全1？
 opt.rate.rate = (rate64 >= (1ULL << 32)) ? ~0U : rate64;
 opt.ceil.rate = (ceil64 >= (1ULL << 32)) ? ~0U : ceil64;

 //如果cbuffer为设置，则取值为当前mtu值加上最大速率下
 //每ticket单位的比特数
 if (!cbuffer)
 cbuffer = ceil64 / get_hz() + mtu;

 opt.ceil.overhead = overhead;       //0
 opt.rate.overhead = overhead;       //0

 opt.ceil.mpu = mpu; //0
 opt.rate.mpu = mpu; //0

 //计算最小速率表
 //cell_log = -1
 //mtu = 1600
 //linklayer = LINKLAYER_ETHERNET
 tc_calc_rtable(&opt.rate, rtab, cell_log, mtu, linklayer)
 //根据最大传输单元计算需要多少槽我理解是不可能每个
 //字节都有准确速率，所以划定字节范围，从多少字节到
 //多少字节的速率相同。
 if (cell_log < 0)
 cell_log = 0;
 while ((mtu >> cell_log) > 255)
 cell_log++;

 for (i=0; i<256; i++)
 //校正当前槽位的字节大小。这个算法比较简单，当前
 //链路类型为以太网，则包根据原值处理，不会影响包
 //大小。Mpu为最小包大小，如果槽位字节小于mpu，
 //则校正为mpu的值。
 sz = tc_adjust_size((i + 1) << cell_log, mpu, linklayer);

 //根据当前槽位字节大小，及用户配置的速率，计算当
 //前槽位所需ticket时间
 rtab[i] = tc_calc_xmittime(bps, sz);

 r->cell_align=-1;
 r->cell_log=cell_log;
 r->linklayer = (linklayer & TC_LINKLAYER_MASK);

 //计算单包正常速率下的传送峰值，这里通过包大小转换成所
 //需要的ticket时间
 opt.buffer = tc_calc_xmittime(rate64, buffer);

 //计算最大速率表，仅在发包速率大于最小速率后，租借模式下
 //有效。
 tc_calc_rtable(&opt.ceil, ctab, ccell_log, mtu, linklayer)

 //计算单包在租借模速率作用下，传送的峰值。
 opt.cbuffer = tc_calc_xmittime(ceil64, cbuffer);

 //添加扩展属性OPTIONS，标记后面都是htb的选项
 addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);

 //超出32位，则添加扩展属性HTB_RATE64
 //超出32位，则添加扩展属性HTB_CEIL64
 if (rate64 >= (1ULL << 32))
 addattr_l(n, 1124, TCA_HTB_RATE64, &rate64,
 sizeof(rate64));
 if (ceil64 >= (1ULL << 32))
 addattr_l(n, 1224, TCA_HTB_CEIL64, &ceil64,
 sizeof(ceil64));

 //添加扩展属性HTB_PARMS
 addattr_l(n, 2024, TCA_HTB_PARMS, &opt, sizeof(opt));

 //添加扩展属性HTB_RTAB
 addattr_l(n, 3024, TCA_HTB_RTAB, rtab, 1024);

 //添加扩展属性HTB_CTAB
 addattr_l(n, 4024, TCA_HTB_CTAB, ctab, 1024);

 //根据接口名获取接口索引
 if (d[0])
 idx = ll_name_to_index(d)
 req.t.tcm_ifindex = idx;

 //给内核发送该netlink消息
 rtnl_talk(&rth, &req.n, 0, 0, NULL)

 rtnl_close(&rth);

 2、内核层分析
 用户侧发出RTM_NEWTCLASS套接口消息后，在内核侧对应的处理回调函数为tc_ctl_tclass，该函数是在pktsched_init中初始化的。

 tc_ctl_tclass
 pid = tcm->tcm_parent            //父类ID          0x00010001
 clid = tcm->tcm_handle;          //创建类ID     0x00010014
 qid = TC_H_MAJ(clid);           //队列ID          0x00010000

 //eth0设备对象
 dev = __dev_get_by_index(tcm->tcm_ifindex))

 if (pid != TC_H_ROOT)
 pid = TC_H_MAKE(qid, pid);  //0x00010001

 //从当前设备的qdisc_list链表中找到已经创建的排队规则，当前q为之前创建的HTB
 q = qdisc_lookup(dev, qid)

 //HTB的回调组为 cops = htb_class_ops
 cops = q->ops->cl_ops;

 clid = TC_H_MAKE(qid, clid);        //0x00010014

 //get的回调函数为htb_get
 cl = cops->get(q, clid);
 htb_get
 htb_class *cl = htb_find(classid, sch);
 //使用类ID做HASH KEY在当前队列的HASH链表中查找已经创建的类
 hlist_for_each_entry(cl, p, q->hash + htb_hash(handle), hlist)
 if (cl->classid == handle)
 return cl;
 return NULL;

 //如果找到则增加引用计数
 if (cl)
 cl->refcnt++;
 return (unsigned long)cl;

 //当前环境还没有该类存在，进行新类的属性设置
 new_cl = cl;
 //当前回调为 htb_change_class
 cops->change(q, clid, pid, tca, &new_cl);/
 htb_change_class
 //opt指向扩展属性基值索引，后续rtattr_parse_nested进行属性查找都从该
 //基值索引之外进行查找。
 rtattr *opt = tca[TCA_OPTIONS - 1];

 //查看枚举定义，TCA_HTB_RTAB值是最后一个，所以rtattr_parse_nested
 //函数会把用户设置的所有扩展参数存储到临时变量tb中。
 //enum
 //{
     //  TCA_HTB_UNSPEC,
     //  TCA_HTB_PARMS,
     //  TCA_HTB_INIT,
     //  TCA_HTB_CTAB,
 //  TCA_HTB_RTAB,
     //  __TCA_HTB_MAX,
 //};
 rtattr_parse_nested(tb, TCA_HTB_RTAB, opt)

 //parentid = 0x00010001
 //以类ID为HASH KEY向当前队规则的hash链表中查找父类，之前已经创建。
 parent = htb_find(parentid, sch);
 htb_sched *q = qdisc_priv(sch);
 hlist_for_each_entry(cl, p, q->hash + htb_hash(handle), hlist)
 if (cl->classid == handle)
 return cl;
 return NULL;

 //取用户配置工具设置的HTB参数属性
 hopt = RTA_DATA(tb[TCA_HTB_PARMS - 1]);

 //将最小速率表加入到全局qdisc_rtab_list链表中
 rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB - 1]);

 //将最大速率表加入到全局qdisc_rtab_list链表中
 ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB - 1]);

 //当前为新类进行创建
 if (!cl)
 cl = kzalloc(sizeof(*cl), GFP_KERNEL)
 cl->refcnt = 1;
 INIT_LIST_HEAD(&cl->sibling);
 INIT_HLIST_NODE(&cl->hlist);
 INIT_LIST_HEAD(&cl->children);
 INIT_LIST_HEAD(&cl->un.leaf.drop_list);
 RB_CLEAR_NODE(&cl->pq_node);

 for (prio = 0; prio < TC_HTB_NUMPRIO; prio++)
 RB_CLEAR_NODE(&cl->node[prio]);

 //创建默认的pfifo排队规则，同时将该排队规则的父亲设置为当前类
 //sch->parent = parentid;        0x00010014
 new_q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, classid);

 //当前存在父类，该父类还未有孩子节点
 if (parent && !parent->level)
 //保留当前父类中排队规则的队列长度，在HTB队列机制仅叶子类
 //含有队列，所以当父类有孩子类后，父类中的队列就要删除。
 qlen = parent->un.leaf.q->q.qlen;

 //调用父类中排队规则的reset回调，当前父类的排队规则为默认的
 //pfifo，则回调为qdisc_reset_queue
 qdisc_reset(parent->un.leaf.q);
 ops = qdisc->ops;
 ops->reset(qdisc);
 //该函数的实现仅仅是删除队列中所有skb报文
 qdisc_reset_queue

 //通知父排队规则，队列长度减少。
 qdisc_tree_decrease_qlen(parent->un.leaf.q, qlen);
 while ((parentid = sch->parent))
 //当前排队规则为父类的pfifo规则，其中parent为父类
 //的ID，TC_H_MAJ(parentid)对应的就是父类所在的排
 //队规则，当前父类所在的排队规则即为最早创建的根
 //排队规则HTB。
 sch = __qdisc_lookup(sch->dev, TC_H_MAJ(parentid));

 cops = sch->ops->cl_ops;

 //htb_get
 //在排队规则中获取指定ID的类对象，并增加引用计数
 cl = cops->get(sch, parentid);
 htb_get(sch, parentid)

 //htb_qlen_notify
 cops->qlen_notify(sch, cl);
 htb_qlen_notify(sch, cl)
 //如果当前父类中排队规则的队列长度为0,则进行
 //去激活
 if (cl->un.leaf.q->q.qlen == 0)
 htb_deactivate(qdisc_priv(sch), cl);
 htb_deactivate_prios(q, cl);
 mask = cl->prio_activity;

 while (cl->cmode ==
 HTB_MAY_BORROW
 && p && mask)
 //当前还未有激活项，不处理

 if (cl->cmode == HTB_CAN_SEND
 && mask)
 //当前还未有激活项，不处理

 cl->prio_activity = 0;
 list_del_init(&cl->un.leaf.drop_list);

 //htb_put
 //减小类引用计数，如果没有其它对象引用该类，则调用
 //htb_destroy_class进行类的销毁
 cops->put(sch, cl);
 htb_put(sch, cl);

 //子排队规则中队列长度减少，则父排队规则中的队列长度
 //相应减少。
 sch->q.qlen -= n;

 //销毁父类中排队规则，当前父类的排队规则为pfifo类型
 qdisc_destroy(parent->un.leaf.q);
 list_del(&qdisc->list);

 //qdisc_reset_queue
 ops->reset(qdisc);
 //删除队列中skb链表
 qdisc_reset_queue

 //递减相关对象引用计数，并释放排队规则占用的分配内存块
 module_put(ops->owner);
 dev_put(qdisc->dev);
 call_rcu(&qdisc->q_rcu, __qdisc_destroy);

 //父类中还有未激活项则去激活
 if (parent->prio_activity)
 htb_deactivate(q, parent);

 //根类等级深度为最大值
 parent->level = TC_HTB_MAXDEPTH) - 1;    //7

 memset(&parent->un.inner, 0, sizeof(parent->un.inner));

 //当前新建的类的默认排队规则设置为pfifo
 cl->un.leaf.q = new_q;

 cl->classid = classid;               //0x00010014
 cl->parent = parent;                 //指向当前ID为1:1的父类

 cl->tokens = hopt->buffer;            //正常速率下单包峰值
 cl->ctokens = hopt->cbuffer;          //借用速率下单包峰值
 cl->mbuffer = PSCHED_JIFFIE2US(HZ * 60);
 PSCHED_GET_TIME(cl->t_c);
 cl->cmode = HTB_CAN_SEND;     //初始时可以发送报文

 //当新建的类加入到根排队规则的hash表中
 hlist_add_head(&cl->hlist, q->hash + htb_hash(classid));

 //将新建的类关联到当前父类上
 list_add_tail(&cl->sibling, &parent->children);

 if (!cl->level)
 //在htb_init时，rate2quantum值默认为1
 //设置quantum值，该值用于在进行带宽租借时的单位量
 cl->un.leaf.quantum = rtab->rate.rate / q->rate2quantum;
 if (!hopt->quantum && cl->un.leaf.quantum < 1000)
 cl->un.leaf.quantum = 1000;
 if (!hopt->quantum && cl->un.leaf.quantum > 200000)
 cl->un.leaf.quantum = 200000;

 cl->un.leaf.prio = hopt->prio;        //0

 cl->quantum = cl->un.leaf.quantum;
 cl->prio = cl->un.leaf.prio;

 cl->buffer = hopt->buffer;                //正常速率下单包峰值
 cl->cbuffer = hopt->cbuffer;              //借用速率下单包峰值

 //设置当前类的最小、最大速率表
 cl->rate = rtab;
 cl->ceil = ctab;

 //发送netlink消息，告知添加成功
 tclass_notify(skb, n, q, new_cl, RTM_NEWTCLASS);

 五、创建一个U32分类器
 1、用户层分析
 //初始化，获取每纳秒对应多少TICKET
 tc_core_init();
 fp = fopen("/proc/net/psched", "r");
 fscanf(fp, "%08x%08x%08x", &t2us, &us2t, &clock_res);
 fclose(fp);

 if (clock_res == 1000000000)
 t2us = us2t;

 clock_factor  = (double)clock_res / TIME_UNITS_PER_SEC;
 tick_in_usec = (double)t2us / us2t * clock_factor;

 //创建一个ROUTE类型的netlink套接口
 rtnl_open(&rth, 0)
 rtnl_open_byproto(rth, subscriptions, NETLINK_ROUTE);
 rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol);
 setsockopt(rth->fd,SOL_SOCKET,SO_SNDBUF,&sndbuf,sizeof(sndbuf))
 setsockopt(rth->fd,SOL_SOCKET,SO_RCVBUF,&rcvbuf,sizeof(rcvbuf))
 rth->local.nl_family = AF_NETLINK;
 rth->local.nl_groups = subscriptions;    //0
 bind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local))
 rth->seq = time(NULL);

 do_cmd(argc-1, argv+1);
 if (matches(*argv, "filter") == 0)
 do_filter(argc-1, argv+1);
 tc_filter_modify(RTM_NEWTFILTER, NLM_F_EXCL|NLM_F_CREATE,
 argc-1, argv+1);
 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg));
 req.n.nlmsg_flags = NLM_F_REQUEST|flags;
 req.n.nlmsg_type = cmd;     //RTM_NEWTFILTER
 req.t.tcm_family = AF_UNSPEC;

 while (argc > 0)
 if (strcmp(*argv, "dev") == 0)
 NEXT_ARG();
 strncpy(d, *argv, sizeof(d)-1);     //eth0
 else if (matches(*argv, "protocol") == 0)
 NEXT_ARG();
 ll_proto_a2n(&id, *argv)
 protocol = id;                  //ETH_P_IP
 else if (strcmp(*argv, "parent") == 0)
 NEXT_ARG();
 get_tc_classid(&handle, *argv)
 req.t.tcm_parent = handle;      //0x00010000
 else if (matches(*argv, "priority") == 0)
 NEXT_ARG();
 get_u32(&prio, *argv, 0)            //1
 Else
 //如果有/usr/lib/tc/f_u32.so动态库中则从中获取u32_filter_util符  //号结构，否则检测当前tc程序是否有u32_filter_util符号结构则
 //从中获取，否则返回q 为空。
 q = get_filter_kind(k);

 //prio = 1，左移到前两个字节
 //protocol = ETH_P_IP，在低两个字节
 req.t.tcm_info = TC_H_MAKE(prio<<16, protocol);

 //增加KIND扩展属性，值为u32
 addattr_l(&req.n, sizeof(req), TCA_KIND, k, strlen(k)+1);

 //使用u32扩展过滤器解析后续规则，当前回调为u32_parse_opt
 q->parse_fopt(q, fhandle, argc, argv, &req.n)
 u32_parse_opt
 //添加OPTIONS扩展属性，标识后续都属于u32的扩展项
 addattr_l(n, MAX_MSG, TCA_OPTIONS, NULL, 0);

 while (argc > 0)
 if (matches(*argv, "match") == 0)
 NEXT_ARG();
 parse_selector(&argc, &argv, &sel.sel, n)
 else if (matches(*argv, "ip") == 0)
 NEXT_ARG();
 parse_ip(&argc, &argv, sel);
 else if (strcmp(*argv, "dport") == 0)
 NEXT_ARG();

 //sel->keys[hwm].val = key; htos(80)
 //sel->keys[hwm].mask = mask;全1
 //sel->keys[hwm].off = off; 20
 //sel->keys[hwm].offmask=offmask; 0
 //sel->nkeys++;              1
 parse_u16(&argc, &argv, sel, 22,0);

 sel_ok++;
 else if (strcmp(*argv, "flowid") == 0)
 NEXT_ARG();
 //0x0001000A（0xA=10）
 get_tc_classid(&handle, *argv)

 //添加U32_CLASSID扩展属性
 addattr_l(n, MAX_MSG, TCA_U32_CLASSID, &handle, 4);
 //添加终止标记TC_U32_TERMINAL，内核代码会根据
 //此标记判断当前处理完成。
 sel.sel.flags |= TC_U32_TERMINAL;

 if (sel_ok)
 //添加U32_SEL扩展属性
 addattr_l(n, MAX_MSG, TCA_U32_SEL, &sel,
 sizeof(sel.sel)+sel.sel.nkeys*sizeof(struct tc_u32_key));

 //根据接口名获取接口索引
 if (d[0])
 idx = ll_name_to_index(d)
 req.t.tcm_ifindex = idx;

 //给内核发送该netlink消息
 rtnl_talk(&rth, &req.n, 0, 0, NULL)

 rtnl_close(&rth);

 2、内核层分析
 用户侧发出RTM_NEWTFILTER套接口消息后，在内核侧对应的处理回调函数为tc_ctl_tfilter，该函数是在tc_filter_init中初始化的。

 protocol = TC_H_MIN(t->tcm_info);    //ETH_P_IP
 prio = TC_H_MAJ(t->tcm_info);        //1
 nprio = prio;
 parent = t->tcm_parent;              //0x00010000

 dev = __dev_get_by_index(t->tcm_ifindex) //eth0设备对象

 //从设备的qdisc_list列表中查找排队规则，之前HTB排队规则已经加入到链表中，所以
 //这里的q就等于HTB排队规则。
 q = qdisc_lookup(dev, TC_H_MAJ(t->tcm_parent))

 //前2个字节为排队规则索引，后2个字节为类索引，当前命令设置基于排队规则之上，后
 //2个字节设置为0，该条件不满足，此时cl变量取值为初始的0。
 if (TC_H_MIN(parent))
 //不走此流程

 //HTB排队规则中对应的回调为htb_find_tcf
 //获取该排队规则中的过滤链表。
 chain = cops->tcf_chain(q, cl);
 htb_find_tcf
 htb_sched *q = qdisc_priv(sch);
 htb_class *cl = (struct htb_class *)arg;
 //当前cl为0，则取的是排队规则中的过滤链表
 tcf_proto **fl = cl ? &cl->filter_list : &q->filter_list;
 return fl;

 //查找待插入的位置，优先级的值越小表示越高。
 for (back = chain; (tp=*back) != NULL; back = &tp->next)
 if (tp->prio >= prio)
 if (tp->prio == prio)
 if (!nprio || (tp->protocol != protocol && protocol))
 goto errout;
 else
 tp = NULL;
 break;

 //新建过滤协议项
 if (tp == NULL)
 //从tcf_proto_base链表中查找u32分类器，当前tp_ops为cls_u32_ops
 tp_ops = tcf_proto_lookup_ops(tca[TCA_KIND-1]);

 tp->ops = tp_ops;            //cls_u32_ops
 tp->protocol = protocol;     //ETH_P_IP
 tp->prio = nprio;            //1
 tp->q = q;               //指向根HTB类型排队规则
 tp->classify = tp_ops->classify;  //u32_classify
 tp->classid = parent;            //0x00010000

 //当前u32类的初始化回调为fw_ini。
 tp_ops->init(tp)
 u32_init
 //查找u32_list链表中是否存在相同的排队规则对象的过滤通用项
 for (tp_c = u32_list; tp_c; tp_c = tp_c->next)
 if (tp_c->q == tp->q)
 break;

 root_ht = kzalloc(sizeof(*root_ht), GFP_KERNEL);
 root_ht->divisor = 0;
 root_ht->refcnt++;
 //当前在u32_list链表中还未存在相同的排队规则对象的过滤通用项，所以
 //tp_c不为真。
 root_ht->handle = tp_c ? gen_new_htid(tp_c) : 0x80000000;
 root_ht->prio = tp->prio;         //1

 //当前tp_c为空，创建一个并加入到u32_list链表中。
 if (tp_c == NULL)
 tp_c = kzalloc(sizeof(*tp_c), GFP_KERNEL);
 tp_c->q = tp->q;
 tp_c->next = u32_list;
 u32_list = tp_c;

 //将新建的root_ht与tc_c互相关联
 tp_c->refcnt++;
 root_ht->next = tp_c->hlist;
 tp_c->hlist = root_ht;
 root_ht->tp_c = tp_c;

 //当前过滤对象的root指向新分配HASH节点对象，同时data指
 //向新分配的过滤通用项
 tp->root = root_ht;
 tp->data = tp_c;

 //将当前过滤器加入到当前排队规则的过滤链表中
 tp->next = *back;
 *back = tp;

 //u32分类器的get回调为u32_get，当前在命令行里没有handle值，所以这里返回为0
 fh = tp->ops->get(tp, t->tcm_handle);

 //u32分类器的change回调为u32_change
 tp->ops->change(tp, cl, t->tcm_handle, tca, &fh);
 u32_change
 //把用户配置的后续所有扩展属性提取到临时变量opt中
 rtattr_parse_nested(tb, TCA_U32_MAX, opt)

 if ((n = (struct tc_u_knode*)*arg) != NULL)
 //当前在调用u32_get后，还不存在对应的hash节点项，所以不走此流程。

 //如果命令接口设置了divisor，则表示创建一个新的hash表对象，该hash表含有
 //divisor个数量的列表项，主要用于规则数量很大时，加快匹配速度。
 if (tb[TCA_U32_DIVISOR-1])
 unsigned divisor = *(unsigned*)RTA_DATA(tb[TCA_U32_DIVISOR-1]);

 ht = kzalloc(sizeof(*ht) + divisor*sizeof(void*), GFP_KERNEL);
 ht->tp_c = tp_c;     //当前hash表与过滤通用项关联
 ht->refcnt = 0;
 ht->divisor = divisor;
 ht->handle = handle;
 ht->prio = tp->prio;
 //通用项中的hlist指向第一hash表，这里将新建的hash插入到通用项的hlist
 //链头。
 ht->next = tp_c->hlist;
 tp_c->hlist = ht;

 *arg = (unsigned long)ht;
 return 0;

 //当用户在命令接口指定了hash表的ID，则查找对应的hash表，否则如果在命令
 //接口没有指定hash表ID，则使用过滤协议项中root指向的第一个hash链表。
 if (tb[TCA_U32_HASH-1])
 htid = *(unsigned*)RTA_DATA(tb[TCA_U32_HASH-1]);

 if (TC_U32_HTID(htid) == TC_U32_ROOT)
 ht = tp->root;
 htid = ht->handle;
 else
 //tp->data指向过滤通用项，这里使用过滤通用项中hlist链表来进行hash
 //表查找。
 ht = u32_lookup_ht(tp->data, TC_U32_HTID(htid));
 else
 ht = tp->root;
 htid = ht->handle;   //0x80000000，该值在上面u32_init中初始化

 //当前命令行未设置handle，使用gen_new_kid生成hash节点id
 if (handle)
 //不走此流程
 else
 handle = gen_new_kid(ht, htid);
 unsigned i = 0x7FF;

 //handle = 0x80000000
 //TC_U32_HASH(handle) = 0
 //当前ht->ht[0]还未有值，所有这里返回值为 0x80000800
 for (n=ht->ht[TC_U32_HASH(handle)]; n; n = n->next)
 if (i < TC_U32_NODE(n->handle))
 i = TC_U32_NODE(n->handle);
 i++;
 return handle|(i>0xFFF ? 0xFFF : i);

 //指向选择项属性值
 s = RTA_DATA(tb[TCA_U32_SEL-1]);

 //当前用户配置接口在当前规则中仅设置了一个匹配项，则nkeys为1
 //这里分配内存空间为一个struct tc_u_knode大小，加上一个struct tc_u32_key大小
 n = kzalloc(sizeof(*n) + s->nkeys*sizeof(struct tc_u32_key), GFP_KERNEL);

 //把用户配置设置匹配规则复制到当前新的hash关键节点的sel中
 memcpy(&n->sel, s, sizeof(*s) + s->nkeys*sizeof(struct tc_u32_key));

 //当前hash关键节点的ht_up指向当前使用的hash表
 n->ht_up = ht;
 n->handle = handle;  // 0x80000800

 //当前s->hmask为0，所以i最后为0
 u8 i = 0;
 u32 mask = s->hmask
 if (mask)
 ......
 n->fshift = i;

 //过滤节点参数设置
 u32_set_parms(tp, base, ht, n, tb, tca[TCA_RATE-1]);
 //当前命令行没有输入action或police，所以无扩展属性
 tcf_exts_validate(tp, tb, est, &e, &u32_ext_map);

 //如果用户接口输入了link，则进行链接处理，这里链接是指在当前过滤项
 //匹配成功后，可以跳到其它hash表项中去处理，如果在其它hash表项中
 //分类成功，则直接返回成功，否则在其它hash表项中分类失败，还可以
 //回来原来的hash表项继续处理。
 if (tb[TCA_U32_LINK-1])
 u32 handle = *(u32*)RTA_DATA(tb[TCA_U32_LINK-1]);

 //根据用户接口设置的link索引，查找当前通用项中hlist对应的hash
 //表是否含有对应id的hash项。
 ht_down = u32_lookup_ht(ht->tp_c, handle);

 //没找到返回错误，找到则增加引用计数
 if (ht_down == NULL)
 goto errout;
 ht_down->refcnt++;

 //将hash关键节点的ht_down指向希望链接的hash表项，在进行分类处
 //理里，如果当前hash关键节点匹配成功，会检测如果存在ht_down，则
 //使用该hash表项的各hash关键节点项继续匹配处理。
 ht_down = xchg(&n->ht_down, ht_down);

 //如果之前ht_down已经关联了其它hash表项，当前已经不使用，则
 //递减引用计数。
 if (ht_down)
 ht_down->refcnt--;

 if (tb[TCA_U32_CLASSID-1])
 //0x0001000A
 n->res.classid = *(u32*)RTA_DATA(tb[TCA_U32_CLASSID-1]);

 tcf_bind_filter(tp, &n->res, base);
 //当前回调为htb_bind_filter
 //查找绑定该hash关键节点对象的类
 cl = tp->q->ops->cl_ops->bind_tcf(tp->q, base, r->classid);
 htb_bind_filter
 htb_sched *q = qdisc_priv(sch);

 //当前classid为0x000100A
 htb_class *cl = htb_find(classid, sch);

 //找到匹配的类，则类的过滤计数递增
 if (cl)
 cl->filter_cnt++;
 else
 q->filter_cnt++;
 return (unsigned long)cl;

 //将找到的类对象关联到hash关键节点对象中，同时返回hash关键
 //节点对象中原有的关联类，当前没有老的关联类，所以old_cl为空
 cl = cls_set_class(tp, &r->class, cl);
 old_cl = __cls_set_class(clp, cl);
 old_cl = *clp;
 *clp = cl;
 return old_cl;
 return old_cl;

 //当前hash关键节点对象是新建的，没有老的关联类，不执行此流程。
 if (cl)
 tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);

 //扩展参数设置，当前命令行没有输入action或police，所以无扩展属性。
 tcf_exts_change(tp, &n->exts, &e);

 //把新建的hash关键节点加入到hash对象的ht链表中
 for (ins = &ht->ht[TC_U32_HASH(handle)]; *ins; ins = &(*ins)->next)
 if (TC_U32_NODE(handle) < TC_U32_NODE((*ins)->handle))
 break;

 n->next = *ins;
 wmb();
 *ins = n;

 //告知添加成功
 tfilter_notify(skb, n, tp, fh, RTM_NEWTFILTER);

 六、发送报文
 当上层发出报文，调用dev_queue_xmit，这里仅分析和出口排队规则相关的代码，其它详细
 的代码分析可以参见《接口设备发包》
 dev_queue_xmit
 ......

 //如果当前使用出口排队规则
 q = rcu_dereference(dev->qdisc);
 if (q->enqueue)
 spin_lock(&dev->queue_lock);
 q = dev->qdisc;

 if (q->enqueue)
 //调用当前排队规则的入队回调，当前HTB类型排队规则回调为
 //htb_enqueue
 rc = q->enqueue(skb, q);
 htb_enqueue
 htb_sched *q = qdisc_priv(sch);

 //分类处理
 htb_class *cl = htb_classify(skb, sch, &ret);
 //直报文的优先级字段与当前队列的句柄相同，则返回直接处理
 if (skb->priority == sch->handle)
 return HTB_DIRECT;

 //使用报文的优先级字段做为类ID，在htb_find函数中，从排队
 //规则的hash表中查找指定类ID的类对象，找到指定类对象后，
 //根据cl->level判断当前类是否为叶子（0为叶子），如果是叶子
 //类则返回。
 if ((cl = htb_find(skb->priority, sch)) != NULL && cl->level == 0)
 return cl;


 *qerr = NET_XMIT_BYPASS;

 tcf = q->filter_list;

 //使用过滤对象进行分类，tc_classify函数在下面单独分析。
 while (tcf && (result = tc_classify(skb, tcf, &res)) >= 0)
 switch (result)
 //这三种处理结果都会返回空类，在htb_enqueue对返回类
 //为空的情况都会将报文丢弃。
 case TC_ACT_QUEUED:
 case TC_ACT_STOLEN:
 *qerr = NET_XMIT_SUCCESS;
 case TC_ACT_SHOT:
 return NULL;

 //如果返回结果的类不存在，则继续尝试
 if ((cl = (void *)res.class) == NULL)
 //如果返回结果就classid为排队规则句柄，也就是说之
 //前用户在命令接口配置过滤规则时，最后匹配的流ID
 //为排队规则句柄，则返回直接处理。
 if (res.classid == sch->handle)
 return HTB_DIRECT;

 //此时根据用户在命令接口配置过滤规则时指定的
 //流ID查找当前排队规则是否存在该类，如果不存
 //在，则直接跳出当前while循环，使用之前创建
 //HTB排队规则时设置的默认的类
 if ((cl = htb_find(res.classid, sch)) == NULL)
 break;

 //如果找到了类，并且该类是叶子类，则返回，否则继续使
 //用下一个过滤器进行查找。
 if (!cl->level)
 return cl;

 //使用非叶子类中的过滤器进行分类
 tcf = cl->filter_list;

 //到达这里，表明所有过滤器都已经遍历完了，但还没有找到
 //对应的叶子类。这里则使用之前创建HTB排队规则时设置的
 //默认类ID进行查找。
 cl = htb_find(TC_H_MAKE(TC_H_MAJ(sch->handle), q->defcls),
 sch);

 //如果使用默认类ID，还没找到对应的类，或者找到的类是非
 //叶子类型的，则返回直接处理。
 if (!cl || cl->level)
 return HTB_DIRECT;

 //返回找到的默认类。
 return cl;

 //当前返回结果为直接处理
 if (cl == HTB_DIRECT)
 //如果当前直接发送队列还未达到直接发送限额，则将报文放入
 //直接发送队列中，否则将报文丢弃处理。
 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;
 //使用叶子类中的排队规则的enqueue回调，将报文压入到该排队规
 //则中，如果压入失败，则进行丢包统计。
 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的机制在对激活的类做了划分。首先
 //分了8层，叶子类为第0层，根类为第7层，中间类在父类的
 //层数上减1，在进行出队处理时从第0层开始优先进行处理。
 //同时每层又分为8个优先级，0为第高优先级，当被激活的类
 //层次相同时，则按优先级最高的优先进行处理。当被激活的类
 //层次也相同，优先级也相同，则被根据类ID为对比值放入一
 //棵红黑树中，类ID越小优先级越高。激活类的数据结构大概
 //如下图所示：

 "https://img-blog.csdn.net/20141214040619778?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbGl1amlhbmZlbmcxOTg0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />
 htb_activate(q, cl);
 //设置当前类中被激活的优先级位图，这里cl->un.leaf.prio
 //是在类被用户接口创建时设置的，如果在用户接口未输入
 //prio则默认为0。
 cl->prio_activity = 1 << (cl->un.leaf.aprio = cl->un.leaf.prio);

 //根据类中层次及优先级位图激活类
 htb_activate_prios(q, cl);
 p = cl->parent;      //当前类的父类
 mask = cl->prio_activity;    //当前类的优先级位图

 //当前类如果已经进到了租借模式，同时该类存在父类
 //则进行处理。这里会对父类进行激活，同时将当前类
 //挂接到父类的feed供给树下。
 while (cl->cmode == HTB_MAY_BORROW && p &&
 mask)
 m = mask;

 while (m)
 //将优先级位图取反，之后使用ffz查找第一
 //为0的位为表示优先级索引。
 int prio = ffz(~m);

 //当前位处理后就去除。
 m &= ~(1 << prio);

 //当前父类如果已经在供给，则表明之前已经
 //激活，则在mask中去除当前优先级位，否
 //则下面会将cl变量指向父类，并对父类进行
 //激活。
 if (p->un.inner.feed[prio].rb_node)
 mask &= ~(1 << prio);

 //这里将当前子类加入到父类的供给树中
 //（un.inner.feed），表明当前父类在给哪些
 //子类供给。
 htb_add_to_id_tree(p->un.inner.feed + prio, cl,
 prio);

 //父类可能租借给多个子类使用，这里在父类中保
 //存子类的优先级。开始对父类准备激活处理。
 p->prio_activity |= mask;
 cl = p;
 p = cl->parent;

 //如果当前类为可发送模式，则在HTB排队规则中激
 //活该优先级类。
 if (cl->cmode == HTB_CAN_SEND && mask)
 htb_add_class_to_row(q, cl, mask);
 //记载当前层次哪些优先级被激活
 q->row_mask[cl->level] |= mask;

 //遍历所有待处理的优先级位，将当前类插入
 //到排队规则row指定位置的树中。插入位置
 //的实现可以参考上图激活类的数据结构来
 //加深理解。
 while (mask)
 int prio = ffz(~mask);
 mask &= ~(1 << prio);
 htb_add_to_id_tree(q->row[cl->level] +
 prio, cl, prio);

 //将当前叶子类插入到HTB排队规则的drops对应优先级的
 //列表中。
 list_add_tail(&cl->un.leaf.drop_list,q->drops +
 cl->un.leaf.aprio);

 //更新统计，返回分类成功。
 sch->q.qlen++;
 sch->bstats.packets++;
 sch->bstats.bytes += skb->len;
 return NET_XMIT_SUCCESS;

 //队列处理
 qdisc_run(dev);
 //如果队列发送没有关闭，并且队列调度还没有运行，则运行队列调度
 if (!netif_queue_stopped(dev)
 &&!test_and_set_bit(__LINK_STATE_QDISC_RUNNING, &dev->state))
 __qdisc_run(dev);
 //如果队列为noop_qdisc类型，则表明接口还未启动，则直接退
 //出队列调度
 if (unlikely(dev->qdisc == &noop_qdisc))
 goto out;

 //当还有待处理的数据，并且发送队列没有关闭，则循环从队列
 //中取出数据，使用网卡驱动进行发送数据。该函数具体实现不
 //详细列出。之前在《接口设备发包》中已经分析过，可以参考
 //那节的分析。这里主要关注，从队列中取出数据是使用的队列
 //的dequeue回调，当前HTB类型的排队规则回调为
 //htb_dequeue，htb_dequeue在下面单独分析。
 while (qdisc_restart(dev) < 0 && !netif_queue_stopped(dev))
 ;

 out:
 //去除正在进行队列调度标记
 clear_bit(__LINK_STATE_QDISC_RUNNING, &dev->state);

 spin_unlock(&dev->queue_lock);

 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
 goto out;

 spin_unlock(&dev->queue_lock);

 ---------------------------------------------------------------------------------------------------------------------
 //使用过滤器进行分类
 tc_classify
 protocol = skb->protocol;

 //遍历所有过滤器
 for ( ; tp; tp = tp->next)
 //首先检测当前报文的协议与过滤器中的协议匹配，或者过滤器匹配任何协议类
 //型，则进一步使用当前过滤器的classify回调进行分类处理，当前u32的回调
 //函数为u32_classify，u32_classify在下面单独分析。
 if ((tp->protocol == protocol ||tp->protocol == __constant_htons(ETH_P_ALL)) &&
 (err = tp->classify(skb, tp, res)) >= 0)
 //返回处理结果
 return err;

 //返回-1，表明分类失败。
 return -1;

 ---------------------------------------------------------------------------------------------------------------------
 使用u32分类器进行分类处理
 u32_classify
 //过滤协议对象的root，即首hash链表对象
 tc_u_hnode *ht = (struct tc_u_hnode*)tp->root;
 u8 *ptr = skb->nh.raw;       //报文的IP头位置
 int sel = 0;

 next_ht:

 n = ht->ht[sel];

 next_knode:

 //判断当前hash关键节点是否存在
 if (n)
 struct tc_u32_key *key = n->sel.keys;    //hash关键节点对象的匹配项

 //遍历当前hash关键节点的所有匹配项，如果有任何一项匹配失败，则使用
 //goto进入下一个hash关键节点进行匹配。这里匹配项中的off就是对应项
 //（比如dport）在报文IP文件位置的偏移。
 for (i = n->sel.nkeys; i>0; i--, key++)
 if ((*(u32*)(ptr+key->off+(off2&key->offmask))^key->val)&key->mask)
 n = n->next;
 goto next_knode;

 //ht_down和命令行中link配置相关，用于多层嵌套，可以实现跳转到其它hash链
 //节点进行查找，当前测试实例没有配置嵌套，这里ht_down 为NULL。
 if (n->ht_down == NULL)
 check_terminal:
 //在用户侧命令接口已经对当前过滤选择项设置了U32_TERMINAL
 if (n->sel.flags&TC_U32_TERMINAL)
 *res = n->res;       //返回该过滤选择项的结果，这里含有绑定的类

 //进行扩展属性处理，处理失败尝试下一个关键匹配点，当前命令接口
 //没有设置相关扩展项，所以这里返回为0
 r = tcf_exts_exec(skb, &n->exts, res);
 if (r < 0)
 n = n->next;
 goto next_knode;

 //当前匹配完成，返回结果。
 return r;

 //如果hash关键节点匹配项匹配完成，但不含U32_TERMINAL处理结束的标
 //记，则尝试下一个hash关键节点。
 n = n->next;
 goto next_knode;

 //n->ht_down不为空，表明有嵌套匹配处理

 //先将当前hash关键节点及匹配指针压入临时变量stack栈中
 stack[sdepth].knode = n;
 stack[sdepth].ptr = ptr;
 sdepth++;

 //取出待跳转的hash链对象
 ht = n->ht_down;

 sel = 0;
 //如果当前hash链对象含有divisor值，表明该hash链对象是之前通过命令接口
 //使用divisor关键字段创建的含有多个列表项的hash链对象，则这里根据之
 //前命令接口设置的散列因子相关的参数（比如根据源IP地址最后1个字节进行散
 //列因子处理）进行计算，来确定当前的报文应该在当前hash链对象的哪个列表
 //项中进行处理。
 if (ht->divisor)
 sel = ht->divisor&u32_hash_fold(*(u32*)(ptr+n->sel.hoff), &n->sel,n->fshift);

 //如果当前hash关键节点的选择项中不含有任何偏移属性，则直接跳转到下一个
 //hash链节点中进行查找。
 if (!(n->sel.flags&(TC_U32_VAROFFSET|TC_U32_OFFSET|TC_U32_EAT)))
 goto next_ht;


 //走到此流程，表明当前hash关键节点中含有相关的偏移属性，则根据用户接口
 //配置进行对应的偏移处理，如果处理完后报文合法，则跳转到下一个hash链节
 //点中进行查找。
 if (n->sel.flags&(TC_U32_OFFSET|TC_U32_VAROFFSET))
 off2 = n->sel.off + 3;
 if (n->sel.flags&TC_U32_VAROFFSET)
 off2 += ntohs(n->sel.offmask & *(u16*)(ptr+n->sel.offoff)) >>n->sel.offshift;
 off2 &= ~3;
 if (n->sel.flags&TC_U32_EAT)
 ptr += off2;
 off2 = 0;
 if (ptr < skb->tail)
 goto next_ht;

 //用户接口含有link关键字时，则进行嵌套处理，每进行一次嵌套则将前一次处理结果
 //存储到临时变量stack中，当最后的嵌套处理没有匹配成功时，会走到此流程，如果
 //当前确定是嵌套处理，则取出前一次的hash链对象继续进行处理。
 if (sdepth--)
 n = stack[sdepth].knode;
 ht = n->ht_up;
 ptr = stack[sdepth].ptr;
 goto check_terminal;

 //分类失败
 return -1;

 ---------------------------------------------------------------------------------------------------------------------
 //HTB数据包出队处理
 htb_dequeue
 q->jiffies = jiffies;            //记载当前滴答

 //如果当前直接发送队列含有报文，则优先进行处理，直接将报文取出。
 skb = __skb_dequeue(&q->direct_queue);
 if (skb != NULL)
 sch->flags &= ~TCQ_F_THROTTLED;
 sch->q.qlen--;
 return skb;

 //队列无数据则返回为NULL
 if (!sch->q.qlen)
 goto fin;

 //获取当前系统时间
 PSCHED_GET_TIME(q->now);

 min_delay = LONG_MAX;

 q->nwc_hit = 0;

 //从第0层开始遍历处理，第0层为叶子类层
 for (level = 0; level < TC_HTB_MAXDEPTH; level++)
 //当前流逝时间已经超过最近事件的缓冲时间
 if (time_after_eq(q->jiffies, q->near_ev_cache[level]))
 delay = htb_do_events(q, level);
 //最多处理500个被阻塞的报文
 for (i = 0; i < 500; i++)
 //取当前层中第1个被阻塞的树节点
 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;

 //当前类的阻塞时间已到。

 //将树节点从阻塞树中删除。
 htb_safe_rb_erase(p, q->wait_pq + level);

 //计算当前类最后一次处理到当前的时间差，该时间差不能超过
 //mbuffer值（在创建类时该值为1分钟）。
 diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32) cl->mbuffer);

 //进行类的模式改变
 htb_change_class_mode(q, cl, &diff);
 new_mode = htb_class_mode(cl, diff);
 //这里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;

 //这里tokens是非租借模式下令牌数，经过一段时间补充后，
 //如果高于高水位线，则状态变为HTB_CAN_SEND
 //（可以发送）
 if ((toks = (cl->tokens + *diff)) >= htb_hiwater(cl))
 return HTB_CAN_SEND;

 //状态变为可租借，返回还需要多少令牌
 *diff = -toks;
 return HTB_MAY_BORROW;

 //当前模式相同则直接返回。
 if (new_mode == cl->cmode)
 reutrn;

 //如果当前类有激活，则根据新、老模式进行类的激活、去激活
 //处理（之前为非不可发送模式，则将当前类去激活，该类后
 //续暂时不能发包，当前新的模式为可发送模式，则将当前类
 //激活，该类后续可以继续发包，当前新的模式为租借模式，则
 //激活父类，并将当前类挂接到父类的feed供给树下）。
 //否则当前类没有激活，则仅修改当前模式。
 if (cl->prio_activity)
 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;

 //如果当前模式不可发送，则将类插入到q->wait_pq[level]等待树中。
 //同时更新类的cl->pq_key等待关键字的值为当前jitter加上diff，其
 //中diff是在上面htb_change_class_mode中计算得到。
 if (cl->cmode != HTB_CAN_SEND)
 htb_add_to_wait_tree(q, cl, diff);

 //在上面等待树中最多处理500个等待报文，超过则放到下轮再来处理，
 //同时返回延时时间为100ms。
 return HZ / 10;

 //更新最近事件处理时间，如果没有等待处理的包，则delay为0，下一次事件
 //处理则加长一些（1秒），否则还有等待处理的包，则下一次事件处理的时间
 //设置为上面的delay值。
 q->near_ev_cache[level] =q->jiffies + (delay ? delay : HZ);
 else
 //如果当前流逝时间还未到达下一次事件处理时间，则delay取值为下一次事
 //件处理所需要的时间点。
 delay = q->near_ev_cache[level] - q->jiffies;

 //因为最终在下面进行延时处理是使用min_delay的值，这里对该值进行校正
 if (delay && min_delay > delay)
 min_delay = delay;

 //row_mask[level]为当前层已经激活的类，这里取反是为了方便下面使用ffz进行
 //查找第一个为0的位所在索引。
 m = ~q->row_mask[level];

 //优先级激活位图如果取反为全为1，则表明当前层的类都没有被激活。
 while (m != (int)(-1))
 //优先取最低优先级位进行处理。
 int prio = ffz(m);

 m |= 1 << prio;   //每处理一次，当前优先级位就清除，以免二次进入。

 //指定层次、指定优先级的树中取出待发送的skb报文。
 skb = htb_dequeue_tree(q, prio, level);
 //q->row记载着激活的位图，仅类被激活后才可以发送报文，当子类未激
 //活时，从父类中租借代宽，父类就会激活。
 //q->ptr记载了最后处理的的类的树节点。
 //q->last_ptr_id记载了最后处理的类ID。
 //这里根据DDR算法，查找出可调度的HTB类。
 //htb_lookup_leaf函数比较复杂，放在下面单独分析。

 start = cl = htb_lookup_leaf(q->row[level] + prio, prio,q->ptr[level] + prio,
                          q->last_ptr_id[level] + prio);

 do
 next:
 //由于代宽受限等原因导致当前没有可出队的报文。
 if (!cl)
 return NULL;

 //如果当前类的队列为空
 if (unlikely(cl->un.leaf.q->q.qlen == 0))
 //该类去激活
 htb_deactivate(q, cl);
 //检查如果当前层、当前优先级已经没有激活的类，则返回为
 //NULL，让上面函数继续下一层、下一优先级类的处理。
 if ((q->row_mask[level] & (1 << prio)) == 0)
 return NULL;

 //当前调度的类没有队列，并且当前层、当前优先级下还有激活
 //的类，则再次调用htb_lookup_leaf查找可调度的类。同时更新
 //临时变量start、cl。
 next = htb_lookup_leaf(q->row[level] + prio,
 prio, q->ptr[level] + prio,q->last_ptr_id[level] + prio);

 if (cl == start)
 start = next;
 cl = next;
 goto next;

 //使用当前类下的排队规则的dequeue回调进行将报文出队，这里
 //dequeue回调实现取决于用户侧给该类下绑定什么排队规则，如
 //果启用未设置，则默认HTB类下的排队规则为pfifo_qdisc，则
 //对应的回调函数为qdisc_dequeue_head，该函数比较简单，仅仅
 //是仅出双向链表中第一个节点的报文。
 skb = cl->un.leaf.q->dequeue(cl->un.leaf.q);

 //报文取出后直接跳出do while循环，返回。
 if (likely(skb != NULL))
 break;

 //当该类下标明有队列，但取出失败，则标记告警。
 if (!cl->warned)
 cl->warned = 1;

 q->nwc_hit++;    //统计不工作的错误类计数
 //将之前保存记录的ptr（最后处理的的类的树节点）更新为下一个节
 //点。
 htb_next_rb_node((level ? cl->parent->un.inner.ptr : q->ptr[0]) + prio);

 //再次调用htb_lookup_leaf查找可调度的类
 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))
 //htb_next_rb_node用来修改下一次使用htb_lookup_leaf选择调度
 //类时先从哪个类进行处理，这里根据quantum值的限额来进行
 //控制，可以防止htb_lookup_leaf在一段时间内始终使用相同的类
 //进行调度。
 if ((cl->un.leaf.deficit[level] -= skb->len) < 0)
 cl->un.leaf.deficit[level] += cl->un.leaf.quantum;
 htb_next_rb_node((level ? cl->parent->un.inner.ptr : q->ptr[0]) +
 prio);

 //当前类下的排队规则中已经没有报文，则将该类去激活。
 if (!cl->un.leaf.q->q.qlen)
 htb_deactivate(q, cl);

 //对该类进行收费计算。
 htb_charge_class(q, cl, level, skb->len);
 //临时定义了一个计帐功能宏，这里T可以是tokens或ctokens，
 //B可以是buffer或cbuffer，R可以是rate或ceil。
 //T表示租借模式或非租借模式下的令牌数。
 //B表示租借模式或非租借模式下基于对应速率的单包峰值。
 //R表示租借模式或非租借模式下不同速率。
 //首先将根据流逝时间来对所剩的令牌数进行补充。
 #define HTB_ACCNT(T,B,R) toks = diff + cl->T; \
 //对令牌数进行上限峰值限制
 if (toks > cl->B) toks = cl->B; \
 //根据当前报文字节数，在速率表中查找符合当前字节范围
 //之内所需消耗的单位值，之后从令牌总数中扣除消耗的单
 //位值。
 toks -= L2T(cl, cl->R, bytes); \
 //如果令牌数小于最大负等待峰值时间（1分钟），则对令牌
 //数修正为最大负等待峰值时间。
 if (toks <= -cl->mbuffer) toks = 1-cl->mbuffer; \
 //将剩余的令牌数保留，供下一次使用。
 cl->T = toks

 while (cl)
 //计算当前HTB类最后一个工作到当前已经流逝的时间，
 //不能超过mbuffer上限。
 diff = PSCHED_TDIFF_SAFE(q->now, cl->t_c, (u32)
 cl->mbuffer);

 //该函数第一次处理的cl类都是叶子类，之后在while
 //循环中cl类依次改变为当前类的父类，而level在循环
 //中是始终保持不变的。如果当前level是0,表明叶子一直
 //未超过最低速率，始终是可发送的。如果当前level非0，
 //表明叶子已经在借用父类的带宽。当cl->level >= level，则
 //对当前类及父类都进行tokens计费处理，当
 //cl->level < level则表明当前类是在对父类进行租借，不
 //再对当前类进行tokens计费处理，仅对提供租借的父类
 //进行tokens计费处理。但不管当前类是否在租借都会
 //对ctokens进行计费处理。这里要理解tokens与ctokens
 //的差别，tokens是当前类的速率限制，ctokens是可向父类
 //借用的速率限制。如果使用当前类发送报文时小于tokens，
 //则当前类速率还比较正常，可以继续处理，如果当前发送
 //报文时大于tokens但小于ctokens，则表明当前类已经超出
 //自己的速率限制，但还可以从父类借用带宽，如果当前发
 //送报文时大于ctokens，则表明都超出了可借用速率，此时
 //该类的模式会修改为不可发送模式，当前类暂时已经不能
 //在发送任何报文。
 if (cl->level >= level)
 if (cl->level == level)
 cl->xstats.lends++;
 HTB_ACCNT(tokens, buffer, rate);