TCP的定时器系列 — 超时重传定时器（有图有代码有真相！！！）

最新推荐文章于 2024-02-12 19:54:44 发布

Sharp_UP

最新推荐文章于 2024-02-12 19:54:44 发布

阅读量1.5k

点赞数

分类专栏：网络

网络专栏收录该内容

18 篇文章 5 订阅

订阅专栏

转载

主要内容：TCP定时器概述，超时重传定时器、ER延迟定时器、PTO定时器的实现。

内核版本：3.15.2

我的博客：http://blog.csdn.net/zhangskd

Q：一条TCP连接会使用多少个定时器呢？

A：目前的答案是9个：

超时重传定时器，持续定时器，ER延迟定时器，PTO定时器，ACK延迟定时器，

SYNACK定时器，保活定时器，FIN_WAIT2定时器，TIME_WAIT定时器。

数据结构

几种定时器的标识：

#define ICSK_TIME_RETRANS 1 /* Retransmit timer */

#define ICSK_TIME_DACK 2 /* Delayed ack timer */

#define ICSK_TIME_PROBE0 3 /* Zero window probe timer */

#define ICSK_TIME_EARLY_RETRANS 4 /* Early retransmit timer */

#define ICSK_TIME_LOSS_PROBE 5 /* Tail loss probe timer */

上述5种定时器分别为：超时重传定时器、ACK延迟定时器、持续定时器、ER延迟定时器、PTO定时器。

另外还有保活定时器、FIN_WAIT2定时器、TIME_WAIT定时器、SYNACK定时器。

虽然定义了9个定时器，但是内核中只用了4个实例(timer_list)，所以有些定时器是共用一个实例的。

这4个实例分别是：

icsk->icsk_retransmit_timer：超时重传定时器、持续定时器、ER延迟定时器、PTO定时器。

icsk->icsk_delack_timer：ACK延迟定时器。

sk->sk_timer：保活定时器，SYNACK定时器，FIN_WAIT2定时器。

death_row->tw_timer：TIME_WAIT定时器。

创建和删除

(1) 定时器的创建

tcp_v4_init_sock

|-> tcp_init_sock

|-> tcp_init_xmit_timers

|-> inet_csk_init_xmit_timers

在初始化连接时，设置三个定时器实例的处理函数：

icsk->icsk_retransmit_timer的处理函数为tcp_write_timer()

icsk->icsk_delack_timer的处理函数为tcp_delack_timer()

sk->sk_timer的处理函数为tcp_keepalive_timer()

void tcp_init_xmit_timers(struct sock *sk)
{
    inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer, &tcp_keepalive_timer);
}

/*
 * Using different timers for retransmit, delayed acks and probes.
 * We may wish use just one timer maintaining a list of expire jiffies to optimize.
 */

void inet_csk_init_xmit_timers(struct sock *sk, 
                      void (*retransmit_handler) (unsigned long),
                      void (*delack_handler) (unsigned long),
                      void (*keepalive_handler) (unsigned long))
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    setup_timer(&icsk->icsk_retransmit_timer, retransmit_handler, (unsigned long)sk);
    setup_timer(&icsk->icsk_delack_timer, delack_timer, (unsigned long)sk);
    setup_timer(&sk->sk_timer, keepalive_handler, (unsigned long)sk);
    icsk->icsk_pending = icsk->icsk_ack.pending = 0;
}

(2) 定时器的删除

tcp_done

tcp_disconnect

tcp_v4_destroy_sock

|-> tcp_clear_xmit_timers

|-> inet_csk_clear_xmit_timers

void inet_csk_clear_xmit_timers(struct sock *sk)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    icsk->icsk_pending = icsk->icsk_ack.pending = icsk->icsk_ack.blocked = 0;
    sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
    sk_stop_timer(sk, &icsk->icsk_delack_timer);
    sk_stop_timer(sk, &sk->sk_timer);
}

激活

icsk->icsk_retransmit_timer和icsk->icsk_delack_timer的激活函数为inet_csk_reset_xmit_timer()，

共负责了5个定时器的激活工作。

/*
 * Reset the retransmissiion timer
 */
static inline void inet_csk_reset_xmit_timer(struct sock *sk, const int what,
                                            unsigned long when,
                                            const unsigned long max_when)
{
    struct inet_connection_sock *icsk = inet_csk(sk);

    if (when > max_when) {
#ifdef INET_CSK_DEBUG
        pr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",
                    sk, what, when, current_text_addr());
#endif
        when = max_when;
    }
    if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0 || 
        what == ICSK_TIME_EARLY_RETRANS || what == ICSK_TIME_LOSS_PROBE) {
        icsk->icsk_pending = what;
        icsk->icsk_timeout = jiffies + when; /*数据包超时时刻*/
        sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
    } else if (what == ICSK_TIME_DACK) {
        icsk->icsk_ack.pending |= ICSK_ACK_TIMER;
        icsk->icsk_ack.timeout = jiffies + when; /*Delay ACK定时器超时时刻*/
        sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
    }
#ifdef INET_CSK_DEBUG
    else {
        pr_debug("%s", inet_csk_timer_bug_msg);
    }  
#endif     
}

其中，超时重传定时器(ICSK_TIME_RETRANS)在以下几种情况下会被激活：

1. 发现对端把保存在接收缓冲区的SACK段丢弃时。

2. 发送一个数据段时，发现之前网络中不存在发送且未确认的段。

之后每当收到确认了新数据段的ACK，则重置定时器。

3. 发送SYN包后。

4. 一些特殊情况。

超时处理函数

当icsk->icsk_retransmit_timer超时后，会调用其处理函数tcp_write_timer()进行处理。

staic void tcp_write_timer(unsigned long data)
{
    struct sock *sk = (struct sock *)data;
    bh_lock_sock(sk);

    if (! sock_owned_by_user(sk)) {  /* sk没被用户空间占用 */
        tcp_write_timer_handler(sk);

    } else { /* 否则先设置延迟标志，之后再处理 */
        /* delegate our work to tcp_release_cb() */
        if (! test_and_set_bit(TCP_WRITE_TIMER_DEFERRED, &tcp_sk(sk)->tsq_flags))
            sock_hold(sk);
    }

    bh_unlock_sock(sk);
    sock_put(sk);
}

icsk->icsk_retransmit_timer可同时作为：超时重传定时器、持续定时器、ER延迟定时器、PTO定时器，

所以需要判断是哪种定时器触发的，然后采取相应的处理措施。

void tcp_write_timer_handler(struct sock *sk)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    int event;

    /* 如果连接处于CLOSED状态，或者没有定时器在计时 */
    if (sk->sk_state == TCP_CLOSE || !icsk->icsk_pending)
        goto out;

    /* 如果定时器还没有超时，那么继续计时 */
    if (time_after(icsk->icsk_timeout, jiffies)) {
        sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
        goto out;
    }

    event = icsk->icsk_pending; /* 用于表明是哪种定时器 */
    switch(event) {
        case ICSK_TIME_EARLY_RETRANS: /* ER延迟定时器触发的 */
            tcp_resume_early_retransmit(sk); /* 进行early retransmit */
            break;

        case ICSK_TIME_LOSS_PROBE: /* PTO定时器触发的 */
            tcp_send_loss_probe(sk); /* 发送TLP探测包 */
            break;

        case ICSK_TIME_RETRANS: /* 超时重传定时器触发的 */
            icsk->icsk_pending = 0;
            tcp_retransmit_timer(sk);
            break;

        case ICSK_TIME_PROBE0: /* 持续定时器触发的 */
            icsk->icsk_pending = 0;
            tcp_probe_timer(sk);
            break;
    }

out:
    sk_mem_reclaim(sk);
}

如果是超时重传定时器触发的，就会调用tcp_retransmit_timer()进行处理。

void tcp_retransmit_timer(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);

    /* Fast Open特性相关，暂时不做分析 */
    if (tp->fastopen_rsk) {
        ...
    }

    /* 如果没有发送且未确认的数据段，没有等待哪来的超时，直接返回 */
    if (! tp->packets_out)
        goto out; 

    /* 如果发送队列为空，显然不合理 */
    WARN_ON(tcp_write_queue_empty(sk));

    /* 发生RTO超时表明数据包的确丢失了，所以不用再进行额外检测了 */
    tp->tlp_high_seq = 0;

    /* 如果对端通告窗口为0，sk不处于DEAD状态，TCP连接不处于三次握手 */
    /* Receiver dastardly shrinks window. Our retransmits become zero probes,
     * but we should not timeout this connection. If the socket is an orphan, time it out,
     * we cannot allow such beasts to hang infinitely.  
     */

    if (! tp->snd_wnd && ! sock_flag(sk, SOCK_DEAD) && 
        ! ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) {

        struct inet_sock *inet = inet_sk(sk);
        if (sk->sk_family == AF_INET) {
            LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("Peer %pI4:%u/ %u unexpectedly shrunk window %u:%u (repaired)\n",
                &inet->inet_daddr, ntohs(inet->inet_dport), inet->inet_num, tp->snd_una, tp->snd_nxt);
        }

#if IS_ENABLED(CONFIG_IPV6)
        /* IPv6的处理，此处省略 */
        ...
#endif

        /* 距离上次收到ACK的时间超过了最大超时时间，认为有错误发生了*/
        if (tcp_time_stamp - tp->rcv_tstamp > TCP_RTO_MAX) {
            tcp_write_err(sk); /* 报告错误，调用tcp_done终止连接 */
            goto out;
        }

        /* 进入Loss状态，标志丢失的数据段 */
        tcp_enter_loss(sk, 0);

        /* 重传发送队列的第一个数据段 */
        tcp_retransmit_skb(sk, tcp_write_queue_head(sk));

        __sk_dst_reset(sk); /* 更新路由缓存 */
        goto out_reset_timer;
    }

    /* 如果重传次数达到上限，报告错误并关闭套接口。
     * 如果资源使用达到上限，放弃本次重传。
     */
    if (tcp_write_timeout(sk))
        goto out;

    /* 刚进入超时重传 */
    if (icsk->icsk_retransmits == 0) {
        int mib_idx;

        /* Recovery状态中发生超时 */
        if (icsk->icsk_ca_state == TCP_CA_Recovery) {
            if (tcp_is_sack(tp))
                mib_idx = LINUX_MIB_TCPSACKRECOVERYFAIL;
            else
                mib_idx = LINUX_MIB_TCPRENORECOVERYFAIL;

        } else if (icsk->icsk_ca_state == TCP_CA_Loss) { /* Loss状态中发生超时 */    
            mib_idx = LINUX_MIB_TCPLOSSFAILURES;

        } else if (icsk->icsk_ca_state == TCP_CA_Disorder) || tp->sacked_out) {
            /* Disorder状态中发生超时 */
            if (tcp_is_sack(tp))
                mib_idx = LINUX_MIB_TCPSACKFAILURES;
            else
                mib_idx = LINUX_MIB_TCPRENOFAILURES;

        } else { /* Open状态或CWR状态中发生超时 */
            mib_idx = LINUX_MIB_TCPTIMEOUTS;
        }

        NET_INC_STATS_BH(sock_net(sk), mib_idx);
    }

    /* 进入Loss状态，标志丢失的数据段。
     * 值得注意的是不再使用tcp_enter_frto_loss()，FRTO机制被重写了。
     */
    tcp_enter_loss(sk, 0);

    /* 重传发送队列的第一个数据段，如果失败说明是本地拥塞，那么不进行指数退避 */
    if (tcp_retransmit_skb(sk, tcp_write_queue_head(sk)) > 0) {
        /* Retransmission failed because of local congestion, do not backoff. */
        if (! icsk->icsk_retransmits)
            icsk->icsk_retransmits = 1;
        inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL),
            TCP_RTO_MAX);
        goto out;
    }

    icsk->icsk_backoff++; /* 退避指数，采集到新的RTT样本时清零 */
    icsk->icsk_retransmits++; /* 超时次数，当确认了新数据时清零 */

out_reset_timer:
    /* 对于符合条件的Thin stream不使用指数退避，重复超时6次后除外（太惨了：） */
    if (sk->sk_state == TCP_ESTABLISHED && (tp->thin_lto || sysctl_tcp_thin_linear_timeouts) &&
        tcp_stream_is_thin(tp) && icsk->icsk_retransmits <= TCP_THIN_LINEAR_RETRIES) {
        icsk->icsk_backoff = 0;
        icsk->icsk_rto = min(__tcp_set_rto(tp), TCP_RTO_MAX); /* RTO保持原样 */

    } else { /* Use normal (exponential) backoff */
        icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX); /* RTO翻倍 */
    }

    /* 重置超时定时器，就是上文说的激活 */
    inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto, TCP_RTO_MAX);

    /* 当重传多次时，需要根据重传时间间隔，决定是否更新路由缓存  */
    if (retransmits_timed_out(sk, sysctl_tcp_retries1 + 1, 0, 0))
        __sk_dst_reset(sk);

out:;
}

连接的超时

很明显，重传不能无限的进行下去，当重传的次数超过设定的上限时，就会判定连接超时，关闭该连接。

此后相应的socket函数，比如connect和send，就会返回-1，errno设为ETIMEDOUT，表示连接超时。

判定连接是否超时，如果超过了最大等待时间，就放弃此连接。

/* A write timeout has occurred. Process the after effects. */ 

static int tcp_write_timeout (struct sock *sk)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    struct tcp_sock *tp = tcp_sk(sk);
    int retry_until;
    bool do_reset, syn_set = false;

    /* 如果超时是发生在三次握手期间 */
    if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
        if (icsk->icsk_retransmits) { /* 如果之前重传过了 */
            dst_negative_advice(sk); /* 更新目的路由缓存 */

            /* SYN携带Fast Open选项，或SYN携带数据 */
            if (tp->syn_fastopen || tp->syn_data)
                tcp_fastopen_cache_set(sk, 0, NULL, true);
            if (tp->syn_data)
                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPFASTOPENACTIVEFAIL);
        }

        /* SYN的最大重传次数，由TCP_SYNCNT选项和tcp_syn_retries参数决定，默认是5次 */
        retry_until = icsk->icsk_syn_retries ?: sysctl_tcp_syn_retries;
        syn_set = true;

    } else {
        /* tcp_retries1默认为3，当重传次数超过此值时，表示可能遇到了黑洞，需要进行PMTU
         * 检测，同时更新路由缓存。
         */
        if (retransmits_timed_out(sk, sysctl_tcp_retries1, 0, 0)) {
            /* Black hole detection */
            tcp_mtu_probing(icsk, sk); /* PMTU检测 */
            dst_negative_advic(sk); /* 更新路由缓存 */
        }

        retry_until = sysctl_tcp_retries2; /* 在断开TCP连接之前，最多进行多少次重传，默认值为15 */

       /* 如果当前套接口即将关闭 */
        if (sock_flag(sk, SOCK_DEAD)) {
            const int alive = (icsk->icsk_rto < TCP_RTO_MAX);
            retry_until = tcp_orphan_retries(sk, alive); /* 决定重传次数 */
            do_reset = alive || ! retransmits_timed_out(sk, retry_until, 0, 0);

            /* 如果当前的孤儿socket数量超过tcp_max_orphans，或者内存不够时，关闭此连接 */
            if (tcp_out_of_resources(sk, do_reset))
                return 1;
        }
    }

    /* 判定连接是否等待过久，即是否超时 */
    if (retransmits_timed_out(sk, retry_until, syn_set ? 0 : icsk->icsk_user_timeout, syn_set)) {
        /* Has it gone just too far ? */
        tcp_write_err(sk);
        return 1;
    }
}

/* Calculate maximal number or retries on an orphaned socket. */
static int tcp_orphan_retries (struct sock *sk, int alive)
{
    int retries = sysctl_tcp_orphan_retries; /* May be zero. */

    /* We know from an ICMP that something is wrong. */
    if (sk->sk_err_soft && !alive)
        retries = 0;

    /* However, if socket sent something recently, select some safe number of retries.
     * 8 corresponds to > 100 seconds with minimal RTO of 200msec.
     */
    if (retries == 0 && alive)
        retries = 8;

    return retries; 
}

判断连接是否超时，要分为3种情况。

1. SYN包：当SYN包的重传次数达到上限时，判定连接超时。(默认允许重传5次，初始超时时间为1s，总共历时31s)

2. 非SYN包，用户使用TCP_USER_TIMEOUT：当数据包发出去后的等待时间超过用户设置的时间时，判定连接超时。

3. 非SYN包，用户没有使用TCP_USER_TIMEOUT：当数据包发出去后的等待时间超过以TCP_RTO_MIN为初始超时

时间，重传boundary次所花费的时间后，判定连接超时。

如果返回值为真，判定连接超时，则关闭连接，把errno设置为ETIMEDOUT，Socket函数返回-1。

boundary为最大重传次数，timeout为用户设置的超时时间。(通过TCP_USER_TIMEOUT选项设置)

struct tcp_sock {
    ...
    /* Timestamp of the last retransmit, also used in SYN-SENT to remember stamp of
     * the first SYN.
     */

    /* 上面的注释是错误的，变量的含义为：
     * 1. 原始SYN包的发送时间点，不是重传的。
     * 2. 本次重传时，第一个被重传的包，原始包的发送时间点。
     * 这个变量是用来计算连接的超时关闭时间：一个包发送多久还没有得到响应，就判断连接超时。
     */
    u32 retrans_stamp; 
    ...
};

/* This function calculates a "timeout" which is equivalent to the timeout of a TCP connection
 * after " boundary unsuccessful, exponentially backed-off retransmissions with an initial RTO
 * of TCP_RTO_MIN or TCP_TIMEOUT_INIT if syn_set flag is set.
 */
static bool retransmits_timed_out (struct sock *sk, unsigned int boundary, unsigned int timeout,
    bool syn_set)
{
    unsigned int linear_backoff_thresh, start_ts;

    /* 如果是SYN包，则默认的初始超时时间为1s，否则为200ms。*/
    unsigned int rto_base = syn_set ? TCP_TIMEOUT_INIT : TCP_RTO_MIN;

    if (! inet_csk(sk)->icsk_retransmits))
        return false; /* 如果之前没有重传过，直接返回false */

    /* start_ts为开始计时点，注意是原始包第一次被发送时的时间戳，不是重传包的 */
    if (unlikely(! tcp_sk(sk)->retrans_stamp)) 
        start_ts = TCP_SKB_CB(tcp_write_queue_head(sk))->when;
    else
        start_ts = tcp_sk(sk)->retrans_stamp;

    /* 包括两种情况：
     * SYN包：timeout始终设置为0，因为在三次握手时TCP_USER_TIMEOUT是无效的。
     * 非SYN包：用户没有使用TCP_USER_TIMEOUT选项时。
     */
    if (likely(timeout == 0)) { 
        /* 当rto不超过最大值时，能够进行多少次指数退避。
         * 以SYN包为例，rto_base为1s，此值向上取整为7。
         */
        linear_backoff_thresh = ilog2(TCP_RTO_MAX/rto_base); 

        /* 从计时点开始，经过boundary次重传后，总共花费的时间 */
        if (boundary <= linear_backoff_thresh)
            timeout = ((2 << boundary) -1) * rto_base; 
        else
            timeout = ((2 << linear_backoff_thresh) -1) * rto_base + 
                (boundary - linear_backoff_thresh) * TCP_RTO_MAX;
    }

    return (tcp_time_stamp - start_ts) >= timeout; /* 判断等待时间是否过长，即是否要放弃连接 */