static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,

                int push_one, gfp_t gfp)

 {

     struct tcp_sock *tp = tcp_sk(sk);

     struct sk_buff *skb;

     unsigned int tso_segs, sent_pkts;

     int cwnd_quota;

     int result;

     bool is_cwnd_limited = false, is_rwnd_limited = false;

     u32 max_segs;

     /* 已发送数据段数量 */

     sent_pkts = ;

     /* 发送多个数据段 */

     if (!push_one) {

         /* Do MTU probing. */

         /* 发送路径mtu探测 */

         result = tcp_mtu_probe(sk);

         /* 失败 */

         if (!result) {

             return false;

         }

         /* 成功，设置已发送数据段数为1 */

         else if (result > ) {

             sent_pkts = ;

         }

     }

     /* 获取最大tso分段 */

     max_segs = tcp_tso_segs(sk, mss_now);

     /* 有数据段要发送 */

     while ((skb = tcp_send_head(sk))) {

         unsigned int limit;

         /* 初始化tso分段相关 */

         tso_segs = tcp_init_tso_segs(skb, mss_now);

         BUG_ON(!tso_segs);

         if (unlikely(tp->repair) && tp->repair_queue == TCP_SEND_QUEUE) {

             /* "skb_mstamp" is used as a start point for the retransmit timer */

             skb_mstamp_get(&skb->skb_mstamp);

             goto repair; /* Skip network transmission */

         }

         /* 检测拥塞窗口大小 */

         cwnd_quota = tcp_cwnd_test(tp, skb);

         /* 为0 */

         if (!cwnd_quota) {

             /* 尾部丢失探测段，设置为1 */

             if (push_one == )

                 /* Force out a loss probe pkt. */

                 cwnd_quota = ;

             /* 其他情况，跳出 */

             else

                 break;

         }

         /* 检查tcp的数据段是否在发送窗口之内 */

         if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now))) {

             /* 不在，标记，跳出 */

             is_rwnd_limited = true;

             break;

         }

         /* 不需要tso分段 */

         if (tso_segs == ) {

             /* 检查nagle算法是否允许发送数据段 */

             if (unlikely(!tcp_nagle_test(tp, skb, mss_now,

                              (tcp_skb_is_last(sk, skb) ?

                               nonagle : TCP_NAGLE_PUSH))))

                 break;

         }

         /* 需要tso分段 */

         else {

             /* 检查是否可以延迟发送 */

             if (!push_one &&

                 tcp_tso_should_defer(sk, skb, &is_cwnd_limited,

                          max_segs))

                 break;

         }

         /* 设置分段长度限制为mss */

         limit = mss_now;

         /* 需要分段 && 非紧急模式，重新确定分段长度限制 */

         if (tso_segs >  && !tcp_urg_mode(tp))

             limit = tcp_mss_split_point(sk, skb, mss_now,

                             min_t(unsigned int,

                               cwnd_quota,

                               max_segs),

                             nonagle);

         /* skb中数据段长度>分段长度限制，则进行分段，会申请新的skb */

         if (skb->len > limit &&

             unlikely(tso_fragment(sk, skb, limit, mss_now, gfp)))

             break;

         if (test_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags))

             clear_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags);

         if (tcp_small_queue_check(sk, skb, ))

             break;

         /* 发送分段数据 */

         if (unlikely(tcp_transmit_skb(sk, skb, , gfp)))

             break;

 repair:

         /* Advance the send_head.  This one is sent out.

          * This call will increment packets_out.

          */

         /* 进行发送之后的数据更新，包括统计计数和定时器等 */

         tcp_event_new_data_sent(sk, skb);

         /* 更新最新发送小包的结束序号 */

         tcp_minshall_update(tp, mss_now, skb);

         /* 更新发送数据段数量 */

         sent_pkts += tcp_skb_pcount(skb);

         /* 只发送一个段，则跳出 */

         if (push_one)

             break;

     }

     if (is_rwnd_limited)

         tcp_chrono_start(sk, TCP_CHRONO_RWND_LIMITED);

     else

         tcp_chrono_stop(sk, TCP_CHRONO_RWND_LIMITED);

     /* 本次有数据发送，拥塞相关数据更新 */

     if (likely(sent_pkts)) {

         if (tcp_in_cwnd_reduction(sk))

             tp->prr_out += sent_pkts;

         /* Send one loss probe per tail loss episode. */

         /* 每次发送一个尾部丢失探测 */

         if (push_one != )

             tcp_schedule_loss_probe(sk);

         /* 拥塞窗口校验 */

         is_cwnd_limited |= (tcp_packets_in_flight(tp) >= tp->snd_cwnd);

         tcp_cwnd_validate(sk, is_cwnd_limited);

         return false;

     }

     /*  本次无数据发送，已发出未确认的数据段不为0或者发送队列为空，认为成功 */

     return !tp->packets_out && tcp_send_head(sk);

 }