BPF List
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Anandu Padinhare" <Anandu.Padinhare@electrifex.com>
Cc: "bpf@vger.kernel.org" <bpf@vger.kernel.org>
Subject: Re: [PATCH net] net: stmmac: retry a failed RX refill from a timer
Date: Sat, 21 Nov 2026 07:49:33 +0000	[thread overview]
Message-ID: <sashiko-outbox-226803@kernel.org> (raw)
In-Reply-To: <MA0PR01MB921746F36D90C7080287ACC9FD782@MA0PR01MB9217.INDPRD01.PROD.OUTLOOK.COM>

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

      reply	other threads:[~2026-11-21  7:49 UTC|newest]

Thread overview: 2+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
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 message]

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=sashiko-outbox-226803@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=Anandu.Padinhare@electrifex.com \
    --cc=bpf@vger.kernel.org \
    --cc=sashiko-reviews@lists.linux.dev \
    /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