watchdog_buddy.c

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