[apple/xnu.git] / osfmk / kern / xpr.c

/*
 * Copyright (c) 2000-2005 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@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
#include <mach_kdb.h>
/*
 * xpr silent tracing circular buffer.
 */

#include <mach/machine/vm_types.h>
#include <kern/xpr.h>
#include <kern/lock.h>
#include <kern/spl.h>
#include <kern/cpu_number.h>
#include <kern/misc_protos.h>
#include <kern/thread.h>
#include <vm/vm_kern.h>
#include <string.h>

/*
 *	After a spontaneous reboot, it is desirable to look
 *	at the old xpr buffer.  Assuming xprbootstrap allocates
 *	the buffer in the same place in physical memory and
 *	the reboot doesn't clear memory, this should work.
 *	xprptr will be reset, but the saved value should be OK.
 *	Just set xprenable false so the buffer isn't overwritten.
 */

decl_simple_lock_data(,xprlock)
boolean_t xprenable = TRUE;	/* Enable xpr tracing */
int nxprbufs = 0;	/* Number of contiguous xprbufs allocated */
int xprflags = 0;	/* Bit mask of xpr flags enabled */
struct xprbuf *xprbase;	/* Pointer to circular buffer nxprbufs*sizeof(xprbuf)*/
struct xprbuf *xprptr;	/* Currently allocated xprbuf */
struct xprbuf *xprlast;	/* Pointer to end of circular buffer */

void
xpr(
	const char	*msg,
	long		arg1,
	long		arg2,
	long		arg3,
	long		arg4,
	long		arg5)
{
	spl_t s;
	register struct xprbuf *x;

	/* If we aren't initialized, ignore trace request */
	if (!xprenable || (xprptr == 0))
		return;
	/* Guard against all interrupts and allocate next buffer. */

	s = splhigh();
	simple_lock(&xprlock);
	x = xprptr++;
	if (xprptr >= xprlast) {
		/* wrap around */
		xprptr = xprbase;
	}
	/* Save xprptr in allocated memory. */
	*(struct xprbuf **)xprlast = xprptr;
	simple_unlock(&xprlock);
	x->timestamp = XPR_TIMESTAMP;
	splx(s);
	x->msg = msg;
	x->arg1 = arg1;
	x->arg2 = arg2;
	x->arg3 = arg3;
	x->arg4 = arg4;
	x->arg5 = arg5;
	mp_disable_preemption();
	x->cpuinfo = cpu_number();
	mp_enable_preemption();
}

void 
xprbootstrap(void)
{
	vm_offset_t	addr;
	vm_size_t	size;
	kern_return_t	kr;

	simple_lock_init(&xprlock, 0);
	if (nxprbufs == 0)
		return;	/* assume XPR support not desired */

	/* leave room at the end for a saved copy of xprptr */
	size = nxprbufs * sizeof(struct xprbuf) + sizeof xprptr;

	kr = kmem_alloc_wired(kernel_map, &addr, size);
	if (kr != KERN_SUCCESS)
		panic("xprbootstrap");

	if (xprenable) {
		/*
		 *	If xprenable is set (the default) then we zero
		 *	the buffer so xpr_dump doesn't encounter bad pointers.
		 *	If xprenable isn't set, then we preserve
		 *	the original contents of the buffer.  This is useful
		 *	if memory survives reboots, so xpr_dump can show
		 *	the previous buffer contents.
		 */

		(void) memset((void *) addr, 0, size);
	}

	xprbase = (struct xprbuf *) addr;
	xprlast = &xprbase[nxprbufs];
	xprptr = xprbase;	/* setting xprptr enables tracing */
}

int		xprinitial = 0;

void
xprinit(void)
{
	xprflags |= xprinitial;
}

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

/*
 * Prototypes for functions called from the debugger
 */
void
xpr_dump(
	struct xprbuf	*base,
	int		nbufs);

void
xpr_search(
	int	arg_index,
	int	value);

extern jmp_buf_t *db_recover;

/*
 *	Print current content of xpr buffers (KDB's sake)
 *	Use stack order to make it understandable.
 *
 *	Called as "!xpr_dump" this dumps the kernel's xpr buffer.
 *	Called with arguments, it can dump xpr buffers in user tasks,
 *	assuming they use the same format as the kernel.
 */
static spl_t xpr_dump_spl;
static struct xprbuf *base;
static int nbufs;
void
xpr_dump(
	struct xprbuf	*_base,
	int		_nbufs)
{
	jmp_buf_t db_jmpbuf;
	jmp_buf_t *prev;
	struct xprbuf *last, *ptr;
	register struct xprbuf *x;
	int i;

	base = _base;
	nbufs = _nbufs;

	if (base == 0) {
		base = xprbase;
		nbufs = nxprbufs;
	}

	if (nbufs == 0)
		return;

	if (base == xprbase) {
		xpr_dump_spl = splhigh();
		simple_lock(&xprlock);
	}

	last = base + nbufs;
	ptr = * (struct xprbuf **) last;

	prev = db_recover;
	if (_setjmp(db_recover = &db_jmpbuf) == 0)
	    for (x = ptr, i = 0; i < nbufs; i++) {
		if (--x < base)
			x = last - 1;

		if (x->msg == 0)
			break;

		db_printf("<%d:%x:%x> ", x - base, x->cpuinfo, x->timestamp);
		db_printf(x->msg, x->arg1,x->arg2,x->arg3,x->arg4,x->arg5);
	    }
	db_recover = prev;

	if (base == xprbase) {
		simple_unlock(&xprlock);
		splx(xpr_dump_spl);
	}
}

/*
 * dump xpr table with a selection criteria.
 * argument number "arg_index" must equal "value"
 */

void
xpr_search(
	int	arg_index,
	int	value)
{
	jmp_buf_t db_jmpbuf;
	jmp_buf_t *prev;
	register struct xprbuf *x;
	spl_t s;
	int n;

	if (!nxprbufs)
		return;

	s = splhigh();
	simple_lock(&xprlock);

	prev = db_recover;
	if (_setjmp(db_recover = &db_jmpbuf) == 0) {
	    n = nxprbufs;

  	    for (x = *(struct xprbuf **)xprlast ; n--; ) {
		if (--x < xprbase)
			x = xprlast - 1;

		if (x->msg == 0) {
			break;
		}

		if (*((&x->arg1)+arg_index) != value)
			continue;

		db_printf("<%d:%d:%x> ", x - xprbase,
			  x->cpuinfo, x->timestamp);
		db_printf(x->msg, x->arg1,x->arg2,x->arg3,x->arg4,x->arg5);
	    }
	}
	db_recover = prev;

	simple_unlock(&xprlock);
	splx(s);
}
#endif	/* MACH_KDB */
Commit	Line	Data
1c79356b	1	/*
2d21ac55	2	* Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
8f6c56a5	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	*/
1c79356b A	31	/*
	32	* Mach Operating System
	33	* Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
	34	* All Rights Reserved.
	35	*
	36	* Permission to use, copy, modify and distribute this software and its
	37	* documentation is hereby granted, provided that both the copyright
	38	* notice and this permission notice appear in all copies of the
	39	* software, derivative works or modified versions, and any portions
	40	* thereof, and that both notices appear in supporting documentation.
	41	*
	42	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	43	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	44	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	45	*
	46	* Carnegie Mellon requests users of this software to return to
	47	*
	48	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	49	* School of Computer Science
	50	* Carnegie Mellon University
	51	* Pittsburgh PA 15213-3890
	52	*
	53	* any improvements or extensions that they make and grant Carnegie Mellon
	54	* the rights to redistribute these changes.
	55	*/
	56	#include <mach_kdb.h>
	57	/*
	58	* xpr silent tracing circular buffer.
	59	*/
	60
1c79356b A	61	#include <mach/machine/vm_types.h>
	62	#include <kern/xpr.h>
	63	#include <kern/lock.h>
	64	#include <kern/spl.h>
	65	#include <kern/cpu_number.h>
	66	#include <kern/misc_protos.h>
	67	#include <kern/thread.h>
	68	#include <vm/vm_kern.h>
	69	#include <string.h>
	70
	71	/*
	72	* After a spontaneous reboot, it is desirable to look
	73	* at the old xpr buffer. Assuming xprbootstrap allocates
	74	* the buffer in the same place in physical memory and
	75	* the reboot doesn't clear memory, this should work.
	76	* xprptr will be reset, but the saved value should be OK.
	77	* Just set xprenable false so the buffer isn't overwritten.
	78	*/
	79
	80	decl_simple_lock_data(,xprlock)
	81	boolean_t xprenable = TRUE; /* Enable xpr tracing */
	82	int nxprbufs = 0; /* Number of contiguous xprbufs allocated */
	83	int xprflags = 0; /* Bit mask of xpr flags enabled */
	84	struct xprbuf xprbase; / Pointer to circular buffer nxprbufssizeof(xprbuf)/
	85	struct xprbuf xprptr; / Currently allocated xprbuf */
	86	struct xprbuf xprlast; / Pointer to end of circular buffer */
	87
	88	void
	89	xpr(
91447636 A	90	const char *msg,
	91	long arg1,
	92	long arg2,
	93	long arg3,
	94	long arg4,
	95	long arg5)
1c79356b A	96	{
	97	spl_t s;
	98	register struct xprbuf *x;
	99
	100	/* If we aren't initialized, ignore trace request */
	101	if (!xprenable \|\| (xprptr == 0))
	102	return;
	103	/* Guard against all interrupts and allocate next buffer. */
	104
	105	s = splhigh();
	106	simple_lock(&xprlock);
	107	x = xprptr++;
	108	if (xprptr >= xprlast) {
	109	/* wrap around */
	110	xprptr = xprbase;
	111	}
	112	/* Save xprptr in allocated memory. */
	113	(struct xprbuf *)xprlast = xprptr;
	114	simple_unlock(&xprlock);
	115	x->timestamp = XPR_TIMESTAMP;
	116	splx(s);
	117	x->msg = msg;
	118	x->arg1 = arg1;
	119	x->arg2 = arg2;
	120	x->arg3 = arg3;
	121	x->arg4 = arg4;
	122	x->arg5 = arg5;
	123	mp_disable_preemption();
	124	x->cpuinfo = cpu_number();
	125	mp_enable_preemption();
	126	}
	127
	128	void
	129	xprbootstrap(void)
	130	{
	131	vm_offset_t addr;
	132	vm_size_t size;
	133	kern_return_t kr;
	134
91447636	135	simple_lock_init(&xprlock, 0);
1c79356b A	136	if (nxprbufs == 0)
	137	return; /* assume XPR support not desired */
	138
	139	/* leave room at the end for a saved copy of xprptr */
	140	size = nxprbufs * sizeof(struct xprbuf) + sizeof xprptr;
	141
	142	kr = kmem_alloc_wired(kernel_map, &addr, size);
	143	if (kr != KERN_SUCCESS)
	144	panic("xprbootstrap");
	145
	146	if (xprenable) {
	147	/*
	148	* If xprenable is set (the default) then we zero
	149	* the buffer so xpr_dump doesn't encounter bad pointers.
	150	* If xprenable isn't set, then we preserve
	151	* the original contents of the buffer. This is useful
	152	* if memory survives reboots, so xpr_dump can show
	153	* the previous buffer contents.
	154	*/
	155
	156	(void) memset((void *) addr, 0, size);
	157	}
	158
	159	xprbase = (struct xprbuf *) addr;
	160	xprlast = &xprbase[nxprbufs];
	161	xprptr = xprbase; /* setting xprptr enables tracing */
	162	}
	163
	164	int xprinitial = 0;
	165
	166	void
	167	xprinit(void)
	168	{
	169	xprflags \|= xprinitial;
	170	}
	171
	172	#if MACH_KDB
	173	#include <ddb/db_output.h>
	174
	175	/*
	176	* Prototypes for functions called from the debugger
	177	*/
	178	void
	179	xpr_dump(
	180	struct xprbuf *base,
	181	int nbufs);
	182
	183	void
	184	xpr_search(
	185	int arg_index,
	186	int value);
	187
	188	extern jmp_buf_t *db_recover;
	189
	190	/*
	191	* Print current content of xpr buffers (KDB's sake)
	192	* Use stack order to make it understandable.
	193	*
	194	* Called as "!xpr_dump" this dumps the kernel's xpr buffer.
	195	* Called with arguments, it can dump xpr buffers in user tasks,
	196	* assuming they use the same format as the kernel.
	197	*/
2d21ac55 A	198	static spl_t xpr_dump_spl;
	199	static struct xprbuf *base;
	200	static int nbufs;
1c79356b A	201	void
1c79356b A	202	xpr_dump(
2d21ac55 A	203	struct xprbuf *_base,
2d21ac55 A	204	int _nbufs)
1c79356b A	205	{
	206	jmp_buf_t db_jmpbuf;
	207	jmp_buf_t *prev;
	208	struct xprbuf last, ptr;
	209	register struct xprbuf *x;
	210	int i;
2d21ac55 A	211
	212	base = _base;
	213	nbufs = _nbufs;
1c79356b A	214
	215	if (base == 0) {
	216	base = xprbase;
	217	nbufs = nxprbufs;
	218	}
	219
	220	if (nbufs == 0)
	221	return;
	222
	223	if (base == xprbase) {
2d21ac55	224	xpr_dump_spl = splhigh();
1c79356b A	225	simple_lock(&xprlock);
	226	}
	227
	228	last = base + nbufs;
	229	ptr = * (struct xprbuf **) last;
	230
	231	prev = db_recover;
	232	if (_setjmp(db_recover = &db_jmpbuf) == 0)
	233	for (x = ptr, i = 0; i < nbufs; i++) {
	234	if (--x < base)
	235	x = last - 1;
	236
	237	if (x->msg == 0)
	238	break;
	239
	240	db_printf("<%d:%x:%x> ", x - base, x->cpuinfo, x->timestamp);
	241	db_printf(x->msg, x->arg1,x->arg2,x->arg3,x->arg4,x->arg5);
	242	}
	243	db_recover = prev;
	244
	245	if (base == xprbase) {
	246	simple_unlock(&xprlock);
2d21ac55	247	splx(xpr_dump_spl);
1c79356b A	248	}
	249	}
	250
	251	/*
	252	* dump xpr table with a selection criteria.
	253	* argument number "arg_index" must equal "value"
	254	*/
	255
	256	void
	257	xpr_search(
	258	int arg_index,
	259	int value)
	260	{
	261	jmp_buf_t db_jmpbuf;
	262	jmp_buf_t *prev;
	263	register struct xprbuf *x;
	264	spl_t s;
	265	int n;
	266
	267	if (!nxprbufs)
	268	return;
	269
1c79356b A	270	s = splhigh();
	271	simple_lock(&xprlock);
	272
	273	prev = db_recover;
cf7d32b8 A	274	if (_setjmp(db_recover = &db_jmpbuf) == 0) {
	275	n = nxprbufs;
	276
1c79356b A	277	for (x = (struct xprbuf *)xprlast ; n--; ) {
	278	if (--x < xprbase)
	279	x = xprlast - 1;
	280
	281	if (x->msg == 0) {
	282	break;
	283	}
	284
	285	if (*((&x->arg1)+arg_index) != value)
	286	continue;
	287
	288	db_printf("<%d:%d:%x> ", x - xprbase,
	289	x->cpuinfo, x->timestamp);
	290	db_printf(x->msg, x->arg1,x->arg2,x->arg3,x->arg4,x->arg5);
	291	}
cf7d32b8	292	}
1c79356b A	293	db_recover = prev;
	294
	295	simple_unlock(&xprlock);
	296	splx(s);
	297	}
	298	#endif /* MACH_KDB */