TCP 异常断开连接的过程

Tcp连接正常断开的情况，大家都了解，也就是一端发送Fin报文开启四次挥手，然后 sock 结构销毁，但是我之前很少去追踪 Tcp 在对端宕机，进程 Crash 之后的行为逻辑。前段时间正巧遇到了这样一个场景： 进程 A 通过 Tcp 连接关联了进程 B，同时进程B还有个备份进程进程C，A在感知到进程B断开连接后会切换到进程C，但是使用的时候没有深入了解这个切换过程需要多久，后来整理了下协议栈中的相关逻辑，了解了进程A大概需要多长时间感知到进程B断开连接。

异常主要分为四种情况：

一：进程B Crash，但进程B所在的宿主机仍然正常工作。

二：进程B所在的宿主机宕机，又迅速重启。

三：进程B所在的宿主机宕机，短时间内没有重启，从A出发的所有报文都被网络丢弃。

四：B已经断网/宕机/进程Crash，但此时A主机也没有需要向B发送的数据。

下面就是要从协议栈上看一下，在这几种情况下socket都需要多长时间才能收到断开连接的事件，以及中间到底发生了什么，这里的断开事件一般就是socket的可读事件，然后返回一个错误码，例如ETIMEOUT。

情况一：进程B Crash，进程B所在的宿主机仍然正常工作

这种情况我们通过 kill 命令直接杀进程就会出现，它的表现和进程调用Close类似，进程终止后，Socket会变成 Orphan Socket，会一个优雅的方式结束连接，即会向对端发送Fin报文，走正常关闭连接的那一套逻辑。

16:42:07.948662 IP localhost.8000 > localhost.59082: Flags [F.], seq 923610111, ack 12287042, win 86, options [nop,nop,TS val 205205320 ecr 205186343], length 0

Orphan Socket 有点像僵尸进程，也会占用系统资源，可以通过下面的配置项进行修改最大数量。

proc/sys/net/ipv4/tcp_max_orphans

情况二：进程B所在的宿主机宕机，又迅速重启

这种情况下，如果A进程恰好有发往B进程的Tcp报文，B重启前都会被丢弃，此时A可能回进入Rto状态，不断重发重传队列内的报文，在B主机被拉起后，重发的报文会被Linux协议栈接收，经过ip层处理，函数 tcp_v4_rcv 会在全局Socket哈希表中找处理该报文的Socket（监听目标端口的Socket，或者已建立连接的Socket），找到则交由该Socket处理，找不到则会向发送端回复Rst报文。

int tcp_v4_rcv(struct sk_buff *skb)
{
    struct net *net = dev_net(skb->dev);
    struct sk_buff *skb_to_free;
    int sdif = inet_sdif(skb);
    int dif = inet_iif(skb);
    const struct iphdr *iph;
    const struct tcphdr *th;
    bool refcounted;
    struct sock *sk;
    int ret;

    if (skb->pkt_type != PACKET_HOST)
        goto discard_it;

    /* Count it even if it's bad */
    __TCP_INC_STATS(net, TCP_MIB_INSEGS);

    if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
        goto discard_it;

    th = (const struct tcphdr *)skb->data;

    if (unlikely(th->doff < sizeof(struct tcphdr) / 4))
        goto bad_packet;
    if (!pskb_may_pull(skb, th->doff * 4))
        goto discard_it;

    /* An explanation is required here, I think.
     * Packet length and doff are validated by header prediction,
     * provided case of th->doff==0 is eliminated.
     * So, we defer the checks. */

    if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
        goto csum_error;

    th = (const struct tcphdr *)skb->data;
    iph = ip_hdr(skb);
lookup:
    // 从所有Socket(已连接和监听中)查找该 skb 所属的 Socket
    sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,
                   th->dest, sdif, &refcounted);
    // 未找到 skb 所属Socket, 发送 Rst 报文
    if (!sk)
        goto no_tcp_socket;

process:
    if (sk->sk_state == TCP_TIME_WAIT)
        goto do_time_wait;

    if (sk->sk_state == TCP_NEW_SYN_RECV) {
        struct request_sock *req = inet_reqsk(sk);
        bool req_stolen = false;
        struct sock *nsk;

        sk = req->rsk_listener;
        if (unlikely(tcp_v4_inbound_md5_hash(sk, skb, dif, sdif))) {
            sk_drops_add(sk, skb);
            reqsk_put(req);
            goto discard_it;
        }
        if (tcp_checksum_complete(skb)) {
            reqsk_put(req);
            goto csum_error;
        }
        if (unlikely(sk->sk_state != TCP_LISTEN)) {
            inet_csk_reqsk_queue_drop_and_put(sk, req);
            goto lookup;
        }
        /* We own a reference on the listener, increase it again
         * as we might lose it too soon.
         */
        sock_hold(sk);
        refcounted = true;
        nsk = NULL;
        if (!tcp_filter(sk, skb)) {
            th = (const struct tcphdr *)skb->data;
            iph = ip_hdr(skb);
            tcp_v4_fill_cb(skb, iph, th);
            nsk = tcp_check_req(sk, skb, req, false, &req_stolen);
        }
        if (!nsk) {
            reqsk_put(req);
            if (req_stolen) {
                /* Another cpu got exclusive access to req
                 * and created a full blown socket.
                 * Try to feed this packet to this socket
                 * instead of discarding it.
                 */
                tcp_v4_restore_cb(skb);
                sock_put(sk);
                goto lookup;
            }
            goto discard_and_relse;
        }
        if (nsk == sk) {
            reqsk_put(req);
            tcp_v4_restore_cb(skb);
        } else if (tcp_child_process(sk, nsk, skb)) {
            tcp_v4_send_reset(nsk, skb);
            goto discard_and_relse;
        } else {
            sock_put(sk);
            return 0;
        }
    }
    if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
        __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
        goto discard_and_relse;
    }

    if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
        goto discard_and_relse;

    if (tcp_v4_inbound_md5_hash(sk, skb, dif, sdif))
        goto discard_and_relse;

    nf_reset_ct(skb);

    if (tcp_filter(sk, skb))
        goto discard_and_relse;
    th = (const struct tcphdr *)skb->data;
    iph = ip_hdr(skb);
    tcp_v4_fill_cb(skb, iph, th);

    skb->dev = NULL;

    if (sk->sk_state == TCP_LISTEN) {
        ret = tcp_v4_do_rcv(sk, skb);
        goto put_and_return;
    }

    sk_incoming_cpu_update(sk);

    bh_lock_sock_nested(sk);
    tcp_segs_in(tcp_sk(sk), skb);
    ret = 0;
    if (!sock_owned_by_user(sk)) {
        skb_to_free = sk->sk_rx_skb_cache;
        sk->sk_rx_skb_cache = NULL;
        ret = tcp_v4_do_rcv(sk, skb);
    } else {
        if (tcp_add_backlog(sk, skb))
            goto discard_and_relse;
        skb_to_free = NULL;
    }
    bh_unlock_sock(sk);
    if (skb_to_free)
        __kfree_skb(skb_to_free);

put_and_return:
    if (refcounted)
        sock_put(sk);

    return ret;

no_tcp_socket:
    if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
        goto discard_it;

    tcp_v4_fill_cb(skb, iph, th);

    if (tcp_checksum_complete(skb)) {
csum_error:
        __TCP_INC_STATS(net, TCP_MIB_CSUMERRORS);
bad_packet:
        __TCP_INC_STATS(net, TCP_MIB_INERRS);
    } else {
        tcp_v4_send_reset(NULL, skb);
    }

discard_it:
    /* Discard frame. */
    kfree_skb(skb);
    return 0;

discard_and_relse:
    sk_drops_add(sk, skb);
    if (refcounted)
        sock_put(sk);
    goto discard_it;

do_time_wait:
    if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
        inet_twsk_put(inet_twsk(sk));
        goto discard_it;
    }

    tcp_v4_fill_cb(skb, iph, th);

    if (tcp_checksum_complete(skb)) {
        inet_twsk_put(inet_twsk(sk));
        goto csum_error;
    }
    switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
    case TCP_TW_SYN: {
        struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
                            &tcp_hashinfo, skb,
                            __tcp_hdrlen(th),
                            iph->saddr, th->source,
                            iph->daddr, th->dest,
                            inet_iif(skb),
                            sdif);
        if (sk2) {
            inet_twsk_deschedule_put(inet_twsk(sk));
            sk = sk2;
            tcp_v4_restore_cb(skb);
            refcounted = false;
            goto process;
        }
    }
        /* to ACK */
        fallthrough;
    case TCP_TW_ACK:
        tcp_v4_timewait_ack(sk, skb);
        break;
    case TCP_TW_RST:
        tcp_v4_send_reset(sk, skb);
        inet_twsk_deschedule_put(inet_twsk(sk));
        goto discard_it;
    case TCP_TW_SUCCESS:;
    }
    goto discard_it;
}

假设 B 主机启动后没有监听相关端口，则A的报文便会被 tcp_v4_rcv 函数判定为无效报文，回复 Rst 了事。

情况三：进程B所在的宿主机宕机，且短暂时间内没有重启

这种情况下，A与B的连接处于黑洞状态，A发送向B的所有报文都被丢弃，且没有任何回复，一定时长后便会触发RTO定时器，定时器处理函数会重发丢失的报文，重发的报文由于对端宕机也会被丢弃，就这样一直重传一直被丢弃，直到达到一定阈值，协议栈便会判定链路出现了故障，并通过Socket接口告诉应用程序链路故障，一般就是ETIMEOUT状态码。在Linux 协议栈上，这段逻辑从RTO超时Timer处理函数触发，在通知Socket接口发送数据失败处结束。下面就简单整理了下这段逻辑。

在内核态Tcp Socket 结构创建的时候，协议栈调用了 tcp_init_xmit_timers 函数来初始化一些定时器。

void tcp_init_sock(struct sock *sk)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    struct tcp_sock *tp = tcp_sk(sk);

    tp->out_of_order_queue = RB_ROOT;
    sk->tcp_rtx_queue = RB_ROOT;
    // 初始化 重传/keepalive/延时确认等 timer
    tcp_init_xmit_timers(sk);
    INIT_LIST_HEAD(&tp->tsq_node);
    INIT_LIST_HEAD(&tp->tsorted_sent_queue);

    icsk->icsk_rto = TCP_TIMEOUT_INIT;
    tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
    minmax_reset(&tp->rtt_min, tcp_jiffies32, ~0U);

    /* So many TCP implementations out there (incorrectly) count the
     * initial SYN frame in their delayed-ACK and congestion control
     * algorithms that we must have the following bandaid to talk
     * efficiently to them.  -DaveM
     */
    tp->snd_cwnd = TCP_INIT_CWND;

    /* There's a bubble in the pipe until at least the first ACK. */
    tp->app_limited = ~0U;

    /* See draft-stevens-tcpca-spec-01 for discussion of the
     * initialization of these values.
     */
    tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
    tp->snd_cwnd_clamp = ~0;
    tp->mss_cache = TCP_MSS_DEFAULT;

    tp->reordering = sock_net(sk)->ipv4.sysctl_tcp_reordering;
    tcp_assign_congestion_control(sk);

    tp->tsoffset = 0;
    tp->rack.reo_wnd_steps = 1;

    sk->sk_write_space = sk_stream_write_space;
    sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);

    icsk->icsk_sync_mss = tcp_sync_mss;

    WRITE_ONCE(sk->sk_sndbuf, sock_net(sk)->ipv4.sysctl_tcp_wmem[1]);
    WRITE_ONCE(sk->sk_rcvbuf, sock_net(sk)->ipv4.sysctl_tcp_rmem[1]);

    sk_sockets_allocated_inc(sk);
    sk->sk_route_forced_caps = NETIF_F_GSO;
}

这些定时器包括重传定时器(tcp_write_timer ),延时确认定时器(tcp_delack_timer ),Tcp KeepAlive定时器(tcp_keepalive_timer ) 等。

770 void tcp_init_xmit_timers(struct sock *sk)
771 {
        // 重传定时器在这里设置
772     inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer,
773                   &tcp_keepalive_timer);
774     hrtimer_init(&tcp_sk(sk)->pacing_timer, CLOCK_MONOTONIC,
775              HRTIMER_MODE_ABS_PINNED_SOFT);
776     tcp_sk(sk)->pacing_timer.function = tcp_pace_kick;
777
778     hrtimer_init(&tcp_sk(sk)->compressed_ack_timer, CLOCK_MONOTONIC,
779              HRTIMER_MODE_REL_PINNED_SOFT);
780     tcp_sk(sk)->compressed_ack_timer.function = tcp_compressed_ack_kick;
781 }

从调用栈追踪下去， tcp_init_xmit_timers  --> tcp_write_timer  --> tcp_write_timer_handler  --> tcp_retransmit_timer，tcp_retransmit_timer 函数处理的就是重传再超时后的情况

  1 void tcp_retransmit_timer(struct sock *sk)
  2 {
  3     struct tcp_sock *tp = tcp_sk(sk);
  4     struct net *net = sock_net(sk);
  5     struct inet_connection_sock *icsk = inet_csk(sk);
  6
  7     if (tp->fastopen_rsk) {
  8         WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
  9                  sk->sk_state != TCP_FIN_WAIT1);
 10         tcp_fastopen_synack_timer(sk);
 11         /* Before we receive ACK to our SYN-ACK don't retransmit
 12          * anything else (e.g., data or FIN segments).
 13          */
 14         return;
 15     }
 16     if (!tp->packets_out || WARN_ON_ONCE(tcp_rtx_queue_empty(sk)))
 17         return;
 18
 19     tp->tlp_high_seq = 0;
 20
 21     if (!tp->snd_wnd && !sock_flag(sk, SOCK_DEAD) &&
 22         !((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) {
 23         /* Receiver dastardly shrinks window. Our retransmits
 24          * become zero probes, but we should not timeout this
 25          * connection. If the socket is an orphan, time it out,
 26          * we cannot allow such beasts to hang infinitely.
 27          */
 28         struct inet_sock *inet = inet_sk(sk);
 29         if (sk->sk_family == AF_INET) {
 30             net_dbg_ratelimited("Peer %pI4:%u/%u unexpectedly shrunk window %u:%u (repaired)\n",
 31                         &inet->inet_daddr,
 32                         ntohs(inet->inet_dport),
 33                         inet->inet_num,
 34                         tp->snd_una, tp->snd_nxt);
 35         }
 36 #if IS_ENABLED(CONFIG_IPV6)
 37         else if (sk->sk_family == AF_INET6) {
 38             net_dbg_ratelimited("Peer %pI6:%u/%u unexpectedly shrunk window %u:%u (repaired)\n",
 39                         &sk->sk_v6_daddr,
 40                         ntohs(inet->inet_dport),
 41                         inet->inet_num,
 42                         tp->snd_una, tp->snd_nxt);
 43         }
 44 #endif
 45         if (tcp_jiffies32 - tp->rcv_tstamp > TCP_RTO_MAX) {
 46             tcp_write_err(sk);
 47             goto out;
 48         }
 49         tcp_enter_loss(sk);
 50         tcp_retransmit_skb(sk, tcp_rtx_queue_head(sk), 1);
 51         __sk_dst_reset(sk);
 52         goto out_reset_timer;
 53     }
 54
 55     __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPTIMEOUTS);
 56     // 处理重传次数的逻辑，重传次数达到阈值后通知Socket传输失败
 57     if (tcp_write_timeout(sk))
 58         goto out;
 59
 60     if (icsk->icsk_retransmits == 0) {
 61         int mib_idx = 0;
 62
 63         if (icsk->icsk_ca_state == TCP_CA_Recovery) {
 64             if (tcp_is_sack(tp))
 65                 mib_idx = LINUX_MIB_TCPSACKRECOVERYFAIL;
 66             else
 67                 mib_idx = LINUX_MIB_TCPRENORECOVERYFAIL;
 68         } else if (icsk->icsk_ca_state == TCP_CA_Loss) {
 69             mib_idx = LINUX_MIB_TCPLOSSFAILURES;
 70         } else if ((icsk->icsk_ca_state == TCP_CA_Disorder) ||
 71                tp->sacked_out) {
 72             if (tcp_is_sack(tp))
 73                 mib_idx = LINUX_MIB_TCPSACKFAILURES;
 74             else
 75                 mib_idx = LINUX_MIB_TCPRENOFAILURES;
 76         }
 77         if (mib_idx)
 78             __NET_INC_STATS(sock_net(sk), mib_idx);
 79     }
 80
 81     tcp_enter_loss(sk);
 82
 83     if (tcp_retransmit_skb(sk, tcp_rtx_queue_head(sk), 1) > 0) {
 84         // 重传失败，一般是由于拥塞窗口不允许，RTO时长不变，重启重传定时器
 85         /* Retransmission failed because of local congestion,
 86          * do not backoff.
 87          */
 88         if (!icsk->icsk_retransmits)
 89             icsk->icsk_retransmits = 1;
 90         inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
 91                       min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL),
 92                       TCP_RTO_MAX);
 93         goto out;
 94     }
 95
 96     /* Increase the timeout each time we retransmit.  Note that
 97      * we do not increase the rtt estimate.  rto is initialized
 98      * from rtt, but increases here.  Jacobson (SIGCOMM 88) suggests
 99      * that doubling rto each time is the least we can get away with.
100      * In KA9Q, Karn uses this for the first few times, and then
101      * goes to quadratic.  netBSD doubles, but only goes up to *64,
102      * and clamps at 1 to 64 sec afterwards.  Note that 120 sec is
103      * defined in the protocol as the maximum possible RTT.  I guess
104      * we'll have to use something other than TCP to talk to the
105      * University of Mars.
106      *
107      * PAWS allows us longer timeouts and large windows, so once
108      * implemented ftp to mars will work nicely. We will have to fix
109      * the 120 second clamps though!
110      */
111     icsk->icsk_backoff++;
112     icsk->icsk_retransmits++;
113
114 out_reset_timer:
115     /* If stream is thin, use linear timeouts. Since 'icsk_backoff' is
116      * used to reset timer, set to 0. Recalculate 'icsk_rto' as this
117      * might be increased if the stream oscillates between thin and thick,
118      * thus the old value might already be too high compared to the value
119      * set by 'tcp_set_rto' in tcp_input.c which resets the rto without
120      * backoff. Limit to TCP_THIN_LINEAR_RETRIES before initiating
121      * exponential backoff behaviour to avoid continue hammering
122      * linear-timeout retransmissions into a black hole
123      */
124     // 重传成功后开启RTO退避
125     if (sk->sk_state == TCP_ESTABLISHED &&
126         (tp->thin_lto || net->ipv4.sysctl_tcp_thin_linear_timeouts) &&
127         tcp_stream_is_thin(tp) &&
128         //另一种退避策略
129         icsk->icsk_retransmits <= TCP_THIN_LINEAR_RETRIES) {
130         icsk->icsk_backoff = 0;
131         icsk->icsk_rto = min(__tcp_set_rto(tp), TCP_RTO_MAX);
132     } else {
133         /* Use normal (exponential) backoff */
134         // 指数式退避，每次重传RTO翻倍，直到达到 TCP_RTO_MAX
135         icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX);
136     }
137
138     // 重启重传定时器
139     inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
140                   tcp_clamp_rto_to_user_timeout(sk), TCP_RTO_MAX);
141     if (retransmits_timed_out(sk, net->ipv4.sysctl_tcp_retries1 + 1, 0))
142         __sk_dst_reset(sk);
143
144 out:;
145 }

tcp_retransmit_timer 函数会在 tcp_write_timeout 函数内判断重传事件（注意： 这里用的是重传时间，而不是次数，虽然时间也是有次数建模计算得来的）是否超过阈值，没有达到阈值就通过函数 tcp_retransmit_skb 尝试重传重传队列的队首报文，并重置重传定时器，而RTO的值也会采用一定策略进行调整，一般是每次重传后RTO都翻倍,直到达到一个最大值。重传/丢包循环有两个结束条件，一个是重传成功，另一个是达到重传次数阈值，达到阈值的逻辑就在 tcp_write_timeout 函数内实现。

 1 /* A write timeout has occurred. Process the after effects. */
 2 static int tcp_write_timeout(struct sock *sk)
 3 {
 4     struct inet_connection_sock *icsk = inet_csk(sk);
 5     struct tcp_sock *tp = tcp_sk(sk);
 6     struct net *net = sock_net(sk);
 7     bool expired = false, do_reset;
 8     int retry_until;
 9
10     if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
11         // 握手阶段超时
12         if (icsk->icsk_retransmits) {
13             dst_negative_advice(sk);
14         } else {
15             sk_rethink_txhash(sk);
16             tp->timeout_rehash++;
17             __NET_INC_STATS(sock_net(sk),
18                     LINUX_MIB_TCPTIMEOUTREHASH);
19         }
20         // 重传次数使用 sysctl_tcp_syn_retries
21         retry_until = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_syn_retries;
22         expired = icsk->icsk_retransmits >= retry_until;
23     } else {
24         // 重传次数达到阈值1，发送链路探测
25         if (retransmits_timed_out(sk, net->ipv4.sysctl_tcp_retries1, 0)) {
26             /* Black hole detection */
27             tcp_mtu_probing(icsk, sk);
28
29             dst_negative_advice(sk);
30         } else {
31             sk_rethink_txhash(sk);
32             tp->timeout_rehash++;
33             __NET_INC_STATS(sock_net(sk),
34                     LINUX_MIB_TCPTIMEOUTREHASH);
35         }
36
37         // 重传次数达到阈值2
38         retry_until = net->ipv4.sysctl_tcp_retries2;
39         if (sock_flag(sk, SOCK_DEAD)) {
40             const bool alive = icsk->icsk_rto < TCP_RTO_MAX;
41
42             retry_until = tcp_orphan_retries(sk, alive);
43             do_reset = alive ||
44                 !retransmits_timed_out(sk, retry_until, 0);
45
46             if (tcp_out_of_resources(sk, do_reset))
47                 return 1;
48         }
49     }
50     // 判断重传是否超时
51     if (!expired)
52         expired = retransmits_timed_out(sk, retry_until,
53                         icsk->icsk_user_timeout);
54     tcp_fastopen_active_detect_blackhole(sk, expired);
55
56     if (BPF_SOCK_OPS_TEST_FLAG(tp, BPF_SOCK_OPS_RTO_CB_FLAG))
57         tcp_call_bpf_3arg(sk, BPF_SOCK_OPS_RTO_CB,
58                   icsk->icsk_retransmits,
59                   icsk->icsk_rto, (int)expired);
60
61     // 达到重传上限，触发socket接口可读时间 ETIMEOUT
62     if (expired) {
63         /* Has it gone just too far? */
64         tcp_write_err(sk);
65         return 1;
66     }
67
68     return 0;
69 }

retransmits_timed_out 判断重传时间是否达到上限。

 1 static bool retransmits_timed_out(struct sock *sk,
 2                   unsigned int boundary,
 3                   unsigned int timeout)
 4 {
 5     unsigned int start_ts;
 6
 7     if (!inet_csk(sk)->icsk_retransmits)
 8         return false;
 9
10     start_ts = tcp_sk(sk)->retrans_stamp;
11     // 传了timeout则用传进来的timeout，否则用重传次数 boundary 计算出重传超时的时间
12     if (likely(timeout == 0)) {
13         unsigned int rto_base = TCP_RTO_MIN;
14
15         if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
16             rto_base = tcp_timeout_init(sk);
17         timeout = tcp_model_timeout(sk, boundary, rto_base);
18     }
19
20     return (s32)(tcp_time_stamp(tcp_sk(sk)) - start_ts - timeout) >= 0;
21 }

tcp_model_timeout 根据设置的重传次数阈值估算重传时间阈值，该函数和 TCP_RETRIES2 参数计算的到的时间应该就是本文一开始要找的时长。

 1 static unsigned int tcp_model_timeout(struct sock *sk,
 2                       unsigned int boundary,
 3                       unsigned int rto_base)
 4 {
 5     unsigned int linear_backoff_thresh, timeout;
 6
 7     // 达到 TCP_RTO_MAX 需要的指数退避次数
 8     linear_backoff_thresh = ilog2(TCP_RTO_MAX / rto_base);
 9     if (boundary <= linear_backoff_thresh)
10         // 小于指数退避次数阈值时，timeout时间和指数退避时间相同，即乘2的n次方
11         timeout = ((2 << boundary) - 1) * rto_base;
12     else
13         // 大于指数退避次数阈值时，timeout时间为指数退避后的最大时间 + TCP_RTO_MAX 乘多余的次数
14         timeout = ((2 << linear_backoff_thresh) - 1) * rto_base +
15             (boundary - linear_backoff_thresh) * TCP_RTO_MAX;
16     return jiffies_to_msecs(timeout);
17 }

重传次数的两个阈值，对应的是linux两个配置项

TCP_RETRIES1:  触发链路探测的重传次数阈值

TCP_RETRIES2:  判定重传失败的重传次数阈值

下面是一个实验数据，客户端/服务端都是用的本机 localhost（怀念研究生时期的实验环境，当年真的可以做很多有意思的事情），没有加额外的时延，最终15次的重传时间间隔就是下面的这张图。

重传时间间隔从400 ms 开始指数式增长，达到最大值120s（默认最大RTO）时候不变，一直重传，直到重传次数达到 TCP_RETRIES2 ，然后客户端 socket 返回 ETIMEOUT错误，这个过程累积在15分钟左右。

情况四 双方都处于静默状态 - Tcp KeepAlive

如果恰巧A 进程没有任何要发往B的数据， A 进程就没有任何途径感知到进程B已经断开了连接了，这种状态也就是我们熟悉的Tcp半打开状态，也就是冷战状态，双方都不知道对方状态，也无探测报文去触发对方Rst或者Ack。这种情况下，就要有一方主动一点，抛出个橄榄枝，看看对方是要回个Rst拒绝你，还是要回个Ack接受你，还是啥也不回继续冷战，但至少通过这次探测，我们就可以知道对方的状态。这就是Tcp的KeepAlive 机制，Tcp KeepAlive 是协议栈里用来检测半打开状态的机制，在上面介绍的 tcp_init_xmit_timers 函数内，Tcp 启动了一个 keepAlive 定时器（默认时长是2个小时），2个小时后链路处于空闲状态，便会触发这个定时器，定时器的主要工作就是向对方发送探测报文。

 1 static void tcp_keepalive_timer (struct timer_list *t)
 2 {
 3     struct sock *sk = from_timer(sk, t, sk_timer);
 4     struct inet_connection_sock *icsk = inet_csk(sk);
 5     struct tcp_sock *tp = tcp_sk(sk);
 6     u32 elapsed;
 7
 8     /* Only process if socket is not in use. */
 9     bh_lock_sock(sk);
10     if (sock_owned_by_user(sk)) {
11         /* Try again later. */
12         inet_csk_reset_keepalive_timer (sk, HZ/20);
13         goto out;
14     }
15
16     if (sk->sk_state == TCP_LISTEN) {
17         pr_err("Hmm... keepalive on a LISTEN ???\n");
18         goto out;
19     }
20
21     tcp_mstamp_refresh(tp);
22     if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) {
23         if (tp->linger2 >= 0) {
24             const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN;
25
26             if (tmo > 0) {
27                 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
28                 goto out;
29             }
30         }
31         tcp_send_active_reset(sk, GFP_ATOMIC);
32         goto death;
33     }
34
35     if (!sock_flag(sk, SOCK_KEEPOPEN) ||
36         ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)))
37         goto out;
38
39     elapsed = keepalive_time_when(tp);
40
41     /* It is alive without keepalive 8) */
42     // 有发送中的数据，则不需要额外的探测报文
43     if (tp->packets_out || !tcp_write_queue_empty(sk))
44         goto resched;
45
46     elapsed = keepalive_time_elapsed(tp);
47
48     if (elapsed >= keepalive_time_when(tp)) {
49         /* If the TCP_USER_TIMEOUT option is enabled, use that
50          * to determine when to timeout instead.
51          */
52         // 关闭连接时间点， 1：空闲时间超过用户设置时间  2： 没有使用时间选项，探测数超过保活探测的最大次数
53         if ((icsk->icsk_user_timeout != 0 &&
54             elapsed >= msecs_to_jiffies(icsk->icsk_user_timeout) &&
55             icsk->icsk_probes_out > 0) ||
56             (icsk->icsk_user_timeout == 0 &&
57             icsk->icsk_probes_out >= keepalive_probes(tp))) { // 最大的系统配置探测次数
58             tcp_send_active_reset(sk, GFP_ATOMIC);
59             tcp_write_err(sk);
60             goto out;
61         }
62         // 发送探测报文
63         if (tcp_write_wakeup(sk, LINUX_MIB_TCPKEEPALIVE) <= 0) {
64             icsk->icsk_probes_out++;
65             // 系统配置 sysctl_tcp_keepalive_intvl，或者是Socket接口设置的探测时间间隔
66             elapsed = keepalive_intvl_when(tp);
67         } else {
68             /* If keepalive was lost due to local congestion,
69              * try harder.
70              */
71             elapsed = TCP_RESOURCE_PROBE_INTERVAL;
72         }
73     } else {
74         /* It is tp->rcv_tstamp + keepalive_time_when(tp) */
75         elapsed = keepalive_time_when(tp) - elapsed;
76     }
77
78     sk_mem_reclaim(sk);
79
80 resched:
81     inet_csk_reset_keepalive_timer (sk, elapsed);
82     goto out;
83
84 death:
85     tcp_done(sk);
86
87 out:
88     bh_unlock_sock(sk);
89     sock_put(sk);
90 }

Tcp KeepAlive 有三个主要的配置参数：

tcp_keepalive_time： Tcp KeepAlive定时器触发时间， 默认7200s
tcp_keepalive_intvl： 保活探测报文的重传时间，默认为75s。
tcp_keepalive_probes： 保活探测报文的发送次数，默认为9次。

从 tcp_keepalive_timer 函数的实现中就可以发现，除了正常的系统配置外，tcp keepalive 还提供了系统接口来针对单条tcp连接配置独自的 keepalive 定时器时长，探测时间间隔，探测次数，具体实现可以通过 setsockopt 接口文档查找。

工具链：如何在不杀进程的情况下，关闭掉某个Tcp连接

Q： 特定场景下，我们在明知到对方进程挂了，但是相关的Tcp连接没有关闭，如果我们要手动关闭这个连接该怎么处理？

A： 处理这个问题主要由两个思路：

1）：根据Tcp协议原理，我们只需要向这个连接发送一个Rst报文，为此我们需要构造一个 Rst 报文，并丢给本机 socket，目前 tcpkill 等工具可以使用，但是这种方法需要知道 sock 当前的 seq 才能发送符合要求的 Rst 报文，否则会被协议栈丢弃。

参考： https://unix.stackexchange.com/questions/71940/killing-tcp-connection-in-linux

2）：通过gdb attach进程，然后直接调用 close 系统调用，关闭对应的描述符 fd

参考： https://superuser.com/questions/127863/manually-closing-a-port-from-commandline/668155#668155

总结

网络传输过程中，如果对端只是进程 Crash 或者宕机后又迅速重启，客户端是能够较快感知到对端状态变化的，但是如果对端宕机后完全变成了丢包黑洞的话，依靠 TCP 协议栈本身发现网络连接断开可能耗时比较久，linux 默认情况下这个过程有可能需要15分钟左右，因此对这个时间不太满意的情况下，可以尝试通过修改 TCP_RETRIES2 参数来进行调优，当然时间太短也有一些隐患，比如它就是网卡了，简单几次重传就放弃连接似乎也不太合理，实现应用层的心跳机制根据业务需求配置似乎更合理些。