一、讲解

tcp_sendmsg_locked 函数是 Linux 内核中实现 TCP 数据发送的一个核心函数。这个函数被调用来将用户空间的数据通过 TCP 发送出去。以下是该函数的基本工作流程的中文解释：
1. 函数初始化和检查：
   - 它首先检查是否使用了 TCP 零拷贝发送（MSG_ZEROCOPY）以及确保发送状态是正确的。
   - 函数通过检查标志位来处理 TCP 快速打开特性。
   - 设置发送超时和评估发送路径是否处于“应用受限”状态。
2. 等待连接完成：
   - 如果 TCP 连接还未建立，它将等待连接完成，除非使用了 TCP 快速打开。
3. 准备发送：
   - 如果存在 TCP 修复模式，它将处理特定的发送队列。
   - 解析传输层控制消息。
   - 清除可能影响发送队列的异步标记。
   - 计算最大段大小（MSS）和发送目标大小。
4. 数据发送循环：
   - 函数进入循环，开始从用户消息（`msg`）中拷贝数据到内核的发送缓冲区。
   - 它处理两种类型的发送缓冲区：线性空间和分散/聚集空间。
   - 可能会处理 socket 的内存分配和等待内存分配。
   - 根据不同情况拷贝数据到 TCP 段（`skb`），并更新 TCP 状态信息（如写序列号）。
5. 错误处理：
   - 如果出现错误或异常，函数会进行错误处理，包括释放必要的资源。
6. 推送数据和结束发送：
   - 完成数据拷贝后，如果已经拷贝了足够的数据，函数将推动网络栈发送这些数据（或者等待发送缓冲区空间可用来发送更多数据）。
   - 根据使用的发送标志，函数可能会标记 PSH 推送位，或使用 Nagle 算法等待发送。
   - 数据发送后，函数执行必要的清理操作，返回拷贝的字节数，或者发送失败时的错误码。
整体上，`tcp_sendmsg_locked` 函数处理了一系列复杂的 TCP 发送逻辑，包括 TCP 发送缓冲区的管理、段的创建及填充、发送拥塞控制、零拷贝优化等。此函数的名称表示它应在相应的 socket 已被锁定的情况下调用，以保证线程安全。这是内核网络栈的核心函数之一，涉及到许多内核编程细节和网络协议的实现。

二、注释

/ tcp_sendmsg_locked函数的实现
int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
{
    // 声明一系列变量
    struct tcp_sock *tp = tcp_sk(sk); // 获取tcp_sock结构
    struct ubuf_info *uarg = NULL;
    struct sk_buff *skb;
    struct sockcm_cookie sockc;
    int flags, err, copied = 0;
    int mss_now = 0, size_goal, copied_syn = 0;
    bool process_backlog = false;
    bool zc = false;
    long timeo;
    flags = msg->msg_flags; // 获取消息标志
    // 检查是否启用了零拷贝发送
    if (flags & MSG_ZEROCOPY && size && sock_flag(sk, SOCK_ZEROCOPY)) {
        // TCP状态检查
        if ((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) {
            err = -EINVAL;
            goto out_err;
        }
        skb = tcp_write_queue_tail(sk);
        uarg = sock_zerocopy_realloc(sk, size, skb_zcopy(skb));
        if (!uarg) {
            err = -ENOBUFS;
            goto out_err;
        }
        zc = sk->sk_route_caps & NETIF_F_SG;
        if (!zc)
            uarg->zerocopy = 0;
    }
    // 处理快速打开的情况
    if (unlikely(flags & MSG_FASTOPEN || inet_sk(sk)->defer_connect) && !tp->repair) {
        err = tcp_sendmsg_fastopen(sk, msg, &copied_syn, size);
        if (err == -EINPROGRESS && copied_syn > 0)
            goto out;
        else if (err)
            goto out_err;
    }
    timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT); // 获取发送超时
    tcp_rate_check_app_limited(sk); // 检查应用级发送是否受限
    // 等待连接完成，除非是被动端的TCP快速打开
    if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) && !tcp_passive_fastopen(sk)) {
        err = sk_stream_wait_connect(sk, &timeo);
        if (err != 0)
            goto do_error;
    }
    // 如果处于TCP修复状态
    if (unlikely(tp->repair)) {
        if (tp->repair_queue == TCP_RECV_QUEUE) {
            // 修复时发送recv队列中的数据
            copied = tcp_send_rcvq(sk, msg, size);
            goto out_nopush;
        }
        err = -EINVAL;
        if (tp->repair_queue == TCP_NO_QUEUE)
            goto out_err;
        // 处于发送队列的修复
    }
    // 初始化sockcm_cookie
    sockcm_init(&sockc, sk);
    if (msg->msg_controllen) {
        err = sock_cmsg_send(sk, msg, &sockc);
        if (unlikely(err)) {
            err = -EINVAL;
            goto out_err;
        }
    }
    sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk); // 清除异步无空间标志
    // 开始发送数据
    copied = 0;
// 重启标签，处理发送过程中需要重启的情况
restart:
    mss_now = tcp_send_mss(sk, &size_goal, flags); // 获取发送的最大报文段大小
    err = -EPIPE;
    if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
        goto do_error;
    // 循环处理要发送的数据
    while (msg_data_left(msg)) {
        int copy = 0;
        skb = tcp_write_queue_tail(sk);
        if (skb)
            copy = size_goal - skb->len;
        if (copy <= 0 || !tcp_skb_can_collapse_to(skb)) {
            bool first_skb;
            int linear;
            // 创建新的数据段
new_segment:
            if (!sk_stream_memory_free(sk))
                goto wait_for_sndbuf;
            if (process_backlog && sk_flush_backlog(sk)) {
                process_backlog = false;
                goto restart;
            }
            first_skb = tcp_rtx_and_write_queues_empty(sk);
            linear = select_size(first_skb, zc);
            skb = sk_stream_alloc_skb(sk, linear, sk->sk_allocation,
                          first_skb);
            if (!skb)
                goto wait_for_memory;
            process_backlog = true;
            skb->ip_summed = CHECKSUM_PARTIAL;
            skb_entail(sk, skb);
            copy = size_goal;
            // 如果处于修复模式，标记该skb已经“发送”
            if (tp->repair)
                TCP_SKB_CB(skb)->sacked |= TCPCB_REPAIRED;
        }
        // 尝试附加数据到skb的末尾
        if (copy > msg_data_left(msg))
            copy = msg_data_left(msg);
        // 将数据从用户空间拷贝到skb中
        if (skb_availroom(skb) > 0 && !zc) {
            // 有空间进行直接拷贝
            copy = min_t(int, copy, skb_availroom(skb));
            err = skb_add_data_nocache(sk, skb, &msg->msg_iter, copy);
            if (err)
                goto do_fault;
        } else if (!zc) {
            bool merge = true;
            int i = skb_shinfo(skb)->nr_frags;
            // 大页内存管理
            struct page_frag *pfrag = sk_page_frag(sk);
            // 确保page_frag有足够内存
            if (!sk_page_frag_refill(sk, pfrag))
                goto wait_for_memory;
            // 检查skb是否可以合并到最后的一个frag
            if (!skb_can_coalesce(skb, i, pfrag->page, pfrag->offset)) {
                // 如果达到了frag的上限，则新建一个段
                if (i >= sysctl_max_skb_frags) {
                    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;
            // 无拷贝地将数据从用户空间复制到页内存
            err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,
                               pfrag->page,
                               pfrag->offset,
                               copy);
            if (err)
                goto do_error;
            // 更新skb状态
            if (merge) {
                // 如果合并成功，增加frag的大小
                skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
            } else {
                // 没有合并，就在skb中新增一个page frag描述符
                skb_fill_page_desc(skb, i, pfrag->page, pfrag->offset, copy);
                page_ref_inc(pfrag->page); // 增加页引用计数
            }
            // 更新page_frag位置
            pfrag->offset += copy;
        } else {
            // 零拷贝的发送方式
            err = skb_zerocopy_iter_stream(sk, skb, msg, copy, uarg);
            if (err == -EMSGSIZE || err == -EEXIST) {
                // 出现错误，需要新段
                tcp_mark_push(tp, skb);
                goto new_segment;
            }
            if (err < 0)
                goto do_error;
            copy = err;
        }
        // 更新TCP状态
        if (!copied)
            TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
        tp->write_seq += copy;
        TCP_SKB_CB(skb)->end_seq += copy;
        tcp_skb_pcount_set(skb, 0);
        copied += copy;
        if (!msg_data_left(msg)) {
            // 如果数据已经全部发送完成，设置结束标志
            if (unlikely(flags & MSG_EOR))
                TCP_SKB_CB(skb)->eor = 1;
            goto out;
        }
        // 检查skb是否达到了目标大小或者其它特殊情况
        if (skb->len < size_goal || (flags & MSG_OOB) || unlikely(tp->repair))
            continue;
        if (forced_push(tp)) {
            // 如果需要立即发送数据，则添加PSH标志并推送数据
            tcp_mark_push(tp, skb);
            __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
        } else if (skb == tcp_send_head(sk))
            // 如果skb是待发送队列的头部，可能需要推送一个分段
            tcp_push_one(sk, mss_now);
        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);
        // 等待足够的发送缓冲区内存
        err = sk_stream_wait_memory(sk, &timeo);
        if (err != 0)
            goto do_error;
        // 重新计算mss和目标大小
        mss_now = tcp_send_mss(sk, &size_goal, flags);
    }
out:
    // 数据发送完成，调用tcp_push推送所有挂起的数据帧
    if (copied) {
        tcp_tx_timestamp(sk, sockc.tsflags);
        tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
    }
out_nopush:
    // 释放uarg资源
    sock_zerocopy_put(uarg);
    return copied + copied_syn;
    // 处理skb没有复制任何数据的情况
do_fault:
    if (!skb->len) {
        tcp_unlink_write_queue(skb, sk);
        // 这是TCP中除了连接重置以外唯一可能删除send_head的地方
        tcp_check_send_head(sk, skb);
        sk_wmem_free_skb(sk, skb);
    }
    // 处理错误，如果已经复制了数据，则直接退出
do_error:
    if (copied + copied_syn)
        goto out;
out_err:
    // 处理失败，中止零拷贝操作，记录错误并返回
    sock_zerocopy_put_abort(uarg);
	// 根据错误代码设置套接字错误状态，并返回错误
    err = sk_stream_error(sk, flags, err);
    // 如果写队列为空，并且返回了EAGAIN错误，则尝试触发epoll的边缘触发事件
    if (unlikely(skb_queue_len(&sk->sk_write_queue) == 0 &&	
err == -EAGAIN)) {
        sk->sk_write_space(sk); // 若写入队列为空并且错误为EAGAIN，确保调用sk_write_space来唤醒epoll等待者,唤醒可能在等待发送缓冲区空间的epoll
        tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED); // 停止发送缓冲区限制的计时器
    }
    return err; // 返回出错信息
}
EXPORT_SYMBOL_GPL(tcp_sendmsg_locked); // 导出tcp_sendmsg_locked符号，允许其他内核模块调用	

三、tcp_sendmsg

这个函数`tcp_sendmsg`用于处理TCP socket的发送消息操作。让我们逐行地用中文解释这个函数的作用：

int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
{
    int ret;

    lock_sock(sk);  // 对指定的socket加锁，以防止并发访问导致的数据竞争。
    ret = tcp_sendmsg_locked(sk, msg, size);  // 在锁定后，调用tcp_sendmsg_locked函数发送消息。这个函数实现了消息的发送逻辑，但假设调用它的上下文已经持有了锁。
    release_sock(sk);  // 消息发送完成后，释放之前获取的锁。

    return ret;  // 返回tcp_sendmsg_locked函数的返回值，通常是已发送数据的字节数或者一个错误码。
}
EXPORT_SYMBOL(tcp_sendmsg);  // 将tcp_sendmsg函数导出，使它可以被该模块外的代码调用。

总的来说，`tcp_sendmsg`是一个对外暴露的接口，它用于在用户空间调用以发起TCP通信。该函数首先锁定目标socket，然后调用实际发送消息实现的内部函数`tcp_sendmsg_locked`，发送过程完成后释放锁，并返回发送操作的结果（成功发送的字节数或错误码）。通过锁来保证tcp发送操作的线程安全性。