Linux 网络栈深度实战：从 NIC 中断到 XDP/eBPF 的数据包处理全链路解析

引言：一个数据包的生命旅程

当你敲下 curl https://www.example.com 的瞬间，一个数据包的奇幻旅程便开始了。它从用户态 socket 出发，穿越协议栈层层封装，进入网卡驱动，踏上网线/光纤，经过交换机路由器的重重转发，抵达目的服务器，再逆向穿越协议栈，最终抵达目标进程的 socket 缓冲区。这个过程中，Linux 内核网络栈每秒处理数百万个数据包，每一个环节都经过数十年的性能打磨。

本文将从硬件层到用户态、从经典路径到现代加速，完整解析 Linux 网络栈的每一个关键组件和性能优化点，涵盖 10 大核心技术领域，配有大量内核源码片段、性能测试数据和实战调优指南。

一、网卡驱动层：NAPI 轮询机制与硬中断风暴

1.1 纯中断模式的灾难

早期 Linux 网卡驱动采用每包一次硬中断（Hard IRQ）的模式。当千兆网卡达到线速时，每秒产生 ~148,800 个最小包（64 bytes）中断。硬中断会打断 CPU 正在执行的任务，导致 Cache 失效、Pipeline 清空，系统陷入"中断风暴"（IRQ Storm），吞吐量断崖式下降。

1.2 NAPI：中断+轮询的混合模式

Linux 2.6 引入的 New API（NAPI）彻底解决了这个问题。核心思想：首包中断，批量轮询。

struct napi_struct {
    struct list_head poll_list;
    unsigned long state;
    int weight;              // 默认权重 = 64（最大处理包数）
    int (*poll)(struct napi_struct *, int);
};

static int mydriver_poll(struct napi_struct *napi, int budget) {
    int work_done = 0;
    while (work_done < budget) {
        if (rx_packet_available()) {
            process_rx_packet();
            work_done++;
        } else {
            napi_complete_done(napi, work_done);
            enable_rx_interrupt();
            break;
        }
    }
    return work_done;
}

NAPI 的工作流程：

1. 数据包到达：网卡将数据从 FIFO/环形缓冲区通过 DMA 写入内存（Ring Buffer）
2. 硬中断触发：网卡触发 IRQ，CPU 调用 hard_irq_handler
3. 关闭 RX 中断：驱动立即屏蔽后续 RX 中断，防止重入
4. 调度 SoftIRQ：调用 napi_schedule()，将设备的 napi_struct 加入 CPU 的 softnet_data.poll_list
5. 触发 NET_RX_SOFTIRQ：__raise_softirq_irqoff(NET_RX_SOFTIRQ)
6. 软中断处理：net_rx_action() 遍历 poll_list，调用每个设备的 poll() 函数
7. budget 控制：全局预算 net.core.netdev_budget=300，每个 NAPI 的 weight 默认 64
8. 重新开中断：若处理完所有数据，调用 napi_complete()，重新允许 RX 中断

1.3 多队列网卡与 RSS

现代网卡支持多队列（Multi-Queue）和接收端缩放（RSS）：

查看网卡队列数：ethtool -l eth0  → RX: 8 / TX: 8
查看中断绑定：cat /proc/interrupts | grep eth0
网卡通过五元组哈希分发到不同 Ring Buffer → 不同中断 → 不同 CPU

1.4 硬中断合并（Coalesce）

ethtool -c eth0 查看中断合并配置
低延迟：rx-usecs=0, rx-frames=1    （每包立即中断）
高吞吐：rx-usecs=200, rx-frames=128  （合并分批处理）
自适应：ethtool -C eth0 adaptive-rx on adaptive-tx on

二、sk_buff：内核网络的核心数据结构

2.1 sk_buff 的精妙设计

sk_buff（Socket Buffer）是网络栈中最先创建、最后释放的元数据，每个数据包对应一个 skb。它采用"瑞士军刀"式设计，同一结构贯穿链路层到传输层。

关键成员：
  struct sock *sk;
  struct net_device *dev;
  unsigned int len;
  unsigned int data_len;        // paged data 分片长度
  __be16 network_header;        // IP头偏移
  __be16 transport_header;      // TCP/UDP头偏移
  unsigned char *head;          // 缓冲区起点
  unsigned char *data;          // 当前层协议数据起点
  unsigned char *tail;          // 有效数据终点
  unsigned char *end;           // 缓冲区终点
  refcount_t users;             // 引用计数
  __sum16 ip_summed;            // 校验和状态

关键设计要点：

• 头指针分离：head/tail/end 固定不变，data 指针随协议层上下移动
• 零拷贝解析：各协议层只需 data += sizeof(header)，无需 memcpy
• 共享数据 + 独立元数据：skb_clone() 仅复制 sk_buff 结构，共享 data 缓冲区
• paged data：大流量场景使用 frags[] 指向 page，避免大段连续内存分配

2.2 GRO/GSO 分片与合并

GRO 将多个小包合并为一个大 skb 再提交协议栈，减少上层处理开销；GSO 则将超过 MTU 的大包分片。

napi_gro_receive() → skb_gro_receive() → 尝试合并到已有 GRO flow
若超时或数据突变 → napi_gro_flush()
查看 offload：ethtool -k eth0 | grep -E "tso|gso|gro"

三、Netfilter/iptables：Linux 防火墙的钩子框架

3.1 五个钩子点

PREROUTING - 路由决策前, DNAT
INPUT - 本机进程消费
FORWARD - 转发到其他地址
OUTPUT - 本机进程发出
POSTROUTING - 出网卡前, SNAT/MASQUERADE

3.2 nftables 后端

现代 iptables 将规则翻译为 nftables，最终由内核 BPF 引擎执行
nft list ruleset
table inet filter {
    chain input {
        type filter hook input priority 0;
        ct state established,related accept
    }
}

四、TCP 协议栈：从三次握手到拥塞控制

4.1 三次握手

客户端：connect() → tcp_connect() 发送 SYN → SYN_SENT → 收到ACK → ESTABLISHED
服务端：listen() → accept() 阻塞 → 收到第三次握手ACK → 从 accept_queue 取出
关键参数：net.core.somaxconn（全连接队列）、tcp_max_syn_backlog（半连接队列）

4.2 拥塞控制

Linux 默认 CUBIC（2.6.19+）：W(t) = C*(t-K)^3 + W_max
慢启动：snd_cwnd < snd_ssthresh，指数增长
拥塞避免：snd_cwnd >= snd_ssthresh，CUBIC 三次函数增长
BBR（Google 2016）：不以丢包为信号，只测量实际带宽和RTT

4.3 数据收发路径

发送：sendmsg() → tcp_sendmsg() → tcp_write_xmit() → ip_queue_xmit()
接收：tcp_v4_rcv() → tcp_rcv_established() → tcp_data_queue()
      有序 → sk_receive_queue，无序 → 红黑树排序 → sk_data_ready() 唤醒 epoll

五、Socket 层与 epoll：高并发事件分发

5.1 Socket 调用链

socket(AF_INET, SOCK_STREAM, 0)
 → inet_create() 分配 tcp_sock（~2240 字节）
connect() → tcp_connect() 发送 SYN → 阻塞等待第三次握手
listen() → 创建 accept_queue，accept() 从队列取出已连接 fd

5.2 epoll 红黑树 + 就绪队列

eventpoll {
    struct rb_root rbr;          // 红黑树根（所有监控的 fd）
    struct list_head rdllist;    // 就绪链表 O(1) 检查
    wait_queue_entry_t wq;       // epoll_wait() 等待队列
}

epoll_ctl()：将 fd 插入红黑树 O(log N) + 安装回调 ep_poll_callback()
epoll_wait()：检查 rdllist O(1) + 被唤醒后取事件

回调路径：网卡收包 → sk_data_ready() → ep_poll_callback() → 加入 rdllist → wake_up()

5.3 ET 与 LT 模式

ET（边沿触发）：只在状态变化时通知一次
  → 必须一次读完所有数据（read until EAGAIN）
LT（水平触发，默认）：只要 fd 就绪就持续通知
  → 编程简单，不会漏数据

ET 正确写法：while (true) { n = read(fd, buf, size); if (errno==EAGAIN) break; }

六、零拷贝技术

传统 read+write：4次拷贝 + 4次上下文切换
sendfile：        2-3次拷贝 + 2次上下文切换
sendfile+SG-DMA： 2次DMA + 0次CPU copy + 2次上下文切换（最佳）
splice：          通过管道零 CPU copy（fd to fd 转发）
mmap+write：      适合随机小 I/O（如 Redis RDB）
io_uring：        批量提交/收割，减少 syscall 次数

七、XDP：驱动层 eBPF 执行

7.1 工作位置与返回码

XDP Hook 位于 NIC Ring Buffer → skb 分配之前（数据包生命周期最早点）

XDP_DROP  → 立即丢弃（~100ns/pkt）DDoS 防护
XDP_PASS  → 继续进入内核协议栈
XDP_TX    → 从同一网卡原路发送（MAC 伪装）
XDP_REDIRECT → 转发到另一网卡/CPU（负载均衡）

7.2 示例

int xdp_drop_prog(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end) return XDP_DROP;
    if (eth->h_proto != htons(ETH_P_IP)) return XDP_PASS;
    struct iphdr *ip = data + sizeof(*eth);
    if (ip->protocol == IPPROTO_ICMP) return XDP_DROP;
    return XDP_PASS;
}
编译：clang -O2 -target bpf -c xdp.c -o xdp.o
加载：ip link set eth0 xdp obj xdp.o sec xdp

八、eBPF：可编程内核引擎

8.1 安全模型

Verifier 验证：
  1. 所有内存访问有边界检查
  2. 循环必须有明确上界（max 1M 指令）
  3. 无未初始化寄存器读取
  4. 无内核指针泄露
  5. 网络程序不能随意修改协议头（需通过 helper）
验证通过后 JIT 编译为 x86/arm64 原生指令

8.2 BPF Maps

BPF_MAP_TYPE_HASH：O(1) 查找，连接计数器、路由缓存
BPF_MAP_TYPE_LPM_Trie：最长前缀匹配，IP 路由查找
BPF_MAP_TYPE_RINGBUF：环形缓冲区（5.8+），用户态事件流
BPF_MAP_TYPE_SOCKMAP：Socket 映射，四层负载均衡
BPF_MAP_TYPE_PERF_EVENT_ARRAY：perf 输出，实时监控

8.3 eBPF Hook 点全景

网络路径：XDP, TC Ingress/Egress, Socket Ops, cgroup, Sockmap
可观测性：Kprobe/Kretprobe, Tracepoint, uprobe, USDT
安全：LSM（6.x+）, Socket Filter（传统 BPF）

九、DPDK 与 AF_XDP：用户态网络 IO

9.1 DPDK

DPDK 绕过内核，在用户态直接操作网卡：
  UIO/VFIO → 直接访问网卡寄存器
  HugePages（2MB/1GB）→ 减少 TLB Miss
  绑核 + 无中断轮询（PMD） rte_eth_rx_burst()
  预分配 rte_mbuf 池 → 避免频繁 malloc

性能对比：
  内核协议栈：~2-5 Mpps/core
  DPDK PMD：  ~25-100 Mpps/core（小包 64B）

9.2 AF_XDP

AF_XDP（Linux 4.18+）= 内核控制面 + 用户态数据面
  用户态分配 UMEM（HugePages 内存池）
  网卡驱动直接写入 UMEM → 用户态零拷贝收包
  性能：~20-40 Mpps/core

XDP + AF_XDP 协作：
  XDP 做 ACL + 简单转发
  AF_XDP 做 L7 解析/负载均衡
  通过 BPF_MAP_TYPE_XSKMAP 共享 socket fd

十、性能调优实战

10.1 核心 sysctl 参数

net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.core.netdev_max_backlog = 10000
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_max_orphans = 262144
net.ipv4.tcp_moderate_rcvbuf = 1
net.ipv4.tcp_slow_start_after_idle = 0
net.ipv4.tcp_fastopen = 3

10.2 Ring Buffer 与中断绑核

ethtool -G eth0 rx 8192 tx 8192    # 调整 Ring Buffer
echo "4" > /proc/irq/95/smp_affinity  # 绑定中断到 CPU2
或使用 irqbalance 服务自动平衡

10.3 监控工具

ss -ti state established    # 查看 TCP cwnd/RTT/retrans
bpftrace -e 'kprobe:tcp_retransmit_skb { @retrans[comm] = count(); }'
bpftool prog show           # 查看 XDP 程序状态
ethtool -S eth0             # 网卡层详细统计（dropped/errors）

总结

Linux 网络栈经过数十年工程打磨，从 NAPI 中断轮询到 sk_buff 精妙指针设计，从 Netfilter 的 5 个钩子点到 epoll 红黑树就绪队列，从 sendfile/splice 的零拷贝到 XDP/eBPF 的驱动层决策，每个组件都体现了内核开发者对性能的极致追求。

现代高性能网络架构采用多层协作：XDP 做第一层 ACL（微秒级），tc-eBPF 做流量整形，epoll/io_uring 做应用层分发，AF_XDP 做零拷贝数据包处理。理解每一层的边界和性能特征，才能在百万并发下做出正确设计决策。

真正的瓶颈往往不在网络 IO 本身，而在应用层的锁竞争、内存分配和计算逻辑。网络栈优化是手段而非目的——理解它，才能让应用跑得更快、更稳。