1 files changed, 35 insertions, 31 deletions

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 52b5c2d0ecd0..2877c3e09587 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -322,7 +322,7 @@ static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb)
         /* Check #1 */
         if (tp->rcv_ssthresh < tp->window_clamp &&
             (int)tp->rcv_ssthresh < tcp_space(sk) &&
-            !tcp_memory_pressure) {
+            !sk_under_memory_pressure(sk)) {
                 int incr;
 
                 /* Check #2. Increase window, if skb with such overhead
@@ -411,8 +411,8 @@ static void tcp_clamp_window(struct sock *sk)
 
         if (sk->sk_rcvbuf < sysctl_tcp_rmem[2] &&
             !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
-            !tcp_memory_pressure &&
-            atomic_long_read(&tcp_memory_allocated) < sysctl_tcp_mem[0]) {
+            !sk_under_memory_pressure(sk) &&
+            sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)) {
                 sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
                                     sysctl_tcp_rmem[2]);
         }
@@ -865,13 +865,13 @@ static void tcp_disable_fack(struct tcp_sock *tp)
         /* RFC3517 uses different metric in lost marker => reset on change */
         if (tcp_is_fack(tp))
                 tp->lost_skb_hint = NULL;
-        tp->rx_opt.sack_ok &= ~2;
+        tp->rx_opt.sack_ok &= ~TCP_FACK_ENABLED;
 }
 
 /* Take a notice that peer is sending D-SACKs */
 static void tcp_dsack_seen(struct tcp_sock *tp)
 {
-        tp->rx_opt.sack_ok |= 4;
+        tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
 }
 
 /* Initialize metrics on socket. */
@@ -2663,7 +2663,7 @@ static void DBGUNDO(struct sock *sk, const char *msg)
                        tp->snd_ssthresh, tp->prior_ssthresh,
                        tp->packets_out);
         }
-#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+#if IS_ENABLED(CONFIG_IPV6)
         else if (sk->sk_family == AF_INET6) {
                 struct ipv6_pinfo *np = inet6_sk(sk);
                 printk(KERN_DEBUG "Undo %s %pI6/%u c%u l%u ss%u/%u p%u\n",
@@ -2858,7 +2858,7 @@ static void tcp_try_keep_open(struct sock *sk)
         struct tcp_sock *tp = tcp_sk(sk);
         int state = TCP_CA_Open;
 
-        if (tcp_left_out(tp) || tcp_any_retrans_done(sk) || tp->undo_marker)
+        if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
                 state = TCP_CA_Disorder;
 
         if (inet_csk(sk)->icsk_ca_state != state) {
@@ -2881,7 +2881,8 @@ static void tcp_try_to_open(struct sock *sk, int flag)
 
         if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
                 tcp_try_keep_open(sk);
-                tcp_moderate_cwnd(tp);
+                if (inet_csk(sk)->icsk_ca_state != TCP_CA_Open)
+                        tcp_moderate_cwnd(tp);
         } else {
                 tcp_cwnd_down(sk, flag);
         }
@@ -3009,11 +3010,11 @@ static void tcp_update_cwnd_in_recovery(struct sock *sk, int newly_acked_sacked,
  * tcp_xmit_retransmit_queue().
  */
 static void tcp_fastretrans_alert(struct sock *sk, int pkts_acked,
-                                  int newly_acked_sacked, int flag)
+                                  int newly_acked_sacked, bool is_dupack,
+                                  int flag)
 {
         struct inet_connection_sock *icsk = inet_csk(sk);
         struct tcp_sock *tp = tcp_sk(sk);
-        int is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
         int do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
                                     (tcp_fackets_out(tp) > tp->reordering));
         int fast_rexmit = 0, mib_idx;
@@ -3066,17 +3067,6 @@ static void tcp_fastretrans_alert(struct sock *sk, int pkts_acked,
                         }
                         break;
 
-                case TCP_CA_Disorder:
-                        tcp_try_undo_dsack(sk);
-                        if (!tp->undo_marker ||
-                            /* For SACK case do not Open to allow to undo
-                             * catching for all duplicate ACKs. */
-                            tcp_is_reno(tp) || tp->snd_una != tp->high_seq) {
-                                tp->undo_marker = 0;
-                                tcp_set_ca_state(sk, TCP_CA_Open);
-                        }
-                        break;
-
                 case TCP_CA_Recovery:
                         if (tcp_is_reno(tp))
                                 tcp_reset_reno_sack(tp);
@@ -3117,7 +3107,7 @@ static void tcp_fastretrans_alert(struct sock *sk, int pkts_acked,
                                 tcp_add_reno_sack(sk);
                 }
 
-                if (icsk->icsk_ca_state == TCP_CA_Disorder)
+                if (icsk->icsk_ca_state <= TCP_CA_Disorder)
                         tcp_try_undo_dsack(sk);
 
                 if (!tcp_time_to_recover(sk)) {
@@ -3681,10 +3671,12 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
         u32 prior_snd_una = tp->snd_una;
         u32 ack_seq = TCP_SKB_CB(skb)->seq;
         u32 ack = TCP_SKB_CB(skb)->ack_seq;
+        bool is_dupack = false;
         u32 prior_in_flight;
         u32 prior_fackets;
         int prior_packets;
         int prior_sacked = tp->sacked_out;
+        int pkts_acked = 0;
         int newly_acked_sacked = 0;
         int frto_cwnd = 0;
 
@@ -3757,6 +3749,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
         /* See if we can take anything off of the retransmit queue. */
         flag |= tcp_clean_rtx_queue(sk, prior_fackets, prior_snd_una);
 
+        pkts_acked = prior_packets - tp->packets_out;
         newly_acked_sacked = (prior_packets - prior_sacked) -
                              (tp->packets_out - tp->sacked_out);
 
@@ -3771,8 +3764,9 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
                 if ((flag & FLAG_DATA_ACKED) && !frto_cwnd &&
                     tcp_may_raise_cwnd(sk, flag))
                         tcp_cong_avoid(sk, ack, prior_in_flight);
-                tcp_fastretrans_alert(sk, prior_packets - tp->packets_out,
-                                      newly_acked_sacked, flag);
+                is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
+                tcp_fastretrans_alert(sk, pkts_acked, newly_acked_sacked,
+                                      is_dupack, flag);
         } else {
                 if ((flag & FLAG_DATA_ACKED) && !frto_cwnd)
                         tcp_cong_avoid(sk, ack, prior_in_flight);
@@ -3784,6 +3778,10 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
         return 1;
 
 no_queue:
+        /* If data was DSACKed, see if we can undo a cwnd reduction. */
+        if (flag & FLAG_DSACKING_ACK)
+                tcp_fastretrans_alert(sk, pkts_acked, newly_acked_sacked,
+                                      is_dupack, flag);
         /* If this ack opens up a zero window, clear backoff.  It was
          * being used to time the probes, and is probably far higher than
          * it needs to be for normal retransmission.
@@ -3797,10 +3795,14 @@ invalid_ack:
         return -1;
 
 old_ack:
+        /* If data was SACKed, tag it and see if we should send more data.
+         * If data was DSACKed, see if we can undo a cwnd reduction.
+         */
         if (TCP_SKB_CB(skb)->sacked) {
-                tcp_sacktag_write_queue(sk, skb, prior_snd_una);
-                if (icsk->icsk_ca_state == TCP_CA_Open)
-                        tcp_try_keep_open(sk);
+                flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una);
+                newly_acked_sacked = tp->sacked_out - prior_sacked;
+                tcp_fastretrans_alert(sk, pkts_acked, newly_acked_sacked,
+                                      is_dupack, flag);
         }
 
         SOCK_DEBUG(sk, "Ack %u before %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
@@ -3876,7 +3878,7 @@ void tcp_parse_options(const struct sk_buff *skb, struct tcp_options_received *o
                         case TCPOPT_SACK_PERM:
                                 if (opsize == TCPOLEN_SACK_PERM && th->syn &&
                                     !estab && sysctl_tcp_sack) {
-                                        opt_rx->sack_ok = 1;
+                                        opt_rx->sack_ok = TCP_SACK_SEEN;
                                         tcp_sack_reset(opt_rx);
                                 }
                                 break;
@@ -4864,7 +4866,7 @@ static int tcp_prune_queue(struct sock *sk)
 
         if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
                 tcp_clamp_window(sk);
-        else if (tcp_memory_pressure)
+        else if (sk_under_memory_pressure(sk))
                 tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);
 
         tcp_collapse_ofo_queue(sk);
@@ -4930,11 +4932,11 @@ static int tcp_should_expand_sndbuf(const struct sock *sk)
                 return 0;
 
         /* If we are under global TCP memory pressure, do not expand.  */
-        if (tcp_memory_pressure)
+        if (sk_under_memory_pressure(sk))
                 return 0;
 
         /* If we are under soft global TCP memory pressure, do not expand.  */
-        if (atomic_long_read(&tcp_memory_allocated) >= sysctl_tcp_mem[0])
+        if (sk_memory_allocated(sk) >= sk_prot_mem_limits(sk, 0))
                 return 0;
 
         /* If we filled the congestion window, do not expand.  */
@@ -5809,6 +5811,8 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                         goto discard;
 
                 if (th->syn) {
+                        if (th->fin)
+                                goto discard;
                         if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
                                 return 1;