转载

主要内容：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_DEBUGpr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",sk, what, when, current_text_addr());
#endifwhen = 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_DEBUGelse {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;elsemib_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;elsemib_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;elsestart_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; elsetimeout = ((2 << linear_backoff_thresh) -1) * rto_base + (boundary - linear_backoff_thresh) * TCP_RTO_MAX;}
    return (tcp_time_stamp - start_ts) >= timeout; /* 判断等待时间是否过长，即是否要放弃连接 */