接上一篇,我们来看与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的函数这里就不继续列举了。