[PATCH v2 net-next 4/4] tcp: move __reqsk_free() out of line

[PATCH v2 net-next 4/4] tcp: move __reqsk_free() out of line

[Eric Dumazet]

Inlining __reqsk_free() is overkill, let's reclaim 2 Kbytes of text.

$ scripts/bloat-o-meter -t vmlinux.old vmlinux.new
add/remove: 2/4 grow/shrink: 2/14 up/down: 225/-2338 (-2113)
Function                                     old     new   delta
__reqsk_free                                   -     114    +114
sock_edemux                                   18      82     +64
inet_csk_listen_start                        233     264     +31
__pfx___reqsk_free                             -      16     +16
__pfx_reqsk_queue_alloc                       16       -     -16
__pfx_reqsk_free                              16       -     -16
reqsk_queue_alloc                             46       -     -46
tcp_req_err                                  272     177     -95
reqsk_fastopen_remove                        348     253     -95
cookie_bpf_check                             157      62     -95
cookie_tcp_reqsk_alloc                       387     290     -97
cookie_v4_check                             1568    1465    -103
reqsk_free                                   105       -    -105
cookie_v6_check                             1519    1412    -107
sock_gen_put                                 187      78    -109
sock_pfree                                   212      82    -130
tcp_try_fastopen                            1818    1683    -135
tcp_v4_rcv                                  3478    3294    -184
reqsk_put                                    306      90    -216
tcp_get_cookie_sock                          551     318    -233
tcp_v6_rcv                                  3404    3141    -263
tcp_conn_request                            2677    2384    -293
Total: Before=24887415, After=24885302, chg -0.01%

Signed-off-by: Eric Dumazet <edumazet@google.com>
---
 include/net/request_sock.h      |  9 +--------
 net/ipv4/inet_connection_sock.c | 10 ++++++++++
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 23bb909771fb..5a9c826a7092 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -123,14 +123,7 @@ static inline struct sock *skb_steal_sock(struct sk_buff *skb,
 	return sk;
 }
 
-static inline void __reqsk_free(struct request_sock *req)
-{
-	req->rsk_ops->destructor(req);
-	if (req->rsk_listener)
-		sock_put(req->rsk_listener);
-	kfree(req->saved_syn);
-	kmem_cache_free(req->rsk_ops->slab, req);
-}
+void __reqsk_free(struct request_sock *req);
 
 static inline void reqsk_free(struct request_sock *req)
 {
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index dc4e2c5725cd..3d0997c39418 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -918,6 +918,16 @@ struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
 }
 EXPORT_SYMBOL(inet_reqsk_alloc);
 
+void __reqsk_free(struct request_sock *req)
+{
+	req->rsk_ops->destructor(req);
+	if (req->rsk_listener)
+		sock_put(req->rsk_listener);
+	kfree(req->saved_syn);
+	kmem_cache_free(req->rsk_ops->slab, req);
+}
+EXPORT_IPV6_MOD_GPL(__reqsk_free);
+
 static struct request_sock *inet_reqsk_clone(struct request_sock *req,
 					     struct sock *sk)
 {
-- 
2.53.0.rc1.225.gd81095ad13-goog

Re: [PATCH v2 net-next 4/4] tcp: move __reqsk_free() out of line

[Kuniyuki Iwashima]

On Mon, Feb 2, 2026 at 9:22 PM Eric Dumazet <edumazet@google.com> wrote:
>
> Inlining __reqsk_free() is overkill, let's reclaim 2 Kbytes of text.
>
> $ scripts/bloat-o-meter -t vmlinux.old vmlinux.new
> add/remove: 2/4 grow/shrink: 2/14 up/down: 225/-2338 (-2113)
> Function                                     old     new   delta
> __reqsk_free                                   -     114    +114
> sock_edemux                                   18      82     +64
> inet_csk_listen_start                        233     264     +31
> __pfx___reqsk_free                             -      16     +16
> __pfx_reqsk_queue_alloc                       16       -     -16
> __pfx_reqsk_free                              16       -     -16
> reqsk_queue_alloc                             46       -     -46
> tcp_req_err                                  272     177     -95
> reqsk_fastopen_remove                        348     253     -95
> cookie_bpf_check                             157      62     -95
> cookie_tcp_reqsk_alloc                       387     290     -97
> cookie_v4_check                             1568    1465    -103
> reqsk_free                                   105       -    -105
> cookie_v6_check                             1519    1412    -107
> sock_gen_put                                 187      78    -109
> sock_pfree                                   212      82    -130
> tcp_try_fastopen                            1818    1683    -135
> tcp_v4_rcv                                  3478    3294    -184
> reqsk_put                                    306      90    -216
> tcp_get_cookie_sock                          551     318    -233
> tcp_v6_rcv                                  3404    3141    -263
> tcp_conn_request                            2677    2384    -293
> Total: Before=24887415, After=24885302, chg -0.01%
>
> Signed-off-by: Eric Dumazet <edumazet@google.com>
> ---
>  include/net/request_sock.h      |  9 +--------
>  net/ipv4/inet_connection_sock.c | 10 ++++++++++
>  2 files changed, 11 insertions(+), 8 deletions(-)
>
> diff --git a/include/net/request_sock.h b/include/net/request_sock.h
> index 23bb909771fb..5a9c826a7092 100644
> --- a/include/net/request_sock.h
> +++ b/include/net/request_sock.h
> @@ -123,14 +123,7 @@ static inline struct sock *skb_steal_sock(struct sk_buff *skb,
>         return sk;
>  }
>
> -static inline void __reqsk_free(struct request_sock *req)
> -{
> -       req->rsk_ops->destructor(req);
> -       if (req->rsk_listener)
> -               sock_put(req->rsk_listener);
> -       kfree(req->saved_syn);
> -       kmem_cache_free(req->rsk_ops->slab, req);
> -}
> +void __reqsk_free(struct request_sock *req);
>
>  static inline void reqsk_free(struct request_sock *req)
>  {
> diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
> index dc4e2c5725cd..3d0997c39418 100644
> --- a/net/ipv4/inet_connection_sock.c
> +++ b/net/ipv4/inet_connection_sock.c
> @@ -918,6 +918,16 @@ struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
>  }
>  EXPORT_SYMBOL(inet_reqsk_alloc);
>
> +void __reqsk_free(struct request_sock *req)
> +{
> +       req->rsk_ops->destructor(req);
> +       if (req->rsk_listener)
> +               sock_put(req->rsk_listener);
> +       kfree(req->saved_syn);
> +       kmem_cache_free(req->rsk_ops->slab, req);
> +}
> +EXPORT_IPV6_MOD_GPL(__reqsk_free);

Probably this needs to be EXPORT_SYMBOL_GPL() due to
drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c ?


> +
>  static struct request_sock *inet_reqsk_clone(struct request_sock *req,
>                                              struct sock *sk)
>  {
> --
> 2.53.0.rc1.225.gd81095ad13-goog
>

Re: [PATCH v2 net-next 4/4] tcp: move __reqsk_free() out of line

[Eric Dumazet]

On Wed, Feb 4, 2026 at 1:38 AM Kuniyuki Iwashima <kuniyu@google.com> wrote:
>
> On Mon, Feb 2, 2026 at 9:22 PM Eric Dumazet <edumazet@google.com> wrote:
> >
> > Inlining __reqsk_free() is overkill, let's reclaim 2 Kbytes of text.
> >

> > +void __reqsk_free(struct request_sock *req)
> > +{
> > +       req->rsk_ops->destructor(req);
> > +       if (req->rsk_listener)
> > +               sock_put(req->rsk_listener);
> > +       kfree(req->saved_syn);
> > +       kmem_cache_free(req->rsk_ops->slab, req);
> > +}
> > +EXPORT_IPV6_MOD_GPL(__reqsk_free);
>
> Probably this needs to be EXPORT_SYMBOL_GPL() due to
> drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c ?
>

Good catch indeed :/

What an abomination this copy/paste of TCP stack.

Will send this change in V2, thanks.

[PATCH v2 net-next 0/4] tcp: remove net/core/request_sock.c and no longer inline __reqsk_free()

[Eric Dumazet]

After DCCP removal, net/core/request_sock.c makes no more sense.

Move reqsk_queue_alloc() and reqsk_fastopen_remove() to TCP files.

Then put __reqsk_free() out of line to save ~2 Kbytes of text.

v2: use EXPORT_SYMBOL_GPL() instead of EXPORT_IPV6_MOD_GPL for
    __reqsk_free (Kuniyuki)

Eric Dumazet (4):
  inet: move reqsk_queue_alloc() to net/ipv4/inet_connection_sock.c
  tcp: move reqsk_fastopen_remove to net/ipv4/tcp_fastopen.c
  net: get rid of net/core/request_sock.c
  tcp: move __reqsk_free() out of line

 include/net/request_sock.h      |  11 +--
 net/core/Makefile               |   2 +-
 net/core/request_sock.c         | 127 --------------------------------
 net/ipv4/inet_connection_sock.c |  19 +++++
 net/ipv4/tcp_fastopen.c         |  86 +++++++++++++++++++++
 5 files changed, 107 insertions(+), 138 deletions(-)
 delete mode 100644 net/core/request_sock.c

-- 
2.53.0.rc2.204.g2597b5adb4-goog

[PATCH v2 net-next 1/4] inet: move reqsk_queue_alloc() to net/ipv4/inet_connection_sock.c

[Eric Dumazet]

Only called once from inet_csk_listen_start(), it can be static.

Signed-off-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: Kuniyuki Iwashima <kuniyu@google.com>
---
 include/net/request_sock.h      |  2 --
 net/core/request_sock.c         | 24 ------------------------
 net/ipv4/inet_connection_sock.c |  9 +++++++++
 3 files changed, 9 insertions(+), 26 deletions(-)

diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 9b9e04f6bb8931088d9bb2fa7d4420fecf235895..23bb909771fbacbbd31f614b1754f0c24e602645 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -196,8 +196,6 @@ struct request_sock_queue {
 					     */
 };
 
-void reqsk_queue_alloc(struct request_sock_queue *queue);
-
 void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,
 			   bool reset);
 
diff --git a/net/core/request_sock.c b/net/core/request_sock.c
index 897a8f01a67b4e09197da2241bc5c33ea3d90c29..31389f875b19b56592e81576b8812359017daac9 100644
--- a/net/core/request_sock.c
+++ b/net/core/request_sock.c
@@ -16,30 +16,6 @@
 
 #include <net/request_sock.h>
 
-/*
- * Maximum number of SYN_RECV sockets in queue per LISTEN socket.
- * One SYN_RECV socket costs about 80bytes on a 32bit machine.
- * It would be better to replace it with a global counter for all sockets
- * but then some measure against one socket starving all other sockets
- * would be needed.
- *
- * The minimum value of it is 128. Experiments with real servers show that
- * it is absolutely not enough even at 100conn/sec. 256 cures most
- * of problems.
- * This value is adjusted to 128 for low memory machines,
- * and it will increase in proportion to the memory of machine.
- * Note : Dont forget somaxconn that may limit backlog too.
- */
-
-void reqsk_queue_alloc(struct request_sock_queue *queue)
-{
-	queue->fastopenq.rskq_rst_head = NULL;
-	queue->fastopenq.rskq_rst_tail = NULL;
-	queue->fastopenq.qlen = 0;
-
-	queue->rskq_accept_head = NULL;
-}
-
 /*
  * This function is called to set a Fast Open socket's "fastopen_rsk" field
  * to NULL when a TFO socket no longer needs to access the request_sock.
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 018e8ffc07176dd4f6ecbaae5697b90b67cb1294..60f2ee039c05f46bdb95f6211a8f9eafbedb9610 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -1314,6 +1314,15 @@ static int inet_ulp_can_listen(const struct sock *sk)
 	return 0;
 }
 
+static void reqsk_queue_alloc(struct request_sock_queue *queue)
+{
+	queue->fastopenq.rskq_rst_head = NULL;
+	queue->fastopenq.rskq_rst_tail = NULL;
+	queue->fastopenq.qlen = 0;
+
+	queue->rskq_accept_head = NULL;
+}
+
 int inet_csk_listen_start(struct sock *sk)
 {
 	struct inet_connection_sock *icsk = inet_csk(sk);
-- 
2.53.0.rc2.204.g2597b5adb4-goog

[PATCH v2 net-next 2/4] tcp: move reqsk_fastopen_remove to net/ipv4/tcp_fastopen.c

[Eric Dumazet]

This function belongs to TCP stack, not to net/core/request_sock.c

We get rid of the now empty request_sock.c n the following patch.

Signed-off-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: Kuniyuki Iwashima <kuniyu@google.com>
---
 net/core/request_sock.c | 85 ----------------------------------------
 net/ipv4/tcp_fastopen.c | 86 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 86 insertions(+), 85 deletions(-)

diff --git a/net/core/request_sock.c b/net/core/request_sock.c
index 31389f875b19b56592e81576b8812359017daac9..e6c451e549ce4fb316b1afc0b40dff68b66e0a0f 100644
--- a/net/core/request_sock.c
+++ b/net/core/request_sock.c
@@ -16,88 +16,3 @@
 
 #include <net/request_sock.h>
 
-/*
- * This function is called to set a Fast Open socket's "fastopen_rsk" field
- * to NULL when a TFO socket no longer needs to access the request_sock.
- * This happens only after 3WHS has been either completed or aborted (e.g.,
- * RST is received).
- *
- * Before TFO, a child socket is created only after 3WHS is completed,
- * hence it never needs to access the request_sock. things get a lot more
- * complex with TFO. A child socket, accepted or not, has to access its
- * request_sock for 3WHS processing, e.g., to retransmit SYN-ACK pkts,
- * until 3WHS is either completed or aborted. Afterwards the req will stay
- * until either the child socket is accepted, or in the rare case when the
- * listener is closed before the child is accepted.
- *
- * In short, a request socket is only freed after BOTH 3WHS has completed
- * (or aborted) and the child socket has been accepted (or listener closed).
- * When a child socket is accepted, its corresponding req->sk is set to
- * NULL since it's no longer needed. More importantly, "req->sk == NULL"
- * will be used by the code below to determine if a child socket has been
- * accepted or not, and the check is protected by the fastopenq->lock
- * described below.
- *
- * Note that fastopen_rsk is only accessed from the child socket's context
- * with its socket lock held. But a request_sock (req) can be accessed by
- * both its child socket through fastopen_rsk, and a listener socket through
- * icsk_accept_queue.rskq_accept_head. To protect the access a simple spin
- * lock per listener "icsk->icsk_accept_queue.fastopenq->lock" is created.
- * only in the rare case when both the listener and the child locks are held,
- * e.g., in inet_csk_listen_stop() do we not need to acquire the lock.
- * The lock also protects other fields such as fastopenq->qlen, which is
- * decremented by this function when fastopen_rsk is no longer needed.
- *
- * Note that another solution was to simply use the existing socket lock
- * from the listener. But first socket lock is difficult to use. It is not
- * a simple spin lock - one must consider sock_owned_by_user() and arrange
- * to use sk_add_backlog() stuff. But what really makes it infeasible is the
- * locking hierarchy violation. E.g., inet_csk_listen_stop() may try to
- * acquire a child's lock while holding listener's socket lock.
- *
- * This function also sets "treq->tfo_listener" to false.
- * treq->tfo_listener is used by the listener so it is protected by the
- * fastopenq->lock in this function.
- */
-void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,
-			   bool reset)
-{
-	struct sock *lsk = req->rsk_listener;
-	struct fastopen_queue *fastopenq;
-
-	fastopenq = &inet_csk(lsk)->icsk_accept_queue.fastopenq;
-
-	RCU_INIT_POINTER(tcp_sk(sk)->fastopen_rsk, NULL);
-	spin_lock_bh(&fastopenq->lock);
-	fastopenq->qlen--;
-	tcp_rsk(req)->tfo_listener = false;
-	if (req->sk)	/* the child socket hasn't been accepted yet */
-		goto out;
-
-	if (!reset || lsk->sk_state != TCP_LISTEN) {
-		/* If the listener has been closed don't bother with the
-		 * special RST handling below.
-		 */
-		spin_unlock_bh(&fastopenq->lock);
-		reqsk_put(req);
-		return;
-	}
-	/* Wait for 60secs before removing a req that has triggered RST.
-	 * This is a simple defense against TFO spoofing attack - by
-	 * counting the req against fastopen.max_qlen, and disabling
-	 * TFO when the qlen exceeds max_qlen.
-	 *
-	 * For more details see CoNext'11 "TCP Fast Open" paper.
-	 */
-	req->rsk_timer.expires = jiffies + 60*HZ;
-	if (fastopenq->rskq_rst_head == NULL)
-		fastopenq->rskq_rst_head = req;
-	else
-		fastopenq->rskq_rst_tail->dl_next = req;
-
-	req->dl_next = NULL;
-	fastopenq->rskq_rst_tail = req;
-	fastopenq->qlen++;
-out:
-	spin_unlock_bh(&fastopenq->lock);
-}
diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c
index 7d945a527daf093f87882c7949e21058ed6df1cc..b30090cff3cf7d925dc46694860abd3ca5516d70 100644
--- a/net/ipv4/tcp_fastopen.c
+++ b/net/ipv4/tcp_fastopen.c
@@ -5,6 +5,92 @@
 #include <net/tcp.h>
 #include <net/busy_poll.h>
 
+/*
+ * This function is called to set a Fast Open socket's "fastopen_rsk" field
+ * to NULL when a TFO socket no longer needs to access the request_sock.
+ * This happens only after 3WHS has been either completed or aborted (e.g.,
+ * RST is received).
+ *
+ * Before TFO, a child socket is created only after 3WHS is completed,
+ * hence it never needs to access the request_sock. things get a lot more
+ * complex with TFO. A child socket, accepted or not, has to access its
+ * request_sock for 3WHS processing, e.g., to retransmit SYN-ACK pkts,
+ * until 3WHS is either completed or aborted. Afterwards the req will stay
+ * until either the child socket is accepted, or in the rare case when the
+ * listener is closed before the child is accepted.
+ *
+ * In short, a request socket is only freed after BOTH 3WHS has completed
+ * (or aborted) and the child socket has been accepted (or listener closed).
+ * When a child socket is accepted, its corresponding req->sk is set to
+ * NULL since it's no longer needed. More importantly, "req->sk == NULL"
+ * will be used by the code below to determine if a child socket has been
+ * accepted or not, and the check is protected by the fastopenq->lock
+ * described below.
+ *
+ * Note that fastopen_rsk is only accessed from the child socket's context
+ * with its socket lock held. But a request_sock (req) can be accessed by
+ * both its child socket through fastopen_rsk, and a listener socket through
+ * icsk_accept_queue.rskq_accept_head. To protect the access a simple spin
+ * lock per listener "icsk->icsk_accept_queue.fastopenq->lock" is created.
+ * only in the rare case when both the listener and the child locks are held,
+ * e.g., in inet_csk_listen_stop() do we not need to acquire the lock.
+ * The lock also protects other fields such as fastopenq->qlen, which is
+ * decremented by this function when fastopen_rsk is no longer needed.
+ *
+ * Note that another solution was to simply use the existing socket lock
+ * from the listener. But first socket lock is difficult to use. It is not
+ * a simple spin lock - one must consider sock_owned_by_user() and arrange
+ * to use sk_add_backlog() stuff. But what really makes it infeasible is the
+ * locking hierarchy violation. E.g., inet_csk_listen_stop() may try to
+ * acquire a child's lock while holding listener's socket lock.
+ *
+ * This function also sets "treq->tfo_listener" to false.
+ * treq->tfo_listener is used by the listener so it is protected by the
+ * fastopenq->lock in this function.
+ */
+void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,
+			   bool reset)
+{
+	struct sock *lsk = req->rsk_listener;
+	struct fastopen_queue *fastopenq;
+
+	fastopenq = &inet_csk(lsk)->icsk_accept_queue.fastopenq;
+
+	RCU_INIT_POINTER(tcp_sk(sk)->fastopen_rsk, NULL);
+	spin_lock_bh(&fastopenq->lock);
+	fastopenq->qlen--;
+	tcp_rsk(req)->tfo_listener = false;
+	if (req->sk)	/* the child socket hasn't been accepted yet */
+		goto out;
+
+	if (!reset || lsk->sk_state != TCP_LISTEN) {
+		/* If the listener has been closed don't bother with the
+		 * special RST handling below.
+		 */
+		spin_unlock_bh(&fastopenq->lock);
+		reqsk_put(req);
+		return;
+	}
+	/* Wait for 60secs before removing a req that has triggered RST.
+	 * This is a simple defense against TFO spoofing attack - by
+	 * counting the req against fastopen.max_qlen, and disabling
+	 * TFO when the qlen exceeds max_qlen.
+	 *
+	 * For more details see CoNext'11 "TCP Fast Open" paper.
+	 */
+	req->rsk_timer.expires = jiffies + 60*HZ;
+	if (fastopenq->rskq_rst_head == NULL)
+		fastopenq->rskq_rst_head = req;
+	else
+		fastopenq->rskq_rst_tail->dl_next = req;
+
+	req->dl_next = NULL;
+	fastopenq->rskq_rst_tail = req;
+	fastopenq->qlen++;
+out:
+	spin_unlock_bh(&fastopenq->lock);
+}
+
 void tcp_fastopen_init_key_once(struct net *net)
 {
 	u8 key[TCP_FASTOPEN_KEY_LENGTH];
-- 
2.53.0.rc2.204.g2597b5adb4-goog

[PATCH v2 net-next 3/4] net: get rid of net/core/request_sock.c

[Eric Dumazet]

After DCCP removal, this file was not needed any more.

Signed-off-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: Kuniyuki Iwashima <kuniyu@google.com>
---
 net/core/Makefile       |  2 +-
 net/core/request_sock.c | 18 ------------------
 2 files changed, 1 insertion(+), 19 deletions(-)
 delete mode 100644 net/core/request_sock.c

diff --git a/net/core/Makefile b/net/core/Makefile
index d643a5a7fd18bd22ba8f62593f6bf0e99f9ccd2b..dc17c5a61e9a4ab2231bc7ccbd447ed206e449fc 100644
--- a/net/core/Makefile
+++ b/net/core/Makefile
@@ -3,7 +3,7 @@
 # Makefile for the Linux networking core.
 #
 
-obj-y := sock.o request_sock.o skbuff.o datagram.o stream.o scm.o \
+obj-y := sock.o skbuff.o datagram.o stream.o scm.o \
 	 gen_stats.o gen_estimator.o net_namespace.o secure_seq.o \
 	 flow_dissector.o
 
diff --git a/net/core/request_sock.c b/net/core/request_sock.c
deleted file mode 100644
index e6c451e549ce4fb316b1afc0b40dff68b66e0a0f..0000000000000000000000000000000000000000
--- a/net/core/request_sock.c
+++ /dev/null
@@ -1,18 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * NET		Generic infrastructure for Network protocols.
- *
- * Authors:	Arnaldo Carvalho de Melo <acme@conectiva.com.br>
- *
- * 		From code originally in include/net/tcp.h
- */
-
-#include <linux/module.h>
-#include <linux/random.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/tcp.h>
-#include <linux/vmalloc.h>
-
-#include <net/request_sock.h>
-
-- 
2.53.0.rc2.204.g2597b5adb4-goog

[PATCH v2 net-next 4/4] tcp: move __reqsk_free() out of line

[Eric Dumazet]

Inlining __reqsk_free() is overkill, let's reclaim 2 Kbytes of text.

$ scripts/bloat-o-meter -t vmlinux.old vmlinux.new
add/remove: 2/4 grow/shrink: 2/14 up/down: 225/-2338 (-2113)
Function                                     old     new   delta
__reqsk_free                                   -     114    +114
sock_edemux                                   18      82     +64
inet_csk_listen_start                        233     264     +31
__pfx___reqsk_free                             -      16     +16
__pfx_reqsk_queue_alloc                       16       -     -16
__pfx_reqsk_free                              16       -     -16
reqsk_queue_alloc                             46       -     -46
tcp_req_err                                  272     177     -95
reqsk_fastopen_remove                        348     253     -95
cookie_bpf_check                             157      62     -95
cookie_tcp_reqsk_alloc                       387     290     -97
cookie_v4_check                             1568    1465    -103
reqsk_free                                   105       -    -105
cookie_v6_check                             1519    1412    -107
sock_gen_put                                 187      78    -109
sock_pfree                                   212      82    -130
tcp_try_fastopen                            1818    1683    -135
tcp_v4_rcv                                  3478    3294    -184
reqsk_put                                    306      90    -216
tcp_get_cookie_sock                          551     318    -233
tcp_v6_rcv                                  3404    3141    -263
tcp_conn_request                            2677    2384    -293
Total: Before=24887415, After=24885302, chg -0.01%

Signed-off-by: Eric Dumazet <edumazet@google.com>
---
v2: use EXPORT_SYMBOL_GPL() instead of EXPORT_IPV6_MOD_GPL for
    __reqsk_free (Kuniyuki)

 include/net/request_sock.h      |  9 +--------
 net/ipv4/inet_connection_sock.c | 10 ++++++++++
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 23bb909771fbacbbd31f614b1754f0c24e602645..5a9c826a7092ddfdbe5a6450a1b01677cb7e670b 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -123,14 +123,7 @@ static inline struct sock *skb_steal_sock(struct sk_buff *skb,
 	return sk;
 }
 
-static inline void __reqsk_free(struct request_sock *req)
-{
-	req->rsk_ops->destructor(req);
-	if (req->rsk_listener)
-		sock_put(req->rsk_listener);
-	kfree(req->saved_syn);
-	kmem_cache_free(req->rsk_ops->slab, req);
-}
+void __reqsk_free(struct request_sock *req);
 
 static inline void reqsk_free(struct request_sock *req)
 {
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 60f2ee039c05f46bdb95f6211a8f9eafbedb9610..5dfac6ce1110b3276fa8aaa02440c774c6a58176 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -919,6 +919,16 @@ struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
 }
 EXPORT_SYMBOL(inet_reqsk_alloc);
 
+void __reqsk_free(struct request_sock *req)
+{
+	req->rsk_ops->destructor(req);
+	if (req->rsk_listener)
+		sock_put(req->rsk_listener);
+	kfree(req->saved_syn);
+	kmem_cache_free(req->rsk_ops->slab, req);
+}
+EXPORT_SYMBOL_GPL(__reqsk_free);
+
 static struct request_sock *inet_reqsk_clone(struct request_sock *req,
 					     struct sock *sk)
 {
-- 
2.53.0.rc2.204.g2597b5adb4-goog

Re: [PATCH v2 net-next 4/4] tcp: move __reqsk_free() out of line

[Kuniyuki Iwashima]

On Tue, Feb 3, 2026 at 9:51 PM Eric Dumazet <edumazet@google.com> wrote:
>
> Inlining __reqsk_free() is overkill, let's reclaim 2 Kbytes of text.
>
> $ scripts/bloat-o-meter -t vmlinux.old vmlinux.new
> add/remove: 2/4 grow/shrink: 2/14 up/down: 225/-2338 (-2113)
> Function                                     old     new   delta
> __reqsk_free                                   -     114    +114
> sock_edemux                                   18      82     +64
> inet_csk_listen_start                        233     264     +31
> __pfx___reqsk_free                             -      16     +16
> __pfx_reqsk_queue_alloc                       16       -     -16
> __pfx_reqsk_free                              16       -     -16
> reqsk_queue_alloc                             46       -     -46
> tcp_req_err                                  272     177     -95
> reqsk_fastopen_remove                        348     253     -95
> cookie_bpf_check                             157      62     -95
> cookie_tcp_reqsk_alloc                       387     290     -97
> cookie_v4_check                             1568    1465    -103
> reqsk_free                                   105       -    -105
> cookie_v6_check                             1519    1412    -107
> sock_gen_put                                 187      78    -109
> sock_pfree                                   212      82    -130
> tcp_try_fastopen                            1818    1683    -135
> tcp_v4_rcv                                  3478    3294    -184
> reqsk_put                                    306      90    -216
> tcp_get_cookie_sock                          551     318    -233
> tcp_v6_rcv                                  3404    3141    -263
> tcp_conn_request                            2677    2384    -293
> Total: Before=24887415, After=24885302, chg -0.01%
>
> Signed-off-by: Eric Dumazet <edumazet@google.com>

Reviewed-by: Kuniyuki Iwashima <kuniyu@google.com>

Re: [PATCH v2 net-next 0/4] tcp: remove net/core/request_sock.c and no longer inline __reqsk_free()

[patchwork-bot+netdevbpf]

Hello:

This series was applied to netdev/net-next.git (main)
by Jakub Kicinski <kuba@kernel.org>:

On Wed,  4 Feb 2026 05:51:43 +0000 you wrote:
> After DCCP removal, net/core/request_sock.c makes no more sense.
> 
> Move reqsk_queue_alloc() and reqsk_fastopen_remove() to TCP files.
> 
> Then put __reqsk_free() out of line to save ~2 Kbytes of text.
> 
> v2: use EXPORT_SYMBOL_GPL() instead of EXPORT_IPV6_MOD_GPL for
>     __reqsk_free (Kuniyuki)
> 
> [...]

Here is the summary with links:
  - [v2,net-next,1/4] inet: move reqsk_queue_alloc() to net/ipv4/inet_connection_sock.c
    https://git.kernel.org/netdev/net-next/c/d5c539155431
  - [v2,net-next,2/4] tcp: move reqsk_fastopen_remove to net/ipv4/tcp_fastopen.c
    https://git.kernel.org/netdev/net-next/c/a90765c6f603
  - [v2,net-next,3/4] net: get rid of net/core/request_sock.c
    https://git.kernel.org/netdev/net-next/c/7d2064eb7317
  - [v2,net-next,4/4] tcp: move __reqsk_free() out of line
    https://git.kernel.org/netdev/net-next/c/22c1264415ef

You are awesome, thank you!
-- 
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html