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