网络子系统51_ip协议报文分片

转：http://blog.csdn.net/nerdx/article/details/12624407

//ip分片
//  快速路径的条件：
//      1.skb
//          1.skb的数据长度(主缓存区+frags缓存区)小于输出路径的mtu
//          2.skb的数据长度对齐到8字节的边界
//          3.skb没有被分片
//          4.skb没有被共享
//      2.skb->frag_list
//          1.长度小于(mtu-ip报头-选项)
//          2.除最后一个分片外，长度都需要对齐到8字节边界
//          3.head-data之间的空间，可以容纳ip报头
//  注：skb->frag_list的skb，没有填充ip头，skb填充有ip头
//
//  慢速路径条件：
//      只要不满足快速路径其中的一条，使用慢速路径

//  快速路径处理过程：
//      1.第一个分片使用完整的ip选项
//      2.其余分片使用部分ip选项
//      3.除最后一个分片外，设置MF标志
//      4.设置offset
//      5.使用相同的路由信息，向下层传递

//  慢速路径处理过程：
//      1.分配新的skb，长度为mtu，或者剩余数据量，对齐到8字节边界
//      2.预留l2帧头空间
//      3.拷贝l3报头，以及数据到新skb中
//      4.除第一个分片使用完整的ip选项，其余分片使用部分ip选项
//      5.设置offset
//      5.使用相同的路由信息，向下层传递


//  对比快速路径与慢速路径：
//      1.慢速路径的慢主要表现在分配新的缓存区，从旧缓存区中拷贝数据

//  注：ip报头的offset字段，只针对有效载荷(ip头，ip选项不包括在内)

//调用路径ip_output/ip_mc_output->ip_fragment
1.1 int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*))
{
    struct iphdr *iph;
    int raw = 0;
    int ptr;
    struct net_device *dev;
    struct sk_buff *skb2;
    unsigned int mtu, hlen, left, len, ll_rs;
    int offset;
    int not_last_frag;
    struct rtable *rt = (struct rtable*)skb->dst;
    int err = 0;
    //出口设备
    dev = rt->u.dst.dev;
    //ip头
    iph = skb->nh.iph;
    //ip报头设置有DF标志，禁止分片
    ////skb->local_df如果被设置，则在需要分片，但是设置DF标志，不向发送方传送ICMP消息
    if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) {
        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,//需要分片，但是设置DF标志，通知发送方不可达，原因是需要分片，并告知对方mtu
              htonl(dst_pmtu(&rt->u.dst)));
        kfree_skb(skb);
        return -EMSGSIZE;
    }

    //可以快速分片的条件：
    //  skb
    //      1.skb的数据长度(主缓存区+frags缓存区)小于输出路径的mtu
    //      2.skb的数据长度对齐到8字节的边界
    //      3.skb没有被分片
    //      4.skb没有被共享
    //  skb->frag_list
    //      1.长度小于(mtu-ip报头)
    //      2.除最后一个分片外，长度都需要对齐到8字节边界
    //      3.head-data之间的空间，可以容纳ip报头
    //  注：skb->frag_list的skb，没有填充ip头，skb填充有ip头
    hlen = iph->ihl * 4;//ip头长度
    mtu = dst_pmtu(&rt->u.dst) - hlen;   //数据空间的大小

    if (skb_shinfo(skb)->frag_list) {//frag_list存在skb
        struct sk_buff *frag;
        int first_len = skb_pagelen(skb);//skb主缓存区，frags片段中的数据长度，不包括frag_list中的skb

        if (first_len - hlen > mtu ||//超过允许的最大数据量
            ((first_len - hlen) & 7) ||//数据长度没有对齐到8字节
            (iph->frag_off & htons(IP_MF|IP_OFFSET)) ||//此skb是一个分片
            skb_cloned(skb))//克隆一份skb，慢速分片
            goto slow_path;
        //检查frag_list中的skb是否可以快速分片
        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
            //frag_list中的skb没有ip头
            if (frag->len > mtu ||
                ((frag->len & 7) && frag->next) ||//除最后一个分片外，其他分片的长度必须对其到8字节
                skb_headroom(frag) < hlen)//头空间不够容纳ip报头(ip头+选项)
                goto slow_path;

            if (skb_shared(frag))//skb被共享
                goto slow_path;
        }
    //快速路径：
        err = 0;
        offset = 0;
        frag = skb_shinfo(skb)->frag_list;
        skb_shinfo(skb)->frag_list = NULL;
        //更新skb->data_len为skb->frags中数据的大小，原始skb->data_len包括frags，frag_list中所有数据的长度
        skb->data_len = first_len - skb_headlen(skb);
        skb->len = first_len;//更新总长度为主缓存区，frags中数据的大小，原始skb->len包括主缓存区，frags，frag_list中所有数据的长度
        iph->tot_len = htons(first_len);//ip报头的数据包长度
        iph->frag_off |= htons(IP_MF);//表示有更多的分片，第一个分片，offset=0
        ip_send_check(iph);//计算ip校验和

        for (;;) {
            if (frag) {//处理skb->frag_list中的skb，为其准备分片的ip报头
                frag->ip_summed = CHECKSUM_NONE;//表示校验和没有计算
                frag->h.raw = frag->data;
                frag->nh.raw = __skb_push(frag, hlen);//移动skb->data指针，填充ip报头和选项
                memcpy(frag->nh.raw, iph, hlen);
                iph = frag->nh.iph;
                iph->tot_len = htons(frag->len);//总长度
                ip_copy_metadata(frag, skb);//使分片skb与头skb有一样的出口设备，路由信息
                if (offset == 0)//第一个分片具有完整的选项，其他分片将所有非copied的选项，均设置为NOOP
                    ip_options_fragment(frag);
                offset += skb->len - hlen;//计算本分片的偏移量
                iph->frag_off = htons(offset>>3);//偏移量对齐在8字节
                if (frag->next != NULL)
                    iph->frag_off |= htons(IP_MF);//设置还有更多skb
                ip_send_check(iph);//计算ip校验和
            }

            err = output(skb);//向下传递前一个skb，调用ip_finish_output

            if (err || !frag)
                break;

            skb = frag;//保留指向前一个skb的指针
            frag = skb->next;//frag为下一个待处理的skb
            skb->next = NULL;//
        }

        if (err == 0) {
            IP_INC_STATS(IPSTATS_MIB_FRAGOKS);
            return 0;
        }
        //快速路径分片出现错误，释放所有skb
        while (frag) {
            skb = frag->next;
            kfree_skb(frag);
            frag = skb;
        }
        IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
        return err;
    }

    //慢速路径
slow_path:
    left = skb->len - hlen;  //(主缓存区，frags，frag_list)数据的总大小(不包括ip头，选项)
    ptr = raw + hlen;       //新分片的数据在原skb中的起始位置

    offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;//当前分片的偏移量
    not_last_frag = iph->frag_off & htons(IP_MF);//判断是否为最后一个分片

    //开始进行分片
    while(left > 0)  {
        len = left;
        if (len > mtu)//使用mtu(此处的mtu去掉ip报头和选项长度)
            len = mtu;

        if (len < left)  {
            len &= ~7;//长度对齐到8字节边界
        }
        //分配新的skb，长度包括l2帧头，l3报头，l3有效载荷
        if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) {
            NETDEBUG(printk(KERN_INFO "IP: frag: no memory for new fragment!\n"));
            err = -ENOMEM;
            goto fail;
        }
        //使所有分片都使用相同的路由信息，出口设备
        ip_copy_metadata(skb2, skb);
        skb_reserve(skb2, ll_rs);//预留l2帧头
        skb_put(skb2, len + hlen);//data-tail之间空间大小为(ip报头+ip选项+ip有效载荷)
        skb2->nh.raw = skb2->data;//设置l3报头起始地址
        skb2->h.raw = skb2->data + hlen;//l3有效载荷
        //设置新创建的skb所属的sock
        if (skb->sk)
            skb_set_owner_w(skb2, skb->sk);
        //拷贝ip头，选项
        memcpy(skb2->nh.raw, skb->data, hlen);
        //将skb起始地址为ptr的len个字节拷贝到skb2中
        //由skb_copy_bits处理frag，frag_list
        if (skb_copy_bits(skb, ptr, skb2->h.raw, len))
            BUG();
        left -= len;//更新剩余待分片的数据量

        iph = skb2->nh.iph;
        iph->frag_off = htons((offset >> 3));//偏移量

        //1.只有第一个分片需要完整的选项，其他分片将非copied的选项设置为NOOP
        //2.由于第一个分片已经拷贝完整的ip报头以及选项到其分片中
        //3.优化效率，在第一个分片拷贝完整的选项后，更新选项，非第一个分片都使用相同的ip选项
        if (offset == 0)
            ip_options_fragment(skb);

        if (left > 0 || not_last_frag)
            iph->frag_off |= htons(IP_MF);//还有跟多的分片
        ptr += len;//下一个分片的数据在原skb中的起始位置
        offset += len;//偏移量

        IP_INC_STATS(IPSTATS_MIB_FRAGCREATES);

        iph->tot_len = htons(len + hlen);

        ip_send_check(iph);

        err = output(skb2);
        if (err)
            goto fail;
    }
    kfree_skb(skb);
    IP_INC_STATS(IPSTATS_MIB_FRAGOKS);
    return err;

fail:
    kfree_skb(skb);
    IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
    return err;
}

//调用路径 ip_fragment->ip_options_fragment
//  修改ip_option(skb->cb)，将非copied类型的选项，均设置为NOOP类型
2.1 void ip_options_fragment(struct sk_buff * skb)
{
    unsigned char * optptr = skb->nh.raw;
    struct ip_options * opt = &(IPCB(skb)->opt);
    int  l = opt->optlen;
    int  optlen;

    while (l > 0) {
        switch (*optptr) {
        case IPOPT_END:
            return;
        case IPOPT_NOOP:
            l--;
            optptr++;
            continue;
        }
        optlen = optptr[1];
        if (optlen<2 || optlen>l)
          return;
        if (!IPOPT_COPIED(*optptr))//在选项type的第8个比特，指出该选项是否应该复制到ip分片中
            memset(optptr, IPOPT_NOOP, optlen);//对不需要拷贝到除第一个分片外的选项，设置为NOOP
        l -= optlen;
        optptr += optlen;
    }
    opt->ts = 0;//均设置为0，表明不需要time stamp，record route
    opt->rr = 0;
    opt->rr_needaddr = 0;
    opt->ts_needaddr = 0;
    opt->ts_needtime = 0;
    return;
}