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

     /*    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) < )
                 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, );
                 /* 释放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 = ;
             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 = ;
                 }
             }

             /* 未拷贝数据到用户空间，或者拷贝失败 */
             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, );
 no_ack:
             /* skb已经复制到用户空间，则释放之 */
             if (eaten)
                 kfree_skb_partial(skb, fragstolen);

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

 slow_path:
     /* 长度错误|| 校验和错误 */
     if (len < (th->doff << ) || 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, ))
         return;

 step5:
     /* 处理ack */
     if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < )
         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);
 }