kernel/time/clocksource-wdtest.c

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