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
kdbprinttrace(modif)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
kdbprintregs(c)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
kdbgetreg(regnam)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
kdbprintpc()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