libkern/gen/OSDebug.cpp

   1 /*
   2  * Copyright (c) 2005 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 // NOTE:  This file is only c++ so I can get static initialisers going
  30 #include <libkern/OSDebug.h>
  31
  32 #include <sys/cdefs.h>
  33
  34 #include <stdarg.h>
  35 #include <mach/mach_types.h>
  36 #include <mach/kmod.h>
  37 #include <kern/locks.h>
  38
  39 #include <libkern/libkern.h>    // From bsd's libkern directory
  40 #include <mach/vm_param.h>
  41
  42 #include <sys/kdebug.h>
  43 #include <kern/thread.h>
  44
  45 extern int etext;
  46 __BEGIN_DECLS
  47 // From osmfk/kern/thread.h but considered to be private
  48 extern vm_offset_t min_valid_stack_address(void);
  49 extern vm_offset_t max_valid_stack_address(void);
  50
  51 // From osfmk/kmod.c
  52 extern void kmod_dump_log(vm_offset_t *addr, unsigned int cnt);
  53
  54 extern addr64_t kvtophys(vm_offset_t va);
  55
  56 __END_DECLS
  57
  58 extern lck_grp_t *IOLockGroup;
  59
  60 static lck_mtx_t *sOSReportLock = lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL);
  61
  62 /* Use kernel_debug() to log a backtrace */
  63 void
  64 trace_backtrace(uint32_t debugid, uint32_t debugid2, uintptr_t size, uintptr_t data) {
  65         void *bt[16];
  66         const unsigned cnt = sizeof(bt) / sizeof(bt[0]);
  67         unsigned i;
  68         int found = 0;
  69
  70         OSBacktrace(bt, cnt);
  71
  72         /* find first non-kernel frame */
  73         for (i = 3; i < cnt && bt[i]; i++) {
  74                 if (bt[i] > (void*)&etext) {
  75                         found = 1;
  76                         break;
  77                 }
  78         }
  79         /*
  80          * if there are non-kernel frames, only log these
  81          * otherwise, log everything but the first two
  82          */
  83         if (!found) i=2;
  84
  85 #define safe_bt(a) (uintptr_t)(a<cnt ? bt[a] : 0)
  86         kernel_debug(debugid, data, size, safe_bt(i), safe_bt(i+1), 0);
  87         kernel_debug(debugid2, safe_bt(i+2), safe_bt(i+3), safe_bt(i+4), safe_bt(i+5), 0);
  88 }
  89
  90 /* Report a message with a 4 entry backtrace - very slow */
  91 void
  92 OSReportWithBacktrace(const char *str, ...)
  93 {
  94     char buf[128];
  95     void *bt[9];
  96     const unsigned cnt = sizeof(bt) / sizeof(bt[0]);
  97     va_list listp;
  98
  99     // Ignore the our and our callers stackframes, skipping frames 0 & 1
 100     (void) OSBacktrace(bt, cnt);
 101
 102     va_start(listp, str);
 103     vsnprintf(buf, sizeof(buf), str, listp);
 104     va_end(listp);
 105
 106     lck_mtx_lock(sOSReportLock);
 107     {
 108         printf("%s\nBacktrace %p %p %p %p %p %p %p\n",
 109             buf, bt[2], bt[3], bt[4], bt[5], bt[6], bt[7], bt[8]);
 110         kmod_dump_log((vm_offset_t *) &bt[2], cnt - 2);
 111     }
 112     lck_mtx_unlock(sOSReportLock);
 113 }
 114
 115 static vm_offset_t minstackaddr = min_valid_stack_address();
 116 static vm_offset_t maxstackaddr = max_valid_stack_address();
 117
 118 #if __i386__
 119 #define i386_RETURN_OFFSET 4
 120
 121 static unsigned int
 122 i386_validate_stackptr(vm_offset_t stackptr)
 123 {
 124         /* Existence and alignment check
 125          */
 126         if (!stackptr || (stackptr & 0x3))
 127                 return 0;
 128
 129         /* Is a virtual->physical translation present?
 130          */
 131         if (!kvtophys(stackptr))
 132                 return 0;
 133
 134         /* Check if the return address lies on the same page;
 135          * If not, verify that a translation exists.
 136          */
 137         if (((PAGE_SIZE - (stackptr & PAGE_MASK)) < i386_RETURN_OFFSET) &&
 138             !kvtophys(stackptr + i386_RETURN_OFFSET))
 139                 return 0;
 140         return 1;
 141 }
 142
 143 static unsigned int
 144 i386_validate_raddr(vm_offset_t raddr)
 145 {
 146         return ((raddr > VM_MIN_KERNEL_AND_KEXT_ADDRESS) &&
 147             (raddr < VM_MAX_KERNEL_ADDRESS));
 148 }
 149 #endif
 150
 151 #if __x86_64__
 152 #define x86_64_RETURN_OFFSET 8
 153 static unsigned int
 154 x86_64_validate_raddr(vm_offset_t raddr)
 155 {
 156         return ((raddr > VM_MIN_KERNEL_AND_KEXT_ADDRESS) &&
 157             (raddr < VM_MAX_KERNEL_ADDRESS));
 158 }
 159 static unsigned int
 160 x86_64_validate_stackptr(vm_offset_t stackptr)
 161 {
 162         /* Existence and alignment check
 163          */
 164         if (!stackptr || (stackptr & 0x7) || !x86_64_validate_raddr(stackptr))
 165                 return 0;
 166
 167         /* Is a virtual->physical translation present?
 168          */
 169         if (!kvtophys(stackptr))
 170                 return 0;
 171
 172         /* Check if the return address lies on the same page;
 173          * If not, verify that a translation exists.
 174          */
 175         if (((PAGE_SIZE - (stackptr & PAGE_MASK)) < x86_64_RETURN_OFFSET) &&
 176             !kvtophys(stackptr + x86_64_RETURN_OFFSET))
 177                 return 0;
 178         return 1;
 179 }
 180 #endif
 181
 182
 183 unsigned OSBacktrace(void **bt, unsigned maxAddrs)
 184 {
 185     unsigned frame;
 186
 187 #if __ppc__
 188     vm_offset_t stackptr, stackptr_prev;
 189     const vm_offset_t * const mem = (vm_offset_t *) 0;
 190     unsigned i = 0;
 191
 192     __asm__ volatile("mflr %0" : "=r" (stackptr));
 193     bt[i++] = (void *) stackptr;
 194
 195     __asm__ volatile("mr %0,r1" : "=r" (stackptr));
 196     for ( ; i < maxAddrs; i++) {
 197         // Validate we have a reasonable stackptr
 198         if ( !(minstackaddr <= stackptr && stackptr < maxstackaddr)
 199         || (stackptr & 3))
 200             break;
 201
 202         stackptr_prev = stackptr;
 203         stackptr = mem[stackptr_prev >> 2];
 204         if ((stackptr - stackptr_prev) > 8 * 1024)      // Sanity check
 205             break;
 206
 207         vm_offset_t addr = mem[(stackptr >> 2) + 2];
 208         if ((addr & 3) || (addr < 0x8000))      // More sanity checks
 209             break;
 210         bt[i] = (void *) addr;
 211     }
 212     frame = i;
 213
 214     for ( ; i < maxAddrs; i++)
 215             bt[i] = (void *) 0;
 216 #elif __i386__
 217 #define SANE_i386_FRAME_SIZE (kernel_stack_size >> 1)
 218     vm_offset_t stackptr, stackptr_prev, raddr;
 219     unsigned frame_index = 0;
 220 /* Obtain current frame pointer */
 221     __asm__ volatile("movl %%ebp, %0" : "=m" (stackptr));
 222
 223     if (!i386_validate_stackptr(stackptr))
 224             goto pad;
 225
 226     raddr = *((vm_offset_t *) (stackptr + i386_RETURN_OFFSET));
 227
 228     if (!i386_validate_raddr(raddr))
 229             goto pad;
 230
 231     bt[frame_index++] = (void *) raddr;
 232
 233     for ( ; frame_index < maxAddrs; frame_index++) {
 234             stackptr_prev = stackptr;
 235             stackptr = *((vm_offset_t *) stackptr_prev);
 236
 237             if (!i386_validate_stackptr(stackptr))
 238                     break;
 239         /* Stack grows downwards */
 240             if (stackptr < stackptr_prev)
 241                     break;
 242
 243             if ((stackptr - stackptr_prev) > SANE_i386_FRAME_SIZE)
 244                     break;
 245
 246             raddr = *((vm_offset_t *) (stackptr + i386_RETURN_OFFSET));
 247
 248             if (!i386_validate_raddr(raddr))
 249                     break;
 250
 251             bt[frame_index] = (void *) raddr;
 252     }
 253 pad:
 254     frame = frame_index;
 255
 256     for ( ; frame_index < maxAddrs; frame_index++)
 257             bt[frame_index] = (void *) 0;
 258 #elif __x86_64__
 259 #define SANE_x86_64_FRAME_SIZE (kernel_stack_size >> 1)
 260     vm_offset_t stackptr, stackptr_prev, raddr;
 261     unsigned frame_index = 0;
 262 /* Obtain current frame pointer */
 263
 264     __asm__ volatile("movq %%rbp, %0" : "=m" (stackptr));
 265
 266     if (!x86_64_validate_stackptr(stackptr))
 267             goto pad;
 268
 269     raddr = *((vm_offset_t *) (stackptr + x86_64_RETURN_OFFSET));
 270
 271     if (!x86_64_validate_raddr(raddr))
 272             goto pad;
 273
 274     bt[frame_index++] = (void *) raddr;
 275
 276     for ( ; frame_index < maxAddrs; frame_index++) {
 277             stackptr_prev = stackptr;
 278             stackptr = *((vm_offset_t *) stackptr_prev);
 279
 280             if (!x86_64_validate_stackptr(stackptr))
 281                     break;
 282         /* Stack grows downwards */
 283             if (stackptr < stackptr_prev)
 284                     break;
 285
 286             if ((stackptr - stackptr_prev) > SANE_x86_64_FRAME_SIZE)
 287                     break;
 288
 289             raddr = *((vm_offset_t *) (stackptr + x86_64_RETURN_OFFSET));
 290
 291             if (!x86_64_validate_raddr(raddr))
 292                     break;
 293
 294             bt[frame_index] = (void *) raddr;
 295     }
 296 pad:
 297     frame = frame_index;
 298
 299     for ( ; frame_index < maxAddrs; frame_index++)
 300             bt[frame_index] = (void *) 0;
 301 #else
 302 #error arch
 303 #endif
 304     return frame;
 305 }
 306