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 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.