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