Chinaunix首页 | 论坛 | 博客

Linux_jiax

首页　| 　博文目录　| 　关于我

老顽童熊

  • 博客访问： 336564
  • 博文数量： 86
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 185
  • 用 户 组： 普通用户
  • 注册时间： 2014-11-25 17:14
个人简介

代码才是最叼的

文章分类

全部博文（86）

文章存档

2019年（1）

2018年（1）

2017年（9）

2016年（19）

2015年（55）

2014年（1）

我的朋友
最近访客
推荐博文
相关博文
linux内核sk_buff的结构分析

分类： 系统运维

2015-08-12 17:04:33

原文地址：linux内核sk_buff的结构分析 作者：jiangsheng84

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的头。

Java代码  收藏代码
  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的结构：

我这里注释了一些简单的域，复杂的域下面会单独解释。
Java代码  收藏代码
  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中，因此来看内核提供的宏来存取这个数据结构：

Java代码  收藏代码
  1. #define TCP_SKB_CB(__skb)  ((struct tcp_skb_cb *)&((__skb)->cb[0]))  


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

Java代码  收藏代码
  1. #define FRAG_CB(skb)    ((struct ipfrag_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个大小。

Java代码  收藏代码
  1. static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)  
  2. {  
  3.     unsigned char *tmp = skb_tail_pointer(skb);  
  4.     SKB_LINEAR_ASSERT(skb);  
  5. ///改变相应的域。  
  6.     skb->tail += len;  
  7.     skb->len  += len;  
  8.     return tmp;  
  9. }  


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

Java代码  收藏代码
  1. static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)  
  2. {  
  3.     skb->data -= len;  
  4.     skb->len  += len;  
  5.     return skb->data;  
  6. }  


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

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




接着是skb的alloc函数。

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

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

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

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

这个函数可以叫做Fast SKB cloning函数，这个函数存在的主要原因是，以前我们每次skb_clone一个skb的时候，都是要调用kmem_cache_alloc从 cache中alloc一块新的内存。而现在当我们拥有了fast clone之后，通过调用alloc_skb_fclone函数来分配一块大于sizeof(struct sk_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的介绍可以看这里：



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

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

Java代码  收藏代码
  1. struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,  
  2.                 int fclone, int node)  
  3. {  
  4.     struct kmem_cache *cache;  
  5.     struct skb_shared_info *shinfo;  
  6.     struct sk_buff *skb;  
  7.     u8 *data;  
  8.   
  9. ///这里通过fclone的值来判断是要从fclone cache还是说从head cache中取。  
  10.     cache = fclone ? skbuff_fclone_cache : skbuff_head_cache;  
  11.   
  12. ///首先是分配skb，也就是包头。  
  13.     skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node);  
  14.     if (!skb)  
  15.         goto out;  
  16. ///首先将size对齐，这里是按一级缓存的大小来对齐。  
  17.     size = SKB_DATA_ALIGN(size);  
  18. ///然后是数据区的大小，大小为size+ sizeof(struct skb_shared_info的大小。  
  19.     data = kmalloc_node_track_caller(size + sizeof(struct skb_shared_info),  
  20.             gfp_mask, node);  
  21.     if (!data)  
  22.         goto nodata;  
  23.   
  24. ///初始化相关域。  
  25.     memset(skb, 0, offsetof(struct sk_buff, tail));  
  26. ///这里truesize可以看到就是我们分配的整个skb+data的大小  
  27.     skb->truesize = size + sizeof(struct sk_buff);  
  28. ///users加一。  
  29.     atomic_set(&skb->users, 1);  
  30. ///一开始head和data是一样大的。  
  31.     skb->head = data;  
  32.     skb->data = data;  
  33. ///设置tail指针  
  34.     skb_reset_tail_pointer(skb);  
  35. ///一开始tail也就是和data是相同的。  
  36.     skb->end = skb->tail + size;  
  37.     kmemcheck_annotate_bitfield(skb, flags1);  
  38.     kmemcheck_annotate_bitfield(skb, flags2);  
  39. #ifdef NET_SKBUFF_DATA_USES_OFFSET  
  40.     skb->mac_header = ~0U;  
  41. #endif  
  42.   
  43. ///初始化shinfo,这个我就不介绍了，前面的blog分析切片时，这个结构很详细的分析过了。  
  44.     shinfo = skb_shinfo(skb);  
  45.     atomic_set(&shinfo->dataref, 1);  
  46.     shinfo->nr_frags  = 0;  
  47.     shinfo->gso_size = 0;  
  48.     shinfo->gso_segs = 0;  
  49.     shinfo->gso_type = 0;  
  50.     shinfo->ip6_frag_id = 0;  
  51.     shinfo->tx_flags.flags = 0;  
  52.     skb_frag_list_init(skb);  
  53.     memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps));  
  54.   
  55. ///fclone为1,说明多分配了一块内存，因此需要设置对应的fclone域。  
  56.     if (fclone) {  
  57. ///可以看到多分配的内存刚好在当前的skb的下方。  
  58.         struct sk_buff *child = skb + 1;  
  59.         atomic_t *fclone_ref = (atomic_t *) (child + 1);  
  60.   
  61.         kmemcheck_annotate_bitfield(child, flags1);  
  62.         kmemcheck_annotate_bitfield(child, flags2);  
  63. ///设置标记。这里要注意，当前的skb和多分配的skb设置的fclone是不同的。  
  64.         skb->fclone = SKB_FCLONE_ORIG;  
  65.         atomic_set(fclone_ref, 1);  
  66.   
  67.         child->fclone = SKB_FCLONE_UNAVAILABLE;  
  68.     }  
  69. out:  
  70.     return skb;  
  71. nodata:  
  72.     kmem_cache_free(cache, skb);  
  73.     skb = NULL;  
  74.     goto out;  
  75. }  


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




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

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

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

Java代码  收藏代码
  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来复制线性区的数据。

Java代码  收藏代码
  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的所有数据段，包括切片数据：

Java代码  收藏代码
  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。

Java代码  收藏代码
  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. }  
阅读(731) | 评论(0) | 转发(0) |
0

上一篇：linux网卡驱动程序分析

下一篇：struct sk_buff分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6