![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kdb_machdep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax|
Return to kdb_machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax |
1.1 root 1: /* @(#)kdb_machdep.c 7.3 (Berkeley) 5/19/88 */
2:
3: #include "param.h"
4: #include "conf.h"
5: #include "dir.h"
6: #include "user.h"
7: #include "proc.h"
8: #include "uio.h"
9: #include "systm.h"
10: #include "reboot.h"
11: #include "vmmac.h"
12: #include "ioctl.h"
13: #include "tty.h"
14:
15: #include "cpu.h"
16: #include "mtpr.h"
17: #include "psl.h"
18: #include "pte.h"
19: #include "reg.h"
20: #include "trap.h"
21: #include "kdbparam.h"
22:
23: #define KDBSPACE 1024 /* 1K of memory for breakpoint table */
24: static char kdbbuf[KDBSPACE];
25: static char *kdbend = kdbbuf;
26: /*
27: * Dynamically allocate space for the debugger.
28: */
29: char *
30: kdbmalloc(n)
31: u_int n;
32: {
33: char *old = kdbend;
34:
35: if (kdbend+n >= kdbbuf+KDBSPACE) {
36: printf("kdb: Out of space\n");
37: return ((char *)-1);
38: }
39: kdbend += n;
40: return (old);
41: }
42:
43: /*
44: * Initialize the kernel debugger.
45: */
46: kdb_init()
47: {
48: char *symtab, *strtab;
49: int strsize;
50: extern int end;
51:
52: kdbsetup();
53: if (bootesym > (char *)&end) {
54: symtab = (char *)&end + sizeof (int);
55: #define symsize *(int *)&end
56: strtab = symtab + symsize;
57: strsize = roundup(*(int *)strtab, sizeof (int));
58: if (strtab + strsize == bootesym) {
59: printf("[Preserving %d bytes of symbol information]\n",
60: symsize + strsize);
61: kdbsetsym(symtab, strtab, strtab, strsize);
62: } else
63: printf("kdb_init: bad bootesym %x, calculated %x\n",
64: bootesym, strtab + strsize);
65: }
66: /*
67: * If boot flags indicate, force entry into the debugger.
68: */
69: if ((boothowto&(RB_HALT|RB_KDB)) == (RB_HALT|RB_KDB))
70: setsoftkdb();
71: #undef symsize
72: }
73:
74: int kdbactive = 0;
75: #define ESC '\033'
76:
77: /*
78: * Process a keyboard interrupt from the console.
79: * We look for an escape sequence which signals
80: * a request to enter the debugger.
81: */
82: kdbrintr(c, tp)
83: int c;
84: struct tty *tp;
85: {
86: static int escape = 0;
87:
88: c &= 0177; /* strip parity also */
89: if (!escape)
90: return (c == ESC && ++escape);
91: escape = 0;
92: /*
93: * Transfer control to the debugger only if the
94: * system was booted with RB_KDB and the trap
95: * enable flag (RB_NOYSNC) is set.
96: */
97: if ((boothowto&(RB_KDB|RB_NOSYNC)) != (RB_KDB|RB_NOSYNC) ||
98: (c != 'k' && c != 'K' && c != CTRL('k'))) {
99: (*linesw[tp->t_line].l_rint)(ESC, tp);
100: return (0);
101: }
102: if (!kdbactive)
103: setsoftkdb();
104: return (1);
105: }
106:
107: static int
108: movpsl()
109: {
110:
111: asm(" movpsl r0"); /* XXX */
112: }
113:
114: #define TYPE SP+1
115: #define CODE PC-1
116: #define USER 040
117: static caddr_t kdbnofault; /* label for peek & poke */
118: /*
119: * Field a kdb-related trap or fault.
120: */
121: kdb_trap(apsl)
122: register int *apsl;
123: {
124: register int *locr0, type;
125: int code, retval;
126: static int prevtype = -1, prevcode;
127: extern char *trap_type[];
128: extern int TRAP_TYPES;
129:
130: /*
131: * Allow panic if the debugger is not enabled.
132: */
133: if ((boothowto&RB_KDB) == 0)
134: return (0);
135: locr0 = apsl - PS;
136: type = locr0[TYPE], code = locr0[CODE];
137: if (type == T_KDBTRAP && prevtype != -1) {
138: type = prevtype, code = prevcode;
139: prevtype = -1;
140: }
141: if (type != T_TRCTRAP && type != T_BPTFLT) {
142: /*
143: * Catch traps from kdbpeek and kdbpoke and perform
144: * non-local goto to error label setup in routines.
145: */
146: if (kdbnofault) {
147: locr0[PC] = (int)kdbnofault;
148: return (1);
149: }
150: type &= ~USER;
151: }
152: /*
153: * We prefer to run the debugger from the interrupt stack to
154: * avoid overflowing the kernel stack. Thus, if we're not
155: * currently on the interrupt stack and the ipl is low, schedule
156: * a software interrupt to force reentry on the interrupt stack
157: * immediately after the rei that'll take place on return.
158: */
159: if ((movpsl()&PSL_IS) == 0) {
160: int s = splhigh();
161: if (s < KDB_IPL) {
162: prevtype = type, prevcode = code;
163: setsoftkdb();
164: return (1);
165: }
166: splx(s);
167: printf("(from kernel stack)\n");
168: }
169: getpcb(locr0);
170: /*
171: * Mark debugger active and initiate input
172: * polling in the console device driver.
173: */
174: cnpoll(kdbactive = 1);
175: retval = kdb(type, code, noproc ? (struct proc *)0 : u.u_procp);
176: cnpoll(kdbactive = 0);
177: setpcb(locr0);
178: return (retval);
179: }
180:
181: static char *codenames[] = {
182: "code = 0",
183: "integer overflow",
184: "integer divide by zero",
185: "floating overflow",
186: "floating/decimal divide by zero",
187: "floating underflow",
188: "decimal overflow",
189: "subscript out of range",
190: "floating overflow",
191: "floating divide by zero",
192: "floating undeflow"
193: };
194: #define NCODES (sizeof (codenames) / sizeof (codenames[0]))
195:
196: /*
197: * Announce a trap.
198: */
199: kdbprinttrap(type, code)
200: int type, code;
201: {
202:
203: extern int TRAP_TYPES;
204: extern char *trap_type[];
205:
206: if (type != T_TRCTRAP && type != T_BPTFLT) {
207: if (type < TRAP_TYPES && trap_type[type])
208: printf(trap_type[type]);
209: else
210: printf("trap type %d", type);
211: if (type == T_ARITHTRAP && (unsigned)code < NCODES)
212: printf(", %s", code);
213: else if (code)
214: printf(", code = %d", code);
215: printf("\n");
216: }
217: }
218:
219: /*
220: * Read character from the console.
221: */
222: kdbreadc(cp)
223: char *cp;
224: {
225:
226: *cp = cngetc();
227: return (1);
228: }
229:
230: /*
231: * Write characters to the console.
232: */
233: kdbwrite(cp, len)
234: register char *cp;
235: register int len;
236: {
237:
238: while (len-- > 0)
239: cnputc(*cp++);
240: }
241:
242: /*
243: * Fetch a longword carefully.
244: */
245: kdbpeek(addr)
246: register caddr_t addr;
247: {
248: register long v = 0;
249:
250: asm("movab 1f,_kdbnofault");
251: v = *(long *)addr;
252: asm("1:");
253: kdbnofault = 0;
254: return (v);
255: }
256:
257: /*
258: * Put a longword carefully.
259: */
260: kdbpoke(addr, v)
261: register caddr_t addr;
262: long v;
263: {
264: register int pn, *pte, opte = 0;
265: extern char Sysbase[], etext;
266:
267: /*
268: * If we're writing to the kernel's text space,
269: * make the page writeable for the duration of
270: * the access.
271: */
272: if ((caddr_t)Sysbase <= addr && addr <= (caddr_t)&etext) {
273: pn = btop((int)addr &~ 0x80000000);
274: pte = (int *)&Sysmap[pn];
275: opte = *pte;
276: *pte = (*pte &~ PG_PROT)|PG_KW;
277: mtpr(TBIS, addr);
278: }
279: asm("movab 1f,_kdbnofault");
280: *(long *)addr = v;
281: asm("1:");
282: kdbnofault = 0;
283: if (opte) {
284: *pte = opte;
285: mtpr(TBIS, addr);
286: }
287: }
288:
289: static
290: getpcb(locr0)
291: register int *locr0;
292: {
293: extern struct pcb kdbpcb;
294: register struct pcb *pcb = &kdbpcb;
295:
296: pcb->pcb_r0 = locr0[R0];
297: pcb->pcb_r1 = locr0[R1];
298: pcb->pcb_r2 = locr0[R2];
299: pcb->pcb_r3 = locr0[R3];
300: pcb->pcb_r4 = locr0[R4];
301: pcb->pcb_r5 = locr0[R5];
302: pcb->pcb_r6 = locr0[R6];
303: pcb->pcb_r7 = locr0[R7];
304: pcb->pcb_r8 = locr0[R8];
305: pcb->pcb_r9 = locr0[R9];
306: pcb->pcb_r10 = locr0[R10];
307: pcb->pcb_r11 = locr0[R11];
308: pcb->pcb_ap = locr0[AP];
309: pcb->pcb_fp = locr0[FP];
310: pcb->pcb_usp = locr0[SP];
311: pcb->pcb_pc = locr0[PC];
312: pcb->pcb_psl = locr0[PS];
313: pcb->pcb_ksp = mfpr(KSP);
314: pcb->pcb_esp = mfpr(ISP);
315: pcb->pcb_p0br = (struct pte *)mfpr(P0BR);
316: pcb->pcb_p0lr = mfpr(P0LR);
317: pcb->pcb_p1br = (struct pte *)mfpr(P1BR);
318: pcb->pcb_p1lr = mfpr(P1LR);
319: }
320:
321: static
322: setpcb(locr0)
323: register int *locr0;
324: {
325: extern struct pcb kdbpcb;
326: register struct pcb *pcb = &kdbpcb;
327:
328: locr0[R0] = pcb->pcb_r0;
329: locr0[R1] = pcb->pcb_r1;
330: locr0[R2] = pcb->pcb_r2;
331: locr0[R3] = pcb->pcb_r3;
332: locr0[R4] = pcb->pcb_r4;
333: locr0[R5] = pcb->pcb_r5;
334: locr0[R6] = pcb->pcb_r6;
335: locr0[R7] = pcb->pcb_r7;
336: locr0[R8] = pcb->pcb_r8;
337: locr0[R9] = pcb->pcb_r9;
338: locr0[R10] = pcb->pcb_r10;
339: locr0[R11] = pcb->pcb_r11;
340: locr0[AP] = pcb->pcb_ap;
341: locr0[FP] = pcb->pcb_fp;
342: locr0[SP] = pcb->pcb_usp;
343: locr0[PC] = pcb->pcb_pc;
344: locr0[PS] = pcb->pcb_psl;
345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.