debug_core.c 25.4 KB
Newer Older
Jason Wessel's avatar
Jason Wessel committed
1
/*
2
 * Kernel Debug Core
Jason Wessel's avatar
Jason Wessel committed
3 4 5 6 7 8
 *
 * Maintainer: Jason Wessel <jason.wessel@windriver.com>
 *
 * Copyright (C) 2000-2001 VERITAS Software Corporation.
 * Copyright (C) 2002-2004 Timesys Corporation
 * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
Pavel Machek's avatar
Pavel Machek committed
9
 * Copyright (C) 2004 Pavel Machek <pavel@ucw.cz>
Jason Wessel's avatar
Jason Wessel committed
10 11
 * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
 * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
12
 * Copyright (C) 2005-2009 Wind River Systems, Inc.
Jason Wessel's avatar
Jason Wessel committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
 * Copyright (C) 2007 MontaVista Software, Inc.
 * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
 *
 * Contributors at various stages not listed above:
 *  Jason Wessel ( jason.wessel@windriver.com )
 *  George Anzinger <george@mvista.com>
 *  Anurekh Saxena (anurekh.saxena@timesys.com)
 *  Lake Stevens Instrument Division (Glenn Engel)
 *  Jim Kingdon, Cygnus Support.
 *
 * Original KGDB stub: David Grothe <dave@gcom.com>,
 * Tigran Aivazian <tigran@sco.com>
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 */
30 31 32

#define pr_fmt(fmt) "KGDB: " fmt

Jason Wessel's avatar
Jason Wessel committed
33
#include <linux/pid_namespace.h>
Jason Wessel's avatar
Jason Wessel committed
34
#include <linux/clocksource.h>
35
#include <linux/serial_core.h>
Jason Wessel's avatar
Jason Wessel committed
36 37 38 39 40 41 42 43 44 45 46 47
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/console.h>
#include <linux/threads.h>
#include <linux/uaccess.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/ptrace.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/sysrq.h>
48
#include <linux/reboot.h>
Jason Wessel's avatar
Jason Wessel committed
49 50
#include <linux/init.h>
#include <linux/kgdb.h>
51
#include <linux/kdb.h>
52
#include <linux/nmi.h>
Jason Wessel's avatar
Jason Wessel committed
53 54 55
#include <linux/pid.h>
#include <linux/smp.h>
#include <linux/mm.h>
Davidlohr Bueso's avatar
Davidlohr Bueso committed
56
#include <linux/vmacache.h>
57
#include <linux/rcupdate.h>
Jason Wessel's avatar
Jason Wessel committed
58 59 60

#include <asm/cacheflush.h>
#include <asm/byteorder.h>
Arun Sharma's avatar
Arun Sharma committed
61
#include <linux/atomic.h>
Jason Wessel's avatar
Jason Wessel committed
62

63
#include "debug_core.h"
Jason Wessel's avatar
Jason Wessel committed
64

65
static int kgdb_break_asap;
66

67
struct debuggerinfo_struct kgdb_info[NR_CPUS];
Jason Wessel's avatar
Jason Wessel committed
68 69 70 71 72 73 74 75

/**
 * kgdb_connected - Is a host GDB connected to us?
 */
int				kgdb_connected;
EXPORT_SYMBOL_GPL(kgdb_connected);

/* All the KGDB handlers are installed */
76
int			kgdb_io_module_registered;
Jason Wessel's avatar
Jason Wessel committed
77 78 79 80

/* Guard for recursive entry */
static int			exception_level;

81
struct kgdb_io		*dbg_io_ops;
Jason Wessel's avatar
Jason Wessel committed
82 83
static DEFINE_SPINLOCK(kgdb_registration_lock);

84 85
/* Action for the reboot notifiter, a global allow kdb to change it */
static int kgdbreboot;
Jason Wessel's avatar
Jason Wessel committed
86 87 88 89
/* kgdb console driver is loaded */
static int kgdb_con_registered;
/* determine if kgdb console output should be used */
static int kgdb_use_con;
90 91
/* Flag for alternate operations for early debugging */
bool dbg_is_early = true;
92 93 94 95
/* Next cpu to become the master debug core */
int dbg_switch_cpu;

/* Use kdb or gdbserver mode */
96
int dbg_kdb_mode = 1;
Jason Wessel's avatar
Jason Wessel committed
97 98 99 100 101 102 103 104 105 106

static int __init opt_kgdb_con(char *str)
{
	kgdb_use_con = 1;
	return 0;
}

early_param("kgdbcon", opt_kgdb_con);

module_param(kgdb_use_con, int, 0644);
107
module_param(kgdbreboot, int, 0644);
Jason Wessel's avatar
Jason Wessel committed
108 109 110 111 112 113 114 115 116 117 118 119 120

/*
 * Holds information about breakpoints in a kernel. These breakpoints are
 * added and removed by gdb.
 */
static struct kgdb_bkpt		kgdb_break[KGDB_MAX_BREAKPOINTS] = {
	[0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
};

/*
 * The CPU# of the active CPU, or -1 if none:
 */
atomic_t			kgdb_active = ATOMIC_INIT(-1);
121
EXPORT_SYMBOL_GPL(kgdb_active);
122 123
static IPIPE_DEFINE_RAW_SPINLOCK(dbg_master_lock);
static IPIPE_DEFINE_RAW_SPINLOCK(dbg_slave_lock);
Jason Wessel's avatar
Jason Wessel committed
124 125 126 127 128

/*
 * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
 * bootup code (which might not have percpu set up yet):
 */
129 130
static atomic_t			masters_in_kgdb;
static atomic_t			slaves_in_kgdb;
131
static atomic_t			kgdb_break_tasklet_var;
Jason Wessel's avatar
Jason Wessel committed
132 133 134 135 136 137
atomic_t			kgdb_setting_breakpoint;

struct task_struct		*kgdb_usethread;
struct task_struct		*kgdb_contthread;

int				kgdb_single_step;
138
static pid_t			kgdb_sstep_pid;
Jason Wessel's avatar
Jason Wessel committed
139 140 141 142 143 144 145 146 147 148 149

/* to keep track of the CPU which is doing the single stepping*/
atomic_t			kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);

/*
 * If you are debugging a problem where roundup (the collection of
 * all other CPUs) is a problem [this should be extremely rare],
 * then use the nokgdbroundup option to avoid roundup. In that case
 * the other CPUs might interfere with your debugging context, so
 * use this with care:
 */
150
static int kgdb_do_roundup = 1;
Jason Wessel's avatar
Jason Wessel committed
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

static int __init opt_nokgdbroundup(char *str)
{
	kgdb_do_roundup = 0;

	return 0;
}

early_param("nokgdbroundup", opt_nokgdbroundup);

/*
 * Finally, some KGDB code :-)
 */

/*
 * Weak aliases for breakpoint management,
 * can be overriden by architectures when needed:
 */
169
int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
Jason Wessel's avatar
Jason Wessel committed
170 171 172
{
	int err;

173 174
	err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
				BREAK_INSTR_SIZE);
Jason Wessel's avatar
Jason Wessel committed
175 176
	if (err)
		return err;
177 178 179
	err = probe_kernel_write((char *)bpt->bpt_addr,
				 arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
	return err;
Jason Wessel's avatar
Jason Wessel committed
180 181
}

182
int __weak kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
Jason Wessel's avatar
Jason Wessel committed
183
{
184 185
	return probe_kernel_write((char *)bpt->bpt_addr,
				  (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
Jason Wessel's avatar
Jason Wessel committed
186 187
}

188 189
int __weak kgdb_validate_break_address(unsigned long addr)
{
190
	struct kgdb_bkpt tmp;
191
	int err;
192
	/* Validate setting the breakpoint and then removing it.  If the
193 194 195 196
	 * remove fails, the kernel needs to emit a bad message because we
	 * are deep trouble not being able to put things back the way we
	 * found them.
	 */
197 198
	tmp.bpt_addr = addr;
	err = kgdb_arch_set_breakpoint(&tmp);
199 200
	if (err)
		return err;
201
	err = kgdb_arch_remove_breakpoint(&tmp);
202
	if (err)
203 204
		pr_err("Critical breakpoint error, kernel memory destroyed at: %lx\n",
		       addr);
205 206 207
	return err;
}

Jason Wessel's avatar
Jason Wessel committed
208 209 210 211 212 213 214 215 216 217
unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
{
	return instruction_pointer(regs);
}

int __weak kgdb_arch_init(void)
{
	return 0;
}

218 219 220 221 222
int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
{
	return 0;
}

Jason Wessel's avatar
Jason Wessel committed
223 224 225 226 227 228 229 230 231
/*
 * Some architectures need cache flushes when we set/clear a
 * breakpoint:
 */
static void kgdb_flush_swbreak_addr(unsigned long addr)
{
	if (!CACHE_FLUSH_IS_SAFE)
		return;

Davidlohr Bueso's avatar
Davidlohr Bueso committed
232 233 234 235
	if (current->mm) {
		int i;

		for (i = 0; i < VMACACHE_SIZE; i++) {
236
			if (!current->vmacache.vmas[i])
Davidlohr Bueso's avatar
Davidlohr Bueso committed
237
				continue;
238
			flush_cache_range(current->vmacache.vmas[i],
Davidlohr Bueso's avatar
Davidlohr Bueso committed
239 240
					  addr, addr + BREAK_INSTR_SIZE);
		}
Jason Wessel's avatar
Jason Wessel committed
241
	}
Davidlohr Bueso's avatar
Davidlohr Bueso committed
242

243 244
	/* Force flush instruction cache if it was outside the mm */
	flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
Jason Wessel's avatar
Jason Wessel committed
245 246 247 248 249
}

/*
 * SW breakpoint management:
 */
250
int dbg_activate_sw_breakpoints(void)
Jason Wessel's avatar
Jason Wessel committed
251
{
252 253
	int error;
	int ret = 0;
Jason Wessel's avatar
Jason Wessel committed
254 255 256 257 258 259
	int i;

	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if (kgdb_break[i].state != BP_SET)
			continue;

260
		error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
261 262
		if (error) {
			ret = error;
263 264
			pr_info("BP install failed: %lx\n",
				kgdb_break[i].bpt_addr);
265 266
			continue;
		}
Jason Wessel's avatar
Jason Wessel committed
267

268
		kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
Jason Wessel's avatar
Jason Wessel committed
269 270
		kgdb_break[i].state = BP_ACTIVE;
	}
271
	return ret;
Jason Wessel's avatar
Jason Wessel committed
272 273
}

274
int dbg_set_sw_break(unsigned long addr)
Jason Wessel's avatar
Jason Wessel committed
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
{
	int err = kgdb_validate_break_address(addr);
	int breakno = -1;
	int i;

	if (err)
		return err;

	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if ((kgdb_break[i].state == BP_SET) &&
					(kgdb_break[i].bpt_addr == addr))
			return -EEXIST;
	}
	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if (kgdb_break[i].state == BP_REMOVED &&
					kgdb_break[i].bpt_addr == addr) {
			breakno = i;
			break;
		}
	}

	if (breakno == -1) {
		for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
			if (kgdb_break[i].state == BP_UNDEFINED) {
				breakno = i;
				break;
			}
		}
	}

	if (breakno == -1)
		return -E2BIG;

	kgdb_break[breakno].state = BP_SET;
	kgdb_break[breakno].type = BP_BREAKPOINT;
	kgdb_break[breakno].bpt_addr = addr;

	return 0;
}

315
int dbg_deactivate_sw_breakpoints(void)
Jason Wessel's avatar
Jason Wessel committed
316
{
317 318
	int error;
	int ret = 0;
Jason Wessel's avatar
Jason Wessel committed
319 320 321 322 323
	int i;

	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if (kgdb_break[i].state != BP_ACTIVE)
			continue;
324
		error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
325
		if (error) {
326 327
			pr_info("BP remove failed: %lx\n",
				kgdb_break[i].bpt_addr);
328 329
			ret = error;
		}
Jason Wessel's avatar
Jason Wessel committed
330

331
		kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
Jason Wessel's avatar
Jason Wessel committed
332 333
		kgdb_break[i].state = BP_SET;
	}
334
	return ret;
Jason Wessel's avatar
Jason Wessel committed
335 336
}

337
int dbg_remove_sw_break(unsigned long addr)
Jason Wessel's avatar
Jason Wessel committed
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
{
	int i;

	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if ((kgdb_break[i].state == BP_SET) &&
				(kgdb_break[i].bpt_addr == addr)) {
			kgdb_break[i].state = BP_REMOVED;
			return 0;
		}
	}
	return -ENOENT;
}

int kgdb_isremovedbreak(unsigned long addr)
{
	int i;

	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if ((kgdb_break[i].state == BP_REMOVED) &&
					(kgdb_break[i].bpt_addr == addr))
			return 1;
	}
	return 0;
}

363
int dbg_remove_all_break(void)
Jason Wessel's avatar
Jason Wessel committed
364 365 366 367 368 369
{
	int error;
	int i;

	/* Clear memory breakpoints. */
	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
370 371
		if (kgdb_break[i].state != BP_ACTIVE)
			goto setundefined;
372
		error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
Jason Wessel's avatar
Jason Wessel committed
373
		if (error)
374
			pr_err("breakpoint remove failed: %lx\n",
375
			       kgdb_break[i].bpt_addr);
376 377
setundefined:
		kgdb_break[i].state = BP_UNDEFINED;
Jason Wessel's avatar
Jason Wessel committed
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
	}

	/* Clear hardware breakpoints. */
	if (arch_kgdb_ops.remove_all_hw_break)
		arch_kgdb_ops.remove_all_hw_break();

	return 0;
}

/*
 * Return true if there is a valid kgdb I/O module.  Also if no
 * debugger is attached a message can be printed to the console about
 * waiting for the debugger to attach.
 *
 * The print_wait argument is only to be true when called from inside
 * the core kgdb_handle_exception, because it will wait for the
 * debugger to attach.
 */
static int kgdb_io_ready(int print_wait)
{
398
	if (!dbg_io_ops)
Jason Wessel's avatar
Jason Wessel committed
399 400 401 402 403
		return 0;
	if (kgdb_connected)
		return 1;
	if (atomic_read(&kgdb_setting_breakpoint))
		return 1;
404 405 406
	if (print_wait) {
#ifdef CONFIG_KGDB_KDB
		if (!dbg_kdb_mode)
407
			pr_crit("waiting... or $3#33 for KDB\n");
408
#else
409
		pr_crit("Waiting for remote debugger\n");
410 411
#endif
	}
Jason Wessel's avatar
Jason Wessel committed
412 413 414 415 416 417 418 419 420 421 422 423 424
	return 1;
}

static int kgdb_reenter_check(struct kgdb_state *ks)
{
	unsigned long addr;

	if (atomic_read(&kgdb_active) != raw_smp_processor_id())
		return 0;

	/* Panic on recursive debugger calls: */
	exception_level++;
	addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
425
	dbg_deactivate_sw_breakpoints();
Jason Wessel's avatar
Jason Wessel committed
426 427 428 429 430 431 432

	/*
	 * If the break point removed ok at the place exception
	 * occurred, try to recover and print a warning to the end
	 * user because the user planted a breakpoint in a place that
	 * KGDB needs in order to function.
	 */
433
	if (dbg_remove_sw_break(addr) == 0) {
Jason Wessel's avatar
Jason Wessel committed
434 435
		exception_level = 0;
		kgdb_skipexception(ks->ex_vector, ks->linux_regs);
436
		dbg_activate_sw_breakpoints();
437
		pr_crit("re-enter error: breakpoint removed %lx\n", addr);
Jason Wessel's avatar
Jason Wessel committed
438 439 440 441
		WARN_ON_ONCE(1);

		return 1;
	}
442
	dbg_remove_all_break();
Jason Wessel's avatar
Jason Wessel committed
443 444 445 446 447 448 449
	kgdb_skipexception(ks->ex_vector, ks->linux_regs);

	if (exception_level > 1) {
		dump_stack();
		panic("Recursive entry to debugger");
	}

450
	pr_crit("re-enter exception: ALL breakpoints killed\n");
451 452 453 454
#ifdef CONFIG_KGDB_KDB
	/* Allow kdb to debug itself one level */
	return 0;
#endif
Jason Wessel's avatar
Jason Wessel committed
455 456 457 458 459 460
	dump_stack();
	panic("Recursive entry to debugger");

	return 1;
}

461 462 463
static void dbg_touch_watchdogs(void)
{
	touch_softlockup_watchdog_sync();
464
#ifndef CONFIG_IPIPE
465
	clocksource_touch_watchdog();
466
#endif
467
	rcu_cpu_stall_reset();
468 469
}

470 471
static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,
		int exception_state)
Jason Wessel's avatar
Jason Wessel committed
472 473
{
	unsigned long flags;
474
	int sstep_tries = 100;
475
	int error;
476
	int cpu;
477
	int trace_on = 0;
478
	int online_cpus = num_online_cpus();
479
	u64 time_left;
480

481 482 483 484 485 486 487
	kgdb_info[ks->cpu].enter_kgdb++;
	kgdb_info[ks->cpu].exception_state |= exception_state;

	if (exception_state == DCPU_WANT_MASTER)
		atomic_inc(&masters_in_kgdb);
	else
		atomic_inc(&slaves_in_kgdb);
488 489 490

	if (arch_kgdb_ops.disable_hw_break)
		arch_kgdb_ops.disable_hw_break(regs);
491

Jason Wessel's avatar
Jason Wessel committed
492 493 494 495 496
acquirelock:
	/*
	 * Interrupts will be restored by the 'trap return' code, except when
	 * single stepping.
	 */
497
	flags = hard_local_irq_save();
Jason Wessel's avatar
Jason Wessel committed
498

499 500 501
	cpu = ks->cpu;
	kgdb_info[cpu].debuggerinfo = regs;
	kgdb_info[cpu].task = current;
502 503
	kgdb_info[cpu].ret_state = 0;
	kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
Jason Wessel's avatar
Jason Wessel committed
504

505 506 507 508 509 510
	/* Make sure the above info reaches the primary CPU */
	smp_mb();

	if (exception_level == 1) {
		if (raw_spin_trylock(&dbg_master_lock))
			atomic_xchg(&kgdb_active, cpu);
511
		goto cpu_master_loop;
512
	}
513

Jason Wessel's avatar
Jason Wessel committed
514
	/*
515 516
	 * CPU will loop if it is a slave or request to become a kgdb
	 * master cpu and acquire the kgdb_active lock:
Jason Wessel's avatar
Jason Wessel committed
517
	 */
518
	while (1) {
519 520 521 522 523
cpu_loop:
		if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
			kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
			goto cpu_master_loop;
		} else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
524 525
			if (raw_spin_trylock(&dbg_master_lock)) {
				atomic_xchg(&kgdb_active, cpu);
526
				break;
527
			}
528
		} else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
529
			if (!raw_spin_is_locked(&dbg_slave_lock))
530 531 532 533 534 535 536 537
				goto return_normal;
		} else {
return_normal:
			/* Return to normal operation by executing any
			 * hw breakpoint fixup.
			 */
			if (arch_kgdb_ops.correct_hw_break)
				arch_kgdb_ops.correct_hw_break();
538 539
			if (trace_on)
				tracing_on();
540 541 542
			kgdb_info[cpu].exception_state &=
				~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
			kgdb_info[cpu].enter_kgdb--;
543
			smp_mb__before_atomic();
544
			atomic_dec(&slaves_in_kgdb);
545
			dbg_touch_watchdogs();
546
			hard_local_irq_restore(flags);
547 548
			return 0;
		}
Jason Wessel's avatar
Jason Wessel committed
549
		cpu_relax();
550
	}
Jason Wessel's avatar
Jason Wessel committed
551 552

	/*
553
	 * For single stepping, try to only enter on the processor
Lucas De Marchi's avatar
Lucas De Marchi committed
554
	 * that was single stepping.  To guard against a deadlock, the
555 556
	 * kernel will only try for the value of sstep_tries before
	 * giving up and continuing on.
Jason Wessel's avatar
Jason Wessel committed
557 558
	 */
	if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
559 560
	    (kgdb_info[cpu].task &&
	     kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
Jason Wessel's avatar
Jason Wessel committed
561
		atomic_set(&kgdb_active, -1);
562
		raw_spin_unlock(&dbg_master_lock);
563
		dbg_touch_watchdogs();
564
		hard_local_irq_restore(flags);
Jason Wessel's avatar
Jason Wessel committed
565 566 567 568 569

		goto acquirelock;
	}

	if (!kgdb_io_ready(1)) {
570
		kgdb_info[cpu].ret_state = 1;
571
		goto kgdb_restore; /* No I/O connection, resume the system */
Jason Wessel's avatar
Jason Wessel committed
572 573 574 575 576 577 578 579 580
	}

	/*
	 * Don't enter if we have hit a removed breakpoint.
	 */
	if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
		goto kgdb_restore;

	/* Call the I/O driver's pre_exception routine */
581 582
	if (dbg_io_ops->pre_exception)
		dbg_io_ops->pre_exception();
Jason Wessel's avatar
Jason Wessel committed
583 584 585 586 587

	/*
	 * Get the passive CPU lock which will hold all the non-primary
	 * CPU in a spin state while the debugger is active
	 */
588 589
	if (!kgdb_single_step)
		raw_spin_lock(&dbg_slave_lock);
Jason Wessel's avatar
Jason Wessel committed
590

591
#ifdef CONFIG_SMP
592 593 594 595
	/* If send_ready set, slaves are already waiting */
	if (ks->send_ready)
		atomic_set(ks->send_ready, 1);

596
	/* Signal the other CPUs to enter kgdb_wait() */
597
	else if ((!kgdb_single_step) && kgdb_do_roundup)
598 599 600
		kgdb_roundup_cpus(flags);
#endif

Jason Wessel's avatar
Jason Wessel committed
601 602 603
	/*
	 * Wait for the other CPUs to be notified and be waiting for us:
	 */
604
	time_left = MSEC_PER_SEC;
605 606 607
	while (kgdb_do_roundup && --time_left &&
	       (atomic_read(&masters_in_kgdb) + atomic_read(&slaves_in_kgdb)) !=
		   online_cpus)
608
		udelay(1000);
609
	if (!time_left)
610
		pr_crit("Timed out waiting for secondary CPUs.\n");
Jason Wessel's avatar
Jason Wessel committed
611 612 613 614 615

	/*
	 * At this point the primary processor is completely
	 * in the debugger and all secondary CPUs are quiescent
	 */
616
	dbg_deactivate_sw_breakpoints();
Jason Wessel's avatar
Jason Wessel committed
617
	kgdb_single_step = 0;
618
	kgdb_contthread = current;
Jason Wessel's avatar
Jason Wessel committed
619
	exception_level = 0;
620 621 622
	trace_on = tracing_is_on();
	if (trace_on)
		tracing_off();
Jason Wessel's avatar
Jason Wessel committed
623

624 625 626 627 628
	while (1) {
cpu_master_loop:
		if (dbg_kdb_mode) {
			kgdb_connected = 1;
			error = kdb_stub(ks);
629 630
			if (error == -1)
				continue;
631
			kgdb_connected = 0;
632 633 634 635 636 637 638
		} else {
			error = gdb_serial_stub(ks);
		}

		if (error == DBG_PASS_EVENT) {
			dbg_kdb_mode = !dbg_kdb_mode;
		} else if (error == DBG_SWITCH_CPU_EVENT) {
639 640
			kgdb_info[dbg_switch_cpu].exception_state |=
				DCPU_NEXT_MASTER;
641 642 643 644 645 646
			goto cpu_loop;
		} else {
			kgdb_info[cpu].ret_state = error;
			break;
		}
	}
Jason Wessel's avatar
Jason Wessel committed
647 648

	/* Call the I/O driver's post_exception routine */
649 650
	if (dbg_io_ops->post_exception)
		dbg_io_ops->post_exception();
Jason Wessel's avatar
Jason Wessel committed
651

652
	if (!kgdb_single_step) {
653 654 655 656
		raw_spin_unlock(&dbg_slave_lock);
		/* Wait till all the CPUs have quit from the debugger. */
		while (kgdb_do_roundup && atomic_read(&slaves_in_kgdb))
			cpu_relax();
Jason Wessel's avatar
Jason Wessel committed
657 658 659
	}

kgdb_restore:
660 661 662 663 664 665 666
	if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
		int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
		if (kgdb_info[sstep_cpu].task)
			kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
		else
			kgdb_sstep_pid = 0;
	}
667 668
	if (arch_kgdb_ops.correct_hw_break)
		arch_kgdb_ops.correct_hw_break();
669 670
	if (trace_on)
		tracing_on();
671 672 673 674

	kgdb_info[cpu].exception_state &=
		~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
	kgdb_info[cpu].enter_kgdb--;
675
	smp_mb__before_atomic();
676
	atomic_dec(&masters_in_kgdb);
Jason Wessel's avatar
Jason Wessel committed
677 678
	/* Free kgdb_active */
	atomic_set(&kgdb_active, -1);
679
	raw_spin_unlock(&dbg_master_lock);
680
	dbg_touch_watchdogs();
681
	hard_local_irq_restore(flags);
Jason Wessel's avatar
Jason Wessel committed
682

683
	return kgdb_info[cpu].ret_state;
Jason Wessel's avatar
Jason Wessel committed
684 685
}

686 687 688 689 690 691 692 693 694 695 696 697
/*
 * kgdb_handle_exception() - main entry point from a kernel exception
 *
 * Locking hierarchy:
 *	interface locks, if any (begin_session)
 *	kgdb lock (kgdb_active)
 */
int
kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
{
	struct kgdb_state kgdb_var;
	struct kgdb_state *ks = &kgdb_var;
698 699 700 701
	int ret = 0;

	if (arch_kgdb_ops.enable_nmi)
		arch_kgdb_ops.enable_nmi(0);
702 703 704 705 706 707 708 709
	/*
	 * Avoid entering the debugger if we were triggered due to an oops
	 * but panic_timeout indicates the system should automatically
	 * reboot on panic. We don't want to get stuck waiting for input
	 * on such systems, especially if its "just" an oops.
	 */
	if (signo != SIGTRAP && panic_timeout)
		return 1;
710

711
	memset(ks, 0, sizeof(struct kgdb_state));
712 713 714 715 716 717 718
	ks->cpu			= raw_smp_processor_id();
	ks->ex_vector		= evector;
	ks->signo		= signo;
	ks->err_code		= ecode;
	ks->linux_regs		= regs;

	if (kgdb_reenter_check(ks))
719
		goto out; /* Ouch, double exception ! */
720
	if (kgdb_info[ks->cpu].enter_kgdb != 0)
721
		goto out;
722

723 724 725 726 727
	ret = kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
out:
	if (arch_kgdb_ops.enable_nmi)
		arch_kgdb_ops.enable_nmi(1);
	return ret;
728 729
}

Jason Wessel's avatar
Jason Wessel committed
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
/*
 * GDB places a breakpoint at this function to know dynamically
 * loaded objects. It's not defined static so that only one instance with this
 * name exists in the kernel.
 */

static int module_event(struct notifier_block *self, unsigned long val,
	void *data)
{
	return 0;
}

static struct notifier_block dbg_module_load_nb = {
	.notifier_call	= module_event,
};

Jason Wessel's avatar
Jason Wessel committed
746 747 748
int kgdb_nmicallback(int cpu, void *regs)
{
#ifdef CONFIG_SMP
749 750 751 752 753 754 755
	struct kgdb_state kgdb_var;
	struct kgdb_state *ks = &kgdb_var;

	memset(ks, 0, sizeof(struct kgdb_state));
	ks->cpu			= cpu;
	ks->linux_regs		= regs;

756 757 758
	if (kgdb_info[ks->cpu].enter_kgdb == 0 &&
			raw_spin_is_locked(&dbg_master_lock)) {
		kgdb_cpu_enter(ks, regs, DCPU_IS_SLAVE);
Jason Wessel's avatar
Jason Wessel committed
759 760 761 762 763 764
		return 0;
	}
#endif
	return 1;
}

765 766
int kgdb_nmicallin(int cpu, int trapnr, void *regs, int err_code,
							atomic_t *send_ready)
767 768 769 770 771 772 773 774 775 776 777 778 779
{
#ifdef CONFIG_SMP
	if (!kgdb_io_ready(0) || !send_ready)
		return 1;

	if (kgdb_info[cpu].enter_kgdb == 0) {
		struct kgdb_state kgdb_var;
		struct kgdb_state *ks = &kgdb_var;

		memset(ks, 0, sizeof(struct kgdb_state));
		ks->cpu			= cpu;
		ks->ex_vector		= trapnr;
		ks->signo		= SIGTRAP;
780
		ks->err_code		= err_code;
781 782 783 784 785 786 787 788 789
		ks->linux_regs		= regs;
		ks->send_ready		= send_ready;
		kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
		return 0;
	}
#endif
	return 1;
}

Jason Wessel's avatar
Jason Wessel committed
790 791
static void kgdb_console_write(struct console *co, const char *s,
   unsigned count)
Jason Wessel's avatar
Jason Wessel committed
792 793 794 795 796
{
	unsigned long flags;

	/* If we're debugging, or KGDB has not connected, don't try
	 * and print. */
797
	if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode)
Jason Wessel's avatar
Jason Wessel committed
798 799
		return;

800
	flags = hard_local_irq_save();
801
	gdbstub_msg_write(s, count);
802
	hard_local_irq_restore(flags);
Jason Wessel's avatar
Jason Wessel committed
803 804 805 806 807 808 809 810 811 812
}

static struct console kgdbcons = {
	.name		= "kgdb",
	.write		= kgdb_console_write,
	.flags		= CON_PRINTBUFFER | CON_ENABLED,
	.index		= -1,
};

#ifdef CONFIG_MAGIC_SYSRQ
813
static void sysrq_handle_dbg(int key)
Jason Wessel's avatar
Jason Wessel committed
814
{
815
	if (!dbg_io_ops) {
816
		pr_crit("ERROR: No KGDB I/O module available\n");
Jason Wessel's avatar
Jason Wessel committed
817 818
		return;
	}
819 820 821
	if (!kgdb_connected) {
#ifdef CONFIG_KGDB_KDB
		if (!dbg_kdb_mode)
822
			pr_crit("KGDB or $3#33 for KDB\n");
823
#else
824
		pr_crit("Entering KGDB\n");
825 826
#endif
	}
Jason Wessel's avatar
Jason Wessel committed
827 828 829 830

	kgdb_breakpoint();
}

831 832
static struct sysrq_key_op sysrq_dbg_op = {
	.handler	= sysrq_handle_dbg,
833
	.help_msg	= "debug(g)",
834
	.action_msg	= "DEBUG",
Jason Wessel's avatar
Jason Wessel committed
835 836 837
};
#endif

838 839 840 841
static int kgdb_panic_event(struct notifier_block *self,
			    unsigned long val,
			    void *data)
{
842 843 844 845 846 847 848 849 850
	/*
	 * Avoid entering the debugger if we were triggered due to a panic
	 * We don't want to get stuck waiting for input from user in such case.
	 * panic_timeout indicates the system should automatically
	 * reboot on panic.
	 */
	if (panic_timeout)
		return NOTIFY_DONE;

851 852 853 854 855 856 857 858 859 860 861
	if (dbg_kdb_mode)
		kdb_printf("PANIC: %s\n", (char *)data);
	kgdb_breakpoint();
	return NOTIFY_DONE;
}

static struct notifier_block kgdb_panic_event_nb = {
       .notifier_call	= kgdb_panic_event,
       .priority	= INT_MAX,
};

862 863 864 865 866 867 868 869 870 871 872 873
void __weak kgdb_arch_late(void)
{
}

void __init dbg_late_init(void)
{
	dbg_is_early = false;
	if (kgdb_io_module_registered)
		kgdb_arch_late();
	kdb_init(KDB_INIT_FULL);
}

874 875 876
static int
dbg_notify_reboot(struct notifier_block *this, unsigned long code, void *x)
{
877 878 879 880 881 882 883 884 885 886 887 888
	/*
	 * Take the following action on reboot notify depending on value:
	 *    1 == Enter debugger
	 *    0 == [the default] detatch debug client
	 *   -1 == Do nothing... and use this until the board resets
	 */
	switch (kgdbreboot) {
	case 1:
		kgdb_breakpoint();
	case -1:
		goto done;
	}
889 890
	if (!dbg_kdb_mode)
		gdbstub_exit(code);
891
done:
892 893 894 895 896 897 898 899 900
	return NOTIFY_DONE;
}

static struct notifier_block dbg_reboot_notifier = {
	.notifier_call		= dbg_notify_reboot,
	.next			= NULL,
	.priority		= INT_MAX,
};

Jason Wessel's avatar
Jason Wessel committed
901 902 903 904 905
static void kgdb_register_callbacks(void)
{
	if (!kgdb_io_module_registered) {
		kgdb_io_module_registered = 1;
		kgdb_arch_init();
906 907
		if (!dbg_is_early)
			kgdb_arch_late();
Jason Wessel's avatar
Jason Wessel committed
908
		register_module_notifier(&dbg_module_load_nb);
909
		register_reboot_notifier(&dbg_reboot_notifier);
910 911
		atomic_notifier_chain_register(&panic_notifier_list,
					       &kgdb_panic_event_nb);
Jason Wessel's avatar
Jason Wessel committed
912
#ifdef CONFIG_MAGIC_SYSRQ
913
		register_sysrq_key('g', &sysrq_dbg_op);
Jason Wessel's avatar
Jason Wessel committed
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
#endif
		if (kgdb_use_con && !kgdb_con_registered) {
			register_console(&kgdbcons);
			kgdb_con_registered = 1;
		}
	}
}

static void kgdb_unregister_callbacks(void)
{
	/*
	 * When this routine is called KGDB should unregister from the
	 * panic handler and clean up, making sure it is not handling any
	 * break exceptions at the time.
	 */
	if (kgdb_io_module_registered) {
		kgdb_io_module_registered = 0;
931
		unregister_reboot_notifier(&dbg_reboot_notifier);
Jason Wessel's avatar
Jason Wessel committed
932
		unregister_module_notifier(&dbg_module_load_nb);
933 934
		atomic_notifier_chain_unregister(&panic_notifier_list,
					       &kgdb_panic_event_nb);
Jason Wessel's avatar
Jason Wessel committed
935 936
		kgdb_arch_exit();
#ifdef CONFIG_MAGIC_SYSRQ
937
		unregister_sysrq_key('g', &sysrq_dbg_op);
Jason Wessel's avatar
Jason Wessel committed
938 939 940 941 942 943 944 945
#endif
		if (kgdb_con_registered) {
			unregister_console(&kgdbcons);
			kgdb_con_registered = 0;
		}
	}
}

946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
/*
 * There are times a tasklet needs to be used vs a compiled in
 * break point so as to cause an exception outside a kgdb I/O module,
 * such as is the case with kgdboe, where calling a breakpoint in the
 * I/O driver itself would be fatal.
 */
static void kgdb_tasklet_bpt(unsigned long ing)
{
	kgdb_breakpoint();
	atomic_set(&kgdb_break_tasklet_var, 0);
}

static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);

void kgdb_schedule_breakpoint(void)
{
	if (atomic_read(&kgdb_break_tasklet_var) ||
		atomic_read(&kgdb_active) != -1 ||
		atomic_read(&kgdb_setting_breakpoint))
		return;
	atomic_inc(&kgdb_break_tasklet_var);
	tasklet_schedule(&kgdb_tasklet_breakpoint);
}
EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint);

Jason Wessel's avatar
Jason Wessel committed
971 972 973 974
static void kgdb_initial_breakpoint(void)
{
	kgdb_break_asap = 0;

975
	pr_crit("Waiting for connection from remote gdb...\n");
Jason Wessel's avatar
Jason Wessel committed
976 977 978 979
	kgdb_breakpoint();
}

/**
980
 *	kgdb_register_io_module - register KGDB IO module
981
 *	@new_dbg_io_ops: the io ops vector
Jason Wessel's avatar
Jason Wessel committed
982 983 984
 *
 *	Register it with the KGDB core.
 */
985
int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
Jason Wessel's avatar
Jason Wessel committed
986 987 988 989 990
{
	int err;

	spin_lock(&kgdb_registration_lock);

991
	if (dbg_io_ops) {
Jason Wessel's avatar
Jason Wessel committed
992 993
		spin_unlock(&kgdb_registration_lock);

994
		pr_err("Another I/O driver is already registered with KGDB\n");
Jason Wessel's avatar
Jason Wessel committed
995 996 997
		return -EBUSY;
	}

998 999
	if (new_dbg_io_ops->init) {
		err = new_dbg_io_ops->init();
Jason Wessel's avatar
Jason Wessel committed
1000 1001 1002 1003 1004 1005
		if (err) {
			spin_unlock(&kgdb_registration_lock);
			return err;
		}
	}

1006
	dbg_io_ops = new_dbg_io_ops;
Jason Wessel's avatar
Jason Wessel committed
1007 1008 1009

	spin_unlock(&kgdb_registration_lock);

1010
	pr_info("Registered I/O driver %s\n", new_dbg_io_ops->name);
Jason Wessel's avatar
Jason Wessel committed
1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023

	/* Arm KGDB now. */
	kgdb_register_callbacks();

	if (kgdb_break_asap)
		kgdb_initial_breakpoint();

	return 0;
}
EXPORT_SYMBOL_GPL(kgdb_register_io_module);

/**
 *	kkgdb_unregister_io_module - unregister KGDB IO module
1024
 *	@old_dbg_io_ops: the io ops vector
Jason Wessel's avatar
Jason Wessel committed
1025 1026 1027
 *
 *	Unregister it with the KGDB core.
 */
1028
void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)
Jason Wessel's avatar
Jason Wessel committed
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
{
	BUG_ON(kgdb_connected);

	/*
	 * KGDB is no longer able to communicate out, so
	 * unregister our callbacks and reset state.
	 */
	kgdb_unregister_callbacks();

	spin_lock(&kgdb_registration_lock);

1040 1041
	WARN_ON_ONCE(dbg_io_ops != old_dbg_io_ops);
	dbg_io_ops = NULL;
Jason Wessel's avatar
Jason Wessel committed
1042 1043 1044

	spin_unlock(&kgdb_registration_lock);

1045
	pr_info("Unregistered I/O driver %s, debugger disabled\n",
1046
		old_dbg_io_ops->name);
Jason Wessel's avatar
Jason Wessel committed
1047 1048 1049
}
EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);

1050 1051 1052
int dbg_io_get_char(void)
{
	int ret = dbg_io_ops->read_char();
1053 1054
	if (ret == NO_POLL_CHAR)
		return -1;
1055 1056 1057 1058 1059 1060 1061
	if (!dbg_kdb_mode)
		return ret;
	if (ret == 127)
		return 8;
	return ret;
}

Jason Wessel's avatar
Jason Wessel committed
1062 1063 1064 1065 1066 1067 1068 1069
/**
 * kgdb_breakpoint - generate breakpoint exception
 *
 * This function will generate a breakpoint exception.  It is used at the
 * beginning of a program to sync up with a debugger and can be used
 * otherwise as a quick means to stop program execution and "break" into
 * the debugger.
 */
1070
noinline void kgdb_breakpoint(void)
Jason Wessel's avatar
Jason Wessel committed
1071
{
1072
	atomic_inc(&kgdb_setting_breakpoint);
Jason Wessel's avatar
Jason Wessel committed
1073 1074 1075
	wmb(); /* Sync point before breakpoint */
	arch_kgdb_breakpoint();
	wmb(); /* Sync point after breakpoint */
1076
	atomic_dec(&kgdb_setting_breakpoint);
Jason Wessel's avatar
Jason Wessel committed
1077 1078 1079 1080 1081 1082 1083
}
EXPORT_SYMBOL_GPL(kgdb_breakpoint);

static int __init opt_kgdb_wait(char *str)
{
	kgdb_break_asap = 1;

1084
	kdb_init(KDB_INIT_EARLY);
Jason Wessel's avatar
Jason Wessel committed
1085 1086 1087 1088 1089 1090 1091
	if (kgdb_io_module_registered)
		kgdb_initial_breakpoint();

	return 0;
}

early_param("kgdbwait", opt_kgdb_wait);