`
simohayha
  • 浏览: 1403649 次
  • 性别: Icon_minigender_1
  • 来自: 火星
社区版块
存档分类
最新评论

linux内核sk_buff的结构分析

阅读更多
我看的内核版本是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的头。

struct sk_buff_head {
	/* These two members must be first. */
	struct sk_buff	*next;
	struct sk_buff	*prev;

	__u32		qlen;
	spinlock_t	lock;
};


这里可以看到前两个域是和sk_buff一致的,而且内核的注释是必须放到最前面。这里的原因是:

这使得两个不同的结构可以放到同一个链表中,尽管sk_buff_head要比sk_buff小巧的多。另外,相同的函数可以同样应用于sk_buff和sk_buff_head。

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

lock域是自旋锁。

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

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

struct sk_buff {
	/* These two members must be first. */
	struct sk_buff		*next;
	struct sk_buff		*prev;

//表示从属于那个socket,主要是被4层用到。
	struct sock		*sk;
//表示这个skb被接收的时间。
	ktime_t			tstamp;
//这个表示一个网络设备,当skb为输出时它表示skb将要输出的设备,当接收时,它表示输入设备。要注意,这个设备有可能会是虚拟设备(在3层以上看来)
	struct net_device	*dev;
///这里其实应该是dst_entry类型,不知道为什么内核要改为ul。这个域主要用于路由子系统。这个数据结构保存了一些路由相关信息
	unsigned long		_skb_dst;
#ifdef CONFIG_XFRM
	struct	sec_path	*sp;
#endif
///这个域很重要,我们下面会详细说明。这里只需要知道这个域是保存每层的控制信息的就够了。
	char			cb[48];
///这个长度表示当前的skb中的数据的长度,这个长度即包括buf中的数据也包括切片的数据,也就是保存在skb_shared_info中的数据。这个值是会随着从一层到另一层而改变的。下面我们会对比这几个长度的。
	unsigned int		len,
///这个长度只表示切片数据的长度,也就是skb_shared_info中的长度。
				data_len;
///这个长度表示mac头的长度(2层的头的长度)
	__u16			mac_len,
///这个主要用于clone的时候,它表示clone的skb的头的长度。
				hdr_len;

///接下来是校验相关的域。
	union {
		__wsum		csum;
		struct {
			__u16	csum_start;
			__u16	csum_offset;
		};
	};
///优先级,主要用于QOS。
	__u32			priority;
	kmemcheck_bitfield_begin(flags1);
///接下来是一些标志位。
//首先是是否可以本地切片的标志。
	__u8			local_df:1,
///为1说明头可能被clone。
				cloned:1,
///这个表示校验相关的一个标记,表示硬件驱动是否为我们已经进行了校验(前面的blog有介绍)
				ip_summed:2,
///这个域如果为1,则说明这个skb的头域指针已经分配完毕,因此这个时候计算头的长度只需要head和data的差就可以了。
				nohdr:1,
///这个域不太理解什么意思。
				nfctinfo:3;

///pkt_type主要是表示数据包的类型,比如多播,单播,回环等等。
	__u8			pkt_type:3,
///这个域是一个clone标记。主要是在fast clone中被设置,我们后面讲到fast clone时会详细介绍这个域。
				fclone:2,
///ipvs拥有的域。
				ipvs_property:1,
///这个域应该是udp使用的一个域。表示只是查看数据。
				peeked:1,
///netfilter使用的域。是一个trace 标记
				nf_trace:1;
///这个表示L3层的协议。比如IP,IPV6等等。
	__be16			protocol:16;
	kmemcheck_bitfield_end(flags1);
///skb的析构函数,一般都是设置为sock_rfree或者sock_wfree.
	void			(*destructor)(struct sk_buff *skb);

///netfilter相关的域。
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
	struct nf_conntrack	*nfct;
	struct sk_buff		*nfct_reasm;
#endif
#ifdef CONFIG_BRIDGE_NETFILTER
	struct nf_bridge_info	*nf_bridge;
#endif

///接收设备的index。
	int			iif;

///流量控制的相关域。
#ifdef CONFIG_NET_SCHED
	__u16			tc_index;	/* traffic control index */
#ifdef CONFIG_NET_CLS_ACT
	__u16			tc_verd;	/* traffic control verdict */
#endif
#endif

	kmemcheck_bitfield_begin(flags2);
///多队列设备的映射,也就是说映射到那个队列。
	__u16			queue_mapping:16;
#ifdef CONFIG_IPV6_NDISC_NODETYPE
	__u8			ndisc_nodetype:2;
#endif
	kmemcheck_bitfield_end(flags2);

	/* 0/14 bit hole */

#ifdef CONFIG_NET_DMA
	dma_cookie_t		dma_cookie;
#endif
#ifdef CONFIG_NETWORK_SECMARK
	__u32			secmark;
#endif
///skb的标记。
	__u32			mark;

///vlan的控制tag。
	__u16			vlan_tci;

///传输层的头
	sk_buff_data_t		transport_header;
///网络层的头
	sk_buff_data_t		network_header;
///链路层的头。
	sk_buff_data_t		mac_header;
///接下来就是几个操作skb数据的指针。下面会详细介绍。
	sk_buff_data_t		tail;
	sk_buff_data_t		end;
	unsigned char		*head,
				*data;
///这个表示整个skb的大小,包括skb本身,以及数据。
	unsigned int		truesize;
///skb的引用计数
	atomic_t		users;
};


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

先来看cb域,他保存了每层所独自需要的内部数据。我们来看tcp的例子。

我们知道tcp层的控制信息保存在tcp_skb_cb中,因此来看内核提供的宏来存取这个数据结构:

#define TCP_SKB_CB(__skb)  ((struct tcp_skb_cb *)&((__skb)->cb[0]))


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

#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个大小。

static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
{
	unsigned char *tmp = skb_tail_pointer(skb);
	SKB_LINEAR_ASSERT(skb);
///改变相应的域。
	skb->tail += len;
	skb->len  += len;
	return tmp;
}


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

static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
{
	skb->data -= len;
	skb->len  += len;
	return skb->data;
}


剩下的两个就不贴代码了,都是很简单的函数,__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的介绍可以看这里:

http://lwn.net/Articles/140552/

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

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


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之后的skb的指针的状态。这里忽略了fclone。




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

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

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


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




  • 大小: 45.1 KB
  • 大小: 14.8 KB
  • 大小: 47.4 KB
  • 大小: 11.4 KB
  • 大小: 28 KB
  • 大小: 54.8 KB
2
2
分享到:
评论
1 楼 huzheng360buy 2013-02-02  
楼主说的
///这个域不太理解什么意思。 
                nfctinfo:3; 

实际上nfctinfo指的 netfilter conntrack info的意思

相关推荐

    Linux内核??与sk_buff有关重要数据结构

    几个月之前做了关于Linux内核版本1.2.13网络栈的结构框架分析并实现了基于Netfilter的包过滤防火墙,这里以内核3.2.1内核为例来进一步分析,更全面的分析网络栈的结构。  1、先说一下sk_buff结构体  这个...

    linuxtcpip协议栈分析.doc

    sk_buff 结构是 Linux 网络代码中最重要的数据结构,它在 `&lt;include/linux/skbuff.h&gt;` 中定义,并包含很多成员变量供网络代码中的各子系统使用。 sk_buff 结构的成员变量可以大致分为四类: 1. 布局(Layout)成员...

    linux tcp ip 协议栈内核代码静态分析

    在Linux内核TCP/IP协议栈的静态分析中,不仅要理解上述的sk_buff结构,还要深入理解网络设备驱动的注册过程,以及网络层、TCP层、UDP层之间是如何双向调用和协同工作的。Linux内核的网络子系统是一个高度抽象和模块...

    Linux 4.4.0内核源码分析TCP实现

    3. sk_buff 结构体:sk_buff 结构体是 Linux 内核中网络子系统的数据结构,它描述了一个网络数据包的信息。 Linux 4.4.0 内核源码中 TCP 实现的主要函数包括: 1. tcp_sendmsg 函数:tcp_sendmsg 函数是用户层 TCP...

    net_linux内核_源码.zip

    首先,从整体结构来看,Linux内核的网络子系统由多个层次组成,包括协议层、驱动层和设备层。协议层处理各种网络协议,如IP、TCP、UDP等;驱动层则与硬件设备交互,完成数据的发送和接收;设备层涉及到网卡等物理...

    LINUX-1.2.13内核网络栈实现源代码分析

    - **sk_buff** 是 Linux 内核中的一个重要数据结构,用于在网络栈内部表示数据包。 - 在早期版本如 **1.2.13** 中,**sk_buff** 的管理和操作通常是直接在代码中实现的,没有专门的函数集。 - 随着内核的发展,针对 ...

    深入分析Linux内核源码.chm

    1.4 分析Linux内核的意义 1.5 Linux内核结构 1.6 Linux内核源代码 1.7 Linux内核源代码分析工具 第二章 Linux运行的硬件基础 2.1 i386的寄存器 2.2 内存地址 2.3 段机制和描述符 2.4 分页机制 2.5 Linux中的分页机制...

    netfielt.rar

    其中,`makefile`教程和技术文档通常涉及构建和编译程序的过程,而`sk_buff`结构分析则与Linux内核中的网络数据包处理密切相关。 首先,让我们深入了解一下`makefile`。在程序开发中,`makefile`是一个至关重要的...

    Linux内核 tcp ip协议栈源码分析

    《Linux内核TCP/IP协议栈源码分析》 在深入探讨Linux内核的TCP/IP协议栈之前,我们先理解一下TCP/IP协议栈的基本结构。TCP/IP协议栈是互联网通信的核心,它将网络通信分为四层:应用层、传输层、网络层和数据链路层...

    Linux 4.4.0 内核源码分析 TCP实现

    首先,分析工作开始之前需要对Linux内核进行准备,了解用户层的TCP工作原理是基础,这包括对RFC文档的阅读,如RFC793定义了传输控制协议的基本规则,RFC1323介绍了TCP的高性能扩展,RFC2018讨论了TCP的选择性确认...

    Linux 2.6内核中IPSec协议接入机制研究与分析.pdf

    7. **套接字缓冲区(sk_buff)支持**:在Linux中,sk_buff数据结构是处理网络数据的关键。在IPSec的实现中,它被扩展以支持添加或删除安全头,适应安全处理的需要。 8. **路由处理支持**:dst_entry结构用于记录IP...

    LINUX内核源代码分析

    在Linux内核中,这些数据结构包括sk_buff(socket buffer),它是网络数据包的主要容器,存储了包的头部信息、数据内容和相关控制信息。此外,还有协议特定的数据结构,如TCP和UDP的控制块,它们存储了连接状态和...

    基于Linux下IEC61850的研究.pdf

    其中sk_buff含义为套接字缓冲区,定义在/include/linux/skbuff.h中。 5. 数据包发送和接收 要从协议层向设备发送数据,需要使用dev_queue_xmit函数。这个函数对数据进行排队,并交由底层设备驱动程序发送数据包。...

    linux内核协议栈分析

    Linux内核协议栈的数据结构是整个网络通信的骨架,包括了sk_buff结构体用于表示缓冲的数据包,socket结构体表示网络连接,sock和inet_sock结构体用于表示IP层的socket。其中,sk_buff是Linux内核网络数据处理的核心...

    linux-linux内核源码分析.zip

    Linux内核源码分析 Linux内核是操作系统的核心部分,负责管理硬件资源、调度进程、管理内存、提供系统调用接口等。对于任何对操作系统有深入理解或希望进行系统级编程的开发者来说,分析Linux内核源码是至关重要的...

    《Linux内核源码剖析 TCP IP实现(上册) 樊东东 莫澜 pdf扫描版.

    在Linux内核层面,书里可能会详细分析网络协议栈的数据结构,如sk_buff(socket缓冲区),它是处理网络数据包的核心结构。还会涉及socket接口的使用,它是用户空间与内核空间进行网络通信的接口。 除了基本的协议...

Global site tag (gtag.js) - Google Analytics