All of lore.kernel.org
 help / color / mirror / Atom feed
From: Maciej Fijalkowski <maciej.fijalkowski@intel.com>
To: Magnus Karlsson <magnus.karlsson@intel.com>
Cc: <netdev@vger.kernel.org>, <magnus.karlsson@gmail.com>,
	<sdf@fomichev.me>,  <davem@davemloft.net>, <edumazet@kernel.org>,
	<kuba@kernel.org>, <pabeni@redhat.com>, <horms@kernel.org>,
	<bjorn@kernel.org>, <kerneljasonxing@gmail.com>,
	<intel-wired-lan@lists.osuosl.org>, <anthony.l.nguyen@intel.com>,
	<przemyslaw.kitszel@intel.com>, <jacob.e.keller@intel.com>
Subject: Re: [PATCH net-next 1/5] xsk: add USO support for skb path
Date: Thu, 19 Nov 2026 19:47:13 +0100	[thread overview]
Message-ID: <av9EMbwng6Oc7chm@boxer> (raw)
In-Reply-To: <20261119165340.1071525-2-magnus.karlsson@intel.com>

On Thu, Nov 19, 2026 at 05:53:36PM +0100, Magnus Karlsson wrote:
> Add UDP Segmentation Offload (USO) to the AF_XDP Tx metadata interface
> and implement it for copy mode. An application submits one Ethernet
> frame holding a single IP and UDP header followed by the aggregate UDP
> payload, and the device emits a train of MTU-sized UDP datagrams.
> 
> The uAPI adds the XDP_TXMD_FLAGS_USO flag and splits the reserved u32
> in the request part of struct xsk_tx_metadata into two u16 fields:
> gso_size, the UDP payload bytes per output datagram, and
> network_offset, the IP header offset. USO requires
> XDP_TXMD_FLAGS_CHECKSUM, with csum_start pointing at the UDP header,
> csum_offset at its checksum field and the checksum field seeded with
> the partial pseudoheader checksum of the aggregate packet. It cannot
> be combined with XDP_TXMD_FLAGS_TIMESTAMP or
> XDP_UMEM_TX_SW_CSUM. Launch time is supported and applies to the start
> of the segmented packet.
> 
> The request is turned into a GSO skb of type SKB_GSO_UDP_L4. Before
> transmission, the headers are validated. The link layer is not parsed:
> the IP header starts at network_offset and its version selects
> unfragmented IPv4 or IPv6 without extension headers, followed by UDP.
> The IP and UDP lengths must describe the aggregate packet, every output
> datagram must fit the MTU, and the number of segments is limited to
> UDP_MAX_SEGMENTS. As skb drivers find L3 through the EtherType, the skb
> path also requires the EtherType, after any VLAN tags, to lead to the
> same IP header. A request that fits in one datagram is sent as an
> ordinary checksum offload request.
> 
> network_offset is part of the uAPI because csum_start only locates L4,
> while segmentation also needs the start of L3: the device rewrites the
> IP header of every datagram and needs the L2 and L3 lengths, and on
> the skb path it becomes the network header. With it, the kernel does
> not need to understand the link layer, and the fields can be reused
> later. Any future tunnel segmentation extension to the uAPI could then
> treat network_offset as the outer L3 offset and csum_start as the
> inner L4 offset, adding only the outer L4 and inner L3 offsets.
> 
> AF_XDP never segments these packets itself. A request that produces more
> than one datagram is rejected unless the bound device advertises
> NETIF_F_GSO_UDP_L4, and the GSO skb is passed to its driver unsegmented.
> As with UDP_SEGMENT sockets, how the segmentation is carried out is up
> to the driver. Stacked devices such as VLAN or bonding forward the
> packet to a lower device that may segment it in software.
> 
> A new pool field, tx_uso_supported, records whether USO requests are
> accepted on a pool. It is set only for Ethernet devices (ARPHRD_ETHER)
> and is cleared when XDP_UMEM_TX_SW_CSUM is used.
> 
> A USO request that fails validation is dropped: its buffers are
> completed and counted in tx_invalid_descs. Errors in other Tx metadata
> keep failing sendmsg() and leave the descriptor on the Tx ring, so the
> existing behaviour for non-USO requests is unchanged. A USO request
> that cannot be processed for lack of memory is also left on the Tx
> ring, and sendmsg() fails with -EAGAIN, unless part of it was already
> released to user space, either by an earlier call or while peeking
> further descriptors. That part may already have been reused, so the
> request is then dropped.
> 
> The header validator works on a raw header copy instead of an skb, so
> that the zero-copy path in a later patch can reuse it. It lives in
> the new files net/xdp/xsk_tx_uso.c and include/net/xsk_tx_uso.h.
> 
> Signed-off-by: Magnus Karlsson <magnus.karlsson@intel.com>

Hmm - this looks good to me!
Reviewed-by: Maciej Fijalkowski <maciej.fijalkowski@intel.com>

I only had minor comments/questions.

> ---
>  Documentation/networking/xsk-tx-metadata.rst |  91 +++++++++++++
>  MAINTAINERS                                  |   1 +
>  include/net/xdp_sock_drv.h                   |  12 ++
>  include/net/xsk_buff_pool.h                  |   4 +
>  include/net/xsk_tx_uso.h                     |  30 +++++
>  include/uapi/linux/if_xdp.h                  |  13 +-
>  net/xdp/Makefile                             |   1 +
>  net/xdp/xsk.c                                | 130 +++++++++++++++++--
>  net/xdp/xsk_buff_pool.c                      |   4 +
>  net/xdp/xsk_queue.h                          |   6 +
>  net/xdp/xsk_tx_uso.c                         |  77 +++++++++++
>  tools/include/uapi/linux/if_xdp.h            |  13 +-
>  12 files changed, 371 insertions(+), 11 deletions(-)
>  create mode 100644 include/net/xsk_tx_uso.h
>  create mode 100644 net/xdp/xsk_tx_uso.c
> 
> diff --git a/Documentation/networking/xsk-tx-metadata.rst b/Documentation/networking/xsk-tx-metadata.rst
> index ac15e5fddc6b..41cfc5482b15 100644
> --- a/Documentation/networking/xsk-tx-metadata.rst
> +++ b/Documentation/networking/xsk-tx-metadata.rst
> @@ -55,6 +55,9 @@ The flags field enables the particular offload:
>    packet for transmission at a pre-determined time called launch time. The
>    value of launch time is indicated by ``request.launch_time`` field of
>    ``struct xsk_tx_metadata``.
> +- ``XDP_TXMD_FLAGS_USO``: requests UDP segmentation offload.
> +  ``request.gso_size`` specifies UDP payload bytes per output datagram;
> +  ``request.network_offset`` identifies the IP header.
>  
>  Besides the flags above, in order to trigger the offloads, the first
>  packet's ``struct xdp_desc`` descriptor should set ``XDP_TX_METADATA``
> @@ -70,6 +73,69 @@ In this case, when running in ``XDP_COPY`` mode, the TX checksum
>  is calculated on the CPU. Do not enable this option in production because
>  it will negatively affect performance.
>  
> +UDP Segmentation
> +================
> +
> +To request UDP segmentation offload (USO), bind the socket in
> +``XDP_COPY`` mode and set ``XDP_TXMD_FLAGS_USO | XDP_TXMD_FLAGS_CHECKSUM``
> +in the Tx metadata. Reserve at least 16 bytes of metadata and set
> +``XDP_TX_METADATA`` on the first descriptor of the packet.
> +
> +Submit an Ethernet frame containing one IP header, one UDP header, and the
> +aggregate UDP payload. Set ``request.network_offset`` to the IP header
> +offset, ``request.csum_start`` to the UDP header offset, and
> +``request.csum_offset`` to the UDP checksum field offset (6 bytes).
> +Header offsets are measured from the first descriptor's packet-data address,
> +excluding metadata. Set ``request.gso_size`` to the number of UDP payload
> +bytes per output datagram, excluding headers; the last datagram may be
> +shorter.
> +
> +USO is only available on Ethernet devices. ``request.network_offset``
> +locates the IP header, and its version selects IPv4 or IPv6. In copy mode,
> +the EtherType, after up to six VLAN tags, must lead to the same IP header,
> +since drivers rely on it. IPv4 headers may carry options but must not be
> +fragmented. In IPv6, the UDP header must directly follow the fixed header;
> +extension headers are not supported.
> +
> +The IP and UDP lengths must describe the aggregate packet. Initialize the
> +UDP checksum field with the partial pseudoheader checksum seed for that
> +packet. The device generates the per-datagram lengths and UDP checksums and,
> +for IPv4 segmentation, the IP header checksums. Supply a valid IPv4 header
> +checksum as well, since a request that fits in one datagram uses ordinary
> +checksum offload without segmentation.
> +
> +All headers through UDP must be in the first buffer. Multi-buffer packets
> +use ``XDP_USE_SG`` and ``XDP_PKT_CONTD``, with metadata only on the first
> +descriptor. Each output IP packet must fit the device MTU, and requests
> +remain subject to the device's segmentation limits. Query
> +``tx-udp-segmentation`` through ethtool to check whether skb UDP segmentation
> +offload is enabled.
> +
> +AF_XDP never segments the packet itself. In copy mode, a request that
> +produces more than one datagram is rejected unless the bound device
> +advertises UDP segmentation offload, and the packet is passed to its driver
> +unsegmented. A request that fits in one datagram does not need the offload,
> +so its success does not show that the device supports USO. As with
> +``UDP_SEGMENT`` sockets, how the segmentation is carried out is up to the
> +driver, which may build the per-datagram headers in software. Stacked
> +devices such as VLAN, bonding, or macvlan advertise UDP segmentation
> +regardless of the lower device and forward the packet through the lower
> +device's qdisc, where it is segmented in software if the lower device lacks
> +the offload.
> +
> +A USO request that is rejected is dropped: its buffers are returned
> +through the completion ring and counted in the socket's ``tx_invalid_descs``
> +statistic. This is the only indication of the failure, whatever its cause:
> +invalid metadata or headers, the MTU, segmentation limits, or a device
> +without the offload. A request that cannot be processed for lack of memory
> +is instead left on the Tx ring, and ``sendmsg()`` fails with ``EAGAIN``,
> +unless part of a multi-buffer request was already released to user space;
> +it is then dropped. Errors in other Tx metadata also fail ``sendmsg()`` and
> +leave the descriptor on the Tx ring.
> +
> +USO cannot be combined with ``XDP_UMEM_TX_SW_CSUM`` or
> +``XDP_TXMD_FLAGS_TIMESTAMP``.
> +
>  Launch Time
>  ===========
>  
> @@ -127,6 +193,31 @@ cycle time is set to 1 second, the horizon of the launch time ranges
>  from 1 second to 2 seconds, depending on where the Qbv cycle is currently
>  running.
>  
> +USO with launch time
> +====================
> +
> +Add ``XDP_TXMD_FLAGS_LAUNCH_TIME`` to the USO and checksum flags and set
> +``request.launch_time`` to schedule the segmented packet. This combination
> +requires at least 24 bytes of Tx metadata.
> +
> +The launch time applies to the start of the segmented packet: the first
> +output UDP datagram is scheduled, and subsequent datagrams follow according
> +to the device's scheduling rules. This does not request per-datagram pacing
> +or separate launch times.
> +
> +The skb path passes one unsegmented GSO skb and its launch time directly to
> +the bound device's driver, bypassing that device's qdisc, including ETF.
> +On stacked devices, the lower device's qdisc and software segmentation
> +may still apply, as described above. The driver and selected queue
> +must support UDP segmentation and launch time together. Separate support
> +for either offload does not establish support for their combination.
> +As with ordinary launch-time requests, drivers may ignore the time when
> +scheduling is disabled or unsupported. Acceptance or Tx completion alone
> +does not prove that a packet was transmitted at the requested time.
> +
> +The clock, queue configuration, and scheduling horizon requirements above
> +also apply to USO launch-time requests.
> +
>  Querying Device Capabilities
>  ============================
>  
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 40bb77cbc6b0..9b5f6f307d53 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -30588,6 +30588,7 @@ F:	Documentation/networking/af_xdp.rst
>  F:	include/net/netns/xdp.h
>  F:	include/net/xdp_sock*
>  F:	include/net/xsk_buff_pool.h
> +F:	include/net/xsk_tx_uso.h
>  F:	include/uapi/linux/if_xdp.h
>  F:	include/uapi/linux/xdp_diag.h
>  F:	net/xdp/
> diff --git a/include/net/xdp_sock_drv.h b/include/net/xdp_sock_drv.h
> index a40ad3f90f13..6b5bb7b29f87 100644
> --- a/include/net/xdp_sock_drv.h
> +++ b/include/net/xdp_sock_drv.h
> @@ -263,6 +263,7 @@ xsk_buff_raw_get_ctx(const struct xsk_buff_pool *pool, u64 addr, u32 options)
>  		XDP_TXMD_FLAGS_TIMESTAMP | \
>  		XDP_TXMD_FLAGS_CHECKSUM | \
>  		XDP_TXMD_FLAGS_LAUNCH_TIME | \
> +		XDP_TXMD_FLAGS_USO | \
>  	0)
>  
>  static inline bool
> @@ -270,6 +271,10 @@ xsk_buff_valid_tx_metadata(const struct xsk_buff_pool *pool,
>  			   const struct xsk_tx_metadata *meta, u64 *flags)
>  {
>  	*flags = READ_ONCE(meta->flags);
> +	if (*flags & XDP_TXMD_FLAGS_USO)
> +		if (!pool->tx_uso_supported || pool->tx_metadata_len <
> +		    offsetofend(struct xsk_tx_metadata, request.network_offset))
> +			return false;
>  	if (*flags & XDP_TXMD_FLAGS_LAUNCH_TIME)
>  		if (pool->tx_metadata_len <
>  		    offsetofend(struct xsk_tx_metadata, request.launch_time))
> @@ -277,6 +282,13 @@ xsk_buff_valid_tx_metadata(const struct xsk_buff_pool *pool,
>  	return !(*flags & ~XDP_TXMD_FLAGS_VALID);
>  }
>  
> +/* USO requires checksum offload and cannot report a Tx timestamp. */
> +static inline bool xsk_tx_uso_flags_valid(u64 flags)
> +{
> +	return (flags & XDP_TXMD_FLAGS_CHECKSUM) &&
> +	       !(flags & XDP_TXMD_FLAGS_TIMESTAMP);
> +}
> +
>  /**
>   *  xsk_tx_metadata_request - Evaluate AF_XDP TX metadata at submission
>   *  and call appropriate xsk_tx_metadata_ops operation.
> diff --git a/include/net/xsk_buff_pool.h b/include/net/xsk_buff_pool.h
> index 02e89350faf9..ea2ff3680efa 100644
> --- a/include/net/xsk_buff_pool.h
> +++ b/include/net/xsk_buff_pool.h
> @@ -89,6 +89,10 @@ struct xsk_buff_pool {
>  	bool uses_need_wakeup;
>  	bool unaligned;
>  	bool tx_sw_csum;
> +	/* USO requests accepted: Ethernet device without SW checksum, and
> +	 * driver support in zero-copy mode. Set when the pool is bound.
> +	 */
> +	bool tx_uso_supported;
>  	void *addrs;
>  	/* Mutual exclusion of the completion ring in the SKB mode.
>  	 * Protect: NAPI TX thread and sendmsg error paths in the SKB
> diff --git a/include/net/xsk_tx_uso.h b/include/net/xsk_tx_uso.h
> new file mode 100644
> index 000000000000..f23384077712
> --- /dev/null
> +++ b/include/net/xsk_tx_uso.h
> @@ -0,0 +1,30 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +#ifndef _NET_XSK_TX_USO_H
> +#define _NET_XSK_TX_USO_H
> +
> +#include <linux/errno.h>
> +#include <linux/types.h>
> +#include <net/xsk_buff_pool.h>
> +
> +/* Header offsets are relative to the start of the supplied Ethernet frame. */
> +struct xsk_tx_uso_info {
> +	struct xsk_tx_metadata metadata;
> +	u32 len;
> +	u16 header_len;
> +	u16 gso_segs;
> +	__be16 protocol;
> +	u8 l4_protocol;
> +};
> +
> +#ifdef CONFIG_XDP_SOCKETS
> +int xsk_tx_uso_validate(const void *header, struct xsk_tx_uso_info *uso,
> +			u32 mtu);
> +#else
> +static inline int
> +xsk_tx_uso_validate(const void *header, struct xsk_tx_uso_info *uso, u32 mtu)
> +{
> +	return -EOPNOTSUPP;
> +}
> +#endif
> +
> +#endif
> diff --git a/include/uapi/linux/if_xdp.h b/include/uapi/linux/if_xdp.h
> index 50d67df78911..0f7ba4859218 100644
> --- a/include/uapi/linux/if_xdp.h
> +++ b/include/uapi/linux/if_xdp.h
> @@ -134,6 +134,12 @@ struct xdp_options {
>   */
>  #define XDP_TXMD_FLAGS_LAUNCH_TIME		(1 << 2)
>  
> +/* Request UDP segmentation offload in XDP_COPY mode. Requires CHECKSUM.
> + * Segment size and IP header offset are in request.
> + * With LAUNCH_TIME, scheduling applies to the start of the segmented packet.
> + */
> +#define XDP_TXMD_FLAGS_USO			(1 << 3)
> +
>  /* AF_XDP offloads request. 'request' union member is consumed by the driver
>   * when the packet is being transmitted. 'completion' union member is
>   * filled by the driver when the transmit completion arrives.
> @@ -149,7 +155,12 @@ struct xsk_tx_metadata {
>  			__u16 csum_start;
>  			/* Offset from csum_start where checksum should be stored. */
>  			__u16 csum_offset;
> -			__u32 reserved;
> +
> +			/* XDP_TXMD_FLAGS_USO */
> +			/* UDP payload bytes per output datagram. */
> +			__u16 gso_size;
> +			/* IP header offset from desc->addr. */
> +			__u16 network_offset;
>  
>  			/* XDP_TXMD_FLAGS_LAUNCH_TIME */
>  			/* Launch time in nanosecond against the PTP HW Clock */
> diff --git a/net/xdp/Makefile b/net/xdp/Makefile
> index 30cdc4315f42..b6109e0e5547 100644
> --- a/net/xdp/Makefile
> +++ b/net/xdp/Makefile
> @@ -1,4 +1,5 @@
>  # SPDX-License-Identifier: GPL-2.0-only
>  obj-$(CONFIG_XDP_SOCKETS) += xsk.o xdp_umem.o xsk_queue.o xskmap.o
>  obj-$(CONFIG_XDP_SOCKETS) += xsk_buff_pool.o
> +obj-$(CONFIG_XDP_SOCKETS) += xsk_tx_uso.o
>  obj-$(CONFIG_XDP_SOCKETS_DIAG) += xsk_diag.o
> diff --git a/net/xdp/xsk.c b/net/xdp/xsk.c
> index f22f9a2cdbbe..14be62b8de5f 100644
> --- a/net/xdp/xsk.c
> +++ b/net/xdp/xsk.c
> @@ -11,6 +11,8 @@
>  
>  #define pr_fmt(fmt) "AF_XDP: %s: " fmt, __func__
>  
> +#include <linux/if_arp.h>
> +#include <linux/if_vlan.h>
>  #include <linux/if_xdp.h>
>  #include <linux/init.h>
>  #include <linux/sched/mm.h>
> @@ -22,6 +24,7 @@
>  #include <linux/net.h>
>  #include <linux/netdevice.h>
>  #include <linux/rculist.h>
> +#include <linux/udp.h>
>  #include <linux/uio.h>
>  #include <linux/vmalloc.h>
>  
> @@ -31,6 +34,7 @@
>  #include <net/netdev_lock.h>
>  #include <net/netdev_rx_queue.h>
>  #include <net/xdp.h>
> +#include <net/xsk_tx_uso.h>
>  
>  #include "../core/dev.h"
>  
> @@ -986,12 +990,62 @@ static void xsk_drop_skb(struct sk_buff *skb)
>  	xs->skb = NULL;
>  }
>  
> +static int xsk_skb_uso(struct sk_buff *skb)
> +{
> +	struct xsk_tx_uso_info uso = {
> +		.metadata.request = {
> +			.gso_size = skb_shinfo(skb)->gso_size,
> +			.csum_start = skb_transport_offset(skb),
> +			.network_offset = skb_network_offset(skb),
> +		},
> +		.header_len = skb_transport_offset(skb) + sizeof(struct udphdr),
> +		.len = skb->len,
> +	};
> +	int depth, err;
> +
> +	/* Best effort: a bond or team device can change type while the pool
> +	 * is bound, also after this check.
> +	 */
> +	if (READ_ONCE(skb->dev->type) != ARPHRD_ETHER)
> +		return -EINVAL;
> +	if (!pskb_may_pull(skb, uso.header_len))
> +		return -ENOMEM;
> +
> +	err = xsk_tx_uso_validate(skb->data, &uso, READ_ONCE(skb->dev->mtu));
> +	if (err)
> +		return err;
> +
> +	skb_reset_mac_header(skb);
> +	skb->protocol = eth_hdr(skb)->h_proto;
> +	/* skb drivers find L3 through the EtherType and VLAN tags. Parse them
> +	 * from the end of the Ethernet header, not from network_offset.
> +	 */
> +	skb->mac_len = ETH_HLEN;
> +	if (__vlan_get_protocol(skb, skb->protocol, &depth) != uso.protocol ||
> +	    depth != skb_network_offset(skb))
> +		return -EINVAL;
> +	skb_reset_mac_len(skb);
> +	if (uso.gso_segs == 1) {
> +		skb_gso_reset(skb);
> +		return 0;
> +	}
> +
> +	skb_shinfo(skb)->gso_segs = uso.gso_segs;
> +	if (netif_needs_gso(skb, netif_skb_features(skb)))
> +		return -EOPNOTSUPP;
> +
> +	return 0;
> +}
> +
> +/* A failed USO request returns -EOVERFLOW, so that the packet is dropped. Other
> + * metadata errors are returned to user space.
> + */
>  static int xsk_skb_metadata(struct sk_buff *skb, void *buffer,
>  			    struct xdp_desc *desc, struct xsk_buff_pool *pool,
>  			    u32 hr)
>  {
>  	struct xsk_tx_metadata *meta = NULL;
> -	u16 csum_start, csum_offset;
> +	int err = -EINVAL;
>  	u64 flags;
>  
>  	if (unlikely(pool->tx_metadata_len == 0))
> @@ -999,18 +1053,43 @@ static int xsk_skb_metadata(struct sk_buff *skb, void *buffer,
>  
>  	meta = buffer - pool->tx_metadata_len;
>  	if (unlikely(!xsk_buff_valid_tx_metadata(pool, meta, &flags)))
> -		return -EINVAL;
> +		goto err;
> +
> +	if (flags & XDP_TXMD_FLAGS_USO) {
> +		u16 nhoff = READ_ONCE(meta->request.network_offset);
> +		u16 offset = READ_ONCE(meta->request.csum_offset);
> +		u16 thoff = READ_ONCE(meta->request.csum_start);
> +		u16 size = READ_ONCE(meta->request.gso_size);
> +
> +		if (!xsk_tx_uso_flags_valid(flags))
> +			goto err;
> +		if (!size || size == GSO_BY_FRAGS ||
> +		    nhoff < ETH_HLEN || thoff < nhoff ||
> +		    thoff + sizeof(struct udphdr) > desc->len ||
> +		    offset != offsetof(struct udphdr, check) ||
> +		    hr + thoff >= U16_MAX)
> +			goto err;
> +
> +		skb_set_network_header(skb, nhoff);
> +		skb_set_transport_header(skb, thoff);
> +		skb_shinfo(skb)->gso_size = size;
> +		skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
> +	}
>  
>  	if (flags & XDP_TXMD_FLAGS_CHECKSUM) {
> -		csum_start = READ_ONCE(meta->request.csum_start);
> -		csum_offset = READ_ONCE(meta->request.csum_offset);
> +		if (flags & XDP_TXMD_FLAGS_USO) {

you're doing it like this as you still want to execute
XDP_TXMD_FLAGS_CHECKSUM which is present for USO, ok.

> +			skb->csum_start = skb_transport_offset(skb);
> +			skb->csum_offset = offsetof(struct udphdr, check);
> +		} else {
> +			skb->csum_start = READ_ONCE(meta->request.csum_start);
> +			skb->csum_offset = READ_ONCE(meta->request.csum_offset);
> +		}
>  
> -		if (unlikely(csum_start + csum_offset +
> +		if (unlikely(skb->csum_start + skb->csum_offset +
>  			     sizeof(__sum16) > desc->len))
> -			return -EINVAL;
> +			goto err;
>  
> -		skb->csum_start = hr + csum_start;
> -		skb->csum_offset = csum_offset;
> +		skb->csum_start += hr;
>  		skb->ip_summed = CHECKSUM_PARTIAL;
>  	}
>  
> @@ -1021,6 +1100,9 @@ static int xsk_skb_metadata(struct sk_buff *skb, void *buffer,
>  	xsk_tx_metadata_to_compl(meta, &skb_shinfo(skb)->xsk_meta);
>  
>  	return 0;
> +
> +err:
> +	return flags & XDP_TXMD_FLAGS_USO ? -EOVERFLOW : err;

could you stick to explicit returns maybe and be consistent with rest of
flags?

>  }
>  
>  static int xsk_skb_sw_csum(struct sk_buff *skb, struct xsk_buff_pool *pool)
> @@ -1108,6 +1190,10 @@ static struct sk_buff *xsk_build_skb_zerocopy(struct xdp_sock *xs,
>  	return skb;
>  }
>  
> +/* On -EOVERFLOW, the packet was dropped and its descriptors were consumed and
> + * completed as invalid. Other errors leave the descriptor on the Tx ring for
> + * the application to retry.
> + */
>  static struct sk_buff *xsk_build_skb(struct xdp_sock *xs,
>  				     struct xdp_desc *desc)
>  {
> @@ -1196,13 +1282,17 @@ static struct sk_buff *xsk_build_skb(struct xdp_sock *xs,
>  	if (skb && !xs->skb)
>  		kfree_skb(skb);
>  
> +	/* Too many descriptors and invalid USO requests drop the packet. Only
> +	 * the latter can fail on the first descriptor, which is completed
> +	 * here. Other errors are returned so that the application can retry.
> +	 */
>  	if (err == -EOVERFLOW) {
>  		if (xs->skb) {
>  			/* Drop the packet */
>  			xsk_inc_num_desc(xs->skb);
>  			xsk_drop_skb(xs->skb);
>  		} else {
> -			xsk_cq_cancel_locked(xs->pool, 1);
> +			xsk_cq_submit_addr_single_locked(xs->pool, desc);
>  			xs->tx->invalid_descs++;
>  		}
>  		xskq_cons_release(xs->tx);
> @@ -1279,6 +1369,28 @@ static int __xsk_generic_xmit(struct sock *sk)
>  			continue;
>  		}
>  
> +		if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4) {
> +			err = xsk_skb_uso(skb);
> +			/* Descriptors already released to user space may be
> +			 * reused, so the packet can only be put back if none
> +			 * of them has been released. Otherwise it is dropped.

This is the only part i don't follow.

> +			 */
> +			if (err == -ENOMEM &&
> +			    xskq_cons_nb_unreleased(xs->tx) >=
> +			    xsk_get_num_desc(skb)) {
> +				/* Tell user-space to retry the send */
> +				xskq_cons_cancel_n(xs->tx, xsk_get_num_desc(skb));
> +				xsk_consume_skb(skb);
> +				err = -EAGAIN;
> +				goto out;
> +			}
> +			if (err) {
> +				xsk_drop_skb(skb);
> +				err = 0;
> +				continue;
> +			}
> +		}
> +
>  		err = xsk_skb_sw_csum(skb, xs->pool);
>  		if (unlikely(err)) {
>  			xsk_drop_skb(skb);
> diff --git a/net/xdp/xsk_buff_pool.c b/net/xdp/xsk_buff_pool.c
> index 5ec092f7cb6f..e62f3c2b3362 100644
> --- a/net/xdp/xsk_buff_pool.c
> +++ b/net/xdp/xsk_buff_pool.c
> @@ -1,5 +1,6 @@
>  // SPDX-License-Identifier: GPL-2.0
>  
> +#include <linux/if_arp.h>
>  #include <linux/netdevice.h>
>  #include <net/netdev_lock.h>
>  #include <net/xsk_buff_pool.h>
> @@ -192,6 +193,8 @@ int xp_assign_dev(struct xsk_buff_pool *pool,
>  	err = xsk_reg_pool_at_qid(netdev, pool, queue_id);
>  	if (err)
>  		return err;
> +	pool->tx_uso_supported = !pool->tx_sw_csum &&
> +				 netdev->type == ARPHRD_ETHER;
>  
>  	if (mbuf)
>  		pool->umem->flags |= XDP_UMEM_SG_FLAG;
> @@ -260,6 +263,7 @@ int xp_assign_dev(struct xsk_buff_pool *pool,
>  		goto err_unreg_xsk;
>  	}
>  	pool->umem->zc = true;
> +	pool->tx_uso_supported = false;

I assume this will be lifted on later patch

>  	pool->xdp_zc_max_segs = netdev->xdp_zc_max_segs;
>  	return 0;
>  
> diff --git a/net/xdp/xsk_queue.h b/net/xdp/xsk_queue.h
> index 1bc42c8902f4..182cd1cccb74 100644
> --- a/net/xdp/xsk_queue.h
> +++ b/net/xdp/xsk_queue.h
> @@ -390,6 +390,12 @@ static inline void xskq_cons_release(struct xsk_queue *q)
>  	q->cached_cons++;
>  }
>  
> +/* Entries consumed locally but not yet released to the producer. */
> +static inline u32 xskq_cons_nb_unreleased(struct xsk_queue *q)
> +{
> +	return q->cached_cons - q->ring->consumer;

READ_ONCE(q->ring->consumer) ?

> +}
> +
>  static inline void xskq_cons_cancel_n(struct xsk_queue *q, u32 cnt)
>  {
>  	q->cached_cons -= cnt;
> diff --git a/net/xdp/xsk_tx_uso.c b/net/xdp/xsk_tx_uso.c
> new file mode 100644
> index 000000000000..a7313ade1092
> --- /dev/null
> +++ b/net/xdp/xsk_tx_uso.c
> @@ -0,0 +1,77 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#include <net/ip.h>
> +#include <net/ipv6.h>
> +#include <net/udp.h>
> +#include <net/xsk_tx_uso.h>
> +
> +/**
> + * xsk_tx_uso_validate - validate a kernel-owned plain UDP header
> + * @header: kernel-owned buffer containing at least uso->header_len bytes
> + * @uso: packet length and metadata offsets; receives protocol and segment count
> + * @mtu: maximum output IP packet length
> + *
> + * The link-layer header is not parsed. The IP header starts at network_offset
> + * and its version selects IPv4 or IPv6. The caller must provide a nonzero
> + * gso_size other than GSO_BY_FRAGS and header_len equal to transport_offset
> + * plus the UDP header size.
> + *
> + * Return: zero on success or a negative error code.
> + */
> +int xsk_tx_uso_validate(const void *header, struct xsk_tx_uso_info *uso,
> +			u32 mtu)
> +{
> +	const struct xsk_tx_metadata *meta = &uso->metadata;
> +	u32 nhoff = meta->request.network_offset;
> +	u32 thoff = meta->request.csum_start;
> +	u32 udp_len, payload_len, network_len;
> +	const struct udphdr *uh;
> +	__be16 protocol;
> +
> +	if (nhoff < ETH_HLEN || thoff <= nhoff || uso->header_len < thoff ||
> +	    uso->len < uso->header_len)
> +		return -EINVAL;
> +
> +	network_len = uso->len - nhoff;
> +	switch (((const struct iphdr *)(header + nhoff))->version) {
> +	case 4: {
> +		const struct iphdr *iph = header + nhoff;
> +
> +		if (thoff - nhoff < sizeof(*iph) ||
> +		    iph->ihl < 5 || iph->ihl * 4 != thoff - nhoff ||
> +		    ip_is_fragment(iph) ||
> +		    ntohs(iph->tot_len) != network_len)

question: i keep on seeing this validation of iphdr - don't we have
somewhere a generic routine for that?

> +			return -EINVAL;
> +		protocol = htons(ETH_P_IP);
> +		uso->l4_protocol = iph->protocol;
> +		break;
> +	}
> +	case 6: {
> +		const struct ipv6hdr *ip6h = header + nhoff;
> +
> +		if (thoff - nhoff != sizeof(*ip6h) ||
> +		    ntohs(ip6h->payload_len) != network_len - sizeof(*ip6h))
> +			return -EINVAL;
> +		protocol = htons(ETH_P_IPV6);
> +		uso->l4_protocol = ip6h->nexthdr;
> +		break;
> +	}
> +	default:
> +		return -EPROTONOSUPPORT;
> +	}
> +	uso->protocol = protocol;
> +	udp_len = uso->len - thoff;
> +	uh = header + thoff;
> +	if (uso->l4_protocol != IPPROTO_UDP || udp_len > U16_MAX ||
> +	    ntohs(uh->len) != udp_len)
> +		return -EINVAL;

nit: i think you should start with this validation?

> +	payload_len = udp_len - sizeof(*uh);
> +	if (payload_len > meta->request.gso_size * UDP_MAX_SEGMENTS ||
> +	    uso->header_len - nhoff +
> +	    min_t(u32, payload_len, meta->request.gso_size) > mtu)
> +		return -EINVAL;
> +
> +	uso->gso_segs = max_t(u32, 1, DIV_ROUND_UP(payload_len,
> +						   meta->request.gso_size));
> +	return 0;
> +}
> +EXPORT_SYMBOL_GPL(xsk_tx_uso_validate);
> diff --git a/tools/include/uapi/linux/if_xdp.h b/tools/include/uapi/linux/if_xdp.h
> index 50d67df78911..0f7ba4859218 100644
> --- a/tools/include/uapi/linux/if_xdp.h
> +++ b/tools/include/uapi/linux/if_xdp.h
> @@ -134,6 +134,12 @@ struct xdp_options {
>   */
>  #define XDP_TXMD_FLAGS_LAUNCH_TIME		(1 << 2)
>  
> +/* Request UDP segmentation offload in XDP_COPY mode. Requires CHECKSUM.
> + * Segment size and IP header offset are in request.
> + * With LAUNCH_TIME, scheduling applies to the start of the segmented packet.
> + */
> +#define XDP_TXMD_FLAGS_USO			(1 << 3)
> +
>  /* AF_XDP offloads request. 'request' union member is consumed by the driver
>   * when the packet is being transmitted. 'completion' union member is
>   * filled by the driver when the transmit completion arrives.
> @@ -149,7 +155,12 @@ struct xsk_tx_metadata {
>  			__u16 csum_start;
>  			/* Offset from csum_start where checksum should be stored. */
>  			__u16 csum_offset;
> -			__u32 reserved;
> +
> +			/* XDP_TXMD_FLAGS_USO */
> +			/* UDP payload bytes per output datagram. */
> +			__u16 gso_size;
> +			/* IP header offset from desc->addr. */
> +			__u16 network_offset;
>  
>  			/* XDP_TXMD_FLAGS_LAUNCH_TIME */
>  			/* Launch time in nanosecond against the PTP HW Clock */
> -- 
> 2.38.1
> 

  reply	other threads:[~2026-11-19 18:47 UTC|newest]

Thread overview: 16+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-19 16:53 [PATCH net-next 0/5] xsk: ice: USO support for AF_XDP Magnus Karlsson
2026-11-19 16:53 ` [PATCH net-next 1/5] xsk: add USO support for skb path Magnus Karlsson
2026-11-19 18:47   ` Maciej Fijalkowski [this message]
2026-11-20  8:55     ` Magnus Karlsson
2026-11-20 11:43       ` Maciej Fijalkowski
2026-11-20 17:22   ` Stanislav Fomichev
2026-11-19 16:53 ` [PATCH net-next 2/5] ice: add Tx descriptor builders and header length check Magnus Karlsson
2026-11-20 11:59   ` Maciej Fijalkowski
2026-11-19 16:53 ` [PATCH net-next 3/5] xsk: ice: add USO zero-copy support Magnus Karlsson
2026-11-20 14:22   ` Maciej Fijalkowski
2026-11-20 16:54   ` sashiko-bot
2026-11-19 16:53 ` [PATCH net-next 4/5] xsk: add KUnit tests for AF_XDP USO header helpers Magnus Karlsson
2026-11-19 16:53 ` [PATCH net-next 5/5] selftests: net: add AF_XDP USO test Magnus Karlsson
2026-11-19 19:05   ` Maciej Fijalkowski
2026-11-20  8:35     ` Magnus Karlsson
  -- strict thread matches above, loose matches on Subject: below --
2026-11-19 14:10 [PATCH net-next 0/5] xsk: ice: USO support for AF_XDP Magnus Karlsson
2026-11-19 14:10 ` [PATCH net-next 1/5] xsk: add USO support for skb path Magnus Karlsson

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=av9EMbwng6Oc7chm@boxer \
    --to=maciej.fijalkowski@intel.com \
    --cc=anthony.l.nguyen@intel.com \
    --cc=bjorn@kernel.org \
    --cc=davem@davemloft.net \
    --cc=edumazet@kernel.org \
    --cc=horms@kernel.org \
    --cc=intel-wired-lan@lists.osuosl.org \
    --cc=jacob.e.keller@intel.com \
    --cc=kerneljasonxing@gmail.com \
    --cc=kuba@kernel.org \
    --cc=magnus.karlsson@gmail.com \
    --cc=magnus.karlsson@intel.com \
    --cc=netdev@vger.kernel.org \
    --cc=pabeni@redhat.com \
    --cc=przemyslaw.kitszel@intel.com \
    --cc=sdf@fomichev.me \
    /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.