我们发送重传包时，重传包也可能丢失，如果没有检查重传包是否丢失的机制，那么只能依靠超时来恢复了。
37版本把检查重传包是否丢失的部分独立出来，这就是tcp_mark_lost_retrans()。
在处理SACK块的同时，会检测是否有出现乱序，如果有乱序，那么会计算乱序的长度并更新。
本文主要内容：检查重传包是否丢失，以及乱序的检测和更新。
Author：zhangskd @ ****
检查重传包是否丢失
tcp_mark_lost_retrans()用于检查重传的包是否丢失，2.6.22内核在检查重传包是否丢失时是有Bug的，
具体可见：http://projects.itri.aist.go.jp/gnet/sack-bug.html
Q: 怎么检查重传包是否丢失呢？
A: 我们知道，要发送数据时，是先发送重传包，之后才发送新包的。
如果重传包顺利到达接收端，当新包到达时，服务器端会收到一个对新包的正常确认。
如果重传包丢失了，当新包到达时，服务器端会收到一个对新包的选择性确认。
基于这个事实：
当重传一个包时，我们记录当时要发送的下一新包的序列号(当时的tp->snd_nxt)。
当我们收到SACK时，就检查新包是被正常ACK，还是被SACK。如果新包被SACK，
但是重传包还没有，就说明当时重传的包已经丢失了。
重传一个包时，会记录当时要发送的下一个新包的序号，即tp->snd_nxt。
int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
{
... /* 如果之前网络中没有重传包 */
if (! tp->retrans_out)
tp->lost_retrans_low = tp->snd_nxt; TCP_SKB_CB(skb)->sacked |= TCPCB_RETRANS; /* 打上R标记 */
tp->retrans_out += tcp_skb_pcount(skb); /* 更新retrans_out */ /* Save stamp of the first retransmit. */
if (! tp->retrans_stamp)
tp->retrans_stamp = TCP_SKB_CB(skb)->when; tp->undo_retrans++; /* snd_nxt is stored to detect loss of retransmitted segment,
* see tcp_input.c tcp_sacktag_write_queue().
* 就是在这里！把这时的snd_nxt保存到重传包的ack_seq。
*/
TCP_SKB_CB(skb)->ack_seq = tp->snd_nxt; ...
}
检查重传包是否丢失，如果丢失了，重新打L标志。
/* Check for lost retransmit. */
static void tcp_mark_lost_retrans(struct sock *sk)
{
const struct inet_connection_sock *icsk = inet_csk(sk);
struct tcp_sock *tp = tcp_sk(sk);
struct sk_buff *skb;
int cnt = 0;
u32 new_low_seq = tp->snd_nxt; /* 下一个要发送的新包序列号 */
u32 received_upto = tcp_highest_sack_seq(tp); /* 被SACK过的最大序列号 */ /* 使用这个方法的条件：
* 使用FACK；有重传包；上次的最低snd_nxt被SACK；处于Recovery状态
*/
if (! tcp_is_fack(tp) || ! tp->retrans_out || ! after(received_upto, tp->lost_retrans_low)
|| icsk->icsk_ca_state != TCP_CA_Recovery)
return; tcp_for_write_queue(skb, sk) {
/* 注意了：对于重传包来说，ack_seq其实是当时的snd_nxt */
u32 ack_seq = TCP_SKB_CB(skb)->ack_seq; if (skb == tcp_send_head(sk)) /* 发送队列头了 */
break; /* 我们关注的是重传的包，如果遍历完了，就退出 */
if (cnt == tp->retrans_out)
break; /* 不关心成功确认过的包 */
if (! after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
continue; /* 只关注重传包，必须有R标志才处理 */
if (! (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS))
continue; /*
* 如果重传包记录的snd_nxt被SACK了，那说明重传包丢了；否则应该在新包之前被确认才对。
*/
if (after(received_upto, ack_seq)) {
TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS; /* 取消R标志 */
tp->retrans_out -= tcp_skb_pcount(skb); /* 更新网络中重传包数量 */
tcp_skb_mark_lost_uncond_verify(tp, skb); /* 给重传包打上LOST标志，并更新相关变量 */
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPLOSTRETRANSMIT); } else { /* 如果重传包对应的snd_nxt在最高SACK序列号之后 */
if (before(ack_seq, new_low_seq))
new_low_seq = ack_seq; /* 更新未检测的重传包对应的最小snd_nxt */
cnt += tcp_skb_pcount(skb); /* 用于判断重传包是否检查完了 */
}
} /* 如果还有未检查完的重传包，那么更新未检测的重传包对应的最小snd_nxt */
if (tp->retrans_out)
tp->lost_retrans_low = new_low_seq; }
给数据包打上LOST标志，更新相关变量。
static void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb)
{
/* 更新重传过的包的最低、最高序号 */
tcp_verfiy_retransmit_hint(tp, skb); /* 如果这个包还未打上L标志，且没有S标志 */
if (! (TCP_SKB_CB(skb)->sacked & (TCP_LOST | TCPCB_SACKED_ACKED))) {
tp->lost_out += tcp_skb_pcount(skb); /* 更新网络中丢失包数量 */
TCP_SKB_CB(skb)->sacked |= TCPCB_LOST; /* 打上L标志 */
}
} /* This must be called before lost_out is incremented
* 记录重传过的包的最低序号、最高序号。
*/
static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
{
if ((tp->retransmit_skb_hint == NULL) || before(TCP_SKB_CB(skb)->seq,
TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
tp->retransmit_skb_hint = skb; if (! tp->lost_out || after(TCP_SKB_CB(skb)->end_seq, tp->retransmit_high))
tp->retransmit_high = TCP_SKB_CB(skb)->end_seq;
}
乱序处理
说明
Reordering metric is maximal distance, which a packet can be displaced in packet stream.
With SACKs we can estimate it:
1. SACK fills old hole and the corresponding segment was not ever retransmitted -> reordering.
Alas, we cannot use it when segment was retransmitted.
2. The last flaw it solved with D-SACK. D-SACK arrives for retransmitted and already SACKed segment
-> reordering..
Both of these heuristics are not used in Loss state, when we cannot account for retransmits accurately.
对于乱序，我们主要关注如何检测乱序，以及计算乱序的长度。
在tcp_sacktag_one()中有进行乱序的检测，那么在收到SACK或DSACK时怎么判断有乱序呢？
（1）skb的记分牌为S|R，然后它被DSACK。
我们想象一下，一个数据包乱序了，它滞留在网络的某个角落里。我们收到后续包的SACK，认为这个包丢失了，
进行重传。之后原始包到达接收端了，这个数据包被SACK了。最后重传包也到达接收端了，这个包被DSACK了。
（2）如果一个包落在highest_sack之前，它既没被SACK过，也不是重传的，那么它肯定是乱序了，到现在才被SACK。
如果检测到了乱序，那么乱序队列的长队为：tp->fackets_out - state.reord。
static void tcp_update_reordering(struct sock *sk, const int metric,
const int ts)
{
struct tcp_sock *tp = tcp_sk(sk); if (metric > tp->reordering) {
int mib_idx;
/* 更新reordering的值，取其小者*/
tp->reordering = min(TCP_MAX_REORDERING, metric); if (ts)
mib_idx = LINUX_MIB_TCPTSREORDER;
else if (tcp_is_reno(tp))
mib_idx = LINUX_MIB_TCPRENOREORDER;
else if (tcp_is_fack(tp))
mib_idx = LINUX_MIB_TCPFACKREORDER;
else
mib_idx = LINUX_MIB_TCPSACKREORDER; NET_INC_STATS_BH(sock_net(sk), mib_idx);
#if FASTRETRANS_DEBUG > 1
printk(KERN_DEBUG "Disorder%d %d %u f%u s%u rr%d\n",
tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
tp->reordering, tp->fackets_out, tp->sacked_out,
tp->undo_marker ? tp->undo_retrans : 0);
#endif
tcp_disable_fack(tp); /* 出现了reorder，再用fack就太激进了*/
}
}
/* Packet counting of FACK is based on in-order assumptions, therefore
* TCP disables it when reordering is detected.
*/
static void tcp_disable_fack(struct tcp_sock *tp)
{
/* RFC3517 uses different metric in lost marker => reset on change */
if (tcp_is_fack(tp))
tp->lost_skb_hint = NULL;
tp->rx_opt.sack_ok &= ~2; /* 取消FACK选项*/
}