TCP输入 之 tcp_rcv_established

概述

tcp_rcv_established用于处理已连接状态下的输入，处理过程根据首部预测字段分为快速路径和慢速路径；

1. 在快路中，对是有有数据负荷进行不同处理：

(1) 若无数据，则处理输入ack，释放该skb，检查是否有数据发送，有则发送；

(2) 若有数据，检查是否当前处理进程上下文，并且是期望读取的数据，若是则将数据复制到用户空间，若不满足直接复制到用户空间的情况，或者复制失败，则需要将数据段加入到接收队列中，加入方式包括合并到已有数据段，或者加入队列尾部，并唤醒用户进程通知有数据可读；

2. 在慢路中，会进行更详细的校验，然后处理ack，处理紧急数据，接收数据段，其中数据段可能包含乱序的情况，最后进行是否有数据和ack的发送检查；

源码分析

he first three cases are guaranteed by proper pred_flags setting,
 *    the rest is checked inline. Fast processing is turned on in
 *    tcp_data_queue when everything is OK.
 */
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);

    skb_mstamp_get(&tp->tcp_mstamp);
    /* 路由为空，则重新设置路由 */
    if (unlikely(!sk->sk_rx_dst))
        inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
    /*
     *    Header prediction.
     *    The code loosely follows the one in the famous
     *    "30 instruction TCP receive" Van Jacobson mail.
     *
     *    Van's trick is to deposit buffers into socket queue
     *    on a device interrupt, to call tcp_recv function
     *    on the receive process context and checksum and copy
     *    the buffer to user space. smart...
     *
     *    Our current scheme is not silly either but we take the
     *    extra cost of the net_bh soft interrupt processing...
     *    We do checksum and copy also but from device to kernel.
     */

    tp->rx_opt.saw_tstamp = 0;

    /*    pred_flags is 0xS?10 << 16 + snd_wnd
     *    if header_prediction is to be made
     *    'S' will always be tp->tcp_header_len >> 2
     *    '?' will be 0 for the fast path, otherwise pred_flags is 0 to
     *  turn it off    (when there are holes in the receive
     *     space for instance)
     *    PSH flag is ignored.
     */

    /* 快路检查&& 序号正确 && 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)) {
        /* tcp头部长度 */
        int tcp_header_len = tp->tcp_header_len;

        /* Timestamp header prediction: tcp_header_len
         * is automatically equal to th->doff*4 due to pred_flags
         * match.
         */

        /* Check timestamp */
        /* 有时间戳选项 */
        if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) {
            /* No? Slow path! */
            /* 解析时间戳选项失败，执行慢路 */
            if (!tcp_parse_aligned_timestamp(tp, th))
                goto slow_path;

            /* If PAWS failed, check it more carefully in slow path */
            /* 序号回转，执行慢路 */
            if ((s32)(tp->rx_opt.rcv_tsval - tp->rx_opt.ts_recent) < 0)
                goto slow_path;

            /* DO NOT update ts_recent here, if checksum fails
             * and timestamp was corrupted part, it will result
             * in a hung connection since we will drop all
             * future packets due to the PAWS test.
             */
        }

        /* 无数据 */
        if (len <= tcp_header_len) {
            /* Bulk data transfer: sender */
            if (len == tcp_header_len) {
                /* Predicted packet is in window by definition.
                 * seq == rcv_nxt and rcv_wup <= rcv_nxt.
                 * Hence, check seq<=rcv_wup reduces to:
                 */
                /* 
                    有时间戳选项
                    && 所有接收的数据段均确认完毕 
                    保存时间戳
                  */
                if (tcp_header_len ==
                    (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&
                    tp->rcv_nxt == tp->rcv_wup)
                    tcp_store_ts_recent(tp);

                /* We know that such packets are checksummed
                 * on entry.
                 */
                /* 输入ack处理 */
                tcp_ack(sk, skb, 0);
                /* 释放skb */
                __kfree_skb(skb);

                /* 检查是否有数据要发送，并检查发送缓冲区大小 */
                tcp_data_snd_check(sk);
                return;
            }
            /* 数据多小，比头部都小，错包 */
            else { /* Header too small */
                TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
                goto discard;
            }
        }
        /* 有数据 */
        else {
            int eaten = 0;
            bool fragstolen = false;

            /* 读取进程上下文 */
            if (tp->ucopy.task == current &&
                /* 期待读取的和期待接收的序号一致 */
                tp->copied_seq == tp->rcv_nxt &&
                /* 数据<= 待读取长度 */
                len - tcp_header_len <= tp->ucopy.len &&
                /* 控制块被用户空间锁定 */
                sock_owned_by_user(sk)) {

                /* 设置状态为running??? */
                __set_current_state(TASK_RUNNING);

                /* 拷贝数据到msghdr */
                if (!tcp_copy_to_iovec(sk, skb, tcp_header_len)) {
                    /* Predicted packet is in window by definition.
                     * seq == rcv_nxt and rcv_wup <= rcv_nxt.
                     * Hence, check seq<=rcv_wup reduces to:
                     */
                    /* 有时间戳选项&& 收到的数据段均已确认，更新时间戳 */
                    if (tcp_header_len ==
                        (sizeof(struct tcphdr) +
                         TCPOLEN_TSTAMP_ALIGNED) &&
                        tp->rcv_nxt == tp->rcv_wup)
                        tcp_store_ts_recent(tp);

                    /* 接收端RTT估算 */
                    tcp_rcv_rtt_measure_ts(sk, skb);

                    __skb_pull(skb, tcp_header_len);

                    /* 更新期望接收的序号 */
                    tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
                    NET_INC_STATS(sock_net(sk),
                            LINUX_MIB_TCPHPHITSTOUSER);
                    eaten = 1;
                }
            }

            /* 未拷贝数据到用户空间，或者拷贝失败 */
            if (!eaten) {
                /* 检查校验和 */
                if (tcp_checksum_complete(skb))
                    goto csum_error;

                /* skb长度> 预分配长度 */
                if ((int)skb->truesize > sk->sk_forward_alloc)
                    goto step5;

                /* Predicted packet is in window by definition.
                 * seq == rcv_nxt and rcv_wup <= rcv_nxt.
                 * Hence, check seq<=rcv_wup reduces to:
                 */
                /* 有时间戳选项，且数据均已确认完毕，则更新时间戳 */
                if (tcp_header_len ==
                    (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&
                    tp->rcv_nxt == tp->rcv_wup)
                    tcp_store_ts_recent(tp);

                /* 计算RTT */
                tcp_rcv_rtt_measure_ts(sk, skb);

                NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPHITS);

                /* Bulk data transfer: receiver */
                /* 数据加入接收队列 */
                eaten = tcp_queue_rcv(sk, skb, tcp_header_len,
                              &fragstolen);
            }

            tcp_event_data_recv(sk, skb);

            /* 确认序号确认了数据 */
            if (TCP_SKB_CB(skb)->ack_seq != tp->snd_una) {
                /* Well, only one small jumplet in fast path... */
                /* 处理ack */
                tcp_ack(sk, skb, FLAG_DATA);
                /* 检查是否有数据要发送，需要则发送 */
                tcp_data_snd_check(sk);
                /* 没有ack要发送 */
                if (!inet_csk_ack_scheduled(sk))
                    goto no_ack;
            }

            /* 检查是否有ack要发送，需要则发送 */
            __tcp_ack_snd_check(sk, 0);
no_ack:
            /* skb已经复制到用户空间，则释放之 */
            if (eaten)
                kfree_skb_partial(skb, fragstolen);

            /* 唤醒用户进程有数据读取 */
            sk->sk_data_ready(sk);
            return;
        }
    }

slow_path:
    /* 长度错误|| 校验和错误 */
    if (len < (th->doff << 2) || tcp_checksum_complete(skb))
        goto csum_error;

    /* 无ack，无rst，无syn */
    if (!th->ack && !th->rst && !th->syn)
        goto discard;

    /*
     *    Standard slow path.
     */
    /* 种种校验 */
    if (!tcp_validate_incoming(sk, skb, th, 1))
        return;

step5:
    /* 处理ack */
    if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
        goto discard;

    /* 计算rtt */
    tcp_rcv_rtt_measure_ts(sk, skb);

    /* Process urgent data. */
    /* 处理紧急数据 */
    tcp_urg(sk, skb, th);

    /* step 7: process the segment text */
    /* 数据段处理 */
    tcp_data_queue(sk, skb);

    /* 发送数据检查，有则发送 */
    tcp_data_snd_check(sk);

    /* 发送ack检查，有则发送 */
    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);
}