Linux内核中流量控制(5)

本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，
严禁用于任何商业用途。
msn: [email protected]
来源：http://yfydz.cublog.cn

5.5 SFQ(Stochastic Fairness Queueing discipline)

SFQ算法是个比较简单的算法，速度也比较快，算法维护一定数量的数据包队列，入队是将数据包进
行哈希后插入某队列，出队则是轮询方式出队列，另外可设置一定的随机因子，在计算哈希值时能碰
撞少些，流控算法在net/sched/sch_sfq.c中定义,在实现中, 队列数量最大为128个，这是保证SFQ私
有数据结构能小于4K，能在一个页面内分配。在使用用不建议作为网卡的根节点流控，而是最好作为
分类流控方法如CBQ等的叶子节点。

5.5.1 SFQ操作结构定义

// TC使用的SFQ配置参数结构
struct tc_sfq_qopt
{
// 定额
 unsigned quantum; /* Bytes per round allocated to flow */
// 扰动周期
 int  perturb_period; /* Period of hash perturbation */
// 队列中的数据包数量限制
 __u32  limit;  /* Maximal packets in queue */
 unsigned divisor; /* Hash divisor  */
// 最大队列数
 unsigned flows;  /* Maximal number of flows  */
};

#define SFQ_DEPTH  128
#define SFQ_HASH_DIVISOR 1024
/* This type should contain at least SFQ_DEPTH*2 values */
// SFQ索引值是无符合8位数
typedef unsigned char sfq_index;
struct sfq_head
{
 sfq_index next;
 sfq_index prev;
};

// SFQ私有数据
struct sfq_sched_data
{
/* Parameters */
// 扰动间隔, 隔一定时间修改HASH扰动 值
 int  perturb_period;
//
 unsigned quantum; /* Allotment per round: MUST BE >= MTU */
// 流量限制值
 int  limit;
/* Variables */
// 扰动更新定时器
 struct timer_list perturb_timer;
// HASH扰动值
 int  perturbation;
// 出队队列索引
 sfq_index tail;  /* Index of current slot in round */
// 最大深度
 sfq_index max_depth; /* Maximal depth */
// HASH值对应的槽位索引表, 1024项, HASH值范围为0~1023
 sfq_index ht[SFQ_HASH_DIVISOR]; /* Hash table */
// 活动槽
 sfq_index next[SFQ_DEPTH]; /* Active slots link */
 short  allot[SFQ_DEPTH]; /* Current allotment per slot */
// 哈希值索引数组
 unsigned short hash[SFQ_DEPTH]; /* Hash value indexed by slots */
// 数据包队列, 128个队列
 struct sk_buff_head qs[SFQ_DEPTH];  /* Slot queue */
// 深度值, 256个成员
 struct sfq_head dep[SFQ_DEPTH*2]; /* Linked list of slots, indexed by
depth */
};

SFQ数据结构比较怪异, 数据存储是数组, 但逻辑上又是双向链表, 访问时又使用数组索引。

// SFQ流控操作结构
static struct Qdisc_ops sfq_qdisc_ops = {
 .next  = NULL,
 .cl_ops  = NULL,
 .id  = "sfq",
 .priv_size = sizeof(struct sfq_sched_data),
 .enqueue = sfq_enqueue,
 .dequeue = sfq_dequeue,
 .requeue = sfq_requeue,
 .drop  = sfq_drop,
 .init  = sfq_init,
 .reset  = sfq_reset,
 .destroy = sfq_destroy,
// 注意没有change函数
 .change  = NULL,
 .dump  = sfq_dump,
 .owner  = THIS_MODULE,
};

5.5.2 SFQ一些基本操作
// HASH函数
static __inline__ unsigned sfq_fold_hash(struct sfq_sched_data *q, u32 h, u32 h1)
{
// 哈希扰动值
 int pert = q->perturbation;
 /* Have we any rotation primitives? If not, WHY? */
// 计算哈希值, 最大值0x3ff=1023
 h ^= (h1<<pert) ^ (h1>>(0x1F - pert));
 h ^= h>>10;
 return h & 0x3FF;
}
// SFQ哈希函数
static unsigned sfq_hash(struct sfq_sched_data *q, struct sk_buff *skb)
{
 u32 h, h2;
// skb->protocol是链路层中的协议值
 switch (skb->protocol) {
// IPV4
 case __constant_htons(ETH_P_IP):
 {
  struct iphdr *iph = skb->nh.iph;
// 哈希函数中用到了源地址,目的地址, 协议, 端口或SPI值
  h = iph->daddr;
  h2 = iph->saddr^iph->protocol;
  if (!(iph->frag_off&htons(IP_MF|IP_OFFSET)) &&
      (iph->protocol == IPPROTO_TCP ||
       iph->protocol == IPPROTO_UDP ||
       iph->protocol == IPPROTO_SCTP ||
       iph->protocol == IPPROTO_DCCP ||
       iph->protocol == IPPROTO_ESP))
   h2 ^= *(((u32*)iph) + iph->ihl);
  break;
 }
// IPV6
 case __constant_htons(ETH_P_IPV6):
 {
  struct ipv6hdr *iph = skb->nh.ipv6h;
// 用地址的最后4字节
  h = iph->daddr.s6_addr32[3];
  h2 = iph->saddr.s6_addr32[3]^iph->nexthdr;
  if (iph->nexthdr == IPPROTO_TCP ||
      iph->nexthdr == IPPROTO_UDP ||
      iph->nexthdr == IPPROTO_SCTP ||
      iph->nexthdr == IPPROTO_DCCP ||
      iph->nexthdr == IPPROTO_ESP)
   h2 ^= *(u32*)&iph[1];
  break;
 }
 default:
// 其他协议就用路由参数, 链路层协议和sock指针
  h = (u32)(unsigned long)skb->dst^skb->protocol;
  h2 = (u32)(unsigned long)skb->sk;
 }
// 计算哈希值
 return sfq_fold_hash(q, h, h2);
}

// 链接操作
static inline void sfq_link(struct sfq_sched_data *q, sfq_index x)
{
 sfq_index p, n;
// 第X个队列尾索引，qlen是不会超过SFQ_DEPTH的
 int d = q->qs[x].qlen + SFQ_DEPTH;
 p = d;
 n = q->dep[d].next;
// x节点插入到队列s的最后, 但形成一个双向环型链表
 q->dep[x].next = n;
 q->dep[x].prev = p;
 q->dep[p].next = q->dep[n].prev = x;
}
// 减少, 将X号索引点断开
static inline void sfq_dec(struct sfq_sched_data *q, sfq_index x)
{
 sfq_index p, n;
// 断开x号索引
 n = q->dep[x].next;
 p = q->dep[x].prev;
 q->dep[p].next = n;
 q->dep[n].prev = p;
// n==p表示链表空了
// 如果当前链表是最多元素链表, 相应最大链表长度减
 if (n == p && q->max_depth == q->qs[x].qlen + 1)
  q->max_depth--;
 sfq_link(q, x);
}
// 增加, 增加X处索引点
static inline void sfq_inc(struct sfq_sched_data *q, sfq_index x)
{
 sfq_index p, n;
 int d;
 n = q->dep[x].next;
 p = q->dep[x].prev;
 q->dep[p].next = n;
 q->dep[n].prev = p;
 d = q->qs[x].qlen;
 if (q->max_depth < d)
  q->max_depth = d;
 sfq_link(q, x);
}
5.5.3 初始化
static int sfq_init(struct Qdisc *sch, struct rtattr *opt)
{
// SFQ私有数据
 struct sfq_sched_data *q = qdisc_priv(sch);
 int i;
// 初始化定时器
 init_timer(&q->perturb_timer);
// 定时器函数参数为流控结构
 q->perturb_timer.data = (unsigned long)sch;
// 定时器函数, 定时修改扰动值
 q->perturb_timer.function = sfq_perturbation;
// 初始化哈希表索引, 都为SFQ_DEPTH
 for (i=0; i<SFQ_HASH_DIVISOR; i++)
  q->ht[i] = SFQ_DEPTH;
 for (i=0; i<SFQ_DEPTH; i++) {
// 初始化数据包队列头
  skb_queue_head_init(&q->qs[i]);
// 初始化dep的后SFQ_DEPTH个元素
  q->dep[i+SFQ_DEPTH].next = i+SFQ_DEPTH;
  q->dep[i+SFQ_DEPTH].prev = i+SFQ_DEPTH;
 }
// SFQ流控数据包总数限制
 q->limit = SFQ_DEPTH;
 q->max_depth = 0;
 q->tail = SFQ_DEPTH;
// 配置SFQ是允许不带任何参数的
 if (opt == NULL) {
// 缺省定额值为网卡MTU
  q->quantum = psched_mtu(sch->dev);
// 不进行扰动更新
  q->perturb_period = 0;
 } else {
// 根据配置的参数设置SFQ参数
  int err = sfq_change(sch, opt);
  if (err)
   return err;
 }
// 初始化索引链表, 初始化dep的前128个元素
 for (i=0; i<SFQ_DEPTH; i++)
  sfq_link(q, i);
 return 0;
}
// SFQ哈希扰动值修改, 这是定时器的定时函数
static void sfq_perturbation(unsigned long arg)
{
// 定时函数参数为流控结构
 struct Qdisc *sch = (struct Qdisc*)arg;
// SFQ私有数据
 struct sfq_sched_data *q = qdisc_priv(sch);
//生成随机扰动值
 q->perturbation = net_random()&0x1F;
// 扰动时间非0, 更新定时器, 现在是在时钟中断中, 定时器已经从定时链表中拆除了,
// 所以要重新添加定时器
 if (q->perturb_period) {
  q->perturb_timer.expires = jiffies + q->perturb_period;
  add_timer(&q->perturb_timer);
 }
}

// 设置SFQ参数, 只在初始化时调用, 以后将不再修改
static int sfq_change(struct Qdisc *sch, struct rtattr *opt)
{
// SFQ私有数据
 struct sfq_sched_data *q = qdisc_priv(sch);
// SFQ配置参数
 struct tc_sfq_qopt *ctl = RTA_DATA(opt);
// 配置参数合法性检查
 if (opt->rta_len < RTA_LENGTH(sizeof(*ctl)))
  return -EINVAL;
 sch_tree_lock(sch);
// 设置定额, 该参数可选
 q->quantum = ctl->quantum ? : psched_mtu(sch->dev);
// 扰动周期, 该参数必须
 q->perturb_period = ctl->perturb_period*HZ;
// 数据包数量限制, 不超过SFQ_DEPTH
 if (ctl->limit)
  q->limit = min_t(u32, ctl->limit, SFQ_DEPTH);
// 如果当前队列中的数据包数超过限制值, 丢包
 while (sch->q.qlen >= q->limit-1)
  sfq_drop(sch);
// 更新定时器
 del_timer(&q->perturb_timer);
 if (q->perturb_period) {
  q->perturb_timer.expires = jiffies + q->perturb_period;
  add_timer(&q->perturb_timer);
 }
 sch_tree_unlock(sch);
 return 0;
}
 
5.5.4 入队

static int
sfq_enqueue(struct sk_buff *skb, struct Qdisc* sch)
{
// SFQ私有数据
 struct sfq_sched_data *q = qdisc_priv(sch);
// 计算数据包的哈希值
 unsigned hash = sfq_hash(q, skb);
 sfq_index x;
// 该哈希值对应的队列号
 x = q->ht[hash];
// SFQ_DEPTH表示该队列还为空
 if (x == SFQ_DEPTH) {
  q->ht[hash] = x = q->dep[SFQ_DEPTH].next;
  q->hash[x] = hash;
 }
// 增加backlog
 sch->qstats.backlog += skb->len;
// 将数据包添加到队列链表
 __skb_queue_tail(&q->qs[x], skb);
// x节点增加操作
 sfq_inc(q, x);
// 如果队列长度为1, 是新队列
 if (q->qs[x].qlen == 1) {  /* The flow is new */
  if (q->tail == SFQ_DEPTH) { /* It is the first flow */
// 这是第一个队列的第一个包
   q->tail = x;
   q->next[x] = x;
   q->allot[x] = q->quantum;
  } else {
// q->tail为准备出队的那个队列索引
   q->next[x] = q->next[q->tail];
   q->next[q->tail] = x;
   q->tail = x;
  }
 }
// 检查当前排队数据包数是否超过限制值
 if (++sch->q.qlen < q->limit-1) {
  sch->bstats.bytes += skb->len;
  sch->bstats.packets++;
  return 0;
 }
// 超限制情况,丢包
 sfq_drop(sch);
 return NET_XMIT_CN;
}
5.5.5 重入队

// 和入队操作几乎一样, 只是统计值处理有点变化而已
static int
sfq_requeue(struct sk_buff *skb, struct Qdisc* sch)
{
 struct sfq_sched_data *q = qdisc_priv(sch);
 unsigned hash = sfq_hash(q, skb);
 sfq_index x;
 x = q->ht[hash];
 if (x == SFQ_DEPTH) {
  q->ht[hash] = x = q->dep[SFQ_DEPTH].next;
  q->hash[x] = hash;
 }
 sch->qstats.backlog += skb->len;
 __skb_queue_head(&q->qs[x], skb);
 sfq_inc(q, x);
 if (q->qs[x].qlen == 1) {  /* The flow is new */
  if (q->tail == SFQ_DEPTH) { /* It is the first flow */
   q->tail = x;
   q->next[x] = x;
   q->allot[x] = q->quantum;
  } else {
   q->next[x] = q->next[q->tail];
   q->next[q->tail] = x;
   q->tail = x;
  }
 }
 if (++sch->q.qlen < q->limit - 1) {
  sch->qstats.requeues++;
  return 0;
 }
 sch->qstats.drops++;
 sfq_drop(sch);
 return NET_XMIT_CN;
}
 

5.5.6 出队

static struct sk_buff *
sfq_dequeue(struct Qdisc* sch)
{
// SFQ私有数据
 struct sfq_sched_data *q = qdisc_priv(sch);
 struct sk_buff *skb;
 sfq_index a, old_a;
 /* No active slots */
// 队列空
 if (q->tail == SFQ_DEPTH)
  return NULL;
// q->tail为要出队的队列索引号
 a = old_a = q->next[q->tail];
 /* Grab packet */
// 数据包出队列
 skb = __skb_dequeue(&q->qs[a]);
// 减少该节点链接
 sfq_dec(q, a);
// 队列长度减
 sch->q.qlen--;
 sch->qstats.backlog -= skb->len;
 /* Is the slot empty? */
 if (q->qs[a].qlen == 0) {
// 队列已经空了, 该队列号对应哈希值复位
  q->ht[q->hash[a]] = SFQ_DEPTH;
  a = q->next[a];
  if (a == old_a) {
   q->tail = SFQ_DEPTH;
   return skb;
  }
  q->next[q->tail] = a;
  q->allot[a] += q->quantum;
 } else if ((q->allot[a] -= skb->len) <= 0) {
// 如果该队列额度不够, 更新q->tail为该队列索引
  q->tail = a;
// 下一个活动槽位
  a = q->next[a];
// 增加额度值
  q->allot[a] += q->quantum;
 }
 return skb;
}

5.5.7 复位
static void
sfq_reset(struct Qdisc* sch)
{
 struct sk_buff *skb;
// 从SFQ队列中进行出队操作, 释放数据包, 直到队列空
 while ((skb = sfq_dequeue(sch)) != NULL)
  kfree_skb(skb);
}
 
5.5.8 释放
static void sfq_destroy(struct Qdisc *sch)
{
 struct sfq_sched_data *q = qdisc_priv(sch);
// 只是进行删除定时器操作
 del_timer(&q->perturb_timer);
}

5.5.9 丢包

static unsigned int sfq_drop(struct Qdisc *sch)
{
// SFQ私有数据
 struct sfq_sched_data *q = qdisc_priv(sch);
// 最大队列深度
 sfq_index d = q->max_depth;
 struct sk_buff *skb;
 unsigned int len;
 /* Queue is full! Find the longest slot and
    drop a packet from it */
 if (d > 1) {
// 对应的x号队列
  sfq_index x = q->dep[d+SFQ_DEPTH].next;
  skb = q->qs[x].prev;
  len = skb->len;
// skb数据包从队列断开, 释放数据包
  __skb_unlink(skb, &q->qs[x]);
  kfree_skb(skb);
// 减少X节点使用
  sfq_dec(q, x);
// 统计数更新
  sch->q.qlen--;
  sch->qstats.drops++;
  sch->qstats.backlog -= len;
  return len;
 }
 if (d == 1) {
// 每个队列长度都是1的情况, 都只有一个数据包
  /* It is difficult to believe, but ALL THE SLOTS HAVE LENGTH 1. */
// 对应的队列索引
  d = q->next[q->tail];
// 更新下一槽位
  q->next[q->tail] = q->next[d];
  q->allot[q->next[d]] += q->quantum;
// 从队列取数据包释放
  skb = q->qs[d].prev;
  len = skb->len;
  __skb_unlink(skb, &q->qs[d]);
  kfree_skb(skb);
  sfq_dec(q, d);
// 统计值更新
  sch->q.qlen--;
  q->ht[q->hash[d]] = SFQ_DEPTH;
  sch->qstats.drops++;
  sch->qstats.backlog -= len;
  return len;
 }
 return 0;
}
 
5.5.10 输出参数

static int sfq_dump(struct Qdisc *sch, struct sk_buff *skb)
{
// SFQ私有数据
 struct sfq_sched_data *q = qdisc_priv(sch);
 unsigned char  *b = skb->tail;
// 向TC输出的SFQ选项结构
 struct tc_sfq_qopt opt;
// 填写SFQ选项参数
// 定额
 opt.quantum = q->quantum;
// 扰动周期
 opt.perturb_period = q->perturb_period/HZ;
// 队列包数限制
 opt.limit = q->limit;
 opt.divisor = SFQ_HASH_DIVISOR;
 opt.flows = q->limit;
// 打包到skb数据区
 RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
 return skb->len;
rtattr_failure:
 skb_trim(skb, b - skb->data);
 return -1;
}
 
...... 待续 ......