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