linux内核sk_buff的结构分析

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

内核版本是2.6.32. 

在内核中sk_buff表示一个网络数据包，它是一个双向链表，而链表头就是sk_buff_head,在老的内核里面sk_buff会有一个list域直接指向sk_buff_head也就是链表头，现在在2.6.32里面这个域已经被删除了。 

而sk_buff的内存布局可以分作3个段，第一个就是sk_buff自身，第二个是linear-data buff,第三个是paged-data buff（也就是skb_shared_info）。 

ok.我们先来看sk_buff_head的结构。它也就是所有sk_buff的头。 

1. struct sk_buff_head {  
2.     /* These two members must be first. */  
3.     struct sk_buff  *next;  
4.     struct sk_buff  *prev;  
5.   
6.     __u32       qlen;  
7.     spinlock_t  lock;  
8. };  

这里可以看到前两个域是和sk_buff一致的，而且内核的注释是必须放到最前面。这里的原因是： 

这使得两个不同的结构可以放到同一个链表中，尽管sk_buff_head要比sk_buff小巧的多。另外，相同的函数可以同样应用于sk_buff和sk_buff_head。 

然后qlen域表示了当前的sk_buff链上包含多少个skb。 

lock域是自旋锁。 

然后我们来看sk_buff，下面就是skb的结构： 

我这里注释了一些简单的域，复杂的域下面会单独解释。 

1. struct sk_buff {  
2.     /* These two members must be first. */  
3.     struct sk_buff      *next;  
4.     struct sk_buff      *prev;  
5.   
6. //表示从属于那个socket，主要是被4层用到。  
7.     struct sock     *sk;  
8. //表示这个skb被接收的时间。  
9.     ktime_t         tstamp;  
10. //这个表示一个网络设备，当skb为输出时它表示skb将要输出的设备，当接收时，它表示输入设备。要注意，这个设备有可能会是虚拟设备(在3层以上看来)  
11.     struct net_device   *dev;  
12. ///这里其实应该是dst_entry类型，不知道为什么内核要改为ul。这个域主要用于路由子系统。这个数据结构保存了一些路由相关信息  
13.     unsigned long       _skb_dst;  
14. #ifdef CONFIG_XFRM  
15.     struct  sec_path    *sp;  
16. #endif  
17. ///这个域很重要，我们下面会详细说明。这里只需要知道这个域是保存每层的控制信息的就够了。  
18.     char            cb[48];  
19. ///这个长度表示当前的skb中的数据的长度，这个长度即包括buf中的数据也包括切片的数据，也就是保存在skb_shared_info中的数据。这个值是会随着从一层到另一层而改变的。下面我们会对比这几个长度的。  
20.     unsigned int        len,  
21. ///这个长度只表示切片数据的长度，也就是skb_shared_info中的长度。  
22.                 data_len;  
23. ///这个长度表示mac头的长度(2层的头的长度)  
24.     __u16           mac_len,  
25. ///这个主要用于clone的时候，它表示clone的skb的头的长度。  
26.                 hdr_len;  
27.   
28. ///接下来是校验相关的域。  
29.     union {  
30.         __wsum      csum;  
31.         struct {  
32.             __u16   csum_start;  
33.             __u16   csum_offset;  
34.         };  
35.     };  
36. ///优先级，主要用于QOS。  
37.     __u32           priority;  
38.     kmemcheck_bitfield_begin(flags1);  
39. ///接下来是一些标志位。  
40. //首先是是否可以本地切片的标志。  
41.     __u8            local_df:1,  
42. ///为1说明头可能被clone。  
43.                 cloned:1,  
44. ///这个表示校验相关的一个标记,表示硬件驱动是否为我们已经进行了校验(前面的blog有介绍)  
45.                 ip_summed:2,  
46. ///这个域如果为1,则说明这个skb的头域指针已经分配完毕，因此这个时候计算头的长度只需要head和data的差就可以了。  
47.                 nohdr:1,  
48. ///这个域不太理解什么意思。  
49.                 nfctinfo:3;  
50.   
51. ///pkt_type主要是表示数据包的类型，比如多播，单播，回环等等。  
52.     __u8            pkt_type:3,  
53. ///这个域是一个clone标记。主要是在fast clone中被设置，我们后面讲到fast clone时会详细介绍这个域。  
54.                 fclone:2,  
55. ///ipvs拥有的域。  
56.                 ipvs_property:1,  
57. ///这个域应该是udp使用的一个域。表示只是查看数据。  
58.                 peeked:1,  
59. ///netfilter使用的域。是一个trace 标记  
60.                 nf_trace:1;  
61. ///这个表示L3层的协议。比如IP,IPV6等等。  
62.     __be16          protocol:16;  
63.     kmemcheck_bitfield_end(flags1);  
64. ///skb的析构函数，一般都是设置为sock_rfree或者sock_wfree.  
65.     void            (*destructor)(struct sk_buff *skb);  
66.   
67. ///netfilter相关的域。  
68. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)  
69.     struct nf_conntrack *nfct;  
70.     struct sk_buff      *nfct_reasm;  
71. #endif  
72. #ifdef CONFIG_BRIDGE_NETFILTER  
73.     struct nf_bridge_info   *nf_bridge;  
74. #endif  
75.   
76. ///接收设备的index。  
77.     int         iif;  
78.   
79. ///流量控制的相关域。  
80. #ifdef CONFIG_NET_SCHED  
81.     __u16           tc_index;   /* traffic control index */  
82. #ifdef CONFIG_NET_CLS_ACT  
83.     __u16           tc_verd;    /* traffic control verdict */  
84. #endif  
85. #endif  
86.   
87.     kmemcheck_bitfield_begin(flags2);  
88. ///多队列设备的映射，也就是说映射到那个队列。  
89.     __u16           queue_mapping:16;  
90. #ifdef CONFIG_IPV6_NDISC_NODETYPE  
91.     __u8            ndisc_nodetype:2;  
92. #endif  
93.     kmemcheck_bitfield_end(flags2);  
94.   
95.     /* 0/14 bit hole */  
96.   
97. #ifdef CONFIG_NET_DMA  
98.     dma_cookie_t        dma_cookie;  
99. #endif  
100. #ifdef CONFIG_NETWORK_SECMARK  
101.     __u32           secmark;  
102. #endif  
103. ///skb的标记。  
104.     __u32           mark;  
105.   
106. ///vlan的控制tag。  
107.     __u16           vlan_tci;  
108.   
109. ///传输层的头  
110.     sk_buff_data_t      transport_header;  
111. ///网络层的头  
112.     sk_buff_data_t      network_header;  
113. ///链路层的头。  
114.     sk_buff_data_t      mac_header;  
115. ///接下来就是几个操作skb数据的指针。下面会详细介绍。  
116.     sk_buff_data_t      tail;  
117.     sk_buff_data_t      end;  
118.     unsigned char       *head,  
119.                 *data;  
120. ///这个表示整个skb的大小，包括skb本身，以及数据。  
121.     unsigned int        truesize;  
122. ///skb的引用计数  
123.     atomic_t        users;  
124. };  

我们来看前面没有解释的那些域。 

先来看cb域，他保存了每层所独自需要的内部数据。我们来看tcp的例子。 

我们知道tcp层的控制信息保存在tcp_skb_cb中，因此来看内核提供的宏来存取这个数据结构： 

1. #define TCP_SKB_CB(__skb)  ((struct tcp_skb_cb *)&((__skb)->cb[0]))  

在ip层的话，我们可能会用cb来存取切片好的帧。 

1. #define FRAG_CB(skb)    ((struct ipfrag_skb_cb *)((skb)->cb))  

到这里你可能会问如果我们想要在到达下一层后，还想保存当前层的私有信息怎么办。这个时候我们就可以使用skb的clone了。也就是之只复制sk_buff结构。 

然后我们到http://vger.kernel.org/~davem/skb_data.html看几个比较比较重要的域 len,data,tail,head,end。 

下图就是alloc_skb之后的skb的指针的状态。这里忽略了fclone。 

 


然后我们来看skb_clone函数，clone的意思就是只复制skb而不复制data域。 

这里它会先判断将要被clone的skb的fclone段，以便与决定是否重新分配一块内存来保存skb。 

然后调用__skb_clone来初始化相关的域。 

1. struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)  
2. {  
3.     struct sk_buff *n;  
4.   
5. ///n为skb紧跟着那块内存，这里如果skb是通过skb_fclone分配的，那么n就是一个skb。  
6.     n = skb + 1;  
7. ///skb和n的fclone都要符合要求，可以看到这里的值就是我们在__alloc_skb中设置的值。  
8.     if (skb->fclone == SKB_FCLONE_ORIG &&  
9.         n->fclone == SKB_FCLONE_UNAVAILABLE) {  
10. ///到这里，就说明我们不需要alloc一个skb，直接取n就可以了，并且设置fclone的标记。并修改引用计数。  
11.         atomic_t *fclone_ref = (atomic_t *) (n + 1);  
12.         n->fclone = SKB_FCLONE_CLONE;  
13.         atomic_inc(fclone_ref);  
14.     } else {  
15.   
16. ///这里就需要从cache中取得一块内存。  
17.         n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);  
18.         if (!n)  
19.             return NULL;  
20.   
21.         kmemcheck_annotate_bitfield(n, flags1);  
22.         kmemcheck_annotate_bitfield(n, flags2);  
23. ///设置新的skb的fclone域。这里我们新建的skb，没有被fclone的都是这个标记。  
24.         n->fclone = SKB_FCLONE_UNAVAILABLE;  
25.     }  
26.   
27.     return __skb_clone(n, skb);  
28. }  

这里__skb_clone就不介绍了，函数就是将要被clone的skb的域赋值给clone的skb。 

下图就是skb_clone之后的两个skb的结构图： 

 

当一个skb被clone之后，这个skb的数据区是不能被修改的，这就意为着，我们存取数据不需要任何锁。可是有时我们需要修改数据区，这个时候会有两个选择，一个是我们只修改linear段，也就是head和end之间的段，一种是我们还要修改切片数据，也就是skb_shared_info. 

这样就有两个函数供我们选择，第一个是pskb_copy,第二个是skb_copy. 

我们先来看pskb_copy,函数先alloc一个新的skb，然后调用skb_copy_from_linear_data来复制线性区的数据。 

1. struct sk_buff *pskb_copy(struct sk_buff *skb, gfp_t gfp_mask)  
2. {  
3.     /* 
4.      *  Allocate the copy buffer 
5.      */  
6.     struct sk_buff *n;  
7. #ifdef NET_SKBUFF_DATA_USES_OFFSET  
8.     n = alloc_skb(skb->end, gfp_mask);  
9. #else  
10.     n = alloc_skb(skb->end - skb->head, gfp_mask);  
11. #endif  
12.     if (!n)  
13.         goto out;  
14.   
15.     /* Set the data pointer */  
16.     skb_reserve(n, skb->data - skb->head);  
17.     /* Set the tail pointer and length */  
18.     skb_put(n, skb_headlen(skb));  
19. ///复制线性数据段。  
20.     skb_copy_from_linear_data(skb, n->data, n->len);  
21. ///更新相关域  
22.     n->truesize += skb->data_len;  
23.     n->data_len  = skb->data_len;  
24.     n->len        = skb->len;  
25.   
26. ///下面只是复制切片数据的指针  
27. if (skb_shinfo(skb)->nr_frags) {  
28.         int i;  
29.   
30.         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {  
31.             skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];  
32.             get_page(skb_shinfo(n)->frags[i].page);  
33.         }  
34.         skb_shinfo(n)->nr_frags = i;  
35.     }  
36.   
37. ...............................  
38.     copy_skb_header(n, skb);  
39. out:  
40.     return n;  
41. }  

然后是skb_copy,它是复制skb的所有数据段，包括切片数据： 

1. struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)  
2. {  
3.     int headerlen = skb->data - skb->head;  
4.     /* 
5.      *  Allocate the copy buffer 
6.      */  
7. //先alloc一个新的skb  
8.     struct sk_buff *n;  
9. #ifdef NET_SKBUFF_DATA_USES_OFFSET  
10.     n = alloc_skb(skb->end + skb->data_len, gfp_mask);  
11. #else  
12.     n = alloc_skb(skb->end - skb->head + skb->data_len, gfp_mask);  
13. #endif  
14.     if (!n)  
15.         return NULL;  
16.   
17.     /* Set the data pointer */  
18.     skb_reserve(n, headerlen);  
19.     /* Set the tail pointer and length */  
20.     skb_put(n, skb->len);  
21. ///然后复制所有的数据。  
22.     if (skb_copy_bits(skb, -headerlen, n->head, headerlen + skb->len))  
23.         BUG();  
24.   
25.     copy_skb_header(n, skb);  
26.     return n;  
27. }  

下面这张图就表示了psb_copy和skb_copy调用后的内存模型，其中a是pskb_copy,b是skb_copy: 


 


最后来看skb的释放： 
这里主要是判断一个引用标记位users,将它减一，如果大于0则直接返回，否则释放skb。 

1. void kfree_skb(struct sk_buff *skb)  
2. {  
3.     if (unlikely(!skb))  
4.         return;  
5.     if (likely(atomic_read(&skb->users) == 1))  
6.         smp_rmb();  
7. ///减一，然后判断。  
8.     else if (likely(!atomic_dec_and_test(&skb->users)))  
9.         return;  
10.     trace_kfree_skb(skb, __builtin_return_address(0));  
11.     __kfree_skb(skb);  
12. }