TCP的ACK确认系列 — 延迟确认

主要内容：TCP的延迟确认、延迟确认定时器的实现。

内核版本：3.15.2

我的博客：http://blog.csdn.net/zhangskd 

 

延迟确认模式

 

发送方在发送数据包时，如果发送的数据包有负载，则会检测拥塞窗口是否超时。

如果超时，则会使拥塞窗口失效并重新计算拥塞窗口。

如果此时距离最近接收到数据包的时间间隔足够短，说明双方处于你来我往的双向数据传输中，

就进入延迟确认模式。

[java]  view plain  copy

 

1. /* Congestion state accounting after a packet has been sent. */  
2. static void tcp_event_data_sent (struct tcp_sock *tp, struct sock *sk)  
3. {  
4.     struct inet_connection_sock *icsk = inet_csk(sk);  
5.     const u32 now = tcp_time_stamp;  
6.     const struct dst_entry *dst = __sk_dst_get(sk);  
7.   
8.     if (sysctl_tcp_slow_start_after_idle &&   
9.         (!tp->packets_out && (s32) (now - tp->lsndtime) > icsk->icsk_rto))  
10.         tcp_cwnd_restart(sk, __sk_dst_get(sk)); /* 重置cnwd */  
11.   
12.     tp->lsndtime = now; /* 更新最近发送数据包的时间*/  
13.   
14.     /* If it is a reply for ato after last received packets,  
15.      * enter pingpong mode. 
16.      * 如果距离上次接收到数据包的时间在ato内，则进入延迟确认模式。 
17.      */  
18.     if ((u32)(now - icsk->icsk_ack.lrcvtime) < icsk.icsk_ack.ato &&   
19.         (!dst || !dst_metric(dst, RTAX_QUICKACK)))  
20.         icsk->icsk_ack.pingpong = 1;  
21. }  

 

ATO的计算

 

Q：icsk->icsk_ack.ato在ACK的发送过程中扮演了重要角色，那么它到底是用来干什么的？

A：ato为ACK Timeout，指ACK的超时时间。但延迟确认定时器的超时时间为icsk->icsk_ack.timeout，

ato只是计算timeout的一个中间变量，会根接收到的数据包的时间间隔来做动态调整。一般如果接收到

的数据包的时间间隔变小，ato也会相应的变小。如果接收到的数据包的时间间隔变大，ato也会相应的

变大。ato的最小值为40ms，ato的最大值一般为200ms或一个RTT。

所以在实际传输过程中，我们看到的ACK的超时时间，是处于40ms ~ min(200ms, RTT)之间的。

 

在tcp_event_data_recv()中更新ato的值，delta为距离上次收到数据包的时间：

1. delta <= TCP_ATO_MIN /2时，ato = ato / 2 + TCP_ATO_MIN / 2。

2. TCP_ATO_MIN / 2 < delta <= ato时，ato = min(ato / 2 + delta, rto)。

3. delta > ato时，ato值不变。

在tcp_send_delayed_ack()中会把ato赋值给icsk->icsk_ack.timeout，用作延迟确认定时器的超时时间。

 

延迟确认定时器

 

#define ICSK_TIME_DACK 2 /* Delayed ack timer */

icsk->icsk_delack_timer：延迟确认定时器。

 

(1) 激活

icsk->icsk_delack_timer的激活函数为inet_csk_reset_xmit_timer()，此函数共负责了5个定时器的激活工作。

延迟确认定时器的另一个激活函数为tcp_send_delayed_ack()，用于判断发送快速确认还是延迟确认。

[java]  view plain  copy

 

1. /* 
2.  * Reset the retransmissiion timer 
3.  */  
4. static inline void inet_csk_reset_xmit_timer(struct sock *sk, const int what,  
5.                                             unsigned long when,  
6.                                             const unsigned long max_when)  
7. {  
8.     struct inet_connection_sock *icsk = inet_csk(sk);  
9.   
10.     if (when > max_when) {  
11. #ifdef INET_CSK_DEBUG  
12.         pr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",  
13.                     sk, what, when, current_text_addr());  
14. #endif  
15.         when = max_when;  
16.     }  
17.     if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0 ||   
18.         what == ICSK_TIME_EARLY_RETRANS || what == ICSK_TIME_LOSS_PROBE) {  
19.         icsk->icsk_pending = what;  
20.         icsk->icsk_timeout = jiffies + when; /*数据包超时时刻*/  
21.         sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);  
22.     } else if (what == ICSK_TIME_DACK) {  
23.         icsk->icsk_ack.pending |= ICSK_ACK_TIMER; /* 延迟确认定时器启动标志 */  
24.         icsk->icsk_ack.timeout = jiffies + when; /* Delay ACK定时器超时时刻*/  
25.         sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);  
26.     }  
27. #ifdef INET_CSK_DEBUG  
28.     else {  
29.         pr_debug("%s", inet_csk_timer_bug_msg);  
30.     }    
31. #endif       
32. }  

 

(2) 超时处理函数

icsk->icsk_delack_timer的超时处理函数为tcp_delack_timer()。

[java]  view plain  copy

 

1. static void tcp_delack_timer (unsigned long data)  
2. {  
3.     struct sock *sk = (struct sock *) data;  
4.   
5.     bh_lock_sock(sk);  
6.     if (! sock_owned_by_user(sk)) {  
7.         tcp_delack_timer_handler(sk); /* 实际的处理函数 */  
8.     } else {  
9.         /* 如果延迟确认定时器触发时，发现用户进程正在使用此socket，就把blocked置为1。 
10.          * 之后在接收到新数据、或者将数据复制到用户空间之后，会马上发送ACK。 
11.          */  
12.         inet_csk(sk)->icsk_ack.blocked = 1;  
13.         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED);  
14.   
15.         /* delegate our work to tcp_release_cb() */  
16.         if (! test_and_set_bit(TCP_DELACK_TIMER_DEFERRED, &tcp_sk(sk)->tsq_flags))  
17.             sock_hold(sk);  
18.     }  
19.     bh_unlock_sock(sk);  
20.     sock_put(sk);  
21. }  

tcp_delack_timer_handler()是延迟确认定时器的实际超时处理函数。

延迟确认定时器触发后，会发出一个被延迟的ACK，之后进入快速确认模式。

因为都等到超时了，本端还没有数据要一起发送，说明不处于pingpong模式。

[java]  view plain  copy

 

1. void tcp_delack_timer_handler (stuct sock *sk)  
2. {  
3.     struct tcp_sock *tp = tcp_sk(sk);  
4.     struct inet_connection_sock *icsk = inet_csk(sk);  
5.   
6.     sk_mem_reclaim_partial(sk);  
7.   
8.     /* 如果连接已关闭，或者延迟确认定时器并没有被启动，直接返回 */  
9.     if (sk->sk_state == TCP_CLOSE || ! (icsk->icsk_ack.pending & ICSK_ACK_TIMER))  
10.         goto out;  
11.   
12.     /* 如果还没有到超时时刻，则继续计时，直接返回 */  
13.     if (time_after(icsk->icsk_ack.timeout, jiffies)) {  
14.         sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);  
15.         goto out;  
16.     }  
17.   
18.     icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER; /* 去除延迟定时器的运行标志 */  
19.   
20.     /* 如果prequeue队列不为空，则处理其中的数据包 */  
21.     if (! skb_queue_empty(&tp->ucopy.prequeue)) {  
22.         struct sk_buff *skb;  
23.         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSCHEDULERFAILED);  
24.   
25.         /* 从prequeue队列中取出skb，并从队列中删除 */  
26.         while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)  
27.             sk_backlog_rcv(sk, skb); /* 调用tcp_v4_do_rcv()来处理 */  
28.   
29.         tp->ucopy.memory = 0; /* 清零prequeue队列消耗的内存 */  
30.     }  
31.   
32.     /* 如果有ACK需要发送 */  
33.     if (inet_csk_ack_scheduled(sk)) {  
34.         /* Delay ACK missed: inflate ATO. */  
35.         /* 在快速确认模式中，如果分配skb失败，就无法发送ACK。 
36.          * 此时也会启动延迟确认定时器，超时时间设为200ms。 
37.          * 在这种情况下，如果再次发送失败，就要进行指数退避了。 
38.          */  
39.         if (! icsk->icsk_ack.pingpong) {  
40.             icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto); /* 超时时间的指数退避 */  
41.   
42.         } else { /* 如果是处于延迟确认模式 */  
43.             icsk->icsk_ack.pingpong = 0; /* 切换到快速确认模式 */  
44.             icsk->icsk_ack.ato = TCP_ATO_MIN; /* 重置ATO */  
45.         }  
46.   
47.         tcp_send_ack(sk); /* 发送ACK */  
48.         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKS);  
49.     }  
50.   
51. out:  
52.     if (sk_under_memory_pressure(sk))  
53.         sk_mem_reclaim(sk);  
54. }  

(3) 删除

成功发送ACK时，会删除延迟确认定时器。

tcp_transmit_skb

    |--> tcp_event_ack_sent

               |--> inet_csk_clear_xmit_timer

[java]  view plain  copy

 

1. static inline void inet_csk_clear_xmit_timer (struct sock *sk, const int what)  
2. {  
3.     struct inet_connection_sock *icsk = inet_csk(sk);  
4.   
5.     if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {  
6.         icsk->icsk_pending = 0;  
7.   
8. #ifdef INET_CSK_CLEAR_TIMERS  
9.         sk_stop_timer(sk, &icsk->icsk_retransmit_timer);  
10. #endif  
11.     } else if (what == ICSK_TIME_DACK) {  
12.         icsk->icsk_ack.blocked = icsk->icsk_ack.pending = 0; /* 清除ACK的发送状态标志 */  
13.   
14. #ifdef INET_CSK_CLEAR_TIMERS  
15.         sk_stop_timer(sk, &icsk->icsk_delack_timer); /* 删除延迟确认定时器 */  
16. #endif  
17.     }  
18.   
19. #ifdef INET_CSK_DEBUG  
20.     else {  
21.         pr_debug("%s", inet_csk_timer_bug_msg);  
22.     }  
23. #endif  
24. }  

 

延迟ACK的发送

 

当接收到数据包后，会检查是否需要发送ACK，如果需要的话是进行快速确认还是延迟确认。

在无法快速确认的情况下，就使用延迟确认。

__tcp_ack_snd_check

    |--> tcp_send_delayed_ack

 

如果已经启动了延迟确认定时器，并符合以下任一条件就马上发送ACK：

1. 上次延迟确认定时器触发时，因为socket被用户进程锁住而无法发送ACK。

2. 接收到数据包时，延迟确认定时器已经快要超时了(离现在不到1/4 * ato)。

 

如果之前没有启动延迟确认定时器，就设置ACK需要发送标志、延迟确认定时器启动标志，

并启动延迟确认定时器。在延迟确认定时器计时期间，如果有捎带确认发生，就会清除ACK的发送状态标志，

删除延迟确认定时器。否则延迟确认定时器会发生超时，然后在超时处理函数中发送纯ACK，之后会进入快速

确认模式。

[java]  view plain  copy

 

1. void tcp_send_delayed_ack (struct sock *sk)  
2. {  
3.     struct inet_connection_sock *icsk = inet_csk(sk);  
4.     int ato = icsk->icsk_ack.ato;  
5.     unsigned long timeout;  
6.   
7.     /* 设置ato的上限可能为： 
8.      * 1. 500ms 
9.      * 2. 200ms，如果处于延迟确认模式，或者处于快速确认模式且收到过小包 
10.      * 3. RTT，如果有RTT采样 
11.       */  
12.     if (ato > TCP_DELACK_MIN) {  
13.         const struct tcp_sock *tp = tcp_sk(sk);  
14.         int max_ato = HZ / 2; /* 500ms */  
15.   
16.         /* 如果处于延迟确认模式，或者处于快速确认模式且设置了ICSK_ACK_PUSHED标志 */  
17.         if (icsk->icsk_ack.pingpong || (icsk->icsk_ack.pending & ICSK_ACK_PUSHED))  
18.             max_ato = TCP_DELACK_MAX; /* 200ms */  
19.   
20.         /* Slow path, intersegment interval is high. */  
21.          
22.         /* If some rtt estimate is known, use it to bound delayed ack. 
23.          * Do not use inet_csk(sk)->icsk_rto here, use results of rtt measurements directly. 
24.          */  
25.         /* 如果有RTT采样，使用RTT来作为ato的最大值 */  
26.         if (tp->srtt_us) {  
27.             int rtt = max_t(int, usecs_to_jiffies(tp->srtt_us >> 3), TCP_DELACK_MIN);  
28.             if (rtt < max_ato)  
29.                 max_ato = rtt;  
30.         }  
31.          
32.         ato = min(ato, max_ato); /* ato不能超过最大值 */  
33.     }  
34.    
35.     /* Stay within the limit we were given */  
36.     timeout = jiffies + ato; /* 延迟ACK的超时时刻 */  
37.   
38.     /* Use new timeout only if there wasn't a older one earlier. */  
39.     /* 如果之前已经启动了延迟确认定时器了 */  
40.     if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {  
41.         /* If delack timer was blocked or is about to expire, send ACK now. 
42.          * 如果之前延迟确认定时器触发时，因为socket被用户进程锁住而无法发送ACK，那么现在马上发送。 
43.          * 如果接收到数据报时，延迟确认定时器已经快要超时了(离现在不到1/4 * ato)，那么马上发送ACK。 
44.          */  
45.         if (icsk->icsk_ack.blocked || time_before_eq(icsk->icsk_ack.timeout, jiffies + (ato >> 2))) {  
46.             tcp_send_ack(sk); /* 发送ACK */  
47.             return;  
48.         }  
49.   
50.         /* 如果新的超时时间，比之前设定的超时时间晚，那么使用之前设定的超时时间 */  
51.         if (! time_before(timeout, icsk->icsk_ack.timeout))  
52.             timeout = icsk->icsk_ack.timeout;  
53.     }  
54.    
55.     /* 如果还没有启动延迟确认定时器 */  
56.     icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER; /* 设置ACK需要发送标志、定时器启动标志 */  
57.     icsk->icsk_ack.timeout = timeout; /* 超时时间 */  
58.     sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout); /* 启动延迟确认定时器 */  
59. }  
60.    
61. /* minimal time to delay before sending an ACK. */  
62. # define TCP_DELACK_MIN ((unsigned) (HZ/25))  
63. /* maximal time to delay before sending an ACK */  
64. # define TCP_DELACK_MAX ((unsigned) (HZ/5))