利用nf_conntrack机制存储路由，省去每包路由查找

IP是无连接的，因此IP路由是每包一路由的，数据包通过查找路由表获取路由，这是现代操作协议协议栈IP路由的默认处理方式。可是假设协议栈具有流识别能力，是不是能够基于流来路由呢？答案无疑是肯定的。

设计思想

在Linux的实现中，nf_conntrack能够做到基于流的IP路由，大致思想就是，仅仅针对一个流的第一个正向包和第一个反向包查找标准的IP路由表，将结果保存在conntrack项中，兴许的属于同一流的数据包直接取出路由项来使用。背后的思想是：这能够省去查找路由表的开销，是这样吗？也不全是！关键是，将一个数据包相应到一个数据流，这本身就须要一个查找匹配的过程，假设能将路由保存在conntrack里面，那么conntrack查找和路由查找就能够合并成一次查找。因此，查找是免不了的，仅仅是换了地方而已，假设有了conntrack，仍然进行标准的基于包的IP路由查找过程，那就是平白多了一次查找。

实现思想

在实现上，非常easy，那就是尽量在数据包离开协议栈的地方设置skb的路由到conntrack。之所以能够这么做是由于无论是POSTROUTING还是INPUT，都是在路由之后，假设前面进行了基于包的IP路由查找，此时skb上一定绑定了dst_entry，将其绑到conntrack里面就可以。另外，在数据包刚进入协议栈的地方试图从conntrack项中取出路由，然后直接将其设置到skb上。整个处理过程相似skb-mark和conntrack mark的处理方式：
-A PREROUTING -m mark --mark 100 -j ACCEPT
-A PREROUTING -j CONNMARK --restore-mark --nfmask 0xffffffff --ctmask 0xffffffff
-A PREROUTING -m mark ! --mark 0x0 -j ACCEPT
...... 慢速匹配过程
-A PREROUTING .....  -j MARK --set-mark 100
.....慢速匹配过程
-A POSTROUTING -m mark ! --mark 0x0 -j CONNMARK --save-mark --nfmask 0xffffffff --ctmask 0xffffffff 

有了以上的理解，代码就非常easy了

#include <linux/ip.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/version.h>
#include <net/netfilter/nf_conntrack.h>
#include <net/dst.h>
#include <net/netfilter/nf_conntrack_acct.h>

MODULE_AUTHOR("xtt");
MODULE_DESCRIPTION("gll");
MODULE_LICENSE("GPL");
MODULE_ALIAS("XTT and GLL");

struct nf_conn_priv {
        struct nf_conn_counter ncc[IP_CT_DIR_MAX];
        struct dst_entry *dst[IP_CT_DIR_MAX];
};

static unsigned int ipv4_conntrack_getdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
        struct nf_conn *ct;
        enum ip_conntrack_info ctinfo;
        struct nf_conn_counter *acct;
        struct nf_conn_priv *dst_info;
        ct = nf_ct_get(skb, &ctinfo);
        if (!ct || ct == &nf_conntrack_untracked)
                return NF_ACCEPT;
        acct = nf_conn_acct_find(ct);
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
                if (dst_info->dst[dir] == NULL) {
                        dst_hold(skb_dst(skb));
                        dst_info->dst[dir] = skb_dst(skb);
                }
        }
        return NF_ACCEPT;
}

static unsigned int ipv4_conntrack_setdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
        struct nf_conn *ct;
        enum ip_conntrack_info ctinfo;
        struct nf_conn_counter *acct;
        struct nf_conn_priv *dst_info;
        ct = nf_ct_get(skb, &ctinfo);
        if (!ct || ct == &nf_conntrack_untracked)
                return NF_ACCEPT;
        acct = nf_conn_acct_find(ct);
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
                if (dst_info->dst[dir] != NULL) {
                       // 假设在此设置了skb的dst，那么在ip_rcv_finish中就不会再去查找路由表了
                        skb_dst_set(skb, dst_info->dst[dir]);
                }
        }
        return NF_ACCEPT;
}
static struct nf_hook_ops ipv4_conn_dst_info[] __read_mostly = {
        {
                .hook           = ipv4_conntrack_getdst,
                .owner          = THIS_MODULE,
                .pf             = NFPROTO_IPV4,
                .hooknum        = NF_INET_POST_ROUTING,
                .priority       = NF_IP_PRI_CONNTRACK + 1,
        },
        {
                .hook           = ipv4_conntrack_getdst,
                .owner          = THIS_MODULE,
                .pf             = NFPROTO_IPV4,
                .hooknum        = NF_INET_LOCAL_IN,
                .priority       = NF_IP_PRI_CONNTRACK + 1,
        },
        {
                .hook           = ipv4_conntrack_setdst,
                .owner          = THIS_MODULE,
                .pf             = NFPROTO_IPV4,
                .hooknum        = NF_INET_PRE_ROUTING,
                .priority       = NF_IP_PRI_CONNTRACK + 1,
        },
};

static int __init test_info_init(void)
{
        int err;
        err = nf_register_hooks(ipv4_conn_dst_info, ARRAY_SIZE(ipv4_conn_dst_info));
        if (err) {
                return err;
        }
        return err;
}

static void __exit test_info_exit(void)
{
        nf_unregister_hooks(ipv4_conn_dst_info, ARRAY_SIZE(ipv4_conn_dst_info));
}

module_init(test_info_init);
module_exit(test_info_exit);

在以上的实现思想的文字描写叙述中，我使用了尽量和试图两个不那么明白的词，这就牵扯到了流路由的老化机制。

老化思想
标准的路由查找是每一个包都要查找，而现在引入了流路由之后，便不须要对skb进行路由查找了，取而代之的是直接从conntrack取出路由设置给skb，这个conntrack上的路由就是第一次的时候针对skb查找路由表的结果。那么就会引入一个问题，即什么时候再次针对skb查找路由表以便更新conntrack的路由。这个问题没法直接回答，对于路由一直稳定的网络，根本不须要又一次查找，由于针对一个流的第一个正向包和第一个反向包的路由查找结果在该流的生命周期中将一直有效，毕竟路由没有改变，可是假设在流的生命周期内一条相关的路由发生了改变，就须要又一次更新conntrack的路由结果。
       因此能够说，引入一个通知机制就能解决问题。每当路由发生改变的时候，在PREROUTING的hook中，不再运行：

skb_dst_set(skb, dst_info->dst[dir]);

而这个非常easy，使用内核的Notifier机制就能够了，在不论什么路由改变的时候，通知上述的流路由模块改变一个标志位，在PREROUTING的hook中，发现该标志位置位，就不运行skb_dst_set。如此一来，上述的代码就会变为以下的：

static unsigned int ipv4_conntrack_getdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
...
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
        // 无条件设置流的路由。skb的dst可能来自两个地方：
        // 1.来自ipv4_conntrack_setdst；
        // 2.来自标准的IP路由查找
                dst_hold(skb_dst(skb));
                dst_info->dst[dir] = skb_dst(skb);
        }
        return NF_ACCEPT;
}

static unsigned int ipv4_conntrack_setdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
...
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
        // 仅仅有标志为1，才信任流路由，而且设置给skb
                if (flag == 1) {
                        skb_dst_set(skb, dst_info->dst[dir]);
                }
        }
        return NF_ACCEPT;
}

然而，把这件事交给用户态也许更好些。毕竟内核态发生的全部事情，用户态都有办法监控到，我觉得用一个procfs的可写文件来通知flag变为1或者变为0可能更好，即flag的值由用户来设置，这样用户就能够在随意时刻启用，停用流路由机制，比方使用iproute2的monitor机制监控到了路由的改变，假设是无关路由改变了，那么就不更新flag，仅仅有是相关的路由改变了，才更新，何其灵活。

时间： 2024-10-12 07:27:41

利用nf_conntrack机制存储路由，省去每包路由查找的相关文章

hbase 学习（十五）缓存机制以及可以利用SSD作为存储的BucketCache

下面介绍Hbase的缓存机制: a.HBase在读取时,会以Block为单位进行cache,用来提升读的性能 b.Block可以分类为DataBlock(默认大小64K,存储KV).BloomBlock(默认大小128K,存储BloomFilter数据).IndexBlock(默认大小128K,索引数据,用来加快Rowkey所在DataBlock的定位) c.对于一次随机读,Block的访问顺序为BloomBlock.IndexBlock.DataBlock,如果Region下面的StoreFi

利用反射机制，获取类的字段、方法、并实现简单调用

这篇文章是为之后要介绍Android的ICO框架做预备的,所以,如果想最近学习Android的ICO框架的同学,可以稍微看一下. 首先,简单介绍一下Java里面的反射. JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 不知道这样的一段解释,你能否看懂.如果更简单的说,反射就是能够根据你给出类名实例化出一个实实在在的对象.所以,对象的实例

Android利用反射机制为实体类属性赋值

在做android项目时,有时会遇到从网络上获取json类型数据,赋值给实体类,实体类属性少可以一个一个的赋值,如果实体类有很多属性,赋值可能就要耗很长的功夫了,幸好Java给我们提供了反射机制.下面是在我在android中如何利用java反射机制给实体类赋值. 在Android中利用反射机制为实体类属性赋值,首先需要导入一下两个包 import java.lang.reflect.Field; import java.lang.reflect.Method; 给实体类赋值首先需要一个实体类,这

Redis 利用锁机制来防止缓存过期产生的惊群现象-转载自 http://my.oschina.net/u/1156660/blog/360552

首先,所谓的缓存过期引起的“惊群”现象是指,在大并发情况下,我们通常会用缓存来给数据库分压,但是会有这么一种情况发生,那就是在一定时间 内生成大量的缓存,然后当缓存到期之后又有大量的缓存失效,导致后端数据库的压力突然增大,这种现象就可以称为“缓存过期产生的惊群现象”! 以下代码的思路,就是利用“锁机制”来防止惊群现象.先看代码: class KomaRedis{ private $redis; //redis对象 private static $_instance = null; private

java中利用反射机制绕开编译器对泛型的类型限制

首先看下面这个例子 public static void main(String[] args) { ArrayList<Integer> al1 = new ArrayList<Integer>(); al1.add(1); ArrayList<String> al2 = new ArrayList<String>(); al2.add("hello"); //int型链表和string型链表,结果为true System.out.pr

浅谈利用同步机制解决Java中的线程安全问题

我们知道大多数程序都不会是单线程程序,单线程程序的功能非常有限,我们假设一下所有的程序都是单线程程序,那么会带来怎样的结果呢?假如淘宝是单线程程序,一直都只能一个一个用户去访问,你要在网上买东西还得等着前面千百万人挑选购买,最后心仪的商品下架或者售空......假如饿了吗是单线程程序,那么一个用户得等前面全国千万个用户点完之后才能进行点餐,那饿了吗就该倒闭了不是吗?以上两个简单的例子,就说明一个程序能进行多线程并发访问的重要性,今天就让我们去了解一下Java中多线程并发访问这个方向吧. **第一

NPOI操作excel——利用反射机制，NPOI读取excel数据准确映射到数据库字段

> 其实需求很明确,就是一大堆不一样的excel,每张excel对应数据库的一张表,我们需要提供用户上传excel,我们解析数据入库的功能实现. 那么,这就涉及到一个问题:我们可以读出excel的表头,但是怎么知道每个表头具体对应数据库里面的字段呢? 博主经过一段时间的思考与构思,想到一法:现在的情况是我们有excel表A,对应数据库表B,但是A与B具体属性字段的映射关系我们不知.那我们是不是可以有一个A到B的映射文件C呢? 我想,说到这,大家就很明了了... 第一步:为每张excel创建一个与

实验四 利用单臂路由实现VLAN间路由

[实验名称] 利用单臂路由实现VLAN间路由. [实验目的] 掌握如何在路由器上划分子接口.封装Dot1q(IEEE 802.1q)协议,实现VLAN间的路由. [需求分析] 需要在交换机上配置VLAN,然后在路由器连接交换机的端口上划分子接口,给相应的VLAN设置IP地址,以实现VLAN间的路由. [实验设备] 三层交换机一台. 路由器一台. [预备知识] 交换机的基本配置方法.VLAN的工作方法.Trunk的工原理和配制作原则和配置方法. [实验原理] 在交换网络中,通过VLAN对一个物理网

Flex中利用事件机制进行主程序与子窗体间参数传递

在开发具有子窗体,或者itemrenderer的应用时,常常涉及到子窗体向父窗体传递参数或者从itemrenderer内的控件向外部的主程序传递参数的需求.这些都可以通过事件机制这一统一方法加以解决.在我的应用中有两个需求: 1.左侧的List控件的itemrenderer中包含CheckBox控件,当其状态改变时需要同时改变主程序中的一个数组变量的内容:2.左下方的"新增届次"按钮会弹出一个窗口,窗口中输入届次信息后需要修改数据库中的表,同时表的更改结果要能够在List控件中体现出来