[apple/xnu.git] / osfmk / kperf / callstack.c

/*
 * Copyright (c) 2011 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@
 */

/* Collect kernel callstacks */

#include <mach/mach_types.h>
#include <machine/machine_routines.h>  /* XXX: remove me */
#include <kern/thread.h>

#include <chud/chud_xnu.h>

#include <kperf/buffer.h>
#include <kperf/context.h>
#include <kperf/callstack.h>
#include <kperf/ast.h>

static void
callstack_sample( struct callstack *cs, 
                  struct kperf_context *context,
                  uint32_t is_user )
{
	kern_return_t kr;
	mach_msg_type_number_t nframes; /* WTF with the type? */
	uint32_t code;

	if( is_user )
		code = PERF_CS_USAMPLE;
	else
		code = PERF_CS_KSAMPLE;

	BUF_INFO1( code, (uintptr_t)context->cur_thread );

	/* fill out known flags */
	cs->flags = 0;
	if( !is_user )
	{
		cs->flags |= CALLSTACK_KERNEL;
#ifdef __LP64__
		cs->flags |= CALLSTACK_64BIT;
#endif
	}
	else
	{
		/* FIXME: detect 32 vs 64-bit? */
	}

	/* collect the callstack */
	nframes = MAX_CALLSTACK_FRAMES;
	kr = chudxnu_thread_get_callstack64_kperf( context->cur_thread, 
						   cs->frames, 
						   &nframes,
						   is_user );

	/* check for overflow */
	if( kr == KERN_SUCCESS )
	{
		cs->flags |= CALLSTACK_VALID;
		cs->nframes = nframes;
	}
	else if( kr == KERN_RESOURCE_SHORTAGE )
	{
		/* FIXME: more here */
		cs->flags |= CALLSTACK_TRUNCATED;
		cs->flags |= CALLSTACK_VALID;
		cs->nframes = nframes;
	}
	else
	{
		BUF_INFO2(PERF_CS_ERROR, ERR_GETSTACK, kr);
		cs->nframes = 0;
	}

	if( cs->nframes >= MAX_CALLSTACK_FRAMES )
	{
		/* necessary? */
		BUF_INFO1(PERF_CS_ERROR, ERR_FRAMES);
		cs->nframes = 0;
	}

}

void
kperf_kcallstack_sample( struct callstack *cs, struct kperf_context *context )
{
	callstack_sample( cs, context, 0 );
}

void
kperf_ucallstack_sample( struct callstack *cs, struct kperf_context *context )
{
	callstack_sample( cs, context, 1 );
}

static void
callstack_log( struct callstack *cs, uint32_t hcode, uint32_t dcode )
{
	unsigned int i, j, n, of = 4;

	/* Header on the stack */
	BUF_DATA2( hcode, cs->flags, cs->nframes );

	/* look for how many batches of 4 */
	n  = cs->nframes / 4;
	of = cs->nframes % 4;
	if( of != 0 )
		n++;

	/* print all the stack data, and zero the overflow */
	for( i = 0; i < n; i++ )
	{
#define SCRUB_FRAME(x) (((x)<cs->nframes)?cs->frames[x]:0)
		j = i * 4;
		BUF_DATA ( dcode, 
		           SCRUB_FRAME(j+0),
		           SCRUB_FRAME(j+1),
		           SCRUB_FRAME(j+2),
		           SCRUB_FRAME(j+3) );
#undef SCRUB_FRAME
	}
}

void
kperf_kcallstack_log( struct callstack *cs )
{
	callstack_log( cs, PERF_CS_KHDR, PERF_CS_KDATA );
}

void
kperf_ucallstack_log( struct callstack *cs )
{
	callstack_log( cs, PERF_CS_UHDR, PERF_CS_UDATA );
}

int
kperf_ucallstack_pend( struct kperf_context * context )
{
	return kperf_ast_pend( context->cur_thread, T_AST_CALLSTACK,
	                       T_AST_CALLSTACK );
}

// 	kr = chudxnu_thread_get_callstack(context->generic->threadID, 
//              (uint32_t*)frames, &frameCount, !collectingSupervisorStack);
Commit	Line	Data
316670eb A	1	/*
	2	* Copyright (c) 2011 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	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.
	14	*
	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
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	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.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	/* Collect kernel callstacks */
	30
	31	#include <mach/mach_types.h>
	32	#include <machine/machine_routines.h> /* XXX: remove me */
	33	#include <kern/thread.h>
	34
	35	#include <chud/chud_xnu.h>
	36
	37	#include <kperf/buffer.h>
	38	#include <kperf/context.h>
	39	#include <kperf/callstack.h>
	40	#include <kperf/ast.h>
	41
	42	static void
	43	callstack_sample( struct callstack *cs,
	44	struct kperf_context *context,
	45	uint32_t is_user )
	46	{
	47	kern_return_t kr;
	48	mach_msg_type_number_t nframes; /* WTF with the type? */
	49	uint32_t code;
	50
	51	if( is_user )
	52	code = PERF_CS_USAMPLE;
	53	else
	54	code = PERF_CS_KSAMPLE;
	55
	56	BUF_INFO1( code, (uintptr_t)context->cur_thread );
	57
	58	/* fill out known flags */
	59	cs->flags = 0;
	60	if( !is_user )
	61	{
	62	cs->flags \|= CALLSTACK_KERNEL;
	63	#ifdef __LP64__
	64	cs->flags \|= CALLSTACK_64BIT;
65	#endif
66	}
67	else
68	{
69	/* FIXME: detect 32 vs 64-bit? */
70	}
71
72	/* collect the callstack */
73	nframes = MAX_CALLSTACK_FRAMES;
39236c6e A	74	kr = chudxnu_thread_get_callstack64_kperf( context->cur_thread,
	75	cs->frames,
	76	&nframes,
	77	is_user );
316670eb A	78
	79	/* check for overflow */
	80	if( kr == KERN_SUCCESS )
	81	{
	82	cs->flags \|= CALLSTACK_VALID;
	83	cs->nframes = nframes;
	84	}
	85	else if( kr == KERN_RESOURCE_SHORTAGE )
	86	{
	87	/* FIXME: more here */
	88	cs->flags \|= CALLSTACK_TRUNCATED;
	89	cs->flags \|= CALLSTACK_VALID;
	90	cs->nframes = nframes;
	91	}
	92	else
	93	{
39236c6e	94	BUF_INFO2(PERF_CS_ERROR, ERR_GETSTACK, kr);
316670eb A	95	cs->nframes = 0;
	96	}
	97
	98	if( cs->nframes >= MAX_CALLSTACK_FRAMES )
	99	{
	100	/* necessary? */
39236c6e	101	BUF_INFO1(PERF_CS_ERROR, ERR_FRAMES);
316670eb A	102	cs->nframes = 0;
	103	}
	104
	105	}
	106
	107	void
	108	kperf_kcallstack_sample( struct callstack cs, struct kperf_context context )
	109	{
	110	callstack_sample( cs, context, 0 );
	111	}
	112
	113	void
	114	kperf_ucallstack_sample( struct callstack cs, struct kperf_context context )
	115	{
	116	callstack_sample( cs, context, 1 );
	117	}
	118
	119	static void
39236c6e	120	callstack_log( struct callstack *cs, uint32_t hcode, uint32_t dcode )
316670eb A	121	{
	122	unsigned int i, j, n, of = 4;
	123
	124	/* Header on the stack */
39236c6e	125	BUF_DATA2( hcode, cs->flags, cs->nframes );
316670eb A	126
	127	/* look for how many batches of 4 */
	128	n = cs->nframes / 4;
	129	of = cs->nframes % 4;
	130	if( of != 0 )
	131	n++;
	132
	133	/* print all the stack data, and zero the overflow */
	134	for( i = 0; i < n; i++ )
	135	{
	136	#define SCRUB_FRAME(x) (((x)<cs->nframes)?cs->frames[x]:0)
	137	j = i * 4;
39236c6e	138	BUF_DATA ( dcode,
316670eb A	139	SCRUB_FRAME(j+0),
	140	SCRUB_FRAME(j+1),
	141	SCRUB_FRAME(j+2),
	142	SCRUB_FRAME(j+3) );
	143	#undef SCRUB_FRAME
	144	}
	145	}
	146
	147	void
	148	kperf_kcallstack_log( struct callstack *cs )
	149	{
39236c6e	150	callstack_log( cs, PERF_CS_KHDR, PERF_CS_KDATA );
316670eb A	151	}
	152
	153	void
	154	kperf_ucallstack_log( struct callstack *cs )
	155	{
39236c6e	156	callstack_log( cs, PERF_CS_UHDR, PERF_CS_UDATA );
316670eb A	157	}
	158
	159	int
	160	kperf_ucallstack_pend( struct kperf_context * context )
	161	{
	162	return kperf_ast_pend( context->cur_thread, T_AST_CALLSTACK,
	163	T_AST_CALLSTACK );
	164	}
	165
	166	// kr = chudxnu_thread_get_callstack(context->generic->threadID,
	167	// (uint32_t*)frames, &frameCount, !collectingSupervisorStack);