Linux内核中sk_buff分析

<style type="text/css"> <!-- @page { margin: 0.79in } P { margin-bottom: 0.08in } --> </style>

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

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

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

1. structsk_buff_head{

2. /*Thesetwomembersmustbefirst.*/

3. structsk_buff*next;

4. structsk_buff*prev;

6. __u32qlen;

7. spinlock_tlock;

8. };

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

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

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

lock域是自旋锁。

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

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

2. structsk_buff{

3. /*Thesetwomembersmustbefirst.*/

4. structsk_buff*next;

5. structsk_buff*prev;

7. //表示从属于那个socket，主要是被4层用到。

8. structsock*sk;

9. //表示这个skb被接收的时间。

10. ktime_ttstamp;

11. //这个表示一个网络设备，当skb为输出时它表示skb将要输出的设备，当接收时，它表示输入设备。要注意，这个设备有可能会是虚拟设备(在3层以上看来)

12. structnet_device*dev;

13. ///这里其实应该是dst_entry类型，不知道为什么内核要改为ul。这个域主要用于路由子系统。这个数据结构保存了一些路由相关信息

14. unsignedlong_skb_dst;

15. #ifdefCONFIG_XFRM

16. structsec_path*sp;

17. #endif

18. ///这个域很重要，我们下面会详细说明。这里只需要知道这个域是保存每层的控制信息的就够了。

19. charcb[48];

20. ///这个长度表示当前的skb中的数据的长度，这个长度即包括buf中的数据也包括切片的数据，也就是保存在skb_shared_info中的数据。这个值是会随着从一层到另一层而改变的。下面我们会对比这几个长度的。

21. unsignedintlen,

22. ///这个长度只表示切片数据的长度，也就是skb_shared_info中的长度。

23. data_len;

24. ///这个长度表示mac头的长度(2层的头的长度)

25. __u16mac_len,

26. ///这个主要用于clone的时候，它表示clone的skb的头的长度。

27. hdr_len;

29. ///接下来是校验相关的域。

30. union{

31. __wsumcsum;

32. struct{

33. __u16csum_start;

34. __u16csum_offset;

35. };

36. };

37. ///优先级，主要用于QOS。

38. __u32priority;

39. kmemcheck_bitfield_begin(flags1);

40. ///接下来是一些标志位。

41. //首先是是否可以本地切片的标志。

42. __u8local_df:1,

43. ///为1说明头可能被clone。

44. cloned:1,

45. ///这个表示校验相关的一个标记,表示硬件驱动是否为我们已经进行了校验(前面的blog有介绍)

46. ip_summed:2,

47. ///这个域如果为1,则说明这个skb的头域指针已经分配完毕，因此这个时候计算头的长度只需要head和data的差就可以了。

48. nohdr:1,

49. ///这个域不太理解什么意思。

50. nfctinfo:3;

52. ///pkt_type主要是表示数据包的类型，比如多播，单播，回环等等。

53. __u8pkt_type:3,

54. ///这个域是一个clone标记。主要是在fastclone中被设置，我们后面讲到fastclone时会详细介绍这个域。

55. fclone:2,

56. ///ipvs拥有的域。

57. ipvs_property:1,

58. ///这个域应该是udp使用的一个域。表示只是查看数据。

59. peeked:1,

60. ///netfilter使用的域。是一个trace标记

61. nf_trace:1;

62. ///这个表示L3层的协议。比如IP,IPV6等等。

63. __be16protocol:16;

64. kmemcheck_bitfield_end(flags1);

65. ///skb的析构函数，一般都是设置为sock_rfree或者sock_wfree.

66. void(*destructor)(structsk_buff*skb);

68. ///netfilter相关的域。

69. #ifdefined(CONFIG_NF_CONNTRACK)||defined(CONFIG_NF_CONNTRACK_MODULE)

70. structnf_conntrack*nfct;

71. structsk_buff*nfct_reasm;

72. #endif

73. #ifdefCONFIG_BRIDGE_NETFILTER

74. structnf_bridge_info*nf_bridge;

75. #endif

77. ///接收设备的index。

78. intiif;

80. ///流量控制的相关域。

81. #ifdefCONFIG_NET_SCHED

82. __u16tc_index;/*trafficcontrolindex*/

83. #ifdefCONFIG_NET_CLS_ACT

84. __u16tc_verd;/*trafficcontrolverdict*/

85. #endif

86. #endif

88. kmemcheck_bitfield_begin(flags2);

89. ///多队列设备的映射，也就是说映射到那个队列。

90. __u16queue_mapping:16;

91. #ifdefCONFIG_IPV6_NDISC_NODETYPE

92. __u8ndisc_nodetype:2;

93. #endif

94. kmemcheck_bitfield_end(flags2);

96. /*0/14bithole*/

98. #ifdefCONFIG_NET_DMA

99. dma_cookie_tdma_cookie;

100. #endif

101. #ifdefCONFIG_NETWORK_SECMARK

102. __u32secmark;

103. #endif

104. ///skb的标记。

105. __u32mark;

107. ///vlan的控制tag。

108. __u16vlan_tci;

110. ///传输层的头

111. sk_buff_data_ttransport_header;

112. ///网络层的头

113. sk_buff_data_tnetwork_header;

114. ///链路层的头。

115. sk_buff_data_tmac_header;

116. ///接下来就是几个操作skb数据的指针。下面会详细介绍。

117. sk_buff_data_ttail;

118. sk_buff_data_tend;

119. unsignedchar*head,

120. *data;

121. ///这个表示整个skb的大小，包括skb本身，以及数据。

122. unsignedinttruesize;

123. ///skb的引用计数

124. atomic_tusers;

125. };

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

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

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

1. #defineTCP_SKB_CB(__skb)((structtcp_skb_cb*)&((__skb)->cb[0]))

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

1. #defineFRAG_CB(skb)((structipfrag_skb_cb*)((skb)->cb))

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

然后我们来看几个比较比较重要的域len,data,tail,head,end。

这几个域都很简单，下面这张图表示了buffer从tcp层到链路层的过程中len，head，data，tail以及end的变化，通过这个图我们可以非常清晰的了解到这几个域的区别。

可以很清楚的看到head指针为分配的buffer的起始位置，end为结束位置，而data为当前数据的起始位置，tail为当前数据的结束位置。len就是数据区的长度。

然后来看transport_header，network_header以及mac_header的变化，这几个指针都是随着数据包到达不同的层次才会有对应的值，我们来看下面的图，这个图表示了当从2层到达3层对应的指针的变化。

这里可以看到data指针会由于数据包到了三层，而跳过2层的头。这里我们就可以得到data起始真正指的是本层的头以及数据的起始位置。

然后我们来看skb的几个重要操作函数。

首先是skb_put,skb_push,skb_pull以及skb_reserve这几个最长用的操作data指针的函数。

这里可以看到内核skb_XXX都还有一个__skb_XXX函数，这是因为前一个只是将后一个函数进行了一个包装，加了一些校验。

先来看__skb_put函数。
可以看到它只是将tail指针移动len个位置，然后len也相应的增加len个大小。

1. staticinlineunsignedchar*__skb_put(structsk_buff*skb,unsignedintlen)

2. {

3. unsignedchar*tmp=skb_tail_pointer(skb);

4. SKB_LINEAR_ASSERT(skb);

5. ///改变相应的域。

6. skb->tail+=len;

7. skb->len+=len;

8. returntmp;

9. }

然后是__skb_push,它是将data指针向上移动len个位置，对应的len肯定也是增加len大小。

1. staticinlineunsignedchar*__skb_push(structsk_buff*skb,unsignedintlen)

2. {

3. skb->data-=len;

4. skb->len+=len;

5. returnskb->data;

6. }

剩下的两个就不贴代码了，都是很简单的函数，__skb_pull是将data指针向下移动len个位置，然后len减小len大小。__skb_reserve是将整个数据区，也就是data以及tail指针一起向下移动len大小。这个函数一般是用来对齐地址用的。

看下面的图，描述了4个函数的操作：

关于skb中的长度函数，这里添加一些自己的理解：

对于每一个网络数据包都包含一个structskb_buff类型的结构和一个存储数据本身的结构，在skb_buff中不包含实际的数据，但它提供了存取数据的方法。

在数据包数据段分配空间的时候，总是会分配一个较大一些的空间，用于各层协议在头部的扩展。

head,end指向分配的空间的头部和尾部，而data则指向有效的数据的起始位置，tail则指向结束位置，有效数据的起始位置是针对协议类型而言的，比如对于当前处于ip层，有效数据即为ip头+tcp头+tcp数据部分，而如果位于tcp层，则有效数据为tcp头+tcp数据部分，data即指向每层有效数据的其实位置，当数据包在各层间传递的时候，data指针也会发生改变，但之前的协议数据并没有消失，仍可以通过其他方式访问。

而skb_buff中的长度字段len长度所指为当前协议数据包的长度，包括主缓冲区的数据长度和分片中的数据长度（实际存储数据区包含的skb_shared_info所指数据），而skb->data_len只计算分片中的长度。

在不考虑分片长度时，也即data_len长度为0时，此时len的长度就等同于主数据缓冲区的长度。

若在l2层，此时len=mac头部+ip头部+tcp头部+tcp数据部分

若在l3层，此时len=ip头部+tcp头部+tcp数据部分

也就是len= (int)(tail - data)

因此，len的长度伴随着数据包在各层间的传递，data指针变化的同时，也会发生变化

接着是skb的alloc函数。

在内核中分配一个skb是在__alloc_skb中实现的，接下来我们就来看这个函数的具体实现。

这个函数起始可以看作三部分，第一部分是从cache中分配内存，第二部分是初始化分配的skb的相关域。第三部分是处理fclone。

还有一个要注意的就是这里__alloc_skb是被三个函数包装后才能直接使用的，我们只看前两个，一个是skb_alloc_skb,一个是alloc_skb_fclone函数，这两个函数传递进来的第三个参数，也就是fclone前一个是0,后一个是1.

那么这个函数是什么意思呢，它和alloc_skb有什么区别的。

这个函数可以叫做FastSKBcloning函数，这个函数存在的主要原因是，以前我们每次skb_clone一个skb的时候，都是要调用kmem_cache_alloc从cache中alloc一块新的内存。而现在当我们拥有了fastclone之后，通过调用alloc_skb_fclone函数来分配一块大于sizeof(structsk_buff)的内存，也就是在这次请求的skb的下方多申请了一些内存，然后返回的时候设置返回的skb的fclone标记为SKB_FCLONE_ORIG，而多申请的那块内存的sk_buff的fclone为SKB_FCLONE_UNAVAILABLE，这样当我们调用skb_clone克隆这个skb的时候看到fclone的标记就可以直接将skb的指针+1,而不需要从cache中取了。这样的话节省了一次内存存取，提高了clone的效率，不过调用flcone一般都是我们确定接下来这个skb会被clone很多次。

更详细的fclone的介绍可以看这里：

http://lwn.net/Articles/140552/

这样我们先来看_alloc_skb,然后紧接着看skb_clone,这样就能更好的理解这些。

这里fclone的多分配的内存部分，没太弄懂从那里多分配的，自己对内核的内存子系统还是不太熟悉。觉得应该是skbuff_fclone_cache中会自动多分配些内存。

2. structsk_buff*__alloc_skb(unsignedintsize,gfp_tgfp_mask,

3. intfclone,intnode)

4. {

5. structkmem_cache*cache;

6. structskb_shared_info*shinfo;

7. structsk_buff*skb;

8. u8*data;

10. ///这里通过fclone的值来判断是要从fclonecache还是说从headcache中取。

11. cache=fclone?skbuff_fclone_cache:skbuff_head_cache;

13. ///首先是分配skb，也就是包头。

14. skb=kmem_cache_alloc_node(cache,gfp_mask&~__GFP_DMA,node);

15. if(!skb)

16. gotoout;

17. ///首先将size对齐，这里是按一级缓存的大小来对齐。

18. size=SKB_DATA_ALIGN(size);

19. ///然后是数据区的大小，大小为size+sizeof(structskb_shared_info的大小。

20. data=kmalloc_node_track_caller(size+sizeof(structskb_shared_info),

21. gfp_mask,node);

22. if(!data)

23. gotonodata;

25. ///初始化相关域。

26. memset(skb,0,offsetof(structsk_buff,tail));

27. ///这里truesize可以看到就是我们分配的整个skb+data的大小

28. skb->truesize=size+sizeof(structsk_buff);

29. ///users加一。

30. atomic_set(&skb->users,1);

31. ///一开始head和data是一样大的。

32. skb->head=data;

33. skb->data=data;

34. ///设置tail指针

35. skb_reset_tail_pointer(skb);

36. ///一开始tail也就是和data是相同的。

37. skb->end=skb->tail+size;

38. kmemcheck_annotate_bitfield(skb,flags1);

39. kmemcheck_annotate_bitfield(skb,flags2);

40. #ifdefNET_SKBUFF_DATA_USES_OFFSET

41. skb->mac_header=~0U;

42. #endif

44. ///初始化shinfo,这个我就不介绍了，前面的blog分析切片时，这个结构很详细的分析过了。

45. shinfo=skb_shinfo(skb);

46. atomic_set(&shinfo->dataref,1);

47. shinfo->nr_frags=0;

48. shinfo->gso_size=0;

49. shinfo->gso_segs=0;

50. shinfo->gso_type=0;

51. shinfo->ip6_frag_id=0;

52. shinfo->tx_flags.flags=0;

53. skb_frag_list_init(skb);

54. memset(&shinfo->hwtstamps,0,sizeof(shinfo->hwtstamps));

56. ///fclone为1,说明多分配了一块内存，因此需要设置对应的fclone域。

57. if(fclone){

58. ///可以看到多分配的内存刚好在当前的skb的下方。

59. structsk_buff*child=skb+1;

60. atomic_t*fclone_ref=(atomic_t*)(child+1);

62. kmemcheck_annotate_bitfield(child,flags1);

63. kmemcheck_annotate_bitfield(child,flags2);

64. ///设置标记。这里要注意，当前的skb和多分配的skb设置的fclone是不同的。

65. skb->fclone=SKB_FCLONE_ORIG;

66. atomic_set(fclone_ref,1);

68. child->fclone=SKB_FCLONE_UNAVAILABLE;

69. }

70. out:

71. returnskb;

72. nodata:

73. kmem_cache_free(cache,skb);

74. skb=NULL;

75. gotoout;

76. }

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

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

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

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

2. structsk_buff*skb_clone(structsk_buff*skb,gfp_tgfp_mask)

3. {

4. structsk_buff*n;

6. ///n为skb紧跟着那块内存，这里如果skb是通过skb_fclone分配的，那么n就是一个skb。

7. n=skb+1;

8. ///skb和n的fclone都要符合要求，可以看到这里的值就是我们在__alloc_skb中设置的值。

9. if(skb->fclone==SKB_FCLONE_ORIG&&

10. n->fclone==SKB_FCLONE_UNAVAILABLE){

11. ///到这里，就说明我们不需要alloc一个skb，直接取n就可以了，并且设置fclone的标记。并修改引用计数。

12. atomic_t*fclone_ref=(atomic_t*)(n+1);

13. n->fclone=SKB_FCLONE_CLONE;

14. atomic_inc(fclone_ref);

15. }else{

17. ///这里就需要从cache中取得一块内存。

18. n=kmem_cache_alloc(skbuff_head_cache,gfp_mask);

19. if(!n)

20. returnNULL;

22. kmemcheck_annotate_bitfield(n,flags1);

23. kmemcheck_annotate_bitfield(n,flags2);

24. ///设置新的skb的fclone域。这里我们新建的skb，没有被fclone的都是这个标记。

25. n->fclone=SKB_FCLONE_UNAVAILABLE;

26. }

28. return__skb_clone(n,skb);

29. }

这里__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来复制线性区的数据。

2. structsk_buff*pskb_copy(structsk_buff*skb,gfp_tgfp_mask)

3. {

4. /*

5. *Allocatethecopybuffer

6. */

7. structsk_buff*n;

8. #ifdefNET_SKBUFF_DATA_USES_OFFSET

9. n=alloc_skb(skb->end,gfp_mask);

10. #else

11. n=alloc_skb(skb->end-skb->head,gfp_mask);

12. #endif

13. if(!n)

14. gotoout;

16. /*Setthedatapointer*/

17. skb_reserve(n,skb->data-skb->head);

18. /*Setthetailpointerandlength*/

19. skb_put(n,skb_headlen(skb));

20. ///复制线性数据段。

21. skb_copy_from_linear_data(skb,n->data,n->len);

22. ///更新相关域

23. n->truesize+=skb->data_len;

24. n->data_len=skb->data_len;

25. n->len=skb->len;

27. ///下面只是复制切片数据的指针

28. if(skb_shinfo(skb)->nr_frags){

29. inti;

31. for(i=0;i<skb_shinfo(skb)->nr_frags;i++){

32. skb_shinfo(n)->frags[i]=skb_shinfo(skb)->frags[i];

33. get_page(skb_shinfo(n)->frags[i].page);

34. }

35. skb_shinfo(n)->nr_frags=i;

36. }

38. ...............................

39. copy_skb_header(n,skb);

40. out:

41. returnn;

42. }

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

1. structsk_buff*skb_copy(conststructsk_buff*skb,gfp_tgfp_mask)

2. {

3. intheaderlen=skb->data-skb->head;

4. /*

5. *Allocatethecopybuffer

6. */

7. //先alloc一个新的skb

8. structsk_buff*n;

9. #ifdefNET_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. returnNULL;

17. /*Setthedatapointer*/

18. skb_reserve(n,headerlen);

19. /*Setthetailpointerandlength*/

20. skb_put(n,skb->len);

21. ///然后复制所有的数据。

22. if(skb_copy_bits(skb,-headerlen,n->head,headerlen+skb->len))

23. BUG();

25. copy_skb_header(n,skb);

26. returnn;

27. }

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