接上一篇，我们来看与skb相关的一些重要函数：

 

网络模块中，有两个用来分配SKB描述符的高速缓存，在SKB模块初始函数skb_init()中被创建：

 

void __init skb_init(void){skbuff_head_cache = kmem_cache_create("skbuff_head_cache",     sizeof(struct sk_buff),     0,     SLAB_HWCACHE_ALIGN|SLAB_PANIC,     NULL);skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",(2*sizeof(struct sk_buff)) +sizeof(atomic_t),0,SLAB_HWCACHE_ALIGN|SLAB_PANIC,NULL);}

skb_init()函数中创建了skbuff_head_cache 高速缓存，一般情况下，SKB都是从该高速缓存中分配的。skbuff_fclone_cahe 高速缓存的创建是为了方便SKB的克隆，如果一个SKB在分配的时候就知道可能被克隆，那么应该从这个高速缓存中分配，因为这个高速缓存中分配SKB时，会同时分配一个后备的SKB，在克隆的时候直接使用后备的SKB即可，不用再次分配SKB，很明显这样能提高效率。

 

alloc_skb()用来分配 SKB。数据缓存区和 SKB 描述符是两个不同的实体，这就意味着，在

分配一个 SKB 时，需要分配两块内存，一块是数据缓存区，一块是 SKB 描述符。__alloc_skb() 

调 用 kmem_cache_alloc_node() 从 高 速 缓 存 中 获 取 一 个 sk_buff 结 构 的 空 间，然 后 调 用kmalloc_node_track_caller()分配数据缓存区。参数说明如下：

size：待分配 SKB 的线性存储区的长度； 

gfp_mask: 分配内存的方式

fclone：预测是否会克隆，用于确定从哪个高速缓存中分配； 

node: 当支持 NUMA（非均匀质存储结构）时，用于确定何种区域中分配 SKB。

struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,   int fclone, int node){struct kmem_cache *cache;struct skb_shared_info *shinfo;struct sk_buff *skb;u8 *data;///这里通过fclone的值来判断是要从fclone cache还是说从head cache中取。cache = fclone ? skbuff_fclone_cache : skbuff_head_cache;///首先是分配skb，也就是包头。skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node);if (!skb)goto out;///首先将size对齐，这里是按一级缓存的大小来对齐。size = SKB_DATA_ALIGN(size);///然后是数据区的大小，大小为size+ sizeof(struct skb_shared_info的大小。data = kmalloc_node_track_caller(size + sizeof(struct skb_shared_info),gfp_mask, node);if (!data)goto nodata;///初始化相关域。memset(skb, 0, offsetof(struct sk_buff, tail));///这里truesize可以看到就是我们分配的整个skb+data的大小skb->truesize = size + sizeof(struct sk_buff);///users加一。atomic_set(&skb->users, 1);///一开始head和data是一样大的。skb->head = data;skb->data = data;///设置tail指针skb_reset_tail_pointer(skb);///一开始tail也就是和data是相同的。skb->end = skb->tail + size;kmemcheck_annotate_bitfield(skb, flags1);kmemcheck_annotate_bitfield(skb, flags2);#ifdef NET_SKBUFF_DATA_USES_OFFSETskb->mac_header = ~0U;#endif///初始化shinfo,这个我就不介绍了，前面的blog分析切片时，这个结构很详细的分析过了。shinfo = skb_shinfo(skb);atomic_set(&shinfo->dataref, 1);shinfo->nr_frags  = 0;shinfo->gso_size = 0;shinfo->gso_segs = 0;shinfo->gso_type = 0;shinfo->ip6_frag_id = 0;shinfo->tx_flags.flags = 0;skb_frag_list_init(skb);memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps));///fclone为1,说明多分配了一块内存，因此需要设置对应的fclone域。if (fclone) {///可以看到多分配的内存刚好在当前的skb的下方。struct sk_buff *child = skb + 1;atomic_t *fclone_ref = (atomic_t *) (child + 1);kmemcheck_annotate_bitfield(child, flags1);kmemcheck_annotate_bitfield(child, flags2);///设置标记。这里要注意，当前的skb和多分配的skb设置的fclone是不同的。skb->fclone = SKB_FCLONE_ORIG;atomic_set(fclone_ref, 1);child->fclone = SKB_FCLONE_UNAVAILABLE;}out:return skb;nodata:kmem_cache_free(cache, skb);skb = NULL;goto out;}

需 要 说 明 的 是 ， __alloc_skb() 一 般 不 被 直 接 调 用 ， 而 是 被 封 装 函 数 调 用 ， 如

__netdev_alloc_skb()、alloc_skb()、alloc_skb_fclone()等函数。

调用alloc_skb()之后的套接口缓存结构: 

struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask){struct sk_buff *n;///n为skb紧跟着那块内存，这里如果skb是通过skb_fclone分配的，那么n就是一个skb。n = skb + 1;///skb和n的fclone都要符合要求，可以看到这里的值就是我们在__alloc_skb中设置的值。if (skb->fclone == SKB_FCLONE_ORIG &&   n->fclone == SKB_FCLONE_UNAVAILABLE) {///到这里，就说明我们不需要alloc一个skb，直接取n就可以了，并且设置fclone的标记。并修改引用计数。atomic_t *fclone_ref = (atomic_t *) (n + 1);n->fclone = SKB_FCLONE_CLONE;atomic_inc(fclone_ref);} else {///这里就需要从cache中取得一块内存。n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);if (!n)return NULL;kmemcheck_annotate_bitfield(n, flags1);kmemcheck_annotate_bitfield(n, flags2);///设置新的skb的fclone域。这里我们新建的skb，没有被fclone的都是这个标记。n->fclone = SKB_FCLONE_UNAVAILABLE;}return __skb_clone(n, skb);}

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

 

struct sk_buff *pskb_copy(struct sk_buff *skb, gfp_t gfp_mask){     /*     *     Allocate the copy buffer     */     struct sk_buff *n;#ifdef NET_SKBUFF_DATA_USES_OFFSET     n = alloc_skb(skb->end, gfp_mask);#else     n = alloc_skb(skb->end - skb->head, gfp_mask);#endif     if (!n)          goto out;     /* Set the data pointer */     skb_reserve(n, skb->data - skb->head);     /* Set the tail pointer and length */     skb_put(n, skb_headlen(skb));///复制线性数据段。     skb_copy_from_linear_data(skb, n->data, n->len);///更新相关域     n->truesize += skb->data_len;     n->data_len  = skb->data_len;     n->len          = skb->len;///下面只是复制切片数据的指针if (skb_shinfo(skb)->nr_frags) {          int i;          for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {               skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];               get_page(skb_shinfo(n)->frags[i].page);          }          skb_shinfo(n)->nr_frags = i;     }...     copy_skb_header(n, skb);out:     return n;}

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

struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask){int headerlen = skb->data - skb->head;/** Allocate the copy buffer*///先alloc一个新的skbstruct sk_buff *n;#ifdef NET_SKBUFF_DATA_USES_OFFSETn = alloc_skb(skb->end + skb->data_len, gfp_mask);#elsen = alloc_skb(skb->end - skb->head + skb->data_len, gfp_mask);#endifif (!n)return NULL;/* Set the data pointer */skb_reserve(n, headerlen);/* Set the tail pointer and length */skb_put(n, skb->len);///然后复制所有的数据。if (skb_copy_bits(skb, -headerlen, n->head, headerlen + skb->len))BUG();copy_skb_header(n, skb);return n;}

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

接着来看skb的释放： 

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

void kfree_skb(struct sk_buff *skb){     if (unlikely(!skb))          return;     if (likely(atomic_read(&skb->users) == 1))          smp_rmb();///减一，然后判断。     else if (likely(!atomic_dec_and_test(&skb->users)))          return;     trace_kfree_skb(skb, __builtin_return_address(0));     __kfree_skb(skb);}

下面几个函数是在网卡驱动里面可能会用到的：

 

skb_reserve() 

此函数在数据缓存区头部预留一定的空间，通常被用来在数据缓存区中插入协议首部或者

在某个边界上对齐。它并没有把数据移出或移入数据缓存区，而只是简单地更新了数据缓存区

的两个指针——分别指向负载起始和结尾的data和tail指针。

请注意：skb_reserve()只能用于空的 SKB，通常会在分配 SKB 之后就调用该函数，此时 data

和 tail 指针还一同指向数据区的起始位置，如（a）所示。例如，某个以太网设备驱动的接收函

数，在分配 SKB 之后，向数据缓存区填充数据之前，会有这样的一条语句 skb_reserve(skb, 2)，

这是因为以太网头部为 14 字节长，再加上 2 字节就正好 16 字节边界对齐，所以大多数以太网

设备都会在数据包之前保留 2 个字节。 

当SKB在协议栈中向下传递时，每一层协议都把skb->data指针向上移动，然后复制本层首

部，同时更新skb->len。

 

 skb_push()

此函数在数据缓存区的头部加入一块数据。修改指向数据区起始的指针data，使之往上移len

字节，即使数据区向上扩大len字节，并更新数据区长度len。调用skb_push()前后，SKB结构变

化见下图：

TCP层向链路层传递时的填充过程： 

1）  当 TCP 发送数据时，会根据一些条件，如 TCP 最大分段长度 MSS、是否支持聚合分散 I/O

等，分配一个 SKB。 

2）  TCP 需在数据缓存区的头部预留足够的空间，用来填充各层首部。MAX_TCP_HEADER 是

各层首部长度的总和，它考虑了最坏的情况：由于 TCP 层不知道将要用哪个接口发送包，

它为每一层预留了最大的首部长度，甚至还考虑了出现多个 IP 首部的可能性，因为在内核

编译支持 IP over IP 的情况下，会遇到多个 IP 首部。 

3）  把TCP负载复制到数据缓存区。需要注意的是，图 3-16  只是一个例子，TCP负载可能会被

组织成其他形式，例如分片，在后续章节中将会看到一个分片的数据缓存区是什么样的。 

4）  TCP 层添加 TCP 首部。 

5）  SKB 传递到 IP 层，IP 层为数据包添加 IP 首部。 

6）  SKB 传递到链路层，链路层为数据包添加链路层首部。

 

skb_put()

 　　

此函数修改指向数据区末尾的指针tail，使之往下移len字节，即使数据区向下扩大len字节，

并更新数据区长度len。调用skb_put()前后，SKB结构变化见下图：

skb_pull() 

 

此函数通过将data指针往下移动来在数据区首部忽略len字节长度的数据，通常用于接收到

的数据包后在各层间由下往上传递时，上层忽略下层的首部。调用skb_pull()前后，SKB结构变

化见下图：

其它还有很多操作sk_buff的函数这里就不继续列举了。