TCP定时器 之 保活定时器

在用户进程启用了保活定时器的情况下，如果连接超过空闲时间没有数据交互，则保活定时器超时，向对端发送保活探测包，若(1)收到回复则说明对端工作正常，重置定时器等下下次达到空闲时间；(2) 收到其他回复，则确定对端已重启，关闭连接；(3) 超过探测次数仍未得到回复，则认为对端主机已经崩溃，关闭连接；

启动定时器：

用户进程可以通过socket的SO_KEEPALIVE选项来开启或关闭保活定时器探测，TCP最终会调用tcp_set_keepalive来实现保活定期的开启与关闭；

 int sock_setsockopt(struct socket *sock, int level, int optname,
             char __user *optval, unsigned int optlen)
 {
     struct sock *sk = sock->sk;
     int val;
     int valbool;
     struct linger ling;
     int ret = ;

     valbool = val ?  : ;

     lock_sock(sk);

     switch (optname) {
     case SO_KEEPALIVE:
         if (sk->sk_prot->keepalive)
             sk->sk_prot->keepalive(sk, valbool);
         sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
         break;
         }
 }

 struct proto tcp_prot = {
     .name            = "TCP",
         /* 省略部分字段 */
     .keepalive        = tcp_set_keepalive,
         /* 省略部分字段 */
 }

 void tcp_set_keepalive(struct sock *sk, int val)
 {
     if (( << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))
         return;

     if (val && !sock_flag(sk, SOCK_KEEPOPEN))
         inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk)));
     else if (!val)
         inet_csk_delete_keepalive_timer(sk);
 }

定时器回调函数：

tcp_keepalive_timer函数为保活定时器和FIN_WAIT_2定时器共用，我们这里只关注保活部分；函数执行必要的状态检查，之后对空闲时间和配置空闲时间阈值进行判断，在超过阈值的情况下，若未超过探测次数和用户配置超时时间，则发送探测包，否则关闭连接；

 static void tcp_keepalive_timer (unsigned long data)
 {
     struct sock *sk = (struct sock *) data;
     struct inet_connection_sock *icsk = inet_csk(sk);
     struct tcp_sock *tp = tcp_sk(sk);
     u32 elapsed;

     /* Only process if socket is not in use. */
     bh_lock_sock(sk);

     /* 传输控制块被用户进程锁定 */
     if (sock_owned_by_user(sk)) {
         /* Try again later. */
         /* 重置定时器 */
         inet_csk_reset_keepalive_timer (sk, HZ/);
         goto out;
     }

     /* 连接处于LISTEN状态，退出 */
     if (sk->sk_state == TCP_LISTEN) {
         pr_err("Hmm... keepalive on a LISTEN ???\n");
         goto out;
     }

     /* 处于fin_wait2且socket即将销毁，用作FIN_WAIT_2定时器 */
     if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) {

         /* 停留在FIN_WAIT_2的停留时间>=0 */
         if (tp->linger2 >= ) {
             /* 获取在FIN_WAIT_2的剩余时间 */
             const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN;

             /* 有剩余时间则调用FIN_WAIT_2定时器 */
             if (tmo > ) {
                 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
                 goto out;
             }
         }

         /* 发送rst */
         tcp_send_active_reset(sk, GFP_ATOMIC);
         goto death;
     }

     /* 未启用保活|| 状态处于关闭或者发送syn状态，退出 */
     if (!sock_flag(sk, SOCK_KEEPOPEN) ||
         (( << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)))
         goto out;

     /* 获取设定的连接空闲时间 */
     elapsed = keepalive_time_when(tp);

     /* It is alive without keepalive 8) */
     /* 有发送未确认的包或者还有待发送的包，不是空闲状态 */
     if (tp->packets_out || tcp_send_head(sk))
         goto resched;

     /* 从上次收到包到现在的空闲时间 */
     elapsed = keepalive_time_elapsed(tp);

     /* 连接空闲时间超过设定值 */
     if (elapsed >= keepalive_time_when(tp)) {
         /* If the TCP_USER_TIMEOUT option is enabled, use that
          * to determine when to timeout instead.
          */
         /*
             设置了用户超时，空闲时间达到用户超时时间，已发送过探测
             未设置用户超时，探测次数达到了保活最大探测次数
             则发送rst关闭连接
         */
         if ((icsk->icsk_user_timeout !=  &&
             elapsed >= icsk->icsk_user_timeout &&
             icsk->icsk_probes_out > ) ||
             (icsk->icsk_user_timeout ==  &&
             icsk->icsk_probes_out >= keepalive_probes(tp))) {
             /* 发送rst */
             tcp_send_active_reset(sk, GFP_ATOMIC);

             /* 关闭连接 */
             tcp_write_err(sk);
             goto out;
         }

         /* 发送保活探测包 */
         if (tcp_write_wakeup(sk, LINUX_MIB_TCPKEEPALIVE) <= ) {
             /* 探测次数增加 */
             icsk->icsk_probes_out++;
             /* 下一次探测时间 */
             elapsed = keepalive_intvl_when(tp);
         } else {
             /* If keepalive was lost due to local congestion,
              * try harder.
              */
             /* 本地拥塞导致的失败，则重置定时器 */
             elapsed = TCP_RESOURCE_PROBE_INTERVAL;
         }
     } else {
         /* It is tp->rcv_tstamp + keepalive_time_when(tp) */
         /* 未超过空闲时间，则计算将要达到空闲的时间 */
         elapsed = keepalive_time_when(tp) - elapsed;
     }

     sk_mem_reclaim(sk);

 resched:
     /* 重置定时器 */
     inet_csk_reset_keepalive_timer (sk, elapsed);
     goto out;

 death:
     tcp_done(sk);

 out:
     bh_unlock_sock(sk);
     sock_put(sk);
 }