xsk: batch xmit in copy mode

index 7b0c68a70888..ace91800c447 100644

net/xdp/xsk.c +31 -0

@@ -1544,6 +1546,55 @@ static int xsk_setsockopt(struct socket *sock, int level, int optname,
 		WRITE_ONCE(xs->max_tx_budget, budget);
 		return 0;
 	}
+	case XDP_GENERIC_XMIT_BATCH:
+	{
+		struct xsk_buff_pool *pool = xs->pool;
+		struct xsk_batch *batch = &xs->batch;
+		struct xdp_desc *descs;
+		struct sk_buff **skbs;
+		unsigned int size;
+		int ret = 0;
+
+		if (optlen != sizeof(size))
+			return -EINVAL;
+		if (copy_from_sockptr(&size, optval, sizeof(size)))
+			return -EFAULT;
+		if (size == batch->generic_xmit_batch)
+			return 0;
+		if (size > xs->max_tx_budget || !pool)
+			return -EACCES;
+
+		mutex_lock(&xs->mutex);
+		if (!size) {
+			kfree(batch->skb_cache);
+			kvfree(batch->desc_cache);
+			batch->generic_xmit_batch = 0;
+			goto out;
+		}
+
+		skbs = kmalloc(size * sizeof(struct sk_buff *), GFP_KERNEL);
+		if (!skbs) {
+			ret = -ENOMEM;
+			goto out;
+		}

net/xdp/xsk.c +8 -0

+
+		batch->skb_cache = skbs;
+		batch->desc_cache = descs;
+		batch->generic_xmit_batch = size;
+out:
+		mutex_unlock(&xs->mutex);
+		return ret;
+	}
 	default:
 		break;
 	}

On Tue, Oct 21, 2025 at 09:12:01PM +0800, Jason Xing wrote:

...

Quoted 1 line

index 7b0c68a70888..ace91800c447 100644

...

Quoted 35 lines

net/xdp/xsk.c +31 -0

@@ -1544,6 +1546,55 @@ static int xsk_setsockopt(struct socket *sock, int level, int optname,
              WRITE_ONCE(xs->max_tx_budget, budget);
              return 0;
      }
+     case XDP_GENERIC_XMIT_BATCH:
+     {
+             struct xsk_buff_pool *pool = xs->pool;
+             struct xsk_batch *batch = &xs->batch;
+             struct xdp_desc *descs;
+             struct sk_buff **skbs;
+             unsigned int size;
+             int ret = 0;
+
+             if (optlen != sizeof(size))
+                     return -EINVAL;
+             if (copy_from_sockptr(&size, optval, sizeof(size)))
+                     return -EFAULT;
+             if (size == batch->generic_xmit_batch)
+                     return 0;
+             if (size > xs->max_tx_budget || !pool)
+                     return -EACCES;
+
+             mutex_lock(&xs->mutex);
+             if (!size) {
+                     kfree(batch->skb_cache);
+                     kvfree(batch->desc_cache);
+                     batch->generic_xmit_batch = 0;
+                     goto out;
+             }
+
+             skbs = kmalloc(size * sizeof(struct sk_buff *), GFP_KERNEL);
+             if (!skbs) {
+                     ret = -ENOMEM;
+                     goto out;
+             }

net/xdp/xsk.c static int xsk_setsockopt(struct socket *sock, int level, int optname, · line 1589

Quoted 10 lines

net/xdp/xsk.c +10 -0

+             descs = kvcalloc(size, sizeof(struct xdp_desc), GFP_KERNEL);
+             if (!descs) {
+                     kfree(skbs);
+                     ret = -ENOMEM;
+                     goto out;
+             }
+             if (batch->skb_cache)
+                     kfree(batch->skb_cache);
+             if (batch->desc_cache)
+                     kvfree(batch->desc_cache);

Hi Jason,

nit: kfree and kvfree are no-ops when passed NULL,
so the conditions above seem unnecessary.

Hi Simon,

Quoted 57 lines · Simon Horman

On Tue, Oct 21, 2025 at 09:12:01PM +0800, Jason Xing wrote:

...

Quoted 1 line

index 7b0c68a70888..ace91800c447 100644

...

Quoted 35 lines

net/xdp/xsk.c +31 -0

@@ -1544,6 +1546,55 @@ static int xsk_setsockopt(struct socket *sock, int level, int optname,
              WRITE_ONCE(xs->max_tx_budget, budget);
              return 0;
      }
+     case XDP_GENERIC_XMIT_BATCH:
+     {
+             struct xsk_buff_pool *pool = xs->pool;
+             struct xsk_batch *batch = &xs->batch;
+             struct xdp_desc *descs;
+             struct sk_buff **skbs;
+             unsigned int size;
+             int ret = 0;
+
+             if (optlen != sizeof(size))
+                     return -EINVAL;
+             if (copy_from_sockptr(&size, optval, sizeof(size)))
+                     return -EFAULT;
+             if (size == batch->generic_xmit_batch)
+                     return 0;
+             if (size > xs->max_tx_budget || !pool)
+                     return -EACCES;
+
+             mutex_lock(&xs->mutex);
+             if (!size) {
+                     kfree(batch->skb_cache);
+                     kvfree(batch->desc_cache);
+                     batch->generic_xmit_batch = 0;
+                     goto out;
+             }
+
+             skbs = kmalloc(size * sizeof(struct sk_buff *), GFP_KERNEL);
+             if (!skbs) {
+                     ret = -ENOMEM;
+                     goto out;
+             }

net/xdp/xsk.c static int xsk_setsockopt(struct socket *sock, int level, int optname, · line 1589

Quoted 10 lines

net/xdp/xsk.c +10 -0

+             descs = kvcalloc(size, sizeof(struct xdp_desc), GFP_KERNEL);
+             if (!descs) {
+                     kfree(skbs);
+                     ret = -ENOMEM;
+                     goto out;
+             }
+             if (batch->skb_cache)
+                     kfree(batch->skb_cache);
+             if (batch->desc_cache)
+                     kvfree(batch->desc_cache);

Hi Jason,

Quoted 2 lines

nit: kfree and kvfree are no-ops when passed NULL,
so the conditions above seem unnecessary.

Yep, but the checkpatch complains. I thought it might be good to keep it because normally we need to check the validation of the pointer first and then free it. WDYT?

Quoted 63 lines · Jason Xing

Hi Simon,

Quoted 59 lines · Simon Horman

On Tue, Oct 21, 2025 at 09:12:01PM +0800, Jason Xing wrote:

...

Quoted 1 line

index 7b0c68a70888..ace91800c447 100644

...

Quoted 35 lines

net/xdp/xsk.c +31 -0

@@ -1544,6 +1546,55 @@ static int xsk_setsockopt(struct socket *sock, int level, int optname,
              WRITE_ONCE(xs->max_tx_budget, budget);
              return 0;
      }
+     case XDP_GENERIC_XMIT_BATCH:
+     {
+             struct xsk_buff_pool *pool = xs->pool;
+             struct xsk_batch *batch = &xs->batch;
+             struct xdp_desc *descs;
+             struct sk_buff **skbs;
+             unsigned int size;
+             int ret = 0;
+
+             if (optlen != sizeof(size))
+                     return -EINVAL;
+             if (copy_from_sockptr(&size, optval, sizeof(size)))
+                     return -EFAULT;
+             if (size == batch->generic_xmit_batch)
+                     return 0;
+             if (size > xs->max_tx_budget || !pool)
+                     return -EACCES;
+
+             mutex_lock(&xs->mutex);
+             if (!size) {
+                     kfree(batch->skb_cache);
+                     kvfree(batch->desc_cache);
+                     batch->generic_xmit_batch = 0;
+                     goto out;
+             }
+
+             skbs = kmalloc(size * sizeof(struct sk_buff *), GFP_KERNEL);
+             if (!skbs) {
+                     ret = -ENOMEM;
+                     goto out;
+             }

net/xdp/xsk.c static int xsk_setsockopt(struct socket *sock, int level, int optname, · line 1589

Quoted 10 lines

net/xdp/xsk.c +10 -0

+             descs = kvcalloc(size, sizeof(struct xdp_desc), GFP_KERNEL);
+             if (!descs) {
+                     kfree(skbs);
+                     ret = -ENOMEM;
+                     goto out;
+             }
+             if (batch->skb_cache)
+                     kfree(batch->skb_cache);
+             if (batch->desc_cache)
+                     kvfree(batch->desc_cache);

Hi Jason,

nit: kfree and kvfree are no-ops when passed NULL,
so the conditions above seem unnecessary.

Quoted 3 lines

Yep, but the checkpatch complains. I thought it might be good to keep it because normally we need to check the validation of the pointer first and then free it. WDYT?

I don't feel particularly strongly about this. But I would lean to wards removing the if() conditions because they are unnecessary: less is more.

net/core/skbuff.c +0 -0

net/core/skbuff.c +69 -0

@@ -615,6 +617,105 @@ static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node,
 	return obj;
 }
 
+int xsk_alloc_batch_skb(struct xdp_sock *xs, u32 nb_pkts, u32 nb_descs, int *err)
+{
+	struct xsk_batch *batch = &xs->batch;
+	struct xdp_desc *descs = batch->desc_cache;
+	struct sk_buff **skbs = batch->skb_cache;
+	gfp_t gfp_mask = xs->sk.sk_allocation;
+	struct net_device *dev = xs->dev;
+	int node = NUMA_NO_NODE;
+	struct sk_buff *skb;
+	u32 i = 0, j = 0;
+	bool pfmemalloc;
+	u32 base_len;
+	u8 *data;
+
+	base_len = max(NET_SKB_PAD, L1_CACHE_ALIGN(dev->needed_headroom));
+	if (!(dev->priv_flags & IFF_TX_SKB_NO_LINEAR))
+		base_len += dev->needed_tailroom;
+
+	if (batch->skb_count >= nb_pkts)
+		goto build;
+
+	if (xs->skb) {
+		i = 1;
+		batch->skb_count++;
+	}
+
+	batch->skb_count += kmem_cache_alloc_bulk(net_hotdata.skbuff_cache,
+						  gfp_mask, nb_pkts - batch->skb_count,
+						  (void **)&skbs[batch->skb_count]);
+	if (batch->skb_count < nb_pkts)
+		nb_pkts = batch->skb_count;
+
+build:
+	for (i = 0, j = 0; j < nb_descs; j++) {
+		if (!xs->skb) {
+			u32 size = base_len + descs[j].len;
+
+			/* In case we don't have enough allocated skbs */
+			if (i >= nb_pkts) {
+				*err = -EAGAIN;
+				break;
+			}
+
+			if (sk_wmem_alloc_get(&xs->sk) > READ_ONCE(xs->sk.sk_sndbuf)) {
+				*err = -EAGAIN;
+				break;
+			}
+
+			skb = skbs[batch->skb_count - 1 - i];
+
+			prefetchw(skb);
+			/* We do our best to align skb_shared_info on a separate cache
+			 * line. It usually works because kmalloc(X > SMP_CACHE_BYTES) gives
+			 * aligned memory blocks, unless SLUB/SLAB debug is enabled.
+			 * Both skb->head and skb_shared_info are cache line aligned.
+			 */
+			data = kmalloc_reserve(&size, gfp_mask, node, &pfmemalloc);
+			if (unlikely(!data)) {
+				*err = -ENOBUFS;
+				break;
+			}
+			/* kmalloc_size_roundup() might give us more room than requested.
+			 * Put skb_shared_info exactly at the end of allocated zone,
+			 * to allow max possible filling before reallocation.
+			 */
+			prefetchw(data + SKB_WITH_OVERHEAD(size));
+
+			memset(skb, 0, offsetof(struct sk_buff, tail));
+			__build_skb_around(skb, data, size);

net/core/skbuff.c +19 -0

+		if (IS_ERR(skb)) {
+			*err = PTR_ERR(skb);
+			break;
+		}
+
+		if (xp_mb_desc(&descs[j])) {
+			xs->skb = skb;
+			continue;
+		}
+
+		xs->skb = NULL;
+		i++;
+		__skb_queue_tail(&batch->send_queue, skb);
+	}
+
+	batch->skb_count -= i;
+
+	return j;
+}

On Tue, Oct 21, 2025 at 09:12:03PM +0800, Jason Xing wrote:

...

Quoted 1 line

net/core/skbuff.c +0 -0

...

Quoted 73 lines

net/core/skbuff.c +69 -0

@@ -615,6 +617,105 @@ static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node,
      return obj;
 }
 
+int xsk_alloc_batch_skb(struct xdp_sock *xs, u32 nb_pkts, u32 nb_descs, int *err)
+{
+     struct xsk_batch *batch = &xs->batch;
+     struct xdp_desc *descs = batch->desc_cache;
+     struct sk_buff **skbs = batch->skb_cache;
+     gfp_t gfp_mask = xs->sk.sk_allocation;
+     struct net_device *dev = xs->dev;
+     int node = NUMA_NO_NODE;
+     struct sk_buff *skb;
+     u32 i = 0, j = 0;
+     bool pfmemalloc;
+     u32 base_len;
+     u8 *data;
+
+     base_len = max(NET_SKB_PAD, L1_CACHE_ALIGN(dev->needed_headroom));
+     if (!(dev->priv_flags & IFF_TX_SKB_NO_LINEAR))
+             base_len += dev->needed_tailroom;
+
+     if (batch->skb_count >= nb_pkts)
+             goto build;
+
+     if (xs->skb) {
+             i = 1;
+             batch->skb_count++;
+     }
+
+     batch->skb_count += kmem_cache_alloc_bulk(net_hotdata.skbuff_cache,
+                                               gfp_mask, nb_pkts - batch->skb_count,
+                                               (void **)&skbs[batch->skb_count]);
+     if (batch->skb_count < nb_pkts)
+             nb_pkts = batch->skb_count;
+
+build:
+     for (i = 0, j = 0; j < nb_descs; j++) {
+             if (!xs->skb) {
+                     u32 size = base_len + descs[j].len;
+
+                     /* In case we don't have enough allocated skbs */
+                     if (i >= nb_pkts) {
+                             *err = -EAGAIN;
+                             break;
+                     }
+
+                     if (sk_wmem_alloc_get(&xs->sk) > READ_ONCE(xs->sk.sk_sndbuf)) {
+                             *err = -EAGAIN;
+                             break;
+                     }
+
+                     skb = skbs[batch->skb_count - 1 - i];
+
+                     prefetchw(skb);
+                     /* We do our best to align skb_shared_info on a separate cache
+                      * line. It usually works because kmalloc(X > SMP_CACHE_BYTES) gives
+                      * aligned memory blocks, unless SLUB/SLAB debug is enabled.
+                      * Both skb->head and skb_shared_info are cache line aligned.
+                      */
+                     data = kmalloc_reserve(&size, gfp_mask, node, &pfmemalloc);
+                     if (unlikely(!data)) {
+                             *err = -ENOBUFS;
+                             break;
+                     }
+                     /* kmalloc_size_roundup() might give us more room than requested.
+                      * Put skb_shared_info exactly at the end of allocated zone,
+                      * to allow max possible filling before reallocation.
+                      */
+                     prefetchw(data + SKB_WITH_OVERHEAD(size));
+
+                     memset(skb, 0, offsetof(struct sk_buff, tail));
+                     __build_skb_around(skb, data, size);

net/core/skbuff.c static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node, · line 698

Quoted 10 lines

net/core/skbuff.c +10 -0

+                     skb->pfmemalloc = pfmemalloc;
+                     skb_set_owner_w(skb, &xs->sk);
+             } else if (unlikely(i == 0)) {
+                     /* We have a skb in cache that is left last time */
+                     kmem_cache_free(net_hotdata.skbuff_cache,
+                                     skbs[batch->skb_count - 1]);
+                     skbs[batch->skb_count - 1] = xs->skb;
+             }
+
+             skb = xsk_build_skb(xs, skb, &descs[j]);

Hi Jason,

Perhaps it cannot occur, but if we reach this line without the if (!xs->skb) condition having been met for any iteration of there loop this code sits inside, then skb will be uninitialised here.

Also, assuming the above doesn't occur, and perhaps this next case is intentional, but if the same condition is not met for any iteration of the loop, then skb will have its value from a prior iteration.

Flagged by Smatch.

From: Jason Xing <[email protected]>

Support allocating and building skbs in batch.

This patch uses kmem_cache_alloc_bulk() to complete the batch allocation which relies on the global common cache 'net_hotdata.skbuff_cache'. Use a xsk standalone skb cache (namely, xs->skb_cache) to store allocated skbs instead of resorting to napi_alloc_cache that was designed for softirq condition.

After allocating memory for each of skbs, in a 'for' loop, the patch borrows part of __allocate_skb() to initialize skb and then calls xsk_build_skb() to complete the rest of initialization process, like copying data and stuff.

Add batch.send_queue and use the skb->list to make skbs into one chain so that they can be easily sent which is shown in the subsequent patches.

In terms of freeing skbs process, napi_consume_skb() in the tx completion would put the skb into global cache 'net_hotdata.skbuff_cache' that implements the deferred freeing skb feature to avoid freeing skb one by one to improve the performance.

Signed-off-by Jason Xing <[email protected]>

---
 include/net/xdp_sock.h |   3 ++
 net/core/skbuff.c      | 101 +++++++++++++++++++++++++++++++++++++++++
 net/xdp/xsk.c          |   1 +
 3 files changed, 105 insertions(+)

include/net/xdp_sock.h +3 -0

index 8944f4782eb6..cb5aa8a314fe 100644
@@ -47,8 +47,10 @@ struct xsk_map {
 
 struct xsk_batch {
 	u32 generic_xmit_batch;
+	unsigned int skb_count;
 	struct sk_buff **skb_cache;
 	struct xdp_desc *desc_cache;
+	struct sk_buff_head send_queue;
 };
 
 struct xdp_sock {

@@ -130,6 +132,7 @@ struct xsk_tx_metadata_ops {
 struct sk_buff *xsk_build_skb(struct xdp_sock *xs,
 			      struct sk_buff *allocated_skb,
 			      struct xdp_desc *desc);
+int xsk_alloc_batch_skb(struct xdp_sock *xs, u32 nb_pkts, u32 nb_descs, int *err);
 #ifdef CONFIG_XDP_SOCKETS
 
 int xsk_generic_rcv(struct xdp_sock *xs, struct xdp_buff *xdp);

net/core/skbuff.c +15 -0

index bc12790017b0..5b6d3b4fa895 100644
@@ -81,6 +81,8 @@
 #include <net/page_pool/helpers.h>
 #include <net/psp/types.h>
 #include <net/dropreason.h>
+#include <net/xdp_sock.h>
+#include <net/xsk_buff_pool.h>
 
 #include <linux/uaccess.h>
 #include <trace/events/skb.h>

@@ -615,6 +617,105 @@ static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node,
 	return obj;
 }
 
+int xsk_alloc_batch_skb(struct xdp_sock *xs, u32 nb_pkts, u32 nb_descs, int *err)
+{
+	struct xsk_batch *batch = &xs->batch;
+	struct xdp_desc *descs = batch->desc_cache;
+	struct sk_buff **skbs = batch->skb_cache;
+	gfp_t gfp_mask = xs->sk.sk_allocation;
+	struct net_device *dev = xs->dev;
+	int node = NUMA_NO_NODE;
+	struct sk_buff *skb;
+	u32 i = 0, j = 0;
+	bool pfmemalloc;
+	u32 base_len;
+	u8 *data;

Quoted 88 lines · Jason Xing

From: Jason Xing <[email protected]>

Support allocating and building skbs in batch.

This patch uses kmem_cache_alloc_bulk() to complete the batch allocation which relies on the global common cache 'net_hotdata.skbuff_cache'. Use a xsk standalone skb cache (namely, xs->skb_cache) to store allocated skbs instead of resorting to napi_alloc_cache that was designed for softirq condition.

After allocating memory for each of skbs, in a 'for' loop, the patch borrows part of __allocate_skb() to initialize skb and then calls xsk_build_skb() to complete the rest of initialization process, like copying data and stuff.

Add batch.send_queue and use the skb->list to make skbs into one chain so that they can be easily sent which is shown in the subsequent patches.

In terms of freeing skbs process, napi_consume_skb() in the tx completion would put the skb into global cache 'net_hotdata.skbuff_cache' that implements the deferred freeing skb feature to avoid freeing skb one by one to improve the performance.

Signed-off-by Jason Xing <[email protected]>

---
 include/net/xdp_sock.h |   3 ++
 net/core/skbuff.c      | 101 +++++++++++++++++++++++++++++++++++++++++
 net/xdp/xsk.c          |   1 +
 3 files changed, 105 insertions(+)

include/net/xdp_sock.h +3 -0

index 8944f4782eb6..cb5aa8a314fe 100644
@@ -47,8 +47,10 @@ struct xsk_map {
 
 struct xsk_batch {
      u32 generic_xmit_batch;
+     unsigned int skb_count;
      struct sk_buff **skb_cache;
      struct xdp_desc *desc_cache;
+     struct sk_buff_head send_queue;
 };
 
 struct xdp_sock {

@@ -130,6 +132,7 @@ struct xsk_tx_metadata_ops {
 struct sk_buff *xsk_build_skb(struct xdp_sock *xs,
                            struct sk_buff *allocated_skb,
                            struct xdp_desc *desc);
+int xsk_alloc_batch_skb(struct xdp_sock *xs, u32 nb_pkts, u32 nb_descs, int *err);
 #ifdef CONFIG_XDP_SOCKETS
 
 int xsk_generic_rcv(struct xdp_sock *xs, struct xdp_buff *xdp);

net/core/skbuff.c +20 -0

index bc12790017b0..5b6d3b4fa895 100644
@@ -81,6 +81,8 @@
 #include <net/page_pool/helpers.h>
 #include <net/psp/types.h>
 #include <net/dropreason.h>
+#include <net/xdp_sock.h>
+#include <net/xsk_buff_pool.h>
 
 #include <linux/uaccess.h>
 #include <trace/events/skb.h>

@@ -615,6 +617,105 @@ static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node,
      return obj;
 }
 
+int xsk_alloc_batch_skb(struct xdp_sock *xs, u32 nb_pkts, u32 nb_descs, int *err)
+{
+     struct xsk_batch *batch = &xs->batch;
+     struct xdp_desc *descs = batch->desc_cache;
+     struct sk_buff **skbs = batch->skb_cache;
+     gfp_t gfp_mask = xs->sk.sk_allocation;
+     struct net_device *dev = xs->dev;
+     int node = NUMA_NO_NODE;
+     struct sk_buff *skb;
+     u32 i = 0, j = 0;
+     bool pfmemalloc;
+     u32 base_len;
+     u8 *data;
+
+     base_len = max(NET_SKB_PAD, L1_CACHE_ALIGN(dev->needed_headroom));
+     if (!(dev->priv_flags & IFF_TX_SKB_NO_LINEAR))
+             base_len += dev->needed_tailroom;
+

net/core/skbuff.c static void *kmalloc_reserve(unsigned int *size, gfp_t flags, int node, · line 642

Quoted 5 lines

net/core/skbuff.c +5 -0

+     if (batch->skb_count >= nb_pkts)
+             goto build;
+
+     if (xs->skb) {
+             i = 1;

What is the point of setting i to 1 here? You always start the loop from i=0.

From: Jason Xing <[email protected]>

This function __xsk_generic_xmit_batch() is the core function in batches xmit, implement a batch version of __xsk_generic_xmit().

The whole logic is divided into sections:
1. check if we have enough available slots in tx ring and completion ring.
2. read descriptors from tx ring into pool->tx_descs in batches
3. reserve enough slots in completion ring to avoid backpressure
4. allocate and build skbs in batches
5. send all the possible packets in batches at one time

Signed-off-by Jason Xing <[email protected]>

Quoted 13 lines · Jason Xing

From: Jason Xing <[email protected]>

This function __xsk_generic_xmit_batch() is the core function in batches xmit, implement a batch version of __xsk_generic_xmit().

The whole logic is divided into sections:
1. check if we have enough available slots in tx ring and completion ring.
2. read descriptors from tx ring into pool->tx_descs in batches
3. reserve enough slots in completion ring to avoid backpressure
4. allocate and build skbs in batches
5. send all the possible packets in batches at one time

Quoted 1 line

Signed-off-by Jason Xing <[email protected]>

Hi Jason,

__xsk_generic_xmit_batch is defined in this patch, but not used until the next one. Which results in a transient warning when building with W=1.

Perhaps it's just as well to squash this patch into the following patch?

From: Jason Xing <[email protected]>

- Move xs->mutex into xsk_generic_xmit to prevent race condition when application manipulates generic_xmit_batch simultaneously.
- Enable batch xmit eventually.

Make the whole feature work eventually.

Signed-off-by Jason Xing <[email protected]>

---
 net/xdp/xsk.c | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

net/xdp/xsk.c +2 -8

index 1fa099653b7d..3741071c68fd 100644
@@ -891,8 +891,6 @@ static int __xsk_generic_xmit_batch(struct xdp_sock *xs)
 	struct sk_buff *skb;
 	int err = 0;
 
-	mutex_lock(&xs->mutex);
-
 	/* Since we dropped the RCU read lock, the socket state might have changed. */
 	if (unlikely(!xsk_is_bound(xs))) {
 		err = -ENXIO;

@@ -982,21 +980,17 @@ static int __xsk_generic_xmit_batch(struct xdp_sock *xs)
 	if (sent_frame)
 		__xsk_tx_release(xs);
 
-	mutex_unlock(&xs->mutex);
 	return err;
 }
 
-static int __xsk_generic_xmit(struct sock *sk)
+static int __xsk_generic_xmit(struct xdp_sock *xs)
 {
-	struct xdp_sock *xs = xdp_sk(sk);
 	bool sent_frame = false;
 	struct xdp_desc desc;
 	struct sk_buff *skb;
 	u32 max_batch;
 	int err = 0;
 
-	mutex_lock(&xs->mutex);
-
 	/* Since we dropped the RCU read lock, the socket state might have changed. */
 	if (unlikely(!xsk_is_bound(xs))) {
 		err = -ENXIO;

@@ -1071,17 +1065,22 @@ static int __xsk_generic_xmit(struct sock *sk)
 	if (sent_frame)
 		__xsk_tx_release(xs);
 
-	mutex_unlock(&xs->mutex);
 	return err;
 }
 
 static int xsk_generic_xmit(struct sock *sk)
 {
+	struct xdp_sock *xs = xdp_sk(sk);

Quoted 62 lines · Jason Xing

From: Jason Xing <[email protected]>

- Move xs->mutex into xsk_generic_xmit to prevent race condition when application manipulates generic_xmit_batch simultaneously.
- Enable batch xmit eventually.

Make the whole feature work eventually.

Signed-off-by Jason Xing <[email protected]>

---
 net/xdp/xsk.c | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

net/xdp/xsk.c +2 -8

index 1fa099653b7d..3741071c68fd 100644
@@ -891,8 +891,6 @@ static int __xsk_generic_xmit_batch(struct xdp_sock *xs)
      struct sk_buff *skb;
      int err = 0;
 
-     mutex_lock(&xs->mutex);
-
      /* Since we dropped the RCU read lock, the socket state might have changed. */
      if (unlikely(!xsk_is_bound(xs))) {
              err = -ENXIO;

@@ -982,21 +980,17 @@ static int __xsk_generic_xmit_batch(struct xdp_sock *xs)
      if (sent_frame)
              __xsk_tx_release(xs);
 
-     mutex_unlock(&xs->mutex);
      return err;
 }
 
-static int __xsk_generic_xmit(struct sock *sk)
+static int __xsk_generic_xmit(struct xdp_sock *xs)
 {
-     struct xdp_sock *xs = xdp_sk(sk);
      bool sent_frame = false;
      struct xdp_desc desc;
      struct sk_buff *skb;
      u32 max_batch;
      int err = 0;
 
-     mutex_lock(&xs->mutex);
-
      /* Since we dropped the RCU read lock, the socket state might have changed. */
      if (unlikely(!xsk_is_bound(xs))) {
              err = -ENXIO;

@@ -1071,17 +1065,22 @@ static int __xsk_generic_xmit(struct sock *sk)
      if (sent_frame)
              __xsk_tx_release(xs);
 
-     mutex_unlock(&xs->mutex);
      return err;
 }
 
 static int xsk_generic_xmit(struct sock *sk)
 {
+     struct xdp_sock *xs = xdp_sk(sk);
      int ret;
 

net/xdp/xsk.c static int __xsk_generic_xmit(struct sock *sk) · line 1082

Quoted 8 lines

net/xdp/xsk.c +5 -1

      /* Drop the RCU lock since the SKB path might sleep. */
      rcu_read_unlock();
-     ret = __xsk_generic_xmit(sk);
+     mutex_lock(&xs->mutex);
+     if (xs->batch.generic_xmit_batch)
+             ret = __xsk_generic_xmit_batch(xs);
+     else
+             ret = __xsk_generic_xmit(xs);

What's the point of keeping __xsk_generic_xmit? Can we have batch=1 by default and always use __xsk_generic_xmit_batch?