kgdb.c revision 91b152aa85bbcf076e269565394c31964f940371
1/* 2 * This program is free software; you can redistribute it and/or modify it 3 * under the terms of the GNU General Public License as published by the 4 * Free Software Foundation; either version 2, or (at your option) any 5 * later version. 6 * 7 * This program is distributed in the hope that it will be useful, but 8 * WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 10 * General Public License for more details. 11 * 12 */ 13 14/* 15 * Copyright (C) 2004 Amit S. Kale <amitkale@linsyssoft.com> 16 * Copyright (C) 2000-2001 VERITAS Software Corporation. 17 * Copyright (C) 2002 Andi Kleen, SuSE Labs 18 * Copyright (C) 2004 LinSysSoft Technologies Pvt. Ltd. 19 * Copyright (C) 2007 MontaVista Software, Inc. 20 * Copyright (C) 2007-2008 Jason Wessel, Wind River Systems, Inc. 21 */ 22/**************************************************************************** 23 * Contributor: Lake Stevens Instrument Division$ 24 * Written by: Glenn Engel $ 25 * Updated by: Amit Kale<akale@veritas.com> 26 * Updated by: Tom Rini <trini@kernel.crashing.org> 27 * Updated by: Jason Wessel <jason.wessel@windriver.com> 28 * Modified for 386 by Jim Kingdon, Cygnus Support. 29 * Origianl kgdb, compatibility with 2.1.xx kernel by 30 * David Grothe <dave@gcom.com> 31 * Integrated into 2.2.5 kernel by Tigran Aivazian <tigran@sco.com> 32 * X86_64 changes from Andi Kleen's patch merged by Jim Houston 33 */ 34#include <linux/spinlock.h> 35#include <linux/kdebug.h> 36#include <linux/string.h> 37#include <linux/kernel.h> 38#include <linux/ptrace.h> 39#include <linux/sched.h> 40#include <linux/delay.h> 41#include <linux/kgdb.h> 42#include <linux/init.h> 43#include <linux/smp.h> 44#include <linux/nmi.h> 45#include <linux/hw_breakpoint.h> 46 47#include <asm/debugreg.h> 48#include <asm/apicdef.h> 49#include <asm/system.h> 50#include <asm/apic.h> 51 52struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = 53{ 54#ifdef CONFIG_X86_32 55 { "ax", 4, offsetof(struct pt_regs, ax) }, 56 { "cx", 4, offsetof(struct pt_regs, cx) }, 57 { "dx", 4, offsetof(struct pt_regs, dx) }, 58 { "bx", 4, offsetof(struct pt_regs, bx) }, 59 { "sp", 4, offsetof(struct pt_regs, sp) }, 60 { "bp", 4, offsetof(struct pt_regs, bp) }, 61 { "si", 4, offsetof(struct pt_regs, si) }, 62 { "di", 4, offsetof(struct pt_regs, di) }, 63 { "ip", 4, offsetof(struct pt_regs, ip) }, 64 { "flags", 4, offsetof(struct pt_regs, flags) }, 65 { "cs", 4, offsetof(struct pt_regs, cs) }, 66 { "ss", 4, offsetof(struct pt_regs, ss) }, 67 { "ds", 4, offsetof(struct pt_regs, ds) }, 68 { "es", 4, offsetof(struct pt_regs, es) }, 69 { "fs", 4, -1 }, 70 { "gs", 4, -1 }, 71#else 72 { "ax", 8, offsetof(struct pt_regs, ax) }, 73 { "bx", 8, offsetof(struct pt_regs, bx) }, 74 { "cx", 8, offsetof(struct pt_regs, cx) }, 75 { "dx", 8, offsetof(struct pt_regs, dx) }, 76 { "si", 8, offsetof(struct pt_regs, dx) }, 77 { "di", 8, offsetof(struct pt_regs, di) }, 78 { "bp", 8, offsetof(struct pt_regs, bp) }, 79 { "sp", 8, offsetof(struct pt_regs, sp) }, 80 { "r8", 8, offsetof(struct pt_regs, r8) }, 81 { "r9", 8, offsetof(struct pt_regs, r9) }, 82 { "r10", 8, offsetof(struct pt_regs, r10) }, 83 { "r11", 8, offsetof(struct pt_regs, r11) }, 84 { "r12", 8, offsetof(struct pt_regs, r12) }, 85 { "r13", 8, offsetof(struct pt_regs, r13) }, 86 { "r14", 8, offsetof(struct pt_regs, r14) }, 87 { "r15", 8, offsetof(struct pt_regs, r15) }, 88 { "ip", 8, offsetof(struct pt_regs, ip) }, 89 { "flags", 4, offsetof(struct pt_regs, flags) }, 90 { "cs", 4, offsetof(struct pt_regs, cs) }, 91 { "ss", 4, offsetof(struct pt_regs, ss) }, 92#endif 93}; 94 95int dbg_set_reg(int regno, void *mem, struct pt_regs *regs) 96{ 97 if ( 98#ifdef CONFIG_X86_32 99 regno == GDB_SS || regno == GDB_FS || regno == GDB_GS || 100#endif 101 regno == GDB_SP || regno == GDB_ORIG_AX) 102 return 0; 103 104 if (dbg_reg_def[regno].offset != -1) 105 memcpy((void *)regs + dbg_reg_def[regno].offset, mem, 106 dbg_reg_def[regno].size); 107 return 0; 108} 109 110char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs) 111{ 112 if (regno == GDB_ORIG_AX) { 113 memcpy(mem, ®s->orig_ax, sizeof(regs->orig_ax)); 114 return "orig_ax"; 115 } 116 if (regno >= DBG_MAX_REG_NUM || regno < 0) 117 return NULL; 118 119 if (dbg_reg_def[regno].offset != -1) 120 memcpy(mem, (void *)regs + dbg_reg_def[regno].offset, 121 dbg_reg_def[regno].size); 122 123 switch (regno) { 124#ifdef CONFIG_X86_32 125 case GDB_SS: 126 if (!user_mode_vm(regs)) 127 *(unsigned long *)mem = __KERNEL_DS; 128 break; 129 case GDB_SP: 130 if (!user_mode_vm(regs)) 131 *(unsigned long *)mem = kernel_stack_pointer(regs); 132 break; 133 case GDB_GS: 134 case GDB_FS: 135 *(unsigned long *)mem = 0xFFFF; 136 break; 137#endif 138 } 139 return dbg_reg_def[regno].name; 140} 141 142/** 143 * sleeping_thread_to_gdb_regs - Convert ptrace regs to GDB regs 144 * @gdb_regs: A pointer to hold the registers in the order GDB wants. 145 * @p: The &struct task_struct of the desired process. 146 * 147 * Convert the register values of the sleeping process in @p to 148 * the format that GDB expects. 149 * This function is called when kgdb does not have access to the 150 * &struct pt_regs and therefore it should fill the gdb registers 151 * @gdb_regs with what has been saved in &struct thread_struct 152 * thread field during switch_to. 153 */ 154void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p) 155{ 156#ifndef CONFIG_X86_32 157 u32 *gdb_regs32 = (u32 *)gdb_regs; 158#endif 159 gdb_regs[GDB_AX] = 0; 160 gdb_regs[GDB_BX] = 0; 161 gdb_regs[GDB_CX] = 0; 162 gdb_regs[GDB_DX] = 0; 163 gdb_regs[GDB_SI] = 0; 164 gdb_regs[GDB_DI] = 0; 165 gdb_regs[GDB_BP] = *(unsigned long *)p->thread.sp; 166#ifdef CONFIG_X86_32 167 gdb_regs[GDB_DS] = __KERNEL_DS; 168 gdb_regs[GDB_ES] = __KERNEL_DS; 169 gdb_regs[GDB_PS] = 0; 170 gdb_regs[GDB_CS] = __KERNEL_CS; 171 gdb_regs[GDB_PC] = p->thread.ip; 172 gdb_regs[GDB_SS] = __KERNEL_DS; 173 gdb_regs[GDB_FS] = 0xFFFF; 174 gdb_regs[GDB_GS] = 0xFFFF; 175#else 176 gdb_regs32[GDB_PS] = *(unsigned long *)(p->thread.sp + 8); 177 gdb_regs32[GDB_CS] = __KERNEL_CS; 178 gdb_regs32[GDB_SS] = __KERNEL_DS; 179 gdb_regs[GDB_PC] = 0; 180 gdb_regs[GDB_R8] = 0; 181 gdb_regs[GDB_R9] = 0; 182 gdb_regs[GDB_R10] = 0; 183 gdb_regs[GDB_R11] = 0; 184 gdb_regs[GDB_R12] = 0; 185 gdb_regs[GDB_R13] = 0; 186 gdb_regs[GDB_R14] = 0; 187 gdb_regs[GDB_R15] = 0; 188#endif 189 gdb_regs[GDB_SP] = p->thread.sp; 190} 191 192static struct hw_breakpoint { 193 unsigned enabled; 194 unsigned long addr; 195 int len; 196 int type; 197 struct perf_event * __percpu *pev; 198} breakinfo[HBP_NUM]; 199 200static unsigned long early_dr7; 201 202static void kgdb_correct_hw_break(void) 203{ 204 int breakno; 205 206 for (breakno = 0; breakno < HBP_NUM; breakno++) { 207 struct perf_event *bp; 208 struct arch_hw_breakpoint *info; 209 int val; 210 int cpu = raw_smp_processor_id(); 211 if (!breakinfo[breakno].enabled) 212 continue; 213 if (dbg_is_early) { 214 set_debugreg(breakinfo[breakno].addr, breakno); 215 early_dr7 |= encode_dr7(breakno, 216 breakinfo[breakno].len, 217 breakinfo[breakno].type); 218 set_debugreg(early_dr7, 7); 219 continue; 220 } 221 bp = *per_cpu_ptr(breakinfo[breakno].pev, cpu); 222 info = counter_arch_bp(bp); 223 if (bp->attr.disabled != 1) 224 continue; 225 bp->attr.bp_addr = breakinfo[breakno].addr; 226 bp->attr.bp_len = breakinfo[breakno].len; 227 bp->attr.bp_type = breakinfo[breakno].type; 228 info->address = breakinfo[breakno].addr; 229 info->len = breakinfo[breakno].len; 230 info->type = breakinfo[breakno].type; 231 val = arch_install_hw_breakpoint(bp); 232 if (!val) 233 bp->attr.disabled = 0; 234 } 235 if (!dbg_is_early) 236 hw_breakpoint_restore(); 237} 238 239static int hw_break_reserve_slot(int breakno) 240{ 241 int cpu; 242 int cnt = 0; 243 struct perf_event **pevent; 244 245 if (dbg_is_early) 246 return 0; 247 248 for_each_online_cpu(cpu) { 249 cnt++; 250 pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu); 251 if (dbg_reserve_bp_slot(*pevent)) 252 goto fail; 253 } 254 255 return 0; 256 257fail: 258 for_each_online_cpu(cpu) { 259 cnt--; 260 if (!cnt) 261 break; 262 pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu); 263 dbg_release_bp_slot(*pevent); 264 } 265 return -1; 266} 267 268static int hw_break_release_slot(int breakno) 269{ 270 struct perf_event **pevent; 271 int cpu; 272 273 if (dbg_is_early) 274 return 0; 275 276 for_each_online_cpu(cpu) { 277 pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu); 278 if (dbg_release_bp_slot(*pevent)) 279 /* 280 * The debugger is responisble for handing the retry on 281 * remove failure. 282 */ 283 return -1; 284 } 285 return 0; 286} 287 288static int 289kgdb_remove_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype) 290{ 291 int i; 292 293 for (i = 0; i < HBP_NUM; i++) 294 if (breakinfo[i].addr == addr && breakinfo[i].enabled) 295 break; 296 if (i == HBP_NUM) 297 return -1; 298 299 if (hw_break_release_slot(i)) { 300 printk(KERN_ERR "Cannot remove hw breakpoint at %lx\n", addr); 301 return -1; 302 } 303 breakinfo[i].enabled = 0; 304 305 return 0; 306} 307 308static void kgdb_remove_all_hw_break(void) 309{ 310 int i; 311 int cpu = raw_smp_processor_id(); 312 struct perf_event *bp; 313 314 for (i = 0; i < HBP_NUM; i++) { 315 if (!breakinfo[i].enabled) 316 continue; 317 bp = *per_cpu_ptr(breakinfo[i].pev, cpu); 318 if (bp->attr.disabled == 1) 319 continue; 320 if (dbg_is_early) 321 early_dr7 &= ~encode_dr7(i, breakinfo[i].len, 322 breakinfo[i].type); 323 else 324 arch_uninstall_hw_breakpoint(bp); 325 bp->attr.disabled = 1; 326 } 327} 328 329static int 330kgdb_set_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype) 331{ 332 int i; 333 334 for (i = 0; i < HBP_NUM; i++) 335 if (!breakinfo[i].enabled) 336 break; 337 if (i == HBP_NUM) 338 return -1; 339 340 switch (bptype) { 341 case BP_HARDWARE_BREAKPOINT: 342 len = 1; 343 breakinfo[i].type = X86_BREAKPOINT_EXECUTE; 344 break; 345 case BP_WRITE_WATCHPOINT: 346 breakinfo[i].type = X86_BREAKPOINT_WRITE; 347 break; 348 case BP_ACCESS_WATCHPOINT: 349 breakinfo[i].type = X86_BREAKPOINT_RW; 350 break; 351 default: 352 return -1; 353 } 354 switch (len) { 355 case 1: 356 breakinfo[i].len = X86_BREAKPOINT_LEN_1; 357 break; 358 case 2: 359 breakinfo[i].len = X86_BREAKPOINT_LEN_2; 360 break; 361 case 4: 362 breakinfo[i].len = X86_BREAKPOINT_LEN_4; 363 break; 364#ifdef CONFIG_X86_64 365 case 8: 366 breakinfo[i].len = X86_BREAKPOINT_LEN_8; 367 break; 368#endif 369 default: 370 return -1; 371 } 372 breakinfo[i].addr = addr; 373 if (hw_break_reserve_slot(i)) { 374 breakinfo[i].addr = 0; 375 return -1; 376 } 377 breakinfo[i].enabled = 1; 378 379 return 0; 380} 381 382/** 383 * kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb. 384 * @regs: Current &struct pt_regs. 385 * 386 * This function will be called if the particular architecture must 387 * disable hardware debugging while it is processing gdb packets or 388 * handling exception. 389 */ 390void kgdb_disable_hw_debug(struct pt_regs *regs) 391{ 392 int i; 393 int cpu = raw_smp_processor_id(); 394 struct perf_event *bp; 395 396 /* Disable hardware debugging while we are in kgdb: */ 397 set_debugreg(0UL, 7); 398 for (i = 0; i < HBP_NUM; i++) { 399 if (!breakinfo[i].enabled) 400 continue; 401 if (dbg_is_early) { 402 early_dr7 &= ~encode_dr7(i, breakinfo[i].len, 403 breakinfo[i].type); 404 continue; 405 } 406 bp = *per_cpu_ptr(breakinfo[i].pev, cpu); 407 if (bp->attr.disabled == 1) 408 continue; 409 arch_uninstall_hw_breakpoint(bp); 410 bp->attr.disabled = 1; 411 } 412} 413 414#ifdef CONFIG_SMP 415/** 416 * kgdb_roundup_cpus - Get other CPUs into a holding pattern 417 * @flags: Current IRQ state 418 * 419 * On SMP systems, we need to get the attention of the other CPUs 420 * and get them be in a known state. This should do what is needed 421 * to get the other CPUs to call kgdb_wait(). Note that on some arches, 422 * the NMI approach is not used for rounding up all the CPUs. For example, 423 * in case of MIPS, smp_call_function() is used to roundup CPUs. In 424 * this case, we have to make sure that interrupts are enabled before 425 * calling smp_call_function(). The argument to this function is 426 * the flags that will be used when restoring the interrupts. There is 427 * local_irq_save() call before kgdb_roundup_cpus(). 428 * 429 * On non-SMP systems, this is not called. 430 */ 431void kgdb_roundup_cpus(unsigned long flags) 432{ 433 apic->send_IPI_allbutself(APIC_DM_NMI); 434} 435#endif 436 437/** 438 * kgdb_arch_handle_exception - Handle architecture specific GDB packets. 439 * @vector: The error vector of the exception that happened. 440 * @signo: The signal number of the exception that happened. 441 * @err_code: The error code of the exception that happened. 442 * @remcom_in_buffer: The buffer of the packet we have read. 443 * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into. 444 * @regs: The &struct pt_regs of the current process. 445 * 446 * This function MUST handle the 'c' and 's' command packets, 447 * as well packets to set / remove a hardware breakpoint, if used. 448 * If there are additional packets which the hardware needs to handle, 449 * they are handled here. The code should return -1 if it wants to 450 * process more packets, and a %0 or %1 if it wants to exit from the 451 * kgdb callback. 452 */ 453int kgdb_arch_handle_exception(int e_vector, int signo, int err_code, 454 char *remcomInBuffer, char *remcomOutBuffer, 455 struct pt_regs *linux_regs) 456{ 457 unsigned long addr; 458 char *ptr; 459 460 switch (remcomInBuffer[0]) { 461 case 'c': 462 case 's': 463 /* try to read optional parameter, pc unchanged if no parm */ 464 ptr = &remcomInBuffer[1]; 465 if (kgdb_hex2long(&ptr, &addr)) 466 linux_regs->ip = addr; 467 case 'D': 468 case 'k': 469 /* clear the trace bit */ 470 linux_regs->flags &= ~X86_EFLAGS_TF; 471 atomic_set(&kgdb_cpu_doing_single_step, -1); 472 473 /* set the trace bit if we're stepping */ 474 if (remcomInBuffer[0] == 's') { 475 linux_regs->flags |= X86_EFLAGS_TF; 476 atomic_set(&kgdb_cpu_doing_single_step, 477 raw_smp_processor_id()); 478 } 479 480 kgdb_correct_hw_break(); 481 482 return 0; 483 } 484 485 /* this means that we do not want to exit from the handler: */ 486 return -1; 487} 488 489static inline int 490single_step_cont(struct pt_regs *regs, struct die_args *args) 491{ 492 /* 493 * Single step exception from kernel space to user space so 494 * eat the exception and continue the process: 495 */ 496 printk(KERN_ERR "KGDB: trap/step from kernel to user space, " 497 "resuming...\n"); 498 kgdb_arch_handle_exception(args->trapnr, args->signr, 499 args->err, "c", "", regs); 500 /* 501 * Reset the BS bit in dr6 (pointed by args->err) to 502 * denote completion of processing 503 */ 504 (*(unsigned long *)ERR_PTR(args->err)) &= ~DR_STEP; 505 506 return NOTIFY_STOP; 507} 508 509static int was_in_debug_nmi[NR_CPUS]; 510 511static int __kgdb_notify(struct die_args *args, unsigned long cmd) 512{ 513 struct pt_regs *regs = args->regs; 514 515 switch (cmd) { 516 case DIE_NMI: 517 if (atomic_read(&kgdb_active) != -1) { 518 /* KGDB CPU roundup */ 519 kgdb_nmicallback(raw_smp_processor_id(), regs); 520 was_in_debug_nmi[raw_smp_processor_id()] = 1; 521 touch_nmi_watchdog(); 522 return NOTIFY_STOP; 523 } 524 return NOTIFY_DONE; 525 526 case DIE_NMI_IPI: 527 /* Just ignore, we will handle the roundup on DIE_NMI. */ 528 return NOTIFY_DONE; 529 530 case DIE_NMIUNKNOWN: 531 if (was_in_debug_nmi[raw_smp_processor_id()]) { 532 was_in_debug_nmi[raw_smp_processor_id()] = 0; 533 return NOTIFY_STOP; 534 } 535 return NOTIFY_DONE; 536 537 case DIE_NMIWATCHDOG: 538 if (atomic_read(&kgdb_active) != -1) { 539 /* KGDB CPU roundup: */ 540 kgdb_nmicallback(raw_smp_processor_id(), regs); 541 return NOTIFY_STOP; 542 } 543 /* Enter debugger: */ 544 break; 545 546 case DIE_DEBUG: 547 if (atomic_read(&kgdb_cpu_doing_single_step) != -1) { 548 if (user_mode(regs)) 549 return single_step_cont(regs, args); 550 break; 551 } else if (test_thread_flag(TIF_SINGLESTEP)) 552 /* This means a user thread is single stepping 553 * a system call which should be ignored 554 */ 555 return NOTIFY_DONE; 556 /* fall through */ 557 default: 558 if (user_mode(regs)) 559 return NOTIFY_DONE; 560 } 561 562 if (kgdb_handle_exception(args->trapnr, args->signr, cmd, regs)) 563 return NOTIFY_DONE; 564 565 /* Must touch watchdog before return to normal operation */ 566 touch_nmi_watchdog(); 567 return NOTIFY_STOP; 568} 569 570int kgdb_ll_trap(int cmd, const char *str, 571 struct pt_regs *regs, long err, int trap, int sig) 572{ 573 struct die_args args = { 574 .regs = regs, 575 .str = str, 576 .err = err, 577 .trapnr = trap, 578 .signr = sig, 579 580 }; 581 582 if (!kgdb_io_module_registered) 583 return NOTIFY_DONE; 584 585 return __kgdb_notify(&args, cmd); 586} 587 588static int 589kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr) 590{ 591 unsigned long flags; 592 int ret; 593 594 local_irq_save(flags); 595 ret = __kgdb_notify(ptr, cmd); 596 local_irq_restore(flags); 597 598 return ret; 599} 600 601static struct notifier_block kgdb_notifier = { 602 .notifier_call = kgdb_notify, 603 604 /* 605 * Lowest-prio notifier priority, we want to be notified last: 606 */ 607 .priority = -INT_MAX, 608}; 609 610/** 611 * kgdb_arch_init - Perform any architecture specific initalization. 612 * 613 * This function will handle the initalization of any architecture 614 * specific callbacks. 615 */ 616int kgdb_arch_init(void) 617{ 618 return register_die_notifier(&kgdb_notifier); 619} 620 621static void kgdb_hw_overflow_handler(struct perf_event *event, int nmi, 622 struct perf_sample_data *data, struct pt_regs *regs) 623{ 624 struct task_struct *tsk = current; 625 int i; 626 627 for (i = 0; i < 4; i++) 628 if (breakinfo[i].enabled) 629 tsk->thread.debugreg6 |= (DR_TRAP0 << i); 630} 631 632void kgdb_arch_late(void) 633{ 634 int i, cpu; 635 struct perf_event_attr attr; 636 struct perf_event **pevent; 637 638 /* 639 * Pre-allocate the hw breakpoint structions in the non-atomic 640 * portion of kgdb because this operation requires mutexs to 641 * complete. 642 */ 643 hw_breakpoint_init(&attr); 644 attr.bp_addr = (unsigned long)kgdb_arch_init; 645 attr.bp_len = HW_BREAKPOINT_LEN_1; 646 attr.bp_type = HW_BREAKPOINT_W; 647 attr.disabled = 1; 648 for (i = 0; i < HBP_NUM; i++) { 649 if (breakinfo[i].pev) 650 continue; 651 breakinfo[i].pev = register_wide_hw_breakpoint(&attr, NULL); 652 if (IS_ERR((void * __force)breakinfo[i].pev)) { 653 printk(KERN_ERR "kgdb: Could not allocate hw" 654 "breakpoints\nDisabling the kernel debugger\n"); 655 breakinfo[i].pev = NULL; 656 kgdb_arch_exit(); 657 return; 658 } 659 for_each_online_cpu(cpu) { 660 pevent = per_cpu_ptr(breakinfo[i].pev, cpu); 661 pevent[0]->hw.sample_period = 1; 662 pevent[0]->overflow_handler = kgdb_hw_overflow_handler; 663 if (pevent[0]->destroy != NULL) { 664 pevent[0]->destroy = NULL; 665 release_bp_slot(*pevent); 666 } 667 } 668 } 669} 670 671/** 672 * kgdb_arch_exit - Perform any architecture specific uninitalization. 673 * 674 * This function will handle the uninitalization of any architecture 675 * specific callbacks, for dynamic registration and unregistration. 676 */ 677void kgdb_arch_exit(void) 678{ 679 int i; 680 for (i = 0; i < 4; i++) { 681 if (breakinfo[i].pev) { 682 unregister_wide_hw_breakpoint(breakinfo[i].pev); 683 breakinfo[i].pev = NULL; 684 } 685 } 686 unregister_die_notifier(&kgdb_notifier); 687} 688 689/** 690 * 691 * kgdb_skipexception - Bail out of KGDB when we've been triggered. 692 * @exception: Exception vector number 693 * @regs: Current &struct pt_regs. 694 * 695 * On some architectures we need to skip a breakpoint exception when 696 * it occurs after a breakpoint has been removed. 697 * 698 * Skip an int3 exception when it occurs after a breakpoint has been 699 * removed. Backtrack eip by 1 since the int3 would have caused it to 700 * increment by 1. 701 */ 702int kgdb_skipexception(int exception, struct pt_regs *regs) 703{ 704 if (exception == 3 && kgdb_isremovedbreak(regs->ip - 1)) { 705 regs->ip -= 1; 706 return 1; 707 } 708 return 0; 709} 710 711unsigned long kgdb_arch_pc(int exception, struct pt_regs *regs) 712{ 713 if (exception == 3) 714 return instruction_pointer(regs) - 1; 715 return instruction_pointer(regs); 716} 717 718void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip) 719{ 720 regs->ip = ip; 721} 722 723struct kgdb_arch arch_kgdb_ops = { 724 /* Breakpoint instruction: */ 725 .gdb_bpt_instr = { 0xcc }, 726 .flags = KGDB_HW_BREAKPOINT, 727 .set_hw_breakpoint = kgdb_set_hw_break, 728 .remove_hw_breakpoint = kgdb_remove_hw_break, 729 .remove_all_hw_break = kgdb_remove_all_hw_break, 730 .correct_hw_break = kgdb_correct_hw_break, 731}; 732