• 目标是本地 → ip_local_deliver() → ip_local_deliver_finish()
• 目标是远程 → 经过 FORWARD hook → ip_forward()

第 3 层：TCP 层

tcp_v4_rcv() 处理 TCP 报文。对于已建立的连接，调用 tcp_rcv_established()，根据报文类型决定：

• 携带数据 → 添加到接收队列或 out-of-order 队列
• ACK 更新 → 发送确认或更新发送窗口
• 控制消息（RST/FIN）→ 状态转移

tcp_rcv_established() 的简化逻辑：

void tcp_rcv_established(struct sock *sk, struct sk_buff *skb) {
    struct tp_sock *tp = tcp_sk(sk);
    // 快速路径：常见的数据 segments
    if ((tcp_flag_word(th) & TCP_FLAGS_HP_MASK) == tp->expected_flags) {
        // 快速路径处理
        tcp_ack_update_rtt(sk, ca_seq, flag);
        // 添加到 socket 接收队列
        // 或直接的 copy 到用户空间（如果应用正在等待）
        eaten = tcp_queue_rcv(tp, skb);
        if (!eaten) {
            // 添加到 prequeue 或 backlog
            // 或直接复制到用户空间
        }
    } else {
        // 慢速路径：乱序、特殊标志等
    }

    // 检查是否需要发送 ACK
    if (tp->ato != ~0U)
        tcp_send_delayed_ack(sk);
}

2.3 sk_buff 的分配与回收

sk_buff 对象本身通过 kmem_cache_alloc() 从专用 slab 缓存分配。内核为每个 CPU 维护了 skbuff_cachep，避免锁争用。

对于数据 buffer，内核采用 alloc_skb() 分配：线性区大小 = size + sizeof(sk_buff)，同时包含 skb_shared_info 结构。

分配路径优化：

• 小数据包（< 2KB）：直接从 slab 分配
• 中等包：__netdev_alloc_skb() 使用预分配的 page pool
• 网卡驱动使用 page pool API（Page Pool API），避免反复分配/释放大页内存

现代驱动（如 mlx5、i40e）使用内核的 page_pool 机制：驱动初始化时分配一批 page，硬件 RX DMA 直接写入这些 page，协议栈处理完后再由 page pool 回收或交给skb持有。这样可以消除 DMA buffer 的分配/映射开销。

三、TCP 协议栈的实现深度剖析

3.1 连接建立：三次握手

TCP 在内核中是一个状态机，定义在 include/net/tcp_states.h 中。三次握手涉及的底层操作：

服务器端（被动打开）：

1. 应用调用 listen() 后，内核调用 inet_listen() 将 socket 状态设为 TCP_LISTEN
2. 收到 SYN 包 → tcp_v4_rcv() → tcp_v4_do_rcv() → tcp_rcv_state_process()
3. 状态从 TCP_LISTEN 转移到 TCP_SYN_RECV
4. 调用 tcp_conn_request() 创建 request_sock（使用 SYN cookie 作为防御手段），分配半连接资源
5. 发送 SYN-ACK，启动 SYN-ACK 重传定时器
6. 收到 ACK 时，request_sock 变为完整 sock，加入 Accept 队列，唤醒阻塞的 accept()

半连接队列（SYN Queue）和 全连接队列（Accept Queue）是两个独立的队列：

• SYN Queue：存储 TCP_SYN_RECV 状态的连接（通过 ehash 管理）
• Accept Queue：存储 TCP_ESTABLISHED 状态但未被 accept() 取走的连接

当全连接队列满时的行为由 net.ipv4.tcp_abort_on_overflow 控制（默认 0：丢弃 SYN，客户端超时；为 1：发送 RST）。半连接队列满时根据 net.ipv4.tcp_syncookies 决定是否使用 SYN Cookie。

全连接队列的长度上限由 listen() 的 backlog 参数和 net.core.somaxconn（默认 4096）共同决定：

// net/socket.c
SYSCALL_DEFINE2(listen, int, fd, int, backlog) {
    // backlog = min(backlog, net.core.somaxconn)
    // accept queue limit = backlog
}

3.2 发送路径：从 send() 到 tx

应用调用 send()/ sendmsg() 时，数据从用户空间复制到内核的 sk_buff，然后进入发送流程：

1. 用户空间 send() → sys_sendmsg() → inet_sendmsg() → tcp_sendmsg()
2. tcp_sendmsg() 中，数据通过 skb_entail() 或 tcp_add_write_queue_tail() 添加到发送队列
3. 调用 tcp_push() 尝试立即发送，不等待 Nagle 算法
4. tcp_write_xmit() 调用 tcp_transmit_skb() 将 sk_buff 路由并送往 Qdisc
5. Qdisc（排队规则）决定何时将数据包传给驱动
6. 驱动调用 ndo_start_xmit() → DMA 映射 → 写入 TX 环形缓冲区 → 通知网卡

关键优化路径——Zero-Copy Send：

当应用程序希望避免内核-用户空间的数据拷贝时，可以使用 MSG_ZEROCOPY 标志。实现原理是内核不立即复制数据，而是将用户空间页面的引用添加到 sk_buff 的分页区，当 DMA 完成后通过 Socket notification 通知应用可以释放该页面。

// 用户态 zero-copy send
int ret = send(fd, buf, len, MSG_ZEROCOPY);
// ... 数据在内核中引用而非拷贝 ...
// 通过 socket error queue 接收 completion notification
int ret = recvmsg(fd, &msg, MSG_ERRQUEUE);
// 收到 notification 后可以重用该 buffer

启用条件：net.core.optmem_max > 0 且 socket 通过 setsockopt 设置了 SO_ZEROCOPY。

3.3 TCP 接收与流式重组

TCP 接收的核心挑战是处理乱序到达的数据包。Linux 的实现围绕三个队列：

• Receive Queue：已按序到达的数据，可以被应用程序读取
• Out-of-Order Queue：乱序到达的 segments，以待重组
• Prequeue：用户态 TCP 快速路径，允许用户态直接 read

当收到一个 sk_buff 时，tcp_data_queue() 按以下逻辑处理：

static void tcp_data_queue(struct sock *sk, struct sk_buff *skb) {
    // 正常情况下，序列号刚好匹配
    if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
        // 检查是否可以 "吞入" receive queue（不需要等到 read）
        if (tp->ucopy.memory == 0 && skb->len <= tp->ucopy.len) {
            // 预队列路径（直接复制到用户空间）
            __skb_queue_tail(&sk->sk_receive_queue, skb);
            tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
        } else {
            // 添加到 receive queue
            eaten = tcp_queue_rcv(sk, skb, 0);
            if (eaten) {
                tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
            }
        }
        // 检查 out-of-order queue 中是否有等待的 segment
        tcp_ofo_queue(sk);
    } else {
        // 乱序，加入 out-of-order 队列
        tcp_data_queue_ofo(sk, skb);
    }
}

Out-of-Order 队列使用红黑树管理，tcp_ofo_queue() 在每次收到按序数据时检查是否有 gap 已被填充，如果有，将其合并到 Receive Queue。

3.4 TCP 拥塞控制

Linux 模块化实现了多种拥塞控制算法，通过 struct tcp_congestion_ops 注册。默认使用 CUBIC（自 2.6.19 起），最新版本内核（6.x）默认可能切换至 BBRv3。

CUBIC 的关键特性：

• 窗口增长函数是立方函数 C * (t - K)^3 + Wmax
• 在高速网络（高 BDP）环境下比 NewReno 更快探测带宽
• 使用拐点（K）作为上次窗口减半后的平衡点
• Linux 的修改版本 hystart（Hybrid Start） 避免慢启动末期的大幅丢包

# 查看可用算法
sysctl net.ipv4.tcp_available_congestion_control
# cubic reno bbr

# 切换为 BBR
sysctl -w net.ipv4.tcp_congestion_control=bbr

# 验证
sysctl net.ipv4.tcp_congestion_control
ss -ti | grep bbr

// net/netfilter/nf_tables_api.c
static const struct nf_hook_ops nf_tables_ipv4_hooks[] = {
    {
        .hook     = nft_do_chain,
        .pf       = NFPROTO_IPV4,
        .hooknum  = NF_INET_PRE_ROUTING,
        .priority = NF_IP_PRI_FILTER,
    },
    // ... 其他 hook 点
};

# 增加 conntrack 表大小（默认约为内存 MB * 16）
sysctl -w net.netfilter.nf_conntrack_max=524288

# 减少超时时间
sysctl -w net.netfilter.nf_conntrack_tcp_timeout_established=86400
sysctl -w net.netfilter.nf_conntrack_udp_timeout=30

# 监控当前条目数
cat /proc/sys/net/netfilter/nf_conntrack_count
wc -l /proc/net/nf_conntrack

// include/linux/tcp.h
struct tcp_sock {
    struct inet_connection_sock inet_conn; // "父类"
    // TCP 特定数据
    u32 snd_nxt;        // next sequence
    u32 rcv_nxt;        // expected next sequence
    u32 copied_seq;     // 已复制到用户空间的序列号
    u64 bytes_received; // 统计
    // ...
};

struct inet_connection_sock {
    struct inet_sock  inet; // "祖父类"
    struct request_sock_queue  icsk_accept_queue; // accept queue
    u32                        icsk_rto;         // retransmission timeout
    const struct tcp_congestion_ops *icsk_ca_ops;
    // ...
};

struct inet_sock {
    struct sock sk;     // "曾祖父类"
    struct ipv4_pinfo  *inet_pinet;
    __be32 daddr;
    __be32 saddr;
    // ...
};

// 数据已缓存在 sk_receive_queue 中
SYSCALL_DEFINE(recvfrom) {
    → sys_recvfrom() → sock_recvmsg() → __sock_recvmsg()
    → sock->ops->recvmsg()  // 对于 TCP: tcp_recvmsg()
}

tcp_recvmsg() {
    // 1. 检查接收队列是否有数据
    skb_queue_walk(&sk->sk_receive_queue, skb) {
        // 2. 线性数据通过 copy_to_user 直接复制
        // 3. 使用 mmap/skb_copy_datagram_msg 处理 paged data
        // 4. 更新 rcv_nxt
    }
    // 5. 释放已读的 skb
    sk_eat_skb(sk, skb);
    // 6. 发送 delayed ACK
}

SYSCALL_DEFINE(sendto) {
    → sys_sendto() → sock_sendmsg() → __sock_sendmsg()
    → sock->ops->sendmsg()  // 对于 TCP: tcp_sendmsg()
}

tcp_sendmsg() {
    // 1. TCP 分段：将用户数据切割为最大 seg_size（通常为 MSS）
    // 2. 为每个 segment 分配 skb
    // 3. 将用户数据 copy_from_user 到 skb 的线性区
    // 4. 添加到发送队列 tcp_send_skb()
    // 5. tcp_push_one() → tcp_write_xmit() → tcp_transmit_skb()
    // 6. ip_queue_xmit() → ip_local_out() → dev_queue_xmit()
}

// 用户态文件到 socket 的 sendfile
#include <sys/sendfile.h>
int in_fd = open("data.bin", O_RDONLY);
int out_fd = accept(...);
struct stat st;
fstat(in_fd, &st);
sendfile(out_fd, in_fd, NULL, st.st_size); // 零拷贝发送整个文件

splice()（2.6.17 引入）：
在两个文件描述符之间移动数据，无需在用户态之间 copy。基于 pipe buffer 实现，本质上是将一个 fd 的页面缓存映射到 pipe，然后从 pipe 引出到另一个 fd。

6.3 mmap 与 Packet mmap
通过 mmap 将内核的 Socket 缓冲区映射到用户空间，让应用程序直接在内核 buffer 中读取数据。Linux 提供了 PACKET_MMAP 机制，通过 setsockopt(fd, SOL_PACKET, PACKET_RX_RING, ...) 设置一个用户空间和内核共享的环形缓冲区（TPACKET_V3），数据包通过该环形缓冲区直接传递，避免了 sk_buff 的分配和释放。

6.4 XDP：极速数据包处理
XDP（eXpress Data Path） 是 Linux 4.8+ 引入的框架，通过在网卡驱动层直接运行 eBPF 程序来处理数据包，可以：

XDP_DROP：丢弃数据包（在网卡驱动层，不经过内核网络栈）
XDP_PASS：传递给内核协议栈正常处理
XDP_TX：从接收该包的网卡同一接口发送回去
XDP_REDIRECT：转发到另一个网卡或 CPU（通过 cpumap/devmap）

XDP 的典型用途：DDoS 防护（在驱动层丢弃攻击流量）、负载均衡（FastNAT）、快速重定向。
性能测试表明，XDP 在单个 CPU 核心上可以达到 24Mpps（百万包/秒） 的转发速率，远超内核协议栈的 ~1.5Mpps。

6.5 内建的 TCP 卸载引擎 TSO/LRO/GRO
TSO（TCP Segmentation Offload）：内核将高达 64KB 的 TSO chunk 传递给 NIC，由网卡硬件完成 TCP 分段和校验和计算。这减少了内核的协议栈开销和 CPU 使用率。
LRO（Large Receive Offload）：网卡硬件在将多个属于同一 TCP 连接的 segments 合并成一个大 buffer 后传递。已逐渐被 GRO 取代。
GRO（Generic Receive Offload）：软件实现的接收合并，在 NIC 不支持 LRO 时由内核的 gro_receive() 实现，减少传递到协议栈的 skb 数量。
# 查看网卡 offload 能力
ethtool -k eth0 | grep scatter-gather
ethtool -k eth0 | grep tcp-segmentation-offload
ethtool -k eth0 | grep generic-receive-offload

# 临时关闭（排查性能问题时有用）
ethtool -K eth0 tso off gro off gso off

七、生产环境中的网络性能调优

7.1 网卡调优与 Ring Buffer
# 检查网卡 Ring Buffer 大小
ethtool -g eth0
# Pre-set RX/TX maximums: 4096
# Current RX/TX settings: 1024

# 设置为最大值
ethtool -G eth0 rx 4096 tx 4096

# 验证
ethtool -g eth0

# 查看丢包统计（Ring Buffer 溢出导致的丢包）
ethtool -S eth0 | grep -E 'drop|miss|error|fifo'
ifconfig eth0 | grep 'RX errors'
# /sys/class/net/eth0/statistics/rx_missed_errors
如果观察到 rx_missed_errors 或 rx_fifo_errors 增加，说明 Ring Buffer 太小，CPU 来不及处理到达的数据包。

7.2 中断合并（Interrupt Coalescing）
网卡收到数据包后不一定立即产生中断，可以积累一定数量的包或在超时后才中断一次。通过 ethtool -C（Coalesce settings）配置：
# 查看当前配置
ethtool -C eth0
# rx-usecs: 30（30微秒超时）
# rx-frames: 8（8个包触发中断）

# 高带宽场景：降低中断频率（增大 coalescing）
ethtool -C eth0 rx-usecs 100 rx-frames 64

# 低延迟场景：降低 coalescing
ethtool -C eth0 rx-usecs 0 rx-frames 1
关闭合并（rx-usecs=0, rx-frames=1）达到最低延迟，但 CPU 中断频率最高。

7.3 Qdisc 与流量整形
Linux 通过 Qdisc（排队规则）控制数据包的发送时序：

pfifo_fast（默认）：三个优先级队列，按优先级 Band 发送
fq（Fair Queue）：每个 Flow 独立队列，防止单一 Flow 占用全部带宽
FQ_Codel（默认推荐）：在 fq 基础上增加 CoDel 算法，控制排队延迟（Bufferbloat 的解决方案）
Cake：结合 FQ + CoDel + 多种功能（ACK 过滤、分片、Diffserv 标记）

# 使用 FQ（自动配置单队列网卡）
tc qdisc del dev eth0 root
tc qdisc add dev eth0 root fq
tc -s qdisc show dev eth0

# 使用 FQ_Codel
tc qdisc add dev eth0 root fq_codel
tc -s qdisc show

# Cake（综合最优，适合带宽有限链路如 ADSL/光纤）
tc qdisc add dev eth0 root cake bandwidth 100mbit

7.4 内核参数调优（/etc/sysctl.conf）
生产环境中典型的 TCP 网络调优参数：
# /etc/sysctl.d/10-network.conf
# 增大 TCP 读写缓冲区最大值（支持自动调优）
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# 增大最大连接数和 backlog
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 65535

# TCP 内存（单位：页 = 4KB）pages
net.ipv4.tcp_mem = 786432 1048576 1572864

# 保持 TIME_WAIT 连接性能
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 15

# TCP 快速打开（需要客户端和服务端同时支持）
net.ipv4.tcp_fastopen = 3

# 保持连接（Keepalive）时间
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 5

# 使用 BBR 拥塞控制
net.ipv4.tcp_congestion_control = bbr
net.core.default_qdisc = fq

# 连接跟踪表大小
net.netfilter.nf_conntrack_max = 524288
net.netfilter.nf_conntrack_tcp_timeout_established = 86400

sysctl -p /etc/sysctl.d/10-network.conf

八、观测、调试与排错工具

8.1 实时监控工具链
# 连接状态与队列监控
ss -ti                     # TCP 内部详情（cwnd/rtt/rto）
ss -tnp                    # 快速查看所有 TCP 连接的 PID/程序名
netstat -s                 # 全局协议统计（TCP/UDP/IP 错误计数）
nstat -z                   # 内核 SNMP 统计（每秒采样，不重置）

# 网卡统计与错误
ethtool -S eth0 | grep -E 'drop|error|fifo|crc|missed'
cat /proc/net/dev                      # 字节和包统计

# 跟踪内核协议栈
perf top -e cycles:k --exclude-user   # 内核热点函数
bpftrace -e 'kprobe:dev_queue_xmit { @[comm] = count(); }'  # eBPF 跟踪

# 完整数据包捕获
tcpdump -i eth0 -w capture.pcap -c 10000
tshark -r capture.pcap -Y "tcp.analysis.retransmission"

8.2 ss 输出深度解读
ss -ti dst 192.168.1.1:443

# 典型输出字段解释：
# cubic：当前拥塞控制算法
# cwnd:20：当前拥塞窗口 20 segments
# ssthresh:28：慢启动阈值
# rtt:15.3/2.1ms：平均 RTT 和 RTT 方差
# ato:40：ACK 发送超时
# pmtu:1500：路径 MTU
# rcvmss:1448：接收端最大 segment
# advmss:1448：通告的 MSS
# wscale:7,7：窗口缩放因子
# bytes_received：接收到的字节数

8.3 常见网络问题排查思路
问题 1：网络吞吐量低

检查 ethtool -S 中的丢包统计 — Ring Buffer 或中断不够
检查 ss -ti 中是否有大量 retransmission（tcp.analysis.retransmission），可能是带宽不足或拥塞控制错误
检查 Qdisc 排队延迟：tc -s qdisc show
检查 Socket 缓冲区是否达到上限（/proc/net/sockstat）

问题 2：TCP 连接建立慢/大量 TIME_WAIT

TIME_WAIT 过多：启用 tcp_tw_reuse，检查应用层是否正确关闭连接
半连接队列打满：检查 netstat -s | grep "SYNs to LISTEN"，启用 SYN Cookie
全连接队列打满：增大 somaxconn，加速 accept() 处理

问题 3：高并发下连接重置（RST）

应用层 listen() backlog 过小 → 客户端 connect 获取 RST
conntrack 表满 → 新建连接被丢弃
文件描述符耗尽


九、总结与展望
Linux 内核网络协议栈是一个历经 30 年演进的系统工程壮举。从 2.6 时代的 NAPI 和多队列，到 4.x 时代的 XDP/eBPF 可编程数据平面，再到 5.x/6.x 的 BBRv3 拥塞控制和大页内存优化，每一代内核都在提升吞吐量的同时降低延迟和抖动。
要真正掌握这个协议栈，建议的进阶路线：从 tcpdump + wireshark 抓包分析开始 → bpftrace 内核函数跟踪定位问题 → 用 eBPF/XDP 实现定制化网络功能 → 在 DPDK/Kernel TCP Stack 之间权衡选择。
未来，随着 CXL 内存池化和硬件卸载（TLS/IPsec/E810 RDMA）的普及，内核协议栈可能会进一步将更多功能卸载到网卡硬件，软件层则通过 eBPF/XDP 提供更灵活的编程接口。理解内核数据路径的本质，将是驾驭这个演进方向的基础。