kernel/time/clocksource-wdtest.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Unit test for the clocksource watchdog.
 *
 * Copyright (C) 2021 Facebook, Inc.
 * Copyright (C) 2026 Intel Corp.
 *
 * Author: Paul E. McKenney <paulmck@kernel.org>
 * Author: Thomas Gleixner <tglx@kernel.org>
 */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/clocksource.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/kthread.h>

#include "tick-internal.h"
#include "timekeeping_internal.h"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Clocksource watchdog unit test");
MODULE_AUTHOR("Paul E. McKenney <paulmck@kernel.org>");
MODULE_AUTHOR("Thomas Gleixner <tglx@kernel.org>");

enum wdtest_states {
	WDTEST_INJECT_NONE,
	WDTEST_INJECT_DELAY,
	WDTEST_INJECT_POSITIVE,
	WDTEST_INJECT_NEGATIVE,
	WDTEST_INJECT_PERCPU	= 0x100,
};

static enum wdtest_states wdtest_state;
static unsigned long wdtest_test_count;
static ktime_t wdtest_last_ts, wdtest_offset;

#define SHIFT_4000PPM	8

static ktime_t wdtest_get_offset(struct clocksource *cs)
{
	if (wdtest_state < WDTEST_INJECT_PERCPU)
		return wdtest_test_count & 0x1 ? 0 : wdtest_offset >> SHIFT_4000PPM;

	/* Only affect the readout of the "remote" CPU */
	return cs->wd_cpu == smp_processor_id() ? 0 : NSEC_PER_MSEC;
}

static u64 wdtest_ktime_read(struct clocksource *cs)
{
	ktime_t now = ktime_get_raw_fast_ns();
	ktime_t intv = now - wdtest_last_ts;

	/*
	 * Only increment the test counter once per watchdog interval and
	 * store the interval for the offset calculation of this step. This
	 * guarantees a consistent behaviour even if the other side needs
	 * to repeat due to a watchdog read timeout.
	 */
	if (intv > (NSEC_PER_SEC / 4)) {
		WRITE_ONCE(wdtest_test_count, wdtest_test_count + 1);
		wdtest_last_ts = now;
		wdtest_offset = intv;
	}

	switch (wdtest_state & ~WDTEST_INJECT_PERCPU) {
	case WDTEST_INJECT_POSITIVE:
		return now + wdtest_get_offset(cs);
	case WDTEST_INJECT_NEGATIVE:
		return now - wdtest_get_offset(cs);
	case WDTEST_INJECT_DELAY:
		udelay(500);
		return now;
	default:
		return now;
	}
}

#define KTIME_FLAGS (CLOCK_SOURCE_IS_CONTINUOUS |	\
		     CLOCK_SOURCE_CALIBRATED |		\
		     CLOCK_SOURCE_MUST_VERIFY |		\
		     CLOCK_SOURCE_WDTEST)

static struct clocksource clocksource_wdtest_ktime = {
	.name			= "wdtest-ktime",
	.rating			= 10,
	.read			= wdtest_ktime_read,
	.mask			= CLOCKSOURCE_MASK(64),
	.flags			= KTIME_FLAGS,
	.list			= LIST_HEAD_INIT(clocksource_wdtest_ktime.list),
};

static void wdtest_clocksource_reset(enum wdtest_states which, bool percpu)
{
	clocksource_unregister(&clocksource_wdtest_ktime);

	pr_info("Test: State %d percpu %d\n", which, percpu);

	wdtest_state = which;
	if (percpu)
		wdtest_state |= WDTEST_INJECT_PERCPU;
	wdtest_test_count = 0;
	wdtest_last_ts = 0;

	clocksource_wdtest_ktime.rating = 10;
	clocksource_wdtest_ktime.flags = KTIME_FLAGS;
	if (percpu)
		clocksource_wdtest_ktime.flags |= CLOCK_SOURCE_WDTEST_PERCPU;
	clocksource_register_khz(&clocksource_wdtest_ktime, 1000 * 1000);
}

static bool wdtest_execute(enum wdtest_states which, bool percpu, unsigned int expect,
			   unsigned long calls)
{
	wdtest_clocksource_reset(which, percpu);

	for (; READ_ONCE(wdtest_test_count) < calls; msleep(100)) {
		unsigned int flags = READ_ONCE(clocksource_wdtest_ktime.flags);

		if (kthread_should_stop())
			return false;

		if (flags & CLOCK_SOURCE_UNSTABLE) {
			if (expect & CLOCK_SOURCE_UNSTABLE)
				return true;
			pr_warn("Fail: Unexpected unstable\n");
			return false;
		}
		if (flags & CLOCK_SOURCE_VALID_FOR_HRES) {
			if (expect & CLOCK_SOURCE_VALID_FOR_HRES)
				return true;
			pr_warn("Fail: Unexpected valid for highres\n");
			return false;
		}
	}

	if (!expect)
		return true;

	pr_warn("Fail: Timed out\n");
	return false;
}

static bool wdtest_run(bool percpu)
{
	if (!wdtest_execute(WDTEST_INJECT_NONE, percpu, CLOCK_SOURCE_VALID_FOR_HRES, 8))
		return false;

	if (!wdtest_execute(WDTEST_INJECT_DELAY, percpu, 0, 4))
		return false;

	if (!wdtest_execute(WDTEST_INJECT_POSITIVE, percpu, CLOCK_SOURCE_UNSTABLE, 8))
		return false;

	if (!wdtest_execute(WDTEST_INJECT_NEGATIVE, percpu, CLOCK_SOURCE_UNSTABLE, 8))
		return false;

	return true;
}

static int wdtest_func(void *arg)
{
	clocksource_register_khz(&clocksource_wdtest_ktime, 1000 * 1000);
	if (wdtest_run(false)) {
		if (wdtest_run(true))
			pr_info("Success: All tests passed\n");
	}
	clocksource_unregister(&clocksource_wdtest_ktime);

	if (!IS_MODULE(CONFIG_TEST_CLOCKSOURCE_WATCHDOG))
		return 0;

	while (!kthread_should_stop())
		schedule_timeout_interruptible(3600 * HZ);
	return 0;
}

static struct task_struct *wdtest_thread;

static int __init clocksource_wdtest_init(void)
{
	struct task_struct *t = kthread_run(wdtest_func, NULL, "wdtest");

	if (IS_ERR(t)) {
		pr_warn("Failed to create wdtest kthread.\n");
		return PTR_ERR(t);
	}
	wdtest_thread = t;
	return 0;
}
module_init(clocksource_wdtest_init);

static void clocksource_wdtest_cleanup(void)
{
	if (wdtest_thread)
		kthread_stop(wdtest_thread);
}
module_exit(clocksource_wdtest_cleanup);