kernel 3.10内核源码分析--ip_ufo_append_data()--UDP发包流程

1、基本原理
本文主要涉及ip_append_data中的UFO(UDP Fragment Offload)相关流程，主要由ip_ufo_append_data函数完成相关功能。比较简单。
UFO(UDP Fragment Offload)是硬件网卡提供的一种特性，由内核和驱动配合完成相关功能。其目的是由网卡硬件来完成本来需要软件进行的分段(分片)操作用于提升效率和性能。如大家所知，在网络上传输的数据包不能大于mtu，当用户发送大于mtu的数据报文时，通常会在传输层(或者在特殊情况下在IP层分片，比如ip转发或ipsec时)就会按mtu大小进行分段，防止发送出去的报文大于mtu，为提升该操作的性能，新的网卡硬件基本都实现了UFO功能，可以使分段(或分片)操作在网卡硬件完成，此时用户态就可以发送长度大于mtu的包，而且不必在协议栈中进行分段(或分片)。
ip_ufo_append_data函数大致原理为：当硬件支持且打开了UFO、udp包大小大于mtu会进入此流程，将用户态数据拷贝拷skb中的非线性区中(即skb_shared_info->frags[]，原本用于SG)。

2、基本流程
主要流程为：从sock发送队列中取skb，如果发送队列为空，则新分配一个skb；如果不为空，则直接使用该skb；然后,判断per task的page_frag中是否有空间可用，有的话，就直接从用户态拷贝数据到该page_frag中，如果没有空间，则分配新的page，放入page_frag中，然后再从用户态拷贝数据到其中，最后将该page_frag中的page链入skb的非线性区中(即skb_shared_info->frags[]).
进入ip_ufo_append_data的调用流程为：
udp_sendmsg-->
    ip_append_data-->
        __ip_append_data-->
            ip_ufo_append_data

3、代码分析
__ip_append_data->ip_ufo_append_data():

点击(此处)折叠或打开

1. /*
   
2.   * ip_append_data中，如果满足ufo的条件，则进入这里处理。
   
3.   * 主要是利用了skb中的frags[]区域存放数据，该区域原本是用于SG场景的，但UFO此时也复用了这段区域。
   
4.   */
   
5. static inline int ip_ufo_append_data(struct sock *sk,
   
6.             struct sk_buff_head *queue,
   
7.             int getfrag(void *from, char *to, int offset, int len,
   
8.              int odd, struct sk_buff *skb),
   
9.             void *from, int length, int hh_len, int fragheaderlen,
   
10.             int transhdrlen, int maxfraglen, unsigned int flags)
    
11. {
    
12.     struct sk_buff *skb;
    
13.     int err;
    
14. 
    
15.     /* There is support for UDP fragmentation offload by network
    
16.      * device, so create one single skb packet containing complete
    
17.      * udp datagram
    
18.      */
    
19.     /*从sock请求队列队尾取skb，如果为空，需要重新分配skb*/
    
20.     if ((skb = skb_peek_tail(queue)) == NULL) {
    
21.         /*重新分配一个skb*/
    
22.         skb = sock_alloc_send_skb(sk,
    
23.             hh_len + fragheaderlen + transhdrlen + 20,
    
24.             (flags & MSG_DONTWAIT), &err);
    
25. 
    
26.         if (skb == NULL)
    
27.             return err;
    
28. 
    
29.         /* reserve space for Hardware header */
    
30.         /*留出链路层头的空间*/
    
31.         skb_reserve(skb, hh_len);
    
32. 
    
33.         /* create space for UDP/IP header */
    
34.         /*留出传输层和IP层头部大小的空间*/
    
35.         skb_put(skb, fragheaderlen + transhdrlen);
    
36. 
    
37.         /* initialize network header pointer */
    
38.         /*初始化IP头*/
    
39.         skb_reset_network_header(skb);
    
40. 
    
41.         /* initialize protocol header pointer */
    
42.         /*初始化传输层头指针*/
    
43.         skb->transport_header = skb->network_header + fragheaderlen;
    
44. 
    
45.         skb->csum = 0;
    
46. 
    
47.         /*将新分配的skb放入sock的发送队列中*/
    
48.         __skb_queue_tail(queue, skb);
    
49.     } else if (skb_is_gso(skb)) {
    
50.         /*当前skb中已设置GSO，直接append*/
    
51.         goto append;
    
52.     }
    
53.     /*
    
54.      * 如果当前skb中未设置GSO标记，说明是因为length > mtu进入到这里的，需要设置GSO标记
    
55.      * 老版本中将这里的几行代码放到了前面的if中(也就是说只设置发送队列中第一个skb的GSO标记)，会导致小包+大包场景下出现分段错误，导致内存混乱
    
56.      * 原因是当sock发送队列不为空时，没有设置SKB_GSO_UDP标记，导致当小包+大包组合时，本来应该走UFO流程的，在这种情况下没有走UFO
    
57.      * 流程，而进入了UDP的分段流程，而在分段时出现了计算错误，导致skb的数据区混乱被覆盖。
    
58.      */
    
59.     skb->ip_summed = CHECKSUM_PARTIAL;
    
60.     /* specify the length of each IP datagram fragment */
    
61.     skb_shinfo(skb)->gso_size = maxfraglen - fragheaderlen;
    
62.     skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
    
63. 
    
64. append:/*向skb中添加数据*/
    
65.     return skb_append_datato_frags(sk, skb, getfrag, from,
    
66.                  (length - transhdrlen));
    
67. }

__ip_append_data->ip_ufo_append_data->skb_append_datato_frags():

点击(此处)折叠或打开

1. /**
   
2.  * skb_append_datato_frags - append the user data to a skb
   
3.  * @sk: sock structure
   
4.  * @skb: skb structure to be appened with user data.
   
5.  * @getfrag: call back function to be used for getting the user data
   
6.  * @from: pointer to user message iov
   
7.  * @length: length of the iov message
   
8.  *
   
9.  * Description: This procedure append the user data in the fragment part
   
10.  * of the skb if any page alloc fails user this procedure returns -ENOMEM
    
11.  */
    
12. /*将用户数据拷贝到skb数据区中，UFO流程调用，本质是将数据拷贝到skb_shared_info->frag[]对应的非线性区中*/
    
13. int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
    
14.             int (*getfrag)(void *from, char *to, int offset,
    
15.                     int len, int odd, struct sk_buff *skb),
    
16.             void *from, int length)
    
17. {
    
18.     /*获取非线性区skb_shared_info->frag[]中frags的数量*/
    
19.     int frg_cnt = skb_shinfo(skb)->nr_frags;
    
20.     int copy;
    
21.     int offset = 0;
    
22.     int ret;
    
23.     /*使用per task的pfrag，用于提升性能*/
    
24.     struct page_frag *pfrag = &current->task_frag;
    
25. 
    
26.     do {
    
27.         /* Return error if we don't have space for new frag */
    
28.         /*skb_shared_info->frag[]的大小是固定的，静态的，17，不能超过这个大小*/
    
29.         if (frg_cnt >= MAX_SKB_FRAGS)
    
30.             return -EMSGSIZE;
    
31.         /*判断是否能在现有的pfrag中append数据，不过不能的话(空间不够)，则新分配page链入pfrag中，用于后面向其中拷贝数据，如果失败，则表示内存不足了。*/
    
32.         if (!sk_page_frag_refill(sk, pfrag))
    
33.             return -ENOMEM;
    
34. 
    
35.         /* copy the user data to page */
    
36.         /*需要拷贝的数据大小，如果pfrag中空间够，就拷贝全部数据；如果不够，则只能先将其填满，下一次循环时重新分配新的page，再往里拷贝*/
    
37.         copy = min_t(int, length, pfrag->size - pfrag->offset);
    
38.         /*从用户态拷贝数据到pfrag的page中，实际调用ip_generic_getfrags*/
    
39.         ret = getfrag(from, page_address(pfrag->page) + pfrag->offset,
    
40.              offset, copy, 0, skb);
    
41.         /*拷贝失败，返回错误*/
    
42.         if (ret < 0)
    
43.             return -EFAULT;
    
44. 
    
45.         /* copy was successful so update the size parameters */
    
46.         /*拷贝成功，将pfrag中的page作为非线性区中的frag链入skb_shared_info->frag[]中，并更新相关计数和大小*/
    
47.         skb_fill_page_desc(skb, frg_cnt, pfrag->page, pfrag->offset,
    
48.                  copy);
    
49.         /*非线性区中的frag数量增加*/
    
50.         frg_cnt++;
    
51.         /*offset增加*/
    
52.         pfrag->offset += copy;
    
53.         /*
    
54.          * 增加page引用计数，因为又有新的地方(skb非线性区)引用了它
    
55.          * Fixme:这里不需要锁保护下?其它地方在put话，是否可能导致page提前释放?
    
56.          */
    
57.         get_page(pfrag->page);
    
58.         /*skb truesize(总的大小，包括线性区和非线性区和skb结构自身的大小)增加*/
    
59.         skb->truesize += copy;
    
60.         /*增加sock发送缓冲区的大小，数据发送出去后会减去相应的大小*/
    
61.         atomic_add(copy, &sk->sk_wmem_alloc);
    
62.         /*skb中的数据长度增加，包括线性区和非线性区*/
    
63.         skb->len += copy;
    
64.         /*skb非线性区数据长度*/
    
65.         skb->data_len += copy;
    
66.         offset += copy;
    
67.         /*length减去已经拷贝的部分，如果小于0，则结束循环，否则继续分配新的frag拷贝*/
    
68.         length -= copy;
    
69. 
    
70.     } while (length > 0);
    
71. 
    
72.     return 0;
    
73. }

__ip_append_data->ip_ufo_append_data->skb_append_datato_frags->sk_page_frag_refill():

点击(此处)折叠或打开

1. /*使用原有frag或分配新页来存放数据*/
   
2. bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
   
3. {
   
4.     int order;
   
5. 
   
6.     if (pfrag->page) {
   
7.         /*如果现有分片(pfrag->page)还没有使用，则使用现有分片*/
   
8.         if (atomic_read(&pfrag->page->_count) == 1) {
   
9.             pfrag->offset = 0;
   
10.             return true;
    
11.         }
    
12.         /*如果现有分片中还有剩余空间，则也使用现有分片*/
    
13.         if (pfrag->offset < pfrag->size)
    
14.             return true;
    
15.         put_page(pfrag->page);
    
16.     }
    
17. 
    
18.     /* We restrict high order allocations to users that can afford to wait */
    
19.     /*
    
20.      * 否则，就需要分配新页作为新分配存放数据了，如果设置__GFP_WAIT，则表示在内存不足时可以等待回收，
    
21.      * 此时可以分配更大的内存8个page(order=3)，否则只分配1个page
    
22.         */
    
23.     order = (sk->sk_allocation & __GFP_WAIT) ? SKB_FRAG_PAGE_ORDER : 0;
    
24. 
    
25.     do {
    
26.         gfp_t gfp = sk->sk_allocation;
    
27. 
    
28.         if (order)
    
29.             gfp |= __GFP_COMP | __GFP_NOWARN;
    
30.         /*分配新页，放入pfrag中，用于后面向其中拷贝数据*/        
    
31.         pfrag->page = alloc_pages(gfp, order);
    
32.         if (likely(pfrag->page)) {
    
33.             pfrag->offset = 0;
    
34.             pfrag->size = PAGE_SIZE << order;
    
35.             return true;
    
36.         }
    
37.     } while (--order >= 0);
    
38. 
    
39.     sk_enter_memory_pressure(sk);
    
40.     sk_stream_moderate_sndbuf(sk);
    
41.     return false;
    
42. }