Pull release into acpica branch
[linux-2.6] / arch / powerpc / kernel / crash.c
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 #undef DEBUG
14
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/types.h>
26
27 #include <asm/processor.h>
28 #include <asm/machdep.h>
29 #include <asm/kdump.h>
30 #include <asm/lmb.h>
31 #include <asm/firmware.h>
32 #include <asm/smp.h>
33
34 #ifdef DEBUG
35 #include <asm/udbg.h>
36 #define DBG(fmt...) udbg_printf(fmt)
37 #else
38 #define DBG(fmt...)
39 #endif
40
41 /* This keeps a track of which one is crashing cpu. */
42 int crashing_cpu = -1;
43
44 static u32 *append_elf_note(u32 *buf, char *name, unsigned type, void *data,
45                                                                size_t data_len)
46 {
47         struct elf_note note;
48
49         note.n_namesz = strlen(name) + 1;
50         note.n_descsz = data_len;
51         note.n_type   = type;
52         memcpy(buf, &note, sizeof(note));
53         buf += (sizeof(note) +3)/4;
54         memcpy(buf, name, note.n_namesz);
55         buf += (note.n_namesz + 3)/4;
56         memcpy(buf, data, note.n_descsz);
57         buf += (note.n_descsz + 3)/4;
58
59         return buf;
60 }
61
62 static void final_note(u32 *buf)
63 {
64         struct elf_note note;
65
66         note.n_namesz = 0;
67         note.n_descsz = 0;
68         note.n_type   = 0;
69         memcpy(buf, &note, sizeof(note));
70 }
71
72 static void crash_save_this_cpu(struct pt_regs *regs, int cpu)
73 {
74         struct elf_prstatus prstatus;
75         u32 *buf;
76
77         if ((cpu < 0) || (cpu >= NR_CPUS))
78                 return;
79
80         /* Using ELF notes here is opportunistic.
81          * I need a well defined structure format
82          * for the data I pass, and I need tags
83          * on the data to indicate what information I have
84          * squirrelled away.  ELF notes happen to provide
85          * all of that that no need to invent something new.
86          */
87         buf = (u32*)per_cpu_ptr(crash_notes, cpu);
88         if (!buf) 
89                 return;
90
91         memset(&prstatus, 0, sizeof(prstatus));
92         prstatus.pr_pid = current->pid;
93         elf_core_copy_regs(&prstatus.pr_reg, regs);
94         buf = append_elf_note(buf, "CORE", NT_PRSTATUS, &prstatus,
95                         sizeof(prstatus));
96         final_note(buf);
97 }
98
99 #ifdef CONFIG_SMP
100 static atomic_t waiting_for_crash_ipi;
101
102 void crash_ipi_callback(struct pt_regs *regs)
103 {
104         int cpu = smp_processor_id();
105
106         if (cpu == crashing_cpu)
107                 return;
108
109         if (!cpu_online(cpu))
110                 return;
111
112         if (ppc_md.kexec_cpu_down)
113                 ppc_md.kexec_cpu_down(1, 1);
114
115         local_irq_disable();
116
117         crash_save_this_cpu(regs, cpu);
118         atomic_dec(&waiting_for_crash_ipi);
119         kexec_smp_wait();
120         /* NOTREACHED */
121 }
122
123 static void crash_kexec_prepare_cpus(void)
124 {
125         unsigned int msecs;
126
127         atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
128
129         crash_send_ipi(crash_ipi_callback);
130         smp_wmb();
131
132         /*
133          * FIXME: Until we will have the way to stop other CPUSs reliabally,
134          * the crash CPU will send an IPI and wait for other CPUs to
135          * respond. If not, proceed the kexec boot even though we failed to
136          * capture other CPU states.
137          */
138         msecs = 1000000;
139         while ((atomic_read(&waiting_for_crash_ipi) > 0) && (--msecs > 0)) {
140                 barrier();
141                 mdelay(1);
142         }
143
144         /* Would it be better to replace the trap vector here? */
145
146         /*
147          * FIXME: In case if we do not get all CPUs, one possibility: ask the
148          * user to do soft reset such that we get all.
149          * IPI handler is already set by the panic cpu initially. Therefore,
150          * all cpus could invoke this handler from die() and the panic CPU
151          * will call machine_kexec() directly from this handler to do
152          * kexec boot.
153          */
154         if (atomic_read(&waiting_for_crash_ipi))
155                 printk(KERN_ALERT "done waiting: %d cpus not responding\n",
156                         atomic_read(&waiting_for_crash_ipi));
157         /* Leave the IPI callback set */
158 }
159 #else
160 static void crash_kexec_prepare_cpus(void)
161 {
162         /*
163          * move the secondarys to us so that we can copy
164          * the new kernel 0-0x100 safely
165          *
166          * do this if kexec in setup.c ?
167          */
168         smp_release_cpus();
169 }
170
171 #endif
172
173 void default_machine_crash_shutdown(struct pt_regs *regs)
174 {
175         /*
176          * This function is only called after the system
177          * has paniced or is otherwise in a critical state.
178          * The minimum amount of code to allow a kexec'd kernel
179          * to run successfully needs to happen here.
180          *
181          * In practice this means stopping other cpus in
182          * an SMP system.
183          * The kernel is broken so disable interrupts.
184          */
185         local_irq_disable();
186
187         if (ppc_md.kexec_cpu_down)
188                 ppc_md.kexec_cpu_down(1, 0);
189
190         /*
191          * Make a note of crashing cpu. Will be used in machine_kexec
192          * such that another IPI will not be sent.
193          */
194         crashing_cpu = smp_processor_id();
195         crash_kexec_prepare_cpus();
196         crash_save_this_cpu(regs, crashing_cpu);
197 }