From: Kuniyuki Iwashima <kuniyu@google.com>
To: Eric Dumazet <edumazet@kernel.org>,
Neal Cardwell <ncardwell@google.com>,
"David S . Miller" <davem@davemloft.net>,
Jakub Kicinski <kuba@kernel.org>, Paolo Abeni <pabeni@redhat.com>,
Matthieu Baerts <matttbe@kernel.org>,
Mat Martineau <martineau@kernel.org>
Cc: Simon Horman <horms@kernel.org>,
Kuniyuki Iwashima <kuniyu@google.com>,
Kuniyuki Iwashima <kuni1840@gmail.com>,
netdev@vger.kernel.org, mptcp@lists.linux.dev
Subject: [PATCH v2 net-next 4/7] tcp: Skip collapsing if collapsed skb is less-dense.
Date: Mon, 16 Nov 2026 23:05:28 +0000 [thread overview]
Message-ID: <20261116230555.2305867-5-kuniyu@google.com> (raw)
In-Reply-To: <20261116230555.2305867-1-kuniyu@google.com>
Once tcp_collapse() finds a collapsible skb, it collapses
consecutive bloated skbs.
However, the end result could be the same or larger than
as is in some cases:
1. skb is already minimum
If SKB_HEAD_ALIGN(len) <= SKB_SMALL_HEAD_CACHE_SIZE,
skb is allocated from skbuff_small_head, and skb->truesize
never changes.
2. SKB_HEAD_ALIGN() and kmalloc_size_roundup() in alloc_skb()
Assume two bloated skbs with len = 1448 B (truesize =
2304 B, scaling_ratio = 160) and len = 300 B (truesize =
896 B, scaling_ratio = 85), whose total truesize is
3200 B.
Collapsing them calls alloc_skb(1748), which rounds up
SKB_HEAD_ALIGN(1748) = 2112 B to 4096 B and allocates a
new skb with truesize = 4352 B (+1152 B!).
Even worse, in case 1, such a skb is reallocated repeatedly
by every tcp_collapse() in vain.
Let's calculate the final collapsed truesize before collapsing
skbs and skip the range if it does not shrink.
We could allocate skbs first and calculate the new truesize,
but given tcp_collapse() is called under memory pressure,
we want to avoid unnecessary allocation.
Note that kmalloc_reserve_size() uses __always_inline so that
this change does not affect non-FDO builds, and returns 0 when
skb_small_head_cache is used, similar to kmalloc_pfmemalloc().
Signed-off-by: Kuniyuki Iwashima <kuniyu@google.com>
---
v2: Add compute_skb_truesize() instead of macro
---
include/linux/skbuff.h | 2 ++
net/core/skbuff.c | 26 +++++++++++++++++++++++---
net/ipv4/tcp_input.c | 24 +++++++++++++++++++++++-
3 files changed, 48 insertions(+), 4 deletions(-)
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 1d6832878930..310e4881045b 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -274,6 +274,8 @@
SKB_DATA_ALIGN(sizeof(struct sk_buff)) + \
SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
+unsigned int compute_skb_truesize(unsigned int size, gfp_t flags);
+
struct net_device;
struct scatterlist;
struct pipe_inode_info;
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 2e81aacc998b..a89eaadc729f 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -589,6 +589,17 @@ struct sk_buff *napi_build_skb(void *data, unsigned int frag_size)
}
EXPORT_SYMBOL(napi_build_skb);
+static __always_inline size_t kmalloc_reserve_size(unsigned int size, gfp_t flags)
+{
+ size_t obj_size = SKB_HEAD_ALIGN(size);
+
+ if (obj_size <= SKB_SMALL_HEAD_CACHE_SIZE &&
+ !(flags & KMALLOC_NOT_NORMAL_BITS))
+ return 0;
+
+ return kmalloc_size_roundup(obj_size);
+}
+
static void *kmalloc_pfmemalloc(size_t obj_size, gfp_t flags, int node)
{
if (!gfp_pfmemalloc_allowed(flags))
@@ -612,9 +623,8 @@ static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node,
size_t obj_size;
void *obj;
- obj_size = SKB_HEAD_ALIGN(*size);
- if (obj_size <= SKB_SMALL_HEAD_CACHE_SIZE &&
- !(flags & KMALLOC_NOT_NORMAL_BITS)) {
+ obj_size = kmalloc_reserve_size(*size, flags);
+ if (!obj_size) {
obj = kmem_cache_alloc_node(net_hotdata.skb_small_head_cache,
flags | __GFP_NOMEMALLOC | __GFP_NOWARN,
node);
@@ -651,6 +661,16 @@ static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node,
return obj;
}
+unsigned int compute_skb_truesize(unsigned int size, gfp_t flags)
+{
+ size_t obj_size = kmalloc_reserve_size(size, flags);
+
+ if (!obj_size)
+ obj_size = SKB_SMALL_HEAD_CACHE_SIZE;
+
+ return obj_size + SKB_DATA_ALIGN(sizeof(struct sk_buff));
+}
+
/* Allocate a new skbuff. We do this ourselves so we can fill in a few
* 'private' fields and also do memory statistics to find all the
* [BEEP] leaks.
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 5bd42a74c6f5..0815e1891fba 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -5850,8 +5850,10 @@ static void
tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root,
struct sk_buff *head, struct sk_buff *tail, u32 start)
{
+ int old_truesize, new_truesize;
struct sk_buff *skb = head, *n;
struct sk_buff_head tmp;
+ int remainder, nskbs;
u8 scaling_ratio;
u32 sub_end;
@@ -5891,6 +5893,7 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root,
/* Second, find consecutive collapsible skb. */
sub_end = TCP_SKB_CB(skb)->end_seq;
+ old_truesize = skb->truesize;
for (n = tcp_skb_next(skb, list); n && n != tail; n = tcp_skb_next(n, list)) {
if (!skb_frags_readable(n) ||
@@ -5898,8 +5901,10 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root,
!tcp_skb_can_collapse_rx(skb, n))
break;
- if (!after(TCP_SKB_CB(n)->end_seq, sub_end))
+ if (!after(TCP_SKB_CB(n)->end_seq, sub_end)) {
+ old_truesize += n->truesize;
continue;
+ }
/* seq and end_seq must increase monotonically for rbtree. */
if ((list || !before(TCP_SKB_CB(n)->seq, sub_end)) &&
@@ -5908,6 +5913,23 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root,
break;
sub_end = TCP_SKB_CB(n)->end_seq;
+ old_truesize += n->truesize;
+ }
+
+ /* Third, check if the new skbs have high density. */
+ nskbs = (sub_end - start) / TCP_COLLAPSE_MAX_SIZE;
+ new_truesize = nskbs * SKB_TRUESIZE(TCP_COLLAPSE_MAX_SIZE);
+
+ remainder = (sub_end - start) % TCP_COLLAPSE_MAX_SIZE;
+ if (remainder) {
+ nskbs++;
+ new_truesize += compute_skb_truesize(remainder, GFP_ATOMIC);
+ }
+
+ if (old_truesize <= new_truesize) {
+ start = sub_end;
+ skb = n;
+ goto restart;
}
while (before(start, sub_end)) {
--
2.56.0.679.gc527c65306-goog
next prev parent reply other threads:[~2026-11-16 23:06 UTC|newest]
Thread overview: 8+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 23:05 [PATCH v2 net-next 0/7] tcp: Prevent tcp_collapse() from bloating queue Kuniyuki Iwashima
2026-11-16 23:05 ` [PATCH v2 net-next 1/7] tcp: Refactor the first loop in tcp_collapse() Kuniyuki Iwashima
2026-11-16 23:05 ` [PATCH v2 net-next 2/7] tcp: Don't collapse high density skb Kuniyuki Iwashima
2026-11-16 23:05 ` [PATCH v2 net-next 3/7] tcp: Stop collapsing if not bloated Kuniyuki Iwashima
2026-11-16 23:05 ` Kuniyuki Iwashima [this message]
2026-11-16 23:05 ` [PATCH v2 net-next 5/7] tcp: Allocate all new skb before collapsing Kuniyuki Iwashima
2026-11-16 23:05 ` [PATCH v2 net-next 6/7] tcp: Batch memory accounting in tcp_collapse() Kuniyuki Iwashima
2026-11-16 23:05 ` [PATCH v2 net-next 7/7] selftest: packetdrill: Add test for tcp_collapse() Kuniyuki Iwashima
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261116230555.2305867-5-kuniyu@google.com \
--to=kuniyu@google.com \
--cc=davem@davemloft.net \
--cc=edumazet@kernel.org \
--cc=horms@kernel.org \
--cc=kuba@kernel.org \
--cc=kuni1840@gmail.com \
--cc=martineau@kernel.org \
--cc=matttbe@kernel.org \
--cc=mptcp@lists.linux.dev \
--cc=ncardwell@google.com \
--cc=netdev@vger.kernel.org \
--cc=pabeni@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox