]>
Commit | Line | Data |
---|---|---|
e5553a6d DM |
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/module.h> | |
14 | #include <linux/kprobes.h> | |
15 | #include <linux/kernel_stat.h> | |
16 | #include <linux/slab.h> | |
17 | #include <linux/kdebug.h> | |
18 | #include <linux/delay.h> | |
19 | #include <linux/smp.h> | |
20 | ||
21 | #include <asm/ptrace.h> | |
22 | #include <asm/local.h> | |
23 | #include <asm/pcr.h> | |
24 | ||
25 | /* We don't have a real NMI on sparc64, but we can fake one | |
26 | * up using profiling counter overflow interrupts and interrupt | |
27 | * levels. | |
28 | * | |
29 | * The profile overflow interrupts at level 15, so we use | |
30 | * level 14 as our IRQ off level. | |
31 | */ | |
32 | ||
33 | static int nmi_watchdog_active; | |
34 | static int panic_on_timeout; | |
35 | ||
36 | int nmi_usable; | |
37 | EXPORT_SYMBOL_GPL(nmi_usable); | |
38 | ||
39 | static unsigned int nmi_hz = HZ; | |
40 | ||
41 | static DEFINE_PER_CPU(unsigned int, last_irq_sum); | |
42 | static DEFINE_PER_CPU(local_t, alert_counter); | |
43 | static DEFINE_PER_CPU(int, nmi_touch); | |
44 | ||
45 | void touch_nmi_watchdog(void) | |
46 | { | |
47 | if (nmi_watchdog_active) { | |
48 | int cpu; | |
49 | ||
50 | for_each_present_cpu(cpu) { | |
51 | if (per_cpu(nmi_touch, cpu) != 1) | |
52 | per_cpu(nmi_touch, cpu) = 1; | |
53 | } | |
54 | } | |
55 | ||
56 | touch_softlockup_watchdog(); | |
57 | } | |
58 | EXPORT_SYMBOL(touch_nmi_watchdog); | |
59 | ||
60 | static void die_nmi(const char *str, struct pt_regs *regs, int do_panic) | |
61 | { | |
62 | if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, | |
63 | pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP) | |
64 | return; | |
65 | ||
66 | console_verbose(); | |
67 | bust_spinlocks(1); | |
68 | ||
69 | printk(KERN_EMERG "%s", str); | |
70 | printk(" on CPU%d, ip %08lx, registers:\n", | |
71 | smp_processor_id(), regs->tpc); | |
72 | show_regs(regs); | |
73 | ||
74 | bust_spinlocks(0); | |
75 | ||
76 | if (do_panic || panic_on_oops) | |
77 | panic("Non maskable interrupt"); | |
78 | ||
79 | local_irq_enable(); | |
80 | do_exit(SIGBUS); | |
81 | } | |
82 | ||
83 | notrace __kprobes void perfctr_irq(int irq, struct pt_regs *regs) | |
84 | { | |
85 | unsigned int sum, touched = 0; | |
86 | int cpu = smp_processor_id(); | |
87 | ||
88 | clear_softint(1 << irq); | |
89 | pcr_ops->write(PCR_PIC_PRIV); | |
90 | ||
91 | local_cpu_data().__nmi_count++; | |
92 | ||
93 | if (notify_die(DIE_NMI, "nmi", regs, 0, | |
94 | pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP) | |
95 | touched = 1; | |
96 | ||
97 | sum = kstat_cpu(cpu).irqs[0]; | |
98 | if (__get_cpu_var(nmi_touch)) { | |
99 | __get_cpu_var(nmi_touch) = 0; | |
100 | touched = 1; | |
101 | } | |
102 | if (!touched && __get_cpu_var(last_irq_sum) == sum) { | |
103 | local_inc(&__get_cpu_var(alert_counter)); | |
104 | if (local_read(&__get_cpu_var(alert_counter)) == 5 * nmi_hz) | |
105 | die_nmi("BUG: NMI Watchdog detected LOCKUP", | |
106 | regs, panic_on_timeout); | |
107 | } else { | |
108 | __get_cpu_var(last_irq_sum) = sum; | |
109 | local_set(&__get_cpu_var(alert_counter), 0); | |
110 | } | |
111 | if (nmi_usable) { | |
112 | write_pic(picl_value(nmi_hz)); | |
113 | pcr_ops->write(pcr_enable); | |
114 | } | |
115 | } | |
116 | ||
117 | static inline unsigned int get_nmi_count(int cpu) | |
118 | { | |
119 | return cpu_data(cpu).__nmi_count; | |
120 | } | |
121 | ||
122 | static int endflag __initdata; | |
123 | ||
124 | static __init void nmi_cpu_busy(void *data) | |
125 | { | |
126 | local_irq_enable_in_hardirq(); | |
127 | while (endflag == 0) | |
128 | mb(); | |
129 | } | |
130 | ||
131 | static void report_broken_nmi(int cpu, int *prev_nmi_count) | |
132 | { | |
133 | printk(KERN_CONT "\n"); | |
134 | ||
135 | printk(KERN_WARNING | |
136 | "WARNING: CPU#%d: NMI appears to be stuck (%d->%d)!\n", | |
137 | cpu, prev_nmi_count[cpu], get_nmi_count(cpu)); | |
138 | ||
139 | printk(KERN_WARNING | |
140 | "Please report this to bugzilla.kernel.org,\n"); | |
141 | printk(KERN_WARNING | |
142 | "and attach the output of the 'dmesg' command.\n"); | |
143 | ||
144 | nmi_usable = 0; | |
145 | } | |
146 | ||
147 | static void stop_watchdog(void *unused) | |
148 | { | |
149 | pcr_ops->write(PCR_PIC_PRIV); | |
150 | } | |
151 | ||
152 | static int __init check_nmi_watchdog(void) | |
153 | { | |
154 | unsigned int *prev_nmi_count; | |
155 | int cpu, err; | |
156 | ||
157 | prev_nmi_count = kmalloc(nr_cpu_ids * sizeof(unsigned int), GFP_KERNEL); | |
158 | if (!prev_nmi_count) { | |
159 | err = -ENOMEM; | |
160 | goto error; | |
161 | } | |
162 | ||
163 | printk(KERN_INFO "Testing NMI watchdog ... "); | |
164 | ||
165 | smp_call_function(nmi_cpu_busy, (void *)&endflag, 0); | |
166 | ||
167 | for_each_possible_cpu(cpu) | |
168 | prev_nmi_count[cpu] = get_nmi_count(cpu); | |
169 | local_irq_enable(); | |
170 | mdelay((20 * 1000) / nmi_hz); /* wait 20 ticks */ | |
171 | ||
172 | for_each_online_cpu(cpu) { | |
173 | if (get_nmi_count(cpu) - prev_nmi_count[cpu] <= 5) | |
174 | report_broken_nmi(cpu, prev_nmi_count); | |
175 | } | |
176 | endflag = 1; | |
177 | if (!nmi_usable) { | |
178 | kfree(prev_nmi_count); | |
179 | err = -ENODEV; | |
180 | goto error; | |
181 | } | |
182 | printk("OK.\n"); | |
183 | ||
184 | nmi_hz = 1; | |
185 | ||
186 | kfree(prev_nmi_count); | |
187 | return 0; | |
188 | error: | |
189 | on_each_cpu(stop_watchdog, NULL, 1); | |
190 | return err; | |
191 | } | |
192 | ||
193 | static void start_watchdog(void *unused) | |
194 | { | |
195 | pcr_ops->write(PCR_PIC_PRIV); | |
196 | write_pic(picl_value(nmi_hz)); | |
197 | ||
198 | pcr_ops->write(pcr_enable); | |
199 | } | |
200 | ||
201 | void nmi_adjust_hz(unsigned int new_hz) | |
202 | { | |
203 | nmi_hz = new_hz; | |
204 | on_each_cpu(start_watchdog, NULL, 1); | |
205 | } | |
206 | EXPORT_SYMBOL_GPL(nmi_adjust_hz); | |
207 | ||
208 | int __init nmi_init(void) | |
209 | { | |
210 | nmi_usable = 1; | |
211 | ||
212 | on_each_cpu(start_watchdog, NULL, 1); | |
213 | ||
214 | return check_nmi_watchdog(); | |
215 | } | |
216 | ||
217 | static int __init setup_nmi_watchdog(char *str) | |
218 | { | |
219 | if (!strncmp(str, "panic", 5)) | |
220 | panic_on_timeout = 1; | |
221 | ||
222 | return 0; | |
223 | } | |
224 | __setup("nmi_watchdog=", setup_nmi_watchdog); |