本文主要内容：tcp_ack()中的一些细节，如发送窗口的更新、持续定时器等。
内核版本：3.2.12
Author：zhangskd @ ****
发送窗口的更新
什么时候需要更新发送窗口呢？
（1）确认了新的数据
（2）条件1不成立，ACK段的序号是最新的。
这表示虽然ACK段没有确认了新的数据，但是它携带了新数据。
（3）条件1和2都不成立，通告窗口变大。
ACK既没有确认了新的数据，序号也不是最新的。
虽然如此，但是如果对端的接收窗口变大，我们还是要更新发送窗口。
此时ack_seq必须等于snd_wl1，而不能小于，因为那可能是乱序的。
判断是否要更新发送窗口：
/* Check that window update is acceptable.
* The function assumes that snd_una <= ack <= snd_nxt.
* ack和ack_seq分别表示ACK段的确认序号和序号，不要混淆了：）
*/
static inline int tcp_may_update_window(const struct tcp_sock *tp, const u32 ack,
const u32 ack_seq, const u32 nwin)
{
return after(ack, tp->snd_una) || after(ack_seq, tp->snd_wl1) ||
(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);
}
更新函数：
/* Update our send window.
* Window update algorithm.
*/
static int tcp_ack_update_window(struct sock *sk, const struct sk_buff, u32 ack, u32 ack_seq)
{
struct tcp_sock *tp = tcp_sk(sk);
int flag = 0;
u32 nwin = ntohs(tcp_hdr(skb)->window); /* 通告窗口*/ /* 在发送syn包时，通告窗口没有乘窗口扩大因子*/
if (likely(! tcp_hdr(skb)->syn))
nwin <<= tp->rx_opt.snd_wscale; /* 乘对端的窗口扩大因子*/ if (tcp_may_update_window(tp, ack, ack_seq, nwin)) { /* 如果可以更新发送窗口*/
flag |= FLAG_WIN_UPDATE; /* 设置发送窗口更新标志*/
tcp_update_wl(tp, ack_seq); /* 记录更新发送窗口的ACK段序号*/ 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); /* Update maximal window ever seen from peer */
if (nwin > tp->max_window) {
tp->max_window = nwin; /* 更新见过的最大接收窗口*/
tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie); /* 更新MSS */
}
}
} tp->snd_una = ack; /* 更新发送窗口左端*/
return flag;
}
持续定时器
持续定时器在对端通告接收窗口为0，阻止TCP继续发送数据时设定。由于允许TCP继续发送数据的窗口更新
有可能丢失，因此，如果TCP有数据要发送，而对端通告窗口为0，则持续定时器启动，超时后向对端发送1
字节的数据，以判断对端接收窗口是否已经打开。
#define ICSK_TIME_PROBE0 3 /* Zero window probe timer */ static void tcp_ack_probe(struct sock *sk)
{
const struct tcp_sock *tp = tcp_sk(sk);
struct inet_connection_sock *icsk = inet_csk(sk); /* Was it a usable window open ?
* 对端是否有足够的接收缓存，即我们能否发送一个包。
*/
if (! after(TCP_SKB_CB(tcp_send_head(sk))->end_seq, tcp_wnd_end(tp))) {
icsk->icsk_backoff = 0; /* 清除退避指数 */
inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0); /* 清除持续定时器*/ /* Socket must be waked up by subsequent tcp_data_snd_check().
* This function is not for random using!
*/ } else { /* 否则根据退避指数重置持续定时器*/
inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
min(icsk->icsk_rto << icsk->icsk_backoff, TCP_RTO_MAX), TCP_RTO_MAX);
}
}
返回发送窗口的最后一个字节序号：
/* Returns end sequence number of the receiver's advertised window */
static inline u32 tcp_wnd_end(const struct tcp_sock *tp)
{
return tp->snd_una + tp->snd_wnd;
}
flag标志
#define FLAG_SND_UNA_ADVANCED 0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED)*/
#define FLAG_DATA 0x01 /* Incoming frame contained data. 接收的ACK段有负荷，不是纯ACK段*/
#define FLAG_WIN_UPDATE 0x02 /* Incoming ACK was a window update. 接收的ACK段更新了发送窗口*/ #define FLAG_DATA_ACKED 0x04 /* This ACK acknowledged new data.*/
#define FLAG_SYN_ACKED 0x10 /* This ACK acnowledged SYN. */
#define FLAG_ACKED (FLAG_DATA_ACKED | FLAG_SYN_ACKED) #define FLAG_NOT_DUP (FLAG_DATA | FLAG_WIN_UPDATE | FLAG_ACKED) #define FLAG_DATA_SACKED 0x20 /* New SACK. */
#define FLAG_ECE 0x40 /* ECE in this ACK .*/
#define FLAG_CA_ALERT (FLAG_DATA_SACKED | FLAG_ECE) #define FLAG_SACK_RENEGING 0x2000 /*snd_una advanced to a sacked seq */ #define FLAG_SLOWPATH 0x100 /* Do not skip RFC checks for window update. 表示在慢速路径中*/
sysctl_tcp_abc选项：
“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.”
默认值应该是0，即对每个ACK都进行拥塞避免。
拥塞控制
网络中数据包个数的计算：
/* This determines how many packets are "in the network" to the best of our knowledge.
* In many cases it is conservative, but where detailed information is available from the
* receiver (via SACK blocks etc.) we can make more aggressive calculations.
*
* Use this for decisions involving congestion control, use just
* tp->packets_out to determine if the send queue is empty or not.
*
* Read this equation as:
* packets sent once on transmission queue MINUS
* packets left network, but not honestly ACKde yet PLUS
* packets fast retransmitted
*/
static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
{
return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;
}
判断一个ACK是否可疑：
返回0表示ACK正常，返回1表示可疑
什么算是可疑的呢？
如果已经处于拥塞状态，则会显示可疑；
如果此ACK为拥塞信号，则会显示可疑。
可疑的条件（或）：
(1) 不属于以下四种(FLAG_NOT_DUP)：
FLAG_DATA：接收的ACK段是负荷数据携带的
FLAG_WIN_UPDATE：接收的ACK段更新了发送窗口
FLAG_DATA_ACKED：接收的ACK确认了新的数据
FLAG_SYN_ACKED：接收的ACK确认了SYN段
(2) 属于以下两种(FLAG_CA_ALERT)：
FLAG_DATA_SACKED：是新的SACK
FLAG_ECE：在ACK中存在ECE标志，显示收到拥塞通知
(3) 拥塞状态不为Open
static inline int tcp_ack_is_dubious(const struct sock *sk, const int flag)
{
return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
}
增加拥塞窗口：
返回1表示可以增加cwnd，返回0便是不能增加。
那么在什么情况下可以增加cwnd呢？
下面几个条件必须同时成立才能增加cwnd：
(1) ACK中没有ECE标志，或者，处于慢启动阶段
(2) 不能处于Recovery、CWR状态
static inline int tcp_may_raise_cwnd(const struct sock *sk, const int flag)
{
const struct tcp_sock *tp = tcp_sk(sk);
return ( !(flag & FLAG_ECE) || tp->snd_cwnd < tp->snd_ssthresh) &&
!((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_Recovery | TCPF_CA_CWR));
}
拥塞窗口的AI接口：
static void tcp_cong_avoid (struct sock *sk, u32 ack, u32 in_flight)
{
const struct inet_connection_sock *icsk = inet_csk(sk);
icsk->icsk_ca_ops->cong_avoid(sk, ack, in_flight);
tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
}