主要内容：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
",
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)
",
&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; /* 判断等待时间是否过长，即是否要放弃连接 */
}