blob: 1edaf15c0b8eef05b36653a0ed9087a9b3717f9e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * NMI watchdog support on APIC systems
3 *
4 * Started by Ingo Molnar <mingo@redhat.com>
5 *
6 * Fixes:
7 * Mikael Pettersson : AMD K7 support for local APIC NMI watchdog.
8 * Mikael Pettersson : Power Management for local APIC NMI watchdog.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * Mikael Pettersson : Pentium 4 support for local APIC NMI watchdog.
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 * Pavel Machek and
11 * Mikael Pettersson : PM converted to driver model. Disable/enable API.
12 */
13
Ingo Molnar7b6aa332009-02-17 13:58:15 +010014#include <asm/apic.h>
Ingo Molnar3d1ba1d2008-06-02 13:50:10 +020015
Andrew Mortonbb81a092006-12-07 02:14:01 +010016#include <linux/nmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/sysdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/sysctl.h>
Don Zickus3e4ff112006-06-26 13:57:01 +020024#include <linux/percpu.h>
Andi Kleeneddb6fb2006-02-03 21:50:41 +010025#include <linux/kprobes.h>
Andrew Mortonbb81a092006-12-07 02:14:01 +010026#include <linux/cpumask.h>
Thomas Gleixnerf8b50352007-02-16 01:28:09 -080027#include <linux/kernel_stat.h>
Christoph Hellwig1eeb66a2007-05-08 00:27:03 -070028#include <linux/kdebug.h>
Hiroshi Shimamoto88ff0a42008-05-27 18:49:39 -070029#include <linux/smp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Maciej W. Rozycki35542c52008-05-21 22:10:22 +010031#include <asm/i8259.h>
32#include <asm/io_apic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <asm/proto.h>
Ingo Molnar6e908942008-03-21 14:32:36 +010034#include <asm/timer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Andi Kleen553f265fe2006-04-07 19:49:57 +020036#include <asm/mce.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Ingo Molnar1164dd02009-01-28 19:34:09 +010038#include <asm/mach_traps.h>
Glauber de Oliveira Costae32ede12008-03-19 14:25:35 -030039
Andi Kleen29cbc782006-09-30 01:47:55 +020040int unknown_nmi_panic;
41int nmi_watchdog_enabled;
Andi Kleen29cbc782006-09-30 01:47:55 +020042
Rusty Russellce7c4272009-11-03 14:53:52 +103043/* For reliability, we're prepared to waste bits here. */
44static DECLARE_BITMAP(backtrace_mask, NR_CPUS) __read_mostly;
Don Zickus828f0af2006-09-26 10:52:26 +020045
Linus Torvalds1da177e2005-04-16 15:20:36 -070046/* nmi_active:
Don Zickusf2802e72006-09-26 10:52:26 +020047 * >0: the lapic NMI watchdog is active, but can be disabled
48 * <0: the lapic NMI watchdog has not been set up, and cannot
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 * be enabled
Don Zickusf2802e72006-09-26 10:52:26 +020050 * 0: the lapic NMI watchdog is disabled, but can be enabled
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 */
Don Zickusf2802e72006-09-26 10:52:26 +020052atomic_t nmi_active = ATOMIC_INIT(0); /* oprofile uses this */
Hiroshi Shimamoto88ff0a42008-05-27 18:49:39 -070053EXPORT_SYMBOL(nmi_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Cyrill Gorcunovc376d452008-06-24 22:52:05 +020055unsigned int nmi_watchdog = NMI_NONE;
Hiroshi Shimamoto88ff0a42008-05-27 18:49:39 -070056EXPORT_SYMBOL(nmi_watchdog);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Hiroshi Shimamoto88ff0a42008-05-27 18:49:39 -070058static int panic_on_timeout;
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +040059
Don Zickusb7471c62006-09-26 10:52:26 +020060static unsigned int nmi_hz = HZ;
Andi Kleen05cb0072007-05-02 19:27:20 +020061static DEFINE_PER_CPU(short, wd_enabled);
Hiroshi Shimamoto88ff0a42008-05-27 18:49:39 -070062static int endflag __initdata;
Ravikiran G Thirumalai92715e22006-12-09 21:33:35 +010063
Cyrill Gorcunovfd5cea02008-05-24 19:36:40 +040064static inline unsigned int get_nmi_count(int cpu)
65{
Brian Gerst1b437c82009-01-19 00:38:57 +090066 return per_cpu(irq_stat, cpu).__nmi_count;
Cyrill Gorcunovfd5cea02008-05-24 19:36:40 +040067}
68
69static inline int mce_in_progress(void)
70{
Andi Kleenc1ebf832009-07-09 00:31:41 +020071#if defined(CONFIG_X86_MCE)
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +040072 return atomic_read(&mce_entry) > 0;
73#endif
Cyrill Gorcunovfd5cea02008-05-24 19:36:40 +040074 return 0;
75}
76
77/*
78 * Take the local apic timer and PIT/HPET into account. We don't
79 * know which one is active, when we have highres/dyntick on
80 */
81static inline unsigned int get_timer_irqs(int cpu)
82{
83 return per_cpu(irq_stat, cpu).apic_timer_irqs +
84 per_cpu(irq_stat, cpu).irq0_irqs;
85}
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Andi Kleen75152112005-05-16 21:53:34 -070087#ifdef CONFIG_SMP
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +040088/*
89 * The performance counters used by NMI_LOCAL_APIC don't trigger when
Andi Kleen75152112005-05-16 21:53:34 -070090 * the CPU is idle. To make sure the NMI watchdog really ticks on all
91 * CPUs during the test make them busy.
92 */
93static __init void nmi_cpu_busy(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
Ingo Molnar366c7f52006-07-03 00:25:25 -070095 local_irq_enable_in_hardirq();
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +040096 /*
97 * Intentionally don't use cpu_relax here. This is
98 * to make sure that the performance counter really ticks,
99 * even if there is a simulator or similar that catches the
100 * pause instruction. On a real HT machine this is fine because
101 * all other CPUs are busy with "useless" delay loops and don't
102 * care if they get somewhat less cycles.
103 */
Ravikiran G Thirumalai92715e22006-12-09 21:33:35 +0100104 while (endflag == 0)
105 mb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
Andi Kleen75152112005-05-16 21:53:34 -0700107#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Jaswinder Singh Rajput2c1b2842009-04-11 00:03:10 +0530109static void report_broken_nmi(int cpu, unsigned int *prev_nmi_count)
Ingo Molnar8bb85192008-08-15 15:34:32 +0200110{
111 printk(KERN_CONT "\n");
112
113 printk(KERN_WARNING
114 "WARNING: CPU#%d: NMI appears to be stuck (%d->%d)!\n",
115 cpu, prev_nmi_count[cpu], get_nmi_count(cpu));
116
117 printk(KERN_WARNING
118 "Please report this to bugzilla.kernel.org,\n");
119 printk(KERN_WARNING
120 "and attach the output of the 'dmesg' command.\n");
121
122 per_cpu(wd_enabled, cpu) = 0;
123 atomic_dec(&nmi_active);
124}
125
Aristeu Rozanski7d5a78c2008-10-27 12:42:35 -0400126static void __acpi_nmi_disable(void *__unused)
127{
128 apic_write(APIC_LVT0, APIC_DM_NMI | APIC_LVT_MASKED);
129}
130
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100131int __init check_nmi_watchdog(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
Eric W. Biederman29b700812005-10-30 14:59:40 -0800133 unsigned int *prev_nmi_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 int cpu;
135
Cyrill Gorcunov4de00432008-06-24 22:52:06 +0200136 if (!nmi_watchdog_active() || !atomic_read(&nmi_active))
Don Zickusf2802e72006-09-26 10:52:26 +0200137 return 0;
138
Mike Travis7496b602008-05-12 21:21:12 +0200139 prev_nmi_count = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL);
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100140 if (!prev_nmi_count)
Maciej W. Rozycki35542c52008-05-21 22:10:22 +0100141 goto error;
Jack F Vogel67701ae92005-05-01 08:58:48 -0700142
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100143 printk(KERN_INFO "Testing NMI watchdog ... ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Andi Kleen7554c3f2006-01-11 22:45:45 +0100145#ifdef CONFIG_SMP
Andi Kleen75152112005-05-16 21:53:34 -0700146 if (nmi_watchdog == NMI_LOCAL_APIC)
Jens Axboe8691e5a2008-06-06 11:18:06 +0200147 smp_call_function(nmi_cpu_busy, (void *)&endflag, 0);
Andi Kleen7554c3f2006-01-11 22:45:45 +0100148#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
KAMEZAWA Hiroyukic89125992006-03-28 01:56:39 -0800150 for_each_possible_cpu(cpu)
Cyrill Gorcunovfd5cea02008-05-24 19:36:40 +0400151 prev_nmi_count[cpu] = get_nmi_count(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 local_irq_enable();
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400153 mdelay((20 * 1000) / nmi_hz); /* wait 20 ticks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Andrew Morton394e3902006-03-23 03:01:05 -0800155 for_each_online_cpu(cpu) {
Andi Kleen05cb0072007-05-02 19:27:20 +0200156 if (!per_cpu(wd_enabled, cpu))
Don Zickusf2802e72006-09-26 10:52:26 +0200157 continue;
Ingo Molnar8bb85192008-08-15 15:34:32 +0200158 if (get_nmi_count(cpu) - prev_nmi_count[cpu] <= 5)
159 report_broken_nmi(cpu, prev_nmi_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 }
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100161 endflag = 1;
Don Zickusf2802e72006-09-26 10:52:26 +0200162 if (!atomic_read(&nmi_active)) {
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100163 kfree(prev_nmi_count);
Don Zickusf2802e72006-09-26 10:52:26 +0200164 atomic_set(&nmi_active, -1);
Maciej W. Rozycki35542c52008-05-21 22:10:22 +0100165 goto error;
Don Zickusf2802e72006-09-26 10:52:26 +0200166 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 printk("OK.\n");
168
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400169 /*
170 * now that we know it works we can reduce NMI frequency to
171 * something more reasonable; makes a difference in some configs
172 */
Andi Kleen05cb0072007-05-02 19:27:20 +0200173 if (nmi_watchdog == NMI_LOCAL_APIC)
174 nmi_hz = lapic_adjust_nmi_hz(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100176 kfree(prev_nmi_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 return 0;
Maciej W. Rozycki35542c52008-05-21 22:10:22 +0100178error:
Aristeu Rozanski7d5a78c2008-10-27 12:42:35 -0400179 if (nmi_watchdog == NMI_IO_APIC) {
180 if (!timer_through_8259)
Jacob Panb81bb372009-11-09 11:27:04 -0800181 legacy_pic->chip->mask(0);
Aristeu Rozanski7d5a78c2008-10-27 12:42:35 -0400182 on_each_cpu(__acpi_nmi_disable, NULL, 1);
183 }
184
Maciej W. Rozycki5b4d2382008-07-11 19:47:15 +0100185#ifdef CONFIG_X86_32
186 timer_ack = 0;
187#endif
Maciej W. Rozycki35542c52008-05-21 22:10:22 +0100188 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189}
190
Adrian Bunk867ab542008-01-30 13:30:31 +0100191static int __init setup_nmi_watchdog(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
Cyrill Gorcunov2b6adda2008-06-24 22:52:04 +0200193 unsigned int nmi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Cyrill Gorcunovd1b946b2008-05-24 19:36:34 +0400195 if (!strncmp(str, "panic", 5)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 panic_on_timeout = 1;
197 str = strchr(str, ',');
198 if (!str)
199 return 1;
200 ++str;
201 }
202
Cyrill Gorcunovb062f842008-10-30 19:16:46 +0300203 if (!strncmp(str, "lapic", 5))
204 nmi_watchdog = NMI_LOCAL_APIC;
205 else if (!strncmp(str, "ioapic", 6))
206 nmi_watchdog = NMI_IO_APIC;
207 else {
208 get_option(&str, &nmi);
209 if (nmi >= NMI_INVALID)
210 return 0;
211 nmi_watchdog = nmi;
212 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 return 1;
215}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216__setup("nmi_watchdog=", setup_nmi_watchdog);
217
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400218/*
219 * Suspend/resume support
220 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221#ifdef CONFIG_PM
222
223static int nmi_pm_active; /* nmi_active before suspend */
224
Pavel Machek829ca9a2005-09-03 15:56:56 -0700225static int lapic_nmi_suspend(struct sys_device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
Shaohua Li4038f902006-09-26 10:52:27 +0200227 /* only CPU0 goes here, other CPUs should be offline */
Don Zickusf2802e72006-09-26 10:52:26 +0200228 nmi_pm_active = atomic_read(&nmi_active);
Shaohua Li4038f902006-09-26 10:52:27 +0200229 stop_apic_nmi_watchdog(NULL);
230 BUG_ON(atomic_read(&nmi_active) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return 0;
232}
233
234static int lapic_nmi_resume(struct sys_device *dev)
235{
Shaohua Li4038f902006-09-26 10:52:27 +0200236 /* only CPU0 goes here, other CPUs should be offline */
237 if (nmi_pm_active > 0) {
238 setup_apic_nmi_watchdog(NULL);
239 touch_nmi_watchdog();
240 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 return 0;
242}
243
244static struct sysdev_class nmi_sysclass = {
Kay Sieversaf5ca3f42007-12-20 02:09:39 +0100245 .name = "lapic_nmi",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 .resume = lapic_nmi_resume,
247 .suspend = lapic_nmi_suspend,
248};
249
250static struct sys_device device_lapic_nmi = {
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100251 .id = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 .cls = &nmi_sysclass,
253};
254
255static int __init init_lapic_nmi_sysfs(void)
256{
257 int error;
258
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400259 /*
260 * should really be a BUG_ON but b/c this is an
Don Zickusf2802e72006-09-26 10:52:26 +0200261 * init call, it just doesn't work. -dcz
262 */
263 if (nmi_watchdog != NMI_LOCAL_APIC)
264 return 0;
265
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100266 if (atomic_read(&nmi_active) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 return 0;
268
269 error = sysdev_class_register(&nmi_sysclass);
270 if (!error)
271 error = sysdev_register(&device_lapic_nmi);
272 return error;
273}
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275/* must come after the local APIC's device_initcall() */
276late_initcall(init_lapic_nmi_sysfs);
277
278#endif /* CONFIG_PM */
279
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100280static void __acpi_nmi_enable(void *__unused)
281{
Maciej W. Rozycki593f4a72008-07-16 19:15:30 +0100282 apic_write(APIC_LVT0, APIC_DM_NMI);
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100283}
284
285/*
286 * Enable timer based NMIs on all CPUs:
287 */
288void acpi_nmi_enable(void)
289{
290 if (atomic_read(&nmi_active) && nmi_watchdog == NMI_IO_APIC)
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200291 on_each_cpu(__acpi_nmi_enable, NULL, 1);
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100292}
293
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100294/*
295 * Disable timer based NMIs on all CPUs:
296 */
297void acpi_nmi_disable(void)
298{
299 if (atomic_read(&nmi_active) && nmi_watchdog == NMI_IO_APIC)
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200300 on_each_cpu(__acpi_nmi_disable, NULL, 1);
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100301}
302
Aristeu Rozanskib3e15bd2008-09-22 13:13:59 -0400303/*
304 * This function is called as soon the LAPIC NMI watchdog driver has everything
305 * in place and it's ready to check if the NMIs belong to the NMI watchdog
306 */
307void cpu_nmi_set_wd_enabled(void)
308{
309 __get_cpu_var(wd_enabled) = 1;
310}
311
Don Zickusf2802e72006-09-26 10:52:26 +0200312void setup_apic_nmi_watchdog(void *unused)
313{
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100314 if (__get_cpu_var(wd_enabled))
Shaohua Li4038f902006-09-26 10:52:27 +0200315 return;
316
317 /* cheap hack to support suspend/resume */
318 /* if cpu0 is not active neither should the other cpus */
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400319 if (smp_processor_id() != 0 && atomic_read(&nmi_active) <= 0)
Shaohua Li4038f902006-09-26 10:52:27 +0200320 return;
321
Andi Kleen05cb0072007-05-02 19:27:20 +0200322 switch (nmi_watchdog) {
323 case NMI_LOCAL_APIC:
Andi Kleen05cb0072007-05-02 19:27:20 +0200324 if (lapic_watchdog_init(nmi_hz) < 0) {
325 __get_cpu_var(wd_enabled) = 0;
Don Zickusf2802e72006-09-26 10:52:26 +0200326 return;
327 }
Andi Kleen05cb0072007-05-02 19:27:20 +0200328 /* FALL THROUGH */
329 case NMI_IO_APIC:
330 __get_cpu_var(wd_enabled) = 1;
331 atomic_inc(&nmi_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 }
Don Zickusf2802e72006-09-26 10:52:26 +0200333}
334
Shaohua Li4038f902006-09-26 10:52:27 +0200335void stop_apic_nmi_watchdog(void *unused)
Don Zickusf2802e72006-09-26 10:52:26 +0200336{
337 /* only support LOCAL and IO APICs for now */
Cyrill Gorcunov4de00432008-06-24 22:52:06 +0200338 if (!nmi_watchdog_active())
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400339 return;
Andi Kleen05cb0072007-05-02 19:27:20 +0200340 if (__get_cpu_var(wd_enabled) == 0)
Shaohua Li4038f902006-09-26 10:52:27 +0200341 return;
Andi Kleen05cb0072007-05-02 19:27:20 +0200342 if (nmi_watchdog == NMI_LOCAL_APIC)
343 lapic_watchdog_stop();
Aristeu Rozanski6f290b42008-10-27 12:42:34 -0400344 else
345 __acpi_nmi_disable(NULL);
Andi Kleen05cb0072007-05-02 19:27:20 +0200346 __get_cpu_var(wd_enabled) = 0;
Don Zickusf2802e72006-09-26 10:52:26 +0200347 atomic_dec(&nmi_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348}
349
350/*
351 * the best way to detect whether a CPU has a 'hard lockup' problem
352 * is to check it's local APIC timer IRQ counts. If they are not
353 * changing then that CPU has some problem.
354 *
355 * as these watchdog NMI IRQs are generated on every CPU, we only
356 * have to check the current processor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 *
358 * since NMIs don't listen to _any_ locks, we have to be extremely
359 * careful not to rely on unsafe variables. The printk might lock
360 * up though, so we have to break up any console locks first ...
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400361 * [when there will be more tty-related locks, break them up here too!]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 */
363
Andi Kleen75152112005-05-16 21:53:34 -0700364static DEFINE_PER_CPU(unsigned, last_irq_sum);
Christoph Lameter494f6a92009-10-07 19:04:29 -0400365static DEFINE_PER_CPU(long, alert_counter);
Andi Kleen75152112005-05-16 21:53:34 -0700366static DEFINE_PER_CPU(int, nmi_touch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
Andrew Morton567f3e42007-07-17 04:03:58 -0700368void touch_nmi_watchdog(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
Cyrill Gorcunov4de00432008-06-24 22:52:06 +0200370 if (nmi_watchdog_active()) {
Jan Beulich99019e92006-02-16 23:41:55 +0100371 unsigned cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Jan Beulich99019e92006-02-16 23:41:55 +0100373 /*
Hiroshi Shimamotof7849462008-05-02 16:45:08 -0700374 * Tell other CPUs to reset their alert counters. We cannot
Jan Beulich99019e92006-02-16 23:41:55 +0100375 * do it ourselves because the alert count increase is not
376 * atomic.
377 */
Andrew Morton567f3e42007-07-17 04:03:58 -0700378 for_each_present_cpu(cpu) {
379 if (per_cpu(nmi_touch, cpu) != 1)
380 per_cpu(nmi_touch, cpu) = 1;
381 }
Jan Beulich99019e92006-02-16 23:41:55 +0100382 }
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700383
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700384 /*
385 * Tickle the softlockup detector too:
386 */
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100387 touch_softlockup_watchdog();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388}
Hiroshi Shimamoto416b7212008-01-30 13:30:33 +0100389EXPORT_SYMBOL(touch_nmi_watchdog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Steven Rostedt5deb45e2008-04-19 19:19:55 +0200391notrace __kprobes int
392nmi_watchdog_tick(struct pt_regs *regs, unsigned reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 /*
395 * Since current_thread_info()-> is always on the stack, and we
396 * always switch the stack NMI-atomically, it's safe to use
397 * smp_processor_id().
398 */
Jesper Juhlb791cce2006-03-28 01:56:52 -0800399 unsigned int sum;
Andi Kleen75152112005-05-16 21:53:34 -0700400 int touched = 0;
Andrew Mortonbb81a092006-12-07 02:14:01 +0100401 int cpu = smp_processor_id();
Andi Kleen05cb0072007-05-02 19:27:20 +0200402 int rc = 0;
Don Zickusf2802e72006-09-26 10:52:26 +0200403
404 /* check for other users first */
405 if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT)
406 == NOTIFY_STOP) {
Don Zickus3adbbcc2006-09-26 10:52:26 +0200407 rc = 1;
Don Zickusf2802e72006-09-26 10:52:26 +0200408 touched = 1;
409 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Cyrill Gorcunovfd5cea02008-05-24 19:36:40 +0400411 sum = get_timer_irqs(cpu);
412
Andi Kleen75152112005-05-16 21:53:34 -0700413 if (__get_cpu_var(nmi_touch)) {
414 __get_cpu_var(nmi_touch) = 0;
415 touched = 1;
416 }
Don Zickusf2802e72006-09-26 10:52:26 +0200417
Rusty Russell2f537a92009-04-21 16:00:15 +0930418 /* We can be called before check_nmi_watchdog, hence NULL check. */
Rusty Russellce7c4272009-11-03 14:53:52 +1030419 if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) {
Thomas Gleixner0fdc7a82009-07-25 16:49:55 +0200420 static DEFINE_RAW_SPINLOCK(lock); /* Serialise the printks */
Andrew Mortonbb81a092006-12-07 02:14:01 +0100421
Thomas Gleixner0fdc7a82009-07-25 16:49:55 +0200422 raw_spin_lock(&lock);
Hiroshi Shimamoto88ff0a42008-05-27 18:49:39 -0700423 printk(KERN_WARNING "NMI backtrace for cpu %d\n", cpu);
Ingo Molnarc1dc0b92009-08-02 11:28:21 +0200424 show_regs(regs);
Andrew Mortonbb81a092006-12-07 02:14:01 +0100425 dump_stack();
Thomas Gleixner0fdc7a82009-07-25 16:49:55 +0200426 raw_spin_unlock(&lock);
Rusty Russellce7c4272009-11-03 14:53:52 +1030427 cpumask_clear_cpu(cpu, to_cpumask(backtrace_mask));
Ingo Molnarc1dc0b92009-08-02 11:28:21 +0200428
429 rc = 1;
Andrew Mortonbb81a092006-12-07 02:14:01 +0100430 }
431
Cyrill Gorcunovfd5cea02008-05-24 19:36:40 +0400432 /* Could check oops_in_progress here too, but it's safer not to */
433 if (mce_in_progress())
Andi Kleen553f265fe2006-04-07 19:49:57 +0200434 touched = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
Thomas Gleixnerf8b50352007-02-16 01:28:09 -0800436 /* if the none of the timers isn't firing, this cpu isn't doing much */
Andi Kleen75152112005-05-16 21:53:34 -0700437 if (!touched && __get_cpu_var(last_irq_sum) == sum) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 /*
439 * Ayiee, looks like this CPU is stuck ...
440 * wait a few IRQs (5 seconds) before doing the oops ...
441 */
Rusty Russelldd17c8f2009-10-29 22:34:15 +0900442 __this_cpu_inc(alert_counter);
443 if (__this_cpu_read(alert_counter) == 5 * nmi_hz)
George Anzinger748f2ed2005-09-03 15:56:48 -0700444 /*
445 * die_nmi will return ONLY if NOTIFY_STOP happens..
446 */
Cyrill Gorcunovddca03c2008-05-24 19:36:31 +0400447 die_nmi("BUG: NMI Watchdog detected LOCKUP",
Cyrill Gorcunovd1b946b2008-05-24 19:36:34 +0400448 regs, panic_on_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 } else {
Andi Kleen75152112005-05-16 21:53:34 -0700450 __get_cpu_var(last_irq_sum) = sum;
Rusty Russelldd17c8f2009-10-29 22:34:15 +0900451 __this_cpu_write(alert_counter, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
Don Zickusf2802e72006-09-26 10:52:26 +0200453
454 /* see if the nmi watchdog went off */
Andi Kleen05cb0072007-05-02 19:27:20 +0200455 if (!__get_cpu_var(wd_enabled))
456 return rc;
457 switch (nmi_watchdog) {
458 case NMI_LOCAL_APIC:
459 rc |= lapic_wd_event(nmi_hz);
460 break;
461 case NMI_IO_APIC:
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400462 /*
463 * don't know how to accurately check for this.
Andi Kleen05cb0072007-05-02 19:27:20 +0200464 * just assume it was a watchdog timer interrupt
465 * This matches the old behaviour.
466 */
467 rc = 1;
468 break;
Andi Kleen75152112005-05-16 21:53:34 -0700469 }
Don Zickus3adbbcc2006-09-26 10:52:26 +0200470 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471}
472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473#ifdef CONFIG_SYSCTL
474
Aristeu Rozanski6f290b42008-10-27 12:42:34 -0400475static void enable_ioapic_nmi_watchdog_single(void *unused)
476{
477 __get_cpu_var(wd_enabled) = 1;
478 atomic_inc(&nmi_active);
479 __acpi_nmi_enable(NULL);
480}
481
482static void enable_ioapic_nmi_watchdog(void)
483{
484 on_each_cpu(enable_ioapic_nmi_watchdog_single, NULL, 1);
485 touch_nmi_watchdog();
486}
487
488static void disable_ioapic_nmi_watchdog(void)
489{
490 on_each_cpu(stop_apic_nmi_watchdog, NULL, 1);
491}
492
Simon Arlotte3a61b02008-07-19 23:32:54 +0100493static int __init setup_unknown_nmi_panic(char *str)
494{
495 unknown_nmi_panic = 1;
496 return 1;
497}
498__setup("unknown_nmi_panic", setup_unknown_nmi_panic);
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500static int unknown_nmi_panic_callback(struct pt_regs *regs, int cpu)
501{
502 unsigned char reason = get_nmi_reason();
503 char buf[64];
504
Don Zickus2fbe7b22006-09-26 10:52:27 +0200505 sprintf(buf, "NMI received for unknown reason %02x\n", reason);
Cyrill Gorcunov6c8decdf2008-05-24 19:36:37 +0400506 die_nmi(buf, regs, 1); /* Always panic here */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 return 0;
508}
509
Don Zickus407984f2006-09-26 10:52:27 +0200510/*
511 * proc handler for /proc/sys/kernel/nmi
512 */
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700513int proc_nmi_enabled(struct ctl_table *table, int write,
Don Zickus407984f2006-09-26 10:52:27 +0200514 void __user *buffer, size_t *length, loff_t *ppos)
515{
516 int old_state;
517
518 nmi_watchdog_enabled = (atomic_read(&nmi_active) > 0) ? 1 : 0;
519 old_state = nmi_watchdog_enabled;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -0700520 proc_dointvec(table, write, buffer, length, ppos);
Don Zickus407984f2006-09-26 10:52:27 +0200521 if (!!old_state == !!nmi_watchdog_enabled)
522 return 0;
523
Cyrill Gorcunov4de00432008-06-24 22:52:06 +0200524 if (atomic_read(&nmi_active) < 0 || !nmi_watchdog_active()) {
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400525 printk(KERN_WARNING
526 "NMI watchdog is permanently disabled\n");
Don Zickuse33e89a2006-09-26 10:52:27 +0200527 return -EIO;
Don Zickus407984f2006-09-26 10:52:27 +0200528 }
529
Don Zickuse33e89a2006-09-26 10:52:27 +0200530 if (nmi_watchdog == NMI_LOCAL_APIC) {
Don Zickus407984f2006-09-26 10:52:27 +0200531 if (nmi_watchdog_enabled)
532 enable_lapic_nmi_watchdog();
533 else
534 disable_lapic_nmi_watchdog();
Aristeu Rozanski6f290b42008-10-27 12:42:34 -0400535 } else if (nmi_watchdog == NMI_IO_APIC) {
536 if (nmi_watchdog_enabled)
537 enable_ioapic_nmi_watchdog();
538 else
539 disable_ioapic_nmi_watchdog();
Don Zickus407984f2006-09-26 10:52:27 +0200540 } else {
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400541 printk(KERN_WARNING
Don Zickus407984f2006-09-26 10:52:27 +0200542 "NMI watchdog doesn't know what hardware to touch\n");
543 return -EIO;
544 }
545 return 0;
546}
547
Cyrill Gorcunov1798bc22008-05-24 19:36:41 +0400548#endif /* CONFIG_SYSCTL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Li Zefana062bae2008-02-03 15:40:30 +0800550int do_nmi_callback(struct pt_regs *regs, int cpu)
551{
552#ifdef CONFIG_SYSCTL
553 if (unknown_nmi_panic)
554 return unknown_nmi_panic_callback(regs, cpu);
555#endif
556 return 0;
557}
558
Ingo Molnar47cab6a2009-08-03 09:31:54 +0200559void arch_trigger_all_cpu_backtrace(void)
Andrew Mortonbb81a092006-12-07 02:14:01 +0100560{
561 int i;
562
Rusty Russellce7c4272009-11-03 14:53:52 +1030563 cpumask_copy(to_cpumask(backtrace_mask), cpu_online_mask);
Ingo Molnarc1dc0b92009-08-02 11:28:21 +0200564
565 printk(KERN_INFO "sending NMI to all CPUs:\n");
566 apic->send_IPI_all(NMI_VECTOR);
567
Andrew Mortonbb81a092006-12-07 02:14:01 +0100568 /* Wait for up to 10 seconds for all CPUs to do the backtrace */
569 for (i = 0; i < 10 * 1000; i++) {
Rusty Russellce7c4272009-11-03 14:53:52 +1030570 if (cpumask_empty(to_cpumask(backtrace_mask)))
Andrew Mortonbb81a092006-12-07 02:14:01 +0100571 break;
572 mdelay(1);
573 }
574}