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
59boolean_t kperf_kdebug_active = FALSE;
60static void kperf_kdebug_update(void);
61
62static uint8_t kperf_kdebug_action = 0;
63
64static 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
70enum 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
79const 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
97int
98kperf_kdebug_init(void)
99{
100 kperf_kdebug_filter = kalloc_tag(sizeof(*kperf_kdebug_filter),
101 VM_KERN_MEMORY_DIAG);
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
110void
111kperf_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
124boolean_t
125kperf_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 =
139 kperf_kdebug_filter->debugids[i];
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
150int
151kperf_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
160 n_debugids_provided = (uint32_t)KPERF_KDEBUG_N_DEBUGIDS(user_size);
161
162 /* detect disabling the filter completely */
163 if (n_debugids_provided == 0) {
164 bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
165 goto out;
166 }
167
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,
173 KPERF_KDEBUG_FILTER_SIZE(n_debugids_provided))))
174 {
175 bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
176 goto out;
177 }
178
179out:
180 kperf_kdebug_update();
181
182 return err;
183}
184
185uint32_t
186kperf_kdebug_get_filter(struct kperf_kdebug_filter **filter)
187{
188 int err;
189
190 if ((err = kperf_init())) {
191 return 0;
192 }
193
194 assert(filter != NULL);
195
196 *filter = kperf_kdebug_filter;
197 return kperf_kdebug_filter->n_debugids;
198}
199
200int
201kperf_kdebug_set_n_debugids(uint32_t n_debugids_in)
202{
203 int err;
204
205 if ((err = kperf_init())) {
206 return EINVAL;
207 }
208
209 if (n_debugids_in > KPERF_KDEBUG_DEBUGIDS_MAX) {
210 return EINVAL;
211 }
212
213 kperf_kdebug_filter->n_debugids = n_debugids_in;
214
215 return 0;
216}
217
218int
219kperf_kdebug_set_action(int action_id)
220{
221 if (action_id < 0 || (unsigned int)action_id > kperf_action_get_count()) {
222 return EINVAL;
223 }
224
225 kperf_kdebug_action = action_id;
226 kperf_kdebug_update();
227
228 return 0;
229}
230
231int
232kperf_kdebug_get_action(void)
233{
234 return kperf_kdebug_action;
235}
236
237static void
238kperf_kdebug_update(void)
239{
240 int err;
241
242 if ((err = kperf_init())) {
243 return;
244 }
245
246 if (kperf_kdebug_action != 0 &&
247 kperf_kdebug_filter->n_debugids != 0)
248 {
249 kperf_kdebug_active = TRUE;
250 } else {
251 kperf_kdebug_active = FALSE;
252 }
253}
254