203 lines
5.8 KiB
C
203 lines
5.8 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Unit test for the clocksource watchdog.
|
|
*
|
|
* Copyright (C) 2021 Facebook, Inc.
|
|
*
|
|
* Author: Paul E. McKenney <paulmck@kernel.org>
|
|
*/
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/clocksource.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
|
|
#include <linux/tick.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/prandom.h>
|
|
#include <linux/cpu.h>
|
|
|
|
#include "tick-internal.h"
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Paul E. McKenney <paulmck@kernel.org>");
|
|
|
|
static int holdoff = IS_BUILTIN(CONFIG_TEST_CLOCKSOURCE_WATCHDOG) ? 10 : 0;
|
|
module_param(holdoff, int, 0444);
|
|
MODULE_PARM_DESC(holdoff, "Time to wait to start test (s).");
|
|
|
|
/* Watchdog kthread's task_struct pointer for debug purposes. */
|
|
static struct task_struct *wdtest_task;
|
|
|
|
static u64 wdtest_jiffies_read(struct clocksource *cs)
|
|
{
|
|
return (u64)jiffies;
|
|
}
|
|
|
|
static struct clocksource clocksource_wdtest_jiffies = {
|
|
.name = "wdtest-jiffies",
|
|
.rating = 1, /* lowest valid rating*/
|
|
.uncertainty_margin = TICK_NSEC,
|
|
.read = wdtest_jiffies_read,
|
|
.mask = CLOCKSOURCE_MASK(32),
|
|
.flags = CLOCK_SOURCE_MUST_VERIFY,
|
|
.mult = TICK_NSEC << JIFFIES_SHIFT, /* details above */
|
|
.shift = JIFFIES_SHIFT,
|
|
.max_cycles = 10,
|
|
};
|
|
|
|
static int wdtest_ktime_read_ndelays;
|
|
static bool wdtest_ktime_read_fuzz;
|
|
|
|
static u64 wdtest_ktime_read(struct clocksource *cs)
|
|
{
|
|
int wkrn = READ_ONCE(wdtest_ktime_read_ndelays);
|
|
static int sign = 1;
|
|
u64 ret;
|
|
|
|
if (wkrn) {
|
|
udelay(cs->uncertainty_margin / 250);
|
|
WRITE_ONCE(wdtest_ktime_read_ndelays, wkrn - 1);
|
|
}
|
|
ret = ktime_get_real_fast_ns();
|
|
if (READ_ONCE(wdtest_ktime_read_fuzz)) {
|
|
sign = -sign;
|
|
ret = ret + sign * 100 * NSEC_PER_MSEC;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void wdtest_ktime_cs_mark_unstable(struct clocksource *cs)
|
|
{
|
|
pr_info("--- Marking %s unstable due to clocksource watchdog.\n", cs->name);
|
|
}
|
|
|
|
#define KTIME_FLAGS (CLOCK_SOURCE_IS_CONTINUOUS | \
|
|
CLOCK_SOURCE_VALID_FOR_HRES | \
|
|
CLOCK_SOURCE_MUST_VERIFY | \
|
|
CLOCK_SOURCE_VERIFY_PERCPU)
|
|
|
|
static struct clocksource clocksource_wdtest_ktime = {
|
|
.name = "wdtest-ktime",
|
|
.rating = 300,
|
|
.read = wdtest_ktime_read,
|
|
.mask = CLOCKSOURCE_MASK(64),
|
|
.flags = KTIME_FLAGS,
|
|
.mark_unstable = wdtest_ktime_cs_mark_unstable,
|
|
.list = LIST_HEAD_INIT(clocksource_wdtest_ktime.list),
|
|
};
|
|
|
|
/* Reset the clocksource if needed. */
|
|
static void wdtest_ktime_clocksource_reset(void)
|
|
{
|
|
if (clocksource_wdtest_ktime.flags & CLOCK_SOURCE_UNSTABLE) {
|
|
clocksource_unregister(&clocksource_wdtest_ktime);
|
|
clocksource_wdtest_ktime.flags = KTIME_FLAGS;
|
|
schedule_timeout_uninterruptible(HZ / 10);
|
|
clocksource_register_khz(&clocksource_wdtest_ktime, 1000 * 1000);
|
|
}
|
|
}
|
|
|
|
/* Run the specified series of watchdog tests. */
|
|
static int wdtest_func(void *arg)
|
|
{
|
|
unsigned long j1, j2;
|
|
int i, max_retries;
|
|
char *s;
|
|
|
|
schedule_timeout_uninterruptible(holdoff * HZ);
|
|
|
|
/*
|
|
* Verify that jiffies-like clocksources get the manually
|
|
* specified uncertainty margin.
|
|
*/
|
|
pr_info("--- Verify jiffies-like uncertainty margin.\n");
|
|
__clocksource_register(&clocksource_wdtest_jiffies);
|
|
WARN_ON_ONCE(clocksource_wdtest_jiffies.uncertainty_margin != TICK_NSEC);
|
|
|
|
j1 = clocksource_wdtest_jiffies.read(&clocksource_wdtest_jiffies);
|
|
schedule_timeout_uninterruptible(HZ);
|
|
j2 = clocksource_wdtest_jiffies.read(&clocksource_wdtest_jiffies);
|
|
WARN_ON_ONCE(j1 == j2);
|
|
|
|
clocksource_unregister(&clocksource_wdtest_jiffies);
|
|
|
|
/*
|
|
* Verify that tsc-like clocksources are assigned a reasonable
|
|
* uncertainty margin.
|
|
*/
|
|
pr_info("--- Verify tsc-like uncertainty margin.\n");
|
|
clocksource_register_khz(&clocksource_wdtest_ktime, 1000 * 1000);
|
|
WARN_ON_ONCE(clocksource_wdtest_ktime.uncertainty_margin < NSEC_PER_USEC);
|
|
|
|
j1 = clocksource_wdtest_ktime.read(&clocksource_wdtest_ktime);
|
|
udelay(1);
|
|
j2 = clocksource_wdtest_ktime.read(&clocksource_wdtest_ktime);
|
|
pr_info("--- tsc-like times: %lu - %lu = %lu.\n", j2, j1, j2 - j1);
|
|
WARN_ON_ONCE(time_before(j2, j1 + NSEC_PER_USEC));
|
|
|
|
/* Verify tsc-like stability with various numbers of errors injected. */
|
|
max_retries = clocksource_get_max_watchdog_retry();
|
|
for (i = 0; i <= max_retries + 1; i++) {
|
|
if (i <= 1 && i < max_retries)
|
|
s = "";
|
|
else if (i <= max_retries)
|
|
s = ", expect message";
|
|
else
|
|
s = ", expect clock skew";
|
|
pr_info("--- Watchdog with %dx error injection, %d retries%s.\n", i, max_retries, s);
|
|
WRITE_ONCE(wdtest_ktime_read_ndelays, i);
|
|
schedule_timeout_uninterruptible(2 * HZ);
|
|
WARN_ON_ONCE(READ_ONCE(wdtest_ktime_read_ndelays));
|
|
WARN_ON_ONCE((i <= max_retries) !=
|
|
!(clocksource_wdtest_ktime.flags & CLOCK_SOURCE_UNSTABLE));
|
|
wdtest_ktime_clocksource_reset();
|
|
}
|
|
|
|
/* Verify tsc-like stability with clock-value-fuzz error injection. */
|
|
pr_info("--- Watchdog clock-value-fuzz error injection, expect clock skew and per-CPU mismatches.\n");
|
|
WRITE_ONCE(wdtest_ktime_read_fuzz, true);
|
|
schedule_timeout_uninterruptible(2 * HZ);
|
|
WARN_ON_ONCE(!(clocksource_wdtest_ktime.flags & CLOCK_SOURCE_UNSTABLE));
|
|
clocksource_verify_percpu(&clocksource_wdtest_ktime);
|
|
WRITE_ONCE(wdtest_ktime_read_fuzz, false);
|
|
|
|
clocksource_unregister(&clocksource_wdtest_ktime);
|
|
|
|
pr_info("--- Done with test.\n");
|
|
return 0;
|
|
}
|
|
|
|
static void wdtest_print_module_parms(void)
|
|
{
|
|
pr_alert("--- holdoff=%d\n", holdoff);
|
|
}
|
|
|
|
/* Cleanup function. */
|
|
static void clocksource_wdtest_cleanup(void)
|
|
{
|
|
}
|
|
|
|
static int __init clocksource_wdtest_init(void)
|
|
{
|
|
int ret = 0;
|
|
|
|
wdtest_print_module_parms();
|
|
|
|
/* Create watchdog-test task. */
|
|
wdtest_task = kthread_run(wdtest_func, NULL, "wdtest");
|
|
if (IS_ERR(wdtest_task)) {
|
|
ret = PTR_ERR(wdtest_task);
|
|
pr_warn("%s: Failed to create wdtest kthread.\n", __func__);
|
|
wdtest_task = NULL;
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
module_init(clocksource_wdtest_init);
|
|
module_exit(clocksource_wdtest_cleanup);
|