Linux 网卡驱动相关——02

接上一篇，我们来看与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_OFFSET
skb->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一个新的skb
struct sk_buff *n;
#ifdef NET_SKBUFF_DATA_USES_OFFSET
n = alloc_skb(skb->end + skb->data_len, gfp_mask);
#else
n = alloc_skb(skb->end - skb->head + skb->data_len, gfp_mask);
#endif
if (!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的函数这里就不继续列举了。