![[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] / 43BSDReno / sys / vax|
Return to kdb_machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vax |
1.1 ! root 1: /* @(#)kdb_machdep.c 7.7 (Berkeley) 4/3/90 */ ! 2: ! 3: #include "param.h" ! 4: #include "conf.h" ! 5: #include "user.h" ! 6: #include "proc.h" ! 7: #include "uio.h" ! 8: #include "systm.h" ! 9: #include "reboot.h" ! 10: #include "vmmac.h" ! 11: #include "ioctl.h" ! 12: #include "tty.h" ! 13: ! 14: #include "cpu.h" ! 15: #include "mtpr.h" ! 16: #include "psl.h" ! 17: #include "pte.h" ! 18: #include "reg.h" ! 19: #include "trap.h" ! 20: #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 * ! 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: */ ! 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: */ ! 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 ! 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: */ ! 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: */ ! 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: */ ! 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: */ ! 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: */ ! 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: */ ! 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 ! 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 ! 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.