tcp: simpler NewReno implementation

This is a rewrite of NewReno loss recovery implementation that is
simpler and standalone for readability and better performance by
using less states.

Note that NewReno refers to RFC6582 as a modification to the fast
recovery algorithm. It is used only if the connection does not
support SACK in Linux. It should not to be confused with the Reno
(AIMD) congestion control.

Signed-off-by: Yuchung Cheng <ycheng@google.com>
Signed-off-by: Neal Cardwell <ncardwell@google.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: Soheil Hassas Yeganeh <soheil@google.com>
Reviewed-by: Priyaranjan Jha <priyarjha@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/tcp.h b/include/net/tcp.h
index 994f869d793c5f46f235cbc21a9d3bd80acbc9bb..9a3ce379b994455a51fcd650ef95e9f1d823ac4a 100644 (file)
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -1877,6 +1877,7 @@ void tcp_v4_init(void);
 void tcp_init(void);
 
 /* tcp_recovery.c */
+void tcp_newreno_mark_lost(struct sock *sk, bool snd_una_advanced);
 extern void tcp_rack_mark_lost(struct sock *sk);
 extern void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 end_seq,
                             u64 xmit_time);

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index ccbe04f80040ec46b2a72734d09b72663cf8af07..076206873e3e15c43f583819bf0802493d6a2162 100644 (file)
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -2223,9 +2223,7 @@ static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
 {
        struct tcp_sock *tp = tcp_sk(sk);
 
-       if (tcp_is_reno(tp)) {
-               tcp_mark_head_lost(sk, 1, 1);
-       } else {
+       if (tcp_is_sack(tp)) {
                int sacked_upto = tp->sacked_out - tp->reordering;
                if (sacked_upto >= 0)
                        tcp_mark_head_lost(sk, sacked_upto, 0);
@@ -2723,11 +2721,16 @@ static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una)
        return false;
 }
 
-static void tcp_rack_identify_loss(struct sock *sk, int *ack_flag)
+static void tcp_identify_packet_loss(struct sock *sk, int *ack_flag)
 {
        struct tcp_sock *tp = tcp_sk(sk);
 
-       if (tcp_is_rack(sk)) {
+       if (tcp_rtx_queue_empty(sk))
+               return;
+
+       if (unlikely(tcp_is_reno(tp))) {
+               tcp_newreno_mark_lost(sk, *ack_flag & FLAG_SND_UNA_ADVANCED);
+       } else if (tcp_is_rack(sk)) {
                u32 prior_retrans = tp->retrans_out;
 
                tcp_rack_mark_lost(sk);
@@ -2823,11 +2826,11 @@ static void tcp_fastretrans_alert(struct sock *sk, const u32 prior_snd_una,
                        tcp_try_keep_open(sk);
                        return;
                }
-               tcp_rack_identify_loss(sk, ack_flag);
+               tcp_identify_packet_loss(sk, ack_flag);
                break;
        case TCP_CA_Loss:
                tcp_process_loss(sk, flag, is_dupack, rexmit);
-               tcp_rack_identify_loss(sk, ack_flag);
+               tcp_identify_packet_loss(sk, ack_flag);
                if (!(icsk->icsk_ca_state == TCP_CA_Open ||
                      (*ack_flag & FLAG_LOST_RETRANS)))
                        return;
@@ -2844,7 +2847,7 @@ static void tcp_fastretrans_alert(struct sock *sk, const u32 prior_snd_una,
                if (icsk->icsk_ca_state <= TCP_CA_Disorder)
                        tcp_try_undo_dsack(sk);
 
-               tcp_rack_identify_loss(sk, ack_flag);
+               tcp_identify_packet_loss(sk, ack_flag);
                if (!tcp_time_to_recover(sk, flag)) {
                        tcp_try_to_open(sk, flag);
                        return;

diff --git a/net/ipv4/tcp_recovery.c b/net/ipv4/tcp_recovery.c
index 1c1bdf12a96f07114f65a068c44db50d17774381..299b0e38aa9adec75e5346fc34389e51808cc617 100644 (file)
--- a/net/ipv4/tcp_recovery.c
+++ b/net/ipv4/tcp_recovery.c
@@ -216,3 +216,30 @@ void tcp_rack_update_reo_wnd(struct sock *sk, struct rate_sample *rs)
                tp->rack.reo_wnd_steps = 1;
        }
 }
+
+/* RFC6582 NewReno recovery for non-SACK connection. It simply retransmits
+ * the next unacked packet upon receiving
+ * a) three or more DUPACKs to start the fast recovery
+ * b) an ACK acknowledging new data during the fast recovery.
+ */
+void tcp_newreno_mark_lost(struct sock *sk, bool snd_una_advanced)
+{
+       const u8 state = inet_csk(sk)->icsk_ca_state;
+       struct tcp_sock *tp = tcp_sk(sk);
+
+       if ((state < TCP_CA_Recovery && tp->sacked_out >= tp->reordering) ||
+           (state == TCP_CA_Recovery && snd_una_advanced)) {
+               struct sk_buff *skb = tcp_rtx_queue_head(sk);
+               u32 mss;
+
+               if (TCP_SKB_CB(skb)->sacked & TCPCB_LOST)
+                       return;
+
+               mss = tcp_skb_mss(skb);
+               if (tcp_skb_pcount(skb) > 1 && skb->len > mss)
+                       tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
+                                    mss, mss, GFP_ATOMIC);
+
+               tcp_skb_mark_lost_uncond_verify(tp, skb);
+       }
+}