skb管理函数之skb_clone、pskb_copy、skb_copy

skb_clone–只复制skb描述符本身，如果只修改skb描述符则使用该函数克隆；

pskb_copy–复制skb描述符+线性数据区域（包括skb_shared_info），如果需要修改描述符以及数据则使用该函数复制；

skb_copy–复制所有数据，包括skb描述符+线性数据区域+非线性数据区，如果需要修改描述符和全部数据则使用该函数复制；

以下为三个函数的分析；

 /**
  *    skb_clone    -    duplicate an sk_buff
  *    @skb: buffer to clone
  *    @gfp_mask: allocation priority
  *
  *    Duplicate an &sk_buff. The new one is not owned by a socket. Both
  *    copies share the same packet data but not structure. The new
  *    buffer has a reference count of 1. If the allocation fails the
  *    function returns %NULL otherwise the new buffer is returned.
  *
  *    If this function is called from an interrupt gfp_mask() must be
  *    %GFP_ATOMIC.
  */
 /*
 用于修改skb描述符中的某些字段
     克隆skb，该函数只克隆sk_buff部分
     数据区域公用(需要递增引用计数)
 */
 struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
 {
     /* 获取到支持克隆的skb */
     struct sk_buff_fclones *fclones = container_of(skb,
                                struct sk_buff_fclones,
                                skb1);
     struct sk_buff *n;

     /*
         若发送标记有零拷贝，则拷贝用户空间的
         片段缓存到内核空间
     */
     if (skb_orphan_frags(skb, gfp_mask))
         return NULL;

     /* 如果skb可以被克隆，并且克隆引用为1 */
     if (skb->fclone == SKB_FCLONE_ORIG &&
         atomic_read(&fclones->fclone_ref) == ) {
         /* 待克隆n指向skb2 */
         n = &fclones->skb2;
         /* 增加引用计数 */
         atomic_set(&fclones->fclone_ref, );
     }
     /* 否则，为新克隆的skb分配内存 */
     else {
         if (skb_pfmemalloc(skb))
             gfp_mask |= __GFP_MEMALLOC;

         n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
         if (!n)
             return NULL;

         kmemcheck_annotate_bitfield(n, flags1);
         /* 初始化克隆状态 */
         n->fclone = SKB_FCLONE_UNAVAILABLE;
     }

     /* 调用克隆 */
     return __skb_clone(n, skb);
 }

 /*
     用于修改skb描述符和数据缓冲区内容时拷贝
     skb拷贝，拷贝skb描述符+ 线性数据缓冲区，
     线性缓冲区以外数据共享
 */
 static inline struct sk_buff *pskb_copy(struct sk_buff *skb,
                     gfp_t gfp_mask)
 {
     return __pskb_copy(skb, skb_headroom(skb), gfp_mask);
 }

 /**
  *    __pskb_copy_fclone    -  create copy of an sk_buff with private head.
  *    @skb: buffer to copy
  *    @headroom: headroom of new skb
  *    @gfp_mask: allocation priority
  *    @fclone: if true allocate the copy of the skb from the fclone
  *    cache instead of the head cache; it is recommended to set this
  *    to true for the cases where the copy will likely be cloned
  *
  *    Make a copy of both an &sk_buff and part of its data, located
  *    in header. Fragmented data remain shared. This is used when
  *    the caller wishes to modify only header of &sk_buff and needs
  *    private copy of the header to alter. Returns %NULL on failure
  *    or the pointer to the buffer on success.
  *    The returned buffer has a reference count of 1.
  */
 /*
     拷贝skb描述符+ 线性数据缓冲区，
     线性缓冲区外部数据共享
 */
 struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
                    gfp_t gfp_mask, bool fclone)
 {
     unsigned int size = skb_headlen(skb) + headroom;
     int flags = skb_alloc_rx_flag(skb) | (fclone ? SKB_ALLOC_FCLONE : );
     struct sk_buff *n = __alloc_skb(size, gfp_mask, flags, NUMA_NO_NODE);

     if (!n)
         goto out;

     /* Set the data pointer */
     /* 保留头部空间 */
     skb_reserve(n, headroom);
     /* Set the tail pointer and length */
     /* 增加尾指针和数据长度 */
     skb_put(n, skb_headlen(skb));
     /* Copy the bytes */
     /* 拷贝线性缓冲区 */
     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;

         /* 片段数据拷贝到内核 */
         if (skb_orphan_frags(skb, gfp_mask)) {
             kfree_skb(n);
             n = NULL;
             goto out;
         }

         /* 复制判断内容 */
         for (i = ; i < skb_shinfo(skb)->nr_frags; i++) {
             skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];
             skb_frag_ref(skb, i);
         }

         /* 片段数 */
         skb_shinfo(n)->nr_frags = i;
     }

     /* 如果有片段链表 */
     if (skb_has_frag_list(skb)) {
         /* 引用片段链表 */
         skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
         skb_clone_fraglist(n);
     }

     /* 拷贝头部信息 */
     copy_skb_header(n, skb);
 out:
     return n;
 }

 /**
  *    skb_copy    -    create private copy of an sk_buff
  *    @skb: buffer to copy
  *    @gfp_mask: allocation priority
  *
  *    Make a copy of both an &sk_buff and its data. This is used when the
  *    caller wishes to modify the data and needs a private copy of the
  *    data to alter. Returns %NULL on failure or the pointer to the buffer
  *    on success. The returned buffer has a reference count of 1.
  *
  *    As by-product this function converts non-linear &sk_buff to linear
  *    one, so that &sk_buff becomes completely private and caller is allowed
  *    to modify all the data of returned buffer. This means that this
  *    function is not recommended for use in circumstances when only
  *    header is going to be modified. Use pskb_copy() instead.
  */
 /* 拷贝skb描述符+线性缓冲区+非线性缓冲区 */
 struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)
 {
     /* 头部空间长度 */
     int headerlen = skb_headroom(skb);

     /* 分配空间= skb空间+ skb以外的数据空间 */
     unsigned int size = skb_end_offset(skb) + skb->data_len;
     struct sk_buff *n = __alloc_skb(size, gfp_mask,
                     skb_alloc_rx_flag(skb), NUMA_NO_NODE);

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

     /* 拷贝skb头 */
     copy_skb_header(n, skb);
     return n;
 }