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/irq.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>
39 #define DBG(fmt...) udbg_printf(fmt)
44 /* This keeps a track of which one is crashing cpu. */
45 int crashing_cpu
= -1;
46 static cpumask_t cpus_in_crash
= CPU_MASK_NONE
;
48 static u32
*append_elf_note(u32
*buf
, char *name
, unsigned type
, void *data
,
53 note
.n_namesz
= strlen(name
) + 1;
54 note
.n_descsz
= data_len
;
56 memcpy(buf
, ¬e
, sizeof(note
));
57 buf
+= (sizeof(note
) +3)/4;
58 memcpy(buf
, name
, note
.n_namesz
);
59 buf
+= (note
.n_namesz
+ 3)/4;
60 memcpy(buf
, data
, note
.n_descsz
);
61 buf
+= (note
.n_descsz
+ 3)/4;
66 static void final_note(u32
*buf
)
73 memcpy(buf
, ¬e
, sizeof(note
));
76 static void crash_save_this_cpu(struct pt_regs
*regs
, int cpu
)
78 struct elf_prstatus prstatus
;
81 if ((cpu
< 0) || (cpu
>= NR_CPUS
))
84 /* Using ELF notes here is opportunistic.
85 * I need a well defined structure format
86 * for the data I pass, and I need tags
87 * on the data to indicate what information I have
88 * squirrelled away. ELF notes happen to provide
89 * all of that that no need to invent something new.
91 buf
= (u32
*)per_cpu_ptr(crash_notes
, cpu
);
95 memset(&prstatus
, 0, sizeof(prstatus
));
96 prstatus
.pr_pid
= current
->pid
;
97 elf_core_copy_regs(&prstatus
.pr_reg
, regs
);
98 buf
= append_elf_note(buf
, "CORE", NT_PRSTATUS
, &prstatus
,
104 static atomic_t enter_on_soft_reset
= ATOMIC_INIT(0);
106 void crash_ipi_callback(struct pt_regs
*regs
)
108 int cpu
= smp_processor_id();
110 if (!cpu_online(cpu
))
114 if (!cpu_isset(cpu
, cpus_in_crash
))
115 crash_save_this_cpu(regs
, cpu
);
116 cpu_set(cpu
, cpus_in_crash
);
119 * Entered via soft-reset - could be the kdump
120 * process is invoked using soft-reset or user activated
121 * it if some CPU did not respond to an IPI.
122 * For soft-reset, the secondary CPU can enter this func
123 * twice. 1 - using IPI, and 2. soft-reset.
124 * Tell the kexec CPU that entered via soft-reset and ready
127 if (cpu_isset(cpu
, cpus_in_sr
)) {
128 cpu_clear(cpu
, cpus_in_sr
);
129 atomic_inc(&enter_on_soft_reset
);
133 * Starting the kdump boot.
134 * This barrier is needed to make sure that all CPUs are stopped.
135 * If not, soft-reset will be invoked to bring other CPUs.
137 while (!cpu_isset(crashing_cpu
, cpus_in_crash
))
140 if (ppc_md
.kexec_cpu_down
)
141 ppc_md
.kexec_cpu_down(1, 1);
147 * Wait until all CPUs are entered via soft-reset.
149 static void crash_soft_reset_check(int cpu
)
151 unsigned int ncpus
= num_online_cpus() - 1;/* Excluding the panic cpu */
153 cpu_clear(cpu
, cpus_in_sr
);
154 while (atomic_read(&enter_on_soft_reset
) != ncpus
)
159 static void crash_kexec_prepare_cpus(int cpu
)
163 unsigned int ncpus
= num_online_cpus() - 1;/* Excluding the panic cpu */
165 crash_send_ipi(crash_ipi_callback
);
169 * FIXME: Until we will have the way to stop other CPUSs reliabally,
170 * the crash CPU will send an IPI and wait for other CPUs to
172 * Delay of at least 10 seconds.
174 printk(KERN_EMERG
"Sending IPI to other cpus...\n");
176 while ((cpus_weight(cpus_in_crash
) < ncpus
) && (--msecs
> 0)) {
181 /* Would it be better to replace the trap vector here? */
184 * FIXME: In case if we do not get all CPUs, one possibility: ask the
185 * user to do soft reset such that we get all.
186 * Soft-reset will be used until better mechanism is implemented.
188 if (cpus_weight(cpus_in_crash
) < ncpus
) {
189 printk(KERN_EMERG
"done waiting: %d cpu(s) not responding\n",
190 ncpus
- cpus_weight(cpus_in_crash
));
191 printk(KERN_EMERG
"Activate soft-reset to stop other cpu(s)\n");
192 cpus_in_sr
= CPU_MASK_NONE
;
193 atomic_set(&enter_on_soft_reset
, 0);
194 while (cpus_weight(cpus_in_crash
) < ncpus
)
198 * Make sure all CPUs are entered via soft-reset if the kdump is
199 * invoked using soft-reset.
201 if (cpu_isset(cpu
, cpus_in_sr
))
202 crash_soft_reset_check(cpu
);
203 /* Leave the IPI callback set */
207 * This function will be called by secondary cpus or by kexec cpu
208 * if soft-reset is activated to stop some CPUs.
210 void crash_kexec_secondary(struct pt_regs
*regs
)
212 int cpu
= smp_processor_id();
216 local_irq_save(flags
);
217 /* Wait 5ms if the kexec CPU is not entered yet. */
218 while (crashing_cpu
< 0) {
221 * Either kdump image is not loaded or
222 * kdump process is not started - Probably xmon
223 * exited using 'x'(exit and recover) or
224 * kexec_should_crash() failed for all running tasks.
226 cpu_clear(cpu
, cpus_in_sr
);
227 local_irq_restore(flags
);
233 if (cpu
== crashing_cpu
) {
235 * Panic CPU will enter this func only via soft-reset.
236 * Wait until all secondary CPUs entered and
237 * then start kexec boot.
239 crash_soft_reset_check(cpu
);
240 cpu_set(crashing_cpu
, cpus_in_crash
);
241 if (ppc_md
.kexec_cpu_down
)
242 ppc_md
.kexec_cpu_down(1, 0);
243 machine_kexec(kexec_crash_image
);
246 crash_ipi_callback(regs
);
250 static void crash_kexec_prepare_cpus(int cpu
)
253 * move the secondarys to us so that we can copy
254 * the new kernel 0-0x100 safely
256 * do this if kexec in setup.c ?
261 void crash_kexec_secondary(struct pt_regs
*regs
)
263 cpus_in_sr
= CPU_MASK_NONE
;
267 void default_machine_crash_shutdown(struct pt_regs
*regs
)
272 * This function is only called after the system
273 * has panicked or is otherwise in a critical state.
274 * The minimum amount of code to allow a kexec'd kernel
275 * to run successfully needs to happen here.
277 * In practice this means stopping other cpus in
279 * The kernel is broken so disable interrupts.
284 struct irq_desc
*desc
= irq_descp(irq
);
286 if (desc
->status
& IRQ_INPROGRESS
)
287 desc
->handler
->end(irq
);
289 if (!(desc
->status
& IRQ_DISABLED
))
290 desc
->handler
->disable(irq
);
294 * Make a note of crashing cpu. Will be used in machine_kexec
295 * such that another IPI will not be sent.
297 crashing_cpu
= smp_processor_id();
298 crash_save_this_cpu(regs
, crashing_cpu
);
299 crash_kexec_prepare_cpus(crashing_cpu
);
300 cpu_set(crashing_cpu
, cpus_in_crash
);
301 if (ppc_md
.kexec_cpu_down
)
302 ppc_md
.kexec_cpu_down(1, 0);