1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/pid_namespace.h>
31#include <linux/clocksource.h>
32#include <linux/serial_core.h>
33#include <linux/interrupt.h>
34#include <linux/spinlock.h>
35#include <linux/console.h>
36#include <linux/threads.h>
37#include <linux/uaccess.h>
38#include <linux/kernel.h>
39#include <linux/module.h>
40#include <linux/ptrace.h>
41#include <linux/string.h>
42#include <linux/delay.h>
43#include <linux/sched.h>
44#include <linux/sysrq.h>
45#include <linux/reboot.h>
46#include <linux/init.h>
47#include <linux/kgdb.h>
48#include <linux/kdb.h>
49#include <linux/pid.h>
50#include <linux/smp.h>
51#include <linux/mm.h>
52#include <linux/rcupdate.h>
53
54#include <asm/cacheflush.h>
55#include <asm/byteorder.h>
56#include <linux/atomic.h>
57
58#include "debug_core.h"
59
60static int kgdb_break_asap;
61
62struct debuggerinfo_struct kgdb_info[NR_CPUS];
63
64
65
66
67int kgdb_connected;
68EXPORT_SYMBOL_GPL(kgdb_connected);
69
70
71int kgdb_io_module_registered;
72
73
74static int exception_level;
75
76struct kgdb_io *dbg_io_ops;
77static DEFINE_SPINLOCK(kgdb_registration_lock);
78
79
80static int kgdbreboot;
81
82static int kgdb_con_registered;
83
84static int kgdb_use_con;
85
86bool dbg_is_early = true;
87
88int dbg_switch_cpu;
89
90
91int dbg_kdb_mode = 1;
92
93static int __init opt_kgdb_con(char *str)
94{
95 kgdb_use_con = 1;
96 return 0;
97}
98
99early_param("kgdbcon", opt_kgdb_con);
100
101module_param(kgdb_use_con, int, 0644);
102module_param(kgdbreboot, int, 0644);
103
104
105
106
107
108static struct kgdb_bkpt kgdb_break[KGDB_MAX_BREAKPOINTS] = {
109 [0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
110};
111
112
113
114
115atomic_t kgdb_active = ATOMIC_INIT(-1);
116EXPORT_SYMBOL_GPL(kgdb_active);
117static DEFINE_RAW_SPINLOCK(dbg_master_lock);
118static DEFINE_RAW_SPINLOCK(dbg_slave_lock);
119
120
121
122
123
124static atomic_t masters_in_kgdb;
125static atomic_t slaves_in_kgdb;
126static atomic_t kgdb_break_tasklet_var;
127atomic_t kgdb_setting_breakpoint;
128
129struct task_struct *kgdb_usethread;
130struct task_struct *kgdb_contthread;
131
132int kgdb_single_step;
133static pid_t kgdb_sstep_pid;
134
135
136atomic_t kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
137
138
139
140
141
142
143
144
145static int kgdb_do_roundup = 1;
146
147static int __init opt_nokgdbroundup(char *str)
148{
149 kgdb_do_roundup = 0;
150
151 return 0;
152}
153
154early_param("nokgdbroundup", opt_nokgdbroundup);
155
156
157
158
159
160
161
162
163
164int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
165{
166 int err;
167
168 err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
169 BREAK_INSTR_SIZE);
170 if (err)
171 return err;
172 err = probe_kernel_write((char *)bpt->bpt_addr,
173 arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
174 return err;
175}
176
177int __weak kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
178{
179 return probe_kernel_write((char *)bpt->bpt_addr,
180 (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
181}
182
183int __weak kgdb_validate_break_address(unsigned long addr)
184{
185 struct kgdb_bkpt tmp;
186 int err;
187
188
189
190
191
192 tmp.bpt_addr = addr;
193 err = kgdb_arch_set_breakpoint(&tmp);
194 if (err)
195 return err;
196 err = kgdb_arch_remove_breakpoint(&tmp);
197 if (err)
198 printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
199 "memory destroyed at: %lx", addr);
200 return err;
201}
202
203unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
204{
205 return instruction_pointer(regs);
206}
207
208int __weak kgdb_arch_init(void)
209{
210 return 0;
211}
212
213int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
214{
215 return 0;
216}
217
218
219
220
221
222static void kgdb_flush_swbreak_addr(unsigned long addr)
223{
224 if (!CACHE_FLUSH_IS_SAFE)
225 return;
226
227 if (current->mm && current->mm->mmap_cache) {
228 flush_cache_range(current->mm->mmap_cache,
229 addr, addr + BREAK_INSTR_SIZE);
230 }
231
232 flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
233}
234
235
236
237
238int dbg_activate_sw_breakpoints(void)
239{
240 int error;
241 int ret = 0;
242 int i;
243
244 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
245 if (kgdb_break[i].state != BP_SET)
246 continue;
247
248 error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
249 if (error) {
250 ret = error;
251 printk(KERN_INFO "KGDB: BP install failed: %lx",
252 kgdb_break[i].bpt_addr);
253 continue;
254 }
255
256 kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
257 kgdb_break[i].state = BP_ACTIVE;
258 }
259 return ret;
260}
261
262int dbg_set_sw_break(unsigned long addr)
263{
264 int err = kgdb_validate_break_address(addr);
265 int breakno = -1;
266 int i;
267
268 if (err)
269 return err;
270
271 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
272 if ((kgdb_break[i].state == BP_SET) &&
273 (kgdb_break[i].bpt_addr == addr))
274 return -EEXIST;
275 }
276 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
277 if (kgdb_break[i].state == BP_REMOVED &&
278 kgdb_break[i].bpt_addr == addr) {
279 breakno = i;
280 break;
281 }
282 }
283
284 if (breakno == -1) {
285 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
286 if (kgdb_break[i].state == BP_UNDEFINED) {
287 breakno = i;
288 break;
289 }
290 }
291 }
292
293 if (breakno == -1)
294 return -E2BIG;
295
296 kgdb_break[breakno].state = BP_SET;
297 kgdb_break[breakno].type = BP_BREAKPOINT;
298 kgdb_break[breakno].bpt_addr = addr;
299
300 return 0;
301}
302
303int dbg_deactivate_sw_breakpoints(void)
304{
305 int error;
306 int ret = 0;
307 int i;
308
309 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
310 if (kgdb_break[i].state != BP_ACTIVE)
311 continue;
312 error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
313 if (error) {
314 printk(KERN_INFO "KGDB: BP remove failed: %lx\n",
315 kgdb_break[i].bpt_addr);
316 ret = error;
317 }
318
319 kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
320 kgdb_break[i].state = BP_SET;
321 }
322 return ret;
323}
324
325int dbg_remove_sw_break(unsigned long addr)
326{
327 int i;
328
329 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
330 if ((kgdb_break[i].state == BP_SET) &&
331 (kgdb_break[i].bpt_addr == addr)) {
332 kgdb_break[i].state = BP_REMOVED;
333 return 0;
334 }
335 }
336 return -ENOENT;
337}
338
339int kgdb_isremovedbreak(unsigned long addr)
340{
341 int i;
342
343 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
344 if ((kgdb_break[i].state == BP_REMOVED) &&
345 (kgdb_break[i].bpt_addr == addr))
346 return 1;
347 }
348 return 0;
349}
350
351int dbg_remove_all_break(void)
352{
353 int error;
354 int i;
355
356
357 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
358 if (kgdb_break[i].state != BP_ACTIVE)
359 goto setundefined;
360 error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
361 if (error)
362 printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
363 kgdb_break[i].bpt_addr);
364setundefined:
365 kgdb_break[i].state = BP_UNDEFINED;
366 }
367
368
369 if (arch_kgdb_ops.remove_all_hw_break)
370 arch_kgdb_ops.remove_all_hw_break();
371
372 return 0;
373}
374
375
376
377
378
379
380
381
382
383
384static int kgdb_io_ready(int print_wait)
385{
386 if (!dbg_io_ops)
387 return 0;
388 if (kgdb_connected)
389 return 1;
390 if (atomic_read(&kgdb_setting_breakpoint))
391 return 1;
392 if (print_wait) {
393#ifdef CONFIG_KGDB_KDB
394 if (!dbg_kdb_mode)
395 printk(KERN_CRIT "KGDB: waiting... or $3#33 for KDB\n");
396#else
397 printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
398#endif
399 }
400 return 1;
401}
402
403static int kgdb_reenter_check(struct kgdb_state *ks)
404{
405 unsigned long addr;
406
407 if (atomic_read(&kgdb_active) != raw_smp_processor_id())
408 return 0;
409
410
411 exception_level++;
412 addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
413 dbg_deactivate_sw_breakpoints();
414
415
416
417
418
419
420
421 if (dbg_remove_sw_break(addr) == 0) {
422 exception_level = 0;
423 kgdb_skipexception(ks->ex_vector, ks->linux_regs);
424 dbg_activate_sw_breakpoints();
425 printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
426 addr);
427 WARN_ON_ONCE(1);
428
429 return 1;
430 }
431 dbg_remove_all_break();
432 kgdb_skipexception(ks->ex_vector, ks->linux_regs);
433
434 if (exception_level > 1) {
435 dump_stack();
436 panic("Recursive entry to debugger");
437 }
438
439 printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
440#ifdef CONFIG_KGDB_KDB
441
442 return 0;
443#endif
444 dump_stack();
445 panic("Recursive entry to debugger");
446
447 return 1;
448}
449
450static void dbg_touch_watchdogs(void)
451{
452 touch_softlockup_watchdog_sync();
453 clocksource_touch_watchdog();
454 rcu_cpu_stall_reset();
455}
456
457static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,
458 int exception_state)
459{
460 unsigned long flags;
461 int sstep_tries = 100;
462 int error;
463 int cpu;
464 int trace_on = 0;
465 int online_cpus = num_online_cpus();
466
467 kgdb_info[ks->cpu].enter_kgdb++;
468 kgdb_info[ks->cpu].exception_state |= exception_state;
469
470 if (exception_state == DCPU_WANT_MASTER)
471 atomic_inc(&masters_in_kgdb);
472 else
473 atomic_inc(&slaves_in_kgdb);
474
475 if (arch_kgdb_ops.disable_hw_break)
476 arch_kgdb_ops.disable_hw_break(regs);
477
478acquirelock:
479
480
481
482
483 local_irq_save(flags);
484
485 cpu = ks->cpu;
486 kgdb_info[cpu].debuggerinfo = regs;
487 kgdb_info[cpu].task = current;
488 kgdb_info[cpu].ret_state = 0;
489 kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
490
491
492 smp_mb();
493
494 if (exception_level == 1) {
495 if (raw_spin_trylock(&dbg_master_lock))
496 atomic_xchg(&kgdb_active, cpu);
497 goto cpu_master_loop;
498 }
499
500
501
502
503
504 while (1) {
505cpu_loop:
506 if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
507 kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
508 goto cpu_master_loop;
509 } else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
510 if (raw_spin_trylock(&dbg_master_lock)) {
511 atomic_xchg(&kgdb_active, cpu);
512 break;
513 }
514 } else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
515 if (!raw_spin_is_locked(&dbg_slave_lock))
516 goto return_normal;
517 } else {
518return_normal:
519
520
521
522 if (arch_kgdb_ops.correct_hw_break)
523 arch_kgdb_ops.correct_hw_break();
524 if (trace_on)
525 tracing_on();
526 kgdb_info[cpu].exception_state &=
527 ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
528 kgdb_info[cpu].enter_kgdb--;
529 smp_mb__before_atomic_dec();
530 atomic_dec(&slaves_in_kgdb);
531 dbg_touch_watchdogs();
532 local_irq_restore(flags);
533 return 0;
534 }
535 cpu_relax();
536 }
537
538
539
540
541
542
543
544 if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
545 (kgdb_info[cpu].task &&
546 kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
547 atomic_set(&kgdb_active, -1);
548 raw_spin_unlock(&dbg_master_lock);
549 dbg_touch_watchdogs();
550 local_irq_restore(flags);
551
552 goto acquirelock;
553 }
554
555 if (!kgdb_io_ready(1)) {
556 kgdb_info[cpu].ret_state = 1;
557 goto kgdb_restore;
558 }
559
560
561
562
563 if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
564 goto kgdb_restore;
565
566
567 if (dbg_io_ops->pre_exception)
568 dbg_io_ops->pre_exception();
569
570
571
572
573
574 if (!kgdb_single_step)
575 raw_spin_lock(&dbg_slave_lock);
576
577#ifdef CONFIG_SMP
578
579 if (ks->send_ready)
580 atomic_set(ks->send_ready, 1);
581
582
583 else if ((!kgdb_single_step) && kgdb_do_roundup)
584 kgdb_roundup_cpus(flags);
585#endif
586
587
588
589
590 while (kgdb_do_roundup && (atomic_read(&masters_in_kgdb) +
591 atomic_read(&slaves_in_kgdb)) != online_cpus)
592 cpu_relax();
593
594
595
596
597
598 dbg_deactivate_sw_breakpoints();
599 kgdb_single_step = 0;
600 kgdb_contthread = current;
601 exception_level = 0;
602 trace_on = tracing_is_on();
603 if (trace_on)
604 tracing_off();
605
606 while (1) {
607cpu_master_loop:
608 if (dbg_kdb_mode) {
609 kgdb_connected = 1;
610 error = kdb_stub(ks);
611 if (error == -1)
612 continue;
613 kgdb_connected = 0;
614 } else {
615 error = gdb_serial_stub(ks);
616 }
617
618 if (error == DBG_PASS_EVENT) {
619 dbg_kdb_mode = !dbg_kdb_mode;
620 } else if (error == DBG_SWITCH_CPU_EVENT) {
621 kgdb_info[dbg_switch_cpu].exception_state |=
622 DCPU_NEXT_MASTER;
623 goto cpu_loop;
624 } else {
625 kgdb_info[cpu].ret_state = error;
626 break;
627 }
628 }
629
630
631 if (dbg_io_ops->post_exception)
632 dbg_io_ops->post_exception();
633
634 if (!kgdb_single_step) {
635 raw_spin_unlock(&dbg_slave_lock);
636
637 while (kgdb_do_roundup && atomic_read(&slaves_in_kgdb))
638 cpu_relax();
639 }
640
641kgdb_restore:
642 if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
643 int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
644 if (kgdb_info[sstep_cpu].task)
645 kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
646 else
647 kgdb_sstep_pid = 0;
648 }
649 if (arch_kgdb_ops.correct_hw_break)
650 arch_kgdb_ops.correct_hw_break();
651 if (trace_on)
652 tracing_on();
653
654 kgdb_info[cpu].exception_state &=
655 ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
656 kgdb_info[cpu].enter_kgdb--;
657 smp_mb__before_atomic_dec();
658 atomic_dec(&masters_in_kgdb);
659
660 atomic_set(&kgdb_active, -1);
661 raw_spin_unlock(&dbg_master_lock);
662 dbg_touch_watchdogs();
663 local_irq_restore(flags);
664
665 return kgdb_info[cpu].ret_state;
666}
667
668
669
670
671
672
673
674
675int
676kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
677{
678 struct kgdb_state kgdb_var;
679 struct kgdb_state *ks = &kgdb_var;
680 int ret = 0;
681
682 if (arch_kgdb_ops.enable_nmi)
683 arch_kgdb_ops.enable_nmi(0);
684
685 memset(ks, 0, sizeof(struct kgdb_state));
686 ks->cpu = raw_smp_processor_id();
687 ks->ex_vector = evector;
688 ks->signo = signo;
689 ks->err_code = ecode;
690 ks->linux_regs = regs;
691
692 if (kgdb_reenter_check(ks))
693 goto out;
694 if (kgdb_info[ks->cpu].enter_kgdb != 0)
695 goto out;
696
697 ret = kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
698out:
699 if (arch_kgdb_ops.enable_nmi)
700 arch_kgdb_ops.enable_nmi(1);
701 return ret;
702}
703
704
705
706
707
708
709
710static int module_event(struct notifier_block *self, unsigned long val,
711 void *data)
712{
713 return 0;
714}
715
716static struct notifier_block dbg_module_load_nb = {
717 .notifier_call = module_event,
718};
719
720int kgdb_nmicallback(int cpu, void *regs)
721{
722#ifdef CONFIG_SMP
723 struct kgdb_state kgdb_var;
724 struct kgdb_state *ks = &kgdb_var;
725
726 memset(ks, 0, sizeof(struct kgdb_state));
727 ks->cpu = cpu;
728 ks->linux_regs = regs;
729
730 if (kgdb_info[ks->cpu].enter_kgdb == 0 &&
731 raw_spin_is_locked(&dbg_master_lock)) {
732 kgdb_cpu_enter(ks, regs, DCPU_IS_SLAVE);
733 return 0;
734 }
735#endif
736 return 1;
737}
738
739int kgdb_nmicallin(int cpu, int trapnr, void *regs, atomic_t *send_ready)
740{
741#ifdef CONFIG_SMP
742 if (!kgdb_io_ready(0) || !send_ready)
743 return 1;
744
745 if (kgdb_info[cpu].enter_kgdb == 0) {
746 struct kgdb_state kgdb_var;
747 struct kgdb_state *ks = &kgdb_var;
748
749 memset(ks, 0, sizeof(struct kgdb_state));
750 ks->cpu = cpu;
751 ks->ex_vector = trapnr;
752 ks->signo = SIGTRAP;
753 ks->err_code = KGDB_KDB_REASON_SYSTEM_NMI;
754 ks->linux_regs = regs;
755 ks->send_ready = send_ready;
756 kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
757 return 0;
758 }
759#endif
760 return 1;
761}
762
763static void kgdb_console_write(struct console *co, const char *s,
764 unsigned count)
765{
766 unsigned long flags;
767
768
769
770 if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode)
771 return;
772
773 local_irq_save(flags);
774 gdbstub_msg_write(s, count);
775 local_irq_restore(flags);
776}
777
778static struct console kgdbcons = {
779 .name = "kgdb",
780 .write = kgdb_console_write,
781 .flags = CON_PRINTBUFFER | CON_ENABLED,
782 .index = -1,
783};
784
785#ifdef CONFIG_MAGIC_SYSRQ
786static void sysrq_handle_dbg(int key)
787{
788 if (!dbg_io_ops) {
789 printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
790 return;
791 }
792 if (!kgdb_connected) {
793#ifdef CONFIG_KGDB_KDB
794 if (!dbg_kdb_mode)
795 printk(KERN_CRIT "KGDB or $3#33 for KDB\n");
796#else
797 printk(KERN_CRIT "Entering KGDB\n");
798#endif
799 }
800
801 kgdb_breakpoint();
802}
803
804static struct sysrq_key_op sysrq_dbg_op = {
805 .handler = sysrq_handle_dbg,
806 .help_msg = "debug(g)",
807 .action_msg = "DEBUG",
808};
809#endif
810
811static int kgdb_panic_event(struct notifier_block *self,
812 unsigned long val,
813 void *data)
814{
815 if (dbg_kdb_mode)
816 kdb_printf("PANIC: %s\n", (char *)data);
817 kgdb_breakpoint();
818 return NOTIFY_DONE;
819}
820
821static struct notifier_block kgdb_panic_event_nb = {
822 .notifier_call = kgdb_panic_event,
823 .priority = INT_MAX,
824};
825
826void __weak kgdb_arch_late(void)
827{
828}
829
830void __init dbg_late_init(void)
831{
832 dbg_is_early = false;
833 if (kgdb_io_module_registered)
834 kgdb_arch_late();
835 kdb_init(KDB_INIT_FULL);
836}
837
838static int
839dbg_notify_reboot(struct notifier_block *this, unsigned long code, void *x)
840{
841
842
843
844
845
846
847 switch (kgdbreboot) {
848 case 1:
849 kgdb_breakpoint();
850 case -1:
851 goto done;
852 }
853 if (!dbg_kdb_mode)
854 gdbstub_exit(code);
855done:
856 return NOTIFY_DONE;
857}
858
859static struct notifier_block dbg_reboot_notifier = {
860 .notifier_call = dbg_notify_reboot,
861 .next = NULL,
862 .priority = INT_MAX,
863};
864
865static void kgdb_register_callbacks(void)
866{
867 if (!kgdb_io_module_registered) {
868 kgdb_io_module_registered = 1;
869 kgdb_arch_init();
870 if (!dbg_is_early)
871 kgdb_arch_late();
872 register_module_notifier(&dbg_module_load_nb);
873 register_reboot_notifier(&dbg_reboot_notifier);
874 atomic_notifier_chain_register(&panic_notifier_list,
875 &kgdb_panic_event_nb);
876#ifdef CONFIG_MAGIC_SYSRQ
877 register_sysrq_key('g', &sysrq_dbg_op);
878#endif
879 if (kgdb_use_con && !kgdb_con_registered) {
880 register_console(&kgdbcons);
881 kgdb_con_registered = 1;
882 }
883 }
884}
885
886static void kgdb_unregister_callbacks(void)
887{
888
889
890
891
892
893 if (kgdb_io_module_registered) {
894 kgdb_io_module_registered = 0;
895 unregister_reboot_notifier(&dbg_reboot_notifier);
896 unregister_module_notifier(&dbg_module_load_nb);
897 atomic_notifier_chain_unregister(&panic_notifier_list,
898 &kgdb_panic_event_nb);
899 kgdb_arch_exit();
900#ifdef CONFIG_MAGIC_SYSRQ
901 unregister_sysrq_key('g', &sysrq_dbg_op);
902#endif
903 if (kgdb_con_registered) {
904 unregister_console(&kgdbcons);
905 kgdb_con_registered = 0;
906 }
907 }
908}
909
910
911
912
913
914
915
916static void kgdb_tasklet_bpt(unsigned long ing)
917{
918 kgdb_breakpoint();
919 atomic_set(&kgdb_break_tasklet_var, 0);
920}
921
922static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);
923
924void kgdb_schedule_breakpoint(void)
925{
926 if (atomic_read(&kgdb_break_tasklet_var) ||
927 atomic_read(&kgdb_active) != -1 ||
928 atomic_read(&kgdb_setting_breakpoint))
929 return;
930 atomic_inc(&kgdb_break_tasklet_var);
931 tasklet_schedule(&kgdb_tasklet_breakpoint);
932}
933EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint);
934
935static void kgdb_initial_breakpoint(void)
936{
937 kgdb_break_asap = 0;
938
939 printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
940 kgdb_breakpoint();
941}
942
943
944
945
946
947
948
949int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
950{
951 int err;
952
953 spin_lock(&kgdb_registration_lock);
954
955 if (dbg_io_ops) {
956 spin_unlock(&kgdb_registration_lock);
957
958 printk(KERN_ERR "kgdb: Another I/O driver is already "
959 "registered with KGDB.\n");
960 return -EBUSY;
961 }
962
963 if (new_dbg_io_ops->init) {
964 err = new_dbg_io_ops->init();
965 if (err) {
966 spin_unlock(&kgdb_registration_lock);
967 return err;
968 }
969 }
970
971 dbg_io_ops = new_dbg_io_ops;
972
973 spin_unlock(&kgdb_registration_lock);
974
975 printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
976 new_dbg_io_ops->name);
977
978
979 kgdb_register_callbacks();
980
981 if (kgdb_break_asap)
982 kgdb_initial_breakpoint();
983
984 return 0;
985}
986EXPORT_SYMBOL_GPL(kgdb_register_io_module);
987
988
989
990
991
992
993
994void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)
995{
996 BUG_ON(kgdb_connected);
997
998
999
1000
1001
1002 kgdb_unregister_callbacks();
1003
1004 spin_lock(&kgdb_registration_lock);
1005
1006 WARN_ON_ONCE(dbg_io_ops != old_dbg_io_ops);
1007 dbg_io_ops = NULL;
1008
1009 spin_unlock(&kgdb_registration_lock);
1010
1011 printk(KERN_INFO
1012 "kgdb: Unregistered I/O driver %s, debugger disabled.\n",
1013 old_dbg_io_ops->name);
1014}
1015EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
1016
1017int dbg_io_get_char(void)
1018{
1019 int ret = dbg_io_ops->read_char();
1020 if (ret == NO_POLL_CHAR)
1021 return -1;
1022 if (!dbg_kdb_mode)
1023 return ret;
1024 if (ret == 127)
1025 return 8;
1026 return ret;
1027}
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037void kgdb_breakpoint(void)
1038{
1039 atomic_inc(&kgdb_setting_breakpoint);
1040 wmb();
1041 arch_kgdb_breakpoint();
1042 wmb();
1043 atomic_dec(&kgdb_setting_breakpoint);
1044}
1045EXPORT_SYMBOL_GPL(kgdb_breakpoint);
1046
1047static int __init opt_kgdb_wait(char *str)
1048{
1049 kgdb_break_asap = 1;
1050
1051 kdb_init(KDB_INIT_EARLY);
1052 if (kgdb_io_module_registered)
1053 kgdb_initial_breakpoint();
1054
1055 return 0;
1056}
1057
1058early_param("kgdbwait", opt_kgdb_wait);
1059