2 * Architecture specific (PPC64) functions for kexec based crash dumps.
4 * Copyright (C) 2005, IBM Corp.
6 * Created by: Haren Myneni
8 * This source code is licensed under the GNU General Public License,
9 * Version 2. See the file COPYING for more details.
15 #include <linux/kernel.h>
16 #include <linux/smp.h>
17 #include <linux/reboot.h>
18 #include <linux/kexec.h>
19 #include <linux/bootmem.h>
20 #include <linux/crash_dump.h>
21 #include <linux/delay.h>
22 #include <linux/elf.h>
23 #include <linux/elfcore.h>
24 #include <linux/init.h>
25 #include <linux/irq.h>
26 #include <linux/types.h>
27 #include <linux/lmb.h>
29 #include <asm/processor.h>
30 #include <asm/machdep.h>
31 #include <asm/kexec.h>
32 #include <asm/kdump.h>
34 #include <asm/firmware.h>
36 #include <asm/system.h>
37 #include <asm/setjmp.h>
41 #define DBG(fmt...) udbg_printf(fmt)
46 /* This keeps a track of which one is crashing cpu. */
47 int crashing_cpu = -1;
48 static cpumask_t cpus_in_crash = CPU_MASK_NONE;
49 cpumask_t cpus_in_sr = CPU_MASK_NONE;
51 #define CRASH_HANDLER_MAX 2
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);
57 static atomic_t enter_on_soft_reset = ATOMIC_INIT(0);
59 void crash_ipi_callback(struct pt_regs *regs)
61 int cpu = smp_processor_id();
67 if (!cpu_isset(cpu, cpus_in_crash))
68 crash_save_cpu(regs, cpu);
69 cpu_set(cpu, cpus_in_crash);
72 * Entered via soft-reset - could be the kdump
73 * process is invoked using soft-reset or user activated
74 * it if some CPU did not respond to an IPI.
75 * For soft-reset, the secondary CPU can enter this func
76 * twice. 1 - using IPI, and 2. soft-reset.
77 * Tell the kexec CPU that entered via soft-reset and ready
80 if (cpu_isset(cpu, cpus_in_sr)) {
81 cpu_clear(cpu, cpus_in_sr);
82 atomic_inc(&enter_on_soft_reset);
86 * Starting the kdump boot.
87 * This barrier is needed to make sure that all CPUs are stopped.
88 * If not, soft-reset will be invoked to bring other CPUs.
90 while (!cpu_isset(crashing_cpu, cpus_in_crash))
93 if (ppc_md.kexec_cpu_down)
94 ppc_md.kexec_cpu_down(1, 1);
106 * Wait until all CPUs are entered via soft-reset.
108 static void crash_soft_reset_check(int cpu)
110 unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
112 cpu_clear(cpu, cpus_in_sr);
113 while (atomic_read(&enter_on_soft_reset) != ncpus)
118 static void crash_kexec_prepare_cpus(int cpu)
122 unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
124 crash_send_ipi(crash_ipi_callback);
128 * FIXME: Until we will have the way to stop other CPUSs reliabally,
129 * the crash CPU will send an IPI and wait for other CPUs to
131 * Delay of at least 10 seconds.
133 printk(KERN_EMERG "Sending IPI to other cpus...\n");
135 while ((cpus_weight(cpus_in_crash) < ncpus) && (--msecs > 0)) {
140 /* Would it be better to replace the trap vector here? */
143 * FIXME: In case if we do not get all CPUs, one possibility: ask the
144 * user to do soft reset such that we get all.
145 * Soft-reset will be used until better mechanism is implemented.
147 if (cpus_weight(cpus_in_crash) < ncpus) {
148 printk(KERN_EMERG "done waiting: %d cpu(s) not responding\n",
149 ncpus - cpus_weight(cpus_in_crash));
150 printk(KERN_EMERG "Activate soft-reset to stop other cpu(s)\n");
151 cpus_in_sr = CPU_MASK_NONE;
152 atomic_set(&enter_on_soft_reset, 0);
153 while (cpus_weight(cpus_in_crash) < ncpus)
157 * Make sure all CPUs are entered via soft-reset if the kdump is
158 * invoked using soft-reset.
160 if (cpu_isset(cpu, cpus_in_sr))
161 crash_soft_reset_check(cpu);
162 /* Leave the IPI callback set */
165 /* wait for all the CPUs to hit real mode but timeout if they don't come in */
166 static void crash_kexec_wait_realmode(int cpu)
172 for (i=0; i < NR_CPUS && msecs > 0; i++) {
176 while (paca[i].kexec_state < KEXEC_STATE_REAL_MODE) {
178 if (!cpu_possible(i)) {
181 if (!cpu_online(i)) {
192 * This function will be called by secondary cpus or by kexec cpu
193 * if soft-reset is activated to stop some CPUs.
195 void crash_kexec_secondary(struct pt_regs *regs)
197 int cpu = smp_processor_id();
201 local_irq_save(flags);
202 /* Wait 5ms if the kexec CPU is not entered yet. */
203 while (crashing_cpu < 0) {
206 * Either kdump image is not loaded or
207 * kdump process is not started - Probably xmon
208 * exited using 'x'(exit and recover) or
209 * kexec_should_crash() failed for all running tasks.
211 cpu_clear(cpu, cpus_in_sr);
212 local_irq_restore(flags);
218 if (cpu == crashing_cpu) {
220 * Panic CPU will enter this func only via soft-reset.
221 * Wait until all secondary CPUs entered and
222 * then start kexec boot.
224 crash_soft_reset_check(cpu);
225 cpu_set(crashing_cpu, cpus_in_crash);
226 if (ppc_md.kexec_cpu_down)
227 ppc_md.kexec_cpu_down(1, 0);
228 machine_kexec(kexec_crash_image);
231 crash_ipi_callback(regs);
235 static void crash_kexec_prepare_cpus(int cpu)
238 * move the secondarys to us so that we can copy
239 * the new kernel 0-0x100 safely
241 * do this if kexec in setup.c ?
250 void crash_kexec_secondary(struct pt_regs *regs)
252 cpus_in_sr = CPU_MASK_NONE;
255 #ifdef CONFIG_SPU_BASE
258 #include <asm/spu_priv1.h>
260 struct crash_spu_info {
262 u32 saved_spu_runcntl_RW;
263 u32 saved_spu_status_R;
264 u32 saved_spu_npc_RW;
265 u64 saved_mfc_sr1_RW;
270 #define CRASH_NUM_SPUS 16 /* Enough for current hardware */
271 static struct crash_spu_info crash_spu_info[CRASH_NUM_SPUS];
273 static void crash_kexec_stop_spus(void)
279 for (i = 0; i < CRASH_NUM_SPUS; i++) {
280 if (!crash_spu_info[i].spu)
283 spu = crash_spu_info[i].spu;
285 crash_spu_info[i].saved_spu_runcntl_RW =
286 in_be32(&spu->problem->spu_runcntl_RW);
287 crash_spu_info[i].saved_spu_status_R =
288 in_be32(&spu->problem->spu_status_R);
289 crash_spu_info[i].saved_spu_npc_RW =
290 in_be32(&spu->problem->spu_npc_RW);
292 crash_spu_info[i].saved_mfc_dar = spu_mfc_dar_get(spu);
293 crash_spu_info[i].saved_mfc_dsisr = spu_mfc_dsisr_get(spu);
294 tmp = spu_mfc_sr1_get(spu);
295 crash_spu_info[i].saved_mfc_sr1_RW = tmp;
297 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
298 spu_mfc_sr1_set(spu, tmp);
304 void crash_register_spus(struct list_head *list)
308 list_for_each_entry(spu, list, full_list) {
309 if (WARN_ON(spu->number >= CRASH_NUM_SPUS))
312 crash_spu_info[spu->number].spu = spu;
317 static inline void crash_kexec_stop_spus(void)
320 #endif /* CONFIG_SPU_BASE */
323 * Register a function to be called on shutdown. Only use this if you
324 * can't reset your device in the second kernel.
326 int crash_shutdown_register(crash_shutdown_t handler)
330 spin_lock(&crash_handlers_lock);
331 for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
332 if (!crash_shutdown_handles[i]) {
333 /* Insert handle at first empty entry */
334 crash_shutdown_handles[i] = handler;
339 if (i == CRASH_HANDLER_MAX) {
340 printk(KERN_ERR "Crash shutdown handles full, "
341 "not registered.\n");
345 spin_unlock(&crash_handlers_lock);
348 EXPORT_SYMBOL(crash_shutdown_register);
350 int crash_shutdown_unregister(crash_shutdown_t handler)
354 spin_lock(&crash_handlers_lock);
355 for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
356 if (crash_shutdown_handles[i] == handler)
359 if (i == CRASH_HANDLER_MAX) {
360 printk(KERN_ERR "Crash shutdown handle not found\n");
363 /* Shift handles down */
364 for (; crash_shutdown_handles[i]; i++)
365 crash_shutdown_handles[i] =
366 crash_shutdown_handles[i+1];
370 spin_unlock(&crash_handlers_lock);
373 EXPORT_SYMBOL(crash_shutdown_unregister);
375 static unsigned long crash_shutdown_buf[JMP_BUF_LEN];
376 static int crash_shutdown_cpu = -1;
378 static int handle_fault(struct pt_regs *regs)
380 if (crash_shutdown_cpu == smp_processor_id())
381 longjmp(crash_shutdown_buf, 1);
385 void default_machine_crash_shutdown(struct pt_regs *regs)
388 int (*old_handler)(struct pt_regs *regs);
392 * This function is only called after the system
393 * has panicked or is otherwise in a critical state.
394 * The minimum amount of code to allow a kexec'd kernel
395 * to run successfully needs to happen here.
397 * In practice this means stopping other cpus in
399 * The kernel is broken so disable interrupts.
404 struct irq_desc *desc = irq_to_desc(i);
406 if (!desc || !desc->chip || !desc->chip->eoi)
409 if (desc->status & IRQ_INPROGRESS)
412 if (!(desc->status & IRQ_DISABLED))
413 desc->chip->shutdown(i);
417 * Call registered shutdown routines savely. Swap out
418 * __debugger_fault_handler, and replace on exit.
420 old_handler = __debugger_fault_handler;
421 __debugger_fault_handler = handle_fault;
422 crash_shutdown_cpu = smp_processor_id();
423 for (i = 0; crash_shutdown_handles[i]; i++) {
424 if (setjmp(crash_shutdown_buf) == 0) {
426 * Insert syncs and delay to ensure
427 * instructions in the dangerous region don't
428 * leak away from this protected region.
430 asm volatile("sync; isync");
431 /* dangerous region */
432 crash_shutdown_handles[i]();
433 asm volatile("sync; isync");
436 crash_shutdown_cpu = -1;
437 __debugger_fault_handler = old_handler;
440 * Make a note of crashing cpu. Will be used in machine_kexec
441 * such that another IPI will not be sent.
443 crashing_cpu = smp_processor_id();
444 crash_save_cpu(regs, crashing_cpu);
445 crash_kexec_prepare_cpus(crashing_cpu);
446 cpu_set(crashing_cpu, cpus_in_crash);
447 crash_kexec_stop_spus();
448 crash_kexec_wait_realmode(crashing_cpu);
449 if (ppc_md.kexec_cpu_down)
450 ppc_md.kexec_cpu_down(1, 0);