Netdev List
 help / color / mirror / Atom feed
From: "David Hildenbrand (Arm)" <david@kernel.org>
To: Stanislav Fomichev <sdf.kernel@gmail.com>
Cc: "David S. Miller" <davem@davemloft.net>,
	Eric Dumazet <edumazet@kernel.org>,
	Jakub Kicinski <kuba@kernel.org>, Paolo Abeni <pabeni@redhat.com>,
	Simon Horman <horms@kernel.org>,
	Andrew Morton <akpm@linux-foundation.org>,
	Kiryl Shutsemau <kas@kernel.org>,
	Song Liu <songliubraving@fb.com>,
	Johannes Weiner <hannes@cmpxchg.org>,
	Rik van Riel <riel@surriel.com>,
	"Matthew Wilcox (Oracle)" <willy@infradead.org>,
	Neal Cardwell <ncardwell@google.com>,
	Kuniyuki Iwashima <kuniyu@google.com>,
	Pedro Falcato <pfalcato@suse.de>,
	netdev@vger.kernel.org, linux-kernel@vger.kernel.org,
	linux-mm@kvack.org, stable@vger.kernel.org
Subject: Re: [PATCH net 1/4] net: skbuff: limit folio refcount when copying skb frag references
Date: Fri, 20 Nov 2026 22:01:15 +0100	[thread overview]
Message-ID: <cd61f39f-db93-4f37-9836-7a81f7a82f9c@kernel.org> (raw)
In-Reply-To: <awBy7PoxdEMEGWyW@devvm16445.scu0.facebook.com>

On 11/20/26 17:21, Stanislav Fomichev wrote:
> On 11/18, David Hildenbrand (Arm) wrote:
>> Various networking features copy frag references of an skb, for example
>> when unsharing a cloned skb (AF_PACKET trimming a clone), when copying an
>> skb (nft dup) or when building NFQUEUE messages. This is an effective
>> way for multiplying folio references held by an skb, allowing for
>> exceeding folio refcount limits.
>>
>> This is not specific to large pagecache folios, but with them it is a
>> lot easier to reach the refcount limit, as page table mappings can cheaply
>> create many references.
>>
>> Let's introduce skb_frag_try_ref() and skb_frags_try_ref(), which use
>> try_get_page(), and use them in pskb_expand_head(), __pskb_copy_fclone(),
>> skb_zerocopy() and pskb_carve_inside_*(). All of these can already fail,
>> and their callers handle that.
>>
>> Fixes: 800d8c63b2e9 ("shmem: add huge pages support")
>> Fixes: 99cb0dbd47a1 ("mm,thp: add read-only THP support for (non-shmem) FS")
>> Fixes: 793917d997df ("mm/readahead: Add large folio readahead")
>> Cc: stable@vger.kernel.org
>> Acked-by: Pedro Falcato <pfalcato@suse.de>
>> Signed-off-by: David Hildenbrand (Arm) <david@kernel.org>
>> ---
>>  include/linux/skbuff_ref.h | 53 ++++++++++++++++++++++++++++++++++++++++++++++
>>  net/core/skbuff.c          | 35 +++++++++++++++++++-----------
>>  2 files changed, 76 insertions(+), 12 deletions(-)
>>
>> diff --git a/include/linux/skbuff_ref.h b/include/linux/skbuff_ref.h
>> index b6f6da556ee90..560ddc863bbec 100644
>> --- a/include/linux/skbuff_ref.h
>> +++ b/include/linux/skbuff_ref.h
>> @@ -44,6 +44,33 @@ static __always_inline void skb_frag_ref(struct sk_buff *skb, int f)
>>  		       skb->pp_recycle);
>>  }
>>  
>> +/**
>> + * skb_frag_try_ref - try to acquire a reference on a paged fragment of an skb
>> + * @skb: the buffer
>> + * @f: the fragment offset
>> + *
>> + * Like skb_frag_ref(), but acquires non-page_pool page references using
>> + * try_get_page(), refusing additional references to a page whose refcount is
>> + * at its limit.
>> + *
>> + * Return: True if a reference was acquired, otherwise false.
>> + */
>> +static __always_inline __must_check bool skb_frag_try_ref(struct sk_buff *skb,
>> +							  int f)
>> +{
>> +	netmem_ref netmem = skb_frag_netmem(&skb_shinfo(skb)->frags[f]);
>> +
>> +#ifdef CONFIG_PAGE_POOL
>> +	if (skb->pp_recycle && napi_pp_get_page(netmem))
>> +		return true;
>> +#endif
>> +	if (netmem_is_net_iov(netmem)) {
>> +		net_iov_inc_ref(netmem_to_net_iov(netmem));
>> +		return true;
>> +	}
>> +	return try_get_page(netmem_to_page(netmem));
>> +}
> 

Hi,

thanks for taking a look!

> I don't see you removing original skb_frag_ref implementations after
> the conversion, any specific reason? 

As explained in the cover letter, I want to get these fixes here upstream asap,
to backport them alongside the core fixes that already landed.

The focus is on the skb users that allow for multiplying folio references easily.

> Do we still have any skb_frag_ref
> callers left? 

Yes, after this series there are still some left. Primarily ones that are not
considered harmful for overflowing the refcount. And some of these require a bit
more work to convert, like skb_split().

> Maybe at least you can make skb_frag_ref do 'return
> (void)skb_frag_try_ref' to avoid duplicate code?

That would be bad: calling code would assume that it obtained a reference but it
actually didn't.

There is some headroom above the folio refcount limit to allow for such harmless
users that are not converted yet. The immediate problems are the users that
allow for unbounded folio references.

> 
> (optional) Also, an easier way to migrate might be to make the existing
> skb_frag_ref return bool, convert everything, and then add __must_check.

That would require teaching all callers about handling errors in one go, because
callers would otherwise silently ignore failures. That's nothing we can
backport, really.

I agree that as a follow-up, all code should be converted to use a single
function that can fail.

But that's nothing for this series that focuses on fixing folio refcounts in a
way that can be backported.

Thanks!

-- 
Cheers,

David

  reply	other threads:[~2026-11-20 21:01 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18  8:32 [PATCH net 0/4] net: skbuff: limit pagecache folio refcount David Hildenbrand (Arm)
2026-11-18  8:32 ` [PATCH net 1/4] net: skbuff: limit folio refcount when copying skb frag references David Hildenbrand (Arm)
2026-11-19 13:53   ` David Hildenbrand (Arm)
2026-11-20 16:21   ` Stanislav Fomichev
2026-11-20 21:01     ` David Hildenbrand (Arm) [this message]
2026-11-18  8:32 ` [PATCH net 2/4] net: skbuff: limit folio refcount when rearranging skb frags David Hildenbrand (Arm)
2026-11-18  8:32 ` [PATCH net 3/4] net: skbuff: limit folio refcount when splicing pages into skbs David Hildenbrand (Arm)
2026-11-18  8:32 ` [PATCH net 4/4] net: skbuff: limit folio refcount when splicing from sockets David Hildenbrand (Arm)

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=cd61f39f-db93-4f37-9836-7a81f7a82f9c@kernel.org \
    --to=david@kernel.org \
    --cc=akpm@linux-foundation.org \
    --cc=davem@davemloft.net \
    --cc=edumazet@kernel.org \
    --cc=hannes@cmpxchg.org \
    --cc=horms@kernel.org \
    --cc=kas@kernel.org \
    --cc=kuba@kernel.org \
    --cc=kuniyu@google.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-mm@kvack.org \
    --cc=ncardwell@google.com \
    --cc=netdev@vger.kernel.org \
    --cc=pabeni@redhat.com \
    --cc=pfalcato@suse.de \
    --cc=riel@surriel.com \
    --cc=sdf.kernel@gmail.com \
    --cc=songliubraving@fb.com \
    --cc=stable@vger.kernel.org \
    --cc=willy@infradead.org \
    /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