1// SPDX-License-Identifier: GPL-2.0
  2
  3#include <linux/cpu.h>
  4#include <linux/cpumask.h>
  5#include <linux/kernel.h>
  6#include <linux/nmi.h>
  7#include <linux/percpu-defs.h>
  8
  9static cpumask_t __read_mostly watchdog_cpus;
 10
 11static unsigned int watchdog_next_cpu(unsigned int cpu)
 12{
 13	unsigned int next_cpu;
 14
 15	next_cpu = cpumask_next(cpu, &watchdog_cpus);
 16	if (next_cpu >= nr_cpu_ids)
 17		next_cpu = cpumask_first(&watchdog_cpus);
 18
 19	if (next_cpu == cpu)
 20		return nr_cpu_ids;
 21
 22	return next_cpu;
 23}
 24
 25int __init watchdog_hardlockup_probe(void)
 26{
 27	return 0;
 28}
 29
 30void watchdog_hardlockup_enable(unsigned int cpu)
 31{
 32	unsigned int next_cpu;
 33
 34	/*
 35	 * The new CPU will be marked online before the hrtimer interrupt
 36	 * gets a chance to run on it. If another CPU tests for a
 37	 * hardlockup on the new CPU before it has run its the hrtimer
 38	 * interrupt, it will get a false positive. Touch the watchdog on
 39	 * the new CPU to delay the check for at least 3 sampling periods
 40	 * to guarantee one hrtimer has run on the new CPU.
 41	 */
 42	watchdog_hardlockup_touch_cpu(cpu);
 43
 44	/*
 45	 * We are going to check the next CPU. Our watchdog_hrtimer
 46	 * need not be zero if the CPU has already been online earlier.
 47	 * Touch the watchdog on the next CPU to avoid false positive
 48	 * if we try to check it in less then 3 interrupts.
 49	 */
 50	next_cpu = watchdog_next_cpu(cpu);
 51	if (next_cpu < nr_cpu_ids)
 52		watchdog_hardlockup_touch_cpu(next_cpu);
 53
 54	/*
 55	 * Makes sure that watchdog is touched on this CPU before
 56	 * other CPUs could see it in watchdog_cpus. The counter
 57	 * part is in watchdog_buddy_check_hardlockup().
 58	 */
 59	smp_wmb();
 60
 61	cpumask_set_cpu(cpu, &watchdog_cpus);
 62}
 63
 64void watchdog_hardlockup_disable(unsigned int cpu)
 65{
 66	unsigned int next_cpu = watchdog_next_cpu(cpu);
 67
 68	/*
 69	 * Offlining this CPU will cause the CPU before this one to start
 70	 * checking the one after this one. If this CPU just finished checking
 71	 * the next CPU and updating hrtimer_interrupts_saved, and then the
 72	 * previous CPU checks it within one sample period, it will trigger a
 73	 * false positive. Touch the watchdog on the next CPU to prevent it.
 74	 */
 75	if (next_cpu < nr_cpu_ids)
 76		watchdog_hardlockup_touch_cpu(next_cpu);
 77
 78	/*
 79	 * Makes sure that watchdog is touched on the next CPU before
 80	 * this CPU disappear in watchdog_cpus. The counter part is in
 81	 * watchdog_buddy_check_hardlockup().
 82	 */
 83	smp_wmb();
 84
 85	cpumask_clear_cpu(cpu, &watchdog_cpus);
 86}
 87
 88void watchdog_buddy_check_hardlockup(int hrtimer_interrupts)
 89{
 90	unsigned int next_cpu;
 91
 92	/*
 93	 * Test for hardlockups every 3 samples. The sample period is
 94	 *  watchdog_thresh * 2 / 5, so 3 samples gets us back to slightly over
 95	 *  watchdog_thresh (over by 20%).
 96	 */
 97	if (hrtimer_interrupts % 3 != 0)
 98		return;
 99
100	/* check for a hardlockup on the next CPU */
101	next_cpu = watchdog_next_cpu(smp_processor_id());
102	if (next_cpu >= nr_cpu_ids)
103		return;
104
105	/*
106	 * Make sure that the watchdog was touched on next CPU when
107	 * watchdog_next_cpu() returned another one because of
108	 * a change in watchdog_hardlockup_enable()/disable().
109	 */
110	smp_rmb();
111
112	watchdog_hardlockup_check(next_cpu, NULL);
113}