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