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