一个Netfilter nf_conntrack流表查找的优化-为conntrack增长一个per cpu cache

时间 2020-01-15

标签一个 netfilter conntrack 流表查找优化增长 cpu cache 栏目应用数学繁體版

原文原文链接

独悲须要忍受，快乐须要分享
对Linux协议栈屡次perf的结果，我没法忍受conntrack的性能，然而它的功能是如此强大，以致于我没法对其割舍，我想本身实现一个快速流表，可是我不得不抛弃依赖于conntrack的诸多功能，好比state match，Linux NAT等，诚然，我虽然对NAT也是抱怨太多，但无论怎样，不是还有不少人在用它吗。
曾经，我针对conntrack查找作过一个基于离线统计的优化，其思路很简单，就使用动态的计算模式代替统一的hash算法。我事先会对通过该BOX的全部五元组进行采样记录，而后离线分析这些数据，好比将五元组拼接成一个32源IP地址+32位目标IP地址+8位协议号+16位源端口+16位目标端口的104位的长串(在个人实现中，我忽略了源端口，由于它是一个易变量，值得被我任性地忽略)，而后根据hash桶的大小，好比说是N，以logN位为一个窗口大小在104位的串上滑动，找出相异数量最大的区间，以此区间为模区间，这样就能够将数据流均匀分布在各个hash桶中，若是数据流过多致使冲突链表过长，能够创建多维嵌套hash，把这个hash表倒过来看，它是多么像一棵平衡N叉树啊，N叉Trie树不就是这回事吗？这里的hash函数就是“取某些位”，这又一次展现了Trie与hash的统一。
以上的优化虽然优美，可是却仍是复杂了，这个优化思路是我从硬件cache的设计思路中借鉴的。可是和硬件cache好比CPU cache相比，软件的相似方式效果大打折扣，缘由在于软件处理hash冲突的时候只能遍历或者查找，而硬件却能够同时进行。请学校里面的不要认为是算法不够优越，这是物理本质决定的。硬件使用的是门电路，流动的是电流，而电流是像水流同样并行连通的，软件使用的逻辑，流动的是步骤，这就是算法，算法就是一系列的逻辑步骤的组合，固然，也有不少复杂的所谓并行算法，可是据我所知，不少效果并很差，复杂带来了更多的复杂，最终经不起继续复杂，只好做罢，另外，这么简单个事儿，搞复杂算法有点大炮打苍蝇了。
面试

nf_conntrack的简单优化-增长一个cache

若是什么东西和后续的处理速率不匹配，成为了瓶颈，那么就增长一个cache来平滑这种差别。CPU cache就是利用了这个思路。对于nf_conntrack的效率问题，咱们也应该使用相同的思路。可是具体怎么作，仍是须要起码的一些哪怕是定性的分析。
       若是你用tcpdump抓包，就会发现，结果几乎老是一连串连续被抓取的数据包属于同一个五元组数据流，可是也不绝对，有时会有一个数据包插入到一个流中，一个很合理的抓包结果多是下面这个样子：
数据流a 正方向
数据流a 正方向
数据流a 反方向
数据流a 正方向
数据流c 正方向
数据流a 反方向
数据流a 发方向
数据流b 反方向
数据流b 正方向
数据流正方向
....
看出规律了吗？数据包到达BOX遵循非严格意义上的时间局部性，也就是属于一个流的数据包会持续到达。至于空间局部性，不少人都说不明显，可是若是你仔细分析数据流a，b，c，d...的源/目标IP元组，你会发现它们的空间局部性，这是TCAM硬件转发表设计的根本原则。TCAM中“取某些位”中“某些位”说明这些位是空间上最分散的局部，这是一种对空间局部性的逆向运用，好比核心传输网上，你会发现大量的IP都是去往北美或者北欧的。
       我本但愿在本文中用数学和统计学来阐述这一规律，可是这个行为实在不适合在一篇大众博客中进行，当有人面试个人时候问到我这个问题，我也只能匆匆几句话带过，而后若是须要，我会用电邮的方式来深刻解析，可是对于一篇博客，这种方式显得卖弄了，并且会失去不少读者，天然也就没有人为我提意见了。博客中最重要的就是快速给出结果，也就是该怎么作。言归正传。
       若是说上述基于“空间局部性逆向利用”的“取某些位hash”的优化是原自“效率来自规则”这个定律的话，那么规则的代价就是复杂化，这个复杂化让我没法继续。还有一个比这个定律更加普适的原则就是“效率来自简单”，我喜欢简单的东西和简单的人，此次，我再次证实了个人正确。在继续以前，我会先简单描述一下nf_conntrack的瓶颈到底在哪。
1.nf_conntrack的正反向tuple使用一个hash表，插入，删除，修改操做须要全局的lock进行保护，这会同意大量的串行化操做。
2.nf_conntrack的hash表使用了jhash算法，这种算法操做步骤太多，若是conntrack数量少，hash操做将会消耗巨大的性能。
[Tips：若是你了解密码学中的DES/AES等对称加密算法，就会明白，替换，倒置，异或操做可数据完成最佳混淆，使得输出与输出无关，从而达到最佳散列，然而这效果的代价就是操做复杂化了，加解密效率问题多在此，这种操做是如此规则(各类盒)以致于彻底能够用硬件电路实现，但是若是没有这种硬件使用CPU的话，这种操做是极其消耗CPU的，jhash也是如此，虽然不很。]
3.nf_conntrack表在多个CPU间是全局的，这会涉及到数据同步的问题，虽然能够经过RCU最大限度缓解，但万一有人写它们呢。
算法

鉴于以上，逐步击破，解决方案就有了。网络

1.cache的构建基于每CPU一个，这彻底符合cache的本地化设计原则，CPU cache不也如此吗。
2.cache尽量小，保存最有可能命中的数据流项，同时保证cache缺失的代价不至于过大。
tcp

3.创建一个合理的cache替换自适应原则，保证在位者谋其职，不思进取者自退位的原则ide

我的设计思路就是以上这些，在逐步落实的过程当中，我起初只保留了一个cache项，也就是最后一次在conntrack hash表中被找到的那个项，这彻底符合时间局部性，然而在我测试的时候发现，若是网络中有诸如ICMP这类慢速流的话，cache抖动会很是厉害，和 TCP流比起来，ICMP太慢，可是按照排队原则，它终究会插队到一个TCP流中间，形成cache替换，为了不这种使人悲哀的状况，我为 conntrack项，即conn结构体加入了时间戳字段，每次hash查找到的时候，用当时的jiffers减去该时间戳字段，同时更新这个字段为当前 jiffers，只有当这个差值小于一个预约值的时候，才会执行cache替换，这个值能够经过网络带宽加权得到。
可是这样就完美了吗？远不！考虑到CPU cache的设计，我发现conntrack cache彻底不一样，对于CPU，因为虚拟内存机制，cache里面保存的确定来自同一个进程的地址空间(不考虑更复杂的CPU cache原理...)，所以除非发生分支跳转或者函数调用，时间局部性是必定的。可是对于网络数据包，彻底是排队论统计决定的，全部的数据包的命名空间就是全世界的IP地址集合，指不定哪一下子就会有任意流的数据包插入进来。最多见的一种状况就是数据流切换，好比数据流a和数据流b的发送速率，通过的网络带宽实力至关，它们颇有可能交替到达，或者间隔两三个数据包交替到达，这种状况下，你要照顾谁呢？这就是第三个原则：效率来自公平。
函数

所以，个人最终设计是如下的样子：性能

1.cache是一个链表，该链表的长度是一个值得微调的参数
cache链表过短：流项频繁在conntrack hash表和cache中跳动被替换。
cache链表太长：对待没法命中cache的流项，cache缺失代价过高。
胜者原则：胜者通吃。凡是有的，还要加给他叫他多余。没有的，连他全部的也要夺过来。(《马太福音》)均衡原则1-针对胜者：遍历cache链表的时间不能比标准hash计算+遍历冲突链表的时间更长(平均状况)。
均衡原则2-针对败者：若是遍历了链表没有命中，虽然损失了些不应损失的时间，可是把这种损失维持在一个能够接受的范围内。
测试

效果：数据流到达速率越快就越容易以极低的代价命中cache，数据流达到速率越慢越不容易命中cache，然而也不用付出高昂的代价。优化

2.基于时间戳的cache替换原则
只有连续的数据包到达时间间隔小于某个动态计算好的值的时候，才会执行cache替换。

this

个人中间步骤测试代码以下：

//修改net/netfilter/nf_conntrack_core.c
//Email：marywangran@126.com

//1.定义
#define A
#ifdef A
/*
 * MAX_CACHE动态计算原则：
 * cache链表长度 = 平均冲突链表长度/3, 其中：
 * 平均冲突链表长度 = net.nf_conntrack_max/net.netfilter.nf_conntrack_buckets
 * 3 = 经验值
 *
 */
#define MAX_CACHE   4

struct conntrack_cache {
    struct nf_conntrack_tuple_hash *caches[MAX_CACHE];
};

DEFINE_PER_CPU(struct conntrack_cache, conntrack_cache);

#endif


//2.修改resolve_normal_ct
static inline struct nf_conn *
resolve_normal_ct(struct net *net,
          struct sk_buff *skb,
          unsigned int dataoff,
          u_int16_t l3num,
          u_int8_t protonum,
          struct nf_conntrack_l3proto *l3proto,
          struct nf_conntrack_l4proto *l4proto,
          int *set_reply,
          enum ip_conntrack_info *ctinfo)
{
    struct nf_conntrack_tuple tuple;
    struct nf_conntrack_tuple_hash *h;
    struct nf_conn *ct;
#ifdef A
    int i;
    struct conntrack_cache *cache;
#endif

    if (!nf_ct_get_tuple(skb, skb_network_offset(skb),
                 dataoff, l3num, protonum, &tuple, l3proto,
                 l4proto)) {
        pr_debug("resolve_normal_ct: Can't get tuple\n");
        return NULL;
    }

#ifdef A

    cache = &__get_cpu_var(conntrack_cache);

    rcu_read_lock();

    if (0 /* 优化3 */) {
        goto slowpath;
    }

    for (i = 0; i < MAX_CACHE; i++) {
        struct nf_conntrack_tuple_hash  *ch = cache->caches[i];
        struct nf_conntrack_tuple_hash  *ch0 = cache->caches[0];
        if (ch && nf_ct_tuple_equal(&tuple, &ch->tuple)) {
            ct = nf_ct_tuplehash_to_ctrack(ch);
            if (unlikely(nf_ct_is_dying(ct) ||
                    !atomic_inc_not_zero(&ct->ct_general.use))) {
                h = NULL;
                goto slowpath;
            }
            else {
                if (unlikely(!nf_ct_tuple_equal(&tuple, &ch->tuple))) {
                    nf_ct_put(ct);
                    h = NULL;
                    goto slowpath;
                }
            }
/*************************************** 优化1简介 *****************************************/
/* 并不是直接提高到第一个，而是根据两次cache命中的间隔酌情提高，提高的步数与时间间隔成反比   */
/* 这就避免了cache队列自己的剧烈抖动。事实上，命中的时间间隔若是能加权历史间隔值，效果更好 */
/*******************************************************************************************/
            /*
             * 基于时间局部性提高命中项的优先级
             */
            if (i > 0 /* && 优化1 */) {
                cache->caches[0] = ch;
                cache->caches[i] = ch0;
            }
            h = ch;
        }
    }
    ct = NULL;

slowpath:
    rcu_read_unlock();

    if (!h)
#endif

    /* look for tuple match */
    h = nf_conntrack_find_get(net, &tuple);
    if (!h) {
        h = init_conntrack(net, &tuple, l3proto, l4proto, skb, dataoff);
        if (!h)
            return NULL;
        if (IS_ERR(h))
            return (void *)h;
    }
#ifdef A
    else {
        int j;
        struct nf_conn *ctp;
        struct nf_conntrack_tuple_hash  *chp;

/*********************** 优化2简介 **************************/
/* 只有连续两个数据包到达的时间间隔小于n时才会执行cache替换 */
/* 这是为了不诸如ICMP之类的慢速流致使的cache抖动          */
/************************************************************/
        if (0 /* 优化2 */) {
            goto skip;
        }

/************************** 优化3简介 *****************************/
/* 只有在总的conntrack数量大于hash bucket数量的4倍时才启用cache   */
/* 由于conntrack数量小的话，通过一次hash运算就能够一次定位，      */
/* 或者通过遍历很短的冲突链表便可定位，使用cache反而下降了性能    */
/******************************************************************/
        if (0 /* 优化3 */) {
            goto skip;
        }

        ct = nf_ct_tuplehash_to_ctrack(h);
        nf_conntrack_get(&ct->ct_general);
        chp = cache->caches[MAX_CACHE-1];

        for (j = MAX_CACHE-1; j > 0; j--) {
            cache->caches[j] = cache->caches[j-1];
        }
        cache->caches[0] = h;
        if (chp) {
            ctp = nf_ct_tuplehash_to_ctrack(chp);
            nf_conntrack_put(&ctp->ct_general);
        }
    }
skip:
    if (!ct) {
        ct = nf_ct_tuplehash_to_ctrack(h);
    }
#else
    ct = nf_ct_tuplehash_to_ctrack(h);
#endif

    /* It exists; we have (non-exclusive) reference. */
    if (NF_CT_DIRECTION(h) == IP_CT_DIR_REPLY) {
        *ctinfo = IP_CT_ESTABLISHED + IP_CT_IS_REPLY;
        /* Please set reply bit if this packet OK */
        *set_reply = 1;
    } else {
        /* Once we've had two way comms, always ESTABLISHED. */
        if (test_bit(IPS_SEEN_REPLY_BIT, &ct->status)) {
            pr_debug("nf_conntrack_in: normal packet for %p\n", ct);
            *ctinfo = IP_CT_ESTABLISHED;
        } else if (test_bit(IPS_EXPECTED_BIT, &ct->status)) {
            pr_debug("nf_conntrack_in: related packet for %p\n",
                 ct);
            *ctinfo = IP_CT_RELATED;
        } else {
            pr_debug("nf_conntrack_in: new packet for %p\n", ct);
            *ctinfo = IP_CT_NEW;
        }
        *set_reply = 0;
    }
    skb->nfct = &ct->ct_general;
    skb->nfctinfo = *ctinfo;
    return ct;
}


//2.修改nf_conntrack_init
int nf_conntrack_init(struct net *net)
{
    int ret;
#ifdef A
    int i;
#endif

    if (net_eq(net, &init_net)) {
        ret = nf_conntrack_init_init_net();
        if (ret < 0)
            goto out_init_net;
    }
    ret = nf_conntrack_init_net(net);
    if (ret < 0)
        goto out_net;

    if (net_eq(net, &init_net)) {
        /* For use by REJECT target */
        rcu_assign_pointer(ip_ct_attach, nf_conntrack_attach);
        rcu_assign_pointer(nf_ct_destroy, destroy_conntrack);

        /* Howto get NAT offsets */
        rcu_assign_pointer(nf_ct_nat_offset, NULL);
    }
#ifdef A

    /* 初始化每CPU的conntrack cache队列 */
    for_each_possible_cpu(i) {
        int j;
        struct conntrack_cache *cache;
        cache = &per_cpu(conntrack_cache, i);
        for (j = 0; j < MAX_CACHE; j++) {
            cache->caches[j] = NULL;
        }
    }

#endif
    return 0;

out_net:
    if (net_eq(net, &init_net))
        nf_conntrack_cleanup_init_net();
out_init_net:
    return ret;
}

但愿看到的人有机会测试一下。效果和疑问能够直接发送到代码注释中所示的邮箱。