主要内容：TCP的延迟确认、延迟确认定时器的实现。
内核版本：3.15.2
我的博客：http://blog.csdn.net/zhangskd
延迟确认模式
发送方在发送数据包时，如果发送的数据包有负载，则会检测拥塞窗口是否超时。
如果超时，则会使拥塞窗口失效并重新计算拥塞窗口。
如果此时距离最近接收到数据包的时间间隔足够短，说明双方处于你来我往的双向数据传输中，
就进入延迟确认模式。
/* Congestion state accounting after a packet has been sent. */
static void tcp_event_data_sent (struct tcp_sock *tp, struct sock *sk)
{
struct inet_connection_sock *icsk = inet_csk(sk);
const u32 now = tcp_time_stamp;
const struct dst_entry *dst = __sk_dst_get(sk);
if (sysctl_tcp_slow_start_after_idle &&
(!tp->packets_out && (s32) (now - tp->lsndtime) > icsk->icsk_rto))
tcp_cwnd_restart(sk, __sk_dst_get(sk)); /* 重置cnwd */
tp->lsndtime = now; /* 更新最近发送数据包的时间*/
/* If it is a reply for ato after last received packets,
* enter pingpong mode.
* 如果距离上次接收到数据包的时间在ato内，则进入延迟确认模式。
*/
if ((u32)(now - icsk->icsk_ack.lrcvtime) < icsk.icsk_ack.ato &&
(!dst || !dst_metric(dst, RTAX_QUICKACK)))
icsk->icsk_ack.pingpong = 1;
}
ATO的计算
Q：icsk->icsk_ack.ato在ACK的发送过程中扮演了重要角色，那么它到底是用来干什么的？
A：ato为ACK Timeout，指ACK的超时时间。但延迟确认定时器的超时时间为icsk->icsk_ack.timeout，
ato只是计算timeout的一个中间变量，会根接收到的数据包的时间间隔来做动态调整。一般如果接收到
的数据包的时间间隔变小，ato也会相应的变小。如果接收到的数据包的时间间隔变大，ato也会相应的
变大。ato的最小值为40ms，ato的最大值一般为200ms或一个RTT。
所以在实际传输过程中，我们看到的ACK的超时时间，是处于40ms ~ min(200ms, RTT)之间的。
在tcp_event_data_recv()中更新ato的值，delta为距离上次收到数据包的时间：
1. delta <= TCP_ATO_MIN /2时，ato = ato / 2 + TCP_ATO_MIN / 2。
2. TCP_ATO_MIN / 2 < delta <= ato时，ato = min(ato / 2 + delta, rto)。
3. delta > ato时，ato值不变。
在tcp_send_delayed_ack()中会把ato赋值给icsk->icsk_ack.timeout，用作延迟确认定时器的超时时间。
延迟确认定时器
#define ICSK_TIME_DACK 2 /* Delayed ack timer */
icsk->icsk_delack_timer：延迟确认定时器。
(1) 激活
icsk->icsk_delack_timer的激活函数为inet_csk_reset_xmit_timer()，此函数共负责了5个定时器的激活工作。
延迟确认定时器的另一个激活函数为tcp_send_delayed_ack()，用于判断发送快速确认还是延迟确认。
/*
* 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
}
(2) 超时处理函数
icsk->icsk_delack_timer的超时处理函数为tcp_delack_timer()。
static void tcp_delack_timer (unsigned long data)
{
struct sock *sk = (struct sock *) data;
bh_lock_sock(sk);
if (! sock_owned_by_user(sk)) {
tcp_delack_timer_handler(sk); /* 实际的处理函数 */
} else {
/* 如果延迟确认定时器触发时，发现用户进程正在使用此socket，就把blocked置为1。
* 之后在接收到新数据、或者将数据复制到用户空间之后，会马上发送ACK。
*/
inet_csk(sk)->icsk_ack.blocked = 1;
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED);
/* delegate our work to tcp_release_cb() */
if (! test_and_set_bit(TCP_DELACK_TIMER_DEFERRED, &tcp_sk(sk)->tsq_flags))
sock_hold(sk);
}
bh_unlock_sock(sk);
sock_put(sk);
}
tcp_delack_timer_handler()是延迟确认定时器的实际超时处理函数。
延迟确认定时器触发后，会发出一个被延迟的ACK，之后进入快速确认模式。
因为都等到超时了，本端还没有数据要一起发送，说明不处于pingpong模式。
void tcp_delack_timer_handler (stuct sock *sk)
{
struct tcp_sock *tp = tcp_sk(sk);
struct inet_connection_sock *icsk = inet_csk(sk);
sk_mem_reclaim_partial(sk);
/* 如果连接已关闭，或者延迟确认定时器并没有被启动，直接返回 */
if (sk->sk_state == TCP_CLOSE || ! (icsk->icsk_ack.pending & ICSK_ACK_TIMER))
goto out;
/* 如果还没有到超时时刻，则继续计时，直接返回 */
if (time_after(icsk->icsk_ack.timeout, jiffies)) {
sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
goto out;
}
icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER; /* 去除延迟定时器的运行标志 */
/* 如果prequeue队列不为空，则处理其中的数据包 */
if (! skb_queue_empty(&tp->ucopy.prequeue)) {
struct sk_buff *skb;
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSCHEDULERFAILED);
/* 从prequeue队列中取出skb，并从队列中删除 */
while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
sk_backlog_rcv(sk, skb); /* 调用tcp_v4_do_rcv()来处理 */
tp->ucopy.memory = 0; /* 清零prequeue队列消耗的内存 */
}
/* 如果有ACK需要发送 */
if (inet_csk_ack_scheduled(sk)) {
/* Delay ACK missed: inflate ATO. */
/* 在快速确认模式中，如果分配skb失败，就无法发送ACK。
* 此时也会启动延迟确认定时器，超时时间设为200ms。
* 在这种情况下，如果再次发送失败，就要进行指数退避了。
*/
if (! icsk->icsk_ack.pingpong) {
icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto); /* 超时时间的指数退避 */
} else { /* 如果是处于延迟确认模式 */
icsk->icsk_ack.pingpong = 0; /* 切换到快速确认模式 */
icsk->icsk_ack.ato = TCP_ATO_MIN; /* 重置ATO */
}
tcp_send_ack(sk); /* 发送ACK */
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKS);
}
out:
if (sk_under_memory_pressure(sk))
sk_mem_reclaim(sk);
}
(3) 删除
成功发送ACK时，会删除延迟确认定时器。
tcp_transmit_skb
|--> tcp_event_ack_sent
|--> inet_csk_clear_xmit_timer
static inline void inet_csk_clear_xmit_timer (struct sock *sk, const int what)
{
struct inet_connection_sock *icsk = inet_csk(sk);
if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {
icsk->icsk_pending = 0;
#ifdef INET_CSK_CLEAR_TIMERS
sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
#endif
} else if (what == ICSK_TIME_DACK) {
icsk->icsk_ack.blocked = icsk->icsk_ack.pending = 0; /* 清除ACK的发送状态标志 */
#ifdef INET_CSK_CLEAR_TIMERS
sk_stop_timer(sk, &icsk->icsk_delack_timer); /* 删除延迟确认定时器 */
#endif
}
#ifdef INET_CSK_DEBUG
else {
pr_debug("%s", inet_csk_timer_bug_msg);
}
#endif
}
延迟ACK的发送
当接收到数据包后，会检查是否需要发送ACK，如果需要的话是进行快速确认还是延迟确认。
在无法快速确认的情况下，就使用延迟确认。
__tcp_ack_snd_check
|--> tcp_send_delayed_ack
如果已经启动了延迟确认定时器，并符合以下任一条件就马上发送ACK：
1. 上次延迟确认定时器触发时，因为socket被用户进程锁住而无法发送ACK。
2. 接收到数据包时，延迟确认定时器已经快要超时了(离现在不到1/4 * ato)。
如果之前没有启动延迟确认定时器，就设置ACK需要发送标志、延迟确认定时器启动标志，
并启动延迟确认定时器。在延迟确认定时器计时期间，如果有捎带确认发生，就会清除ACK的发送状态标志，
删除延迟确认定时器。否则延迟确认定时器会发生超时，然后在超时处理函数中发送纯ACK，之后会进入快速
确认模式。
void tcp_send_delayed_ack (struct sock *sk)
{
struct inet_connection_sock *icsk = inet_csk(sk);
int ato = icsk->icsk_ack.ato;
unsigned long timeout;
/* 设置ato的上限可能为：
* 1. 500ms
* 2. 200ms，如果处于延迟确认模式，或者处于快速确认模式且收到过小包
* 3. RTT，如果有RTT采样
*/
if (ato > TCP_DELACK_MIN) {
const struct tcp_sock *tp = tcp_sk(sk);
int max_ato = HZ / 2; /* 500ms */
/* 如果处于延迟确认模式，或者处于快速确认模式且设置了ICSK_ACK_PUSHED标志 */
if (icsk->icsk_ack.pingpong || (icsk->icsk_ack.pending & ICSK_ACK_PUSHED))
max_ato = TCP_DELACK_MAX; /* 200ms */
/* Slow path, intersegment interval is high. */
/* If some rtt estimate is known, use it to bound delayed ack.
* Do not use inet_csk(sk)->icsk_rto here, use results of rtt measurements directly.
*/
/* 如果有RTT采样，使用RTT来作为ato的最大值 */
if (tp->srtt_us) {
int rtt = max_t(int, usecs_to_jiffies(tp->srtt_us >> 3), TCP_DELACK_MIN);
if (rtt < max_ato)
max_ato = rtt;
}
ato = min(ato, max_ato); /* ato不能超过最大值 */
}
/* Stay within the limit we were given */
timeout = jiffies + ato; /* 延迟ACK的超时时刻 */
/* Use new timeout only if there wasn't a older one earlier. */
/* 如果之前已经启动了延迟确认定时器了 */
if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
/* If delack timer was blocked or is about to expire, send ACK now.
* 如果之前延迟确认定时器触发时，因为socket被用户进程锁住而无法发送ACK，那么现在马上发送。
* 如果接收到数据报时，延迟确认定时器已经快要超时了(离现在不到1/4 * ato)，那么马上发送ACK。
*/
if (icsk->icsk_ack.blocked || time_before_eq(icsk->icsk_ack.timeout, jiffies + (ato >> 2))) {
tcp_send_ack(sk); /* 发送ACK */
return;
}
/* 如果新的超时时间，比之前设定的超时时间晚，那么使用之前设定的超时时间 */
if (! time_before(timeout, icsk->icsk_ack.timeout))
timeout = icsk->icsk_ack.timeout;
}
/* 如果还没有启动延迟确认定时器 */
icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER; /* 设置ACK需要发送标志、定时器启动标志 */
icsk->icsk_ack.timeout = timeout; /* 超时时间 */
sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout); /* 启动延迟确认定时器 */
}
/* minimal time to delay before sending an ACK. */
# define TCP_DELACK_MIN ((unsigned) (HZ/25))
/* maximal time to delay before sending an ACK */
# define TCP_DELACK_MAX ((unsigned) (HZ/5))