1 /* Pseudo NMI support on sparc64 systems. 2 * 3 * Copyright (C) 2009 David S. Miller <davem@davemloft.net> 4 * 5 * The NMI watchdog support and infrastructure is based almost 6 * entirely upon the x86 NMI support code. 7 */ 8 #include <linux/kernel.h> 9 #include <linux/param.h> 10 #include <linux/init.h> 11 #include <linux/percpu.h> 12 #include <linux/nmi.h> 13 #include <linux/export.h> 14 #include <linux/kprobes.h> 15 #include <linux/kernel_stat.h> 16 #include <linux/reboot.h> 17 #include <linux/slab.h> 18 #include <linux/kdebug.h> 19 #include <linux/delay.h> 20 #include <linux/smp.h> 21 22 #include <asm/perf_event.h> 23 #include <asm/ptrace.h> 24 #include <asm/pcr.h> 25 26 #include "kstack.h" 27 28 /* We don't have a real NMI on sparc64, but we can fake one 29 * up using profiling counter overflow interrupts and interrupt 30 * levels. 31 * 32 * The profile overflow interrupts at level 15, so we use 33 * level 14 as our IRQ off level. 34 */ 35 36 static int panic_on_timeout; 37 38 /* nmi_active: 39 * >0: the NMI watchdog is active, but can be disabled 40 * <0: the NMI watchdog has not been set up, and cannot be enabled 41 * 0: the NMI watchdog is disabled, but can be enabled 42 */ 43 atomic_t nmi_active = ATOMIC_INIT(0); /* oprofile uses this */ 44 EXPORT_SYMBOL(nmi_active); 45 46 static unsigned int nmi_hz = HZ; 47 static DEFINE_PER_CPU(short, wd_enabled); 48 static int endflag __initdata; 49 50 static DEFINE_PER_CPU(unsigned int, last_irq_sum); 51 static DEFINE_PER_CPU(long, alert_counter); 52 static DEFINE_PER_CPU(int, nmi_touch); 53 54 void touch_nmi_watchdog(void) 55 { 56 if (atomic_read(&nmi_active)) { 57 int cpu; 58 59 for_each_present_cpu(cpu) { 60 if (per_cpu(nmi_touch, cpu) != 1) 61 per_cpu(nmi_touch, cpu) = 1; 62 } 63 } 64 65 touch_softlockup_watchdog(); 66 } 67 EXPORT_SYMBOL(touch_nmi_watchdog); 68 69 static void die_nmi(const char *str, struct pt_regs *regs, int do_panic) 70 { 71 int this_cpu = smp_processor_id(); 72 73 if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 74 pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP) 75 return; 76 77 if (do_panic || panic_on_oops) 78 panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu); 79 else 80 WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu); 81 } 82 83 notrace __kprobes void perfctr_irq(int irq, struct pt_regs *regs) 84 { 85 unsigned int sum, touched = 0; 86 void *orig_sp; 87 88 clear_softint(1 << irq); 89 90 local_cpu_data().__nmi_count++; 91 92 nmi_enter(); 93 94 orig_sp = set_hardirq_stack(); 95 96 if (notify_die(DIE_NMI, "nmi", regs, 0, 97 pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP) 98 touched = 1; 99 else 100 pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable); 101 102 sum = local_cpu_data().irq0_irqs; 103 if (__get_cpu_var(nmi_touch)) { 104 __get_cpu_var(nmi_touch) = 0; 105 touched = 1; 106 } 107 if (!touched && __get_cpu_var(last_irq_sum) == sum) { 108 __this_cpu_inc(alert_counter); 109 if (__this_cpu_read(alert_counter) == 30 * nmi_hz) 110 die_nmi("BUG: NMI Watchdog detected LOCKUP", 111 regs, panic_on_timeout); 112 } else { 113 __get_cpu_var(last_irq_sum) = sum; 114 __this_cpu_write(alert_counter, 0); 115 } 116 if (__get_cpu_var(wd_enabled)) { 117 pcr_ops->write_pic(0, pcr_ops->nmi_picl_value(nmi_hz)); 118 pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_enable); 119 } 120 121 restore_hardirq_stack(orig_sp); 122 123 nmi_exit(); 124 } 125 126 static inline unsigned int get_nmi_count(int cpu) 127 { 128 return cpu_data(cpu).__nmi_count; 129 } 130 131 static __init void nmi_cpu_busy(void *data) 132 { 133 local_irq_enable_in_hardirq(); 134 while (endflag == 0) 135 mb(); 136 } 137 138 static void report_broken_nmi(int cpu, int *prev_nmi_count) 139 { 140 printk(KERN_CONT "\n"); 141 142 printk(KERN_WARNING 143 "WARNING: CPU#%d: NMI appears to be stuck (%d->%d)!\n", 144 cpu, prev_nmi_count[cpu], get_nmi_count(cpu)); 145 146 printk(KERN_WARNING 147 "Please report this to bugzilla.kernel.org,\n"); 148 printk(KERN_WARNING 149 "and attach the output of the 'dmesg' command.\n"); 150 151 per_cpu(wd_enabled, cpu) = 0; 152 atomic_dec(&nmi_active); 153 } 154 155 void stop_nmi_watchdog(void *unused) 156 { 157 pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable); 158 __get_cpu_var(wd_enabled) = 0; 159 atomic_dec(&nmi_active); 160 } 161 162 static int __init check_nmi_watchdog(void) 163 { 164 unsigned int *prev_nmi_count; 165 int cpu, err; 166 167 if (!atomic_read(&nmi_active)) 168 return 0; 169 170 prev_nmi_count = kmalloc(nr_cpu_ids * sizeof(unsigned int), GFP_KERNEL); 171 if (!prev_nmi_count) { 172 err = -ENOMEM; 173 goto error; 174 } 175 176 printk(KERN_INFO "Testing NMI watchdog ... "); 177 178 smp_call_function(nmi_cpu_busy, (void *)&endflag, 0); 179 180 for_each_possible_cpu(cpu) 181 prev_nmi_count[cpu] = get_nmi_count(cpu); 182 local_irq_enable(); 183 mdelay((20 * 1000) / nmi_hz); /* wait 20 ticks */ 184 185 for_each_online_cpu(cpu) { 186 if (!per_cpu(wd_enabled, cpu)) 187 continue; 188 if (get_nmi_count(cpu) - prev_nmi_count[cpu] <= 5) 189 report_broken_nmi(cpu, prev_nmi_count); 190 } 191 endflag = 1; 192 if (!atomic_read(&nmi_active)) { 193 kfree(prev_nmi_count); 194 atomic_set(&nmi_active, -1); 195 err = -ENODEV; 196 goto error; 197 } 198 printk("OK.\n"); 199 200 nmi_hz = 1; 201 202 kfree(prev_nmi_count); 203 return 0; 204 error: 205 on_each_cpu(stop_nmi_watchdog, NULL, 1); 206 return err; 207 } 208 209 void start_nmi_watchdog(void *unused) 210 { 211 __get_cpu_var(wd_enabled) = 1; 212 atomic_inc(&nmi_active); 213 214 pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable); 215 pcr_ops->write_pic(0, pcr_ops->nmi_picl_value(nmi_hz)); 216 217 pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_enable); 218 } 219 220 static void nmi_adjust_hz_one(void *unused) 221 { 222 if (!__get_cpu_var(wd_enabled)) 223 return; 224 225 pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable); 226 pcr_ops->write_pic(0, pcr_ops->nmi_picl_value(nmi_hz)); 227 228 pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_enable); 229 } 230 231 void nmi_adjust_hz(unsigned int new_hz) 232 { 233 nmi_hz = new_hz; 234 on_each_cpu(nmi_adjust_hz_one, NULL, 1); 235 } 236 EXPORT_SYMBOL_GPL(nmi_adjust_hz); 237 238 static int nmi_shutdown(struct notifier_block *nb, unsigned long cmd, void *p) 239 { 240 on_each_cpu(stop_nmi_watchdog, NULL, 1); 241 return 0; 242 } 243 244 static struct notifier_block nmi_reboot_notifier = { 245 .notifier_call = nmi_shutdown, 246 }; 247 248 int __init nmi_init(void) 249 { 250 int err; 251 252 on_each_cpu(start_nmi_watchdog, NULL, 1); 253 254 err = check_nmi_watchdog(); 255 if (!err) { 256 err = register_reboot_notifier(&nmi_reboot_notifier); 257 if (err) { 258 on_each_cpu(stop_nmi_watchdog, NULL, 1); 259 atomic_set(&nmi_active, -1); 260 } 261 } 262 263 return err; 264 } 265 266 static int __init setup_nmi_watchdog(char *str) 267 { 268 if (!strncmp(str, "panic", 5)) 269 panic_on_timeout = 1; 270 271 return 0; 272 } 273 __setup("nmi_watchdog=", setup_nmi_watchdog); 274