[apple/xnu.git] / osfmk / ddb / tr.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/*
 *	File:		ddb/tr.c
 *	Authors:	Alan Langerman, Jeffrey Heller
 *	Date:		1992
 *
 *	Internal trace routines.  Like old-style XPRs but
 *	less formatting.
 */

#include <ddb/tr.h>

#if	TRACE_BUFFER
#include <string.h>
#include <ddb/db_command.h>
#include <mach_kdb.h>
#include <kern/lock.h>
#include <kern/spl.h>

extern void fc_get(int *);

/*
 *	Primitive event tracing facility for kernel debugging.  Yes,
 *	this has some resemblance to XPRs.  However, it is primarily
 *	intended for post-mortem analysis through ddb.
 */

#define	TRACE_MAX	(4 * 1024)
#define	TRACE_WINDOW	40

typedef struct trace_event {
	char		*funcname;
	char		*file;
	char		*fmt;
#if	NCPUS > 1
	char		cpu_number;
#endif	/* NCPUS > 1 */
	unsigned int	lineno;
	unsigned int	tag1;
	unsigned int	tag2;
	unsigned int	tag3;
	unsigned int	tag4;
	int		indent;
	int		timestamp[2]; /* largest needed by any clock */
} trace_event;

trace_event	trace_buffer[TRACE_MAX];
unsigned long	trace_index;
#if	NCPUS == 1
int 		tr_indent = 0;
#else	/* NCPUS == 1 */
int 		tr_indent[NCPUS];
int		tr_limit = -1;
#endif	/* NCPUS == 1 */

decl_simple_lock_data(,trace_lock)

void
tr_init(void)
{
#if	NCPUS > 1
	int i;

	for(i=0;i<NCPUS;i++)
	    tr_indent[i]=0;
#endif	/* NCPUS > 1 */

	simple_lock_init(&trace_lock, 0);
}

void
tr(
	char		*funcname,
	char		*file,
	unsigned int	lineno,
	char		*fmt,
	unsigned int	tag1,
	unsigned int	tag2,
	unsigned int	tag3,
	unsigned int	tag4)
{
	int	s;
	register unsigned long ti, tn;
#if	NCPUS > 1
	char cpu;
#endif	/* NCPUS > 1 */

#if	PARAGON860
	/*
	 * The following loop replaces the spl_and_lock sequence that
	 * would normally be here, as they are too heavy weight.  The
	 * cmpsw (compare-and-swap) call returns -1 if unsuccessful.
	 */
	do {
		ti = trace_index;
		tn = ti + 1;
		if (tn >= TRACE_MAX - 1)
			tn = 0;
	} while (cmpsw(ti, tn, &trace_index) == -1);
	fc_get(trace_buffer[ti].timestamp);
#else	/* PARAGON860 */
	/*
	 * Until someone does a cmpsw for other platforms, do it
	 * the slow way
	 */
	s = splimp();
	simple_lock(&trace_lock);

	ti = trace_index++;
	if (trace_index >= TRACE_MAX - 1)
		trace_index = 0;

	simple_unlock(&trace_lock);
	splx(s);

	fc_get(trace_buffer[ti].timestamp);
/*	get_uniq_timestamp(trace_buffer[ti].timestamp);*/
#endif	/* PARAGON860 */

	trace_buffer[ti].funcname = funcname;
	trace_buffer[ti].file = file;
	trace_buffer[ti].lineno = lineno;
	trace_buffer[ti].fmt = fmt;
	trace_buffer[ti].tag1 = tag1;
	trace_buffer[ti].tag2 = tag2;
	trace_buffer[ti].tag3 = tag3;
	trace_buffer[ti].tag4 = tag4;
#if	NCPUS == 1
	trace_buffer[ti].indent = tr_indent;
#else	/* NCPUS == 1 */
	mp_disable_preemption();
	cpu = cpu_number();
	trace_buffer[ti].indent = tr_indent[cpu];
	trace_buffer[ti].cpu_number = cpu;
	mp_enable_preemption();
#endif	/* NCPUS == 1 */
}

#if	MACH_KDB
#include <ddb/db_output.h>

/*
 * Forward.
 */
void	show_tr(
		unsigned long	index,
		unsigned long	range,
		unsigned long	show_extra);

int	matches(
		char	*pattern,
		char	*target);

void	parse_tr(
		unsigned long	index,
		unsigned long	range);

/*
 *	The blank array must be a bit bigger than
 *	MAX_BLANKS to leave room for a terminating NULL.
 */
#define	MAX_BLANKS	16
char			blanks[MAX_BLANKS+4];

void
show_tr(
	unsigned long	index,
	unsigned long	range,
	unsigned long	show_extra)
{
	char		*filename, *cp;
#if	PARAGON860
	trace_event	*last_trace;
#endif	/* PARAGON860 */
	unsigned int	level;
	int		old_history;
	int		i;

	if (index == -1) {
		index = trace_index - (TRACE_WINDOW-4);
		range = TRACE_WINDOW;
	} else if (index == 0) {
		index = trace_index - (TRACE_WINDOW-4);
		range = TRACE_WINDOW;
		show_extra = 0;
	}
	if (index + range > TRACE_MAX)
		range = TRACE_MAX - index;
#if	PARAGON860
	last_trace = &trace_buffer[index-1];
#endif	/* PARAGON860 */
	level = trace_buffer[index-1].indent;
	/*
	 * Set up the indentation buffer
	 */
	memset(blanks, ' ', trace_buffer[index].indent);
	blanks[trace_buffer[index].indent] = '\0';
	for (i = index; i < index + range; ++i) {
#if	NCPUS > 1
		if ((tr_limit != -1) &&
		    (trace_buffer[i].cpu_number != tr_limit))
		    continue;
#endif	/* NCPUS > 1 */
		if (trace_buffer[i].file == (char *) 0 ||
		    trace_buffer[i].funcname == (char *) 0 ||
		    trace_buffer[i].lineno == 0 ||
		    trace_buffer[i].fmt == 0) {
			db_printf("[%04x%s]\n", i,
				  i >= trace_index ? "*" : "");
			continue;
		}

		old_history = (i >= trace_index);

		/*
		 * Adjust the blank count if necessary
		 */
		if (level != trace_buffer[i].indent) {
			level = trace_buffer[i].indent;
			if (level >= MAX_BLANKS)
				level = MAX_BLANKS;
			memset(blanks, ' ', level);
			blanks[level] = '\0';
		} 

		for (cp = trace_buffer[i].file; *cp; ++cp)
			if (*cp == '/')
				filename = cp + 1;
#if	NCPUS > 1
		db_printf("{%02d}",trace_buffer[i].cpu_number);
#endif	/* NCPUS > 1 */
		db_printf("[%04x%s] %s%-16s", i, old_history ? "*" : "",
			  blanks, trace_buffer[i].funcname);

		if (show_extra) {
			if (show_extra > 0) {
				db_printf(" (%x/%8x)", 
					  trace_buffer[i].timestamp[0],
					  trace_buffer[i].timestamp[1]);
#if	PARAGON860
				/*
				 *	For Paragon only, we compute and
				 *	print out deltas on the timestamps
				 *	accumulated in the tr buffer.  One
				 *	interesting case:  it is meaningless
				 *	to compute this delta for the last
				 *	current entry in the log.
				 */
				if (old_history &&
				    ((last_trace - trace_buffer)
				     < trace_index))
					db_printf("(N/A)");
				else
					db_printf("(%d)", 
						  timer_subtime(
						     trace_buffer[i].timestamp,
						     last_trace->timestamp));
#endif	/*PARAGON860*/
				db_printf(" ");
			}
			if (show_extra > 1) {
				db_printf("(%s:%05d):\n\t", 
					  filename, trace_buffer[i].lineno);
			}
		} else
			db_printf(":  ");
		db_printf(trace_buffer[i].fmt, trace_buffer[i].tag1,
			  trace_buffer[i].tag2, trace_buffer[i].tag3,
			  trace_buffer[i].tag4);
		db_printf("\n");
#if	PARAGON860
		last_trace = &trace_buffer[i];
#endif	/* PARAGON860 */
	}
}


int
matches(
	char	*pattern,
	char	*target)
{
	char	*cp, *cp1, *cp2;

	for (cp = target; *cp; ++cp) {
		for (cp2 = pattern, cp1 = cp; *cp2 && *cp1; ++cp2, ++cp1)
			if (*cp2 != *cp1)
				break;
		if (!*cp2)
			return 1;
	}
	return 0;
}


char	parse_tr_buffer[100] = "KMSG";

void
parse_tr(
	unsigned long	index,
	unsigned long	range)
{
	int		i;
	char		*filename, *cp;
	char		*string = parse_tr_buffer;

	if (index == 0) {
		index = trace_index - (TRACE_WINDOW-4);
		range = TRACE_WINDOW;
	}
	if (index + range > TRACE_MAX)
		range = TRACE_MAX - index;
	for (i = index; i < index + range; ++i) {
#if	NCPUS > 1
		if ((tr_limit != -1) &&
		    (trace_buffer[i].cpu_number != tr_limit))
		    continue;
#endif	/* NCPUS > 1 */
		if (trace_buffer[i].file == (char *) 0 ||
		    trace_buffer[i].funcname == (char *) 0 ||
		    trace_buffer[i].lineno == 0 ||
		    trace_buffer[i].fmt == 0) {
			db_printf("[%04x%s]\n", i,
				  i >= trace_index ? "*" : "");
			continue;
		}
		if (!matches(string, trace_buffer[i].fmt))
			continue;
		for (cp = trace_buffer[i].file; *cp; ++cp)
			if (*cp == '/')
				filename = cp + 1;
#if	NCPUS > 1
		db_printf("{%02d}",trace_buffer[i].cpu_number);
#endif	/* NCPUS > 1 */
		db_printf("[%04x%s] %s", i, i >= trace_index ? "*" : "",
		       trace_buffer[i].funcname);
		db_printf(":  ");
		db_printf(trace_buffer[i].fmt, trace_buffer[i].tag1,
			  trace_buffer[i].tag2, trace_buffer[i].tag3,
			  trace_buffer[i].tag4);
		db_printf("\n");
	}
}


void
db_show_tr(
	db_expr_t	addr,
	boolean_t	have_addr,
	db_expr_t	count,
	char *		modif)
{
	int		flag, level;

	flag = 0, level = 0;
	if (db_option(modif, 'l')) {
		flag = 1;
		level = -1;
	}
	if (db_option(modif, 'a')) {
		flag = 2;
		level = -1;
	}

	TR_SHOW(level, 0, flag);
}

#endif	/* MACH_KDB */

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