Chinaunix首页 | 论坛 | 博客

随风去的ChinaUnix博客

首页　| 　博文目录　| 　关于我

随风去

  • 博客访问： 86380
  • 博文数量： 15
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 210
  • 用 户 组： 普通用户
  • 注册时间： 2014-01-05 15:27
文章分类

全部博文（15）

文章存档

2014年（15）

我的朋友
最近访客
推荐博文
相关博文
GRO 接收流程

分类： LINUX

2014-03-21 00:01:28

GRO是一种优化机制，让包尽可能在底层合并，给上层呈现一个大的数据包
驱动调用napi_gro_receive触发GRO流程

首先初始化GRO相应的分量，然后根据__napi_gro_receive的返回值做不同的处理：如果能够合并或者保留，则不需要往上层协议栈送，否则就上报。
  1. gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
  2. {
  3.     switch (ret) {
  4.     case GRO_NORMAL:
  5.         if (netif_receive_skb(skb))
  6.             ret = GRO_DROP;
  7.         break;

  9.     case GRO_DROP:
  10.     case GRO_MERGED_FREE:
  11.         kfree_skb(skb);
  12.         break;

  14.     case GRO_HELD:
  15.     case GRO_MERGED:
  16.         break;
  17.     }

  19.     return ret;
  20. }

  22.  void skb_gro_reset_offset(struct sk_buff *skb)
  23.  {
  24.      NAPI_GRO_CB(skb)->data_offset = 0;
  25.      NAPI_GRO_CB(skb)->frag0 = NULL;
  26.      NAPI_GRO_CB(skb)->frag0_len = 0;
  27.  
  28.      if (skb->mac_header == skb->tail &&  //跟驱动强相关，r8169不会走这个流程
  29.       !PageHighMem(skb_shinfo(skb)->frags[0].page)) {
  30.          NAPI_GRO_CB(skb)->frag0 =
  31.              page_address(skb_shinfo(skb)->frags[0].page) +
  32.              skb_shinfo(skb)->frags[0].page_offset;
  33.          NAPI_GRO_CB(skb)->frag0_len = skb_shinfo(skb)->frags[0].size;
  34.      }
  35.  }
  36.  
  37.  gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
  38.  {
  39.      skb_gro_reset_offset(skb);
  40.  
  41.      return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
  42.  }
GRO的判断分层进行，首先是判断L2层相关的内容，然后是L3、L4，先看L2层的判断：

  1. static inline gro_result_t
  2. __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
  3. {
  4.     struct sk_buff *p;

  6.     for (p = napi->gro_list; p; p = p->next) {
  7.         unsigned long diffs;

  9.         diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev; //网卡设备需要一样
  10.         diffs |= p->vlan_tci ^ skb->vlan_tci;
  11.         diffs |= compare_ether_header(skb_mac_header(p),  //L2头需要一样，14个字节
  12.                      skb_gro_mac_header(skb));
  13.         NAPI_GRO_CB(p)->same_flow = !diffs;
  14.         NAPI_GRO_CB(p)->flush = 0;
  15.     }

  17.     return dev_gro_receive(napi, skb);
  18. }
L2层处理完后调用dev_gro_receive，这个涉及L3层的处理，需要相应的L3层协议提供相应的钩子函数，IP协议满足：

  1. static struct packet_type ip_packet_type __read_mostly = {
  2.     .type = cpu_to_be16(ETH_P_IP),
  3.     .func = ip_rcv,
  4.     .gso_send_check = inet_gso_send_check,
  5.     .gso_segment = inet_gso_segment,
  6.     .gro_receive = inet_gro_receive,
  7.     .gro_complete = inet_gro_complete,
  8. }
后面还会涉及L4的操作，同样需要相应的协议提供钩子函数，TCP满足，而UDP没有注册类似的函数：

  1. static const struct net_protocol tcp_protocol = {
  2.     .handler =    tcp_v4_rcv,
  3.     .err_handler =    tcp_v4_err,
  4.     .gso_send_check = tcp_v4_gso_send_check,
  5.     .gso_segment =    tcp_tso_segment,
  6.     .gro_receive =    tcp4_gro_receive,
  7.     .gro_complete =    tcp4_gro_complete,
  8.     .no_policy =    1,
  9.     .netns_ok =    1,
  10. }
看一下具体的流程：
  1. enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
  2. {
  3.     struct sk_buff **pp = NULL;
  4.     struct packet_type *ptype;
  5.     __be16 type = skb->protocol;
  6.     struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
  7.     int same_flow;
  8.     int mac_len;
  9.     enum gro_result ret;

  11.     if (!(skb->dev->features & NETIF_F_GRO) || netpoll_rx_on(skb))  //GRO可以通过ethtool动态开启或者关闭，关闭的话直接返回NORMAL
  12.         goto normal;

  14.     if (skb_is_gso(skb) || skb_has_frag_list(skb)) 
  15.         goto normal;

  17.     rcu_read_lock();
  18.     list_for_each_entry_rcu(ptype, head, list) {
  19.         if (ptype->type != type || ptype->dev || !ptype->gro_receive)  //只有ip_packet_type满足
  20.             continue;

  22.         skb_set_network_header(skb, skb_gro_offset(skb));
  23.         mac_len = skb->network_header - skb->mac_header;
  24.         skb->mac_len = mac_len;
  25.         NAPI_GRO_CB(skb)->same_flow = 0;
  26.         NAPI_GRO_CB(skb)->flush = 0;
  27.         NAPI_GRO_CB(skb)->free = 0;

  29.         pp = ptype->gro_receive(&napi->gro_list, skb);//inet_gro_receive
  30.         break;
  31.     }
  32.     rcu_read_unlock();

  34.     if (&ptype->list == head)
  35.         goto normal;

  37.     same_flow = NAPI_GRO_CB(skb)->same_flow;
  38.     ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;

  40.     if (pp) {
  41.         struct sk_buff *nskb = *pp;

  43.         *pp = nskb->next;
  44.         nskb->next = NULL;
  45.         napi_gro_complete(nskb);
  46.         napi->gro_count--;
  47.     }

  49.     if (same_flow)
  50.         goto ok;

  52.     if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
  53.         goto normal;

  55.     napi->gro_count++;
  56.     NAPI_GRO_CB(skb)->count = 1;
  57.     skb_shinfo(skb)->gso_size = skb_gro_len(skb);
  58.     skb->next = napi->gro_list;
  59.     napi->gro_list = skb;
  60.     ret = GRO_HELD;

  62. pull:
  63.     if (skb_headlen(skb) < skb_gro_offset(skb)) {  
  64.         int grow = skb_gro_offset(skb) - skb_headlen(skb);

  66.         BUG_ON(skb->end - skb->tail < grow);

  68.         memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);

  70.         skb->tail += grow;
  71.         skb->data_len -= grow;

  73.         skb_shinfo(skb)->frags[0].page_offset += grow;
  74.         skb_shinfo(skb)->frags[0].size -= grow;

  76.         if (unlikely(!skb_shinfo(skb)->frags[0].size)) {
  77.             put_page(skb_shinfo(skb)->frags[0].page);
  78.             memmove(skb_shinfo(skb)->frags,
  79.                 skb_shinfo(skb)->frags + 1,
  80.                 --skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t));
  81.         }
  82.     }

  84. ok:
  85.     return ret;

  87. normal:
  88.     ret = GRO_NORMAL;
  89.     goto pull;
  90. }


  1. static struct sk_buff **inet_gro_receive(struct sk_buff **head,
  2.                      struct sk_buff *skb)
  3. {
  4.     const struct net_protocol *ops;
  5.     struct sk_buff **pp = NULL;
  6.     struct sk_buff *p;
  7.     const struct iphdr *iph;
  8.     unsigned int hlen;
  9.     unsigned int off;
  10.     unsigned int id;
  11.     int flush = 1;
  12.     int proto;

  14.     off = skb_gro_offset(skb);  
  15.     hlen = off + sizeof(*iph);
  16.     iph = skb_gro_header_fast(skb, off);
  17.     if (skb_gro_header_hard(skb, hlen)) {
  18.         iph = skb_gro_header_slow(skb, hlen, off);
  19.         if (unlikely(!iph))
  20.             goto out;
  21.     }  //最后iph指向skb对应的ip头,即skb->data

  23.     proto = iph->protocol & (MAX_INET_PROTOS - 1);

  25.     rcu_read_lock();
  26.     ops = rcu_dereference(inet_protos[proto]);
  27.     if (!ops || !ops->gro_receive)
  28.         goto out_unlock;

  30.     if (*(u8 *)iph != 0x45)
  31.         goto out_unlock;

  33.     if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
  34.         goto out_unlock;

  36.     id = ntohl(*(__be32 *)&iph->id);
  37.     flush = (u16)((ntohl(*(__be32 *)iph) ^ skb_gro_len(skb)) | (id ^ IP_DF)); //ip头的第3-4个字节表示长度，长度不一样或者是分片的话就flush
  38.     id >>= 16;

  40.     for (p = *head; p; p = p->next) {
  41.         struct iphdr *iph2;

  43.         if (!NAPI_GRO_CB(p)->same_flow)
  44.             continue;

  46.         iph2 = ip_hdr(p);

  48.         if ((iph->protocol ^ iph2->protocol) |     //IP层判断same flow需要L4协议一样，tos一样，源和目的地址一样
  49.          (iph->tos ^ iph2->tos) |
  50.          ((__force u32)iph->saddr ^ (__force u32)iph2->saddr) |
  51.          ((__force u32)iph->daddr ^ (__force u32)iph2->daddr)) {
  52.             NAPI_GRO_CB(p)->same_flow = 0;
  53.             continue;
  54.         }

  56.         /* All fields must match except length and checksum. */ //只有flow一样的情况下才会设置flush
  57.         NAPI_GRO_CB(p)->flush |=
  58.             (iph->ttl ^ iph2->ttl) |
  59.             ((u16)(ntohs(iph2->id) + NAPI_GRO_CB(p)->count) ^ id);

  61.         NAPI_GRO_CB(p)->flush |= flush;
  62.     }

  64.     NAPI_GRO_CB(skb)->flush |= flush;
  65.     skb_gro_pull(skb, sizeof(*iph)); //NAPI_GRO_CB(skb)->data_offset += len;
  66.     skb_set_transport_header(skb, skb_gro_offset(skb)); //skb->transport_header = skb->data + offset;

  68.     pp = ops->gro_receive(head, skb);

  70. out_unlock:
  71.     rcu_read_unlock();

  73. out:
  74.     NAPI_GRO_CB(skb)->flush |= flush;

  76.     return pp;
  77. }

  1. struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
  2. {
  3.     struct sk_buff **pp = NULL;
  4.     struct sk_buff *p;
  5.     struct tcphdr *th;
  6.     struct tcphdr *th2;
  7.     unsigned int len;
  8.     unsigned int thlen;
  9.     __be32 flags;
  10.     unsigned int mss = 1;
  11.     unsigned int hlen;
  12.     unsigned int off;
  13.     int flush = 1;
  14.     int i;

  16.     off = skb_gro_offset(skb);
  17.     hlen = off + sizeof(*th);
  18.     th = skb_gro_header_fast(skb, off);
  19.     if (skb_gro_header_hard(skb, hlen)) {
  20.         th = skb_gro_header_slow(skb, hlen, off);
  21.         if (unlikely(!th))
  22.             goto out;  //th指向TCP的头，即skb->data+off
  23.     }

  25.     thlen = th->doff * 4;
  26.     if (thlen < sizeof(*th))
  27.         goto out;

  29.     hlen = off + thlen;
  30.     if (skb_gro_header_hard(skb, hlen)) {
  31.         th = skb_gro_header_slow(skb, hlen, off);
  32.         if (unlikely(!th))
  33.             goto out;
  34.     }

  36.     skb_gro_pull(skb, thlen); // NAPI_GRO_CB(skb)->data_offset += len; 即等于L3+L4的头

  38.     len = skb_gro_len(skb);  //skb->len - NAPI_GRO_CB(skb)->data_offset;即len表示取掉头的负载
  39.     flags = tcp_flag_word(th);

  41.     for (; (p = *head); head = &p->next) {
  42.         if (!NAPI_GRO_CB(p)->same_flow)
  43.             continue;

  45.         th2 = tcp_hdr(p);

  47.         if (*(u32 *)&th->source ^ *(u32 *)&th2->source) {  //tcp判断same flow的标准是源端口号一样
  48.             NAPI_GRO_CB(p)->same_flow = 0;
  49.             continue;
  50.         }

  52.         goto found;
  53.     }

  55.     goto out_check_final;

  57. found:
  58.     flush = NAPI_GRO_CB(p)->flush;
  59.     flush |= (__force int)(flags & TCP_FLAG_CWR);
  60.     flush |= (__force int)((flags ^ tcp_flag_word(th2)) &
  61.          ~(TCP_FLAG_CWR | TCP_FLAG_FIN | TCP_FLAG_PSH));
  62.     flush |= (__force int)(th->ack_seq ^ th2->ack_seq);
  63.     for (i = sizeof(*th); i < thlen; i += 4)  //option区域必须一样，否则flush
  64.         flush |= *(u32 *)((u8 *)th + i) ^
  65.              *(u32 *)((u8 *)th2 + i);

  67.     mss = skb_shinfo(p)->gso_size;

  69.     flush |= (len - 1) >= mss;
  70.     flush |= (ntohl(th2->seq) + skb_gro_len(p)) ^ ntohl(th->seq);

  72.     if (flush || skb_gro_receive(head, skb)) {
  73.         mss = 1;
  74.         goto out_check_final;
  75.     }

  77.     p = *head;
  78.     th2 = tcp_hdr(p);
  79.     tcp_flag_word(th2) |= flags & (TCP_FLAG_FIN | TCP_FLAG_PSH);

  81. out_check_final:
  82.     flush = len < mss;
  83.     flush |= (__force int)(flags & (TCP_FLAG_URG | TCP_FLAG_PSH |
  84.                     TCP_FLAG_RST | TCP_FLAG_SYN |
  85.                     TCP_FLAG_FIN));

  87.     if (p && (!NAPI_GRO_CB(skb)->same_flow || flush))
  88.         pp = head;

  90. out:
  91.     NAPI_GRO_CB(skb)->flush |= flush;

  93.     return pp;
  94. }









阅读(4138) | 评论(0) | 转发(0) |
0

上一篇：网卡驱动的收发包流程

下一篇：udp的收包流程

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6