archives/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-03-08 01:24:47 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

kunit: irq: Ensure timer doesn't fire too frequently

Browse source 
Fix a bug where kunit_run_irq_test() could hang if the system is too
slow.  This was noticed with the crypto library tests in certain VMs.

Specifically, if kunit_irq_test_timer_func() and the associated hrtimer
code took over 5us to run, then the CPU would spend all its time
executing that code in hardirq context.  As a result, the task executing
kunit_run_irq_test() never had a chance to run, exit the loop, and
cancel the timer.

To fix it, make kunit_irq_test_timer_func() increase the timer interval
when the other contexts aren't having a chance to run.

Fixes: 950a81224e ("lib/crypto: tests: Add hash-test-template.h and gen-hash-testvecs.py")
Cc: stable@vger.kernel.org
Reviewed-by: David Gow <david@davidgow.net>
Link: https://lore.kernel.org/r/20260224033751.97615-1-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>
This commit is contained in:
Eric Biggers 2026-02-23 19:37:51 -08:00
parent 6de23f81a5
commit 201ceb94aa
1 changed files with 28 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

44
include/kunit/run-in-irq-context.h
View file

@ -12,16 +12,16 @@
#include <linux/hrtimer.h> #include <linux/hrtimer.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#define KUNIT_IRQ_TEST_HRTIMER_INTERVAL us_to_ktime(5)
struct kunit_irq_test_state { struct kunit_irq_test_state {
bool (*func)(void *test_specific_state); bool (*func)(void *test_specific_state);
void *test_specific_state; void *test_specific_state;
bool task_func_reported_failure; bool task_func_reported_failure;
bool hardirq_func_reported_failure; bool hardirq_func_reported_failure;
bool softirq_func_reported_failure; bool softirq_func_reported_failure;
atomic_t task_func_calls;
atomic_t hardirq_func_calls; atomic_t hardirq_func_calls;
atomic_t softirq_func_calls; atomic_t softirq_func_calls;
ktime_t interval;
struct hrtimer timer; struct hrtimer timer;
struct work_struct bh_work; struct work_struct bh_work;
}; };
@ -30,14 +30,25 @@ static enum hrtimer_restart kunit_irq_test_timer_func(struct hrtimer *timer)
{ {
struct kunit_irq_test_state *state = struct kunit_irq_test_state *state =
container_of(timer, typeof(*state), timer); container_of(timer, typeof(*state), timer);
int task_calls, hardirq_calls, softirq_calls;
WARN_ON_ONCE(!in_hardirq()); WARN_ON_ONCE(!in_hardirq());
atomic_inc(&state->hardirq_func_calls); task_calls = atomic_read(&state->task_func_calls);
hardirq_calls = atomic_inc_return(&state->hardirq_func_calls);
softirq_calls = atomic_read(&state->softirq_func_calls);
/*
* If the timer is firing too often for the softirq or task to ever have
* a chance to run, increase the timer interval. This is needed on very
* slow systems.
*/
if (hardirq_calls >= 20 && (softirq_calls == 0 || task_calls == 0))
state->interval = ktime_add_ns(state->interval, 250);
if (!state->func(state->test_specific_state)) if (!state->func(state->test_specific_state))
state->hardirq_func_reported_failure = true; state->hardirq_func_reported_failure = true;
hrtimer_forward_now(&state->timer, KUNIT_IRQ_TEST_HRTIMER_INTERVAL); hrtimer_forward_now(&state->timer, state->interval);
queue_work(system_bh_wq, &state->bh_work); queue_work(system_bh_wq, &state->bh_work);
return HRTIMER_RESTART; return HRTIMER_RESTART;
} }
@ -86,10 +97,14 @@ static inline void kunit_run_irq_test(struct kunit *test, bool (*func)(void *),
struct kunit_irq_test_state state = { struct kunit_irq_test_state state = {
.func = func, .func = func,
.test_specific_state = test_specific_state, .test_specific_state = test_specific_state,
/*
* Start with a 5us timer interval. If the system can't keep
* up, kunit_irq_test_timer_func() will increase it.
*/
.interval = us_to_ktime(5),
}; };
unsigned long end_jiffies; unsigned long end_jiffies;
int hardirq_calls, softirq_calls; int task_calls, hardirq_calls, softirq_calls;
bool allctx = false;
/* /*
* Set up a hrtimer (the way we access hardirq context) and a work * Set up a hrtimer (the way we access hardirq context) and a work
@ -104,21 +119,18 @@ static inline void kunit_run_irq_test(struct kunit *test, bool (*func)(void *),
* and hardirq), or 1 second, whichever comes first. * and hardirq), or 1 second, whichever comes first.
*/ */
end_jiffies = jiffies + HZ; end_jiffies = jiffies + HZ;
hrtimer_start(&state.timer, KUNIT_IRQ_TEST_HRTIMER_INTERVAL, hrtimer_start(&state.timer, state.interval, HRTIMER_MODE_REL_HARD);
HRTIMER_MODE_REL_HARD); do {
for (int task_calls = 0, calls = 0;
((calls < max_iterations) || !allctx) &&
!time_after(jiffies, end_jiffies);
task_calls++) {
if (!func(test_specific_state)) if (!func(test_specific_state))
state.task_func_reported_failure = true; state.task_func_reported_failure = true;
task_calls = atomic_inc_return(&state.task_func_calls);
hardirq_calls = atomic_read(&state.hardirq_func_calls); hardirq_calls = atomic_read(&state.hardirq_func_calls);
softirq_calls = atomic_read(&state.softirq_func_calls); softirq_calls = atomic_read(&state.softirq_func_calls);
calls = task_calls + hardirq_calls + softirq_calls; } while ((task_calls + hardirq_calls + softirq_calls < max_iterations ||
allctx = (task_calls > 0) && (hardirq_calls > 0) && (task_calls == 0 || hardirq_calls == 0 ||
(softirq_calls > 0); softirq_calls == 0)) &&
} !time_after(jiffies, end_jiffies));
/* Cancel the timer and work. */ /* Cancel the timer and work. */
hrtimer_cancel(&state.timer); hrtimer_cancel(&state.timer);