Linux 内核之旅（二十五）：TCP 数据包接收全景 && 内核源码追踪

//file: net/ipv4/ip_input.c - ip_local_deliver_finish
int protocol = ip_hdr(skb)->protocol;
const struct net_protocol *ipprot;

ipprot = rcu_dereference(inet_protos[protocol]);
// 对于TCP，ipprot->handler = tcp_v4_rcv
ret = ipprot->handler(skb);

//file: net/ipv4/tcp_ipv4.c
static const struct net_protocol tcp_protocol = {
    .early_demux    = tcp_v4_early_demux,
    .handler        = tcp_v4_rcv,
    .err_handler    = tcp_v4_err,
    .no_policy      = 1,
    .netns_ok       = 1,
};

//file: net/ipv4/tcp_ipv4.c
int tcp_v4_rcv(struct sk_buff *skb)
{
    const struct tcphdr *th;
    const struct iphdr *iph;
    struct sock *sk;
    int ret;
    struct net *net = dev_net(skb->dev);

    // 1. 基本校验：数据包长度至少包含TCP头
    if (skb->pkt_type != PACKET_HOST)
        goto discard_it;

    // 2. 解析TCP头
    if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
        goto discard_it;

    th = (const struct tcphdr *)skb->data;
    if (th->doff < sizeof(struct tcphdr) / 4)
        goto bad_packet;

    // 3. 完整TCP头部校验（含options）
    if (!pskb_may_pull(skb, th->doff * 4))
        goto discard_it;

    // 4. TCP checksum校验
    if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
        goto csum_error;

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

    // 5. 核心：查找对应的socket
    // 先在ESTABLISHED哈希表中查找（四元组精确匹配）
    // 未命中再在LISTEN哈希表中查找（目的IP+端口匹配）
    sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th),
                           th->source, th->dest, &refcounted);
    if (!sk)
        goto no_tcp_socket;  // 无对应socket → 发送RST

    // ...后续状态分发
}

//file: net/ipv4/tcp_ipv4.c - tcp_v4_rcv 续
    // 6. TIME_WAIT状态特殊处理
    if (sk->sk_state == TCP_TIME_WAIT)
        goto do_time_wait;

    // 7. NEW_SYN_RECV状态（收到ACK完成三次握手）
    if (sk->sk_state == TCP_NEW_SYN_RECV) {
        struct request_sock *req = inet_reqsk(sk);
        sk = req->rsk_listener;
        // ... 将连接从半连接队列提升为全连接
        // 最终转入tcp_child_process()
    }

    // 8. 加锁处理
    bh_lock_sock_nested(sk);
    ret = 0;

    if (!sock_owned_by_user(sk)) {
        // socket未被用户进程锁定，直接处理
        if (!tcp_prequeue(sk, skb))
            ret = tcp_v4_do_rcv(sk, skb);
    } else {
        // socket正被用户进程使用（如正在recv）
        // 将skb加入backlog队列，延迟到release_sock时处理
        if (tcp_add_backlog(sk, skb))
            goto discard_and_relse;
    }
    bh_unlock_sock(sk);

    // ...
    return ret;

do_time_wait:
    // TIME_WAIT状态：仅处理合法的SYN或发送ACK
    switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
    case TCP_TW_SYN:
        // 收到SYN，可能是新连接复用旧四元组
        // 查找LISTEN socket处理
        break;
    case TCP_TW_ACK:
        tcp_v4_timewait_ack(sk, skb);
        break;
    case TCP_TW_RST:
        // ...
    }
}

//file: net/ipv4/tcp_ipv4.c - tcp_v4_rcv().
......
    if (sk->sk_state == TCP_NEW_SYN_RECV) {
        struct request_sock *req = inet_reqsk(sk);
        struct sock *nsk;

        // 1. 获取listener socket
        sk = req->rsk_listener;

        // 2. MD5校验（如果开启）
        if (unlikely(tcp_v4_inbound_md5_hash(sk, skb))) {
            sk_drops_add(sk, skb);
            reqsk_put(req);
            goto discard_it;
        }

        // 3. 如果listener已不在LISTEN状态（竞态），丢弃req重新查找
        if (unlikely(sk->sk_state != TCP_LISTEN)) {
            inet_csk_reqsk_queue_drop_and_put(sk, req);
            goto lookup;
        }

        sock_hold(sk);
        refcounted = true;

        // 4. 核心：验证ACK并创建子socket
        nsk = tcp_check_req(sk, skb, req, false);
        if (!nsk) {
            reqsk_put(req);
            goto discard_and_relse;
        }

        if (nsk == sk) {
            // SYN重传等场景：listener自己处理
            reqsk_put(req);
        } else if (tcp_child_process(sk, nsk, skb)) {
            // 5. 子socket创建成功，处理数据
            tcp_v4_send_reset(nsk, skb);
            goto discard_and_relse;
        } else {
            sock_put(sk);
            return 0;
        }
    }
    ......

//file: net/ipv4/tcp_minisocks.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_minisocks.c#L562
struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
                           struct request_sock *req, bool fastopen)
{
    struct tcp_options_received tmp_opt;
    struct sock *child;
    const struct tcphdr *th = tcp_hdr(skb);
    bool own_req;

    // 1. 解析TCP选项（时间戳等）
    tcp_parse_options(skb, &tmp_opt, 0, NULL);

    // 2. 检查是否为纯SYN重传（对端没收到SYN-ACK）
    if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn &&
        flg == TCP_FLAG_SYN && !paws_reject) {
        // 重发SYN-ACK
        inet_rtx_syn_ack(sk, req);
        return NULL;
    }

    // 3. ACK序号校验：必须确认的是我方SYN-ACK的序号+1
    if ((flg & TCP_FLAG_ACK) && !fastopen &&
        (TCP_SKB_CB(skb)->ack_seq != tcp_rsk(req)->snt_isn + 1))
        return sk;  // 无效ACK → 交给listener处理（发送RST）

    // 4. 序号窗口校验（PAWS + 窗口范围）
    if (paws_reject || !tcp_in_window(...))
        return NULL;

    // 5. RST/SYN检查
    if (flg & (TCP_FLAG_RST | TCP_FLAG_SYN))
        goto embryonic_reset;

    // 6. TCP_DEFER_ACCEPT处理：如果设置了且是纯ACK（无数据），则忽略
    if (req->num_timeout < inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
        TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {
        inet_rsk(req)->acked = 1;
        return NULL;
    }

    // 7. 核心：创建子socket
    // 调用 tcp_v4_syn_recv_sock() → tcp_create_openreq_child()
    // 子socket初始状态为 TCP_SYN_RECV
    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL,
                                                      req, &own_req);
    if (!child)
        goto listen_overflow;

    // 8. 将子socket插入ESTABLISHED哈希表，从半连接队列移到全连接队列
    return inet_csk_complete_hashdance(sk, child, req, own_req);
}

//file: net/ipv4/inet_connection_sock.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/inet_connection_sock.c#L947
struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child,
                                         struct request_sock *req, bool own_req)
{
    if (own_req) {
        // 1. 从半连接队列中移除request_sock
        inet_csk_reqsk_queue_drop(sk, req);

        // 2. 将子socket加入listener的accept队列（全连接队列）
        //    req->sk = child，req链入 icsk_accept_queue
        inet_csk_reqsk_queue_add(sk, req, child);

        // accept队列非空 → listener的sk_data_ready会唤醒accept()调用
    }
    ......
    return child;
}

//file: net/ipv4/tcp_minisocks.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_minisocks.c#L811
int tcp_child_process(struct sock *parent, struct sock *child,
                      struct sk_buff *skb)
{
    int ret = 0;
    int state = child->sk_state;  // 此时为TCP_SYN_RECV

    if (!sock_owned_by_user(child)) {
        // 子socket未被锁定：直接处理
        // tcp_rcv_state_process会将状态从TCP_SYN_RECV推进到TCP_ESTABLISHED
        ret = tcp_rcv_state_process(child, skb);

        // 如果状态发生了变化（SYN_RECV → ESTABLISHED）
        // 通知listener的sk_data_ready → 唤醒阻塞在accept()的进程
        if (state == TCP_SYN_RECV && child->sk_state != state)
            parent->sk_data_ready(parent);
    } else {
        // 子socket被锁定：暂存到backlog
        __sk_add_backlog(child, skb);
    }

    bh_unlock_sock(child);
    sock_put(child);
    return ret;
}

//file: net/ipv4/tcp_ipv4.c
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);

    if (sk->sk_state == TCP_ESTABLISHED) {
        // 已建立连接的数据包 → 快速路径优化
        struct dst_entry *dst = sk->sk_rx_dst;
        // ... early demux路由缓存复用
        tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
        return 0;
    }

    // 非ESTABLISHED状态（SYN_RECV/FIN_WAIT等）
    // 走完整的状态机处理
    if (tcp_rcv_state_process(sk, skb)) {
        rsk = sk;
        goto reset;
    }
    return 0;
}

//file: net/ipv4/tcp_input.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_input.c#L5351
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
                         const struct tcphdr *th, unsigned int len)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // ====== Header Prediction 快速路径检查 ======
    // pred_flags在窗口/状态变化时由tcp_fast_path_check()更新
    // 它预编码了：窗口大小未变 + 无SYN/FIN/RST/URG标志 + ACK已设置
    if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
        TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&        // 序号是期望的下一个
        !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {  // ACK合法
        int tcp_header_len = th->doff * 4;

        // ---- 快速路径分支1：纯ACK包（无数据负载）----
        if (tcp_header_len == len) {
            // 只有ACK，无数据
            tcp_ack(sk, skb, 0);   // 处理ACK（推进snd_una、释放已确认skb）
            __kfree_skb(skb);      // 释放skb

            // 检查是否有数据需要发送（ACK可能释放了窗口）
            if (!tcp_data_snd_check(sk))
                tcp_ack_snd_check(sk);
            return;
        }

        // ---- 快速路径分支2：纯数据包（有负载，按序到达）----
        if (tp->ucopy.task == current &&
            tp->copied_seq == tp->rcv_nxt &&
            len - tcp_header_len <= tp->ucopy.len &&
            sock_owned_by_user(sk)) {
            // 用户进程正在recv且缓冲区足够：直接复制到用户空间（零中间拷贝）
            __set_current_state(TASK_RUNNING);
            if (!tcp_copy_to_iovec(sk, skb, tcp_header_len)) {
                // 直接复制成功
                tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
                // ...
                __kfree_skb(skb);
                tcp_ack(sk, skb, FLAG_DATA);
                tcp_data_snd_check(sk);
                return;
            }
        }

        // 快速路径分支3：标准入队
        if (eaten <= 0) {
eaten:
            // 数据入sk_receive_queue
            tcp_queue_rcv(sk, skb, tcp_header_len, &fragstolen);

            // 更新rcv_nxt
            tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
        }

        // 处理ACK
        tcp_event_data_recv(sk, skb);
        tcp_ack(sk, skb, FLAG_DATA);

        // 重要：唤醒等待数据的进程/epoll
        sk->sk_data_ready(sk);

        // 检查是否需要发送ACK
        tcp_data_snd_check(sk);
        return;
    }

    ......

    // ====== 慢速路径 ======
    // 条件不满足header prediction时，通过goto跳转到slow_path标签
    // 注意：慢速路径是tcp_rcv_established内部的inline代码

slow_path:
    if (len < (th->doff << 2) || tcp_checksum_complete(skb))
        goto csum_error;

    if (!th->ack && !th->rst && !th->syn)
        goto discard;

    // 完整校验（序号、RST、SYN检查）
    if (!tcp_validate_incoming(sk, skb, th, 1))
        return;

step5:
    if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
        goto discard;

    tcp_rcv_rtt_measure_ts(sk, skb);

    tcp_urg(sk, skb, th);           // 处理紧急数据
    tcp_data_queue(sk, skb);        // 数据入队（含乱序处理）
    tcp_data_snd_check(sk);
    tcp_ack_snd_check(sk);
    return;

csum_error:
    TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
    TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
discard:
    tcp_drop(sk, skb);
    ......
}

//file: include/net/tcp.h
//https://elixir.bootlin.com/linux/v4.11.6/source/include/net/tcp.h#L644
static inline void tcp_fast_path_check(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);

    ......
    
    // 快速路径条件（全部满足才开启）：
    // 1. 乱序队列为空（rb_tree为空）
    // 2. 接收窗口大于0
    // 3. 已分配的接收内存 < 接收缓冲区上限（有空间接收）
    // 4. 没有待处理的紧急数据
    if (RB_EMPTY_ROOT(&tp->out_of_order_queue) &&
        tp->rcv_wnd &&
        atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
        !tp->urg_data)
        tcp_fast_path_on(tp);
}

static inline void tcp_fast_path_on(struct tcp_sock *tp)
{
    // 预编码期望的TCP头标志：ACK置位 + 对端通告的窗口大小不变
    // 注意：这里用snd_wnd（对端通告给我方的窗口），不是rcv_wnd
    // 因为pred_flags需要与到达包的TCP头中的window字段匹配
    __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
}

static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
{
    // pred_flags = (TCP头的前32位应该匹配的值)
    // 包含：doff=5(无options) + ACK标志 + 窗口大小
    tp->pred_flags = htonl((tp->tcp_header_len << 26) |
                           ntohl(TCP_FLAG_ACK) |
                           snd_wnd);
}

//file: net/ipv4/tcp_input.c
// 判断段[seq, end_seq)是否与接收窗口[rcv_nxt, rcv_nxt+rcv_wnd)有交集
static inline bool tcp_sequence(const struct tcp_sock *tp, u32 seq, u32 end_seq)
{
    return !before(end_seq, tp->rcv_wup) &&
           !after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

// before/after 宏处理序号回绕
static inline bool before(__u32 seq1, __u32 seq2)
{
    return (__s32)(seq1 - seq2) < 0;
}
#define after(seq2, seq1) before(seq1, seq2)

//file: net/ipv4/tcp_input.c
static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
                                  const struct tcphdr *th, int syn_inerr)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // 1. 序号校验：段必须在接收窗口内
    if (!tcp_sequence(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq)) {
        // 序号不在窗口内
        if (!th->rst) {
            // 非RST包：发送一个ACK通知对端我方的rcv_nxt
            // （常见场景：对端重传了已确认的旧数据）
            tcp_send_dupack(sk, skb);
        }
        goto discard;
    }

    // 2. RST标志检查
    if (th->rst) {
        if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt)
            tcp_reset(sk);  // 合法RST → 重置连接
        else
            // 窗口内的非精确RST → challenge ACK（RFC 5961）
            tcp_send_challenge_ack(sk, skb);
        goto discard;
    }

    // 3. SYN标志检查（ESTABLISHED状态不应收到SYN）
    if (th->syn) {
        tcp_send_challenge_ack(sk, skb);
        goto discard;
    }

    return true;

discard:
    return false;
}

//file: net/ipv4/tcp_input.c
static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
{
    struct tcp_sock *tp = tcp_sk(sk);
    u32 ack_seq = TCP_SKB_CB(skb)->ack_seq;  // 对端确认的序号
    u32 prior_snd_una = tp->snd_una;         // 之前的发送未确认起始点
    int prior_packets = tp->packets_out;

    // 1. ACK合法性检查
    if (before(ack_seq, prior_snd_una))
        goto old_ack;    // 旧ACK（已处理过的确认）
    if (after(ack_seq, tp->snd_nxt))
        goto invalid_ack; // 超前ACK（确认了未发送的数据）

    // 2. 标记确认了新数据
    flag |= FLAG_SND_UNA_ADVANCED;

    // 3. SACK信息处理
    if (TCP_SKB_CB(skb)->sacked)
        flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una, &sack_state);

    // 4. 推进snd_una（发送窗口左边界右移）
    tp->snd_una = ack_seq;

    // 5. 释放已确认的skb（从重传队列中移除）
    // tcp_clean_rtx_queue内部会调用tcp_rtt_estimator更新RTT估算
    flag |= tcp_clean_rtx_queue(sk, prior_fackets, prior_snd_una,
                                 &sack_state);

    // 6. 拥塞控制更新（核心！）
    // 如果算法实现了cong_control（如BBR），走tcp_cong_control
    // 否则走传统的tcp_cong_avoid
    tcp_cong_avoid(sk, ack_seq, acked);

    // 7. 更新发送窗口
    tcp_ack_update_window(sk, skb, ack_seq, ntohs(th->window) << tp->rx_opt.snd_wscale);

    // 8. 快速重传/恢复检测
    tcp_fastretrans_alert(sk, acked, prior_unsacked, is_dupack, flag);

    return 1;

old_ack:
    // duplicate ACK检测
    if (TCP_SKB_CB(skb)->sacked) {
        flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una, &sack_state);
    }
    // ...
}

//file: net/ipv4/tcp_input.c
// https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_input.c#L657
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);
    u32 now;

    // 1. 标记需要发送ACK（调度ACK，但不一定立即发送）
    inet_csk_schedule_ack(sk);

    // 2. 测量接收MSS
    tcp_measure_rcv_mss(sk, skb);

    // 3. 测量接收端RTT
    tcp_rcv_rtt_measure(tp);

    now = tcp_time_stamp;

    // 4. 自适应调整ACK延迟时间（ATO）
    if (!icsk->icsk_ack.ato) {
        // 第一个数据包：初始化delayed ACK引擎
        tcp_incr_quickack(sk);           // 进入QuickACK模式
        icsk->icsk_ack.ato = TCP_ATO_MIN;  // ATO初始值（40ms）
    } else {
        int m = now - icsk->icsk_ack.lrcvtime;  // 距上次收包的间隔

        if (m <= TCP_ATO_MIN / 2) {
            // 包到达非常快：缩小ATO（更快发送ACK）
            icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + TCP_ATO_MIN / 2;
        } else if (m < icsk->icsk_ack.ato) {
            // 正常间隔：平滑调整ATO
            icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + m;
            if (icsk->icsk_ack.ato > icsk->icsk_rto)
                icsk->icsk_ack.ato = icsk->icsk_rto;
        } else if (m > icsk->icsk_rto) {
            // 间隔太长（发送端可能窗口受限）：进入QuickACK模式
            tcp_incr_quickack(sk);
            sk_mem_reclaim(sk);
        }
    }
    icsk->icsk_ack.lrcvtime = now;  // 记录本次收包时间

    // 5. ECN检查
    tcp_ecn_check_ce(tp, skb);

    // 6. 如果收到较大的数据段，尝试增长接收窗口
    if (skb->len >= 128)
        tcp_grow_window(sk, skb);
}

//file: net/ipv4/tcp_input.c
static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // 收到一个序号不等于rcv_nxt的包（即乱序到达）
    // 发送一个重复的ACK（ack_seq仍是rcv_nxt），通知对端有包丢失

    if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
        before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
        // D-SACK: 收到已确认过的重复数据
        tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
    }

    tcp_send_ack(sk);  // 发送ACK（携带SACK块信息）
}

//file: include/net/tcp.h
static inline int tcp_is_sack(const struct tcp_sock *tp)
{
    return tp->rx_opt.sack_ok;
}

//file: include/linux/tcp.h
struct tcp_sock {
    // === 接收端SACK（我方生成，随ACK发送给对端）===
    struct tcp_sack_block selective_acks[4];  // 最多4个SACK块
    // selective_acks[i].start_seq / end_seq 描述一段已收到的不连续区间

    struct tcp_options_received rx_opt;
    // rx_opt.num_sacks:  当前SACK块数量（0~4）
    // rx_opt.dsack:      本次ACK是否携带D-SACK信息
    // rx_opt.sack_ok:    SACK是否已协商开启

    // === 发送端SACK处理（解析对端返回的SACK信息）===
    struct tcp_sack_block recv_sack_cache[4]; // 缓存上一次收到的SACK块（优化增量处理）
    u32 sacked_out;   // 被SACK标记但未确认的段数量
    // ...
};

struct tcp_sack_block {
    u32 start_seq;    // SACK块起始序号
    u32 end_seq;      // SACK块结束序号（不包含）
};

//file: net/ipv4/tcp_input.c
// 乱序段入队后，生成或更新SACK块
// https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_input.c#L4191
static void tcp_sack_new_ofo_skb(struct sock *sk, u32 seq, u32 end_seq)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct tcp_sack_block *sp = &tp->selective_acks[0];
    int cur_sacks = tp->rx_opt.num_sacks;
    int this_sack;

    // 检查是否能与已有的SACK块合并
    for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
        if (tcp_sack_extend(sp, seq, end_seq)) {
            // 与已有块相邻或重叠 → 合并扩展
            // 将合并后的块移到selective_acks[0]（RFC要求最新的排最前）
            // ...
            return;
        }
    }

    // 无法合并 → 创建新的SACK块
    if (cur_sacks < TCP_NUM_SACKS) {
        // 还有空间：直接添加
        tp->rx_opt.num_sacks++;
    }
    // 将新块放在selective_acks[0]，已有块后移
    // （超过4个块时，最旧的块被丢弃）
    sp = tp->selective_acks;
    memmove(sp + 1, sp, cur_sacks * sizeof(*sp));
    sp[0].start_seq = seq;
    sp[0].end_seq = end_seq;
}

//file: net/ipv4/tcp_input.c
static int tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
                                    u32 prior_snd_una,
                                    struct tcp_sacktag_state *state)
{
    struct tcp_sock *tp = tcp_sk(sk);
    // 从ACK的TCP选项中解析SACK块
    const unsigned char *ptr = (skb_transport_header(ack_skb) +
                                TCP_SKB_CB(ack_skb)->sacked);

    // 1. D-SACK检测：第一个SACK块如果落在snd_una之前，则为D-SACK
    //    D-SACK表示对端收到了重复数据（可能是不必要的重传）

    // 2. SACK块合法性校验：必须在[snd_una, snd_nxt]范围内

    // 3. 遍历发送队列（write_queue），标记被SACK覆盖的skb
    //    使用 recv_sack_cache 做增量处理（只处理新增的SACK范围）

    // 4. 对每个被SACK覆盖的skb：
    //    TCP_SKB_CB(skb)->sacked |= TCPCB_SACKED_ACKED
    //    tp->sacked_out++ （记录被SACK的段数）

    // 5. 更新FACK（Forward ACK）：tp->fackets_out = 最远SACK覆盖的段

    // 6. 检测乱序（reordering）：
    //    如果SACK填补了旧空洞且该段从未被重传 → 网络发生了乱序

    return flag;  // 返回FLAG_DATA_SACKED等标志
}

//file: net/ipv4/tcp_input.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_input.c#L4112
// 当接收端收到已确认过的重复数据时，标记D-SACK
static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // D-SACK块放在selective_acks[0]，其范围落在ack_seq之前
    // 发送端看到 SACK[0].start < ack_seq 就知道这是D-SACK
    if (tp->rx_opt.sack_ok) {
        tp->rx_opt.dsack = 1;
        tp->duplicate_sack[0].start_seq = seq;
        tp->duplicate_sack[0].end_seq = end_seq;
    }
}

//file: include/linux/tcp.h - struct tcp_sock
struct tcp_sock {
    // 接收窗口相关
    u32 rcv_wnd;        // 当前接收窗口大小（字节）
    u32 rcv_wup;        // 上次通告窗口时的rcv_nxt值
    u32 rcv_nxt;        // 期望接收的下一个序号
    u32 window_clamp;   // 窗口上限（对端不会超过此值）

    // 窗口缩放
    u8  rx_opt.rcv_wscale;  // 接收窗口缩放因子（2^wscale）

    // 自动调优
    u32 rcvq_space;     // 估算的接收速率（用于自动调优）
    u32 space;          // 最近一段时间内的数据到达量
};

//file: net/ipv4/tcp_output.c
u16 tcp_select_window(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    u32 old_win = tp->rcv_wnd;
    u32 cur_win;
    u32 new_win;

    // 1. 计算当前可用窗口空间
    // = sk_rcvbuf（接收缓冲区总大小）- 已使用的空间
    cur_win = tcp_receive_window(tp);
    new_win = __tcp_select_window(sk);

    // 2. 窗口只增不减原则（避免SWS - Silly Window Syndrome）
    if (new_win < cur_win) {
        // 不能收缩已通告的窗口（RFC规定）
        // 但如果内存确实紧张，可以冻结窗口为0（零窗口）
    }

    // 3. 更新rcv_wnd
    tp->rcv_wnd = new_win;
    tp->rcv_wup = tp->rcv_nxt;  // 记录通告时的rcv_nxt

    // 4. 返回窗口值（需要右移wscale位放入TCP头的16bit字段）
    return new_win >> tp->rx_opt.rcv_wscale;
}

static u32 __tcp_select_window(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    int mss = tp->advmss;  // 对端MSS

    // 可用空间 = 接收缓冲区剩余
    int free_space = tcp_space(sk);

    // Silly Window Syndrome防护：
    // 如果可用空间小于MSS的一半，通告窗口为0
    // 避免对端发送大量小包
    if (free_space < (int)(mss / 2))
        return 0;

    // 对齐到MSS的整数倍（鼓励对端发送满尺寸段）
    free_space = round_down(free_space, mss);

    // 不超过window_clamp
    if (free_space > tp->window_clamp)
        free_space = tp->window_clamp;

    return free_space;
}

//file: net/ipv4/tcp_input.c
void tcp_rcv_space_adjust(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    int time, space;

    // 每隔一段时间（RTT级别）调整一次
    if (tp->rcvq_space.time == 0)
        goto new_measure;

    time = tcp_time_stamp - tp->rcvq_space.time;
    if (time < (tp->rcv_rtt_est.rtt >> 3) || tp->rcv_rtt_est.rtt == 0)
        return;

    // 计算这段时间内到达的数据量
    space = tp->copied_seq - tp->rcvq_space.seq;
    if (space <= 0)
        goto new_measure;

    // 目标：缓冲区至少能容纳2倍的BDP（Bandwidth-Delay Product）
    // 即 2 * (实际速率 * RTT)
    space *= 2;  // 留出2倍冗余

    // 只增不减：仅在需要更大缓冲区时才调大
    if (space > tp->rcvq_space.space) {
        int rcvbuf = min(space, sysctl_tcp_rmem[2]);  // 不超过rmem_max
        if (rcvbuf > sk->sk_rcvbuf) {
            sk->sk_rcvbuf = rcvbuf;
            // 调大缓冲区后重新计算接收窗口
            tp->window_clamp = rcvbuf;
        }
    }
    tp->rcvq_space.space = space;

new_measure:
    tp->rcvq_space.seq = tp->copied_seq;
    tp->rcvq_space.time = tcp_time_stamp;
}

//file: net/ipv4/tcp_input.c
// ECN接收处理
static void TCP_ECN_check_ce(struct tcp_sock *tp, const struct sk_buff *skb)
{
    // 检查IP头的ECN字段
    if (TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_CE) {
        // 路由器标记了拥塞
        // 在下一个ACK中设置ECE标志通知发送端
        tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
    }
}

//file: include/net/tcp.h
enum tcp_ca_state {
    TCP_CA_Open = 0,       // 正常状态：慢启动或拥塞避免
    TCP_CA_Disorder = 1,   // 检测到潜在丢包（少量dup ACK/SACK）
    TCP_CA_CWR = 2,        // 收到ECN或本地拥塞，正在主动降窗
    TCP_CA_Recovery = 3,   // 快速恢复中（收到3个dup ACK触发）
    TCP_CA_Loss = 4,       // 超时重传，进入拥塞避免重置
};

//file: net/ipv4/tcp_input.c
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
{
    const struct inet_connection_sock *icsk = inet_csk(sk);
    // 调用当前拥塞控制算法的cong_avoid回调
    icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
    // 确保cwnd不超过snd_cwnd_clamp
    tcp_sk(sk)->snd_cwnd = min(tcp_sk(sk)->snd_cwnd,
                               tcp_sk(sk)->snd_cwnd_clamp);
}

//file: net/ipv4/tcp_cubic.c
static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked, u32 in_flight)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct bictcp *ca = inet_csk_ca(sk);

    if (!tcp_is_cwnd_limited(sk, in_flight))
        return;  // 窗口未满，无需调整

    if (tp->snd_cwnd <= tp->snd_ssthresh) {
        // 慢启动阶段：每个ACK窗口+1（指数增长）
        tcp_slow_start(tp, acked);
    } else {
        // 拥塞避免阶段：使用CUBIC函数
        bictcp_update(ca, tp->snd_cwnd);
        tcp_cong_avoid_ai(tp, ca->cnt, acked);
    }
}

// CUBIC核心：计算窗口增长目标
static inline void bictcp_update(struct bictcp *ca, u32 cwnd)
{
    u32 delta, bic_target, max_cnt;
    u64 offs, t;

    ca->ack_cnt += ca->delayed_ack;

    // 计算距上次窗口缩减的时间 t
    t = (s32)(tcp_time_stamp - ca->epoch_start);
    t += ca->delay_min >> 3;  // 加上最小RTT（K值修正）

    // CUBIC函数: W(t) = C * (t - K)^3 + W_max
    // K = cubic_root(W_max * beta / C)
    // C = 0.4, beta = 0.7

    // 计算K（从W_max恢复到满窗的时间）
    // ... 省略K的计算

    // 计算W_cubic(t) = C*(t-K)^3 + W_max
    if (t < ca->bic_K) {
        // t < K: 在W_max下方，凹函数慢增长
        offs = ca->bic_K - t;
        delta = (cube_rtt_scale * offs * offs * offs) >> 40;
        bic_target = ca->bic_origin_point - delta;
    } else {
        // t >= K: 在W_max上方，凸函数快增长
        offs = t - ca->bic_K;
        delta = (cube_rtt_scale * offs * offs * offs) >> 40;
        bic_target = ca->bic_origin_point + delta;
    }

    // cnt = cwnd / (bic_target - cwnd)
    // 即每cnt个ACK才增加1个cwnd
    if (bic_target > cwnd) {
        ca->cnt = cwnd / (bic_target - cwnd);
    } else {
        ca->cnt = 100 * cwnd;  // 非常慢的增长
    }
}

//file: net/ipv4/tcp_cong.c
// Reno拥塞避免：每RTT增加1个MSS（线性增长）
void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked, u32 in_flight)
{
    struct tcp_sock *tp = tcp_sk(sk);

    if (!tcp_is_cwnd_limited(sk, in_flight))
        return;

    if (tp->snd_cwnd <= tp->snd_ssthresh) {
        // 慢启动：每ACK增1（指数增长）
        tcp_slow_start(tp, acked);
    } else {
        // 拥塞避免：每cwnd个ACK增1（线性增长）
        // 即每个RTT增加1个MSS
        tcp_cong_avoid_ai(tp, tp->snd_cwnd, acked);
    }
}

//file: net/ipv4/tcp_input.c
static void tcp_fastretrans_alert(struct sock *sk, ...)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // 进入Recovery状态
    if (icsk->icsk_ca_state != TCP_CA_Recovery) {
        // 记录当前cwnd为ssthresh的参考
        tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
        // CUBIC: ssthresh = cwnd * 0.7
        // Reno:  ssthresh = cwnd / 2

        tcp_set_ca_state(sk, TCP_CA_Recovery);
        tp->high_seq = tp->snd_nxt;  // 标记恢复点

        // PRR（Proportional Rate Reduction）：
        // 在恢复期间按比例降低发送速率，而非直接砍半
        tp->prr_delivered = 0;
        tp->prr_out = 0;

        // 触发快速重传
        tcp_retransmit_skb(sk, tcp_write_queue_head(sk));
    }
}

//file: net/ipv4/tcp_input.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_input.c#L4588
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    int eaten = -1;

    // 1. 检查是否按序到达
    if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
        // ===== 按序到达：直接入sk_receive_queue =====

        // 尝试与队列尾部的skb合并（减少skb数量）
        if (tcp_try_coalesce(sk, skb)) {
            eaten = 1;
        }

        if (eaten <= 0) {
            // 入receive_queue尾部
            __skb_queue_tail(&sk->sk_receive_queue, skb);
        }

        // 更新rcv_nxt
        tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;

        // 检查ofo_queue（rb_tree）中是否有后续数据可以补齐
        //https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_input.c#L4646
        if (!RB_EMPTY_ROOT(&tp->out_of_order_queue))
            tcp_ofo_queue(sk);

        // 通知应用层有数据可读
        if (!sock_flag(sk, SOCK_DEAD))
            sk->sk_data_ready(sk);

    } else {
        // ===== 乱序到达：入out_of_order_queue =====

        // 先检查是否完全在窗口外（应丢弃）
        if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
            // 完全重复的数据（seq < rcv_nxt）
            tcp_dsack_set(sk, ...);
            goto discard;
        }

        // 入乱序队列
        tcp_data_queue_ofo(sk, skb);

        // 发送duplicate ACK（携带SACK信息）
        tcp_send_dupack(sk, skb);
    }
    ......
}

//file: net/ipv4/tcp_input.c
// 将乱序数据插入ofo_queue（v4.11.6使用红黑树，按seq排序）
static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct rb_node **p, *q, *parent;
    struct sk_buff *skb1;
    u32 seq, end_seq;
    bool fragstolen;

    // 内存调度检查（内存不足则丢弃）
    if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
        tcp_drop(sk, skb);
        return;
    }

    // 关闭快速路径（有乱序数据时pred_flags必须清零）
    tp->pred_flags = 0;
    inet_csk_schedule_ack(sk);

    seq = TCP_SKB_CB(skb)->seq;
    end_seq = TCP_SKB_CB(skb)->end_seq;

    p = &tp->out_of_order_queue.rb_node;
    if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
        // 空树：创建第一个SACK块，直接插入
        if (tcp_is_sack(tp)) {
            tp->rx_opt.num_sacks = 1;
            tp->selective_acks[0].start_seq = seq;
            tp->selective_acks[0].end_seq = end_seq;
        }
        rb_link_node(&skb->rbnode, NULL, p);
        rb_insert_color(&skb->rbnode, &tp->out_of_order_queue);
        tp->ooo_last_skb = skb;
        goto end;
    }

    // 快速路径：尝试与ooo_last_skb合并或追加在其后（O(1)）
    if (tcp_try_coalesce(sk, tp->ooo_last_skb, skb, &fragstolen)) {
        goto coalesce_done;
    }
    if (!before(seq, TCP_SKB_CB(tp->ooo_last_skb)->end_seq)) {
        parent = &tp->ooo_last_skb->rbnode;
        p = &parent->rb_right;
        goto insert;
    }

    // 通用路径：在rb_tree中查找插入位置（O(log n)）
    parent = NULL;
    while (*p) {
        parent = *p;
        skb1 = rb_entry(parent, struct sk_buff, rbnode);
        if (before(seq, TCP_SKB_CB(skb1)->seq)) {
            p = &parent->rb_left;
            continue;
        }
        if (before(seq, TCP_SKB_CB(skb1)->end_seq)) {
            if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
                // 新段完全被已有段包含 → 丢弃，标记D-SACK
                tcp_dsack_set(sk, seq, end_seq);
                goto discard;
            }
            if (after(seq, TCP_SKB_CB(skb1)->seq)) {
                // 部分重叠 → 标记D-SACK
                tcp_dsack_set(sk, seq, TCP_SKB_CB(skb1)->end_seq);
            } else {
                // seq相同但新段更大 → 替换旧段
                rb_replace_node(&skb1->rbnode, &skb->rbnode,
                                &tp->out_of_order_queue);
                tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
                                 TCP_SKB_CB(skb1)->end_seq);
                __kfree_skb(skb1);
                goto merge_right;
            }
        } else if (tcp_try_coalesce(sk, skb1, skb, &fragstolen)) {
            goto coalesce_done;
        }
        p = &parent->rb_right;
    }

insert:
    rb_link_node(&skb->rbnode, parent, p);
    rb_insert_color(&skb->rbnode, &tp->out_of_order_queue);

merge_right:
    // 向右合并：移除被新段完全覆盖的后续段
    while ((q = rb_next(&skb->rbnode)) != NULL) {
        skb1 = rb_entry(q, struct sk_buff, rbnode);
        if (!after(end_seq, TCP_SKB_CB(skb1)->seq))
            break;
        if (before(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
            tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq, end_seq);
            break;
        }
        rb_erase(&skb1->rbnode, &tp->out_of_order_queue);
        tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
                         TCP_SKB_CB(skb1)->end_seq);
        tcp_drop(sk, skb1);
    }
    // 更新ooo_last_skb缓存
    if (!tp->ooo_last_skb || !after(end_seq, TCP_SKB_CB(tp->ooo_last_skb)->end_seq))
        tp->ooo_last_skb = skb;

add_sack:
    if (tcp_is_sack(tp))
        tcp_sack_new_ofo_skb(sk, seq, end_seq);
end:
    ......
}

// 尝试将ofo_queue中的连续数据转入receive_queue（使用rb_tree遍历）
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_input.c#L4314
static void tcp_ofo_queue(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct sk_buff *skb, *tail;
    struct rb_node *p;

    p = rb_first(&tp->out_of_order_queue);
    while (p) {
        skb = rb_entry(p, struct sk_buff, rbnode);
        // 检查该段是否能衔接上rcv_nxt
        if (after(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))
            break;  // 还有空洞，等待

        // 处理重叠部分（D-SACK）
        if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))
            tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);

        p = rb_next(p);
        rb_erase(&skb->rbnode, &tp->out_of_order_queue);

        if (unlikely(!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))) {
            // 完全重复的旧数据 → 丢弃
            tcp_drop(sk, skb);
            continue;
        }

        // 入sk_receive_queue尾部
        tail = skb_peek_tail(&sk->sk_receive_queue);
        eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
        tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
        if (!eaten)
            __skb_queue_tail(&sk->sk_receive_queue, skb);
        // ...
    }
    ......
}

//file: include/linux/tcp.h
struct tcp_sock {
    struct rb_root out_of_order_queue;  // 乱序队列rb_tree根节点
    struct sk_buff *ooo_last_skb;       // 缓存rb_tree最右节点（优化尾部追加）
    // ...
};

#define skb_queue_walk(queue, skb) \
    for (skb = (queue)->next;      \
         skb != (struct sk_buff *)(queue); \
         skb = skb->next)

//file: net/ipv4/tcp_ipv4.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp_ipv4.c#L1511
static bool tcp_prequeue(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // 条件：有进程正在等待数据（ucopy.task != NULL）
    if (sysctl_tcp_low_latency || !tp->ucopy.task)
        return false;

    // 入prequeue
    __skb_queue_tail(&tp->ucopy.prequeue, skb);
    tp->ucopy.memory += skb->truesize;

    // 如果prequeue累积的数据超过sk_rcvbuf的一半
    // 或者进程正在sleeping，唤醒进程来处理
    if (tp->ucopy.memory > sk->sk_rcvbuf >> 1) {
        // 唤醒等待的进程
        sk->sk_data_ready(sk);
    }

    return true;
}

//file: net/ipv4/tcp_input.c
static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
{
    struct tcp_sock *tp = tcp_sk(sk);
    u32 ptr = ntohs(th->urg_ptr);

    // URG pointer指向紧急数据的末尾偏移
    if (ptr && !th->syn) {
        u32 urg_seq = ntohl(th->seq) + ptr - 1;

        // 新的紧急数据序号比之前的更新
        if (after(urg_seq, tp->copied_seq) &&
            after(urg_seq, tp->urg_seq)) {
            // 更新紧急数据序号
            tp->urg_seq = urg_seq;
            tp->urg_data = TCP_URG_NOTREAD;  // 标记有未读紧急数据

            // 通知应用层（SIGURG信号或POLLPRI事件）
            sk_send_sigurg(sk);
        }
    }
}

// 读取紧急数据
static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
{
    struct tcp_sock *tp = tcp_sk(sk);

    if (th->urg) {
        tcp_check_urg(sk, th);
    }

    // 如果SO_OOBINLINE未设置，紧急数据存储在tp->urg_data单字节中
    // 应用层通过recv(MSG_OOB)读取
    if (tp->urg_data == TCP_URG_NOTREAD &&
        tp->urg_seq == tp->copied_seq &&
        !sock_flag(sk, SOCK_URGINLINE)) {
        tp->urg_data = TCP_URG_READ;
        // 紧急字节存储在 tp->urg_data的高字节中
    }
}

//file: net/ipv4/tcp.c
int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
                int nonblock, int flags, int *addr_len)
{
    struct tcp_sock *tp = tcp_sk(sk);
    int copied = 0;
    u32 *seq;       // 当前读取位置（copied_seq）
    long timeo;

    lock_sock(sk);

    // 读取位置指针
    seq = &tp->copied_seq;
    if (flags & MSG_OOB)
        goto recv_urg;  // 带外数据走单独路径

    // 确定超时时间
    timeo = sock_rcvtimeo(sk, nonblock);

    do {
        struct sk_buff *skb;
        u32 offset;

        // 1. 先处理prequeue中积压的数据
        if (!skb_queue_empty(&tp->ucopy.prequeue))
            tcp_prequeue_process(sk);

        // 2. 从sk_receive_queue中获取下一个skb
        skb_queue_walk(&sk->sk_receive_queue, skb) {
            // 跳过已读取的部分
            offset = *seq - TCP_SKB_CB(skb)->seq;
            if (offset < skb->len)
                goto found_ok_skb;
        }

        // 3. 队列为空，检查是否需要等待
        if (copied >= target)
            break;  // 已读取足够数据

        if (sk->sk_err || sk->sk_state == TCP_CLOSE ||
            (sk->sk_shutdown & RCV_SHUTDOWN)) {
            // 连接出错或已关闭
            break;
        }

        if (!timeo) {
            // 非阻塞模式：返回EAGAIN
            copied = -EAGAIN;
            break;
        }

        // 4. 阻塞等待数据到达
        // 释放socket锁 → 等待sk_data_ready唤醒 → 重新加锁
        sk_wait_data(sk, &timeo, last);
        continue;

found_ok_skb:
        // 5. 复制数据到用户空间
        used = min_t(unsigned int, skb->len - offset, len);
        if (!(flags & MSG_TRUNC)) {
            err = skb_copy_datagram_msg(skb, offset, msg, used);
            if (err) {
                copied = -EFAULT;
                break;
            }
        }

        *seq += used;
        copied += used;
        len -= used;

        // 6. 如果skb数据全部读完，释放skb
        if (offset + used == skb->len) {
            __skb_unlink(skb, &sk->sk_receive_queue);
            __kfree_skb(skb);
        }

    } while (len > 0);

    // 7. 读取后更新接收窗口
    // 应用层消费了数据 → 释放了缓冲区空间 → 可以通告更大窗口
    tcp_cleanup_rbuf(sk, copied);

    release_sock(sk);
    return copied;

recv_urg:
    // MSG_OOB路径：读取tp->urg_data
    err = tcp_recv_urg(sk, msg, len, flags);
    goto out;
}

//file: net/ipv4/tcp.c
static void tcp_cleanup_rbuf(struct sock *sk, int copied)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // 判断是否需要发送窗口更新ACK
    // 条件：释放了足够的缓冲区空间（窗口增大超过一定阈值）
    if (tcp_time_to_send_ack(sk, tp)) {
        // 立即发送ACK，通告新的更大接收窗口
        tcp_send_ack(sk);
    }
}

//file: net/ipv4/tcp.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp.c#L722
ssize_t tcp_splice_read(struct socket *sock, loff_t *ppos,
                        struct pipe_inode_info *pipe, size_t len,
                        unsigned int flags)
{
    struct sock *sk = sock->sk;
    struct tcp_splice_state tss = {
        .pipe = pipe,
        .len = len,
        .flags = flags,
    };
    long timeo;
    ssize_t spliced;

    lock_sock(sk);
    timeo = sock_rcvtimeo(sk, sock->file->f_flags & O_NONBLOCK);

    ......

    while (tss.len) {
        ret = __tcp_splice_read(sk, &tss);
        if (ret < 0)
            break;
        else if (!ret) {
            // 无数据可读，处理各种状态
            if (spliced) break;
            if (sock_flag(sk, SOCK_DONE)) break;
            if (sk->sk_shutdown & RCV_SHUTDOWN) break;
            if (!timeo) { ret = -EAGAIN; break; }
            // 如果receive_queue非空但__tcp_splice_read返回0
            // 可能是URG数据导致，避免死循环
            if (!skb_queue_empty(&sk->sk_receive_queue)) break;
            // 阻塞等待数据
            sk_wait_data(sk, &timeo, NULL);
            continue;
        }
        tss.len -= ret;
        spliced += ret;
    }
    ......
    release_sock(sk);
    return spliced ? spliced : ret;
}

// __tcp_splice_read通过tcp_read_sock遍历receive_queue
static int __tcp_splice_read(struct sock *sk, struct tcp_splice_state *tss)
{
    read_descriptor_t rd_desc = {
        .arg.data = tss,
        .count = tss->len,
    };
    return tcp_read_sock(sk, &rd_desc, tcp_splice_data_recv);
}

//file: net/ipv4/tcp.c
int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
                  sk_read_actor_t recv_actor)
{
    struct sk_buff *skb;
    struct tcp_sock *tp = tcp_sk(sk);
    u32 seq = tp->copied_seq;

    while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
        if (offset < skb->len) {
            // 调用recv_actor（splice场景下为tcp_splice_data_recv）
            used = recv_actor(desc, skb, offset, len);
            seq += used;
            copied += used;
        }
        // skb数据读完后释放
        sk_eat_skb(sk, skb);
    }
    tp->copied_seq = seq;
    tcp_rcv_space_adjust(sk);
    tcp_cleanup_rbuf(sk, copied);  // 触发窗口更新ACK
    return copied;
}

//file: net/ipv4/tcp.c
//https://elixir.bootlin.com/linux/v4.11.6/source/net/ipv4/tcp.c#L686
static int tcp_splice_data_recv(read_descriptor_t *rd_desc,
                                struct sk_buff *skb,
                                unsigned int offset, size_t len)
{
    struct tcp_splice_state *tss = rd_desc->arg.data;
    // 将skb的page通过引用计数共享到pipe buffer
    return skb_splice_bits(skb, skb->sk, offset, tss->pipe,
                           min(rd_desc->count, len), tss->flags);
}

//https://elixir.bootlin.com/linux/v4.11.6/source/net/core/skbuff.c#L1975
int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
		    struct pipe_inode_info *pipe, unsigned int tlen,
		    unsigned int flags)
{
	struct partial_page partial[MAX_SKB_FRAGS];
	struct page *pages[MAX_SKB_FRAGS];
	struct splice_pipe_desc spd = {
		.pages = pages,
		.partial = partial,
		.nr_pages_max = MAX_SKB_FRAGS,
		.flags = flags,
		.ops = &nosteal_pipe_buf_ops,
		.spd_release = sock_spd_release,
	};
	int ret = 0;

	__skb_splice_bits(skb, pipe, &offset, &tlen, &spd, sk);

	if (spd.nr_pages)
		ret = splice_to_pipe(pipe, &spd);

	return ret;
}

//splice_to_pipe
//https://elixir.bootlin.com/linux/v4.11.6/source/fs/splice.c#L185

//file: net/ipv4/tcp_input.c - tcp_data_queue() 中
// 数据入sk_receive_queue后
if (!sock_flag(sk, SOCK_DEAD))
    sk->sk_data_ready(sk);  // 触发通知

//file: net/core/sock.c
void sock_init_data(struct socket *sock, struct sock *sk)
{
    // ...
    sk->sk_data_ready  = sock_def_readable;   // 数据可读通知
    sk->sk_error_report = sock_def_error_report; // 错误通知
    sk->sk_write_space = sock_def_write_space;  // 可写通知
    // ...
}

//file: net/core/sock.c
static void sock_def_readable(struct sock *sk)
{
    struct socket_wq *wq;

    rcu_read_lock();
    wq = rcu_dereference(sk->sk_wq);

    // 唤醒等待队列上的所有waiter
    // EPOLLIN | EPOLLRDNORM 表示可读事件
    if (skwq_has_sleeper(wq))
        wake_up_interruptible_sync_poll(&wq->wait,
                                        EPOLLIN | EPOLLRDNORM |
                                        EPOLLRDBAND);

    // 通知fasync（SIGIO信号）
    sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
    rcu_read_unlock();
}

//file: fs/eventpoll.c
static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode,
                            int sync, void *key)
{
    struct epitem *epi = ep_item_from_wait(wait);
    struct eventpoll *ep = epi->ep;
    unsigned long flags;
    __poll_t pollflags = key_to_poll(key);  // EPOLLIN等事件标志

    spin_lock_irqsave(&ep->lock, flags);

    // 将epitem加入就绪链表rdllist
    if (!ep_is_linked(&epi->rdllink))
        list_add_tail(&epi->rdllink, &ep->rdllist);

    // 唤醒epoll_wait中阻塞的进程
    if (waitqueue_active(&ep->wq))
        wake_up_locked(&ep->wq);

    // 唤醒通过eventfd等待的进程
    if (waitqueue_active(&ep->poll_wait))
        pwake++;

    spin_unlock_irqrestore(&ep->lock, flags);

    return 1;
}

//file: net/ipv4/tcp_input.c
static void tcp_fin(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);

    // 更新接收序号（FIN占一个序号）
    tp->fin_seq = tp->rcv_nxt;

    // 标记接收方向关闭
    sk->sk_shutdown |= RCV_SHUTDOWN;
    sock_set_flag(sk, SOCK_DONE);

    // 状态切换（根据当前状态）
    switch (sk->sk_state) {
    case TCP_ESTABLISHED:
        tcp_set_state(sk, TCP_CLOSE_WAIT);
        break;
    case TCP_FIN_WAIT1:
        tcp_set_state(sk, TCP_CLOSING);
        break;
    case TCP_FIN_WAIT2:
        tcp_set_state(sk, TCP_TIME_WAIT);
        break;
    // ...
    }

    // 关键：通知应用层！
    // FIN等效于"对端不再发送数据"，对应用来说就是"可读"事件
    // recv()会返回0表示连接关闭
    if (!sock_flag(sk, SOCK_DEAD)) {
        sk->sk_state_change(sk);  // 状态变更通知
        sk->sk_data_ready(sk);    // 可读通知（recv返回0）
    }
}

//file: net/ipv4/tcp_input.c
static void tcp_reset(struct sock *sk)
{
    // 根据当前状态设置不同的错误码
    switch (sk->sk_state) {
    case TCP_SYN_SENT:
        sk->sk_err = ECONNREFUSED;  // 连接被拒绝
        break;
    case TCP_CLOSE_WAIT:
        sk->sk_err = EPIPE;         // 对端已关闭
        break;
    default:
        sk->sk_err = ECONNRESET;    // 连接被重置
    }

    // 设置连接为CLOSE状态
    tcp_done(sk);

    // 通知应用层——通过错误报告通道
    if (!sock_flag(sk, SOCK_DEAD))
        sk->sk_error_report(sk);  // 即 sock_def_error_report()
}

//file: net/core/sock.c
static void sock_def_error_report(struct sock *sk)
{
    struct socket_wq *wq;

    rcu_read_lock();
    wq = rcu_dereference(sk->sk_wq);

    // 唤醒等待队列，报告EPOLLERR事件
    if (skwq_has_sleeper(wq))
        wake_up_interruptible_poll(&wq->wait, EPOLLERR);

    sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
    rcu_read_unlock();
}

//file: net/ipv4/tcp_timer.c
static void tcp_keepalive_timer(unsigned long data)
{
    struct sock *sk = (struct sock *)data;
    struct tcp_sock *tp = tcp_sk(sk);

    // 如果探测次数超过tcp_keepalive_probes
    if (tp->probes_out >= keepalive_probes(tp)) {
        // 连接死亡
        tcp_send_active_reset(sk, GFP_ATOMIC);
        tcp_done(sk);  // 内部会设置sk_err并调用sk_error_report
        goto out;
    }

    // 否则发送keepalive探测
    tcp_write_wakeup(sk);
    tp->probes_out++;
    // 重置定时器
}

// tcp_done: 连接终结的统一处理
void tcp_done(struct sock *sk)
{
    if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
        TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);

    tcp_set_state(sk, TCP_CLOSE);
    tcp_clear_xmit_timers(sk);

    sk->sk_shutdown = SHUTDOWN_MASK;

    if (!sock_flag(sk, SOCK_DEAD))
        sk->sk_state_change(sk);  // 触发EPOLLHUP
}