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