当容器跨节点通信时,Linux 内核在做什么?IPIP 隧道源码深度剖析

当你的容器跨节点通信时，内核在做什么？这篇文章从内核源码角度拆解 IPIP 隧道的完整工作流程。

为什么要学这个？

排查 Calico 网络问题时，你需要理解 IPIP 封装原理；性能调优时，需要权衡 IPIP vs VXLAN 的开销差异；面试常考隧道封装原理。更重要的是，理解了 IPIP，其他隧道技术（VXLAN、GRE）也就触类旁通了。

IPIP 协议编号是 4，定义在 Linux 内核 include/uapi/linux/in.h 中：

#define IPPROTO_IPIP    4

当内核看到协议字段为 4 的数据包时，自动触发 IPIP 解封装逻辑，这个过程完全在内核态完成，不需要用户态程序干预。IPIP 的本质是 IP-in-IP 封装，在原始 IP 包外面再套一层 IP 头，外层 IP 头的源地址是隧道入口节点，目的地址是隧道出口节点。

一、tun0 设备是怎么来的？

创建 IPIP 隧道设备使用 ip tunnel 命令，底层通过 ioctl 系统调用与内核交互：

ip tunnel add tun0 mode ipip remote 172.16.2.2 local 192.168.1.1
ip link set tun0 up
ip addr add 10.0.0.1/24 dev tun0

这条命令在内核中创建了一个 tun0 设备，隧道模式是 ipip，远端地址是 172.16.2.2，本地地址是 192.168.1.1。

内核源码中，隧道设备的创建入口在 net/ipv4/ip_tunnel.c 的 ip_tunnel_ioctl 函数：

static int ip_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
    struct ip_tunnel_parm p;
    
    if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
        return -EFAULT;
    
    if (cmd == SIOCADDTUNNEL) {
        return ip_tunnel_create(net, &p);  // 创建隧道设备
    }
    // ...
}

ip_tunnel_create 函数分配 ip_tunnel 结构体并注册网络设备：

static struct ip_tunnel *ip_tunnel_create(struct net *net,
                                           struct ip_tunnel_parm *p)
{
    struct ip_tunnel *t;
    
    t = kzalloc(sizeof(*t), GFP_KERNEL);
    if (!t)
        return ERR_PTR(-ENOMEM);
    
    t->dev = alloc_netdev(sizeof(struct ip_tunnel),
                          p->name, NET_NAME_UNKNOWN,
                          ip_tunnel_setup);
    
    // 设置隧道参数
    t->parms.iph.saddr = p->iph.saddr;  // 本地地址
    t->parms.iph.daddr = p->iph.daddr;  // 远端地址
    t->parms.iph.protocol = IPPROTO_IPIP;  // 协议号 4
    
    register_netdev(t->dev);
    return t;
}

隧道设备创建后，内核会为它分配一个 tun0 接口，这个接口看起来和普通网卡一样，但它的发送函数 ndo_start_xmit 指向 ip_tunnel_xmit，所有从 tun0 发出的包都会经过 IPIP 封装。

二、一个 IP 包的 5 步封装旅程

当数据包进入 tun0 设备时，内核调用 ip_tunnel_xmit 函数进行封装。这个函数定义在 net/ipv4/ip_tunnel.c，核心逻辑如下：

void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
                    const struct ip_tunnel_encap_ops *encap_ops)
{
    struct ip_tunnel *tunnel = netdev_priv(dev);
    const struct iphdr *inner_iph = ip_hdr(skb);
    struct iphdr *outer_iph;
    
    // 1. 分配新的 skb，在外层预留 20 字节 IP 头空间
    if (skb_cow_head(skb, LL_RESERVED_SPACE(dev) + sizeof(struct iphdr)))
        goto drop;
    
    // 2. 构造外层 IP 头
    outer_iph = ip_hdr(skb);
    outer_iph->version = 4;
    outer_iph->ihl = 5;  // 20 字节
    outer_iph->tos = inner_iph->tos;
    outer_iph->tot_len = htons(skb->len);
    outer_iph->id = htons(tunnel_id++);
    outer_iph->ttl = ip_select_ttl(inner_iph, skb);  // 继承内层 TTL，保障 traceroute 正常工作
    outer_iph->protocol = IPPROTO_IPIP;  // 协议号 4
    outer_iph->saddr = tunnel->parms.iph.saddr;  // 本地地址
    outer_iph->daddr = tunnel->parms.iph.daddr;  // 远端地址
    outer_iph->check = 0;
    outer_iph->check = ip_fast_csum((unsigned char *)outer_iph, outer_iph->ihl);
    
    // 3. 更新 skb 元数据
    skb->protocol = htons(ETH_P_IP);
    skb->pkt_type = PACKET_OUTGOING;
    skb->dev = tunnel->dev;
    
    // 4. 重新路由，查找下一跳
    rt = ip_route_output_key(net, &fl4);
    if (IS_ERR(rt))
        goto drop;
    
    // 5. 发送到物理网卡
    ip_local_out(net, skb->sk, skb);
    return;
    
drop:
    kfree_skb(skb);
}

整个流程可以分为五个关键步骤：

步骤 1：预留空间。内核调用 skb_cow_head 在原始 IP 包前面预留 20 字节空间，准备塞外层 IP 头。

步骤 2：构造外层 IP 头。内核填充外层 IP 头的各个字段：版本 4、头长度 20 字节、TTL 64、协议号 4（关键字段）、源地址 192.168.1.1、目的地址 172.16.2.2。

步骤 3：设置 skb 元数据。内核设置 skb->protocol 为 htons(ETH_P_IP)，skb->pkt_type 为 PACKET_OUTGOING，并将 skb->dev 更新为隧道设备（tunnel->dev），以便后续在路由查找后交由物理网卡发出。

步骤 4：重新路由。外层 IP 包需要根据外层目的地址重新查找路由，内核调用 ip_route_output_key 确定从哪个物理网卡发出。

步骤 5：发送到物理网卡。内核构造以太网帧头，填充源 MAC 和目的 MAC，然后调用 ip_local_out 将 skb 放入物理网卡的发送队列。

封装完成后，原始 IP 包（源 10.1.1.2，目的 10.1.2.3）被包在外层 IP 包（源 192.168.1.1，目的 172.16.2.2）中，从 eth0 发出。

关键数字一览

三、内核如何识别并解封装？

当外层 IP 包到达接收端时，内核在网络栈的 IP 层处理这个包。整个解封装流程定义在 net/ipv4/ip_tunnel.c：

static int ip_tunnel_rcv(struct sk_buff *skb, u8 proto)
{
    struct ip_tunnel *tunnel;
    const struct iphdr *iph = ip_hdr(skb);
    
    // 1. 查找对应的隧道设备
    tunnel = ip_tunnel_lookup(tunnel_net, iph->daddr, iph->saddr);
    if (!tunnel)
        goto drop;
    
    // 2. 剥离外层 IP 头
    skb_pull(skb, iph->ihl * 4);  // 移动 20 字节
    skb_reset_network_header(skb);
    
    // 3. 恢复内层 IP 包
    skb->protocol = htons(ETH_P_IP);
    skb->pkt_type = PACKET_HOST;
    skb->dev = tunnel->dev;
    
    // 4. 重新注入网络栈
    if (netif_rx(skb) == NET_RX_DROP)
        goto drop;
    
    return 0;
    
drop:
    kfree_skb(skb);
    return -ENOMEM;
}

IPIP 协议在内核启动时通过 inet_add_protocol 注册：

static const struct net_protocol ipip_protocol = {
    .handler = ipip_rcv,        // 接收处理函数
    .err_handler = ipip_err,    // 错误处理函数
    .flags = INET_PROTOSW_PERMANENT,
};

static int __init ipip_init(void)
{
    // 注册 IPIP 协议（协议号 4）
    if (inet_add_protocol(&ipip_protocol, IPPROTO_IPIP))
        return -EAGAIN;
    
    return 0;
}

解封装流程分为四个关键步骤：

步骤 1：IP 头解析。内核在 ip_rcv 函数中解析外层 IP 头，检查协议字段。如果协议字段是 4（IPPROTO_IPIP），内核知道这是一个 IPIP 封装包，调用 ip_local_deliver 将包分发给 ipip_rcv 处理函数。

步骤 2：协议分发。内核根据协议号 4 找到注册的处理函数 ipip_rcv，这个函数会调用 ip_tunnel_rcv 完成解封装。

步骤 3：解封装。ip_tunnel_rcv 函数调用 skb_pull 剥离外层 IP 头（移动 20 字节），调用 skb_reset_network_header 重置网络层指针，设置 skb->protocol 为原始 IP 包的协议类型。

步骤 4：重新注入。解封装后的原始 IP 包被重新注入网络栈，内核调用 netif_rx 将包放入接收队列，重新走一遍 IP 层处理流程。这次路由查找会匹配本地路由表项，将包发送到目的容器。

解封装完成后，原始 IP 包（源 10.1.1.2，目的 10.1.2.3）恢复，进入容器网络命名空间，最终到达目的容器。

四、路由表怎么配？

IPIP 隧道需要正确配置路由表才能工作。假设我们有两个节点，Node1（192.168.1.1）和 Node2（172.16.2.2），各自运行容器网络：

Node1 路由表：

10.1.2.0/24 via 172.16.2.2 dev tun0

这条路由表示：访问 10.1.2.0/24 网段的包，下一跳是 172.16.2.2，从 tun0 设备发出。当内核匹配到这条路由时，会将包发送到 tun0，触发 IPIP 封装。

Node2 路由表：

10.1.1.0/24 via 192.168.1.1 dev tun0

对称配置，Node2 访问 Node1 的容器网段时，也会经过 IPIP 封装。

踩坑经验

我在生产环境遇到过 IPIP 隧道单向通信的问题，排查发现是只配置了一个节点的路由表。如果你发现 ping 能通但 curl 不通，检查两个节点的 tun0 设备是否都正确配置了。

IPIP 隧道是双向的，两个节点都需要创建 tun0 设备并配置路由。如果只有一个节点配置，隧道只能单向通信。

五、性能开销实测

IPIP 封装会引入额外的开销，主要体现在三个方面：

CPU 开销：封装和解封装需要额外的 CPU 周期。在内核态处理，开销相对可控，但高吞吐量场景下会占用 CPU 资源。实测在 Intel Xeon E5-2680 上，IPIP 封装的 CPU 开销约为 5-10%。

带宽开销：外层 IP 头占用 20 字节。假设原始包是 1500 字节，封装后变成 1520 字节，带宽开销约为 1.3%。对于小包场景（如 64 字节），开销更明显，约为 31%。

延迟开销：封装和解封装增加处理延迟。实测单跳延迟增加约 0.1-0.3ms，对于大多数应用影响不大，但对延迟敏感场景需要考虑。

MTU 调整：IPIP 封装增加 20 字节，如果不调整 MTU，可能会触发分片。建议将 tun0 的 MTU 设置为 1480（1500 - 20），或者在物理网卡上启用 PMTU 发现。

调试技巧

# 查看 IPIP 隧道状态
ip tunnel show

# 查看隧道统计信息
cat /proc/net/dev | grep tun

# 抓包验证封装（协议号 4）
tcpdump -i eth0 'ip proto 4' -nn

# 启用 GRO/GSO 减少 CPU 开销
ethtool -K eth0 gro on
ethtool -K eth0 gso on

# 调整 MTU 避免分片
ip link set tun0 mtu 1480

六、IPIP vs VXLAN 选型对比

IPIP 和 VXLAN 都是隧道封装技术，但适用场景不同：

封装开销：从物理层整体报文来看，IPIP 增加 20 字节 IP 头，VXLAN 增加 50 字节（8 字节 UDP 头 + 8 字节 VXLAN 头 + 14 字节以太网头 + 20 字节 IP 头），较 IPIP 多出 30 字节。IPIP 更节省带宽。

MTU 要求：IPIP 需要至少 1480 字节 MTU，VXLAN 需要 1450 字节。在 MTU 受限的环境，IPIP 更有优势。

多租户隔离：VXLAN 支持 VNI（24 位），可以隔离 1600 万个租户。IPIP 没有租户隔离能力，只能用于单租户场景。

跨网段通信：IPIP 需要两端 IP 可达，适合同网段或三层可达的网络。VXLAN 可以跨网段，适合跨数据中心的场景。

硬件卸载：现代网卡支持 VXLAN 硬件卸载，可以显著降低 CPU 开销。IPIP 的硬件支持较少。

性能对比表

选型建议：如果是同网段、单租户、追求低开销，选 IPIP。如果是跨网段、多租户、需要硬件加速，选 VXLAN。

七、内核实现要点

IPIP 协议的标准定义可以参考 RFC 2003 (IP Encapsulation within IP)。

IPIP 的内核实现有几个关键设计：

隧道设备抽象：内核将 IPIP、VXLAN、GRE 等隧道技术统一抽象为 ip_tunnel 结构体，共享核心逻辑。不同隧道类型通过 handlers 数组注册各自的封装解封装函数：

struct ip_tunnel {
    struct ip_tunnel_parm parms;    // 隧道参数
    struct net_device *dev;         // 网络设备
    struct hlist_node hlist;        // 哈希表节点
    int collect_md;                 // 元数据收集标志
};

per-cpu 统计：隧道设备的统计信息（收发包数、字节数、错误数）使用 per-cpu 变量，避免多核竞争，提高性能：

struct ip_tunnel_pcpu_stats {
    u64 rx_packets;
    u64 rx_bytes;
    u64 tx_packets;
    u64 tx_bytes;
    struct u64_stats_sync syncp;
};

GRO/GSO 支持：IPIP 支持 GRO（Generic Receive Offload）和 GSO（Generic Segmentation Offload），可以在发送端合并多个小包，减少中断和上下文切换。内核通过 dev->features 标志位控制：

dev->features |= NETIF_F_GSO;
dev->features |= NETIF_F_GRO;

错误处理：内核实现了标准的错误处理，包括 ICMP 目的不可达、超时、参数问题等。错误处理函数 ipip_err 会解析 ICMP 错误包，更新隧道状态：

static void ipip_err(struct sk_buff *skb, u32 info)
{
    const struct iphdr *iph = (const struct iphdr *)skb->data;
    
    // 解析 ICMP 错误，更新隧道状态
    switch (icmp_hdr(skb)->type) {
    case ICMP_DEST_UNREACH:
        // 目的不可达，关闭隧道
        break;
    case ICMP_TIME_EXCEEDED:
        // 超时，记录日志
        break;
    }
}

八、总结

IPIP 隧道是 Linux 内核中一种轻量级的封装技术，通过在原始 IP 包外层封装 IP 头实现跨节点通信。它的核心优势是开销小（20 字节）、实现简单、内核态处理高效。缺点是不支持多租户隔离、需要两端 IP 可达。

Calico IPIP 模式使用这种封装技术，将容器 IP 包封装在主机 IP 包中，实现跨节点通信。理解 IPIP 的内核实现，有助于排查容器网络问题和优化网络性能。

如果有问题欢迎留言，下回再聊其他内核网络机制。