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 58static int kgdb_break_asap; 59 60struct debuggerinfo_struct kgdb_info[NR_CPUS]; 61 62/** 63 * kgdb_connected - Is a host GDB connected to us? 64 */ 65int kgdb_connected; 66EXPORT_SYMBOL_GPL(kgdb_connected); 67 68/* All the KGDB handlers are installed */ 69int kgdb_io_module_registered; 70 71/* Guard for recursive entry */ 72static int exception_level; 73 74struct kgdb_io *dbg_io_ops; 75static DEFINE_SPINLOCK(kgdb_registration_lock); 76 77/* kgdb console driver is loaded */ 78static int kgdb_con_registered; 79/* determine if kgdb console output should be used */ 80static int kgdb_use_con; 81/* Flag for alternate operations for early debugging */ 82bool dbg_is_early = true; 83/* Next cpu to become the master debug core */ 84int dbg_switch_cpu; 85 86/* Use kdb or gdbserver mode */ 87int dbg_kdb_mode = 1; 88 89static int __init opt_kgdb_con(char *str) 90{ 91 kgdb_use_con = 1; 92 return 0; 93} 94 95early_param("kgdbcon", opt_kgdb_con); 96 97module_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 */ 103static 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 */ 110atomic_t kgdb_active = ATOMIC_INIT(-1); 111EXPORT_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 */ 117static atomic_t passive_cpu_wait[NR_CPUS]; 118static atomic_t cpu_in_kgdb[NR_CPUS]; 119static atomic_t kgdb_break_tasklet_var; 120atomic_t kgdb_setting_breakpoint; 121 122struct task_struct *kgdb_usethread; 123struct task_struct *kgdb_contthread; 124 125int kgdb_single_step; 126static pid_t kgdb_sstep_pid; 127 128/* to keep track of the CPU which is doing the single stepping*/ 129atomic_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 */ 138static int kgdb_do_roundup = 1; 139 140static int __init opt_nokgdbroundup(char *str) 141{ 142 kgdb_do_roundup = 0; 143 144 return 0; 145} 146 147early_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 */ 157int __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 169int __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 175int __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 194unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs) 195{ 196 return instruction_pointer(regs); 197} 198 199int __weak kgdb_arch_init(void) 200{ 201 return 0; 202} 203 204int __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 */ 217void __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 */ 225static 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 */ 241int 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 267int 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 308int 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 332int 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 346int 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 358int 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); 374setundefined: 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 */ 394static 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 413static 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 460static 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 473static 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; 480acquirelock: 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) { 506cpu_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 { 517return_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) { 604cpu_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 650kgdb_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 */ 676int 677kgdb_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 699int 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 721static 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 736static 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 744static void sysrq_handle_dbg(int key) 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 762static 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 769static 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 779static struct notifier_block kgdb_panic_event_nb = { 780 .notifier_call = kgdb_panic_event, 781 .priority = INT_MAX, 782}; 783 784void __weak kgdb_arch_late(void) 785{ 786} 787 788void __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 796static 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 815static 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 */ 843static void kgdb_tasklet_bpt(unsigned long ing) 844{ 845 kgdb_breakpoint(); 846 atomic_set(&kgdb_break_tasklet_var, 0); 847} 848 849static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0); 850 851void 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} 860EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint); 861 862static 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 */ 876int 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} 913EXPORT_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 */ 921void 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} 942EXPORT_SYMBOL_GPL(kgdb_unregister_io_module); 943 944int 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 */ 964void 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} 972EXPORT_SYMBOL_GPL(kgdb_breakpoint); 973 974static 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 985early_param("kgdbwait", opt_kgdb_wait); 986