第13周：TCP 协议栈内核实现

字数统计: 3.1k字   |   阅读时长≈ 15分

第13周：TCP 协议栈内核实现

目标：深入阅读 TCP 协议栈关键函数源码，理解内核如何管理 TCP 连接和拥塞控制。

1. TCP 协议栈源码导航

1.1 关键文件

1
2
3
4
5
6
7
8
9
10
11
12
13
net/ipv4/tcp.c              # TCP 主文件（socket 操作、管理）
net/ipv4/tcp_input.c        # TCP 输入处理（最复杂，约 3000 行）
net/ipv4/tcp_output.c       # TCP 输出处理（发送）
net/ipv4/tcp_timer.c        # TCP 定时器（重传、保活等）
net/ipv4/tcp_ipv4.c         # IPv4 专用 TCP 处理
net/ipv4/tcp_minisocks.c    # TCP_MIN 状态处理
net/ipv4/tcp_metrics.c      # TCP 指标缓存
net/ipv4/tcp_rate.c         # 速率估计

include/net/tcp.h           # TCP 结构体定义和宏
include/linux/tcp.h         # TCP 协议常量
include/uapi/linux/tcp.h    # 用户可见 TCP 头
include/net/inet_connection_sock.h  # INET socket 结构

1.2 TCP 核心结构体

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
52
53
54
55
56
57
58
59
60
// include/net/tcp.h

struct tcp_sock {
    // 通用 INET 连接 socket
    struct inet_connection_sock inet_conn;

    // === 发送 ===
    __u32   snd_nxt;           // 下一个发送序列号
    __u32   snd_una;           // 最早未确认序列号
    __u32   snd_wl1;           // 上次收到 ACK 时的序列号
    __u32   snd_wl2;           // 上次收到 ACK 时的确认号
    __u32   snd_wnd;           // 对方通告的发送窗口
    __u32   snd_up;            // 紧急指针
    __u32   snd_ssthresh;      // 慢启动阈值
    __u32   snd_cwnd;          // 拥塞窗口（字节）
    __u32   snd_cwnd_stamp;    // cwnd 上次更新时间
    __u32   snd_mss;           // 缓存 MSS
    __u32   packets_out;       // 已发送未确认的段数
    __u32   retrans_out;       // 重传的段数
    __u32   lost_out;          // 标记为丢失的段数

    // === 接收 ===
    __u32   rcv_nxt;           // 期望接收的下一个序列号
    __u32   rcv_wnd;           // 接收窗口
    __u32   copied_seq;        // 用户已读到的序列号
    __u32   rcv_tstamp;        // 接收时间戳

    // === 队列 ===
    struct sk_buff_head out_of_order_queue;  // 乱序队列
    struct sk_buff_head receive_queue;       // 已接收且已排序
    struct sk_buff_head backlog_queue;       // 等待处理的队列
    struct sk_buff_head prequeue;            // 条件接收队列

    // === RTT 测量 ===
    __u32   srtt_us;           // 平滑 RTT（微秒）
    __u32   mdev_us;           // RTT 偏差
    __u32   mdev_max_us;       // RTT 偏差最大值
    __u32   rttvar_us;         // RTT 方差
    __u32   rtt_seq;           // RTT 测量序列号

    // === 时间戳（RFC 7323）===
    __u32   rx_opt.ts_recent;   // 最近收到的时间戳
    u32     rx_opt.ts_recent_stamp;  // 时间戳的时间

    // === 选项 ===
    u16     rx_opt.mss_clamp;  // 协商的 MSS
    u8      rx_opt.wscale_ok;  // 窗口缩放
    u8      rx_opt.sack_ok;    // SACK 启用
    u8      rx_opt.tstamp_ok;  // Timestamp 启用

    // === 拥塞控制 ===
    struct cubictcp_info      *cubic_info;  // Cubic/BBR 参数
    u32                       *ca_priv;      // 拥塞控制私有数据
    const struct tcp_congestion_ops *icsk_ca_ops;

    // === 其他 ===
    __u32   ecn_flags;         // ECN 标志
    u32     repair;            // 修复模式（TCP_REPAIR）
    // ... 更多字段
};

2. 接收路径源码分析

2.1 tcp_v4_rcv（TCP 输入入口）

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
// net/ipv4/tcp_ipv4.c

int tcp_v4_rcv(struct sk_buff *skb) {
    struct net *net = dev_net(skb->dev);
    struct sock *sk;
    struct tcphdr *th;
    bool refcounted;

    // 1. IP 头检查
    if (skb->pkt_type != PACKET_HOST)
        goto discard_it;

    th = (struct tcphdr *)skb->data;

    // 2. TCP 头检查
    if (th->doff < sizeof(*th) / 4)
        goto bad_packet;

    // 3. 跳过 TCP 头，定位 payload
    __skb_pull(skb, th->doff * 4);

    // 4. 校验和验证
    if (tcp_v4_checksum_init(skb))
        goto bad_packet;

    // 5. 查找 socket
lookup:
    sk = __inet_lookup_established(net, &tcp_hashinfo,
                                   iph->saddr, th->source,
                                   iph->daddr, ntohs(th->dest),
                                   inet_iif(skb));
    if (sk) {
        // === 找到已建立的 socket ===
        refcounted = sk->sk_state != TCP_TIME_WAIT;

        if (refcounted)
            sock_hold(sk);

        // 从 backlog 队列读取
        if (!sock_owned_by_user(sk)) {
            // 没有进程持有锁，直接处理
            ret = tcp_v4_do_rcv(skb, sk);
        } else {
            // 进程正在读写，加入 backlog 队列
            bh_lock_sock(sk);
            if (!sock_owned_by_user(sk)) {
                ret = tcp_v4_do_rcv(skb, sk);
            } else {
                // 加入 backlog
                tcp_add_backlog(sk, skb);
                bh_unlock_sock(sk);
                sock_put(sk);
                return NET_RX_SUCCESS;
            }
            bh_unlock_sock(sk);
        }

        if (refcounted) sock_put(sk);
        return ret;
    }

    // 6. 没有找到已建立的连接 → 检查是否需要新建
    if (th->ack) {
        // 收到 ACK 但无对应连接 → 发送 RST
        goto no_tcp_socket;
    }

    // 7. 新连接请求
    sk = __inet_lookup_listener(net, &tcp_hashinfo, iph->daddr, th->dest);
    if (!sk) {
        // 没有监听 socket → 发送 RST
        tcp_v4_send_reset(skb);
        goto discard_it;
    }

    // 8. 同步队列（SYN queue）处理
    sk = tcp_check_req(sk, skb, req, false);
    if (!sk)
        goto discard_it;

    // 9. 处理请求
    return tcp_v4_do_rcv(skb, sk);

no_tcp_socket:
    tcp_v4_send_reset(skb);
    ...;
}

2.2 tcp_v4_do_rcv（TCP 状态机处理）

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
// net/ipv4/tcp_ipv4.c

int tcp_v4_do_rcv(struct sk_buff *skb, struct sock *sk) {
    if (sk->sk_state == TCP_ESTABLISHED) {
        // === 已建立连接 ===
        tcp_rcv_established(sk, skb);
        return 0;
    }

    if (sk->sk_state == TCP_LISTEN) {
        // === 监听状态（新连接）===
        struct sock *child = tcp_v4_syn_recv_sock(sk, skb);
        if (child)
            tcp_v4_do_rcv(skb, child);  // 递归处理
        return 0;
    }

    // 其他状态
    if (tcp_rcv_state_process(sk, skb)) {
        // ...
    }

    tcp_prequeue(sk, skb);  // 条件预读
    return 0;
}

2.3 tcp_rcv_established（接收数据包处理）

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
// net/ipv4/tcp_input.c（核心）

void tcp_rcv_established(struct sock *sk, struct sk_buff *skb) {
    struct tcp_sock *tp = tcp_sk(sk);
    const struct tcphdr *th = tcp_hdr(skb);
    unsigned int len = skb->len;

    // 1. 快速路径检查
    if (len == tcp_hdrlen(th) && th->psh == 0 && !tp->urg_data) {
        // 纯 ACK（无数据）
        tcp_ack(sk, skb);
        __kfree_skb(skb);
        return;
    }

    // 2. 序列号有效性检查
    if (tcp_sequence(tp, TCP_SKB_CB(skb)->seq, len,
                     tp->rcv_nxt, tp->rcv_wnd)) {
        // 序列号无效
        tcp_send_ack(sk);
        goto drop;
    }

    // 3. 快速恢复（如果存在）
    if (tp->fast_ack_mode) {
        tcp_fast_ack(sk, skb);
    }

    // 4. 放入接收队列
    tcp_skb_enter_data_queue(sk, skb, TCP_SKB_CB(skb)->seq, len);

    // 5. 处理接收队列
    tcp_data_queue(sk, skb);

    // 6. 更新接收窗口
    tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;

    // 7. 发送 ACK
    if (tcp_should_ack(sk))
        tcp_send_ack(sk);

    // 8. 通知上层
    sk->sk_data_ready(sk);

    return;

drop:
    __kfree_skb(skb);
}

3. 发送路径源码分析

3.1 tcp_sendmsg（用户数据发送）

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// net/ipv4/tcp.c — 简化说明版（部分 API 为内核内部函数）

int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) {
    struct tcp_sock *tp = tcp_sk(sk);
    struct sk_buff *skb;
    int flags = msg->msg_flags;
    int mss_now;
    int copied = 0;

    // 1. 获取当前 MSS（限制每段大小）
    mss_now = tcp_send_mss(sk, &size, flags);

    // 2. 循环发送数据
    while (msg_data_left(msg)) {
        int copy;
        int max = size;

        // 等待发送窗口可用
        long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
        while (sk_stream_wait_memory(sk, &timeo)) {
            if (msg_data_left(msg) == 0)
                goto out;
            if (signal_pending(current))
                goto interrupted;
        }

        // 3. 获取当前写队列尾部 skb
        skb = tcp_write_queue_tail(sk);
        copy = mss_now;
        if (copy > max)
            copy = max;

        // 4. 拷贝数据到 skb（实际内核使用 iov_iter 处理分散/聚集 I/O）
        //    这里简化为：确保 skb 有足够 tailroom，然后 memcpy
        if (!skb || skb_tailroom(skb) < copy) {
            // 实际内核会调用 tcp_alloc_skb 或调整队列
            // 此处为简化示意
            skb = alloc_skb(copy + MAX_TCP_HEADER, GFP_KERNEL);
            if (!skb) break;
            skb_reserve(skb, MAX_TCP_HEADER);
        }
        {
            size_t to_copy = min(copy, skb_tailroom(skb));
            skb_put(skb, to_copy);
            // 从用户 iovec 拷贝（实际用 copy_from_iter_full）
            copy = to_copy;
            copied += copy;
        }

        // 5. 如果 skb 满了，提交发送
        if (skb_tailroom(skb) <= 0) {
            bool empty = tcp_write_queue_empty(sk);

            // 提交给 IP 层
            tcp_transmit_skb(sk, skb, empty);

            // 继续发送剩余数据
            while (msg_data_left(msg) > 0) {
                if (sk_stream_wait_memory(sk, &timeo))
                    break;
                skb = alloc_skb(mss_now + MAX_TCP_HEADER, GFP_KERNEL);
                // ... 分配并发送
            }
        }
    }

out:
    return copied;
}

3.2 tcp_transmit_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
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
// net/ipv4/tcp_output.c

int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, bool cloned) {
    struct inet_sock *inet = inet_sk(sk);
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);
    struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
    struct tcphdr *th;
    int err;

    // 1. 确定发送接口
    __skb_push(skb, sizeof(struct tcphdr));
    skb_reset_transport_header(skb);

    // 2. 构建 TCP 头
    th = tcp_hdr(skb);
    th->source = inet->inet_sport;
    th->dest = inet->inet_dport;
    th->seq = tcb->seq;
    th->ack_seq = tp->rcv_nxt;
    th->doff = sizeof(struct tcphdr) / 4;

    // 标志位
    if (tcb->tcp_flags & TCPHDR_PSH) th->psh = 1;
    if (tcb->tcp_flags & TCPHDR_URG) th->urg = 1;

    th->window = htons(tp->rcv_wnd);  // 通告接收窗口

    // 3. 构建 IP 头（通过路由）
    skb_push(skb, sizeof(struct iphdr));
    skb_reset_network_header(skb);
    skb_set_transport_header(skb, sizeof(struct iphdr));

    // 4. TCP 校验和
    th->check = 0;
    th->check = tcp_v4_send_check(sk, skb);

    // 5. 设置 IP 源/目的
    iph = ip_hdr(skb);
    iph->ihl = 5;
    iph->tot_len = htons(skb->len);
    iph->protocol = IPPROTO_TCP;
    iph->saddr = inet->inet_saddr;
    iph->daddr = inet->inet_rcv_saddr;
    iph->tos = inet->tos;

    // 6. 通过路由发送
    err = ip_queue_xmit(sk, skb, ipc->sndxmit);
    return err;
}

4. 拥塞控制机制

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
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
// include/net/tcp.h

struct tcp_congestion_ops {
    struct list_head list;
    const char *name;

    // 初始化（新连接建立时调用）
    void (*init)(struct sock *sk);

    // 释放
    void (*release)(struct sock *sk);

    // 检测到丢包时调用
    void (*cong_event)(struct sock *sk, enum tcp_ca_event ev);

    // 数据包确认时调用（更新 cwnd）
    void (*pkts_acked)(struct sock *sk, const struct skb_mstamp *info,
                       u32 num_acked);

    // 调整拥塞窗口
    void (*cong_control)(struct sock *sk, u32 ack, int flag);

    // 获取信息
    u32 (*get_info)(struct sock *sk, u32 ext);

    // 可选钩子
    u32 (*ssthresh)(struct sock *sk);
    u32 (*undo_cwnd)(struct sock *sk);

    // 拥塞状态标志
    u32 flags;
};

// 注册
static int __init tcp_cubic_register(void) {
    return tcp_register_congestion_control(&tcp_cubic_ops);
}

// 当前使用的拥塞控制
const struct tcp_congestion_ops *icsk->icsk_ca_ops;

// 切换拥塞控制
int tcp_set_congestion_control(struct sock *sk, const char *name) {
    struct tcp_congestion_ops *ca = tcp_ca_find(name);
    if (!ca) return -ENOENT;

    sk->sk_tx_queue_maybe_resched = 1;
    icsk->icsk_ca_ops = ca;
    ca->init(sk);
    return 0;
}

4.2 可用拥塞控制算法

1
2
3
4
5
6
7
8
9
10
# 查看支持的算法
cat /proc/sys/net/ipv4/tcp_available_congestion_control
# reno cubic bbr ...

# 查看当前使用的
cat /proc/sys/net/ipv4/tcp_congestion_control
# cubic

# 动态切换
echo bbr | sudo tee /proc/sys/net/ipv4/tcp_congestion_control

4.3 BBR 算法关键点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// BBR 核心概念（net/ipv4/tcp_bbr.c）：

struct bbr {
    u32     min_rtt_us;        // 最近测得的最小 RTT
    u32     bw;                // 带宽估计（bytes/s）
    u32     bw_lo;             // 带宽下限（探测阶段用）
    u32     bw_hi;             // 带宽上限
    u32     bw_in_use;         // 当前使用的带宽
    u32     bw_probe_pending;  // 是否在带宽探测

    u32     pacing_gain;       // pacing 速率增益
    u32     cwnd_gain;         // cwnd 增益

    u32     prior_cwnd;        // 上一次的 cwnd
    u32     idle_restart;      // 是否刚从空闲恢复
};

// BBR 四种模式：
// PROBE_BW  → 探测带宽（主要运行模式）
// PROBE_RTT → 降低 cwnd 测量真实最小 RTT
// STARTUP   → 慢启动（指数增长寻找带宽上限）
// DRAIN     → 排空队列

5. 接收队列深度分析

5.1 三级接收队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
包到达后经过的队列（从快到慢）：

1. prequeue（条件接收队列）：
   - 只在某些条件下使用（如 TCP_CORK）
   - 如果 socket 有 backlog 数据待处理，可能跳过
   - 数据在此等待被进程直接读取

2. backlog_queue（积压队列）：
   - 在进程上下文处理时的缓冲区
   - 当用户进程正在 read() 时，新数据先到这里
   - 大小受 tcp_rmem[2]（接收缓冲区上限）限制

3. receive_queue（接收队列）：
   - TCP 协议栈处理完毕，等待用户读取
   - 通过 sk->sk_receive_queue 访问
   - sock_def_readable() 唤醒等待的进程
   - 大小 = 已接收但未读取的数据量
1
2
3
4
5
6
7
8
9
// 查看接收队列状态（内核调试）
// sk->sk_receive_queue.qlen  → 队列中 skb 数量
// sk->sk_rmem_alloc          → 已分配接收内存
// sk->sk_rcvbuf              → 接收缓冲区上限

// 系统级查看
ss -tin               # 显示 rmem 信息
cat /proc/net/tcp     # 连接状态
ss -s                 # socket 统计摘要

5.2 sk_rcvbuf 动态调整

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
// net/ipv4/tcp.c

// 接收缓冲区动态调整
static void tcp_rcv_space_adjust(struct sock *sk, int copied) {
    struct tcp_sock *tp = tcp_sk(sk);
    u64 time;

    if (copied <= 0)
        return;

    // 定期调整（不是每个包都调）
    if (time_after_eq(jiffies, tp->rcvtime_stamp + HZ / 2)) {
        u64 val;
        int mss;

        mss = tp->rx_opt.mss_clamp ?: tcp_default_mss(sk);

        // 计算新的接收窗口
        // rcv_wnd = (收到数据的速率) × (RTT)
        time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcv_time_stamp);
        val = (u64)copied * scaled;

        // 平滑处理
        tp->rcvq_space.space = max(tp->rcvq_space.space >> 1, val);

        // 调整 sk_rcvbuf
        sk->sk_rcvbuf = min(tp->rcvq_space.space * 2,
                            sysctl_tcp_rmem[2]);
    }
}

6. 内核 TCP 参数速查

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
# === 发送缓冲区 ===
/proc/sys/net/ipv4/tcp_wmem  # 格式: min default max
# 默认: 4096 16384 4194304

# === 接收缓冲区 ===
/proc/sys/net/ipv4/tcp_rmem  # min default max
# 默认: 4096 87380 6291456

# === 其他重要参数 ===

# 延迟 ACK
/proc/sys/net/ipv4/tcp_delack_min    # 最小延迟 ACK 时间（us，默认 40000）
/proc/sys/net/ipv4/tcp_delack_max    # 最大延迟 ACK 时间（us，默认 500000）

# 超时
/proc/sys/net/ipv4/tcp_keepalive_time    # keepalive 开始时间（s，默认 7200）
/proc/sys/net/ipv4/tcp_keepalive_intvl   # keepalive 间隔（s，默认 75）
/proc/sys/net/ipv4/tcp_keepalive_probes  # 探测次数（默认 9）

# 时间戳
/proc/sys/net/ipv4/tcp_timestamps  # 0=关 1=开（默认 1）

# SACK
/proc/sys/net/ipv4/tcp_sack       # 0=关 1=开（默认 1）

# 窗口缩放
/proc/sys/net/ipv4/tcp_window_scaling  # 0=关 1=开（默认 1）

# Fin 超时
/proc/sys/net/ipv4/tcp_fin_timeout    # 默认 30 秒

# 内存压力
/proc/sys/net/ipv4/tcp_mem  # 格式: low pressure high（页数）

# 滑动窗口比例
/proc/sys/net/ipv4/tcp_app_win   # 应用窗口比例
/proc/sys/net/ipv4/tcp_adv_win_scale

7. 实践：追踪 TCP 状态转换

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
// tcp_tracer.c — 跟踪 TCP 连接状态变化
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/tracepoint.h>

// 使用 tracepoint 跟踪 TCP 状态变化
// 需要在有 CONFIG_NET_TCP_STATE_TRACE 的内核上运行

static int tp_handler(struct notifier_block *nb, unsigned long action,
                      void *data) {
    struct tcp_event_work *event = data;
    const char *state_names[] = {
        "NONE", "ESTABLISHED", "SYN_SENT", "SYN_RECV",
        "FIN_WAIT1", "FIN_WAIT2", "TIME_WAIT", "CLOSE",
        "CLOSE_WAIT", "LAST_ACK", "LISTEN", "CLOSING"
    };

    printk(KERN_INFO "TCP: %pI4:%u -> %pI4:%u state: %s -> %s\n",
           &event->saddr, ntohs(event->sport),
           &event->daddr, ntohs(event->dport),
           state_names[event->old_state],
           state_names[event->new_state]);

    return NOTIFY_DONE;
}

static struct notifier_block tp_nb = {
    .notifier_call = tp_handler,
};

static int __init tracer_init(void) {
    register_tracepoint_probe(&event_class_tcp_state_lock,
                               tp_handler, NULL);
    printk(KERN_INFO "TCP tracer loaded\n");
    return 0;
}

static void __exit tracer_exit(void) {
    unregister_tracepoint_probe(&event_class_tcp_state_lock,
                                tp_handler);
    printk(KERN_INFO "TCP tracer unloaded\n");
}

module_init(tracer_init);
module_exit(tracer_exit);
MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
11
12
# 使用 bpftrace 跟踪（更简单）
sudo bpftrace -e '
tracepoint:tcp:tcp_set_state {
    $state_names = {"NONE","ESTABLISHED","SYN_SENT","SYN_RECV",
                     "FIN_WAIT1","FIN_WAIT2","TIME_WAIT","CLOSE",
                     "CLOSE_WAIT","LAST_ACK","LISTEN","CLOSING"};
    printf("%s -> %s: %s:%u -> %s:%u\n",
           $state_names[args->oldstate],
           $state_names[args->newstate],
           str(args->saddr), args->sport,
           str(args->daddr), args->dport);
}'

8. 阅读源码建议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 使用 ctags/cscope 或 LSP（clangd/lspsaga）阅读

# 关键阅读路径：
# 1. 新建连接：tcp_v4_rcv() → tcp_check_req() → tcp_v4_syn_recv_sock()
# 2. 接收数据：tcp_v4_rcv() → tcp_v4_do_rcv() → tcp_rcv_established()
# 3. 发送数据：tcp_sendmsg() → tcp_transmit_skb() → ip_queue_xmit()
# 4. 超时处理：tcp_keepalive_timer() / tcp_retransmit_timer()
# 5. 连接关闭：tcp_close() → tcp_time_wait()

# 调试技巧
# - 添加 printk 到关键路径
# - 使用 ftrace function_graph 跟踪调用链
# - 用 gdb 附加到 qemu 运行的 Linux
# - 使用 kdump 捕获内核崩溃
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

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