1 /* kdb_machdep.c 7.4 87/03/13 */ 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 CTRL([) 76 /* 77 * Process a keyboard interrupt from the console. 78 * We look for an escape sequence which signals 79 * a request to enter the debugger. 80 */ 81 kdbrintr(c, tp) 82 int c; 83 struct tty *tp; 84 { 85 static int escape = 0; 86 87 /* 88 * Transfer control to the debugger only if the 89 * system was booted with RB_KDB and the trap 90 * enable flag (RB_NOYSNC) is set. 91 */ 92 if ((boothowto&(RB_KDB|RB_NOSYNC)) != (RB_KDB|RB_NOSYNC)) 93 return (0); 94 c &= 0177; /* strip parity also */ 95 if (!escape) 96 return (c == ESC && ++escape); 97 escape = 0; 98 if ((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 #define TYPE SP+1 108 #define CODE PC-1 109 #define USER 040 110 static caddr_t kdbnofault; /* label for peek & poke */ 111 /* 112 * Field a kdb-related trap or fault. 113 */ 114 kdb_trap(apsl) 115 register int *apsl; 116 { 117 register int *locr0, type; 118 int code, retval; 119 static int prevtype = -1, prevcode; 120 extern char *trap_type[]; 121 extern int TRAP_TYPES; 122 123 /* 124 * Allow panic if the debugger is not enabled. 125 */ 126 if ((boothowto&RB_KDB) == 0) 127 return (0); 128 locr0 = apsl - PS; 129 type = locr0[TYPE], code = locr0[CODE]; 130 if (type == T_KDBTRAP && prevtype != -1) { 131 type = prevtype, code = prevcode; 132 prevtype = -1; 133 } 134 if (type != T_TRCTRAP && type != T_BPTFLT) { 135 /* 136 * Catch traps from kdbpeek and kdbpoke and perform 137 * non-local goto to error label setup in routines. 138 */ 139 if (kdbnofault) { 140 locr0[PC] = (int)kdbnofault; 141 return (1); 142 } 143 type &= ~USER; 144 } 145 /* 146 * We prefer to run the debugger from the interrupt stack to 147 * avoid overflowing the kernel stack. Thus, if we're not 148 * currently on the interrupt stack and the ipl is low, schedule 149 * a software interrupt to force reentry on the interrupt stack 150 * immediately after the rei that'll take place on return. 151 */ 152 if ((movpsl()&PSL_IS) == 0) { 153 int s = splhigh(); 154 if (s < KDB_IPL) { 155 prevtype = type, prevcode = code; 156 setsoftkdb(); 157 return (1); 158 } 159 splx(s); 160 printf("(from kernel stack)\n"); 161 } 162 getpcb(locr0); 163 /* 164 * Mark debugger active and initiate input 165 * polling in the console device driver. 166 */ 167 cnpoll(kdbactive = 1); 168 retval = kdb(type, code, noproc ? (struct proc *)0 : u.u_procp); 169 cnpoll(kdbactive = 0); 170 setpcb(locr0); 171 return (retval); 172 } 173 174 static char *codenames[] = { 175 "code = 0", /* not defined */ 176 "integer overflow", 177 "integer divide by zero", 178 "floating divide by zero", 179 "floating overflow", 180 "float underflow" 181 }; 182 #define NCODES (sizeof (codenames) / sizeof (codenames[0])) 183 184 /* 185 * Announce a trap. 186 */ 187 kdbprinttrap(type, code) 188 long type, code; 189 { 190 191 extern int TRAP_TYPES; 192 extern char *trap_type[]; 193 194 if (type != T_TRCTRAP && type != T_BPTFLT) { 195 if (type < TRAP_TYPES && trap_type[type]) 196 printf(trap_type[type]); 197 else 198 printf("trap type %d", type); 199 if (type == T_ARITHTRAP && (unsigned)code < NCODES) 200 printf(", %s", code); 201 else if (code) 202 printf(", code = %x", code); 203 printf("\n"); 204 } 205 } 206 207 /* 208 * Read character from the console. 209 */ 210 kdbreadc(cp) 211 char *cp; 212 { 213 214 *cp = cngetc(); 215 return (1); 216 } 217 218 /* 219 * Write characters to the console. 220 */ 221 kdbwrite(cp, len) 222 register char *cp; 223 register int len; 224 { 225 226 while (len-- > 0) 227 cnputc(*cp++); 228 } 229 230 /* 231 * Fetch a longword carefully. 232 */ 233 kdbpeek(addr) 234 register caddr_t addr; 235 { 236 register long v = 0; 237 238 asm("movab 1f,_kdbnofault"); 239 switch ((int)addr&03) { 240 case 0: 241 v = *(long *)addr; 242 break; 243 case 2: 244 v = *(u_short *)addr, addr += sizeof (short); 245 v = (v << 16) | *(u_short *)addr; 246 break; 247 case 1: case 3: 248 v = *(u_char *)addr++; 249 v = (v << 8) | *(u_char *)addr++; 250 v = (v << 8) | *(u_char *)addr++; 251 v = (v << 8) | *(u_char *)addr; 252 break; 253 } 254 asm("1:"); 255 kdbnofault = 0; 256 return (v); 257 } 258 259 /* 260 * Put a longword carefully. 261 */ 262 kdbpoke(addr, v) 263 register caddr_t addr; 264 long v; 265 { 266 register int pn, *pte, opte = 0; 267 extern caddr_t Sysbase; 268 extern int etext; 269 u_short *wp; 270 u_char *cp; 271 272 /* 273 * If we're writing to the kernel's text space, 274 * make the page writeable for the duration of 275 * the access. 276 */ 277 if (Sysbase <= addr && addr <= (caddr_t)&etext) { 278 pn = btop((int)addr &~ 0xc0000000); 279 pte = (int *)&Sysmap[pn]; 280 opte = *pte; 281 *pte = (*pte &~ PG_PROT)|PG_KW; 282 mtpr(TBIS, addr); 283 } 284 asm("movab 1f,_kdbnofault"); 285 switch ((int)addr&03) { 286 case 0: 287 *(long *)addr = v; 288 break; 289 case 2: 290 wp = (u_short *)&v; 291 *(u_short*)addr = *wp++, addr += sizeof (short); 292 *(u_short *)addr = *wp; 293 break; 294 case 1: case 3: 295 cp = (u_char *)&v; 296 *(u_char *)addr++ = *cp++; 297 *(u_char *)addr++ = *cp++; 298 *(u_char *)addr++ = *cp++; 299 *(u_char *)addr = *cp; 300 break; 301 } 302 asm("1:"); 303 kdbnofault = 0; 304 if (opte) { 305 *pte = opte; 306 mtpr(TBIS, addr); 307 mtpr(PACC, 1); 308 } 309 } 310 311 static 312 getpcb(locr0) 313 register int *locr0; 314 { 315 extern struct pcb kdbpcb; 316 register struct pcb *pcb = &kdbpcb; 317 318 pcb->pcb_r0 = locr0[R0]; 319 pcb->pcb_r1 = locr0[R1]; 320 pcb->pcb_r2 = locr0[R2]; 321 pcb->pcb_r3 = locr0[R3]; 322 pcb->pcb_r4 = locr0[R4]; 323 pcb->pcb_r5 = locr0[R5]; 324 pcb->pcb_r6 = locr0[R6]; 325 pcb->pcb_r7 = locr0[R7]; 326 pcb->pcb_r8 = locr0[R8]; 327 pcb->pcb_r9 = locr0[R9]; 328 pcb->pcb_r10 = locr0[R10]; 329 pcb->pcb_r11 = locr0[R11]; 330 pcb->pcb_r12 = locr0[R12]; 331 pcb->pcb_fp = locr0[FP]; 332 pcb->pcb_usp = locr0[SP]; 333 pcb->pcb_pc = locr0[PC]; 334 pcb->pcb_psl = locr0[PS]; 335 pcb->pcb_ksp = mfpr(KSP); 336 pcb->pcb_p0br = (struct pte *)mfpr(P0BR); 337 pcb->pcb_p0lr = mfpr(P0LR); 338 pcb->pcb_p1br = (struct pte *)mfpr(P1BR); 339 pcb->pcb_p1lr = mfpr(P1LR); 340 pcb->pcb_p2br = (struct pte *)mfpr(P2BR); 341 pcb->pcb_p2lr = mfpr(P2LR); 342 pcb->pcb_ach = locr0[RACH]; 343 pcb->pcb_acl = locr0[RACL]; 344 } 345 346 static 347 setpcb(locr0) 348 register int *locr0; 349 { 350 extern struct pcb kdbpcb; 351 register struct pcb *pcb = &kdbpcb; 352 353 locr0[R0] = pcb->pcb_r0; 354 locr0[R1] = pcb->pcb_r1; 355 locr0[R2] = pcb->pcb_r2; 356 locr0[R3] = pcb->pcb_r3; 357 locr0[R4] = pcb->pcb_r4; 358 locr0[R5] = pcb->pcb_r5; 359 locr0[R6] = pcb->pcb_r6; 360 locr0[R7] = pcb->pcb_r7; 361 locr0[R8] = pcb->pcb_r8; 362 locr0[R9] = pcb->pcb_r9; 363 locr0[R10] = pcb->pcb_r10; 364 locr0[R11] = pcb->pcb_r11; 365 locr0[R12] = pcb->pcb_r12; 366 locr0[FP] = pcb->pcb_fp; 367 locr0[SP] = pcb->pcb_usp; 368 locr0[PC] = pcb->pcb_pc; 369 locr0[PS] = pcb->pcb_psl; 370 locr0[RACH] = pcb->pcb_ach; 371 locr0[RACL] = pcb->pcb_acl; 372 } 373