IPVS之隧道转发模式

如下ipvsadm配置命令：

$ ipvsadm -A -t 207.175.44.110:80 -s rr
$ ipvsadm -a -t 207.175.44.110:80 -r 192.168.10.1:80 -i

选项-i（–ipip）即指定使用IPIP隧道转发模式。由ipvsadm-1.29源码中的选项解析函数parse_options可知，-i对应着隧道Tunnel模式，使用标志IP_VS_CONN_F_TUNNEL标识。

static int parse_options(int argc, char **argv, struct ipvs_command_entry *ce, unsigned int *options, unsigned int *format)
{
    while ((c=poptGetNextOpt(context)) >= 0){
        switch (c) {
        case 'i':
            set_option(options, OPT_FORWARD);
            ce->dest.conn_flags = IP_VS_CONN_F_TUNNEL;
            break;

连接绑定转发函数

在连接新建函数ip_vs_conn_new中，对于新创建的连接，使用函数ip_vs_bind_xmit为其绑定发送函数。

struct ip_vs_conn *ip_vs_conn_new(const struct ip_vs_conn_param *p, int dest_af, const union nf_inet_addr *daddr, 
			__be16 dport, unsigned int flags, struct ip_vs_dest *dest, __u32 fwmark)
{
    struct ip_vs_conn *cp;
    cp = kmem_cache_alloc(ip_vs_conn_cachep, GFP_ATOMIC);

#ifdef CONFIG_IP_VS_IPV6
    if (p->af == AF_INET6)
        ip_vs_bind_xmit_v6(cp);
    else
#endif
        ip_vs_bind_xmit(cp);

对于转发模式为隧道Tunnel的连接，其传输函数设置为ip_vs_tunnel_xmit。

/* Bind a connection entry with the corresponding packet_xmit. Called by ip_vs_conn_new. */
static inline void ip_vs_bind_xmit(struct ip_vs_conn *cp)
{ 
    switch (IP_VS_FWD_METHOD(cp)) {
    case IP_VS_CONN_F_TUNNEL:
#ifdef CONFIG_IP_VS_IPV6
        if (cp->daf == AF_INET6)
            cp->packet_xmit = ip_vs_tunnel_xmit_v6;
        else
#endif
            cp->packet_xmit = ip_vs_tunnel_xmit;
        break;

请求报文（IPIP隧道发送处理）

在netfilter的hook点NF_INET_LOCAL_IN或者NF_INET_LOCAL_OUT处理客户端请求报文时，函数ip_vs_in在进行完相应的处理之后，使用连接（如果连接不存在，将新建连接）的packet_xmit函数指针执行发送操作。对于IPIP隧道转发模式，其为函数ip_vs_tunnel_xmit。

static unsigned int ip_vs_in(struct netns_ipvs *ipvs, unsigned int hooknum, struct sk_buff *skb, int af)
{

    ip_vs_set_state(cp, IP_VS_DIR_INPUT, skb, pd);
    if (cp->packet_xmit)
        ret = cp->packet_xmit(skb, cp, pp, &iph);
        /* do not touch skb anymore */

以下看以下IPIP隧道发送函数ip_vs_tunnel_xmit，首先使用出口路由查找函数__ip_vs_get_out_rt，更新skb中的路由缓存，关于IPVS路由函数请参考：https://blog.csdn.net/sinat_20184565/article/details/102410129。对于Tunnel转发模式，由于要使用路由源地址作为Tunnel的源地址，在查找路由时，要求获取到路由源地址。

其次对于路由目的地为本地的报文，使用函数ip_vs_send_or_cont进行处理，实际上并未做处理，返回NF_ACCEPT，交由内核协议栈进行后续处理了。

int ip_vs_tunnel_xmit(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, struct ip_vs_iphdr *ipvsh)
{
    struct netns_ipvs *ipvs = cp->ipvs;
    struct net *net = ipvs->net;
    struct rtable *rt;          /* Route to the other host */
    __be32 saddr;               /* Source for tunnel */
    struct net_device *tdev;        /* Device to other host */
    __be16 *dfp = NULL;

    local = __ip_vs_get_out_rt(ipvs, cp->af, skb, cp->dest, cp->daddr.ip,
                   IP_VS_RT_MODE_LOCAL | IP_VS_RT_MODE_NON_LOCAL | IP_VS_RT_MODE_CONNECT | IP_VS_RT_MODE_TUNNEL, &saddr, ipvsh);
    if (local < 0)
        goto tx_error;
    if (local)
        return ip_vs_send_or_cont(NFPROTO_IPV4, skb, cp, 1);

接下来，为添加Tunnel头部（外层IP报头）做准备。需要skb头部空余空间为max_headroom。默认情况下，PROC文件/proc/sys/net/ipv4/vs/pmtu_disc的值为1，即sysctl_pmtu_disc为真，表示将报文当前IP头部中的DF标志拷贝到Tunnel外部IP头部中。函数ip_vs_prepare_tunneled_skb用于确保skb头部空余空间，以及获取下一个协议号next_protocol，DS字段，TTL字段。

    rt = skb_rtable(skb);
    tdev = rt->dst.dev;

    /* Okay, now see if we can stuff it in the buffer as-is.
     */
    max_headroom = LL_RESERVED_SPACE(tdev) + sizeof(struct iphdr);

    /* We only care about the df field if sysctl_pmtu_disc(ipvs) is set */
    dfp = sysctl_pmtu_disc(ipvs) ? &df : NULL;
    skb = ip_vs_prepare_tunneled_skb(skb, cp->af, max_headroom, &next_protocol, NULL, &dsfield, &ttl, dfp);
    if (IS_ERR(skb))
        goto tx_error;

之后由函数iptunnel_handle_offloads进行卸载相关的处理。然后，对Tunnel的外层IP头部进行初始化。其中源地址为出口路由查询时获得的源地址，而目的IP地址为真实服务器的IP地址。

    if (iptunnel_handle_offloads(skb, __tun_gso_type_mask(AF_INET, cp->af)))
        goto tx_error;

    skb->transport_header = skb->network_header;

    skb_push(skb, sizeof(struct iphdr));
    skb_reset_network_header(skb);
    memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));

    /* Push down and install the IPIP header.
     */
    iph         =   ip_hdr(skb);
    iph->version        =   4;
    iph->ihl        =   sizeof(struct iphdr)>>2;
    iph->frag_off       =   df;
    iph->protocol       =   next_protocol;
    iph->tos        =   dsfield;
    iph->daddr      =   cp->daddr.ip;
    iph->saddr      =   saddr;
    iph->ttl        =   ttl;
    ip_select_ident(net, skb, NULL);

在报文发送之前，设置忽略禁止分片标志ignore_df，以避免在分片函数ip_fragment中，遇到IP报头设置有DF标志的报文，并且其长度大于MTU，而引发icmp_send函数发送代码为ICMP_FRAG_NEEDED的ICMP报文。最后由协议栈函数ip_local_out发送报文。

    /* Another hack: avoid icmp_send in ip_fragment */
    skb->ignore_df = 1;

    ret = ip_vs_tunnel_xmit_prepare(skb, cp);
    if (ret == NF_ACCEPT)
        ip_local_out(net, skb->sk, skb);
    else if (ret == NF_DROP)
        kfree_skb(skb);

    return NF_STOLEN;

辅助函数

隧道准备函数ip_vs_prepare_tunneled_skb，首先检查skb缓存的头部空余空间是否满足max_headroom的需求，不满足的话，重新分配skb缓存。其次，对于IPv6，外层IP头部中的协议字段使用IPPROTO_IPV6；对于IPv4，协议字段使用IPPROTO_IPIP。

static struct sk_buff *ip_vs_prepare_tunneled_skb(struct sk_buff *skb, int skb_af,
               unsigned int max_headroom, __u8 *next_protocol,  __u32 *payload_len, __u8 *dsfield, __u8 *ttl,  __be16 *df)
{ 
    struct sk_buff *new_skb = NULL;
    struct iphdr *old_iph = NULL;  
    __u8 old_dsfield;              
#ifdef CONFIG_IP_VS_IPV6           
    struct ipv6hdr *old_ipv6h = NULL;
#endif
  
    ip_vs_drop_early_demux_sk(skb);
  
    if (skb_headroom(skb) < max_headroom || skb_cloned(skb)) {
        new_skb = skb_realloc_headroom(skb, max_headroom); 
        if (!new_skb)              
            goto error;            
        if (skb->sk)               
            skb_set_owner_w(new_skb, skb->sk);       
        consume_skb(skb);          
        skb = new_skb;
    }

#ifdef CONFIG_IP_VS_IPV6
    if (skb_af == AF_INET6) {
        old_ipv6h = ipv6_hdr(skb);
        *next_protocol = IPPROTO_IPV6;
        if (payload_len)
            *payload_len = ntohs(old_ipv6h->payload_len) + sizeof(*old_ipv6h);
        old_dsfield = ipv6_get_dsfield(old_ipv6h);
        *ttl = old_ipv6h->hop_limit;
        if (df)
            *df = 0;
    } else
#endif
    {
        old_iph = ip_hdr(skb);
        /* Copy DF, reset fragment offset and MF */
        if (df)
            *df = (old_iph->frag_off & htons(IP_DF));
        *next_protocol = IPPROTO_IPIP;

        /* fix old IP header checksum */
        ip_send_check(old_iph);
        old_dsfield = ipv4_get_dsfield(old_iph);
        *ttl = old_iph->ttl;
        if (payload_len)
            *payload_len = ntohs(old_iph->tot_len);
    }

    /* Implement full-functionality option for ECN encapsulation */
    *dsfield = INET_ECN_encapsulate(old_dsfield, old_dsfield);

另外，外层IP头部的TOS字段保留内部IP头部的ECN标志。以及拷贝内部IP的ttl字段到外部IP头部中。

函数iptunnel_handle_offloads处理skb的卸载设置，如果当前skb不是封装报文（没有隧道，encapsulation为零），由于此时要进行IPIP隧道封装，使用函数skb_reset_inner_headers设置内层头部指针，并且值为encapsulation表示做封装。

int iptunnel_handle_offloads(struct sk_buff *skb, int gso_type_mask)
{   
    int err;
    
    if (likely(!skb->encapsulation)) {
        skb_reset_inner_headers(skb);
        skb->encapsulation = 1;
    }

对于GSO报文，首先，如果skb的头部（非共享数据区）是克隆clone的，使用函数skb_header_unclone将其独立出来，对于IPv6将其gso_type字段设置为SKB_GSO_IPXIP6，表明下一个协议为IPv6。对于IPv4将gso_type设置为SKB_GSO_IPXIP4，表明外层隧道为IP头，内层也为IP。目前只有Intel的i40e网卡驱动程序会使用此标志。

对于非GSO报文，如果skb的IP校验方式不等于CHECKSUM_PARTIAL，表明不需要网卡辅助计算校验和，以下代码清空了encapsulation标志，感觉这并没有什么用处，因为ip_summed不等于CHECKSUM_PARTIAL导致驱动根本不会计算校验和，更不会计算进行了封装的内部协议的校验和，encapsulation无论为何值，都没有作用。

    if (skb_is_gso(skb)) {
        err = skb_header_unclone(skb, GFP_ATOMIC);
        if (unlikely(err))
            return err;
        skb_shinfo(skb)->gso_type |= gso_type_mask;
        return 0;
    }
    
    if (skb->ip_summed != CHECKSUM_PARTIAL) {
        skb->ip_summed = CHECKSUM_NONE;
        /* We clear encapsulation here to prevent badly-written drivers potentially deciding to offload an inner checksum
         * if we set CHECKSUM_PARTIAL on the outer header. This should go away when the drivers are all fixed.
         */
        skb->encapsulation = 0;
    }

但是，参见代码中的注释部分，其打算实现的作用是在设置了CHECKSUM_PARTIAL的时候，防止一些不规范的网卡驱动程序错误的计算内存协议的校验和，而清空encapsulation标志。然而，ip_summed等于CHECKSUM_PARTIAL表明内部四层协议的校验和并不完整，需要网卡驱动进行辅助计算，在以上代码中，如果将判断条件修改为skb->ip_summed == CHECKSUM_PARTIAL，也说不通，不能简单的将ip_summed修改为CHECKSUM_NONE。

真实服务器

如以上介绍，配置了如下的ipvs虚拟服务。

$ ipvsadm -A -t 207.175.44.110:80 -s rr
$ ipvsadm -a -t 207.175.44.110:80 -r 192.168.10.1:80 -i

需要在真实服务器192.168.10.1上创建ipip隧道接口(ipip01)，以便接收ipvs调度来的报文。

# ip link add ipip01 type ipip remote 207.175.44.110 local 192.168.10.1
# ip link set device ipip01 up

另外，真实服务器可直接回复客户端的请求报文，无需再经过ipvs系统，可减轻ipvs的负荷。

内核版本 4.15