1 /* 2 * Copyright (c) 1986 Regents of the University of California. 3 * All rights reserved. The Berkeley software License Agreement 4 * specifies the terms and conditions for redistribution. 5 * 6 * @(#)kdb_print.c 7.18 (Berkeley) 05/04/90 7 */ 8 9 #include "machine/mtpr.h" 10 #undef ISP 11 #include "../kdb/defs.h" 12 #undef CTRL 13 #include "ioctl.h" 14 #include "tty.h" 15 #include "vnode.h" 16 #include "mount.h" 17 18 char *kdbBADRAD; 19 20 ADDR kdblastframe; 21 ADDR kdbcallpc; 22 23 char *kdbBADMOD; 24 char *kdblp; 25 long kdbmaxpos; 26 int kdbradix; 27 char kdblastc; 28 29 /* breakpoints */ 30 BKPTR kdbbkpthead; 31 32 extern REGLIST kdbreglist[]; 33 34 /* general printing routines ($) */ 35 36 kdbprinttrace(modif) 37 { 38 register narg, i; 39 register BKPTR bkptr; 40 register ADDR word; 41 register char *comptr; 42 register ADDR argp, frame; 43 register struct nlist *sp; 44 int ntramp; 45 register struct proc *p; 46 extern struct proc *allproc; 47 48 if (kdbcntflg==0) 49 kdbcntval = -1; 50 switch (modif) { 51 52 case 'd': 53 if (kdbadrflg) { 54 if (kdbadrval < 2 || kdbadrval > 16) 55 kdberror(kdbBADRAD); 56 kdbradix = kdbadrval; 57 } 58 kdbprintf("radix=%d base ten", kdbradix); 59 break; 60 61 case 'w': case 'W': 62 kdbprintf("maxpos=%d", kdbmaxpos=(kdbadrflg?kdbadrval:MAXPOS)); 63 break; 64 65 case 's': case 'S': 66 kdbprintf("maxoff=%d", kdbmaxoff=(kdbadrflg?kdbadrval:MAXOFF)); 67 break; 68 69 case 'V': 70 kdbprintf("variables\n"); 71 for (i=0;i<=35;i++) 72 if (kdbvar[i]) { 73 kdbprintc((i<=9 ? '0' : 'a'-10) + i); 74 kdbprintf(" = %R\n",kdbvar[i]); 75 } 76 break; 77 78 case 0: case '?': 79 if (p = (struct proc *)kdbvar[kdbvarchk('p')]) 80 kdbprintf("pid = %d\n", p->p_pid); 81 else 82 kdbprintf("in idle loop\n"); 83 kdbprinttrap(kdbvar[kdbvarchk('t')], kdbvar[kdbvarchk('c')]); 84 /* fall thru... */ 85 case 'r': case 'R': 86 kdbprintregs(modif); 87 return; 88 89 case 'c': case 'C': 90 if (kdbadrflg) { 91 frame = kdbadrval; 92 kdbcallpc = getprevpc(frame); 93 } else { 94 frame = kdbpcb.pcb_fp; 95 kdbcallpc = kdbpcb.pcb_pc; 96 } 97 kdblastframe = NOFRAME; 98 ntramp = 0; 99 while (kdbcntval-- && frame != NOFRAME) { 100 char *name; 101 102 kdbchkerr(); 103 /* check for pc in pcb (signal trampoline code) */ 104 if (issignalpc(kdbcallpc)) { 105 name = "sigtramp"; 106 ntramp++; 107 } else { 108 ntramp = 0; 109 (void) kdbfindsym((long)kdbcallpc, ISYM); 110 if (kdbcursym) 111 name = kdbcursym->n_un.n_name; 112 else 113 name = "?"; 114 } 115 kdbprintf("%s(", name); 116 narg = getnargs(frame); 117 if (narg > 10) 118 narg = 10; 119 argp = frame; 120 if (ntramp != 1) 121 while (narg) { 122 kdbprintf("%R", 123 kdbget((off_t)(argp = nextarg(argp)), 124 DSP)); 125 if (--narg != 0) 126 kdbprintc(','); 127 } 128 kdbprintf(") at "); 129 kdbpsymoff((long)kdbcallpc, ISYM, "\n"); 130 131 if (modif=='C') { 132 while (kdblocalsym((long)frame)) { 133 word = kdbget((off_t)kdblocalval, DSP); 134 kdbprintf("%8t%s:%10t", 135 kdbcursym->n_un.n_name); 136 if (kdberrflg) { 137 kdbprintf("?\n"); 138 kdberrflg = 0; 139 } else 140 kdbprintf("%R\n", word); 141 } 142 } 143 if (ntramp != 1) { 144 kdbcallpc = getprevpc(frame); 145 kdblastframe = frame; 146 frame = getprevframe(frame); 147 } else 148 kdbcallpc = getsignalpc(kdblastframe); 149 if (!kdbadrflg && !INSTACK(frame)) 150 break; 151 } 152 break; 153 154 /*print externals*/ 155 case 'e': case 'E': 156 for (sp = kdbsymtab; sp < kdbesymtab; sp++) 157 if (sp->n_type==(N_DATA|N_EXT) || 158 sp->n_type==(N_BSS|N_EXT)) 159 kdbprintf("%s:%12t%R\n", sp->n_un.n_name, 160 kdbget((off_t)sp->n_value, DSP)); 161 break; 162 163 /*print breakpoints*/ 164 case 'b': case 'B': 165 kdbprintf("breakpoints\ncount%8tbkpt%24tcommand\n"); 166 for (bkptr=kdbbkpthead; bkptr; bkptr=bkptr->nxtbkpt) 167 if (bkptr->flag) { 168 kdbprintf("%-8.8d",bkptr->count); 169 kdbpsymoff((long)bkptr->loc,ISYM,"%24t"); 170 comptr=bkptr->comm; 171 while (*comptr) 172 kdbprintc(*comptr++); 173 } 174 break; 175 176 case 'k': 177 panic("kdb requested panic"); 178 /* NOTREACHED */ 179 180 case 'l': { 181 struct pte savemmap; 182 extern char vmmap[]; 183 184 savemmap = mmap[0]; 185 for (p = allproc; p; p = p->p_nxt) { 186 kdbprintf("%X pid %5d%c%5d %c ", p, p->p_pid, 187 p == (struct proc *)kdbvar[kdbvarchk('p')]? '*' : ' ', 188 p->p_ppid, 189 p->p_stat == SSLEEP ? 'S' : 190 p->p_stat == SRUN ? 'R': 191 p->p_stat == SIDL ? 'I': 192 p->p_stat == SSTOP ? 'T' : '?'); 193 if (p->p_wchan) 194 kdbpsymoff((long)p->p_wchan, ISYM, ""); 195 if ((p->p_flag & SLOAD) && p->p_addr) { 196 int i; 197 *(int *)mmap = *(int *)p->p_addr; 198 mtpr(TBIS, vmmap); 199 #define U ((struct user *)vmmap) 200 #ifdef not_until_uarea_completely_mapped 201 if (U->u_ttyp) 202 kdbprintf(" ctty %x ", U->u_ttyp); 203 #endif 204 kdbprintf(" %.8s ", p->p_comm); 205 #undef U 206 } 207 208 kdbprintc(EOR); 209 } 210 mmap[0] = savemmap; 211 mtpr(TBIS, vmmap); 212 break; 213 } 214 215 case 't': /* XXX - debug */ 216 if (kdbadrflg) { 217 kdbprintf("dev state rawq canq outq lwat hwat\n"); 218 219 #define T ((struct tty *)kdbadrval) 220 kdbprintf("%x %x %d %d %d %d %d\n", T->t_dev, 221 T->t_state, T->t_rawq.c_cc, 222 T->t_canq.c_cc, T->t_outq.c_cc, 223 T->t_lowat, T->t_hiwat); 224 kdbprintf(" &rawq &canq &outq &outq.c_cf &rawq.c_cf\n"); 225 kdbprintf(" %x %x %x %x %x \n", &T->t_rawq, 226 &T->t_canq, &T->t_outq, &T->t_outq.c_cf, 227 &T->t_rawq.c_cf); 228 #undef T 229 } 230 231 case 'v': { 232 register struct mount *mp; 233 register struct vnode *vp; 234 235 kdbprintf("Locked vnodes\n"); 236 mp = rootfs; 237 do { 238 for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) 239 if (VOP_ISLOCKED(vp)) 240 vprint((char *)0, vp); 241 mp = mp->mnt_next; 242 } while (mp != rootfs); 243 break; 244 } 245 246 default: 247 kdberror(kdbBADMOD); 248 } 249 } 250 251 static 252 kdbprintregs(c) 253 { 254 register REGPTR p; 255 ADDR v; 256 257 for (p = kdbreglist; p->rname; p++) { 258 if (c != 'R' && ishiddenreg(p)) 259 continue; 260 v = *p->rkern; 261 kdbprintf("%s%6t%R %16t", p->rname, v); 262 kdbvalpr((long)v, p->rkern == &kdbpcb.pcb_pc ? ISYM : DSYM); 263 kdbprintc(EOR); 264 } 265 kdbprintpc(); 266 } 267 268 kdbgetreg(regnam) 269 { 270 register REGPTR p; 271 register char *regptr; 272 char *olp; 273 274 olp = kdblp; 275 for (p = kdbreglist; p->rname; p++) { 276 regptr = p->rname; 277 if (regnam == *regptr++) { 278 while (*regptr) 279 if (kdbreadchar() != *regptr++) { 280 --regptr; 281 break; 282 } 283 if (*regptr) 284 kdblp = olp; 285 else 286 return ((int)p->rkern); 287 } 288 } 289 kdblp = olp; 290 return (-1); 291 } 292 293 kdbprintpc() 294 { 295 296 kdbpsymoff((long)kdbpcb.pcb_pc, ISYM, ":%16t"); 297 kdbprintins(ISP, (long)kdbchkget((off_t)kdbpcb.pcb_pc, ISP)); 298 kdbprintc(EOR); 299 } 300