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 void
kperf_kdebug_setup(void)98 kperf_kdebug_setup(void)
99 {
100 kperf_kdebug_filter = zalloc_permanent_type(struct kperf_kdebug_filter);
101 }
102
103 void
kperf_kdebug_reset(void)104 kperf_kdebug_reset(void)
105 {
106 kperf_setup();
107
108 kperf_kdebug_action = 0;
109 bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
110 kperf_kdebug_update();
111 }
112
113 boolean_t
kperf_kdebug_should_trigger(uint32_t debugid)114 kperf_kdebug_should_trigger(uint32_t debugid)
115 {
116 /* ignore kperf events */
117 if (KDBG_EXTRACT_CLASS(debugid) == DBG_PERF) {
118 return FALSE;
119 }
120
121 /*
122 * Search linearly through list of debugids and masks. If the filter
123 * gets larger than 128 bytes, change this to either a binary search or
124 * a sparse bitmap on the uint32_t range, depending on the new size.
125 */
126 for (uint8_t i = 0; i < kperf_kdebug_filter->n_debugids; i++) {
127 uint32_t check_debugid =
128 kperf_kdebug_filter->debugids[i];
129 uint32_t mask = debugid_masks[DECODE_TYPE(kperf_kdebug_filter->types, i)];
130
131 if ((debugid & mask) == check_debugid) {
132 return TRUE;
133 }
134 }
135
136 return FALSE;
137 }
138
139 int
kperf_kdebug_set_filter(user_addr_t user_filter,uint32_t user_size)140 kperf_kdebug_set_filter(user_addr_t user_filter, uint32_t user_size)
141 {
142 uint32_t n_debugids_provided = 0;
143 int err = 0;
144
145 kperf_setup();
146
147 n_debugids_provided = (uint32_t)KPERF_KDEBUG_N_DEBUGIDS(user_size);
148
149 /* detect disabling the filter completely */
150 if (n_debugids_provided == 0) {
151 bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
152 goto out;
153 }
154
155 if ((err = kperf_kdebug_set_n_debugids(n_debugids_provided))) {
156 goto out;
157 }
158
159 if ((err = copyin(user_filter, (char *)kperf_kdebug_filter,
160 KPERF_KDEBUG_FILTER_SIZE(n_debugids_provided)))) {
161 bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter));
162 goto out;
163 }
164
165 out:
166 kperf_kdebug_update();
167
168 return err;
169 }
170
171 uint32_t
kperf_kdebug_get_filter(struct kperf_kdebug_filter ** filter)172 kperf_kdebug_get_filter(struct kperf_kdebug_filter **filter)
173 {
174 kperf_setup();
175
176 assert(filter != NULL);
177
178 *filter = kperf_kdebug_filter;
179 return kperf_kdebug_filter->n_debugids;
180 }
181
182 int
kperf_kdebug_set_n_debugids(uint32_t n_debugids_in)183 kperf_kdebug_set_n_debugids(uint32_t n_debugids_in)
184 {
185 kperf_setup();
186
187 if (n_debugids_in > KPERF_KDEBUG_DEBUGIDS_MAX) {
188 return EINVAL;
189 }
190
191 kperf_kdebug_filter->n_debugids = n_debugids_in;
192
193 return 0;
194 }
195
196 int
kperf_kdebug_set_action(int action_id)197 kperf_kdebug_set_action(int action_id)
198 {
199 if (action_id < 0 || (unsigned int)action_id > kperf_action_get_count()) {
200 return EINVAL;
201 }
202
203 kperf_kdebug_action = action_id;
204 kperf_kdebug_update();
205
206 return 0;
207 }
208
209 int
kperf_kdebug_get_action(void)210 kperf_kdebug_get_action(void)
211 {
212 return kperf_kdebug_action;
213 }
214
215 static void
kperf_kdebug_update(void)216 kperf_kdebug_update(void)
217 {
218 kperf_setup();
219
220 if (kperf_kdebug_action != 0 &&
221 kperf_kdebug_filter->n_debugids != 0) {
222 kperf_kdebug_active = TRUE;
223 } else {
224 kperf_kdebug_active = FALSE;
225 }
226 }
227