Linux 内核 TCP/IP 协议栈深度实战：从 NAPI 轮询到零拷贝收包与拥塞控制全链路

struct napi_struct {
    struct list_head poll_list;    // 全局轮询链表节点
    unsigned long state;            // NAPI_STATE_SCHED 等状态位
    int weight;                     // 单次 poll() 配额（默认 64）
    int (*poll)(struct napi_struct *, int);  // 驱动注册的轮询函数
    // ... gro 相关字段、timestamp 字段
};

// drivers/net/ethernet/intel/ice/ice_base.c
netif_napi_add(pf->netdev, &q_vector->napi, ice_napi_poll, NAPI_POLL_WEIGHT);

static int ice_napi_poll(struct napi_struct *napi, int budget) {
    struct ice_q_vector *q_vector = container_of(napi, struct ice_q_vector, napi);
    int work_done = 0;
    
    // 1. 清理已完成的 Tx 描述符
    ice_clean_tx_irq(tx_ring, budget);
    
    // 2. 处理 Rx 队列
    if (ring->rx_buf_len <= PAGE_SIZE) {
        work_done = ice_clean_rx_irq(ring, budget);
    } else {
        // 大帧场景使用 page 拆分模式
        work_done = ice_clean_rx_irq_unlocked(ring, budget);
    }
    
    // 3. Budget 用完仍有包则返回 budget，触发下次轮询
    if (work_done < budget) {
        napi_complete_done(napi, work_done);  // 退出轮询模式
        ice_irq_enable(q_vector, true);        // 重新使能中断
    }
    return work_done;
}

struct sk_buff {
    union { struct sk_buff *next; struct rb_node rbnode; };
    struct sock *sk;                    // 所属 socket
    unsigned char *head;                // 缓冲区起始
    unsigned char *data;                // 当前层数据起始
    unsigned char *tail;                // 当前层数据结束
    unsigned char *end;                 // 缓冲区结束
    unsigned int len;                   // 实际数据长度
    unsigned int data_len;              // paged data 长度（分片场景）
    __u16 mac_len, transport_header;    // 各层头部偏移
    // ... protocol, priority, mark 等字段
    // 关键：共享信息结构体 refcount 控制生命周期
};

// net/core/dev.c
static void net_rx_action(struct softirq_action *h) {
    struct list_head *list = &__this_cpu(softnet_data).poll_list;
    unsigned long time_limit = jiffies + 2;  // 2 jiffies 时间片限制
    int budget = netdev_budget;               // 默认 budget = 300
    
    // 遍历本 CPU 注册的所有 NAPI 设备
    while (!list_empty(list)) {
        struct napi_struct *n;
        int work, weight;
        
        n = list_first_entry(list, struct napi_struct, poll_list);
        weight = n->weight;
        work = n->poll(n, min(budget, weight));
        
        budget -= work;
        if (work >= weight) budget--;  // 开销扣除
    }
}

# 将流量按 CPU0-CPU3 分流（掩码形式）
echo f > /sys/class/net/eth0/queues/rx-0/rps_cpus

# 设置全局的 RPS 流表大小（控制 per-flow 的 CPU 分配）
echo 32768 > /proc/sys/net/core/rps_sock_flow_entries
echo 4096 > /sys/class/net/eth0/queues/rx-0/rps_flow_cnt

// include/net/request_sock_queue.h
struct request_sock_queue {
    struct request_sock *rskq_accept_head;  // accept 队列头
    struct request_sock *rskq_accept_tail;  // accept 队列尾
    // ...
    u8 rskq_defer_accept;                   // TCP_DEFER_ACCEPT 选项
};

// net/ipv4/tcp_bbr.c
struct bbr {
    u64 min_rtt_us;              // 最小 RTT（10s 窗口）
    u64 bw_hi;                   // 瓶颈带宽上限
    u64 bw_lo;                   // 瓶颈带宽下限
    u64 pacing_rate;             // 当前 pacing 速率
    u32 rtt_probe_bw_cwnd_gain;  // RTT 探测时的窗口增益
    u32 probe_rtt_cwnd_timeout;  // RTT 探测超时
    // BBR v3 新增：ECN 响应
    u32 ecn_alpha;               // ECN 标记累积率计算
};

# 全局启用 TFO（客户端 + 服务端）
sysctl -w net.ipv4.tcp_fastopen=3
# 0=关闭  1=仅客户端  2=仅服务端  3=两者都启用

// 传统方式（4 次拷贝）
read(buf, len);    // PageCache → user buf  [CPU copy]
write(sock, len);  // user buf → socket    [CPU copy] + DMA

// sendfile 方式（2 次拷贝，0 次 CPU 拷贝）
sendfile(sock, fd, &offset, len);
// PageCache → socket buffer descriptor  [仅需复制描述符]
// 实际数据通过 DMA 从磁盘 → PageCache → 网卡

// GRO 收包流程（简化）
gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb) {
    // 1. 有 GRO 能力的协议层（TCP/UDP/VXLAN）注册 gro_receive()
    list_for_each_entry_rcu(offload, &offload_base, list) {
        if (offload->type == ntohs(skb->protocol)) {
            ret = offload->gro_receive(&napi->gro_hash, skb);
        }
    }
    // 2. 合并成功的包暂存在 gro_hash，超时或包积累到一定量后 flush
    // 3. 无法合并的包通过 netif_receive_skb() 注入协议栈
}

# 全局 busy_poll 超时（微秒）
sysctl -w net.core.busy_poll=50
sysctl -w net.core.busy_read=50

# 或在 socket 级别设置
setsockopt(fd, SOL_SOCKET, SO_BUSY_POLL, &timeout_us, sizeof(int));

// BPF 程序：跟踪 netif_receive_skb 到 tcp_v4_rcv 的延迟
SEC("kprobe/netif_receive_skb")
int trace_recv_start(struct pt_regs *ctx) {
    struct sk_buff *skb = (struct sk_buff *)PT_REGS_PARM1(ctx);
    u64 ts = bpf_ktime_get_ns();
    u32 key = hash_skb(skb);
    start.update(&key, &ts);
    return 0;
}

SEC("kretprobe/tcp_v4_rcv")
int trace_recv_end(struct pt_regs *ctx) {
    struct sk_buff *skb = ctx->ret_value;
    u64 *tsp = start.lookup(&key);
    if (tsp) {
        u64 delta_us = (bpf_ktime_get_ns() - *tsp) / 1000;
        // 直方图记录延迟分布
        latency.increment(bpf_log2l(delta_us));
    }
    return 0;
}

#!/bin/bash
# netdiag.sh：网络栈健康诊断
echo "=== TCP 连接状态分布 ==="
ss -tan | awk '{print $1}' | sort | uniq -c | sort -rn

echo ""
echo "=== 重传率（需 ethtool 支持） ==="
netstat -s | grep -i "retrans\|timeout\|error"

echo ""
echo "=== 半连接/全连接队列溢出 ==="
netstat -s | grep -E "overflow|drop|abort"

echo ""
echo "=== 各队列收包统计 ==="
for rxq in /sys/class/net/eth0/queues/rx-*; do
    echo "$rxq: packets=$(cat $rxq/rps_cpus) drops=$(cat $rxq/rx_*_dropped)"
done

echo ""
echo "=== conntrack 使用率 ==="
echo "当前: $(cat /proc/sys/net/netfilter/nf_conntrack_count)"
echo "上限: $(cat /proc/sys/net/netfilter/nf_conntrack_max)"
echo "使用率: $(awk "BEGIN {printf \"%.2f%%\", $(cat /proc/sys/net/netfilter/nf_conntrack_count)*100/$(cat /proc/sys/net/netfilter/nf_conntrack_max)}")"

echo ""
echo "=== 软中断分布 ==="
top -H -b -n1 | grep softirq