![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kgdb_stub.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300|
Return to kgdb_stub.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300 |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution is only permitted until one year after the first shipment
11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
12: * binary forms are permitted provided that: (1) source distributions retain
13: * this entire copyright notice and comment, and (2) distributions including
14: * binaries display the following acknowledgement: This product includes
15: * software developed by the University of California, Berkeley and its
16: * contributors'' in the documentation or other materials provided with the
17: * distribution and in all advertising materials mentioning features or use
18: * of this software. Neither the name of the University nor the names of
19: * its contributors may be used to endorse or promote products derived from
20: * this software without specific prior written permission.
21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24: *
25: * @(#)kgdb_stub.c 7.3 (Berkeley) 6/22/90
26: */
27:
28: /*
29: *
30: * The following gdb commands are supported:
31: *
32: * command function Return value
33: *
34: * g return the value of the CPU registers hex data or ENN
35: * G set the value of the CPU registers OK or ENN
36: *
37: * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
38: * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
39: *
40: * c Resume at current address SNN ( signal NN)
41: * cAA..AA Continue at address AA..AA SNN
42: *
43: * s Step one instruction SNN
44: * sAA..AA Step one instruction from AA..AA SNN
45: *
46: * k kill
47: *
48: * ? What was the last sigval ? SNN (signal NN)
49: *
50: * All commands and responses are sent with a packet which includes a
51: * checksum. A packet consists of
52: *
53: * $<packet info>#<checksum>.
54: *
55: * where
56: * <packet info> :: <characters representing the command or response>
57: * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
58: *
59: * When a packet is received, it is first acknowledged with either '+' or '-'.
60: * '+' indicates a successful transfer. '-' indicates a failed transfer.
61: *
62: * Example:
63: *
64: * Host: Reply:
65: * $m0,10#2a +$00010203040506070809101112131415#42
66: *
67: ****************************************************************************/
68:
69: #ifdef KGDB
70: #include "param.h"
71: #include "systm.h"
72: #include "trap.h"
73: #include "cpu.h"
74: #include "psl.h"
75: #include "reg.h"
76: #include "frame.h"
77: #include "buf.h"
78:
79: extern void printf();
80: extern void bcopy();
81: extern int kernacc();
82: extern void chgkprot();
83:
84: /* # of additional (beyond 4) bytes in 680x0 exception frame format n */
85: static int frame_bytes[16] = {
86: 4, 4, 8, 4,
87: 4, 4, 4, 4,
88: 54, 16, 28, 88,
89: 4, 4, 4, 4
90: };
91:
92: #define USER 040 /* (XXX from trap.c) user-mode flag in type */
93:
94: /*
95: * BUFMAX defines the maximum number of characters in inbound/outbound
96: * buffers. At least NUMREGBYTES*2 are needed for register packets.
97: */
98: #define BUFMAX 512
99:
100: #ifndef KGDBDEV
101: #define KGDBDEV -1
102: #endif
103: #ifndef KGDBRATE
104: #define KGDBRATE 9600
105: #endif
106:
107: int kgdb_dev = KGDBDEV; /* remote debugging device (-1 if none) */
108: int kgdb_rate = KGDBRATE; /* remote debugging baud rate */
109: int kgdb_debug_init = 0; /* != 0 waits for remote at system init */
110: int kgdb_debug = 0; /* > 0 prints command & checksum errors */
111:
112: #include "../hp300/cons.h"
113:
114: #define GETC \
115: (constab[major(kgdb_dev)].cn_getc ? \
116: (*constab[major(kgdb_dev)].cn_getc)(kgdb_dev) : 0)
117: #define PUTC(c) { \
118: if (constab[major(kgdb_dev)].cn_putc) \
119: (*constab[major(kgdb_dev)].cn_putc)(kgdb_dev, c); \
120: }
121:
122: static char hexchars[] = "0123456789abcdef";
123:
124: /*
125: * There are 180 bytes of registers on a 68020 w/68881. Many of the fpa
126: * registers are 12 byte (96 bit) registers.
127: */
128: #define NUMREGBYTES 180
129:
130: static char inbuffer[BUFMAX];
131: static char outbuffer[BUFMAX];
132:
133: static inline int
134: hex(ch)
135: char ch;
136: {
137: if ((ch >= '0') && (ch <= '9'))
138: return (ch - '0');
139: if ((ch >= 'a') && (ch <= 'f'))
140: return (ch - ('a' - 10));
141: return (0);
142: }
143:
144: /* scan for the sequence $<data>#<checksum> */
145: static void
146: getpacket(char *buffer)
147: {
148: unsigned char checksum;
149: unsigned char xmitcsum;
150: int i;
151: int count;
152: char ch;
153:
154: do {
155: /*
156: * wait around for the start character, ignore all other
157: * characters
158: */
159: while ((ch = GETC) != '$')
160: ;
161: checksum = 0;
162: count = 0;
163: xmitcsum = 1;
164:
165: /* now, read until a # or end of buffer is found */
166: while (count < BUFMAX) {
167: ch = GETC;
168: if (ch == '#')
169: break;
170: checksum = checksum + ch;
171: buffer[count] = ch;
172: count = count + 1;
173: }
174: buffer[count] = 0;
175:
176: if (ch == '#') {
177: xmitcsum = hex(GETC) << 4;
178: xmitcsum += hex(GETC);
179: if (kgdb_debug && (checksum != xmitcsum)) {
180: printf(
181: "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
182: checksum, xmitcsum, buffer);
183: }
184: if (checksum != xmitcsum) {
185: PUTC('-'); /* failed checksum */
186: } else {
187: PUTC('+'); /* successful transfer */
188: /*
189: * if a sequence char is present, reply the
190: * sequence ID
191: */
192: if (buffer[2] == ':') {
193: PUTC(buffer[0]);
194: PUTC(buffer[1]);
195: /* remove sequence chars from buffer */
196: for (i = 3; i <= count; ++i)
197: buffer[i - 3] = buffer[i];
198: }
199: }
200: }
201: } while (checksum != xmitcsum);
202: }
203:
204: /*
205: * send the packet in buffer. The host gets one chance to read it. This
206: * routine does not wait for a positive acknowledge.
207: */
208: static void
209: putpacket(char *buffer)
210: {
211: unsigned char checksum;
212: int count;
213: char ch;
214:
215: /* $<packet info>#<checksum>. */
216: do {
217: PUTC('$');
218: checksum = 0;
219: count = 0;
220:
221: while (ch = buffer[count]) {
222: PUTC(ch);
223: checksum += ch;
224: count += 1;
225: }
226: PUTC('#');
227: PUTC(hexchars[checksum >> 4]);
228: PUTC(hexchars[checksum & 15]);
229:
230: } while (0); /* (GETC != '+'); */
231:
232: }
233:
234: static inline void
235: debug_error(char *format, char *parm)
236: {
237: if (kgdb_debug)
238: printf(format, parm);
239: }
240:
241: /*
242: * Convert at most 'dig' digits of hex data in buf into a value.
243: * Stop on non-hex char. Return a pointer to next char in buf.
244: */
245: static char *
246: hex2val(char *buf, int *val, int dig)
247: {
248: int i, v;
249: char ch;
250:
251: v = 0;
252: for (i = dig; --i >= 0; ) {
253: ch = *buf++;
254: if ((ch >= '0') && (ch <= '9'))
255: v = (v << 4) | (ch - '0');
256: else if ((ch >= 'a') && (ch <= 'f'))
257: v = (v << 4) | (ch - ('a' - 10));
258: else {
259: --buf;
260: break;
261: }
262: }
263: *val = v;
264: return (buf);
265: }
266:
267: /*
268: * convert the integer value 'val' into 'dig' hex digits, placing
269: * result in buf. Return a pointer to the last char put in buf (null).
270: */
271: static char *
272: val2hex(char *buf, int val, int dig)
273: {
274: for (dig <<= 2; (dig -= 4) >= 0; )
275: *buf++ = hexchars[(val >> dig) & 0xf];
276: *buf = 0;
277: return (buf);
278: }
279:
280: /*
281: * convert the memory pointed to by mem into hex, placing result in buf.
282: * return a pointer to the last char put in buf (null).
283: */
284: static char *
285: mem2hex(char *buf, char *mem, int count)
286: {
287: if ((count & 1) || ((int)mem & 1)) {
288: char ch;
289:
290: while(--count >= 0) {
291: ch = *mem++;
292: *buf++ = hexchars[ch >> 4];
293: *buf++ = hexchars[ch & 15];
294: }
295: } else {
296: u_short s;
297: u_short *mp = (u_short *)mem;
298:
299: for (count >>= 1; --count >= 0; ) {
300: s = *mp++;
301: *buf++ = hexchars[(s >> 12) & 15];
302: *buf++ = hexchars[(s >> 8) & 15];
303: *buf++ = hexchars[(s >> 4) & 15];
304: *buf++ = hexchars[s & 15];
305: }
306: }
307: *buf = 0;
308: return (buf);
309: }
310:
311: /*
312: * Convert the hex array pointed to by buf into binary to be placed in mem.
313: * Return a pointer to next char in buf.
314: */
315: static char *
316: hex2mem(char *buf, char *mem, int count)
317: {
318: int i;
319: unsigned char ch;
320:
321: for (i = 0; i < count; ++i) {
322: ch = hex(*buf++) << 4;
323: ch = ch + hex(*buf++);
324: *mem++ = ch;
325: }
326: return (buf);
327: }
328:
329: /*
330: * Translate a trap number into a unix compatible signal value.
331: * (gdb only understands unix signal numbers).
332: */
333: static int
334: computeSignal(int type)
335: {
336: int sigval;
337:
338: switch (type &~ USER) {
339: case T_BUSERR:
340: sigval = SIGBUS;
341: break; /* bus error */
342: case T_ADDRERR:
343: sigval = SIGBUS;
344: break; /* address error */
345: case T_ILLINST:
346: sigval = SIGILL;
347: break; /* illegal instruction */
348: case T_ZERODIV:
349: sigval = SIGFPE;
350: break; /* zero divide */
351: case T_CHKINST:
352: sigval = SIGFPE;
353: break; /* chk instruction */
354: case T_TRAPVINST:
355: sigval = SIGFPE;
356: break; /* trapv instruction */
357: case T_PRIVINST:
358: sigval = SIGILL;
359: break; /* privilege violation */
360: case T_TRACE:
361: sigval = SIGTRAP;
362: break; /* trace trap */
363: case T_MMUFLT:
364: sigval = SIGSEGV;
365: break;
366: case T_SSIR:
367: sigval = SIGSEGV;
368: break;
369: case T_FMTERR:
370: sigval = SIGILL;
371: break;
372: case T_FPERR:
373: sigval = SIGFPE;
374: break;
375: case T_COPERR:
376: sigval = SIGFPE;
377: break;
378: case T_ASTFLT:
379: sigval = SIGINT;
380: break;
381: case T_TRAP15:
382: sigval = SIGIOT;
383: break;
384: default:
385: sigval = SIGEMT;
386: break;
387: }
388: return (sigval);
389: }
390:
391: #define RESPOND(str) (bcopy(str, outbuffer, sizeof(str)))
392:
393: /*
394: * This function does all command procesing for interfacing to
395: * a remote gdb.
396: */
397: int
398: kgdb_trap(int type, unsigned code, unsigned v, struct frame *frame)
399: {
400: int sigval;
401: int addr, length;
402: char *ptr;
403:
404: if (kgdb_dev < 0)
405: /* not debugging */
406: return (0);
407:
408: if (kgdb_debug)
409: printf("type=%d, code=%d, vector=0x%x, pc=0x%x, sr=0x%x\n",
410: type, code, frame->f_vector, frame->f_pc, frame->f_sr);
411:
412: /* reply to host that an exception has occurred */
413: sigval = computeSignal(type);
414: outbuffer[0] = 'S';
415: (void)val2hex(&outbuffer[1], sigval, 2);
416: putpacket(outbuffer);
417:
418: while (1) {
419: outbuffer[0] = 0;
420: getpacket(inbuffer);
421: ptr = inbuffer;
422: switch (*ptr++) {
423: case '?':
424: outbuffer[0] = 'S';
425: (void)val2hex(&outbuffer[1], sigval, 2);
426: break;
427: case 'g': /* return the value of the CPU registers */
428: ptr = outbuffer;
429: if (type & USER)
430: ptr = mem2hex(ptr, (char *)frame->f_regs,
431: sizeof(frame->f_regs));
432: else {
433: ptr = mem2hex(ptr, (char *)frame->f_regs,
434: sizeof(frame->f_regs) - 4);
435: addr = (int)&frame->f_pc -
436: frame_bytes[frame->f_format];
437: ptr = mem2hex(ptr, (char *)&addr, sizeof(addr));
438: }
439: addr = frame->f_sr;
440: ptr = mem2hex(ptr, (char *)&addr, sizeof(addr));
441: ptr = mem2hex(ptr, (char *)&frame->f_pc,
442: sizeof(frame->f_pc));
443: break;
444: case 'G': /* set the value of the CPU registers */
445: ptr = hex2mem(ptr, (char *)frame->f_regs,
446: sizeof(frame->f_regs) - 4);
447: ptr = hex2mem(ptr, (char *)&addr, sizeof(addr));
448: ptr = hex2mem(ptr, (char *)&addr, sizeof(addr));
449: frame->f_sr = addr;
450: ptr = hex2mem(ptr, (char *)&frame->f_pc,
451: sizeof(frame->f_pc));
452: RESPOND("OK");
453: break;
454:
455: /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
456: case 'm':
457: ptr = hex2val(ptr, &addr, 8);
458: if (*ptr++ != ',') {
459: RESPOND("E01");
460: debug_error("malformed read memory cmd: %s\n",
461: inbuffer);
462: break;
463: }
464: ptr = hex2val(ptr, &length, 8);
465: if (length <= 0 || length >= BUFMAX*2) {
466: RESPOND("E02");
467: if (kgdb_debug)
468: printf("bad read memory length: %d\n",
469: length);
470: break;
471: }
472: if (! kernacc(addr, length, B_READ)) {
473: RESPOND("E03");
474: if (kgdb_debug)
475: printf("read access violation addr 0x%x len %d\n", addr, length);
476: break;
477: }
478: (void)mem2hex(outbuffer, (char *)addr, length);
479: break;
480:
481: /*
482: * MAA..AA,LLLL: Write LLLL bytes at address AA.AA
483: * return OK
484: */
485: case 'M':
486: ptr = hex2val(ptr, &addr, 8);
487: if (*ptr++ != ',') {
488: RESPOND("E01");
489: debug_error("malformed write memory cmd: %s\n",
490: inbuffer);
491: break;
492: }
493: ptr = hex2val(ptr, &length, 8);
494: if (*ptr++ != ':') {
495: RESPOND("E01");
496: debug_error("malformed write memory cmd: %s\n",
497: inbuffer);
498: break;
499: }
500: if (length <= 0 || length >= BUFMAX*2 - 32) {
501: RESPOND("E02");
502: if (kgdb_debug)
503: printf("bad write memory length: %d\n",
504: length);
505: break;
506: }
507: if (! kernacc(addr, length, B_READ)) {
508: RESPOND("E03");
509: if (kgdb_debug)
510: printf("write access violation addr 0x%x len %d\n", addr, length);
511: break;
512: }
513: if (! kernacc(addr, length, B_WRITE))
514: chgkprot(addr, length, B_WRITE);
515: (void)hex2mem(ptr, (char *)addr, length);
516: RESPOND("OK");
517: break;
518:
519: /*
520: * cAA..AA Continue at address AA..AA
521: * sAA..AA Step one instruction from AA..AA
522: * (addresses optional)
523: */
524: case 'c':
525: case 's':
526: /*
527: * try to read optional start address.
528: */
529: if (ptr != hex2val(ptr, &addr, 8)) {
530: frame->f_pc = addr;
531: if (kgdb_debug)
532: printf("new pc = 0x%x\n", addr);
533: }
534: /* deal with the trace bit */
535: if (inbuffer[0] == 's')
536: frame->f_sr |= PSL_T;
537: else
538: frame->f_sr &=~ PSL_T;
539:
540: if (kgdb_debug)
541: printf("restarting at 0x%x\n", frame->f_pc);
542:
543: return (1);
544:
545: /* kill the program (same as continue for now) */
546: case 'k':
547: return (1);
548: }
549: /* reply to the request */
550: putpacket(outbuffer);
551: }
552: }
553: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.