Intel-Wired-Lan Archive on 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: 9+ 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-19 16:53 ` [PATCH net-next 2/5] ice: add Tx descriptor builders and header length check Magnus Karlsson
2026-11-19 16:53 ` [PATCH net-next 3/5] xsk: ice: add USO zero-copy support Magnus Karlsson
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
  -- 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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox