内核协议栈tcp层的内存管理

我们先来看tcp内存管理相关的几个内核参数,这些都能通过proc文件系统来修改: 

Java代码  

1. ///内核写buf的最大值.  
2. extern __u32 sysctl_wmem_max;  
3. ///协议栈读buf的最大值  
4. extern __u32 sysctl_rmem_max;  

这两个值在/proc/sys/net/core 下。这里要注意，这两个值的单位是字节。 

它们的初始化在sk_init里面,这里可以看到这两个值的大小是依赖于num_physpages的，而这个值应该是物理页数。也就是说这两个值依赖于物理内存： 

Java代码  

1. void __init sk_init(void)  
2. {  
3.     if (num_physpages <= 4096) {  
4.         sysctl_wmem_max = 32767;  
5.         sysctl_rmem_max = 32767;  
6.         sysctl_wmem_default = 32767;  
7.         sysctl_rmem_default = 32767;  
8.     } else if (num_physpages >= 131072) {  
9.         sysctl_wmem_max = 131071;  
10.         sysctl_rmem_max = 131071;  
11.     }  
12. }  

而我通过搜索源码，只有设置套接口选项的时候，才会用到这两个值，也就是setsockopt，optname为SO_SNDBUF或者SO_RCVBUF时，来限制设置的值: 

Java代码  

1. case SO_SNDBUF:  
2.         if (val > sysctl_wmem_max)  
3.             val = sysctl_wmem_max;  

接下来就是整个tcp协议栈的socket的buf限制(也就是所有的socket). 
这里要注意，这个东西的单位都是以页为单位的，我们下面就会看到。 

Java代码  

1. 其中sysctl_tcp_mem[0]表示整个tcp sock的buf限制.  
2. sysctl_tcp_mem[1]也就是tcp sock内存使用的警戒线.  
3. sysctl_tcp_mem[2]也就是tcp sock内存使用的hard limit,当超过这个限制,我们就要禁止再分配buf.  
4. extern int sysctl_tcp_mem[3];  

接下来就是针对每个sock的读写buf限制。 

Java代码  

1. ///其中依次为最小buf,中等buf,以及最大buf.  
2. extern int sysctl_tcp_wmem[3];  
3. extern int sysctl_tcp_rmem[3];  

这几个值的初始化在tcp_init里面，这里就能清晰的看到sysctl_tcp_mem的单位是页。而sysctl_tcp_wmem和sysctl_tcp_rmem的单位是字节。 

Java代码  

1. void __init tcp_init(void)  
2. {  
3. .................................  
4. ///nr_pages就是页。  
5. nr_pages = totalram_pages - totalhigh_pages;  
6.     limit = min(nr_pages, 1UL<<(28-PAGE_SHIFT)) >> (20-PAGE_SHIFT);  
7.     limit = (limit * (nr_pages >> (20-PAGE_SHIFT))) >> (PAGE_SHIFT-11);  
8.     limit = max(limit, 128UL);  
9. sysctl_tcp_mem[0] = limit / 4 * 3;  
10. sysctl_tcp_mem[1] = limit;  
11. sysctl_tcp_mem[2] = sysctl_tcp_mem[0] * 2;  
12.   
13. /* Set per-socket limits to no more than 1/128 the pressure threshold */  
14. ///转换为字节。  
15. limit = ((unsigned long)sysctl_tcp_mem[1]) << (PAGE_SHIFT - 7);  
16. max_share = min(4UL*1024*1024, limit);  
17.   
18. sysctl_tcp_wmem[0] = SK_MEM_QUANTUM;  
19. sysctl_tcp_wmem[1] = 16*1024;  
20. sysctl_tcp_wmem[2] = max(64*1024, max_share);  
21.   
22. sysctl_tcp_rmem[0] = SK_MEM_QUANTUM;  
23. sysctl_tcp_rmem[1] = 87380;  
24. sysctl_tcp_rmem[2] = max(87380, max_share);  
25. ................................  
26. }  

然后就是读写buf的最小值 

Java代码  

1. #define SOCK_MIN_SNDBUF 2048  
2. #define SOCK_MIN_RCVBUF 256  

最后就是当前tcp协议栈已经分配了的buf的总大小。这里要注意，这个值也是以页为单位的。 

Java代码  

1. atomic_t tcp_memory_allocated  

而上面的这些值如何与协议栈关联起来呢，我们来看tcp_prot结构，可以看到这些值的地址都被放到对应的tcp_prot的域。 

Java代码  

1. struct proto tcp_prot = {  
2. .name = "TCP",  
3. .owner = THIS_MODULE,  
4. ...................................................  
5. .enter_memory_pressure = tcp_enter_memory_pressure,  
6. .sockets_allocated = &tcp_sockets_allocated,  
7. .orphan_count = &tcp_orphan_count,  
8. .memory_allocated = &tcp_memory_allocated,  
9. .memory_pressure = &tcp_memory_pressure,  
10. .sysctl_mem = sysctl_tcp_mem,  
11. .sysctl_wmem = sysctl_tcp_wmem,  
12. .sysctl_rmem = sysctl_tcp_rmem,  
13. ........................................................  
14. };  

而对应的sock域中的几个值，这几个域非常重要，我们来看他们表示的含义： 


sk_rcvbuf和sk_sndbuf,这两个值分别代表每个sock的读写buf的最大限制： 

sk_rmem_alloc和sk_wmem_alloc这两个值分别代表已经提交的数据包的字节数。 

读buf意味着进入tcp层的数据大小，而当数据提交给用户空间之后，这个值会相应的减去提交的大小（也就类似写buf的sk_wmem_queued)。 

写buf意味着提交给ip层。可以看到这个值的增加是在tcp_transmit_skb中进行的。 

而sk_wmem_queued也就代表skb的写队列write_queue的大小。 

还有一个sk_forward_alloc，这个值表示一个预分配置，也就是整个tcp协议栈的内存cache，第一次为一个缓冲区分配buf的时候，我们不会直接分配精确的大小，而是按页来分配，而分配的大小就是这个值，下面我们会看到这个。并且这个值初始是0. 

Java代码  

1. struct sock {  
2. int sk_rcvbuf;  
3. atomic_t sk_rmem_alloc;  
4. atomic_t sk_wmem_alloc;  
5. int sk_forward_alloc;  
6. ..........................  
7. int sk_sndbuf;  
8. ///这个表示写buf已经分配的字节长度  
9. int sk_wmem_queued;  
10. ...........................  
11. }  

sk_sndbuf和sk_rcvbuf,这两个的初始化在这里： 

Java代码  

1. static int tcp_v4_init_sock(struct sock *sk)  
2. {  
3. ..................................  
4.     sk->sk_sndbuf = sysctl_tcp_wmem[1];  
5.     sk->sk_rcvbuf = sysctl_tcp_rmem[1];  
6. ..........................  
7. }  

而当进入establish状态之后,sock会自己调整sndbuf和rcvbuf.他是通过tcp_init_buffer_space来进行调整的.这个函数会调用tcp_fixup_rcvbuf和tcp_fixup_sndbuf来调整读写buf的大小. 

这里有用到sk_userlock这个标记，这个标记主要就是用来标记SO_SNDBUF 和SO_RCVBUF套接口选项是否被设置。而是否设置对应的值为： 

Java代码  

1. #define SOCK_SNDBUF_LOCK    1  
2. #define SOCK_RCVBUF_LOCK    2  

我们可以看下面的设置SO_SNDBUF 和SO_RCVBUF的代码片断： 

Java代码  

1. //首先设置sk_userlocks.  
2. sk->sk_userlocks |= SOCK_SNDBUF_LOCK;  
3.         if ((val * 2) < SOCK_MIN_SNDBUF)  
4.             sk->sk_sndbuf = SOCK_MIN_SNDBUF;  
5.         else  
6.             sk->sk_sndbuf = val * 2;  

因此内核里面的处理是这样的，如果用户已经通过套接字选项设置了读或者写buf的大小，那么这里将不会调整读写buf的大小，否则就进入tcp_fixup_XXX来调整大小。 

还有一个要注意的就是MAX_TCP_HEADER，这个值表示了TCP + IP + link layer headers 以及option的长度。 

我们来看代码。 

Java代码  

1. static void tcp_init_buffer_space(struct sock *sk)  
2. {  
3.     struct tcp_sock *tp = tcp_sk(sk);  
4.     int maxwin;  
5.   
6. ///判断sk_userlocks，来决定是否需要fix缓冲区大小。  
7.     if (!(sk->sk_userlocks & SOCK_RCVBUF_LOCK))  
8.         tcp_fixup_rcvbuf(sk);  
9.     if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK))  
10.         tcp_fixup_sndbuf(sk);  
11. ......................................  
12.   
13. }  

接下来来看这两个函数如何来调整读写buf的大小，不过这里还有些疑问，就是为什么是要和3*sndmem以及4*rcvmem： 

Java代码  

1. static void tcp_fixup_sndbuf(struct sock *sk)  
2. {  
3. ///首先通过mss，tcp头，以及sk_buff的大小，得到一个最小范围的sndmem。  
4.     int sndmem = tcp_sk(sk)->rx_opt.mss_clamp + MAX_TCP_HEADER + 16 +sizeof(struct sk_buff);  
5.   
6. ///然后取sysctl_tcp_wmem[2]和3倍的sndmem之间的最小值。  
7.     if (sk->sk_sndbuf < 3 * sndmem)  
8.         sk->sk_sndbuf = min(3 * sndmem, sysctl_tcp_wmem[2]);  
9. }  
10.   
11. static void tcp_fixup_rcvbuf(struct sock *sk)  
12. {  
13.     struct tcp_sock *tp = tcp_sk(sk);  
14. ///这里和上面类似，也是先得到最小的一个rcvmem段。  
15.     int rcvmem = tp->advmss + MAX_TCP_HEADER + 16 + sizeof(struct sk_buff);  
16.   
17.     /* Try to select rcvbuf so that 4 mss-sized segments 
18.      * will fit to window and corresponding skbs will fit to our rcvbuf. 
19.      * (was 3; 4 is minimum to allow fast retransmit to work.) 
20.      */  
21. ///这里则是通过sysctl_tcp_adv_win_scale来调整rcvmem的值。  
22.     while (tcp_win_from_space(rcvmem) < tp->advmss)  
23.         rcvmem += 128;  
24.     if (sk->sk_rcvbuf < 4 * rcvmem)  
25.         sk->sk_rcvbuf = min(4 * rcvmem, sysctl_tcp_rmem[2]);  
26. }  

ok，看完初始化，我们来看协议栈具体如何管理内存的，先来看发送端，发送端的主要实现是在tcp_sendmsg里面，这个函数我们前面已经详细的分析过了，我们这次只分析里面几个与内存相关的东西。 

来看代码片断： 

Java代码  

1. int tcp_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,  
2.         size_t size)  
3. {  
4. ..................................  
5.   
6.     if (copy <= 0) {  
7. new_segment:  
8.     if (!sk_stream_memory_free(sk))  
9.             goto wait_for_sndbuf;  
10.   
11.     skb = sk_stream_alloc_skb(sk, select_size(sk),  
12.     sk->sk_allocation);  
13. if (sk->sk_route_caps & NETIF_F_ALL_CSUM)  
14.         skb->ip_summed = CHECKSUM_PARTIAL;  
15.   
16.         skb_entail(sk, skb);  
17.         copy = size_goal;  
18.         max = size_goal;  
19. ..................  
20. }  

可以看到这里第一个sk_stream_memory_free用来判断是否还有空间来供我们分配，如果没有则跳到wait_for_sndbuf来等待buf的释放。 

然后如果有空间供我们分配，则调用sk_stream_alloc_skb来分配一个skb，然后这个大小的选择是通过select_size。 

最后调用skb_entail来更新相关的域。 

现在我们就来详细看上面的四个函数,先来看第一个： 

Java代码  

1. static inline int sk_stream_memory_free(struct sock *sk)  
2. {  
3.     return sk->sk_wmem_queued < sk->sk_sndbuf;  
4. }  

sk_stream_memory_free实现很简单，就是判断当前已经分配的写缓冲区的大小(sk_wmem_queued)是否小于当前写缓冲区(sk_sndbuf)的最大限制。 

然后是skb_entail，这个函数主要是当我们分配完buf后，进行一些相关域的更新，以及添加skb到writequeue。 

Java代码  

1. static inline void skb_entail(struct sock *sk, struct sk_buff *skb)  
2. {  
3.     struct tcp_sock *tp = tcp_sk(sk);  
4.     struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);  
5. ............................  
6.     skb_header_release(skb);  
7.     tcp_add_write_queue_tail(sk, skb);  
8. ///增加sk_wmem_queued.  
9.     sk->sk_wmem_queued += skb->truesize;  
10. ///这里调整sk_forward_alloc的大小，也就是预分配buf的大小(减小).  
11.     sk_mem_charge(sk, skb->truesize);  
12.     if (tp->nonagle & TCP_NAGLE_PUSH)  
13.         tp->nonagle &= ~TCP_NAGLE_PUSH;  
14. }  
15. ///这个函数很简单，就是将sk_forward_alloc - size.  
16. static inline void sk_mem_charge(struct sock *sk, int size)  
17. {  
18.     if (!sk_has_account(sk))  
19.         return;  
20.     sk->sk_forward_alloc -= size;  
21. }  

然后是select_size，在看这个之前我们先来坎SKB_MAX_HEAD的实现. 
SKB_MAX_HEAD主要是得到要分配的tcp数据段（不包括头)在一页中最大为多少。 

Java代码  

1. #define SKB_WITH_OVERHEAD(X)    \  
2.     ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))  
3. #define SKB_MAX_ORDER(X, ORDER) \  
4.     SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))  
5. #define SKB_MAX_HEAD(X)     (SKB_MAX_ORDER((X), 0))  

我们带入代码来看，我们下面的代码是SKB_MAX_HEAD(MAX_TCP_HEADER)，展开这个宏可以看到就是PAGE_SIZE-MAX_TCP_HEADER-SKB_DATA_ALIGN(sizeof(struct skb_shared_info).其实也就是一页还能容纳多少tcp的数据。 

Java代码  

1. static inline int select_size(struct sock *sk)  
2. {  
3.     struct tcp_sock *tp = tcp_sk(sk);  
4. ///首先取得存储的mss。  
5.     int tmp = tp->mss_cache;  
6.   
7. ///然后判断是否使用scatter–gather(前面blog有介绍)  
8. if (sk->sk_route_caps & NETIF_F_SG) {  
9.     if (sk_can_gso(sk))  
10.             tmp = 0;  
11.     else {  
12. ///然后开始计算buf的长度。  
13.         int pgbreak = SKB_MAX_HEAD(MAX_TCP_HEADER);  
14.   
15. ///如果mss大于pgbreak,那么说明我们一页放不下当前需要的tcp数据，因此我们将会在skb的页区域分配，而skb的页区域是有限制的，因此tmp必须小于这个值。  
16. if (tmp >= pgbreak &&  
17.     tmp <= pgbreak + (MAX_SKB_FRAGS - 1) * PAGE_SIZE)  
18.             tmp = pgbreak;  
19.         }  
20.     }  
21.   
22.     return tmp;  
23. }  

接下来来看sk_stream_alloc_skb的实现。 

1 它会调用alloc_skb_fclone来分配内存，这个函数就不详细分析了，我们只需要知道它会从slab里分配一块内存，而大小为size+max_header(上面的分析我们知道slect_size只计算数据段). 

2 如果分配成功，则调用sk_wmem_schedule来判断我们所分配的skb的大小是否精确，是的话，就调整指针，然后返回。 

3 否则调用tcp_enter_memory_pressure设置标志进入TCP memory pressure zone。然后再调用sk_stream_moderate_sndbuf调整sndbuf(缩小sndbuf)。 

Java代码  

1. struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp)  
2. {  
3.     struct sk_buff *skb;  
4.   
5. ///4字节对其  
6.     size = ALIGN(size, 4);  
7. ///分配skb。  
8.     skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);  
9.     if (skb) {  
10. ///得到精确的大小。  
11.         if (sk_wmem_schedule(sk, skb->truesize)) {  
12. ///返回skb。  
13.         skb_reserve(skb, skb_tailroom(skb) - size);  
14.             return skb;  
15.         }  
16.         __kfree_skb(skb);  
17.     } else {  
18. ///否则设置全局标记进入pressure zone  
19.         sk->sk_prot->enter_memory_pressure(sk);  
20.         sk_stream_moderate_sndbuf(sk);  
21.     }  
22.     return NULL;  
23. }  

ok,现在就来看上面的几个函数的实现。先来看几个简单的。 

首先是tcp_enter_memory_pressure,这个函数很简单，就是判断全局标记tcp_memory_pressure,然后设置这个标记。这个标记主要是用来通知其他模块调整的，比如窗口大小等等，详细的话自己搜索这个值，就知道了。 

Java代码  

1. void tcp_enter_memory_pressure(struct sock *sk)  
2. {  
3.     if (!tcp_memory_pressure) {  
4.         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);  
5. ///设置压力标志。  
6.         tcp_memory_pressure = 1;  
7.     }  
8. }  

然后是sk_stream_moderate_sndbuf，这个函数也是要使用sk_userlocks,来判断是否已经被用户设置了。可以看到如果我们自己设置过了snd_buf的话，内核就不会帮我们调整它的大小了。 

Java代码  

1. static inline void sk_stream_moderate_sndbuf(struct sock *sk)  
2. {  
3.     if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {  
4. ///它的大小调整为大于最小值，小于sk->sk_wmem_queued >> 1。  
5.         sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);  
6.         sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);  
7.     }  
8. }  

最后来看最核心的一个函数sk_wmem_schedule，这个函数只是对__sk_mem_schedule的简单封装。这里要知道传递进来的size是skb->truesize，也就是所分配的skb的真实大小。并且第一次进入这个函数，也就是分配第一个缓冲区包时，sk_forward_alloc是为0的，也就是说，第一次必然会执行__sk_mem_schedule函数。 

Java代码  

1. static inline int sk_wmem_schedule(struct sock *sk, int size)  
2. {  
3.     if (!sk_has_account(sk))  
4.         return 1;  
5. ///先比较size(也就是skb->truesize)和预分配的内存大小。如果小于等于预分配的大小，则直接返回，否则调用__sk_mem_schedule进行调整。  
6.     return size <= sk->sk_forward_alloc ||  
7.         __sk_mem_schedule(sk, size, SK_MEM_SEND);  
8. }  

来看__sk_mem_schedule，这个函数的功能注释写的很清楚： 

引用

increase sk_forward_alloc and memory_allocated

然后来看源码。这里在看之前，我们要知道，协议栈通过读写buf的使用量，划分了3个区域，或者说标志。不同标志进行不同处理。这里的区域的划分是通过sysctl_tcp_mem，也就是prot->sysctl_mem这个数组进行的。 

Java代码  

1. ///页的大小  
2. #define SK_MEM_QUANTUM ((int)PAGE_SIZE)  
3.   
4. int __sk_mem_schedule(struct sock *sk, int size, int kind)  
5. {  
6.     struct proto *prot = sk->sk_prot;  
7. ///首先得到size占用几个内存页。  
8.     int amt = sk_mem_pages(size);  
9.     int allocated;  
10. ///更新sk_forward_alloc，可以看到这个值是页的大小的倍数。  
11.     sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;  
12.   
13. ///amt+memory_allocated也就是当前的总得内存使用量加上将要分配的内存的话，现在的tcp协议栈的总得内存使用量。（可以看到是以页为单位的。  
14.     allocated = atomic_add_return(amt, prot->memory_allocated);  
15.   
16. ///然后开始判断，将会落入哪一个区域。通过上面的分析我们知道sysctl_mem也就是sysctl_tcp_mem.  
17.   
18. ///先判断是否小于等于内存最小使用限额。  
19.     if (allocated <= prot->sysctl_mem[0]) {  
20. ///这里取消memory_pressure，然后返回。  
21.         if (prot->memory_pressure && *prot->memory_pressure)  
22.             *prot->memory_pressure = 0;  
23.         return 1;  
24.     }  
25.   
26. //然后判断Under pressure。  
27.     if (allocated > prot->sysctl_mem[1])  
28. //大于sysctl_mem[1]说明，已经进入pressure，一次你需要调用tcp_enter_memory_pressure来设置标志。  
29.         if (prot->enter_memory_pressure)  
30.             prot->enter_memory_pressure(sk);  
31.   
32. ///如果超过的hard limit。则进入另外的处理。  
33.     if (allocated > prot->sysctl_mem[2])  
34.         goto suppress_allocation;  
35.   
36. //判断类型，这里只有两种类型，读和写。总的内存大小判断完，这里开始判断单独的sock的读写内存。  
37.     if (kind == SK_MEM_RECV) {  
38.         if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])  
39.             return 1;  
40.     } else { /* SK_MEM_SEND */  
41. ///这里当为tcp的时候，写队列的大小只有当对端数据确认后才会更新，因此我们要用sk_wmem_queued来判断。  
42.         if (sk->sk_type == SOCK_STREAM) {  
43.             if (sk->sk_wmem_queued < prot->sysctl_wmem[0])  
44.                 return 1;  
45.         } else if (atomic_read(&sk->sk_wmem_alloc) <  
46.                prot->sysctl_wmem[0])  
47.                 return 1;  
48.     }  
49.   
50. ///程序到达这里说明总的内存大小在sysctl_mem[0]和sysctl_mem[2]之间，因此我们再次判断memory_pressure  
51.     if (prot->memory_pressure) {  
52.         int alloc;  
53.   
54. ///如果没有在memory_pressure区域，则我们直接返回1。  
55.         if (!*prot->memory_pressure)  
56.             return 1;  
57. ///这个其实也就是计算整个系统分配的socket的多少。  
58.         alloc = percpu_counter_read_positive(prot->sockets_allocated);  
59. ///这里假设其余的每个sock所占用的buf都和当前的sock一样大的时候，如果他们的总和小于sysctl_mem[2],也就是hard limit。那么我们也认为这次内存请求是成功的。  
60.         if (prot->sysctl_mem[2] > alloc *  
61.             sk_mem_pages(sk->sk_wmem_queued +  
62.              atomic_read(&sk->sk_rmem_alloc) +  
63.                  sk->sk_forward_alloc))  
64.             return 1;  
65.     }  
66.   
67. suppress_allocation:  
68.   
69. ///到达这里说明，我们超过了hard limit或者说处于presure 区域。  
70.     if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {  
71. ///调整sk_sndbuf(减小).这个函数前面已经分析过了。  
72.         sk_stream_moderate_sndbuf(sk);  
73. ///然后比较和sk_sndbuf的大小，如果大于的话，就说明下次我们再次要分配buf的时候会在tcp_memory_free阻塞住，因此这次我们返回1.  
74.         if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)  
75.             return 1;  
76.     }  
77.   
78.     /* Alas. Undo changes. */  
79. ///到达这里说明，请求内存是不被接受的，因此undo所有的操作。然后返回0.  
80.     sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;  
81.     atomic_sub(amt, prot->memory_allocated);  
82.     return 0;  
83. }  

接下来来看个很重要的函数skb_set_owner_w。 

顾名思义，这个函数也就是将一个skb和scok关联起来。只不过关联的时候更新sock相应的域。我们来看源码： 

Java代码  

1. static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)  
2. {  
3.     skb_orphan(skb);  
4. ///与传递进来的sock关联起来  
5.     skb->sk = sk;  
6. ///设置skb的析构函数  
7.     skb->destructor = sock_wfree;  
8. ///更新sk_wmem_alloc域，就是sk_wmem_alloc+truesize.  
9.     atomic_add(skb->truesize, &sk->sk_wmem_alloc);  
10. }  

ok，接下来来看个scok_wfree函数，这个函数做得基本和上面函数相反。这个函数都是被kfree_skb自动调用的。 

Java代码  

1. void sock_wfree(struct sk_buff *skb)  
2. {  
3.     struct sock *sk = skb->sk;  
4.     int res;  
5.   
6. ///更新sk_wmem_alloc,减去skb的大小。  
7.     res = atomic_sub_return(skb->truesize, &sk->sk_wmem_alloc);  
8.     if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))  
9. ///唤醒等待队列，也就是唤醒等待内存分配。  
10.         sk->sk_write_space(sk);  
11.     if (res == 0)  
12.         __sk_free(sk);  
13. }  

而skb_set_owner_w是什么时候被调用呢，我们通过搜索代码可以看到，它是在tcp_transmit_skb中被调用的。而tcp_transmit_skb我们知道是传递数据包到ip层的函数。 

而kfree_skb被调用也就是在对端已经确认完我们发送的包后才会被调用来释放skb。 

接下来来看接收数据的内存管理。我们主要来看tcp_rcv_established这个函数，我前面的blog已经断断续续的分析过了，因此这里我们只看一些重要的代码片断。 

这里我们要知道，代码能到达下面的位置，则说明，数据并没有直接拷贝到用户空间。否则的话，是不会进入下面的片断的。 

Java代码  

1.               
2. if (!eaten) {  
3. ..........................................  
4.   
5. ///如果skb的大小大于预分配的值,如果大于则要另外处理。  
6.     if ((int)skb->truesize > sk->sk_forward_alloc)  
7.             goto step5;  
8.         __skb_pull(skb, tcp_header_len);  
9.                 __skb_queue_tail(&sk->sk_receive_queue, skb);  
10. ///这里关联skb和对应的sk，并且更新相关的域，我们下面会分析这个函数。  
11.         skb_set_owner_r(skb, sk);  
12.         tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;  
13.         }  
14. ...............................................  
15.   
16. step5:  
17.     if (th->ack && tcp_ack(sk, skb, FLAG_SLOWPATH) < 0)  
18.         goto discard;  
19.   
20.     tcp_rcv_rtt_measure_ts(sk, skb);  
21.   
22.     /* Process urgent data. */  
23.     tcp_urg(sk, skb, th);  
24.   
25.     /* step 7: process the segment text */  
26. ///最核心的函数就是这个。我们接下来会详细分析这个函数。  
27.     tcp_data_queue(sk, skb);  
28.   
29.     tcp_data_snd_check(sk);  
30.     tcp_ack_snd_check(sk);  
31.     return 0;  

先来看skb_set_owner_r函数，这个函数关联skb和sk其实它和skb_set_owner_w类似： 

Java代码  

1. static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)  
2. {  
3.     skb_orphan(skb);  
4. ///关联sk  
5.     skb->sk = sk;  
6. //设置析构函数  
7.     skb->destructor = sock_rfree;  
8. ///更新rmem_alloc  
9.     atomic_add(skb->truesize, &sk->sk_rmem_alloc);  
10. ///改变forward_alloc.  
11.     sk_mem_charge(sk, skb->truesize);  
12. }  

然后是tcp_data_queue，这个函数主要用来排队接收数据，并update相关的读buf。由于这个函数比较复杂，我们只关心我们感兴趣的部分： 

Java代码  

1. static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)  
2. {  
3.     struct tcphdr *th = tcp_hdr(skb);  
4.     struct tcp_sock *tp = tcp_sk(sk);  
5.     int eaten = -1;  
6. .......................................  
7. ///首先判断skb的开始序列号和我们想要接收的序列号。如果相等开始处理这个数据包(也就是拷贝到用户空间).  
8.     if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {  
9.         if (tcp_receive_window(tp) == 0)  
10.             goto out_of_window;  
11.   
12. //tp的ucopy我前面的blog已经详细分析过了。这里就不解释了。  
13.         if (tp->ucopy.task == current &&  
14.             tp->copied_seq == tp->rcv_nxt && tp->ucopy.len &&sock_owned_by_user(sk) && !tp->urg_data)  
15. {  
16. ///计算将要拷贝给用户空间的大小。  
17.             int chunk = min_t(unsigned int, skb->len,tp->ucopy.len);  
18.   
19. ///设置状态，说明我们处于进程上下文。  
20.             __set_current_state(TASK_RUNNING);  
21.   
22.             local_bh_enable();  
23. ///拷贝skb  
24.             if (!skb_copy_datagram_iovec(skb, 0, tp->ucopy.iov, chunk)) {  
25.                 tp->ucopy.len -= chunk;  
26.                 tp->copied_seq += chunk;  
27. ///更新eaten，它的默认值为-1.  
28.         eaten = (chunk == skb->len && !th->fin);  
29.         tcp_rcv_space_adjust(sk);  
30.             }  
31.             local_bh_disable();  
32.         }  
33.   
34. ///如果小于0则说明没有拷贝成功，或者说就没有进行拷贝。此时需要更新sock的相关域。  
35.     if (eaten <= 0) {  
36. queue_and_out:  
37. ///最关键的tcp_try_rmem_schedule函数。接下来会详细分析。  
38.     if (eaten < 0 &&  
39.          tcp_try_rmem_schedule(sk, skb->truesize))  
40.                 goto drop;  
41.   
42. ///关联skb和sk。到达这里说明tcp_try_rmem_schedule成功，也就是返回0.  
43.         skb_set_owner_r(skb, sk);  
44. ///加skb到receive_queue.  
45.         __skb_queue_tail(&sk->sk_receive_queue, skb);  
46.         }  
47. ///更新期待序列号。  
48.         tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;  
49. ..............................................  
50.         }  
51. .....................................  
52.   
53.         tcp_fast_path_check(sk);  
54.   
55.         if (eaten > 0)  
56.             __kfree_skb(skb);  
57.         else if (!sock_flag(sk, SOCK_DEAD))  
58.             sk->sk_data_ready(sk, 0);  
59.         return;  
60.     }  
61. ///下面就是处理乱序包。以后会详细分析。  
62. ......................................  
63. }  

接下来我们就来看tcp_try_rmem_schedule这个函数,这个函数如果返回0则说明sk_rmem_schedule返回1,而sk_rmem_schedule和sk_wmem_schedule是一样的。也就是看当前的skb加入后有没有超过读buf的限制。并更新相关的域。： 

Java代码  

1. static inline int tcp_try_rmem_schedule(struct sock *sk, unsigned int size)  
2. {  
3. ///首先判断rmem_alloc(当前的读buf字节数)是否大于最大buf字节数，如果大于则调用tcp_prune_queue调整分配的buf。否则调用sk_rmem_schedule来调整相关域（sk_forward_alloc）。  
4.     if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||!sk_rmem_schedule(sk, size)) {  
5.   
6. ///调整分配的buf。  
7.         if (tcp_prune_queue(sk) < 0)  
8.             return -1;  
9. ///更新sk的相关域。  
10.         if (!sk_rmem_schedule(sk, size)) {  
11.             if (!tcp_prune_ofo_queue(sk))  
12.                 return -1;  
13.   
14.             if (!sk_rmem_schedule(sk, size))  
15.                 return -1;  
16.         }  
17.     }  
18.     return 0;  
19. }  

来看sk_rmem_schedule，这个函数很简单，就是封装了__sk_mem_schedule。而这个函数我们上面已经分析过了。 

Java代码  

1. static inline int sk_rmem_schedule(struct sock *sk, int size)  
2. {  
3.     if (!sk_has_account(sk))  
4.         return 1;  
5.     return size <= sk->sk_forward_alloc ||  
6.         __sk_mem_schedule(sk, size, SK_MEM_RECV);  
7. }  

最后是tcp_prune_queue，这个函数主要是用来丢掉一些skb，因为到这个函数就说明我们的内存使用已经到极限了，因此我们要合并一些buf。这个合并也就是将序列号连续的段进行合并。 

这里我们要知道tcp的包是有序的，因此内核中tcp专门有一个队列来保存那些Out of order segments。因此我们这里会先处理这个队列里面的skb。 

然后调用tcp_collapse来处理接收队列里面的skb。和上面的类似。 

这里要注意，合并的话都是按页来合并，也就是先分配一页大小的内存，然后将老的skb复制进去，最后free掉老的buf。 

Java代码  

1. static int tcp_prune_queue(struct sock *sk)  
2. {  
3.     struct tcp_sock *tp = tcp_sk(sk);  
4. ..................................  
5. ///如果rmem_alloc过于大，则重新计算窗口的大小。一半都会缩小窗口。  
6.     if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)  
7.         tcp_clamp_window(sk);  
8. ///如果处于pressure区域，则调整窗口大小。这里也是缩小窗口。  
9.     else if (tcp_memory_pressure)  
10.         tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);  
11.   
12. ///处理ofo队列。  
13.     tcp_collapse_ofo_queue(sk);  
14. ///如果接收队列为非空，则调用tcp_collapse来处理sk_receive_queue  
15.     if (!skb_queue_empty(&sk->sk_receive_queue))  
16.         tcp_collapse(sk, &sk->sk_receive_queue,  
17.                  skb_peek(&sk->sk_receive_queue),  
18.                  NULL,  
19.                  tp->copied_seq, tp->rcv_nxt);  
20. ///更新全局的已分配内存的大小，也就是memory_allocated，接下来会详细介绍这个函数。  
21.     sk_mem_reclaim(sk);  
22.   
23. ///如果调整后小于sk_rcvbuf,则返回0.  
24.     if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)  
25.         return 0;  
26.   
27. ......................................  
28.     return -1;  
29. }  

来看sk_mem_reclaim函数，它只是简单的封装了__sk_mem_reclaim： 

Java代码  

1. static inline void sk_mem_reclaim(struct sock *sk)  
2. {  
3.     if (!sk_has_account(sk))  
4.         return;  
5. ///如果sk_forward_alloc大于1页则调用__sk_mem_reclaim，我们知道sk_forward_alloc是以页为单位的，因此这里也就是和大于0一样。  
6.     if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)  
7.         __sk_mem_reclaim(sk);  
8. }  

这里我们对tcp_collapse和tcp_collapse_ofo_queue对没有详细分析，只是简要的描述了下。 

__sk_mem_reclaim就是真正操作的函数，它会更新memory_allocated： 

Java代码  

1. void __sk_mem_reclaim(struct sock *sk)  
2. {  
3.     struct proto *prot = sk->sk_prot;  
4. //更新memory_allocated，这里我们知道memory_allocated也是以页为单位的，因此需要将sk_forward_alloc转化为页。  
5.     atomic_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,prot->memory_allocated);  
6.   
7. //更新这个sk的sk_forward_alloc为一页。  
8.     sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;  
9. ///判断是否处于pressure区域，是的话更新memory_pressure变量。  
10.     if (prot->memory_pressure && *prot->memory_pressure &&(atomic_read(prot->memory_allocated) < （prot->sysctl_mem[0]))  
11.         *prot->memory_pressure = 0;  
12. }  

最后看一下读buf的释放。这个函数会在kfree_skb中被调用。 

Java代码  

1. void sock_rfree(struct sk_buff *skb)  
2. {  
3.   
4.     struct sock *sk = skb->sk;  
5. ///更新rmem_alloc  
6.     atomic_sub(skb->truesize, &sk->sk_rmem_alloc);  
7. ///更新forward_alloc.  
8.     sk_mem_uncharge(skb->sk, skb->truesize);  
9. }