Kernel

Kernel Git Source Tree

Root/kernel/kgdb.c

1	/*
2	* KGDB stub.
3	*
4	* Maintainer: Jason Wessel <jason.wessel@windriver.com>
5	*
6	* Copyright (C) 2000-2001 VERITAS Software Corporation.
7	* Copyright (C) 2002-2004 Timesys Corporation
8	* Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
9	* Copyright (C) 2004 Pavel Machek <pavel@suse.cz>
10	* Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
11	* Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
12	* Copyright (C) 2005-2008 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/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>
49	#include <linux/mm.h>
50
51	#include <asm/cacheflush.h>
52	#include <asm/byteorder.h>
53	#include <asm/atomic.h>
54	#include <asm/system.h>
55	#include <asm/unaligned.h>
56
57	static int kgdb_break_asap;
58
59	#define KGDB_MAX_THREAD_QUERY 17
60	struct kgdb_state {
61	int ex_vector;
62	int signo;
63	int err_code;
64	int cpu;
65	int pass_exception;
66	unsigned long thr_query;
67	unsigned long threadid;
68	long kgdb_usethreadid;
69	struct pt_regs *linux_regs;
70	};
71
72	/* Exception state values */
73	#define DCPU_WANT_MASTER 0x1 /* Waiting to become a master kgdb cpu */
74	#define DCPU_NEXT_MASTER 0x2 /* Transition from one master cpu to another */
75	#define DCPU_IS_SLAVE 0x4 /* Slave cpu enter exception */
76	#define DCPU_SSTEP 0x8 /* CPU is single stepping */
77
78	static struct debuggerinfo_struct {
79	void *debuggerinfo;
80	struct task_struct *task;
81	int exception_state;
82	} kgdb_info[NR_CPUS];
83
84	/**
85	* kgdb_connected - Is a host GDB connected to us?
86	*/
87	int kgdb_connected;
88	EXPORT_SYMBOL_GPL(kgdb_connected);
89
90	/* All the KGDB handlers are installed */
91	static int kgdb_io_module_registered;
92
93	/* Guard for recursive entry */
94	static int exception_level;
95
96	static struct kgdb_io *kgdb_io_ops;
97	static DEFINE_SPINLOCK(kgdb_registration_lock);
98
99	/* kgdb console driver is loaded */
100	static int kgdb_con_registered;
101	/* determine if kgdb console output should be used */
102	static int kgdb_use_con;
103
104	static int __init opt_kgdb_con(char *str)
105	{
106	kgdb_use_con = 1;
107	return 0;
108	}
109
110	early_param("kgdbcon", opt_kgdb_con);
111
112	module_param(kgdb_use_con, int, 0644);
113
114	/*
115	* Holds information about breakpoints in a kernel. These breakpoints are
116	* added and removed by gdb.
117	*/
118	static struct kgdb_bkpt kgdb_break[KGDB_MAX_BREAKPOINTS] = {
119	[0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
120	};
121
122	/*
123	* The CPU# of the active CPU, or -1 if none:
124	*/
125	atomic_t kgdb_active = ATOMIC_INIT(-1);
126
127	/*
128	* We use NR_CPUs not PERCPU, in case kgdb is used to debug early
129	* bootup code (which might not have percpu set up yet):
130	*/
131	static atomic_t passive_cpu_wait[NR_CPUS];
132	static atomic_t cpu_in_kgdb[NR_CPUS];
133	atomic_t kgdb_setting_breakpoint;
134
135	struct task_struct *kgdb_usethread;
136	struct task_struct *kgdb_contthread;
137
138	int kgdb_single_step;
139	pid_t kgdb_sstep_pid;
140
141	/* Our I/O buffers. */
142	static char remcom_in_buffer[BUFMAX];
143	static char remcom_out_buffer[BUFMAX];
144
145	/* Storage for the registers, in GDB format. */
146	static unsigned long gdb_regs[(NUMREGBYTES +
147	sizeof(unsigned long) - 1) /
148	sizeof(unsigned long)];
149
150	/* to keep track of the CPU which is doing the single stepping*/
151	atomic_t kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
152
153	/*
154	* If you are debugging a problem where roundup (the collection of
155	* all other CPUs) is a problem [this should be extremely rare],
156	* then use the nokgdbroundup option to avoid roundup. In that case
157	* the other CPUs might interfere with your debugging context, so
158	* use this with care:
159	*/
160	static int kgdb_do_roundup = 1;
161
162	static int __init opt_nokgdbroundup(char *str)
163	{
164	kgdb_do_roundup = 0;
165
166	return 0;
167	}
168
169	early_param("nokgdbroundup", opt_nokgdbroundup);
170
171	/*
172	* Finally, some KGDB code :-)
173	*/
174
175	/*
176	* Weak aliases for breakpoint management,
177	* can be overriden by architectures when needed:
178	*/
179	int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
180	{
181	int err;
182
183	err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
184	if (err)
185	return err;
186
187	return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
188	BREAK_INSTR_SIZE);
189	}
190
191	int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
192	{
193	return probe_kernel_write((char *)addr,
194	(char *)bundle, BREAK_INSTR_SIZE);
195	}
196
197	int __weak kgdb_validate_break_address(unsigned long addr)
198	{
199	char tmp_variable[BREAK_INSTR_SIZE];
200	int err;
201	/* Validate setting the breakpoint and then removing it. In the
202	* remove fails, the kernel needs to emit a bad message because we
203	* are deep trouble not being able to put things back the way we
204	* found them.
205	*/
206	err = kgdb_arch_set_breakpoint(addr, tmp_variable);
207	if (err)
208	return err;
209	err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
210	if (err)
211	printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
212	"memory destroyed at: %lx", addr);
213	return err;
214	}
215
216	unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
217	{
218	return instruction_pointer(regs);
219	}
220
221	int __weak kgdb_arch_init(void)
222	{
223	return 0;
224	}
225
226	int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
227	{
228	return 0;
229	}
230
231	void __weak
232	kgdb_post_primary_code(struct pt_regs *regs, int e_vector, int err_code)
233	{
234	return;
235	}
236
237	/**
238	* kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb.
239	* @regs: Current &struct pt_regs.
240	*
241	* This function will be called if the particular architecture must
242	* disable hardware debugging while it is processing gdb packets or
243	* handling exception.
244	*/
245	void __weak kgdb_disable_hw_debug(struct pt_regs *regs)
246	{
247	}
248
249	/*
250	* GDB remote protocol parser:
251	*/
252
253	static int hex(char ch)
254	{
255	if ((ch >= 'a') && (ch <= 'f'))
256	return ch - 'a' + 10;
257	if ((ch >= '0') && (ch <= '9'))
258	return ch - '0';
259	if ((ch >= 'A') && (ch <= 'F'))
260	return ch - 'A' + 10;
261	return -1;
262	}
263
264	/* scan for the sequence $<data>#<checksum> */
265	static void get_packet(char *buffer)
266	{
267	unsigned char checksum;
268	unsigned char xmitcsum;
269	int count;
270	char ch;
271
272	do {
273	/*
274	* Spin and wait around for the start character, ignore all
275	* other characters:
276	*/
277	while ((ch = (kgdb_io_ops->read_char())) != '$')
278	/* nothing */;
279
280	kgdb_connected = 1;
281	checksum = 0;
282	xmitcsum = -1;
283
284	count = 0;
285
286	/*
287	* now, read until a # or end of buffer is found:
288	*/
289	while (count < (BUFMAX - 1)) {
290	ch = kgdb_io_ops->read_char();
291	if (ch == '#')
292	break;
293	checksum = checksum + ch;
294	buffer[count] = ch;
295	count = count + 1;
296	}
297	buffer[count] = 0;
298
299	if (ch == '#') {
300	xmitcsum = hex(kgdb_io_ops->read_char()) << 4;
301	xmitcsum += hex(kgdb_io_ops->read_char());
302
303	if (checksum != xmitcsum)
304	/* failed checksum */
305	kgdb_io_ops->write_char('-');
306	else
307	/* successful transfer */
308	kgdb_io_ops->write_char('+');
309	if (kgdb_io_ops->flush)
310	kgdb_io_ops->flush();
311	}
312	} while (checksum != xmitcsum);
313	}
314
315	/*
316	* Send the packet in buffer.
317	* Check for gdb connection if asked for.
318	*/
319	static void put_packet(char *buffer)
320	{
321	unsigned char checksum;
322	int count;
323	char ch;
324
325	/*
326	* $<packet info>#<checksum>.
327	*/
328	while (1) {
329	kgdb_io_ops->write_char('$');
330	checksum = 0;
331	count = 0;
332
333	while ((ch = buffer[count])) {
334	kgdb_io_ops->write_char(ch);
335	checksum += ch;
336	count++;
337	}
338
339	kgdb_io_ops->write_char('#');
340	kgdb_io_ops->write_char(hex_asc_hi(checksum));
341	kgdb_io_ops->write_char(hex_asc_lo(checksum));
342	if (kgdb_io_ops->flush)
343	kgdb_io_ops->flush();
344
345	/* Now see what we get in reply. */
346	ch = kgdb_io_ops->read_char();
347
348	if (ch == 3)
349	ch = kgdb_io_ops->read_char();
350
351	/* If we get an ACK, we are done. */
352	if (ch == '+')
353	return;
354
355	/*
356	* If we get the start of another packet, this means
357	* that GDB is attempting to reconnect. We will NAK
358	* the packet being sent, and stop trying to send this
359	* packet.
360	*/
361	if (ch == '$') {
362	kgdb_io_ops->write_char('-');
363	if (kgdb_io_ops->flush)
364	kgdb_io_ops->flush();
365	return;
366	}
367	}
368	}
369
370	/*
371	* Convert the memory pointed to by mem into hex, placing result in buf.
372	* Return a pointer to the last char put in buf (null). May return an error.
373	*/
374	int kgdb_mem2hex(char mem, char buf, int count)
375	{
376	char *tmp;
377	int err;
378
379	/*
380	* We use the upper half of buf as an intermediate buffer for the
381	* raw memory copy. Hex conversion will work against this one.
382	*/
383	tmp = buf + count;
384
385	err = probe_kernel_read(tmp, mem, count);
386	if (!err) {
387	while (count > 0) {
388	buf = pack_hex_byte(buf, *tmp);
389	tmp++;
390	count--;
391	}
392
393	*buf = 0;
394	}
395
396	return err;
397	}
398
399	/*
400	* Copy the binary array pointed to by buf into mem. Fix $, #, and
401	* 0x7d escaped with 0x7d. Return -EFAULT on failure or 0 on success.
402	* The input buf is overwitten with the result to write to mem.
403	*/
404	static int kgdb_ebin2mem(char buf, char mem, int count)
405	{
406	int size = 0;
407	char *c = buf;
408
409	while (count-- > 0) {
410	c[size] = *buf++;
411	if (c[size] == 0x7d)
412	c[size] = *buf++ ^ 0x20;
413	size++;
414	}
415
416	return probe_kernel_write(mem, c, size);
417	}
418
419	/*
420	* Convert the hex array pointed to by buf into binary to be placed in mem.
421	* Return a pointer to the character AFTER the last byte written.
422	* May return an error.
423	*/
424	int kgdb_hex2mem(char buf, char mem, int count)
425	{
426	char *tmp_raw;
427	char *tmp_hex;
428
429	/*
430	* We use the upper half of buf as an intermediate buffer for the
431	* raw memory that is converted from hex.
432	*/
433	tmp_raw = buf + count * 2;
434
435	tmp_hex = tmp_raw - 1;
436	while (tmp_hex >= buf) {
437	tmp_raw--;
438	tmp_raw = hex(tmp_hex--);
439	tmp_raw \|= hex(tmp_hex--) << 4;
440	}
441
442	return probe_kernel_write(mem, tmp_raw, count);
443	}
444
445	/*
446	* While we find nice hex chars, build a long_val.
447	* Return number of chars processed.
448	*/
449	int kgdb_hex2long(char *ptr, unsigned long long_val)
450	{
451	int hex_val;
452	int num = 0;
453	int negate = 0;
454
455	*long_val = 0;
456
457	if (**ptr == '-') {
458	negate = 1;
459	(*ptr)++;
460	}
461	while (**ptr) {
462	hex_val = hex(**ptr);
463	if (hex_val < 0)
464	break;
465
466	long_val = (long_val << 4) \| hex_val;
467	num++;
468	(*ptr)++;
469	}
470
471	if (negate)
472	long_val = -long_val;
473
474	return num;
475	}
476
477	/* Write memory due to an 'M' or 'X' packet. */
478	static int write_mem_msg(int binary)
479	{
480	char *ptr = &remcom_in_buffer[1];
481	unsigned long addr;
482	unsigned long length;
483	int err;
484
485	if (kgdb_hex2long(&ptr, &addr) > 0 && *(ptr++) == ',' &&
486	kgdb_hex2long(&ptr, &length) > 0 && *(ptr++) == ':') {
487	if (binary)
488	err = kgdb_ebin2mem(ptr, (char *)addr, length);
489	else
490	err = kgdb_hex2mem(ptr, (char *)addr, length);
491	if (err)
492	return err;
493	if (CACHE_FLUSH_IS_SAFE)
494	flush_icache_range(addr, addr + length);
495	return 0;
496	}
497
498	return -EINVAL;
499	}
500
501	static void error_packet(char *pkt, int error)
502	{
503	error = -error;
504	pkt[0] = 'E';
505	pkt[1] = hex_asc[(error / 10)];
506	pkt[2] = hex_asc[(error % 10)];
507	pkt[3] = '\0';
508	}
509
510	/*
511	* Thread ID accessors. We represent a flat TID space to GDB, where
512	* the per CPU idle threads (which under Linux all have PID 0) are
513	* remapped to negative TIDs.
514	*/
515
516	#define BUF_THREAD_ID_SIZE 16
517
518	static char pack_threadid(char pkt, unsigned char *id)
519	{
520	char *limit;
521
522	limit = pkt + BUF_THREAD_ID_SIZE;
523	while (pkt < limit)
524	pkt = pack_hex_byte(pkt, *id++);
525
526	return pkt;
527	}
528
529	static void int_to_threadref(unsigned char *id, int value)
530	{
531	unsigned char *scan;
532	int i = 4;
533
534	scan = (unsigned char *)id;
535	while (i--)
536	*scan++ = 0;
537	put_unaligned_be32(value, scan);
538	}
539
540	static struct task_struct getthread(struct pt_regs regs, int tid)
541	{
542	/*
543	* Non-positive TIDs are remapped to the cpu shadow information
544	*/
545	if (tid == 0 \|\| tid == -1)
546	tid = -atomic_read(&kgdb_active) - 2;
547	if (tid < -1 && tid > -NR_CPUS - 2) {
548	if (kgdb_info[-tid - 2].task)
549	return kgdb_info[-tid - 2].task;
550	else
551	return idle_task(-tid - 2);
552	}
553	if (tid <= 0) {
554	printk(KERN_ERR "KGDB: Internal thread select error\n");
555	dump_stack();
556	return NULL;
557	}
558
559	/*
560	* find_task_by_pid_ns() does not take the tasklist lock anymore
561	* but is nicely RCU locked - hence is a pretty resilient
562	* thing to use:
563	*/
564	return find_task_by_pid_ns(tid, &init_pid_ns);
565	}
566
567	/*
568	* Some architectures need cache flushes when we set/clear a
569	* breakpoint:
570	*/
571	static void kgdb_flush_swbreak_addr(unsigned long addr)
572	{
573	if (!CACHE_FLUSH_IS_SAFE)
574	return;
575
576	if (current->mm && current->mm->mmap_cache) {
577	flush_cache_range(current->mm->mmap_cache,
578	addr, addr + BREAK_INSTR_SIZE);
579	}
580	/* Force flush instruction cache if it was outside the mm */
581	flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
582	}
583
584	/*
585	* SW breakpoint management:
586	*/
587	static int kgdb_activate_sw_breakpoints(void)
588	{
589	unsigned long addr;
590	int error;
591	int ret = 0;
592	int i;
593
594	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
595	if (kgdb_break[i].state != BP_SET)
596	continue;
597
598	addr = kgdb_break[i].bpt_addr;
599	error = kgdb_arch_set_breakpoint(addr,
600	kgdb_break[i].saved_instr);
601	if (error) {
602	ret = error;
603	printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
604	continue;
605	}
606
607	kgdb_flush_swbreak_addr(addr);
608	kgdb_break[i].state = BP_ACTIVE;
609	}
610	return ret;
611	}
612
613	static int kgdb_set_sw_break(unsigned long addr)
614	{
615	int err = kgdb_validate_break_address(addr);
616	int breakno = -1;
617	int i;
618
619	if (err)
620	return err;
621
622	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
623	if ((kgdb_break[i].state == BP_SET) &&
624	(kgdb_break[i].bpt_addr == addr))
625	return -EEXIST;
626	}
627	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
628	if (kgdb_break[i].state == BP_REMOVED &&
629	kgdb_break[i].bpt_addr == addr) {
630	breakno = i;
631	break;
632	}
633	}
634
635	if (breakno == -1) {
636	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
637	if (kgdb_break[i].state == BP_UNDEFINED) {
638	breakno = i;
639	break;
640	}
641	}
642	}
643
644	if (breakno == -1)
645	return -E2BIG;
646
647	kgdb_break[breakno].state = BP_SET;
648	kgdb_break[breakno].type = BP_BREAKPOINT;
649	kgdb_break[breakno].bpt_addr = addr;
650
651	return 0;
652	}
653
654	static int kgdb_deactivate_sw_breakpoints(void)
655	{
656	unsigned long addr;
657	int error;
658	int ret = 0;
659	int i;
660
661	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
662	if (kgdb_break[i].state != BP_ACTIVE)
663	continue;
664	addr = kgdb_break[i].bpt_addr;
665	error = kgdb_arch_remove_breakpoint(addr,
666	kgdb_break[i].saved_instr);
667	if (error) {
668	printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
669	ret = error;
670	}
671
672	kgdb_flush_swbreak_addr(addr);
673	kgdb_break[i].state = BP_SET;
674	}
675	return ret;
676	}
677
678	static int kgdb_remove_sw_break(unsigned long addr)
679	{
680	int i;
681
682	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
683	if ((kgdb_break[i].state == BP_SET) &&
684	(kgdb_break[i].bpt_addr == addr)) {
685	kgdb_break[i].state = BP_REMOVED;
686	return 0;
687	}
688	}
689	return -ENOENT;
690	}
691
692	int kgdb_isremovedbreak(unsigned long addr)
693	{
694	int i;
695
696	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
697	if ((kgdb_break[i].state == BP_REMOVED) &&
698	(kgdb_break[i].bpt_addr == addr))
699	return 1;
700	}
701	return 0;
702	}
703
704	static int remove_all_break(void)
705	{
706	unsigned long addr;
707	int error;
708	int i;
709
710	/* Clear memory breakpoints. */
711	for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
712	if (kgdb_break[i].state != BP_ACTIVE)
713	goto setundefined;
714	addr = kgdb_break[i].bpt_addr;
715	error = kgdb_arch_remove_breakpoint(addr,
716	kgdb_break[i].saved_instr);
717	if (error)
718	printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
719	addr);
720	setundefined:
721	kgdb_break[i].state = BP_UNDEFINED;
722	}
723
724	/* Clear hardware breakpoints. */
725	if (arch_kgdb_ops.remove_all_hw_break)
726	arch_kgdb_ops.remove_all_hw_break();
727
728	return 0;
729	}
730
731	/*
732	* Remap normal tasks to their real PID,
733	* CPU shadow threads are mapped to -CPU - 2
734	*/
735	static inline int shadow_pid(int realpid)
736	{
737	if (realpid)
738	return realpid;
739
740	return -raw_smp_processor_id() - 2;
741	}
742
743	static char gdbmsgbuf[BUFMAX + 1];
744
745	static void kgdb_msg_write(const char *s, int len)
746	{
747	char *bufptr;
748	int wcount;
749	int i;
750
751	/* 'O'utput */
752	gdbmsgbuf[0] = 'O';
753
754	/* Fill and send buffers... */
755	while (len > 0) {
756	bufptr = gdbmsgbuf + 1;
757
758	/* Calculate how many this time */
759	if ((len << 1) > (BUFMAX - 2))
760	wcount = (BUFMAX - 2) >> 1;
761	else
762	wcount = len;
763
764	/* Pack in hex chars */
765	for (i = 0; i < wcount; i++)
766	bufptr = pack_hex_byte(bufptr, s[i]);
767	*bufptr = '\0';
768
769	/* Move up */
770	s += wcount;
771	len -= wcount;
772
773	/* Write packet */
774	put_packet(gdbmsgbuf);
775	}
776	}
777
778	/*
779	* Return true if there is a valid kgdb I/O module. Also if no
780	* debugger is attached a message can be printed to the console about
781	* waiting for the debugger to attach.
782	*
783	* The print_wait argument is only to be true when called from inside
784	* the core kgdb_handle_exception, because it will wait for the
785	* debugger to attach.
786	*/
787	static int kgdb_io_ready(int print_wait)
788	{
789	if (!kgdb_io_ops)
790	return 0;
791	if (kgdb_connected)
792	return 1;
793	if (atomic_read(&kgdb_setting_breakpoint))
794	return 1;
795	if (print_wait)
796	printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
797	return 1;
798	}
799
800	/*
801	* All the functions that start with gdb_cmd are the various
802	* operations to implement the handlers for the gdbserial protocol
803	* where KGDB is communicating with an external debugger
804	*/
805
806	/* Handle the '?' status packets */
807	static void gdb_cmd_status(struct kgdb_state *ks)
808	{
809	/*
810	* We know that this packet is only sent
811	* during initial connect. So to be safe,
812	* we clear out our breakpoints now in case
813	* GDB is reconnecting.
814	*/
815	remove_all_break();
816
817	remcom_out_buffer[0] = 'S';
818	pack_hex_byte(&remcom_out_buffer[1], ks->signo);
819	}
820
821	/* Handle the 'g' get registers request */
822	static void gdb_cmd_getregs(struct kgdb_state *ks)
823	{
824	struct task_struct *thread;
825	void *local_debuggerinfo;
826	int i;
827
828	thread = kgdb_usethread;
829	if (!thread) {
830	thread = kgdb_info[ks->cpu].task;
831	local_debuggerinfo = kgdb_info[ks->cpu].debuggerinfo;
832	} else {
833	local_debuggerinfo = NULL;
834	for_each_online_cpu(i) {
835	/*
836	* Try to find the task on some other
837	* or possibly this node if we do not
838	* find the matching task then we try
839	* to approximate the results.
840	*/
841	if (thread == kgdb_info[i].task)
842	local_debuggerinfo = kgdb_info[i].debuggerinfo;
843	}
844	}
845
846	/*
847	* All threads that don't have debuggerinfo should be
848	* in schedule() sleeping, since all other CPUs
849	* are in kgdb_wait, and thus have debuggerinfo.
850	*/
851	if (local_debuggerinfo) {
852	pt_regs_to_gdb_regs(gdb_regs, local_debuggerinfo);
853	} else {
854	/*
855	* Pull stuff saved during switch_to; nothing
856	* else is accessible (or even particularly
857	* relevant).
858	*
859	* This should be enough for a stack trace.
860	*/
861	sleeping_thread_to_gdb_regs(gdb_regs, thread);
862	}
863	kgdb_mem2hex((char *)gdb_regs, remcom_out_buffer, NUMREGBYTES);
864	}
865
866	/* Handle the 'G' set registers request */
867	static void gdb_cmd_setregs(struct kgdb_state *ks)
868	{
869	kgdb_hex2mem(&remcom_in_buffer[1], (char *)gdb_regs, NUMREGBYTES);
870
871	if (kgdb_usethread && kgdb_usethread != current) {
872	error_packet(remcom_out_buffer, -EINVAL);
873	} else {
874	gdb_regs_to_pt_regs(gdb_regs, ks->linux_regs);
875	strcpy(remcom_out_buffer, "OK");
876	}
877	}
878
879	/* Handle the 'm' memory read bytes */
880	static void gdb_cmd_memread(struct kgdb_state *ks)
881	{
882	char *ptr = &remcom_in_buffer[1];
883	unsigned long length;
884	unsigned long addr;
885	int err;
886
887	if (kgdb_hex2long(&ptr, &addr) > 0 && *ptr++ == ',' &&
888	kgdb_hex2long(&ptr, &length) > 0) {
889	err = kgdb_mem2hex((char *)addr, remcom_out_buffer, length);
890	if (err)
891	error_packet(remcom_out_buffer, err);
892	} else {
893	error_packet(remcom_out_buffer, -EINVAL);
894	}
895	}
896
897	/* Handle the 'M' memory write bytes */
898	static void gdb_cmd_memwrite(struct kgdb_state *ks)
899	{
900	int err = write_mem_msg(0);
901
902	if (err)
903	error_packet(remcom_out_buffer, err);
904	else
905	strcpy(remcom_out_buffer, "OK");
906	}
907
908	/* Handle the 'X' memory binary write bytes */
909	static void gdb_cmd_binwrite(struct kgdb_state *ks)
910	{
911	int err = write_mem_msg(1);
912
913	if (err)
914	error_packet(remcom_out_buffer, err);
915	else
916	strcpy(remcom_out_buffer, "OK");
917	}
918
919	/* Handle the 'D' or 'k', detach or kill packets */
920	static void gdb_cmd_detachkill(struct kgdb_state *ks)
921	{
922	int error;
923
924	/* The detach case */
925	if (remcom_in_buffer[0] == 'D') {
926	error = remove_all_break();
927	if (error < 0) {
928	error_packet(remcom_out_buffer, error);
929	} else {
930	strcpy(remcom_out_buffer, "OK");
931	kgdb_connected = 0;
932	}
933	put_packet(remcom_out_buffer);
934	} else {
935	/*
936	* Assume the kill case, with no exit code checking,
937	* trying to force detach the debugger:
938	*/
939	remove_all_break();
940	kgdb_connected = 0;
941	}
942	}
943
944	/* Handle the 'R' reboot packets */
945	static int gdb_cmd_reboot(struct kgdb_state *ks)
946	{
947	/* For now, only honor R0 */
948	if (strcmp(remcom_in_buffer, "R0") == 0) {
949	printk(KERN_CRIT "Executing emergency reboot\n");
950	strcpy(remcom_out_buffer, "OK");
951	put_packet(remcom_out_buffer);
952
953	/*
954	* Execution should not return from
955	* machine_emergency_restart()
956	*/
957	machine_emergency_restart();
958	kgdb_connected = 0;
959
960	return 1;
961	}
962	return 0;
963	}
964
965	/* Handle the 'q' query packets */
966	static void gdb_cmd_query(struct kgdb_state *ks)
967	{
968	struct task_struct *g;
969	struct task_struct *p;
970	unsigned char thref[8];
971	char *ptr;
972	int i;
973	int cpu;
974	int finished = 0;
975
976	switch (remcom_in_buffer[1]) {
977	case 's':
978	case 'f':
979	if (memcmp(remcom_in_buffer + 2, "ThreadInfo", 10)) {
980	error_packet(remcom_out_buffer, -EINVAL);
981	break;
982	}
983
984	i = 0;
985	remcom_out_buffer[0] = 'm';
986	ptr = remcom_out_buffer + 1;
987	if (remcom_in_buffer[1] == 'f') {
988	/* Each cpu is a shadow thread */
989	for_each_online_cpu(cpu) {
990	ks->thr_query = 0;
991	int_to_threadref(thref, -cpu - 2);
992	pack_threadid(ptr, thref);
993	ptr += BUF_THREAD_ID_SIZE;
994	*(ptr++) = ',';
995	i++;
996	}
997	}
998
999	do_each_thread(g, p) {
1000	if (i >= ks->thr_query && !finished) {
1001	int_to_threadref(thref, p->pid);
1002	pack_threadid(ptr, thref);
1003	ptr += BUF_THREAD_ID_SIZE;
1004	*(ptr++) = ',';
1005	ks->thr_query++;
1006	if (ks->thr_query % KGDB_MAX_THREAD_QUERY == 0)
1007	finished = 1;
1008	}
1009	i++;
1010	} while_each_thread(g, p);
1011
1012	*(--ptr) = '\0';
1013	break;
1014
1015	case 'C':
1016	/* Current thread id */
1017	strcpy(remcom_out_buffer, "QC");
1018	ks->threadid = shadow_pid(current->pid);
1019	int_to_threadref(thref, ks->threadid);
1020	pack_threadid(remcom_out_buffer + 2, thref);
1021	break;
1022	case 'T':
1023	if (memcmp(remcom_in_buffer + 1, "ThreadExtraInfo,", 16)) {
1024	error_packet(remcom_out_buffer, -EINVAL);
1025	break;
1026	}
1027	ks->threadid = 0;
1028	ptr = remcom_in_buffer + 17;
1029	kgdb_hex2long(&ptr, &ks->threadid);
1030	if (!getthread(ks->linux_regs, ks->threadid)) {
1031	error_packet(remcom_out_buffer, -EINVAL);
1032	break;
1033	}
1034	if ((int)ks->threadid > 0) {
1035	kgdb_mem2hex(getthread(ks->linux_regs,
1036	ks->threadid)->comm,
1037	remcom_out_buffer, 16);
1038	} else {
1039	static char tmpstr[23 + BUF_THREAD_ID_SIZE];
1040
1041	sprintf(tmpstr, "shadowCPU%d",
1042	(int)(-ks->threadid - 2));
1043	kgdb_mem2hex(tmpstr, remcom_out_buffer, strlen(tmpstr));
1044	}
1045	break;
1046	}
1047	}
1048
1049	/* Handle the 'H' task query packets */
1050	static void gdb_cmd_task(struct kgdb_state *ks)
1051	{
1052	struct task_struct *thread;
1053	char *ptr;
1054
1055	switch (remcom_in_buffer[1]) {
1056	case 'g':
1057	ptr = &remcom_in_buffer[2];
1058	kgdb_hex2long(&ptr, &ks->threadid);
1059	thread = getthread(ks->linux_regs, ks->threadid);
1060	if (!thread && ks->threadid > 0) {
1061	error_packet(remcom_out_buffer, -EINVAL);
1062	break;
1063	}
1064	kgdb_usethread = thread;
1065	ks->kgdb_usethreadid = ks->threadid;
1066	strcpy(remcom_out_buffer, "OK");
1067	break;
1068	case 'c':
1069	ptr = &remcom_in_buffer[2];
1070	kgdb_hex2long(&ptr, &ks->threadid);
1071	if (!ks->threadid) {
1072	kgdb_contthread = NULL;
1073	} else {
1074	thread = getthread(ks->linux_regs, ks->threadid);
1075	if (!thread && ks->threadid > 0) {
1076	error_packet(remcom_out_buffer, -EINVAL);
1077	break;
1078	}
1079	kgdb_contthread = thread;
1080	}
1081	strcpy(remcom_out_buffer, "OK");
1082	break;
1083	}
1084	}
1085
1086	/* Handle the 'T' thread query packets */
1087	static void gdb_cmd_thread(struct kgdb_state *ks)
1088	{
1089	char *ptr = &remcom_in_buffer[1];
1090	struct task_struct *thread;
1091
1092	kgdb_hex2long(&ptr, &ks->threadid);
1093	thread = getthread(ks->linux_regs, ks->threadid);
1094	if (thread)
1095	strcpy(remcom_out_buffer, "OK");
1096	else
1097	error_packet(remcom_out_buffer, -EINVAL);
1098	}
1099
1100	/* Handle the 'z' or 'Z' breakpoint remove or set packets */
1101	static void gdb_cmd_break(struct kgdb_state *ks)
1102	{
1103	/*
1104	* Since GDB-5.3, it's been drafted that '0' is a software
1105	* breakpoint, '1' is a hardware breakpoint, so let's do that.
1106	*/
1107	char *bpt_type = &remcom_in_buffer[1];
1108	char *ptr = &remcom_in_buffer[2];
1109	unsigned long addr;
1110	unsigned long length;
1111	int error = 0;
1112
1113	if (arch_kgdb_ops.set_hw_breakpoint && *bpt_type >= '1') {
1114	/* Unsupported */
1115	if (*bpt_type > '4')
1116	return;
1117	} else {
1118	if (bpt_type != '0' && bpt_type != '1')
1119	/* Unsupported. */
1120	return;
1121	}
1122
1123	/*
1124	* Test if this is a hardware breakpoint, and
1125	* if we support it:
1126	*/
1127	if (*bpt_type == '1' && !(arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT))
1128	/* Unsupported. */
1129	return;
1130
1131	if (*(ptr++) != ',') {
1132	error_packet(remcom_out_buffer, -EINVAL);
1133	return;
1134	}
1135	if (!kgdb_hex2long(&ptr, &addr)) {
1136	error_packet(remcom_out_buffer, -EINVAL);
1137	return;
1138	}
1139	if (*(ptr++) != ',' \|\|
1140	!kgdb_hex2long(&ptr, &length)) {
1141	error_packet(remcom_out_buffer, -EINVAL);
1142	return;
1143	}
1144
1145	if (remcom_in_buffer[0] == 'Z' && *bpt_type == '0')
1146	error = kgdb_set_sw_break(addr);
1147	else if (remcom_in_buffer[0] == 'z' && *bpt_type == '0')
1148	error = kgdb_remove_sw_break(addr);
1149	else if (remcom_in_buffer[0] == 'Z')
1150	error = arch_kgdb_ops.set_hw_breakpoint(addr,
1151	(int)length, *bpt_type - '0');
1152	else if (remcom_in_buffer[0] == 'z')
1153	error = arch_kgdb_ops.remove_hw_breakpoint(addr,
1154	(int) length, *bpt_type - '0');
1155
1156	if (error == 0)
1157	strcpy(remcom_out_buffer, "OK");
1158	else
1159	error_packet(remcom_out_buffer, error);
1160	}
1161
1162	/* Handle the 'C' signal / exception passing packets */
1163	static int gdb_cmd_exception_pass(struct kgdb_state *ks)
1164	{
1165	/* C09 == pass exception
1166	* C15 == detach kgdb, pass exception
1167	*/
1168	if (remcom_in_buffer[1] == '0' && remcom_in_buffer[2] == '9') {
1169
1170	ks->pass_exception = 1;
1171	remcom_in_buffer[0] = 'c';
1172
1173	} else if (remcom_in_buffer[1] == '1' && remcom_in_buffer[2] == '5') {
1174
1175	ks->pass_exception = 1;
1176	remcom_in_buffer[0] = 'D';
1177	remove_all_break();
1178	kgdb_connected = 0;
1179	return 1;
1180
1181	} else {
1182	kgdb_msg_write("KGDB only knows signal 9 (pass)"
1183	" and 15 (pass and disconnect)\n"
1184	"Executing a continue without signal passing\n", 0);
1185	remcom_in_buffer[0] = 'c';
1186	}
1187
1188	/* Indicate fall through */
1189	return -1;
1190	}
1191
1192	/*
1193	* This function performs all gdbserial command procesing
1194	*/
1195	static int gdb_serial_stub(struct kgdb_state *ks)
1196	{
1197	int error = 0;
1198	int tmp;
1199
1200	/* Clear the out buffer. */
1201	memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
1202
1203	if (kgdb_connected) {
1204	unsigned char thref[8];
1205	char *ptr;
1206
1207	/* Reply to host that an exception has occurred */
1208	ptr = remcom_out_buffer;
1209	*ptr++ = 'T';
1210	ptr = pack_hex_byte(ptr, ks->signo);
1211	ptr += strlen(strcpy(ptr, "thread:"));
1212	int_to_threadref(thref, shadow_pid(current->pid));
1213	ptr = pack_threadid(ptr, thref);
1214	*ptr++ = ';';
1215	put_packet(remcom_out_buffer);
1216	}
1217
1218	kgdb_usethread = kgdb_info[ks->cpu].task;
1219	ks->kgdb_usethreadid = shadow_pid(kgdb_info[ks->cpu].task->pid);
1220	ks->pass_exception = 0;
1221
1222	while (1) {
1223	error = 0;
1224
1225	/* Clear the out buffer. */
1226	memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
1227
1228	get_packet(remcom_in_buffer);
1229
1230	switch (remcom_in_buffer[0]) {
1231	case '?': /* gdbserial status */
1232	gdb_cmd_status(ks);
1233	break;
1234	case 'g': /* return the value of the CPU registers */
1235	gdb_cmd_getregs(ks);
1236	break;
1237	case 'G': /* set the value of the CPU registers - return OK */
1238	gdb_cmd_setregs(ks);
1239	break;
1240	case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
1241	gdb_cmd_memread(ks);
1242	break;
1243	case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA..AA */
1244	gdb_cmd_memwrite(ks);
1245	break;
1246	case 'X': /* XAA..AA,LLLL: Write LLLL bytes at address AA..AA */
1247	gdb_cmd_binwrite(ks);
1248	break;
1249	/* kill or detach. KGDB should treat this like a
1250	* continue.
1251	*/
1252	case 'D': /* Debugger detach */
1253	case 'k': /* Debugger detach via kill */
1254	gdb_cmd_detachkill(ks);
1255	goto default_handle;
1256	case 'R': /* Reboot */
1257	if (gdb_cmd_reboot(ks))
1258	goto default_handle;
1259	break;
1260	case 'q': /* query command */
1261	gdb_cmd_query(ks);
1262	break;
1263	case 'H': /* task related */
1264	gdb_cmd_task(ks);
1265	break;
1266	case 'T': /* Query thread status */
1267	gdb_cmd_thread(ks);
1268	break;
1269	case 'z': /* Break point remove */
1270	case 'Z': /* Break point set */
1271	gdb_cmd_break(ks);
1272	break;
1273	case 'C': /* Exception passing */
1274	tmp = gdb_cmd_exception_pass(ks);
1275	if (tmp > 0)
1276	goto default_handle;
1277	if (tmp == 0)
1278	break;
1279	/* Fall through on tmp < 0 */
1280	case 'c': /* Continue packet */
1281	case 's': /* Single step packet */
1282	if (kgdb_contthread && kgdb_contthread != current) {
1283	/* Can't switch threads in kgdb */
1284	error_packet(remcom_out_buffer, -EINVAL);
1285	break;
1286	}
1287	kgdb_activate_sw_breakpoints();
1288	/* Fall through to default processing */
1289	default:
1290	default_handle:
1291	error = kgdb_arch_handle_exception(ks->ex_vector,
1292	ks->signo,
1293	ks->err_code,
1294	remcom_in_buffer,
1295	remcom_out_buffer,
1296	ks->linux_regs);
1297	/*
1298	* Leave cmd processing on error, detach,
1299	* kill, continue, or single step.
1300	*/
1301	if (error >= 0 \|\| remcom_in_buffer[0] == 'D' \|\|
1302	remcom_in_buffer[0] == 'k') {
1303	error = 0;
1304	goto kgdb_exit;
1305	}
1306
1307	}
1308
1309	/* reply to the request */
1310	put_packet(remcom_out_buffer);
1311	}
1312
1313	kgdb_exit:
1314	if (ks->pass_exception)
1315	error = 1;
1316	return error;
1317	}
1318
1319	static int kgdb_reenter_check(struct kgdb_state *ks)
1320	{
1321	unsigned long addr;
1322
1323	if (atomic_read(&kgdb_active) != raw_smp_processor_id())
1324	return 0;
1325
1326	/* Panic on recursive debugger calls: */
1327	exception_level++;
1328	addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
1329	kgdb_deactivate_sw_breakpoints();
1330
1331	/*
1332	* If the break point removed ok at the place exception
1333	* occurred, try to recover and print a warning to the end
1334	* user because the user planted a breakpoint in a place that
1335	* KGDB needs in order to function.
1336	*/
1337	if (kgdb_remove_sw_break(addr) == 0) {
1338	exception_level = 0;
1339	kgdb_skipexception(ks->ex_vector, ks->linux_regs);
1340	kgdb_activate_sw_breakpoints();
1341	printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
1342	addr);
1343	WARN_ON_ONCE(1);
1344
1345	return 1;
1346	}
1347	remove_all_break();
1348	kgdb_skipexception(ks->ex_vector, ks->linux_regs);
1349
1350	if (exception_level > 1) {
1351	dump_stack();
1352	panic("Recursive entry to debugger");
1353	}
1354
1355	printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
1356	dump_stack();
1357	panic("Recursive entry to debugger");
1358
1359	return 1;
1360	}
1361
1362	static int kgdb_cpu_enter(struct kgdb_state ks, struct pt_regs regs)
1363	{
1364	unsigned long flags;
1365	int sstep_tries = 100;
1366	int error = 0;
1367	int i, cpu;
1368	int trace_on = 0;
1369	acquirelock:
1370	/*
1371	* Interrupts will be restored by the 'trap return' code, except when
1372	* single stepping.
1373	*/
1374	local_irq_save(flags);
1375
1376	cpu = ks->cpu;
1377	kgdb_info[cpu].debuggerinfo = regs;
1378	kgdb_info[cpu].task = current;
1379	/*
1380	* Make sure the above info reaches the primary CPU before
1381	* our cpu_in_kgdb[] flag setting does:
1382	*/
1383	atomic_inc(&cpu_in_kgdb[cpu]);
1384
1385	/*
1386	* CPU will loop if it is a slave or request to become a kgdb
1387	* master cpu and acquire the kgdb_active lock:
1388	*/
1389	while (1) {
1390	if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
1391	if (atomic_cmpxchg(&kgdb_active, -1, cpu) == cpu)
1392	break;
1393	} else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
1394	if (!atomic_read(&passive_cpu_wait[cpu]))
1395	goto return_normal;
1396	} else {
1397	return_normal:
1398	/* Return to normal operation by executing any
1399	* hw breakpoint fixup.
1400	*/
1401	if (arch_kgdb_ops.correct_hw_break)
1402	arch_kgdb_ops.correct_hw_break();
1403	if (trace_on)
1404	tracing_on();
1405	atomic_dec(&cpu_in_kgdb[cpu]);
1406	touch_softlockup_watchdog_sync();
1407	clocksource_touch_watchdog();
1408	local_irq_restore(flags);
1409	return 0;
1410	}
1411	cpu_relax();
1412	}
1413
1414	/*
1415	* For single stepping, try to only enter on the processor
1416	* that was single stepping. To gaurd against a deadlock, the
1417	* kernel will only try for the value of sstep_tries before
1418	* giving up and continuing on.
1419	*/
1420	if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
1421	(kgdb_info[cpu].task &&
1422	kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
1423	atomic_set(&kgdb_active, -1);
1424	touch_softlockup_watchdog_sync();
1425	clocksource_touch_watchdog();
1426	local_irq_restore(flags);
1427
1428	goto acquirelock;
1429	}
1430
1431	if (!kgdb_io_ready(1)) {
1432	error = 1;
1433	goto kgdb_restore; /* No I/O connection, so resume the system */
1434	}
1435
1436	/*
1437	* Don't enter if we have hit a removed breakpoint.
1438	*/
1439	if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
1440	goto kgdb_restore;
1441
1442	/* Call the I/O driver's pre_exception routine */
1443	if (kgdb_io_ops->pre_exception)
1444	kgdb_io_ops->pre_exception();
1445
1446	kgdb_disable_hw_debug(ks->linux_regs);
1447
1448	/*
1449	* Get the passive CPU lock which will hold all the non-primary
1450	* CPU in a spin state while the debugger is active
1451	*/
1452	if (!kgdb_single_step) {
1453	for (i = 0; i < NR_CPUS; i++)
1454	atomic_inc(&passive_cpu_wait[i]);
1455	}
1456
1457	#ifdef CONFIG_SMP
1458	/* Signal the other CPUs to enter kgdb_wait() */
1459	if ((!kgdb_single_step) && kgdb_do_roundup)
1460	kgdb_roundup_cpus(flags);
1461	#endif
1462
1463	/*
1464	* Wait for the other CPUs to be notified and be waiting for us:
1465	*/
1466	for_each_online_cpu(i) {
1467	while (!atomic_read(&cpu_in_kgdb[i]))
1468	cpu_relax();
1469	}
1470
1471	/*
1472	* At this point the primary processor is completely
1473	* in the debugger and all secondary CPUs are quiescent
1474	*/
1475	kgdb_post_primary_code(ks->linux_regs, ks->ex_vector, ks->err_code);
1476	kgdb_deactivate_sw_breakpoints();
1477	kgdb_single_step = 0;
1478	kgdb_contthread = current;
1479	exception_level = 0;
1480	trace_on = tracing_is_on();
1481	if (trace_on)
1482	tracing_off();
1483
1484	/* Talk to debugger with gdbserial protocol */
1485	error = gdb_serial_stub(ks);
1486
1487	/* Call the I/O driver's post_exception routine */
1488	if (kgdb_io_ops->post_exception)
1489	kgdb_io_ops->post_exception();
1490
1491	atomic_dec(&cpu_in_kgdb[ks->cpu]);
1492
1493	if (!kgdb_single_step) {
1494	for (i = NR_CPUS-1; i >= 0; i--)
1495	atomic_dec(&passive_cpu_wait[i]);
1496	/*
1497	* Wait till all the CPUs have quit
1498	* from the debugger.
1499	*/
1500	for_each_online_cpu(i) {
1501	while (atomic_read(&cpu_in_kgdb[i]))
1502	cpu_relax();
1503	}
1504	}
1505
1506	kgdb_restore:
1507	if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
1508	int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
1509	if (kgdb_info[sstep_cpu].task)
1510	kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
1511	else
1512	kgdb_sstep_pid = 0;
1513	}
1514	if (trace_on)
1515	tracing_on();
1516	/* Free kgdb_active */
1517	atomic_set(&kgdb_active, -1);
1518	touch_softlockup_watchdog_sync();
1519	clocksource_touch_watchdog();
1520	local_irq_restore(flags);
1521
1522	return error;
1523	}
1524
1525	/*
1526	* kgdb_handle_exception() - main entry point from a kernel exception
1527	*
1528	* Locking hierarchy:
1529	* interface locks, if any (begin_session)
1530	* kgdb lock (kgdb_active)
1531	*/
1532	int
1533	kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
1534	{
1535	struct kgdb_state kgdb_var;
1536	struct kgdb_state *ks = &kgdb_var;
1537	int ret;
1538
1539	ks->cpu = raw_smp_processor_id();
1540	ks->ex_vector = evector;
1541	ks->signo = signo;
1542	ks->ex_vector = evector;
1543	ks->err_code = ecode;
1544	ks->kgdb_usethreadid = 0;
1545	ks->linux_regs = regs;
1546
1547	if (kgdb_reenter_check(ks))
1548	return 0; /* Ouch, double exception ! */
1549	kgdb_info[ks->cpu].exception_state \|= DCPU_WANT_MASTER;
1550	ret = kgdb_cpu_enter(ks, regs);
1551	kgdb_info[ks->cpu].exception_state &= ~DCPU_WANT_MASTER;
1552	return ret;
1553	}
1554
1555	int kgdb_nmicallback(int cpu, void *regs)
1556	{
1557	#ifdef CONFIG_SMP
1558	struct kgdb_state kgdb_var;
1559	struct kgdb_state *ks = &kgdb_var;
1560
1561	memset(ks, 0, sizeof(struct kgdb_state));
1562	ks->cpu = cpu;
1563	ks->linux_regs = regs;
1564
1565	if (!atomic_read(&cpu_in_kgdb[cpu]) &&
1566	atomic_read(&kgdb_active) != -1 &&
1567	atomic_read(&kgdb_active) != cpu) {
1568	kgdb_info[cpu].exception_state \|= DCPU_IS_SLAVE;
1569	kgdb_cpu_enter(ks, regs);
1570	kgdb_info[cpu].exception_state &= ~DCPU_IS_SLAVE;
1571	return 0;
1572	}
1573	#endif
1574	return 1;
1575	}
1576
1577	static void kgdb_console_write(struct console co, const char s,
1578	unsigned count)
1579	{
1580	unsigned long flags;
1581
1582	/* If we're debugging, or KGDB has not connected, don't try
1583	* and print. */
1584	if (!kgdb_connected \|\| atomic_read(&kgdb_active) != -1)
1585	return;
1586
1587	local_irq_save(flags);
1588	kgdb_msg_write(s, count);
1589	local_irq_restore(flags);
1590	}
1591
1592	static struct console kgdbcons = {
1593	.name = "kgdb",
1594	.write = kgdb_console_write,
1595	.flags = CON_PRINTBUFFER \| CON_ENABLED,
1596	.index = -1,
1597	};
1598
1599	#ifdef CONFIG_MAGIC_SYSRQ
1600	static void sysrq_handle_gdb(int key, struct tty_struct *tty)
1601	{
1602	if (!kgdb_io_ops) {
1603	printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
1604	return;
1605	}
1606	if (!kgdb_connected)
1607	printk(KERN_CRIT "Entering KGDB\n");
1608
1609	kgdb_breakpoint();
1610	}
1611
1612	static struct sysrq_key_op sysrq_gdb_op = {
1613	.handler = sysrq_handle_gdb,
1614	.help_msg = "debug(G)",
1615	.action_msg = "DEBUG",
1616	};
1617	#endif
1618
1619	static void kgdb_register_callbacks(void)
1620	{
1621	if (!kgdb_io_module_registered) {
1622	kgdb_io_module_registered = 1;
1623	kgdb_arch_init();
1624	#ifdef CONFIG_MAGIC_SYSRQ
1625	register_sysrq_key('g', &sysrq_gdb_op);
1626	#endif
1627	if (kgdb_use_con && !kgdb_con_registered) {
1628	register_console(&kgdbcons);
1629	kgdb_con_registered = 1;
1630	}
1631	}
1632	}
1633
1634	static void kgdb_unregister_callbacks(void)
1635	{
1636	/*
1637	* When this routine is called KGDB should unregister from the
1638	* panic handler and clean up, making sure it is not handling any
1639	* break exceptions at the time.
1640	*/
1641	if (kgdb_io_module_registered) {
1642	kgdb_io_module_registered = 0;
1643	kgdb_arch_exit();
1644	#ifdef CONFIG_MAGIC_SYSRQ
1645	unregister_sysrq_key('g', &sysrq_gdb_op);
1646	#endif
1647	if (kgdb_con_registered) {
1648	unregister_console(&kgdbcons);
1649	kgdb_con_registered = 0;
1650	}
1651	}
1652	}
1653
1654	static void kgdb_initial_breakpoint(void)
1655	{
1656	kgdb_break_asap = 0;
1657
1658	printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
1659	kgdb_breakpoint();
1660	}
1661
1662	/**
1663	* kgdb_register_io_module - register KGDB IO module
1664	* @new_kgdb_io_ops: the io ops vector
1665	*
1666	* Register it with the KGDB core.
1667	*/
1668	int kgdb_register_io_module(struct kgdb_io *new_kgdb_io_ops)
1669	{
1670	int err;
1671
1672	spin_lock(&kgdb_registration_lock);
1673
1674	if (kgdb_io_ops) {
1675	spin_unlock(&kgdb_registration_lock);
1676
1677	printk(KERN_ERR "kgdb: Another I/O driver is already "
1678	"registered with KGDB.\n");
1679	return -EBUSY;
1680	}
1681
1682	if (new_kgdb_io_ops->init) {
1683	err = new_kgdb_io_ops->init();
1684	if (err) {
1685	spin_unlock(&kgdb_registration_lock);
1686	return err;
1687	}
1688	}
1689
1690	kgdb_io_ops = new_kgdb_io_ops;
1691
1692	spin_unlock(&kgdb_registration_lock);
1693
1694	printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
1695	new_kgdb_io_ops->name);
1696
1697	/* Arm KGDB now. */
1698	kgdb_register_callbacks();
1699
1700	if (kgdb_break_asap)
1701	kgdb_initial_breakpoint();
1702
1703	return 0;
1704	}
1705	EXPORT_SYMBOL_GPL(kgdb_register_io_module);
1706
1707	/**
1708	* kkgdb_unregister_io_module - unregister KGDB IO module
1709	* @old_kgdb_io_ops: the io ops vector
1710	*
1711	* Unregister it with the KGDB core.
1712	*/
1713	void kgdb_unregister_io_module(struct kgdb_io *old_kgdb_io_ops)
1714	{
1715	BUG_ON(kgdb_connected);
1716
1717	/*
1718	* KGDB is no longer able to communicate out, so
1719	* unregister our callbacks and reset state.
1720	*/
1721	kgdb_unregister_callbacks();
1722
1723	spin_lock(&kgdb_registration_lock);
1724
1725	WARN_ON_ONCE(kgdb_io_ops != old_kgdb_io_ops);
1726	kgdb_io_ops = NULL;
1727
1728	spin_unlock(&kgdb_registration_lock);
1729
1730	printk(KERN_INFO
1731	"kgdb: Unregistered I/O driver %s, debugger disabled.\n",
1732	old_kgdb_io_ops->name);
1733	}
1734	EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
1735
1736	/**
1737	* kgdb_breakpoint - generate breakpoint exception
1738	*
1739	* This function will generate a breakpoint exception. It is used at the
1740	* beginning of a program to sync up with a debugger and can be used
1741	* otherwise as a quick means to stop program execution and "break" into
1742	* the debugger.
1743	*/
1744	void kgdb_breakpoint(void)
1745	{
1746	atomic_inc(&kgdb_setting_breakpoint);
1747	wmb(); /* Sync point before breakpoint */
1748	arch_kgdb_breakpoint();
1749	wmb(); /* Sync point after breakpoint */
1750	atomic_dec(&kgdb_setting_breakpoint);
1751	}
1752	EXPORT_SYMBOL_GPL(kgdb_breakpoint);
1753
1754	static int __init opt_kgdb_wait(char *str)
1755	{
1756	kgdb_break_asap = 1;
1757
1758	if (kgdb_io_module_registered)
1759	kgdb_initial_breakpoint();
1760
1761	return 0;
1762	}
1763
1764	early_param("kgdbwait", opt_kgdb_wait);
1765

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/kernel/kgdb.c

interactive