内核处理time_wait状态详解

这次来详细看内核的time_wait状态的实现，在前面介绍定时器的时候，time_wait就简单的介绍了下。这里我们会先介绍tw状态的实现，然后来介绍内核协议栈如何处理tw状态。 

首先我们要知道在linux内核中time_wait的处理是由tcp_time_wait这个函数来做得，比如我们在closing状态收到一个fin，就会调用tcp_time_wait.而内核为time_wait状态的socket专门设计了一个结构就是inet_timewait_sock，并且是挂载在inet_ehash_bucket的tw上(这个结构前面也已经介绍过了)。这里要注意，端口号的那个hash链表中也是会保存time_wait状态的socket的。 

Java代码  

1. struct inet_timewait_sock {  
2.   
3. ///common也就是包含了一些socket的必要信息。  
4.     struct sock_common  __tw_common;  
5. #define tw_family       __tw_common.skc_family  
6. #define tw_state        __tw_common.skc_state  
7. #define tw_reuse        __tw_common.skc_reuse  
8. #define tw_bound_dev_if     __tw_common.skc_bound_dev_if  
9. #define tw_node         __tw_common.skc_nulls_node  
10. #define tw_bind_node        __tw_common.skc_bind_node  
11. #define tw_refcnt       __tw_common.skc_refcnt  
12. #define tw_hash         __tw_common.skc_hash  
13. #define tw_prot         __tw_common.skc_prot  
14. #define tw_net          __tw_common.skc_net  
15.   
16. ///tw状态的超时时间  
17.     int         tw_timeout;  
18. ///这个用来标记我们是正常进入tw还是说由于超时等一系列原因进入(比如超时等一系列原因)  
19.     volatile unsigned char  tw_substate;  
20.     /* 3 bits hole, try to pack */  
21. ///和tcp option中的接收窗口比例类似  
22.     unsigned char       tw_rcv_wscale;  
23.   
24. ///也就是标示sock的4个域，源目的端口和地址  
25.     __be16          tw_sport;  
26.     __be32          tw_daddr __attribute__((aligned(INET_TIMEWAIT_ADDRCMP_ALIGN_BYTES)));  
27.     __be32          tw_rcv_saddr;  
28.     __be16          tw_dport;  
29. ///本地端口。  
30.     __u16           tw_num;  
31.     kmemcheck_bitfield_begin(flags);  
32.     /* And these are ours. */  
33. ///几个标记位。  
34.     unsigned int        tw_ipv6only     : 1,  
35.                 tw_transparent  : 1,  
36.                 tw_pad      : 14,   /* 14 bits hole */  
37.                 tw_ipv6_offset  : 16;  
38.     kmemcheck_bitfield_end(flags);  
39.     unsigned long       tw_ttd;  
40. ///链接到端口的hash表中。  
41.     struct inet_bind_bucket *tw_tb;  
42. //链接到全局的tw状态hash表中。  
43.     struct hlist_node   tw_death_node;  
44. };  

然后我们要知道linux有两种方式执行tw状态的socket，一种是等待2×MSL时间（内核中是60秒)，一种是基于RTO来计算超时时间。 

基于RTO的超时时间也叫做recycle模式，这里内核会通过sysctl_tw_recycle（也就是说我们能通过sysctl来打开这个值)以及是否我们还保存有从对端接收到的最近的数据包的时间戳来判断是否进入打开recycle模式的处理。如果进入则会调用tcp_v4_remember_stamp来得到是否打开recycle模式。 

下面就是这个片断的代码片断： 

Java代码  

1. //必须要设置sysctl_tw_recycle以及保存有最后一次的时间戳.  
2. if (tcp_death_row.sysctl_tw_recycle && tp->rx_opt.ts_recent_stamp)  
3. //然后调用remember_stamp（在ipv4中被初始化为tcp_v4_remember_stamp）来得到是否要打开recycle模式。  
4.     recycle_ok = icsk->icsk_af_ops->remember_stamp(sk);  

然后我们来看tcp_v4_remember_stamp，在看这个之前，我们需要理解inet_peer结构，这个结构也就是保存了何当前主机通信的主机的一些信息，我前面在分析ip层的时候有详细分析这个结构，因此可以看我前面的blog： 

http://simohayha.iteye.com/blog/437695 


tcp_v4_remember_stamp主要用来从全局的inet_peer中得到对应的当前sock的对端的信息(通过ip地址).然后设置相关的时间戳(tcp_ts_stamp和tcp_ts）.这里要特别注意一个东西，那就是inet_peer是ip层的东西，因此它的key是ip地址，它会忽略端口号。所以说这里inet_peer的这两个时间戳是专门为解决tw状态而设置的。 

然后我们来看下tcp option的几个关键的域： 

Java代码  

1. struct tcp_options_received {  
2. /*  PAWS/RTTM data  */  
3.   
4. //这个值为我们本机更新ts_recent的时间  
5.     long    ts_recent_stamp;  
6. //这个表示最近接收的那个数据包的时间戳  
7.     u32 ts_recent;  
8. //这个表示这个数据包发送时的时间戳    
9.     u32 rcv_tsval;  
10. //这个表示当前数据包所回应的数据包的时间戳。  
11.     u32 rcv_tsecr;  
12. ///如果上面两个时间戳都有设置，则saw_tstamp设置为1.  
13.     u16     saw_tstamp : 1,   
14. //TIMESTAMP seen on SYN packet  
15.         tstamp_ok : 1,    
16. //d-scack标记  
17.         dsack : 1,  
18. //Wscale seen on SYN packet  
19.         wscale_ok : 1,  
20. //SACK seen on SYN packet     
21.         sack_ok : 4,  
22. ///下面两个是窗口扩大倍数，主要是为了解决一些特殊网络下大窗口的问题。  
23.         snd_wscale : 4,   
24.         rcv_wscale : 4;   
25. /*  SACKs data  */  
26.     u8  num_sacks;    
27.     u16 user_mss;     
28.     u16 mss_clamp;    
29. };  

而inet_peer中的两个时间戳与option中的ts_recent和ts_recent_stamp类似。 

来看tcp_v4_remember_stamp的实现： 

Java代码  

1. int tcp_v4_remember_stamp(struct sock *sk)  
2. {  
3.     struct inet_sock *inet = inet_sk(sk);  
4.     struct tcp_sock *tp = tcp_sk(sk);  
5.     struct rtable *rt = (struct rtable *)__sk_dst_get(sk);  
6.     struct inet_peer *peer = NULL;  
7.     int release_it = 0;  
8.   
9. //得到对应peer（两种得到的方式)。  
10.     if (!rt || rt->rt_dst != inet->daddr) {  
11.         peer = inet_getpeer(inet->daddr, 1);  
12.         release_it = 1;  
13.     } else {  
14.         if (!rt->peer)  
15.             rt_bind_peer(rt, 1);  
16.         peer = rt->peer;  
17.     }  
18.   
19. ///如果peer不存在则会返回0,也就是关闭recycle模式。  
20.     if (peer) {  
21. //这里tcp_ts以及tcp_ts_stamp保存的是最新的时间戳，所以这里与当前的sock的时间戳比较小的话就要更新。  
22.     if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||(peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&  
23.      peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {  
24.   
25. ///更新时间戳。  
26.     peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;  
27.         peer->tcp_ts = tp->rx_opt.ts_recent;  
28.         }  
29.         if (release_it)  
30.             inet_putpeer(peer);  
31.         return 1;  
32.     }  
33.   
34. //关闭recycle模式。  
35.     return 0;  
36. }  

ok,我们来看tcp_time_wait的实现，这里删掉了ipv6以及md5的部分： 

Java代码  

1. ///这里也就是2*MSL=60秒。  
2. #define TCP_TIMEWAIT_LEN (60*HZ)   
3.   
4. ///这里的state标记我们是正常进入tw状态，还是由于死在fin-wait-2状态才进入tw状态的。  
5. void tcp_time_wait(struct sock *sk, int state, int timeo)  
6. {  
7. //TW的socket  
8.     struct inet_timewait_sock *tw = NULL;  
9.     const struct inet_connection_sock *icsk = inet_csk(sk);  
10.     const struct tcp_sock *tp = tcp_sk(sk);  
11.   
12. //recycle模式的标记。  
13.     int recycle_ok = 0;  
14.   
15. ///上面已经分析过了。  
16.     if (tcp_death_row.sysctl_tw_recycle && tp->rx_opt.ts_recent_stamp)  
17.     recycle_ok = icsk->icsk_af_ops->remember_stamp(sk);  
18. //然后判断tw状态的sock数量是否已经超过限制。  
19.     if (tcp_death_row.tw_count < tcp_death_row.sysctl_max_tw_buckets)  
20. //没有的话alloc一个新的。  
21.         tw = inet_twsk_alloc(sk, state);  
22.   
23. ///如果tw不为空才会进入处理。  
24.     if (tw != NULL) {  
25.     struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);  
26. //计算对应的超时时间，这里可以看到刚好是3.5*rto.  
27.                const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1);  
28. ///更新对应的域。  
29.     tw->tw_rcv_wscale    = tp->rx_opt.rcv_wscale;  
30.     tcptw->tw_rcv_nxt    = tp->rcv_nxt;  
31.     tcptw->tw_snd_nxt    = tp->snd_nxt;  
32.     tcptw->tw_rcv_wnd    = tcp_receive_window(tp);  
33.     tcptw->tw_ts_recent  = tp->rx_opt.ts_recent;  
34.     tcptw->tw_ts_recent_stamp = tp->rx_opt.ts_recent_stamp;  
35.   
36. //更新链表(下面会分析)。  
37.         __inet_twsk_hashdance(tw, sk, &tcp_hashinfo);  
38. //如果传递进来的超时时间小于我们计算的，则让他等于我们计算的超时时间。  
39.         /* Get the TIME_WAIT timeout firing. */  
40.         if (timeo < rto)  
41.             timeo = rto;  
42.   
43. ///如果打开recycle模式，则超时时间为我们基于rto计算的时间。  
44.         if (recycle_ok) {  
45.             tw->tw_timeout = rto;  
46.         } else {  
47. ///否则为2*MSL=60秒  
48.             tw->tw_timeout = TCP_TIMEWAIT_LEN;  
49. ///如果正常进入则timeo也就是超时时间为2*MSL.  
50.             if (state == TCP_TIME_WAIT)  
51.                 timeo = TCP_TIMEWAIT_LEN;  
52.         }  
53.   
54. ///最关键的一个函数，我们后面会详细分析。  
55.         inet_twsk_schedule(tw, &tcp_death_row, timeo,  
56.                    TCP_TIMEWAIT_LEN);  
57. ///更新引用计数。  
58.         inet_twsk_put(tw);  
59.     } else {  
60.     LIMIT_NETDEBUG(KERN_INFO "TCP: time wait bucket table overflow\n");  
61.     }  
62.     tcp_update_metrics(sk);  
63.     tcp_done(sk);  
64. }  

然后我们来看__inet_twsk_hashdance函数，这个函数主要是用于更新对应的全局hash表。有关这几个hash表的结构可以去看我前面的blog。 

Java代码  

1. void __inet_twsk_hashdance(struct inet_timewait_sock *tw, struct sock *sk,  
2.                struct inet_hashinfo *hashinfo)  
3. {  
4.     const struct inet_sock *inet = inet_sk(sk);  
5.     const struct inet_connection_sock *icsk = inet_csk(sk);  
6. //得到ehash。  
7.     struct inet_ehash_bucket *ehead = inet_ehash_bucket(hashinfo, sk->sk_hash);  
8.     spinlock_t *lock = inet_ehash_lockp(hashinfo, sk->sk_hash);  
9.     struct inet_bind_hashbucket *bhead;  
10.   
11. //下面这几步是将tw sock链接到bhash中。  
12.     bhead = &hashinfo->bhash[inet_bhashfn(twsk_net(tw), inet->num,hashinfo->bhash_size)];  
13.     spin_lock(&bhead->lock);  
14. ///链接到bhash。这里icsk的icsk_bind_hash也就是bash的一个元素。  
15.     tw->tw_tb = icsk->icsk_bind_hash;  
16.     WARN_ON(!icsk->icsk_bind_hash);  
17. ///将tw加入到bash中。  
18.     inet_twsk_add_bind_node(tw, &tw->tw_tb->owners);  
19.     spin_unlock(&bhead->lock);  
20.   
21.     spin_lock(lock);  
22.   
23.   
24.     atomic_inc(&tw->tw_refcnt);  
25. //将tw sock加入到ehash的tw chain中。  
26.     inet_twsk_add_node_rcu(tw, &ehead->twchain);  
27.   
28. //然后从全局的establish hash中remove掉这个socket。详见sock的sk_common域。  
29.     if (__sk_nulls_del_node_init_rcu(sk))  
30.         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);  
31.   
32.     spin_unlock(lock);  
33. }  

这里我们要知道还有一个专门的全局的struct inet_timewait_death_row类型的变量tcp_death_row来保存所有的tw状态的socket。而整个tw状态的socket并不是全部加入到定时器中，而是将tcp_death_row加入到定时器中，然后每次定时器超时通过tcp_death_row来查看定时器的超时情况，从而处理tw状态的sock。 

而这里定时器分为两种，一种是长时间的定时器，它也就是tw_timer域，一种是短时间的定时器，它也就是twcal_timer域。 

而这里还有两个hash表，一个是twcal_row，它对应twcal_timer这个定时器，也就是说当twcal_timer超时，它就会从twcal_row中取得对应的twsock。对应的cells保存的就是tw_timer定时器超时所用的twsock。 

还有两个slot，一个是slot域，一个是twcal_hand域，分别表示当前对应的定时器(上面介绍的两个)所正在执行的定时器的slot。 

而上面所说的recycle模式也就是指twcal_timer定时器。 

来看结构。 

Java代码  

1. struct inet_timewait_death_row {  
2.   
3. ///这几个域会在tcp_death_row中被初始化。  
4.     int         twcal_hand;  
5.     unsigned long       twcal_jiffie;  
6. //短时间定时器。  
7.     struct timer_list   twcal_timer;  
8. ///twcal_timer定时器对应的hash表  
9.     struct hlist_head   twcal_row[INET_TWDR_RECYCLE_SLOTS];  
10.   
11.     spinlock_t      death_lock;  
12. ///tw的个数。  
13.     int         tw_count;  
14. //超时时间。  
15.     int         period;  
16.     u32         thread_slots;  
17.     struct work_struct  twkill_work;  
18. ///长时间定时器  
19.     struct timer_list   tw_timer;  
20.     int         slot;  
21.   
22. //短时间的定时器对应的hash表  
23.     struct hlist_head   cells[INET_TWDR_TWKILL_SLOTS];  
24.     struct inet_hashinfo    *hashinfo;  
25.     int         sysctl_tw_recycle;  
26.     int         sysctl_max_tw_buckets;  
27. };  

这里要注意INET_TWDR_TWKILL_SLOTS为8,而INET_TWDR_RECYCLE_SLOTS为32。 

ok我们接着来看tcp_death_row的初始化。 

Java代码  

1. struct inet_timewait_death_row tcp_death_row = {  
2.   
3. ///最大桶的个数。  
4.     .sysctl_max_tw_buckets = NR_FILE * 2,  
5. //超时时间，  
6.     .period     = TCP_TIMEWAIT_LEN / INET_TWDR_TWKILL_SLOTS,  
7. //锁  
8.     .death_lock = __SPIN_LOCK_UNLOCKED(tcp_death_row.death_lock),  
9.   
10. ///可以看到它是链接到全局的inet_hashinfo中的。  
11.     .hashinfo   = &tcp_hashinfo,  
12. //定时器，这里要注意超时函数。  
13.     .tw_timer   = TIMER_INITIALIZER(inet_twdr_hangman, 0,(unsigned long)&tcp_death_row),  
14. //工作队列。其实也就是销毁twsock工作的工作队列。  
15.     .twkill_work    = __WORK_INITIALIZER(tcp_death_row.twkill_work,                   inet_twdr_twkill_work),  
16. /* Short-time timewait calendar */  
17.   
18. //twcal_hand用来标记twcal_timer定时器是否还在工作。  
19.     .twcal_hand = -1,  
20.     .twcal_timer    = TIMER_INITIALIZER(inet_twdr_twcal_tick, 0,(unsigned long)&tcp_death_row),  
21. };  

然后就是inet_twsk_schedule的实现，这个函数也就是tw状态的处理函数。他主要是用来基于超时时间来计算当前twsock的可用的位置。也就是来判断启动那个定时器，然后加入到那个队列。 

因此这里的关键就是slot的计算。这里slot的计算是根据我们传递进来的timeo来计算的。 

recycle模式下tcp_death_row的超时时间的就为2的INET_TWDR_RECYCLE_TICK幂。 

我们一般桌面的hz为100,来看对应的值： 

Java代码  

1. #elif HZ <= 128  
2. # define INET_TWDR_RECYCLE_TICK (7 + 2 - INET_TWDR_RECYCLE_SLOTS_LOG)  

可以看到这时它的值就为4. 

而tw_timer的slot也就是长时间定时器的slot的计算是这样的，它也就是用我们传递进来的超时时间timeo/16(可以看到就是2的INET_TWDR_RECYCLE_TICK次方)然后向上取整。 

而这里twdr的period被设置为 

Java代码  

1. TCP_TIMEWAIT_LEN / INET_TWDR_TWKILL_SLOTS,  
2.   
3. //取slot的代码片断。  
4. slot = DIV_ROUND_UP(timeo, twdr->period);  

而我们下面取slot的时候也就是会用这个值来散列。可以看到散列表的桶的数目就为INET_TWDR_TWKILL_SLOTS个，因此这里也就是把时间分为INET_TWDR_TWKILL_SLOTS份，每一段时间内的超时twsock都放在一个桶里面，而大于60秒的都放在最后一个桶。 

Java代码  

1. void inet_twsk_schedule(struct inet_timewait_sock *tw,  
2.                struct inet_timewait_death_row *twdr,  
3.                const int timeo, const int timewait_len)  
4. {  
5.     struct hlist_head *list;  
6.     int slot;  
7.   
8. //得到slot。  
9.     slot = (timeo + (1 << INET_TWDR_RECYCLE_TICK) - 1) >> INET_TWDR_RECYCLE_TICK;  
10.   
11.     spin_lock(&twdr->death_lock);  
12.   
13.     /* Unlink it, if it was scheduled */  
14.     if (inet_twsk_del_dead_node(tw))  
15.         twdr->tw_count--;  
16.     else  
17.         atomic_inc(&tw->tw_refcnt);  
18.   
19. ///判断该添加到那个定时器。  
20.     if (slot >= INET_TWDR_RECYCLE_SLOTS) {  
21.         /* Schedule to slow timer */  
22. ///如果大于timewait_len也就是2*MSL=60秒，则slot为cells的最后一项。  
23.         if (timeo >= timewait_len) {  
24. ///设为最后一项。  
25.             slot = INET_TWDR_TWKILL_SLOTS - 1;  
26.         } else {  
27. //否则timeo除于period然后向上取整。  
28.             slot = DIV_ROUND_UP(timeo, twdr->period);  
29. //如果大于cells的桶的大小，则也是放到最后一个位置。  
30.             if (slot >= INET_TWDR_TWKILL_SLOTS)  
31.                 slot = INET_TWDR_TWKILL_SLOTS - 1;  
32.         }  
33. //然后设置超时时间，  
34.         tw->tw_ttd = jiffies + timeo;  
35. ///而twdr的slot为当前正在处理的slot，因此我们需要以这个slot为基准来计算真正的slot  
36.         slot = (twdr->slot + slot) & (INET_TWDR_TWKILL_SLOTS - 1);  
37. //最后取得对应的链表。  
38.         list = &twdr->cells[slot];  
39.     } else {  
40. ///设置应当超时的时间。  
41.         tw->tw_ttd = jiffies + (slot << INET_TWDR_RECYCLE_TICK);  
42. //判断定时器是否还在工作。如果是第一次我们一定会进入下面的处理  
43.         if (twdr->twcal_hand < 0) {  
44. //如果没有或者第一次进入，则修改定时器然后重新启动定时器  
45.             twdr->twcal_hand = 0;  
46.             twdr->twcal_jiffie = jiffies;  
47. //定时器的超时时间。可以看到时间为我们传进来的timeo(只不过象tick对齐了)  
48.             twdr->twcal_timer.expires = twdr->twcal_jiffie +(slot << INET_TWDR_RECYCLE_TICK);  
49. //重新添加定时器。  
50.             add_timer(&twdr->twcal_timer);  
51.         } else {  
52. //如果原本超时时间太小，则修改定时器的超时时间  
53.     if (time_after(twdr->twcal_timer.expires,  
54.         jiffies + (slot << INET_TWDR_RECYCLE_TICK)))  
55.     mod_timer(&twdr->twcal_timer,  
56.     jiffies + (slot << INET_TWDR_RECYCLE_TICK));  
57.   
58. //和上面的tw_timer定时器类似，我们要通过当前正在执行的slot也就是twcal_hand来得到真正的slot。  
59.         slot = (twdr->twcal_hand + slot) & (INET_TWDR_RECYCLE_SLOTS - 1);  
60.              }  
61. ///取得该插入的桶。  
62.         list = &twdr->twcal_row[slot];  
63.     }  
64.   
65. ///将tw加入到对应的链表中。  
66.     hlist_add_head(&tw->tw_death_node, list);  
67. ///如果第一次则启动定时器。  
68.     if (twdr->tw_count++ == 0)  
69.         mod_timer(&twdr->tw_timer, jiffies + twdr->period);  
70.     spin_unlock(&twdr->death_lock);  
71. }  

我们先来总结一下上面的代码。当我们进入tw状态，然后我们会根据计算出来的timeo的不同来加载到不同的hash表中。而对应的定时器一个（tw_timer)是每peroid启动一次，一个是每(slot << INET_TWDR_RECYCLE_TICK)启动一次。 

下面的两张图很好的表示了recycle模式(twcal定时器)和非recycle模式的区别： 

先是非recycle模式： 




然后是recycle模式： 






接下来我们来看两个超时函数的实现，这里我只简单的介绍下两个超时函数，一个是inet_twdr_hangman，一个是inet_twdr_twcal_tick。 

在inet_twdr_hangman中，每次只是遍历对应的slot的队列，然后将队列中的所有sock删除，同时也从bind_hash中删除对应的端口信息。这个函数就不详细分析了。 

而在inet_twdr_twcal_tick中，每次遍历所有的twcal_row，然后超时的进行处理(和上面一样),然后没有超时的继续处理). 

这里有一个j的计算要注意，前面我们知道我们的twcal的超时时间可以说都是以INET_TWDR_RECYCLE_SLOTS对齐的，而我们这里在处理超时的同时，有可能上面又有很多sock加入到了tw状态，因此这里我们的超时检测的间隔就是1 << INET_TWDR_RECYCLE_TICK。 

来看inet_twdr_twcal_tick的实现： 

Java代码  

1. void inet_twdr_twcal_tick(unsigned long data)  
2. {  
3. ............................  
4.     if (twdr->twcal_hand < 0)  
5.         goto out;  
6.   
7. //得到slot。  
8.     slot = twdr->twcal_hand;  
9. //得到定时器启动时候的jiffes。  
10.     j = twdr->twcal_jiffie;  
11.   
12. //遍历所有的twscok。  
13.     for (n = 0; n < INET_TWDR_RECYCLE_SLOTS; n++) {  
14. //判断是否超时。  
15.         if (time_before_eq(j, now)) {  
16. ///处理超时的socket  
17.             struct hlist_node *node, *safe;  
18.             struct inet_timewait_sock *tw;  
19. .......................................  
20.         } else {  
21.             if (!adv) {  
22.                 adv = 1;  
23.                 twdr->twcal_jiffie = j;  
24.                 twdr->twcal_hand = slot;  
25.             }  
26.   
27. //如果不为空，则将重新添加这些定时器  
28.         if (!hlist_empty(&twdr->twcal_row[slot])) {  
29.             mod_timer(&twdr->twcal_timer, j);  
30.                 goto out;  
31.             }  
32.         }  
33. //设置间隔  
34.         j += 1 << INET_TWDR_RECYCLE_TICK;  
35. //更新  
36.         slot = (slot + 1) & (INET_TWDR_RECYCLE_SLOTS - 1);  
37.     }  
38. //处理完毕则将twcal_hand设为-1.  
39.     twdr->twcal_hand = -1;  
40.   
41. ...............................  
42. }  

然后我们来看tcp怎么样进入tw状态。这里分为两种，一种是正常进入也就是在wait2收到一个fin，或者closing收到ack。这种都是比较简单的。我们就不分析了。 

比较特殊的是，我们有可能会直接从wait1进入tw状态，或者是在wait2等待超时也将会直接进入tw状态。这个时候也就是没有收到对端的fin。 

这个主要是为了处理当对端死在close_wait状态的时候，我们需要自己能够恢复到close状态，而不是一直处于wait2状态。 

在看代码之前我们需要知道一个东西，那就是fin超时时间，这个超时时间我们可以通过TCP_LINGER2这个option来设置，并且这个值的最大值是sysctl_tcp_fin_timeout/HZ. 这里可以看到sysctl_tcp_fin_timeout是jiffies数，所以要转成秒。我这里简单的测试了下，linger2的默认值也就是60,刚好是2*MSL. 

这里linger2也就是代表在tcp_wait2的最大生命周期。如果小于0则说明我们要跳过tw状态。 

先来看在tcp_close中的处理，不过这里不理解为什么这么做的原因。 

这里为什么有可能会为wait2状态呢，原因是如果设置了linger，则我们就会休眠掉，而休眠的时间可能我们已经收到ack，此时将会进入wait2的处理。 

Java代码  

1. if (sk->sk_state == TCP_FIN_WAIT2) {  
2.         struct tcp_sock *tp = tcp_sk(sk);  
3. //如果小于0,则说明从wait2立即超时此时也就是相当于跳过tw状态，所以我们直接发送rst，然后进入close。  
4.         if (tp->linger2 < 0) {  
5.             tcp_set_state(sk, TCP_CLOSE);  
6.             tcp_send_active_reset(sk, GFP_ATOMIC);  
7.             NET_INC_STATS_BH(sock_net(sk),  
8.                     LINUX_MIB_TCPABORTONLINGER);  
9.         } else {  
10. //否则计算fin的时间，这里的超时时间是在linger2和3.5RTO之间取最大值。  
11.             const int tmo = tcp_fin_time(sk);  
12.   
13. //如果超时时间很大，则说明我们需要等待时间很长，因此我们启动keepalive探测对端是否存活。  
14.             if (tmo > TCP_TIMEWAIT_LEN) {  
15.             inet_csk_reset_keepalive_timer(sk,  
16.                 tmo - TCP_TIMEWAIT_LEN);  
17.             } else {  
18. //否则我们直接进入tw状态。  
19.                 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);  
20.                 goto out;  
21.             }  
22.         }  
23.     }  

还有从wait1直接进入tw，和上面类似，我就不介绍了。 


最后我们来看当内核处于tw状态后，再次接收到数据包后如何处理。这里的处理函数就是tcp_timewait_state_process，而他是在tcp_v4_rcv中被调用的，它会先判断是否处于tw状态，如果是的话，进入tw的处理。 

这个函数的返回值分为4种。 

Java代码  

1. enum tcp_tw_status  
2. {  
3. //这个代表我们成功处理了数据包。  
4.     TCP_TW_SUCCESS = 0,  
5. //我们需要发送给对端一个rst。  
6.     TCP_TW_RST = 1,  
7. //我们接收到了重传的fin，因此我们需要重传ack。  
8.     TCP_TW_ACK = 2,  
9. //这个表示我们需要重新建立一个连接。  
10.     TCP_TW_SYN = 3  
11. };  

这里可能最后一个比较难理解，这里内核注释得很详细，主要是实现了RFC1122: 

引用

RFC 1122: 
"When a connection is [...] on TIME-WAIT state [...] [a TCP] MAY accept a new SYN from the remote TCP to reopen the connection directly, if it: 
(1)  assigns its initial sequence number for the new  connection to be larger than the largest sequence number it used on the previous connection incarnation,and 

(2)  returns to TIME-WAIT state if the SYN turns out 
to be an old duplicate". 

来看这段处理代码： 

Java代码  

1. switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {  
2.     case TCP_TW_SYN: {  
3. //取得一个sk。  
4.     struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),&tcp_hashinfo,  
5. iph->daddr, th->dest,inet_iif(skb));  
6.         if (sk2) {  
7. //从tw中删除，然后继续执行（也就是开始三次握手)。  
8.             inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);  
9.             inet_twsk_put(inet_twsk(sk));  
10.             sk = sk2;  
11.             goto process;  
12.         }  
13.         /* Fall through to ACK */  
14.     }  
15.     case TCP_TW_ACK:  
16. //发送ack  
17.         tcp_v4_timewait_ack(sk, skb);  
18.         break;  
19. //发送给对端rst。  
20.     case TCP_TW_RST:  
21.         goto no_tcp_socket;  
22. //处理成功  
23.     case TCP_TW_SUCCESS:;  
24.     }  
25.     goto discard_it;  

tcp_timewait_state_process这个函数具体的实现我就不介绍了，它就是分为两部分，一部分处理tw_substate == TCP_FIN_WAIT2的情况，一部分是正常情况。在前一种情况，我们对于syn的相应是直接rst的。而后一种我们需要判断是否新建连接。 

而对于fin的处理他们也是不一样的，wait2的话，它会将当前的tw重新加入到定时器列表(inet_twsk_schedule).而后一种则只是重新发送ack。