TCP定时器的回调函数中，为何存在检查定时时间是否超时的代码？

linux_26

个人认为，定时器触发后，应该被定时的对象肯定是超时了，为何存在检查定时时间没有超时的代码，不太理解。
比如在重传定时器到点时，调用的 tcp_write_timer（）中有下面代码
440           if (time_after(tp->timeout, jiffies)) {
441                   if (!mod_timer(&tp->retransmit_timer, tp->timeout))
442                           sock_hold(sk);
443                   goto out;
444           }
在tcp_delack_timer（）中，也存在如下代码：
231           if (time_after(tp->ack.timeout, jiffies)) {
232                   if (!mod_timer(&tp->delack_timer, tp->ack.timeout))
233                           sock_hold(sk);
234                   goto out;
235           }

瀚海书香

回复 1# linux_26

个人认为，定时器触发后，应该被定时的对象肯定是超时了，为何存在检查定时时间没有超时的代码，不太理解。
比如在重传定时器到点时，调用的 tcp_write_timer（）中有下面代码
440           if (time_after(tp->timeout, jiffies)) {
441                   if (!mod_timer(&tp->retransmit_timer, tp->timeout))
442                           sock_hold(sk);
443                   goto out;
444           }
在tcp_delack_timer（）中，也存在如下代码：
231           if (time_after(tp->ack.timeout, jiffies)) {
232                   if (!mod_timer(&tp->delack_timer, tp->ack.timeout))
233                           sock_hold(sk);
234                   goto out;
235           }

在家里没有代码，只能从在线代码猜测一下，这个与timer的关系不大，应该结合代码所处的语境有关系。以tcp_delack_timer()为例：

1. static void tcp_delack_timer(unsigned long data)
   
2. 209 {
   
3. 210         struct sock *sk = (struct sock *)data;
   
4. 211         struct tcp_sock *tp = tcp_sk(sk);
   
5. 212         struct inet_connection_sock *icsk = inet_csk(sk);
   
6. 213
   
7. 214         bh_lock_sock(sk);
   
8. 215         if (sock_owned_by_user(sk)) {
   
9. 216                 /* Try again later. */
   
10. 217                 icsk->icsk_ack.blocked = 1;
    
11. 218                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED);
    
12. 219                 sk_reset_timer(sk, &icsk->icsk_delack_timer, jiffies + TCP_DELACK_MIN);
    
13. 220                 goto out_unlock;
    
14. 221         }
    
15. 222
    
16. 223         sk_mem_reclaim_partial(sk);
    
17. 224
    
18. 225         if (sk->sk_state == TCP_CLOSE || !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
    
19. 226                 goto out;
    
20. 227
    
21. 228         if (time_after(icsk->icsk_ack.timeout, jiffies)) {
    
22. 229                 sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
    
23. 230                 goto out;
    
24. 231         }

复制代码

假设场景为：
1. timer触发，进入219行，重置timer的超时时间为jiffies+TCP_DELACK_MIN，返回
2. 在这个过程中另一个路径修改了icsk->icsk_ack.timeout 要大于jiffies+TCP_DELACK_MIN，尚没有触发sk_reset_timer
3.timer到期运行，此时的icsk->icsk_ack.timeout > jiffies.
   

henrystark

回复 2# 瀚海书香

最近也在看这一段代码，有些疑问不大清楚：
1.在tcp相关的源代码里，没有看到tcp主流程显式调用tcp_delack_timer，但这个函数确实起作用了。
2.tcp_output.c中有tcp_send_delayed_ack函数，也判断是否超时，如果到了发送时间，就发送ack，这一点很好理解。但是，如果没有达到发送时间，就需要等待定时器。但是它的逻辑也没有显式调用delack_timer，那么，等待定时器这个过程如何实现？
3.delack_timer是一个“回调”函数，这个“回调”体现在哪里？
4.我在源代码里面使用过dump_stack(),结果显示delack_timer的调用过程难以理解
   
另外，delack_timer这个函数有个有趣的地方：它可以直接发送ack。

linux_26

回复 3# henrystark

所谓定时器 回调函数的整个工作流程是这样的：
1，初始化某个定时器。
如：TCP中初始化delack定时器如下。这样就向内核申请了一个定时器。
void tcp_init_xmit_timers(struct sock *sk)
{
...
        init_timer(&tp->delack_timer);
        tp->delack_timer.function=&tcp_delack_timer;
        tp->delack_timer.data = (unsigned long) sk;
        tp->ack.pending = 0;
...
}

2，某个事件触发了启动定时器，比如在下述函数中，发送ack的时候发现不用立即发送，延迟一会发送更好，于是启动定时：
void tcp_send_ack(struct sock *sk)
{
tcp_reset_xmit_timer(sk, TCP_TIME_DACK, TCP_DELACK_MAX);//启动定时器
}

3，等待定时器设置的时间到点后，中断就会导致调用定时器设置的函数被调用，即 tcp_delack_timer。而该函数的功能就是发送ack给对端。
tp->delack_timer.function=&tcp_delack_timer;
   

henrystark

回复 4# linux_26
3.2.18的逻辑稍微有些不同，看这段代码，设置delack_timer的是最后一句sk_reset_timer吗？怎么看都不像。。。

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.         if (ato > TCP_DELACK_MIN) {
   
8.                 const struct tcp_sock *tp = tcp_sk(sk);
   
9.                 int max_ato = HZ / 2;
   
10. 
    
11.                 if (icsk->icsk_ack.pingpong ||
    
12.                     (icsk->icsk_ack.pending & ICSK_ACK_PUSHED))
    
13.                         max_ato = TCP_DELACK_MAX;
    
14. 
    
15.                 /* Slow path, intersegment interval is "high". */
    
16. 
    
17.                 /* If some rtt estimate is known, use it to bound delayed ack.
    
18.                  * Do not use inet_csk(sk)->icsk_rto here, use results of rtt measurements
    
19.                  * directly.
    
20.                  */
    
21.                 if (tp->srtt) {
    
22.                         int rtt = max(tp->srtt >> 3, TCP_DELACK_MIN);
    
23. 
    
24.                         if (rtt < max_ato)
    
25.                                 max_ato = rtt;
    
26.                 }
    
27. 
    
28.                 ato = min(ato, max_ato);
    
29.         }
    
30. 
    
31.         /* Stay within the limit we were given */
    
32.         timeout = jiffies + ato;
    
33. 
    
34.         /* Use new timeout only if there wasn't a older one earlier. */
    
35.         if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
    
36.                 /* If delack timer was blocked or is about to expire,
    
37.                  * send ACK now.
    
38.                  */
    
39.                 if (icsk->icsk_ack.blocked ||
    
40.                     time_before_eq(icsk->icsk_ack.timeout, jiffies + (ato >> 2))) {
    
41.                         tcp_send_ack(sk);
    
42.                         return;
    
43.                 }
    
44. 
    
45.                 if (!time_before(timeout, icsk->icsk_ack.timeout))
    
46.                         timeout = icsk->icsk_ack.timeout;
    
47.         }
    
48.         icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
    
49.         icsk->icsk_ack.timeout = timeout;
    
50.         sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
    
51. }
    

复制代码

1. void sk_reset_timer(struct sock *sk, struct timer_list* timer,
   
2.                     unsigned long expires)
   
3. {
   
4.         if (!mod_timer(timer, expires))
   
5.                 sock_hold(sk);
   
6. }

复制代码