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

内核版本：3.15.2

我的博客： 

 

延迟确认模式

 

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

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

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

就进入延迟确认模式。

/* 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\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()。

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