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