TCP定时器 之 连接建立定时器

当服务器收到新的syn请求，会回复syn+ack给请求端，若某时间内未收到请求端回复的ack，新建连接定时器超时执行回调，重传syn+ack，当超时超过固定次数时，该连接中止；本文主要分析其初始化流程，具体的建立连接和超时重传流程在后续的文章中进行详细讨论；

request_sock结构中的rsk_timer成员为新建连接计时器；

 /* struct request_sock - mini sock to represent a connection request
  */
 struct request_sock {
     struct sock_common        __req_common;
         /* 省略了一些字段 */
     struct timer_list        rsk_timer;
     const struct request_sock_ops    *rsk_ops;
     struct sock            *sk;
     /* 省略了一些字段 */
 };

函数调用关系如下，其中tcp_rcv_state_process中判断标记，如果发生是设置了syn请求标记，则进入新建连接流程，在tcp_conn_request中将会新建连接请求控制块，用于跟踪完成三次握手；

 /**
  *tcp_v4_rcv
  * |-->tcp_v4_do_rcv
  *      |-->tcp_rcv_state_process /* 这里如果是syn请求，则调用下面的conn_request函数 */
  *             |-->tcp_v4_conn_request
  *                  |-->tcp_conn_request /* 这里新建请求控制块 */
  *                      |-->inet_csk_reqsk_queue_hash_add
  *                           |-->reqsk_queue_hash_req
  */

启动定时器：

reqsk_queue_hash_req函数进行连接请求定时器的设定，将req->rsk_timer的超时回调设置为reqsk_timer_handler，reqsk_timer_handler调用inet_rtx_syn_ack进行syn+ack的重传；

其中超时时间初始化为timeout=TCP_TIMEOUT_INIT，为1HZ；timeout会随着重传的次数不断变化timeo = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX);

 static void reqsk_queue_hash_req(struct request_sock *req,
                  unsigned long timeout)
 {
     req->num_retrans = ;
     req->num_timeout = ;
     req->sk = NULL;

     /* 添加定时器 */
     setup_pinned_timer(&req->rsk_timer, reqsk_timer_handler,
                 (unsigned long)req);
     mod_timer(&req->rsk_timer, jiffies + timeout);

     inet_ehash_insert(req_to_sk(req), NULL);
     /* before letting lookups find us, make sure all req fields
      * are committed to memory and refcnt initialized.
      */
     smp_wmb();
     atomic_set(&req->rsk_refcnt,  + );
 }

定时器回调函数：

判断是否超时次数超过阈值，是否需要重传syn+ack，如果超时或者未收到ack情况下重传失败，则取消连接；函数中还包含了对refer_accept选项的处理；

 /* 新建连接定时器超时处理 */
 static void reqsk_timer_handler(unsigned long data)
 {
     struct request_sock *req = (struct request_sock *)data;
     struct sock *sk_listener = req->rsk_listener;
     struct net *net = sock_net(sk_listener);
     struct inet_connection_sock *icsk = inet_csk(sk_listener);
     struct request_sock_queue *queue = &icsk->icsk_accept_queue;
     int qlen, expire = , resend = ;
     int max_retries, thresh;
     u8 defer_accept;

     /* 不是LISTEN状态 */
     if (sk_state_load(sk_listener) != TCP_LISTEN)
         goto drop;

     /* 阈值设置为允许的最大重传数 */
     max_retries = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_synack_retries;
     thresh = max_retries;
     /* Normally all the openreqs are young and become mature
      * (i.e. converted to established socket) for first timeout.
      * If synack was not acknowledged for 1 second, it means
      * one of the following things: synack was lost, ack was lost,
      * rtt is high or nobody planned to ack (i.e. synflood).
      * When server is a bit loaded, queue is populated with old
      * open requests, reducing effective size of queue.
      * When server is well loaded, queue size reduces to zero
      * after several minutes of work. It is not synflood,
      * it is normal operation. The solution is pruning
      * too old entries overriding normal timeout, when
      * situation becomes dangerous.
      *
      * Essentially, we reserve half of room for young
      * embrions; and abort old ones without pity, if old
      * ones are about to clog our table.
      */

     /* 获取accept队列长度 */
     qlen = reqsk_queue_len(queue);

     /* 请求accept队列数> 最大未完成连接数的一半 */
     if ((qlen << ) > max(8U, sk_listener->sk_max_ack_backlog)) {

         /* 没有重传ack的请求控制块数 */
         int young = reqsk_queue_len_young(queue) << ;

         /* 可以看出年轻的数量越多，则允许重传次数越多 */
         while (thresh > ) {

             // 没重传的数量> 队列长度的(1/2, 1/4,1/8...)
             if (qlen < young)
                 break;

             /* 阈值减1 */
             thresh--;

             /* 扩大young */
             young <<= ;
         }
     }
     /* 设置了TCP_DEFER_ACCEPT，则使用之 */
     defer_accept = READ_ONCE(queue->rskq_defer_accept);
     if (defer_accept)
         max_retries = defer_accept;

     /* 超时和是否重传判断 */
     syn_ack_recalc(req, thresh, max_retries, defer_accept,
                &expire, &resend);
     /* 统计超时次数 */
     req->rsk_ops->syn_ack_timeout(req);
     if (!expire && /* 未超时 */
         (!resend || /* 不需要重传 */
          !inet_rtx_syn_ack(sk_listener, req) || /* 重传成功 */
          inet_rsk(req)->acked)) { /* 收到ack了，但是未建立连接(defer_accept，其他情况?) */
         unsigned long timeo;

         /* 该请求尚未重传过，则将未重传块-1 */
         /* 超时次数+ 1 */
         if (req->num_timeout++ == )
             atomic_dec(&queue->young);

         /* 重新设定超时时间为上次时间* 2，与pto_max取最小值 */
         timeo = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX);
         mod_timer(&req->rsk_timer, jiffies + timeo);
         return;
     }

     /* 取消连接，从链表移除请求控制块 */
 drop:
     inet_csk_reqsk_queue_drop_and_put(sk_listener, req);
 }

判断是否已经超时，或者是否需要重传syn+ack；

 /* Decide when to expire the request and when to resend SYN-ACK */
 /* 判断是否超时，是否重传syn+ack */
 static inline void syn_ack_recalc(struct request_sock *req, const int thresh,
                   const int max_retries,
                   const u8 rskq_defer_accept,
                   int *expire, int *resend)
 {
     /* 无defer_accept选项 */
     if (!rskq_defer_accept) {
         /* 超时次数> 重传阈值则超时 */
         *expire = req->num_timeout >= thresh;

         /* 需要重传 */
         *resend = ;
         return;
     }

     /* 以下设置了defer_accept */

     /* 超时次数> 重传阈值&&  (未收到ack || 超时次数>= 最大重传数)，则超时 */
     /* 已经收到ack的情况下，超时次数达到defer_accept限制 */
     *expire = req->num_timeout >= thresh &&
           (!inet_rsk(req)->acked || req->num_timeout >= max_retries);
     /*
      * Do not resend while waiting for data after ACK,
      * start to resend on end of deferring period to give
      * last chance for data or ACK to create established socket.
      */

     /* 未收到ack || 收到ack，但是超时次数达到了defer_accept限制-1，需要重传*/
     /* 给了设置defer_accept选项情况下一次机会 */
     *resend = !inet_rsk(req)->acked ||
           req->num_timeout >= rskq_defer_accept - ;
 }