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

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

/*
 * Sample KPC data into kperf and manage shared context-switch and AST handlers
 */

#include <kperf/kperf.h>
#include <kperf/buffer.h>
#include <kperf/context.h>
#include <kperf/pet.h>
#include <kperf/kperf_kpc.h>
#include <kern/kpc.h> /* kpc_cswitch_context, kpc_threads_counting */

void
kperf_kpc_thread_ast(thread_t thread)
{
	kpc_thread_ast_handler(thread);
	kperf_thread_ast_handler(thread);

	thread->kperf_flags = 0;
}

void
kperf_kpc_thread_sample(struct kpcdata *kpcd, int sample_config)
{
	BUF_INFO(PERF_KPC_THREAD_SAMPLE | DBG_FUNC_START, sample_config);

	kpcd->running = kpc_get_running();
	/* let kpc_get_curthread_counters set the correct count */
	kpcd->counterc = KPC_MAX_COUNTERS;
	if (kpc_get_curthread_counters(&kpcd->counterc,
	    kpcd->counterv)) {
		/* if thread counters aren't ready, default to 0 */
		memset(kpcd->counterv, 0,
		    sizeof(uint64_t) * kpcd->counterc);
	}
	/* help out Instruments by sampling KPC's config */
	if (!sample_config) {
		kpcd->configc = 0;
	} else {
		kpcd->configc = kpc_get_config_count(kpcd->running);
		kpc_get_config(kpcd->running, kpcd->configv);
	}

	BUF_INFO(PERF_KPC_THREAD_SAMPLE | DBG_FUNC_END, kpcd->running, kpcd->counterc);
}

void
kperf_kpc_cpu_sample(struct kpcdata *kpcd, int sample_config)
{
	BUF_INFO(PERF_KPC_CPU_SAMPLE | DBG_FUNC_START, sample_config);

	kpcd->running  = kpc_get_running();
	kpcd->counterc = kpc_get_cpu_counters(0, kpcd->running,
	    &kpcd->curcpu,
	    kpcd->counterv);
	if (!sample_config) {
		kpcd->configc = 0;
	} else {
		kpcd->configc = kpc_get_config_count(kpcd->running);
		kpc_get_config(kpcd->running, kpcd->configv);
	}

	BUF_INFO(PERF_KPC_CPU_SAMPLE | DBG_FUNC_END, kpcd->running, kpcd->counterc);
}

void
kperf_kpc_config_log(const struct kpcdata *kpcd)
{
	BUF_DATA(PERF_KPC_CONFIG,
	    kpcd->running,
	    kpcd->counterc,
	    kpc_get_counter_count(KPC_CLASS_FIXED_MASK),
	    kpcd->configc);

#if __LP64__
	unsigned int max = (kpcd->configc + 3) / 4;
	for (unsigned int i = 0; i < max; i++) {
		uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
		BUF_DATA(PERF_KPC_CFG_REG | flag,
		    kpcd->configv[0 + i * 4], kpcd->configv[1 + i * 4],
		    kpcd->configv[2 + i * 4], kpcd->configv[3 + i * 4]);
	}
#else /* __LP64__ */
	unsigned int max = (kpcd->configc + 1) / 2;
	for (unsigned int i = 0; i < max; i++) {
		uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
		BUF_DATA(PERF_KPC_CFG_REG32 | flag,
		    kpcd->configv[i * 2] >> 32ULL,
		    kpcd->configv[i * 2] & 0xffffffffULL,
		    kpcd->configv[i * 2 + 1] >> 32ULL,
		    kpcd->configv[i * 2 + 1] & 0xffffffffULL);
	}
#endif /* !__LP64__ */
}

static void
kperf_kpc_log(uint32_t code, uint32_t code32, const struct kpcdata *kpcd)
{
#if __LP64__
#pragma unused(code32)
	unsigned int max = (kpcd->counterc + 3) / 4;
	/* and the actual counts with one 64-bit argument each */
	for (unsigned int i = 0; i < max; i++) {
		uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
		BUF_DATA(code | flag,
		    kpcd->counterv[0 + i * 4],
		    kpcd->counterv[1 + i * 4],
		    kpcd->counterv[2 + i * 4],
		    kpcd->counterv[3 + i * 4]);
	}
#else /* __LP64__ */
#pragma unused(code)
	unsigned int max = (kpcd->counterc + 1) / 2;
	/* and the actual counts with two 32-bit trace arguments each */
	for (unsigned int i = 0; i < max; i++) {
		uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
		BUF_DATA(code32 | flag,
		    (kpcd->counterv[0 + i * 2] >> 32ULL),
		    kpcd->counterv[0 + i * 2] & 0xffffffffULL,
		    (kpcd->counterv[1 + i * 2] >> 32ULL),
		    kpcd->counterv[1 + i * 2] & 0xffffffffULL);
	}
#endif /* !__LP64__ */
}

void
kperf_kpc_cpu_log(const struct kpcdata *kpcd)
{
	kperf_kpc_log(PERF_KPC_DATA, PERF_KPC_DATA32, kpcd);
}

void
kperf_kpc_thread_log(const struct kpcdata *kpcd)
{
	kperf_kpc_log(PERF_KPC_DATA_THREAD, PERF_KPC_DATA_THREAD32, kpcd);
}
Commit	Line	Data
39236c6e A	1	/*
	2	* Copyright (c) 2013 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
39037602	5	*
39236c6e 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.
39037602	14	*
39236c6e A	15	* Please obtain a copy of the License at
39236c6e A	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
39037602	17	*
39236c6e A	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.
39037602	25	*
39236c6e A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
39037602 A	29	/*
	30	* Sample KPC data into kperf and manage shared context-switch and AST handlers
	31	*/
39236c6e	32
39236c6e	33	#include <kperf/kperf.h>
39236c6e A	34	#include <kperf/buffer.h>
39236c6e A	35	#include <kperf/context.h>
39037602	36	#include <kperf/pet.h>
39236c6e	37	#include <kperf/kperf_kpc.h>
3e170ce0	38	#include <kern/kpc.h> /* kpc_cswitch_context, kpc_threads_counting */
39236c6e	39
39236c6e	40	void
39037602	41	kperf_kpc_thread_ast(thread_t thread)
39236c6e	42	{
39037602 A	43	kpc_thread_ast_handler(thread);
39037602 A	44	kperf_thread_ast_handler(thread);
3e170ce0	45
39037602	46	thread->kperf_flags = 0;
3e170ce0 A	47	}
	48
	49	void
	50	kperf_kpc_thread_sample(struct kpcdata *kpcd, int sample_config)
	51	{
39037602 A	52	BUF_INFO(PERF_KPC_THREAD_SAMPLE \| DBG_FUNC_START, sample_config);
39037602 A	53
3e170ce0 A	54	kpcd->running = kpc_get_running();
	55	/* let kpc_get_curthread_counters set the correct count */
	56	kpcd->counterc = KPC_MAX_COUNTERS;
	57	if (kpc_get_curthread_counters(&kpcd->counterc,
0a7de745	58	kpcd->counterv)) {
3e170ce0 A	59	/* if thread counters aren't ready, default to 0 */
3e170ce0 A	60	memset(kpcd->counterv, 0,
0a7de745	61	sizeof(uint64_t) * kpcd->counterc);
3e170ce0	62	}
39037602	63	/* help out Instruments by sampling KPC's config */
3e170ce0	64	if (!sample_config) {
39236c6e	65	kpcd->configc = 0;
3e170ce0	66	} else {
39236c6e A	67	kpcd->configc = kpc_get_config_count(kpcd->running);
	68	kpc_get_config(kpcd->running, kpcd->configv);
	69	}
39037602 A	70
39037602 A	71	BUF_INFO(PERF_KPC_THREAD_SAMPLE \| DBG_FUNC_END, kpcd->running, kpcd->counterc);
39236c6e A	72	}
	73
	74	void
3e170ce0	75	kperf_kpc_cpu_sample(struct kpcdata *kpcd, int sample_config)
39236c6e	76	{
39037602 A	77	BUF_INFO(PERF_KPC_CPU_SAMPLE \| DBG_FUNC_START, sample_config);
39037602 A	78
3e170ce0 A	79	kpcd->running = kpc_get_running();
3e170ce0 A	80	kpcd->counterc = kpc_get_cpu_counters(0, kpcd->running,
0a7de745 A	81	&kpcd->curcpu,
0a7de745 A	82	kpcd->counterv);
3e170ce0 A	83	if (!sample_config) {
	84	kpcd->configc = 0;
	85	} else {
	86	kpcd->configc = kpc_get_config_count(kpcd->running);
	87	kpc_get_config(kpcd->running, kpcd->configv);
	88	}
39037602 A	89
39037602 A	90	BUF_INFO(PERF_KPC_CPU_SAMPLE \| DBG_FUNC_END, kpcd->running, kpcd->counterc);
3e170ce0	91	}
39236c6e	92
cb323159	93	void
3e170ce0 A	94	kperf_kpc_config_log(const struct kpcdata *kpcd)
3e170ce0 A	95	{
39236c6e	96	BUF_DATA(PERF_KPC_CONFIG,
0a7de745 A	97	kpcd->running,
	98	kpcd->counterc,
	99	kpc_get_counter_count(KPC_CLASS_FIXED_MASK),
	100	kpcd->configc);
cb323159 A	101
	102	#if __LP64__
	103	unsigned int max = (kpcd->configc + 3) / 4;
	104	for (unsigned int i = 0; i < max; i++) {
	105	uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
	106	BUF_DATA(PERF_KPC_CFG_REG \| flag,
	107	kpcd->configv[0 + i * 4], kpcd->configv[1 + i * 4],
	108	kpcd->configv[2 + i * 4], kpcd->configv[3 + i * 4]);
	109	}
	110	#else /* __LP64__ */
	111	unsigned int max = (kpcd->configc + 1) / 2;
	112	for (unsigned int i = 0; i < max; i++) {
	113	uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
	114	BUF_DATA(PERF_KPC_CFG_REG32 \| flag,
	115	kpcd->configv[i * 2] >> 32ULL,
	116	kpcd->configv[i * 2] & 0xffffffffULL,
	117	kpcd->configv[i * 2 + 1] >> 32ULL,
	118	kpcd->configv[i * 2 + 1] & 0xffffffffULL);
	119	}
	120	#endif /* !__LP64__ */
3e170ce0 A	121	}
	122
	123	static void
	124	kperf_kpc_log(uint32_t code, uint32_t code32, const struct kpcdata *kpcd)
	125	{
39236c6e	126	#if __LP64__
cb323159 A	127	#pragma unused(code32)
cb323159 A	128	unsigned int max = (kpcd->counterc + 3) / 4;
3e170ce0	129	/* and the actual counts with one 64-bit argument each */
cb323159 A	130	for (unsigned int i = 0; i < max; i++) {
	131	uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
	132	BUF_DATA(code \| flag,
0a7de745 A	133	kpcd->counterv[0 + i * 4],
	134	kpcd->counterv[1 + i * 4],
	135	kpcd->counterv[2 + i * 4],
	136	kpcd->counterv[3 + i * 4]);
39236c6e	137	}
cb323159 A	138	#else /* __LP64__ */
	139	#pragma unused(code)
	140	unsigned int max = (kpcd->counterc + 1) / 2;
3e170ce0	141	/* and the actual counts with two 32-bit trace arguments each */
cb323159 A	142	for (unsigned int i = 0; i < max; i++) {
	143	uint32_t flag = (i == 0) ? DBG_FUNC_START : ((i == (max - 1)) ? DBG_FUNC_END : DBG_FUNC_NONE);
	144	BUF_DATA(code32 \| flag,
0a7de745 A	145	(kpcd->counterv[0 + i * 2] >> 32ULL),
	146	kpcd->counterv[0 + i * 2] & 0xffffffffULL,
	147	(kpcd->counterv[1 + i * 2] >> 32ULL),
	148	kpcd->counterv[1 + i * 2] & 0xffffffffULL);
39236c6e	149	}
cb323159	150	#endif /* !__LP64__ */
39236c6e A	151	}
39236c6e A	152
3e170ce0 A	153	void
	154	kperf_kpc_cpu_log(const struct kpcdata *kpcd)
	155	{
3e170ce0 A	156	kperf_kpc_log(PERF_KPC_DATA, PERF_KPC_DATA32, kpcd);
	157	}
	158
	159	void
	160	kperf_kpc_thread_log(const struct kpcdata *kpcd)
	161	{
3e170ce0 A	162	kperf_kpc_log(PERF_KPC_DATA_THREAD, PERF_KPC_DATA_THREAD32, kpcd);
3e170ce0 A	163	}