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/export.h>
  21 #include <linux/crash_dump.h>
  22 #include <linux/delay.h>
  23 #include <linux/elf.h>
  24 #include <linux/elfcore.h>
  25 #include <linux/init.h>
  26 #include <linux/irq.h>
  27 #include <linux/types.h>
  28 #include <linux/memblock.h>
  29
  30 #include <asm/processor.h>
  31 #include <asm/machdep.h>
  32 #include <asm/kexec.h>
  33 #include <asm/kdump.h>
  34 #include <asm/prom.h>
  35 #include <asm/firmware.h>
  36 #include <asm/smp.h>
  37 #include <asm/system.h>
  38 #include <asm/setjmp.h>
  39
  40 #ifdef DEBUG
  41 #include <asm/udbg.h>
  42 #define DBG(fmt...) udbg_printf(fmt)
  43 #else
  44 #define DBG(fmt...)
  45 #endif
  46
  47 /* This keeps a track of which one is crashing cpu. */
  48 int crashing_cpu = -1;
  49 static cpumask_t cpus_in_crash = CPU_MASK_NONE;
  50
  51 #define CRASH_HANDLER_MAX 3
  52 /* NULL terminated list of shutdown handles */
  53 static crash_shutdown_t crash_shutdown_handles[CRASH_HANDLER_MAX+1];
  54 static DEFINE_SPINLOCK(crash_handlers_lock);
  55
  56 #ifdef CONFIG_SMP
  57
  58 void crash_ipi_callback(struct pt_regs *regs)
  59 {
  60         int cpu = smp_processor_id();
  61
  62         if (!cpu_online(cpu))
  63                 return;
  64
  65         hard_irq_disable();
  66         if (!cpumask_test_cpu(cpu, &cpus_in_crash))
  67                 crash_save_cpu(regs, cpu);
  68         cpumask_set_cpu(cpu, &cpus_in_crash);
  69
  70         /*
  71          * Starting the kdump boot.
  72          * This barrier is needed to make sure that all CPUs are stopped.
  73          */
  74         while (!cpumask_test_cpu(crashing_cpu, &cpus_in_crash))
  75                 cpu_relax();
  76
  77         if (ppc_md.kexec_cpu_down)
  78                 ppc_md.kexec_cpu_down(1, 1);
  79
  80 #ifdef CONFIG_PPC64
  81         kexec_smp_wait();
  82 #else
  83         for (;;);       /* FIXME */
  84 #endif
  85
  86         /* NOTREACHED */
  87 }
  88
  89 static void crash_kexec_prepare_cpus(int cpu)
  90 {
  91         unsigned int msecs;
  92
  93         unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
  94
  95         printk(KERN_EMERG "Sending IPI to other CPUs\n");
  96
  97         crash_send_ipi(crash_ipi_callback);
  98         smp_wmb();
  99
 100         /*
 101          * FIXME: Until we will have the way to stop other CPUs reliably,
 102          * the crash CPU will send an IPI and wait for other CPUs to
 103          * respond.
 104          * Delay of at least 10 seconds.
 105          */
 106         msecs = 10000;
 107         while ((cpumask_weight(&cpus_in_crash) < ncpus) && (--msecs > 0)) {
 108                 cpu_relax();
 109                 mdelay(1);
 110         }
 111
 112         /* Would it be better to replace the trap vector here? */
 113
 114         if (cpumask_weight(&cpus_in_crash) < ncpus) {
 115                 printk(KERN_EMERG "ERROR: %d CPU(s) not responding\n",
 116                         ncpus - cpumask_weight(&cpus_in_crash));
 117         }
 118
 119         printk(KERN_EMERG "IPI complete\n");
 120 }
 121
 122 /*
 123  * This function will be called by secondary cpus.
 124  */
 125 void crash_kexec_secondary(struct pt_regs *regs)
 126 {
 127         unsigned long flags;
 128         int msecs = 500;
 129
 130         local_irq_save(flags);
 131
 132         /* Wait 500ms for the primary crash CPU to signal its progress */
 133         while (crashing_cpu < 0) {
 134                 if (--msecs < 0) {
 135                         /* No response, kdump image may not have been loaded */
 136                         local_irq_restore(flags);
 137                         return;
 138                 }
 139
 140                 mdelay(1);
 141                 cpu_relax();
 142         }
 143
 144         crash_ipi_callback(regs);
 145 }
 146
 147 #else   /* ! CONFIG_SMP */
 148
 149 static void crash_kexec_prepare_cpus(int cpu)
 150 {
 151         /*
 152          * move the secondarys to us so that we can copy
 153          * the new kernel 0-0x100 safely
 154          *
 155          * do this if kexec in setup.c ?
 156          */
 157 #ifdef CONFIG_PPC64
 158         smp_release_cpus();
 159 #else
 160         /* FIXME */
 161 #endif
 162 }
 163
 164 void crash_kexec_secondary(struct pt_regs *regs)
 165 {
 166 }
 167 #endif  /* CONFIG_SMP */
 168
 169 /* wait for all the CPUs to hit real mode but timeout if they don't come in */
 170 #if defined(CONFIG_SMP) && defined(CONFIG_PPC_STD_MMU_64)
 171 static void crash_kexec_wait_realmode(int cpu)
 172 {
 173         unsigned int msecs;
 174         int i;
 175
 176         msecs = 10000;
 177         for (i=0; i < nr_cpu_ids && msecs > 0; i++) {
 178                 if (i == cpu)
 179                         continue;
 180
 181                 while (paca[i].kexec_state < KEXEC_STATE_REAL_MODE) {
 182                         barrier();
 183                         if (!cpu_possible(i) || !cpu_online(i) || (msecs <= 0))
 184                                 break;
 185                         msecs--;
 186                         mdelay(1);
 187                 }
 188         }
 189         mb();
 190 }
 191 #else
 192 static inline void crash_kexec_wait_realmode(int cpu) {}
 193 #endif  /* CONFIG_SMP && CONFIG_PPC_STD_MMU_64 */
 194
 195 /*
 196  * Register a function to be called on shutdown.  Only use this if you
 197  * can't reset your device in the second kernel.
 198  */
 199 int crash_shutdown_register(crash_shutdown_t handler)
 200 {
 201         unsigned int i, rc;
 202
 203         spin_lock(&crash_handlers_lock);
 204         for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
 205                 if (!crash_shutdown_handles[i]) {
 206                         /* Insert handle at first empty entry */
 207                         crash_shutdown_handles[i] = handler;
 208                         rc = 0;
 209                         break;
 210                 }
 211
 212         if (i == CRASH_HANDLER_MAX) {
 213                 printk(KERN_ERR "Crash shutdown handles full, "
 214                        "not registered.\n");
 215                 rc = 1;
 216         }
 217
 218         spin_unlock(&crash_handlers_lock);
 219         return rc;
 220 }
 221 EXPORT_SYMBOL(crash_shutdown_register);
 222
 223 int crash_shutdown_unregister(crash_shutdown_t handler)
 224 {
 225         unsigned int i, rc;
 226
 227         spin_lock(&crash_handlers_lock);
 228         for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
 229                 if (crash_shutdown_handles[i] == handler)
 230                         break;
 231
 232         if (i == CRASH_HANDLER_MAX) {
 233                 printk(KERN_ERR "Crash shutdown handle not found\n");
 234                 rc = 1;
 235         } else {
 236                 /* Shift handles down */
 237                 for (; crash_shutdown_handles[i]; i++)
 238                         crash_shutdown_handles[i] =
 239                                 crash_shutdown_handles[i+1];
 240                 rc = 0;
 241         }
 242
 243         spin_unlock(&crash_handlers_lock);
 244         return rc;
 245 }
 246 EXPORT_SYMBOL(crash_shutdown_unregister);
 247
 248 static unsigned long crash_shutdown_buf[JMP_BUF_LEN];
 249 static int crash_shutdown_cpu = -1;
 250
 251 static int handle_fault(struct pt_regs *regs)
 252 {
 253         if (crash_shutdown_cpu == smp_processor_id())
 254                 longjmp(crash_shutdown_buf, 1);
 255         return 0;
 256 }
 257
 258 void default_machine_crash_shutdown(struct pt_regs *regs)
 259 {
 260         unsigned int i;
 261         int (*old_handler)(struct pt_regs *regs);
 262
 263
 264         /*
 265          * This function is only called after the system
 266          * has panicked or is otherwise in a critical state.
 267          * The minimum amount of code to allow a kexec'd kernel
 268          * to run successfully needs to happen here.
 269          *
 270          * In practice this means stopping other cpus in
 271          * an SMP system.
 272          * The kernel is broken so disable interrupts.
 273          */
 274         hard_irq_disable();
 275
 276         /*
 277          * Make a note of crashing cpu. Will be used in machine_kexec
 278          * such that another IPI will not be sent.
 279          */
 280         crashing_cpu = smp_processor_id();
 281         crash_save_cpu(regs, crashing_cpu);
 282         crash_kexec_prepare_cpus(crashing_cpu);
 283         cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
 284         crash_kexec_wait_realmode(crashing_cpu);
 285
 286         machine_kexec_mask_interrupts();
 287
 288         /*
 289          * Call registered shutdown routines savely.  Swap out
 290          * __debugger_fault_handler, and replace on exit.
 291          */
 292         old_handler = __debugger_fault_handler;
 293         __debugger_fault_handler = handle_fault;
 294         crash_shutdown_cpu = smp_processor_id();
 295         for (i = 0; crash_shutdown_handles[i]; i++) {
 296                 if (setjmp(crash_shutdown_buf) == 0) {
 297                         /*
 298                          * Insert syncs and delay to ensure
 299                          * instructions in the dangerous region don't
 300                          * leak away from this protected region.
 301                          */
 302                         asm volatile("sync; isync");
 303                         /* dangerous region */
 304                         crash_shutdown_handles[i]();
 305                         asm volatile("sync; isync");
 306                 }
 307         }
 308         crash_shutdown_cpu = -1;
 309         __debugger_fault_handler = old_handler;
 310
 311         if (ppc_md.kexec_cpu_down)
 312                 ppc_md.kexec_cpu_down(1, 0);
 313 }