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.22 (Berkeley) 05/25/91 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("%lx 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 #ifdef DEBUG 166 case 'v': 167 printlockedvnodes(); 168 break; 169 #endif 170 171 default: 172 kdberror(kdbBADMOD); 173 } 174 } 175 176 static 177 kdbprintregs(c) 178 { 179 register REGPTR p; 180 ADDR v; 181 182 for (p = kdbreglist; p->rname; p++) { 183 if (c != 'R' && ishiddenreg(p)) 184 continue; 185 v = *p->rkern; 186 kdbprintf("%s%6t%R %16t", p->rname, v); 187 kdbvalpr((long)v, p->rkern == &kdbpcb.pcb_pc ? ISYM : DSYM); 188 kdbprintc(EOR); 189 } 190 kdbprintpc(); 191 } 192 193 kdbgetreg(regnam) 194 { 195 register REGPTR p; 196 register char *regptr; 197 char *olp; 198 199 olp = kdblp; 200 for (p = kdbreglist; p->rname; p++) { 201 regptr = p->rname; 202 if (regnam == *regptr++) { 203 while (*regptr) 204 if (kdbreadchar() != *regptr++) { 205 --regptr; 206 break; 207 } 208 if (*regptr) 209 kdblp = olp; 210 else 211 return ((int)p->rkern); 212 } 213 } 214 kdblp = olp; 215 return (-1); 216 } 217 218 kdbprintpc() 219 { 220 221 kdbpsymoff((long)kdbpcb.pcb_pc, ISYM, ":%16t"); 222 kdbprintins(ISP, (long)kdbchkget((off_t)kdbpcb.pcb_pc, ISP)); 223 kdbprintc(EOR); 224 } 225