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/memblock.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
);
127 printk(KERN_EMERG
"Sending IPI to other cpus...\n");
129 while ((cpus_weight(cpus_in_crash
) < ncpus
) && (--msecs
> 0)) {
134 /* Would it be better to replace the trap vector here? */
136 if (cpus_weight(cpus_in_crash
) < ncpus
) {
137 printk(KERN_EMERG
"done waiting: %d cpu(s) not responding\n",
138 ncpus
- cpus_weight(cpus_in_crash
));
139 printk(KERN_EMERG
"Activate soft-reset to stop other cpu(s)\n");
140 cpus_in_sr
= CPU_MASK_NONE
;
141 atomic_set(&enter_on_soft_reset
, 0);
142 while (cpus_weight(cpus_in_crash
) < ncpus
)
146 * Make sure all CPUs are entered via soft-reset if the kdump is
147 * invoked using soft-reset.
149 if (cpu_isset(cpu
, cpus_in_sr
))
150 crash_soft_reset_check(cpu
);
151 /* Leave the IPI callback set */
154 /* wait for all the CPUs to hit real mode but timeout if they don't come in */
155 #ifdef CONFIG_PPC_STD_MMU_64
156 static void crash_kexec_wait_realmode(int cpu
)
162 for (i
=0; i
< NR_CPUS
&& msecs
> 0; i
++) {
166 while (paca
[i
].kexec_state
< KEXEC_STATE_REAL_MODE
) {
168 if (!cpu_possible(i
)) {
171 if (!cpu_online(i
)) {
183 * This function will be called by secondary cpus or by kexec cpu
184 * if soft-reset is activated to stop some CPUs.
186 void crash_kexec_secondary(struct pt_regs
*regs
)
188 int cpu
= smp_processor_id();
192 local_irq_save(flags
);
193 /* Wait 5ms if the kexec CPU is not entered yet. */
194 while (crashing_cpu
< 0) {
197 * Either kdump image is not loaded or
198 * kdump process is not started - Probably xmon
199 * exited using 'x'(exit and recover) or
200 * kexec_should_crash() failed for all running tasks.
202 cpu_clear(cpu
, cpus_in_sr
);
203 local_irq_restore(flags
);
209 if (cpu
== crashing_cpu
) {
211 * Panic CPU will enter this func only via soft-reset.
212 * Wait until all secondary CPUs entered and
213 * then start kexec boot.
215 crash_soft_reset_check(cpu
);
216 cpu_set(crashing_cpu
, cpus_in_crash
);
217 if (ppc_md
.kexec_cpu_down
)
218 ppc_md
.kexec_cpu_down(1, 0);
219 machine_kexec(kexec_crash_image
);
222 crash_ipi_callback(regs
);
226 static void crash_kexec_prepare_cpus(int cpu
)
229 * move the secondarys to us so that we can copy
230 * the new kernel 0-0x100 safely
232 * do this if kexec in setup.c ?
240 void crash_kexec_secondary(struct pt_regs
*regs
)
242 cpus_in_sr
= CPU_MASK_NONE
;
245 #ifdef CONFIG_SPU_BASE
248 #include <asm/spu_priv1.h>
250 struct crash_spu_info
{
252 u32 saved_spu_runcntl_RW
;
253 u32 saved_spu_status_R
;
254 u32 saved_spu_npc_RW
;
255 u64 saved_mfc_sr1_RW
;
260 #define CRASH_NUM_SPUS 16 /* Enough for current hardware */
261 static struct crash_spu_info crash_spu_info
[CRASH_NUM_SPUS
];
263 static void crash_kexec_stop_spus(void)
269 for (i
= 0; i
< CRASH_NUM_SPUS
; i
++) {
270 if (!crash_spu_info
[i
].spu
)
273 spu
= crash_spu_info
[i
].spu
;
275 crash_spu_info
[i
].saved_spu_runcntl_RW
=
276 in_be32(&spu
->problem
->spu_runcntl_RW
);
277 crash_spu_info
[i
].saved_spu_status_R
=
278 in_be32(&spu
->problem
->spu_status_R
);
279 crash_spu_info
[i
].saved_spu_npc_RW
=
280 in_be32(&spu
->problem
->spu_npc_RW
);
282 crash_spu_info
[i
].saved_mfc_dar
= spu_mfc_dar_get(spu
);
283 crash_spu_info
[i
].saved_mfc_dsisr
= spu_mfc_dsisr_get(spu
);
284 tmp
= spu_mfc_sr1_get(spu
);
285 crash_spu_info
[i
].saved_mfc_sr1_RW
= tmp
;
287 tmp
&= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK
;
288 spu_mfc_sr1_set(spu
, tmp
);
294 void crash_register_spus(struct list_head
*list
)
298 list_for_each_entry(spu
, list
, full_list
) {
299 if (WARN_ON(spu
->number
>= CRASH_NUM_SPUS
))
302 crash_spu_info
[spu
->number
].spu
= spu
;
307 static inline void crash_kexec_stop_spus(void)
310 #endif /* CONFIG_SPU_BASE */
313 * Register a function to be called on shutdown. Only use this if you
314 * can't reset your device in the second kernel.
316 int crash_shutdown_register(crash_shutdown_t handler
)
320 spin_lock(&crash_handlers_lock
);
321 for (i
= 0 ; i
< CRASH_HANDLER_MAX
; i
++)
322 if (!crash_shutdown_handles
[i
]) {
323 /* Insert handle at first empty entry */
324 crash_shutdown_handles
[i
] = handler
;
329 if (i
== CRASH_HANDLER_MAX
) {
330 printk(KERN_ERR
"Crash shutdown handles full, "
331 "not registered.\n");
335 spin_unlock(&crash_handlers_lock
);
338 EXPORT_SYMBOL(crash_shutdown_register
);
340 int crash_shutdown_unregister(crash_shutdown_t handler
)
344 spin_lock(&crash_handlers_lock
);
345 for (i
= 0 ; i
< CRASH_HANDLER_MAX
; i
++)
346 if (crash_shutdown_handles
[i
] == handler
)
349 if (i
== CRASH_HANDLER_MAX
) {
350 printk(KERN_ERR
"Crash shutdown handle not found\n");
353 /* Shift handles down */
354 for (; crash_shutdown_handles
[i
]; i
++)
355 crash_shutdown_handles
[i
] =
356 crash_shutdown_handles
[i
+1];
360 spin_unlock(&crash_handlers_lock
);
363 EXPORT_SYMBOL(crash_shutdown_unregister
);
365 static unsigned long crash_shutdown_buf
[JMP_BUF_LEN
];
366 static int crash_shutdown_cpu
= -1;
368 static int handle_fault(struct pt_regs
*regs
)
370 if (crash_shutdown_cpu
== smp_processor_id())
371 longjmp(crash_shutdown_buf
, 1);
375 void default_machine_crash_shutdown(struct pt_regs
*regs
)
378 int (*old_handler
)(struct pt_regs
*regs
);
382 * This function is only called after the system
383 * has panicked or is otherwise in a critical state.
384 * The minimum amount of code to allow a kexec'd kernel
385 * to run successfully needs to happen here.
387 * In practice this means stopping other cpus in
389 * The kernel is broken so disable interrupts.
394 * Make a note of crashing cpu. Will be used in machine_kexec
395 * such that another IPI will not be sent.
397 crashing_cpu
= smp_processor_id();
398 crash_save_cpu(regs
, crashing_cpu
);
399 crash_kexec_prepare_cpus(crashing_cpu
);
400 cpu_set(crashing_cpu
, cpus_in_crash
);
401 #if defined(CONFIG_PPC_STD_MMU_64) && defined(CONFIG_SMP)
402 crash_kexec_wait_realmode(crashing_cpu
);
406 struct irq_desc
*desc
= irq_to_desc(i
);
408 if (!desc
|| !desc
->chip
|| !desc
->chip
->eoi
)
411 if (desc
->status
& IRQ_INPROGRESS
)
414 if (!(desc
->status
& IRQ_DISABLED
))
415 desc
->chip
->shutdown(i
);
419 * Call registered shutdown routines savely. Swap out
420 * __debugger_fault_handler, and replace on exit.
422 old_handler
= __debugger_fault_handler
;
423 __debugger_fault_handler
= handle_fault
;
424 crash_shutdown_cpu
= smp_processor_id();
425 for (i
= 0; crash_shutdown_handles
[i
]; i
++) {
426 if (setjmp(crash_shutdown_buf
) == 0) {
428 * Insert syncs and delay to ensure
429 * instructions in the dangerous region don't
430 * leak away from this protected region.
432 asm volatile("sync; isync");
433 /* dangerous region */
434 crash_shutdown_handles
[i
]();
435 asm volatile("sync; isync");
438 crash_shutdown_cpu
= -1;
439 __debugger_fault_handler
= old_handler
;
441 crash_kexec_stop_spus();
443 if (ppc_md
.kexec_cpu_down
)
444 ppc_md
.kexec_cpu_down(1, 0);