Add KUnit tests for the txq->trans_start handling of netif_tx_stop_queue(), which dev_watchdog() uses to detect a stuck queue: - a stop on a running queue writes trans_start - a stop on a queue already stopped by the driver keeps trans_start - a stop after netif_tx_start_queue() writes trans_start again - a stop on a queue stopped only by BQL (__QUEUE_STATE_STACK_XOFF) writes trans_start txq_stop_keeps_stamp_stopped_queue fails without the previous patch. The tests run on a single thread and do not cover a wake that races with a stop. The previous patch removes that race by construction: a stop that finds the bit set writes neither trans_start nor the bit. Tested on UML with CONFIG_KUNIT, CONFIG_NET and CONFIG_NET_TEST: tools/testing/kunit/kunit.py run --kunitconfig= 'net_core.txq_*' Claude Code (Anthropic) wrote these tests and this changelog. Signed-off-by: Curtis McBurney --- net/core/net_test.c | 112 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 112 insertions(+) diff --git a/net/core/net_test.c b/net/core/net_test.c index c36333b36211..368545f1f987 100644 --- a/net/core/net_test.c +++ b/net/core/net_test.c @@ -1723,6 +1723,114 @@ static void netmem_ref_test_tcp_devmem_recv(struct kunit *test) #endif #endif +/* netif_tx_stop_queue() and txq->trans_start */ + +#include +#include +#include + +/* dev_watchdog() reports a timeout when a queue stays stopped for longer + * than watchdog_timeo after txq->trans_start. A trans_start value this far + * in the past is distinguishable from a fresh one. + */ +#define TXQ_TEST_OLD_DELTA (10 * HZ) + +KUNIT_DEFINE_ACTION_WRAPPER(txq_test_free_netdev, free_netdev, + struct net_device *); + +static struct netdev_queue *txq_test_alloc(struct kunit *test) +{ + struct net_device *dev; + + dev = alloc_etherdev(0); + KUNIT_ASSERT_NOT_NULL(test, dev); + KUNIT_ASSERT_EQ(test, 0, + kunit_add_action_or_reset(test, txq_test_free_netdev, + dev)); + + return netdev_get_tx_queue(dev, 0); +} + +static void txq_test_expect_fresh(struct kunit *test, + struct netdev_queue *txq, + unsigned long before) +{ + unsigned long stamp = READ_ONCE(txq->trans_start); + + KUNIT_EXPECT_TRUE_MSG(test, time_in_range(stamp, before, jiffies), + "trans_start=%lu not in [%lu, %lu]", + stamp, before, jiffies); +} + +/* A stop on a running queue records the stop time in trans_start */ +static void txq_stop_stamps_running_queue(struct kunit *test) +{ + struct netdev_queue *txq = txq_test_alloc(test); + unsigned long before; + + WRITE_ONCE(txq->trans_start, jiffies - TXQ_TEST_OLD_DELTA); + before = jiffies; + netif_tx_stop_queue(txq); + + KUNIT_EXPECT_TRUE(test, netif_tx_queue_stopped(txq)); + txq_test_expect_fresh(test, txq, before); +} + +/* A stop on a queue that is already stopped keeps the first stop time, so + * repeated stops from a driver hang check do not postpone dev_watchdog() + */ +static void txq_stop_keeps_stamp_stopped_queue(struct kunit *test) +{ + struct netdev_queue *txq = txq_test_alloc(test); + unsigned long old, stamp; + + netif_tx_stop_queue(txq); + old = jiffies - TXQ_TEST_OLD_DELTA; + WRITE_ONCE(txq->trans_start, old); + netif_tx_stop_queue(txq); + stamp = READ_ONCE(txq->trans_start); + + KUNIT_EXPECT_TRUE(test, netif_tx_queue_stopped(txq)); + KUNIT_EXPECT_EQ_MSG(test, stamp, old, + "second stop moved trans_start forward by %lu jiffies", + stamp - old); +} + +/* A stop after a restart records a new stop time */ +static void txq_stop_stamps_restarted_queue(struct kunit *test) +{ + struct netdev_queue *txq = txq_test_alloc(test); + unsigned long before; + + netif_tx_stop_queue(txq); + netif_tx_start_queue(txq); + KUNIT_EXPECT_FALSE(test, netif_tx_queue_stopped(txq)); + + WRITE_ONCE(txq->trans_start, jiffies - TXQ_TEST_OLD_DELTA); + before = jiffies; + netif_tx_stop_queue(txq); + + KUNIT_EXPECT_TRUE(test, netif_tx_queue_stopped(txq)); + txq_test_expect_fresh(test, txq, before); +} + +/* Only the driver XOFF bit decides whether the stop is a transition. A queue + * stopped by BQL (stack XOFF) gets a new stop time when the driver stops it. + */ +static void txq_stop_stamps_stack_stopped_queue(struct kunit *test) +{ + struct netdev_queue *txq = txq_test_alloc(test); + unsigned long before; + + set_bit(__QUEUE_STATE_STACK_XOFF, &txq->state); + WRITE_ONCE(txq->trans_start, jiffies - TXQ_TEST_OLD_DELTA); + before = jiffies; + netif_tx_stop_queue(txq); + + KUNIT_EXPECT_TRUE(test, netif_tx_queue_stopped(txq)); + txq_test_expect_fresh(test, txq, before); +} + static struct kunit_case net_test_cases[] = { KUNIT_CASE_PARAM(gso_test_func, gso_test_gen_params), KUNIT_CASE_PARAM(ip_tunnel_flags_test_run, @@ -1740,6 +1848,10 @@ static struct kunit_case net_test_cases[] = { KUNIT_CASE(netmem_ref_test_tcp_devmem_recv), #endif #endif + KUNIT_CASE(txq_stop_stamps_running_queue), + KUNIT_CASE(txq_stop_keeps_stamp_stopped_queue), + KUNIT_CASE(txq_stop_stamps_restarted_queue), + KUNIT_CASE(txq_stop_stamps_stack_stopped_queue), { }, }; -- 2.52.0