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 watchdog_next_cpu(unsigned int cpu)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 watchdog_hardlockup_probe(void)25int __init watchdog_hardlockup_probe(void) 26 { 27 return 0; 28 } 29 watchdog_hardlockup_enable(unsigned int cpu)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 watchdog_hardlockup_disable(unsigned int cpu)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 watchdog_buddy_check_hardlockup(int hrtimer_interrupts)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 } 114