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

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

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

内核版本：3.15.2

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

TCP的ACK确认系列 — 快速确认 https://www.cnblogs.com/aiwz/p/6333256.html

 参考https://blog.csdn.net/cd_yourheart/article/details/108245652

延迟确认模式

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

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

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

就进入延迟确认模式。

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