Linux内核中sk_buff分析

【MAC】 专栏收录该内容
25 篇文章 1 订阅

在内核中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. 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_buffsk_buff_head。 

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

lock
域是自旋锁。 

然后我们来看sk_buff,下面就是skb的结构: 

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

  1.   

  2. struct sk_buff {  

  3.     /* These two members must be first. */  

  4.     struct sk_buff      *next;  

  5.     struct sk_buff      *prev;  

  6.   

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

  8.     struct sock     *sk;  

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

  10.     ktime_t         tstamp;  

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

  12.     struct net_device   *dev;  

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

  14.     unsigned long       _skb_dst;  

  15. #ifdef CONFIG_XFRM  

  16.     struct  sec_path    *sp;  

  17. #endif  

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

  19.     char            cb[48];  

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

  21.     unsigned int        len,  

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

  23.                 data_len;  

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

  25.     __u16           mac_len,  

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

  27.                 hdr_len;  

  28.   

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

  30.     union {  

  31.         __wsum      csum;  

  32.         struct {  

  33.             __u16   csum_start;  

  34.             __u16   csum_offset;  

  35.         };  

  36.     };  

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

  38.     __u32           priority;  

  39.     kmemcheck_bitfield_begin(flags1);  

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

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

  42.     __u8            local_df:1,  

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

  44.                 cloned:1,  

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

  46.                 ip_summed:2,  

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

  48.                 nohdr:1,  

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

  50.                 nfctinfo:3;  

  51.   

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

  53.     __u8            pkt_type:3,  

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

  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.     __be16          protocol:16;  

  64.     kmemcheck_bitfield_end(flags1);  

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

  66.     void            (*destructor)(struct sk_buff *skb);  

  67.   

  68. ///netfilter相关的域。   

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

  70.     struct nf_conntrack *nfct;  

  71.     struct sk_buff      *nfct_reasm;  

  72. #endif  

  73. #ifdef CONFIG_BRIDGE_NETFILTER  

  74.     struct nf_bridge_info   *nf_bridge;  

  75. #endif  

  76.   

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

  78.     int         iif;  

  79.   

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

  81. #ifdef CONFIG_NET_SCHED  

  82.     __u16           tc_index;   /* traffic control index */  

  83. #ifdef CONFIG_NET_CLS_ACT  

  84.     __u16           tc_verd;    /* traffic control verdict */  

  85. #endif  

  86. #endif  

  87.   

  88.     kmemcheck_bitfield_begin(flags2);  

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

  90.     __u16           queue_mapping:16;  

  91. #ifdef CONFIG_IPV6_NDISC_NODETYPE  

  92.     __u8            ndisc_nodetype:2;  

  93. #endif  

  94.     kmemcheck_bitfield_end(flags2);  

  95.   

  96.     /* 0/14 bit hole */  

  97.   

  98. #ifdef CONFIG_NET_DMA  

  99.     dma_cookie_t        dma_cookie;  

  100. #endif  

  101. #ifdef CONFIG_NETWORK_SECMARK  

  102.     __u32           secmark;  

  103. #endif  

  104. ///skb的标记。   

  105.     __u32           mark;  

  106.   

  107. ///vlan的控制tag。   

  108.     __u16           vlan_tci;  

  109.   

  110. ///传输层的头   

  111.     sk_buff_data_t      transport_header;  

  112. ///网络层的头   

  113.     sk_buff_data_t      network_header;  

  114. ///链路层的头。   

  115.     sk_buff_data_t      mac_header;  

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

  117.     sk_buff_data_t      tail;  

  118.     sk_buff_data_t      end;  

  119.     unsigned char       *head,  

  120.                 *data;  

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

  122.     unsigned int        truesize;  

  123. ///skb的引用计数   

  124.     atomic_t        users;  

  125. };  


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

先来看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))  

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

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

这几个域都很简单,下面这张图表示了buffertcp层到链路层的过程中lenheaddatatail以及end的变化,通过这个图我们可以非常清晰的了解到这几个域的区别。 

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

然后来看transport_headernetwork_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. 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大小。 

 

  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中的长度函数,这里添加一些自己的理解:

对于每一个网络数据包都包含一个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指针变化的同时,也会发生变化

 

 

接着是skballoc函数。 

在内核中分配一个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_alloccachealloc一块新的内存。而现在当我们拥有了fastclone之后,通过调用alloc_skb_fclone函数来分配一块大于sizeof(structsk_buff)的内存,也就是在这次请求的skb的下方多申请了一些内存,然后返回的时候设置返回的skbfclone标记为SKB_FCLONE_ORIG,而多申请的那块内存的sk_bufffcloneSKB_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中会自动多分配些内存。

  1.   

  2. struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,  

  3.                 int fclone, int node)  

  4. {  

  5.     struct kmem_cache *cache;  

  6.     struct skb_shared_info *shinfo;  

  7.     struct sk_buff *skb;  

  8.     u8 *data;  

  9.   

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

  11.     cache = fclone ? skbuff_fclone_cache : skbuff_head_cache;  

  12.   

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

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

  15.     if (!skb)  

  16.         goto out;  

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

  18.     size = SKB_DATA_ALIGN(size);  

  19. ///然后是数据区的大小,大小为size+ sizeof(struct skb_shared_info的大小。   

  20.     data = kmalloc_node_track_caller(size + sizeof(struct skb_shared_info),  

  21.             gfp_mask, node);  

  22.     if (!data)  

  23.         goto nodata;  

  24.   

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

  26.     memset(skb, 0, offsetof(struct sk_buff, tail));  

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

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

  29. ///users加一。   

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

  31. ///一开始headdata是一样大的。   

  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. #ifdef NET_SKBUFF_DATA_USES_OFFSET  

  41.     skb->mac_header = ~0U;  

  42. #endif  

  43.   

  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));  

  55.   

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

  57.     if (fclone) {  

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

  59.         struct sk_buff *child = skb + 1;  

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

  61.   

  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);  

  67.   

  68.         child->fclone = SKB_FCLONE_UNAVAILABLE;  

  69.     }  

  70. out:  

  71.     return skb;  

  72. nodata:  

  73.     kmem_cache_free(cache, skb);  

  74.     skb = NULL;  

  75.     goto out;  

  76. }  


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

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

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

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

  1.   

  2. struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)  

  3. {  

  4.     struct sk_buff *n;  

  5.   

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

  7.     n = skb + 1;  

  8. ///skbnfclone都要符合要求,可以看到这里的值就是我们在__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 {  

  16.   

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

  18.         n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);  

  19.         if (!n)  

  20.             return NULL;  

  21.   

  22.         kmemcheck_annotate_bitfield(n, flags1);  

  23.         kmemcheck_annotate_bitfield(n, flags2);  

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

  25.         n->fclone = SKB_FCLONE_UNAVAILABLE;  

  26.     }  

  27.   

  28.     return __skb_clone(n, skb);  

  29. }  


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

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

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

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

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

  1.   

  2. struct sk_buff *pskb_copy(struct sk_buff *skb, gfp_t gfp_mask)  

  3. {  

  4.     /*  

  5.      *  Allocate the copy buffer  

  6.      */  

  7.     struct sk_buff *n;  

  8. #ifdef NET_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.         goto out;  

  15.   

  16.     /* Set the data pointer */  

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

  18.     /* Set the tail pointer and length */  

  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;  

  26.   

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

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

  29.         int i;  

  30.   

  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.     }  

  37.   

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

  39.     copy_skb_header(n, skb);  

  40. out:  

  41.     return n;  

  42. }  


然后是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;  

下面这张图就表示了psb_copyskb_copy调用后的内存模型,其中apskb_copy,bskb_copy: 

  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值