Linux內核--網絡協議棧深入分析(二)--sk_buff的操作函數

本文分析基於Linux Kernel 3.2.1

更多請查看 Linux內核--網絡內核實現分析

1、alloc_skb()函數

該函數的作用是在上層協議要發送數據包的時候或網絡設備准備接收數據包的時候會調用alloc_skb()函數分配sk_buff結構體，需要釋放時調用kfree_skb()函數。

1. static inline struct sk_buff *alloc_skb(unsigned int size,  
2.                     gfp_t priority)  
3. {  
4.     return __alloc_skb(size, priority, 0, NUMA_NO_NODE);  
5. } 

這裡使用內聯函數，非內聯函數調用會進堆棧的切換，造成額外的開銷，而內聯函數可以解決這一點，可以提高執行效率，只是增加了程序的空間開銷。

函數調用需要時間和空間開銷，調用函數實際上將程序執行流程轉移到被調函數中，被調函數的代碼執行完後，再返回到調用的地方。這種調用操作要求調用前保護好現場並記憶執行的地址，返回後恢復現場，並按原來保存的地址繼續執行。對於較長的函數這種開銷可以忽略不計，但對於一些函數體代碼很短，又被頻繁調用的函數，就不能忽視這種開銷。引入內聯函數正是為了解決這個問題，提高程序的運行效率。

1. /*  Allocate a new skbuff. We do this ourselves so we can fill in a few 
2.  *  'private' fields and also do memory statistics to find all the 
3.  *  [BEEP] leaks. 
4.  * 
5.  */  
6.   
7. /** 
8.  *  __alloc_skb -   allocate a network buffer 
9.  *  @size: size to allocate 
10.  *  @gfp_mask: allocation mask 
11.  *  @fclone: allocate from fclone cache instead of head cache 
12.  *      and allocate a cloned (child) skb 
13.  *  @node: numa node to allocate memory on 
14.  * 
15.  *  Allocate a new &sk_buff. The returned buffer has no headroom and a 
16.  *  tail room of size bytes. The object has a reference count of one. 
17.  *  The return is the buffer. On a failure the return is %NULL. 
18.  * 
19.  *  Buffers may only be allocated from interrupts using a @gfp_mask of 
20.  *  %GFP_ATOMIC. 
21.  */  
22. struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,  
23.                 int fclone, int node)  
24. {  
25.     struct kmem_cache *cache;  
26.     struct skb_shared_info *shinfo;  
27.     struct sk_buff *skb;  
28.     u8 *data;  
29.   
30.     cache = fclone ? skbuff_fclone_cache : skbuff_head_cache;  
31.   
32.     /* Get the HEAD */  
33.     skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node);//分配存儲空間   
34.     if (!skb)  
35.         goto out;//分配失敗，返回NULL   
36.     prefetchw(skb);  
37.   
38.     /* We do our best to align skb_shared_info on a separate cache 
39.      * line. It usually works because kmalloc(X > SMP_CACHE_BYTES) gives 
40.      * aligned memory blocks, unless SLUB/SLAB debug is enabled. 
41.      * Both skb->head and skb_shared_info are cache line aligned. 
42.      */  
43.     size = SKB_DATA_ALIGN(size);//調整skb大小   
44.     size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));  
45.     data = kmalloc_node_track_caller(size, gfp_mask, node);//分配數據區   
46.     if (!data)  
47.         goto nodata;  
48.     /* kmalloc(size) might give us more room than requested. 
49.      * Put skb_shared_info exactly at the end of allocated zone, 
50.      * to allow max possible filling before reallocation. 
51.      */  
52.     size = SKB_WITH_OVERHEAD(ksize(data));  
53.     prefetchw(data + size);  
54.   
55.     /* 
56.      * Only clear those fields we need to clear, not those that we will 
57.      * actually initialise below. Hence, don't put any more fields after 
58.      * the tail pointer in struct sk_buff! 
59.      */  
60.      //sk_buff結構體中最後6個屬性不能改變位置，只能在最後   
61.     memset(skb, 0, offsetof(struct sk_buff, tail));//將sk_buff結構體中tail屬性之前的屬性清零   
62.     /* Account for allocated memory : skb + skb->head */  
63.     skb->truesize = SKB_TRUESIZE(size);//計算緩沖區的尺寸   
64.     atomic_set(&skb->users, 1);  
65.     //初始化數據區的指針   
66.     skb->head = data;  
67.     skb->data = data;  
68.     skb_reset_tail_pointer(skb);  
69.     skb->end = skb->tail + size;  
70. #ifdef NET_SKBUFF_DATA_USES_OFFSET   
71.     skb->mac_header = ~0U;  
72. #endif   
73.   
74.     /* make sure we initialize shinfo sequentially */  
75.     //初始化skb_shared_info   
76.     shinfo = skb_shinfo(skb);  
77.     memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));  
78.     atomic_set(&shinfo->dataref, 1);  
79.     kmemcheck_annotate_variable(shinfo->destructor_arg);  
80.   
81.     if (fclone) {  
82.         struct sk_buff *child = skb + 1;  
83.         atomic_t *fclone_ref = (atomic_t *) (child + 1);  
84.   
85.         kmemcheck_annotate_bitfield(child, flags1);  
86.         kmemcheck_annotate_bitfield(child, flags2);  
87.         skb->fclone = SKB_FCLONE_ORIG;  
88.         atomic_set(fclone_ref, 1);  
89.   
90.         child->fclone = SKB_FCLONE_UNAVAILABLE;  
91.     }  
92. out:  
93.     return skb;  
94. nodata:  
95.     kmem_cache_free(cache, skb);  
96.     skb = NULL;  
97.     goto out;  
98. }