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

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

/*
 * kperf's kdebug trigger is a precise mechanism for taking samples of the
 * thread tracing a kdebug event.
 *
 * The filter used by kperf differs from kdebug's typefilter. kperf's filter
 * is small -- only around 140 bytes, as opposed to kdebug's 8KB filter.  It
 * can also target precise debug IDs, instead of only being able to specify
 * an entire subclass in a kdebug typefilter.  Function specifiers can be
 * provided to match against along with a class or subclass.  For instance, this
 * allows the kperf filter to only trigger a sample if an ending syscall event
 * (DBG_BSD, DBG_BSD_EXCP_SC) occurs.
 *
 * The tradeoff for this flexibility is that only KPERF_KDEBUG_DEBUGIDS_MAX (32)
 * classes, subclasses, or exact debug IDs can be filtered at one time.
 *
 * The filter consists of up to 32 debug IDs and an array of 2-bit type codes
 * packed into a 64-bit value.  To determine if a given debug ID should trigger
 * a kperf sample, each debug ID is checked.  The type code is unpacked from the
 * 64-bit value to apply a mask to the debug ID.  Then, a sample occurs if the
 * masked debug ID is equal to the debug ID in the filter's list.
 */

#include <kern/kalloc.h>
#include <kperf/action.h>
#include <kperf/buffer.h>
#include <kperf/context.h>
#include <kperf/kdebug_trigger.h>
#include <kperf/kperf.h>
#include <sys/errno.h>

boolean_t kperf_kdebug_active = FALSE;
static void kperf_kdebug_update(void);

static uint8_t kperf_kdebug_action = 0;

static struct kperf_kdebug_filter {
	uint64_t types[2];
	uint32_t debugids[KPERF_KDEBUG_DEBUGIDS_MAX];
	uint8_t n_debugids;
} __attribute__((packed)) *kperf_kdebug_filter = NULL;

enum kperf_kdebug_filter_type {
	KPERF_KDEBUG_FILTER_CLASS,
	KPERF_KDEBUG_FILTER_CLASS_FN,
	KPERF_KDEBUG_FILTER_CSC,
	KPERF_KDEBUG_FILTER_CSC_FN,
	KPERF_KDEBUG_FILTER_DEBUGID,
	KPERF_KDEBUG_FILTER_DEBUGID_FN
};

const static uint32_t debugid_masks[] = {
	[KPERF_KDEBUG_FILTER_CLASS] = KDBG_CLASS_MASK,
	[KPERF_KDEBUG_FILTER_CLASS_FN] = KDBG_CLASS_MASK | KDBG_FUNC_MASK,
	[KPERF_KDEBUG_FILTER_CSC] = KDBG_CSC_MASK,
	[KPERF_KDEBUG_FILTER_CSC_FN] = KDBG_CSC_MASK | KDBG_FUNC_MASK,
	[KPERF_KDEBUG_FILTER_DEBUGID] = KDBG_EVENTID_MASK,
	[KPERF_KDEBUG_FILTER_DEBUGID_FN] = UINT32_MAX,
};

/*
 * Types are packed into 2 64-bit fields in the filter, with 4-bits for each
 * type.  Only 3 bits are strictly necessary, but using 4 simplifies the
 * unpacking.
 */

/* UNSAFE */
#define DECODE_TYPE(TYPES, I) ((((uint8_t *)(TYPES))[(I) / 2] >> ((I) % 2) * 4) & 0xf)

int
kperf_kdebug_init(void)
{
	kperf_kdebug_filter = kalloc_tag(sizeof(*kperf_kdebug_filter),
	    VM_KERN_MEMORY_DIAG);
	if (kperf_kdebug_filter == NULL) {
		return ENOMEM;
	}
	bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));

	return 0;
}

void
kperf_kdebug_reset(void)
{
	int err;

	if ((err = kperf_init())) {
		return;
	}

	kperf_kdebug_action = 0;
	bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
	kperf_kdebug_update();
}

boolean_t
kperf_kdebug_should_trigger(uint32_t debugid)
{
	/* ignore kperf events */
	if (KDBG_EXTRACT_CLASS(debugid) == DBG_PERF) {
		return FALSE;
	}

	/*
	 * Search linearly through list of debugids and masks.  If the filter
	 * gets larger than 128 bytes, change this to either a binary search or
	 * a sparse bitmap on the uint32_t range, depending on the new size.
	 */
	for (uint8_t i = 0; i < kperf_kdebug_filter->n_debugids; i++) {
		uint32_t check_debugid =
		    kperf_kdebug_filter->debugids[i];
		uint32_t mask = debugid_masks[DECODE_TYPE(kperf_kdebug_filter->types, i)];

		if ((debugid & mask) == check_debugid) {
			return TRUE;
		}
	}

	return FALSE;
}

int
kperf_kdebug_set_filter(user_addr_t user_filter, uint32_t user_size)
{
	uint32_t n_debugids_provided = 0;
	int err = 0;

	if ((err = kperf_init())) {
		return err;
	}

	n_debugids_provided = (uint32_t)KPERF_KDEBUG_N_DEBUGIDS(user_size);

	/* detect disabling the filter completely */
	if (n_debugids_provided == 0) {
		bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
		goto out;
	}

	if ((err = kperf_kdebug_set_n_debugids(n_debugids_provided))) {
		goto out;
	}

	if ((err = copyin(user_filter, (char *)kperf_kdebug_filter,
	    KPERF_KDEBUG_FILTER_SIZE(n_debugids_provided)))) {
		bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
		goto out;
	}

out:
	kperf_kdebug_update();

	return err;
}

uint32_t
kperf_kdebug_get_filter(struct kperf_kdebug_filter **filter)
{
	int err;

	if ((err = kperf_init())) {
		return 0;
	}

	assert(filter != NULL);

	*filter = kperf_kdebug_filter;
	return kperf_kdebug_filter->n_debugids;
}

int
kperf_kdebug_set_n_debugids(uint32_t n_debugids_in)
{
	int err;

	if ((err = kperf_init())) {
		return EINVAL;
	}

	if (n_debugids_in > KPERF_KDEBUG_DEBUGIDS_MAX) {
		return EINVAL;
	}

	kperf_kdebug_filter->n_debugids = n_debugids_in;

	return 0;
}

int
kperf_kdebug_set_action(int action_id)
{
	if (action_id < 0 || (unsigned int)action_id > kperf_action_get_count()) {
		return EINVAL;
	}

	kperf_kdebug_action = action_id;
	kperf_kdebug_update();

	return 0;
}

int
kperf_kdebug_get_action(void)
{
	return kperf_kdebug_action;
}

static void
kperf_kdebug_update(void)
{
	int err;

	if ((err = kperf_init())) {
		return;
	}

	if (kperf_kdebug_action != 0 &&
	    kperf_kdebug_filter->n_debugids != 0) {
		kperf_kdebug_active = TRUE;
	} else {
		kperf_kdebug_active = FALSE;
	}
}
Commit	Line	Data
39037602 A	1	/*
	2	* Copyright (c) 2016 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	/*
	30	* kperf's kdebug trigger is a precise mechanism for taking samples of the
	31	* thread tracing a kdebug event.
	32	*
	33	* The filter used by kperf differs from kdebug's typefilter. kperf's filter
	34	* is small -- only around 140 bytes, as opposed to kdebug's 8KB filter. It
	35	* can also target precise debug IDs, instead of only being able to specify
	36	* an entire subclass in a kdebug typefilter. Function specifiers can be
	37	* provided to match against along with a class or subclass. For instance, this
	38	* allows the kperf filter to only trigger a sample if an ending syscall event
	39	* (DBG_BSD, DBG_BSD_EXCP_SC) occurs.
	40	*
	41	* The tradeoff for this flexibility is that only KPERF_KDEBUG_DEBUGIDS_MAX (32)
	42	* classes, subclasses, or exact debug IDs can be filtered at one time.
	43	*
	44	* The filter consists of up to 32 debug IDs and an array of 2-bit type codes
	45	* packed into a 64-bit value. To determine if a given debug ID should trigger
	46	* a kperf sample, each debug ID is checked. The type code is unpacked from the
	47	* 64-bit value to apply a mask to the debug ID. Then, a sample occurs if the
	48	* masked debug ID is equal to the debug ID in the filter's list.
	49	*/
	50
	51	#include <kern/kalloc.h>
	52	#include <kperf/action.h>
	53	#include <kperf/buffer.h>
	54	#include <kperf/context.h>
	55	#include <kperf/kdebug_trigger.h>
	56	#include <kperf/kperf.h>
	57	#include <sys/errno.h>
	58
	59	boolean_t kperf_kdebug_active = FALSE;
	60	static void kperf_kdebug_update(void);
	61
	62	static uint8_t kperf_kdebug_action = 0;
	63
	64	static struct kperf_kdebug_filter {
65	uint64_t types[2];
66	uint32_t debugids[KPERF_KDEBUG_DEBUGIDS_MAX];
67	uint8_t n_debugids;
68	} __attribute__((packed)) *kperf_kdebug_filter = NULL;
69
70	enum kperf_kdebug_filter_type {
71	KPERF_KDEBUG_FILTER_CLASS,
72	KPERF_KDEBUG_FILTER_CLASS_FN,
73	KPERF_KDEBUG_FILTER_CSC,
74	KPERF_KDEBUG_FILTER_CSC_FN,
75	KPERF_KDEBUG_FILTER_DEBUGID,
76	KPERF_KDEBUG_FILTER_DEBUGID_FN
77	};
78
79	const static uint32_t debugid_masks[] = {
80	[KPERF_KDEBUG_FILTER_CLASS] = KDBG_CLASS_MASK,
81	[KPERF_KDEBUG_FILTER_CLASS_FN] = KDBG_CLASS_MASK \| KDBG_FUNC_MASK,
82	[KPERF_KDEBUG_FILTER_CSC] = KDBG_CSC_MASK,
83	[KPERF_KDEBUG_FILTER_CSC_FN] = KDBG_CSC_MASK \| KDBG_FUNC_MASK,
84	[KPERF_KDEBUG_FILTER_DEBUGID] = KDBG_EVENTID_MASK,
85	[KPERF_KDEBUG_FILTER_DEBUGID_FN] = UINT32_MAX,
86	};
87
88	/*
89	* Types are packed into 2 64-bit fields in the filter, with 4-bits for each
90	* type. Only 3 bits are strictly necessary, but using 4 simplifies the
91	* unpacking.
92	*/
93
94	/* UNSAFE */
95	#define DECODE_TYPE(TYPES, I) ((((uint8_t )(TYPES))[(I) / 2] >> ((I) % 2) 4) & 0xf)
96
97	int
98	kperf_kdebug_init(void)
99	{
100	kperf_kdebug_filter = kalloc_tag(sizeof(*kperf_kdebug_filter),
0a7de745	101	VM_KERN_MEMORY_DIAG);
39037602 A	102	if (kperf_kdebug_filter == NULL) {
	103	return ENOMEM;
	104	}
	105	bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
	106
	107	return 0;
	108	}
	109
	110	void
	111	kperf_kdebug_reset(void)
	112	{
	113	int err;
	114
	115	if ((err = kperf_init())) {
	116	return;
	117	}
	118
	119	kperf_kdebug_action = 0;
	120	bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
	121	kperf_kdebug_update();
	122	}
	123
	124	boolean_t
	125	kperf_kdebug_should_trigger(uint32_t debugid)
	126	{
	127	/* ignore kperf events */
	128	if (KDBG_EXTRACT_CLASS(debugid) == DBG_PERF) {
	129	return FALSE;
	130	}
	131
	132	/*
	133	* Search linearly through list of debugids and masks. If the filter
	134	* gets larger than 128 bytes, change this to either a binary search or
	135	* a sparse bitmap on the uint32_t range, depending on the new size.
	136	*/
	137	for (uint8_t i = 0; i < kperf_kdebug_filter->n_debugids; i++) {
	138	uint32_t check_debugid =
0a7de745	139	kperf_kdebug_filter->debugids[i];
39037602 A	140	uint32_t mask = debugid_masks[DECODE_TYPE(kperf_kdebug_filter->types, i)];
	141
	142	if ((debugid & mask) == check_debugid) {
	143	return TRUE;
	144	}
	145	}
	146
	147	return FALSE;
	148	}
	149
	150	int
	151	kperf_kdebug_set_filter(user_addr_t user_filter, uint32_t user_size)
	152	{
	153	uint32_t n_debugids_provided = 0;
	154	int err = 0;
	155
	156	if ((err = kperf_init())) {
	157	return err;
	158	}
	159
d9a64523 A	160	n_debugids_provided = (uint32_t)KPERF_KDEBUG_N_DEBUGIDS(user_size);
d9a64523 A	161
39037602	162	/* detect disabling the filter completely */
d9a64523	163	if (n_debugids_provided == 0) {
39037602 A	164	bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
	165	goto out;
	166	}
	167
39037602 A	168	if ((err = kperf_kdebug_set_n_debugids(n_debugids_provided))) {
	169	goto out;
	170	}
	171
	172	if ((err = copyin(user_filter, (char *)kperf_kdebug_filter,
0a7de745	173	KPERF_KDEBUG_FILTER_SIZE(n_debugids_provided)))) {
39037602 A	174	bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
	175	goto out;
	176	}
	177
	178	out:
	179	kperf_kdebug_update();
	180
	181	return err;
	182	}
	183
	184	uint32_t
	185	kperf_kdebug_get_filter(struct kperf_kdebug_filter **filter)
	186	{
	187	int err;
	188
	189	if ((err = kperf_init())) {
	190	return 0;
	191	}
	192
	193	assert(filter != NULL);
	194
	195	*filter = kperf_kdebug_filter;
	196	return kperf_kdebug_filter->n_debugids;
	197	}
	198
	199	int
	200	kperf_kdebug_set_n_debugids(uint32_t n_debugids_in)
	201	{
	202	int err;
	203
	204	if ((err = kperf_init())) {
	205	return EINVAL;
	206	}
	207
	208	if (n_debugids_in > KPERF_KDEBUG_DEBUGIDS_MAX) {
	209	return EINVAL;
	210	}
	211
	212	kperf_kdebug_filter->n_debugids = n_debugids_in;
	213
	214	return 0;
	215	}
	216
	217	int
	218	kperf_kdebug_set_action(int action_id)
	219	{
	220	if (action_id < 0 \|\| (unsigned int)action_id > kperf_action_get_count()) {
	221	return EINVAL;
	222	}
	223
	224	kperf_kdebug_action = action_id;
	225	kperf_kdebug_update();
	226
	227	return 0;
	228	}
	229
	230	int
	231	kperf_kdebug_get_action(void)
	232	{
	233	return kperf_kdebug_action;
	234	}
	235
	236	static void
	237	kperf_kdebug_update(void)
238	{
239	int err;
240
241	if ((err = kperf_init())) {
242	return;
243	}
244
245	if (kperf_kdebug_action != 0 &&
0a7de745	246	kperf_kdebug_filter->n_debugids != 0) {
39037602 A	247	kperf_kdebug_active = TRUE;
	248	} else {
	249	kperf_kdebug_active = FALSE;
	250	}
	251	}