![[BACK]](/icons/back.gif){kind=icon}
Return to kgdb_stub.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to kgdb_stub.c CVS log | Up to [local] / sys / kern |
1.1 nbrk 1: /* $OpenBSD: kgdb_stub.c,v 1.8 2005/11/17 19:23:01 fgsch Exp $ */
2: /* $NetBSD: kgdb_stub.c,v 1.6 1998/08/30 20:30:57 scottr Exp $ */
3:
4: /*
5: * Copyright (c) 1990, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * This software was developed by the Computer Systems Engineering group
9: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
10: * contributed to Berkeley.
11: *
12: * All advertising materials mentioning features or use of this software
13: * must display the following acknowledgement:
14: * This product includes software developed by the University of
15: * California, Lawrence Berkeley Laboratories.
16: *
17: * Redistribution and use in source and binary forms, with or without
18: * modification, are permitted provided that the following conditions
19: * are met:
20: * 1. Redistributions of source code must retain the above copyright
21: * notice, this list of conditions and the following disclaimer.
22: * 2. Redistributions in binary form must reproduce the above copyright
23: * notice, this list of conditions and the following disclaimer in the
24: * documentation and/or other materials provided with the distribution.
25: * 3. Neither the name of the University nor the names of its contributors
26: * may be used to endorse or promote products derived from this software
27: * without specific prior written permission.
28: *
29: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39: * SUCH DAMAGE.
40: *
41: * @(#)kgdb_stub.c 8.4 (Berkeley) 1/12/94
42: */
43:
44: /*
45: * "Stub" to allow remote cpu to debug over a serial line using gdb.
46: */
47:
48: #include <sys/param.h>
49: #include <sys/systm.h>
50: #include <sys/kgdb.h>
51:
52: /* #define DEBUG_KGDB XXX */
53:
54: /* XXX: Maybe these should be in the MD files? */
55: #ifndef KGDBDEV
56: #define KGDBDEV -1
57: #endif
58: #ifndef KGDBRATE
59: #define KGDBRATE 19200
60: #endif
61:
62: int kgdb_dev = KGDBDEV; /* remote debugging device (-1 if none) */
63: int kgdb_rate = KGDBRATE; /* remote debugging baud rate */
64: int kgdb_active = 0; /* remote debugging active if != 0 */
65: int kgdb_debug_init = 0; /* != 0 waits for remote at system init */
66: int kgdb_debug_panic = 0; /* != 0 waits for remote on panic */
67: label_t *kgdb_recover = 0;
68:
69: static void kgdb_copy(void *, void *, int);
70: /* static void kgdb_zero(void *, int); */
71: static void kgdb_send(u_char *);
72: static int kgdb_recv(u_char *, int);
73: static int digit2i(u_char);
74: static u_char i2digit(int);
75: static void mem2hex(void *, void *, int);
76: static u_char *hex2mem(void *, u_char *, int);
77: static vaddr_t hex2i(u_char **);
78:
79: static int (*kgdb_getc)(void *);
80: static void (*kgdb_putc)(void *, int);
81: static void *kgdb_ioarg;
82:
83: static u_char buffer[KGDB_BUFLEN];
84: static kgdb_reg_t gdb_regs[KGDB_NUMREGS];
85:
86: #define GETC() ((*kgdb_getc)(kgdb_ioarg))
87: #define PUTC(c) ((*kgdb_putc)(kgdb_ioarg, c))
88:
89: /*
90: * This little routine exists simply so that bcopy() can be debugged.
91: */
92: static void
93: kgdb_copy(void *vsrc, void *vdst, int len)
94: {
95: char *src = vsrc;
96: char *dst = vdst;
97:
98: while (--len >= 0)
99: *dst++ = *src++;
100: }
101:
102: #if 0
103: /* ditto for bzero */
104: static void
105: kgdb_zero(void *vptr, int len)
106: {
107: char *ptr = vptr;
108:
109: while (--len >= 0)
110: *ptr++ = (char) 0;
111: }
112: #endif
113:
114: /*
115: * Convert a hex digit into an integer.
116: * This returns -1 if the argument passed is no
117: * valid hex digit.
118: */
119: static int
120: digit2i(u_char c)
121: {
122: if (c >= '0' && c <= '9')
123: return (c - '0');
124: else if (c >= 'a' && c <= 'f')
125: return (c - 'a' + 10);
126: else if (c >= 'A' && c <= 'F')
127:
128: return (c - 'A' + 10);
129: else
130: return (-1);
131: }
132:
133: /*
134: * Convert the low 4 bits of an integer into
135: * an hex digit.
136: */
137: static u_char
138: i2digit(int n)
139: {
140: return ("0123456789abcdef"[n & 0x0f]);
141: }
142:
143: /*
144: * Convert a byte array into an hex string.
145: */
146: static void
147: mem2hex(void *vdst, void *vsrc, int len)
148: {
149: u_char *dst = vdst;
150: u_char *src = vsrc;
151:
152: while (len--) {
153: *dst++ = i2digit(*src >> 4);
154: *dst++ = i2digit(*src++);
155: }
156: *dst = '\0';
157: }
158:
159: /*
160: * Convert an hex string into a byte array.
161: * This returns a pointer to the character following
162: * the last valid hex digit. If the string ends in
163: * the middle of a byte, NULL is returned.
164: */
165: static u_char *
166: hex2mem(void *vdst, u_char *src, int maxlen)
167: {
168: u_char *dst = vdst;
169: int msb, lsb;
170:
171: while (*src && maxlen--) {
172: msb = digit2i(*src++);
173: if (msb < 0)
174: return (src - 1);
175: lsb = digit2i(*src++);
176: if (lsb < 0)
177: return (NULL);
178: *dst++ = (msb << 4) | lsb;
179: }
180: return (src);
181: }
182:
183: /*
184: * Convert an hex string into an integer.
185: * This returns a pointer to the character following
186: * the last valid hex digit.
187: */
188: static vaddr_t
189: hex2i(u_char **srcp)
190: {
191: char *src = *srcp;
192: vaddr_t r = 0;
193: int nibble;
194:
195: while ((nibble = digit2i(*src)) >= 0) {
196: r *= 16;
197: r += nibble;
198: src++;
199: }
200: *srcp = src;
201: return (r);
202: }
203:
204: /*
205: * Send a packet.
206: */
207: static void
208: kgdb_send(u_char *bp)
209: {
210: u_char *p;
211: u_char csum, c;
212:
213: #ifdef DEBUG_KGDB
214: printf("kgdb_send: %s\n", bp);
215: #endif
216: do {
217: p = bp;
218: PUTC(KGDB_START);
219: for (csum = 0; (c = *p); p++) {
220: PUTC(c);
221: csum += c;
222: }
223: PUTC(KGDB_END);
224: PUTC(i2digit(csum >> 4));
225: PUTC(i2digit(csum));
226: } while ((c = GETC() & 0x7f) == KGDB_BADP);
227: }
228:
229: /*
230: * Receive a packet.
231: */
232: static int
233: kgdb_recv(u_char *bp, int maxlen)
234: {
235: u_char *p;
236: int c, csum;
237: int len;
238:
239: do {
240: p = bp;
241: csum = len = 0;
242: while ((c = GETC()) != KGDB_START)
243: ;
244:
245: while ((c = GETC()) != KGDB_END && len < maxlen) {
246: c &= 0x7f;
247: csum += c;
248: *p++ = c;
249: len++;
250: }
251: csum &= 0xff;
252: *p = '\0';
253:
254: if (len >= maxlen) {
255: PUTC(KGDB_BADP);
256: continue;
257: }
258:
259: csum -= digit2i(GETC()) * 16;
260: csum -= digit2i(GETC());
261:
262: if (csum == 0) {
263: PUTC(KGDB_GOODP);
264: /* Sequence present? */
265: if (bp[2] == ':') {
266: PUTC(bp[0]);
267: PUTC(bp[1]);
268: len -= 3;
269: kgdb_copy(bp + 3, bp, len);
270: }
271: break;
272: }
273: PUTC(KGDB_BADP);
274: } while (1);
275: #ifdef DEBUG_KGDB
276: printf("kgdb_recv: %s\n", bp);
277: #endif
278: return (len);
279: }
280:
281: /*
282: * This is called by the appropriate tty driver.
283: */
284: void
285: kgdb_attach(int (*getfn)(void *), void (*putfn)(void *, int), void *ioarg)
286: {
287: kgdb_getc = getfn;
288: kgdb_putc = putfn;
289: kgdb_ioarg = ioarg;
290: }
291:
292: /*
293: * This function does all command processing for interfacing to
294: * a remote gdb. Note that the error codes are ignored by gdb
295: * at present, but might eventually become meaningful. (XXX)
296: * It might makes sense to use POSIX errno values, because
297: * that is what the gdb/remote.c functions want to return.
298: */
299: int
300: kgdb_trap(int type, db_regs_t *regs)
301: {
302: label_t jmpbuf;
303: vaddr_t addr;
304: size_t len;
305: u_char *p;
306:
307: if (kgdb_dev < 0 || kgdb_getc == NULL) {
308: /* not debugging */
309: return (0);
310: }
311:
312: /* Detect and recover from unexpected traps. */
313: if (kgdb_recover != 0) {
314: printf("kgdb: caught trap 0x%x at %p\n",
315: type, (void *)PC_REGS(regs));
316: kgdb_send("E0E"); /* 14==EFAULT */
317: longjmp(kgdb_recover);
318: }
319:
320: /*
321: * The first entry to this function is normally through
322: * a breakpoint trap in kgdb_connect(), in which case we
323: * must advance past the breakpoint because gdb will not.
324: *
325: * Machines vary as to where they leave the PC after a
326: * breakpoint trap. Those that leave the PC set to the
327: * address of the trap instruction (i.e. pc532) will not
328: * define FIXUP_PC_AFTER_BREAK(), and therefore will just
329: * advance the PC. On machines that leave the PC set to
330: * the instruction after the trap, FIXUP_PC_AFTER_BREAK
331: * will be defined to back-up the PC, so that after the
332: * "first-time" part of the if statement below has run,
333: * the PC will be the same as it was on entry.
334: *
335: * On the first entry here, we expect that gdb is not yet
336: * listening to us, so just enter the interaction loop.
337: * After the debugger is "active" (connected) it will be
338: * waiting for a "signaled" message from us.
339: */
340: if (kgdb_active == 0) {
341: if (!IS_BREAKPOINT_TRAP(type, 0)) {
342: /* No debugger active -- let trap handle this. */
343: return (0);
344: }
345: /* Make the PC point at the breakpoint... */
346: #ifdef FIXUP_PC_AFTER_BREAK
347: FIXUP_PC_AFTER_BREAK(regs);
348: #endif
349: /* ... and then advance past it. */
350: #ifdef PC_ADVANCE
351: PC_ADVANCE(regs);
352: #else
353: PC_REGS(regs) += BKPT_SIZE;
354: #endif
355: kgdb_active = 1;
356: } else {
357: /* Tell remote host that an exception has occurred. */
358: snprintf(buffer, sizeof buffer, "S%02x", kgdb_signal(type));
359: kgdb_send(buffer);
360: }
361:
362: /* Stick frame regs into our reg cache. */
363: kgdb_getregs(regs, gdb_regs);
364:
365: /*
366: * Interact with gdb until it lets us go.
367: * If we cause a trap, resume here.
368: */
369: (void)setjmp((kgdb_recover = &jmpbuf));
370: for (;;) {
371: kgdb_recv(buffer, sizeof(buffer));
372: switch (buffer[0]) {
373:
374: default:
375: /* Unknown command. */
376: kgdb_send("");
377: continue;
378:
379: case KGDB_SIGNAL:
380: /*
381: * if this command came from a running gdb,
382: * answer it -- the other guy has no way of
383: * knowing if we're in or out of this loop
384: * when he issues a "remote-signal".
385: */
386: snprintf(buffer, sizeof buffer, "S%02x",
387: kgdb_signal(type));
388: kgdb_send(buffer);
389: continue;
390:
391: case KGDB_REG_R:
392: mem2hex(buffer, gdb_regs, sizeof(gdb_regs));
393: kgdb_send(buffer);
394: continue;
395:
396: case KGDB_REG_W:
397: p = hex2mem(gdb_regs, buffer + 1, sizeof(gdb_regs));
398: if (p == NULL || *p != '\0')
399: kgdb_send("E01");
400: else {
401: kgdb_setregs(regs, gdb_regs);
402: kgdb_send("OK");
403: }
404: continue;
405:
406: case KGDB_MEM_R:
407: p = buffer + 1;
408: addr = hex2i(&p);
409: if (*p++ != ',') {
410: kgdb_send("E02");
411: continue;
412: }
413: len = hex2i(&p);
414: if (*p != '\0') {
415: kgdb_send("E03");
416: continue;
417: }
418: if (len > sizeof(buffer) / 2) {
419: kgdb_send("E04");
420: continue;
421: }
422: if (kgdb_acc(addr, len) == 0) {
423: kgdb_send("E05");
424: continue;
425: }
426: db_read_bytes(addr, (size_t)len,
427: (char *)buffer + sizeof(buffer) / 2);
428: mem2hex(buffer, buffer + sizeof(buffer) / 2, len);
429: kgdb_send(buffer);
430: continue;
431:
432: case KGDB_MEM_W:
433: p = buffer + 1;
434: addr = hex2i(&p);
435: if (*p++ != ',') {
436: kgdb_send("E06");
437: continue;
438: }
439: len = hex2i(&p);
440: if (*p++ != ':') {
441: kgdb_send("E07");
442: continue;
443: }
444: if (len > (sizeof(buffer) - (p - buffer))) {
445: kgdb_send("E08");
446: continue;
447: }
448: p = hex2mem(buffer, p, sizeof(buffer));
449: if (p == NULL) {
450: kgdb_send("E09");
451: continue;
452: }
453: if (kgdb_acc(addr, len) == 0) {
454: kgdb_send("E0A");
455: continue;
456: }
457: db_write_bytes(addr, (size_t)len, (char *)buffer);
458: kgdb_send("OK");
459: continue;
460:
461: case KGDB_DETACH:
462: kgdb_active = 0;
463: printf("kgdb detached\n");
464: db_clear_single_step(regs);
465: kgdb_send("OK");
466: goto out;
467:
468: case KGDB_KILL:
469: kgdb_active = 0;
470: printf("kgdb detached\n");
471: db_clear_single_step(regs);
472: goto out;
473:
474: case KGDB_CONT:
475: if (buffer[1]) {
476: p = buffer + 1;
477: addr = hex2i(&p);
478: if (*p) {
479: kgdb_send("E0B");
480: continue;
481: }
482: PC_REGS(regs) = addr;
483: }
484: db_clear_single_step(regs);
485: goto out;
486:
487: case KGDB_STEP:
488: if (buffer[1]) {
489: p = buffer + 1;
490: addr = hex2i(&p);
491: if (*p) {
492: kgdb_send("E0B");
493: continue;
494: }
495: PC_REGS(regs) = addr;
496: }
497: db_set_single_step(regs);
498: goto out;
499: }
500: }
501: out:
502: kgdb_recover = 0;
503: return (1);
504: }
505:
506: /*
507: * Trap into kgdb to wait for debugger to connect,
508: * noting on the console why nothing else is going on.
509: */
510: void
511: kgdb_connect(int verbose)
512: {
513: if (kgdb_dev < 0)
514: return;
515:
516: KGDB_PREPARE;
517:
518: if (verbose)
519: printf("kgdb waiting...");
520:
521: KGDB_ENTER;
522:
523: if (verbose)
524: printf("connected.\n");
525:
526: kgdb_debug_panic = 1;
527: }
528:
529: /*
530: * Decide what to do on panic.
531: * (This is called by panic, like Debugger())
532: */
533: void
534: kgdb_panic()
535: {
536: if (kgdb_dev >= 0 && kgdb_debug_panic) {
537: printf("entering kgdb\n");
538: kgdb_connect(kgdb_active == 0);
539: }
540: }