[PATCH net v2 1/2] net: keep txq->trans_start on repeated netif_tx_stop_queue()
From: Curtis McBurney
Date: Thu Nov 19 2026 - 09:17:05 EST
Since commit 95ecba62e2fd ("net: fix races in
netdev_tx_sent_queue()/dev_watchdog()"), netif_tx_stop_queue() writes
txq->trans_start on every call, also when the queue is already stopped.
Several drivers stop the queue from their periodic Tx hang check and
leave the recovery to dev_watchdog(). e1000, e1000e, igb and igc call
netif_stop_queue() or netif_stop_subqueue() each time the hang check,
requested every 2 seconds by the driver watchdog, finds the hang again,
and do not wake the queue. Each call now moves trans_start forward, so
dev_watchdog() never sees the queue stopped for longer than
watchdog_timeo (5 seconds for these drivers). ndo_tx_timeout() is never
called and the adapter is never reset: the driver logs "Detected Tx Unit
Hang" every 2 seconds while the NIC stays hung.
Return early from netif_tx_stop_queue() when __QUEUE_STATE_DRV_XOFF is
already set, so a stop on a queue that the driver already stopped
writes neither trans_start nor the bit. A queue stopped only by BQL
(__QUEUE_STATE_STACK_XOFF) still gets a new trans_start when the driver
stops it. On the path that sets the bit, trans_start is still written
before set_bit(), which keeps the ordering against dev_watchdog() added
by 95ecba62e2fd. The early return issues smp_mb(), so callers that
follow the stop with smp_mb__after_atomic(), such as
netif_txq_try_stop(), still get a full barrier.
netif_tx_wake_queue() can clear the bit between test_bit() and the
return. The queue is then running, as if the wake had come after the
stop, and the next stop writes a new trans_start. Setting the bit
without writing trans_start would instead leave a newly stopped queue
with the trans_start of an earlier stop, from any time before if the
caller is preempted, and dev_watchdog() could report a spurious
timeout. netif_tx_stop_queue() is the only function that sets
DRV_XOFF, so every transition of the bit from 0 to 1 follows a
trans_start write by the same caller. The time between that write and
set_bit() is unchanged from 95ecba62e2fd.
The issue was observed on a system in real use: a hung NIC kept
reporting a Tx unit hang and was never reset. Code inspection then
pointed to 95ecba62e2fd.
I reproduced the issue and tested the fix on an AlmaLinux 10 kernel
(6.12.0-211.74.2.el10_2, which contains 95ecba62e2fd) with the e1000
driver on a VMware-emulated Intel 82545EM. Reproducing required
modifying the driver: a test-only module parameter makes
e1000_clean_tx_irq() report a Tx unit hang on every hang check of one
interface. netif_tx_stop_queue() is inlined into the driver, so the
patched variant was e1000 built out of tree against the 6.12 headers
with this change applied. With the fake hang held for 30 seconds:
unpatched: 15 "Detected Tx Unit Hang", no NETDEV WATCHDOG,
tx_timeout 0 -> 0
patched: first "NETDEV WATCHDOG ... timed out 5052 ms" 5 seconds
after the first stop, followed by an adapter reset; the
cycle repeated 5 times (5052 to 5584 ms), each time
followed by a reset; tx_timeout 0 -> 5
This patch was not booted on the net tree. The KUnit tests added in the
next patch pass with this change and fail without it.
I wrote the first version of the fix. Claude Code (Anthropic) reviewed
it, wrote the current change, built the e1000
reproducer and wrote this changelog.
Fixes: 95ecba62e2fd ("net: fix races in netdev_tx_sent_queue()/dev_watchdog()")
Cc: stable@xxxxxxxxxxxxxxx
Signed-off-by: Curtis McBurney <cmcburney@xxxxxxxxxxxxxxxx>
---
include/linux/netdevice.h | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 435be7880d7e..6c0c38d8884a 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -3805,6 +3805,20 @@ static inline void netif_tx_wake_all_queues(struct net_device *dev)
static __always_inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
{
+ /* A queue already stopped by the driver keeps the trans_start of
+ * the stop that set DRV_XOFF, so repeated stops from a driver hang
+ * check do not postpone dev_watchdog(). Neither the stamp nor the
+ * bit is written: a wake racing with this call leaves the queue
+ * running, as if it came after the stop.
+ */
+ if (test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state)) {
+ /* Full barrier, as given by set_bit() followed by
+ * smp_mb__after_atomic(), see netif_txq_try_stop()
+ */
+ smp_mb();
+ return;
+ }
+
/* Paired with READ_ONCE() from dev_watchdog() */
WRITE_ONCE(dev_queue->trans_start, jiffies);
--
2.52.0