如果重传队列中的一些数据已经被确认，那么， 需要从重传队列中清除出去，需要使用这个函数：tcp_clean_rtx_queue
/* Remove acknowledged frames from the retransmission queue. If our packet
* is before the ack sequence we can discard it as it‘s confirmed to have
* arrived at the other end.
*/
static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets)
{
struct tcp_sock *tp = tcp_sk(sk); // 获得tcp_sock
const struct inet_connection_sock *icsk = inet_csk(sk); // 获得连接sock
struct sk_buff *skb;
u32 now = tcp_time_stamp; // 当前时间，用于计算RTT
int fully_acked = 1; // 表示数据段是否完全被确认
int flag = 0;
u32 pkts_acked = 0;
u32 reord = tp->packets_out; // 发送出去，还在网络上跑，但是还没有被确认的数据包们
s32 seq_rtt = -1;
s32 ca_seq_rtt = -1;
ktime_t last_ackt = net_invalid_timestamp(); // 把last_ackt设置位0
// 下面就是遍历sk_write_queue队列，遇到snd_una就停止，如果没有更新过，开始就直接退出了
while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) {
struct tcp_skb_cb *scb = TCP_SKB_CB(skb); // 获得这个重传队列的一个skb的cb字段
u32 end_seq;
u32 acked_pcount;
u8 sacked = scb->sacked;
/* Determine how many packets and what bytes were acked, tso and else */
if (after(scb->end_seq, tp->snd_una)) { // 注意这个scb是我们发出去的数据的skb中的一个scb哦！，不是接受到的数据！小心
if (tcp_skb_pcount(skb) == 1 || // 这里的意思就是发出去的数据最后一个字节在已经确认的snd_una之后，说明还有没有确认的字节
!after(tp->snd_una, scb->seq)) // 如果没有设置了TSO 或者 seq不在snd_una之前，即不是 seq---snd_una---end_seq这样情况
break; // 那么说明没有必要把重传元素去掉，(如果是seq---snd_una---end_seq)那么前面半部分的就可以
// 冲队列中删除！！！ 注意是需要理解cb[]数组中seq和end_seq意义！在分片的情况下也是不变的！
acked_pcount = tcp_tso_acked(sk, skb); // 如果只确认了TSO段中的一部分，则从skb删除已经确认的segs，并统计确认了多少段( 1 )
if (!acked_pcount) // 处理出错
break;
fully_acked = 0; // 表示TSO只处理了一部分，其他还没处理完
end_seq = tp->snd_una;
} else {
acked_pcount = tcp_skb_pcount(skb); // 即 !after(scb->end_seq, tp->snd_una)，说明已经完全确认OK！
end_seq = scb->end_seq;
}
/* MTU probing checks */
if (fully_acked && icsk->icsk_mtup.probe_size && // 探测mtu，暂时不多说
!after(tp->mtu_probe.probe_seq_end, scb->end_seq)) {
tcp_mtup_probe_success(sk, skb);
}
// 下面通过sack的信息得到这是一个被重传的过包
if (sacked & TCPCB_RETRANS) {
if (sacked & TCPCB_SACKED_RETRANS) // 如果之前重传过，&& 之前还没收到回复
tp->retrans_out -= acked_pcount; // 现在需要更新重传的且没有收到ACK的包
flag |= FLAG_RETRANS_DATA_ACKED; // 重传包收到ACK
ca_seq_rtt = -1;
seq_rtt = -1;
if ((flag & FLAG_DATA_ACKED) || (acked_pcount > 1))
flag |= FLAG_NONHEAD_RETRANS_ACKED;
} else { // 如果此数据段没有被重传过
ca_seq_rtt = now - scb->when; // 通过ACK确认获得RTT值
last_ackt = skb->tstamp; // 获得skb的发送时间
if (seq_rtt < 0) {
seq_rtt = ca_seq_rtt;
}
if (!(sacked & TCPCB_SACKED_ACKED)) // 如果SACK存在一段没有被确认，那么保存其中序号最小号的
reord = min(pkts_acked, reord);
}
if (sacked & TCPCB_SACKED_ACKED) // 如果是有sack标识
tp->sacked_out -= acked_pcount; // 那么更新sack的发出没有接受到确认的数量
if (sacked & TCPCB_LOST) // 如果是丢包标识，那么更新数量
tp->lost_out -= acked_pcount;
if (unlikely(tp->urg_mode && !before(end_seq, tp->snd_up))) // 紧急模式
tp->urg_mode = 0;
tp->packets_out -= acked_pcount; // 发送的包没有确认的数量-=acked_pcount
pkts_acked += acked_pcount; // 接收到确认的包数量+=acked_pcount
/* Initial outgoing SYN‘s get put onto the write_queue
* just like anything else we transmit. It is not
* true data, and if we misinform our callers that
* this ACK acks real data, we will erroneously exit
* connection startup slow start one packet too
* quickly. This is severely frowned upon behavior.
*/
if (!(scb->flags & TCPCB_FLAG_SYN)) { // 如果不是SYN握手包
flag |= FLAG_DATA_ACKED; // 标识是数据确认
} else {
flag |= FLAG_SYN_ACKED; // 标识是SYN包标识
tp->retrans_stamp = 0; // 清除重传戳
}
if (!fully_acked) // 如果TSO段没被完全确认，则到此为止
break;
tcp_unlink_write_queue(skb, sk); // 从发送队列上移除这个skb！！！这个函数其实很简单，其实就是从链表中移除这个skb而已
sk_wmem_free_skb(sk, skb); // 删除skb内存对象
tcp_clear_all_retrans_hints(tp); //
} // while循环结束
if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)) // 虚假的SACK
flag |= FLAG_SACK_RENEGING;
if (flag & FLAG_ACKED) { // 如果ACK更新了数据，是的snd_una更新了
const struct tcp_congestion_ops *ca_ops
= inet_csk(sk)->icsk_ca_ops; // 拥塞信息
tcp_ack_update_rtt(sk, flag, seq_rtt); // 更新RTT
tcp_rearm_rto(sk); // 重置超时重传计时器
if (tcp_is_reno(tp)) { // 如果没有SACK处理
tcp_remove_reno_sacks(sk, pkts_acked); // 处理乱序的包
} else {
/* Non-retransmitted hole got filled? That‘s reordering */
if (reord < prior_fackets)
tcp_update_reordering(sk, tp->fackets_out - reord, 0); // 更新乱序队列大小
}
tp->fackets_out -= min(pkts_acked, tp->fackets_out); // 更新提前确认算法得出的尚未得到确认的包的数量
if (ca_ops->pkts_acked) { // 这是一个钩子函数
s32 rtt_us = -1;
/* Is the ACK triggering packet unambiguous? */
if (!(flag & FLAG_RETRANS_DATA_ACKED)) { // 如果是确认了非重传的包
/* High resolution needed and available? */
if (ca_ops->flags & TCP_CONG_RTT_STAMP && // 下面都是测量RTT，精读不同而已
!ktime_equal(last_ackt,
net_invalid_timestamp()))
rtt_us = ktime_us_delta(ktime_get_real(),
last_ackt);
else if (ca_seq_rtt > 0)
rtt_us = jiffies_to_usecs(ca_seq_rtt);
}
ca_ops->pkts_acked(sk, pkts_acked, rtt_us);
}
}
#if FASTRETRANS_DEBUG > 0 // 下面用于调试
BUG_TRAP((int)tp->sacked_out >= 0);
BUG_TRAP((int)tp->lost_out >= 0);
BUG_TRAP((int)tp->retrans_out >= 0);
if (!tp->packets_out && tcp_is_sack(tp)) {
icsk = inet_csk(sk);
if (tp->lost_out) {
printk(KERN_DEBUG "Leak l=%u %d\n",
tp->lost_out, icsk->icsk_ca_state);
tp->lost_out = 0;
}
if (tp->sacked_out) {
printk(KERN_DEBUG "Leak s=%u %d\n",
tp->sacked_out, icsk->icsk_ca_state);
tp->sacked_out = 0;
}
if (tp->retrans_out) {
printk(KERN_DEBUG "Leak r=%u %d\n",
tp->retrans_out, icsk->icsk_ca_state);
tp->retrans_out = 0;
}
}
#endif
return flag;
}
下面看一下tcp_tso_acked函数：
/* If we get here, the whole TSO packet has not been acked. */
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb) // TSO 包并没有全部被确认，现在需要统计已经被确认的数量
{
struct tcp_sock *tp = tcp_sk(sk); // 获得tcp_sock
u32 packets_acked;
BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una)); // seq---end_seq---snd_una 这种情况不可能进来
packets_acked = tcp_skb_pcount(skb); // TSO段总共包括几个
if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq)) // 对于已经确认的部分，更新skb中的信息。例如len之类信息都变了
return 0; // 然后重新计算出新的剩余的segs
packets_acked -= tcp_skb_pcount(skb); // 之前总的segs - 现在剩余的segs == 被确认的segs
if (packets_acked) {
BUG_ON(tcp_skb_pcount(skb) == 0);
BUG_ON(!before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq));
}
return packets_acked; // 返回被确认的数量
}
Linux 内核网络协议栈 ------ 清理重传队列中函数 tcp_clean_rtx_queue,布布扣,bubuko.com