1 /*
2 * Architecture specific (PPC64) functions for kexec based crash dumps.
3 *
4 * Copyright (C) 2005, IBM Corp.
5 *
6 * Created by: Haren Myneni
7 *
8 * This source code is licensed under the GNU General Public License,
9 * Version 2. See the file COPYING for more details.
10 *
11 */
12
13 #include <linux/kernel.h>
14 #include <linux/smp.h>
15 #include <linux/reboot.h>
16 #include <linux/kexec.h>
17 #include <linux/export.h>
18 #include <linux/crash_dump.h>
19 #include <linux/delay.h>
20 #include <linux/init.h>
21 #include <linux/irq.h>
22 #include <linux/types.h>
23
24 #include <asm/processor.h>
25 #include <asm/machdep.h>
26 #include <asm/kexec.h>
27 #include <asm/kdump.h>
28 #include <asm/prom.h>
29 #include <asm/smp.h>
30 #include <asm/setjmp.h>
31 #include <asm/debug.h>
32
33 /*
34 * The primary CPU waits a while for all secondary CPUs to enter. This is to
35 * avoid sending an IPI if the secondary CPUs are entering
36 * crash_kexec_secondary on their own (eg via a system reset).
37 *
38 * The secondary timeout has to be longer than the primary. Both timeouts are
39 * in milliseconds.
40 */
41 #define PRIMARY_TIMEOUT 500
42 #define SECONDARY_TIMEOUT 1000
43
44 #define IPI_TIMEOUT 10000
45 #define REAL_MODE_TIMEOUT 10000
46
47 /* This keeps a track of which one is the crashing cpu. */
48 int crashing_cpu = -1;
49 static int time_to_dump;
50
51 #define CRASH_HANDLER_MAX 3
52 /* NULL terminated list of shutdown handles */
53 static crash_shutdown_t crash_shutdown_handles[CRASH_HANDLER_MAX+1];
54 static DEFINE_SPINLOCK(crash_handlers_lock);
55
56 static unsigned long crash_shutdown_buf[JMP_BUF_LEN];
57 static int crash_shutdown_cpu = -1;
58
handle_fault(struct pt_regs * regs)59 static int handle_fault(struct pt_regs *regs)
60 {
61 if (crash_shutdown_cpu == smp_processor_id())
62 longjmp(crash_shutdown_buf, 1);
63 return 0;
64 }
65
66 #ifdef CONFIG_SMP
67
68 static atomic_t cpus_in_crash;
crash_ipi_callback(struct pt_regs * regs)69 void crash_ipi_callback(struct pt_regs *regs)
70 {
71 static cpumask_t cpus_state_saved = CPU_MASK_NONE;
72
73 int cpu = smp_processor_id();
74
75 if (!cpu_online(cpu))
76 return;
77
78 hard_irq_disable();
79 if (!cpumask_test_cpu(cpu, &cpus_state_saved)) {
80 crash_save_cpu(regs, cpu);
81 cpumask_set_cpu(cpu, &cpus_state_saved);
82 }
83
84 atomic_inc(&cpus_in_crash);
85 smp_mb__after_atomic_inc();
86
87 /*
88 * Starting the kdump boot.
89 * This barrier is needed to make sure that all CPUs are stopped.
90 */
91 while (!time_to_dump)
92 cpu_relax();
93
94 if (ppc_md.kexec_cpu_down)
95 ppc_md.kexec_cpu_down(1, 1);
96
97 #ifdef CONFIG_PPC64
98 kexec_smp_wait();
99 #else
100 for (;;); /* FIXME */
101 #endif
102
103 /* NOTREACHED */
104 }
105
crash_kexec_prepare_cpus(int cpu)106 static void crash_kexec_prepare_cpus(int cpu)
107 {
108 unsigned int msecs;
109 unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
110 int tries = 0;
111 int (*old_handler)(struct pt_regs *regs);
112
113 printk(KERN_EMERG "Sending IPI to other CPUs\n");
114
115 crash_send_ipi(crash_ipi_callback);
116 smp_wmb();
117
118 again:
119 /*
120 * FIXME: Until we will have the way to stop other CPUs reliably,
121 * the crash CPU will send an IPI and wait for other CPUs to
122 * respond.
123 */
124 msecs = IPI_TIMEOUT;
125 while ((atomic_read(&cpus_in_crash) < ncpus) && (--msecs > 0))
126 mdelay(1);
127
128 /* Would it be better to replace the trap vector here? */
129
130 if (atomic_read(&cpus_in_crash) >= ncpus) {
131 printk(KERN_EMERG "IPI complete\n");
132 return;
133 }
134
135 printk(KERN_EMERG "ERROR: %d cpu(s) not responding\n",
136 ncpus - atomic_read(&cpus_in_crash));
137
138 /*
139 * If we have a panic timeout set then we can't wait indefinitely
140 * for someone to activate system reset. We also give up on the
141 * second time through if system reset fail to work.
142 */
143 if ((panic_timeout > 0) || (tries > 0))
144 return;
145
146 /*
147 * A system reset will cause all CPUs to take an 0x100 exception.
148 * The primary CPU returns here via setjmp, and the secondary
149 * CPUs reexecute the crash_kexec_secondary path.
150 */
151 old_handler = __debugger;
152 __debugger = handle_fault;
153 crash_shutdown_cpu = smp_processor_id();
154
155 if (setjmp(crash_shutdown_buf) == 0) {
156 printk(KERN_EMERG "Activate system reset (dumprestart) "
157 "to stop other cpu(s)\n");
158
159 /*
160 * A system reset will force all CPUs to execute the
161 * crash code again. We need to reset cpus_in_crash so we
162 * wait for everyone to do this.
163 */
164 atomic_set(&cpus_in_crash, 0);
165 smp_mb();
166
167 while (atomic_read(&cpus_in_crash) < ncpus)
168 cpu_relax();
169 }
170
171 crash_shutdown_cpu = -1;
172 __debugger = old_handler;
173
174 tries++;
175 goto again;
176 }
177
178 /*
179 * This function will be called by secondary cpus.
180 */
crash_kexec_secondary(struct pt_regs * regs)181 void crash_kexec_secondary(struct pt_regs *regs)
182 {
183 unsigned long flags;
184 int msecs = SECONDARY_TIMEOUT;
185
186 local_irq_save(flags);
187
188 /* Wait for the primary crash CPU to signal its progress */
189 while (crashing_cpu < 0) {
190 if (--msecs < 0) {
191 /* No response, kdump image may not have been loaded */
192 local_irq_restore(flags);
193 return;
194 }
195
196 mdelay(1);
197 }
198
199 crash_ipi_callback(regs);
200 }
201
202 #else /* ! CONFIG_SMP */
203
crash_kexec_prepare_cpus(int cpu)204 static void crash_kexec_prepare_cpus(int cpu)
205 {
206 /*
207 * move the secondaries to us so that we can copy
208 * the new kernel 0-0x100 safely
209 *
210 * do this if kexec in setup.c ?
211 */
212 #ifdef CONFIG_PPC64
213 smp_release_cpus();
214 #else
215 /* FIXME */
216 #endif
217 }
218
crash_kexec_secondary(struct pt_regs * regs)219 void crash_kexec_secondary(struct pt_regs *regs)
220 {
221 }
222 #endif /* CONFIG_SMP */
223
224 /* wait for all the CPUs to hit real mode but timeout if they don't come in */
225 #if defined(CONFIG_SMP) && defined(CONFIG_PPC_STD_MMU_64)
crash_kexec_wait_realmode(int cpu)226 static void crash_kexec_wait_realmode(int cpu)
227 {
228 unsigned int msecs;
229 int i;
230
231 msecs = REAL_MODE_TIMEOUT;
232 for (i=0; i < nr_cpu_ids && msecs > 0; i++) {
233 if (i == cpu)
234 continue;
235
236 while (paca[i].kexec_state < KEXEC_STATE_REAL_MODE) {
237 barrier();
238 if (!cpu_possible(i) || !cpu_online(i) || (msecs <= 0))
239 break;
240 msecs--;
241 mdelay(1);
242 }
243 }
244 mb();
245 }
246 #else
crash_kexec_wait_realmode(int cpu)247 static inline void crash_kexec_wait_realmode(int cpu) {}
248 #endif /* CONFIG_SMP && CONFIG_PPC_STD_MMU_64 */
249
250 /*
251 * Register a function to be called on shutdown. Only use this if you
252 * can't reset your device in the second kernel.
253 */
crash_shutdown_register(crash_shutdown_t handler)254 int crash_shutdown_register(crash_shutdown_t handler)
255 {
256 unsigned int i, rc;
257
258 spin_lock(&crash_handlers_lock);
259 for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
260 if (!crash_shutdown_handles[i]) {
261 /* Insert handle at first empty entry */
262 crash_shutdown_handles[i] = handler;
263 rc = 0;
264 break;
265 }
266
267 if (i == CRASH_HANDLER_MAX) {
268 printk(KERN_ERR "Crash shutdown handles full, "
269 "not registered.\n");
270 rc = 1;
271 }
272
273 spin_unlock(&crash_handlers_lock);
274 return rc;
275 }
276 EXPORT_SYMBOL(crash_shutdown_register);
277
crash_shutdown_unregister(crash_shutdown_t handler)278 int crash_shutdown_unregister(crash_shutdown_t handler)
279 {
280 unsigned int i, rc;
281
282 spin_lock(&crash_handlers_lock);
283 for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
284 if (crash_shutdown_handles[i] == handler)
285 break;
286
287 if (i == CRASH_HANDLER_MAX) {
288 printk(KERN_ERR "Crash shutdown handle not found\n");
289 rc = 1;
290 } else {
291 /* Shift handles down */
292 for (; crash_shutdown_handles[i]; i++)
293 crash_shutdown_handles[i] =
294 crash_shutdown_handles[i+1];
295 rc = 0;
296 }
297
298 spin_unlock(&crash_handlers_lock);
299 return rc;
300 }
301 EXPORT_SYMBOL(crash_shutdown_unregister);
302
default_machine_crash_shutdown(struct pt_regs * regs)303 void default_machine_crash_shutdown(struct pt_regs *regs)
304 {
305 unsigned int i;
306 int (*old_handler)(struct pt_regs *regs);
307
308 /*
309 * This function is only called after the system
310 * has panicked or is otherwise in a critical state.
311 * The minimum amount of code to allow a kexec'd kernel
312 * to run successfully needs to happen here.
313 *
314 * In practice this means stopping other cpus in
315 * an SMP system.
316 * The kernel is broken so disable interrupts.
317 */
318 hard_irq_disable();
319
320 /*
321 * Make a note of crashing cpu. Will be used in machine_kexec
322 * such that another IPI will not be sent.
323 */
324 crashing_cpu = smp_processor_id();
325
326 /*
327 * If we came in via system reset, wait a while for the secondary
328 * CPUs to enter.
329 */
330 if (TRAP(regs) == 0x100)
331 mdelay(PRIMARY_TIMEOUT);
332
333 crash_kexec_prepare_cpus(crashing_cpu);
334
335 crash_save_cpu(regs, crashing_cpu);
336
337 time_to_dump = 1;
338
339 crash_kexec_wait_realmode(crashing_cpu);
340
341 machine_kexec_mask_interrupts();
342
343 /*
344 * Call registered shutdown routines safely. Swap out
345 * __debugger_fault_handler, and replace on exit.
346 */
347 old_handler = __debugger_fault_handler;
348 __debugger_fault_handler = handle_fault;
349 crash_shutdown_cpu = smp_processor_id();
350 for (i = 0; crash_shutdown_handles[i]; i++) {
351 if (setjmp(crash_shutdown_buf) == 0) {
352 /*
353 * Insert syncs and delay to ensure
354 * instructions in the dangerous region don't
355 * leak away from this protected region.
356 */
357 asm volatile("sync; isync");
358 /* dangerous region */
359 crash_shutdown_handles[i]();
360 asm volatile("sync; isync");
361 }
362 }
363 crash_shutdown_cpu = -1;
364 __debugger_fault_handler = old_handler;
365
366 if (ppc_md.kexec_cpu_down)
367 ppc_md.kexec_cpu_down(1, 0);
368 }
369