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

3830阅读　2评论2015-06-04　humjb_1983
分类：LINUX

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;

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

  26.         if (skb == NULL)
  27.             return err;

  29.         /* reserve space for Hardware header */
  30.         /*留出链路层头的空间*/
  31.         skb_reserve(skb, hh_len);

  33.         /* create space for UDP/IP header */
  34.         /*留出传输层和IP层头部大小的空间*/
  35.         skb_put(skb, fragheaderlen + transhdrlen);

  37.         /* initialize network header pointer */
  38.         /*初始化IP头*/
  39.         skb_reset_network_header(skb);

  41.         /* initialize protocol header pointer */
  42.         /*初始化传输层头指针*/
  43.         skb->transport_header = skb->network_header + fragheaderlen;

  45.         skb->csum = 0;

  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;

  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;

  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;

  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;

  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;

  70.     } while (length > 0);

  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;

  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.     }

  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;

  25.     do {
  26.         gfp_t gfp = sk->sk_allocation;

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

  39.     sk_enter_memory_pressure(sk);
  40.     sk_stream_moderate_sndbuf(sk);
  41.     return false;
  42. }


上一篇：bios中断调用
下一篇：Crash工具分析vmcore时对进程Running状态的疑问

文章评论