![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ddb|
Return to tr.c CVS log | Up to [Apple XNU] / XNU / osfmk / ddb |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * File: ddb/tr.c
27: * Authors: Alan Langerman, Jeffrey Heller
28: * Date: 1992
29: *
30: * Internal trace routines. Like old-style XPRs but
31: * less formatting.
32: */
33:
34: #include <ddb/tr.h>
35:
36: #if TRACE_BUFFER
37: #include <string.h>
38: #include <ddb/db_command.h>
39: #include <mach_kdb.h>
40: #include <kern/lock.h>
41: #include <kern/spl.h>
42:
43: extern void fc_get(int *);
44:
45: /*
46: * Primitive event tracing facility for kernel debugging. Yes,
47: * this has some resemblance to XPRs. However, it is primarily
48: * intended for post-mortem analysis through ddb.
49: */
50:
51: #define TRACE_MAX (4 * 1024)
52: #define TRACE_WINDOW 40
53:
54: typedef struct trace_event {
55: char *funcname;
56: char *file;
57: char *fmt;
58: #if NCPUS > 1
59: char cpu_number;
60: #endif /* NCPUS > 1 */
61: unsigned int lineno;
62: unsigned int tag1;
63: unsigned int tag2;
64: unsigned int tag3;
65: unsigned int tag4;
66: int indent;
67: int timestamp[2]; /* largest needed by any clock */
68: } trace_event;
69:
70: trace_event trace_buffer[TRACE_MAX];
71: unsigned long trace_index;
72: #if NCPUS == 1
73: int tr_indent = 0;
74: #else /* NCPUS == 1 */
75: int tr_indent[NCPUS];
76: int tr_limit = -1;
77: #endif /* NCPUS == 1 */
78:
79: decl_simple_lock_data(,trace_lock)
80:
81: void
82: tr_init(void)
83: {
84: #if NCPUS > 1
85: int i;
86:
87: for(i=0;i<NCPUS;i++)
88: tr_indent[i]=0;
89: #endif /* NCPUS > 1 */
90:
91: simple_lock_init(&trace_lock, ETAP_DIPC_TRACE);
92: }
93:
94: void
95: tr(
96: char *funcname,
97: char *file,
98: unsigned int lineno,
99: char *fmt,
100: unsigned int tag1,
101: unsigned int tag2,
102: unsigned int tag3,
103: unsigned int tag4)
104: {
105: int s;
106: register unsigned long ti, tn;
107: #if NCPUS > 1
108: char cpu;
109: #endif /* NCPUS > 1 */
110:
111: #if PARAGON860
112: /*
113: * The following loop replaces the spl_and_lock sequence that
114: * would normally be here, as they are too heavy weight. The
115: * cmpsw (compare-and-swap) call returns -1 if unsuccessful.
116: */
117: do {
118: ti = trace_index;
119: tn = ti + 1;
120: if (tn >= TRACE_MAX - 1)
121: tn = 0;
122: } while (cmpsw(ti, tn, &trace_index) == -1);
123: fc_get(trace_buffer[ti].timestamp);
124: #else /* PARAGON860 */
125: /*
126: * Until someone does a cmpsw for other platforms, do it
127: * the slow way
128: */
129: s = splimp();
130: simple_lock(&trace_lock);
131:
132: ti = trace_index++;
133: if (trace_index >= TRACE_MAX - 1)
134: trace_index = 0;
135:
136: simple_unlock(&trace_lock);
137: splx(s);
138:
139: fc_get(trace_buffer[ti].timestamp);
140: /* get_uniq_timestamp(trace_buffer[ti].timestamp);*/
141: #endif /* PARAGON860 */
142:
143: trace_buffer[ti].funcname = funcname;
144: trace_buffer[ti].file = file;
145: trace_buffer[ti].lineno = lineno;
146: trace_buffer[ti].fmt = fmt;
147: trace_buffer[ti].tag1 = tag1;
148: trace_buffer[ti].tag2 = tag2;
149: trace_buffer[ti].tag3 = tag3;
150: trace_buffer[ti].tag4 = tag4;
151: #if NCPUS == 1
152: trace_buffer[ti].indent = tr_indent;
153: #else /* NCPUS == 1 */
154: mp_disable_preemption();
155: cpu = cpu_number();
156: trace_buffer[ti].indent = tr_indent[cpu];
157: trace_buffer[ti].cpu_number = cpu;
158: mp_enable_preemption();
159: #endif /* NCPUS == 1 */
160: }
161:
162: #if MACH_KDB
163: #include <ddb/db_output.h>
164:
165: /*
166: * Forward.
167: */
168: void show_tr(
169: unsigned long index,
170: unsigned long range,
171: unsigned long show_extra);
172:
173: int matches(
174: char *pattern,
175: char *target);
176:
177: void parse_tr(
178: unsigned long index,
179: unsigned long range);
180:
181: /*
182: * The blank array must be a bit bigger than
183: * MAX_BLANKS to leave room for a terminating NULL.
184: */
185: #define MAX_BLANKS 16
186: char blanks[MAX_BLANKS+4];
187:
188: void
189: show_tr(
190: unsigned long index,
191: unsigned long range,
192: unsigned long show_extra)
193: {
194: char *filename, *cp;
195: #if PARAGON860
196: trace_event *last_trace;
197: #endif /* PARAGON860 */
198: unsigned int level;
199: int old_history;
200: int i;
201:
202: if (index == -1) {
203: index = trace_index - (TRACE_WINDOW-4);
204: range = TRACE_WINDOW;
205: } else if (index == 0) {
206: index = trace_index - (TRACE_WINDOW-4);
207: range = TRACE_WINDOW;
208: show_extra = 0;
209: }
210: if (index + range > TRACE_MAX)
211: range = TRACE_MAX - index;
212: #if PARAGON860
213: last_trace = &trace_buffer[index-1];
214: #endif /* PARAGON860 */
215: level = trace_buffer[index-1].indent;
216: /*
217: * Set up the indentation buffer
218: */
219: memset(blanks, ' ', trace_buffer[index].indent);
220: blanks[trace_buffer[index].indent] = '\0';
221: for (i = index; i < index + range; ++i) {
222: #if NCPUS > 1
223: if ((tr_limit != -1) &&
224: (trace_buffer[i].cpu_number != tr_limit))
225: continue;
226: #endif /* NCPUS > 1 */
227: if (trace_buffer[i].file == (char *) 0 ||
228: trace_buffer[i].funcname == (char *) 0 ||
229: trace_buffer[i].lineno == 0 ||
230: trace_buffer[i].fmt == 0) {
231: db_printf("[%04x%s]\n", i,
232: i >= trace_index ? "*" : "");
233: continue;
234: }
235:
236: old_history = (i >= trace_index);
237:
238: /*
239: * Adjust the blank count if necessary
240: */
241: if (level != trace_buffer[i].indent) {
242: level = trace_buffer[i].indent;
243: if (level >= MAX_BLANKS)
244: level = MAX_BLANKS;
245: memset(blanks, ' ', level);
246: blanks[level] = '\0';
247: }
248:
249: for (cp = trace_buffer[i].file; *cp; ++cp)
250: if (*cp == '/')
251: filename = cp + 1;
252: #if NCPUS > 1
253: db_printf("{%02d}",trace_buffer[i].cpu_number);
254: #endif /* NCPUS > 1 */
255: db_printf("[%04x%s] %s%-16s", i, old_history ? "*" : "",
256: blanks, trace_buffer[i].funcname);
257:
258: if (show_extra) {
259: if (show_extra > 0) {
260: db_printf(" (%x/%8x)",
261: trace_buffer[i].timestamp[0],
262: trace_buffer[i].timestamp[1]);
263: #if PARAGON860
264: /*
265: * For Paragon only, we compute and
266: * print out deltas on the timestamps
267: * accumulated in the tr buffer. One
268: * interesting case: it is meaningless
269: * to compute this delta for the last
270: * current entry in the log.
271: */
272: if (old_history &&
273: ((last_trace - trace_buffer)
274: < trace_index))
275: db_printf("(N/A)");
276: else
277: db_printf("(%d)",
278: timer_subtime(
279: trace_buffer[i].timestamp,
280: last_trace->timestamp));
281: #endif /*PARAGON860*/
282: db_printf(" ");
283: }
284: if (show_extra > 1) {
285: db_printf("(%s:%05d):\n\t",
286: filename, trace_buffer[i].lineno);
287: }
288: } else
289: db_printf(": ");
290: db_printf(trace_buffer[i].fmt, trace_buffer[i].tag1,
291: trace_buffer[i].tag2, trace_buffer[i].tag3,
292: trace_buffer[i].tag4);
293: db_printf("\n");
294: #if PARAGON860
295: last_trace = &trace_buffer[i];
296: #endif /* PARAGON860 */
297: }
298: }
299:
300:
301: int
302: matches(
303: char *pattern,
304: char *target)
305: {
306: char *cp, *cp1, *cp2;
307:
308: for (cp = target; *cp; ++cp) {
309: for (cp2 = pattern, cp1 = cp; *cp2 && *cp1; ++cp2, ++cp1)
310: if (*cp2 != *cp1)
311: break;
312: if (!*cp2)
313: return 1;
314: }
315: return 0;
316: }
317:
318:
319: char parse_tr_buffer[100] = "KMSG";
320:
321: void
322: parse_tr(
323: unsigned long index,
324: unsigned long range)
325: {
326: int i;
327: char *filename, *cp;
328: char *string = parse_tr_buffer;
329:
330: if (index == 0) {
331: index = trace_index - (TRACE_WINDOW-4);
332: range = TRACE_WINDOW;
333: }
334: if (index + range > TRACE_MAX)
335: range = TRACE_MAX - index;
336: for (i = index; i < index + range; ++i) {
337: #if NCPUS > 1
338: if ((tr_limit != -1) &&
339: (trace_buffer[i].cpu_number != tr_limit))
340: continue;
341: #endif /* NCPUS > 1 */
342: if (trace_buffer[i].file == (char *) 0 ||
343: trace_buffer[i].funcname == (char *) 0 ||
344: trace_buffer[i].lineno == 0 ||
345: trace_buffer[i].fmt == 0) {
346: db_printf("[%04x%s]\n", i,
347: i >= trace_index ? "*" : "");
348: continue;
349: }
350: if (!matches(string, trace_buffer[i].fmt))
351: continue;
352: for (cp = trace_buffer[i].file; *cp; ++cp)
353: if (*cp == '/')
354: filename = cp + 1;
355: #if NCPUS > 1
356: db_printf("{%02d}",trace_buffer[i].cpu_number);
357: #endif /* NCPUS > 1 */
358: db_printf("[%04x%s] %s", i, i >= trace_index ? "*" : "",
359: trace_buffer[i].funcname);
360: db_printf(": ");
361: db_printf(trace_buffer[i].fmt, trace_buffer[i].tag1,
362: trace_buffer[i].tag2, trace_buffer[i].tag3,
363: trace_buffer[i].tag4);
364: db_printf("\n");
365: }
366: }
367:
368:
369: void
370: db_show_tr(
371: db_expr_t addr,
372: boolean_t have_addr,
373: db_expr_t count,
374: char * modif)
375: {
376: int flag, level;
377:
378: flag = 0, level = 0;
379: if (db_option(modif, 'l')) {
380: flag = 1;
381: level = -1;
382: }
383: if (db_option(modif, 'a')) {
384: flag = 2;
385: level = -1;
386: }
387:
388: TR_SHOW(level, 0, flag);
389: }
390:
391: #endif /* MACH_KDB */
392:
393: #endif /* TRACE_BUFFER */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.