TCP/IP源码学习(54)——TCP的连接过程的实现(3)

作者：[e-mail]
博客：blog.focus-linux.net   linuxfocus.blog.chinaunix.net 

 

本文的copyleft归[e-mail]所有，使用GPL发布，可以自由拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。

======================================================================================================

上文在学习处理三次握手的最后一个ack的过程中，还没有完全走完流程。根据上文最后处

1. int tcp_child_process(struct sock *parent, struct sock *child,
   
2.          struct sk_buff *skb)
   
3. {
   
4.     int ret = 0;
   
5.     int state = child->sk_state;
   
6. 
   
7.     if (!sock_owned_by_user(child)) {
   
8.         //到达这里
9.         ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb),
   
10.                      skb->len);
    
11.         /* Wakeup parent, send SIGIO */
    
12.         if (state == TCP_SYN_RECV && child->sk_state != state)
    
13.             parent->sk_data_ready(parent, 0);
    
14.     } 
15.     ...... ......
16. }

那么包的处理仍然是交给tcp_rcv_state_process。回忆第一篇文章中，tcp_rcv_state_process是根据child的状态来决定如何处理。而child是从父socket生成的。如果child的状态和父socket状态一样，肯定是有问题的。那么child的状态是何时改变的呢？

经过一番搜索，回到创建child的函数tcp_v4_sync_recv_sock->tcp_create_openreq_child->inet_csk_clone

1. struct sock *inet_csk_clone(struct sock *sk, const struct request_sock *req,
   
2.              const gfp_t priority)
   
3. {
   
4.     //首先clone统一的sock结构信息
5.     struct sock *newsk = sk_clone(sk, priority);
   
6. 
   
7.     if (newsk != NULL) {
   
8.         //开始clone 面向连接的sock的信息
9.         struct inet_connection_sock *newicsk = inet_csk(newsk);
   
10.         //在这里，newsk的状态被设置为TCP_SYN_RECV
11.         newsk->sk_state = TCP_SYN_RECV;
    
12.         newicsk->icsk_bind_hash = NULL;
    
13. 
    
14.         ...... ......
15.     }
    
16.     return newsk;
    
17. }

说实话，这个结果让我觉得有些不爽。

首先这个函数名字叫做clone，结果生成的sock内部成员与传入的sock的内部成员不同，确实让我意想不到。另外这个函数是为所有面向连接的协议准备的。其名字为csk即connection sock，另外其位置位于inet_connection_sock.c中，都说明了这一点。这样的话，将其状态设置为TCP_SYN_RECV，与其通用性不符。

下面查看tcp_rcv_state_process处理TCP_SYN_RECV状态的代码：

1. int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
   
2.              const struct tcphdr *th, unsigned int len)
   
3. {
   
4.     struct tcp_sock *tp = tcp_sk(sk);
   
5.     struct inet_connection_sock *icsk = inet_csk(sk);
   
6.     int queued = 0;
   
7.     int res;
   
8. 
   
9.     tp->rx_opt.saw_tstamp = 0;
   

     

      ...... ......

1. 
   
2.     res = tcp_validate_incoming(sk, skb, th, 0);
3.     if (res <= 0)
   
4.         return -res;
   
5. 
   
6.     /* step 5: check the ACK field */
   
7.     if (th->ack) {
   
8.         //检查是否接受这个ack包
9.         int acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH) > 0;
   
10. 
    
11.         switch (sk->sk_state) {
    
12.         case TCP_SYN_RECV:
    
13.             if (acceptable) {
    
14.                 tp->copied_seq = tp->rcv_nxt;
    
15.                 smp_mb();
    
16.                 //完成了三次握手，sk的状态自然改为 TCP_ESTABLISHED
17.                 tcp_set_state(sk, TCP_ESTABLISHED);
    
18.                 //sk_state_change默认为sock_def_wakeup, 会唤醒sleep在该socket上的进程
19.                 sk->sk_state_change(sk);
    
20. 
    
21.                 /* Note, that this wakeup is only for marginal
    
22.                  * crossed SYN case. Passively open sockets
    
23.                  * are not waked up, because sk->sk_sleep ==
    
24.                  * NULL and sk->sk_socket == NULL.
    
25.                  */
    
26.                 //这里也仍然是一个wake动作，但是按照我的理解
27.                 //这里应该是处理socket作为文件描述符的异步操作，如epoll
28.                 if (sk->sk_socket)
    
29.                     sk_wake_async(sk,
    
30.                          SOCK_WAKE_IO, POLL_OUT);
    
31. 
    
32.                 tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
    
33.                 tp->snd_wnd = ntohs(th->window) <<
    
34.                      tp->rx_opt.snd_wscale;
    
35.                 tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
    
36. 
    
37.                 if (tp->rx_opt.tstamp_ok)
    
38.                     tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;
    
39. 
    
40.                 /* Make sure socket is routed, for
    
41.                  * correct metrics.
    
42.                  */
    
43.                 icsk->icsk_af_ops->rebuild_header(sk);
    
44. 
    
45.                 tcp_init_metrics(sk);
    
46. 
    
47.                 tcp_init_congestion_control(sk);
    
48. 
    
49.                 /* Prevent spurious tcp_cwnd_restart() on
    
50.                  * first data packet.
    
51.                  */
    
52.                 tp->lsndtime = tcp_time_stamp;
    
53. 
    
54.                 tcp_mtup_init(sk);
    
55.                 tcp_initialize_rcv_mss(sk);
    
56.                 tcp_init_buffer_space(sk);
    
57.                 tcp_fast_path_on(tp);
    
58.             } else {
    
59.                 return 1;
    
60.             }
    
61.             break;
    
62. 
    
63.         }
64.     } else
    
65.         goto discard;
    
66. 
    
67.     /* step 6: check the URG bit */
    
68.     tcp_urg(sk, skb, th);
    
69. 
    
70.     /* step 7: process the segment text */
    
71.     //这时sk->sk_state的状态已经为TCP_ESTABLISHED
72.     /* 其实对于这个ack包，它只含有TCP的首部，没有数据。那么我认为在将tcp置为established后，不需要后面的操     作了 */
73.     switch (sk->sk_state) {
    
74.         ...... ......
75.     case TCP_ESTABLISHED:
76.         tcp_data_queue(sk, skb);
    
77.         queued = 1;
    
78.         break;
    
79.     }
    
80. 
    
81.     /* tcp_data could move socket to TIME-WAIT */
    
82.     if (sk->sk_state != TCP_CLOSE) {
    
83.         tcp_data_snd_check(sk);
    
84.         tcp_ack_snd_check(sk);
    
85.     }
    
86. 
    
87.     if (!queued) {
    
88. discard:
    
89.         __kfree_skb(skb);
    
90.     }
    
91.     return 0;
    
92. }

这里处理完毕后，回到tcp_child_process

1. int tcp_child_process(struct sock *parent, struct sock *child,
   
2.          struct sk_buff *skb)
   
3. {
   
4.     int ret = 0;
   
5.     int state = child->sk_state;
   
6. 
   
7.     if (!sock_owned_by_user(child)) {
   
8.         ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb),
   
9.                      skb->len);
   
10.         /* Wakeup parent, send SIGIO */
    
11.         /*
12.         对于这个ack包，state的状态即为child之前的状态，即TCP_SYN_RECV。
13.         再成功处理了ack包后，child->sk_state变为TCP_ESTABLISHED
14.         因此进入parent->sk_data_ready，仍然是一个异步通知的手段
15.         */
16.         if (state == TCP_SYN_RECV && child->sk_state != state)
    
17.             parent->sk_data_ready(parent, 0);
    
18.     } 

      ...... ......

1. }

这样这个ack包基本上已经处理完毕。但是还有一个问题，这个新建的child socket是何时添加到TCP的ehash中，即已经连接的hash表中。还是要回到tcp_v4_syn_recv_sock中，在该函数的结尾处，调用了__inet_hash_nolisten(newsk, NULL);将newsk加入父socket的ehash表中的。

为啥要将这个newsk加入到父socket的ehash表中呢？其实socket下面的ehash表就是全局变量tcp_hashinfo的ehash表。那么这里也就是将newsk加入到了全局变量tcp_hashinfo的ehash中。也就是说所有的已连接的TCP，都是保存在一个公共的hash表中。这样，再收到后面的包时，都可以匹配从全局的tcp_hashinfo的ehash中直接匹配到这个新连接的TCP。