![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xpr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / kern|
Return to xpr.c CVS log | Up to [GnuMach] / Gnu-Mach / kern |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26:
27: #include <mach_kdb.h>
28: /*
29: * xpr silent tracing circular buffer.
30: */
31: #include <kern/xpr.h>
32: #include <kern/lock.h>
33: #include "cpu_number.h"
34: #include <machine/machspl.h>
35: #include <vm/vm_kern.h>
36:
37:
38: /*
39: * After a spontaneous reboot, it is desirable to look
40: * at the old xpr buffer. Assuming xprbootstrap allocates
41: * the buffer in the same place in physical memory and
42: * the reboot doesn't clear memory, this should work.
43: * xprptr will be reset, but the saved value should be OK.
44: * Just set xprenable false so the buffer isn't overwritten.
45: */
46:
47: decl_simple_lock_data(, xprlock)
48:
49: boolean_t xprenable = TRUE; /* Enable xpr tracing */
50: int nxprbufs = 0; /* Number of contiguous xprbufs allocated */
51: int xprflags = 0; /* Bit mask of xpr flags enabled */
52: struct xprbuf *xprbase; /* Pointer to circular buffer nxprbufs*sizeof(xprbuf)*/
53: struct xprbuf *xprptr; /* Currently allocated xprbuf */
54: struct xprbuf *xprlast; /* Pointer to end of circular buffer */
55:
56: /*VARARGS1*/
57: void xpr(msg, arg1, arg2, arg3, arg4, arg5)
58: char *msg;
59: int arg1, arg2, arg3, arg4, arg5;
60: {
61: register spl_t s;
62: register struct xprbuf *x;
63:
64: /* If we aren't initialized, ignore trace request */
65: if (!xprenable || (xprptr == 0))
66: return;
67: /* Guard against all interrupts and allocate next buffer. */
68: s = splhigh();
69: simple_lock(&xprlock);
70: x = xprptr++;
71: if (xprptr >= xprlast) {
72: /* wrap around */
73: xprptr = xprbase;
74: }
75: /* Save xprptr in allocated memory. */
76: *(struct xprbuf **)xprlast = xprptr;
77: simple_unlock(&xprlock);
78: splx(s);
79: x->msg = msg;
80: x->arg1 = arg1;
81: x->arg2 = arg2;
82: x->arg3 = arg3;
83: x->arg4 = arg4;
84: x->arg5 = arg5;
85: x->timestamp = XPR_TIMESTAMP;
86: x->cpuinfo = cpu_number();
87: }
88:
89: void xprbootstrap()
90: {
91: vm_offset_t addr;
92: vm_size_t size;
93: kern_return_t kr;
94:
95: simple_lock_init(&xprlock);
96: if (nxprbufs == 0)
97: return; /* assume XPR support not desired */
98:
99: /* leave room at the end for a saved copy of xprptr */
100: size = nxprbufs * sizeof(struct xprbuf) + sizeof xprptr;
101:
102: kr = kmem_alloc_wired(kernel_map, &addr, size);
103: if (kr != KERN_SUCCESS)
104: panic("xprbootstrap");
105:
106: if (xprenable) {
107: /*
108: * If xprenable is set (the default) then we zero
109: * the buffer so xpr_dump doesn't encounter bad pointers.
110: * If xprenable isn't set, then we preserve
111: * the original contents of the buffer. This is useful
112: * if memory survives reboots, so xpr_dump can show
113: * the previous buffer contents.
114: */
115:
116: bzero((char *) addr, size);
117: }
118:
119: xprbase = (struct xprbuf *) addr;
120: xprlast = &xprbase[nxprbufs];
121: xprptr = xprbase; /* setting xprptr enables tracing */
122: }
123:
124: int xprinitial = 0;
125:
126: void xprinit()
127: {
128: xprflags |= xprinitial;
129: }
130:
131: #if MACH_KDB
132: #include <machine/setjmp.h>
133:
134:
135: extern void db_printf();
136: extern jmp_buf_t *db_recover;
137:
138: /*
139: * Print current content of xpr buffers (KDB's sake)
140: * Use stack order to make it understandable.
141: *
142: * Called as "!xpr_dump" this dumps the kernel's xpr buffer.
143: * Called with arguments, it can dump xpr buffers in user tasks,
144: * assuming they use the same format as the kernel.
145: */
146: void xpr_dump(base, nbufs)
147: struct xprbuf *base;
148: int nbufs;
149: {
150: jmp_buf_t db_jmpbuf;
151: jmp_buf_t *prev;
152: struct xprbuf *last, *ptr;
153: register struct xprbuf *x;
154: int i;
155: spl_t s;
156:
157: if (base == 0) {
158: base = xprbase;
159: nbufs = nxprbufs;
160: }
161:
162: if (nbufs == 0)
163: return;
164:
165: if (base == xprbase) {
166: s = splhigh();
167: simple_lock(&xprlock);
168: }
169:
170: last = base + nbufs;
171: ptr = * (struct xprbuf **) last;
172:
173: prev = db_recover;
174: if (_setjmp(db_recover = &db_jmpbuf) == 0)
175: for (x = ptr, i = 0; i < nbufs; i++) {
176: if (--x < base)
177: x = last - 1;
178:
179: if (x->msg == 0)
180: break;
181:
182: db_printf("<%d:%x:%x> ", x - base, x->cpuinfo, x->timestamp);
183: db_printf(x->msg, x->arg1,x->arg2,x->arg3,x->arg4,x->arg5);
184: }
185: db_recover = prev;
186:
187: if (base == xprbase) {
188: simple_unlock(&xprlock);
189: (void) splx(s);
190: }
191: }
192: #endif MACH_KDB
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.