tcp: remove thin_dupack feature

Thin stream DUPACK is to start fast recovery on only one DUPACK
provided the connection is a thin stream (i.e., low inflight).  But
this older feature is now subsumed with RACK. If a connection
receives only a single DUPACK, RACK would arm a reordering timer
and soon starts fast recovery instead of timeout if no further
ACKs are received.

The socket option (THIN_DUPACK) is kept as a nop for compatibility.
Note that this patch does not change another thin-stream feature
which enables linear RTO. Although it might be good to generalize
that in the future (i.e., linear RTO for the first say 3 retries).

Signed-off-by: Yuchung Cheng <ycheng@google.com>
Signed-off-by: Neal Cardwell <ncardwell@google.com>
Acked-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/Documentation/networking/ip-sysctl.txt b/Documentation/networking/ip-sysctl.txt
index 7de2cf79e16fb09fd1e588a97c4f4da10d2d523c..aa1bb49f1dc67fbea70812aef6f72ce8663f5680 100644 (file)
--- a/Documentation/networking/ip-sysctl.txt
+++ b/Documentation/networking/ip-sysctl.txt
@@ -703,18 +703,6 @@ tcp_thin_linear_timeouts - BOOLEAN
        Documentation/networking/tcp-thin.txt
        Default: 0
 
-tcp_thin_dupack - BOOLEAN
-       Enable dynamic triggering of retransmissions after one dupACK
-       for thin streams. If set, a check is performed upon reception
-       of a dupACK to determine if the stream is thin (less than 4
-       packets in flight). As long as the stream is found to be thin,
-       data is retransmitted on the first received dupACK. This
-       improves retransmission latency for non-aggressive thin
-       streams, often found to be time-dependent.
-       For more information on thin streams, see
-       Documentation/networking/tcp-thin.txt
-       Default: 0
-
 tcp_limit_output_bytes - INTEGER
        Controls TCP Small Queue limit per tcp socket.
        TCP bulk sender tends to increase packets in flight until it

diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 4733368f953a95b2cec77b5d0a50261393d2deae..6c22332afb759a02cb93d5d05135add81f4339eb 100644 (file)
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -220,7 +220,7 @@ struct tcp_sock {
                unused:5;
        u8      nonagle     : 4,/* Disable Nagle algorithm?             */
                thin_lto    : 1,/* Use linear timeouts for thin streams */
-               thin_dupack : 1,/* Fast retransmit on first dupack      */
+               unused1     : 1,
                repair      : 1,
                frto        : 1;/* F-RTO (RFC5682) activated in CA_Loss */
        u8      repair_queue;

diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 0f2d37e8e983d93245e52b041a146210e657a655..c8d283615c6fb9806e0095445c926195b3e28ec6 100644 (file)
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -536,13 +536,6 @@ static struct ctl_table ipv4_table[] = {
                .mode           = 0644,
                .proc_handler   = proc_dointvec
        },
-       {
-               .procname       = "tcp_thin_dupack",
-               .data           = &sysctl_tcp_thin_dupack,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = proc_dointvec
-       },
        {
                .procname       = "tcp_early_retrans",
                .data           = &sysctl_tcp_early_retrans,

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index d9023e8ed53e862366435ff641e52ec06bb0e88e..aba6ea76338e35e36124580dcab3c80e3c638659 100644 (file)
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -2474,9 +2474,6 @@ static int do_tcp_setsockopt(struct sock *sk, int level,
        case TCP_THIN_DUPACK:
                if (val < 0 || val > 1)
                        err = -EINVAL;
-               else {
-                       tp->thin_dupack = val;
-               }
                break;
 
        case TCP_REPAIR:
@@ -2966,8 +2963,9 @@ static int do_tcp_getsockopt(struct sock *sk, int level,
        case TCP_THIN_LINEAR_TIMEOUTS:
                val = tp->thin_lto;
                break;
+
        case TCP_THIN_DUPACK:
-               val = tp->thin_dupack;
+               val = 0;
                break;
 
        case TCP_REPAIR:

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 87315ab1ab1ac3dc2bce4471a490821dbb2467ca..39ebc20ca1b2ae943e54b58c1797b8a24920aca4 100644 (file)
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -95,9 +95,6 @@ int sysctl_tcp_rfc1337 __read_mostly;
 int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
 int sysctl_tcp_frto __read_mostly = 2;
 int sysctl_tcp_min_rtt_wlen __read_mostly = 300;
-
-int sysctl_tcp_thin_dupack __read_mostly;
-
 int sysctl_tcp_moderate_rcvbuf __read_mostly = 1;
 int sysctl_tcp_early_retrans __read_mostly = 3;
 int sysctl_tcp_invalid_ratelimit __read_mostly = HZ/2;
@@ -2170,16 +2167,6 @@ static bool tcp_time_to_recover(struct sock *sk, int flag)
        if (tcp_dupack_heuristics(tp) > tp->reordering)
                return true;
 
-       /* If a thin stream is detected, retransmit after first
-        * received dupack. Employ only if SACK is supported in order
-        * to avoid possible corner-case series of spurious retransmissions
-        * Use only if there are no unsent data.
-        */
-       if ((tp->thin_dupack || sysctl_tcp_thin_dupack) &&
-           tcp_stream_is_thin(tp) && tcp_dupack_heuristics(tp) > 1 &&
-           tcp_is_sack(tp) && !tcp_send_head(sk))
-               return true;
-
        return false;
 }