1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Unit test for the clocksource watchdog.
4 *
5 * Copyright (C) 2021 Facebook, Inc.
6 *
7 * Author: Paul E. McKenney <paulmck@kernel.org>
8 */
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#include <linux/device.h>
12#include <linux/clocksource.h>
13#include <linux/init.h>
14#include <linux/module.h>
15#include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
16#include <linux/tick.h>
17#include <linux/kthread.h>
18#include <linux/delay.h>
19#include <linux/prandom.h>
20#include <linux/cpu.h>
21
22#include "tick-internal.h"
23
24MODULE_LICENSE("GPL");
25MODULE_AUTHOR("Paul E. McKenney <paulmck@kernel.org>");
26
27static int holdoff = IS_BUILTIN(CONFIG_TEST_CLOCKSOURCE_WATCHDOG) ? 10 : 0;
28module_param(holdoff, int, 0444);
29MODULE_PARM_DESC(holdoff, "Time to wait to start test (s).");
30
31/* Watchdog kthread's task_struct pointer for debug purposes. */
32static struct task_struct *wdtest_task;
33
34static u64 wdtest_jiffies_read(struct clocksource *cs)
35{
36	return (u64)jiffies;
37}
38
39static struct clocksource clocksource_wdtest_jiffies = {
40	.name			= "wdtest-jiffies",
41	.rating			= 1, /* lowest valid rating*/
42	.uncertainty_margin	= TICK_NSEC,
43	.read			= wdtest_jiffies_read,
44	.mask			= CLOCKSOURCE_MASK(32),
45	.flags			= CLOCK_SOURCE_MUST_VERIFY,
46	.mult			= TICK_NSEC << JIFFIES_SHIFT, /* details above */
47	.shift			= JIFFIES_SHIFT,
48	.max_cycles		= 10,
49};
50
51static int wdtest_ktime_read_ndelays;
52static bool wdtest_ktime_read_fuzz;
53
54static u64 wdtest_ktime_read(struct clocksource *cs)
55{
56	int wkrn = READ_ONCE(wdtest_ktime_read_ndelays);
57	static int sign = 1;
58	u64 ret;
59
60	if (wkrn) {
61		udelay(cs->uncertainty_margin / 250);
62		WRITE_ONCE(wdtest_ktime_read_ndelays, wkrn - 1);
63	}
64	ret = ktime_get_real_fast_ns();
65	if (READ_ONCE(wdtest_ktime_read_fuzz)) {
66		sign = -sign;
67		ret = ret + sign * 100 * NSEC_PER_MSEC;
68	}
69	return ret;
70}
71
72static void wdtest_ktime_cs_mark_unstable(struct clocksource *cs)
73{
74	pr_info("--- Marking %s unstable due to clocksource watchdog.\n", cs->name);
75}
76
77#define KTIME_FLAGS (CLOCK_SOURCE_IS_CONTINUOUS | \
78		     CLOCK_SOURCE_VALID_FOR_HRES | \
79		     CLOCK_SOURCE_MUST_VERIFY | \
80		     CLOCK_SOURCE_VERIFY_PERCPU)
81
82static struct clocksource clocksource_wdtest_ktime = {
83	.name			= "wdtest-ktime",
84	.rating			= 300,
85	.read			= wdtest_ktime_read,
86	.mask			= CLOCKSOURCE_MASK(64),
87	.flags			= KTIME_FLAGS,
88	.mark_unstable		= wdtest_ktime_cs_mark_unstable,
89	.list			= LIST_HEAD_INIT(clocksource_wdtest_ktime.list),
90};
91
92/* Reset the clocksource if needed. */
93static void wdtest_ktime_clocksource_reset(void)
94{
95	if (clocksource_wdtest_ktime.flags & CLOCK_SOURCE_UNSTABLE) {
96		clocksource_unregister(&clocksource_wdtest_ktime);
97		clocksource_wdtest_ktime.flags = KTIME_FLAGS;
98		schedule_timeout_uninterruptible(HZ / 10);
99		clocksource_register_khz(&clocksource_wdtest_ktime, 1000 * 1000);
100	}
101}
102
103/* Run the specified series of watchdog tests. */
104static int wdtest_func(void *arg)
105{
106	unsigned long j1, j2;
107	int i, max_retries;
108	char *s;
109
110	schedule_timeout_uninterruptible(holdoff * HZ);
111
112	/*
113	 * Verify that jiffies-like clocksources get the manually
114	 * specified uncertainty margin.
115	 */
116	pr_info("--- Verify jiffies-like uncertainty margin.\n");
117	__clocksource_register(&clocksource_wdtest_jiffies);
118	WARN_ON_ONCE(clocksource_wdtest_jiffies.uncertainty_margin != TICK_NSEC);
119
120	j1 = clocksource_wdtest_jiffies.read(&clocksource_wdtest_jiffies);
121	schedule_timeout_uninterruptible(HZ);
122	j2 = clocksource_wdtest_jiffies.read(&clocksource_wdtest_jiffies);
123	WARN_ON_ONCE(j1 == j2);
124
125	clocksource_unregister(&clocksource_wdtest_jiffies);
126
127	/*
128	 * Verify that tsc-like clocksources are assigned a reasonable
129	 * uncertainty margin.
130	 */
131	pr_info("--- Verify tsc-like uncertainty margin.\n");
132	clocksource_register_khz(&clocksource_wdtest_ktime, 1000 * 1000);
133	WARN_ON_ONCE(clocksource_wdtest_ktime.uncertainty_margin < NSEC_PER_USEC);
134
135	j1 = clocksource_wdtest_ktime.read(&clocksource_wdtest_ktime);
136	udelay(1);
137	j2 = clocksource_wdtest_ktime.read(&clocksource_wdtest_ktime);
138	pr_info("--- tsc-like times: %lu - %lu = %lu.\n", j2, j1, j2 - j1);
139	WARN_ON_ONCE(time_before(j2, j1 + NSEC_PER_USEC));
140
141	/* Verify tsc-like stability with various numbers of errors injected. */
142	max_retries = clocksource_get_max_watchdog_retry();
143	for (i = 0; i <= max_retries + 1; i++) {
144		if (i <= 1 && i < max_retries)
145			s = "";
146		else if (i <= max_retries)
147			s = ", expect message";
148		else
149			s = ", expect clock skew";
150		pr_info("--- Watchdog with %dx error injection, %d retries%s.\n", i, max_retries, s);
151		WRITE_ONCE(wdtest_ktime_read_ndelays, i);
152		schedule_timeout_uninterruptible(2 * HZ);
153		WARN_ON_ONCE(READ_ONCE(wdtest_ktime_read_ndelays));
154		WARN_ON_ONCE((i <= max_retries) !=
155			     !(clocksource_wdtest_ktime.flags & CLOCK_SOURCE_UNSTABLE));
156		wdtest_ktime_clocksource_reset();
157	}
158
159	/* Verify tsc-like stability with clock-value-fuzz error injection. */
160	pr_info("--- Watchdog clock-value-fuzz error injection, expect clock skew and per-CPU mismatches.\n");
161	WRITE_ONCE(wdtest_ktime_read_fuzz, true);
162	schedule_timeout_uninterruptible(2 * HZ);
163	WARN_ON_ONCE(!(clocksource_wdtest_ktime.flags & CLOCK_SOURCE_UNSTABLE));
164	clocksource_verify_percpu(&clocksource_wdtest_ktime);
165	WRITE_ONCE(wdtest_ktime_read_fuzz, false);
166
167	clocksource_unregister(&clocksource_wdtest_ktime);
168
169	pr_info("--- Done with test.\n");
170	return 0;
171}
172
173static void wdtest_print_module_parms(void)
174{
175	pr_alert("--- holdoff=%d\n", holdoff);
176}
177
178/* Cleanup function. */
179static void clocksource_wdtest_cleanup(void)
180{
181}
182
183static int __init clocksource_wdtest_init(void)
184{
185	int ret = 0;
186
187	wdtest_print_module_parms();
188
189	/* Create watchdog-test task. */
190	wdtest_task = kthread_run(wdtest_func, NULL, "wdtest");
191	if (IS_ERR(wdtest_task)) {
192		ret = PTR_ERR(wdtest_task);
193		pr_warn("%s: Failed to create wdtest kthread.\n", __func__);
194		wdtest_task = NULL;
195		return ret;
196	}
197
198	return 0;
199}
200
201module_init(clocksource_wdtest_init);
202module_exit(clocksource_wdtest_cleanup);
203