Linux 内核网络协议栈 ------ tcp_ack 函数处理接收到的ACK包之后
注意 tcp_ack 是来处理接收到的ACK的，那么到底怎么去做呢？看下面：
先还上把tcp_sock的结构放在这里，下面一些数据的分析需要用到：
struct tcp_sock {
/* inet_connection_sock has to be the first member of tcp_sock */
struct inet_connection_sock inet_conn;
u16 tcp_header_len; /* Bytes of tcp header to send */ // tcp头部长度
u16 xmit_size_goal_segs; /* Goal for segmenting output packets */// 分段数据包的数量
/*
* Header prediction flags
* 0x5?10 << 16 + snd_wnd in net byte order
*/
__be32 pred_flags; // 头部预置位（用于检测头部标识位处理ACK和PUSH之外还有没有其他位，从而判断是不是可以使用快速路径处理数据）
/*
* RFC793 variables by their proper names. This means you can
* read the code and the spec side by side (and laugh ...)
* See RFC793 and RFC1122. The RFC writes these in capitals.
*/
u32 rcv_nxt; /* What we want to receive next */ // 下一个想要收到的第一个数据的字节编号
u32 copied_seq; /* Head of yet unread data */ // 没还有读出的数据的头
u32 rcv_wup; /* rcv_nxt on last window update sent */ // rcv_nxt在最后一个窗口更新时的值
u32 snd_nxt; /* Next sequence we send */ // 下一个发送的第一个字节编号
u32 snd_una; /* First byte we want an ack for */ // 对于发出的数据，都需要对方的ACK，这里标示当前需要被确认的第一个字节
u32 snd_sml; /* Last byte of the most recently transmitted small packet */ // 最近发送的小数据包的最后一个字节
u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */ // 最后一次接收到ACK的时间戳
u32 lsndtime; /* timestamp of last sent data packet (for restart window) */ // 最后一次发送数据包时间戳
u32 tsoffset; /* timestamp offset */ // 时间戳偏移
struct list_head tsq_node; /* anchor in tsq_tasklet.head list */ //
unsigned long tsq_flags;
// 注意下面这个ucopy：就是将用户数据从skb中拿出来放进去，然后传给应用进程！！！
/* Data for direct copy to user */
struct {
struct sk_buff_head prequeue; // 预处理队列
struct task_struct *task; // 预处理进程
struct iovec *iov; // 用户程序(应用程序)接收数据的缓冲区
int memory; // 用于预处理计数
int len; // 预处理长度
#ifdef CONFIG_NET_DMA
/* members for async copy */
struct dma_chan *dma_chan;
int wakeup;
struct dma_pinned_list *pinned_list;
dma_cookie_t dma_cookie;
#endif
} ucopy;
// snd_wl1：记录发送窗口更新时，造成窗口更新的那个数据报的第一个序号。 它主要用于在下一次判断是否需要更新发送窗口。
u32 snd_wl1; /* Sequence for window update */ // 窗口更新序列号( 每一次收到确认之后都会改变 )
u32 snd_wnd; /* The window we expect to receive */ // 我们期望收到的窗口
u32 max_window; /* Maximal window ever seen from peer */ // 从对方接收到的最大窗口
u32 mss_cache; /* Cached effective mss, not including SACKS */ // 有效的MSS，SACKS不算
u32 window_clamp; /* Maximal window to advertise */ // 对外公布的最大的窗口
u32 rcv_ssthresh; /* Current window clamp */ // 当前窗口值
u16 advmss; /* Advertised MSS */ // 对外公布的MSS
u8 unused;
u8 nonagle : 4,/* Disable Nagle algorithm? */ // Nagle算法是否有效
thin_lto : 1,/* Use linear timeouts for thin streams */ // 使用线性超时处理
thin_dupack : 1,/* Fast retransmit on first dupack */ // 收到第一个重复的ACK的时候是否快速重传
repair : 1,
frto : 1;/* F-RTO (RFC5682) activated in CA_Loss */
u8 repair_queue;
u8 do_early_retrans:1,/* Enable RFC5827 early-retransmit */ // 是否可以使用之前的重传
syn_data:1, /* SYN includes data */ // data中是否包含SYN
syn_fastopen:1, /* SYN includes Fast Open option */ // SYN选项
syn_data_acked:1;/* data in SYN is acked by SYN-ACK */ // SYN回复
u32 tlp_high_seq; /* snd_nxt at the time of TLP retransmit. */ // tlp重传时候snd_nxt的值
/* RTT measurement */
u32 srtt; /* smoothed round trip time << 3 */ // 往返时间
u32 mdev; /* medium deviation */ //
u32 mdev_max; /* maximal mdev for the last rtt period */ // 最大mdev
u32 rttvar; /* smoothed mdev_max */
u32 rtt_seq; /* sequence number to update rttvar */
u32 packets_out; /* Packets which are "in flight" */ // 已经发出去的尚未收到确认的包
u32 retrans_out; /* Retransmitted packets out */ // 重传的包
u16 urg_data; /* Saved octet of OOB data and control flags */ // OOB数据和控制位
u8 ecn_flags; /* ECN status bits. */ // ECN状态位
u8 reordering; /* Packet reordering metric. */ // 包重排度量
u32 snd_up; /* Urgent pointer */ // 紧急指针
u8 keepalive_probes; /* num of allowed keep alive probes */
/*
* Options received (usually on last packet, some only on SYN packets).
*/
struct tcp_options_received rx_opt; // tcp接收选项
/*
* Slow start and congestion control (see also Nagle, and Karn & Partridge)
*/
u32 snd_ssthresh; /* Slow start size threshold */ // 慢启动的开始大小
u32 snd_cwnd; /* Sending congestion window */ // 发送阻塞窗口
u32 snd_cwnd_cnt; /* Linear increase counter */ // 线性增长计数器(为了窗口的扩大)
u32 snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */ // snd_cwnd值不可以超过这个门限
u32 snd_cwnd_used;
u32 snd_cwnd_stamp;
u32 prior_cwnd; /* Congestion window at start of Recovery. */ // 在刚刚恢复时候的阻塞窗口大小
u32 prr_delivered; /* Number of newly delivered packets to // 在恢复期间接收方收到的包
* receiver in Recovery. */
u32 prr_out; /* Total number of pkts sent during Recovery. */ // 在恢复期间发出去的包
u32 rcv_wnd; /* Current receiver window */ // 当前接收窗口
u32 write_seq; /* Tail(+1) of data held in tcp send buffer */ // tcp发送buf中数据的尾部
u32 notsent_lowat; /* TCP_NOTSENT_LOWAT */
u32 pushed_seq; /* Last pushed seq, required to talk to windows */ // push序列
u32 lost_out; /* Lost packets */ // 丢失的包
u32 sacked_out; /* SACK'd packets */ // SACK包
u32 fackets_out; /* FACK'd packets */ // FACK包
u32 tso_deferred;
/* from STCP, retrans queue hinting */
struct sk_buff* lost_skb_hint; // 用于丢失的包
struct sk_buff *retransmit_skb_hint; // 用于重传的包
struct sk_buff_head out_of_order_queue; /* Out of order segments go here */ // 接收到的无序的包保存
/* SACKs data, these 2 need to be together (see tcp_options_write) */
struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */
struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/
struct tcp_sack_block recv_sack_cache[4];
struct sk_buff *highest_sack; /* skb just after the highest
* skb with SACKed bit set
* (validity guaranteed only if
* sacked_out > 0)
*/
int lost_cnt_hint;
u32 retransmit_high; /* L-bits may be on up to this seqno */
u32 lost_retrans_low; /* Sent seq after any rxmit (lowest) */
u32 prior_ssthresh; /* ssthresh saved at recovery start */
u32 high_seq; /* snd_nxt at onset of congestion */
u32 retrans_stamp; /* Timestamp of the last retransmit,
* also used in SYN-SENT to remember stamp of
* the first SYN. */
u32 undo_marker; /* tracking retrans started here. */
int undo_retrans; /* number of undoable retransmissions. */
u32 total_retrans; /* Total retransmits for entire connection */
u32 urg_seq; /* Seq of received urgent pointer */
unsigned int keepalive_time; /* time before keep alive takes place */
unsigned int keepalive_intvl; /* time interval between keep alive probes */
int linger2;
/* Receiver side RTT estimation */
struct {
u32 rtt;
u32 seq;
u32 time;
} rcv_rtt_est;
/* Receiver queue space */
struct {
int space;
u32 seq;
u32 time;
} rcvq_space;
/* TCP-specific MTU probe information. */
struct {
u32 probe_seq_start;
u32 probe_seq_end;
} mtu_probe;
u32 mtu_info; /* We received an ICMP_FRAG_NEEDED / ICMPV6_PKT_TOOBIG
* while socket was owned by user.
*/
#ifdef CONFIG_TCP_MD5SIG
/* TCP AF-Specific parts; only used by MD5 Signature support so far */
const struct tcp_sock_af_ops *af_specific;
/* TCP MD5 Signature Option information */
struct tcp_md5sig_info __rcu *md5sig_info;
#endif
/* TCP fastopen related information */
struct tcp_fastopen_request *fastopen_req;
/* fastopen_rsk points to request_sock that resulted in this big
* socket. Used to retransmit SYNACKs etc.
*/
struct request_sock *fastopen_rsk;
};
关于窗口的操作值snd_una，snd_wnd等可以看下面的图形：
先看发送窗口：
再看接收窗口：
还有tcp_skb_cb结构：
struct tcp_skb_cb {
union {
struct inet_skb_parm h4;
#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
struct inet6_skb_parm h6;
#endif
} header; /* For incoming frames */
__u32 seq; // 当前tcp包的第一个序列号
__u32 end_seq; // 表示结束的序列号：seq + FIN + SYN + 数据长度len
__u32 when; // 用于计算RTT
__u8 flags; // tcp头的flag
__u8 sacked; // SACK/FACK的状态flag或者是sack option的偏移
__u32 ack_seq; // ack(确认)的序列号
};
关于tcp头的标识(flags)可以取：
#define TCPCB_FLAG_FIN 0x01 // FIN 结束符 #define TCPCB_FLAG_SYN 0x02 // SYN 握手 #define TCPCB_FLAG_RST 0x04 // RST 重置 #define TCPCB_FLAG_PSH 0x08 // PSH 接收方要立即处理 #define TCPCB_FLAG_ACK 0x10 // ACK ack段有效 #define TCPCB_FLAG_URG 0x20 // URG 紧急指针 #define TCPCB_FLAG_ECE 0x40 // ECE 有拥塞情况(可能是传播线路上的拥塞，例如路由器提供的信息) #define TCPCB_FLAG_CWR 0x80 // CWR (发生某种拥塞，例如ICMP源抑制、本地设备拥塞)
sack的标识：
#define TCPCB_SACKED_ACKED 0x01 // tcp的cb结构上是被sack确认的 #define TCPCB_SACKED_RETRANS 0x02 // 重传帧 #define TCPCB_LOST 0x04 // 丢失 #define TCPCB_TAGBITS 0x07 // tag bits ？ #define TCPCB_EVER_RETRANS 0x80 #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
OK，回到tcp_ack函数，函数的主要功能是：
1 更新重传队列。
2 更新发送窗口。
3 从sack的信息或者重复ack来决定是否进入拥塞模式。
/* This routine deals with incoming acks, but not outgoing ones. */
static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
{
struct inet_connection_sock *icsk = inet_csk(sk); // 获得连接sock
struct tcp_sock *tp = tcp_sk(sk); // 获得tcp_sock
u32 prior_snd_una = tp->snd_una; // 获得未发送确认的序号
u32 ack_seq = TCP_SKB_CB(skb)->seq; // 获得数据序号
u32 ack = TCP_SKB_CB(skb)->ack_seq; // 获得ack序号(用于确认的序号)
u32 prior_in_flight;
u32 prior_fackets;
int prior_packets;
int frto_cwnd = 0;
/* If the ack is newer than sent or older than previous acks
* then we can probably ignore it.
*/
if (after(ack, tp->snd_nxt)) // 如果确认序号比我还下一个准备发送的序号还要大，即确认了我们尚未发送的数据，那么显然不合理
goto uninteresting_ack; // 没有意义的ACK
if (before(ack, prior_snd_una)) // 如果ack确认比我期望的确认序号小，那么可能是以前老的ack，丢弃！！！
goto old_ack; // 老的ack
if (after(ack, prior_snd_una)) // 如果ack确认比我期望的第一个ack要大，但是经过上面我们还知道没有超过我没有发送的数据序号，范围
flag |= FLAG_SND_UNA_ADVANCED; // 那么设置标识~
if (sysctl_tcp_abc) { // 是否设置了tcp_abc，若有则我们不需要对每个ack确认都要拥塞避免，所以我们需要计算已经ack(确认)的字节数。
if (icsk->icsk_ca_state < TCP_CA_CWR)
tp->bytes_acked += ack - prior_snd_una; // 已经(确定)ack的字节数增大了( ack - prior_snd_una )大小
else if (icsk->icsk_ca_state == TCP_CA_Loss)
/* we assume just one segment left network */
tp->bytes_acked += min(ack - prior_snd_una,
tp->mss_cache);
}
prior_fackets = tp->fackets_out; // 得到fack的数据包的字节数
prior_in_flight = tcp_packets_in_flight(tp); // 计算还在传输的数据段的字节数，下面会说手这个函数！（ 1 ）
if (!(flag & FLAG_SLOWPATH) && after(ack, prior_snd_una)) { // 如果不是“慢路径” && ack确认比其需要的第一个大(正确的确认序号)
/* Window is constant, pure forward advance.
* No more checks are required.
* Note, we use the fact that SND.UNA>=SND.WL2.
*/
tcp_update_wl(tp, ack, ack_seq); // 需要更新sock中的snd_wl1字段：tp->snd_wl1 = ack_seq;( 记录造成发送窗口更新的第一个数据 )
tp->snd_una = ack; // snd_una更新为已经确认的序列号！下一次期待从这里开始的确认！！！
flag |= FLAG_WIN_UPDATE; // 窗口更新标识
tcp_ca_event(sk, CA_EVENT_FAST_ACK); // 重要函数！！！进入拥塞操作！这个函数最后看，这里处理的是“正常的ACK”事件（999999）
NET_INC_STATS_BH(LINUX_MIB_TCPHPACKS);
} else {
if (ack_seq != TCP_SKB_CB(skb)->end_seq) // 如果不相等，那么说明还是带有数据一起的~不仅仅是一个ACK的包
flag |= FLAG_DATA; // 说明还是有数据的~
else
NET_INC_STATS_BH(LINUX_MIB_TCPPUREACKS); // 否则仅仅是ACK的包
flag |= tcp_ack_update_window(sk, skb, ack, ack_seq); // 下面需要更新发送窗口~（2）
if (TCP_SKB_CB(skb)->sacked) // 然后判断是否有sack段，有的话，我们进入sack段的处理。
flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una); // ~~~~~处理SACK(选择确认)，以后单独解释
if (TCP_ECN_rcv_ecn_echo(tp, tcp_hdr(skb))) // 判断是否有ecn标记，如果有的话，设置ecn标记。
flag |= FLAG_ECE; // ECE 也是用于判断是否阻塞情况
tcp_ca_event(sk, CA_EVENT_SLOW_ACK); // 重要函数！！！进入拥塞操作！这个函数最后看，这里处理“其他ACK”事件（999999）
}
/* We passed data and got it acked, remove any soft error
* log. Something worked...
*/
sk->sk_err_soft = 0;
tp->rcv_tstamp = tcp_time_stamp;
prior_packets = tp->packets_out; // 获得发出去没有收到确认的包数量
if (!prior_packets) // 如果为0，则可能是0窗口探测包
goto no_queue;
/* See if we can take anything off of the retransmit queue. */
flag |= tcp_clean_rtx_queue(sk, prior_fackets); // 清理重传队列中的已经确认的数据段。（3）
if (tp->frto_counter) // 处理F-RTO （4）
frto_cwnd = tcp_process_frto(sk, flag); // 处理超时重传，暂时先不多说
/* Guarantee sacktag reordering detection against wrap-arounds */
if (before(tp->frto_highmark, tp->snd_una))
tp->frto_highmark = 0;
if (tcp_ack_is_dubious(sk, flag)) { // 判断ack是否可疑，其实本质就是判断可不可以增大拥塞窗口，下面会有详细解释（5）
/* Advance CWND, if state allows this. */
if ((flag & FLAG_DATA_ACKED) && !frto_cwnd && // 如果是数据确认包
tcp_may_raise_cwnd(sk, flag)) // 检测flag以及是否需要update拥塞窗口的大小！！！（6）--->被怀疑也有可能增大窗口哦~~~
tcp_cong_avoid(sk, ack, prior_in_flight); // 为真则更新拥塞窗口,拥塞避免算法（7）--->如果允许增大窗口，那么拥塞算法处理窗口
tcp_fastretrans_alert(sk, prior_packets - tp->packets_out, // 这里进入拥塞状态的处理，非常重要的函数(对于拥塞处理来说)！！！（8）
flag); // 处理完窗口变化之后，进入快速重传处理！！！
} else { // 没有被怀疑(说明是正常的确认ACK)
if ((flag & FLAG_DATA_ACKED) && !frto_cwnd)
tcp_cong_avoid(sk, ack, prior_in_flight); // 如果没有被怀疑，直接拥塞算法处理窗口变化
}
if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
dst_confirm(sk->sk_dst_cache);
return 1;
no_queue:
icsk->icsk_probes_out = 0;
/* If this ack opens up a zero window, clear backoff. It was
* being used to time the probes, and is probably far higher than
* it needs to be for normal retransmission.
*/
if (tcp_send_head(sk)) // 这里判断发送缓冲区是否为空，如果不为空，则进入判断需要重启keepalive定时器还是关闭定时器
tcp_ack_probe(sk); // 处理定时器函数~（暂时不看）
return 1;
old_ack:
if (TCP_SKB_CB(skb)->sacked) // 如果有sack标识
tcp_sacktag_write_queue(sk, skb, prior_snd_una); // 进入sack段处理（暂时不看）
uninteresting_ack:
SOCK_DEBUG(sk, "Ack %u out of %u:%u\n", ack, tp->snd_una, tp->snd_nxt);// 没有意义的包~
return 0;
}
-----------------------------------------------------------------------------------------------------------------------------------------
看看这个函数：tcp_packets_in_flight，就是计算还在传输中的字节数：
static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
{
return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;
}
static inline unsigned int tcp_left_out(const struct tcp_sock *tp)
{
return tp->sacked_out + tp->lost_out;
}
我们从tcp_sock可以知道：其实就是返回 packets_out - sacked_out - lost_out + retrans_out，就是还没有到达对方的数据段的字节数
-----------------------------------------------------------------------------------------------------------------------------------------
下面我们看一下“发送窗口”的更新tcp_ack_update_window：
static int tcp_ack_update_window(struct sock *sk, struct sk_buff *skb, u32 ack,
u32 ack_seq)
{
struct tcp_sock *tp = tcp_sk(sk); // 获得tcp_sock
int flag = 0;
u32 nwin = ntohs(tcp_hdr(skb)->window); // 获得skb发送方的可以接收的窗口值
if (likely(!tcp_hdr(skb)->syn)) // 如果不是建立连接时候，即是普通传递数据时候，窗口缩放
nwin <<= tp->rx_opt.snd_wscale; // 接收方要求对窗口进行缩放
// 下面正式更新窗口
if (tcp_may_update_window(tp, ack, ack_seq, nwin)) { // 可能需要更新窗口大小，在函数tcp_may_update_window中实际处理（1）
flag |= FLAG_WIN_UPDATE; // 窗口更新成功
tcp_update_wl(tp, ack, ack_seq); // 更新snd_wl1
if (tp->snd_wnd != nwin) { // 如果发送窗口！=缩放后的新窗口（注意skb发送方的接收窗口和本tp的发送窗口应该一致）
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); // 检验是否能够开启“快速路径”（2）看下面
if (nwin > tp->max_window) { // 如果调整之后的窗口大于从对方接收到的最大的窗口值
tp->max_window = nwin; // 调整为小的
tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie); // 改变mss_cache
}
}
}
tp->snd_una = ack; // 下一个第一个需要确认就是所有当前已经确认序号之后~~~~
return flag;
}
下面看这个函数：tcp_may_update_window
/* Check that window update is acceptable.
* The function assumes that snd_una<=ack<=snd_next.
*/ // 这个函数是检查窗口是否可变，只要确认ack在snd_una~下一个需要发送的数据之间，就是需要改变窗口的！
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) || // snd_una<=ack
after(ack_seq, tp->snd_wl1) || // 看上面的窗口图可以知道
(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd)); // 调整的新窗口大于原始发送窗口
}
看一下检测是否可以进入“快速路径”处理函数：tcp_fast_path_check
static inline void tcp_fast_path_check(struct sock *sk)
{
struct tcp_sock *tp = tcp_sk(sk);
if (skb_queue_empty(&tp->out_of_order_queue) &&
tp->rcv_wnd &&
atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
!tp->urg_data)
tcp_fast_path_on(tp);
}
能够进入“快速路径”处理的基本条件是：
1 ：是否ofo(乱序包队列)队列为空，如果不为空也就是说有乱序数据不可以进入快速路径。
2： 当前的接收窗口是否大于0.，如果不是，不可以进入。
3 ：当前的已经提交的数据包大小是否小于接收缓冲区的大小，能够放的下才可以进入快速路径。
4： 是否含有urgent 数据，不含有才可以进入快速路径。
再看看 为tp开启快速路径函数tcp_fast_path_on：
static inline void tcp_fast_path_on(struct tcp_sock *tp)
{
__tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
}
static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
{
tp->pred_flags = htonl((tp->tcp_header_len << 26) | // 看见没有。本质就是设置pred_flags变量
ntohl(TCP_FLAG_ACK) |
snd_wnd);
}
其实就是就是说标志位除了ACK和PSH外，如果其他的存在的话，就不能用快速路径！
-----------------------------------------------------------------------------------------------------------------------------------------
下面看进入拥塞操作函数tcp_ca_event：
有必要先看看拥塞控制结构体：
struct tcp_congestion_ops {
struct list_head list;
unsigned long flags;
/* initialize private data (optional) */
void (*init)(struct sock *sk); // 初始化
/* cleanup private data (optional) */
void (*release)(struct sock *sk); // 清除数据
/* return slow start threshold (required) */
u32 (*ssthresh)(struct sock *sk); // 返回慢开始门限
/* lower bound for congestion window (optional) */
u32 (*min_cwnd)(const struct sock *sk); // 拥塞窗口最小值
/* do new cwnd calculation (required) */
void (*cong_avoid)(struct sock *sk, u32 ack, u32 in_flight); // 计算新的拥塞窗口
/* call before changing ca_state (optional) */
void (*set_state)(struct sock *sk, u8 new_state); // 设置拥塞状态
/* call when cwnd event occurs (optional) */
void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev); // 拥塞事件发生时候处理
/* new value of cwnd after loss (optional) */
u32 (*undo_cwnd)(struct sock *sk); // 丢包之后，拥塞窗口新的值
/* hook for packet ack accounting (optional) */
void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us); // 包的ack计数器
/* get info for inet_diag (optional) */
void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb); //
char name[TCP_CA_NAME_MAX];
struct module *owner;
};
看一下TCP拥塞事件：
/* Events passed to congestion control interface */
enum tcp_ca_event {
CA_EVENT_TX_START, /* first transmit when no packets in flight */
CA_EVENT_CWND_RESTART, /* congestion window restart */
CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */
CA_EVENT_FRTO, /* fast recovery timeout */
CA_EVENT_LOSS, /* loss timeout */
CA_EVENT_FAST_ACK, /* in sequence ack */
CA_EVENT_SLOW_ACK, /* other ack */
};
static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event) // 第三个参数在上面的来说分别是：CA_EVENT_SLOW_ACK和CA_EVENT_FAST_ACK
{
const struct inet_connection_sock *icsk = inet_csk(sk); // 获得连接sock
if (icsk->icsk_ca_ops->cwnd_event) // 注意这是一个函数指针：结构体struct tcp_congestion_ops中的！当拥塞事件发生时候执行
icsk->icsk_ca_ops->cwnd_event(sk, event); // 执行这个事件
}
拥塞窗口事件初始化在这：
if (icsk->icsk_ca_ops == &tcp_init_congestion_ops) { //////////////////////////// 初始化结构体
rcu_read_lock();
list_for_each_entry_rcu(ca, &tcp_cong_list, list) {
if (try_module_get(ca->owner)) {
icsk->icsk_ca_ops = ca;
break;
}
/* fallback to next available */
}
rcu_read_unlock();
}
struct tcp_congestion_ops tcp_init_congestion_ops = {
.name = "",
.owner = THIS_MODULE,
.ssthresh = tcp_reno_ssthresh,
.cong_avoid = tcp_reno_cong_avoid,
.min_cwnd = tcp_reno_min_cwnd,
};
这有点问题！对于这个函数没有进行实现？还是我没有找到处理赋值的地方？无语了~~~~~~~~~~~~~~~~~~~~~~~~
或许这里面初始化：下面是关于cwnd_event所有的初始化
static struct tcp_congestion_ops tcp_veno = {
.flags = TCP_CONG_RTT_STAMP,
.init = tcp_veno_init,
.ssthresh = tcp_veno_ssthresh,
.cong_avoid = tcp_veno_cong_avoid,
.pkts_acked = tcp_veno_pkts_acked,
.set_state = tcp_veno_state,
.cwnd_event = tcp_veno_cwnd_event, ///////////////////////////////////////////////
.owner = THIS_MODULE,
.name = "veno",
};
static struct tcp_congestion_ops tcp_vegas = {
.flags = TCP_CONG_RTT_STAMP,
.init = tcp_vegas_init,
.ssthresh = tcp_reno_ssthresh,
.cong_avoid = tcp_vegas_cong_avoid,
.min_cwnd = tcp_reno_min_cwnd,
.pkts_acked = tcp_vegas_pkts_acked,
.set_state = tcp_vegas_state,
.cwnd_event = tcp_vegas_cwnd_event, ///////////////////////////////////////////////
.get_info = tcp_vegas_get_info,
.owner = THIS_MODULE,
.name = "vegas",
};
static struct tcp_congestion_ops tcp_yeah = {
.flags = TCP_CONG_RTT_STAMP,
.init = tcp_yeah_init,
.ssthresh = tcp_yeah_ssthresh,
.cong_avoid = tcp_yeah_cong_avoid,
.min_cwnd = tcp_reno_min_cwnd,
.set_state = tcp_vegas_state,
.cwnd_event = tcp_vegas_cwnd_event, ////////////////////////////////////////////////
.get_info = tcp_vegas_get_info,
.pkts_acked = tcp_yeah_pkts_acked,
.owner = THIS_MODULE,
.name = "yeah",
};
-------------------------------------------------------------------------------------------------------------------------------------------
下面清理重传队列中已经确认的数据，看函数tcp_clean_rtx_queue：
看这个链接：tcp_clean_rtx_queue
现在可以看一下tcp_ack_is_dubious函数，来判断是不是进入了拥塞状态：
先可以看一下状态的定义：
#define FLAG_DATA 0x01 /* Incoming frame contained data. */ // 来了一个包含数据的包 #define FLAG_WIN_UPDATE 0x02 /* Incoming ACK was a window update. */ // 来了一个ACK用于更新窗口 #define FLAG_DATA_ACKED 0x04 /* This ACK acknowledged new data. */ // 对于数据的确认 #define FLAG_RETRANS_DATA_ACKED 0x08 /* "" "" some of which was retransmitted. */ // 对于重传数据的确认 #define FLAG_SYN_ACKED 0x10 /* This ACK acknowledged SYN. */ // 对于SYN的确认 #define FLAG_DATA_SACKED 0x20 /* New SACK. */ // 这是对数据的一个选择确认 #define FLAG_ECE 0x40 /* ECE in this ACK */ // 确认中旅带有ECE信息 #define FLAG_DATA_LOST 0x80 /* SACK detected data lossage. */ // SACK检测到数据丢失 #define FLAG_SLOWPATH 0x100 /* Do not skip RFC checks for window update.*/ // slowpath，需要做一些检查 #define FLAG_ONLY_ORIG_SACKED 0x200 /* SACKs only non-rexmit sent before RTO */ #define FLAG_SND_UNA_ADVANCED 0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */ // snd-una改变 #define FLAG_DSACKING_ACK 0x800 /* SACK blocks contained D-SACK info */ // 包含DSACK信息 #define FLAG_NONHEAD_RETRANS_ACKED 0x1000 /* Non-head rexmitted data was ACKed */ #define FLAG_SACK_RENEGING 0x2000 /* snd_una advanced to a sacked seq */ // snd_una移动到一个sack中的一个位置 #define FLAG_ACKED (FLAG_DATA_ACKED|FLAG_SYN_ACKED) // 表示数据确认或者SYN确认 #define FLAG_NOT_DUP (FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED) // 表示ACK是不重复的 #define FLAG_CA_ALERT (FLAG_DATA_SACKED|FLAG_ECE) // 表示是否在进入拥塞状态的时候被alert(原因可能是SACK丢包或者路由器提示拥塞) #define FLAG_FORWARD_PROGRESS (FLAG_ACKED|FLAG_DATA_SACKED) // 选择确认
再看一下：
TCP_CA_Open：TCP连接的初始化的状态。TCP连接会在慢启动和拥塞避免阶段（调用tcp_cong_avoid）增加拥塞窗口。每个接收到的ACK都要调用tcp_ack_is_dubious，检查它是否可疑。如果是ACK可疑，就调用 tcp_fastretrans_alert()就切换到其他CA拥塞状态。但是对于可疑的ACK，若窗口也允许增大(tcp_may_raise_cwnd)，那么(tcp_fastretrans_alert)仍然可能增大拥塞窗口。
TCP_CA_Disorder：注意如果收到重复的ACK或者SACK，那么可能出现乱序情况，进入这个状态处理。
TCP_CA_CWR：表示发生某些道路拥塞，需要减慢发送速度。
TCP_CA_Recovery：正在进行快速重传丢失的数据包。
TCP_CA_Loss：超时重传情况下，如果接收到的ACK与SACK信息不一样，则阻塞丢包状态。
static inline int tcp_ack_is_dubious(const struct sock *sk, const int flag)
{
return (!(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) || // 是重复的ACK 或者 在进入拥塞状态的时候出现警告
inet_csk(sk)->icsk_ca_state != TCP_CA_Open); // 或者拥塞状态不是“增大拥塞窗口”状态
} // 则这个ACK是可疑的，其实意思就是，不是一个正常的ACK，不能随便增大拥塞窗口
下面就两条路：
1：如果被怀疑
2：如果没有被怀疑
先看如果被怀疑了，那么：
先看函数：tcp_may_raise_cwnd
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) && // 没有其他阻塞 或者 (发送窗口小于门限&&不是Recovery ，也不是CWR)
!((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_Recovery | TCPF_CA_CWR)); // 那么这样还是可以增大窗口的嘛~~~~~ ^_^
}
如果可以增大窗口，那么就需要使用tcp_cong_avoid执行这个函数用来实现慢启动和快速重传拥塞避免算法：
这个函数也是在“没有被怀疑”的情况下执行的函数，所以
如果没有被怀疑，执行的也是tcp_cong_avoid，一起解释：
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; // 发送窗口改变时间戳
}
我们看到上面说的拥塞结构体的初始化：
struct tcp_congestion_ops tcp_init_congestion_ops = {
.name = "",
.owner = THIS_MODULE,
.ssthresh = tcp_reno_ssthresh,
.cong_avoid = tcp_reno_cong_avoid, //////////////////////这个函数
.min_cwnd = tcp_reno_min_cwnd,
};
那么实际执行的就是tcp_reno_cong_avoid函数！！！
看这个链接：tcp_reno_cong_avoid
----------------------------------------------------------------------------------------------------------------------------------
OK，下面再看看tcp_fastretrans_alert函数：TCP拥塞状态机主要是在tcp_fastretrans_alert()中实现的，只有在ACK被怀疑的时候才会执行这个提醒函数
此函数被调用的条件也就是怀疑的条件：
1：进来一个ACK，但是状态不是 Open
2：收到的是 SACK 、Duplicate ACK、ECN、ECE 等警告信息
请看这个链接：tcp_fastretrans_alert
到此为止，处理接收到的ACK基本结束。。。。