linux内核API每天来一发（5）

怼烎@ 2022-10-02 01:57 84阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

第七章 网络编程

第一节 Socket缓冲相关函数

如果想查看源码可以到这里用ctrl+F查看

[http://blog.chinaunix.net/uid-488742-id-2113564.html][http_blog.chinaunix.net_uid-488742-id-2113564.html]

skb\_queue\_empty

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>检查一个队列是否为空</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>int skb_queue_empty(struct sk_buff_head* list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list---队列头指针</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>如果队列为空，返回TRUE</td> 
  </tr> 
 </tbody> 
</table>

skb\_get

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>获取socket buffer的新引用</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff* skb_get(struct sk_buff* skb)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb---被引用的socket buffer</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>向socket添加一个新的引用，同时返回指向缓冲区的指针</td> 
  </tr> 
 </tbody> 
</table>

kfree\_skb

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>释放一个socket buffer引用</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void kfree_skb(struct sk_buff* skb)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb----被释放的socket buffer指针</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>当缓冲区的使用量为0 时 ，可以将其删除</td> 
  </tr> 
 </tbody> 
</table>

skb\_cloned

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>缓冲区是否是克隆的</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>int skb_cloned(struct sk_buff* skb)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb----为要检查的缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>如果以skb_clone标志来产生缓冲区，并且是缓冲区多个共享拷贝中的一个，则返回真。克隆的缓冲区具有共享数据，因此在正常情况下不必对其进行写。</td> 
  </tr> 
 </tbody> 
</table>

skb\_shared

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>缓冲区是否是可共享的</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>int skb_shared(struct sk_buff* skb)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb---为要检查的缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>如果有多于一个的人引用这个缓冲区就返回真。</td> 
  </tr> 
 </tbody> 
</table>

skb\_share\_check

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>检查缓冲区是否共享的，如果是就克隆它</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff * skb_share_check (struct sk_buff * skb, int pri)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb---为要检查的缓冲区 <br>pri---为内存分配的优先级</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td> <p>如果缓冲区是共享的，就克隆这个缓冲区，并把原来缓冲区的引用计数减1，返回新克隆的缓冲区。如果不是共享的，则返回原来的缓冲区。当从中断状态或全局锁调用该函数时，pri必须是GFP_ATOMIC。 <br>内存分配失败则返回NULL</p> </td> 
  </tr> 
 </tbody> 
</table>

skb\_unshare

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>产生一个共享缓冲区的拷贝</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff * skb_unshare (struct sk_buff * skb, int pri);</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb---为要检查的缓冲区 <br>pri---为内存分配的优先级</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td> <p>如果套接字缓冲区是克隆的，那么这个函数就创建一个新的数据拷贝，并把原来缓冲区的引用计数减1，返回引用计数为1的新拷贝。如果不是克隆的，就返回原缓冲区。当从中断状态或全局锁调用该函数时，pri必须是GFP_ATOMIC。 <br>内存分配失败则返回NULL。</p> </td> 
  </tr> 
 </tbody> 
</table>

skb\_peek

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>查看skb</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff * skb_peek (struct sk_buff_head * list_);</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list_----为测量的链表</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

skb\_queue\_len

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>获得队列的长度</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>__u32 skb_queue_len (struct sk_buff_head * list_)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td> <p>list_----为测量的链表</p> </td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td> <p>返回&amp;sk_buff 队列的指针。</p> </td> 
  </tr> 
 </tbody> 
</table>

\_\_skb\_queue\_head

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>在链表首部对一个缓冲区排队</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void __skb_queue_head (struct sk_buff_head * list, struct sk_buff * newsk)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td> <p>list---为要使用的链表 <br>newsk---为要排队的缓冲区</p> </td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>在链表首部对一个缓冲区进行排队。这个函数没有锁，因此在调用它之前必须持有必要的锁。一个缓冲区不能同时放在两个链表中</td> 
  </tr> 
 </tbody> 
</table>

skb\_queue\_head

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>在链表首部对一个缓冲区排队</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_queue_head (struct sk_buff_head * list, struct sk_buff * newsk)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td> <p>list---为要使用的链表 <br>newsk---为要排队的缓冲区</p> </td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>在链表首部对一个缓冲区进行排队。这个函持有锁，因此可以安全地使用。一个缓冲区不能同时放在两个链表中。</td> 
  </tr> 
 </tbody> 
</table>

\_\_skb\_queue\_tail

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>在链表尾部对一个缓冲区排队</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void __skb_queue_tail (struct sk_buff_head * list, struct sk_buff * newsk)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td> <p>list---为要使用的链表， <br>newsk---为要排队的缓冲区</p> </td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>在链表尾部对一个缓冲区进行排队。这个函数没有锁，因此在调用它之前必须持有必要的锁。一个缓冲区不能同时放在两个链表中。</td> 
  </tr> 
 </tbody> 
</table>

skb\_dequeue\_tail

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>从队头删除</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *skb_dequeue_tail(struct sk_buff_head * list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>List为要操作的链表删除链表尾部</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数持有锁，因此可以安全地使用。如果队链表为空则返回NULL，成功则返回首部元素。</td> 
  </tr> 
 </tbody> 
</table>

\_\_\_skb\_dequeue

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>从队列的首部删除一个缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff * __skb_dequeue (struct sk_buff_head * list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list为要操作的队列删除链表首部</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数不持有任何锁，因此使用时应当持有适当的锁。如果队链表为空则返回NULL，成功则返回首部元素。</td> 
  </tr> 
 </tbody> 
</table>

skb\_dequeue

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>从队列的首部删除一个缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff * skb_dequeue (struct sk_buff_head * list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list为要操作的队列删除链表首部</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数持有锁，因此可以安全地使用。如果队链表为空则返回NULL，成功则返回首部元素</td> 
  </tr> 
 </tbody> 
</table>

skb\_insert

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>插入一个缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_insert (struct sk_buff * old, struct sk_buff * newsk)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>old---为插入之前的缓冲区 <br>newsk---为要插入的缓冲区把一个数据包放在链表中给定的包之前</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>该函数持有链表锁，并且是原子操作。一个缓冲区不能同时放在两个链表中。</td> 
  </tr> 
 </tbody> 
</table>

skb\_append

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>追加一个缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_append (struct sk_buff * old, struct sk_buff * newsk)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>old---为插入之前的缓冲区 <br>newsk---为要插入的缓冲区把一个数据包放在链表中给定的包之前</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>该函数持有链表锁，并且是原子操作。一个缓冲区不能同时放在两个链表中。</td> 
  </tr> 
 </tbody> 
</table>

skb\_unlink

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>从链表删除一个缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_unlink(struct sk_buff *skb);</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>Skb为要删除的缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>把一个数据包放在链表中给定的包之前。该函数持有链表锁，并且是原子操作。</td> 
  </tr> 
 </tbody> 
</table>

\_\_skb\_dequeue\_tail

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>从队尾删除</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *__skb_dequeue_tail(struct sk_buff_head * list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list为要操作的链表从链表尾部删除</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数不持有任何锁，因此必须持以合适的锁来使用。如果链表为空，则返回NULL，成功则返首部元素。</td> 
  </tr> 
 </tbody> 
</table>

skb\_dequeue\_tail

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>从队头删除</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *skb_dequeue_tail(struct sk_buff_head * list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list为要操作的链表从链表尾部删除</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数持有锁，因此可以安全地使用。如果队链表为空则返回NULL，成功则返回首部元素。</td> 
  </tr> 
 </tbody> 
</table>

skb\_put

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>把数据加到缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>unsigned char *skb_put (struct sk_buff * skb, unsigned int len)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要使用的缓冲区 <br>len为要增加的数据长度</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数扩充缓冲区所使用的数据区。如果扩充后超过缓冲区总长度，内核会产生警告。函数返回的指针指向所扩充数据的第一个字节。</td> 
  </tr> 
 </tbody> 
</table>

skb\_push

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>把数据加到缓冲区的开始</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>unsigned char *skb_push (struct sk_buff * skb, unsigned int len);</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要使用的缓冲区，len为要增加的数据长度</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数扩充在缓冲区的开始处缓冲区所使用的数据区。如果扩充后超过缓冲区首部空间的总长度，内核会产生警告。函数返回的指针指向所扩充数据的第一个字节。</td> 
  </tr> 
 </tbody> 
</table>

skb\_headroom

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>缓冲区首部空闲空间的字节数</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>int skb_headroom(const struct sk_buff * skb)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要检查的缓冲区返回&amp;sk_buff首部空闲空间的字节数</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

skb\_tailroom

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>缓冲区尾部的空闲字节数</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>int skb_tailroom(const struct sk_buff * skb)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要检查的缓冲区返回&amp;sk_buff尾部空闲空间的字节数</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

skb\_reserve

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>调整头部的空间</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_reserve(struct sk_buff * skb, unsigned int len)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要改变的缓冲区，len为要删除的字节数</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>通过减少尾部空间，增加一个空&amp;sk_buff的首部空间。这仅仅适用于空缓冲区。</td> 
  </tr> 
 </tbody> 
</table>

skb\_trim

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>从缓冲区删除尾部</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_trim (struct sk_buff * skb, unsigned int len)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要改变的缓冲区，len为新的长度</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>通过从尾部删除数据，剪切缓冲区的长度。如果缓冲区已经处于指定的长度，则不用改变。</td> 
  </tr> 
 </tbody> 
</table>

skb\_orphan

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>使一个缓冲区成为孤儿</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_orphan(struct sk_buff *skb);</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb是要成为孤儿的缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>如果一个缓冲区当前有一个拥有者，我们就调用拥有者的析构函数，使skb没有拥有者。该缓冲区继续存在，但以前的拥有者不再对其“负责”。</td> 
  </tr> 
 </tbody> 
</table>

skb\_queue\_purge

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>使一个链表空</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_queue_purge(struct sk_buff_head * list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list为要腾空的链表删除在&amp;sk_buff链表上的所有缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数持有链表锁，并且是原子的。</td> 
  </tr> 
 </tbody> 
</table>

\_\_\_skb\_queue\_purge

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>使一个链表空</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void__skb_queue_purge(struct sk_buff_head * list)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>list为要腾空的链表删除在&amp;sk_buff链表上的所有缓冲区。</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个函数不持有链表锁，调用者必须持有相关的锁来使用它。</td> 
  </tr> 
 </tbody> 
</table>

\_\_\_dev\_alloc\_skb

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>为发送分配一个skbuff</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *dev_alloc_skb(unsigned int length)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>Length为要分配的长度分配一个新的&amp;sk_buff，并赋予它一个引用计数</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>这个缓冲区有未确定的头空间。用户应该分配自己需要的头空间。如果没有空闲内存，则返回NULL。尽管这个函数是分配内存，但也可以从中断来调用。</td> 
  </tr> 
 </tbody> 
</table>

dev\_alloc\_skb

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>为发送分配一个skbuff</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *dev_alloc_skb(unsigned int length)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>length为要分配的长度分配一个新的&amp;sk_buff，并赋予它一个引用计数</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td> <p>这个缓冲区有未确定的头空间。用户应该分配自己需要的头空间。 <br>如果没有空闲内存，则返回NULL。尽管这个函数是分配内存，但也可以从中断来调用。</p> </td> 
  </tr> 
 </tbody> 
</table>

skb\_cow

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>当需要时拷贝skb的首部</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *skb_cow (struct sk_buff * skb, unsigned int headroom)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>Skb为要拷贝的缓冲区，headroom为需要的头空间</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>如果传递过来的缓冲区缺乏足够的头空间或是克隆的，则该缓冲区被拷贝，并且附加的头空间变为可用。如果没有空闲的内存，则返回空。如果缓冲区拷贝成功，则返回新的缓冲区，否则返回已存在的缓冲区。</td> 
  </tr> 
 </tbody> 
</table>

skb\_over\_panic

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>有函数</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void skb_over_panic(struct sk_buff * skb, int sz, void * here)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为缓冲区，sz为大小，here为地址</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>用户不可调用。</td> 
  </tr> 
 </tbody> 
</table>

alloc\_skb

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>分配一个网络缓冲区</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *alloc_skb (unsigned int size, int gfp_mask)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>size为要分配的大小，gfp_mask为分配掩码</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>分配一个新的&amp;sk_buff。返回的缓冲区没有size大小的头空间和尾空间。新缓冲区的引用计数为1。返回值为一缓冲区，如果失败则返回空。从中断分配缓冲区，掩码只能使用GFP_ATOMIC的gfp_mask。</td> 
  </tr> 
 </tbody> 
</table>

\_\_kfree\_skb

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>私有函数</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>void __kfree_skb(struct sk_buff * skb)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为缓冲区释放一个sk_buff</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>释放与该缓冲区相关的所有事情，清除状态。这是一个内部使用的函数，用户应当调用kfree_skb</td> 
  </tr> 
 </tbody> 
</table>

skb\_clone

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>复制一个sk_buff</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *skb_clone (struct sk_buff * skb, intgfp_mask)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要克隆的缓冲区，gfp_mask为分配掩码</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td>复制一个&amp;sk_buff。新缓冲区不是由套接字拥有。两个拷贝共享相同的数据包而不是结构。新缓冲区的引用计数为1。如果分配失败，函数返回NULL，否则返回新的缓冲区。如果从中断调用这个函数，掩码只能使用GFP_ATOMIC的</td> 
  </tr> 
 </tbody> 
</table>

skb\_copy

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>创建一个sk_buff的私有拷贝</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td>struct sk_buff *skb_copy (const struct sk_buff * skb, int gfp_mask)</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要拷贝的缓冲区，gfp_mask为分配优先级</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td> <p>既拷贝&amp;sk_buff也拷贝其数据。该函数用在调用者希望修改数据并需要数据的私有拷贝来进行改变时。失败返回NULL，成功返回指向缓冲区的指针。 <br>返回的缓冲区其引用计数为1。如果从中断调用，则必须传递的优先级为GFP_ATOMIC。</p> </td> 
  </tr> 
 </tbody> 
</table>

skb\_copy\_expand

<table> 
 <tbody> 
  <tr> 
   <td>函数名称</td> 
   <td>拷贝并扩展sk_buff</td> 
  </tr> 
  <tr> 
   <td>函数原型</td> 
   <td> <p>struct sk_buff *skb_copy_expand(const struct sk_buff * skb, int <br>newheadroom, int newtailroom, int gfp_mask)</p> </td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>skb为要拷贝的缓冲区，newheadroom为头部的新空闲字节数，newtailroom为尾部的新空闲字节数gfp_mask为分配掩码</td> 
  </tr> 
  <tr> 
   <td>函数简介</td> 
   <td> <p>既拷贝&amp;sk_buff也拷贝其数据，同时分配额外的空间。当调用者希望修改数据并需要对私有数据进行改变，以及给新的域更多的空间时调用该函数。失败返回NULL，成功返回指向缓冲区的指针。 <br>返回的缓冲区其引用计数为1。如果从中断调用，则必须传递的优先级为GFP_ATOM</p> </td> 
  </tr> 
 </tbody> 
</table>

转载于:https://my.oschina.net/fuchao2014/blog/126271

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220113/d670dd71718d42d88b34616cb573339b.png
[http_blog.chinaunix.net_uid-488742-id-2113564.html]: http://blog.chinaunix.net/uid-488742-id-2113564.html