tcp: move tcp_rack_update_reo_wnd() to tcp_input.c

tcp_rack_update_reo_wnd() is called only once from tcp_ack()

Move it to tcp_input.c so that it can be inlined by the compiler
to save space and cpu cycles.

$ scripts/bloat-o-meter -t vmlinux.old vmlinux.new
add/remove: 0/2 grow/shrink: 1/0 up/down: 110/-153 (-43)
Function                                     old     new   delta
tcp_ack                                     5631    5741    +110
__pfx_tcp_rack_update_reo_wnd                 16       -     -16
tcp_rack_update_reo_wnd                      137       -    -137
Total: Before=22572723, After=22572680, chg -0.00%

Signed-off-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: Kuniyuki Iwashima <kuniyu@google.com>
Link: https://patch.msgid.link/20260127032147.3498272-3-edumazet@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/include/net/tcp.h b/include/net/tcp.h
index efff433de9a41b31cb3d9fbceab1eb9fd4b46e42..a4d9f263ea68cb73d888f252558f372a582321f5 100644 (file)
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -2517,7 +2517,6 @@ extern bool tcp_rack_mark_lost(struct sock *sk);
 extern void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 end_seq,
                             u64 xmit_time);
 extern void tcp_rack_reo_timeout(struct sock *sk);
-extern void tcp_rack_update_reo_wnd(struct sock *sk, struct rate_sample *rs);
 
 /* tcp_plb.c */
 

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index f2fafba9570573c566a6e21cf4663cc8d2b4eb14..d504a9a9b6ec66363ab5537907522a2d73d019a4 100644 (file)
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -4149,6 +4149,49 @@ static u32 tcp_newly_delivered(struct sock *sk, u32 prior_delivered,
        return delivered;
 }
 
+/* Updates the RACK's reo_wnd based on DSACK and no. of recoveries.
+ *
+ * If a DSACK is received that seems like it may have been due to reordering
+ * triggering fast recovery, increment reo_wnd by min_rtt/4 (upper bounded
+ * by srtt), since there is possibility that spurious retransmission was
+ * due to reordering delay longer than reo_wnd.
+ *
+ * Persist the current reo_wnd value for TCP_RACK_RECOVERY_THRESH (16)
+ * no. of successful recoveries (accounts for full DSACK-based loss
+ * recovery undo). After that, reset it to default (min_rtt/4).
+ *
+ * At max, reo_wnd is incremented only once per rtt. So that the new
+ * DSACK on which we are reacting, is due to the spurious retx (approx)
+ * after the reo_wnd has been updated last time.
+ *
+ * reo_wnd is tracked in terms of steps (of min_rtt/4), rather than
+ * absolute value to account for change in rtt.
+ */
+static void tcp_rack_update_reo_wnd(struct sock *sk, struct rate_sample *rs)
+{
+       struct tcp_sock *tp = tcp_sk(sk);
+
+       if ((READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_recovery) &
+            TCP_RACK_STATIC_REO_WND) ||
+           !rs->prior_delivered)
+               return;
+
+       /* Disregard DSACK if a rtt has not passed since we adjusted reo_wnd */
+       if (before(rs->prior_delivered, tp->rack.last_delivered))
+               tp->rack.dsack_seen = 0;
+
+       /* Adjust the reo_wnd if update is pending */
+       if (tp->rack.dsack_seen) {
+               tp->rack.reo_wnd_steps = min_t(u32, 0xFF,
+                                              tp->rack.reo_wnd_steps + 1);
+               tp->rack.dsack_seen = 0;
+               tp->rack.last_delivered = tp->delivered;
+               tp->rack.reo_wnd_persist = TCP_RACK_RECOVERY_THRESH;
+       } else if (!tp->rack.reo_wnd_persist) {
+               tp->rack.reo_wnd_steps = 1;
+       }
+}
+
 /* This routine deals with incoming acks, but not outgoing ones. */
 static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
 {

diff --git a/net/ipv4/tcp_recovery.c b/net/ipv4/tcp_recovery.c
index c52fd3254b6e04678b1506fa575cea45ceefa67d..40732b84771e6db4267a71d51631699425ac1a7b 100644 (file)
--- a/net/ipv4/tcp_recovery.c
+++ b/net/ipv4/tcp_recovery.c
@@ -166,49 +166,6 @@ void tcp_rack_reo_timeout(struct sock *sk)
                tcp_rearm_rto(sk);
 }
 
-/* Updates the RACK's reo_wnd based on DSACK and no. of recoveries.
- *
- * If a DSACK is received that seems like it may have been due to reordering
- * triggering fast recovery, increment reo_wnd by min_rtt/4 (upper bounded
- * by srtt), since there is possibility that spurious retransmission was
- * due to reordering delay longer than reo_wnd.
- *
- * Persist the current reo_wnd value for TCP_RACK_RECOVERY_THRESH (16)
- * no. of successful recoveries (accounts for full DSACK-based loss
- * recovery undo). After that, reset it to default (min_rtt/4).
- *
- * At max, reo_wnd is incremented only once per rtt. So that the new
- * DSACK on which we are reacting, is due to the spurious retx (approx)
- * after the reo_wnd has been updated last time.
- *
- * reo_wnd is tracked in terms of steps (of min_rtt/4), rather than
- * absolute value to account for change in rtt.
- */
-void tcp_rack_update_reo_wnd(struct sock *sk, struct rate_sample *rs)
-{
-       struct tcp_sock *tp = tcp_sk(sk);
-
-       if ((READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_recovery) &
-            TCP_RACK_STATIC_REO_WND) ||
-           !rs->prior_delivered)
-               return;
-
-       /* Disregard DSACK if a rtt has not passed since we adjusted reo_wnd */
-       if (before(rs->prior_delivered, tp->rack.last_delivered))
-               tp->rack.dsack_seen = 0;
-
-       /* Adjust the reo_wnd if update is pending */
-       if (tp->rack.dsack_seen) {
-               tp->rack.reo_wnd_steps = min_t(u32, 0xFF,
-                                              tp->rack.reo_wnd_steps + 1);
-               tp->rack.dsack_seen = 0;
-               tp->rack.last_delivered = tp->delivered;
-               tp->rack.reo_wnd_persist = TCP_RACK_RECOVERY_THRESH;
-       } else if (!tp->rack.reo_wnd_persist) {
-               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