SKB几个复制函数的区别

本文主要是介绍SKB几个复制函数的区别，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1、skb_clone()

Skb_clone()函数只是复制sk_buff结构，并不复制skb的数据缓冲区。Clone后的sk_buff结构与原始的sk_buff指向同一数据缓冲区。原始的和clone后的skb描述符的cloned值都会被置1，clone的skb描述符的users值置1，同时数据缓冲区的引用计数dataref增加1。

1. struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
   
2. {
   
3.     struct sk_buff *n;
   
4. 
   
5.     /* n指向被clone的skb */
   
6.     n = skb + 1;
   
7.     /* 判断原始skb是否是从skbuff_fclone_cache 缓冲区中分配的，从skbuff_fclone_cache 分配将预先为clone的skb分配好内存，同时判定该预先分配的clone skb是否被使用 */
   
8.     if (skb->fclone == SKB_FCLONE_ORIG &&
   
9.      n->fclone == SKB_FCLONE_UNAVAILABLE) {
   
10.         /* 预先从skbuff_fclone_cache 中分配的skb结构，且未使用，则增加dataref计数*/
    
11.         atomic_t *fclone_ref = (atomic_t *) (n + 1);
    
12.         n->fclone = SKB_FCLONE_CLONE; /* 置clone的skb中fclone值为SKB_FCLONE_CLONE ，标明其数据区指向原始skb同一数据区 */
    
13.         atomic_inc(fclone_ref);
    
14.     } else {
    
15.         /* 主skb并未同时分配clone skb的情况，将重新独立分配skb结构作为clone的skb */
    
16.         n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
    
17.         if (!n)
    
18.             return NULL;
    
19. 
    
20.         kmemcheck_annotate_bitfield(n, flags1);
    
21.         kmemcheck_annotate_bitfield(n, flags2);
    
22.         /* 指明该clone的skb并未分配独立的数据缓冲区 */
    
23.         n->fclone = SKB_FCLONE_UNAVAILABLE;
    
24.     }
    
25.     /* 完成后续的skb结构体的复制工作 */
    
26.     return __skb_clone(n, skb);
    
27. }
    
28. 
    
29. 
    
30. /*
    
31.  * You should not add any new code to this function. Add it to
    
32.  * __copy_skb_header above instead.
    
33.  */
    
34. static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
    
35. {
    
36. #define C(x) n->x = skb->x
    
37. 
    
38.     n->next = n->prev = NULL;
    
39.     n->sk = NULL;
    
40.     /* copy 头部字段，详细请参考源代码，很简单 */
    
41.     __copy_skb_header(n, skb);
    
42. 
    
43.     C(len);
    
44.     C(data_len);
    
45.     C(mac_len);
    
46.     n->hdr_len = skb->nohdr ? skb_headroom(skb) : skb->hdr_len;
    
47.     n->cloned = 1;
    
48.     n->nohdr = 0;
    
49.     n->destructor = NULL;
    
50.     C(tail);
    
51.     C(end);
    
52.     C(head);
    
53.     C(data);
    
54.     C(truesize);
    
55.     /* 设置skb描述符的users为1 */
    
56.     atomic_set(&n->users, 1);
    
57. 
    
58.     /* 增加shinfo中dataref的引用计数，因为clone的skb与原始skb指向同一数据缓冲区*/
    
59.     atomic_inc(&(skb_shinfo(skb)->dataref));
    
60.     skb->cloned = 1; /* 指明原始skb是被clone过的 */
    
61. 
    
62.     return n;
    
63. #undef C
    
64. }

65. 特别说明，skb_clone()函数复制的只是skb描述符，而复制后的skb与原始skb指向的是同一数据缓冲区，由于数据缓冲区并未加什么同步锁机制，因此skb_clone()操作的skb结构的数据缓冲区是不能被修改的。

    2、pskb_copy()

    与skb_copy()不同，当一个函数不仅需要修改skb描述符，而且需要修改其缓冲区中的数据时，就需要复制缓冲区的数据。如果需要修改的数据在skb->head到skb->end之间，即数据是一个线性空间的数据时，便可调用pskb_copy()函数来完成此操作。

    1. /**
        * pskb_copy - create copy of an sk_buff with private head.
       
       
    2.  * Make a copy of both an &sk_buff and part of its data, located
       
    3. 
       
    4.  * in header. Fragmented data remain shared. This is used when
       
    5. 
       
    6.  * the caller wishes to modify only header of &sk_buff and needs
       
    7. 
       
    8.  * private copy of the header to alter. Returns %NULL on failure
       
    9. 
       
    10.  * or the pointer to the buffer on success.
        
    11. 
        
    12.  * The returned buffer has a reference count of 1.
        
    13. 
        
    14.  */
        
    15. 
        
    16. struct sk_buff *pskb_copy(struct sk_buff *skb, gfp_t gfp_mask)
    17. {
        
        
    18.        struct sk_buff *n;
        
    19. /* 先申请skb描述符字段的内存空间，在这种情况下，skb描述符是不能继用预先分配的skb描述符的 */
        
    21. #ifdef NET_SKBUFF_DATA_USES_OFFSET
        
    22.        n = alloc_skb(skb->end, gfp_mask);
        
    23. #else
        
    24.        n = alloc_skb(skb->end - skb->head, gfp_mask);
        
    25. #endif
               if (!n)
                      goto out;
        
    26.        /* Set the data pointer */
            /* 设置数据指针 */
               skb_reserve(n, skb->data - skb->head);
               /* Set the tail pointer and length */
            /* 设置skb->tail指针和skb->len 长度 */
        
    27.        skb_put(n, skb_headlen(skb));
               /* Copy the bytes */
            /* 拷贝线性空间的数据 */
               skb_copy_from_linear_data(skb, n->data, n->len);
        
    28.     /* 对share info结构进行拷贝，并设置相关字段的值 */
        
    29.        n->truesize += skb->data_len;
        
        
    30.        n->data_len = skb->data_len;
        
    31.        n->len = skb->len;
        
    32.        if (skb_shinfo(skb)->nr_frags) {
                      int i;
        
    33.         /*在share info中有数据的情况下，拷贝share字段，特别注意：这里并没有拷贝share info中的数据 */
        
    34.               for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
        
    35.                      skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];
        
    36.                      get_page(skb_shinfo(n)->frags[i].page);
        
    37. 
        
    38.               }
        
    39.               skb_shinfo(n)->nr_frags = i;
        
    40. 
        
    41.        }
        
        
    42.        if (skb_has_frags(skb)) {
                      skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
        
    43.               skb_clone_fraglist(n);
        
    44.        }
        
    45.     /* 拷贝skb头部的相关字段 */
        
    46. 
        
    47.        copy_skb_header(n, skb);
        
    48. 
        
    49. out:
        
    50.        return n;
        
    51. 
        
    52. }
        
        
    53. static inline void skb_reserve(struct sk_buff *skb, int len
    54. {
        
    55.        skb->data += len;
        
    56.        skb->tail += len;
        
    57. }

    特别说明：pskb_copy()与skb_copy()更重量级一些，他不仅仅拷贝skb描述符，还需要拷贝skb->data指向的数据，但他并不拷贝share info指向的非线性数据，新skb的share info指向与原始skb的share info相同的数据。

这篇关于SKB几个复制函数的区别的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---