本文共 11391 字，大约阅读时间需要 37 分钟。

当知道需要重传数据结的时候执行这个函数：

对于函数tcp_xmit_retransmit_queue：需要重传哪些包呢到底？

首先是lost、标记的包；

然后还需要处理：之前发送过的但是尚未收到确认的包（向前重传），或者新数据，在这两者之间有一个选择

/* This gets called after a retransmit timeout, and the initially * retransmitted data is acknowledged.  It tries to continue * resending the rest of the retransmit queue, until either * we've sent it all or the congestion window limit is reached. * If doing SACK, the first ACK which comes back for a timeout * based retransmit packet might feed us FACK information again. * If so, we use it to avoid unnecessarily retransmissions. */void tcp_xmit_retransmit_queue(struct sock *sk){         const struct inet_connection_sock *icsk = inet_csk(sk);         struct tcp_sock *tp = tcp_sk(sk);         struct sk_buff *skb;         int packet_cnt;          if (tp->retransmit_skb_hint) {        // 如果有重传信息                 skb = tp->retransmit_skb_hint;                 packet_cnt = tp->retransmit_cnt_hint; // 保存cnt值         } else {                 skb = tcp_write_queue_head(sk); // 发送队列                 packet_cnt = 0;         }         // 第一步，如果有丢失的包，那么需要重传         /* First pass: retransmit lost packets. */         if (tp->lost_out) {  // lost_out > 0                 tcp_for_write_queue_from(skb, sk) {   // 遍历                         __u8 sacked = TCP_SKB_CB(skb)->sacked;   // 获得sacked标识                          if (skb == tcp_send_head(sk))                                break;                         /* we could do better than to assign each time */                         tp->retransmit_skb_hint = skb;           // 更新两个值                         tp->retransmit_cnt_hint = packet_cnt;                          /* Assume this retransmit will generate                          * only one packet for congestion window                          * calculation purposes.  This works because                          * tcp_retransmit_skb() will chop up the                          * packet to be MSS sized and all the                          * packet counting works out.                          */                         if (tcp_packets_in_flight(tp) >= tp->snd_cwnd)   // 如果传输中的报文数量 > 窗口数量，那么没有必要再发送数据                                 return;                          if (sacked & TCPCB_LOST) {  // 如果是LOST标识                                 if (!(sacked & (TCPCB_SACKED_ACKED|TCPCB_SACKED_RETRANS))) {  // 如果丢失了 && 没有被选择确认或者重传                                         if (tcp_retransmit_skb(sk, skb)) {       // 重传该数据函数！！！最后再看（1）                                                 tp->retransmit_skb_hint = NULL;  // 重传之后重置这个值                                                 return;                          // 返回                                         }                                         if (icsk->icsk_ca_state != TCP_CA_Loss)                                                 NET_INC_STATS_BH(LINUX_MIB_TCPFASTRETRANS);                                         else                                                 NET_INC_STATS_BH(LINUX_MIB_TCPSLOWSTARTRETRANS);                                          if (skb == tcp_write_queue_head(sk))   // 如果是第一个重传数据，那么重置重传计数器！！！                                                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,                                                                           inet_csk(sk)->icsk_rto,                                                                           TCP_RTO_MAX);                                 }                                  packet_cnt += tcp_skb_pcount(skb);    // 重传数量                                 if (packet_cnt >= tp->lost_out)  // 大于lost的数量，那么break；下面就不是lost数据问题了                                         break;                         }                 }         }          /* OK, demanded retransmission is finished. */         // 上面的是必须要重传的，下面的在前向重传和发送新数据之间进行选择         /* Forward retransmissions are possible only during Recovery. */         if (icsk->icsk_ca_state != TCP_CA_Recovery)  // 只有在恢复状态才可以这样做，在丢失状态不可以；                 return;   // 原因：在丢失状态希望通过可控制的方式进行重传？这一块不是很懂          /* No forward retransmissions in Reno are possible. */         if (tcp_is_reno(tp))   // 前向选择重传只能是SACK下，reno下是不可能的~                 return;          /* Yeah, we have to make difficult choice between forward transmission          * and retransmission... Both ways have their merits...          *          * For now we do not retransmit anything, while we have some new          * segments to send. In the other cases, follow rule 3 for          * NextSeg() specified in RFC3517.          */ // 下面还是需要选择考虑传输新数据还是前向重传，优先考虑新数据          if (tcp_may_send_now(sk))   // 检查是否有新的数据在等待传输（1）                 return;             // 以及这些新数据是否可以发送，可以的话返回，不需要做下面事                  /* If nothing is SACKed, highest_sack in the loop won't be valid */         if (!tp->sacked_out)                 return;         // 下面开始就是“前向重传”处理         if (tp->forward_skb_hint)               // 是否已经缓存这个队列                 skb = tp->forward_skb_hint;         else                 skb = tcp_write_queue_head(sk); // 没有          tcp_for_write_queue_from(skb, sk) {     // 需要遍历                 if (skb == tcp_send_head(sk))   // 到头了                         break;                 tp->forward_skb_hint = skb;                  if (!before(TCP_SKB_CB(skb)->seq, tcp_highest_sack_seq(tp)))   // 不可以超过最大的即highest_sack_seq                         break;                  if (tcp_packets_in_flight(tp) >= tp->snd_cwnd)  // 如果传输中的包数量 > 窗口大小                         break;  // 不能再发了                  if (TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS)   // ?                         continue;                  /* Ok, retransmit it. */                 if (tcp_retransmit_skb(sk, skb)) {         // 下面就是传输这个包                         tp->forward_skb_hint = NULL;                         break;                 }                  if (skb == tcp_write_queue_head(sk))      // 如果是第一个重传的包，那么启动设置定时器                         inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,                                                   inet_csk(sk)->icsk_rto,                                                   TCP_RTO_MAX);                  NET_INC_STATS_BH(LINUX_MIB_TCPFORWARDRETRANS);         }}

看一下检查是否有新的数据需要传输的函数：tcp_may_send_now

因为此处涉及到Nagle算法，所以先简介一下：

Nagle算法：如果发送端欲多次发送包含少量字符的数据包（一般情况下，后面统一称长度小于MSS的数据包为小包，称长度等于MSS的数据包为大包），则发送端会先将第一个小包发送出去，而将后面到达的少量字符数据都缓存起来而不立即发送，直到收到接收端对前一个数据包报文段的ACK确认、或当前字符属于紧急数据，或者积攒到了一定数量的数据（比如缓存的字符数据已经达到数据包报文段的最大长度）等多种情况才将其组成一个较大的数据包发送出去。

int tcp_may_send_now(struct sock *sk){         struct tcp_sock *tp = tcp_sk(sk);         struct sk_buff *skb = tcp_send_head(sk);  // 获得需要发送的数据头部          return (skb &&  // 尚有新数据需要传输                 tcp_snd_test(sk, skb, tcp_current_mss(sk, 1),  // 看下面这个函数：检查是否这些新的数据需要尽快发送出去                              (tcp_skb_is_last(sk, skb) ?       // 是否是最后一个包                               tp->nonagle : TCP_NAGLE_PUSH))); }

/* This checks if the data bearing packet SKB (usually tcp_send_head(sk)) * should be put on the wire right now.  If so, it returns the number of * packets allowed by the congestion window. */static unsigned int tcp_snd_test(struct sock *sk, struct sk_buff *skb,                                  unsigned int cur_mss, int nonagle){         struct tcp_sock *tp = tcp_sk(sk);         unsigned int cwnd_quota;          tcp_init_tso_segs(sk, skb, cur_mss);    // 看看这个包的tso信息，便于后期和其他包一起处理          if (!tcp_nagle_test(tp, skb, cur_mss, nonagle))  // 使用Nagle测试是不是数据现在就允许被发送，看下面函数（1）                 return 0;                                // 如果不可以就返回了          cwnd_quota = tcp_cwnd_test(tp, skb);             // 返回还可以发送几个窗口的数据         if (cwnd_quota && !tcp_snd_wnd_test(tp, skb, cur_mss))  // 如果有窗口数据可以发送 &&                  cwnd_quota = 0;   // 不可发送，设置=0          return cwnd_quota;}

看Nagle测试函数tcp_nagle_test：

/* Return non-zero if the Nagle test allows this packet to be * sent now. */static inline int tcp_nagle_test(struct tcp_sock *tp, struct sk_buff *skb,                                  unsigned int cur_mss, int nonagle)        // 注意：测试返回1就是说明那个数据包现在允许直接发送出去{                                                                           // 而Nagle对于小包是缓存一起发送的，除了第一个包、最后一个包         /* Nagle rule does not apply to frames, which sit in the middle of the          * write_queue (they have no chances to get new data).          *          * This is implemented in the callers, where they modify the 'nonagle'          * argument based upon the location of SKB in the send queue.          */         if (nonagle & TCP_NAGLE_PUSH)  // 设置了这个标识是因为说明可能是第一个包或者第二个包，或者其他一些允许的原因呢                 return 1;              // Nagle允许直接发送包出去          /* Don't use the nagle rule for urgent data (or for the final FIN).          * Nagle can be ignored during F-RTO too (see RFC4138).          */         if (tp->urg_mode || (tp->frto_counter == 2) || // 注意对于紧急数据来说不可以使用Nagle规则！上面说过Nagle是缓存处理数据，紧急数据不可以！             (TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN)) // 注意结束包(FIN)和F-RTO标识包都需要立马发送出去                 return 1;          if (!tcp_nagle_check(tp, skb, cur_mss, nonagle))  // 在Nagle算法下，是否允许发送这个包？返回0则允许立刻发送                 return 1;          return 0;}

tcp_nagle_check函数：

/* Return 0, if packet can be sent now without violation Nagle's rules:   Nagle算法允许下面条件的包可以正常发送 * 1. It is full sized.                                       // 大小等于MSS，即缓存满，或者是大包 * 2. Or it contains FIN. (already checked by caller)         // 是结束包FIN * 3. Or TCP_NODELAY was set.                                 // 不允许延迟的包 * 4. Or TCP_CORK is not set, and all sent packets are ACKed. // TCP_CORK没有设置 *    With Minshall's modification: all sent small packets are ACKed. */static inline int tcp_nagle_check(const struct tcp_sock *tp,                                  const struct sk_buff *skb,                                   unsigned mss_now, int nonagle){         return (skb->len < mss_now &&                // 检查在Nagle算法情况下，是不是可以发送这个包                 ((nonagle & TCP_NAGLE_CORK) ||       // 满足上面四个条件就OK                  (!nonagle && tp->packets_out && tcp_minshall_check(tp))));}

tcp_cwnd_test函数用于测试在当前的拥塞窗口情况下，最多还可以发送几个新数据

/* Can at least one segment of SKB be sent right now, according to the * congestion window rules?  If so, return how many segments are allowed. */static inline unsigned int tcp_cwnd_test(struct tcp_sock *tp,    // 根据当前的拥塞窗口，返回当前还可以发送几个segs                                          struct sk_buff *skb){         u32 in_flight, cwnd;          /* Don't be strict about the congestion window for the final FIN.  */         if ((TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN) &&   // 如果是最后的FIN包             tcp_skb_pcount(skb) == 1)                 return 1;                   // 返回一个OK          in_flight = tcp_packets_in_flight(tp);  // 获得还在传输中的包         cwnd = tp->snd_cwnd;                    // 获得当前窗口大小         if (in_flight < cwnd)                   //                  return (cwnd - in_flight);      // 剩下的部分都是可以发送的          return 0;}

主要是用于测试最后一个数据是不是在窗口内，在则可以发送，不在则不可以发送

/* Does at least the first segment of SKB fit into the send window? */static inline int tcp_snd_wnd_test(struct tcp_sock *tp, struct sk_buff *skb,                                    unsigned int cur_mss){         u32 end_seq = TCP_SKB_CB(skb)->end_seq;          if (skb->len > cur_mss)   // skb数据长度比MSS长                 end_seq = TCP_SKB_CB(skb)->seq + cur_mss;  // 最后一个seq          return !after(end_seq, tcp_wnd_end(tp));  // 最后一个seq是不是在窗口内，不在则不可以发送}

至于这个具体的传输函数tcp_retransmit_skb，在这篇中可以看到：

转载地址：http://paaci.baihongyu.com/