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
 46static 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 */
 54int crash_wake_offline;
 55
 56#define CRASH_HANDLER_MAX 3
 57/* List of shutdown handles */
 58static crash_shutdown_t crash_shutdown_handles[CRASH_HANDLER_MAX];
 59static DEFINE_SPINLOCK(crash_handlers_lock);
 60
 61static unsigned long crash_shutdown_buf[JMP_BUF_LEN];
 62static int crash_shutdown_cpu = -1;
 63
 64static 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
 73static atomic_t cpus_in_crash;
 74void 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
108static 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
123again:
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 */
186void 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
209static 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
224void 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)
231static 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
252static 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 */
259int 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}
281EXPORT_SYMBOL(crash_shutdown_register);
282
283int 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}
311EXPORT_SYMBOL(crash_shutdown_unregister);
312
313void 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}