xref: /openbmc/linux/kernel/debug/debug_core.c (revision 4800cd83)
1 /*
2  * Kernel Debug Core
3  *
4  * Maintainer: Jason Wessel <jason.wessel@windriver.com>
5  *
6  * Copyright (C) 2000-2001 VERITAS Software Corporation.
7  * Copyright (C) 2002-2004 Timesys Corporation
8  * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
9  * Copyright (C) 2004 Pavel Machek <pavel@ucw.cz>
10  * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
11  * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
12  * Copyright (C) 2005-2009 Wind River Systems, Inc.
13  * Copyright (C) 2007 MontaVista Software, Inc.
14  * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
15  *
16  * Contributors at various stages not listed above:
17  *  Jason Wessel ( jason.wessel@windriver.com )
18  *  George Anzinger <george@mvista.com>
19  *  Anurekh Saxena (anurekh.saxena@timesys.com)
20  *  Lake Stevens Instrument Division (Glenn Engel)
21  *  Jim Kingdon, Cygnus Support.
22  *
23  * Original KGDB stub: David Grothe <dave@gcom.com>,
24  * Tigran Aivazian <tigran@sco.com>
25  *
26  * This file is licensed under the terms of the GNU General Public License
27  * version 2. This program is licensed "as is" without any warranty of any
28  * kind, whether express or implied.
29  */
30 #include <linux/pid_namespace.h>
31 #include <linux/clocksource.h>
32 #include <linux/interrupt.h>
33 #include <linux/spinlock.h>
34 #include <linux/console.h>
35 #include <linux/threads.h>
36 #include <linux/uaccess.h>
37 #include <linux/kernel.h>
38 #include <linux/module.h>
39 #include <linux/ptrace.h>
40 #include <linux/string.h>
41 #include <linux/delay.h>
42 #include <linux/sched.h>
43 #include <linux/sysrq.h>
44 #include <linux/init.h>
45 #include <linux/kgdb.h>
46 #include <linux/kdb.h>
47 #include <linux/pid.h>
48 #include <linux/smp.h>
49 #include <linux/mm.h>
50 #include <linux/rcupdate.h>
51 
52 #include <asm/cacheflush.h>
53 #include <asm/byteorder.h>
54 #include <asm/atomic.h>
55 #include <asm/system.h>
56 
57 #include "debug_core.h"
58 
59 static int kgdb_break_asap;
60 
61 struct debuggerinfo_struct kgdb_info[NR_CPUS];
62 
63 /**
64  * kgdb_connected - Is a host GDB connected to us?
65  */
66 int				kgdb_connected;
67 EXPORT_SYMBOL_GPL(kgdb_connected);
68 
69 /* All the KGDB handlers are installed */
70 int			kgdb_io_module_registered;
71 
72 /* Guard for recursive entry */
73 static int			exception_level;
74 
75 struct kgdb_io		*dbg_io_ops;
76 static DEFINE_SPINLOCK(kgdb_registration_lock);
77 
78 /* kgdb console driver is loaded */
79 static int kgdb_con_registered;
80 /* determine if kgdb console output should be used */
81 static int kgdb_use_con;
82 /* Flag for alternate operations for early debugging */
83 bool dbg_is_early = true;
84 /* Next cpu to become the master debug core */
85 int dbg_switch_cpu;
86 
87 /* Use kdb or gdbserver mode */
88 int dbg_kdb_mode = 1;
89 
90 static int __init opt_kgdb_con(char *str)
91 {
92 	kgdb_use_con = 1;
93 	return 0;
94 }
95 
96 early_param("kgdbcon", opt_kgdb_con);
97 
98 module_param(kgdb_use_con, int, 0644);
99 
100 /*
101  * Holds information about breakpoints in a kernel. These breakpoints are
102  * added and removed by gdb.
103  */
104 static struct kgdb_bkpt		kgdb_break[KGDB_MAX_BREAKPOINTS] = {
105 	[0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
106 };
107 
108 /*
109  * The CPU# of the active CPU, or -1 if none:
110  */
111 atomic_t			kgdb_active = ATOMIC_INIT(-1);
112 EXPORT_SYMBOL_GPL(kgdb_active);
113 static DEFINE_RAW_SPINLOCK(dbg_master_lock);
114 static DEFINE_RAW_SPINLOCK(dbg_slave_lock);
115 
116 /*
117  * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
118  * bootup code (which might not have percpu set up yet):
119  */
120 static atomic_t			masters_in_kgdb;
121 static atomic_t			slaves_in_kgdb;
122 static atomic_t			kgdb_break_tasklet_var;
123 atomic_t			kgdb_setting_breakpoint;
124 
125 struct task_struct		*kgdb_usethread;
126 struct task_struct		*kgdb_contthread;
127 
128 int				kgdb_single_step;
129 static pid_t			kgdb_sstep_pid;
130 
131 /* to keep track of the CPU which is doing the single stepping*/
132 atomic_t			kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
133 
134 /*
135  * If you are debugging a problem where roundup (the collection of
136  * all other CPUs) is a problem [this should be extremely rare],
137  * then use the nokgdbroundup option to avoid roundup. In that case
138  * the other CPUs might interfere with your debugging context, so
139  * use this with care:
140  */
141 static int kgdb_do_roundup = 1;
142 
143 static int __init opt_nokgdbroundup(char *str)
144 {
145 	kgdb_do_roundup = 0;
146 
147 	return 0;
148 }
149 
150 early_param("nokgdbroundup", opt_nokgdbroundup);
151 
152 /*
153  * Finally, some KGDB code :-)
154  */
155 
156 /*
157  * Weak aliases for breakpoint management,
158  * can be overriden by architectures when needed:
159  */
160 int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
161 {
162 	int err;
163 
164 	err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
165 	if (err)
166 		return err;
167 
168 	return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
169 				  BREAK_INSTR_SIZE);
170 }
171 
172 int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
173 {
174 	return probe_kernel_write((char *)addr,
175 				  (char *)bundle, BREAK_INSTR_SIZE);
176 }
177 
178 int __weak kgdb_validate_break_address(unsigned long addr)
179 {
180 	char tmp_variable[BREAK_INSTR_SIZE];
181 	int err;
182 	/* Validate setting the breakpoint and then removing it.  In the
183 	 * remove fails, the kernel needs to emit a bad message because we
184 	 * are deep trouble not being able to put things back the way we
185 	 * found them.
186 	 */
187 	err = kgdb_arch_set_breakpoint(addr, tmp_variable);
188 	if (err)
189 		return err;
190 	err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
191 	if (err)
192 		printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
193 		   "memory destroyed at: %lx", addr);
194 	return err;
195 }
196 
197 unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
198 {
199 	return instruction_pointer(regs);
200 }
201 
202 int __weak kgdb_arch_init(void)
203 {
204 	return 0;
205 }
206 
207 int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
208 {
209 	return 0;
210 }
211 
212 /*
213  * Some architectures need cache flushes when we set/clear a
214  * breakpoint:
215  */
216 static void kgdb_flush_swbreak_addr(unsigned long addr)
217 {
218 	if (!CACHE_FLUSH_IS_SAFE)
219 		return;
220 
221 	if (current->mm && current->mm->mmap_cache) {
222 		flush_cache_range(current->mm->mmap_cache,
223 				  addr, addr + BREAK_INSTR_SIZE);
224 	}
225 	/* Force flush instruction cache if it was outside the mm */
226 	flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
227 }
228 
229 /*
230  * SW breakpoint management:
231  */
232 int dbg_activate_sw_breakpoints(void)
233 {
234 	unsigned long addr;
235 	int error;
236 	int ret = 0;
237 	int i;
238 
239 	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
240 		if (kgdb_break[i].state != BP_SET)
241 			continue;
242 
243 		addr = kgdb_break[i].bpt_addr;
244 		error = kgdb_arch_set_breakpoint(addr,
245 				kgdb_break[i].saved_instr);
246 		if (error) {
247 			ret = error;
248 			printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
249 			continue;
250 		}
251 
252 		kgdb_flush_swbreak_addr(addr);
253 		kgdb_break[i].state = BP_ACTIVE;
254 	}
255 	return ret;
256 }
257 
258 int dbg_set_sw_break(unsigned long addr)
259 {
260 	int err = kgdb_validate_break_address(addr);
261 	int breakno = -1;
262 	int i;
263 
264 	if (err)
265 		return err;
266 
267 	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
268 		if ((kgdb_break[i].state == BP_SET) &&
269 					(kgdb_break[i].bpt_addr == addr))
270 			return -EEXIST;
271 	}
272 	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
273 		if (kgdb_break[i].state == BP_REMOVED &&
274 					kgdb_break[i].bpt_addr == addr) {
275 			breakno = i;
276 			break;
277 		}
278 	}
279 
280 	if (breakno == -1) {
281 		for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
282 			if (kgdb_break[i].state == BP_UNDEFINED) {
283 				breakno = i;
284 				break;
285 			}
286 		}
287 	}
288 
289 	if (breakno == -1)
290 		return -E2BIG;
291 
292 	kgdb_break[breakno].state = BP_SET;
293 	kgdb_break[breakno].type = BP_BREAKPOINT;
294 	kgdb_break[breakno].bpt_addr = addr;
295 
296 	return 0;
297 }
298 
299 int dbg_deactivate_sw_breakpoints(void)
300 {
301 	unsigned long addr;
302 	int error;
303 	int ret = 0;
304 	int i;
305 
306 	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
307 		if (kgdb_break[i].state != BP_ACTIVE)
308 			continue;
309 		addr = kgdb_break[i].bpt_addr;
310 		error = kgdb_arch_remove_breakpoint(addr,
311 					kgdb_break[i].saved_instr);
312 		if (error) {
313 			printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
314 			ret = error;
315 		}
316 
317 		kgdb_flush_swbreak_addr(addr);
318 		kgdb_break[i].state = BP_SET;
319 	}
320 	return ret;
321 }
322 
323 int dbg_remove_sw_break(unsigned long addr)
324 {
325 	int i;
326 
327 	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
328 		if ((kgdb_break[i].state == BP_SET) &&
329 				(kgdb_break[i].bpt_addr == addr)) {
330 			kgdb_break[i].state = BP_REMOVED;
331 			return 0;
332 		}
333 	}
334 	return -ENOENT;
335 }
336 
337 int kgdb_isremovedbreak(unsigned long addr)
338 {
339 	int i;
340 
341 	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
342 		if ((kgdb_break[i].state == BP_REMOVED) &&
343 					(kgdb_break[i].bpt_addr == addr))
344 			return 1;
345 	}
346 	return 0;
347 }
348 
349 int dbg_remove_all_break(void)
350 {
351 	unsigned long addr;
352 	int error;
353 	int i;
354 
355 	/* Clear memory breakpoints. */
356 	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
357 		if (kgdb_break[i].state != BP_ACTIVE)
358 			goto setundefined;
359 		addr = kgdb_break[i].bpt_addr;
360 		error = kgdb_arch_remove_breakpoint(addr,
361 				kgdb_break[i].saved_instr);
362 		if (error)
363 			printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
364 			   addr);
365 setundefined:
366 		kgdb_break[i].state = BP_UNDEFINED;
367 	}
368 
369 	/* Clear hardware breakpoints. */
370 	if (arch_kgdb_ops.remove_all_hw_break)
371 		arch_kgdb_ops.remove_all_hw_break();
372 
373 	return 0;
374 }
375 
376 /*
377  * Return true if there is a valid kgdb I/O module.  Also if no
378  * debugger is attached a message can be printed to the console about
379  * waiting for the debugger to attach.
380  *
381  * The print_wait argument is only to be true when called from inside
382  * the core kgdb_handle_exception, because it will wait for the
383  * debugger to attach.
384  */
385 static int kgdb_io_ready(int print_wait)
386 {
387 	if (!dbg_io_ops)
388 		return 0;
389 	if (kgdb_connected)
390 		return 1;
391 	if (atomic_read(&kgdb_setting_breakpoint))
392 		return 1;
393 	if (print_wait) {
394 #ifdef CONFIG_KGDB_KDB
395 		if (!dbg_kdb_mode)
396 			printk(KERN_CRIT "KGDB: waiting... or $3#33 for KDB\n");
397 #else
398 		printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
399 #endif
400 	}
401 	return 1;
402 }
403 
404 static int kgdb_reenter_check(struct kgdb_state *ks)
405 {
406 	unsigned long addr;
407 
408 	if (atomic_read(&kgdb_active) != raw_smp_processor_id())
409 		return 0;
410 
411 	/* Panic on recursive debugger calls: */
412 	exception_level++;
413 	addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
414 	dbg_deactivate_sw_breakpoints();
415 
416 	/*
417 	 * If the break point removed ok at the place exception
418 	 * occurred, try to recover and print a warning to the end
419 	 * user because the user planted a breakpoint in a place that
420 	 * KGDB needs in order to function.
421 	 */
422 	if (dbg_remove_sw_break(addr) == 0) {
423 		exception_level = 0;
424 		kgdb_skipexception(ks->ex_vector, ks->linux_regs);
425 		dbg_activate_sw_breakpoints();
426 		printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
427 			addr);
428 		WARN_ON_ONCE(1);
429 
430 		return 1;
431 	}
432 	dbg_remove_all_break();
433 	kgdb_skipexception(ks->ex_vector, ks->linux_regs);
434 
435 	if (exception_level > 1) {
436 		dump_stack();
437 		panic("Recursive entry to debugger");
438 	}
439 
440 	printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
441 #ifdef CONFIG_KGDB_KDB
442 	/* Allow kdb to debug itself one level */
443 	return 0;
444 #endif
445 	dump_stack();
446 	panic("Recursive entry to debugger");
447 
448 	return 1;
449 }
450 
451 static void dbg_touch_watchdogs(void)
452 {
453 	touch_softlockup_watchdog_sync();
454 	clocksource_touch_watchdog();
455 	rcu_cpu_stall_reset();
456 }
457 
458 static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,
459 		int exception_state)
460 {
461 	unsigned long flags;
462 	int sstep_tries = 100;
463 	int error;
464 	int cpu;
465 	int trace_on = 0;
466 	int online_cpus = num_online_cpus();
467 
468 	kgdb_info[ks->cpu].enter_kgdb++;
469 	kgdb_info[ks->cpu].exception_state |= exception_state;
470 
471 	if (exception_state == DCPU_WANT_MASTER)
472 		atomic_inc(&masters_in_kgdb);
473 	else
474 		atomic_inc(&slaves_in_kgdb);
475 
476 	if (arch_kgdb_ops.disable_hw_break)
477 		arch_kgdb_ops.disable_hw_break(regs);
478 
479 acquirelock:
480 	/*
481 	 * Interrupts will be restored by the 'trap return' code, except when
482 	 * single stepping.
483 	 */
484 	local_irq_save(flags);
485 
486 	cpu = ks->cpu;
487 	kgdb_info[cpu].debuggerinfo = regs;
488 	kgdb_info[cpu].task = current;
489 	kgdb_info[cpu].ret_state = 0;
490 	kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
491 
492 	/* Make sure the above info reaches the primary CPU */
493 	smp_mb();
494 
495 	if (exception_level == 1) {
496 		if (raw_spin_trylock(&dbg_master_lock))
497 			atomic_xchg(&kgdb_active, cpu);
498 		goto cpu_master_loop;
499 	}
500 
501 	/*
502 	 * CPU will loop if it is a slave or request to become a kgdb
503 	 * master cpu and acquire the kgdb_active lock:
504 	 */
505 	while (1) {
506 cpu_loop:
507 		if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
508 			kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
509 			goto cpu_master_loop;
510 		} else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
511 			if (raw_spin_trylock(&dbg_master_lock)) {
512 				atomic_xchg(&kgdb_active, cpu);
513 				break;
514 			}
515 		} else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
516 			if (!raw_spin_is_locked(&dbg_slave_lock))
517 				goto return_normal;
518 		} else {
519 return_normal:
520 			/* Return to normal operation by executing any
521 			 * hw breakpoint fixup.
522 			 */
523 			if (arch_kgdb_ops.correct_hw_break)
524 				arch_kgdb_ops.correct_hw_break();
525 			if (trace_on)
526 				tracing_on();
527 			kgdb_info[cpu].exception_state &=
528 				~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
529 			kgdb_info[cpu].enter_kgdb--;
530 			smp_mb__before_atomic_dec();
531 			atomic_dec(&slaves_in_kgdb);
532 			dbg_touch_watchdogs();
533 			local_irq_restore(flags);
534 			return 0;
535 		}
536 		cpu_relax();
537 	}
538 
539 	/*
540 	 * For single stepping, try to only enter on the processor
541 	 * that was single stepping.  To gaurd against a deadlock, the
542 	 * kernel will only try for the value of sstep_tries before
543 	 * giving up and continuing on.
544 	 */
545 	if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
546 	    (kgdb_info[cpu].task &&
547 	     kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
548 		atomic_set(&kgdb_active, -1);
549 		raw_spin_unlock(&dbg_master_lock);
550 		dbg_touch_watchdogs();
551 		local_irq_restore(flags);
552 
553 		goto acquirelock;
554 	}
555 
556 	if (!kgdb_io_ready(1)) {
557 		kgdb_info[cpu].ret_state = 1;
558 		goto kgdb_restore; /* No I/O connection, resume the system */
559 	}
560 
561 	/*
562 	 * Don't enter if we have hit a removed breakpoint.
563 	 */
564 	if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
565 		goto kgdb_restore;
566 
567 	/* Call the I/O driver's pre_exception routine */
568 	if (dbg_io_ops->pre_exception)
569 		dbg_io_ops->pre_exception();
570 
571 	/*
572 	 * Get the passive CPU lock which will hold all the non-primary
573 	 * CPU in a spin state while the debugger is active
574 	 */
575 	if (!kgdb_single_step)
576 		raw_spin_lock(&dbg_slave_lock);
577 
578 #ifdef CONFIG_SMP
579 	/* Signal the other CPUs to enter kgdb_wait() */
580 	if ((!kgdb_single_step) && kgdb_do_roundup)
581 		kgdb_roundup_cpus(flags);
582 #endif
583 
584 	/*
585 	 * Wait for the other CPUs to be notified and be waiting for us:
586 	 */
587 	while (kgdb_do_roundup && (atomic_read(&masters_in_kgdb) +
588 				atomic_read(&slaves_in_kgdb)) != online_cpus)
589 		cpu_relax();
590 
591 	/*
592 	 * At this point the primary processor is completely
593 	 * in the debugger and all secondary CPUs are quiescent
594 	 */
595 	dbg_deactivate_sw_breakpoints();
596 	kgdb_single_step = 0;
597 	kgdb_contthread = current;
598 	exception_level = 0;
599 	trace_on = tracing_is_on();
600 	if (trace_on)
601 		tracing_off();
602 
603 	while (1) {
604 cpu_master_loop:
605 		if (dbg_kdb_mode) {
606 			kgdb_connected = 1;
607 			error = kdb_stub(ks);
608 			if (error == -1)
609 				continue;
610 			kgdb_connected = 0;
611 		} else {
612 			error = gdb_serial_stub(ks);
613 		}
614 
615 		if (error == DBG_PASS_EVENT) {
616 			dbg_kdb_mode = !dbg_kdb_mode;
617 		} else if (error == DBG_SWITCH_CPU_EVENT) {
618 			kgdb_info[dbg_switch_cpu].exception_state |=
619 				DCPU_NEXT_MASTER;
620 			goto cpu_loop;
621 		} else {
622 			kgdb_info[cpu].ret_state = error;
623 			break;
624 		}
625 	}
626 
627 	/* Call the I/O driver's post_exception routine */
628 	if (dbg_io_ops->post_exception)
629 		dbg_io_ops->post_exception();
630 
631 	if (!kgdb_single_step) {
632 		raw_spin_unlock(&dbg_slave_lock);
633 		/* Wait till all the CPUs have quit from the debugger. */
634 		while (kgdb_do_roundup && atomic_read(&slaves_in_kgdb))
635 			cpu_relax();
636 	}
637 
638 kgdb_restore:
639 	if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
640 		int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
641 		if (kgdb_info[sstep_cpu].task)
642 			kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
643 		else
644 			kgdb_sstep_pid = 0;
645 	}
646 	if (arch_kgdb_ops.correct_hw_break)
647 		arch_kgdb_ops.correct_hw_break();
648 	if (trace_on)
649 		tracing_on();
650 
651 	kgdb_info[cpu].exception_state &=
652 		~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
653 	kgdb_info[cpu].enter_kgdb--;
654 	smp_mb__before_atomic_dec();
655 	atomic_dec(&masters_in_kgdb);
656 	/* Free kgdb_active */
657 	atomic_set(&kgdb_active, -1);
658 	raw_spin_unlock(&dbg_master_lock);
659 	dbg_touch_watchdogs();
660 	local_irq_restore(flags);
661 
662 	return kgdb_info[cpu].ret_state;
663 }
664 
665 /*
666  * kgdb_handle_exception() - main entry point from a kernel exception
667  *
668  * Locking hierarchy:
669  *	interface locks, if any (begin_session)
670  *	kgdb lock (kgdb_active)
671  */
672 int
673 kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
674 {
675 	struct kgdb_state kgdb_var;
676 	struct kgdb_state *ks = &kgdb_var;
677 
678 	ks->cpu			= raw_smp_processor_id();
679 	ks->ex_vector		= evector;
680 	ks->signo		= signo;
681 	ks->err_code		= ecode;
682 	ks->kgdb_usethreadid	= 0;
683 	ks->linux_regs		= regs;
684 
685 	if (kgdb_reenter_check(ks))
686 		return 0; /* Ouch, double exception ! */
687 	if (kgdb_info[ks->cpu].enter_kgdb != 0)
688 		return 0;
689 
690 	return kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
691 }
692 
693 int kgdb_nmicallback(int cpu, void *regs)
694 {
695 #ifdef CONFIG_SMP
696 	struct kgdb_state kgdb_var;
697 	struct kgdb_state *ks = &kgdb_var;
698 
699 	memset(ks, 0, sizeof(struct kgdb_state));
700 	ks->cpu			= cpu;
701 	ks->linux_regs		= regs;
702 
703 	if (kgdb_info[ks->cpu].enter_kgdb == 0 &&
704 			raw_spin_is_locked(&dbg_master_lock)) {
705 		kgdb_cpu_enter(ks, regs, DCPU_IS_SLAVE);
706 		return 0;
707 	}
708 #endif
709 	return 1;
710 }
711 
712 static void kgdb_console_write(struct console *co, const char *s,
713    unsigned count)
714 {
715 	unsigned long flags;
716 
717 	/* If we're debugging, or KGDB has not connected, don't try
718 	 * and print. */
719 	if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode)
720 		return;
721 
722 	local_irq_save(flags);
723 	gdbstub_msg_write(s, count);
724 	local_irq_restore(flags);
725 }
726 
727 static struct console kgdbcons = {
728 	.name		= "kgdb",
729 	.write		= kgdb_console_write,
730 	.flags		= CON_PRINTBUFFER | CON_ENABLED,
731 	.index		= -1,
732 };
733 
734 #ifdef CONFIG_MAGIC_SYSRQ
735 static void sysrq_handle_dbg(int key)
736 {
737 	if (!dbg_io_ops) {
738 		printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
739 		return;
740 	}
741 	if (!kgdb_connected) {
742 #ifdef CONFIG_KGDB_KDB
743 		if (!dbg_kdb_mode)
744 			printk(KERN_CRIT "KGDB or $3#33 for KDB\n");
745 #else
746 		printk(KERN_CRIT "Entering KGDB\n");
747 #endif
748 	}
749 
750 	kgdb_breakpoint();
751 }
752 
753 static struct sysrq_key_op sysrq_dbg_op = {
754 	.handler	= sysrq_handle_dbg,
755 	.help_msg	= "debug(G)",
756 	.action_msg	= "DEBUG",
757 };
758 #endif
759 
760 static int kgdb_panic_event(struct notifier_block *self,
761 			    unsigned long val,
762 			    void *data)
763 {
764 	if (dbg_kdb_mode)
765 		kdb_printf("PANIC: %s\n", (char *)data);
766 	kgdb_breakpoint();
767 	return NOTIFY_DONE;
768 }
769 
770 static struct notifier_block kgdb_panic_event_nb = {
771        .notifier_call	= kgdb_panic_event,
772        .priority	= INT_MAX,
773 };
774 
775 void __weak kgdb_arch_late(void)
776 {
777 }
778 
779 void __init dbg_late_init(void)
780 {
781 	dbg_is_early = false;
782 	if (kgdb_io_module_registered)
783 		kgdb_arch_late();
784 	kdb_init(KDB_INIT_FULL);
785 }
786 
787 static void kgdb_register_callbacks(void)
788 {
789 	if (!kgdb_io_module_registered) {
790 		kgdb_io_module_registered = 1;
791 		kgdb_arch_init();
792 		if (!dbg_is_early)
793 			kgdb_arch_late();
794 		atomic_notifier_chain_register(&panic_notifier_list,
795 					       &kgdb_panic_event_nb);
796 #ifdef CONFIG_MAGIC_SYSRQ
797 		register_sysrq_key('g', &sysrq_dbg_op);
798 #endif
799 		if (kgdb_use_con && !kgdb_con_registered) {
800 			register_console(&kgdbcons);
801 			kgdb_con_registered = 1;
802 		}
803 	}
804 }
805 
806 static void kgdb_unregister_callbacks(void)
807 {
808 	/*
809 	 * When this routine is called KGDB should unregister from the
810 	 * panic handler and clean up, making sure it is not handling any
811 	 * break exceptions at the time.
812 	 */
813 	if (kgdb_io_module_registered) {
814 		kgdb_io_module_registered = 0;
815 		atomic_notifier_chain_unregister(&panic_notifier_list,
816 					       &kgdb_panic_event_nb);
817 		kgdb_arch_exit();
818 #ifdef CONFIG_MAGIC_SYSRQ
819 		unregister_sysrq_key('g', &sysrq_dbg_op);
820 #endif
821 		if (kgdb_con_registered) {
822 			unregister_console(&kgdbcons);
823 			kgdb_con_registered = 0;
824 		}
825 	}
826 }
827 
828 /*
829  * There are times a tasklet needs to be used vs a compiled in
830  * break point so as to cause an exception outside a kgdb I/O module,
831  * such as is the case with kgdboe, where calling a breakpoint in the
832  * I/O driver itself would be fatal.
833  */
834 static void kgdb_tasklet_bpt(unsigned long ing)
835 {
836 	kgdb_breakpoint();
837 	atomic_set(&kgdb_break_tasklet_var, 0);
838 }
839 
840 static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);
841 
842 void kgdb_schedule_breakpoint(void)
843 {
844 	if (atomic_read(&kgdb_break_tasklet_var) ||
845 		atomic_read(&kgdb_active) != -1 ||
846 		atomic_read(&kgdb_setting_breakpoint))
847 		return;
848 	atomic_inc(&kgdb_break_tasklet_var);
849 	tasklet_schedule(&kgdb_tasklet_breakpoint);
850 }
851 EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint);
852 
853 static void kgdb_initial_breakpoint(void)
854 {
855 	kgdb_break_asap = 0;
856 
857 	printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
858 	kgdb_breakpoint();
859 }
860 
861 /**
862  *	kgdb_register_io_module - register KGDB IO module
863  *	@new_dbg_io_ops: the io ops vector
864  *
865  *	Register it with the KGDB core.
866  */
867 int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
868 {
869 	int err;
870 
871 	spin_lock(&kgdb_registration_lock);
872 
873 	if (dbg_io_ops) {
874 		spin_unlock(&kgdb_registration_lock);
875 
876 		printk(KERN_ERR "kgdb: Another I/O driver is already "
877 				"registered with KGDB.\n");
878 		return -EBUSY;
879 	}
880 
881 	if (new_dbg_io_ops->init) {
882 		err = new_dbg_io_ops->init();
883 		if (err) {
884 			spin_unlock(&kgdb_registration_lock);
885 			return err;
886 		}
887 	}
888 
889 	dbg_io_ops = new_dbg_io_ops;
890 
891 	spin_unlock(&kgdb_registration_lock);
892 
893 	printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
894 	       new_dbg_io_ops->name);
895 
896 	/* Arm KGDB now. */
897 	kgdb_register_callbacks();
898 
899 	if (kgdb_break_asap)
900 		kgdb_initial_breakpoint();
901 
902 	return 0;
903 }
904 EXPORT_SYMBOL_GPL(kgdb_register_io_module);
905 
906 /**
907  *	kkgdb_unregister_io_module - unregister KGDB IO module
908  *	@old_dbg_io_ops: the io ops vector
909  *
910  *	Unregister it with the KGDB core.
911  */
912 void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)
913 {
914 	BUG_ON(kgdb_connected);
915 
916 	/*
917 	 * KGDB is no longer able to communicate out, so
918 	 * unregister our callbacks and reset state.
919 	 */
920 	kgdb_unregister_callbacks();
921 
922 	spin_lock(&kgdb_registration_lock);
923 
924 	WARN_ON_ONCE(dbg_io_ops != old_dbg_io_ops);
925 	dbg_io_ops = NULL;
926 
927 	spin_unlock(&kgdb_registration_lock);
928 
929 	printk(KERN_INFO
930 		"kgdb: Unregistered I/O driver %s, debugger disabled.\n",
931 		old_dbg_io_ops->name);
932 }
933 EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
934 
935 int dbg_io_get_char(void)
936 {
937 	int ret = dbg_io_ops->read_char();
938 	if (ret == NO_POLL_CHAR)
939 		return -1;
940 	if (!dbg_kdb_mode)
941 		return ret;
942 	if (ret == 127)
943 		return 8;
944 	return ret;
945 }
946 
947 /**
948  * kgdb_breakpoint - generate breakpoint exception
949  *
950  * This function will generate a breakpoint exception.  It is used at the
951  * beginning of a program to sync up with a debugger and can be used
952  * otherwise as a quick means to stop program execution and "break" into
953  * the debugger.
954  */
955 void kgdb_breakpoint(void)
956 {
957 	atomic_inc(&kgdb_setting_breakpoint);
958 	wmb(); /* Sync point before breakpoint */
959 	arch_kgdb_breakpoint();
960 	wmb(); /* Sync point after breakpoint */
961 	atomic_dec(&kgdb_setting_breakpoint);
962 }
963 EXPORT_SYMBOL_GPL(kgdb_breakpoint);
964 
965 static int __init opt_kgdb_wait(char *str)
966 {
967 	kgdb_break_asap = 1;
968 
969 	kdb_init(KDB_INIT_EARLY);
970 	if (kgdb_io_module_registered)
971 		kgdb_initial_breakpoint();
972 
973 	return 0;
974 }
975 
976 early_param("kgdbwait", opt_kgdb_wait);
977