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 = -;

     /* 无数据 */
     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 * );

     tcp_ecn_accept_cwr(tp, skb);

     tp->rx_opt.dsack = ;

     /*  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) == )
             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, , tp->ucopy.msg, chunk)) {
                 tp->ucopy.len -= chunk;
                 tp->copied_seq += chunk;
                 /* 完整读取了该数据段 */
                 eaten = (chunk == skb->len);

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

         /* 未拷贝到用户空间或者未拷贝完整数据段 */
         if (eaten <= ) {
 queue_and_out:
             /* 没有拷贝到用户空间，对内存进行检查 */
             if (eaten < ) {
                 if (skb_queue_len(&sk->sk_receive_queue) == )
                     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, , &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 = ;
         }

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

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

         /* 向用户空间拷贝了数据，则释放skb */
         if (eaten > )
             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\n",
                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);
 }