Linux内核中流量控制(21)

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

7.12 route

route分类是根据数据包的路由信息进行分类的, 路由信息中会带tclassid参数用于分类, 代码在net/sched/cls_route.c中定义, 只支持IPV4。

7.12.1 数据结构和过滤器操作结构

// route 快速映射结构, 相当于分类结果的cache
struct route4_fastmap
{
 struct route4_filter *filter;
 u32   id;
 int   iif;
};

// route头结构
struct route4_head
{
// 16个快速映射结构
 struct route4_fastmap fastmap[16];
// 257个bucket链表
 struct route4_bucket *table[256+1];
};
struct route4_bucket
{
 /* 16 FROM buckets + 16 IIF buckets + 1 wildcard bucket */
 struct route4_filter *ht[16+16+1];
};

// route过滤器结构
struct route4_filter
{
// 链表中的下一项
 struct route4_filter *next;
// ID
 u32   id;
// 网卡索引号
 int   iif;
// 分类结构
 struct tcf_result res;
// TCF扩展
 struct tcf_exts  exts;
// 句柄
 u32   handle;
// 所在的bucket
 struct route4_bucket *bkt;
};
#define ROUTE4_FAILURE ((struct route4_filter*)(-1L))
static struct tcf_ext_map route_ext_map = {
 .police = TCA_ROUTE4_POLICE,
 .action = TCA_ROUTE4_ACT
};

static struct tcf_ext_map tcindex_ext_map = {
 .police = TCA_TCINDEX_POLICE,
 .action = TCA_TCINDEX_ACT
};

// 分类操作结构
static struct tcf_proto_ops cls_route4_ops = {
 .next  = NULL,
 .kind  = "route",
 .classify = route4_classify,
 .init  = route4_init,
 .destroy = route4_destroy,
 .get  = route4_get,
 .put  = route4_put,
 .change  = route4_change,
 .delete  = route4_delete,
 .walk  = route4_walk,
 .dump  = route4_dump,
 .owner  = THIS_MODULE,
};

7.12.2 一些哈希函数

// 快速映射表位置哈希
static __inline__ int route4_fastmap_hash(u32 id, int iif)
{
// 取ID的低4位, 结果在0~15之间
 return id&0xF;
}

// 进入方向路由哈希
static __inline__ int route4_hash_to(u32 id)
{
// 取ID的低8位, 结果在0~255之间
 return id&0xFF;
}

// 来源方向路由哈希
static __inline__ int route4_hash_from(u32 id)
{
// 取ID的16~19位, 结果在0~15之间
 return (id>>16)&0xF;
}
// 网卡索引号哈希
static __inline__ int route4_hash_iif(int iif)
{
// 取网卡索引号的16~19位再加16, 结果在16~31之间
 return 16 + ((iif>>16)&0xF);
}

// 外卡哈希, 返回外卡哈希表号:32
static __inline__ int route4_hash_wild(void)
{
 return 32;
}

// 插入哈希, 从哈希表中删除时计算
static inline u32 to_hash(u32 id)
{
// 取低8位
 u32 h = id&0xFF;
// 第15位为1的话哈希值增加256
 if (id&0x8000)
  h += 256;
// 结果范围应该是0~511
 return h;
}

// 来源哈希, 插入哈希表时计算
static inline u32 from_hash(u32 id)
{
// 高16位清零
 id &= 0xFFFF;
// 低16位全1的话返回32, 外卡值
 if (id == 0xFFFF)
  return 32;
// 如果第15位为0
 if (!(id & 0x8000)) {
// 超过255的话返回256
  if (id > 255)
   return 256;
// 否则返回低4位, 范围为0~15
  return id&0xF;
 }
// 第15位为1
// 返回低4位加16, 范围为16~31
 return 16 + (id&0xF);
}

7.12.3 初始化

// 空函数
static int route4_init(struct tcf_proto *tp)
{
 return 0;
}

7.12.4 分类

// 分类结果处理宏
#define ROUTE4_APPLY_RESULT()     \
{        \
// 要返回的分类结果
 *res = f->res;      \
 if (tcf_exts_is_available(&f->exts)) {   \
// 执行TCF扩展操作
  int r = tcf_exts_exec(skb, &f->exts, res); \
  if (r < 0) {     \
// 操作失败, 不需要将结果进cache, 继续循环
   dont_cache = 1;    \
   continue;    \
  }      \
  return r;     \
 } else if (!dont_cache)     \
// 将结果进cache,
  route4_set_fastmap(head, id, iif, f);  \
 return 0;      \
}

static int route4_classify(struct sk_buff *skb, struct tcf_proto *tp,
      struct tcf_result *res)
{
// route头节点
 struct route4_head *head = (struct route4_head*)tp->root;
 struct dst_entry *dst;
 struct route4_bucket *b;
 struct route4_filter *f;
 u32 id, h;
 int iif, dont_cache = 0;

// 如果数据包路由项为空, 分类失败
 if ((dst = skb->dst) == NULL)
  goto failure;
// 类别ID
 id = dst->tclassid;
// 如果头节点空, 用老方法分类
 if (head == NULL)
  goto old_method;
// 网卡索引号
 iif = ((struct rtable*)dst)->fl.iif;
// 根据ID和网卡索引号计算快速映射哈希值
 h = route4_fastmap_hash(id, iif);
// 如果快速映射表中元素和此ID和网卡匹配, 而且过滤结构有效
 if (id == head->fastmap[h].id &&
     iif == head->fastmap[h].iif &&
     (f = head->fastmap[h].filter) != NULL) {
// 如果是错误分类, 返回失败
  if (f == ROUTE4_FAILURE)
   goto failure;
// 否则返回分类结构, 分类成功
  *res = f->res;
  return 0;
 }
// 单独根据ID计算路由to哈希值
 h = route4_hash_to(id);
restart:
// 如果该哈希值对应的表有效
 if ((b = head->table[h]) != NULL) {
// 根据ID哈希, 遍历合适的链表
  for (f = b->ht[route4_hash_from(id)]; f; f = f->next)
// 如果ID匹配, 成功返回
   if (f->id == id)
    ROUTE4_APPLY_RESULT();
// 根据网卡索引哈希, 遍历合适链表
  for (f = b->ht[route4_hash_iif(iif)]; f; f = f->next)
// 如果网卡索引匹配, 成功返回
   if (f->iif == iif)
    ROUTE4_APPLY_RESULT();
// 还没找到, 如果外卡链表存在的话, 也成功返回
  for (f = b->ht[route4_hash_wild()]; f; f = f->next)
   ROUTE4_APPLY_RESULT();
 }
// 哈希值对应的表为空的情况
// 如果哈希值太小, 更新其值后重新查找
 if (h < 256) {
  h = 256;
  id &= ~0xFFFF;
  goto restart;
 }
// 否则分类失败
// 如果需要保存在cache中, 将ID和网卡索引号保存到快速索引表中
 if (!dont_cache)
  route4_set_fastmap(head, id, iif, ROUTE4_FAILURE);
failure:
 return -1;
old_method:
// 老分类方法
// 如果ID有效, 而且ID高16位为0或高16位和handle的高16位相同
 if (id && (TC_H_MAJ(id) == 0 ||
     !(TC_H_MAJ(id^tp->q->handle)))) {
// 将ID作为类别ID返回
  res->classid = id;
  res->class = 0;
  return 0;
 }
 return -1;
}

7.12.5 释放

static void route4_destroy(struct tcf_proto *tp)
{
// 将根节点换出来准备释放
 struct route4_head *head = xchg(&tp->root, NULL);
 int h1, h2;
// 如果根节点空, 直接返回
 if (head == NULL)
  return;
// 遍历257个表
 for (h1=0; h1<=256; h1++) {
  struct route4_bucket *b;
// 如果链表头非空
  if ((b = head->table[h1]) != NULL) {
// 遍历bucket结构的33个filter链表
   for (h2=0; h2<=32; h2++) {
    struct route4_filter *f;
// 遍历每个链表
    while ((f = b->ht[h2]) != NULL) {
// 断开节点
     b->ht[h2] = f->next;
// 删除filter
     route4_delete_filter(tp, f);
    }
   }
// 释放bucket
   kfree(b);
  }
 }
// 释放根节点
 kfree(head);
}

static inline void
route4_delete_filter(struct tcf_proto *tp, struct route4_filter *f)
{
// 解除绑定
 tcf_unbind_filter(tp, &f->res);
// 释放TCF扩展结构
 tcf_exts_destroy(tp, &f->exts);
// 释放过滤器空间
 kfree(f);
}

7.12.6 获取

// 根据handle查找route4_filter结构
static unsigned long route4_get(struct tcf_proto *tp, u32 handle)
{
// 根节点
 struct route4_head *head = (struct route4_head*)tp->root;
 struct route4_bucket *b;
 struct route4_filter *f;
 unsigned h1, h2;

// 根节点空的话返回0
 if (!head)
  return 0;
// 根据handle计算哈希值
 h1 = to_hash(handle);
// 超过256的话返回0
 if (h1 > 256)
  return 0;
// 根据handle的高16位计算哈希找bucket
 h2 = from_hash(handle>>16);
// 超过32的话返回0
 if (h2 > 32)
  return 0;
// 如果bucket非空
 if ((b = head->table[h1]) != NULL) {
// 遍历链表
  for (f = b->ht[h2]; f; f = f->next)
// 查找handle匹配的filter节点返回
   if (f->handle == handle)
    return (unsigned long)f;
 }
 return 0;
}

7.12.7 放下
// 空函数
static void route4_put(struct tcf_proto *tp, unsigned long f)
{
}

7.12.8 修改

// 增加和修改tc filter规则时调用
static int route4_change(struct tcf_proto *tp, unsigned long base,
         u32 handle,
         struct rtattr **tca,
         unsigned long *arg)
{
// 根节点
 struct route4_head *head = tp->root;
 struct route4_filter *f, *f1, **fp;
 struct route4_bucket *b;
// 输入的选项参数
 struct rtattr *opt = tca[TCA_OPTIONS-1];
 struct rtattr *tb[TCA_ROUTE4_MAX];
 unsigned int h, th;
 u32 old_handle = 0;
 int err;
// 选项参数空, 返回
 if (opt == NULL)
  return handle ? -EINVAL : 0;
// 解析选项参数, 结果保存到tb数组
 if (rtattr_parse_nested(tb, TCA_ROUTE4_MAX, opt) < 0)
  return -EINVAL;
// 过滤器参数非空, 是修改操作
 if ((f = (struct route4_filter*)*arg) != NULL) {
// 比较handle是否正确
  if (f->handle != handle && handle)
   return -EINVAL;
// 如果已经在某bucket的链表里, 保存handle
  if (f->bkt)
   old_handle = f->handle;
// 设置过滤器参数, 函数最后一个参数为0表示是修改
  err = route4_set_parms(tp, base, f, handle, head, tb,
   tca[TCA_RATE-1], 0);
// 操作失败, 返回错误
  if (err < 0)
   return err;
// 成功则跳转重新插入, 将f从原链表中断开的操作也在后面进行
  goto reinsert;
 }
// 过滤器参数空, 是新建操作
 err = -ENOBUFS;
 if (head == NULL) {
// 如果根节点为空, 分配更节点空间
  head = kzalloc(sizeof(struct route4_head), GFP_KERNEL);
  if (head == NULL)
   goto errout;
  tcf_tree_lock(tp);
// 将其作为tcf_proto的根参数指针
  tp->root = head;
  tcf_tree_unlock(tp);
 }
// 分配新的过滤器空间
 f = kzalloc(sizeof(struct route4_filter), GFP_KERNEL);
 if (f == NULL)
  goto errout;
// 设置过滤器参数, 函数最后一个参数为1表示是新建
 err = route4_set_parms(tp, base, f, handle, head, tb,
  tca[TCA_RATE-1], 1);
// 失败的话转失败处理
 if (err < 0)
  goto errout;
reinsert:
// 重新插入操作, 将过滤器f插入合适的bucket链表, 对于修改操作, 因为参数变了,
// 所以要重新插入到合适的bucket中
// 计算from哈希
 h = from_hash(f->handle >> 16);
// 遍历相应的哈希链表查找插入位置, 该链表是按handle值排序, 小的在前, 大的在后
 for (fp = &f->bkt->ht[h]; (f1=*fp) != NULL; fp = &f1->next)
  if (f->handle < f1->handle)
    break;
// 将新节点插入链表
 f->next = f1;
 tcf_tree_lock(tp);
 *fp = f;
// 如果handle发生了变化, 需要将该过滤器从原来的链表中断开
// 不过找哪个哈希表的过程确挺费解的
 if (old_handle && f->handle != old_handle) {
// 计算老handle的to哈希
  th = to_hash(old_handle);
// 计算老handle高16位的from哈希
  h = from_hash(old_handle >> 16);
// to哈希链表非空
  if ((b = head->table[th]) != NULL) {
// 遍历链表
   for (fp = &b->ht[h]; *fp; fp = &(*fp)->next) {
// 查找过滤器节点
    if (*fp == f) {
// 从链表中断开
     *fp = f->next;
     break;
    }
   }
  }
 }
 tcf_tree_unlock(tp);
// 复位快速映射数组, 全部清零
 route4_reset_fastmap(tp->q->dev, head, f->id);
// 返回f的地址
 *arg = (unsigned long)f;
 return 0;
errout:
 kfree(f);
 return err;
}

// 设置过滤器参数
static int route4_set_parms(struct tcf_proto *tp, unsigned long base,
 struct route4_filter *f, u32 handle, struct route4_head *head,
 struct rtattr **tb, struct rtattr *est, int new)
{
 int err;
 u32 id = 0, to = 0, nhandle = 0x8000;
 struct route4_filter *fp;
 unsigned int h1;
 struct route4_bucket *b;
 struct tcf_exts e;
// TCF扩展验证
 err = tcf_exts_validate(tp, tb, est, &e, &route_ext_map);
 if (err < 0)
  return err;
 err = -EINVAL;
// 判断类别ID是否合法
 if (tb[TCA_ROUTE4_CLASSID-1])
  if (RTA_PAYLOAD(tb[TCA_ROUTE4_CLASSID-1]) < sizeof(u32))
   goto errout;
// 解析TO参数
 if (tb[TCA_ROUTE4_TO-1]) {
  if (new && handle & 0x8000)
   goto errout;
  if (RTA_PAYLOAD(tb[TCA_ROUTE4_TO-1]) < sizeof(u32))
   goto errout;
  to = *(u32*)RTA_DATA(tb[TCA_ROUTE4_TO-1]);
// TO参数不能超过255
  if (to > 0xFF)
   goto errout;
// 将TO参数作为nhandle的低0~8位
  nhandle = to;
 }
// 如果存在FROM参数
 if (tb[TCA_ROUTE4_FROM-1]) {
// 解析FROM参数
  if (tb[TCA_ROUTE4_IIF-1])
   goto errout;
  if (RTA_PAYLOAD(tb[TCA_ROUTE4_FROM-1]) < sizeof(u32))
   goto errout;
  id = *(u32*)RTA_DATA(tb[TCA_ROUTE4_FROM-1]);
// FROM参数也不能超过255
  if (id > 0xFF)
   goto errout;
// 将FROM参数作为nhandle的16~23位
  nhandle |= id << 16;
 } else if (tb[TCA_ROUTE4_IIF-1]) {
// 否则如果存在网卡参数
  if (RTA_PAYLOAD(tb[TCA_ROUTE4_IIF-1]) < sizeof(u32))
   goto errout;
  id = *(u32*)RTA_DATA(tb[TCA_ROUTE4_IIF-1]);
// 网卡参数不能超过0x7ffff
  if (id > 0x7FFF)
   goto errout;
// 将网卡参数作为nhandle的16~30位, 同时第15位置1
  nhandle |= (id | 0x8000) << 16;
 } else
// 否则nhandle高16位全1
  nhandle |= 0xFFFF << 16;
 if (handle && new) {
// 如果是新建而且handle非0
// 更新nhandle, 前面的计算全部费了
  nhandle |= handle & 0x7F00;
// 对于新建的filter, handle只能是在16~22位可以为1
  if (nhandle != handle)
   goto errout;
 }
// 计算新handle的to哈希
 h1 = to_hash(nhandle);
// 如果对应哈希值的bucket为空
 if ((b = head->table[h1]) == NULL) {
  err = -ENOBUFS;
// 分配bucket空间
  b = kzalloc(sizeof(struct route4_bucket), GFP_KERNEL);
  if (b == NULL)
   goto errout;
  tcf_tree_lock(tp);
// 赋值到bucket头数组
  head->table[h1] = b;
  tcf_tree_unlock(tp);
 } else {
// 否则计算高16位的from哈希
  unsigned int h2 = from_hash(nhandle >> 16);
  err = -EEXIST;
// 遍历bucket中相应的链表, 查找是否已经有相同的handle, 找到的话返回错误
  for (fp = b->ht[h2]; fp; fp = fp->next)
   if (fp->handle == f->handle)
    goto errout;
 }
 tcf_tree_lock(tp);
// 如果TO参数存在的话, ID取TO参数
 if (tb[TCA_ROUTE4_TO-1])
  f->id = to;

// 如果FROM参数存在的话, ID放到ID的高16位
 if (tb[TCA_ROUTE4_FROM-1])
  f->id = to | id<<16;
 else if (tb[TCA_ROUTE4_IIF-1])
  f->iif = id;
// 过滤器的新handle
 f->handle = nhandle;
// 过滤器所在的bucket
 f->bkt = b;
 tcf_tree_unlock(tp);
// 设置类别ID, 绑定过滤器
 if (tb[TCA_ROUTE4_CLASSID-1]) {
  f->res.classid = *(u32*)RTA_DATA(tb[TCA_ROUTE4_CLASSID-1]);
  tcf_bind_filter(tp, &f->res, base);
 }
// TCF扩展修改操作
 tcf_exts_change(tp, &f->exts, &e);
 return 0;
errout:
 tcf_exts_destroy(tp, &e);
 return err;
}

7.12.9 删除

static int route4_delete(struct tcf_proto *tp, unsigned long arg)
{
// 更节点
 struct route4_head *head = (struct route4_head*)tp->root;
// f是要删除的节点
 struct route4_filter **fp, *f = (struct route4_filter*)arg;
 unsigned h = 0;
 struct route4_bucket *b;
 int i;
// 根节点或要删除的节点为空, 参数错误
 if (!head || !f)
  return -EINVAL;
// 获取过滤器节点的handle和所在的bucket
 h = f->handle;
 b = f->bkt;
// 遍历该bucket的链表
 for (fp = &b->ht[from_hash(h>>16)]; *fp; fp = &(*fp)->next) {
// 查找f节点
  if (*fp == f) {
// 找到
   tcf_tree_lock(tp);
// 将该节点从链表中断开
   *fp = f->next;
   tcf_tree_unlock(tp);
// 复位快速映射表, 是将fastmap数组全部清零了, 好象是连坐一样
   route4_reset_fastmap(tp->q->dev, head, f->id);
// 释放该过滤器f
   route4_delete_filter(tp, f);
   /* Strip tree */
// 检查该f所在bucket是否已经空了
   for (i=0; i<=32; i++)
    if (b->ht[i])
     return 0;
   /* OK, session has no flows */
// 如果空了, 就准备删除该bucket
   tcf_tree_lock(tp);
// 哈希表头置空
   head->table[to_hash(h)] = NULL;
   tcf_tree_unlock(tp);
// 释放bucket
   kfree(b);
   return 0;
  }
 }
 return 0;
}

7.12.10 遍历

static void route4_walk(struct tcf_proto *tp, struct tcf_walker *arg)
{
// 根节点
 struct route4_head *head = tp->root;
 unsigned h, h1;

// 根节点空的话设置停止标志
 if (head == NULL)
  arg->stop = 1;
// 设置了停止标志时直接返回
 if (arg->stop)
  return;
// 遍历257个bucket
 for (h = 0; h <= 256; h++) {
  struct route4_bucket *b = head->table[h];
// 如果该bucket非空
  if (b) {
// 遍历33个链表
   for (h1 = 0; h1 <= 32; h1++) {
    struct route4_filter *f;
// 遍历链表
    for (f = b->ht[h1]; f; f = f->next) {
// 检查是否是需要跳过的节点
     if (arg->count < arg->skip) {
      arg->count++;
      continue;
     }
// 执行单节点处理函数
     if (arg->fn(tp, (unsigned long)f, arg) < 0) {
// 失败的话设置停止标志, 返回
      arg->stop = 1;
      return;
     }
     arg->count++;
    }
   }
  }
 }
}

7.12.11 输出

static int route4_dump(struct tcf_proto *tp, unsigned long fh,
         struct sk_buff *skb, struct tcmsg *t)
{
// 要输出的route过滤器节点
 struct route4_filter *f = (struct route4_filter*)fh;
// skb数据包缓冲区定位
 unsigned char  *b = skb->tail;
 struct rtattr *rta;
 u32 id;
// 过滤器空, 返回
 if (f == NULL)
  return skb->len;
// 填写handle
 t->tcm_handle = f->handle;
// 结构定位
 rta = (struct rtattr*)b;
 RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
// 输出ROUTE_TO
 if (!(f->handle&0x8000)) {
  id = f->id&0xFF;
  RTA_PUT(skb, TCA_ROUTE4_TO, sizeof(id), &id);
 }
 if (f->handle&0x80000000) {
// handle最高位为1
  if ((f->handle>>16) != 0xFFFF)
// handle高16非全1的话输出网卡索引号
   RTA_PUT(skb, TCA_ROUTE4_IIF, sizeof(f->iif), &f->iif);
 } else {
// handle最高位为0
// ID高16位是ROUTE_FROM
  id = f->id>>16;
  RTA_PUT(skb, TCA_ROUTE4_FROM, sizeof(id), &id);
 }
// 类别ID
 if (f->res.classid)
  RTA_PUT(skb, TCA_ROUTE4_CLASSID, 4, &f->res.classid);
// TCF扩展输出
 if (tcf_exts_dump(skb, &f->exts, &route_ext_map) < 0)
  goto rtattr_failure;
 rta->rta_len = skb->tail - b;
// TCF扩展统计
 if (tcf_exts_dump_stats(skb, &f->exts, &route_ext_map) < 0)
  goto rtattr_failure;
 return skb->len;
rtattr_failure:
 skb_trim(skb, b - skb->data);
 return -1;
}

7.13 小结

分类操作结构分析告一段落, 基本的特点就是对节点操作时都不直接操作, 而是先在链表中查找确认后才操作, 这也是sched各种代码的共同特征, 为什么不能直接操作呢? 难道是怕在get操作时获取的结构指针在后来操作时已经被删除了? 不过的确这些结构中不是所有都有引用计数的原子操作; 另外一点就是handle的取值, 每个操作结构所对应的handle各个位的定义是不同, 同时进行各种哈希操作也不同, 这些都需要注意, 不过在此不仔细比较各类型的handle的不同了, 有兴趣的自己去分析。

...... 待续 ......