Linux 内核网络协议栈 ------ 清理重传队列中函数 tcp_clean_rtx_queue

如果重传队列中的一些数据已经被确认，那么， 需要从重传队列中清除出去，需要使用这个函数：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,古老的榕树,5-wow.com