1、滑动窗口

滑动窗口是发送方根据接收方的接收窗口来控制发送速率的手段，接收发的滑动窗口可分成以下四个部分，最左边的紫色表示发送方已发送并且接收发已经确认的序列号，蓝色部分表示发送方已经发送但接收方还未确认的序列号，绿色部门表示发送方可发送但未发送的序列号（也表示接收方通知的接收窗口），蓝色和绿色两部分之和即为接收端通知的接收窗口，对应发送端的snd_wnd字段，最右边表示发送方不能发送的序列号。紫色区域最右边的值对应tcp的snd_una，蓝色最左侧对应tcp的snd_next；在数据包传输过程中，snd_una、snd_next一直在增加，整个窗口呈现出不断向右侧滑动的状态。

接收窗口发送：

接收端回复发送端时，在数据包发送流程，会根据当前接收socket内存信息获取一个接收窗口，填充到tcp头的window字段；

static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,gfp_t gfp_mask)
{...tcp_options_write((__be32 *)(th + 1), tp, &opts);skb_shinfo(skb)->gso_type = sk->sk_gso_type;if (likely(!(tcb->tcp_flags & TCPHDR_SYN))) {th->window      = htons(tcp_select_window(sk));tcp_ecn_send(sk, skb, th, tcp_header_size);} else {/* RFC1323: The window in SYN & SYN/ACK segments* is never scaled.*/th->window    = htons(min(tp->rcv_wnd, 65535U));}
}

接收端更新窗口时机：

发送端会将接收端的接收窗口记录在tcp的snd_wnd里，主要有两个时机更新：

1）、tcp建联时

tcp服务端在收到第三次握手时，记录接收端的窗口；

int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
{...switch (sk->sk_state) {case TCP_SYN_RECV:if (!acceptable)return 1;if (!tp->srtt_us)tcp_synack_rtt_meas(sk, req);/* Once we leave TCP_SYN_RECV, we no longer need req* so release it.*/if (req) {inet_csk(sk)->icsk_retransmits = 0;reqsk_fastopen_remove(sk, req, false);} else {/* Make sure socket is routed, for correct metrics. */icsk->icsk_af_ops->rebuild_header(sk);tcp_init_congestion_control(sk);tcp_mtup_init(sk);tp->copied_seq = tp->rcv_nxt;tcp_init_buffer_space(sk);}smp_mb();tcp_set_state(sk, TCP_ESTABLISHED);sk->sk_state_change(sk);/* Note, that this wakeup is only for marginal crossed SYN case.* Passively open sockets are not waked up, because* sk->sk_sleep == NULL and sk->sk_socket == NULL.*/if (sk->sk_socket)sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);tp->snd_una = TCP_SKB_CB(skb)->ack_seq;tp->snd_wnd = ntohs(th->window) << tp->rx_opt.snd_wscale;tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);if (tp->rx_opt.tstamp_ok)tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;if (req) {/* Re-arm the timer because data may have been sent out.* This is similar to the regular data transmission case* when new data has just been ack'ed.** (TFO) - we could try to be more aggressive and* retransmitting any data sooner based on when they* are sent out.*/tcp_rearm_rto(sk);} elsetcp_init_metrics(sk);if (!inet_csk(sk)->icsk_ca_ops->cong_control)tcp_update_pacing_rate(sk);/* Prevent spurious tcp_cwnd_restart() on first data packet */tp->lsndtime = tcp_time_stamp;tcp_initialize_rcv_mss(sk);tcp_fast_path_on(tp);break;}...
}

2）、tcp接收慢路径

static int tcp_ack_update_window(struct sock *sk, const struct sk_buff *skb, u32 ack,u32 ack_seq)
{struct tcp_sock *tp = tcp_sk(sk);int flag = 0;u32 nwin = ntohs(tcp_hdr(skb)->window);if (likely(!tcp_hdr(skb)->syn))nwin <<= tp->rx_opt.snd_wscale;//ack表示接收端本次确认的序列号，ack_seq表示接收方发送本次ack数据包所使用的序列号//如果://1、接收方本次有新确认的数据包//2、发送发所使用的序列号比上次更新接收窗口时使用的序列号大//3、发送发使用的序列号与上次更新窗口时使用的序列号相同，但接收窗口值变大(发送方重传?,并且重传数据包通知的接收窗口变大)if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {flag |= FLAG_WIN_UPDATE;tcp_update_wl(tp, ack_seq);if (tp->snd_wnd != nwin) {tp->snd_wnd = nwin;/* Note, it is the only place, where* fast path is recovered for sending TCP.*/tp->pred_flags = 0;tcp_fast_path_check(sk);if (nwin > tp->max_window) {tp->max_window = nwin;tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);}}}tcp_snd_una_update(tp, ack);return flag;
}

发送方的流量控制

当发送方需要发送数据包时，会检验当前接收方是否有足够的接收窗口，从这里的流程看，发送方会校验接收方至少要有1个接收窗口才能正常发送，当接收端没有足够的接收窗口时，发送端会暂停发送，从这里也可以看出，发送窗口(snd_wnd)主要是用于流量控制，防止接收端的接收速率跟不上发送端的发送速率。

static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,int push_one, gfp_t gfp)
{...max_segs = tcp_tso_segs(sk, mss_now);//从下一个要发送的数据开始遍历while ((skb = tcp_send_head(sk))) {...if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now))) {is_rwnd_limited = true;break;}...}...
}static bool tcp_snd_wnd_test(const struct tcp_sock *tp,const struct sk_buff *skb,unsigned int cur_mss)
{u32 end_seq = TCP_SKB_CB(skb)->end_seq;if (skb->len > cur_mss)end_seq = TCP_SKB_CB(skb)->seq + cur_mss;return !after(end_seq, tcp_wnd_end(tp));
}

2、拥塞窗口（snd_cwnd）

拥塞窗口主要是用于控制数据包在链路上的传输，避免过多的数据包发送到链路上导致拥塞丢包，拥塞窗口对应tcp的snd_cwnd字段。拥塞控制算法主要就是根据链路的状态（传统拥塞算法主要是看丢包、乱序等，bbr算法主要是根据检测到的链路带宽及最小时延）调节拥塞窗口的大小，初始化时，会为每个tcp连接分配一个10的初始拥塞窗口。

void tcp_init_sock(struct sock *sk)
{.../* So many TCP implementations out there (incorrectly) count the* initial SYN frame in their delayed-ACK and congestion control* algorithms that we must have the following bandaid to talk* efficiently to them.  -DaveM*/tp->snd_cwnd = TCP_INIT_CWND;...
}

3、拥塞控制

拥塞控制算法主要包含几个流程：慢启动、拥塞避免、快恢复、快重传等状态；

慢启动流程 && 拥塞避免：

tcp为每个连接分配一个snd_ssthresh，当snd_cwnd小于snd_ssthresh时，每ack一个数据包，snd_cwnd就加1，此时的snd_cwnd呈现比较快速的增长阶段。

1）、snd_ssthresh初始化

snd_ssthresh会初始化一个0x7fffffff的值；

void tcp_init_sock(struct sock *sk)
{.../* See draft-stevens-tcpca-spec-01 for discussion of the* initialization of these values.*/tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;...
}

2）、snd_ssthresh更新

判断当snd_cwnd小于snd_ssthresh时，处于慢启动流程，由于snd_ssthresh初始化的值是一个很大的值，因此如果用snd_cwnd跟snd_ssthresh初始化比较，显然没有意义；当tcp正常ack数据时，会进入pkts_acked，最终调用cubic的处理函数bictcp_acked，在bictcp_acked里，判断当snd_cwnd小于snd_ssthresh，并且snd_cwnd大于16时就会将snd_ssthresh更新成当前的snd_cwnd；

static void bictcp_acked(struct sock *sk, const struct ack_sample *sample)
{const struct tcp_sock *tp = tcp_sk(sk);struct bictcp *ca = inet_csk_ca(sk);u32 delay;/* Some calls are for duplicates without timetamps */if (sample->rtt_us < 0)return;/* Discard delay samples right after fast recovery */if (ca->epoch_start && (s32)(tcp_time_stamp - ca->epoch_start) < HZ)return;delay = (sample->rtt_us << 3) / USEC_PER_MSEC;if (delay == 0)delay = 1;/* first time call or link delay decreases */if (ca->delay_min == 0 || ca->delay_min > delay)ca->delay_min = delay;/* hystart triggers when cwnd is larger than some threshold */if (hystart && tcp_in_slow_start(tp) &&tp->snd_cwnd >= hystart_low_window)hystart_update(sk, delay);
}

接收端在收到ack时，判断如果当前不处于快恢复或loss状态，并且数据正常ack，则进入tcp_cong_avoid流程，这里会根据当前snd_cwnd与snd_ssthresh的关系决定当前的snd_cwnd如何增长；

static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
{struct tcp_sock *tp = tcp_sk(sk);struct bictcp *ca = inet_csk_ca(sk);if (!tcp_is_cwnd_limited(sk))return;if (tp->snd_cwnd <= tp->snd_ssthresh) {if (hystart && after(ack, ca->end_seq))bictcp_hystart_reset(sk);//acked返回非0表示，增加完拥塞窗口后，拥塞窗口已经超过了阀值snd_ssthresh//正常慢启动流程，这里返回0，snd_cwnd += acked，每ack一个数据包，拥塞窗口加1acked = tcp_slow_start(tp, acked);if (!acked)return;}//到了这里说明已经完成慢启动，进入拥塞避免阶段//首先先计算一个阈值ca->cnt，表示ack多少个数据才增加一个拥塞窗口bictcp_update(ca, tp->snd_cwnd, acked);//更新拥塞窗口值tcp_cong_avoid_ai(tp, ca->cnt, acked);
}

快恢复状态：

当tcp数据包乱序时，接收端会回复重复的ack，当接收端收到可疑的ack或重复ack时，会调用tcp_fastretrans_alert修改当前的拥塞状态，在tcp_fastretrans_alert里会判断如果当前处于open状态，并且乱序包已经超过乱序阀值，判断当前有数据包丢失，进入快恢复阶段，调用tcp_entry_recovery；

进入快恢复状态，cubic首先将snd_ssthresh降为当前拥塞窗口的717/1024倍，然后将拥塞窗口降为当前网络上的数据包个数（tcp_packets_in_flight + 1），然后重新进入慢启动流程；

void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int flag)
{struct tcp_sock *tp = tcp_sk(sk);int sndcnt = 0;int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))return;tp->prr_delivered += newly_acked_sacked;if (delta < 0) {u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +tp->prior_cwnd - 1;sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;} else if ((flag & FLAG_RETRANS_DATA_ACKED) &&!(flag & FLAG_LOST_RETRANS)) {sndcnt = min_t(int, delta,max_t(int, tp->prr_delivered - tp->prr_out,newly_acked_sacked) + 1);} else {sndcnt = min(delta, newly_acked_sacked);}/* Force a fast retransmit upon entering fast recovery */sndcnt = max(sndcnt, (tp->prr_out ? 0 : 1));tp->snd_cwnd = tcp_packets_in_flight(tp) + sndcnt;
}

快恢复状态退出：

在进入快恢复阶段时，tcp会保存当时的snd_next到high_seq，每次ack时，tcp判断当前处于非open状态都会进入tcp_fastretrans_alert，在tcp_fastretrans_alert里，判断如果snd_uan大于high_seq，那说明之前未ack的数据现在都已经ack了，已经没有数据空洞了，此时可以退出快恢复，重新回到open状态；

static void tcp_fastretrans_alert(struct sock *sk, const int acked,const int prior_unsacked,bool is_dupack, int flag)
{.../* D. Check state exit conditions. State can be terminated*    when high_seq is ACKed. */if (icsk->icsk_ca_state == TCP_CA_Open) {WARN_ON(tp->retrans_out != 0);tp->retrans_stamp = 0;} else if (!before(tp->snd_una, tp->high_seq)) {  /* high_seq表示进入快恢复状态时的snd_next值，如果snd_una比high_seq大那说明已经有新数据得到ack了，因此以下流程判断是否可以退出快恢复状态*/switch (icsk->icsk_ca_state) {case TCP_CA_CWR:/* CWR is to be held something *above* high_seq* is ACKed for CWR bit to reach receiver. */if (tp->snd_una != tp->high_seq) {tcp_end_cwnd_reduction(sk);tcp_set_ca_state(sk, TCP_CA_Open);}break;case TCP_CA_Recovery:if (tcp_is_reno(tp))tcp_reset_reno_sack(tp);if (tcp_try_undo_recovery(sk))return;tcp_end_cwnd_reduction(sk);break;}}...
}

当tcp退出快恢复状态时，snd_cwnd、snd_ssthresh从当前值与进入快恢复时的值两者间取更大的那个作为回到open状态时的snd_cwnd和snd_ssthresh；

static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
{struct tcp_sock *tp = tcp_sk(sk);if (unmark_loss) {struct sk_buff *skb;tcp_for_write_queue(skb, sk) {if (skb == tcp_send_head(sk))break;TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;}tp->lost_out = 0;tcp_clear_all_retrans_hints(tp);}if (tp->prior_ssthresh) {const struct inet_connection_sock *icsk = inet_csk(sk);if (icsk->icsk_ca_ops->undo_cwnd)//设置退出快恢复状态的cwndtp->snd_cwnd = icsk->icsk_ca_ops->undo_cwnd(sk);elsetp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh << 1);//设置退出快恢复状态的snd_ssthreshif (tp->prior_ssthresh > tp->snd_ssthresh) {tp->snd_ssthresh = tp->prior_ssthresh;TCP_ECN_withdraw_cwr(tp);}} else {tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh);}tp->snd_cwnd_stamp = tcp_time_stamp;tp->undo_marker = 0;
}

上图的icsk->icsk_ca_ops->undo_cwnd最终会调用到bictcp_undo_cwnd里；

static u32 bictcp_undo_cwnd(struct sock *sk)
{struct bictcp *ca = inet_csk_ca(sk);//退出loss或recovery时，snd_cwnd取当前snd_cwnd与进入loss或recovery时的snd_cwnd的最大值return max(tcp_sk(sk)->snd_cwnd, ca->loss_cwnd);
}

快重传：

针对不同的拥塞算法，快重传的条件也不一样：

1）、reno

收到3个重复的ack；

static void tcp_fastretrans_alert(struct sock *sk, const int acked,const int prior_unsacked,bool is_dupack, int flag)
{.../* E. Process state. */switch (icsk->icsk_ca_state) {case TCP_CA_Recovery:if (!(flag & FLAG_SND_UNA_ADVANCED)) {if (tcp_is_reno(tp) && is_dupack)tcp_add_reno_sack(sk);} else {if (tcp_try_undo_partial(sk, acked, prior_unsacked))return;/* Partial ACK arrived. Force fast retransmit. */do_lost = tcp_is_reno(tp) ||tcp_fackets_out(tp) > tp->reordering;}if (tcp_try_undo_dsack(sk)) {tcp_try_keep_open(sk);return;}break;case TCP_CA_Loss:tcp_process_loss(sk, flag, is_dupack);if (icsk->icsk_ca_state != TCP_CA_Open)return;/* Fall through to processing in Open state. */default:if (tcp_is_reno(tp)) {if (flag & FLAG_SND_UNA_ADVANCED)tcp_reset_reno_sack(tp);if (is_dupack)//reno算法时，每收到一个重复ack，sack_out加1，直到//sack_out到达乱序阀值3时，触发重传tcp_add_reno_sack(sk);}...
}

验证过程：

通过packetdrill构造数据报文，同时结合ss命令查看：

关闭rack： echo 0 > /proc/sys/net/ipv4/tcp_recovery；

关闭fack： echo 0 >/proc/sys/net/ipv4/tcp_fack；

关闭sack： echo 0 > /proc/sys/net/ipv4/tcp_sack；

packetdrill脚本：

// Test fast retransmit with 4 packets outstanding, receiver sending SACKs.
// In this variant the receiver supports SACK.// Establish a connection.
0   socket(..., SOCK_STREAM, IPPROTO_TCP) = 3
+0  setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0+0  bind(3, ..., ...) = 0
+0  listen(3, 1) = 0+0  < S 0:0(0) win 32792 <mss 1000,sackOK,nop,nop,nop,wscale 7>
+0  > S. 0:0(0) ack 1 <...>+.1 < . 1:1(0) ack 1 win 257
+0  accept(3, ..., ...) = 4// Send 1 data segment and get an ACK, so cwnd is now 4.
+0  write(4, ..., 1000) = 1000
+0  > P. 1:1001(1000) ack 1+.1 < . 1:1(0) ack 1001 win 257// Write 10 data segments.
+0  write(4, ..., 10000) = 10000
+0  > P. 1001:10001(9000) ack 1//连续收到3个重复ack
+.1 < . 1:1(0) ack 1001 win 257 <sack 3001:4001,nop,nop>
+.1 < . 1:1(0) ack 1001 win 257 <sack 4001:5001,nop,nop>
+.1 < . 1:1(0) ack 1001 win 257 <sack 5001:6001,nop,nop>//重传1001:2001数据包
+.0  > . 1001:2001(1000) ack 1// Receiver ACKs all data.
//所有消息包都ack，关闭socket连接
+1 < . 1:1(0) ack 10001 win 257

每隔一小段时间，捕获一次ss状态，从ss的状态显示看，当重复ack个数未满3个时，tcp保持在乱序状态（1---open），当收到第3个重复ack时，tcp状态为快恢复状态，并对第一个未ack的数据包标记loss，然后重传；

2）、sack

当sack的个数大于等于乱序阀值（默认3）时，tcp就会开始标记loss状态，标记的时候，从write队列最开始的skb开始标记，直至被标记loss的skb的右侧的sack个数为3为止。如下所示，一共发送10个skb，其中第4、7、9、10四个包被sack，那tcp计算此时fack_out=10，sack_out=4，loss_out=5；

3）、fack

echo 1 >/proc/sys/net/ipv4/tcp_fack启用fack

fack是sack的更进一步优化，当使用fack时，sack的数据包个数不再需要超过乱序阀值，fack只关心收到的最大的sack数据包相比snd_una的间距是否超过乱序阀值，当超过时就会开始标记loss，fack标记loss时，从write队列最左侧开始标记，直至待标记的skb距离最大sack的skb的间距为reordering-1为止；

如下，发送10个skb，其中第4、9个skb被sack，那此时fack_out=9，loss_out=5；

4）、rack

echo 1 > /proc/sys/net/ipv4/tcp_recovery启用rack；

rack相比fack又更进一步，rack是根据skb的发送时间来判断消息包是否丢失，tcp每发送一个skb时，都会为其分配一个时间戳信息，当sack时，rack机制判断那些在被sack的数据包之前发送的，并且相比被sack的数据包的时间间距到达一定间隔时，就判断该数据包为丢失，进而进入快恢复状态，然后重传被标记丢失的数据包。

tcp发送数据包时，设置当前的发送时间：

static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,gfp_t gfp_mask)
{...if (clone_it) {//标记数据包发送时间skb_mstamp_get(&skb->skb_mstamp);TCP_SKB_CB(skb)->tx.in_flight = TCP_SKB_CB(skb)->end_seq- tp->snd_una;tcp_rate_skb_sent(sk, skb);if (unlikely(skb_cloned(skb)))skb = pskb_copy(skb, gfp_mask);elseskb = skb_clone(skb, gfp_mask);if (unlikely(!skb))return -ENOBUFS;}...
}

当发送端收到sack报文时，开始标记sack标记时，进入rack更新流程：

static u8 tcp_sacktag_one(struct sock *sk,struct tcp_sacktag_state *state, u8 sacked,u32 start_seq, u32 end_seq,int dup_sack, int pcount,const struct skb_mstamp *xmit_time)
{...if (!(sacked & TCPCB_SACKED_ACKED)) {tcp_rack_advance(tp, sacked, end_seq, xmit_time);...
}

rack更新流程主要是记录当前最新的sack数据包的发送时间及序列号等信息：

/*当接收端收到sack时，进入该函数，记录被sack的消息包的发送时间及序列号*/
void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 end_seq,const struct skb_mstamp *xmit_time)
{u32 rtt_us;//如果skb比上一次标记rack的skb的发送时间更早，或者序列号更小，则不处理if (tp->rack.mstamp.v64 &&!tcp_rack_sent_after(xmit_time, &tp->rack.mstamp,end_seq, tp->rack.end_seq))return;rtt_us = skb_mstamp_us_delta(&tp->tcp_mstamp, xmit_time);if (sacked & TCPCB_RETRANS) {/* If the sacked packet was retransmitted, it's ambiguous* whether the retransmission or the original (or the prior* retransmission) was sacked.** If the original is lost, there is no ambiguity. Otherwise* we assume the original can be delayed up to aRTT + min_rtt.* the aRTT term is bounded by the fast recovery or timeout,* so it's at least one RTT (i.e., retransmission is at least* an RTT later).*/if (rtt_us < tcp_min_rtt(tp))return;}//设置sack数据包的发送时间及序列号信息tp->rack.rtt_us = rtt_us;tp->rack.mstamp = *xmit_time;tp->rack.end_seq = end_seq;tp->rack.advanced = 1;
}

在tcp_fastretrans_alert流程判断如果有开启rack，则进入rack标记loss的流程：tcp_rack_identify_loss；

如果有开启rack，则根据sack数据包的时间戳判断未sack的数据包是否丢包，在标记loss流程里会更新tp->lost_out计数，等回到tcp_fastretrans_alert里，函数tcp_time_to_recover判断lost_out非零，则进入recovery状态。如果没有需要标记loss的数据包，则根据剩余时间启动定时器，定时器超时，重新检测。

static void tcp_rack_detect_loss(struct sock *sk, u32 *reo_timeout)
{struct tcp_sock *tp = tcp_sk(sk);struct sk_buff *skb;u32 reo_wnd;*reo_timeout = 0;/* To be more reordering resilient, allow min_rtt/4 settling delay* (lower-bounded to 1000uS). We use min_rtt instead of the smoothed* RTT because reordering is often a path property and less related* to queuing or delayed ACKs.*/reo_wnd = 1000;if ((tp->rack.reord || !tp->lost_out) && tcp_min_rtt(tp) != ~0U)reo_wnd = max(tcp_min_rtt(tp) >> 2, reo_wnd);tcp_for_write_queue(skb, sk) {struct tcp_skb_cb *scb = TCP_SKB_CB(skb);if (skb == tcp_send_head(sk))break;/* Skip ones already (s)acked */if (!after(scb->end_seq, tp->snd_una) ||scb->sacked & TCPCB_SACKED_ACKED)continue;//tp->rack.mstamp表示sack的包的发送时间，tp->rack.end_seq表示sack数据包的序列号//如果skb比被sack的数据的发送时间更早，或者序列号更小，那说明有可能这个skb是丢了if (tcp_rack_sent_after(&tp->rack.mstamp, &skb->skb_mstamp,tp->rack.end_seq, scb->end_seq)) {/* Step 3 in draft-cheng-tcpm-rack-00.txt:* A packet is lost if its elapsed time is beyond* the recent RTT plus the reordering window.*///tp->tcp_mstamp为最新ack(sack)的发送时间//计算skb从发送到现在的时间距离u32 elapsed = skb_mstamp_us_delta(&tp->tcp_mstamp,&skb->skb_mstamp);//如果后发送的skb已经被sack，旧的还没有sack，并且时间超过rtt+窗口阀值//则认为之前的包已经丢失，rack对其标记loss//tp->rack.rtt_us表示sack的数据包的发送到现在的时间距离//这个remaining的意思是，如果sack的数据包与比它更早发送出去但还未被sack的数据包//的时间间隔超过1000us与1/4 rtt两个时间相对大的那个，那说明还未被sack的数据包可能是已经丢了，标记losss32 remaining = tp->rack.rtt_us + reo_wnd - elapsed;if (remaining < 0) {tcp_rack_mark_skb_lost(sk, skb);continue;}/* Skip ones marked lost but not yet retransmitted */if ((scb->sacked & TCPCB_LOST) &&!(scb->sacked & TCPCB_SACKED_RETRANS))continue;//如果时间还未超时，则启动超时定时器，如果定时器超时，则超时处理函数又进入tcp_rack_detect_loss重新检测/* Record maximum wait time (+1 to avoid 0) */*reo_timeout = max_t(u32, *reo_timeout, 1 + remaining);} else if (!(scb->sacked & TCPCB_RETRANS)) {/* Original data are sent sequentially so stop early* b/c the rest are all sent after rack_sent*/break;}}
}

验证过程：

开启rack： echo 1 >/proc/sys/net/ipv4/tcp_recovery；

先发送一个数据包，然后延时一定时间再发送第二个数据包；然后packetdrill构造直接sack第二个数据包；此时ss可以看到发送端标记了一个loss，并且进入了recovery状态，说明这个loss并非rto超时标记的，而是rack标记的。