【转】sk_buff详解

One of the problems of having many layers of network protocols, each one using the services of another, is that each protocol needs to add protocol headers and tails to data as it is transmitted and to remove them as it processes received data [Cox96] [Rus96]. This make passing data buffers between the protocols difficult as each layer needs to find where its particular protocol headers and tails are. One solution is to copy buffers at each layer but that would be inefficient. Instead, Linux uses socket buffers or sk_buffs to pass data between the protocol layers and the network device drivers. sk_buffs contain pointer and length fields that allow each protocol layer to manipulate the application data via standard functions or "methods".

Figure: Network Socket Buffers

Figure (fig [*]) shows the sk_buff data structure, each sk_buff has a block of data associated with it. The sk_buff has four data pointers, which are used to manipulate and manage the socket buffer's data. (The reader is referred to include/linux/skbuff.h of the linux source for details).

head points to the start of the data area in memory. This is fixed when the sk_buff and its associated data block is allocated.

data points at the current start of the protocol data. This pointer varies depending on the protocol layer that currently owns the sk_buff.

tail points at the current end of the protocol data. Again, this pointer varies depending on the owning protocol layer.

end points at the end of the data area in memory. This is fixed when the sk_buff is allocated.

There are two length fields len and truesize, which describe the length of the current protocol packet and the total size of the data buffer respectively. The sk_buff handling code provides standard mechanisms for adding and removing protocol headers and tails to the application data. These safely manipulate the data, tail and len fields in the sk_buff. (The reader is advised to refer to net/core/skbuff.c for more details).

push This moves the data pointer towards the start of the data area and increments the len field. This is used when adding data or protocol headers to the start of the data to be transmitted.

pull This moves the data pointer away from the start, towards the end of the data area and decrements the len field. This is used when removing data or protocol headers from the start of the data that has been received.

put This moves the tail pointer towards the end of the data area and increments the len field. This is used when adding data or protocol information to the end of the data to be transmitted.

trim This moves the tail pointer towards the start of the data area and decrements the len field. This is used when removing data or protocol tails from the received packet.

The sk_buff data structure also contains pointers that are used as it is stored in doubly linked circular lists of sk_buff's during processing. There are generic sk_buff routines for adding sk_buffs to the front and back of these lists and for removing them.

The primary goal of the sk_buff routines is to provide a consistent and efficient buffer handling method for all of the network layers, and by being consistent to make it possible to provide higher level sk_buff and socket handling facilities to all the protocols.

包缓冲区操作的几个内嵌函数
==========================

包缓冲由sk_buff结构描述, 包缓冲数据区由其head和end成员界定,
而包数据体则由包数据区内data和tail界定的子区域来描述,
采用这种结构可以使添加或去除包头的操作变得非常方便.

skb_put(skb,len) 在包体尾部扩展长度为len的数据块, 返回扩展块的地址

__skb_put()为未校验版本

skb_push(skb,len) 在包体前部扩展长度为len的数据块, 返回扩展块的地址

__skb_push()为未校验版本

skb_pull(skb,len) 去除包体前部长度为len的数据块, 返回新包体的起始地址

__skb_pull()为未校验版本

skb_headroom(skb) 返回包体前部距离包区开始的长度

skb_tailroom(skb) 返回包体尾部距离包区结束的长度

skb_reserve(skb,len) 设置包体起始位置为包区开始的len字节

skb_trim(skb,len) 将包体截断为len字节, __skb_trim()为未校验版本

; include/linux/skbuff.h:

struct sk_buff {
　　...
　　unsigned int len; /* Length of actual data */
　　unsigned char *head; /* Head of buffer */
　　unsigned char *data; /* Data head pointer */
　　unsigned char *tail; /* Tail pointer */
　　unsigned char *end; /* End pointer */
　　...
}

/*
* Add data to an sk_buff
*/

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

/**
* skb_put - add data to a buffer
* @skb: buffer to use 
* @len: amount of data to add
*
* This function extends the used data area of the buffer. If this would
* exceed the total buffer size the kernel will panic. A pointer to the
* first byte of the extra data is returned.
*/

static inline unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
{
　　unsigned char *tmp=skb->tail;
　　skb->tail+=len;
　　skb->len+=len;
　　if(skb->tail>skb->end)
　　{
　　　　skb_over_panic(skb, len, current_text_addr());
　　}
　　return tmp;
}

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

/**
* skb_push - add data to the start of a buffer
* @skb: buffer to use 
* @len: amount of data to add
*
* This function extends the used data area of the buffer at the buffer
* start. If this would exceed the total buffer headroom the kernel will
* panic. A pointer to the first byte of the extra data is returned.
*/

static inline unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
{
　　skb->data-=len;
　　skb->len+=len;
　　if(skb->datahead)
　　{
　　　　skb_under_panic(skb, len, current_text_addr());
　　}
　　return skb->data;
}

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

/**
* skb_pull - remove data from the start of a buffer
* @skb: buffer to use 
* @len: amount of data to remove
*
* This function removes data from the start of a buffer, returning
* the memory to the headroom. A pointer to the next data in the buffer
* is returned. Once the data has been pulled future pushes will overwrite
* the old data.
*/

static inline unsigned char * skb_pull(struct sk_buff *skb, unsigned int len)
{ 
　　if (len > skb->len)
　　　　return NULL;
　　return __skb_pull(skb,len);
}

/**
* skb_headroom - bytes at buffer head
* @skb: buffer to check
*
* Return the number of bytes of free space at the head of an &sk_buff.
*/

static inline int skb_headroom(const struct sk_buff *skb)
{
　　return skb->data-skb->head;
}

/**
* skb_tailroom - bytes at buffer end
* @skb: buffer to check
*
* Return the number of bytes of free space at the tail of an sk_buff
*/

static inline int skb_tailroom(const struct sk_buff *skb)
{
　　return skb->end-skb->tail;
}

/**
* skb_reserve - adjust headroom
* @skb: buffer to alter
* @len: bytes to move
*
* Increase the headroom of an empty &sk_buff by reducing the tail
* room. This is only allowed for an empty buffer.
*/

static inline void skb_reserve(struct sk_buff *skb, unsigned int len)
{
　　skb->data+=len;
　　skb->tail+=len;
}


static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
{
　　skb->len = len;
　　skb->tail = skb->data+len;
}

/**
* skb_trim - remove end from a buffer
* @skb: buffer to alter
* @len: new length
*
* Cut the length of a buffer down by removing data from the tail. If
* the buffer is already under the length specified it is not modified.
*/

static inline void skb_trim(struct sk_buff *skb, unsigned int len)
{
　　if (skb->len > len)

　　{
　　　　__skb_trim(skb, len);
　　}
}