Merge master.kernel.org:/pub/scm/linux/kernel/git/mchehab/v4l-dvb
[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 = &crash_notes[cpu][0];
88         memset(&prstatus, 0, sizeof(prstatus));
89         prstatus.pr_pid = current->pid;
90         elf_core_copy_regs(&prstatus.pr_reg, regs);
91         buf = append_elf_note(buf, "CORE", NT_PRSTATUS, &prstatus,
92                         sizeof(prstatus));
93         final_note(buf);
94 }
95
96 /* FIXME Merge this with xmon_save_regs ?? */
97 static inline void crash_get_current_regs(struct pt_regs *regs)
98 {
99         unsigned long tmp1, tmp2;
100
101         __asm__ __volatile__ (
102                 "std    0,0(%2)\n"
103                 "std    1,8(%2)\n"
104                 "std    2,16(%2)\n"
105                 "std    3,24(%2)\n"
106                 "std    4,32(%2)\n"
107                 "std    5,40(%2)\n"
108                 "std    6,48(%2)\n"
109                 "std    7,56(%2)\n"
110                 "std    8,64(%2)\n"
111                 "std    9,72(%2)\n"
112                 "std    10,80(%2)\n"
113                 "std    11,88(%2)\n"
114                 "std    12,96(%2)\n"
115                 "std    13,104(%2)\n"
116                 "std    14,112(%2)\n"
117                 "std    15,120(%2)\n"
118                 "std    16,128(%2)\n"
119                 "std    17,136(%2)\n"
120                 "std    18,144(%2)\n"
121                 "std    19,152(%2)\n"
122                 "std    20,160(%2)\n"
123                 "std    21,168(%2)\n"
124                 "std    22,176(%2)\n"
125                 "std    23,184(%2)\n"
126                 "std    24,192(%2)\n"
127                 "std    25,200(%2)\n"
128                 "std    26,208(%2)\n"
129                 "std    27,216(%2)\n"
130                 "std    28,224(%2)\n"
131                 "std    29,232(%2)\n"
132                 "std    30,240(%2)\n"
133                 "std    31,248(%2)\n"
134                 "mfmsr  %0\n"
135                 "std    %0, 264(%2)\n"
136                 "mfctr  %0\n"
137                 "std    %0, 280(%2)\n"
138                 "mflr   %0\n"
139                 "std    %0, 288(%2)\n"
140                 "bl     1f\n"
141         "1:      mflr   %1\n"
142                 "std    %1, 256(%2)\n"
143                 "mtlr   %0\n"
144                 "mfxer  %0\n"
145                 "std    %0, 296(%2)\n"
146                 : "=&r" (tmp1), "=&r" (tmp2)
147                 : "b" (regs));
148 }
149
150 /* We may have saved_regs from where the error came from
151  * or it is NULL if via a direct panic().
152  */
153 static void crash_save_self(struct pt_regs *saved_regs)
154 {
155         struct pt_regs regs;
156         int cpu;
157
158         cpu = smp_processor_id();
159         if (saved_regs)
160                 memcpy(&regs, saved_regs, sizeof(regs));
161         else
162                 crash_get_current_regs(&regs);
163         crash_save_this_cpu(&regs, cpu);
164 }
165
166 #ifdef CONFIG_SMP
167 static atomic_t waiting_for_crash_ipi;
168
169 void crash_ipi_callback(struct pt_regs *regs)
170 {
171         int cpu = smp_processor_id();
172
173         if (cpu == crashing_cpu)
174                 return;
175
176         if (!cpu_online(cpu))
177                 return;
178
179         if (ppc_md.kexec_cpu_down)
180                 ppc_md.kexec_cpu_down(1, 1);
181
182         local_irq_disable();
183
184         crash_save_this_cpu(regs, cpu);
185         atomic_dec(&waiting_for_crash_ipi);
186         kexec_smp_wait();
187         /* NOTREACHED */
188 }
189
190 static void crash_kexec_prepare_cpus(void)
191 {
192         unsigned int msecs;
193
194         atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
195
196         crash_send_ipi(crash_ipi_callback);
197         smp_wmb();
198
199         /*
200          * FIXME: Until we will have the way to stop other CPUSs reliabally,
201          * the crash CPU will send an IPI and wait for other CPUs to
202          * respond. If not, proceed the kexec boot even though we failed to
203          * capture other CPU states.
204          */
205         msecs = 1000000;
206         while ((atomic_read(&waiting_for_crash_ipi) > 0) && (--msecs > 0)) {
207                 barrier();
208                 mdelay(1);
209         }
210
211         /* Would it be better to replace the trap vector here? */
212
213         /*
214          * FIXME: In case if we do not get all CPUs, one possibility: ask the
215          * user to do soft reset such that we get all.
216          * IPI handler is already set by the panic cpu initially. Therefore,
217          * all cpus could invoke this handler from die() and the panic CPU
218          * will call machine_kexec() directly from this handler to do
219          * kexec boot.
220          */
221         if (atomic_read(&waiting_for_crash_ipi))
222                 printk(KERN_ALERT "done waiting: %d cpus not responding\n",
223                         atomic_read(&waiting_for_crash_ipi));
224         /* Leave the IPI callback set */
225 }
226 #else
227 static void crash_kexec_prepare_cpus(void)
228 {
229         /*
230          * move the secondarys to us so that we can copy
231          * the new kernel 0-0x100 safely
232          *
233          * do this if kexec in setup.c ?
234          */
235         smp_release_cpus();
236 }
237
238 #endif
239
240 void default_machine_crash_shutdown(struct pt_regs *regs)
241 {
242         /*
243          * This function is only called after the system
244          * has paniced or is otherwise in a critical state.
245          * The minimum amount of code to allow a kexec'd kernel
246          * to run successfully needs to happen here.
247          *
248          * In practice this means stopping other cpus in
249          * an SMP system.
250          * The kernel is broken so disable interrupts.
251          */
252         local_irq_disable();
253
254         if (ppc_md.kexec_cpu_down)
255                 ppc_md.kexec_cpu_down(1, 0);
256
257         /*
258          * Make a note of crashing cpu. Will be used in machine_kexec
259          * such that another IPI will not be sent.
260          */
261         crashing_cpu = smp_processor_id();
262         crash_kexec_prepare_cpus();
263         crash_save_self(regs);
264 }