net/ipv4/tcp_recovery.c

   1 #include <linux/tcp.h>
   2 #include <net/tcp.h>
   3
   4 int sysctl_tcp_recovery __read_mostly = TCP_RACK_LOST_RETRANS;
   5
   6 /* Marks a packet lost, if some packet sent later has been (s)acked.
   7  * The underlying idea is similar to the traditional dupthresh and FACK
   8  * but they look at different metrics:
   9  *
  10  * dupthresh: 3 OOO packets delivered (packet count)
  11  * FACK: sequence delta to highest sacked sequence (sequence space)
  12  * RACK: sent time delta to the latest delivered packet (time domain)
  13  *
  14  * The advantage of RACK is it applies to both original and retransmitted
  15  * packet and therefore is robust against tail losses. Another advantage
  16  * is being more resilient to reordering by simply allowing some
  17  * "settling delay", instead of tweaking the dupthresh.
  18  *
  19  * The current version is only used after recovery starts but can be
  20  * easily extended to detect the first loss.
  21  */
  22 int tcp_rack_mark_lost(struct sock *sk)
  23 {
  24         struct tcp_sock *tp = tcp_sk(sk);
  25         struct sk_buff *skb;
  26         u32 reo_wnd, prior_retrans = tp->retrans_out;
  27
  28         if (inet_csk(sk)->icsk_ca_state < TCP_CA_Recovery || !tp->rack.advanced)
  29                 return 0;
  30
  31         /* Reset the advanced flag to avoid unnecessary queue scanning */
  32         tp->rack.advanced = 0;
  33
  34         /* To be more reordering resilient, allow min_rtt/4 settling delay
  35          * (lower-bounded to 1000uS). We use min_rtt instead of the smoothed
  36          * RTT because reordering is often a path property and less related
  37          * to queuing or delayed ACKs.
  38          *
  39          * TODO: measure and adapt to the observed reordering delay, and
  40          * use a timer to retransmit like the delayed early retransmit.
  41          */
  42         reo_wnd = 1000;
  43         if (tp->rack.reord && tcp_min_rtt(tp) != ~0U)
  44                 reo_wnd = max(tcp_min_rtt(tp) >> 2, reo_wnd);
  45
  46         tcp_for_write_queue(skb, sk) {
  47                 struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
  48
  49                 if (skb == tcp_send_head(sk))
  50                         break;
  51
  52                 /* Skip ones already (s)acked */
  53                 if (!after(scb->end_seq, tp->snd_una) ||
  54                     scb->sacked & TCPCB_SACKED_ACKED)
  55                         continue;
  56
  57                 if (skb_mstamp_after(&tp->rack.mstamp, &skb->skb_mstamp)) {
  58
  59                         if (skb_mstamp_us_delta(&tp->rack.mstamp,
  60                                                 &skb->skb_mstamp) <= reo_wnd)
  61                                 continue;
  62
  63                         /* skb is lost if packet sent later is sacked */
  64                         tcp_skb_mark_lost_uncond_verify(tp, skb);
  65                         if (scb->sacked & TCPCB_SACKED_RETRANS) {
  66                                 scb->sacked &= ~TCPCB_SACKED_RETRANS;
  67                                 tp->retrans_out -= tcp_skb_pcount(skb);
  68                                 NET_INC_STATS_BH(sock_net(sk),
  69                                                  LINUX_MIB_TCPLOSTRETRANSMIT);
  70                         }
  71                 } else if (!(scb->sacked & TCPCB_RETRANS)) {
  72                         /* Original data are sent sequentially so stop early
  73                          * b/c the rest are all sent after rack_sent
  74                          */
  75                         break;
  76                 }
  77         }
  78         return prior_retrans - tp->retrans_out;
  79 }
  80
  81 /* Record the most recently (re)sent time among the (s)acked packets */
  82 void tcp_rack_advance(struct tcp_sock *tp,
  83                       const struct skb_mstamp *xmit_time, u8 sacked)
  84 {
  85         if (tp->rack.mstamp.v64 &&
  86             !skb_mstamp_after(xmit_time, &tp->rack.mstamp))
  87                 return;
  88
  89         if (sacked & TCPCB_RETRANS) {
  90                 struct skb_mstamp now;
  91
  92                 /* If the sacked packet was retransmitted, it's ambiguous
  93                  * whether the retransmission or the original (or the prior
  94                  * retransmission) was sacked.
  95                  *
  96                  * If the original is lost, there is no ambiguity. Otherwise
  97                  * we assume the original can be delayed up to aRTT + min_rtt.
  98                  * the aRTT term is bounded by the fast recovery or timeout,
  99                  * so it's at least one RTT (i.e., retransmission is at least
 100                  * an RTT later).
 101                  */
 102                 skb_mstamp_get(&now);
 103                 if (skb_mstamp_us_delta(&now, xmit_time) < tcp_min_rtt(tp))
 104                         return;
 105         }
 106
 107         tp->rack.mstamp = *xmit_time;
 108         tp->rack.advanced = 1;
 109 }