第10周：网络数据包旅程——从网卡到 socket

字数统计: 2.5k字   |   阅读时长≈ 11分

第10周：网络数据包旅程——从网卡到 socket

目标：理解一个网络数据包从网卡硬件到用户态 socket 的完整路径，掌握 sk_buff 结构体和中断/软中断机制。

1. 数据包接收路径全貌

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
硬件层面：
  网卡 DMA → 网卡 Ring Buffer → 中断通知 CPU

内核层面：
  硬中断 (IRQ handler)
     → NAPI 调度
       → 软中断 (ksoftirqd / NET_RX 软中断)
         → netif_receive_skb
           → IP 层 (ip_rcv)
             → 路由查找
               → TCP/UDP 层
                 → socket 接收队列
                   → 用户进程 read() 读取

发送路径（反向）：
  用户 write()
    → socket 发送队列
      → TCP 层处理
        → IP 层 (ip_queue_xmit)
          → 邻居子系统（ARP）
            → 网络设备 (dev_queue_xmit)
              → 网卡驱动排队
                → DMA 发送

2. 中断处理与 NAPI

2.1 硬中断（Top Half）

1
2
3
4
5
6
7
8
9
10
11
收到数据包 → 网卡 DMA 到内存 → 触发中断 → CPU 暂停当前任务 → 执行 IRQ handler

硬中断 handler 工作：
  1. 读取网卡 Ring Buffer 中的新包描述符
  2. 分配 sk_buff（skb）
  3. 将数据 DMA 地址映射到 skb
  4. 调用 netif_receive_skb()（大部分工作推迟）
  5. 通知网卡可以接收新包
  6. 清除中断

时间要求：硬中断 handler 必须极短（< 1ms），不能睡眠

2.2 NAPI（New API）机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
问题：高流量时，每个包都触发硬中断 → 中断风暴 → CPU 卡在中断处理

NAPI 解决方案：
  1. 硬中断 handler 只做最少的必要工作
  2. 禁用网卡中断，改为轮询（poll）
  3. 轮询一批包后再开启中断
  4. 如果还有包，调度 ksoftirqd 继续处理

流程：
  硬中断 handler
    → napi_schedule()       // 调度 NAPI 轮询
      → __raise_softirq_irqoff(NET_RX_SOFTIRQ)
        → 唤醒 ksoftirqd 或当前 CPU 的软中断处理
          → net_rx_action()   // 轮询循环
            → 从网卡 Ring Buffer 取包
            → 调用 netif_receive_skb()
            → 直到 Ring Buffer 清空
            → 重新开启网卡中断

2.3 软中断与 ksoftirqd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
软中断优先级（高→低）：
  TIMER_SOFTIRQ      // 定时器
  NET_TX_SOFTIRQ     // 网络发送
  NET_RX_SOFTIRQ     // 网络接收（NAPI）
  BLOCK_SOFTIRQ      // 块设备
  TASKLET_SOFTIRQ    // Tasklet

ksoftirqd：每个 CPU 一个内核线程
  - 当软中断过多时，ksoftirqd 被唤醒分担处理
  - 防止软中断长时间占用 CPU 导致用户进程饥饿

查看软中断：
  cat /proc/softirqs          # 累计计数
  watch -n 1 "cat /proc/softirqs"  # 实时监控
  cat /proc/interrupts        # 硬中断
1
2
3
4
5
6
7
8
9
10
11
# 查看 NAPI 统计
cat /proc/net/softnet_stat
# 字段: CPU  [处理次数] [ dropped ] [ 时间片超时 ]

# 查看 ksoftirqd
ps aux | grep ksoftirqd

# 查看网络中断
cat /proc/interrupts | grep eth
#  45:  1234567  0  PCI-MSI  eth0-rx-0
#  46:   234567  0  PCI-MSI  eth0-tx-0

3. sk_buff 结构体（核心中的核心）

3.1 结构体图示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
struct sk_buff {
    // ─── 链表节点 ───
    struct sk_buff      *next, *prev;     // 双向链表（socket 发送/接收队列）
    struct sk_buff      *next, *prev;     // 链表（TCP 分片队列等）

    // ─── 时间戳 ───
    ktime_t             tstamp;           // 接收/发送时间戳

    // ─── 协议相关 ───
    struct sock         *sk;              // 所属 socket
    struct net_device   *dev;             // 发送/接收设备
    struct sk_buff      *tcp_ts_skb;      // TCP timestamp 引用

    // ─── 数据指针 ───（最关键）
    unsigned int        len;              // 当前数据长度（可变化）
    unsigned int        data_len;         // 非线性数据长度（fragments）
    __u16               hdr_len;           // 头部长度
    __be16              protocol;         // 协议类型（ETH_P_IP, ETH_P_IPV6）

    // 数据区域指针：
    unsigned char       *head;            // 缓冲区起始（分配的内存头）
    unsigned char       *data;            // 当前数据起始（头部之后）
    unsigned char       *tail;            // 数据末尾（最后一个字节+1）
    unsigned char       *end;             // 缓冲区末尾（end = head + alloc_size）

    // ─── 协议头指针（辅助，指向各层头部）───
    __u16               mac_header;       // 二层 MAC 头偏移（相对 head）
    __u16               network_header;   // 三层 IP 头偏移
    __u16               transport_header; // 四层 TCP/UDP 头偏移
    __u16               mac_len;          // MAC 头长度
    __u16               hdr_len;          // 头部总长度

    // ─── 分片 ───
    unsigned int        truesize;         // 真实占用内存大小
    unsigned int        frag_list_len;    // 分片链表长度
    struct sk_buff      *frag_list;       // 分片链表头

    // ─── 控制信息 ───
    __u32               priority;         // 包优先级
    __u32               mark;             // netfilter mark
    sk_buff_data_t      mac_header;       // mac 头偏移
};

// 内存布局示意：
// head                                                end
//  |----------- alloc_size (truesize) ---------------|
//  |--- headroom ---|--- len ---|--- tailroom ---|
//  |                  data                  tail   |
//  [ MAC | IP | TCP | payload | ...  padding       ]
//   ↑                 ↑
//   mac_header        data (transport_header 之后)
1
2
3
4
5
6
7
8
9
数据指针关系：
  head → 分配的缓冲区起始
  data → 实际数据的起始（通常跳过 MAC 头）
  tail → 数据末尾（最后一个字节的下一个位置）
  end  → 缓冲区末尾

  有效数据 = [data, tail)，长度为 len = tail - data
  可用尾部空间 = end - tail（用于 push 数据）
  可用头部空间 = data - head（用于 push 头部）

3.2 sk_buff 操作函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <linux/skbuff.h>

// === 分配/释放 ===
struct sk_buff *skb = alloc_skb(len, GFP_KERNEL);
kfree_skb(skb);
dev_kfree_skb(skb);      // 通知设备层
consume_skb(skb);        // 不通知（快速释放）

// === 数据操作 ===
skb_put(skb, len);       // 尾部扩展 len 字节，返回旧 tail
skb_push(skb, len);      // 头部扩展 len 字节（预添加头部），返回新 data
skb_pull(skb, len);      // 从头部移除 len 字节（消费头部），返回新 data
skb_reserve(skb, len);   // 头部预留空间（push 数据前用）

// 等价关系：
// data + len == tail
// head <= data （data 在 head 之后）
// tail <= end

// === 头部操作示例 ===

// TCP 发送时：
skb = alloc_skb(64, GFP_KERNEL);  // 分配 64 字节
skb_reserve(skb, MAX_TCP_HEADER);  // 头部留出空间

// push IP 头（20 字节）
skb_push(skb, sizeof(struct iphdr));
skb_reset_network_header(skb);    // 设置 network_header

// push TCP 头（20 字节）
skb_push(skb, sizeof(struct tcphdr));
skb_reset_transport_header(skb);  // 设置 transport_header

// 复制 payload
skb_put(skb, payload_len);
memcpy(skb->data, payload, payload_len);

// 设置 MAC 头
skb_reset_mac_header(skb);
// 如果是在 bridge 或 ethernet 层
eth_hdr(skb)->h_proto = htons(ETH_P_IP);

// === 复制/裁剪 ===
skb_copy(skb);           // 深拷贝
skb_clone(skb);          // 浅拷贝（共享数据，引用计数+1）
skb_split(skb, split_at, child_skb);  // 分片
skb_trim(skb, len);      // 裁剪到 len 长度

3.3 sk_buff 变体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// struct sk_buff — 完整版（大对象，用在关键路径）
// - 包含所有字段
// - 通过 slab 缓存分配
// - 对齐到 cache line

// struct sk_buff_head — sk_buff 链表头
struct sk_buff_head {
    struct sk_buff *next;
    struct sk_buff *prev;
    __u32 qlen;      // 链表长度
    spinlock_t lock; // 自旋锁
};

// 常用操作
skb_queue_head(&head, skb);   // 头部入队
skb_queue_tail(&head, skb);   // 尾部入队
skb_dequeue(&head);           // 头部出队
skb_dequeue_tail(&head);      // 尾部出队
skb_queue_purge(&head);       // 清空队列

4. 发送路径详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
用户态：write(buf, len)
  │
  ▼
系统调用 → sys_write()
  │
  ▼
sock_write_iter() → kernel_sendpage()
  │
  ▼
sk->sk_prot->sendmsg() = tcp_sendmsg()
  │
  ▼
tcp_sendmsg()
  1. 获取 tcp_sock (sk)
  2. 锁定 socket
  3. 遍历用户数据，分段为 MSS 大小的段
  4. 每段：
     a. alloc_skb() + skb_reserve(headroom)
     b. skb_store_bits() — 拷贝数据
     c. tcp_transmit_skb() — 提交发送
  5. 如果 sk_stream_wait_memory() 返回错误，等待或报错

tcp_transmit_skb():
  1. 调用 ip_queue_xmit(skb)
     ├── 检查路由（dst = skb_dst(skb)）
     ├── 设置 IP 头（iphdr）
     ├── 分片判断（DF 标志 + MTU）
     └── dst->output(skb) → ip_finish_output()
        ├── 检查邻居（ARP 解析）
        ├── dev_queue_xmit(skb)  → 提交到网卡
        └── 网卡驱动 poll / interrupt → DMA 发送

4.1 关键数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// tcp_sock — TCP socket 专用结构
struct tcp_sock {
    struct inet_connection_sock inet_conn;
    
    // 发送
    __u32               snd_nxt;       // 下一个发送序列号
    __u32               snd_una;       // 最早未确认序列号
    __u32               snd_wnd;       // 发送窗口
    __u32               snd_cwnd;      // 拥塞窗口
    __u32               snd_ssthresh;  // 慢启动阈值
    
    // 接收
    __u32               rcv_nxt;       // 期望接收的下一个序列号
    __u32               rcv_wnd;       // 接收窗口
    
    // 队列
    struct sk_buff_head out_of_order_queue;  // 乱序队列
    struct sk_buff_head receive_queue;       // 接收队列（已排好序）
    struct sk_buff_head backlog_queue;       // backlog 队列
    struct sk_buff_head prequeue;            // 预读队列（条件接收）
    
    // 其他
    __u32               mss_cache;     // 缓存 MSS
    __u32               rx_opt;        // 接收选项
    // ... 更多 TCP 状态
};

5. 接收路径详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
网卡 DMA → 内存
  │
  ▼ 硬中断
netif_rx(skb)
  │
  ▼
enqueue_to_backlog() 或 napi_gro_receive()
  │
  ▼ 软中断 NET_RX_SOFTIRQ
net_rx_action()
  │
  ▼
__netif_receive_skb(skb)
  │
  ├── VLAN 处理（vlan_do_receive）
  ├── BPF/XDP 过滤
  ├── bond/team 处理
  │
  ▼
deliver_skb()
  │
  ├── 本地交付 → ip_local_deliver()
  │   ├── ip_local_deliver_finish()
  │   │   ├── iptables (NF_INET_LOCAL_IN)
  │   │   ├── 协议分发 (raw/udp/tcp/icmp)
  │   │   └── tcp_v4_rcv() 或 udp_v4_rcv()
  │   │       ├── sock_put() 查找 socket
  │   │       ├── sk_receive_skb() → 加入接收队列
  │   │       └── sock_def_readable() → 唤醒等待进程
  │   └── 通过 netlink 通知用户态（如 tcpdump）
  │
  └── 转发 → ip_forward() → NF_INET_FORWARD
      ├── 路由查找
      ├── 分片/重组
      └── ip_finish_output() → 发送到下一个 hop

6. 实践：ftrace 跟踪数据包路径

6.1 ftrace 基础

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 挂载 tracefs
sudo mount -t tracefs nodev /sys/kernel/tracing

# 或使用 debugfs
sudo mount -t debugfs nodev /sys/kernel/debug/tracing

# 进入跟踪目录
cd /sys/kernel/tracing

# === 常用命令 ===
cat available_tracer_functions     # 查看可跟踪的函数
cat available_filter_functions     # 过滤函数
cat trace          # 查看跟踪结果
cat trace_pipe     # 实时流式输出
echo 0 > tracing_on  # 停止跟踪
echo 1 > tracing_on  # 开始跟踪
echo > trace         # 清空缓冲区

6.2 跟踪 netif_receive_skb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
cd /sys/kernel/tracing

# 设置函数过滤器
echo netif_receive_skb > set_ftrace_filter

# 设置跟踪选项
echo function > current_tracer      # 函数跟踪
echo 'funcgraph-proc' > options    # 显示进程信息

# 开始跟踪
echo 1 > tracing_on

# 产生一些网络流量
ping -c 5 8.8.8.8

# 停止跟踪
echo 0 > tracing_on

# 查看结果
cat trace | head -50

# 示例输出：
#  ping-1234  [001] ....  1234.567890: netif_receive_skb <- __netif_receive_skb_one_core
#  ping-1234  [001] ....  1234.567890: __netif_receive_skb_one_core <- process_backlog
#  ping-1234  [001] ....  1234.567890: process_backlog <- net_rx_action

6.3 跟踪网络完整路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
cd /sys/kernel/tracing

# 设置多个跟踪点
cat available_tracer_functions | grep -E "netif|ip_rcv|tcp_v4|skb_alloc" | head -20

# 批量过滤
echo netif_rx >> set_ftrace_filter
echo netif_receive_skb >> set_ftrace_filter
echo ip_rcv >> set_ftrace_filter
echo tcp_v4_rcv >> set_ftrace_filter
echo skb_alloc >> set_ftrace_filter

# 使用 function_graph 跟踪（显示调用层级）
echo function_graph > current_tracer
echo 1 > tracing_on

# 产生流量
curl http://example.com &

# 等待几秒
sleep 3
echo 0 > tracing_on

# 查看完整调用链
cat trace | grep -E "skb_alloc|netif_rx|ip_rcv|tcp_v4"

6.4 kprobe 动态跟踪

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# kprobe 可以在运行时跟踪任意函数，无需重新编译内核

cd /sys/kernel/tracing

# 设置 kprobe（在函数入口跟踪）
echo 'p:myprobe netif_receive_skb' > kprobe_events

# 设置返回值跟踪
echo 'r:myret netif_receive_skb' > kprobe_events

# 或使用 uprobe（跟踪用户空间函数）
echo 'p:my_uprobe /usr/bin/ping:main' > uprobe_events

# 过滤特定条件
echo 'p:myprobe netif_receive_skb if (skb->protocol == 8)' > kprobe_events

# 启用
echo 1 > events/kprobes/myprobe/enable

# 产生流量
ping -c 3 8.8.8.8

# 查看结果
cat trace | grep myprobe

# 清理
echo 0 > events/kprobes/myprobe/enable
echo > kprobe_events

7. perf 分析网络栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# === CPU 性能分析 ===

# 统计网络相关函数的热度
perf record -g -p $(pidof nginx) -- sleep 10
perf report

# 按网络子系统过滤
perf record -e net:net_dev_queue -e net:net_dev_xmit \
            -e net:napi_gro_receive \
            -a -- sleep 5

# === tracepoint 分析 ===
perf record -e net:netif_receive_skb \
            -e net:net_dev_xmit \
            -e skb:skb_copy_datagram_iovec \
            -a -- sleep 5

perf report

8. 跟踪工具总结

工具 用途 层次
tcpdump 抓包分析 数据平面（包内容）
ftrace 内核函数跟踪 内核函数调用
perf 性能分析 CPU 指令级
bpftrace 动态 eBPF 跟踪 内核/用户态事件
systemtap 深度内核跟踪 内核任意位置
etrace 网络栈跟踪 特定于网络

8.1 bpftrace 跟踪示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 跟踪 skb 分配
sudo bpftrace -e '
tracepoint:skb:skb_alloc {
    @alloc[stack] = count();
}'

# 跟踪 netif_receive_skb 的延迟
sudo bpftrace -e '
kprobe:netif_receive_skb {
    @start[arg0] = nsecs;
}
kretprobe:netif_receive_skb /@start[arg0]/ {
    @latency = hist((nsecs - @start[arg0]) / 1000);
    delete(@start[arg0]);
}'

# 跟踪 TCP 状态转换
sudo bpftrace -e '
tracepoint:tcp:tcp_set_state {
    if (args->newstate == 1)  // TCP_ESTABLISHED
        @established = count();
    if (args->newstate == 8)  // TCP_CLOSE
        @closed = count();
}'
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870