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
prev parent 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