TCP的发送系列 — tcp_sendmsg()的实现（一）

主要内容：Socket发送函数在TCP层的实现

内核版本：3.15.2

我的博客：http://blog.csdn.net/zhangskd

上一篇blog讲的是send()、sendto()、sendmsg()和sendmmsg()这些发送函数的系统调用和

Socket层实现，现在来看下它们的TCP层实现。

TCP层实现

SOCK_STREAM类socket的TCP层操作函数集实例为tcp_prot，其中使用tcp_sendmsg()来发送数据。

struct proto tcp_prot = {
    .name = "TCP",
    .owner = THIS_MODULE,
    ...
    .sendmsg = tcp_sendmsg,
    ...
};

tcp_sendmsg()的主要工作是把用户层的数据，填充到skb中，然后加入到sock的发送队列。

之后调用tcp_write_xmit()来把sock发送队列中的skb尽量地发送出去。

另外TCP发送缓存的管理也主要发生在tcp_sendmsg()函数中，在接下来的blog中会有单独的分析。

tcp_sendmsg()做了以下事情：

1. 如果使用了TCP Fast Open，则会在发送SYN包的同时携带上数据。

2. 如果连接尚未建立好，不处于ESTABLISHED或者CLOSE_WAIT状态，

那么进程进行睡眠，等待三次握手的完成。

3. 获取当前的MSS、网络设备支持的最大数据长度size_goal。

如果支持GSO，size_goal会是MSS的整数倍。

4. 遍历用户层的数据块数组：

4.1 获取发送队列的最后一个skb，如果是尚未发送的，且长度尚未达到size_goal，

那么可以往此skb继续追加数据。

4.2 否则需要申请一个新的skb来装载数据。

4.2.1 如果发送队列的总大小sk_wmem_queued大于等于发送缓存的上限sk_sndbuf，

或者发送缓存中尚未发送的数据量超过了用户的设置值：

设置同步发送时发送缓存不够的标志。

如果此时已有数据复制到发送队列了，就尝试立即发送。

等待发送缓存，直到sock有发送缓存可写事件唤醒进程，或者等待超时。

4.2.2 申请一个skb，其线性数据区的大小为：

通过select_size()得到的线性数据区中TCP负荷的大小 + 最大的协议头长度。

如果申请skb失败了，或者虽然申请skb成功，但是从系统层面判断此次申请不合法，

等待可用内存，等待时间为2~202ms之间的一个随机数。

4.2.3 如果以上两步成功了，就更新skb的TCP控制块字段，把skb加入到sock发送队列的尾部，

增加发送队列的大小，减小预分配缓存的大小。

4.3 接下来就是拷贝消息头中的数据到skb中了。

如果skb的线性数据区还有剩余空间，就复制数据到线性数据区中，同时计算校验和。

4.4 如果skb的线性数据区已经用完了，那么就使用分页区：

4.4.1 检查分页是否有可用空间，如果没有就申请新的page。如果申请失败，说明系统内存不足。

之后会设置TCP内存压力标志，减小发送缓冲区的上限，睡眠等待内存。

4.4.2 判断能否往最后一个分页追加数据。不能追加时，检查分页数是否达到了上限、

或网卡不支持分散聚合。如果是的话，就为此skb设置PSH标志。

然后跳转到4.2处申请新的skb，来继续填装数据。

4.4.3 从系统层面判断此次分页发送缓存的申请是否合法。

4.4.4 拷贝用户空间的数据到skb的分页中，同时计算校验和。

更新skb的长度字段，更新sock的发送队列大小和预分配缓存。

4.4.5 如果把数据追加到最后一个分页了，更新最后一个分页的数据大小。否则初始化新的分页。

4.5 拷贝成功后更新：送队列的最后一个序号、skb的结束序号、已经拷贝到发送队列的数据量。

4.6 尽可能的将发送队列中的skb发送出去。

int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, size_t size)
{
    struct iovec *iov;
    struct tcp_sock *tp = tcp_sk(sk);
    struct sk_buff *skb;
    int iovlen, flags, err, copied = 0;
    int mss_now = 0, size_goal, copied_syn = 0, offset = 0;
    bool sg;
    long timeo;

    lock_sock(sk);

    flags = msg->msg_flags;

    /* Send data in TCP SYN.
     * 使用了TCP Fast Open时，会在发送SYN时携带上数据。
     */
    if (flags & MSG_FASTOPEN) {
        err = tcp_sendmsg_fastopen(sk, msg, &copied_syn, size);
        if (err == -EINPROGRESS && copied_syn > 0)
            goto out;
        else if (err)
            goto out_err;

        offset = copied_syn;
    }

    /* 发送的超时时间，如果是非阻塞的则为0 */
    timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT); 

    /* Wait for a connection to finish.
     * One exception is TCP Fast Open (passive side) where data is allowed to
     * be sent before a connection is fully established.
     */

    /* 如果连接尚未完成三次握手，是不允许发送数据的，除非是Fast Open的被动打开方 */
    if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
        ! (tcp_passive_fastopen(sk)) {

        /* 等待连接的建立，成功时返回值为0 */
        if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)
            goto do_error;
    }

    /* 使用TCP_REPAIR选项时 */
    if (unlikely(tp->repair)) {

        /* 发送到接收队列中 */
        if (tp->repair_queue == TCP_RECV_QUEUE) {
            copied = tcp_send_rcvq(sk, msg, size);
            goto out;
        }

        err = -EINVAL;
        if (tp->repair_queue == TCP_NO_QUEUE)
            goto out_err;

        /* common sending to sendq */
    }

    /* This should be in poll.
     * 清除使用异步情况下，发送队列满了的标志。
     */
    clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

    /* 获取当前的发送MSS.
     * 获取可发送到网卡的最大数据长度，如果使用GSO，会是MSS的整数倍。
     */
    mss_now = tcp_send_mss(sk, &size_goal, flags);

    /* Ok commence sending. */
    iovlen = msg->msg_iovlen; /* 应用层数据块的个数*/
    iov = msg->msg_iov; /* 应用层数据块数组的地址 */
    copied = 0; /* 已拷贝到发送队列的字节数 */

    err = -EPIPE; /* Broken pipe */
    /* 如果连接有错误，或者不允许发送数据了，那么返回-EPIPE */
    if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
        goto out_err;

    sg = !! (sk->sk_route_caps & NETIF_F_SG); /* 网卡是否支持分散聚合 */

    /* 遍历用户层的数据块数组 */
    while (--iovlen >= 0) {

        size_t seglen = iov->iov_len; /* 数据块的长度 */
        unsigned char __user *from = iov->iov_base; /* 数据块的地址 */

        iov++; /* 指向下一个数据块 */

        /* Skip bytes copied in SYN.
         * 如果使用了TCP Fast Open，需要跳过SYN包发送过的数据。
         */
        if (unlikely(offset > 0)) {
            if (offset >= seglen) {
                offset -= seglen;
                continue;
            }

            seglen -= offset;
            from += offset;
            offset = 0;
        }

        while (seglen > 0) {
            int copy = 0;
            int max = size_goal; /* 单个skb的最大数据长度，如果使用了GSO，长度为MSS的整数倍 */

            skb = tcp_write_queue_tail(sk); /* 发送队列的最后一个skb */

            if (tcp_send_head(sk)) { /* 还有未发送的数据，说明该skb还未发送 */
                /* 如果网卡不支持检验和计算，那么skb的最大长度为MSS，即不能使用GSO */
                if (skb->ip_summed == CHECKSUM_NONE)
                    max = mss_now;

                copy = max - skb->len; /* 此skb可追加的数据长度 */
            }

            if (copy <= 0) { /* 需要使用新的skb来装数据 */
new_segment:
                /* Allocate new segment. If the interface is SG,
                 * allocate skb fitting to single page.
                 */

                /* 如果发送队列的总大小sk_wmem_queued大于等于发送缓存的上限sk_sndbuf，
                 * 或者发送缓存中尚未发送的数据量超过了用户的设置值，就进入等待。
                  */
                if (! sk_stream_memory_free(sk))
                    goto wait_for_sndbuf;

                /* 申请一个skb，其线性数据区的大小为：
                 * 通过select_size()得到的线性数据区中TCP负荷的大小 + 最大的协议头长度。
                 * 如果申请skb失败了，或者虽然申请skb成功，但是从系统层面判断此次申请不合法，
                 * 那么就进入睡眠，等待内存。
                 */
                skb = sk_stream_alloc_skb(sk, select_size(sk, sg), sk->sk_allocation);
                if (! skb)
                    goto wait_for_memory;            

                /* All packets are restored as if they have already been sent.
                 * 如果使用了TCP REPAIR选项，那么为skb设置“发送时间”。
                 */
                if (tp->repair)
                    TCP_SKB_CB(skb)->when = tcp_time_stamp;

               /* Check whether we can use HW checksum.
                * 如果网卡支持校验和的计算，那么由硬件计算报头和首部的校验和。
                */
               if (sk->sk_route_caps & NETIF_F_ALL_CSUM)
                    skb->ip_summed = CHECKSUM_PARTIAL;

                /* 更新skb的TCP控制块字段，把skb加入到sock发送队列的尾部，
                 * 增加发送队列的大小，减小预分配缓存的大小。
                 */
                skb_entail(sk, skb);

                copy = size_goal;
                max = size_goal;
            }

            /* Try to append data to the end of skb.
             * 本次可拷贝的数据量不能超过数据块的长度。
             */
            if (copy > seglen)
                copy = seglen;

            /* Where to copy to ?
             * 如果skb的线性数据区还有剩余空间，就先复制到线性数据区。
             */
            if (skb_availroom(skb) > 0) {
                copy = min_t(int, copy, skb_availroom(skb));

                /* 拷贝用户空间的数据到内核空间，同时计算校验和 */
                err = skb_add_data_nocache(sk, skb, from, copy);
                if (err)
                    goto do_fault;

            } else { /* 如果skb的线性数据区已经用完了，那么就使用分页区 */
                bool merge = true;
                int i = skb_shinfo(skb)->nr_frags; /* 分页数 */
                struct page_frag *pfrag = sk_page_frag(sk); /* 上次缓存的分页 */

                /* 检查分页是否有可用空间，如果没有就申请新的page。
                 * 如果申请失败，说明系统内存不足。
                 * 之后会设置TCP内存压力标志，减小发送缓冲区的上限，睡眠等待内存。
                 */
                if (! sk_page_frag_refill(sk, pfrag))
                    goto wait_for_memory;

                /* 判断能否往最后一个分页追加数据 */
                if (! skb_can_coalesce(skb, i, pfrag->page, pfrag->offset)) {

                    /* 不能追加时，检查分页数是否达到了上限，或者网卡不支持分散聚合。
                     * 如果是的话，就为此skb设置PSH标志，尽快地发送出去。
                     * 然后跳转到new_segment处申请新的skb，来继续填装数据。
                     */
                    if (i == MAX_SKB_FRAGS || ! sg) {
                        tcp_mark_push(tp, skb);
                        goto new_segment;
                    }
                    merge = false;
                }

                copy = min_t(int ,copy, pfrag->size - pfrag->offset);

                /* 从系统层面判断发送缓存的申请是否合法 */
                if (! sk_wmem_schedule(sk, copy))
                    goto wait_for_memory;

                /* 拷贝用户空间的数据到内核空间，同时计算校验和。
                 * 更新skb的长度字段，更新sock的发送队列大小和预分配缓存。
                 */
                err = skb_copy_to_page_nocache(sk, from, skb, pfrag->page, pfrag->offset, copy);
                if (err)
                    goto do_error;

                /* Update the skb. */
                if (merge) { /* 如果把数据追加到最后一个分页了，更新最后一个分页的数据大小 */
                    skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
                } else {
                    /* 初始化新增加的页 */
                    skb_fill_page_desc(skb, i, pfrag->page, pfrag->offset, copy);
                    get_page(pfrag->page);
                }

                pfrag->offset += copy;
            }

            /* 如果这是第一次拷贝，取消PSH标志 */
            if (! copied)
                TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;

            tp->write_seq += copy; /* 更新发送队列的最后一个序号 */
            TCP_SKB_CB(skb)->send_seq += copy; /* 更新skb的结束序号 */
            skb_shinfo(skb)->gso_segs = 0;

            from += copy; /* 下次拷贝的地址 */
            copied += copy; /* 已经拷贝到发送队列的数据量 */

            /* 如果所有数据都拷贝好了，就退出 */
            if ((seglen -= copy) == 0 && iovlen == 0)
                goto out;

            /* 如果skb还可以继续填充数据，或者发送的是带外数据，或者使用TCP REPAIR选项，
             * 那么继续拷贝数据，先不发送。
             */
            if (skb->len < max || (flags & MSG_OOB) || unlikely(tp->repair))
                continue;

            /* 如果需要设置PSH标志 */
            if (forced_push(tp)) {
                tcp_mark_push(tp, skb);

                /* 尽可能的将发送队列中的skb发送出去，禁用nalge */
                __tcp_push_pending_frames(sk, mss_now,TCP_NAGLE_PUSH);

            } else if (skb == tcp_send_head(sk))
                tcp_push_one(sk, mss_now); /* 只发送一个skb */

            continue;

wait_for_sndbuf:
                /* 设置同步发送时，发送缓存不够的标志 */
                set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);

wait_for_memory:
                /* 如果已经有数据复制到发送队列了，就尝试立即发送 */
                if (copied)
                    tcp_push(sk, flags & ~MSG_MORE, mss_now, TCP_NAGLE_PUSH, size_goal);

                /* 分两种情况：
                 * 1. sock的发送缓存不足。等待sock有发送缓存可写事件，或者超时。
                 * 2. TCP层内存不足，等待2~202ms之间的一个随机时间。
                 */
                if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
                    goto do_err;  

                /* 睡眠后MSS和TSO段长可能会发生变化，重新计算 */
                mss_now = tcp_send_mss(sk, &size_goal, flags);

            } // end while seglen > 0
        } // end while --iovlen >= 0

out:
    /* 如果已经有数据复制到发送队列了，就尝试立即发送 */
    if (copied)
        tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);

    release_sock(sk);
    return copied + copied_syn;

do_fault:
    if (! skb->len) { /* 如果skb没有负荷 */
        tcp_unlink_write_queue(skb, sk); /* 把skb从发送队列中删除 */

        /* It is the one place in all of TCP, except connection reset,
         * where we can be unlinking the send_head.
         */
        tcp_check_send_head(sk, skb); /* 是否要撤销sk->sk_send_head */
        sk_wmem_free_skb(sk, skb); /* 更新发送队列的大小和预分配缓存，释放skb */
    }

do_error:
    if (copied + copied_syn)
        goto out;

out_err:
    err = sk_stream_error(sk, flags, err);
    release_sock(sk);
    return err;
}