Chinaunix首页 | 论坛 | 博客

随风去的ChinaUnix博客

首页　| 　博文目录　| 　关于我

随风去

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

全部博文（15）

文章存档

2014年（15）

我的朋友
最近访客
推荐博文
相关博文
ip_fragment以及ip_defrag流程

分类： LINUX

2014-04-03 23:38:38

当一个ip报文超过MTU的时候，发送端会进行fragment，接收端反过来需要进行defrag

发送端：

在函数ip_finish_output中会判断是否进行fragment，以udp发送10k的数据为例：
  1. static int ip_finish_output(struct sk_buff *skb)
  2. {
  3. #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM)
  4.     /* Policy lookup after SNAT yielded a new policy */
  5.     if (skb_dst(skb)->xfrm != NULL) {
  6.         IPCB(skb)->flags |= IPSKB_REROUTED;
  7.         return dst_output(skb);
  8.     }
  9. #endif
  10.     if (skb->len > ip_skb_dst_mtu(skb) && !skb_is_gso(skb))//skb->len=10008,mtu=1500,gso=0
  11.         return ip_fragment(skb, ip_finish_output2);
  12.     else
  13.         return ip_finish_output2(skb);
  14. }

  1. int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
  2. {
  3.     struct iphdr *iph;
  4.     int ptr;
  5.     struct net_device *dev;
  6.     struct sk_buff *skb2;
  7.     unsigned int mtu, hlen, left, len, ll_rs;
  8.     int offset;
  9.     __be16 not_last_frag;
  10.     struct rtable *rt = skb_rtable(skb);
  11.     int err = 0;

  13.     dev = rt->dst.dev;

  15.     /*
  16.      * Point into the IP datagram header.
  17.      */

  19.     iph = ip_hdr(skb);

  21.     if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) {  //如果置了不可分片的标志位，则发送icmp信息
  22.         IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
  23.         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
  24.               htonl(ip_skb_dst_mtu(skb)));
  25.         kfree_skb(skb);
  26.         return -EMSGSIZE;
  27.     }

  29.     /*
  30.      * Setup starting values.
  31.      */

  33.     hlen = iph->ihl * 4;
  34.     mtu = dst_mtu(&rt->dst) - hlen; /* Size of data space */  //1480
  35. #ifdef CONFIG_BRIDGE_NETFILTER
  36.     if (skb->nf_bridge)
  37.         mtu -= nf_bridge_mtu_reduction(skb);
  38. #endif
  39.     IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE;

  41.     /* When frag_list is given, use it. First, check its validity:
  42.      * some transformers could create wrong frag_list or break existing
  43.      * one, it is not prohibited. In this case fall back to copying.
  44.      *
  45.      * LATER: this step can be merged to real generation of fragments,
  46.      * we can switch to copy when see the first bad fragment.
  47.      */
  48.     if (skb_has_frag_list(skb)) {  //如果有frag list，说明上层有可能已经做了一些事情，可以走fast流程
  49.         struct sk_buff *frag, *frag2;
  50.         int first_len = skb_pagelen(skb);  //skb的线性区和shinfo中的frags的总大小，不包括fraglist，1500

  52.         if (first_len - hlen > mtu ||
  53.             ((first_len - hlen) & 7) ||
  54.             ip_is_fragment(iph) ||
  55.             skb_cloned(skb))
  56.             goto slow_path;

  58.         skb_walk_frags(skb, frag) {
  59.             /* Correct geometry. */
  60.             if (frag->len > mtu ||
  61.                 ((frag->len & 7) && frag->next) ||
  62.                 skb_headroom(frag) < hlen)
  63.                 goto slow_path_clean;

  65.             /* Partially cloned skb? */
  66.             if (skb_shared(frag))
  67.                 goto slow_path_clean;

  69.             BUG_ON(frag->sk);
  70.             if (skb->sk) {
  71.                 frag->sk = skb->sk;  //后续每个frag都将独立，因此赋值相应的分量
  72.                 frag->destructor = sock_wfree;
  73.             }
  74.             skb->truesize -= frag->truesize;   //如果fraglist中的skb满足条件的话，从总的skb大小中减掉
  75.         }

  77.         /* Everything is OK. */

  79.         err = 0;
  80.         offset = 0;
  81.         frag = skb_shinfo(skb)->frag_list;
  82.         skb_frag_list_init(skb);
  83.         skb->data_len = first_len - skb_headlen(skb);    //当前skb不再包含fraglist的大小
  84.         skb->len = first_len;
  85.         iph->tot_len = htons(first_len);
  86.         iph->frag_off = htons(IP_MF);  //设置第一个分片的标志，没有offset
  87.         ip_send_check(iph);
  88.         for (;;) {
  89.             /* Prepare header of the next frame,
  90.              * before previous one went down. */
  91.             if (frag) {
  92.                 frag->ip_summed = CHECKSUM_NONE;
  93.                 skb_reset_transport_header(frag);
  94.                 __skb_push(frag, hlen);
  95.                 skb_reset_network_header(frag);
  96.                 memcpy(skb_network_header(frag), iph, hlen); //把上一个skb的ip头拷贝到这一个skb
  97.                 iph = ip_hdr(frag);
  98.                 iph->tot_len = htons(frag->len);
  99.                 ip_copy_metadata(frag, skb);
  100.                 if (offset == 0)
  101.                     ip_options_fragment(frag);
  102.                 offset += skb->len - hlen;  //offset为L3层看到的负载，不包含L3的头
  103.                 iph->frag_off = htons(offset>>3);
  104.                 if (frag->next != NULL)
  105.                     iph->frag_off |= htons(IP_MF); //除非是最后一个分片，否则都置为MF标志
  106.                 /* Ready, complete checksum */
  107.                 ip_send_check(iph);
  108.             }

  110.             err = output(skb); //对每一个skb进行发送 ：ip_finish_output2

  112.             if (!err)
  113.                 IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
  114.             if (err || !frag)
  115.                 break;

  117.             skb = frag;
  118.             frag = skb->next;
  119.             skb->next = NULL;
  120.         }

  122.         if (err == 0) {
  123.             IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
  124.             return 0; //如果一切顺利的话就到这
  125.         }

  127.         while (frag) {
  128.             skb = frag->next;
  129.             kfree_skb(frag);
  130.             frag = skb;
  131.         }
  132.         IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
  133.         return err;

  135. slow_path_clean:
  136.         skb_walk_frags(skb, frag2) {
  137.             if (frag2 == frag)
  138.                 break;
  139.             frag2->sk = NULL;
  140.             frag2->destructor = NULL;
  141.             skb->truesize += frag2->truesize;
  142.         }
  143.     }

  145. slow_path:
  146.     left = skb->len - hlen; /* Space per frame */
  147.     ptr = hlen; /* Where to start from */

  149.     /* for bridged IP traffic encapsulated inside f.e. a vlan header,
  150.      * we need to make room for the encapsulating header
  151.      */
  152.     ll_rs = LL_RESERVED_SPACE_EXTRA(rt->dst.dev, nf_bridge_pad(skb));

  154.     /*
  155.      * Fragment the datagram.
  156.      */

  158.     offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
  159.     not_last_frag = iph->frag_off & htons(IP_MF);

  161.     /*
  162.      * Keep copying data until we run out.
  163.      */

  165.     while (left > 0) {
  166.         len = left;
  167.         /* IF: it doesn't fit, use 'mtu' - the data space left */
  168.         if (len > mtu)
  169.             len = mtu;
  170.         /* IF: we are not sending up to and including the packet end
  171.            then align the next start on an eight byte boundary */
  172.         if (len < left) {
  173.             len &= ~7;
  174.         }
  175.         /*
  176.          * Allocate buffer.
  177.          */

  179.         if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) { //分配一个新的skb，数据都放在线性区
  180.             NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!\n");
  181.             err = -ENOMEM;
  182.             goto fail;
  183.         }

  185.         /*
  186.          * Set up data on packet
  187.          */

  189.         ip_copy_metadata(skb2, skb);
  190.         skb_reserve(skb2, ll_rs); 
  191.         skb_put(skb2, len + hlen);
  192.         skb_reset_network_header(skb2);  //data和network_header指向L3的头
  193.         skb2->transport_header = skb2->network_header + hlen;

  195.         /*
  196.          * Charge the memory for the fragment to any owner
  197.          * it might possess
  198.          */

  200.         if (skb->sk)
  201.             skb_set_owner_w(skb2, skb->sk);

  203.         /*
  204.          * Copy the packet header into the new buffer.
  205.          */

  207.         skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen); //拷贝L3头

  209.         /*
  210.          * Copy a block of the IP datagram.
  211.          */
  212.         if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len)) //拷贝负载数据，可能从skb的线性区、frag或者list中获取
  213.             BUG();                                                    //由ptr即offset决定
  214.         left -= len;

  216.         /*
  217.         /*
  218.          * Fill in the new header fields.
  219.          */
  220.         iph = ip_hdr(skb2);
  221.         iph->frag_off = htons((offset >> 3));

  223.         /* ANK: dirty, but effective trick. Upgrade options only if
  224.          * the segment to be fragmented was THE FIRST (otherwise,
  225.          * options are already fixed) and make it ONCE
  226.          * on the initial skb, so that all the following fragments
  227.          * will inherit fixed options.
  228.          */
  229.         if (offset == 0)
  230.             ip_options_fragment(skb);

  232.         /*
  233.          * Added AC : If we are fragmenting a fragment that's not the
  234.          * last fragment then keep MF on each bit
  235.          */
  236.         if (left > 0 || not_last_frag)
  237.             iph->frag_off |= htons(IP_MF);
  238.         ptr += len;
  239.         offset += len;

  241.         /*
  242.          * Put this fragment into the sending queue.
  243.          */
  244.         iph->tot_len = htons(len + hlen);

  246.         ip_send_check(iph);

  248.         err = output(skb2); //fast path中，入参skb是第一个发送的分片，slow path中入参skb是不会动的，它只负责提供数据
  249.         if (err)
  250.             goto fail;

  252.         IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
  253.     }
  254.     kfree_skb(skb);
  255.     IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
  256.     return err;

  258. fail:
  259.     kfree_skb(skb);
  260.     IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
  261.     return err;
  262. }

简单总结：ip_fragment根据上层传入的情况做不同的处理，如果上层已经基本分片过的，则拷贝下L3头，对每一个分片调发包函数，否则创建skb结构，拷贝数据，然后对每一个分片调发包函数

接收端：

发送10K的数据的时候，接收端tcpdump输出如下：
  1. 22:39:47.521105 IP 100.100.100.11.51389 > 100.100.100.2.8888: UDP, length 10000
  2. 22:39:47.521189 IP 100.100.100.11 > 100.100.100.2: ip-proto-17
  3. 22:39:47.521329 IP 100.100.100.11 > 100.100.100.2: ip-proto-17
  4. 22:39:47.521450 IP 100.100.100.11 > 100.100.100.2: ip-proto-17
  5. 22:39:47.521567 IP 100.100.100.11 > 100.100.100.2: ip-proto-17
  6. 22:39:47.521697 IP 100.100.100.11 > 100.100.100.2: ip-proto-17
  7. 22:39:47.521791 IP 100.100.100.11 > 100.100.100.2: ip-proto-17
第一个报文和第二个报文的详细信息如下：
  1. 22:45:34.400082 IP 100.100.100.11.37617 > 100.100.100.2.8888: UDP, length 10000
  2.     0x0000: 60eb 6945 291b 3c97 0ecd a46d 0800 4500 `.iE).<....m..E.
  3.     0x0010: 05dc 8e6c 2000 4011 35cf 6464 640b 6464 ...l..@.5.ddd.dd  
  4.     0x0020: 6402 92f1 22b8 2718 cfa2 6767 6767 6767 d...".'...gggggg  //0x2718=10008=负载+一个UDP头
  1. 22:45:34.400161 IP 100.100.100.11 > 100.100.100.2: ip-proto-17
  2.     0x0000: 60eb 6945 291b 3c97 0ecd a46d 0800 4500 `.iE).<....m..E.
  3.     0x0010: 05dc 8e6c 20b9 4011 3516 6464 640b 6464 ...l..@.5.ddd.dd
  4.     0x0020: 6402 6767 6767 6767 6767 6767 6767 6767 d.gggggggggggggg  //不包含UDP头
对于ip分片而言，IP的头结构中有两个字节相关，即加红的字段，16bit中高三位为标记为，低13位为偏移/8
因此20b9表示标记位为001（表示MF），偏移为0xb9×8=1480（MTU-IP头的长度），即第一个分片包含了1480个字节（包括8字节UDP头）。
看代码是如何分辨一个skb是否是一个分片：
  1. static inline bool ip_is_fragment(const struct iphdr *iph)
  2. {
  3.     return (iph->frag_off & htons(IP_MF | IP_OFFSET)) != 0;
  4. }
在收包函数ip_local_deliver中会进行判断，如果是的话，会调用ip_defrag进行分片重组：
  1. int ip_defrag(struct sk_buff *skb, u32 user)
  2. {
  3.     struct ipq *qp;
  4.     struct net *net;

  6.     net = skb->dev ? dev_net(skb->dev) : dev_net(skb_dst(skb)->dev);
  7.     IP_INC_STATS_BH(net, IPSTATS_MIB_REASMREQDS);

  9.     /* Start by cleaning up the memory. */
  10.     if (atomic_read(&net->ipv4.frags.mem) > net->ipv4.frags.high_thresh)
  11.         ip_evictor(net);

  13.     /* Lookup (or create) queue header */
  14.     if ((qp = ip_find(net, ip_hdr(skb), user)) != NULL) {  //找到和该skb匹配的项，没有的话说明是第一个，新建一个
  15.         int ret;

  17.         spin_lock(&qp->q.lock);

  19.         ret = ip_frag_queue(qp, skb);

  21.         spin_unlock(&qp->q.lock);
  22.         ipq_put(qp);
  23.         return ret;
  24.     }

  26.     IP_INC_STATS_BH(net, IPSTATS_MIB_REASMFAILS);
  27.     kfree_skb(skb);
  28.     return -ENOMEM;
  29. }
涉及的数据结构如下：

找到或者新建完ipq的数据结构后，把当前的skb放到对应的数据结构：

  1. static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb)
  2. {
  3.     struct sk_buff *prev, *next;
  4.     struct net_device *dev;
  5.     int flags, offset;
  6.     int ihl, end;
  7.     int err = -ENOENT;
  8.     u8 ecn;

  10.     if (qp->q.last_in & INET_FRAG_COMPLETE)  //当ipq需要释放的时候才会设置这个标志位
  11.         goto err;

  13.     if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) &&
  14.         unlikely(ip_frag_too_far(qp)) &&
  15.         unlikely(err = ip_frag_reinit(qp))) {
  16.         ipq_kill(qp);
  17.         goto err;
  18.     }

  20.     ecn = ip4_frag_ecn(ip_hdr(skb)->tos);
  21.     offset = ntohs(ip_hdr(skb)->frag_off);
  22.     flags = offset & ~IP_OFFSET;
  23.     offset &= IP_OFFSET;
  24.     offset <<= 3; /* offset is in 8-byte chunks */
  25.     ihl = ip_hdrlen(skb);

  27.     /* Determine the position of this fragment. */
  28.     end = offset + skb->len - ihl;
  29.     err = -EINVAL;

  31.     /* Is this the final fragment? */
  32.     if ((flags & IP_MF) == 0) {
  33.         /* If we already have some bits beyond end
  34.          * or have different end, the segment is corrrupted.
  35.          */
  36.         if (end < qp->q.len ||
  37.             ((qp->q.last_in & INET_FRAG_LAST_IN) && end != qp->q.len))
  38.             goto err;
  39.         qp->q.last_in |= INET_FRAG_LAST_IN;  //设置最后一个分片的标志位
  40.         qp->q.len = end;  //这个包总的长度
  41.     } else {
  42.         if (end&7) {  //8字节对齐
  43.             end &= ~7;
  44.             if (skb->ip_summed != CHECKSUM_UNNECESSARY)
  45.                 skb->ip_summed = CHECKSUM_NONE;
  46.         }
  47.         if (end > qp->q.len) {
  48.             /* Some bits beyond end -> corruption. */
  49.             if (qp->q.last_in & INET_FRAG_LAST_IN)
  50.                 goto err;
  51.             qp->q.len = end;
  52.         }
  53.     }
  54.     if (end == offset)
  55.         goto err;
  56.     err = -ENOMEM;
  57.     if (pskb_pull(skb, ihl) == NULL)  //去掉skb的头
  58.         goto err;

  60.     err = pskb_trim_rcsum(skb, end - offset);
  61.     if (err)
  62.         goto err;

  64.     /* Find out which fragments are in front and at the back of us
  65.      * in the chain of fragments so far. We must know where to put
  66.      * this fragment, right?
  67.      */
  68.     prev = qp->q.fragments_tail;
  69.     if (!prev || FRAG_CB(prev)->offset < offset) { //第一个情况prev为空，则表示当前skb为第一个;后面的情况的话当前skb放到最后
  70.         next = NULL;
  71.         goto found;
  72.     }
  73.     prev = NULL;
  74.     for (next = qp->q.fragments; next != NULL; next = next->next) { //fragments以offset从小到大排列
  75.         if (FRAG_CB(next)->offset >= offset)
  76.             break; /* */
  77.         prev = next;
  78.     }

  80. found:
  81.     /* We found where to put this one. Check for overlap with
  82.      * preceding fragment, and, if needed, align things so that
  83.      * any overlaps are eliminated.
  84.      */
  85.     if (prev) {
  86.         int i = (FRAG_CB(prev)->offset + prev->len) - offset; //处理当前skb和prev的重叠部分，以前面的为准，改变skb

  88.         if (i > 0) {
  89.             offset += i;
  90.             err = -EINVAL;
  91.             if (end <= offset)
  92.                 goto err;
  93.             err = -ENOMEM;
  94.             if (!pskb_pull(skb, i))
  95.                 goto err;
  96.             if (skb->ip_summed != CHECKSUM_UNNECESSARY)
  97.                 skb->ip_summed = CHECKSUM_NONE;
  98.         }
  99.     }

  101.     err = -ENOMEM;

  103.     while (next && FRAG_CB(next)->offset < end) { //处理当前skb和next的重叠部分，以当前skb为准，改变next
  104.         int i = end - FRAG_CB(next)->offset; /* overlap is 'i' bytes */

  106.         if (i < next->len) {
  107.             /* Eat head of the next overlapped fragment
  108.              * and leave the loop. The next ones cannot overlap.
  109.              */
  110.             if (!pskb_pull(next, i))
  111.                 goto err;
  112.             FRAG_CB(next)->offset += i;
  113.             qp->q.meat -= i;
  114.             if (next->ip_summed != CHECKSUM_UNNECESSARY)
  115.                 next->ip_summed = CHECKSUM_NONE;
  116.             break;
  117.         } else {
  118.             struct sk_buff *free_it = next;

  120.             /* Old fragment is completely overridden with
  121.              * new one drop it.
  122.              */
  123.             next = next->next;

  125.             if (prev)
  126.                 prev->next = next;
  127.             else
  128.                 qp->q.fragments = next;

  130.             qp->q.meat -= free_it->len;
  131.             frag_kfree_skb(qp->q.net, free_it);
  132.         }
  133.     }

  135.     FRAG_CB(skb)->offset = offset;

  137.     /* Insert this fragment in the chain of fragments. */
  138.     skb->next = next;
  139.     if (!next)
  140.         qp->q.fragments_tail = skb;  //插入到链表
  141.     if (prev)
  142.         prev->next = skb;
  143.     else
  144.         qp->q.fragments = skb;

  146.     dev = skb->dev;
  147.     if (dev) {
  148.         qp->iif = dev->ifindex;
  149.         skb->dev = NULL;
  150.     }
  151.     qp->q.stamp = skb->tstamp;
  152.     qp->q.meat += skb->len;
  153.     qp->ecn |= ecn;
  154.     atomic_add(skb->truesize, &qp->q.net->mem);
  155.     if (offset == 0)
  156.         qp->q.last_in |= INET_FRAG_FIRST_IN; //如果offset为0,表示第一个分片，置标志位

  158.     if (qp->q.last_in == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) && //第一个分片和最后一个分片到了
  159.         qp->q.meat == qp->q.len) //如果最后一个分片到了，则len已经得到包的总大小了，meat是每个skb加入的时候增加的，两者相等说明包齐了
  160.         return ip_frag_reasm(qp, prev, dev); //重组

  162.     write_lock(&ip4_frags.lock);
  163.     list_move_tail(&qp->q.lru_list, &qp->q.net->lru_list); //更新当前ipq的位置，降低被释放的优先级
  164.     write_unlock(&ip4_frags.lock);
  165.     return -EINPROGRESS;  //返回非零的话，不会再往下处理了
  166. err:
  167.     kfree_skb(skb);
  168.     return err;
  169. }
需要关注ip_frag_reasm函数的参数，由于ip_frag_queue函数的传入参数为skb，而且没有返回参数，而后续的操作必须有sk_buff的数据结构，因此不管最后调用ip_frag_queue时的skb是哪一个分片，返回的时候必须代表整个数据包。而这个过程是函数在ip_frag_reasm完成的：

  1. static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
  2.              struct net_device *dev)
  3. {
  4.     struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
  5.     struct iphdr *iph;
  6.     struct sk_buff *fp, *head = qp->q.fragments;
  7.     int len;
  8.     int ihlen;
  9.     int err;
  10.     u8 ecn;

  12.     ipq_kill(qp);

  14.     ecn = ip4_frag_ecn_table[qp->ecn];
  15.     if (unlikely(ecn == 0xff)) {
  16.         err = -EINVAL;
  17.         goto out_fail;
  18.     }
  19.     /* Make the one we just received the head. */  
  20.     if (prev) {
  21.         head = prev->next;  //后续流程保证head即最初传入的skb包含的是一个分片的内容
  22.         fp = skb_clone(head, GFP_ATOMIC);  
  23.         if (!fp)
  24.             goto out_nomem;

  26.         fp->next = head->next;
  27.         if (!fp->next)
  28.             qp->q.fragments_tail = fp;
  29.         prev->next = fp;

  31.         skb_morph(head, qp->q.fragments);
  32.         head->next = qp->q.fragments->next;

  34.         kfree_skb(qp->q.fragments);
  35.         qp->q.fragments = head;
  36.     }

  38.     WARN_ON(head == NULL);
  39.     WARN_ON(FRAG_CB(head)->offset != 0);

  41.     /* Allocate a new buffer for the datagram. */
  42.     ihlen = ip_hdrlen(head);
  43.     len = ihlen + qp->q.len;
  44.     err = -E2BIG;
  45.     if (len > 65535)
  46.         goto out_oversize;

  48.     /* Head of list must not be cloned. */
  49.     if (skb_cloned(head) && pskb_expand_head(head, 0, 0, GFP_ATOMIC))
  50.         goto out_nomem;

  52.     /* If the first fragment is fragmented itself, we split
  53.      * it to two chunks: the first with data and paged part
  54.      * and the second, holding only fragments. */
  55.     if (skb_has_frag_list(head)) {
  56.         struct sk_buff *clone;
  57.         int i, plen = 0;

  59.         if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL)
  60.             goto out_nomem;
  61.         clone->next = head->next;
  62.         head->next = clone;
  63.         skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
  64.         skb_frag_list_init(head);
  65.         for (i=0; i<skb_shinfo(head)->nr_frags; i++)
  66.             plen += skb_shinfo(head)->frags[i].size;
  67.         clone->len = clone->data_len = head->data_len - plen;
  68.         head->data_len -= clone->len;
  69.         head->len -= clone->len;
  70.         clone->csum = 0;
  71.         clone->ip_summed = head->ip_summed;
  72.         atomic_add(clone->truesize, &qp->q.net->mem);
  73.     }

  75.     skb_shinfo(head)->frag_list = head->next;//相当与把fragments对应的链表搬到当前skb上了
  76.     skb_push(head, head->data - skb_network_header(head));  //第一个分片对应的skb需要包含IP头

  78.     for (fp=head->next; fp; fp = fp->next) {
  79.         head->data_len += fp->len;   //更新当前skb的分量，因为它不再只代表自己一个分片，而是整个包
  80.         head->len += fp->len;
  81.         if (head->ip_summed != fp->ip_summed)
  82.             head->ip_summed = CHECKSUM_NONE;
  83.         else if (head->ip_summed == CHECKSUM_COMPLETE)
  84.             head->csum = csum_add(head->csum, fp->csum);
  85.         head->truesize += fp->truesize;
  86.     }
  87.     atomic_sub(head->truesize, &qp->q.net->mem);

  89.     head->next = NULL;
  90.     head->dev = dev;
  91.     head->tstamp = qp->q.stamp;

  93.     iph = ip_hdr(head);
  94.     iph->frag_off = 0;  //重组完，改变相应的标志
  95.     iph->tot_len = htons(len);
  96.     iph->tos |= ecn;
  97.     IP_INC_STATS_BH(net, IPSTATS_MIB_REASMOKS);
  98.     qp->q.fragments = NULL;
  99.     qp->q.fragments_tail = NULL;
  100.     return 0;

  102. out_nomem:
  103.     LIMIT_NETDEBUG(KERN_ERR "IP: queue_glue: no memory for gluing "
  104.                   "queue %p\n", qp);
  105.     err = -ENOMEM;
  106.     goto out_fail;
  107. out_oversize:
  108.     if (net_ratelimit())
  109.         printk(KERN_INFO "Oversized IP packet from %pI4.\n",
  110.             &qp->saddr);
  111. out_fail:
  112.     IP_INC_STATS_BH(net, IPSTATS_MIB_REASMFAILS);
  113.     return err;
  114. }
简单的来说，重组过程就是先把所有的分片skb加到qp->q.fragments对应的链表中，当分片都到的时候，再把该链表中的所有skb都移到一个统一的skb上的frag_list上，更新这个统一skb的分量，然后交由函数ip_local_deliver_finish继续处理。







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

上一篇：udp的收包流程

下一篇：网络收发流程中struct iovec的使用

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

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

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

16024965号-6