【Linux 网络子系统深度拆解】TCP 内核实现（上）：连接管理与状态机

struct sock_common          // 最基础：五元组、状态
  └─ struct sock            // 通用 socket：缓冲区、定时器、backlog
      └─ struct inet_sock   // IPv4 特有：IP 地址、端口
          └─ struct inet_connection_sock  // 面向连接：Accept Queue、拥塞控制
              └─ struct tcp_sock         // TCP 特有：序列号、窗口、SACK

struct sock {
    struct sock_common __sk_common;
    // sk_state = __sk_common.skc_state  (行 365)
    // TCP 状态：TCP_LISTEN, TCP_ESTABLISHED, ...

    struct sk_buff_head sk_receive_queue;   // 行 390: 接收队列
    struct rb_root      tcp_rtx_queue;      // 行 441: 重传队列（红黑树）

    u32 sk_ack_backlog;        // 行 477: Accept Queue 当前长度
    u32 sk_max_ack_backlog;    // 行 478: Accept Queue 最大长度
    // = min(somaxconn, listen() 的 backlog 参数)

    struct timer_list sk_timer;  // 行 447: 通用定时器
};

struct inet_connection_sock {
    struct inet_sock          icsk_inet;
    struct request_sock_queue icsk_accept_queue;  // 行 85: SYN + Accept 队列

    unsigned long  icsk_timeout;                  // 行 88
    struct timer_list icsk_retransmit_timer;       // 行 89: RTO 重传定时器
    struct timer_list icsk_delack_timer;           // 行 90: 延迟 ACK 定时器
    __u32          icsk_rto;                       // 行 91: 当前 RTO 值

    const struct tcp_congestion_ops *icsk_ca_ops;  // 行 95: 拥塞控制算法
};

enum {
    TCP_ESTABLISHED = 1,
    TCP_SYN_SENT,          // 客户端发出 SYN
    TCP_SYN_RECV,          // 服务端收到 SYN（完整 socket）
    TCP_FIN_WAIT1,         // 已发 FIN，等对端 ACK
    TCP_FIN_WAIT2,         // 对端已 ACK 我们的 FIN
    TCP_TIME_WAIT,         // 等待 2MSL
    TCP_CLOSE,             // 连接关闭
    TCP_CLOSE_WAIT,        // 对端已关，等本地关
    TCP_LAST_ACK,          // 已发 FIN，等最后 ACK
    TCP_LISTEN,            // 监听
    TCP_CLOSING,           // 双方同时关闭
    TCP_NEW_SYN_RECV,      // Linux 4.10+：SYN Queue 中的轻量级状态
};

void tcp_set_state(struct sock *sk, int state);

bpftrace -e '
tracepoint:tcp:tcp_set_state {
    printf("%-16s %-6d %s → %s\n",
        comm, pid,
        @states[args->oldstate],
        @states[args->newstate]);
}
BEGIN {
    @states[1] = "ESTABLISHED";
    @states[2] = "SYN_SENT";
    @states[3] = "SYN_RECV";
    @states[4] = "FIN_WAIT1";
    @states[5] = "FIN_WAIT2";
    @states[6] = "TIME_WAIT";
    @states[7] = "CLOSE";
    @states[8] = "CLOSE_WAIT";
    @states[9] = "LAST_ACK";
    @states[10] = "LISTEN";
    @states[11] = "CLOSING";
    @states[12] = "NEW_SYN_RECV";
}
'

struct request_sock_queue {
    spinlock_t    rskq_lock;               // 保护队列的自旋锁
    u8            rskq_defer_accept;        // TCP_DEFER_ACCEPT 延迟标志

    u32           synflood_warned;          // SYN Flood 告警标记
    atomic_t      qlen;                    // SYN Queue 长度
    atomic_t      young;                   // 未重传过的 SYN 请求数

    struct request_sock *rskq_accept_head;  // Accept Queue 头
    struct request_sock *rskq_accept_tail;  // Accept Queue 尾

    struct fastopen_queue fastopenq;        // TFO 队列
};

struct request_sock {
    struct sock_common __req_common;    // 五元组

    struct request_sock *dl_next;       // SYN Queue 链表
    u16           mss;                  // 客户端 MSS
    u8            num_retrans;          // SYN+ACK 已重传次数
    u8            syncookie:1;          // 是否由 SYN Cookie 生成
    u8            num_timeout:7;        // 超时次数
    u32           ts_recent;            // 客户端时间戳
    struct timer_list rsk_timer;        // SYN+ACK 重传定时器
    struct sock   *sk;                  // 握手完成后指向完整 socket
    u32           timeout;              // 当前超时值
};

// Accept Queue 最大值
sk->sk_max_ack_backlog = min(somaxconn, listen(backlog));
// somaxconn: sysctl net.core.somaxconn，默认 4096
// backlog: 应用调用 listen(fd, backlog) 时指定

// SYN Queue 最大值
// 由 sk_max_ack_backlog 间接控制
// 检查: inet_csk_reqsk_queue_is_full()
// = qlen > sk_max_ack_backlog

# 查看当前队列状态
ss -lnt
# Recv-Q = Accept Queue 当前长度
# Send-Q = Accept Queue 最大长度 (sk_max_ack_backlog)

// include/net/sock.h:1003
static inline bool sk_acceptq_is_full(const struct sock *sk)
{
    return READ_ONCE(sk->sk_ack_backlog) > READ_ONCE(sk->sk_max_ack_backlog);
}

# 启用 SYN Cookie（默认 1）
sysctl net.ipv4.tcp_syncookies
# 0: 禁用
# 1: SYN Queue 满时自动启用
# 2: 始终启用

# SYN+ACK 重传次数
sysctl net.ipv4.tcp_synack_retries  # 默认 5
# 每次重传间隔翻倍：1s → 2s → 4s → 8s → 16s
# 5 次重传约 31 秒后放弃

struct tcp_fastopen_context {
    siphash_key_t key[TCP_FASTOPEN_KEY_MAX]; // 最多 2 把密钥（支持轮换）
    int           num;                        // 当前有效密钥数
    struct rcu_head rcu;
};

// TFO Cookie 结构 (include/linux/tcp.h:90)
struct tcp_fastopen_cookie {
    __le64 val[...];     // Cookie 值（默认 8 字节）
    s8     len;          // 4-16 字节
    bool   exp;          // RFC6994 实验格式
};

struct fastopen_queue {
    struct request_sock *rskq_rst_head; // 发送过 RST 的 TFO 请求
    struct request_sock *rskq_rst_tail;
    spinlock_t lock;
    int        qlen;      // 待处理 TFO 请求数
    int        max_qlen;  // TFO 最大队列长度（!= 0 表示 TFO 已启用）
    struct tcp_fastopen_context __rcu *ctx; // Cookie 加密上下文
};

# 启用 TFO（位掩码）
sysctl net.ipv4.tcp_fastopen
# bit 0 (1): 客户端启用
# bit 1 (2): 服务端启用
# bit 2 (4): 客户端无 Cookie 时也允许数据 in SYN
# 常用值: 3 (客户端+服务端)

# TFO 黑洞检测超时
sysctl net.ipv4.tcp_fastopen_blackhole_timeout_sec  # 默认 0（禁用）
# 中间设备可能丢弃带数据的 SYN，这个参数让内核自动回退

# TFO 最大队列长度（per-listener）
# 在应用代码中设置: setsockopt(fd, SOL_TCP, TCP_FASTOPEN, &qlen, sizeof(qlen))

struct inet_timewait_sock {
    struct sock_common __tw_common;       // 五元组
    __u32          tw_mark;               // fwmark
    volatile unsigned char tw_substate;   // TIME_WAIT 子状态
    unsigned char  tw_rcv_wscale;         // 窗口缩放
    __be16         tw_sport;              // 源端口
    unsigned int   tw_transparent:1;
    unsigned int   tw_flowlabel:20;
    unsigned int   tw_usec_ts:1;
    unsigned int   tw_tos:8;
    u32            tw_txhash;
    u32            tw_priority;
    struct timer_list tw_timer;           // TIME_WAIT 定时器
    struct inet_bind_bucket  *tw_tb;
    struct inet_bind2_bucket *tw_tb2;
};

// include/net/tcp.h:125
#define TCP_TIMEWAIT_LEN  (60 * HZ)   // 60 秒
#define TCP_FIN_TIMEOUT   TCP_TIMEWAIT_LEN

tcp_time_wait(sk, state, timeo)       // include/net/tcp.h:56
  → inet_twsk_alloc(sk, dr, state)    // 分配轻量级 socket
  → inet_twsk_hashdance_schedule(tw, sk, hashinfo, timeo)
    // 1. 从连接哈希表摘除完整 socket
    // 2. 插入 TIME_WAIT socket
    // 3. 启动 tw_timer 定时器
  → sock_put(sk)                       // 释放完整 socket

enum tcp_tw_status
tcp_timewait_state_process(struct inet_timewait_sock *tw,
                           struct sk_buff *skb,
                           const struct tcphdr *th);

# 允许复用 TIME_WAIT 端口（作为客户端连接时）
sysctl net.ipv4.tcp_tw_reuse  # 默认 2
# 0: 禁用
# 1: 启用（仅限 loopback）
# 2: 启用（所有接口，Linux 4.6+ 默认）

// include/net/tcp.h:109
#define TCP_SYN_RETRIES   6    // 默认 6 次

sysctl net.ipv4.tcp_syn_retries  # 默认 6
# 设为 2: 约 7 秒超时（1+2+4）
# 设为 1: 约 3 秒超时（1+2）

// include/net/tcp.h:118
#define TCP_SYNACK_RETRIES  5   // 默认 5 次

sysctl net.ipv4.tcp_synack_retries  # 默认 5
# 在 SYN Flood 时可减小到 1-2，更快释放 SYN Queue 中的条目

// request_sock_queue 中的标志
struct request_sock_queue {
    // ...
    u8 rskq_defer_accept;  // 行 177: TCP_DEFER_ACCEPT 启用标志
    // ...
};

// 应用代码
int val = 5;  // 最多等 5 秒
setsockopt(fd, SOL_TCP, TCP_DEFER_ACCEPT, &val, sizeof(val));

# 从 SYN 收到到 ESTABLISHED 的延迟
bpftrace -e '
tracepoint:tcp:tcp_set_state
/args->newstate == 1/  // TCP_ESTABLISHED
{
    @handshake_us[comm] = hist(
        (nsecs - @syn_time[args->skaddr]) / 1000);
    delete(@syn_time[args->skaddr]);
}
tracepoint:tcp:tcp_set_state
/args->newstate == 12/  // TCP_NEW_SYN_RECV
{
    @syn_time[args->skaddr] = nsecs;
}
'

# 追踪 Accept Queue 满导致的丢包
bpftrace -e '
kprobe:tcp_v4_syn_recv_sock {
    @attempts = count();
}
kretprobe:tcp_v4_syn_recv_sock /retval == 0/ {
    @overflow = count();
    printf("Accept queue overflow at %s\n", strftime("%H:%M:%S", nsecs));
}
interval:s:5 {
    printf("--- syn_recv attempts: %d, overflows: %d ---\n",
        @attempts, @overflow);
    clear(@attempts);
    clear(@overflow);
}
'

# 追踪 SYN Cookie 的发送和验证
bpftrace -e '
kprobe:cookie_v4_init_sequence {
    @syncookie_sent = count();
    printf("[%s] SYN Cookie sent from CPU %d\n",
        strftime("%H:%M:%S", nsecs), cpu);
}
kprobe:cookie_v4_check {
    @syncookie_check = count();
}
interval:s:5 {
    printf("--- SYN Cookies: sent=%d checked=%d ---\n",
        @syncookie_sent, @syncookie_check);
    clear(@syncookie_sent);
    clear(@syncookie_check);
}
'

# TIME_WAIT socket 数量和端口复用频率
ss -s | grep timewait

# 追踪 TIME_WAIT 创建和销毁
bpftrace -e '
kprobe:tcp_time_wait {
    @tw_created = count();
}
kprobe:inet_twsk_free {
    @tw_freed = count();
}
interval:s:10 {
    printf("--- TIME_WAIT: created=%d freed=%d ---\n",
        @tw_created, @tw_freed);
    clear(@tw_created);
    clear(@tw_freed);
}
'

# 查看所有 LISTEN socket 的队列状态
ss -lnt
# State   Recv-Q  Send-Q  Local Address:Port
# LISTEN  0       4096    0.0.0.0:80
# Recv-Q = Accept Queue 当前长度
# Send-Q = sk_max_ack_backlog

# 查看半连接队列
ss -n state syn-recv

# 查看 TIME_WAIT 统计
ss -n state time-wait | wc -l

# 查看连接的详细 TCP 信息
ss -tiep
# 显示 RTO, RTT, cwnd, retrans 等

# 增大 Accept Queue（配合应用 listen() backlog）
sysctl -w net.core.somaxconn=65535

# 加速 SYN+ACK 重试超时
sysctl -w net.ipv4.tcp_synack_retries=2

# 启用 TFO
sysctl -w net.ipv4.tcp_fastopen=3

# TIME_WAIT 复用
sysctl -w net.ipv4.tcp_tw_reuse=1

# 减少 FIN_WAIT2 超时
sysctl -w net.ipv4.tcp_fin_timeout=15