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 9 static cpumask_t __read_mostly watchdog_cpus; 10 11 static 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 22 int __init watchdog_hardlockup_probe(void) 23 { 24 return 0; 25 } 26 27 void 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 61 void 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 85 void 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 } 111