kgdb.c 18.6 KB
Newer Older
I
Ingo Molnar 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 */

/*
 * Copyright (C) 2004 Amit S. Kale <amitkale@linsyssoft.com>
 * Copyright (C) 2000-2001 VERITAS Software Corporation.
 * Copyright (C) 2002 Andi Kleen, SuSE Labs
 * Copyright (C) 2004 LinSysSoft Technologies Pvt. Ltd.
 * Copyright (C) 2007 MontaVista Software, Inc.
 * Copyright (C) 2007-2008 Jason Wessel, Wind River Systems, Inc.
 */
/****************************************************************************
 *  Contributor:     Lake Stevens Instrument Division$
 *  Written by:      Glenn Engel $
 *  Updated by:	     Amit Kale<akale@veritas.com>
 *  Updated by:	     Tom Rini <trini@kernel.crashing.org>
 *  Updated by:	     Jason Wessel <jason.wessel@windriver.com>
 *  Modified for 386 by Jim Kingdon, Cygnus Support.
 *  Origianl kgdb, compatibility with 2.1.xx kernel by
 *  David Grothe <dave@gcom.com>
 *  Integrated into 2.2.5 kernel by Tigran Aivazian <tigran@sco.com>
 *  X86_64 changes from Andi Kleen's patch merged by Jim Houston
 */
#include <linux/spinlock.h>
#include <linux/kdebug.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/ptrace.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/kgdb.h>
#include <linux/init.h>
#include <linux/smp.h>
J
Jason Wessel 已提交
44
#include <linux/nmi.h>
45
#include <linux/hw_breakpoint.h>
I
Ingo Molnar 已提交
46

47
#include <asm/debugreg.h>
I
Ingo Molnar 已提交
48 49
#include <asm/apicdef.h>
#include <asm/system.h>
I
Ingo Molnar 已提交
50
#include <asm/apic.h>
51
#include <asm/nmi.h>
I
Ingo Molnar 已提交
52

53
struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] =
I
Ingo Molnar 已提交
54
{
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
#ifdef CONFIG_X86_32
	{ "ax", 4, offsetof(struct pt_regs, ax) },
	{ "cx", 4, offsetof(struct pt_regs, cx) },
	{ "dx", 4, offsetof(struct pt_regs, dx) },
	{ "bx", 4, offsetof(struct pt_regs, bx) },
	{ "sp", 4, offsetof(struct pt_regs, sp) },
	{ "bp", 4, offsetof(struct pt_regs, bp) },
	{ "si", 4, offsetof(struct pt_regs, si) },
	{ "di", 4, offsetof(struct pt_regs, di) },
	{ "ip", 4, offsetof(struct pt_regs, ip) },
	{ "flags", 4, offsetof(struct pt_regs, flags) },
	{ "cs", 4, offsetof(struct pt_regs, cs) },
	{ "ss", 4, offsetof(struct pt_regs, ss) },
	{ "ds", 4, offsetof(struct pt_regs, ds) },
	{ "es", 4, offsetof(struct pt_regs, es) },
	{ "fs", 4, -1 },
	{ "gs", 4, -1 },
#else
	{ "ax", 8, offsetof(struct pt_regs, ax) },
	{ "bx", 8, offsetof(struct pt_regs, bx) },
	{ "cx", 8, offsetof(struct pt_regs, cx) },
	{ "dx", 8, offsetof(struct pt_regs, dx) },
	{ "si", 8, offsetof(struct pt_regs, dx) },
	{ "di", 8, offsetof(struct pt_regs, di) },
	{ "bp", 8, offsetof(struct pt_regs, bp) },
	{ "sp", 8, offsetof(struct pt_regs, sp) },
	{ "r8", 8, offsetof(struct pt_regs, r8) },
	{ "r9", 8, offsetof(struct pt_regs, r9) },
	{ "r10", 8, offsetof(struct pt_regs, r10) },
	{ "r11", 8, offsetof(struct pt_regs, r11) },
	{ "r12", 8, offsetof(struct pt_regs, r12) },
	{ "r13", 8, offsetof(struct pt_regs, r13) },
	{ "r14", 8, offsetof(struct pt_regs, r14) },
	{ "r15", 8, offsetof(struct pt_regs, r15) },
	{ "ip", 8, offsetof(struct pt_regs, ip) },
	{ "flags", 4, offsetof(struct pt_regs, flags) },
	{ "cs", 4, offsetof(struct pt_regs, cs) },
	{ "ss", 4, offsetof(struct pt_regs, ss) },
93
#endif
94 95 96 97 98
};

int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
{
	if (
I
Ingo Molnar 已提交
99
#ifdef CONFIG_X86_32
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
	    regno == GDB_SS || regno == GDB_FS || regno == GDB_GS ||
#endif
	    regno == GDB_SP || regno == GDB_ORIG_AX)
		return 0;

	if (dbg_reg_def[regno].offset != -1)
		memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
		       dbg_reg_def[regno].size);
	return 0;
}

char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
{
	if (regno == GDB_ORIG_AX) {
		memcpy(mem, &regs->orig_ax, sizeof(regs->orig_ax));
		return "orig_ax";
116
	}
117 118 119 120 121 122 123 124
	if (regno >= DBG_MAX_REG_NUM || regno < 0)
		return NULL;

	if (dbg_reg_def[regno].offset != -1)
		memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
		       dbg_reg_def[regno].size);

#ifdef CONFIG_X86_32
125
	switch (regno) {
126 127 128 129 130 131 132 133 134 135 136 137 138
	case GDB_SS:
		if (!user_mode_vm(regs))
			*(unsigned long *)mem = __KERNEL_DS;
		break;
	case GDB_SP:
		if (!user_mode_vm(regs))
			*(unsigned long *)mem = kernel_stack_pointer(regs);
		break;
	case GDB_GS:
	case GDB_FS:
		*(unsigned long *)mem = 0xFFFF;
		break;
	}
139
#endif
140
	return dbg_reg_def[regno].name;
I
Ingo Molnar 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
}

/**
 *	sleeping_thread_to_gdb_regs - Convert ptrace regs to GDB regs
 *	@gdb_regs: A pointer to hold the registers in the order GDB wants.
 *	@p: The &struct task_struct of the desired process.
 *
 *	Convert the register values of the sleeping process in @p to
 *	the format that GDB expects.
 *	This function is called when kgdb does not have access to the
 *	&struct pt_regs and therefore it should fill the gdb registers
 *	@gdb_regs with what has	been saved in &struct thread_struct
 *	thread field during switch_to.
 */
void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
{
157 158 159
#ifndef CONFIG_X86_32
	u32 *gdb_regs32 = (u32 *)gdb_regs;
#endif
I
Ingo Molnar 已提交
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
	gdb_regs[GDB_AX]	= 0;
	gdb_regs[GDB_BX]	= 0;
	gdb_regs[GDB_CX]	= 0;
	gdb_regs[GDB_DX]	= 0;
	gdb_regs[GDB_SI]	= 0;
	gdb_regs[GDB_DI]	= 0;
	gdb_regs[GDB_BP]	= *(unsigned long *)p->thread.sp;
#ifdef CONFIG_X86_32
	gdb_regs[GDB_DS]	= __KERNEL_DS;
	gdb_regs[GDB_ES]	= __KERNEL_DS;
	gdb_regs[GDB_PS]	= 0;
	gdb_regs[GDB_CS]	= __KERNEL_CS;
	gdb_regs[GDB_PC]	= p->thread.ip;
	gdb_regs[GDB_SS]	= __KERNEL_DS;
	gdb_regs[GDB_FS]	= 0xFFFF;
	gdb_regs[GDB_GS]	= 0xFFFF;
#else
177 178 179
	gdb_regs32[GDB_PS]	= *(unsigned long *)(p->thread.sp + 8);
	gdb_regs32[GDB_CS]	= __KERNEL_CS;
	gdb_regs32[GDB_SS]	= __KERNEL_DS;
180
	gdb_regs[GDB_PC]	= 0;
I
Ingo Molnar 已提交
181 182 183 184 185 186 187 188 189 190 191 192
	gdb_regs[GDB_R8]	= 0;
	gdb_regs[GDB_R9]	= 0;
	gdb_regs[GDB_R10]	= 0;
	gdb_regs[GDB_R11]	= 0;
	gdb_regs[GDB_R12]	= 0;
	gdb_regs[GDB_R13]	= 0;
	gdb_regs[GDB_R14]	= 0;
	gdb_regs[GDB_R15]	= 0;
#endif
	gdb_regs[GDB_SP]	= p->thread.sp;
}

J
Jason Wessel 已提交
193 194 195
static struct hw_breakpoint {
	unsigned		enabled;
	unsigned long		addr;
196 197
	int			len;
	int			type;
198
	struct perf_event	* __percpu *pev;
199
} breakinfo[HBP_NUM];
J
Jason Wessel 已提交
200

201 202
static unsigned long early_dr7;

J
Jason Wessel 已提交
203 204 205 206
static void kgdb_correct_hw_break(void)
{
	int breakno;

207
	for (breakno = 0; breakno < HBP_NUM; breakno++) {
208 209 210 211 212 213
		struct perf_event *bp;
		struct arch_hw_breakpoint *info;
		int val;
		int cpu = raw_smp_processor_id();
		if (!breakinfo[breakno].enabled)
			continue;
214 215 216 217 218 219 220 221
		if (dbg_is_early) {
			set_debugreg(breakinfo[breakno].addr, breakno);
			early_dr7 |= encode_dr7(breakno,
						breakinfo[breakno].len,
						breakinfo[breakno].type);
			set_debugreg(early_dr7, 7);
			continue;
		}
222 223 224 225 226 227 228 229 230 231 232 233 234
		bp = *per_cpu_ptr(breakinfo[breakno].pev, cpu);
		info = counter_arch_bp(bp);
		if (bp->attr.disabled != 1)
			continue;
		bp->attr.bp_addr = breakinfo[breakno].addr;
		bp->attr.bp_len = breakinfo[breakno].len;
		bp->attr.bp_type = breakinfo[breakno].type;
		info->address = breakinfo[breakno].addr;
		info->len = breakinfo[breakno].len;
		info->type = breakinfo[breakno].type;
		val = arch_install_hw_breakpoint(bp);
		if (!val)
			bp->attr.disabled = 0;
J
Jason Wessel 已提交
235
	}
236 237
	if (!dbg_is_early)
		hw_breakpoint_restore();
J
Jason Wessel 已提交
238 239
}

240 241 242 243 244 245
static int hw_break_reserve_slot(int breakno)
{
	int cpu;
	int cnt = 0;
	struct perf_event **pevent;

246 247 248
	if (dbg_is_early)
		return 0;

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
	for_each_online_cpu(cpu) {
		cnt++;
		pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
		if (dbg_reserve_bp_slot(*pevent))
			goto fail;
	}

	return 0;

fail:
	for_each_online_cpu(cpu) {
		cnt--;
		if (!cnt)
			break;
		pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
		dbg_release_bp_slot(*pevent);
	}
	return -1;
}

static int hw_break_release_slot(int breakno)
{
	struct perf_event **pevent;
	int cpu;

274 275 276
	if (dbg_is_early)
		return 0;

277 278 279 280
	for_each_online_cpu(cpu) {
		pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
		if (dbg_release_bp_slot(*pevent))
			/*
L
Lucas De Marchi 已提交
281
			 * The debugger is responsible for handing the retry on
282 283 284 285 286 287 288
			 * remove failure.
			 */
			return -1;
	}
	return 0;
}

J
Jason Wessel 已提交
289 290 291 292 293
static int
kgdb_remove_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype)
{
	int i;

294
	for (i = 0; i < HBP_NUM; i++)
J
Jason Wessel 已提交
295 296
		if (breakinfo[i].addr == addr && breakinfo[i].enabled)
			break;
297
	if (i == HBP_NUM)
J
Jason Wessel 已提交
298 299
		return -1;

300 301 302 303
	if (hw_break_release_slot(i)) {
		printk(KERN_ERR "Cannot remove hw breakpoint at %lx\n", addr);
		return -1;
	}
J
Jason Wessel 已提交
304 305 306 307 308 309 310 311
	breakinfo[i].enabled = 0;

	return 0;
}

static void kgdb_remove_all_hw_break(void)
{
	int i;
312 313
	int cpu = raw_smp_processor_id();
	struct perf_event *bp;
J
Jason Wessel 已提交
314

315
	for (i = 0; i < HBP_NUM; i++) {
316 317 318
		if (!breakinfo[i].enabled)
			continue;
		bp = *per_cpu_ptr(breakinfo[i].pev, cpu);
319 320 321
		if (!bp->attr.disabled) {
			arch_uninstall_hw_breakpoint(bp);
			bp->attr.disabled = 1;
322
			continue;
323
		}
324 325 326
		if (dbg_is_early)
			early_dr7 &= ~encode_dr7(i, breakinfo[i].len,
						 breakinfo[i].type);
327 328 329 330
		else if (hw_break_release_slot(i))
			printk(KERN_ERR "KGDB: hw bpt remove failed %lx\n",
			       breakinfo[i].addr);
		breakinfo[i].enabled = 0;
331
	}
J
Jason Wessel 已提交
332 333 334 335 336 337 338
}

static int
kgdb_set_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype)
{
	int i;

339
	for (i = 0; i < HBP_NUM; i++)
J
Jason Wessel 已提交
340 341
		if (!breakinfo[i].enabled)
			break;
342
	if (i == HBP_NUM)
J
Jason Wessel 已提交
343 344 345 346
		return -1;

	switch (bptype) {
	case BP_HARDWARE_BREAKPOINT:
347 348
		len = 1;
		breakinfo[i].type = X86_BREAKPOINT_EXECUTE;
J
Jason Wessel 已提交
349 350
		break;
	case BP_WRITE_WATCHPOINT:
351
		breakinfo[i].type = X86_BREAKPOINT_WRITE;
J
Jason Wessel 已提交
352 353
		break;
	case BP_ACCESS_WATCHPOINT:
354
		breakinfo[i].type = X86_BREAKPOINT_RW;
J
Jason Wessel 已提交
355 356 357 358
		break;
	default:
		return -1;
	}
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
	switch (len) {
	case 1:
		breakinfo[i].len = X86_BREAKPOINT_LEN_1;
		break;
	case 2:
		breakinfo[i].len = X86_BREAKPOINT_LEN_2;
		break;
	case 4:
		breakinfo[i].len = X86_BREAKPOINT_LEN_4;
		break;
#ifdef CONFIG_X86_64
	case 8:
		breakinfo[i].len = X86_BREAKPOINT_LEN_8;
		break;
#endif
	default:
J
Jason Wessel 已提交
375
		return -1;
376
	}
J
Jason Wessel 已提交
377
	breakinfo[i].addr = addr;
378 379 380 381
	if (hw_break_reserve_slot(i)) {
		breakinfo[i].addr = 0;
		return -1;
	}
382
	breakinfo[i].enabled = 1;
J
Jason Wessel 已提交
383 384 385 386 387 388 389 390 391 392 393 394

	return 0;
}

/**
 *	kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb.
 *	@regs: Current &struct pt_regs.
 *
 *	This function will be called if the particular architecture must
 *	disable hardware debugging while it is processing gdb packets or
 *	handling exception.
 */
395
static void kgdb_disable_hw_debug(struct pt_regs *regs)
J
Jason Wessel 已提交
396
{
397 398 399 400
	int i;
	int cpu = raw_smp_processor_id();
	struct perf_event *bp;

J
Jason Wessel 已提交
401 402
	/* Disable hardware debugging while we are in kgdb: */
	set_debugreg(0UL, 7);
403
	for (i = 0; i < HBP_NUM; i++) {
404 405
		if (!breakinfo[i].enabled)
			continue;
406 407 408 409 410
		if (dbg_is_early) {
			early_dr7 &= ~encode_dr7(i, breakinfo[i].len,
						 breakinfo[i].type);
			continue;
		}
411 412 413 414 415 416
		bp = *per_cpu_ptr(breakinfo[i].pev, cpu);
		if (bp->attr.disabled == 1)
			continue;
		arch_uninstall_hw_breakpoint(bp);
		bp->attr.disabled = 1;
	}
J
Jason Wessel 已提交
417 418
}

I
Ingo Molnar 已提交
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
#ifdef CONFIG_SMP
/**
 *	kgdb_roundup_cpus - Get other CPUs into a holding pattern
 *	@flags: Current IRQ state
 *
 *	On SMP systems, we need to get the attention of the other CPUs
 *	and get them be in a known state.  This should do what is needed
 *	to get the other CPUs to call kgdb_wait(). Note that on some arches,
 *	the NMI approach is not used for rounding up all the CPUs. For example,
 *	in case of MIPS, smp_call_function() is used to roundup CPUs. In
 *	this case, we have to make sure that interrupts are enabled before
 *	calling smp_call_function(). The argument to this function is
 *	the flags that will be used when restoring the interrupts. There is
 *	local_irq_save() call before kgdb_roundup_cpus().
 *
 *	On non-SMP systems, this is not called.
 */
void kgdb_roundup_cpus(unsigned long flags)
{
438
	apic->send_IPI_allbutself(APIC_DM_NMI);
I
Ingo Molnar 已提交
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
}
#endif

/**
 *	kgdb_arch_handle_exception - Handle architecture specific GDB packets.
 *	@vector: The error vector of the exception that happened.
 *	@signo: The signal number of the exception that happened.
 *	@err_code: The error code of the exception that happened.
 *	@remcom_in_buffer: The buffer of the packet we have read.
 *	@remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
 *	@regs: The &struct pt_regs of the current process.
 *
 *	This function MUST handle the 'c' and 's' command packets,
 *	as well packets to set / remove a hardware breakpoint, if used.
 *	If there are additional packets which the hardware needs to handle,
 *	they are handled here.  The code should return -1 if it wants to
 *	process more packets, and a %0 or %1 if it wants to exit from the
 *	kgdb callback.
 */
int kgdb_arch_handle_exception(int e_vector, int signo, int err_code,
			       char *remcomInBuffer, char *remcomOutBuffer,
			       struct pt_regs *linux_regs)
{
	unsigned long addr;
	char *ptr;

	switch (remcomInBuffer[0]) {
	case 'c':
	case 's':
		/* try to read optional parameter, pc unchanged if no parm */
		ptr = &remcomInBuffer[1];
		if (kgdb_hex2long(&ptr, &addr))
			linux_regs->ip = addr;
472 473
	case 'D':
	case 'k':
I
Ingo Molnar 已提交
474
		/* clear the trace bit */
H
Harvey Harrison 已提交
475
		linux_regs->flags &= ~X86_EFLAGS_TF;
I
Ingo Molnar 已提交
476 477 478 479
		atomic_set(&kgdb_cpu_doing_single_step, -1);

		/* set the trace bit if we're stepping */
		if (remcomInBuffer[0] == 's') {
H
Harvey Harrison 已提交
480
			linux_regs->flags |= X86_EFLAGS_TF;
481 482
			atomic_set(&kgdb_cpu_doing_single_step,
				   raw_smp_processor_id());
I
Ingo Molnar 已提交
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
		}

		return 0;
	}

	/* this means that we do not want to exit from the handler: */
	return -1;
}

static inline int
single_step_cont(struct pt_regs *regs, struct die_args *args)
{
	/*
	 * Single step exception from kernel space to user space so
	 * eat the exception and continue the process:
	 */
	printk(KERN_ERR "KGDB: trap/step from kernel to user space, "
			"resuming...\n");
	kgdb_arch_handle_exception(args->trapnr, args->signr,
				   args->err, "c", "", regs);
503 504 505 506 507
	/*
	 * Reset the BS bit in dr6 (pointed by args->err) to
	 * denote completion of processing
	 */
	(*(unsigned long *)ERR_PTR(args->err)) &= ~DR_STEP;
I
Ingo Molnar 已提交
508 509 510 511

	return NOTIFY_STOP;
}

J
Jason Wessel 已提交
512 513
static int was_in_debug_nmi[NR_CPUS];

I
Ingo Molnar 已提交
514 515 516 517 518 519 520 521 522
static int __kgdb_notify(struct die_args *args, unsigned long cmd)
{
	struct pt_regs *regs = args->regs;

	switch (cmd) {
	case DIE_NMI:
		if (atomic_read(&kgdb_active) != -1) {
			/* KGDB CPU roundup */
			kgdb_nmicallback(raw_smp_processor_id(), regs);
J
Jason Wessel 已提交
523 524
			was_in_debug_nmi[raw_smp_processor_id()] = 1;
			touch_nmi_watchdog();
I
Ingo Molnar 已提交
525 526 527 528
			return NOTIFY_STOP;
		}
		return NOTIFY_DONE;

J
Jason Wessel 已提交
529 530 531
	case DIE_NMIUNKNOWN:
		if (was_in_debug_nmi[raw_smp_processor_id()]) {
			was_in_debug_nmi[raw_smp_processor_id()] = 0;
I
Ingo Molnar 已提交
532 533 534 535 536
			return NOTIFY_STOP;
		}
		return NOTIFY_DONE;

	case DIE_DEBUG:
537
		if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
538 539 540 541 542 543 544 545
			if (user_mode(regs))
				return single_step_cont(regs, args);
			break;
		} else if (test_thread_flag(TIF_SINGLESTEP))
			/* This means a user thread is single stepping
			 * a system call which should be ignored
			 */
			return NOTIFY_DONE;
I
Ingo Molnar 已提交
546 547 548 549 550 551
		/* fall through */
	default:
		if (user_mode(regs))
			return NOTIFY_DONE;
	}

552
	if (kgdb_handle_exception(args->trapnr, args->signr, cmd, regs))
I
Ingo Molnar 已提交
553 554
		return NOTIFY_DONE;

555 556
	/* Must touch watchdog before return to normal operation */
	touch_nmi_watchdog();
I
Ingo Molnar 已提交
557 558 559
	return NOTIFY_STOP;
}

560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
int kgdb_ll_trap(int cmd, const char *str,
		 struct pt_regs *regs, long err, int trap, int sig)
{
	struct die_args args = {
		.regs	= regs,
		.str	= str,
		.err	= err,
		.trapnr	= trap,
		.signr	= sig,

	};

	if (!kgdb_io_module_registered)
		return NOTIFY_DONE;

	return __kgdb_notify(&args, cmd);
}

I
Ingo Molnar 已提交
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
static int
kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr)
{
	unsigned long flags;
	int ret;

	local_irq_save(flags);
	ret = __kgdb_notify(ptr, cmd);
	local_irq_restore(flags);

	return ret;
}

static struct notifier_block kgdb_notifier = {
	.notifier_call	= kgdb_notify,

	/*
	 * Lowest-prio notifier priority, we want to be notified last:
	 */
597
	.priority	= NMI_LOCAL_LOW_PRIOR,
I
Ingo Molnar 已提交
598 599 600 601 602 603 604 605 606
};

/**
 *	kgdb_arch_init - Perform any architecture specific initalization.
 *
 *	This function will handle the initalization of any architecture
 *	specific callbacks.
 */
int kgdb_arch_init(void)
607 608 609 610
{
	return register_die_notifier(&kgdb_notifier);
}

611
static void kgdb_hw_overflow_handler(struct perf_event *event,
612 613
		struct perf_sample_data *data, struct pt_regs *regs)
{
614 615 616 617 618 619
	struct task_struct *tsk = current;
	int i;

	for (i = 0; i < 4; i++)
		if (breakinfo[i].enabled)
			tsk->thread.debugreg6 |= (DR_TRAP0 << i);
620 621
}

622
void kgdb_arch_late(void)
I
Ingo Molnar 已提交
623
{
624 625 626 627 628 629 630 631 632
	int i, cpu;
	struct perf_event_attr attr;
	struct perf_event **pevent;

	/*
	 * Pre-allocate the hw breakpoint structions in the non-atomic
	 * portion of kgdb because this operation requires mutexs to
	 * complete.
	 */
633
	hw_breakpoint_init(&attr);
634 635 636 637
	attr.bp_addr = (unsigned long)kgdb_arch_init;
	attr.bp_len = HW_BREAKPOINT_LEN_1;
	attr.bp_type = HW_BREAKPOINT_W;
	attr.disabled = 1;
638
	for (i = 0; i < HBP_NUM; i++) {
639 640
		if (breakinfo[i].pev)
			continue;
641
		breakinfo[i].pev = register_wide_hw_breakpoint(&attr, NULL, NULL);
J
Jason Wessel 已提交
642
		if (IS_ERR((void * __force)breakinfo[i].pev)) {
643 644
			printk(KERN_ERR "kgdb: Could not allocate hw"
			       "breakpoints\nDisabling the kernel debugger\n");
645 646
			breakinfo[i].pev = NULL;
			kgdb_arch_exit();
647
			return;
648 649 650 651
		}
		for_each_online_cpu(cpu) {
			pevent = per_cpu_ptr(breakinfo[i].pev, cpu);
			pevent[0]->hw.sample_period = 1;
652
			pevent[0]->overflow_handler = kgdb_hw_overflow_handler;
653 654 655 656 657 658
			if (pevent[0]->destroy != NULL) {
				pevent[0]->destroy = NULL;
				release_bp_slot(*pevent);
			}
		}
	}
I
Ingo Molnar 已提交
659 660 661 662 663 664 665 666 667 668
}

/**
 *	kgdb_arch_exit - Perform any architecture specific uninitalization.
 *
 *	This function will handle the uninitalization of any architecture
 *	specific callbacks, for dynamic registration and unregistration.
 */
void kgdb_arch_exit(void)
{
669 670 671 672 673 674 675
	int i;
	for (i = 0; i < 4; i++) {
		if (breakinfo[i].pev) {
			unregister_wide_hw_breakpoint(breakinfo[i].pev);
			breakinfo[i].pev = NULL;
		}
	}
I
Ingo Molnar 已提交
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
	unregister_die_notifier(&kgdb_notifier);
}

/**
 *
 *	kgdb_skipexception - Bail out of KGDB when we've been triggered.
 *	@exception: Exception vector number
 *	@regs: Current &struct pt_regs.
 *
 *	On some architectures we need to skip a breakpoint exception when
 *	it occurs after a breakpoint has been removed.
 *
 * Skip an int3 exception when it occurs after a breakpoint has been
 * removed. Backtrack eip by 1 since the int3 would have caused it to
 * increment by 1.
 */
int kgdb_skipexception(int exception, struct pt_regs *regs)
{
	if (exception == 3 && kgdb_isremovedbreak(regs->ip - 1)) {
		regs->ip -= 1;
		return 1;
	}
	return 0;
}

unsigned long kgdb_arch_pc(int exception, struct pt_regs *regs)
{
	if (exception == 3)
		return instruction_pointer(regs) - 1;
	return instruction_pointer(regs);
}

J
Jason Wessel 已提交
708 709 710 711 712
void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
{
	regs->ip = ip;
}

I
Ingo Molnar 已提交
713 714 715
struct kgdb_arch arch_kgdb_ops = {
	/* Breakpoint instruction: */
	.gdb_bpt_instr		= { 0xcc },
J
Jason Wessel 已提交
716 717 718
	.flags			= KGDB_HW_BREAKPOINT,
	.set_hw_breakpoint	= kgdb_set_hw_break,
	.remove_hw_breakpoint	= kgdb_remove_hw_break,
719
	.disable_hw_break	= kgdb_disable_hw_debug,
J
Jason Wessel 已提交
720 721
	.remove_all_hw_break	= kgdb_remove_all_hw_break,
	.correct_hw_break	= kgdb_correct_hw_break,
I
Ingo Molnar 已提交
722
};