1 | /* |
2 | * Copyright (c) 2005-2012 Apple 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 | // NOTE: This file is only c++ so I can get static initialisers going |
30 | #include <libkern/OSDebug.h> |
31 | #include <IOKit/IOLib.h> |
32 | |
33 | #include <sys/cdefs.h> |
34 | |
35 | #include <stdarg.h> |
36 | #include <mach/mach_types.h> |
37 | #include <mach/kmod.h> |
38 | #include <kern/locks.h> |
39 | |
40 | #include <libkern/libkern.h> // From bsd's libkern directory |
41 | #include <mach/vm_param.h> |
42 | |
43 | #include <sys/kdebug.h> |
44 | #include <kern/thread.h> |
45 | |
46 | |
47 | extern int etext; |
48 | __BEGIN_DECLS |
49 | // From osmfk/kern/thread.h but considered to be private |
50 | extern vm_offset_t min_valid_stack_address(void); |
51 | extern vm_offset_t max_valid_stack_address(void); |
52 | |
53 | // From osfmk/kern/printf.c |
54 | extern boolean_t doprnt_hide_pointers; |
55 | |
56 | // From osfmk/kmod.c |
57 | extern void kmod_dump_log(vm_offset_t *addr, unsigned int cnt, boolean_t doUnslide); |
58 | |
59 | extern addr64_t kvtophys(vm_offset_t va); |
60 | #if __arm__ |
61 | extern int copyinframe(vm_address_t fp, char *frame); |
62 | #elif defined(__arm64__) |
63 | extern int copyinframe(vm_address_t fp, char *frame, boolean_t is64bit); |
64 | #endif |
65 | |
66 | __END_DECLS |
67 | |
68 | extern lck_grp_t *IOLockGroup; |
69 | |
70 | static lck_mtx_t *sOSReportLock = lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL); |
71 | |
72 | /* Use kernel_debug() to log a backtrace */ |
73 | void |
74 | trace_backtrace(uint32_t debugid, uint32_t debugid2, uintptr_t size, uintptr_t data) { |
75 | void *bt[16]; |
76 | const unsigned cnt = sizeof(bt) / sizeof(bt[0]); |
77 | unsigned i; |
78 | int found = 0; |
79 | |
80 | OSBacktrace(bt, cnt); |
81 | |
82 | /* find first non-kernel frame */ |
83 | for (i = 3; i < cnt && bt[i]; i++) { |
84 | if (bt[i] > (void*)&etext) { |
85 | found = 1; |
86 | break; |
87 | } |
88 | } |
89 | /* |
90 | * if there are non-kernel frames, only log these |
91 | * otherwise, log everything but the first two |
92 | */ |
93 | if (!found) i=2; |
94 | |
95 | #define safe_bt(a) (uintptr_t)(a<cnt ? bt[a] : 0) |
96 | kernel_debug(debugid, data, size, safe_bt(i), safe_bt(i+1), 0); |
97 | kernel_debug(debugid2, safe_bt(i+2), safe_bt(i+3), safe_bt(i+4), safe_bt(i+5), 0); |
98 | } |
99 | |
100 | /* Report a message with a 4 entry backtrace - very slow */ |
101 | void |
102 | OSReportWithBacktrace(const char *str, ...) |
103 | { |
104 | char buf[128]; |
105 | void *bt[9] = {}; |
106 | const unsigned cnt = sizeof(bt) / sizeof(bt[0]); |
107 | va_list listp; |
108 | |
109 | // Ignore the our and our callers stackframes, skipping frames 0 & 1 |
110 | (void) OSBacktrace(bt, cnt); |
111 | |
112 | va_start(listp, str); |
113 | vsnprintf(buf, sizeof(buf), str, listp); |
114 | va_end(listp); |
115 | |
116 | lck_mtx_lock(sOSReportLock); |
117 | { |
118 | boolean_t old_doprnt_hide_pointers = doprnt_hide_pointers; |
119 | doprnt_hide_pointers = FALSE; |
120 | printf("%s\nBacktrace 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n" , buf, |
121 | (unsigned long) VM_KERNEL_UNSLIDE(bt[2]), (unsigned long) VM_KERNEL_UNSLIDE(bt[3]), |
122 | (unsigned long) VM_KERNEL_UNSLIDE(bt[4]), (unsigned long) VM_KERNEL_UNSLIDE(bt[5]), |
123 | (unsigned long) VM_KERNEL_UNSLIDE(bt[6]), (unsigned long) VM_KERNEL_UNSLIDE(bt[7]), |
124 | (unsigned long) VM_KERNEL_UNSLIDE(bt[8])); |
125 | kmod_dump_log((vm_offset_t *) &bt[2], cnt - 2, TRUE); |
126 | doprnt_hide_pointers = old_doprnt_hide_pointers; |
127 | } |
128 | lck_mtx_unlock(sOSReportLock); |
129 | } |
130 | |
131 | static vm_offset_t minstackaddr = min_valid_stack_address(); |
132 | static vm_offset_t maxstackaddr = max_valid_stack_address(); |
133 | |
134 | |
135 | #if __x86_64__ |
136 | #define x86_64_RETURN_OFFSET 8 |
137 | static unsigned int |
138 | x86_64_validate_raddr(vm_offset_t raddr) |
139 | { |
140 | return ((raddr > VM_MIN_KERNEL_AND_KEXT_ADDRESS) && |
141 | (raddr < VM_MAX_KERNEL_ADDRESS)); |
142 | } |
143 | static unsigned int |
144 | x86_64_validate_stackptr(vm_offset_t stackptr) |
145 | { |
146 | /* Existence and alignment check |
147 | */ |
148 | if (!stackptr || (stackptr & 0x7) || !x86_64_validate_raddr(stackptr)) |
149 | return 0; |
150 | |
151 | /* Is a virtual->physical translation present? |
152 | */ |
153 | if (!kvtophys(stackptr)) |
154 | return 0; |
155 | |
156 | /* Check if the return address lies on the same page; |
157 | * If not, verify that a translation exists. |
158 | */ |
159 | if (((PAGE_SIZE - (stackptr & PAGE_MASK)) < x86_64_RETURN_OFFSET) && |
160 | !kvtophys(stackptr + x86_64_RETURN_OFFSET)) |
161 | return 0; |
162 | return 1; |
163 | } |
164 | #endif |
165 | |
166 | void |
167 | OSPrintBacktrace(void) |
168 | { |
169 | void * btbuf[20]; |
170 | int tmp = OSBacktrace(btbuf, 20); |
171 | int i; |
172 | for(i=0;i<tmp;i++) |
173 | { |
174 | kprintf("bt[%.2d] = %p\n" , i, btbuf[i]); |
175 | } |
176 | } |
177 | |
178 | unsigned OSBacktrace(void **bt, unsigned maxAddrs) |
179 | { |
180 | unsigned frame; |
181 | if (!current_thread()) return 0; |
182 | |
183 | #if __x86_64__ |
184 | #define SANE_x86_64_FRAME_SIZE (kernel_stack_size >> 1) |
185 | vm_offset_t stackptr, stackptr_prev, raddr; |
186 | unsigned frame_index = 0; |
187 | /* Obtain current frame pointer */ |
188 | |
189 | __asm__ volatile("movq %%rbp, %0" : "=m" (stackptr)); |
190 | |
191 | if (!x86_64_validate_stackptr(stackptr)) |
192 | goto pad; |
193 | |
194 | raddr = *((vm_offset_t *) (stackptr + x86_64_RETURN_OFFSET)); |
195 | |
196 | if (!x86_64_validate_raddr(raddr)) |
197 | goto pad; |
198 | |
199 | bt[frame_index++] = (void *) raddr; |
200 | |
201 | for ( ; frame_index < maxAddrs; frame_index++) { |
202 | stackptr_prev = stackptr; |
203 | stackptr = *((vm_offset_t *) stackptr_prev); |
204 | |
205 | if (!x86_64_validate_stackptr(stackptr)) |
206 | break; |
207 | /* Stack grows downwards */ |
208 | if (stackptr < stackptr_prev) |
209 | break; |
210 | |
211 | if ((stackptr - stackptr_prev) > SANE_x86_64_FRAME_SIZE) |
212 | break; |
213 | |
214 | raddr = *((vm_offset_t *) (stackptr + x86_64_RETURN_OFFSET)); |
215 | |
216 | if (!x86_64_validate_raddr(raddr)) |
217 | break; |
218 | |
219 | bt[frame_index] = (void *) raddr; |
220 | } |
221 | pad: |
222 | frame = frame_index; |
223 | |
224 | for ( ; frame_index < maxAddrs; frame_index++) |
225 | bt[frame_index] = (void *) 0; |
226 | #elif __arm__ || __arm64__ |
227 | uint32_t i = 0; |
228 | uintptr_t frameb[2]; |
229 | uintptr_t fp = 0; |
230 | |
231 | // get the current frame pointer for this thread |
232 | #if defined(__arm__) |
233 | #define OSBacktraceFrameAlignOK(x) (((x) & 0x3) == 0) |
234 | __asm__ volatile("mov %0,r7" : "=r" (fp)); |
235 | #elif defined(__arm64__) |
236 | #define OSBacktraceFrameAlignOK(x) (((x) & 0xf) == 0) |
237 | __asm__ volatile("mov %0, fp" : "=r" (fp)); |
238 | #else |
239 | #error Unknown architecture. |
240 | #endif |
241 | |
242 | // now crawl up the stack recording the link value of each frame |
243 | do { |
244 | // check bounds |
245 | if ((fp == 0) || (!OSBacktraceFrameAlignOK(fp)) || (fp > VM_MAX_KERNEL_ADDRESS) || (fp < VM_MIN_KERNEL_AND_KEXT_ADDRESS)) { |
246 | break; |
247 | } |
248 | // safely read frame |
249 | #ifdef __arm64__ |
250 | if (copyinframe(fp, (char*)frameb, TRUE) != 0) { |
251 | #else |
252 | if (copyinframe(fp, (char*)frameb) != 0) { |
253 | #endif |
254 | break; |
255 | } |
256 | |
257 | // No need to use copyin as this is always a kernel address, see check above |
258 | bt[i] = (void*)frameb[1]; // link register |
259 | fp = frameb[0]; |
260 | } while (++i < maxAddrs); |
261 | frame= i; |
262 | #else |
263 | #error arch |
264 | #endif |
265 | return frame; |
266 | } |
267 | |