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.20 (Berkeley) 12/16/90 7 */ 8 9 #include "machine/mtpr.h" 10 #undef ISP 11 #undef TB 12 #include "../kdb/defs.h" 13 #undef CTRL 14 #include "ioctl.h" 15 #include "tty.h" 16 #include "vnode.h" 17 #include "mount.h" 18 19 char *kdbBADRAD; 20 21 char *kdbBADMOD; 22 char *kdblp; 23 long kdbmaxpos; 24 int kdbradix; 25 char kdblastc; 26 27 /* breakpoints */ 28 BKPTR kdbbkpthead; 29 30 extern REGLIST kdbreglist[]; 31 32 /* general printing routines ($) */ 33 34 kdbprinttrace(modif) 35 { 36 register int i; 37 register BKPTR bkptr; 38 register char *comptr; 39 register struct nlist *sp; 40 register struct proc *p; 41 extern struct proc *allproc; 42 43 if (kdbcntflg==0) 44 kdbcntval = -1; 45 switch (modif) { 46 47 case 'd': 48 if (kdbadrflg) { 49 if (kdbadrval < 2 || kdbadrval > 16) 50 kdberror(kdbBADRAD); 51 kdbradix = kdbadrval; 52 } 53 kdbprintf("radix=%d base ten", kdbradix); 54 break; 55 56 case 'w': case 'W': 57 kdbprintf("maxpos=%d", kdbmaxpos=(kdbadrflg?kdbadrval:MAXPOS)); 58 break; 59 60 case 's': case 'S': 61 kdbprintf("maxoff=%d", kdbmaxoff=(kdbadrflg?kdbadrval:MAXOFF)); 62 break; 63 64 case 'V': 65 kdbprintf("variables\n"); 66 for (i=0;i<=35;i++) 67 if (kdbvar[i]) { 68 kdbprintc((i<=9 ? '0' : 'a'-10) + i); 69 kdbprintf(" = %R\n",kdbvar[i]); 70 } 71 break; 72 73 case 0: case '?': 74 if (p = (struct proc *)kdbvar[kdbvarchk('p')]) 75 kdbprintf("pid = %d\n", p->p_pid); 76 else 77 kdbprintf("in idle loop\n"); 78 kdbprinttrap(kdbvar[kdbvarchk('t')], kdbvar[kdbvarchk('c')]); 79 /* fall thru... */ 80 case 'r': case 'R': 81 kdbprintregs(modif); 82 return; 83 84 case 'c': case 'C': 85 kdbstacktrace(modif == 'C'); 86 break; 87 88 /*print externals*/ 89 case 'e': case 'E': 90 for (sp = kdbsymtab; sp < kdbesymtab; sp++) 91 if (sp->n_type==(N_DATA|N_EXT) || 92 sp->n_type==(N_BSS|N_EXT)) 93 kdbprintf("%s:%12t%R\n", sp->n_un.n_name, 94 kdbget((off_t)sp->n_value, DSP)); 95 break; 96 97 /*print breakpoints*/ 98 case 'b': case 'B': 99 kdbprintf("breakpoints\ncount%8tbkpt%24tcommand\n"); 100 for (bkptr=kdbbkpthead; bkptr; bkptr=bkptr->nxtbkpt) 101 if (bkptr->flag) { 102 kdbprintf("%-8.8d",bkptr->count); 103 kdbpsymoff((long)bkptr->loc,ISYM,"%24t"); 104 comptr=bkptr->comm; 105 while (*comptr) 106 kdbprintc(*comptr++); 107 } 108 break; 109 110 case 'k': 111 panic("kdb requested panic"); 112 /* NOTREACHED */ 113 114 case 'l': { 115 struct pte savemmap; 116 extern char vmmap[]; 117 118 savemmap = mmap[0]; 119 for (p = allproc; p; p = p->p_nxt) { 120 kdbprintf("%X pid %5d%c%5d %c ", p, p->p_pid, 121 p == (struct proc *)kdbvar[kdbvarchk('p')]? '*' : ' ', 122 p->p_ppid, 123 p->p_stat == SSLEEP ? 'S' : 124 p->p_stat == SRUN ? 'R': 125 p->p_stat == SIDL ? 'I': 126 p->p_stat == SSTOP ? 'T' : '?'); 127 if (p->p_wchan) 128 kdbpsymoff((long)p->p_wchan, ISYM, ""); 129 if ((p->p_flag & SLOAD) && p->p_addr) { 130 int i; 131 *(int *)mmap = *(int *)p->p_addr; 132 mtpr(TBIS, vmmap); 133 #define U ((struct user *)vmmap) 134 #ifdef not_until_uarea_completely_mapped 135 if (U->u_ttyp) 136 kdbprintf(" ctty %x ", U->u_ttyp); 137 #endif 138 kdbprintf(" %.8s ", p->p_comm); 139 #undef U 140 } 141 142 kdbprintc(EOR); 143 } 144 mmap[0] = savemmap; 145 mtpr(TBIS, vmmap); 146 break; 147 } 148 149 case 't': /* XXX - debug */ 150 if (kdbadrflg) { 151 kdbprintf("dev state rawq canq outq lwat hwat\n"); 152 153 #define T ((struct tty *)kdbadrval) 154 kdbprintf("%x %x %d %d %d %d %d\n", T->t_dev, 155 T->t_state, T->t_rawq.c_cc, 156 T->t_canq.c_cc, T->t_outq.c_cc, 157 T->t_lowat, T->t_hiwat); 158 kdbprintf(" &rawq &canq &outq &outq.c_cf &rawq.c_cf\n"); 159 kdbprintf(" %x %x %x %x %x \n", &T->t_rawq, 160 &T->t_canq, &T->t_outq, &T->t_outq.c_cf, 161 &T->t_rawq.c_cf); 162 #undef T 163 } 164 165 case 'v': { 166 register struct mount *mp; 167 register struct vnode *vp; 168 169 kdbprintf("Locked vnodes\n"); 170 mp = rootfs; 171 do { 172 for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) 173 if (VOP_ISLOCKED(vp)) 174 vprint((char *)0, vp); 175 mp = mp->mnt_next; 176 } while (mp != rootfs); 177 break; 178 } 179 180 default: 181 kdberror(kdbBADMOD); 182 } 183 } 184 185 static 186 kdbprintregs(c) 187 { 188 register REGPTR p; 189 ADDR v; 190 191 for (p = kdbreglist; p->rname; p++) { 192 if (c != 'R' && ishiddenreg(p)) 193 continue; 194 v = *p->rkern; 195 kdbprintf("%s%6t%R %16t", p->rname, v); 196 kdbvalpr((long)v, p->rkern == &kdbpcb.pcb_pc ? ISYM : DSYM); 197 kdbprintc(EOR); 198 } 199 kdbprintpc(); 200 } 201 202 kdbgetreg(regnam) 203 { 204 register REGPTR p; 205 register char *regptr; 206 char *olp; 207 208 olp = kdblp; 209 for (p = kdbreglist; p->rname; p++) { 210 regptr = p->rname; 211 if (regnam == *regptr++) { 212 while (*regptr) 213 if (kdbreadchar() != *regptr++) { 214 --regptr; 215 break; 216 } 217 if (*regptr) 218 kdblp = olp; 219 else 220 return ((int)p->rkern); 221 } 222 } 223 kdblp = olp; 224 return (-1); 225 } 226 227 kdbprintpc() 228 { 229 230 kdbpsymoff((long)kdbpcb.pcb_pc, ISYM, ":%16t"); 231 kdbprintins(ISP, (long)kdbchkget((off_t)kdbpcb.pcb_pc, ISP)); 232 kdbprintc(EOR); 233 } 234