// 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);