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