drivers/misc/vcpu_stall_detector.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // VCPU stall detector.
   4 //  Copyright (C) Google, 2022
   5
   6 #include <linux/cpu.h>
   7 #include <linux/init.h>
   8 #include <linux/io.h>
   9 #include <linux/kernel.h>
  10
  11 #include <linux/device.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/module.h>
  14 #include <linux/nmi.h>
  15 #include <linux/of.h>
  16 #include <linux/param.h>
  17 #include <linux/percpu.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/slab.h>
  20
  21 #define VCPU_STALL_REG_STATUS           (0x00)
  22 #define VCPU_STALL_REG_LOAD_CNT         (0x04)
  23 #define VCPU_STALL_REG_CURRENT_CNT      (0x08)
  24 #define VCPU_STALL_REG_CLOCK_FREQ_HZ    (0x0C)
  25 #define VCPU_STALL_REG_LEN              (0x10)
  26
  27 #define VCPU_STALL_DEFAULT_CLOCK_HZ     (10)
  28 #define VCPU_STALL_MAX_CLOCK_HZ         (100)
  29 #define VCPU_STALL_DEFAULT_TIMEOUT_SEC  (8)
  30 #define VCPU_STALL_MAX_TIMEOUT_SEC      (600)
  31
  32 struct vcpu_stall_detect_config {
  33         u32 clock_freq_hz;
  34         u32 stall_timeout_sec;
  35         int ppi_irq;
  36
  37         void __iomem *membase;
  38         struct platform_device *dev;
  39         enum cpuhp_state hp_online;
  40 };
  41
  42 struct vcpu_stall_priv {
  43         struct hrtimer vcpu_hrtimer;
  44         bool is_initialized;
  45 };
  46
  47 /* The vcpu stall configuration structure which applies to all the CPUs */
  48 static struct vcpu_stall_detect_config vcpu_stall_config;
  49
  50 #define vcpu_stall_reg_write(vcpu, reg, value)                          \
  51         writel_relaxed((value),                                         \
  52                        (void __iomem *)(vcpu_stall_config.membase +     \
  53                        (vcpu) * VCPU_STALL_REG_LEN + (reg)))
  54
  55
  56 static struct vcpu_stall_priv __percpu *vcpu_stall_detectors;
  57
  58 static enum hrtimer_restart
  59 vcpu_stall_detect_timer_fn(struct hrtimer *hrtimer)
  60 {
  61         u32 ticks, ping_timeout_ms;
  62
  63         /* Reload the stall detector counter register every
  64          * `ping_timeout_ms` to prevent the virtual device
  65          * from decrementing it to 0. The virtual device decrements this
  66          * register at 'clock_freq_hz' frequency.
  67          */
  68         ticks = vcpu_stall_config.clock_freq_hz *
  69                 vcpu_stall_config.stall_timeout_sec;
  70         vcpu_stall_reg_write(smp_processor_id(),
  71                              VCPU_STALL_REG_LOAD_CNT, ticks);
  72
  73         ping_timeout_ms = vcpu_stall_config.stall_timeout_sec *
  74                           MSEC_PER_SEC / 2;
  75         hrtimer_forward_now(hrtimer,
  76                             ms_to_ktime(ping_timeout_ms));
  77
  78         return HRTIMER_RESTART;
  79 }
  80
  81 static irqreturn_t vcpu_stall_detector_irq(int irq, void *dev)
  82 {
  83         panic("vCPU stall detector");
  84         return IRQ_HANDLED;
  85 }
  86
  87 static int start_stall_detector_cpu(unsigned int cpu)
  88 {
  89         u32 ticks, ping_timeout_ms;
  90         struct vcpu_stall_priv *vcpu_stall_detector =
  91                 this_cpu_ptr(vcpu_stall_detectors);
  92         struct hrtimer *vcpu_hrtimer = &vcpu_stall_detector->vcpu_hrtimer;
  93
  94         vcpu_stall_reg_write(cpu, VCPU_STALL_REG_CLOCK_FREQ_HZ,
  95                              vcpu_stall_config.clock_freq_hz);
  96
  97         /* Compute the number of ticks required for the stall detector
  98          * counter register based on the internal clock frequency and the
  99          * timeout value given from the device tree.
 100          */
 101         ticks = vcpu_stall_config.clock_freq_hz *
 102                 vcpu_stall_config.stall_timeout_sec;
 103         vcpu_stall_reg_write(cpu, VCPU_STALL_REG_LOAD_CNT, ticks);
 104
 105         /* Enable the internal clock and start the stall detector */
 106         vcpu_stall_reg_write(cpu, VCPU_STALL_REG_STATUS, 1);
 107
 108         /* Pet the stall detector at half of its expiration timeout
 109          * to prevent spurious resets.
 110          */
 111         ping_timeout_ms = vcpu_stall_config.stall_timeout_sec *
 112                           MSEC_PER_SEC / 2;
 113
 114         hrtimer_init(vcpu_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 115         vcpu_hrtimer->function = vcpu_stall_detect_timer_fn;
 116         vcpu_stall_detector->is_initialized = true;
 117
 118         hrtimer_start(vcpu_hrtimer, ms_to_ktime(ping_timeout_ms),
 119                       HRTIMER_MODE_REL_PINNED);
 120
 121         return 0;
 122 }
 123
 124 static int stop_stall_detector_cpu(unsigned int cpu)
 125 {
 126         struct vcpu_stall_priv *vcpu_stall_detector =
 127                 per_cpu_ptr(vcpu_stall_detectors, cpu);
 128
 129         if (!vcpu_stall_detector->is_initialized)
 130                 return 0;
 131
 132         /* Disable the stall detector for the current CPU */
 133         hrtimer_cancel(&vcpu_stall_detector->vcpu_hrtimer);
 134         vcpu_stall_reg_write(cpu, VCPU_STALL_REG_STATUS, 0);
 135         vcpu_stall_detector->is_initialized = false;
 136
 137         return 0;
 138 }
 139
 140 static int vcpu_stall_detect_probe(struct platform_device *pdev)
 141 {
 142         int ret, irq;
 143         struct resource *r;
 144         void __iomem *membase;
 145         u32 clock_freq_hz = VCPU_STALL_DEFAULT_CLOCK_HZ;
 146         u32 stall_timeout_sec = VCPU_STALL_DEFAULT_TIMEOUT_SEC;
 147         struct device_node *np = pdev->dev.of_node;
 148
 149         vcpu_stall_detectors = devm_alloc_percpu(&pdev->dev,
 150                                                  typeof(struct vcpu_stall_priv));
 151         if (!vcpu_stall_detectors)
 152                 return -ENOMEM;
 153
 154         membase = devm_platform_get_and_ioremap_resource(pdev, 0, &r);
 155         if (IS_ERR(membase)) {
 156                 dev_err(&pdev->dev, "Failed to get memory resource\n");
 157                 return PTR_ERR(membase);
 158         }
 159
 160         if (!of_property_read_u32(np, "clock-frequency", &clock_freq_hz)) {
 161                 if (!(clock_freq_hz > 0 &&
 162                       clock_freq_hz < VCPU_STALL_MAX_CLOCK_HZ)) {
 163                         dev_warn(&pdev->dev, "clk out of range\n");
 164                         clock_freq_hz = VCPU_STALL_DEFAULT_CLOCK_HZ;
 165                 }
 166         }
 167
 168         if (!of_property_read_u32(np, "timeout-sec", &stall_timeout_sec)) {
 169                 if (!(stall_timeout_sec > 0 &&
 170                       stall_timeout_sec < VCPU_STALL_MAX_TIMEOUT_SEC)) {
 171                         dev_warn(&pdev->dev, "stall timeout out of range\n");
 172                         stall_timeout_sec = VCPU_STALL_DEFAULT_TIMEOUT_SEC;
 173                 }
 174         }
 175
 176         vcpu_stall_config = (struct vcpu_stall_detect_config) {
 177                 .membase                = membase,
 178                 .clock_freq_hz          = clock_freq_hz,
 179                 .stall_timeout_sec      = stall_timeout_sec,
 180                 .ppi_irq                = -1,
 181         };
 182
 183         irq = platform_get_irq_optional(pdev, 0);
 184         if (irq > 0) {
 185                 ret = request_percpu_irq(irq,
 186                                          vcpu_stall_detector_irq,
 187                                          "vcpu_stall_detector",
 188                                          vcpu_stall_detectors);
 189                 if (ret)
 190                         goto err;
 191
 192                 vcpu_stall_config.ppi_irq = irq;
 193         }
 194
 195         ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
 196                                 "virt/vcpu_stall_detector:online",
 197                                 start_stall_detector_cpu,
 198                                 stop_stall_detector_cpu);
 199         if (ret < 0) {
 200                 dev_err(&pdev->dev, "failed to install cpu hotplug");
 201                 goto err;
 202         }
 203
 204         vcpu_stall_config.hp_online = ret;
 205         return 0;
 206 err:
 207         if (vcpu_stall_config.ppi_irq > 0)
 208                 free_percpu_irq(vcpu_stall_config.ppi_irq,
 209                                 vcpu_stall_detectors);
 210         return ret;
 211 }
 212
 213 static void vcpu_stall_detect_remove(struct platform_device *pdev)
 214 {
 215         int cpu;
 216
 217         cpuhp_remove_state(vcpu_stall_config.hp_online);
 218
 219         if (vcpu_stall_config.ppi_irq > 0)
 220                 free_percpu_irq(vcpu_stall_config.ppi_irq,
 221                                 vcpu_stall_detectors);
 222
 223         for_each_possible_cpu(cpu)
 224                 stop_stall_detector_cpu(cpu);
 225 }
 226
 227 static const struct of_device_id vcpu_stall_detect_of_match[] = {
 228         { .compatible = "qemu,vcpu-stall-detector", },
 229         {}
 230 };
 231
 232 MODULE_DEVICE_TABLE(of, vcpu_stall_detect_of_match);
 233
 234 static struct platform_driver vcpu_stall_detect_driver = {
 235         .probe  = vcpu_stall_detect_probe,
 236         .remove_new = vcpu_stall_detect_remove,
 237         .driver = {
 238                 .name           = KBUILD_MODNAME,
 239                 .of_match_table = vcpu_stall_detect_of_match,
 240         },
 241 };
 242
 243 module_platform_driver(vcpu_stall_detect_driver);
 244
 245 MODULE_LICENSE("GPL");
 246 MODULE_AUTHOR("Sebastian Ene <sebastianene@google.com>");
 247 MODULE_DESCRIPTION("VCPU stall detector");