Re: [PATCH net-next v5 2/3] net: prevent mixing frags from different memory providers or bindings
- From
- Stanislav Fomichev <hidden>
- Date
- 2026-11-16 19:05:53
- Also in
- lkml
- Reply to
- Mina Almasry, 2026-11-15
On 11/15, Mina Almasry wrote:
quoted hunk ↗ jump to hunk
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 <redacted> --- 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 bufferdiff --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 todiff --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
[..]
quoted hunk ↗ jump to hunk
@@ -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.