Linux网络协议栈--ip_append_data函数分析

http://blog.csdn.net/minghe_uestc/article/details/7836920

开场白：

要分析这个函数原因有两个：

一个是前几天要写《Linux网络协议栈--UDP》结果卡在这个函数这了。

另外一个就是这个函数又是UDP报文必经之路，而且对其理解对于套接口中发送队列的理解非常有帮助，所以认真去学习了下。

文章定位：

（1）尽可能撇开一些不需要的细节，重点介绍流程

（2）说明发送队列是如何组织起来的

（3）书本肯定都比我说的好，要真的看明白，还是需要看书，这里能做的就是将其结构重新组织，并且将不同的书的内容重新揉合，帮忙看的更快一些

参考书籍：

（1）《Understand Linux Kernel Internel》

（2）《Linux内核源码剖析-TCP/IP实现》

（3）linux内核源码--我使用的版本是3.2.4

注：虽然这写书都有电子版的，不过我还是希望大家能够支持正版。作者写这些书不容易。

一、cork

一开始先来说一个单词，以下内容为个人理解，仅供参考，如果有错恳请指正。

UDP相关的数据经常会存储在一个名为cork的变量中，第一次看的时候非常的让人感觉疑惑。

cork在英文中是软木塞的意思，那软木塞又和UDP有什么关系？

可以将UDP底部到IP的部分看成一个漏斗，如果从UDP下来的数据都是小数据（比如都只有几十个字节），那无疑会加重下层处理数据的负担，而且会 让网络充斥各种小报文。所以cork给人的感觉就是将这个漏斗底部给堵住，等在一定时候再拔掉这个塞子，这样就可以把各种小数据汇集成一个大数据了。

不过需要注意的是，cork的标志是需要应用层来设置，所以这个塞塞子和拔塞子的动作都掌握在应用层手中，所以可以掐头去尾的看了。

二、ip_append_data在做什么

就是将上层下来的数据进行整形，如果是大数据包进行切割，变成多个小于或等于MTU的SKB。如果是小数据包，并且开启了聚合，就会将若干个数据包整合。

说的简单，但是在实现的时候做起来就复杂了，因为函数中考虑到了

（1）如何填充队列中上一个skb中未填充的部分？

（2）如何将队列中上一个skb中不能进行对齐的数据部分移动到新的skb中

（3）如何什么时候分配skb，而且skb的大小是多少

（4）如何在分配skb的时候为下层预留足够的空间

（5）需要将数据重用户空间拷贝到内核空间，那怎么拷贝效率才高

（6）如何才能减少内存的拷贝消耗

（7）……

因为考虑的事情太多，所以做起来就比较繁琐了。

三、参数

先介绍下参数，虽然参数多，但是关键参数却很少

注：该参数是3.2.4中的，可能与其他版本的不一样，不过不影响整体介绍

struct *sk : 

struct flowi4 *fl4 : 

struct sk_buff_head *queue : 

struct inet_cork *cork : 输出数据块的地址。

int getfrag() : 将数据复制到SKB中，其为一个函数指针，会有不同的选择，在udp_sendmsg最开始的时候会进行初始化。其可能的函数如图1-1所示（见《Linux内核源码剖析-TCP/IP实现》表11-12）

图 1-1

void *from : 

int length : 数据长度

int transhdrlen : 传输层首部长度，同时也是标志是否为第一个fragment的标志

struct ipcm_cookie *ipc :

struct rtable **rpt : 

unsigned int flags : 处理标志，如图1-2所示（见《Linux内核源码剖析-TCP/IP实现》表23-1），在ip_append_data中只用到其中两个MSG_PROBE和MSG_MORE。其余暂时不关心

图1-2

三、几个标志

ip_append_data代码非常大，主要是它存在多个分支，不过令人高兴的是，它的分支的标志都比较清晰，所以看到如下标志就需要多注意了： 

1、copy

队列中最后一个skb剩余的空间，存在3种情况，如图3-1所示（《Understand Linux Kernel Internal》章节21.1.4.9）：

图3-1

注 ： 不过在函数中是分为两种情况分别是：copy <= 0 和 copy > 0

2、flag & MSG_MORE

MSG_MORE在图1-2中就介绍了，在ip_append_data中这个标志也是分支的判断依据之一

 

3、rt->dst.dev->features&NETIF_F_SG

这个标识是判断是否开启 聚合分散 I/O的标识，也是分支的判断依据之一

下文会慢慢介绍这几个分支是怎么回事。

四、流程及代码分析

内核3.2.4中ip_append_data函数流程和以前的基本一样，区别就是将最主要的循环部分包裹到了__ip_append_data函数中。

1、ip_append_data流程图

图4-1是ip_append_data的主要流程图（见《Linux内核源码剖析-TCP/IP实现》图11-8），不过个人感觉这个图画的也不是太好，主要是下半部分画的不是太清晰，后面会用其他的流程图替换该图下半部分说明。

图4-1

（1）在3.2.4内核中将图中蓝色框中的部分包裹到了函数__ip_append_data中，不过这个部分本来就是整个函数的重点，是最主要的循环。

（2）绿色框内的部分包裹在ip_ufo_append_data中，这个函数相对比较简单，最后会给介绍。

（3）现在说明函数上半部分内容：

int ip_append_data(struct sock *sk, struct flowi4 *fl4,
           int getfrag(void *from, char *to, int offset, int len,
                   int odd, struct sk_buff *skb),
           void *from, int length, int transhdrlen,
           struct ipcm_cookie *ipc, struct rtable **rtp,
           unsigned int flags)
{
    struct inet_sock *inet = inet_sk(sk);
    int err;

    if (flags&MSG_PROBE) /*见《Linux内核源码剖析TCP/IP实现》表23-1 */
        return 0;

    if (skb_queue_empty(&sk->sk_write_queue)) {
        err = ip_setup_cork(sk, &inet->cork.base, ipc, rtp);
        if (err)
            return err;
    } else { /*队列不为空，则使用上次的路由，IP选项，以及分片长度 */
        transhdrlen = 0;
    }

这里就只需要注意一个参数：MSG_PROBE，内容见图1-2的说明。
（4）然后就进入下半部的内容：

    return __ip_append_data(sk, fl4, &sk->sk_write_queue, &inet->cork.base, getfrag,
                from, length, transhdrlen, flags);
}

2、__ip_append_data流程图

图4-2本来是ip_append_data的主要循环，在3.2.4中是__ip_append_data的流程图，不伤大雅。（见《Understand Linux Kernel Internel》图21-11）

为了便于后面说明，给图中每个分支进行了编号，图中标识的（图21-X是该分支最后得到的数据结构图，这些图在《Understand Linux Kernel Internel》中可以找到）

图 4-2

2.1、分支（1）

该分支的代码部分如下：

static int __ip_append_data(struct sock *sk,
                struct flowi4 *fl4,
                struct sk_buff_head *queue,
                struct inet_cork *cork,
                int getfrag(void *from, char *to, int offset,
                    int len, int odd, struct sk_buff *skb),
                void *from, int length, int transhdrlen,
                unsigned int flags)
{
    struct inet_sock *inet = inet_sk(sk);
    struct sk_buff *skb;

    struct ip_options *opt = cork->opt;
    int hh_len;
    int exthdrlen;
    int mtu;
    int copy;
    int err;
    int offset = 0;
    unsigned int maxfraglen, fragheaderlen;
    int csummode = CHECKSUM_NONE;
    struct rtable *rt = (struct rtable *)cork->dst;

    skb = skb_peek_tail(queue); /*这里skb有两种情况，如果队列为空，
                                  则skb = NULL，否则为尾部skb的指针 */


    /*这部分内容最好参考《understand linux network internal》图21-10*/
    exthdrlen = !skb ? rt->dst.header_len : 0;
    mtu = cork->fragsize;

    hh_len = LL_RESERVED_SPACE(rt->dst.dev); /*链路层首部长度 */

    fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0); /* IP首部（包括IP选项）长度 */
    maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen; /* 最大IP首部长度,注意对齐 */

    if (cork->length + length > 0xFFFF - fragheaderlen) { /*一个IP数据包最大大小不能超过64K */
        ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
                   mtu-exthdrlen);
        return -EMSGSIZE;
    }

    /*
     * transhdrlen > 0 means that this is the first fragment and we wish
     * it won't be fragmented in the future.
     */
    if (transhdrlen &&
        length + fragheaderlen <= mtu &&
        rt->dst.dev->features & NETIF_F_V4_CSUM &&
        !exthdrlen)
        csummode = CHECKSUM_PARTIAL; /*由硬件执行校验和计算 */

    cork->length += length; /*更新数据长度 */

    /* 对于UDP报文，新加的数据长度大于MTU，并且需要进行分片，则需要
     * 进行分片处理
     * 这里相当于《understand linux network internel》图21-11最左边的那条支线
     * 注意：这里需要加入判断skb是否为NULL*/
    if (((length > mtu) || (skb && skb_is_gso(skb))) &&
        (sk->sk_protocol == IPPROTO_UDP) &&
        (rt->dst.dev->features & NETIF_F_UFO) && !rt->dst.header_len) {
        /* ufo = UDP fragmentation offload*/
        err = ip_ufo_append_data(sk, queue, getfrag, from, length,
                     hh_len, fragheaderlen, transhdrlen,
                     maxfraglen, flags);
        if (err)
            goto error;
        return 0;
    }

    /* So, what's going on in the loop below?
     *
     * We use calculated fragment length to generate chained skb,
     * each of segments is IP fragment ready for sending to network after
     * adding appropriate IP header.
     */

    if (!skb)
        goto alloc_new_skb;

（1）通过skb_peek_tail得到发送队列中最后一个skb，如果队列为空，则该函数返回NULL

（2）代码最后2行就是分支的判断语句

（3）中间的是很多初始化操作，这里很有必要提一点的就是skb_peek_tail语句后面的几行代码，这里涉及到了8字节对齐的内容，见图4-3（见《Understand Linux Kernel Internel》图21-10）

图 4-3

注：代码中的变量对应图中看就基本能看懂了。

（4）在最后分支语句上的一个分支语句需要返回图4-1看绿色框部分的内容

2.2、分支（2）

  /* 这个循环最好参照《understand linux network internel》图21-11
   * 主要可以分为4条支线，copy <= 0和copy > 0两种与是否设置NETIF_F_SG
   * 标志两种的组合。
   * 这几种组合可以结合《understand linux network internel》图21-3～图21-6
   * 来看。*/
hile (length > 0) {
/* Check if the remaining data fits into current packet. */
copy = mtu - skb->len;
      /* copy > 0 : 最后一个skb还有一些空余空间
       * copy = 0 : 最后一个skb已经被填满
       * copy < 0 : 有些数据必须从当前IP片段中删除移动到新的片段*/
if (copy < length)
    copy = maxfraglen - skb->len; /*获取一次可以拷贝的份额 */

（1）while (lengh > 0)就是分支2的内容

2.3、分支（3） -> yes

分支（3）的依据是copy的值，在图4-2中已经标明，这里先看分支（3） -> yes部分内容：

if (copy <= 0) {
    char *data;
    unsigned int datalen;
    unsigned int fraglen;
    unsigned int fraggap;
    unsigned int alloclen;
    struct sk_buff *skb_prev;
loc_new_skb:
    skb_prev = skb;
    if (skb_prev) /*需要计算从上一个skb中复制到新的新的skb中的数据长度 */
        fraggap = skb_prev->len - maxfraglen; /*明显就是copy取反 */
    else
        fraggap = 0;

    /*
     * If remaining data exceeds the mtu,
     * we know we need more fragment(s).
     */
    datalen = length + fraggap;
    if (datalen > mtu - fragheaderlen)
        datalen = maxfraglen - fragheaderlen;
    fraglen = datalen + fragheaderlen;

          /* 对应图21-11中MSG_MORE？的分支*/
    if ((flags & MSG_MORE) &&
        !(rt->dst.dev->features&NETIF_F_SG))
        alloclen = mtu; /*最大尺寸分配缓冲区，参考图21-3 */
    else
        alloclen = fraglen; /*确切尺寸分配，参考图21-4
                                    注：fraglen = datalen + fragheaderlen*/

（1）这部分代码已经项图4-2中虚线框部分的内容全部包括进去了（即包含了分支（5）和分支（7））

（2）需要注意的是，这里仅仅只是确定（而且还只是初步确定）了之后需要分配的skb缓存大小

（3）alloc_new_skb是分支（1） -> yes的跳转后的入口

（4）fraggap的内容请参考图4-3

之后的代码就是进一步确定分配空间，然后分配，最后将成功分配的skb插入到发送队列中，代码不难读懂：

    alloclen += exthdrlen; /*扩展长度支持 */

    /* The last fragment gets additional space at tail.
     * Note, with MSG_MORE we overallocate on fragments,
     * because we have no idea what fragment will be
     * the last.
     */
    if (datalen == length + fraggap)
        alloclen += rt->dst.trailer_len;

          /* 分配SKB的空间*/
    if (transhdrlen) {
        skb = sock_alloc_send_skb(sk,
                alloclen + hh_len + 15,
                (flags & MSG_DONTWAIT), &err);
    } else {
        skb = NULL;
        if (atomic_read(&sk->sk_wmem_alloc) <=
            2 * sk->sk_sndbuf)
            skb = sock_wmalloc(sk,
                       alloclen + hh_len + 15, 1,
                       sk->sk_allocation);
        if (unlikely(skb == NULL))
            err = -ENOBUFS;
        else
            /* only the initial fragment is
               time stamped */
            cork->tx_flags = 0;
    }
    if (skb == NULL)
        goto error;

    /*
     *  Fill in the control structures
     */
    skb->ip_summed = csummode;
    skb->csum = 0;
    skb_reserve(skb, hh_len);
    skb_shinfo(skb)->tx_flags = cork->tx_flags;

    /*
     *  Find where to start putting bytes.
     */
    data = skb_put(skb, fraglen + exthdrlen); /*预留L2，L3首部空间 */
    skb_set_network_header(skb, exthdrlen); /*设置L3层的指针 */
    skb->transport_header = (skb->network_header +
                 fragheaderlen);
    data += fragheaderlen + exthdrlen;

    if (fraggap) { /*填充原来的skb尾部的空间 */
        skb->csum = skb_copy_and_csum_bits(
            skb_prev, maxfraglen,
            data + transhdrlen, fraggap, 0);
        skb_prev->csum = csum_sub(skb_prev->csum,
                      skb->csum);
        data += fraggap;
        pskb_trim_unique(skb_prev, maxfraglen);
    }

    copy = datalen - transhdrlen - fraggap;
    if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
        err = -EFAULT;
        kfree_skb(skb);
        goto error;
    }

          /* 计算下次需要复制的数据长度*/
    offset += copy;
    length -= datalen - fraggap;
    transhdrlen = 0; /*注意 */
    exthdrlen = 0; /*注意 */
    csummode = CHECKSUM_NONE;

    /*
     * Put the packet on the pending queue.
     */
    __skb_queue_tail(queue, skb); /*将skb添加的尾部 */
    continue;
}

（1）这里第一个需要注意的就是fraggap的内容，还是参照图4-3来看

（2）最后需要计算下次需要复制的数据的长度。

可能只看代码会比较让人头晕，所以下面给出这些内存分配后数据组织的情况：

注：在代码中这些部分内容都揉在一起，也不是不能拆，只是觉得拆了以后代码太零散，看的更让人头晕。

（a）分支（5） -> yes （见《Understand Linux Kernel Internel》图21-5）

图 4-4

这里需要注意PMTU大小和skb缓存实际大小。

（b）分支（7） -> no （见《Understand Linux Kernel Internel》图21-3）

图 4-5

注：这里需要注意一些参数之间的关系：

（c） 分支（7）-> yes （见《Understand Linux Kernel Internel》图21-4）

图 4-6

注：这里注意skb缓存大小的分配。

2.4 分支（3）-> no

该分支对应copy > 0的情况，根据分支4中的情况会分为两条支线。

2.4.1 分支（4） -> no

if (copy > length)
    copy = length;

if (!(rt->dst.dev->features&NETIF_F_SG)) { /*不支持分散聚合,《understand
                                                   linux netowrk internel》图21-11
                                                   中的分支,直接填充缓存*/
    unsigned int off;

    off = skb->len;
    if (getfrag(from, skb_put(skb, copy),
            offset, copy, off, skb) < 0) {
        __skb_trim(skb, off);
        err = -EFAULT;
        goto error;
    }

copy > 0 说明有足够的空间，如果不开启分散聚合 I/O，就直接拷贝，之后的数据结构如下图（见《Understand Linux Kernel Internel》图21-6（b））

图 4-7

2.4.2 、分支（4） ->  yes

    } else {
        int i = skb_shinfo(skb)->nr_frags;
        skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];
        struct page *page = cork->page;
        int off = cork->off;
        unsigned int left;

        if (page && (left = PAGE_SIZE - off) > 0) { /*已经分配了页面 */
            if (copy >= left)
                copy = left;
            if (page != skb_frag_page(frag)) {
                if (i == MAX_SKB_FRAGS) {
                    err = -EMSGSIZE;
                    goto error;
                }
                skb_fill_page_desc(skb, i, page, off, 0);
                skb_frag_ref(skb, i);
                frag = &skb_shinfo(skb)->frags[i];
            }
        } else if (i < MAX_SKB_FRAGS) {
               /* 注： MAC_SKB_FRAGS是最大片段数量，即skb->frags数组的最大下标
                * 注2： 由此可以推断一个IP封包最大不能超过64K + MTU
                * 注3： IP封包大小不是IP报文大小，IP报文大小根据MTU的值规定*/
            if (copy > PAGE_SIZE)
                copy = PAGE_SIZE;
            page = alloc_pages(sk->sk_allocation, 0); /*分配一个页面 */
            if (page == NULL)  {
                err = -ENOMEM;
                goto error;
            }
            cork->page = page;
            cork->off = 0;

            skb_fill_page_desc(skb, i, page, 0, 0);
            frag = &skb_shinfo(skb)->frags[i];
        } else {
            err = -EMSGSIZE;
            goto error;
        }
        if (getfrag(from, skb_frag_address(frag)+skb_frag_size(frag), /*将数据拷贝到页面内 */
                offset, copy, skb->len, skb) < 0) {
            err = -EFAULT;
            goto error;
        }
        cork->off += copy;
        skb_frag_size_add(frag, copy);
        skb->len += copy;
        skb->data_len += copy;
        skb->truesize += copy;
        atomic_add(copy, &sk->sk_wmem_alloc);
    }
    offset += copy;
    length -= copy;
}

return 0;

注：上述代码已经包含了页面分配的内容

见《Understand Linux Kernel Internel》图21-7

图 4-8

注：这里注意下MAX_SKB_FRAGS，源代码定义是16，一个page是4K，所以一个IP封包最大的大小是64K.

2.5 扫尾。

return 0;

rror:
cork->length -= length;
IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
return err;

结束：

关于ip_ufo_append_data函数，如果弄懂上面的过程，那个看起来就很简单了。ip_append_data函数涉及的参数很多，但 是涉及的知识面却是很少的，主要都是在缓存分配和数据结构组织上。所有的内容去其实都在《understand linux network internal》图21-2～图21-8中。对照源码以及《Linux内核源码剖析-TCP/IP实现》中的说明，看起来应该还是比较简单的。

另外还有ip_append_page函数，我没去看，感觉应该和这个差不多