![[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 / Old|
Return to kdb_print.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kdb / Old |
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.16 (Berkeley) 5/3/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 *BADRAD;
19:
20: ADDR lastframe;
21: ADDR callpc;
22:
23: char *BADMOD;
24: char *lp;
25: long maxpos;
26: int radix;
27: char lastc;
28:
29: /* breakpoints */
30: BKPTR bkpthead;
31:
32: extern REGLIST reglist[];
33:
34: /* general printing routines ($) */
35:
36: printtrace(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 (cntflg==0)
49: cntval = -1;
50: switch (modif) {
51:
52: case 'd':
53: if (adrflg) {
54: if (adrval < 2 || adrval > 16)
55: error(BADRAD);
56: radix = adrval;
57: }
58: printf("radix=%d base ten", radix);
59: break;
60:
61: case 'w': case 'W':
62: printf("maxpos=%d", maxpos=(adrflg?adrval:MAXPOS));
63: break;
64:
65: case 's': case 'S':
66: printf("maxoff=%d", maxoff=(adrflg?adrval:MAXOFF));
67: break;
68:
69: case 'V':
70: printf("variables\n");
71: for (i=0;i<=35;i++)
72: if (var[i]) {
73: printc((i<=9 ? '0' : 'a'-10) + i);
74: printf(" = %R\n",var[i]);
75: }
76: break;
77:
78: case 0: case '?':
79: if (p = (struct proc *)var[varchk('p')])
80: printf("pid = %d\n", p->p_pid);
81: else
82: printf("in idle loop\n");
83: printtrap(var[varchk('t')], var[varchk('c')]);
84: /* fall thru... */
85: case 'r': case 'R':
86: printregs(modif);
87: return;
88:
89: case 'c': case 'C':
90: if (adrflg) {
91: frame = adrval;
92: callpc = getprevpc(frame);
93: } else {
94: frame = pcb.pcb_fp;
95: callpc = pcb.pcb_pc;
96: }
97: lastframe = NOFRAME;
98: ntramp = 0;
99: while (cntval-- && frame != NOFRAME) {
100: char *name;
101:
102: chkerr();
103: /* check for pc in pcb (signal trampoline code) */
104: if (issignalpc(callpc)) {
105: name = "sigtramp";
106: ntramp++;
107: } else {
108: ntramp = 0;
109: (void) findsym((long)callpc, ISYM);
110: if (cursym)
111: name = cursym->n_un.n_name;
112: else
113: name = "?";
114: }
115: printf("%s(", name);
116: narg = getnargs(frame);
117: if (narg > 10)
118: narg = 10;
119: argp = frame;
120: if (ntramp != 1)
121: while (narg) {
122: printf("%R",
123: get((off_t)(argp = nextarg(argp)),
124: DSP));
125: if (--narg != 0)
126: printc(',');
127: }
128: printf(") at ");
129: psymoff((long)callpc, ISYM, "\n");
130:
131: if (modif=='C') {
132: while (localsym((long)frame)) {
133: word = get((off_t)localval, DSP);
134: printf("%8t%s:%10t",
135: cursym->n_un.n_name);
136: if (errflg) {
137: printf("?\n");
138: errflg = 0;
139: } else
140: printf("%R\n", word);
141: }
142: }
143: if (ntramp != 1) {
144: callpc = getprevpc(frame);
145: lastframe = frame;
146: frame = getprevframe(frame);
147: } else
148: callpc = getsignalpc(lastframe);
149: if (!adrflg && !INSTACK(frame))
150: break;
151: }
152: break;
153:
154: /*print externals*/
155: case 'e': case 'E':
156: for (sp = symtab; sp < esymtab; sp++)
157: if (sp->n_type==(N_DATA|N_EXT) ||
158: sp->n_type==(N_BSS|N_EXT))
159: printf("%s:%12t%R\n", sp->n_un.n_name,
160: get((off_t)sp->n_value, DSP));
161: break;
162:
163: /*print breakpoints*/
164: case 'b': case 'B':
165: printf("breakpoints\ncount%8tbkpt%24tcommand\n");
166: for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
167: if (bkptr->flag) {
168: printf("%-8.8d",bkptr->count);
169: psymoff((long)bkptr->loc,ISYM,"%24t");
170: comptr=bkptr->comm;
171: while (*comptr)
172: printc(*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: printf("%X pid %5d%c%5d %c ", p, p->p_pid,
187: p == (struct proc *)var[varchk('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: psymoff((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: printf(" ctty %x ", U->u_ttyp);
203: #endif
204: printf(" %.8s ", p->p_comm);
205: #undef U
206: }
207:
208: printc(EOR);
209: }
210: mmap[0] = savemmap;
211: mtpr(TBIS, vmmap);
212: break;
213: }
214:
215: case 't': /* XXX - debug */
216: if (adrflg) {
217: printf("dev state rawq canq outq lwat hwat\n");
218:
219: #define T ((struct tty *)adrval)
220: printf("%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: printf(" &rawq &canq &outq &outq.c_cf &rawq.c_cf\n");
225: printf(" %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: printf("Locked vnodes\n");
236: mp = rootfs;
237: do {
238: for (vp = mp->m_mounth; vp; vp = vp->v_mountf)
239: if (VOP_ISLOCKED(vp))
240: vprint((char *)0, vp);
241: mp = mp->m_next;
242: } while (mp != rootfs);
243: break;
244: }
245:
246: default:
247: error(BADMOD);
248: }
249: }
250:
251: static
252: printregs(c)
253: {
254: register REGPTR p;
255: ADDR v;
256:
257: for (p = reglist; p->rname; p++) {
258: if (c != 'R' && ishiddenreg(p))
259: continue;
260: v = *p->rkern;
261: printf("%s%6t%R %16t", p->rname, v);
262: valpr((long)v, p->rkern == &pcb.pcb_pc ? ISYM : DSYM);
263: printc(EOR);
264: }
265: printpc();
266: }
267:
268: getreg(regnam)
269: {
270: register REGPTR p;
271: register char *regptr;
272: char *olp;
273:
274: olp = lp;
275: for (p = reglist; p->rname; p++) {
276: regptr = p->rname;
277: if (regnam == *regptr++) {
278: while (*regptr)
279: if (readchar() != *regptr++) {
280: --regptr;
281: break;
282: }
283: if (*regptr)
284: lp = olp;
285: else
286: return ((int)p->rkern);
287: }
288: }
289: lp = olp;
290: return (-1);
291: }
292:
293: printpc()
294: {
295:
296: psymoff((long)pcb.pcb_pc, ISYM, ":%16t");
297: printins(ISP, (long)chkget((off_t)pcb.pcb_pc, ISP));
298: printc(EOR);
299: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.