Linux内核中流量控制(22)

本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。
msn: yfydz_no1@hotmail.com
来源：http://yfydz.cublog.cn 8. action动作操作
8.1 概述
tc action命令是用来定义数据包进行最终处理方法的命令, 其功能就象netfilter的target一样, 需要内核定义NET_CLS_ACT选项。
动作处理的基本api在net/sched/act_api.c中定义, 而各种动作方法在net/sched/act_*.c中定义。
8.2 数据结构/* include/net/act_api.h */
// TCF通用结构, 实际是用来描述动作的, 这是通用结构, 每种动作结构还有自己的
// 私有数据
struct tcf_common {
struct tcf_common *tcfc_next;
u32 tcfc_index;
int tcfc_refcnt;
int tcfc_bindcnt;
u32 tcfc_capab;
int tcfc_action;
struct tcf_t tcfc_tm;
struct gnet_stats_basic tcfc_bstats;
struct gnet_stats_queue tcfc_qstats;
struct gnet_stats_rate_est tcfc_rate_est;
spinlock_t *tcfc_stats_lock;
spinlock_t tcfc_lock;
};
#define tcf_next common.tcfc_next
#define tcf_index common.tcfc_index
#define tcf_refcnt common.tcfc_refcnt
#define tcf_bindcnt common.tcfc_bindcnt
#define tcf_capab common.tcfc_capab
#define tcf_action common.tcfc_action
#define tcf_tm common.tcfc_tm
#define tcf_bstats common.tcfc_bstats
#define tcf_qstats common.tcfc_qstats
#define tcf_rate_est common.tcfc_rate_est
#define tcf_stats_lock common.tcfc_stats_lock
#define tcf_lock common.tcfc_lock
// action操作结果, 其实这是一个中间数据结构, 在操作过程中产生的
// 命令执行完其实也就释放了没必要一直保存
struct tc_action {
// 私有数据
void *priv;
// 操作结构
struct tc_action_ops *ops;
// 类型
__u32 type; /* for backward compat(TCA_OLD_COMPAT) */
// 阶数
__u32 order;
// 动作链表下一项
struct tc_action *next;
};#define TCA_CAP_NONE 0
// action操作结构, 实际就是定义目标操作, 通常每个匹配操作都由一个静态tcf_action_ops
// 结构定义, 作为一个内核模块, 初始化事登记系统的链表
struct tc_action_ops {
// 链表中的下一项
struct tc_action_ops *next;
struct tcf_hashinfo *hinfo;
// 名称
char kind[IFNAMSIZ];
__u32 type; /* TBD to match kind */
__u32 capab; /* capabilities includes 4 bit version */
struct module *owner;
// 动作
int (*act)(struct sk_buff *, struct tc_action *, struct tcf_result *);
// 获取统计参数
int (*get_stats)(struct sk_buff *, struct tc_action *);
// 输出
int (*dump)(struct sk_buff *, struct tc_action *, int, int);
// 清除
int (*cleanup)(struct tc_action *, int bind);
// 查找
int (*lookup)(struct tc_action *, u32);
// 初始化
int (*init)(struct rtattr *, struct rtattr *, struct tc_action *, int , int);
// 遍历
int (*walk)(struct sk_buff *, struct netlink_callback *, int, struct tc_action *);
};
8.3 初始化
/* net/sched/act_api.c */static int __init tc_action_init(void)
{
struct rtnetlink_link *link_p = rtnetlink_links[PF_UNSPEC]; if (link_p) {
// 定义action操作处理函数
// 关于action的增加/删除/获取等操作
link_p[RTM_NEWACTION-RTM_BASE].doit = tc_ctl_action;
link_p[RTM_DELACTION-RTM_BASE].doit = tc_ctl_action;
link_p[RTM_GETACTION-RTM_BASE].doit = tc_ctl_action;
link_p[RTM_GETACTION-RTM_BASE].dumpit = tc_dump_action;
} return 0;
}
8.4 filter控制
相关函数调用关系:tc_ctl_action
-> tcf_action_add
-> tcf_action_init
-> tcf_action_init_1
-> tc_lookup_action_n
-> action_ops->init
-> tcf_add_notify
-> tcf_action_dump
-> tcf_action_dump_1
-> tcf_action_dump_old
-> a->ops->dump
-> tcf_action_gd
-> tca_action_flush
-> create_a
-> tcf_action_get_1
-> act_get_notify
-> tca_get_fill
-> tcf_action_dump
-> rtnl_unicast
-> tca_get_fill
-> tcf_action_destroy
8.4.1 编辑操作// 用于增加, 修改, 删除, 获取动作结构
static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
{
// 属性配置参数
struct rtattr **tca = arg;
// 用户空间进程的pid
u32 pid = skb ? NETLINK_CB(skb).pid : 0;
int ret = 0, ovr = 0;// 动作参数为空, 返回非法参数错误
if (tca[TCA_ACT_TAB-1] == NULL) {
printk("tc_ctl_action: received NO action attribs\n");
return -EINVAL;
} /* n->nlmsg_flags&NLM_F_CREATE
* */
switch (n->nlmsg_type) {
case RTM_NEWACTION:
// 新建
/* we are going to assume all other flags
* imply create only if it doesnt exist
* Note that CREATE | EXCL implies that
* but since we want avoid ambiguity (eg when flags
* is zero) then just set this
*/
// 是否是修改操作
if (n->nlmsg_flags&NLM_F_REPLACE)
ovr = 1;
replay:
ret = tcf_action_add(tca[TCA_ACT_TAB-1], n, pid, ovr);
// 如果操作结果是重来, 重新进行添加操作, 在相关动作的内核模块没插入内核时会出现这种情况
if (ret == -EAGAIN)
goto replay;
break;
case RTM_DELACTION:
// 删除动作
ret = tca_action_gd(tca[TCA_ACT_TAB-1], n, pid, RTM_DELACTION);
break;
case RTM_GETACTION:
// 获取动作
ret = tca_action_gd(tca[TCA_ACT_TAB-1], n, pid, RTM_GETACTION);
break;
default:
BUG();
} return ret;
}
8.4.2 增加// 添加动作
static int
tcf_action_add(struct rtattr *rta, struct nlmsghdr *n, u32 pid, int ovr)
{
int ret = 0;
struct tc_action *act;
struct tc_action *a;
u32 seq = n->nlmsg_seq;// 根据选项信息进行TCF动作结构的初始化, 生成动作链表, 注意, 这个链表只是中间结果
act = tcf_action_init(rta, NULL, NULL, ovr, 0, &ret);
if (act == NULL)
goto done; /* dump then free all the actions after update; inserted policy
* stays intact
* */
// 向pid进程发送netlink通知消息
ret = tcf_add_notify(act, pid, seq, RTM_NEWACTION, n->nlmsg_flags);
// 释放动作链表中的所有节点, 因为是中间结果, 没必要保存的
for (a = act; a; a = act) {
// 断开链表
act = a->next;
// 释放动作的内存空间
kfree(a);
}
done:
return ret;
}
// 动作初始化
struct tc_action *tcf_action_init(struct rtattr *rta, struct rtattr *est,
char *name, int ovr, int bind, int *err)
{
struct rtattr *tb[TCA_ACT_MAX_PRIO+1];
struct tc_action *head = NULL, *act, *act_prev = NULL;
int i;// 解析动作参数, TCA_ACT_MAX_PRIO为32
if (rtattr_parse_nested(tb, TCA_ACT_MAX_PRIO, rta) < 0) {
*err = -EINVAL;
return head;
}// 循环所有参数项
for (i=0; i < TCA_ACT_MAX_PRIO && tb[i]; i++) {
// 初始化一个动作结构
act = tcf_action_init_1(tb[i], est, name, ovr, bind, err);
// 失败的话返回
if (act == NULL)
goto err;
// 动作顺序
act->order = i+1;// 加入一head为头指针的动作链表
if (head == NULL)
head = act;
else
act_prev->next = act;
act_prev = act;
}
// 返回链表头指针
return head;err:
// 错误处理, 释放当前链表所有节点
if (head != NULL)
tcf_action_destroy(head, bind);
return NULL;
}
// 初始化单个动作
struct tc_action *tcf_action_init_1(struct rtattr *rta, struct rtattr *est,
char *name, int ovr, int bind, int *err)
{
struct tc_action *a;
struct tc_action_ops *a_o;
char act_name[IFNAMSIZ];
struct rtattr *tb[TCA_ACT_MAX+1];
struct rtattr *kind; *err = -EINVAL; if (name == NULL) {
// 名称参数为空, 从配置参数中提取名称
if (rtattr_parse_nested(tb, TCA_ACT_MAX, rta) < 0)
goto err_out;
// 动作名称
kind = tb[TCA_ACT_KIND-1];
if (kind == NULL)
goto err_out;
// 名称复制
if (rtattr_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ)
goto err_out;
} else {
// 名称复制
if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ)
goto err_out;
}// 根据名称查找动作操作结构
a_o = tc_lookup_action_n(act_name);
if (a_o == NULL) {
#ifdef CONFIG_KMOD
// 如果没找到, 进行模块请求操作, 动态插入和名称对应的动作模块
rtnl_unlock();
request_module("act_%s", act_name);
rtnl_lock();
// 重新查找动作操作结构
a_o = tc_lookup_action_n(act_name); /* We dropped the RTNL semaphore in order to
* perform the module load. So, even if we
* succeeded in loading the module we have to
* tell the caller to replay the request. We
* indicate this using -EAGAIN.
*/
// 找到, 返回EAGAIN错误, 重新操作
if (a_o != NULL) {
*err = -EAGAIN;
goto err_mod;
}
#endif
// 否则操作失败, 没有该类型的动作操作
*err = -ENOENT;
goto err_out;
} *err = -ENOMEM;
// 分配动作空间
a = kzalloc(sizeof(*a), GFP_KERNEL);
if (a == NULL)
goto err_mod; /* backward compatibility for policer */
// 调用动作操作结构的初始化函数进行初始化
if (name == NULL)
*err = a_o->init(tb[TCA_ACT_OPTIONS-1], est, a, ovr, bind);
else
*err = a_o->init(rta, est, a, ovr, bind);
if (*err < 0)
goto err_free; /* module count goes up only when brand new policy is created
if it exists and is only bound to in a_o->init() then
ACT_P_CREATED is not returned (a zero is).
*/
// 如果初始化结果不是ACT_P_CREATED, 减少模块计数
if (*err != ACT_P_CREATED)
module_put(a_o->owner);
// 操作结构指针复制
a->ops = a_o; *err = 0;
return a;err_free:
kfree(a);
err_mod:
module_put(a_o->owner);
err_out:
return NULL;
}
// 增加操作通告
static int tcf_add_notify(struct tc_action *a, u32 pid, u32 seq, int event,
u16 flags)
{
struct tcamsg *t;
struct nlmsghdr *nlh;
struct sk_buff *skb;
struct rtattr *x;
unsigned char *b;
int err = 0;
// 分配数据包用于发送到用户空间进程
skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
if (!skb)
return -ENOBUFS;
// 数据缓存起始点
b = (unsigned char *)skb->tail;// 构造netlink头
nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags);
// TC动作信息头
t = NLMSG_DATA(nlh);
t->tca_family = AF_UNSPEC;
t->tca__pad1 = 0;
t->tca__pad2 = 0; x = (struct rtattr*) skb->tail;
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
// 输出动作参数
if (tcf_action_dump(skb, a, 0, 0) < 0)
goto rtattr_failure;
// rtnetlink信息长度
x->rta_len = skb->tail - (u8*)x;
// netlink信息长度
nlh->nlmsg_len = skb->tail - b;
NETLINK_CB(skb).dst_group = RTNLGRP_TC;
// 发送消息
err = rtnetlink_send(skb, pid, RTNLGRP_TC, flags&NLM_F_ECHO);
if (err > 0)
err = 0;
return err;rtattr_failure:
nlmsg_failure:
kfree_skb(skb);
return -1;
} // 动作参数输出
int
tcf_action_dump(struct sk_buff *skb, struct tc_action *act, int bind, int ref)
{
struct tc_action *a;
int err = -EINVAL;
unsigned char *b = skb->tail;
struct rtattr *r ;// 遍历动作链表
while ((a = act) != NULL) {
// 当前数据末尾
r = (struct rtattr*) skb->tail;
act = a->next;
RTA_PUT(skb, a->order, 0, NULL);
// 填充动作结构参数
err = tcf_action_dump_1(skb, a, bind, ref);
if (err < 0)
goto errout;
// 该rtnetlink消息长度
r->rta_len = skb->tail - (u8*)r;
} return 0;rtattr_failure:
err = -EINVAL;
errout:
skb_trim(skb, b - skb->data);
return err;
}
// 输出单一动作结构参数
int
tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
{
int err = -EINVAL;
unsigned char *b = skb->tail;
struct rtattr *r;// 如果没有动作操作结构或操作结构中无dump输出函数, 返回失败
if (a->ops == NULL || a->ops->dump == NULL)
return err; RTA_PUT(skb, TCA_KIND, IFNAMSIZ, a->ops->kind);
// 输出统计参数
if (tcf_action_copy_stats(skb, a, 0))
goto rtattr_failure;
r = (struct rtattr*) skb->tail;
RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
// 动作参数输出
if ((err = tcf_action_dump_old(skb, a, bind, ref)) > 0) {
r->rta_len = skb->tail - (u8*)r;
return err;
}rtattr_failure:
skb_trim(skb, b - skb->data);
return -1;
}
// 调用动作操作结构的dump函数输出动作参数信息
int
tcf_action_dump_old(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
{
int err = -EINVAL; if (a->ops == NULL || a->ops->dump == NULL)
return err;
return a->ops->dump(skb, a, bind, ref);
}
8.4.3 获取/删除动作
static int
tca_action_gd(struct rtattr *rta, struct nlmsghdr *n, u32 pid, int event)
{
int i, ret = 0;
struct rtattr *tb[TCA_ACT_MAX_PRIO+1];
struct tc_action *head = NULL, *act, *act_prev = NULL;// 选项参数解析
if (rtattr_parse_nested(tb, TCA_ACT_MAX_PRIO, rta) < 0)
return -EINVAL;
if (event == RTM_DELACTION && n->nlmsg_flags&NLM_F_ROOT) {
// 删除根节点操作
if (tb[0] != NULL && tb[1] == NULL)
// 删除全部动作
return tca_action_flush(tb[0], n, pid);
}// 遍历所有参数
for (i=0; i < TCA_ACT_MAX_PRIO && tb[i]; i++) {
// 获取一个动作
act = tcf_action_get_1(tb[i], n, pid, &ret);
if (act == NULL)
goto err;
act->order = i+1;
// 添加到以head为头的链表中
if (head == NULL)
head = act;
else
act_prev->next = act;
act_prev = act;
} if (event == RTM_GETACTION)
// 如果是获取动作, 发送获取的动作链表到用户空间进程
ret = act_get_notify(pid, n, head, event);
else { /* delete */
// 否则是删除操作
struct sk_buff *skb;
// 分配一个skb数据包准备发送删除通告
skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
if (!skb) {
ret = -ENOBUFS;
goto err;
}
// TC动作信息填充到skb数据包中
if (tca_get_fill(skb, head, pid, n->nlmsg_seq, 0, event,
0, 1) <= 0) {
// 填充失败返回
kfree_skb(skb);
ret = -EINVAL;
goto err;
} /* now do the delete */
// 释放动作, 注意这里的释放和下面的cleanup_a()不同, 操作更复杂
tcf_action_destroy(head, 0);
// 发送数据包到pid进程
ret = rtnetlink_send(skb, pid, RTNLGRP_TC,
n->nlmsg_flags&NLM_F_ECHO);
if (ret > 0)
return 0;
return ret;
}
err:
// 删除head链表, 只是简单释放动态内存空间
cleanup_a(head);
return ret;
}
// 删除全部动作
static int tca_action_flush(struct rtattr *rta, struct nlmsghdr *n, u32 pid)
{
struct sk_buff *skb;
unsigned char *b;
struct nlmsghdr *nlh;
struct tcamsg *t;
struct netlink_callback dcb;
struct rtattr *x;
struct rtattr *tb[TCA_ACT_MAX+1];
struct rtattr *kind;
// 先分配一个动作结构, 阶数为0, 这个节点只是用来辅助操作用的, 其实可以是一个结构
// 只是为了减少所用的堆栈空间
struct tc_action *a = create_a(0);
int err = -EINVAL; if (a == NULL) {
printk("tca_action_flush: couldnt create tc_action\n");
return err;
}// 分配数据包
skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
if (!skb) {
printk("tca_action_flush: failed skb alloc\n");
kfree(a);
return -ENOBUFS;
}
// 数据缓冲区起始点
b = (unsigned char *)skb->tail;
// 解析参数
if (rtattr_parse_nested(tb, TCA_ACT_MAX, rta) < 0)
goto err_out;
// 动作类型
kind = tb[TCA_ACT_KIND-1];
// 根据名称查找动作类型
a->ops = tc_lookup_action(kind);
if (a->ops == NULL)
goto err_out;
// 填充netlink数据头
nlh = NLMSG_PUT(skb, pid, n->nlmsg_seq, RTM_DELACTION, sizeof(*t));
t = NLMSG_DATA(nlh);
t->tca_family = AF_UNSPEC;
t->tca__pad1 = 0;
t->tca__pad2 = 0; x = (struct rtattr *) skb->tail;
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
// 调用动作操作结构的遍历操作函数进行删除, 其实最终调用的是tcf_del_walker
err = a->ops->walk(skb, &dcb, RTM_DELACTION, a);
if (err < 0)
goto rtattr_failure;
// 实际数据长度
x->rta_len = skb->tail - (u8 *) x; nlh->nlmsg_len = skb->tail - b;
nlh->nlmsg_flags |= NLM_F_ROOT;
module_put(a->ops->owner);
// 释放a节点
kfree(a);
// 发送数据包
err = rtnetlink_send(skb, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
if (err > 0)
return 0; return err;rtattr_failure:
nlmsg_failure:
module_put(a->ops->owner);
err_out:
kfree_skb(skb);
kfree(a);
return err;
}
// 填充动作参数到数据包
static int
tca_get_fill(struct sk_buff *skb, struct tc_action *a, u32 pid, u32 seq,
u16 flags, int event, int bind, int ref)
{
struct tcamsg *t;
struct nlmsghdr *nlh;
unsigned char *b = skb->tail;
struct rtattr *x;
// 构造netlink数据头
nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags);// TC动作信息
t = NLMSG_DATA(nlh);
t->tca_family = AF_UNSPEC;
t->tca__pad1 = 0;
t->tca__pad2 = 0;
// 属性参数结构指针
x = (struct rtattr*) skb->tail;
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);// 动作结构输出
if (tcf_action_dump(skb, a, bind, ref) < 0)
goto rtattr_failure;
// 数据长度
x->rta_len = skb->tail - (u8*)x;
// netlink消息长度
nlh->nlmsg_len = skb->tail - b;
return skb->len;rtattr_failure:
nlmsg_failure:
skb_trim(skb, b - skb->data);
return -1;
}
// 动作结构释放
void tcf_action_destroy(struct tc_action *act, int bind)
{
struct tc_action *a;// 遍历链表
for (a = act; a; a = act) {
if (a->ops && a->ops->cleanup) {
// 执行操作结构中的清除操作,
if (a->ops->cleanup(a, bind) == ACT_P_DELETED)
module_put(a->ops->owner);
// 断开节点
act = act->next;
// 释放节点
kfree(a);
} else { /*FIXME: Remove later - catch insertion bugs*/
// 无清除操作, 直接断开链表, 释放节点
printk("tcf_action_destroy: BUG? destroying NULL ops\n");
act = act->next;
kfree(a);
}
}
}
8.5 filter输出
static int
tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb)
{
struct nlmsghdr *nlh;
// 数据包缓冲区起始点
unsigned char *b = skb->tail;
struct rtattr *x;
struct tc_action_ops *a_o;
// 这个动作参数只是一个辅助作用
struct tc_action a;
int ret = 0;
struct tcamsg *t = (struct tcamsg *) NLMSG_DATA(cb->nlh);
// 查找动作类型名称
struct rtattr *kind = find_dump_kind(cb->nlh); if (kind == NULL) {
printk("tc_dump_action: action bad kind\n");
return 0;
}
// 根据类型名称查找动作操作结构
a_o = tc_lookup_action(kind);
if (a_o == NULL) {
return 0;
}
// 结构清零
memset(&a, 0, sizeof(struct tc_action));
// 动作操作结构赋值
a.ops = a_o;// 如果该操作结构中没有遍历函数, 失败
if (a_o->walk == NULL) {
printk("tc_dump_action: %s !capable of dumping table\n", a_o->kind);
goto rtattr_failure;
}// 填写netlink头数据
nlh = NLMSG_PUT(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
cb->nlh->nlmsg_type, sizeof(*t));
t = NLMSG_DATA(nlh);
t->tca_family = AF_UNSPEC;
t->tca__pad1 = 0;
t->tca__pad2 = 0; x = (struct rtattr *) skb->tail;
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
// 遍历所有action节点执行GET操作
ret = a_o->walk(skb, cb, RTM_GETACTION, &a);
if (ret < 0)
goto rtattr_failure;
// 操作成功, 设置数据包长度
if (ret > 0) {
x->rta_len = skb->tail - (u8 *) x;
ret = skb->len;
} else
skb_trim(skb, (u8*)x - skb->data);
// 填充的数据长度
nlh->nlmsg_len = skb->tail - b;
if (NETLINK_CB(cb->skb).pid && ret)
nlh->nlmsg_flags |= NLM_F_MULTI;
// 减少模块引用, 因为在tc_lookup_action时增加了引用
module_put(a_o->owner);
return skb->len;rtattr_failure:
nlmsg_failure:
module_put(a_o->owner);
skb_trim(skb, b - skb->data);
return skb->len;
}
8.6 其他相关函数
8.6.1 遍历
// 通用遍历函数, 在一些动作操作结构中的walk函数就用这个函数
// 不过只进行删除和输出两种遍历操作
int tcf_generic_walker(struct sk_buff *skb, struct netlink_callback *cb,
int type, struct tc_action *a)
{
// 哈希信息结构
struct tcf_hashinfo *hinfo = a->ops->hinfo;
// 根据动作类型进行不同的遍历操作
if (type == RTM_DELACTION) {
// 删除遍历
return tcf_del_walker(skb, a, hinfo);
} else if (type == RTM_GETACTION) {
// 输出遍历
return tcf_dump_walker(skb, cb, a, hinfo);
} else {
// 其他是非法参数
printk("tcf_generic_walker: unknown action %d\n", type);
return -EINVAL;
}
}
// 输出遍历
static int tcf_dump_walker(struct sk_buff *skb, struct netlink_callback *cb,
struct tc_action *a, struct tcf_hashinfo *hinfo)
{
struct tcf_common *p;
int err = 0, index = -1,i = 0, s_i = 0, n_i = 0;
struct rtattr *r ; read_lock(hinfo->lock);
// 起始
s_i = cb->args[0];
// 遍历所有哈希表
for (i = 0; i < (hinfo->hmask + 1); i++) {
// 链表头
p = hinfo->htab[tcf_hash(i, hinfo->hmask)];
// 遍历链表
for (; p; p = p->tcfc_next) {
index++;
// 是否是要跳过的数
if (index < s_i)
continue;
// 将common节点赋值为动作结构的私有数据
a->priv = p;
a->order = n_i;
// 数据缓冲区起始点
r = (struct rtattr*) skb->tail;
RTA_PUT(skb, a->order, 0, NULL);
// 填写一个动作结构参数
err = tcf_action_dump_1(skb, a, 0, 0);
if (err < 0) {
/ 操作失败, 中断循环
index--;
skb_trim(skb, (u8*)r - skb->data);
goto done;
}
// 该信息长度
r->rta_len = skb->tail - (u8*)r;
// 统计计数
n_i++;
if (n_i >= TCA_ACT_MAX_PRIO)
goto done;
}
}
done:
read_unlock(hinfo->lock);
// 增加统计数
if (n_i)
cb->args[0] += n_i;
return n_i;rtattr_failure:
skb_trim(skb, (u8*)r - skb->data);
goto done;
}
// 删除遍历
static int tcf_del_walker(struct sk_buff *skb, struct tc_action *a,
struct tcf_hashinfo *hinfo)
{
struct tcf_common *p, *s_p;
struct rtattr *r ;
int i= 0, n_i = 0;// 数据缓冲区起始点
r = (struct rtattr*) skb->tail;
// 填写动作节点的order和名称
RTA_PUT(skb, a->order, 0, NULL);
RTA_PUT(skb, TCA_KIND, IFNAMSIZ, a->ops->kind);
// 遍历所有common哈希表
for (i = 0; i < (hinfo->hmask + 1); i++) {
// 链表头
p = hinfo->htab[tcf_hash(i, hinfo->hmask)];
// 遍历链表
while (p != NULL) {
s_p = p->tcfc_next;
// 释放common节点
if (ACT_P_DELETED == tcf_hash_release(p, 0, hinfo))
module_put(a->ops->owner);
// 计数
n_i++;
p = s_p;
}
}
// 删除的节点数
RTA_PUT(skb, TCA_FCNT, 4, &n_i);
// 数据长度
r->rta_len = skb->tail - (u8*)r; return n_i;
rtattr_failure:
skb_trim(skb, (u8*)r - skb->data);
return -EINVAL;
}
8.6.2 tcf_common结构相关操作
tcf_common结构是作为动作结构的私有数据(priv), 所有common结构都保存为哈希表, 是TC动作的具体实现, 所有common结构节点是通过哈希表链接在一起的.
// 根据索引号index查找common节点
struct tcf_common *tcf_hash_lookup(u32 index, struct tcf_hashinfo *hinfo)
{
struct tcf_common *p; read_lock(hinfo->lock);
// 遍历相应的哈希链表
for (p = hinfo->htab[tcf_hash(index, hinfo->hmask)]; p;
p = p->tcfc_next) {
// 如果索引号相同则返回之
if (p->tcfc_index == index)
break;
}
read_unlock(hinfo->lock); return p;
}
EXPORT_SYMBOL(tcf_hash_lookup);
// 获取新索引值
u32 tcf_hash_new_index(u32 *idx_gen, struct tcf_hashinfo *hinfo)
{
// 起始值
u32 val = *idx_gen; do {
// 数组增加
if (++val == 0)
val = 1;
// 根据索引号查找common节点, 找到的话继续循环知道找到没有被使用的节点
// 这有可能会死循环, 就是已经分配了4G个common节点的情况
} while (tcf_hash_lookup(val, hinfo));
// 返回找到的索引号
return (*idx_gen = val);
}
EXPORT_SYMBOL(tcf_hash_new_index);
// 查找common结构作为动作结构的私有数据
// 返回1表操作成功, 0表示失败
int tcf_hash_search(struct tc_action *a, u32 index)
{
struct tcf_hashinfo *hinfo = a->ops->hinfo;
// 根据索引值查找common结构
struct tcf_common *p = tcf_hash_lookup(index, hinfo); if (p) {
// 找到, 将common结构作为动作结构的私有数据
a->priv = p;
return 1;
}
return 0;
}
EXPORT_SYMBOL(tcf_hash_search);
// 根据index获取common结构, 返回NULL表示失败
struct tcf_common *tcf_hash_check(u32 index, struct tc_action *a, int bind,
struct tcf_hashinfo *hinfo)
{
struct tcf_common *p = NULL;
// 如果索引号非0, 查找相应的common节点
if (index && (p = tcf_hash_lookup(index, hinfo)) != NULL) {
// 找到
if (bind) {
// 绑定操作, 增加引用数
p->tcfc_bindcnt++;
p->tcfc_refcnt++;
}
// 将common结构作为动作结构的私有数据
a->priv = p;
}
// 返回common结构
return p;
}
EXPORT_SYMBOL(tcf_hash_check);
// 生成新common节点
struct tcf_common *tcf_hash_create(u32 index, struct rtattr *est, struct tc_action *a, int size, int bind, u32 *idx_gen, struct tcf_hashinfo *hinfo)
{
// 分配空间
struct tcf_common *p = kzalloc(size, GFP_KERNEL); if (unlikely(!p))
return p;
// 索引数初始化为1
p->tcfc_refcnt = 1;
// 如果要绑定, 绑定数也初始化为1
if (bind)
p->tcfc_bindcnt = 1; spin_lock_init(&p->tcfc_lock);
// 统计锁
p->tcfc_stats_lock = &p->tcfc_lock;
// 索引数
p->tcfc_index = index ? index : tcf_hash_new_index(idx_gen, hinfo);
// 生成时间
p->tcfc_tm.install = jiffies;
// 上次使用时间
p->tcfc_tm.lastuse = jiffies;
#ifdef CONFIG_NET_ESTIMATOR
// 初始化估计器结构
if (est)
gen_new_estimator(&p->tcfc_bstats, &p->tcfc_rate_est,
p->tcfc_stats_lock, est);
#endif
// 将该common节点作为动作结构的私有数据
a->priv = (void *) p;
return p;
}
EXPORT_SYMBOL(tcf_hash_create);
// 插入common节点
void tcf_hash_insert(struct tcf_common *p, struct tcf_hashinfo *hinfo)
{
// 计算哈希数
unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask); write_lock_bh(hinfo->lock);
// 将新节点插头到链表头作为头节点
p->tcfc_next = hinfo->htab[h];
hinfo->htab[h] = p;
write_unlock_bh(hinfo->lock);
}
EXPORT_SYMBOL(tcf_hash_insert);
// 释放
void tcf_hash_destroy(struct tcf_common *p, struct tcf_hashinfo *hinfo)
{
// 计算哈希数
unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask);
struct tcf_common **p1p;
// 遍历哈希数指定的链表
for (p1p = &hinfo->htab[h]; *p1p; p1p = &(*p1p)->tcfc_next) {
// 比较结构地址
if (*p1p == p) {
// 找到
write_lock_bh(hinfo->lock);
// 从链表中断开
*p1p = p->tcfc_next;
write_unlock_bh(hinfo->lock);
#ifdef CONFIG_NET_ESTIMATOR
// 释放估计器
gen_kill_estimator(&p->tcfc_bstats,
&p->tcfc_rate_est);
#endif
// 释放空间
kfree(p);
return;
}
}
BUG_TRAP(0);
}
EXPORT_SYMBOL(tcf_hash_destroy);
// TCF哈希信息释放
int tcf_hash_release(struct tcf_common *p, int bind,
struct tcf_hashinfo *hinfo)
{
int ret = 0; if (p) {
// 如果已经是绑定的, 减少绑定数
if (bind)
p->tcfc_bindcnt--;
// 引用数减
p->tcfc_refcnt--;
// 如果绑定数和引用数都减到0了, 释放common节点
if (p->tcfc_bindcnt <= 0 && p->tcfc_refcnt <= 0) {
tcf_hash_destroy(p, hinfo);
ret = 1;
}
}
return ret;
}
8.6.3 登记/撤销
// 登记
int tcf_register_action(struct tc_action_ops *act)
{
struct tc_action_ops *a, **ap; write_lock(&act_mod_lock);
// 遍历action操作链表, 这个链表中的动作操作结构应该都是静态量, 不是动态分配的
for (ap = &act_base; (a = *ap) != NULL; ap = &a->next) {
// 比较动作的类型或名称是否相同
if (act->type == a->type || (strcmp(act->kind, a->kind) == 0)) {
// 相同的话表示已经登记过了
write_unlock(&act_mod_lock);
return -EEXIST;
}
}
// 将新节点添加到链表末尾
act->next = NULL;
*ap = act;
write_unlock(&act_mod_lock);
return 0;
}
// 撤销
int tcf_unregister_action(struct tc_action_ops *act)
{
struct tc_action_ops *a, **ap;
int err = -ENOENT; write_lock(&act_mod_lock);
// 遍历action操作链表, 直接比较地址
for (ap = &act_base; (a = *ap) != NULL; ap = &a->next)
if (a == act)
break;
if (a) {
// 如果找到
// 从链表中断开
*ap = a->next;
a->next = NULL;
err = 0;
}
write_unlock(&act_mod_lock);
return err;
}
...... 待续 ......