大龙的博客

常用链接

统计

最新评论

Linux TCP数据包接收处理 --- 转

在接收流程一节中可以看到数据包在读取到用户空间前，都要经过tcp_v4_do_rcv处理，从而在receive queue中排队。

在该函数中，我们只分析当连接已经建立后的数据包处理流程，也即tcp_rcv_established函数。

 

tcp_rcv_established函数的工作原理是把数据包的处理分为2类：fast path和slow path，其含义显而易见。这样分类

的目的当然是加快数据包的处理，因为在正常情况下，数据包是按顺序到达的，网络状况也是稳定的，这时可以按照fast path

直接把数据包存放到receive queue了。而在其他的情况下则需要走slow path流程了。

 

在协议栈中，是用头部预测来实现的，每个tcp sock有个pred_flags成员，它就是判别的依据。

[cpp] view plaincopy
  1. static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)  
  2. {  
  3.     tp->pred_flags = htonl((tp->tcp_header_len << 26) |  
  4.                    ntohl(TCP_FLAG_ACK) |  
  5.                    snd_wnd);  
  6. }  

 

可以看出头部预测依赖的是头部长度字段和通告窗口。也就是说标志位除了ACK和PSH外，如果其他的存在的话，就不能用

fast path处理，其揭示的含义如下：

1 Either the data transaction is taking place in only one direction (which means that we are the receiver

and not transmitting any data) or in the case where we are sending out data also, the window advertised

 from the other end is constant. The latter means that we have not transmitted any data from our side for

quite some time but are receiving data from the other end. The receive window advertised by the other end is constant.

 

2. Other than PSH|ACK flags in the TCP header, no other flag is set (ACK is set for each TCP segment). 

This means that if any other flag is set such as URG, FIN, SYN, ECN, RST, and CWR, we
know that something important is there to be attended and we need to move into the SLOW path.

 

3. The header length has unchanged. If the TCP header length remains unchanged,
we have not added/reduced any TCP option and we can safely assume that
there is nothing important to be attended, if the above two conditions are TRUE.

 

fast path工作的条件

[c-sharp] view plaincopy
  1. static inline void tcp_fast_path_check(struct sock *sk)  
  2. {  
  3.     struct tcp_sock *tp = tcp_sk(sk);  
  4.   
  5.     if (skb_queue_empty(&tp->out_of_order_queue) &&  
  6.         tp->rcv_wnd &&  
  7.         atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&  
  8.         !tp->urg_data)  
  9.         tcp_fast_path_on(tp);  
  10. }  

 

 

1 没有乱序数据包

2 接收窗口不为0

3 还有接收缓存空间

4 没有紧急数据

 

反之，则进入slow path处理；另外当连接新建立时处于slow path。

 

从fast path进入slow path的触发条件（进入slow path 后pred_flags清除为0）：

1 在tcp_data_queue中接收到乱序数据包

2 在tcp_prune_queue中用完缓存并且开始丢弃数据包

3 在tcp_urgent_check中遇到紧急指针

4 在tcp_select_window中发送的通告窗口下降到0.

 

从slow_path进入fast_path的触发条件：

1 When we have read past an urgent byte in tcp_recvmsg() . Wehave gotten an urgent byte and we remain

  in the slow path mode until we receive the urgent byte because it is handled in the slow path in
  tcp_rcv_established() .

2 当在tcp_data_queue中乱序队列由于gap被填充而处理完毕时，运行tcp_fast_path_check。

3 tcp_ack_update_window()中更新了通告窗口。

 

fast path处理流程

A 判断能否进入fast path

[cpp] view plaincopy
  1. if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&  
  2.         TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {  

 

TCP_HP_BITS的作用就是排除flag中的PSH标志位。只有在头部预测满足并且数据包以正确的顺序（该数据包的第一个序号就是下个要接收

的序号）到达时才进入fast path。

[c-sharp] view plaincopy
  1. int tcp_header_len = tp->tcp_header_len;  
  2.   
  3. /* Timestamp header prediction: tcp_header_len 
  4.  * is automatically equal to th->doff*4 due to pred_flags 
  5.  * match. 
  6.  */  
  7.   
  8. /* Check timestamp */  
  9. if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) {  
  10.     /* No? Slow path! */  
  11.     if (!tcp_parse_aligned_timestamp(tp, th))  
  12.         goto slow_path;  
  13.   
  14.     /* If PAWS failed, check it more carefully in slow path */  
  15.     if ((s32)(tp->rx_opt.rcv_tsval - tp->rx_opt.ts_recent) < 0)  
  16.         goto slow_path;  
  17.   
  18.     /* DO NOT update ts_recent here, if checksum fails 
  19.      * and timestamp was corrupted part, it will result 
  20.      * in a hung connection since we will drop all 
  21.      * future packets due to the PAWS test. 
  22.      */  
  23. }  

 

该代码段是依据时戳选项来检查PAWS（Protect Against Wrapped Sequence numbers）。

 

如果发送来的仅是一个TCP头的话（没有捎带数据或者接收端检测到有乱序数据这些情况时都会发送一个纯粹的ACK包）

[c-sharp] view plaincopy
  1. /* Bulk data transfer: sender */  
  2. if (len == tcp_header_len) {  
  3.     /* Predicted packet is in window by definition. 
  4.      * seq == rcv_nxt and rcv_wup <= rcv_nxt. 
  5.      * Hence, check seq<=rcv_wup reduces to: 
  6.      */  
  7.     if (tcp_header_len ==  
  8.         (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&  
  9.         tp->rcv_nxt == tp->rcv_wup)  
  10.         tcp_store_ts_recent(tp);  
  11.   
  12.     /* We know that such packets are checksummed 
  13.      * on entry. 
  14.      */  
  15.     tcp_ack(sk, skb, 0);  
  16.     __kfree_skb(skb);  
  17.     tcp_data_snd_check(sk);  
  18.     return 0;  
  19. } else { /* Header too small */  
  20.     TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);  
  21.     goto discard;  
  22. }  

 

主要的工作如下：

1 保存对方的最近时戳 tcp_store_ts_recent。通过前面的if判断可以看出tcp总是回显2次时戳回显直接最先到达的数据包的时戳，

  rcv_wup只在发送数据（这时回显时戳）时重置为rcv_nxt，所以接收到前一次回显后第一个数据包后，rcv_nxt增加了，但是

  rcv_wup没有更新，所以后面的数据包处理时不会调用该函数来保存时戳。

2 ACK处理。这个函数非常复杂，包含了拥塞控制机制，确认处理等等。

3 检查是否有数据待发送 tcp_data_snd_check。

 

如果该数据包中包含了数据的话

[cpp] view plaincopy
  1.         } else {  
  2.             int eaten = 0;  
  3.             int copied_early = 0;  
  4.                         /* 此数据包刚好是下一个读取的数据，并且用户空间可存放下该数据包*/  
  5.             if (tp->copied_seq == tp->rcv_nxt &&  
  6.                 len - tcp_header_len <= tp->ucopy.len) {  
  7. #ifdef CONFIG_NET_DMA  
  8.                 if (tcp_dma_try_early_copy(sk, skb, tcp_header_len)) {  
  9.                     copied_early = 1;  
  10.                     eaten = 1;  
  11.                 }  
  12. #endif                          /* 如果该函数在进程上下文中调用并且sock被用户占用的话*/  
  13.                 if (tp->ucopy.task == current &&  
  14.                     sock_owned_by_user(sk) && !copied_early) {  
  15.                                         /* 进程有可能被设置为TASK_INTERRUPTIBLE */  
  16.                     __set_current_state(TASK_RUNNING);  
  17.                                         /* 直接copy数据到用户空间*/  
  18.                     if (!tcp_copy_to_iovec(sk, skb, tcp_header_len))  
  19.                         eaten = 1;  
  20.                 }  
  21.                 if (eaten) {  
  22.                     /* Predicted packet is in window by definition. 
  23.                      * seq == rcv_nxt and rcv_wup <= rcv_nxt. 
  24.                      * Hence, check seq<=rcv_wup reduces to: 
  25.                      */  
  26.                     if (tcp_header_len ==  
  27.                         (sizeof(struct tcphdr) +  
  28.                          TCPOLEN_TSTAMP_ALIGNED) &&  
  29.                         tp->rcv_nxt == tp->rcv_wup)  
  30.                         tcp_store_ts_recent(tp);  
  31.                                         /* 更新RCV RTT，Dynamic Right-Sizing算法*/  
  32.                     tcp_rcv_rtt_measure_ts(sk, skb);  
  33.   
  34.                     __skb_pull(skb, tcp_header_len);  
  35.                     tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;  
  36.                     NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITSTOUSER);  
  37.                 }  
  38.                 if (copied_early)  
  39.                     tcp_cleanup_rbuf(sk, skb->len);  
  40.             }  
  41.             if (!eaten) { /* 没有直接读到用户空间*/  
  42.                 if (tcp_checksum_complete_user(sk, skb))  
  43.                     goto csum_error;  
  44.   
  45.                 /* Predicted packet is in window by definition. 
  46.                  * seq == rcv_nxt and rcv_wup <= rcv_nxt. 
  47.                  * Hence, check seq<=rcv_wup reduces to: 
  48.                  */  
  49.                 if (tcp_header_len ==  
  50.                     (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&  
  51.                     tp->rcv_nxt == tp->rcv_wup)  
  52.                     tcp_store_ts_recent(tp);  
  53.   
  54.                 tcp_rcv_rtt_measure_ts(sk, skb);  
  55.   
  56.                 if ((int)skb->truesize > sk->sk_forward_alloc)  
  57.                     goto step5;  
  58.   
  59.                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITS);  
  60.   
  61.                 /* Bulk data transfer: receiver */  
  62.                 __skb_pull(skb, tcp_header_len);  
  63.                                 /* 进入receive queue 排队，以待tcp_recvmsg读取*/  
  64.                 __skb_queue_tail(&sk->sk_receive_queue, skb);  
  65.                 skb_set_owner_r(skb, sk);  
  66.                 tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;  
  67.             }  
  68.                         /* 数据包接收后续处理*/  
  69.             tcp_event_data_recv(sk, skb);  
  70.                         /* ACK 处理*/  
  71.             if (TCP_SKB_CB(skb)->ack_seq != tp->snd_una) {  
  72.                 /* Well, only one small jumplet in fast path... */  
  73.                 tcp_ack(sk, skb, FLAG_DATA);  
  74.                 tcp_data_snd_check(sk);  
  75.                 if (!inet_csk_ack_scheduled(sk))  
  76.                     goto no_ack;  
  77.             }  
  78.                         /* ACK发送处理*/  
  79.             if (!copied_early || tp->rcv_nxt != tp->rcv_wup)  
  80.                 __tcp_ack_snd_check(sk, 0);  
  81. no_ack:  
  82. #ifdef CONFIG_NET_DMA  
  83.             if (copied_early)  
  84.                 __skb_queue_tail(&sk->sk_async_wait_queue, skb);  
  85.             else  
  86. #endif                    
  87.                         /* eaten为1，表示数据直接copy到了用户空间，这时无需提醒用户进程数据的到达，否则需调用sk_data_ready来通知，因为此时数据到达了receive queue*/  
  88.             if (eaten)  
  89.                 __kfree_skb(skb);  
  90.             else  
  91.                 sk->sk_data_ready(sk, 0);  
  92.             return 0;  
  93.         }  

 

 

tcp_event_data_recv函数

[c-sharp] view plaincopy
  1. static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)  
  2. {  
  3.     struct tcp_sock *tp = tcp_sk(sk);  
  4.     struct inet_connection_sock *icsk = inet_csk(sk);  
  5.     u32 now;  
  6.         /* 接收到了数据，设置ACK需调度标志*/  
  7.     inet_csk_schedule_ack(sk);  
  8.   
  9.     tcp_measure_rcv_mss(sk, skb);  
  10.   
  11.     tcp_rcv_rtt_measure(tp);  
  12.   
  13.     now = tcp_time_stamp;  
  14.         /* 以下为根据接收间隔更新icsk_ack.ato，该值主要用于判断pingpong模式见函数tcp_event_data_sent */  
  15.     if (!icsk->icsk_ack.ato) {  
  16.         /* The _first_ data packet received, initialize 
  17.          * delayed ACK engine. 
  18.          */  
  19.         tcp_incr_quickack(sk);  
  20.         icsk->icsk_ack.ato = TCP_ATO_MIN;  
  21.     } else {  
  22.         int m = now - icsk->icsk_ack.lrcvtime;  
  23.   
  24.         if (m <= TCP_ATO_MIN / 2) {  
  25.             /* The fastest case is the first. */  
  26.             icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + TCP_ATO_MIN / 2;  
  27.         } else if (m < icsk->icsk_ack.ato) {  
  28.             icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + m;  
  29.             if (icsk->icsk_ack.ato > icsk->icsk_rto)  
  30.                 icsk->icsk_ack.ato = icsk->icsk_rto;  
  31.         } else if (m > icsk->icsk_rto) {  
  32.             /* Too long gap. Apparently sender failed to 
  33.              * restart window, so that we send ACKs quickly. 
  34.              */  
  35.             tcp_incr_quickack(sk);  
  36.             sk_mem_reclaim(sk);  
  37.         }  
  38.     }  
  39.     icsk->icsk_ack.lrcvtime = now;  
  40.   
  41.     TCP_ECN_check_ce(tp, skb);  
  42.         /* 每次接收到来自对方的一个TCP数据报，且数据报长度大于128字节时，我们需要调用tcp_grow_window，增加rcv_ssthresh的值，一般每次为rcv_ssthresh增长两倍的mss，增加的条件是rcv_ssthresh小于window_clamp,并且 rcv_ssthresh小于接收缓存剩余空间的3/4，同时tcp_memory_pressure没有被置位(即接收缓存中的数据量没有太大)。 tcp_grow_window中对新收到的skb的长度还有一些限制，并不总是增长rcv_ssthresh的值*/  
  43.     if (skb->len >= 128)  
  44.         tcp_grow_window(sk, skb);  
  45. }  

 

rcv_ssthresh是当前的接收窗口大小的一个阀值，其初始值就置为rcv_wnd。它跟rcv_wnd配合工作，

当本地socket收到数据报，并满足一定条件时，增长rcv_ssthresh的值，在下一次发送数据报组建TCP首部时，

需要通告对方当前的接收窗口大小，这时需要更新rcv_wnd，此时rcv_wnd的取值不能超过rcv_ssthresh的值。

两者配合，达到一个滑动窗口大小缓慢增长的效果。

__tcp_ack_snd_check用来判断ACK的发送方式

[c-sharp] view plaincopy
  1. /* 
  2.  * Check if sending an ack is needed. 
  3.  */  
  4. static void __tcp_ack_snd_check(struct sock *sk, int ofo_possible)  
  5. {  
  6.     struct tcp_sock *tp = tcp_sk(sk);  
  7.   
  8.         /* More than one full frame received... */  
  9.     if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss  
  10.          /* ... and right edge of window advances far enough. 
  11.           * (tcp_recvmsg() will send ACK otherwise). Or... 
  12.           */  
  13.          && __tcp_select_window(sk) >= tp->rcv_wnd) ||  
  14.         /* We ACK each frame or... */  
  15.         tcp_in_quickack_mode(sk) ||  
  16.         /* We have out of order data. */  
  17.         (ofo_possible && skb_peek(&tp->out_of_order_queue))) {  
  18.         /* Then ack it now */  
  19.         tcp_send_ack(sk);  
  20.     } else {  
  21.         /* Else, send delayed ack. */  
  22.         tcp_send_delayed_ack(sk);  
  23.     }  
  24. }  

 

注释很清楚，无需解释。

 

 

这里有个疑问，就是当ucopy应用读到需要读取到的数据包后，也即在一次处理中

[cpp] view plaincopy
  1. if (tp->copied_seq == tp->rcv_nxt &&  
  2.                 len - tcp_header_len <= tp->ucopy.len) {  

 

 

的第二个条件的等号为真 len - tcp_header_len == tp->ucopy.len，然后执行流程到后面eaten为1，所以函数以释放skb结束，没有

调用sk_data_ready函数。假设这个处理调用流程如下：

tcp_recvmsg-> sk_wait_data  -> sk_wait_event -> release_sock -> __release_sock-> sk_backlog_rcv-> tcp_rcv_established

那么即使此时用户得到了所需的数据，但是在tcp_rcv_established返回前没有提示数据已得到，

 

[cpp] view plaincopy
  1. #define sk_wait_event(__sk, __timeo, __condition)           /  
  2.     ({  int __rc;                       /  
  3.         release_sock(__sk);                 /  
  4.         __rc = __condition;                 /  
  5.         if (!__rc) {                        /  
  6.             *(__timeo) = schedule_timeout(*(__timeo));  /  
  7.         }                           /  
  8.         lock_sock(__sk);                    /  
  9.         __rc = __condition;                 /  
  10.         __rc;                           /  
  11.     })  

 

但是在回到sk_wait_event后，由于__condition为 !skb_queue_empty(&sk->sk_receive_queue)，所以还是会调用schedule_timeout

来等待。这点显然是浪费时间，所以这个condition应该考虑下这个数据已经读满的情况，而不能光靠观察receive queue来判断是否等待。

 

接下来分析slow path

[cpp] view plaincopy
  1. slow_path:  
  2.     if (len < (th->doff << 2) || tcp_checksum_complete_user(sk, skb))  
  3.         goto csum_error;  
  4.   
  5.     /* 
  6.      *  Standard slow path. 
  7.      */  
  8.         /* 检查到达的数据包 */  
  9.     res = tcp_validate_incoming(sk, skb, th, 1);  
  10.     if (res <= 0)  
  11.         return -res;  
  12.   
  13. step5:  /* 如果设置了ACK，则调用tcp_ack处理，后面再分析该函数*/  
  14.     if (th->ack)  
  15.         tcp_ack(sk, skb, FLAG_SLOWPATH);  
  16.   
  17.     tcp_rcv_rtt_measure_ts(sk, skb);  
  18.   
  19.     /* Process urgent data. */  
  20.     tcp_urg(sk, skb, th);  
  21.   
  22.     /* step 7: process the segment text */  
  23.     tcp_data_queue(sk, skb);  
  24.           
  25.     tcp_data_snd_check(sk);  
  26.     tcp_ack_snd_check(sk);  
  27.     return 0;  

 

 

先看看tcp_validate_incoming函数，在slow path处理前检查输入数据包的合法性。

[cpp] view plaincopy
  1. /* Does PAWS and seqno based validation of an incoming segment, flags will 
  2.  * play significant role here. 
  3.  */  
  4. static int tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,  
  5.                   struct tcphdr *th, int syn_inerr)  
  6. {  
  7.     struct tcp_sock *tp = tcp_sk(sk);  
  8.   
  9.     /* RFC1323: H1. Apply PAWS check first. */  
  10.     if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&  
  11.         tcp_paws_discard(sk, skb)) {  
  12.         if (!th->rst) {  
  13.             NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);  
  14.             tcp_send_dupack(sk, skb);  
  15.             goto discard;  
  16.         }  
  17.         /* Reset is accepted even if it did not pass PAWS. */  
  18.     }  
  19.   
  20.     /* Step 1: check sequence number */  
  21.     if (!tcp_sequence(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq)) {  
  22.         /* RFC793, page 37: "In all states except SYN-SENT, all reset 
  23.          * (RST) segments are validated by checking their SEQ-fields." 
  24.          * And page 69: "If an incoming segment is not acceptable, 
  25.          * an acknowledgment should be sent in reply (unless the RST 
  26.          * bit is set, if so drop the segment and return)". 
  27.          */  
  28.         if (!th->rst)  
  29.             tcp_send_dupack(sk, skb);  
  30.         goto discard;  
  31.     }  
  32.   
  33.     /* Step 2: check RST bit */  
  34.     if (th->rst) {  
  35.         tcp_reset(sk);  
  36.         goto discard;  
  37.     }  
  38.   
  39.     /* ts_recent update must be made after we are sure that the packet 
  40.      * is in window. 
  41.      */  
  42.     tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);  
  43.   
  44.     /* step 3: check security and precedence [ignored] */  
  45.   
  46.     /* step 4: Check for a SYN in window. */  
  47.     if (th->syn && !before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {  
  48.         if (syn_inerr)  
  49.             TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);  
  50.         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONSYN);  
  51.         tcp_reset(sk);  
  52.         return -1;  
  53.     }  
  54.   
  55.     return 1;  
  56.   
  57. discard:  
  58.     __kfree_skb(skb);  
  59.     return 0;  
  60. }  

 

 

第一步：检查PAWS tcp_paws_discard

[c-sharp] view plaincopy
  1. static inline int tcp_paws_discard(const struct sock *sk,  
  2.                    const struct sk_buff *skb)  
  3. {  
  4.     const struct tcp_sock *tp = tcp_sk(sk);  
  5.     return ((s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) > TCP_PAWS_WINDOW &&  
  6.         get_seconds() < tp->rx_opt.ts_recent_stamp + TCP_PAWS_24DAYS &&  
  7.         !tcp_disordered_ack(sk, skb));  
  8. }  

 

 

 PAWS丢弃数据包要满足以下条件

1 The difference between the timestamp value obtained in the current segmentand last seen timestamp on

the incoming TCP segment should be more than TCP_PAWS_WINDOW (= 1), which means that if the segment that was
transmitted 1 clock tick before the segment that reached here earlier TCP seq should be acceptable.

It may be because of reordering of the segments that the latter reached earlier.

2 the 24 days have not elapsed since last time timestamp was stored,

3 tcp_disordered_ack返回0.

 

以下转载自CU论坛http://linux.chinaunix.net/bbs/viewthread.php?tid=1130308

 

 

 

 

在实际进行PAWS预防时，Linux是通过如下代码调用来完成的
tcp_rcv_established
    |
    |-->tcp_paws_discard
          |
          |-->tcp_disordered_ack
其中关键是local方通过tcp_disordered_ack函数对一个刚收到的数据分段进行判断，下面我们对该函数的判断逻辑进行下总结：
大前提：该收到分段的TS值表明有回绕现象发生
a）若该分段不是一个纯ACK，则丢弃。因为显然这个分段所携带的数据是一个老数据了，不是local方目前希望接收的（参见PAWS的处理依据一节）
b）若该分段不是local所希望接收的，则丢弃。这个原因很显然
c）若该分段是一个纯ACK，但该ACK并不是一个重复ACK（由local方后续数据正确到达所引发的），则丢弃。因为显然该ACK是一个老的ACK，并不是由于为了加快local方重发而在每收到一个丢失分段后的分段而发出的ACK。
d）若该分段是一个ACK，且为重复ACK，并且该ACK的TS值超过了local方那个丢失分段后的重发rto，则丢弃。因为显然此时local方已经重发了那个导致此重复ACK产生的分段，因此再收到此重复ACK就可以直接丢弃。
e）若该分段是一个ACK，且为重复ACK，但是没有超过一个rto的时间，则不能丢弃，因为这正代表peer方收到了local方发出的丢失分段后的分段，local方要对此ACK进行处理（例如立刻重传）

这里有一个重要概念需要理解，即在出现TS问题后，纯ACK和带ACK的数据分段二者是显著不同的，对于后者，可以立刻丢弃掉，因为从一个窗口的某个seq到下一个窗口的同一个seq过程中，一定有窗口变化曾经发生过，从而TS记录值ts_recent也一定更新过，此时一定可以通过PAWS进行丢弃处理。但是对于前者，一个纯ACK，就不能简单丢弃了，因为有这样一个现象是合理的，即假定local方的接收缓存很大，并且peer方在发送时很快就回绕了，于是在local方的某个分段丢失后，peer方需要在每收到的后续分段时发送重复ACK，而此时该重发ACK的ack_seq就是这个丢失分段的序号，而该重发ACK的seq已经是回绕后的重复序号了，尽管此时到底是回绕后的那个重复ACK还是之前的那个同样序号seq的重复ACK，对于local方来都需要处理（立刻启动重发动作），而不能简单丢弃掉。

 

 

 第2步 检查数据包的序号是否正确，该判断失败后调用tcp_send_dupack发送一个duplicate acknowledge（未设置RST标志位时）。

[cpp] view plaincopy
  1. static inline int tcp_sequence(struct tcp_sock *tp, u32 seq, u32 end_seq)  
  2. {  
  3.     return  !before(end_seq, tp->rcv_wup) &&  
  4.         !after(seq, tp->rcv_nxt + tcp_receive_window(tp));  
  5. }  

 

由rcv_wup的更新时机（发送ACK时的tcp_select_window）可知位于序号rcv_wup前面的数据都已确认，所以待检查数据包的结束序号至少

要大于该值；同时开始序号要落在接收窗口内。

 

第3步 如果设置了RST，则调用tcp_reset处理

第4步 更新ts_recent，

第5步 检查SYN，因为重发的SYN和原来的SYN之间不会发送数据，所以这2个SYN的序号是相同的，如果不满足则reset连接。

 

接下来重点分析tcp_data_queue函数，这里就是对数据包的处理了。

 

 

[cpp] view plaincopy
  1. static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)  
  2. {  
  3.     struct tcphdr *th = tcp_hdr(skb);  
  4.     struct tcp_sock *tp = tcp_sk(sk);  
  5.     int eaten = -1;  
  6.         /* 没有数据处理*/  
  7.     if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq)  
  8.         goto drop;  
  9.         /* 跳过tcp头部*/  
  10.     __skb_pull(skb, th->doff * 4);  
  11.         /* 如果收到对方发来的CWR，则本地TCP发送时不在设置ECE*/  
  12.     TCP_ECN_accept_cwr(tp, skb);  
  13.         /* 初始化Duplicate SACK*/  
  14.     if (tp->rx_opt.dsack) {  
  15.         tp->rx_opt.dsack = 0;  
  16.         tp->rx_opt.eff_sacks = tp->rx_opt.num_sacks;  
  17.     }  

 

 

如果该数据包刚好是下一个要接收的数据，则可以直接copy到用户空间（如果存在且可用），否则排队到receive queue

[cpp] view plaincopy
  1. /*  Queue data for delivery to the user. 
  2.  *  Packets in sequence go to the receive queue. 
  3.  *  Out of sequence packets to the out_of_order_queue. 
  4.  */  
  5. if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {  
  6.     if (tcp_receive_window(tp) == 0)  
  7.         goto out_of_window;  
  8.   
  9.     /* Ok. In sequence. In window. */  
  10.     if (tp->ucopy.task == current &&  
  11.         tp->copied_seq == tp->rcv_nxt && tp->ucopy.len &&  
  12.         sock_owned_by_user(sk) && !tp->urg_data) {  
  13.         int chunk = min_t(unsigned int, skb->len,  
  14.                   tp->ucopy.len);  
  15.   
  16.         __set_current_state(TASK_RUNNING);  
  17.                        /* 这里的下半部开关的作用不解*/  
  18.         local_bh_enable();  
  19.         if (!skb_copy_datagram_iovec(skb, 0, tp->ucopy.iov, chunk)) {  
  20.             tp->ucopy.len -= chunk;  
  21.             tp->copied_seq += chunk;  
  22.             eaten = (chunk == skb->len && !th->fin);  
  23.             tcp_rcv_space_adjust(sk);  
  24.         }  
  25.         local_bh_disable();  
  26.     }  
  27.   
  28.     if (eaten <= 0) {  
  29. ueue_and_out:  
  30.         if (eaten < 0 &&  
  31.                            /* 该函数用于判断是否有接收缓存，在tcp内存管理中将分析*/  
  32.             tcp_try_rmem_schedule(sk, skb->truesize))  
  33.             goto drop;  
  34.   
  35.         skb_set_owner_r(skb, sk);  
  36.         __skb_queue_tail(&sk->sk_receive_queue, skb);  
  37.     }  
  38.     tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;  
  39.     if (skb->len)  
  40.         tcp_event_data_recv(sk, skb);  
  41.     if (th->fin)  
  42.         tcp_fin(skb, sk, th);  
  43.                /* 到达的数据包哟可能填充了乱序队列中的hole */  
  44.     if (!skb_queue_empty(&tp->out_of_order_queue)) {  
  45.         tcp_ofo_queue(sk);  
  46.   
  47.         /* RFC2581. 4.2. SHOULD send immediate ACK, when 
  48.          * gap in queue is filled. 
  49.          */  
  50.                        /*关闭乒乓模式，在quick计数没消耗完时则可立即发送ACK，见tcp_in_quickack_mode*/  
  51.         if (skb_queue_empty(&tp->out_of_order_queue))  
  52.             inet_csk(sk)->icsk_ack.pingpong = 0;  
  53.     }  
  54.                /* 新数据到达导致返回给对方的SACK Block 调整*/  
  55.     if (tp->rx_opt.num_sacks)  
  56.         tcp_sack_remove(tp);  
  57.                /* 在当前slow path，检测是否可以进入fast path*/  
  58.     tcp_fast_path_check(sk);  
  59.   
  60.     if (eaten > 0)  
  61.         __kfree_skb(skb);  
  62.     else if (!sock_flag(sk, SOCK_DEAD))  
  63.         sk->sk_data_ready(sk, 0);  
  64.     return;  
  65. }  

 

下面看看函数tcp_ofo_queue，也即out-of-order queue的处理

[cpp] view plaincopy
  1. /* This one checks to see if we can put data from the 
  2.  * out_of_order queue into the receive_queue. 
  3.  */  
  4. static void tcp_ofo_queue(struct sock *sk)  
  5. {  
  6.     struct tcp_sock *tp = tcp_sk(sk);  
  7.     __u32 dsack_high = tp->rcv_nxt;  
  8.     struct sk_buff *skb;  
  9.   
  10.     while ((skb = skb_peek(&tp->out_of_order_queue)) != NULL) {  
  11.                 /* 当前hole未覆盖，则处理结束*/  
  12.         if (after(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))  
  13.             break;  
  14.                 /* DSACK处理*/  
  15.         if (before(TCP_SKB_CB(skb)->seq, dsack_high)) {  
  16.             __u32 dsack = dsack_high;  
  17.             if (before(TCP_SKB_CB(skb)->end_seq, dsack_high))  
  18.                 dsack_high = TCP_SKB_CB(skb)->end_seq;  
  19.             tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);  
  20.         }  
  21.                 /* 该乱序数据包完全被到达的数据包覆盖，则从乱序队列中删除之，并释放该数据包*/  
  22.         if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {  
  23.             SOCK_DEBUG(sk, "ofo packet was already received /n");  
  24.             __skb_unlink(skb, &tp->out_of_order_queue);  
  25.             __kfree_skb(skb);  
  26.             continue;  
  27.         }  
  28.         SOCK_DEBUG(sk, "ofo requeuing : rcv_next %X seq %X - %X/n",  
  29.                tp->rcv_nxt, TCP_SKB_CB(skb)->seq,  
  30.                TCP_SKB_CB(skb)->end_seq);  
  31.                 /* hole被填充，取出该乱序数据包到receive queue中排队，并更新rcv_nxt */  
  32.         __skb_unlink(skb, &tp->out_of_order_queue);  
  33.         __skb_queue_tail(&sk->sk_receive_queue, skb);  
  34.         tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;  
  35.         if (tcp_hdr(skb)->fin)  
  36.             tcp_fin(skb, sk, tcp_hdr(skb));  
  37.     }  
  38. }  

 

这里DSACK的处理中为什么即使dsack比end_seq大，还是用dsack作为右边界呢？

 

[c-sharp] view plaincopy
  1. /* 该数据包的数据已经完全存在，则发送DSACK，并进入快速ACK模式，调度ACK发送*/    
  2. if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {  
  3.         /* A retransmit, 2nd most common case.  Force an immediate ack. */  
  4.         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);  
  5.         tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);  
  6.   
  7. out_of_window:  
  8.         tcp_enter_quickack_mode(sk);  
  9.         inet_csk_schedule_ack(sk);  
  10. drop:  
  11.         __kfree_skb(skb);  
  12.         return;  
  13.     }  
  14.   
  15.     /* Out of window. F.e. zero window probe. */  
  16.     if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt + tcp_receive_window(tp)))  
  17.         goto out_of_window;  
  18.           
  19.     tcp_enter_quickack_mode(sk);  
  20.         /* 部分数据已存在，则设置正确的DSACK，然后排队到receive queue*/  
  21.     if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {  
  22.         /* Partial packet, seq < rcv_next < end_seq */  
  23.         SOCK_DEBUG(sk, "partial packet: rcv_next %X seq %X - %X/n",  
  24.                tp->rcv_nxt, TCP_SKB_CB(skb)->seq,  
  25.                TCP_SKB_CB(skb)->end_seq);  
  26.   
  27.         tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);  
  28.   
  29.         /* If window is closed, drop tail of packet. But after 
  30.          * remembering D-SACK for its head made in previous line. 
  31.          */  
  32.         if (!tcp_receive_window(tp))  
  33.             goto out_of_window;  
  34.         goto queue_and_out;  
  35.     }  

 

 

[cpp] view plaincopy
  1.     TCP_ECN_check_ce(tp, skb); /* 检查ECE是否设置 */  
  2.         /* 以下则把数据包排队到失序队列 */  
  3.         /* 同样先判断内存是否满足 */  
  4.     if (tcp_try_rmem_schedule(sk, skb->truesize))  
  5.         goto drop;  
  6.   
  7.     /* Disable header prediction. */  
  8.     tp->pred_flags = 0;  
  9.     inet_csk_schedule_ack(sk);  
  10.   
  11.     SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X/n",  
  12.            tp->rcv_nxt, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);  
  13.   
  14.     skb_set_owner_r(skb, sk);  
  15.         /* 该数据包是失序队列的第一个数据包*/  
  16.     if (!skb_peek(&tp->out_of_order_queue)) {  
  17.         /* Initial out of order segment, build 1 SACK. */  
  18.         if (tcp_is_sack(tp)) {  
  19.             tp->rx_opt.num_sacks = 1;  
  20.             tp->rx_opt.dsack     = 0;  
  21.             tp->rx_opt.eff_sacks = 1;  
  22.             tp->selective_acks[0].start_seq = TCP_SKB_CB(skb)->seq;  
  23.             tp->selective_acks[0].end_seq =  
  24.                         TCP_SKB_CB(skb)->end_seq;  
  25.         }  
  26.         __skb_queue_head(&tp->out_of_order_queue, skb);  
  27.     } else {  
  28.         struct sk_buff *skb1 = tp->out_of_order_queue.prev;  
  29.         u32 seq = TCP_SKB_CB(skb)->seq;  
  30.         u32 end_seq = TCP_SKB_CB(skb)->end_seq;  
  31.                 /*刚好与失序队列最后一个数据包数据衔接*/  
  32.         if (seq == TCP_SKB_CB(skb1)->end_seq) {  
  33.             __skb_queue_after(&tp->out_of_order_queue, skb1, skb);  
  34.                         /*如果没有sack block或者当前数据包开始序号不等于第一个block右边界*/  
  35.             if (!tp->rx_opt.num_sacks ||  
  36.                 tp->selective_acks[0].end_seq != seq)  
  37.                 goto add_sack;  
  38.                         /*该数据包在某个hole后是按序到达的，所以可以直接扩展第一个sack*/    
  39.             /* Common case: data arrive in order after hole. */  
  40.             tp->selective_acks[0].end_seq = end_seq;  
  41.             return;  
  42.         }  
  43.   
  44.         /* Find place to insert this segment. */  
  45.                 /* 该循环找到一个开始序号不大于该数据包开始序号的失序队列中的数据包*/  
  46.         do {  
  47.             if (!after(TCP_SKB_CB(skb1)->seq, seq))  
  48.                 break;  
  49.         } while ((skb1 = skb1->prev) !=  
  50.              (struct sk_buff *)&tp->out_of_order_queue);  
  51.   
  52.         /* Do skb overlap to previous one? 检查与前个数据包是否有重叠*/  
  53.         if (skb1 != (struct sk_buff *)&tp->out_of_order_queue &&  
  54.             before(seq, TCP_SKB_CB(skb1)->end_seq)) {  
  55.             if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {  
  56.                 /* All the bits are present. Drop. */  
  57.                 __kfree_skb(skb);  
  58.                 tcp_dsack_set(sk, seq, end_seq);  
  59.                 goto add_sack;  
  60.             }  
  61.             if (after(seq, TCP_SKB_CB(skb1)->seq)) {  
  62.                 /* Partial overlap. */  
  63.                 tcp_dsack_set(sk, seq,  
  64.                           TCP_SKB_CB(skb1)->end_seq);  
  65.             } else {  
  66.                 skb1 = skb1->prev;  
  67.             }  
  68.         }  
  69.                 /* 排队到失序队列*/  
  70.         __skb_queue_after(&tp->out_of_order_queue, skb1, skb);  
  71.   
  72.         /* And clean segments covered by new one as whole. 检测与后面的数据包重叠*/  
  73.         while ((skb1 = skb->next) !=  
  74.                (struct sk_buff *)&tp->out_of_order_queue &&  
  75.                after(end_seq, TCP_SKB_CB(skb1)->seq)) {  
  76.             if (before(end_seq, TCP_SKB_CB(skb1)->end_seq)) {  
  77.                 tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,  
  78.                          end_seq);  
  79.                 break;  
  80.             }  
  81.             __skb_unlink(skb1, &tp->out_of_order_queue);  
  82.             tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,  
  83.                      TCP_SKB_CB(skb1)->end_seq);  
  84.             __kfree_skb(skb1);  
  85.         }  
  86.   
  87. add_sack:  
  88.         if (tcp_is_sack(tp))  
  89.                         /* 根据失序队列的现状更新SACK的blocks */  
  90.             tcp_sack_new_ofo_skb(sk, seq, end_seq);  
  91.     }  
  92. }  

 

@import url(http://www.cppblog.com/cutesoft_client/cuteeditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);

posted on 2013-02-18 14:23 大龙 阅读(6810) 评论(0)  编辑 收藏 引用


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理