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