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;  // 返回被确认的数量}