All of lore.kernel.org
 help / color / mirror / Atom feed
From: Stanislav Fomichev <sdf.kernel@gmail.com>
To: Mina Almasry <almasrymina@google.com>
Cc: netdev@vger.kernel.org, Eric Dumazet <edumazet@kernel.org>,
	 Neal Cardwell <ncardwell@google.com>,
	Kuniyuki Iwashima <kuniyu@google.com>,
	 "David S. Miller" <davem@davemloft.net>,
	Jakub Kicinski <kuba@kernel.org>,
	 Paolo Abeni <pabeni@redhat.com>, Simon Horman <horms@kernel.org>,
	linux-kernel@vger.kernel.org,  Josef Bacik <josef@toxicpanda.com>,
	Kaiyuan Zhang <kaiyuanz@google.com>,
	 Willem de Bruijn <willemb@google.com>,
	Bobby Eshleman <bobbyeshleman@meta.com>,
	 Stanislav Fomichev <sdf@fomichev.me>,
	Pavel Begunkov <asml.silence@gmail.com>,
	 Daniel Borkmann <daniel@iogearbox.net>
Subject: Re: [PATCH net-next v5 2/3] net: prevent mixing frags from different memory providers or bindings
Date: Mon, 16 Nov 2026 11:05:08 -0800	[thread overview]
Message-ID: <avtRYLif2GvfuAmu@devvm16445.scu0.facebook.com> (raw)
In-Reply-To: <20261115004003.3695475-3-almasrymina@google.com>

On 11/15, Mina Almasry wrote:
> Prevent coalescing, shifting, or appending skb fragments from
> incompatible memory providers or different devmem bindings.
> 
> Add skb_net_iov_provider(), skb_mem_provider_compat(), and
> skb_frags_can_coalesce() to check readability and fragment provider
> compatibility (net_iov_owner(niov) for devmem, niov->desc.pp for other
> net_iov providers such as io_uring zcrx, and NULL for page-backed skbs)
> across skb_try_coalesce(), skb_shift(), skb_gro_receive(),
> skb_gro_receive_list(), tcp_skb_can_collapse(), and
> tcp_skb_can_collapse_rx().
> 
> Also add net_devmem_skb_binding() and use it in tcp_sendmsg_locked(),
> zerocopy_fill_skb_from_devmem(), and validate_xmit_unreadable_skb() so
> TX skbs cannot mix different devmem bindings or transmit non-devmem
> unreadable frags on DMA TX devices. Reject converting linear head_frag
> payloads into page frags on unreadable skbs in skb_try_coalesce() and
> skb_gro_receive(), and propagate skb->unreadable and compare
> skb_frag_netmem() in tcp_clone_payload().
> 
> Update netmem_ref_test_net_iov and netmem_ref_test_try_coalesce so their
> target skbs carry a compatible unreadable net_iov frag before shifting
> or coalescing.
> 
> This issue was found by manual code inspection and LLM review; it was
> not triggered in production. Verified with the net_core KUnit test
> suite; not tested on real hardware.
> 
> Fixes: 65249feb6b3d ("net: add support for skbs with unreadable frags")
> Fixes: bd61848900bf ("net: devmem: Implement TX path")
> Signed-off-by: Mina Almasry <almasrymina@google.com>
> ---
>  include/linux/skbuff.h | 55 ++++++++++++++++++++++++++++++++++++++++++
>  include/net/tcp.h      |  5 ++--
>  net/core/datagram.c    |  4 +--
>  net/core/dev.c         | 14 ++++-------
>  net/core/devmem.h      | 22 +++++++++++++++++
>  net/core/gro.c         | 16 ++++--------
>  net/core/net_test.c    | 42 +++++++++++++++++++++++++++-----
>  net/core/skbuff.c      | 24 +++++++-----------
>  net/ipv4/tcp.c         |  3 ++-
>  net/ipv4/tcp_output.c  |  4 ++-
>  10 files changed, 142 insertions(+), 47 deletions(-)
> 
> diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
> index 1d6832878930..867e3ab17c17 100644
> --- a/include/linux/skbuff.h
> +++ b/include/linux/skbuff.h
> @@ -3770,6 +3770,61 @@ static inline void *skb_frag_address(const skb_frag_t *frag)
>  	return page_address(skb_frag_page(frag)) + skb_frag_off(frag);
>  }
>  
> +/* Return an opaque pointer identifying the memory provider instance of @skb's
> + * net_iov fragments:
> + * - For devmem (NET_IOV_DMABUF), net_iov_owner(niov) (&binding->area, 1:1 with
> + *   the binding across RX queues and TX).
> + * - For other net_iov providers (e.g., io_uring zcrx), niov->desc.pp (shared
> + *   across all areas of an io_zcrx_ifq).
> + */
> +static inline void *skb_net_iov_provider(const struct sk_buff *skb)
> +{
> +	struct net_iov *niov;
> +
> +	if (skb_frags_readable(skb) || !skb_shinfo(skb)->nr_frags)
> +		return NULL;
> +
> +	niov = skb_frag_net_iov(&skb_shinfo(skb)->frags[0]);
> +	if (!niov)
> +		return NULL;
> +
> +	if (net_is_devmem_iov(niov))
> +		return net_iov_owner(niov);
> +
> +	return niov->desc.pp;
> +}
> +
> +/* Return true if the memory providers of @skb1 and @skb2 are compatible
> + * for coalescing. For any struct page-backed provider (the buddy allocator
> + * or a future provider handing out struct pages), coalescing is assumed
> + * feasible. For net_iov-backed providers, the provider instance pointer
> + * must match.
> + */
> +static inline bool skb_mem_provider_compat(const struct sk_buff *skb1,
> +					   const struct sk_buff *skb2)
> +{
> +	/* Check skb_frags_readable() first to reject readable/unreadable
> +	 * mismatches and avoid chasing frags[0] and struct net_iov when
> +	 * only one skb has unreadable frags.
> +	 */
> +	if (skb_frags_readable(skb1) != skb_frags_readable(skb2))
> +		return false;
> +
> +	return skb_net_iov_provider(skb1) == skb_net_iov_provider(skb2);
> +}
> +
> +static inline bool skb_frags_can_coalesce(struct sk_buff *to,
> +					  struct sk_buff *from)
> +{
> +	if (to->pp_recycle != from->pp_recycle)
> +		return false;
> +
> +	if (skb_zcopy(to) || skb_zcopy(from))
> +		return false;
> +
> +	return skb_mem_provider_compat(to, from);
> +}
> +
>  /**
>   * skb_frag_address_safe - gets the address of the data contained in a paged fragment
>   * @frag: the paged fragment buffer
> diff --git a/include/net/tcp.h b/include/net/tcp.h
> index 25d11fab1b03..bf5f28e52fca 100644
> --- a/include/net/tcp.h
> +++ b/include/net/tcp.h
> @@ -1275,14 +1275,15 @@ static inline bool tcp_skb_can_collapse(const struct sk_buff *to,
>  		      mptcp_skb_can_collapse(to, from) &&
>  		      !skb_cmp_decrypted(to, from) &&
>  		      skb_pure_zcopy_same(to, from) &&
> -		      skb_frags_readable(to) == skb_frags_readable(from));
> +		      skb_mem_provider_compat(to, from));
>  }
>  
>  static inline bool tcp_skb_can_collapse_rx(const struct sk_buff *to,
>  					   const struct sk_buff *from)
>  {
>  	return likely(mptcp_skb_can_collapse(to, from) &&
> -		      !skb_cmp_decrypted(to, from));
> +		      !skb_cmp_decrypted(to, from) &&
> +		      skb_mem_provider_compat(to, from));
>  }
>  
>  /* Events passed to congestion control interface */
> diff --git a/net/core/datagram.c b/net/core/datagram.c
> index ecc30a6f8302..88cc0a6c62f6 100644
> --- a/net/core/datagram.c
> +++ b/net/core/datagram.c
> @@ -712,8 +712,8 @@ zerocopy_fill_skb_from_devmem(struct sk_buff *skb, struct iov_iter *from,
>  	size_t virt_addr, size, off;
>  	struct net_iov *niov;
>  
> -	if (i && skb_frags_readable(skb))
> -		return -EFAULT;
> +	if (i && net_devmem_skb_binding(skb) != binding)
> +		return -EMSGSIZE;
>  
>  	/* Devmem filling works by taking an IOVEC from the user where the
>  	 * iov_addrs are interpreted as an offset in bytes into the dma-buf to
> diff --git a/net/core/dev.c b/net/core/dev.c
> index a230ecce9327..51f5e4800eee 100644
> --- a/net/core/dev.c
> +++ b/net/core/dev.c

[..]

> @@ -4175,8 +4175,7 @@ static struct sk_buff *sk_validate_xmit_skb(struct sk_buff *skb,
>  static struct sk_buff *validate_xmit_unreadable_skb(struct sk_buff *skb,
>  						    struct net_device *dev)
>  {
> -	struct skb_shared_info *shinfo;
> -	struct net_iov *niov;
> +	struct net_devmem_dmabuf_binding *binding;
>  
>  	if (likely(skb_frags_readable(skb) ||
>  		   dev->netmem_tx == NETMEM_TX_NO_DMA))
> @@ -4185,14 +4184,11 @@ static struct sk_buff *validate_xmit_unreadable_skb(struct sk_buff *skb,
>  	if (dev->netmem_tx == NETMEM_TX_NONE)
>  		goto out_free;
>  
> -	shinfo = skb_shinfo(skb);
> -
>  	/* All net_iovs in an unreadable skb share the same binding. */
> -	if (shinfo->nr_frags > 0) {
> -		niov = netmem_to_net_iov(skb_frag_netmem(&shinfo->frags[0]));
> -		if (net_is_devmem_iov(niov) &&
> -		    (net_devmem_iov_binding(niov)->direction != DMA_TO_DEVICE ||
> -		     READ_ONCE(net_devmem_iov_binding(niov)->dev) != dev))
> +	if (skb_shinfo(skb)->nr_frags > 0) {
> +		binding = net_devmem_skb_binding(skb);
> +		if (!binding || binding->direction != DMA_TO_DEVICE ||
> +		    READ_ONCE(binding->dev) != dev)
>  			goto out_free;
>  	}
>  

Should we limit this patch to the real fixes only? This part does
not look essential. validate_xmit_unreadable_skb already does skb_frags_readable
check above, it already does nr_frags > 0 check here...
so why go through the same stuff again via net_devmem_skb_binding?

If you want, maybe move this to a separate patch at least? And do
something like:

binding = net_devmem_skb_binding(skb);
/* I hope likely() below properly unwraps net_devmem_skb_binding similar
 * to existing likely(skb_frags_readable) case... */
if (likely(!binding)) goto out;
if (dev->netmem_tx == NETMEM_TX_NO_DMA) goto out;
if (dev->netmem_tx == NETMEM_TX_NONE) goto out_free;
if (READ_ONCE(binding->dev) != dev) goto out_free;
return skb;

And call it cleanup with no fixes tags.

  reply	other threads:[~2026-11-16 19:05 UTC|newest]

Thread overview: 7+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-15  0:40 [PATCH net-next v5 0/3] net: prevent mixing incompatible memory providers in skbs Mina Almasry
2026-11-15  0:40 ` [PATCH net-next v5 1/3] net: fix skb->unreadable propagation in skb_split() and skb_shift() Mina Almasry
2026-11-15  0:40 ` [PATCH net-next v5 2/3] net: prevent mixing frags from different memory providers or bindings Mina Almasry
2026-11-16 19:05   ` Stanislav Fomichev [this message]
2026-11-16 20:05     ` Mina Almasry
2026-11-16 22:38       ` Stanislav Fomichev
2026-11-15  0:40 ` [PATCH net-next v5 3/3] tcp: propagate skb_zcopy() uarg in tcp_mtu_probe() Mina Almasry

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=avtRYLif2GvfuAmu@devvm16445.scu0.facebook.com \
    --to=sdf.kernel@gmail.com \
    --cc=almasrymina@google.com \
    --cc=asml.silence@gmail.com \
    --cc=bobbyeshleman@meta.com \
    --cc=daniel@iogearbox.net \
    --cc=davem@davemloft.net \
    --cc=edumazet@kernel.org \
    --cc=horms@kernel.org \
    --cc=josef@toxicpanda.com \
    --cc=kaiyuanz@google.com \
    --cc=kuba@kernel.org \
    --cc=kuniyu@google.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=ncardwell@google.com \
    --cc=netdev@vger.kernel.org \
    --cc=pabeni@redhat.com \
    --cc=sdf@fomichev.me \
    --cc=willemb@google.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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.