/* 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_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

  */

 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,  + );

 }

 /* 新建连接定时器超时处理 */

 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);

 }

 /* 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 - ;

 }