2005-12-04 07:39:43 +00:00
|
|
|
/*
|
|
|
|
* Architecture specific (PPC64) functions for kexec based crash dumps.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005, IBM Corp.
|
|
|
|
*
|
|
|
|
* Created by: Haren Myneni
|
|
|
|
*
|
|
|
|
* This source code is licensed under the GNU General Public License,
|
|
|
|
* Version 2. See the file COPYING for more details.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#undef DEBUG
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/kexec.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/crash_dump.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/elf.h>
|
|
|
|
#include <linux/elfcore.h>
|
|
|
|
#include <linux/init.h>
|
2006-04-04 11:43:01 +00:00
|
|
|
#include <linux/irq.h>
|
2005-12-04 07:39:43 +00:00
|
|
|
#include <linux/types.h>
|
2010-07-12 04:36:09 +00:00
|
|
|
#include <linux/memblock.h>
|
2005-12-04 07:39:43 +00:00
|
|
|
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/machdep.h>
|
2006-06-23 22:29:34 +00:00
|
|
|
#include <asm/kexec.h>
|
2005-12-04 07:39:43 +00:00
|
|
|
#include <asm/kdump.h>
|
2008-02-14 00:56:49 +00:00
|
|
|
#include <asm/prom.h>
|
2005-12-04 07:39:43 +00:00
|
|
|
#include <asm/firmware.h>
|
2006-01-11 03:25:25 +00:00
|
|
|
#include <asm/smp.h>
|
2008-01-18 04:50:30 +00:00
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/setjmp.h>
|
2005-12-04 07:39:43 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
#include <asm/udbg.h>
|
|
|
|
#define DBG(fmt...) udbg_printf(fmt)
|
|
|
|
#else
|
|
|
|
#define DBG(fmt...)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* This keeps a track of which one is crashing cpu. */
|
|
|
|
int crashing_cpu = -1;
|
2006-06-23 22:29:34 +00:00
|
|
|
static cpumask_t cpus_in_crash = CPU_MASK_NONE;
|
2006-07-05 04:39:43 +00:00
|
|
|
cpumask_t cpus_in_sr = CPU_MASK_NONE;
|
2005-12-04 07:39:43 +00:00
|
|
|
|
2011-01-21 02:43:59 +00:00
|
|
|
#define CRASH_HANDLER_MAX 3
|
2008-01-18 04:50:30 +00:00
|
|
|
/* NULL terminated list of shutdown handles */
|
|
|
|
static crash_shutdown_t crash_shutdown_handles[CRASH_HANDLER_MAX+1];
|
|
|
|
static DEFINE_SPINLOCK(crash_handlers_lock);
|
|
|
|
|
2005-12-04 07:39:43 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2006-06-23 22:29:34 +00:00
|
|
|
static atomic_t enter_on_soft_reset = ATOMIC_INIT(0);
|
2005-12-04 07:39:43 +00:00
|
|
|
|
|
|
|
void crash_ipi_callback(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
if (!cpu_online(cpu))
|
|
|
|
return;
|
|
|
|
|
[POWERPC] Lazy interrupt disabling for 64-bit machines
This implements a lazy strategy for disabling interrupts. This means
that local_irq_disable() et al. just clear the 'interrupts are
enabled' flag in the paca. If an interrupt comes along, the interrupt
entry code notices that interrupts are supposed to be disabled, and
clears the EE bit in SRR1, clears the 'interrupts are hard-enabled'
flag in the paca, and returns. This means that interrupts only
actually get disabled in the processor when an interrupt comes along.
When interrupts are enabled by local_irq_enable() et al., the code
sets the interrupts-enabled flag in the paca, and then checks whether
interrupts got hard-disabled. If so, it also sets the EE bit in the
MSR to hard-enable the interrupts.
This has the potential to improve performance, and also makes it
easier to make a kernel that can boot on iSeries and on other 64-bit
machines, since this lazy-disable strategy is very similar to the
soft-disable strategy that iSeries already uses.
This version renames paca->proc_enabled to paca->soft_enabled, and
changes a couple of soft-disables in the kexec code to hard-disables,
which should fix the crash that Michael Ellerman saw. This doesn't
yet use a reserved CR field for the soft_enabled and hard_enabled
flags. This applies on top of Stephen Rothwell's patches to make it
possible to build a combined iSeries/other kernel.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-10-04 06:47:49 +00:00
|
|
|
hard_irq_disable();
|
2006-06-23 22:29:34 +00:00
|
|
|
if (!cpu_isset(cpu, cpus_in_crash))
|
2006-12-07 04:40:41 +00:00
|
|
|
crash_save_cpu(regs, cpu);
|
2006-06-23 22:29:34 +00:00
|
|
|
cpu_set(cpu, cpus_in_crash);
|
2005-12-04 07:39:43 +00:00
|
|
|
|
2006-06-23 22:29:34 +00:00
|
|
|
/*
|
|
|
|
* Entered via soft-reset - could be the kdump
|
|
|
|
* process is invoked using soft-reset or user activated
|
|
|
|
* it if some CPU did not respond to an IPI.
|
|
|
|
* For soft-reset, the secondary CPU can enter this func
|
|
|
|
* twice. 1 - using IPI, and 2. soft-reset.
|
|
|
|
* Tell the kexec CPU that entered via soft-reset and ready
|
|
|
|
* to go down.
|
|
|
|
*/
|
|
|
|
if (cpu_isset(cpu, cpus_in_sr)) {
|
|
|
|
cpu_clear(cpu, cpus_in_sr);
|
|
|
|
atomic_inc(&enter_on_soft_reset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Starting the kdump boot.
|
|
|
|
* This barrier is needed to make sure that all CPUs are stopped.
|
|
|
|
* If not, soft-reset will be invoked to bring other CPUs.
|
|
|
|
*/
|
|
|
|
while (!cpu_isset(crashing_cpu, cpus_in_crash))
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
if (ppc_md.kexec_cpu_down)
|
|
|
|
ppc_md.kexec_cpu_down(1, 1);
|
2006-07-05 04:39:43 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
2005-12-04 07:39:43 +00:00
|
|
|
kexec_smp_wait();
|
2006-07-05 04:39:43 +00:00
|
|
|
#else
|
|
|
|
for (;;); /* FIXME */
|
|
|
|
#endif
|
|
|
|
|
2005-12-04 07:39:43 +00:00
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
|
2006-06-23 22:29:34 +00:00
|
|
|
/*
|
|
|
|
* Wait until all CPUs are entered via soft-reset.
|
|
|
|
*/
|
|
|
|
static void crash_soft_reset_check(int cpu)
|
|
|
|
{
|
|
|
|
unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
|
|
|
|
|
|
|
|
cpu_clear(cpu, cpus_in_sr);
|
|
|
|
while (atomic_read(&enter_on_soft_reset) != ncpus)
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void crash_kexec_prepare_cpus(int cpu)
|
2005-12-04 07:39:43 +00:00
|
|
|
{
|
|
|
|
unsigned int msecs;
|
|
|
|
|
2006-06-23 22:29:34 +00:00
|
|
|
unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
|
2005-12-04 07:39:43 +00:00
|
|
|
|
|
|
|
crash_send_ipi(crash_ipi_callback);
|
|
|
|
smp_wmb();
|
|
|
|
|
|
|
|
/*
|
2011-01-21 02:43:59 +00:00
|
|
|
* FIXME: Until we will have the way to stop other CPUs reliably,
|
2005-12-04 07:39:43 +00:00
|
|
|
* the crash CPU will send an IPI and wait for other CPUs to
|
2006-06-23 22:29:34 +00:00
|
|
|
* respond.
|
2006-02-07 23:47:03 +00:00
|
|
|
* Delay of at least 10 seconds.
|
2005-12-04 07:39:43 +00:00
|
|
|
*/
|
2006-06-23 22:29:34 +00:00
|
|
|
printk(KERN_EMERG "Sending IPI to other cpus...\n");
|
2006-02-07 23:47:03 +00:00
|
|
|
msecs = 10000;
|
2006-06-23 22:29:34 +00:00
|
|
|
while ((cpus_weight(cpus_in_crash) < ncpus) && (--msecs > 0)) {
|
|
|
|
cpu_relax();
|
2005-12-04 07:39:43 +00:00
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Would it be better to replace the trap vector here? */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: In case if we do not get all CPUs, one possibility: ask the
|
|
|
|
* user to do soft reset such that we get all.
|
2006-06-23 22:29:34 +00:00
|
|
|
* Soft-reset will be used until better mechanism is implemented.
|
|
|
|
*/
|
|
|
|
if (cpus_weight(cpus_in_crash) < ncpus) {
|
|
|
|
printk(KERN_EMERG "done waiting: %d cpu(s) not responding\n",
|
|
|
|
ncpus - cpus_weight(cpus_in_crash));
|
|
|
|
printk(KERN_EMERG "Activate soft-reset to stop other cpu(s)\n");
|
|
|
|
cpus_in_sr = CPU_MASK_NONE;
|
|
|
|
atomic_set(&enter_on_soft_reset, 0);
|
|
|
|
while (cpus_weight(cpus_in_crash) < ncpus)
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Make sure all CPUs are entered via soft-reset if the kdump is
|
|
|
|
* invoked using soft-reset.
|
2005-12-04 07:39:43 +00:00
|
|
|
*/
|
2006-06-23 22:29:34 +00:00
|
|
|
if (cpu_isset(cpu, cpus_in_sr))
|
|
|
|
crash_soft_reset_check(cpu);
|
2005-12-04 07:39:43 +00:00
|
|
|
/* Leave the IPI callback set */
|
|
|
|
}
|
2006-06-23 22:29:34 +00:00
|
|
|
|
2010-05-13 19:40:11 +00:00
|
|
|
/* wait for all the CPUs to hit real mode but timeout if they don't come in */
|
2011-04-13 06:30:08 +00:00
|
|
|
#ifdef CONFIG_PPC_STD_MMU_64
|
2010-05-13 19:40:11 +00:00
|
|
|
static void crash_kexec_wait_realmode(int cpu)
|
|
|
|
{
|
|
|
|
unsigned int msecs;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
msecs = 10000;
|
|
|
|
for (i=0; i < NR_CPUS && msecs > 0; i++) {
|
|
|
|
if (i == cpu)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
while (paca[i].kexec_state < KEXEC_STATE_REAL_MODE) {
|
|
|
|
barrier();
|
|
|
|
if (!cpu_possible(i)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!cpu_online(i)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
msecs--;
|
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mb();
|
|
|
|
}
|
2011-04-13 06:30:08 +00:00
|
|
|
#endif /* CONFIG_PPC_STD_MMU_64 */
|
2010-05-13 19:40:11 +00:00
|
|
|
|
2006-06-23 22:29:34 +00:00
|
|
|
/*
|
|
|
|
* This function will be called by secondary cpus or by kexec cpu
|
|
|
|
* if soft-reset is activated to stop some CPUs.
|
|
|
|
*/
|
|
|
|
void crash_kexec_secondary(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
unsigned long flags;
|
|
|
|
int msecs = 5;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
/* Wait 5ms if the kexec CPU is not entered yet. */
|
|
|
|
while (crashing_cpu < 0) {
|
|
|
|
if (--msecs < 0) {
|
|
|
|
/*
|
|
|
|
* Either kdump image is not loaded or
|
|
|
|
* kdump process is not started - Probably xmon
|
|
|
|
* exited using 'x'(exit and recover) or
|
|
|
|
* kexec_should_crash() failed for all running tasks.
|
|
|
|
*/
|
|
|
|
cpu_clear(cpu, cpus_in_sr);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
mdelay(1);
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
if (cpu == crashing_cpu) {
|
|
|
|
/*
|
|
|
|
* Panic CPU will enter this func only via soft-reset.
|
|
|
|
* Wait until all secondary CPUs entered and
|
|
|
|
* then start kexec boot.
|
|
|
|
*/
|
|
|
|
crash_soft_reset_check(cpu);
|
|
|
|
cpu_set(crashing_cpu, cpus_in_crash);
|
|
|
|
if (ppc_md.kexec_cpu_down)
|
|
|
|
ppc_md.kexec_cpu_down(1, 0);
|
|
|
|
machine_kexec(kexec_crash_image);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
crash_ipi_callback(regs);
|
|
|
|
}
|
|
|
|
|
2011-04-13 06:30:08 +00:00
|
|
|
#else /* ! CONFIG_SMP */
|
|
|
|
static inline void crash_kexec_wait_realmode(int cpu) {}
|
|
|
|
|
2006-06-23 22:29:34 +00:00
|
|
|
static void crash_kexec_prepare_cpus(int cpu)
|
2005-12-04 07:39:43 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* move the secondarys to us so that we can copy
|
|
|
|
* the new kernel 0-0x100 safely
|
|
|
|
*
|
|
|
|
* do this if kexec in setup.c ?
|
|
|
|
*/
|
2006-07-05 04:39:43 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-12-04 07:39:43 +00:00
|
|
|
smp_release_cpus();
|
2006-07-05 04:39:43 +00:00
|
|
|
#else
|
|
|
|
/* FIXME */
|
|
|
|
#endif
|
2005-12-04 07:39:43 +00:00
|
|
|
}
|
|
|
|
|
2006-06-23 22:29:34 +00:00
|
|
|
void crash_kexec_secondary(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
cpus_in_sr = CPU_MASK_NONE;
|
|
|
|
}
|
2011-04-13 06:30:08 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
2005-12-04 07:39:43 +00:00
|
|
|
|
2008-01-18 04:50:30 +00:00
|
|
|
/*
|
|
|
|
* Register a function to be called on shutdown. Only use this if you
|
|
|
|
* can't reset your device in the second kernel.
|
|
|
|
*/
|
|
|
|
int crash_shutdown_register(crash_shutdown_t handler)
|
|
|
|
{
|
|
|
|
unsigned int i, rc;
|
|
|
|
|
|
|
|
spin_lock(&crash_handlers_lock);
|
|
|
|
for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
|
|
|
|
if (!crash_shutdown_handles[i]) {
|
|
|
|
/* Insert handle at first empty entry */
|
|
|
|
crash_shutdown_handles[i] = handler;
|
|
|
|
rc = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == CRASH_HANDLER_MAX) {
|
|
|
|
printk(KERN_ERR "Crash shutdown handles full, "
|
|
|
|
"not registered.\n");
|
|
|
|
rc = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&crash_handlers_lock);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(crash_shutdown_register);
|
|
|
|
|
|
|
|
int crash_shutdown_unregister(crash_shutdown_t handler)
|
|
|
|
{
|
|
|
|
unsigned int i, rc;
|
|
|
|
|
|
|
|
spin_lock(&crash_handlers_lock);
|
|
|
|
for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
|
|
|
|
if (crash_shutdown_handles[i] == handler)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (i == CRASH_HANDLER_MAX) {
|
|
|
|
printk(KERN_ERR "Crash shutdown handle not found\n");
|
|
|
|
rc = 1;
|
|
|
|
} else {
|
|
|
|
/* Shift handles down */
|
|
|
|
for (; crash_shutdown_handles[i]; i++)
|
|
|
|
crash_shutdown_handles[i] =
|
|
|
|
crash_shutdown_handles[i+1];
|
|
|
|
rc = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&crash_handlers_lock);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(crash_shutdown_unregister);
|
|
|
|
|
|
|
|
static unsigned long crash_shutdown_buf[JMP_BUF_LEN];
|
2010-05-10 16:25:51 +00:00
|
|
|
static int crash_shutdown_cpu = -1;
|
2008-01-18 04:50:30 +00:00
|
|
|
|
|
|
|
static int handle_fault(struct pt_regs *regs)
|
|
|
|
{
|
2010-05-10 16:25:51 +00:00
|
|
|
if (crash_shutdown_cpu == smp_processor_id())
|
|
|
|
longjmp(crash_shutdown_buf, 1);
|
2008-01-18 04:50:30 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-04 07:39:43 +00:00
|
|
|
void default_machine_crash_shutdown(struct pt_regs *regs)
|
|
|
|
{
|
2008-01-18 04:50:30 +00:00
|
|
|
unsigned int i;
|
|
|
|
int (*old_handler)(struct pt_regs *regs);
|
|
|
|
|
2006-04-04 11:43:01 +00:00
|
|
|
|
2005-12-04 07:39:43 +00:00
|
|
|
/*
|
|
|
|
* This function is only called after the system
|
2006-06-26 16:30:00 +00:00
|
|
|
* has panicked or is otherwise in a critical state.
|
2005-12-04 07:39:43 +00:00
|
|
|
* The minimum amount of code to allow a kexec'd kernel
|
|
|
|
* to run successfully needs to happen here.
|
|
|
|
*
|
|
|
|
* In practice this means stopping other cpus in
|
|
|
|
* an SMP system.
|
|
|
|
* The kernel is broken so disable interrupts.
|
|
|
|
*/
|
[POWERPC] Lazy interrupt disabling for 64-bit machines
This implements a lazy strategy for disabling interrupts. This means
that local_irq_disable() et al. just clear the 'interrupts are
enabled' flag in the paca. If an interrupt comes along, the interrupt
entry code notices that interrupts are supposed to be disabled, and
clears the EE bit in SRR1, clears the 'interrupts are hard-enabled'
flag in the paca, and returns. This means that interrupts only
actually get disabled in the processor when an interrupt comes along.
When interrupts are enabled by local_irq_enable() et al., the code
sets the interrupts-enabled flag in the paca, and then checks whether
interrupts got hard-disabled. If so, it also sets the EE bit in the
MSR to hard-enable the interrupts.
This has the potential to improve performance, and also makes it
easier to make a kernel that can boot on iSeries and on other 64-bit
machines, since this lazy-disable strategy is very similar to the
soft-disable strategy that iSeries already uses.
This version renames paca->proc_enabled to paca->soft_enabled, and
changes a couple of soft-disables in the kexec code to hard-disables,
which should fix the crash that Michael Ellerman saw. This doesn't
yet use a reserved CR field for the soft_enabled and hard_enabled
flags. This applies on top of Stephen Rothwell's patches to make it
possible to build a combined iSeries/other kernel.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-10-04 06:47:49 +00:00
|
|
|
hard_irq_disable();
|
2005-12-04 07:39:43 +00:00
|
|
|
|
2010-08-02 20:39:41 +00:00
|
|
|
/*
|
|
|
|
* Make a note of crashing cpu. Will be used in machine_kexec
|
|
|
|
* such that another IPI will not be sent.
|
|
|
|
*/
|
|
|
|
crashing_cpu = smp_processor_id();
|
|
|
|
crash_save_cpu(regs, crashing_cpu);
|
|
|
|
crash_kexec_prepare_cpus(crashing_cpu);
|
|
|
|
cpu_set(crashing_cpu, cpus_in_crash);
|
|
|
|
crash_kexec_wait_realmode(crashing_cpu);
|
|
|
|
|
2010-09-16 22:58:23 +00:00
|
|
|
machine_kexec_mask_interrupts();
|
2008-01-18 04:50:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Call registered shutdown routines savely. Swap out
|
|
|
|
* __debugger_fault_handler, and replace on exit.
|
|
|
|
*/
|
|
|
|
old_handler = __debugger_fault_handler;
|
|
|
|
__debugger_fault_handler = handle_fault;
|
2010-05-10 16:25:51 +00:00
|
|
|
crash_shutdown_cpu = smp_processor_id();
|
2008-01-18 04:50:30 +00:00
|
|
|
for (i = 0; crash_shutdown_handles[i]; i++) {
|
|
|
|
if (setjmp(crash_shutdown_buf) == 0) {
|
|
|
|
/*
|
|
|
|
* Insert syncs and delay to ensure
|
|
|
|
* instructions in the dangerous region don't
|
|
|
|
* leak away from this protected region.
|
|
|
|
*/
|
|
|
|
asm volatile("sync; isync");
|
|
|
|
/* dangerous region */
|
|
|
|
crash_shutdown_handles[i]();
|
|
|
|
asm volatile("sync; isync");
|
|
|
|
}
|
2006-04-04 11:43:01 +00:00
|
|
|
}
|
2010-05-10 16:25:51 +00:00
|
|
|
crash_shutdown_cpu = -1;
|
2008-01-18 04:50:30 +00:00
|
|
|
__debugger_fault_handler = old_handler;
|
2006-04-04 11:43:01 +00:00
|
|
|
|
2006-06-23 22:29:34 +00:00
|
|
|
if (ppc_md.kexec_cpu_down)
|
|
|
|
ppc_md.kexec_cpu_down(1, 0);
|
2005-12-04 07:39:43 +00:00
|
|
|
}
|