内核tcp的ack的处理

我们来看tcp输入对于ack，段的处理。 

先是ack的处理，在内核中，处理ack段是通过tcp_ack来进行的。 

这个函数主要功能是： 

1 update重传队列，并基于sack来设置skb的相关buf。 

2 update发送窗口。 

3 基于sack的信息或者重复ack来决定是否进入拥塞模式。 


在看之前我们要知道tcp是累积确认的。为了解决带来的缺点，我们才需要sack的。 

然后我们来看几个很重要的数据结构，先是tcp_skb_cb，它其实就是表示skb中所保存的tcp的控制信息。而他是保存在skb的cb中的(这个域可以看我前面的blog）。所以这里我们经常会用TCP_SKB_CB来存取这个结构。 

Java代码  

1. #define TCP_SKB_CB(__skb)   ((struct tcp_skb_cb *)&((__skb)->cb[0]))  

这里还有一个inet_skb_parm，这个结构保存了ipoption的一些信息。 

Java代码  

1. struct inet_skb_parm  
2. {  
3.     struct ip_options   opt;        /* Compiled IP options      */  
4.     unsigned char       flags;  
5.   
6. #define IPSKB_FORWARDED     1  
7. #define IPSKB_XFRM_TUNNEL_SIZE  2  
8. #define IPSKB_XFRM_TRANSFORMED  4  
9. #define IPSKB_FRAG_COMPLETE 8  
10. #define IPSKB_REROUTED      16  
11. };  

然后来看tcp_skb_cb： 

Java代码  

1. struct tcp_skb_cb {  
2.     union {  
3.         struct inet_skb_parm    h4;  
4. #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)  
5.         struct inet6_skb_parm   h6;  
6. #endif  
7.     } header;   /* For incoming frames      */  
8. //这个表示当前tcp包的序列号  
9.     __u32       seq;  
10. //这个表示结束序列号，也就是SEQ + FIN + SYN + datalen。         
11.     __u32       end_seq;  
12. ///主要用来计算rtt      
13.     __u32       when;  
14. //tcp头的flag（比如syn，fin等)，它能取的值，我们下面会介绍。        
15.     __u8        flags;        
16.   
17. //SACK/FACK的状态flag或者是sack option的偏移(相对于tcp头的)。我们下面会介绍  
18.     __u8        sacked;   
19. //ack的序列号。  
20.     __u32       ack_seq;      
21. };  

下面就是flags所能取的值，可以看到也就是tcp头的控制位。 

Java代码  

1. #define TCPCB_FLAG_FIN      0x01  
2. #define TCPCB_FLAG_SYN      0x02  
3. #define TCPCB_FLAG_RST      0x04  
4. #define TCPCB_FLAG_PSH      0x08  
5. #define TCPCB_FLAG_ACK      0x10  
6. #define TCPCB_FLAG_URG      0x20  
7. #define TCPCB_FLAG_ECE      0x40  
8. #define TCPCB_FLAG_CWR      0x80  

然后是sack/fack的状态标记： 

Java代码  

1. //有这个域说明当前的tcpcb是被sack块确认的。  
2. #define TCPCB_SACKED_ACKED  0x01  
3. //表示重传的帧      
4. #define TCPCB_SACKED_RETRANS    0x02  
5. //丢失  
6. #define TCPCB_LOST      0x04      
7. #define TCPCB_TAGBITS       0x07      
8. //重传的帧。  
9. #define TCPCB_EVER_RETRANS  0x80      
10. #define TCPCB_RETRANS       (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)  

这里要注意，当我们接收到正确的SACK后，这个域就会被初始化为sack所在的相对偏移(也就是相对于tcp头的偏移值，这样我们就能很容易得到sack option的位置). 


然后是tcp_sock，这个结构保存了我们整个tcp层所需要得所有必要的信息（也就是从sock中提取出来).我们分两个部分来看这个结构，这里只看我们关注的两部分，第一部分是窗口相关的一些域。第二部分是拥塞控制的一些相关域。 

先来看窗口相关的： 

Java代码  

1. //我们期待从另一台设备接收的下一个数据字节的序列号。  
2.         u32 rcv_nxt;  
3. //还没有被读取的数据的序列号。  
4.     u32 copied_seq;  
5. //当最后一次窗口update被发送之前我们的rcv_nxt.   
6.     u32 rcv_wup;  
7. //将要发送给另一台设备的下一个数据字节的序列号。     
8.     u32 snd_nxt;      
9. //已经发送但尚未被确认的第一个数据字节的序列号。  
10.     u32 snd_una;  
11. //  
12.     u32 snd_sml;  
13. //最后一次接收到ack的时间戳，主要用于keepalive    
14.     u32 rcv_tstamp;   
15. //最后一次发送数据包的时间戳。  
16.     u32 lsndtime;  
17. //发送窗口长度  
18.         u32 snd_wnd;  
19. //接收窗口长度。  
20.         u32 rcv_wnd   
21. //发送未确认的数据包的个数（或者字节数？）  
22.         u32 packets_out;  
23. //重传的数据包的个数   
24.     u32 retrans_out;      

然后是拥塞部分，看这里之前还是需要取熟悉一下tcp拥塞控制的相关概念。 

Java代码  

1.       
2. //慢开始的阀值，也就是超过这个我们就要进入拥塞避免的阶段  
3.        u32  snd_ssthresh;     
4. //发送的拥塞窗口  
5.     u32 snd_cwnd;  
6. //这个应该是拥塞状态下所发松的数据字节数     
7.     u32 snd_cwnd_cnt;     
8. //这里也就是cwnd的最大值  
9.     u32 snd_cwnd_clamp;  
10. //这两个值不太理解什么意思。  
11.     u32 snd_cwnd_used;  
12.     u32 snd_cwnd_stamp;  
13.   
14. ///接收窗口打消  
15.     u32 rcv_wnd;  
16. //tcp的发送buf数据的尾部序列号。      
17.     u32 write_seq;  
18. //最后一次push的数据的序列号  
19.     u32 pushed_seq;  
20. //丢失的数据包字节数   
21.     u32 lost_out;  
22. //sack的数据包的字节数  
23.     u32 sacked_out;  
24. //fack处理的数据包的字节数      
25.     u32 fackets_out;      
26.     u32 tso_deferred;  
27. //计数  
28.     u32 bytes_acked;      

分析完相关的数据结构我们来看函数的实现。 

来看tcp_ack的代码,函数比较大，因此我们分段来看，先来看一开始的一些校验部分。 

这里有一个tcp_abc也就是proc下面的可以设置的东西，这个主要是看要不要每个ack都要进行拥塞控制。 

引用

Controls Appropriate Byte Count defined in RFC3465. If set to 0 then does congestion avoid once per ACK. 1 is conservative value, and 2 is more aggressive. The default value is 1.

Java代码  

1. struct inet_connection_sock *icsk = inet_csk(sk);  
2.     struct tcp_sock *tp = tcp_sk(sk);  
3. ///等待ack，也就是发送未确认的序列号。  
4.     u32 prior_snd_una = tp->snd_una;  
5.     u32 ack_seq = TCP_SKB_CB(skb)->seq;  
6. ///得到ack的序列号。  
7.     u32 ack = TCP_SKB_CB(skb)->ack_seq;  
8.     u32 prior_in_flight;  
9.     u32 prior_fackets;  
10.     int prior_packets;  
11.     int frto_cwnd = 0;  
12.   
13. ///如果ack的序列号小于发送未确认的，也就是说可能这个ack只是重传老的ack，因此我们忽略它。  
14.     if (before(ack, prior_snd_una))  
15.         goto old_ack;  
16.   
17. ///如果ack大于snd_nxt,也就是它确认了我们还没发送的数据段，因此我们discard这个段。  
18.     if (after(ack, tp->snd_nxt))  
19.         goto invalid_ack;  
20. //如果ack大于发送未确认，则设置flag  
21.     if (after(ack, prior_snd_una))  
22.         flag |= FLAG_SND_UNA_ADVANCED;  
23.   
24. //是否设置tcp_abc，有设置的话，说明我们不需要每个ack都要拥塞避免，因此我们需要计算已经ack的字节数。  
25.     if (sysctl_tcp_abc) {  
26.         if (icsk->icsk_ca_state < TCP_CA_CWR)  
27.         tp->bytes_acked += ack - prior_snd_una;  
28.         else if (icsk->icsk_ca_state == TCP_CA_Loss)  
29.          tp->bytes_acked += min(ack - prior_snd_una,q  
30.                        tp->mss_cache);  
31.     }  
32.   
33. ///得到fack的数据包的字节数  
34. prior_fackets = tp->fackets_out;  
35. //计算还在传输的数据段的字节数,下面会详细分析这个函数。  
36.     prior_in_flight = tcp_packets_in_flight(tp);  

packets_out这个表示已经发送还没有ack的数据段的字节数(这个值不会重复加的，比如重传的话不会增加这个值）。 

sakced_out :sack了的字节数。 

lost_out:丢失了的字节数。 

retrans_out:重传的字节数。 

现在我们就对这个函数的返回值很清楚了，它也就是包含了还没有到达对方的数据段的字节数。 

Java代码  

1. static inline unsigned int tcp_left_out(const struct tcp_sock *tp)  
2. {  
3.     return tp->sacked_out + tp->lost_out;  
4. }  
5.   
6. static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)  
7. {  
8.     return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;  
9. }  

接下来这一段主要是通过判断flag(slow还是fast)来进行一些窗口的操作。有关slow_path和fast_path的区别，可以看我前面的blog。 

fast_path的话很简单，我们就更新相关的域以及snd_wl1(这个域主要是用于update窗口的时候).它这里会被赋值为我们这次的数据包的序列号。然后进行拥塞控制的操作。 

snd_wl1是只要我们需要更新发送窗口的话，这个值是都会被更新的。 

slow_path的话，我们就需要判断要不要update窗口的大小了。以及是否要处理sack等。 

在看下面的代码之前，我们先来看传递进tcp_ack这个函数中的第三个参数flag，这里我们在函数中也还会修改这个值，这个flag也就是当前的skb的类型信息。看了注释后就清楚了。可疑看到好几个都是ack的类型。 

Java代码  

1. //这个说明当前的输入帧包含有数据。  
2. #define FLAG_DATA       0x01   
3. //这个说明当前的ack是一个窗口更新的ack  
4. #define FLAG_WIN_UPDATE     0x02   
5. //这个ack确认了一些数据  
6. #define FLAG_DATA_ACKED     0x04   
7. //这个表示ack确认了一些我们重传的段。  
8. #define FLAG_RETRANS_DATA_ACKED 0x08   
9. //这个表示这个ack是对syn的回复。  
10. #define FLAG_SYN_ACKED      0x10   
11. //新的sack  
12. #define FLAG_DATA_SACKED    0x20   
13. //ack中包含ECE  
14. #define FLAG_ECE        0x40   
15. //sack检测到了数据丢失。  
16. #define FLAG_DATA_LOST      0x80   
17. //当更新窗口的时候不跳过RFC的检测。  
18. #define FLAG_SLOWPATH       0x100   
19.   
20. #define FLAG_ONLY_ORIG_SACKED   0x200   
21. //snd_una被改变了。也就是更新了。  
22. #define FLAG_SND_UNA_ADVANCED   0x400   
23. //包含D-sack  
24. #define FLAG_DSACKING_ACK   0x800  
25. //这个不太理解什么意思。  
26. #define FLAG_NONHEAD_RETRANS_ACKED  0x1000  
27. //  
28. #define FLAG_SACK_RENEGING  0x2000   
29.   
30. //下面也就是一些组合。  
31. #define FLAG_ACKED  (FLAG_DATA_ACKED|FLAG_SYN_ACKED)  
32. #define FLAG_NOT_DUP (FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED)  
33. #define FLAG_CA_ALERT       (FLAG_DATA_SACKED|FLAG_ECE)  
34. #define FLAG_FORWARD_PROGRESS   (FLAG_ACKED|FLAG_DATA_SACKED)  
35. #define FLAG_ANY_PROGRESS   (FLAG_FORWARD_PROGRESS|FLAG_SND_UNA_ADVANCED)  

然后我们来看代码，下面的代码会设置flag，也就是用上面的宏。 

这里有一个很大的不同就是slow_path中，我们需要update窗口的大小，而在fast模式中，我们不需要，这个详细去看我前面的blog介绍的fast和slow的区别。fast就是最理想的情况，因此我们不需要update窗口。 

Java代码  

1. ///如果不是slowpath并且ack确实是正确的序列号(必须大于snd_una).  
2.     if (!(flag & FLAG_SLOWPATH) && after(ack, prior_snd_una)) {  
3. //更新snd_wl1域为ack_seq;  
4.         tcp_update_wl(tp, ack_seq);  
5. ///snd_una更新为ack也就是确认的序列号  
6.         tp->snd_una = ack;  
7. //更新flag域。  
8.         flag |= FLAG_WIN_UPDATE;  
9. //进入拥塞的操作。  
10.         tcp_ca_event(sk, CA_EVENT_FAST_ACK);  
11. ................................  
12.     } else {  
13. //这个判断主要是为了判断是否输入帧包含数据。也就是ack还包含了数据，如果有的话，我们设置标记然后后面会处理。  
14.         if (ack_seq != TCP_SKB_CB(skb)->end_seq)  
15.             flag |= FLAG_DATA;  
16.         else  
17. .....................................  
18.   
19. //然后进入更新窗口的操作。  
20.         flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);  
21. //然后判断是否有sack段，有的话，我们进入sack段的处理。  
22.         if (TCP_SKB_CB(skb)->sacked)  
23.             flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una);  
24. //判断是否有ecn标记，如果有的话，设置ecn标记。  
25.         if (TCP_ECN_rcv_ecn_echo(tp, tcp_hdr(skb)))  
26.             flag |= FLAG_ECE;  
27. //进入拥塞的处理。  
28.         tcp_ca_event(sk, CA_EVENT_SLOW_ACK);  
29.     }  

接下来这段主要工作是： 

1 清理重传队列中的已经ack的段。 

2 处理F-RTO。 

3 判断是否是零窗口探测的回复ack。 

4 检测是否要进入拥塞处理。 

Java代码  

1. sk->sk_err_soft = 0;  
2.     icsk->icsk_probes_out = 0;  
3.     tp->rcv_tstamp = tcp_time_stamp;  
4. ///如果发送并且没有ack的数据段的值为0,则说明这个有可能是0窗口探测的回复，因此我们进入no_queue的处理，这个我们紧接着会详细介绍。  
5.     prior_packets = tp->packets_out;  
6.     if (!prior_packets)  
7.         goto no_queue;  
8. ///清理重传队列中的已经ack的数据段。  
9.     flag |= tcp_clean_rtx_queue(sk, prior_fackets, prior_snd_una);  
10.   
11. ///处理F-RTO  
12.     if (tp->frto_counter)  
13.         frto_cwnd = tcp_process_frto(sk, flag);  
14.   
15.     if (before(tp->frto_highmark, tp->snd_una))  
16.         tp->frto_highmark = 0;  
17. //判断ack是否是可疑的。它主要是检测我们是否进入拥塞状态，或者已经处于拥塞状态。  
18.     if (tcp_ack_is_dubious(sk, flag)) {  
19. //检测flag以及是否需要update拥塞窗口的大小。  
20.         if ((flag & FLAG_DATA_ACKED) && !frto_cwnd &&  
21.             tcp_may_raise_cwnd(sk, flag))  
22. ///如果都为真，则更新拥塞窗口。  
23.             tcp_cong_avoid(sk, ack, prior_in_flight);  
24. ///这里进入拥塞状态的处理(这个函数是一个非常关键的函数,等到后面详细分析拥塞的时候，会分析到)。  
25.         tcp_fastretrans_alert(sk, prior_packets - tp->packets_out,flag);  
26.     } else {  
27. //这里可以看到和上面相比，没有tcp_may_raise_cwnd这个，我们紧接着就会分析到。  
28.         if ((flag & FLAG_DATA_ACKED) && !frto_cwnd)  
29.             tcp_cong_avoid(sk, ack, prior_in_flight);  
30.     }  
31. //是否更新neigh子系统。  
32.     if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))  
33.         dst_confirm(sk->sk_dst_cache);  
34.   
35.     return 1;  
36.   
37. no_queue:  
38. //这里判断发送缓冲区是否为空，如果不为空，则我们进入判断需要重启keepalive定时器还是关闭定时器  
39.     if (tcp_send_head(sk))  
40.         tcp_ack_probe(sk);  
41.     return 1;  

ok，，接着来看上面略过的几个函数，先来看tcp_ack_is_dubious，这里的条件我们一个个来看 

1 说明flag不能是 FLAG_NOT_DUP的， FLAG_NOT_DUP表示我们的ack不是重复的。 

2 是flag是CA_ALERT,它的意思是我们是否在我们进入拥塞状态时被alert。 

3 拥塞状态不能为TCP_CA_OPEN不为这个，就说明我们已经进入了拥塞状态。 

可以看下面这几个宏的定义，就比较清楚了。 

Java代码  

1. #define FLAG_ACKED  (FLAG_DATA_ACKED|FLAG_SYN_ACKED)  
2. #define FLAG_NOT_DUP (FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED)  
3.   
4. //收到sack则说明可能有的段丢失了。而ECE则是路由器提示我们有拥塞了。我们必须处理。  
5. #define FLAG_CA_ALERT       (FLAG_DATA_SACKED|FLAG_ECE)  

上面的任意一个为真。就说明ack是可疑的。这里起始也可以说我们就必须进入拥塞的处理了(tcp_fastretrans_alert) 

Java代码  

1. static inline int tcp_ack_is_dubious(const struct sock *sk, const int flag)  
2. {  
3.     return (!(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||inet_csk(sk)->icsk_ca_state != TCP_CA_Open);  
4. }  

然后是 tcp_may_raise_cwnd，这个函数用来判断是否需要增大拥塞窗口。 

1 不能有ECE flag或者发送的拥塞窗口不能大于slow start的阀值。 

3 拥塞状态为RECO或者CWR. 

Java代码  

1. static inline int tcp_may_raise_cwnd(const struct sock *sk, const int flag)  
2. {  
3.     const struct tcp_sock *tp = tcp_sk(sk);  
4.     return (!(flag & FLAG_ECE) || tp->snd_cwnd < tp->snd_ssthresh) &&!((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_Recovery | TCPF_CA_CWR));  
5. }  

在看tcp_ack_update_window函数之前，我们先来看tcp_may_update_window，这个函数用来判断是否需要更新发送窗口。 

1 新的数据已经被ack了。 

2 当前的数据包的序列号大于当窗口更新的时候那个数据包的序列号。 

3 当前的数据包的序列号等于窗口更新时的序列号并且新的窗口大小大于当前的发送窗口大小。这个说明对端可能已经增加了窗口的大小 

Java代码  

1. static inline int tcp_may_update_window(const struct tcp_sock *tp,const u32 ack, const u32 ack_seq,const u32 nwin)  
2. {  
3.     return (after(ack, tp->snd_una) ||  
4.         after(ack_seq, tp->snd_wl1) ||  
5.         (ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd));  
6. }  

然后是tcp_ack_update_window函数，这个主要用来更新发送窗口的大小。 

Java代码  

1. static int tcp_ack_update_window(struct sock *sk, struct sk_buff *skb, u32 ack,  
2.                  u32 ack_seq)  
3. {  
4.     struct tcp_sock *tp = tcp_sk(sk);  
5.     int flag = 0;  
6. //得到窗口的大小。  
7.     u32 nwin = ntohs(tcp_hdr(skb)->window);  
8.   
9.     if (likely(!tcp_hdr(skb)->syn))  
10.         nwin <<= tp->rx_opt.snd_wscale;  
11.   
12. //判断是否需要update窗口。  
13.     if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {  
14.         flag |= FLAG_WIN_UPDATE;  
15. //更新snd_wl1  
16.         tcp_update_wl(tp, ack_seq);  
17. //如果不等于，则说明我们需要更新窗口。  
18.         if (tp->snd_wnd != nwin) {  
19.             tp->snd_wnd = nwin;  
20. ...................................  
21.         }  
22.     }  
23.   
24.     tp->snd_una = ack;  
25.   
26.     return flag;  
27. }  

然后是tcp_cong_avoid函数，这个函数用来实现慢开始和快重传的拥塞算法。 

Java代码  

1. static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)  
2. {  
3.     const struct inet_connection_sock *icsk = inet_csk(sk);  
4.     icsk->icsk_ca_ops->cong_avoid(sk, ack, in_flight);  
5.     tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;  
6. }  

可以看到它主要是调用cong_avoid回调函数，而这个函数被初始化为tcp_reno_cong_avoid，我们来看这个函数，在看这个函数之前我们要知道一些慢开始和快回复的概念。这些东西随便介绍tcp的书上都有介绍的。 

Java代码  

1. void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)  
2. {  
3.     struct tcp_sock *tp = tcp_sk(sk);  
4. //是否已经到达拥塞窗口的限制。  
5.     if (!tcp_is_cwnd_limited(sk, in_flight))  
6.         return;  
7. //如果拥塞窗口还没有到达慢开始的阈值，我们就进入慢开始处理。  
8.     if (tp->snd_cwnd <= tp->snd_ssthresh)  
9.         tcp_slow_start(tp);  
10.   
11. //否则我们就要进入拥塞避免阶段。  
12.     else if (sysctl_tcp_abc) {  
13. //RFC3465,只有当当前的拥塞窗口的所有段都被ack了，窗口才被允许增加。  
14.     if (tp->bytes_acked >= tp->snd_cwnd*tp->mss_cache) {  
15.     tp->bytes_acked -= tp->snd_cwnd*tp->mss_cache;  
16.             if (tp->snd_cwnd < tp->snd_cwnd_clamp)  
17.                 tp->snd_cwnd++;  
18.         }  
19.     } else {  
20. //和上面处理方式类似。  
21.         tcp_cong_avoid_ai(tp, tp->snd_cwnd);  
22.     }  
23. }  

最后我们来看tcp_clean_rtx_queue函数，这个函数主要用于清理发送队列中已经被ack的数据段。函数比较大，我们来分段看。 

这里有使用karn算法，也就是如果重传的段，则计算rto的话，不采样这次的值。 

还有就是要判断是syn的ack回复，还是数据的ack回复。以及sack的判断。 

首先是遍历部分： 

Java代码  

1.     while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) {  
2.         struct tcp_skb_cb *scb = TCP_SKB_CB(skb);  
3.         u32 acked_pcount;  
4.         u8 sacked = scb->sacked;  
5. //这个说明当前的数据已经在发送未确认的段里面了。  
6.         if (after(scb->end_seq, tp->snd_una)) {  
7. //这边不是很懂。  
8.             if (tcp_skb_pcount(skb) == 1 ||  
9.                 !after(tp->snd_una, scb->seq))  
10.                 break;  
11.         acked_pcount = tcp_tso_acked(sk, skb);  
12.             if (!acked_pcount)  
13.                 break;  
14.             fully_acked = 0;  
15.         } else {  
16.             acked_pcount = tcp_skb_pcount(skb);  
17.         }  
18. //如果sack的状态有被设置重传，则我们会使用karn算法。  
19.         if (sacked & TCPCB_RETRANS) {  
20. ///如果标记为sack了重传段，则更新重传的计数。  
21.                 if (sacked & TCPCB_SACKED_RETRANS)  
22.                tp->retrans_out -= acked_pcount;  
23.             flag |= FLAG_RETRANS_DATA_ACKED;  
24.   
25. //都为-1，也就是后面计算rtt，不会采样这次值。  
26.             ca_seq_rtt = -1;  
27.             seq_rtt = -1;  
28.                 if ((flag & FLAG_DATA_ACKED) || (acked_pcount > 1))  
29.             flag |= FLAG_NONHEAD_RETRANS_ACKED;  
30.         } else {  
31. //否则根据时间戳得到对应的rtt  
32.             ca_seq_rtt = now - scb->when;  
33.             last_ackt = skb->tstamp;  
34.             if (seq_rtt < 0) {  
35.                 seq_rtt = ca_seq_rtt;  
36.             }  
37.             if (!(sacked & TCPCB_SACKED_ACKED))  
38.               reord = min(pkts_acked, reord);  
39.         }  
40. //如果有sack的数据包被ack确认了，则我们需要减小sack的计数  
41.         if (sacked & TCPCB_SACKED_ACKED)  
42.             tp->sacked_out -= acked_pcount;  
43.         if (sacked & TCPCB_LOST)  
44.             tp->lost_out -= acked_pcount;  
45. //总得发送为ack的数据字节计数更新。  
46.         tp->packets_out -= acked_pcount;  
47.         pkts_acked += acked_pcount;  
48. //判断是否为syn的ack。  
49.         if (!(scb->flags & TCPCB_FLAG_SYN)) {  
50.             flag |= FLAG_DATA_ACKED;  
51.         } else {  
52. //如果是设置标记  
53.             flag |= FLAG_SYN_ACKED;  
54.             tp->retrans_stamp = 0;  
55.         }  
56.   
57.         if (!fully_acked)  
58.             break;  
59. //从写buf，unlink掉。  
60.         tcp_unlink_write_queue(skb, sk);  
61. //释放内存。  
62.         sk_wmem_free_skb(sk, skb);  
63.         tp->scoreboard_skb_hint = NULL;  
64.         if (skb == tp->retransmit_skb_hint)  
65.             tp->retransmit_skb_hint = NULL;  
66.         if (skb == tp->lost_skb_hint)  
67.             tp->lost_skb_hint = NULL;  
68.     }  

剩下的部分就是计算rtt的部分，这里就不介绍了。