TCP的ACK确认系列 — 延迟确认

主要内容：TCP的延迟确认、延迟确认定时器的实现。

内核版本：3.15.2

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

延迟确认模式

发送方在发送数据包时，如果发送的数据包有负载，则会检测拥塞窗口是否超时。

如果超时，则会使拥塞窗口失效并重新计算拥塞窗口。

如果此时距离最近接收到数据包的时间间隔足够短，说明双方处于你来我往的双向数据传输中，

就进入延迟确认模式。

[java] view
plain copy







/* 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()，用于判断发送快速确认还是延迟确认。

[java] view
plain copy







/*

* 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

}

(2) 超时处理函数

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

[java] view
plain copy







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模式。

[java] view
plain copy







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

[java] view
plain copy







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，之后会进入快速

确认模式。

[java] view
plain copy







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))