TCP输入 之 tcp_data_queue

tcp_data_queue作用为数据段的接收处理，其中分为多种情况：

(1) 无数据，释放skb，返回；

(2) 预期接收的数据段，a. 进行0窗口判断；b. 进程上下文，复制数据到用户空间；c. 不满足b或者b未完整拷贝此skb的数据段，则加入到接收队列；d. 更新下一个期望接收的序号；e. 若有fin标记，则处理fin；f. 乱序队列不为空，则处理乱序；g. 快速路径的检查和设置；h. 唤醒用户空间进程读取数据；

(3) 重传的数据段，进入快速ack模式，释放该skb；

(4) 窗口以外的数据段，进入快速ack模式，释放该skb；

(5) 数据段重叠，在进行0窗口判断之后，进行(2)中的加入接收队列，以及>=d的流程；

(6) 乱序的数据段，调用tcp_data_queue_ofo进行乱序数据段的接收处理；

static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    bool fragstolen = false;
    int eaten = -1;

    /* 无数据 */
    if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
        __kfree_skb(skb);
        return;
    }

    /* 删除路由缓存 */
    skb_dst_drop(skb);

    /* 去掉tcp首部 */
    __skb_pull(skb, tcp_hdr(skb)->doff * 4);

    tcp_ecn_accept_cwr(tp, skb);

    tp->rx_opt.dsack = 0;

    /*  Queue data for delivery to the user.
     *  Packets in sequence go to the receive queue.
     *  Out of sequence packets to the out_of_order_queue.
     */
    /* 预期接收的数据段 */
    if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
        /* 窗口为0，不能接收数据 */
        if (tcp_receive_window(tp) == 0)
            goto out_of_window;

        /* Ok. In sequence. In window. */
        /* 进程上下文 */

        /* 当前进程读取数据 */
        if (tp->ucopy.task == current &&
            /* 用户空间读取序号与接收序号一致&& 需要读取的数据不为0 */
            tp->copied_seq == tp->rcv_nxt && tp->ucopy.len &&
            /* 被用户空间锁定&& 无紧急数据 */
            sock_owned_by_user(sk) && !tp->urg_data) {

            /* 带读取长度和数据段长度的较小值 */
            int chunk = min_t(unsigned int, skb->len,
                      tp->ucopy.len);
            /* 设置running状态 */
            __set_current_state(TASK_RUNNING);

            /* 拷贝数据 */
            if (!skb_copy_datagram_msg(skb, 0, tp->ucopy.msg, chunk)) {
                tp->ucopy.len -= chunk;
                tp->copied_seq += chunk;
                /* 完整读取了该数据段 */
                eaten = (chunk == skb->len);

                /* 调整接收缓存和窗口 */
                tcp_rcv_space_adjust(sk);
            }
        }

        /* 未拷贝到用户空间或者未拷贝完整数据段 */
        if (eaten <= 0) {
queue_and_out:
            /* 没有拷贝到用户空间，对内存进行检查 */
            if (eaten < 0) {
                if (skb_queue_len(&sk->sk_receive_queue) == 0)
                    sk_forced_mem_schedule(sk, skb->truesize);
                else if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
                    goto drop;
            }

            /* 添加到接收队列 */
            eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);
        }

        /* 更新下一个期望接收的序号*/
        tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
        /* 有数据 */
        if (skb->len)
            tcp_event_data_recv(sk, skb);

        /* 标记有fin，则处理 */
        if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
            tcp_fin(sk);

        /* 乱序队列有数据，则处理 */
        if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {

            /* 将乱序队列中的数据段转移到接收队列 */
            tcp_ofo_queue(sk);

            /* RFC2581. 4.2. SHOULD send immediate ACK, when
             * gap in queue is filled.
             */
            /* 乱序数据段处理完毕，需要立即发送ack */
            if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
                inet_csk(sk)->icsk_ack.pingpong = 0;
        }

        if (tp->rx_opt.num_sacks)
            tcp_sack_remove(tp);

        /* 快路检查 */
        tcp_fast_path_check(sk);

        /* 向用户空间拷贝了数据，则释放skb */
        if (eaten > 0)
            kfree_skb_partial(skb, fragstolen);

        /* 不在销毁状态，则唤醒进程读取数据 */
        if (!sock_flag(sk, SOCK_DEAD))
            sk->sk_data_ready(sk);
        return;
    }

    /* 重传 */
    if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
        /* A retransmit, 2nd most common case.  Force an immediate ack. */
        NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
        tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);

out_of_window:
        /* 进入快速ack模式 */
        tcp_enter_quickack_mode(sk);

        /*  调度ack */
        inet_csk_schedule_ack(sk);
drop:
        /* 释放skb */
        tcp_drop(sk, skb);
        return;
    }

    /* Out of window. F.e. zero window probe. */
    /* 窗口以外的数据，比如零窗口探测报文段 */
    if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt + tcp_receive_window(tp)))
        goto out_of_window;

    /* 进入快速ack模式 */
    tcp_enter_quickack_mode(sk);

    /* 数据段重叠 */
    if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
        /* Partial packet, seq < rcv_next < end_seq */
        SOCK_DEBUG(sk, "partial packet: rcv_next %X seq %X - %X
",
               tp->rcv_nxt, TCP_SKB_CB(skb)->seq,
               TCP_SKB_CB(skb)->end_seq);

        tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);

        /* If window is closed, drop tail of packet. But after
         * remembering D-SACK for its head made in previous line.
         */
        /* 窗口为0，不能接收 */
        if (!tcp_receive_window(tp))
            goto out_of_window;
        goto queue_and_out;
    }

    /* 接收乱序数据段 */
    tcp_data_queue_ofo(sk, skb);
}