4 * Maintainer: Jason Wessel <jason.wessel@windriver.com>
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-2008 Wind River Systems, Inc.
13 * Copyright (C) 2007 MontaVista Software, Inc.
14 * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
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.
23 * Original KGDB stub: David Grothe <dave@gcom.com>,
24 * Tigran Aivazian <tigran@sco.com>
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.
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/reboot.h>
41 #include <linux/string.h>
42 #include <linux/delay.h>
43 #include <linux/sched.h>
44 #include <linux/sysrq.h>
45 #include <linux/init.h>
46 #include <linux/kgdb.h>
47 #include <linux/pid.h>
48 #include <linux/smp.h>
51 #include <asm/cacheflush.h>
52 #include <asm/byteorder.h>
53 #include <asm/atomic.h>
54 #include <asm/system.h>
55 #include <asm/unaligned.h>
57 static int kgdb_break_asap
;
59 #define KGDB_MAX_THREAD_QUERY 17
66 unsigned long thr_query
;
67 unsigned long threadid
;
68 long kgdb_usethreadid
;
69 struct pt_regs
*linux_regs
;
72 static struct debuggerinfo_struct
{
74 struct task_struct
*task
;
78 * kgdb_connected - Is a host GDB connected to us?
81 EXPORT_SYMBOL_GPL(kgdb_connected
);
83 /* All the KGDB handlers are installed */
84 static int kgdb_io_module_registered
;
86 /* Guard for recursive entry */
87 static int exception_level
;
89 static struct kgdb_io
*kgdb_io_ops
;
90 static DEFINE_SPINLOCK(kgdb_registration_lock
);
92 /* kgdb console driver is loaded */
93 static int kgdb_con_registered
;
94 /* determine if kgdb console output should be used */
95 static int kgdb_use_con
;
97 static int __init
opt_kgdb_con(char *str
)
103 early_param("kgdbcon", opt_kgdb_con
);
105 module_param(kgdb_use_con
, int, 0644);
108 * Holds information about breakpoints in a kernel. These breakpoints are
109 * added and removed by gdb.
111 static struct kgdb_bkpt kgdb_break
[KGDB_MAX_BREAKPOINTS
] = {
112 [0 ... KGDB_MAX_BREAKPOINTS
-1] = { .state
= BP_UNDEFINED
}
116 * The CPU# of the active CPU, or -1 if none:
118 atomic_t kgdb_active
= ATOMIC_INIT(-1);
121 * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
122 * bootup code (which might not have percpu set up yet):
124 static atomic_t passive_cpu_wait
[NR_CPUS
];
125 static atomic_t cpu_in_kgdb
[NR_CPUS
];
126 atomic_t kgdb_setting_breakpoint
;
128 struct task_struct
*kgdb_usethread
;
129 struct task_struct
*kgdb_contthread
;
131 int kgdb_single_step
;
132 pid_t kgdb_sstep_pid
;
134 /* Our I/O buffers. */
135 static char remcom_in_buffer
[BUFMAX
];
136 static char remcom_out_buffer
[BUFMAX
];
138 /* Storage for the registers, in GDB format. */
139 static unsigned long gdb_regs
[(NUMREGBYTES
+
140 sizeof(unsigned long) - 1) /
141 sizeof(unsigned long)];
143 /* to keep track of the CPU which is doing the single stepping*/
144 atomic_t kgdb_cpu_doing_single_step
= ATOMIC_INIT(-1);
147 * If you are debugging a problem where roundup (the collection of
148 * all other CPUs) is a problem [this should be extremely rare],
149 * then use the nokgdbroundup option to avoid roundup. In that case
150 * the other CPUs might interfere with your debugging context, so
151 * use this with care:
153 static int kgdb_do_roundup
= 1;
155 static int __init
opt_nokgdbroundup(char *str
)
162 early_param("nokgdbroundup", opt_nokgdbroundup
);
165 * Finally, some KGDB code :-)
169 * Weak aliases for breakpoint management,
170 * can be overriden by architectures when needed:
172 int __weak
kgdb_arch_set_breakpoint(unsigned long addr
, char *saved_instr
)
176 err
= probe_kernel_read(saved_instr
, (char *)addr
, BREAK_INSTR_SIZE
);
180 return probe_kernel_write((char *)addr
, arch_kgdb_ops
.gdb_bpt_instr
,
184 int __weak
kgdb_arch_remove_breakpoint(unsigned long addr
, char *bundle
)
186 return probe_kernel_write((char *)addr
,
187 (char *)bundle
, BREAK_INSTR_SIZE
);
190 int __weak
kgdb_validate_break_address(unsigned long addr
)
192 char tmp_variable
[BREAK_INSTR_SIZE
];
194 /* Validate setting the breakpoint and then removing it. In the
195 * remove fails, the kernel needs to emit a bad message because we
196 * are deep trouble not being able to put things back the way we
199 err
= kgdb_arch_set_breakpoint(addr
, tmp_variable
);
202 err
= kgdb_arch_remove_breakpoint(addr
, tmp_variable
);
204 printk(KERN_ERR
"KGDB: Critical breakpoint error, kernel "
205 "memory destroyed at: %lx", addr
);
209 unsigned long __weak
kgdb_arch_pc(int exception
, struct pt_regs
*regs
)
211 return instruction_pointer(regs
);
214 int __weak
kgdb_arch_init(void)
219 int __weak
kgdb_skipexception(int exception
, struct pt_regs
*regs
)
225 kgdb_post_primary_code(struct pt_regs
*regs
, int e_vector
, int err_code
)
231 * kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb.
232 * @regs: Current &struct pt_regs.
234 * This function will be called if the particular architecture must
235 * disable hardware debugging while it is processing gdb packets or
236 * handling exception.
238 void __weak
kgdb_disable_hw_debug(struct pt_regs
*regs
)
243 * GDB remote protocol parser:
246 static int hex(char ch
)
248 if ((ch
>= 'a') && (ch
<= 'f'))
249 return ch
- 'a' + 10;
250 if ((ch
>= '0') && (ch
<= '9'))
252 if ((ch
>= 'A') && (ch
<= 'F'))
253 return ch
- 'A' + 10;
257 /* scan for the sequence $<data>#<checksum> */
258 static void get_packet(char *buffer
)
260 unsigned char checksum
;
261 unsigned char xmitcsum
;
267 * Spin and wait around for the start character, ignore all
270 while ((ch
= (kgdb_io_ops
->read_char())) != '$')
280 * now, read until a # or end of buffer is found:
282 while (count
< (BUFMAX
- 1)) {
283 ch
= kgdb_io_ops
->read_char();
286 checksum
= checksum
+ ch
;
293 xmitcsum
= hex(kgdb_io_ops
->read_char()) << 4;
294 xmitcsum
+= hex(kgdb_io_ops
->read_char());
296 if (checksum
!= xmitcsum
)
297 /* failed checksum */
298 kgdb_io_ops
->write_char('-');
300 /* successful transfer */
301 kgdb_io_ops
->write_char('+');
302 if (kgdb_io_ops
->flush
)
303 kgdb_io_ops
->flush();
305 } while (checksum
!= xmitcsum
);
309 * Send the packet in buffer.
310 * Check for gdb connection if asked for.
312 static void put_packet(char *buffer
)
314 unsigned char checksum
;
319 * $<packet info>#<checksum>.
322 kgdb_io_ops
->write_char('$');
326 while ((ch
= buffer
[count
])) {
327 kgdb_io_ops
->write_char(ch
);
332 kgdb_io_ops
->write_char('#');
333 kgdb_io_ops
->write_char(hex_asc_hi(checksum
));
334 kgdb_io_ops
->write_char(hex_asc_lo(checksum
));
335 if (kgdb_io_ops
->flush
)
336 kgdb_io_ops
->flush();
338 /* Now see what we get in reply. */
339 ch
= kgdb_io_ops
->read_char();
342 ch
= kgdb_io_ops
->read_char();
344 /* If we get an ACK, we are done. */
349 * If we get the start of another packet, this means
350 * that GDB is attempting to reconnect. We will NAK
351 * the packet being sent, and stop trying to send this
355 kgdb_io_ops
->write_char('-');
356 if (kgdb_io_ops
->flush
)
357 kgdb_io_ops
->flush();
364 * Convert the memory pointed to by mem into hex, placing result in buf.
365 * Return a pointer to the last char put in buf (null). May return an error.
367 int kgdb_mem2hex(char *mem
, char *buf
, int count
)
373 * We use the upper half of buf as an intermediate buffer for the
374 * raw memory copy. Hex conversion will work against this one.
378 err
= probe_kernel_read(tmp
, mem
, count
);
381 buf
= pack_hex_byte(buf
, *tmp
);
393 * Copy the binary array pointed to by buf into mem. Fix $, #, and
394 * 0x7d escaped with 0x7d. Return a pointer to the character after
395 * the last byte written.
397 static int kgdb_ebin2mem(char *buf
, char *mem
, int count
)
402 while (count
-- > 0) {
407 err
= probe_kernel_write(mem
, &c
, 1);
418 * Convert the hex array pointed to by buf into binary to be placed in mem.
419 * Return a pointer to the character AFTER the last byte written.
420 * May return an error.
422 int kgdb_hex2mem(char *buf
, char *mem
, int count
)
428 * We use the upper half of buf as an intermediate buffer for the
429 * raw memory that is converted from hex.
431 tmp_raw
= buf
+ count
* 2;
433 tmp_hex
= tmp_raw
- 1;
434 while (tmp_hex
>= buf
) {
436 *tmp_raw
= hex(*tmp_hex
--);
437 *tmp_raw
|= hex(*tmp_hex
--) << 4;
440 return probe_kernel_write(mem
, tmp_raw
, count
);
444 * While we find nice hex chars, build a long_val.
445 * Return number of chars processed.
447 int kgdb_hex2long(char **ptr
, unsigned long *long_val
)
460 hex_val
= hex(**ptr
);
464 *long_val
= (*long_val
<< 4) | hex_val
;
470 *long_val
= -*long_val
;
475 /* Write memory due to an 'M' or 'X' packet. */
476 static int write_mem_msg(int binary
)
478 char *ptr
= &remcom_in_buffer
[1];
480 unsigned long length
;
483 if (kgdb_hex2long(&ptr
, &addr
) > 0 && *(ptr
++) == ',' &&
484 kgdb_hex2long(&ptr
, &length
) > 0 && *(ptr
++) == ':') {
486 err
= kgdb_ebin2mem(ptr
, (char *)addr
, length
);
488 err
= kgdb_hex2mem(ptr
, (char *)addr
, length
);
491 if (CACHE_FLUSH_IS_SAFE
)
492 flush_icache_range(addr
, addr
+ length
);
499 static void error_packet(char *pkt
, int error
)
503 pkt
[1] = hex_asc
[(error
/ 10)];
504 pkt
[2] = hex_asc
[(error
% 10)];
509 * Thread ID accessors. We represent a flat TID space to GDB, where
510 * the per CPU idle threads (which under Linux all have PID 0) are
511 * remapped to negative TIDs.
514 #define BUF_THREAD_ID_SIZE 16
516 static char *pack_threadid(char *pkt
, unsigned char *id
)
520 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
522 pkt
= pack_hex_byte(pkt
, *id
++);
527 static void int_to_threadref(unsigned char *id
, int value
)
532 scan
= (unsigned char *)id
;
535 put_unaligned_be32(value
, scan
);
538 static struct task_struct
*getthread(struct pt_regs
*regs
, int tid
)
541 * Non-positive TIDs are remapped to the cpu shadow information
543 if (tid
== 0 || tid
== -1)
544 tid
= -atomic_read(&kgdb_active
) - 2;
545 if (tid
< -1 && tid
> -NR_CPUS
- 2) {
546 if (kgdb_info
[-tid
- 2].task
)
547 return kgdb_info
[-tid
- 2].task
;
549 return idle_task(-tid
- 2);
552 printk(KERN_ERR
"KGDB: Internal thread select error\n");
558 * find_task_by_pid_ns() does not take the tasklist lock anymore
559 * but is nicely RCU locked - hence is a pretty resilient
562 return find_task_by_pid_ns(tid
, &init_pid_ns
);
566 * CPU debug state control:
570 static void kgdb_wait(struct pt_regs
*regs
)
575 local_irq_save(flags
);
576 cpu
= raw_smp_processor_id();
577 kgdb_info
[cpu
].debuggerinfo
= regs
;
578 kgdb_info
[cpu
].task
= current
;
580 * Make sure the above info reaches the primary CPU before
581 * our cpu_in_kgdb[] flag setting does:
584 atomic_set(&cpu_in_kgdb
[cpu
], 1);
586 /* Wait till primary CPU is done with debugging */
587 while (atomic_read(&passive_cpu_wait
[cpu
]))
590 kgdb_info
[cpu
].debuggerinfo
= NULL
;
591 kgdb_info
[cpu
].task
= NULL
;
593 /* fix up hardware debug registers on local cpu */
594 if (arch_kgdb_ops
.correct_hw_break
)
595 arch_kgdb_ops
.correct_hw_break();
597 /* Signal the primary CPU that we are done: */
598 atomic_set(&cpu_in_kgdb
[cpu
], 0);
599 touch_softlockup_watchdog_sync();
600 clocksource_touch_watchdog();
601 local_irq_restore(flags
);
606 * Some architectures need cache flushes when we set/clear a
609 static void kgdb_flush_swbreak_addr(unsigned long addr
)
611 if (!CACHE_FLUSH_IS_SAFE
)
614 if (current
->mm
&& current
->mm
->mmap_cache
) {
615 flush_cache_range(current
->mm
->mmap_cache
,
616 addr
, addr
+ BREAK_INSTR_SIZE
);
618 /* Force flush instruction cache if it was outside the mm */
619 flush_icache_range(addr
, addr
+ BREAK_INSTR_SIZE
);
623 * SW breakpoint management:
625 static int kgdb_activate_sw_breakpoints(void)
631 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
632 if (kgdb_break
[i
].state
!= BP_SET
)
635 addr
= kgdb_break
[i
].bpt_addr
;
636 error
= kgdb_arch_set_breakpoint(addr
,
637 kgdb_break
[i
].saved_instr
);
641 kgdb_flush_swbreak_addr(addr
);
642 kgdb_break
[i
].state
= BP_ACTIVE
;
647 static int kgdb_set_sw_break(unsigned long addr
)
649 int err
= kgdb_validate_break_address(addr
);
656 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
657 if ((kgdb_break
[i
].state
== BP_SET
) &&
658 (kgdb_break
[i
].bpt_addr
== addr
))
661 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
662 if (kgdb_break
[i
].state
== BP_REMOVED
&&
663 kgdb_break
[i
].bpt_addr
== addr
) {
670 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
671 if (kgdb_break
[i
].state
== BP_UNDEFINED
) {
681 kgdb_break
[breakno
].state
= BP_SET
;
682 kgdb_break
[breakno
].type
= BP_BREAKPOINT
;
683 kgdb_break
[breakno
].bpt_addr
= addr
;
688 static int kgdb_deactivate_sw_breakpoints(void)
694 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
695 if (kgdb_break
[i
].state
!= BP_ACTIVE
)
697 addr
= kgdb_break
[i
].bpt_addr
;
698 error
= kgdb_arch_remove_breakpoint(addr
,
699 kgdb_break
[i
].saved_instr
);
703 kgdb_flush_swbreak_addr(addr
);
704 kgdb_break
[i
].state
= BP_SET
;
709 static int kgdb_remove_sw_break(unsigned long addr
)
713 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
714 if ((kgdb_break
[i
].state
== BP_SET
) &&
715 (kgdb_break
[i
].bpt_addr
== addr
)) {
716 kgdb_break
[i
].state
= BP_REMOVED
;
723 int kgdb_isremovedbreak(unsigned long addr
)
727 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
728 if ((kgdb_break
[i
].state
== BP_REMOVED
) &&
729 (kgdb_break
[i
].bpt_addr
== addr
))
735 static int remove_all_break(void)
741 /* Clear memory breakpoints. */
742 for (i
= 0; i
< KGDB_MAX_BREAKPOINTS
; i
++) {
743 if (kgdb_break
[i
].state
!= BP_ACTIVE
)
745 addr
= kgdb_break
[i
].bpt_addr
;
746 error
= kgdb_arch_remove_breakpoint(addr
,
747 kgdb_break
[i
].saved_instr
);
749 printk(KERN_ERR
"KGDB: breakpoint remove failed: %lx\n",
752 kgdb_break
[i
].state
= BP_UNDEFINED
;
755 /* Clear hardware breakpoints. */
756 if (arch_kgdb_ops
.remove_all_hw_break
)
757 arch_kgdb_ops
.remove_all_hw_break();
763 * Remap normal tasks to their real PID,
764 * CPU shadow threads are mapped to -CPU - 2
766 static inline int shadow_pid(int realpid
)
771 return -raw_smp_processor_id() - 2;
774 static char gdbmsgbuf
[BUFMAX
+ 1];
776 static void kgdb_msg_write(const char *s
, int len
)
785 /* Fill and send buffers... */
787 bufptr
= gdbmsgbuf
+ 1;
789 /* Calculate how many this time */
790 if ((len
<< 1) > (BUFMAX
- 2))
791 wcount
= (BUFMAX
- 2) >> 1;
795 /* Pack in hex chars */
796 for (i
= 0; i
< wcount
; i
++)
797 bufptr
= pack_hex_byte(bufptr
, s
[i
]);
805 put_packet(gdbmsgbuf
);
810 * Return true if there is a valid kgdb I/O module. Also if no
811 * debugger is attached a message can be printed to the console about
812 * waiting for the debugger to attach.
814 * The print_wait argument is only to be true when called from inside
815 * the core kgdb_handle_exception, because it will wait for the
816 * debugger to attach.
818 static int kgdb_io_ready(int print_wait
)
824 if (atomic_read(&kgdb_setting_breakpoint
))
827 printk(KERN_CRIT
"KGDB: Waiting for remote debugger\n");
832 * All the functions that start with gdb_cmd are the various
833 * operations to implement the handlers for the gdbserial protocol
834 * where KGDB is communicating with an external debugger
837 /* Handle the '?' status packets */
838 static void gdb_cmd_status(struct kgdb_state
*ks
)
841 * We know that this packet is only sent
842 * during initial connect. So to be safe,
843 * we clear out our breakpoints now in case
844 * GDB is reconnecting.
848 remcom_out_buffer
[0] = 'S';
849 pack_hex_byte(&remcom_out_buffer
[1], ks
->signo
);
852 /* Handle the 'g' get registers request */
853 static void gdb_cmd_getregs(struct kgdb_state
*ks
)
855 struct task_struct
*thread
;
856 void *local_debuggerinfo
;
859 thread
= kgdb_usethread
;
861 thread
= kgdb_info
[ks
->cpu
].task
;
862 local_debuggerinfo
= kgdb_info
[ks
->cpu
].debuggerinfo
;
864 local_debuggerinfo
= NULL
;
865 for_each_online_cpu(i
) {
867 * Try to find the task on some other
868 * or possibly this node if we do not
869 * find the matching task then we try
870 * to approximate the results.
872 if (thread
== kgdb_info
[i
].task
)
873 local_debuggerinfo
= kgdb_info
[i
].debuggerinfo
;
878 * All threads that don't have debuggerinfo should be
879 * in __schedule() sleeping, since all other CPUs
880 * are in kgdb_wait, and thus have debuggerinfo.
882 if (local_debuggerinfo
) {
883 pt_regs_to_gdb_regs(gdb_regs
, local_debuggerinfo
);
886 * Pull stuff saved during switch_to; nothing
887 * else is accessible (or even particularly
890 * This should be enough for a stack trace.
892 sleeping_thread_to_gdb_regs(gdb_regs
, thread
);
894 kgdb_mem2hex((char *)gdb_regs
, remcom_out_buffer
, NUMREGBYTES
);
897 /* Handle the 'G' set registers request */
898 static void gdb_cmd_setregs(struct kgdb_state
*ks
)
900 kgdb_hex2mem(&remcom_in_buffer
[1], (char *)gdb_regs
, NUMREGBYTES
);
902 if (kgdb_usethread
&& kgdb_usethread
!= current
) {
903 error_packet(remcom_out_buffer
, -EINVAL
);
905 gdb_regs_to_pt_regs(gdb_regs
, ks
->linux_regs
);
906 strcpy(remcom_out_buffer
, "OK");
910 /* Handle the 'm' memory read bytes */
911 static void gdb_cmd_memread(struct kgdb_state
*ks
)
913 char *ptr
= &remcom_in_buffer
[1];
914 unsigned long length
;
918 if (kgdb_hex2long(&ptr
, &addr
) > 0 && *ptr
++ == ',' &&
919 kgdb_hex2long(&ptr
, &length
) > 0) {
920 err
= kgdb_mem2hex((char *)addr
, remcom_out_buffer
, length
);
922 error_packet(remcom_out_buffer
, err
);
924 error_packet(remcom_out_buffer
, -EINVAL
);
928 /* Handle the 'M' memory write bytes */
929 static void gdb_cmd_memwrite(struct kgdb_state
*ks
)
931 int err
= write_mem_msg(0);
934 error_packet(remcom_out_buffer
, err
);
936 strcpy(remcom_out_buffer
, "OK");
939 /* Handle the 'X' memory binary write bytes */
940 static void gdb_cmd_binwrite(struct kgdb_state
*ks
)
942 int err
= write_mem_msg(1);
945 error_packet(remcom_out_buffer
, err
);
947 strcpy(remcom_out_buffer
, "OK");
950 /* Handle the 'D' or 'k', detach or kill packets */
951 static void gdb_cmd_detachkill(struct kgdb_state
*ks
)
955 /* The detach case */
956 if (remcom_in_buffer
[0] == 'D') {
957 error
= remove_all_break();
959 error_packet(remcom_out_buffer
, error
);
961 strcpy(remcom_out_buffer
, "OK");
964 put_packet(remcom_out_buffer
);
967 * Assume the kill case, with no exit code checking,
968 * trying to force detach the debugger:
975 /* Handle the 'R' reboot packets */
976 static int gdb_cmd_reboot(struct kgdb_state
*ks
)
978 /* For now, only honor R0 */
979 if (strcmp(remcom_in_buffer
, "R0") == 0) {
980 printk(KERN_CRIT
"Executing emergency reboot\n");
981 strcpy(remcom_out_buffer
, "OK");
982 put_packet(remcom_out_buffer
);
985 * Execution should not return from
986 * machine_emergency_restart()
988 machine_emergency_restart();
996 /* Handle the 'q' query packets */
997 static void gdb_cmd_query(struct kgdb_state
*ks
)
999 struct task_struct
*g
;
1000 struct task_struct
*p
;
1001 unsigned char thref
[8];
1007 switch (remcom_in_buffer
[1]) {
1010 if (memcmp(remcom_in_buffer
+ 2, "ThreadInfo", 10)) {
1011 error_packet(remcom_out_buffer
, -EINVAL
);
1016 remcom_out_buffer
[0] = 'm';
1017 ptr
= remcom_out_buffer
+ 1;
1018 if (remcom_in_buffer
[1] == 'f') {
1019 /* Each cpu is a shadow thread */
1020 for_each_online_cpu(cpu
) {
1022 int_to_threadref(thref
, -cpu
- 2);
1023 pack_threadid(ptr
, thref
);
1024 ptr
+= BUF_THREAD_ID_SIZE
;
1030 do_each_thread(g
, p
) {
1031 if (i
>= ks
->thr_query
&& !finished
) {
1032 int_to_threadref(thref
, p
->pid
);
1033 pack_threadid(ptr
, thref
);
1034 ptr
+= BUF_THREAD_ID_SIZE
;
1037 if (ks
->thr_query
% KGDB_MAX_THREAD_QUERY
== 0)
1041 } while_each_thread(g
, p
);
1047 /* Current thread id */
1048 strcpy(remcom_out_buffer
, "QC");
1049 ks
->threadid
= shadow_pid(current
->pid
);
1050 int_to_threadref(thref
, ks
->threadid
);
1051 pack_threadid(remcom_out_buffer
+ 2, thref
);
1054 if (memcmp(remcom_in_buffer
+ 1, "ThreadExtraInfo,", 16)) {
1055 error_packet(remcom_out_buffer
, -EINVAL
);
1059 ptr
= remcom_in_buffer
+ 17;
1060 kgdb_hex2long(&ptr
, &ks
->threadid
);
1061 if (!getthread(ks
->linux_regs
, ks
->threadid
)) {
1062 error_packet(remcom_out_buffer
, -EINVAL
);
1065 if ((int)ks
->threadid
> 0) {
1066 kgdb_mem2hex(getthread(ks
->linux_regs
,
1067 ks
->threadid
)->comm
,
1068 remcom_out_buffer
, 16);
1070 static char tmpstr
[23 + BUF_THREAD_ID_SIZE
];
1072 sprintf(tmpstr
, "shadowCPU%d",
1073 (int)(-ks
->threadid
- 2));
1074 kgdb_mem2hex(tmpstr
, remcom_out_buffer
, strlen(tmpstr
));
1080 /* Handle the 'H' task query packets */
1081 static void gdb_cmd_task(struct kgdb_state
*ks
)
1083 struct task_struct
*thread
;
1086 switch (remcom_in_buffer
[1]) {
1088 ptr
= &remcom_in_buffer
[2];
1089 kgdb_hex2long(&ptr
, &ks
->threadid
);
1090 thread
= getthread(ks
->linux_regs
, ks
->threadid
);
1091 if (!thread
&& ks
->threadid
> 0) {
1092 error_packet(remcom_out_buffer
, -EINVAL
);
1095 kgdb_usethread
= thread
;
1096 ks
->kgdb_usethreadid
= ks
->threadid
;
1097 strcpy(remcom_out_buffer
, "OK");
1100 ptr
= &remcom_in_buffer
[2];
1101 kgdb_hex2long(&ptr
, &ks
->threadid
);
1102 if (!ks
->threadid
) {
1103 kgdb_contthread
= NULL
;
1105 thread
= getthread(ks
->linux_regs
, ks
->threadid
);
1106 if (!thread
&& ks
->threadid
> 0) {
1107 error_packet(remcom_out_buffer
, -EINVAL
);
1110 kgdb_contthread
= thread
;
1112 strcpy(remcom_out_buffer
, "OK");
1117 /* Handle the 'T' thread query packets */
1118 static void gdb_cmd_thread(struct kgdb_state
*ks
)
1120 char *ptr
= &remcom_in_buffer
[1];
1121 struct task_struct
*thread
;
1123 kgdb_hex2long(&ptr
, &ks
->threadid
);
1124 thread
= getthread(ks
->linux_regs
, ks
->threadid
);
1126 strcpy(remcom_out_buffer
, "OK");
1128 error_packet(remcom_out_buffer
, -EINVAL
);
1131 /* Handle the 'z' or 'Z' breakpoint remove or set packets */
1132 static void gdb_cmd_break(struct kgdb_state
*ks
)
1135 * Since GDB-5.3, it's been drafted that '0' is a software
1136 * breakpoint, '1' is a hardware breakpoint, so let's do that.
1138 char *bpt_type
= &remcom_in_buffer
[1];
1139 char *ptr
= &remcom_in_buffer
[2];
1141 unsigned long length
;
1144 if (arch_kgdb_ops
.set_hw_breakpoint
&& *bpt_type
>= '1') {
1146 if (*bpt_type
> '4')
1149 if (*bpt_type
!= '0' && *bpt_type
!= '1')
1155 * Test if this is a hardware breakpoint, and
1158 if (*bpt_type
== '1' && !(arch_kgdb_ops
.flags
& KGDB_HW_BREAKPOINT
))
1162 if (*(ptr
++) != ',') {
1163 error_packet(remcom_out_buffer
, -EINVAL
);
1166 if (!kgdb_hex2long(&ptr
, &addr
)) {
1167 error_packet(remcom_out_buffer
, -EINVAL
);
1170 if (*(ptr
++) != ',' ||
1171 !kgdb_hex2long(&ptr
, &length
)) {
1172 error_packet(remcom_out_buffer
, -EINVAL
);
1176 if (remcom_in_buffer
[0] == 'Z' && *bpt_type
== '0')
1177 error
= kgdb_set_sw_break(addr
);
1178 else if (remcom_in_buffer
[0] == 'z' && *bpt_type
== '0')
1179 error
= kgdb_remove_sw_break(addr
);
1180 else if (remcom_in_buffer
[0] == 'Z')
1181 error
= arch_kgdb_ops
.set_hw_breakpoint(addr
,
1182 (int)length
, *bpt_type
- '0');
1183 else if (remcom_in_buffer
[0] == 'z')
1184 error
= arch_kgdb_ops
.remove_hw_breakpoint(addr
,
1185 (int) length
, *bpt_type
- '0');
1188 strcpy(remcom_out_buffer
, "OK");
1190 error_packet(remcom_out_buffer
, error
);
1193 /* Handle the 'C' signal / exception passing packets */
1194 static int gdb_cmd_exception_pass(struct kgdb_state
*ks
)
1196 /* C09 == pass exception
1197 * C15 == detach kgdb, pass exception
1199 if (remcom_in_buffer
[1] == '0' && remcom_in_buffer
[2] == '9') {
1201 ks
->pass_exception
= 1;
1202 remcom_in_buffer
[0] = 'c';
1204 } else if (remcom_in_buffer
[1] == '1' && remcom_in_buffer
[2] == '5') {
1206 ks
->pass_exception
= 1;
1207 remcom_in_buffer
[0] = 'D';
1213 kgdb_msg_write("KGDB only knows signal 9 (pass)"
1214 " and 15 (pass and disconnect)\n"
1215 "Executing a continue without signal passing\n", 0);
1216 remcom_in_buffer
[0] = 'c';
1219 /* Indicate fall through */
1224 * This function performs all gdbserial command procesing
1226 static int gdb_serial_stub(struct kgdb_state
*ks
)
1231 /* Clear the out buffer. */
1232 memset(remcom_out_buffer
, 0, sizeof(remcom_out_buffer
));
1234 if (kgdb_connected
) {
1235 unsigned char thref
[8];
1238 /* Reply to host that an exception has occurred */
1239 ptr
= remcom_out_buffer
;
1241 ptr
= pack_hex_byte(ptr
, ks
->signo
);
1242 ptr
+= strlen(strcpy(ptr
, "thread:"));
1243 int_to_threadref(thref
, shadow_pid(current
->pid
));
1244 ptr
= pack_threadid(ptr
, thref
);
1246 put_packet(remcom_out_buffer
);
1249 kgdb_usethread
= kgdb_info
[ks
->cpu
].task
;
1250 ks
->kgdb_usethreadid
= shadow_pid(kgdb_info
[ks
->cpu
].task
->pid
);
1251 ks
->pass_exception
= 0;
1256 /* Clear the out buffer. */
1257 memset(remcom_out_buffer
, 0, sizeof(remcom_out_buffer
));
1259 get_packet(remcom_in_buffer
);
1261 switch (remcom_in_buffer
[0]) {
1262 case '?': /* gdbserial status */
1265 case 'g': /* return the value of the CPU registers */
1266 gdb_cmd_getregs(ks
);
1268 case 'G': /* set the value of the CPU registers - return OK */
1269 gdb_cmd_setregs(ks
);
1271 case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
1272 gdb_cmd_memread(ks
);
1274 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA..AA */
1275 gdb_cmd_memwrite(ks
);
1277 case 'X': /* XAA..AA,LLLL: Write LLLL bytes at address AA..AA */
1278 gdb_cmd_binwrite(ks
);
1280 /* kill or detach. KGDB should treat this like a
1283 case 'D': /* Debugger detach */
1284 case 'k': /* Debugger detach via kill */
1285 gdb_cmd_detachkill(ks
);
1286 goto default_handle
;
1287 case 'R': /* Reboot */
1288 if (gdb_cmd_reboot(ks
))
1289 goto default_handle
;
1291 case 'q': /* query command */
1294 case 'H': /* task related */
1297 case 'T': /* Query thread status */
1300 case 'z': /* Break point remove */
1301 case 'Z': /* Break point set */
1304 case 'C': /* Exception passing */
1305 tmp
= gdb_cmd_exception_pass(ks
);
1307 goto default_handle
;
1310 /* Fall through on tmp < 0 */
1311 case 'c': /* Continue packet */
1312 case 's': /* Single step packet */
1313 if (kgdb_contthread
&& kgdb_contthread
!= current
) {
1314 /* Can't switch threads in kgdb */
1315 error_packet(remcom_out_buffer
, -EINVAL
);
1318 kgdb_activate_sw_breakpoints();
1319 /* Fall through to default processing */
1322 error
= kgdb_arch_handle_exception(ks
->ex_vector
,
1329 * Leave cmd processing on error, detach,
1330 * kill, continue, or single step.
1332 if (error
>= 0 || remcom_in_buffer
[0] == 'D' ||
1333 remcom_in_buffer
[0] == 'k') {
1340 /* reply to the request */
1341 put_packet(remcom_out_buffer
);
1345 if (ks
->pass_exception
)
1350 static int kgdb_reenter_check(struct kgdb_state
*ks
)
1354 if (atomic_read(&kgdb_active
) != raw_smp_processor_id())
1357 /* Panic on recursive debugger calls: */
1359 addr
= kgdb_arch_pc(ks
->ex_vector
, ks
->linux_regs
);
1360 kgdb_deactivate_sw_breakpoints();
1363 * If the break point removed ok at the place exception
1364 * occurred, try to recover and print a warning to the end
1365 * user because the user planted a breakpoint in a place that
1366 * KGDB needs in order to function.
1368 if (kgdb_remove_sw_break(addr
) == 0) {
1369 exception_level
= 0;
1370 kgdb_skipexception(ks
->ex_vector
, ks
->linux_regs
);
1371 kgdb_activate_sw_breakpoints();
1372 printk(KERN_CRIT
"KGDB: re-enter error: breakpoint removed %lx\n",
1379 kgdb_skipexception(ks
->ex_vector
, ks
->linux_regs
);
1381 if (exception_level
> 1) {
1383 panic("Recursive entry to debugger");
1386 printk(KERN_CRIT
"KGDB: re-enter exception: ALL breakpoints killed\n");
1388 panic("Recursive entry to debugger");
1394 * kgdb_handle_exception() - main entry point from a kernel exception
1396 * Locking hierarchy:
1397 * interface locks, if any (begin_session)
1398 * kgdb lock (kgdb_active)
1401 kgdb_handle_exception(int evector
, int signo
, int ecode
, struct pt_regs
*regs
)
1403 struct kgdb_state kgdb_var
;
1404 struct kgdb_state
*ks
= &kgdb_var
;
1405 unsigned long flags
;
1409 ks
->cpu
= raw_smp_processor_id();
1410 ks
->ex_vector
= evector
;
1412 ks
->ex_vector
= evector
;
1413 ks
->err_code
= ecode
;
1414 ks
->kgdb_usethreadid
= 0;
1415 ks
->linux_regs
= regs
;
1417 if (kgdb_reenter_check(ks
))
1418 return 0; /* Ouch, double exception ! */
1422 * Interrupts will be restored by the 'trap return' code, except when
1425 local_irq_save(flags
);
1427 cpu
= raw_smp_processor_id();
1430 * Acquire the kgdb_active lock:
1432 while (atomic_cmpxchg(&kgdb_active
, -1, cpu
) != -1)
1436 * Do not start the debugger connection on this CPU if the last
1437 * instance of the exception handler wanted to come into the
1438 * debugger on a different CPU via a single step
1440 if (atomic_read(&kgdb_cpu_doing_single_step
) != -1 &&
1441 kgdb_info
[cpu
].task
&&
1442 kgdb_info
[cpu
].task
->pid
!= kgdb_sstep_pid
) {
1443 atomic_set(&kgdb_active
, -1);
1444 touch_softlockup_watchdog_sync();
1445 clocksource_touch_watchdog();
1446 local_irq_restore(flags
);
1451 if (!kgdb_io_ready(1)) {
1453 goto kgdb_restore
; /* No I/O connection, so resume the system */
1457 * Don't enter if we have hit a removed breakpoint.
1459 if (kgdb_skipexception(ks
->ex_vector
, ks
->linux_regs
))
1462 /* Call the I/O driver's pre_exception routine */
1463 if (kgdb_io_ops
->pre_exception
)
1464 kgdb_io_ops
->pre_exception();
1466 kgdb_info
[ks
->cpu
].debuggerinfo
= ks
->linux_regs
;
1467 kgdb_info
[ks
->cpu
].task
= current
;
1469 kgdb_disable_hw_debug(ks
->linux_regs
);
1472 * Get the passive CPU lock which will hold all the non-primary
1473 * CPU in a spin state while the debugger is active
1475 if (!kgdb_single_step
) {
1476 for (i
= 0; i
< NR_CPUS
; i
++)
1477 atomic_set(&passive_cpu_wait
[i
], 1);
1481 * spin_lock code is good enough as a barrier so we don't
1484 atomic_set(&cpu_in_kgdb
[ks
->cpu
], 1);
1487 /* Signal the other CPUs to enter kgdb_wait() */
1488 if ((!kgdb_single_step
) && kgdb_do_roundup
)
1489 kgdb_roundup_cpus(flags
);
1493 * Wait for the other CPUs to be notified and be waiting for us:
1495 for_each_online_cpu(i
) {
1496 while (!atomic_read(&cpu_in_kgdb
[i
]))
1501 * At this point the primary processor is completely
1502 * in the debugger and all secondary CPUs are quiescent
1504 kgdb_post_primary_code(ks
->linux_regs
, ks
->ex_vector
, ks
->err_code
);
1505 kgdb_deactivate_sw_breakpoints();
1506 kgdb_single_step
= 0;
1507 kgdb_contthread
= current
;
1508 exception_level
= 0;
1510 /* Talk to debugger with gdbserial protocol */
1511 error
= gdb_serial_stub(ks
);
1513 /* Call the I/O driver's post_exception routine */
1514 if (kgdb_io_ops
->post_exception
)
1515 kgdb_io_ops
->post_exception();
1517 kgdb_info
[ks
->cpu
].debuggerinfo
= NULL
;
1518 kgdb_info
[ks
->cpu
].task
= NULL
;
1519 atomic_set(&cpu_in_kgdb
[ks
->cpu
], 0);
1521 if (!kgdb_single_step
) {
1522 for (i
= NR_CPUS
-1; i
>= 0; i
--)
1523 atomic_set(&passive_cpu_wait
[i
], 0);
1525 * Wait till all the CPUs have quit
1526 * from the debugger.
1528 for_each_online_cpu(i
) {
1529 while (atomic_read(&cpu_in_kgdb
[i
]))
1535 if (atomic_read(&kgdb_cpu_doing_single_step
) != -1) {
1536 int sstep_cpu
= atomic_read(&kgdb_cpu_doing_single_step
);
1537 if (kgdb_info
[sstep_cpu
].task
)
1538 kgdb_sstep_pid
= kgdb_info
[sstep_cpu
].task
->pid
;
1542 /* Free kgdb_active */
1543 atomic_set(&kgdb_active
, -1);
1544 touch_softlockup_watchdog_sync();
1545 clocksource_touch_watchdog();
1546 local_irq_restore(flags
);
1551 int kgdb_nmicallback(int cpu
, void *regs
)
1554 if (!atomic_read(&cpu_in_kgdb
[cpu
]) &&
1555 atomic_read(&kgdb_active
) != cpu
&&
1556 atomic_read(&cpu_in_kgdb
[atomic_read(&kgdb_active
)])) {
1557 kgdb_wait((struct pt_regs
*)regs
);
1564 static void kgdb_console_write(struct console
*co
, const char *s
,
1567 unsigned long flags
;
1569 /* If we're debugging, or KGDB has not connected, don't try
1571 if (!kgdb_connected
|| atomic_read(&kgdb_active
) != -1)
1574 local_irq_save(flags
);
1575 kgdb_msg_write(s
, count
);
1576 local_irq_restore(flags
);
1579 static struct console kgdbcons
= {
1581 .write
= kgdb_console_write
,
1582 .flags
= CON_PRINTBUFFER
| CON_ENABLED
,
1586 #ifdef CONFIG_MAGIC_SYSRQ
1587 static void sysrq_handle_gdb(int key
, struct tty_struct
*tty
)
1590 printk(KERN_CRIT
"ERROR: No KGDB I/O module available\n");
1593 if (!kgdb_connected
)
1594 printk(KERN_CRIT
"Entering KGDB\n");
1599 static struct sysrq_key_op sysrq_gdb_op
= {
1600 .handler
= sysrq_handle_gdb
,
1601 .help_msg
= "debug(G)",
1602 .action_msg
= "DEBUG",
1606 static void kgdb_register_callbacks(void)
1608 if (!kgdb_io_module_registered
) {
1609 kgdb_io_module_registered
= 1;
1611 #ifdef CONFIG_MAGIC_SYSRQ
1612 register_sysrq_key('g', &sysrq_gdb_op
);
1614 if (kgdb_use_con
&& !kgdb_con_registered
) {
1615 register_console(&kgdbcons
);
1616 kgdb_con_registered
= 1;
1621 static void kgdb_unregister_callbacks(void)
1624 * When this routine is called KGDB should unregister from the
1625 * panic handler and clean up, making sure it is not handling any
1626 * break exceptions at the time.
1628 if (kgdb_io_module_registered
) {
1629 kgdb_io_module_registered
= 0;
1631 #ifdef CONFIG_MAGIC_SYSRQ
1632 unregister_sysrq_key('g', &sysrq_gdb_op
);
1634 if (kgdb_con_registered
) {
1635 unregister_console(&kgdbcons
);
1636 kgdb_con_registered
= 0;
1641 static void kgdb_initial_breakpoint(void)
1643 kgdb_break_asap
= 0;
1645 printk(KERN_CRIT
"kgdb: Waiting for connection from remote gdb...\n");
1650 * kgdb_register_io_module - register KGDB IO module
1651 * @new_kgdb_io_ops: the io ops vector
1653 * Register it with the KGDB core.
1655 int kgdb_register_io_module(struct kgdb_io
*new_kgdb_io_ops
)
1659 spin_lock(&kgdb_registration_lock
);
1662 spin_unlock(&kgdb_registration_lock
);
1664 printk(KERN_ERR
"kgdb: Another I/O driver is already "
1665 "registered with KGDB.\n");
1669 if (new_kgdb_io_ops
->init
) {
1670 err
= new_kgdb_io_ops
->init();
1672 spin_unlock(&kgdb_registration_lock
);
1677 kgdb_io_ops
= new_kgdb_io_ops
;
1679 spin_unlock(&kgdb_registration_lock
);
1681 printk(KERN_INFO
"kgdb: Registered I/O driver %s.\n",
1682 new_kgdb_io_ops
->name
);
1685 kgdb_register_callbacks();
1687 if (kgdb_break_asap
)
1688 kgdb_initial_breakpoint();
1692 EXPORT_SYMBOL_GPL(kgdb_register_io_module
);
1695 * kkgdb_unregister_io_module - unregister KGDB IO module
1696 * @old_kgdb_io_ops: the io ops vector
1698 * Unregister it with the KGDB core.
1700 void kgdb_unregister_io_module(struct kgdb_io
*old_kgdb_io_ops
)
1702 BUG_ON(kgdb_connected
);
1705 * KGDB is no longer able to communicate out, so
1706 * unregister our callbacks and reset state.
1708 kgdb_unregister_callbacks();
1710 spin_lock(&kgdb_registration_lock
);
1712 WARN_ON_ONCE(kgdb_io_ops
!= old_kgdb_io_ops
);
1715 spin_unlock(&kgdb_registration_lock
);
1718 "kgdb: Unregistered I/O driver %s, debugger disabled.\n",
1719 old_kgdb_io_ops
->name
);
1721 EXPORT_SYMBOL_GPL(kgdb_unregister_io_module
);
1724 * kgdb_breakpoint - generate breakpoint exception
1726 * This function will generate a breakpoint exception. It is used at the
1727 * beginning of a program to sync up with a debugger and can be used
1728 * otherwise as a quick means to stop program execution and "break" into
1731 void kgdb_breakpoint(void)
1733 atomic_set(&kgdb_setting_breakpoint
, 1);
1734 wmb(); /* Sync point before breakpoint */
1735 arch_kgdb_breakpoint();
1736 wmb(); /* Sync point after breakpoint */
1737 atomic_set(&kgdb_setting_breakpoint
, 0);
1739 EXPORT_SYMBOL_GPL(kgdb_breakpoint
);
1741 static int __init
opt_kgdb_wait(char *str
)
1743 kgdb_break_asap
= 1;
1745 if (kgdb_io_module_registered
)
1746 kgdb_initial_breakpoint();
1751 early_param("kgdbwait", opt_kgdb_wait
);