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