TCP 之 FIN_WAIT_2状态处理流程

概述

在主动关闭方发送了FIN之后，进入FIN_WAIT_1状态，在此状态收到了ACK，则进入FIN_WAIT_2状态，而FIN_WAIT_2后续要做的工作是等待接收对端发过来的FIN包，并且发送ACK，进而进入到TIME_WAIT状态；本文主要关注从FIN_WAIT_1进入FIN_WAIT_2状态，以及在FIN_WAIT_2状态来包或者定时器触发后的处理流程；

进入FIN_WAIT_2

tcp_rcv_state_process函数中对于ack的处理步骤中，假如连接处于FIN_WAIT_1，且数据均已经被确认完，则进入TIME_WAIT_2状态；如果无需在该状态等待（linger2<0），或者收到了乱序数据段，则直接关闭连接；如果需要等待，则需要判断等待时间与TIMEWAIT时间的大小关系，若>TIMEWAIT_LEN，则添加TIME_WAIT_2定时器，否则直接进入TIME_WAIT接管(其子状态仍然是FIN_WAIT_2)，接管之后会添加TIME_WAIT定时器；

另，tcp_close函数调用时，如果当前状态是FIN_WAIT_2也会用相似方式进入TIME_WAIT接管，不再单独介绍；

 int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
 {
     /* step 5: check the ACK field */
     acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
                       FLAG_UPDATE_TS_RECENT) > ;
 
     switch (sk->sk_state) {
     case TCP_FIN_WAIT1: {
         int tmo;
 
         /* If we enter the TCP_FIN_WAIT1 state and we are a
          * Fast Open socket and this is the first acceptable
          * ACK we have received, this would have acknowledged
          * our SYNACK so stop the SYNACK timer.
          */
         if (req) {
             /* Return RST if ack_seq is invalid.
              * Note that RFC793 only says to generate a
              * DUPACK for it but for TCP Fast Open it seems
              * better to treat this case like TCP_SYN_RECV
              * above.
              */
             if (!acceptable)
                 return ;
             /* We no longer need the request sock. */
             reqsk_fastopen_remove(sk, req, false);
             tcp_rearm_rto(sk);
         }
 
         /* 发送数据未确认完毕 */
         if (tp->snd_una != tp->write_seq)
             break;
 
         /* 进入FIN_WAIT_2状态 */
         tcp_set_state(sk, TCP_FIN_WAIT2);
 
         /* 关闭发送端 */
         sk->sk_shutdown |= SEND_SHUTDOWN;
 
         /* 路由缓存确认 */
         sk_dst_confirm(sk);
 
         /* 套接口不是DEAD状态，状态发生变化，唤醒等待进程 */
         if (!sock_flag(sk, SOCK_DEAD)) {
             /* Wake up lingering close() */
             sk->sk_state_change(sk);
             break;
         }
 
         /* linger2<0，无需在FIN_WAIT_2等待 */
         if (tp->linger2 < ) {
             /* 关闭连接 */
             tcp_done(sk);
             NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
             return ;
         }
 
         /* 收到期望序号以后的数据段(data, fin) */
         if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
             after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
             /* Receive out of order FIN after close() */
             if (tp->syn_fastopen && th->fin)
                 tcp_fastopen_active_disable(sk);
             /* 关闭连接 */
             tcp_done(sk);
             NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
             return ;
         }
 
         /* 获取FIN_WAIT_2等待时间 */
         tmo = tcp_fin_time(sk);
 
         /* > TIMEWAIT_LEN，加入FIN_WAIT_2定时器 */
         if (tmo > TCP_TIMEWAIT_LEN) {
             inet_csk_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN);
         }
         /* 有fin?? 或者 被用户进程锁定，加入FIN_WAIT_2定时器 */
         else if (th->fin || sock_owned_by_user(sk)) {
             /* Bad case. We could lose such FIN otherwise.
              * It is not a big problem, but it looks confusing
              * and not so rare event. We still can lose it now,
              * if it spins in bh_lock_sock(), but it is really
              * marginal case.
              */
             inet_csk_reset_keepalive_timer(sk, tmo);
         }
         /* 正常等待时间< TIMEWAIT_LEN，进入TIMEWAIT接管状态 */
         else {
             tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
             goto discard;
         }
         break;
     }
 }

状态转换触发

FIN_WAIT_2状态的走向有以下几个流程触发点，(1)TIME_WAIT_2定时器未超时时间内，收到数据段触发； (2)TIME_WAIT_2定时器超时触发； (3)TIME_WAIT定时器未超时时间内，收到数据段触发； (4)TIME_WAIT定时器超时触发；

(1) TIME_WAIT_2定时器未超时时间内，收到数据段触发，如果设置FIN标记，则直接进入TIME_WAIT状态；

在函数tcp_rcv_state_process处理数据段的过程中，FIN_WAIT_2状态最终会调用tcp_data_queue来处理数据段；

 int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
 {
         /* step 7: process the segment text */
     switch (sk->sk_state) {
     case TCP_CLOSE_WAIT:
     case TCP_CLOSING:
     case TCP_LAST_ACK:
         if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))
             break;
     case TCP_FIN_WAIT1:
     case TCP_FIN_WAIT2:
         /* RFC 793 says to queue data in these states,
          * RFC 1122 says we MUST send a reset.
          * BSD 4.4 also does reset.
          */
         if (sk->sk_shutdown & RCV_SHUTDOWN) {
             if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
                 after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
                 tcp_reset(sk);
                 return ;
             }
         }
         /* Fall through */
     case TCP_ESTABLISHED:
         tcp_data_queue(sk, skb);
         queued = ;
         break;
     }
 }

tcp_data_queue在处理数据段的时候，有对FIN标记的检查，如果有该标记，则进入tcp_fin函数；

 static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
 {
     /* ... */
     if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
         tcp_fin(sk);
     /* ... */
 }

tcp_fin函数中，如果此时连接状态为FIN_WAIT_2，则发送ACK，并且直接进入TIME_WAIT状态；在tcp_time_wait函数处理中，会删除当前控制块，所以FIN_WAIT_2定时器也就不存在了；

 void tcp_fin(struct sock *sk)
 {
         /* ... */
     switch (sk->sk_state) {
     case TCP_FIN_WAIT2:
         /* Received a FIN -- send ACK and enter TIME_WAIT. */
         tcp_send_ack(sk);
         tcp_time_wait(sk, TCP_TIME_WAIT, );
         break;
     }
         /* ... */
 }

(2)TIME_WAIT_2定时器超时触发，如果linger2<0，或者等待时间<=TIMEWAIT_LEN，直接发送reset关闭连接；如果linger2>=0，且等待时间>TIMEWAIT_LEN，则进入TIME_WAIT接管；

 static void tcp_keepalive_timer (unsigned long data)
 {
         /*...*/
     /* 处于fin_wait2且socket即将销毁，用作FIN_WAIT_2定时器 */
     if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) {
 
         /* 停留在FIN_WAIT_2的停留时间>=0 */
         if (tp->linger2 >= ) {
             /* 获取时间差值 */
             const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN;
 
             /* 差值>0，等待时间>TIME_WAIT时间，则进入TIME_WAIT状态 */
             if (tmo > ) {
                 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
                 goto out;
             }
         }
 
         /* 发送rst */
         tcp_send_active_reset(sk, GFP_ATOMIC);
         goto death;
     }
         /*...*/
 }

(3)TIME_WAIT定时器未超时时间内，收到数据段触发，若收到合法的FIN，则进入真正的TIME_WAIT状态；

tcp_v4_rcv收入数据段过程中，会对TIME_WAIT状态做特别处理，而对于TIME_WAIT子状态的处理在函数tcp_timewait_state_process中；

 int tcp_v4_rcv(struct sk_buff *skb)
 {
 /*...*/
 do_time_wait:
     if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
         inet_twsk_put(inet_twsk(sk));
         goto discard_it;
     }
 
     /* 校验和错误 */
     if (tcp_checksum_complete(skb)) {
         inet_twsk_put(inet_twsk(sk));
         goto csum_error;
     }
 
     /* TIME_WAIT入包处理 */
     switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
 
     /* 收到syn */
     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));
 
         /* 找到 */
         if (sk2) {
             /* 删除tw控制块 */
             inet_twsk_deschedule_put(inet_twsk(sk));
             /* 记录监听控制块 */
             sk = sk2;
             refcounted = false;
 
             /* 进行新请求的处理 */
             goto process;
         }
         /* Fall through to ACK */
     }
 
     /* 发送ack */
     case TCP_TW_ACK:
         tcp_v4_timewait_ack(sk, skb);
         break;
     /* 发送rst */
     case TCP_TW_RST:
         tcp_v4_send_reset(sk, skb);
         /* 删除tw控制块 */
         inet_twsk_deschedule_put(inet_twsk(sk));
         goto discard_it;
     /* 成功*/
     case TCP_TW_SUCCESS:;
     }
     goto discard_it;
 }

tcp_timewait_state_process函数处理流程中，如果TIME_WAIT的子状态为FIN_WAIT_2，并且收到了合法的FIN之后，会进入真正的TIME_WAIT状态，即子状态也为TIME_WAIT，并且设置TIME_WAIT定时器；

 enum tcp_tw_status
 tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,
                const struct tcphdr *th)
 {
         /*...*/
     /* 子状态是FIN_WAIT2 */
     if (tw->tw_substate == TCP_FIN_WAIT2) {
         /* Just repeat all the checks of tcp_rcv_state_process() */
 
         /* Out of window, send ACK */
         /* 序号回绕或者数据超出窗口范围，发送ack */
         if (paws_reject ||
             !tcp_in_window(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq,
                    tcptw->tw_rcv_nxt,
                    tcptw->tw_rcv_nxt + tcptw->tw_rcv_wnd))
             return tcp_timewait_check_oow_rate_limit(
                 tw, skb, LINUX_MIB_TCPACKSKIPPEDFINWAIT2);
 
         /* rst，则停止调度，销毁tw控制块 */
         if (th->rst)
             goto kill;
 
         /* syn && 序号>= 期望接收序号??? */
         if (th->syn && !before(TCP_SKB_CB(skb)->seq, tcptw->tw_rcv_nxt))
             return TCP_TW_RST;
 
         /* Dup ACK? */
         /* 非ack || 以前的ack || 新的无数据ack */
         if (!th->ack ||
             !after(TCP_SKB_CB(skb)->end_seq, tcptw->tw_rcv_nxt) ||
             TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq) {
             inet_twsk_put(tw);
             return TCP_TW_SUCCESS;
         }
 
         /* New data or FIN. If new data arrive after half-duplex close,
          * reset.
          */
         /* 不是fin，或者fin有数据 */
         if (!th->fin ||
             TCP_SKB_CB(skb)->end_seq != tcptw->tw_rcv_nxt + )
             return TCP_TW_RST;
 
         /* FIN arrived, enter true time-wait state. */
         /* fin包，进入真正的TIME_WAIT */
         tw->tw_substate      = TCP_TIME_WAIT;
 
         /* 设置下一次接收序号 */
         tcptw->tw_rcv_nxt = TCP_SKB_CB(skb)->end_seq;
 
         /* 设置时间戳 */
         if (tmp_opt.saw_tstamp) {
             tcptw->tw_ts_recent_stamp = get_seconds();
             tcptw->tw_ts_recent      = tmp_opt.rcv_tsval;
         }
 
         /*重新设置tw定时器 */
         inet_twsk_reschedule(tw, TCP_TIMEWAIT_LEN);
 
         /* 发送ack */
         return TCP_TW_ACK;
     }
         /*...*/
 }

(4)TIME_WAIT定时器超时触发，定时器超时，将tw控制块从ehash和bhash中删除，在收到数据段会发送reset；

定时器超时会进入到tw_timer_handler处理函数，该函数在统计信息之后，调用inet_twsk_kill;

 static void tw_timer_handler(unsigned long data)
 {
     struct inet_timewait_sock *tw = (struct inet_timewait_sock *)data;
 
     if (tw->tw_kill)
         __NET_INC_STATS(twsk_net(tw), LINUX_MIB_TIMEWAITKILLED);
     else
         __NET_INC_STATS(twsk_net(tw), LINUX_MIB_TIMEWAITED);
     inet_twsk_kill(tw);
 }

inet_twsk_kill从ehash和bhash中把tw控制块删除，并且释放之；

 static void inet_twsk_kill(struct inet_timewait_sock *tw)
 {
     struct inet_hashinfo *hashinfo = tw->tw_dr->hashinfo;
     spinlock_t *lock = inet_ehash_lockp(hashinfo, tw->tw_hash);
     struct inet_bind_hashbucket *bhead;
 
     spin_lock(lock);
     sk_nulls_del_node_init_rcu((struct sock *)tw);
     spin_unlock(lock);
 
     /* Disassociate with bind bucket. */
     bhead = &hashinfo->bhash[inet_bhashfn(twsk_net(tw), tw->tw_num,
             hashinfo->bhash_size)];
 
     spin_lock(&bhead->lock);
     inet_twsk_bind_unhash(tw, hashinfo);
     spin_unlock(&bhead->lock);
 
     atomic_dec(&tw->tw_dr->tw_count);
     inet_twsk_put(tw);
 }