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