TCP三次握手超时处理

以TCP服务端为例,在接收到客户端的第一个SYN报文之后,负责处理的tcp_conn_request函数,判断如果不使用syn cookie处理机制,将正常相应SYN+ACK报文,并且在此之前,启用TCP的定时器,负责SYN+ACK的超时重传。

int tcp_conn_request(struct request_sock_ops *rsk_ops, ...)
{
    if (fastopen_sk) {
    } else {
        tcp_rsk(req)->tfo_listener = false;
        if (!want_cookie)
            inet_csk_reqsk_queue_hash_add(sk, req, tcp_timeout_init((struct sock *)req));
        af_ops->send_synack(sk, dst, &fl, req, &foc, !want_cookie ? TCP_SYNACK_NORMAL : TCP_SYNACK_COOKIE);
    }
}

超时时间由函数tcp_timeout_init计算得到。默认情况下设置为宏TCP_TIMEOUT_INIT的值,1秒钟(1*HZ),即RFC6298规定的初始RTO值(重传超时时间)。

#define TCP_TIMEOUT_INIT ((unsigned)(1*HZ)) /* RFC6298 2.1 initial RTO value    */

定时器的超时处理函数为reqsk_timer_handler,启动之前,将重传次数和超时次数清零。

static void reqsk_queue_hash_req(struct request_sock *req, unsigned long timeout)
{
    req->num_retrans = 0;
    req->num_timeout = 0;
    req->sk = NULL;
    
    timer_setup(&req->rsk_timer, reqsk_timer_handler, TIMER_PINNED);
    mod_timer(&req->rsk_timer, jiffies + timeout);
}

SYN+ACK重传次数默认初始化为宏TCP_SYNACK_RETRIES(5),可通过proc文件修改此值。按照RTO为1秒计算,重传5此需要耗时31秒钟,最后一次超时经发生在63秒之后。

static int __net_init tcp_sk_init(struct net *net)
{
    net->ipv4.sysctl_tcp_synack_retries = TCP_SYNACK_RETRIES;
}

$ cat /proc/sys/net/ipv4/tcp_synack_retries
5


另外,用户层可通过setsockopt系统调用指定重传次数。最大可设定的重传次数由宏MAX_TCP_SYNCNT定义,为127次。

static int do_tcp_setsockopt(struct sock *sk, int level, int optname, ...)
{ 
    switch (optname) {
    case TCP_SYNCNT:
        if (val < 1 || val > MAX_TCP_SYNCNT)
            err = -EINVAL;
        else
            icsk->icsk_syn_retries = val;
        break;
    }
}

一旦超时发生,执行reqsk_timer_handler函数。出现超时情况可能会是由于服务端发送SYN+ACK响应报文丢失;客户端回复的ACK报文丢失;RTT(Round Trip Timeout)时间太长超过定时器的1秒钟;又或者是客户端根本就没有进行相应(如SYN泛洪攻击)。
 
在进行处理之前,需要确定重传次数的阈值。默认情况下,如果用户未通过setsockopt设置icsk_syn_retries次数,重传次数阈值就等于sysctl_tcp_synack_retries的值(默认为5次)。如果当前的请求套接口队列的长度小于规定的最大长度的一半(最大长度取值为8与sk_listener->sk_max_ack_backlog两者之中的较大值),重传次数阈值不变。反之,就要对thresh值再做处理,当然要保证thresh的值大于2(至少重传一次),如果队列中还在等待客户端的第三个ACK报文并且没有超时的请求套接口(young状态)的数量大于当前队列长度的一半,说明队列尚在健康状态,不对thresh做修改,否则,递减thresh的值,直到达到上述的健康状态。队列中不在young状态的请求套接口,意指已经重传过SYN+ACK的套接口。

static void reqsk_timer_handler(struct timer_list *t)
{
    max_retries = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_synack_retries;
    thresh = max_retries;
 
    qlen = reqsk_queue_len(queue);
    if ((qlen << 1) > max(8U, sk_listener->sk_max_ack_backlog)) {
        int young = reqsk_queue_len_young(queue) << 1;

        while (thresh > 2) {
            if (qlen < young)
                break;
            thresh--;
            young <<= 1;
        }
    }
    syn_ack_recalc(req, thresh, max_retries, defer_accept, &expire, &resend);
    req->rsk_ops->syn_ack_timeout(req);
}

函数syn_ack_recalc设置两个参数,分别是总的超时时间是否已超过(expire)和是否重传SYN+ACK数据包(resend)。不考虑延时accept的情况下,实现逻辑比较简单,超时次数已经大于限定的阈值,说明已经超时,需要销毁此请求套接口;另外,设置resend变量,重传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)
{
    if (!rskq_defer_accept) {
        *expire = req->num_timeout >= thresh;
        *resend = 1;
        return;
    }
} 

另外,超时处理函数会调用特定的面向连接的套接口的超时函数,对于TCP来说,其为tcp_syn_ack_timeout,其并没有实质性的处理逻辑,仅完成增加MIB的统计计数。对于DCCP而言,其为dccp_syn_ack_timeout函数。

struct request_sock_ops tcp_request_sock_ops __read_mostly = {
    .family     =   PF_INET,
	.rtx_syn_ack    =   tcp_rtx_synack,
    .syn_ack_timeout =  tcp_syn_ack_timeout,
};
void tcp_syn_ack_timeout(const struct request_sock *req)
{   
    struct net *net = read_pnet(&inet_rsk(req)->ireq_net);
    __NET_INC_STATS(net, LINUX_MIB_TCPTIMEOUTS);
}

接下来超时处理函数根据之前计算的条件变量,决定是否进行重传操作。注意此处,在重传之后要更新重传计数,如果是第一次重传,减少young的计数,表明队列中一个套接口不再处于young状态。

static void reqsk_timer_handler(struct timer_list *t)
{
    if (!expire &&
        (!resend ||
         !inet_rtx_syn_ack(sk_listener, req) ||
         inet_rsk(req)->acked)) {
        unsigned long timeo;

        if (req->num_timeout++ == 0)
            atomic_dec(&queue->young);
        timeo = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX);
        mod_timer(&req->rsk_timer, jiffies + timeo);
        return;
    }
}

具体由tcp_rtx_synack函数完成TCP的SYN+ACK报文的重传。成功之后,增加重传次数的计数值(num_retrans)。

int inet_rtx_syn_ack(const struct sock *parent, struct request_sock *req)
{
    int err = req->rsk_ops->rtx_syn_ack(parent, req);
    if (!err)
        req->num_retrans++;
}

下次超时时间的计算,为初始时间TCP_TIMEOUT_INIT(1秒钟),左移num_timeout位,最大超时时间为TCP_RTO_MAX(120秒),可见超时时间以2的指数级增长。

    timeo = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX);

RTT的更新

在接收到客户端的SYN报文后,记录下当前的时间。

static void tcp_openreq_init(struct request_sock *req, ...)
{
    struct inet_request_sock *ireq = inet_rsk(req);

    tcp_rsk(req)->snt_synack = tcp_clock_us();
}

在接收到TCP三次握手的第三个ACK报文之后,计算网络的RTT值。如果中间有重传发生(num_retrans不为零),不计算RTT值。否则使用当前时间由函数tcp_clock_us得到的值减去snt_sysack之前记录的值,结果为RTT,单位为微秒。

void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
{      
    struct rate_sample rs;
    long rtt_us = -1L;
   
    if (req && !req->num_retrans && tcp_rsk(req)->snt_synack)
        rtt_us = tcp_stamp_us_delta(tcp_clock_us(), tcp_rsk(req)->snt_synack);

    tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us, &rs);
} 

延时ACCEPT功能

用户层可通过setsockopt设置延时accept功能。

static int do_tcp_setsockopt(struct sock *sk, int level,
        int optname, char __user *optval, unsigned int optlen)
{
    switch (optname) {
    case TCP_DEFER_ACCEPT:
        /* Translate value in seconds to number of retransmits */
        icsk->icsk_accept_queue.rskq_defer_accept = secs_to_retrans(val, TCP_TIMEOUT_INIT / HZ,  TCP_RTO_MAX / HZ);
        break;
	}
}

如果开启此功能,处理逻辑位于函数tcp_check_req中。如果仅仅是接收到客户端回复的第三个握手ACK报文,无数据,不进行处理,设置acked为1。反之如果接收到数据和ACK,进行正常处理,忽略延时accept功能。

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, struct request_sock *req, bool fastopen)
{
    /* While TCP_DEFER_ACCEPT is active, drop bare ACK. */
    if (req->num_timeout < inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
        TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {
        inet_rsk(req)->acked = 1;
        return NULL;
    }
}

这将导致触发SYN+ACK报文的重传处理函数,defer_accept与max_retries设为了相同的值。

static void reqsk_timer_handler(struct timer_list *t)
{
    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);
}

其中,expire和resend的计算逻辑变化如下,如果当前的超时次数大于阈值thresh,并且大于最大重传次数(即延时accept的次数),判定为超时;或者acked等于0(即未接收到单独的ACK报文)也判定为超时,其它情况下判定未超时。

对于重传resend,如果未接收到单独的ACK报文或者是已到延时accept的最后,设定resend为真,进行SYN+ACK的重传,保证还能接收到客户端的ACK或者数据,可将此请求套接口转换到established状态。

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)
{
    *expire = req->num_timeout >= thresh &&
          (!inet_rsk(req)->acked || req->num_timeout >= max_retries);
    
    *resend = !inet_rsk(req)->acked || req->num_timeout >= rskq_defer_accept - 1;
}

超时定时器清除

在正常接收到客户端的ACK报文之后,在tcp_check_req函数中,调用inet_csk_complete_hashdance函数,最终由reqsk_queue_unlink删除SYN+ACK超时定时器。

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, struct request_sock *req, bool fastopen)
{
    return inet_csk_complete_hashdance(sk, child, req, own_req);
}
struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child,
                     struct request_sock *req, bool own_req)
{
    if (own_req) {
        inet_csk_reqsk_queue_drop(sk, req);
        reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req);
    }
}
void inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req)
{
    if (reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req)) {

    }
}
static bool reqsk_queue_unlink(struct request_sock_queue *queue, struct request_sock *req)
{
    if (timer_pending(&req->rsk_timer) && del_timer_sync(&req->rsk_timer))
        reqsk_put(req);
}

 

内核版本 Linux-4.15

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页