All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH net] net: stmmac: retry a failed RX refill from a timer
@ 2026-11-20  7:49 Anandu Padinhare
  2026-11-21  7:49 ` sashiko-bot
  0 siblings, 1 reply; 2+ messages in thread
From: Anandu Padinhare @ 2026-11-20  7:49 UTC (permalink / raw)
  To: maxime.chevallier@bootlin.com, andrew+netdev@lunn.ch,
	davem@davemloft.net, edumazet@kernel.org, kuba@kernel.org,
	pabeni@redhat.com
  Cc: mcoquelin.stm32@gmail.com, alexandre.torgue@foss.st.com,
	Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
	John Fastabend, Stanislav Fomichev, Sam Edwards,
	Russell King (Oracle), David Wu, stable@vger.kernel.org,
	netdev@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com,
	linux-arm-kernel@lists.infradead.org, bpf@vger.kernel.org

stmmac_rx_refill() stops at the first page_pool allocation failure. The
refill is retried only from the next RX NAPI poll, and only an RX
interrupt schedules that poll. Once the DMA has used the buffers it
still had, it suspends, no RX interrupt comes, and receive can stay dead
even after memory is available again, until the interface is reopened.
Commit 0bb05e6adfa9 ("net: stmmac: Prevent NULL deref when RX memory
exhausted") describes this stall and leaves it for a later change.

When at most STMMAC_RX_REFILL_THRESH (16) slots are left with the DMA
after a poll, arm a per-channel timer that schedules the RX NAPI 10 ms
later. The poll retries the refill and re-arms the timer while
allocations keep failing, so NAPI does not keep polling while memory is
short. This follows the review of an earlier attempt (see Links). The
retry does not rely on the Receive Buffer Unavailable (RBU) interrupt,
which is not enabled on every core and kernel version.

The timer lives in struct stmmac_channel, because __stmmac_open()
replaces priv->dma_conf. It is cancelled after rx_napi is disabled, and
stmmac_enable_all_queues() re-arms it, because
stmmac_setup_tc_block_cb() disables and re-enables the queues without
re-initialising the rings.

Found while debugging a separate AF_XDP zero-copy RX stall, with the
help of an AI code review agent. Reproduced on an ADI ADSP-SC598
(dwmac 5.20) with a kernel based on ADI's 6.18.31, using error
injection: page_pool_alloc_netmems() was made to return NULL on every
call through fail_function (retval 0, probability 100, times -1) for 3 s
while receiving about 4000 frames/s. With the RBU interrupt disabled
(the dwmac4 default in 6.18), receive stayed dead in 6 of 6 runs until
ethtool -G.

Tested on the same board with the fix backported: receive came back by
itself in every run of the reproducer, with the RBU interrupt off and
on. Only build-tested on mainline. Other DMA cores were not tested.
Kernel selftests were not run.

Fixes: 47dd7a540b8a ("net: add support for STMicroelectronics Ethernet controllers.")
Cc: stable@vger.kernel.org
Link: https://lore.kernel.org/netdev/20260331195927.3353cc6d@kernel.org/
Link: https://lore.kernel.org/netdev/20260402174049.0ac088cc@kernel.org/
Signed-off-by: Anandu Padinhare <Anandu.Padinhare@electrifex.com>
---
More testing on the board, with KASAN, lockdep and DEBUG_OBJECTS_TIMERS
and the RBU interrupt off and on: failure rates from 1 % to 99 %, up to
60 s of failures, RX rings of 64 to 1024 entries, and down/up, ethtool
-G/-L, MTU, tc flower, XDP and AF_XDP zero-copy changes while the ring
was empty. A driver unbind with a retry pending was also tested (RBU
interrupt off). Traced with ftrace, frames arrived again 31-37 ms after
the failures stopped. With 50 % to 100 % of the allocations failing and
the RBU interrupt off, the retry timer fired 52-61 times per second and
the CPU stayed 86-96 % idle.

With the RBU interrupt enabled (dwmac4 since v7.1), an RBU interrupt
storm follows on the test board when every allocation fails, with and
without this patch. Without this patch, receive came back through that
storm in 4 of 5 runs and stayed dead in one.

 drivers/net/ethernet/stmicro/stmmac/stmmac.h  |  1 +
 .../net/ethernet/stmicro/stmmac/stmmac_main.c | 47 ++++++++++++++++++-
 .../net/ethernet/stmicro/stmmac/stmmac_xdp.c  |  1 +
 3 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac.h b/drivers/net/ethernet/stmicro/stmmac/stmmac.h
index b76acfe0d958..88b83dc3cf0f 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac.h
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac.h
@@ -142,6 +142,7 @@ struct stmmac_channel {
 	struct napi_struct rx_napi ____cacheline_aligned_in_smp;
 	struct napi_struct tx_napi ____cacheline_aligned_in_smp;
 	struct napi_struct rxtx_napi ____cacheline_aligned_in_smp;
+	struct timer_list rx_refill_timer;
 	struct stmmac_priv *priv_data;
 	spinlock_t lock;
 	u32 index;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index a685ce4638f6..ad9873aaf2db 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -86,6 +86,8 @@ MODULE_PARM_DESC(phyaddr, "Physical device address");
 #define STMMAC_XSK_TX_BUDGET_MAX	256
 #define STMMAC_TX_XSK_AVAIL		16
 #define STMMAC_RX_FILL_BATCH		16
+#define STMMAC_RX_REFILL_THRESH		16
+#define STMMAC_RX_REFILL_RETRY_MS	10
 
 #define STMMAC_XDP_PASS		0
 #define STMMAC_XDP_CONSUMED	BIT(0)
@@ -263,6 +265,32 @@ static void stmmac_verify_args(void)
 		pr_warn("stmmac: module parameter 'flow_ctrl' is obsolete - please remove from your module configuration\n");
 }
 
+/* The RX DMA suspends without an interrupt once it has used all its buffers,
+ * so a refill that failed for lack of memory would never be retried. Retry it
+ * from a timer when few slots are left with the DMA.
+ */
+static bool stmmac_rx_refill_needed(struct stmmac_priv *priv, u32 queue)
+{
+	struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[queue];
+
+	return CIRC_SPACE(rx_q->cur_rx, rx_q->dirty_rx,
+			  priv->dma_conf.dma_rx_size) < STMMAC_RX_REFILL_THRESH;
+}
+
+static void stmmac_rx_refill_timer_arm(struct stmmac_channel *ch)
+{
+	if (!timer_pending(&ch->rx_refill_timer))
+		mod_timer(&ch->rx_refill_timer,
+			  jiffies + msecs_to_jiffies(STMMAC_RX_REFILL_RETRY_MS));
+}
+
+static void stmmac_rx_refill_timer(struct timer_list *t)
+{
+	struct stmmac_channel *ch = timer_container_of(ch, t, rx_refill_timer);
+
+	napi_schedule(&ch->rx_napi);
+}
+
 static void __stmmac_disable_all_queues(struct stmmac_priv *priv)
 {
 	u8 rx_queues_cnt = priv->plat->rx_queues_to_use;
@@ -284,6 +312,10 @@ static void __stmmac_disable_all_queues(struct stmmac_priv *priv)
 		if (queue < tx_queues_cnt)
 			napi_disable(&ch->tx_napi);
 	}
+
+	/* With NAPI disabled no poll can re-arm the refill timers */
+	for (queue = 0; queue < rx_queues_cnt; queue++)
+		timer_delete_sync(&priv->channel[queue].rx_refill_timer);
 }
 
 /**
@@ -328,8 +360,17 @@ static void stmmac_enable_all_queues(struct stmmac_priv *priv)
 			continue;
 		}
 
-		if (queue < rx_queues_cnt)
+		if (queue < rx_queues_cnt) {
+			/* Disabling the queues cancelled any pending refill
+			 * retry, but the ring may have been kept as it was.
+			 * Check it while no poll can run.
+			 */
+			bool refill = stmmac_rx_refill_needed(priv, queue);
+
 			napi_enable(&ch->rx_napi);
+			if (refill)
+				stmmac_rx_refill_timer_arm(ch);
+		}
 		if (queue < tx_queues_cnt)
 			napi_enable(&ch->tx_napi);
 	}
@@ -6164,6 +6205,8 @@ static int stmmac_napi_poll_rx(struct napi_struct *napi, int budget)
 	u64_stats_update_end(&rxq_stats->napi_syncp);
 
 	work_done = stmmac_rx(priv, budget, chan);
+	if (unlikely(stmmac_rx_refill_needed(priv, chan)))
+		stmmac_rx_refill_timer_arm(ch);
 	if (work_done < budget && napi_complete_done(napi, work_done)) {
 		unsigned long flags;
 
@@ -7779,6 +7822,8 @@ static void stmmac_napi_add(struct net_device *dev)
 
 		if (queue < priv->plat->rx_queues_to_use) {
 			netif_napi_add(dev, &ch->rx_napi, stmmac_napi_poll_rx);
+			timer_setup(&ch->rx_refill_timer,
+				    stmmac_rx_refill_timer, 0);
 		}
 		if (queue < priv->plat->tx_queues_to_use) {
 			netif_napi_add_tx(dev, &ch->tx_napi,
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c
index 9af9e0cb366c..c3e85ee1067c 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c
@@ -35,6 +35,7 @@ static int stmmac_xdp_enable_pool(struct stmmac_priv *priv,
 
 	if (need_update) {
 		napi_disable(&ch->rx_napi);
+		timer_delete_sync(&ch->rx_refill_timer);
 		napi_disable(&ch->tx_napi);
 		stmmac_disable_rx_queue(priv, queue);
 		stmmac_disable_tx_queue(priv, queue);

base-commit: 325e921a7aa170181e1cce235d9c652cb0ad3a5b

^ permalink raw reply related	[flat|nested] 2+ messages in thread

* Re: [PATCH net] net: stmmac: retry a failed RX refill from a timer
  2026-11-20  7:49 [PATCH net] net: stmmac: retry a failed RX refill from a timer Anandu Padinhare
@ 2026-11-21  7:49 ` sashiko-bot
  0 siblings, 0 replies; 2+ messages in thread
From: sashiko-bot @ 2026-11-21  7:49 UTC (permalink / raw)
  To: Anandu Padinhare; +Cc: bpf@vger.kernel.org

Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Medium] net: stmmac: stmmac_rx() runs receive loop before
  stmmac_rx_refill() on retry
It also noticed 2 related pre-existing issues this patch does not
introduce:
- [Critical] net: stmmac: XDP buffer race window in
  stmmac_disable_all_queues() [1]
- [High] net: stmmac: missing datapath and PM runtime checks in
  stmmac_setup_tc() [2]
--

commit 23d224e20637c2030c16317bc5eb885c790893b3
Author: Anandu Padinhare <Anandu.Padinhare@electrifex.com>

net: stmmac: retry a failed RX refill from a timer

This commit adds a per-channel timer that schedules RX NAPI when fewer than
16 RX descriptor slots remain with the DMA, so failed page_pool allocations
in stmmac_rx_refill() are retried without relying on new RX interrupts.

Link: https://lore.kernel.org/netdev/20260331195927.3353cc6d@kernel.org/
Link: https://lore.kernel.org/netdev/20260402174049.0ac088cc@kernel.org/

> diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
> index a685ce4638f61..ad9873aaf2dba 100644
> --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
> +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

[ ... ]

> @@ -284,6 +312,10 @@ static void __stmmac_disable_all_queues(struct stmmac_priv *priv)
>  		if (queue < tx_queues_cnt)
>  			napi_disable(&ch->tx_napi);
>  	}
> +
> +	/* With NAPI disabled no poll can re-arm the refill timers */
> +	for (queue = 0; queue < rx_queues_cnt; queue++)
> +		timer_delete_sync(&priv->channel[queue].rx_refill_timer);
>  }

[Severity: Critical]
This problem wasn't introduced by this patch, but in
stmmac_disable_all_queues() [1], doesn't calling synchronize_rcu()
before __stmmac_disable_all_queues() leave a window where NAPI is still
enabled and can queue new AF_XDP zero-copy buffers after the RCU grace
period finishes?

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c:stmmac_disable_all_queues() {
	/* synchronize_rcu() needed for pending XDP buffers to drain */
	for (queue = 0; queue < rx_queues_cnt; queue++) {
		rx_q = &priv->dma_conf.rx_queue[queue];
		if (rx_q->xsk_pool) {
			synchronize_rcu();
			break;
		}
	}

	__stmmac_disable_all_queues(priv);
}

Because NAPI and the refill timers are only stopped inside
__stmmac_disable_all_queues(), polls running during or after
synchronize_rcu() can continue processing XDP buffers right before the XSK
pool and DMA resources are torn down, leading to a use-after-free.

> @@ -328,8 +360,17 @@ static void stmmac_enable_all_queues(struct stmmac_priv *priv)
>  			continue;
>  		}
>  
> -		if (queue < rx_queues_cnt)
> +		if (queue < rx_queues_cnt) {
> +			/* Disabling the queues cancelled any pending refill
> +			 * retry, but the ring may have been kept as it was.
> +			 * Check it while no poll can run.
> +			 */
> +			bool refill = stmmac_rx_refill_needed(priv, queue);
> +
>  			napi_enable(&ch->rx_napi);
> +			if (refill)
> +				stmmac_rx_refill_timer_arm(ch);
> +		}
>  		if (queue < tx_queues_cnt)
>  			napi_enable(&ch->tx_napi);
>  	}

[Severity: High]
This problem wasn't introduced by this patch, but what happens when
stmmac_setup_tc_block_cb() [2] calls __stmmac_disable_all_queues()
and stmmac_enable_all_queues() while the interface is administratively
down?

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c:stmmac_setup_tc_block_cb() {
	if (!tc_cls_can_offload_and_chain0(priv->dev, type_data))
		return ret;

	__stmmac_disable_all_queues(priv);
	...
	stmmac_enable_all_queues(priv);
}

When the interface is down, NAPI is already disabled and the device is
runtime-suspended, so configuring a TC flower or u32 filter calls
napi_disable() a second time in __stmmac_disable_all_queues() (deadlocking
on NAPI state) and accesses clock-gated MAC registers without waking the
device via pm_runtime_resume_and_get().

> @@ -6164,6 +6205,8 @@ static int stmmac_napi_poll_rx(struct napi_struct *napi, int budget)
>  	u64_stats_update_end(&rxq_stats->napi_syncp);
>  
>  	work_done = stmmac_rx(priv, budget, chan);
> +	if (unlikely(stmmac_rx_refill_needed(priv, chan)))
> +		stmmac_rx_refill_timer_arm(ch);
>  	if (work_done < budget && napi_complete_done(napi, work_done)) {
>  		unsigned long flags;

[Severity: Medium]
When the RX ring is completely depleted (CIRC_SPACE is 0) and the DMA has
already written a frame into the final descriptor at rx_q->cur_rx, can
stmmac_rx() leave that frame stranded once the timer poll finally succeeds
in refilling the ring?

In stmmac_rx(), the receive loop runs before stmmac_rx_refill():

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c:stmmac_rx() {
	while (count < limit) {
		...
		status = stmmac_rx_status(priv, &priv->xstats, p);
		/* check if managed by the DMA otherwise go ahead */
		if (unlikely(status & dma_own))
			break;

		next_entry = STMMAC_NEXT_ENTRY(rx_q->cur_rx,
					       priv->dma_conf.dma_rx_size);
		if (unlikely(next_entry == rx_q->dirty_rx))
			break;
		...
	}
	...
	stmmac_rx_refill(priv, queue);
}

Commit 0bb05e6adfa9 ("net: stmmac: Prevent NULL deref when RX memory
exhausted") defers consuming the last descriptor at rx_q->cur_rx when
next_entry == rx_q->dirty_rx until stmmac_rx_refill() advances
rx_q->dirty_rx.  Because the timer-scheduled poll enters the receive loop
before calling stmmac_rx_refill(), two things happen:

1. While allocations keep failing, every 10 ms retry poll runs
   stmmac_rx_status() on the same unconsumed descriptor at rx_q->cur_rx
   before breaking on next_entry == rx_q->dirty_rx, repeatedly incrementing
   priv->xstats counters for that frame.
2. Once memory is available again, the receive loop still sees
   next_entry == rx_q->dirty_rx and breaks out with work_done == 0, after
   which stmmac_rx_refill() refills the ring and advances rx_q->dirty_rx.
   stmmac_napi_poll_rx() then sees stmmac_rx_refill_needed() == false and
   completes NAPI via napi_complete_done(), leaving the already-received
   frame at rx_q->cur_rx unprocessed until another packet arrives on that
   queue.

Calling stmmac_rx_refill() at the start of stmmac_rx() when
stmmac_rx_refill_needed() is true (or checking next_entry == rx_q->dirty_rx
before stmmac_rx_status()) would allow the recovery poll to consume the
deferred descriptor and avoid double-counting its status.

[1] https://sashiko.dev/#/bug/linux-644f1987-e595-49b8-bf50-2de2c07a3eaf
[2] https://sashiko.dev/#/bug/linux-3ead95d4-661e-4a8f-a68a-8b257e32b68c

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/MA0PR01MB921746F36D90C7080287ACC9FD782@MA0PR01MB9217.INDPRD01.PROD.OUTLOOK.COM?part=1

^ permalink raw reply	[flat|nested] 2+ messages in thread

end of thread, other threads:[~2026-11-21  7:49 UTC | newest]

Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-20  7:49 [PATCH net] net: stmmac: retry a failed RX refill from a timer Anandu Padinhare
2026-11-21  7:49 ` sashiko-bot

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.