~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/kernel/crash.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/kernel.h>
 14 #include <linux/smp.h>
 15 #include <linux/reboot.h>
 16 #include <linux/kexec.h>
 17 #include <linux/export.h>
 18 #include <linux/crash_dump.h>
 19 #include <linux/delay.h>
 20 #include <linux/irq.h>
 21 #include <linux/types.h>
 22 
 23 #include <asm/processor.h>
 24 #include <asm/machdep.h>
 25 #include <asm/kexec.h>
 26 #include <asm/kdump.h>
 27 #include <asm/prom.h>
 28 #include <asm/smp.h>
 29 #include <asm/setjmp.h>
 30 #include <asm/debug.h>
 31 
 32 /*
 33  * The primary CPU waits a while for all secondary CPUs to enter. This is to
 34  * avoid sending an IPI if the secondary CPUs are entering
 35  * crash_kexec_secondary on their own (eg via a system reset).
 36  *
 37  * The secondary timeout has to be longer than the primary. Both timeouts are
 38  * in milliseconds.
 39  */
 40 #define PRIMARY_TIMEOUT         500
 41 #define SECONDARY_TIMEOUT       1000
 42 
 43 #define IPI_TIMEOUT             10000
 44 #define REAL_MODE_TIMEOUT       10000
 45 
 46 static int time_to_dump;
 47 /*
 48  * crash_wake_offline should be set to 1 by platforms that intend to wake
 49  * up offline cpus prior to jumping to a kdump kernel. Currently powernv
 50  * sets it to 1, since we want to avoid things from happening when an
 51  * offline CPU wakes up due to something like an HMI (malfunction error),
 52  * which propagates to all threads.
 53  */
 54 int crash_wake_offline;
 55 
 56 #define CRASH_HANDLER_MAX 3
 57 /* List of shutdown handles */
 58 static crash_shutdown_t crash_shutdown_handles[CRASH_HANDLER_MAX];
 59 static DEFINE_SPINLOCK(crash_handlers_lock);
 60 
 61 static unsigned long crash_shutdown_buf[JMP_BUF_LEN];
 62 static int crash_shutdown_cpu = -1;
 63 
 64 static int handle_fault(struct pt_regs *regs)
 65 {
 66         if (crash_shutdown_cpu == smp_processor_id())
 67                 longjmp(crash_shutdown_buf, 1);
 68         return 0;
 69 }
 70 
 71 #ifdef CONFIG_SMP
 72 
 73 static atomic_t cpus_in_crash;
 74 void crash_ipi_callback(struct pt_regs *regs)
 75 {
 76         static cpumask_t cpus_state_saved = CPU_MASK_NONE;
 77 
 78         int cpu = smp_processor_id();
 79 
 80         hard_irq_disable();
 81         if (!cpumask_test_cpu(cpu, &cpus_state_saved)) {
 82                 crash_save_cpu(regs, cpu);
 83                 cpumask_set_cpu(cpu, &cpus_state_saved);
 84         }
 85 
 86         atomic_inc(&cpus_in_crash);
 87         smp_mb__after_atomic();
 88 
 89         /*
 90          * Starting the kdump boot.
 91          * This barrier is needed to make sure that all CPUs are stopped.
 92          */
 93         while (!time_to_dump)
 94                 cpu_relax();
 95 
 96         if (ppc_md.kexec_cpu_down)
 97                 ppc_md.kexec_cpu_down(1, 1);
 98 
 99 #ifdef CONFIG_PPC64
100         kexec_smp_wait();
101 #else
102         for (;;);       /* FIXME */
103 #endif
104 
105         /* NOTREACHED */
106 }
107 
108 static void crash_kexec_prepare_cpus(int cpu)
109 {
110         unsigned int msecs;
111         unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
112         int tries = 0;
113         int (*old_handler)(struct pt_regs *regs);
114 
115         printk(KERN_EMERG "Sending IPI to other CPUs\n");
116 
117         if (crash_wake_offline)
118                 ncpus = num_present_cpus() - 1;
119 
120         crash_send_ipi(crash_ipi_callback);
121         smp_wmb();
122 
123 again:
124         /*
125          * FIXME: Until we will have the way to stop other CPUs reliably,
126          * the crash CPU will send an IPI and wait for other CPUs to
127          * respond.
128          */
129         msecs = IPI_TIMEOUT;
130         while ((atomic_read(&cpus_in_crash) < ncpus) && (--msecs > 0))
131                 mdelay(1);
132 
133         /* Would it be better to replace the trap vector here? */
134 
135         if (atomic_read(&cpus_in_crash) >= ncpus) {
136                 printk(KERN_EMERG "IPI complete\n");
137                 return;
138         }
139 
140         printk(KERN_EMERG "ERROR: %d cpu(s) not responding\n",
141                 ncpus - atomic_read(&cpus_in_crash));
142 
143         /*
144          * If we have a panic timeout set then we can't wait indefinitely
145          * for someone to activate system reset. We also give up on the
146          * second time through if system reset fail to work.
147          */
148         if ((panic_timeout > 0) || (tries > 0))
149                 return;
150 
151         /*
152          * A system reset will cause all CPUs to take an 0x100 exception.
153          * The primary CPU returns here via setjmp, and the secondary
154          * CPUs reexecute the crash_kexec_secondary path.
155          */
156         old_handler = __debugger;
157         __debugger = handle_fault;
158         crash_shutdown_cpu = smp_processor_id();
159 
160         if (setjmp(crash_shutdown_buf) == 0) {
161                 printk(KERN_EMERG "Activate system reset (dumprestart) "
162                                   "to stop other cpu(s)\n");
163 
164                 /*
165                  * A system reset will force all CPUs to execute the
166                  * crash code again. We need to reset cpus_in_crash so we
167                  * wait for everyone to do this.
168                  */
169                 atomic_set(&cpus_in_crash, 0);
170                 smp_mb();
171 
172                 while (atomic_read(&cpus_in_crash) < ncpus)
173                         cpu_relax();
174         }
175 
176         crash_shutdown_cpu = -1;
177         __debugger = old_handler;
178 
179         tries++;
180         goto again;
181 }
182 
183 /*
184  * This function will be called by secondary cpus.
185  */
186 void crash_kexec_secondary(struct pt_regs *regs)
187 {
188         unsigned long flags;
189         int msecs = SECONDARY_TIMEOUT;
190 
191         local_irq_save(flags);
192 
193         /* Wait for the primary crash CPU to signal its progress */
194         while (crashing_cpu < 0) {
195                 if (--msecs < 0) {
196                         /* No response, kdump image may not have been loaded */
197                         local_irq_restore(flags);
198                         return;
199                 }
200 
201                 mdelay(1);
202         }
203 
204         crash_ipi_callback(regs);
205 }
206 
207 #else   /* ! CONFIG_SMP */
208 
209 static void crash_kexec_prepare_cpus(int cpu)
210 {
211         /*
212          * move the secondaries to us so that we can copy
213          * the new kernel 0-0x100 safely
214          *
215          * do this if kexec in setup.c ?
216          */
217 #ifdef CONFIG_PPC64
218         smp_release_cpus();
219 #else
220         /* FIXME */
221 #endif
222 }
223 
224 void crash_kexec_secondary(struct pt_regs *regs)
225 {
226 }
227 #endif  /* CONFIG_SMP */
228 
229 /* wait for all the CPUs to hit real mode but timeout if they don't come in */
230 #if defined(CONFIG_SMP) && defined(CONFIG_PPC64)
231 static void __maybe_unused crash_kexec_wait_realmode(int cpu)
232 {
233         unsigned int msecs;
234         int i;
235 
236         msecs = REAL_MODE_TIMEOUT;
237         for (i=0; i < nr_cpu_ids && msecs > 0; i++) {
238                 if (i == cpu)
239                         continue;
240 
241                 while (paca_ptrs[i]->kexec_state < KEXEC_STATE_REAL_MODE) {
242                         barrier();
243                         if (!cpu_possible(i) || !cpu_online(i) || (msecs <= 0))
244                                 break;
245                         msecs--;
246                         mdelay(1);
247                 }
248         }
249         mb();
250 }
251 #else
252 static inline void crash_kexec_wait_realmode(int cpu) {}
253 #endif  /* CONFIG_SMP && CONFIG_PPC64 */
254 
255 /*
256  * Register a function to be called on shutdown.  Only use this if you
257  * can't reset your device in the second kernel.
258  */
259 int crash_shutdown_register(crash_shutdown_t handler)
260 {
261         unsigned int i, rc;
262 
263         spin_lock(&crash_handlers_lock);
264         for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
265                 if (!crash_shutdown_handles[i]) {
266                         /* Insert handle at first empty entry */
267                         crash_shutdown_handles[i] = handler;
268                         rc = 0;
269                         break;
270                 }
271 
272         if (i == CRASH_HANDLER_MAX) {
273                 printk(KERN_ERR "Crash shutdown handles full, "
274                        "not registered.\n");
275                 rc = 1;
276         }
277 
278         spin_unlock(&crash_handlers_lock);
279         return rc;
280 }
281 EXPORT_SYMBOL(crash_shutdown_register);
282 
283 int crash_shutdown_unregister(crash_shutdown_t handler)
284 {
285         unsigned int i, rc;
286 
287         spin_lock(&crash_handlers_lock);
288         for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
289                 if (crash_shutdown_handles[i] == handler)
290                         break;
291 
292         if (i == CRASH_HANDLER_MAX) {
293                 printk(KERN_ERR "Crash shutdown handle not found\n");
294                 rc = 1;
295         } else {
296                 /* Shift handles down */
297                 for (; i < (CRASH_HANDLER_MAX - 1); i++)
298                         crash_shutdown_handles[i] =
299                                 crash_shutdown_handles[i+1];
300                 /*
301                  * Reset last entry to NULL now that it has been shifted down,
302                  * this will allow new handles to be added here.
303                  */
304                 crash_shutdown_handles[i] = NULL;
305                 rc = 0;
306         }
307 
308         spin_unlock(&crash_handlers_lock);
309         return rc;
310 }
311 EXPORT_SYMBOL(crash_shutdown_unregister);
312 
313 void default_machine_crash_shutdown(struct pt_regs *regs)
314 {
315         unsigned int i;
316         int (*old_handler)(struct pt_regs *regs);
317 
318         /*
319          * This function is only called after the system
320          * has panicked or is otherwise in a critical state.
321          * The minimum amount of code to allow a kexec'd kernel
322          * to run successfully needs to happen here.
323          *
324          * In practice this means stopping other cpus in
325          * an SMP system.
326          * The kernel is broken so disable interrupts.
327          */
328         hard_irq_disable();
329 
330         /*
331          * Make a note of crashing cpu. Will be used in machine_kexec
332          * such that another IPI will not be sent.
333          */
334         crashing_cpu = smp_processor_id();
335 
336         /*
337          * If we came in via system reset, wait a while for the secondary
338          * CPUs to enter.
339          */
340         if (TRAP(regs) == 0x100)
341                 mdelay(PRIMARY_TIMEOUT);
342 
343         crash_kexec_prepare_cpus(crashing_cpu);
344 
345         crash_save_cpu(regs, crashing_cpu);
346 
347         time_to_dump = 1;
348 
349         crash_kexec_wait_realmode(crashing_cpu);
350 
351         machine_kexec_mask_interrupts();
352 
353         /*
354          * Call registered shutdown routines safely.  Swap out
355          * __debugger_fault_handler, and replace on exit.
356          */
357         old_handler = __debugger_fault_handler;
358         __debugger_fault_handler = handle_fault;
359         crash_shutdown_cpu = smp_processor_id();
360         for (i = 0; i < CRASH_HANDLER_MAX && crash_shutdown_handles[i]; i++) {
361                 if (setjmp(crash_shutdown_buf) == 0) {
362                         /*
363                          * Insert syncs and delay to ensure
364                          * instructions in the dangerous region don't
365                          * leak away from this protected region.
366                          */
367                         asm volatile("sync; isync");
368                         /* dangerous region */
369                         crash_shutdown_handles[i]();
370                         asm volatile("sync; isync");
371                 }
372         }
373         crash_shutdown_cpu = -1;
374         __debugger_fault_handler = old_handler;
375 
376         if (ppc_md.kexec_cpu_down)
377                 ppc_md.kexec_cpu_down(1, 0);
378 }
379 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp