skb_clone--只复制skb描述符本身，如果只修改skb描述符则使用该函数克隆；
pskb_copy--复制skb描述符+线性数据区域（包括skb_shared_info），如果需要修改描述符以及数据则使用该函数复制；
skb_copy--复制所有数据，包括skb描述符+线性数据区域+非线性数据区，如果需要修改描述符和全部数据则使用该函数复制；
1 /**
2 * skb_clone - duplicate an sk_buff
3 * @skb: buffer to clone
4 * @gfp_mask: allocation priority
5 *
6 * Duplicate an &sk_buff. The new one is not owned by a socket. Both
7 * copies share the same packet data but not structure. The new
8 * buffer has a reference count of 1. If the allocation fails the
9 * function returns %NULL otherwise the new buffer is returned.
10 *
11 * If this function is called from an interrupt gfp_mask() must be
12 * %GFP_ATOMIC.
13 */
14 /*
15 用于修改skb描述符中的某些字段
16 克隆skb，该函数只克隆sk_buff部分
17 数据区域公用(需要递增引用计数)
18 */
19 struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
20 {
21 /* 获取到支持克隆的skb */
22 struct sk_buff_fclones *fclones = container_of(skb,
23 struct sk_buff_fclones,
24 skb1);
25 struct sk_buff *n;
26
27 /*
28 若发送标记有零拷贝，则拷贝用户空间的
29 片段缓存到内核空间
30 */
31 if (skb_orphan_frags(skb, gfp_mask))
32 return NULL;
33
34 /* 如果skb可以被克隆，并且克隆引用为1 */
35 if (skb->fclone == SKB_FCLONE_ORIG &&
36 atomic_read(&fclones->fclone_ref) == 1) {
37 /* 待克隆n指向skb2 */
38 n = &fclones->skb2;
39 /* 增加引用计数 */
40 atomic_set(&fclones->fclone_ref, 2);
41 }
42 /* 否则，为新克隆的skb分配内存 */
43 else {
44 if (skb_pfmemalloc(skb))
45 gfp_mask |= __GFP_MEMALLOC;
46
47 n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
48 if (!n)
49 return NULL;
50
51 kmemcheck_annotate_bitfield(n, flags1);
52 /* 初始化克隆状态 */
53 n->fclone = SKB_FCLONE_UNAVAILABLE;
54 }
55
56 /* 调用克隆 */
57 return __skb_clone(n, skb);
58 }
1 /*
2 用于修改skb描述符和数据缓冲区内容时拷贝
3 skb拷贝，拷贝skb描述符+ 线性数据缓冲区，
4 线性缓冲区以外数据共享
5 */
6 static inline struct sk_buff *pskb_copy(struct sk_buff *skb,
7 gfp_t gfp_mask)
8 {
9 return __pskb_copy(skb, skb_headroom(skb), gfp_mask);
10 }
1 /**
2 * __pskb_copy_fclone - create copy of an sk_buff with private head.
3 * @skb: buffer to copy
4 * @headroom: headroom of new skb
5 * @gfp_mask: allocation priority
6 * @fclone: if true allocate the copy of the skb from the fclone
7 * cache instead of the head cache; it is recommended to set this
8 * to true for the cases where the copy will likely be cloned
9 *
10 * Make a copy of both an &sk_buff and part of its data, located
11 * in header. Fragmented data remain shared. This is used when
12 * the caller wishes to modify only header of &sk_buff and needs
13 * private copy of the header to alter. Returns %NULL on failure
14 * or the pointer to the buffer on success.
15 * The returned buffer has a reference count of 1.
16 */
17 /*
18 拷贝skb描述符+ 线性数据缓冲区，
19 线性缓冲区外部数据共享
20 */
21 struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
22 gfp_t gfp_mask, bool fclone)
23 {
24 unsigned int size = skb_headlen(skb) + headroom;
25 int flags = skb_alloc_rx_flag(skb) | (fclone ? SKB_ALLOC_FCLONE : 0);
26 struct sk_buff *n = __alloc_skb(size, gfp_mask, flags, NUMA_NO_NODE);
27
28 if (!n)
29 goto out;
30
31 /* Set the data pointer */
32 /* 保留头部空间 */
33 skb_reserve(n, headroom);
34 /* Set the tail pointer and length */
35 /* 增加尾指针和数据长度 */
36 skb_put(n, skb_headlen(skb));
37 /* Copy the bytes */
38 /* 拷贝线性缓冲区 */
39 skb_copy_from_linear_data(skb, n->data, n->len);
40
41 /* 设置长度值 */
42 n->truesize += skb->data_len;
43 n->data_len = skb->data_len;
44 n->len = skb->len;
45
46 /* 若有片段 */
47 if (skb_shinfo(skb)->nr_frags) {
48 int i;
49
50 /* 片段数据拷贝到内核 */
51 if (skb_orphan_frags(skb, gfp_mask)) {
52 kfree_skb(n);
53 n = NULL;
54 goto out;
55 }
56
57 /* 复制判断内容 */
58 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
59 skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];
60 skb_frag_ref(skb, i);
61 }
62
63 /* 片段数 */
64 skb_shinfo(n)->nr_frags = i;
65 }
66
67 /* 如果有片段链表 */
68 if (skb_has_frag_list(skb)) {
69 /* 引用片段链表 */
70 skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
71 skb_clone_fraglist(n);
72 }
73
74 /* 拷贝头部信息 */
75 copy_skb_header(n, skb);
76 out:
77 return n;
78 }
1 /**
2 * skb_copy - create private copy of an sk_buff
3 * @skb: buffer to copy
4 * @gfp_mask: allocation priority
5 *
6 * Make a copy of both an &sk_buff and its data. This is used when the
7 * caller wishes to modify the data and needs a private copy of the
8 * data to alter. Returns %NULL on failure or the pointer to the buffer
9 * on success. The returned buffer has a reference count of 1.
10 *
11 * As by-product this function converts non-linear &sk_buff to linear
12 * one, so that &sk_buff becomes completely private and caller is allowed
13 * to modify all the data of returned buffer. This means that this
14 * function is not recommended for use in circumstances when only
15 * header is going to be modified. Use pskb_copy() instead.
16 */
17 /* 拷贝skb描述符+线性缓冲区+非线性缓冲区 */
18 struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)
19 {
20 /* 头部空间长度 */
21 int headerlen = skb_headroom(skb);
22
23 /* 分配空间= skb空间+ skb以外的数据空间 */
24 unsigned int size = skb_end_offset(skb) + skb->data_len;
25 struct sk_buff *n = __alloc_skb(size, gfp_mask,
26 skb_alloc_rx_flag(skb), NUMA_NO_NODE);
27
28 if (!n)
29 return NULL;
30
31 /* Set the data pointer */
32 //保留头部空间
33 skb_reserve(n, headerlen);
34 /* Set the tail pointer and length */
35 /* 偏移尾部指针修改总长度 */
36 skb_put(n, skb->len);
37
38 /* 拷贝数据 */
39 if (skb_copy_bits(skb, -headerlen, n->head, headerlen + skb->len))
40 BUG();
41
42 /* 拷贝skb头 */
43 copy_skb_header(n, skb);
44 return n;
45 }
时间： 2024-08-02 11:21:07