/* * 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 #include #include #include #include #include #include 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) void kperf_kdebug_setup(void) { kperf_kdebug_filter = zalloc_permanent_type(struct kperf_kdebug_filter); } void kperf_kdebug_reset(void) { kperf_setup(); 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; kperf_setup(); 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) { kperf_setup(); assert(filter != NULL); *filter = kperf_kdebug_filter; return kperf_kdebug_filter->n_debugids; } int kperf_kdebug_set_n_debugids(uint32_t n_debugids_in) { kperf_setup(); 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) { kperf_setup(); if (kperf_kdebug_action != 0 && kperf_kdebug_filter->n_debugids != 0) { kperf_kdebug_active = TRUE; } else { kperf_kdebug_active = FALSE; } }