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

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_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	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
37839358 A	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.
1c79356b	11	*
37839358 A	12	* This Original Code and all software distributed under the License are
37839358 A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
37839358 A	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.
1c79356b A	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
91447636	91	simple_lock_init(&trace_lock, 0);
1c79356b A	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 */