1 /* $NetBSD: backtrace.c,v 1.7 2014/12/10 04:37:59 christos Exp $ */ 2 3 /* 4 * Copyright (C) 2009, 2013, 2014 Internet Systems Consortium, Inc. ("ISC") 5 * 6 * Permission to use, copy, modify, and/or distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH 11 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 12 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, 13 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 14 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 15 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 /* Id: backtrace.c,v 1.3 2009/09/02 23:48:02 tbox Exp */ 20 21 /*! \file */ 22 23 #include "config.h" 24 25 #include <string.h> 26 #include <stdlib.h> 27 #ifdef HAVE_LIBCTRACE 28 #include <execinfo.h> 29 #endif 30 31 #include <isc/backtrace.h> 32 #include <isc/result.h> 33 #include <isc/util.h> 34 35 #ifdef ISC_PLATFORM_USEBACKTRACE 36 /* 37 * Getting a back trace of a running process is tricky and highly platform 38 * dependent. Our current approach is as follows: 39 * 1. If the system library supports the "backtrace()" function, use it. 40 * 2. Otherwise, if the compiler is gcc and the architecture is x86_64 or IA64, 41 * then use gcc's (hidden) Unwind_Backtrace() function. Note that this 42 * function doesn't work for C programs on many other architectures. 43 * 3. Otherwise, if the architecture x86 or x86_64, try to unwind the stack 44 * frame following frame pointers. This assumes the executable binary 45 * compiled with frame pointers; this is not always true for x86_64 (rather, 46 * compiler optimizations often disable frame pointers). The validation 47 * checks in getnextframeptr() hopefully rejects bogus values stored in 48 * the RBP register in such a case. If the backtrace function itself crashes 49 * due to this problem, the whole package should be rebuilt with 50 * --disable-backtrace. 51 */ 52 #ifdef HAVE_LIBCTRACE 53 #define BACKTRACE_LIBC 54 #elif defined(__GNUC__) && (defined(__x86_64__) || defined(__ia64__)) 55 #define BACKTRACE_GCC 56 #elif defined(WIN32) 57 #define BACKTRACE_WIN32 58 #elif defined(__x86_64__) || defined(__i386__) 59 #define BACKTRACE_X86STACK 60 #else 61 #define BACKTRACE_DISABLED 62 #endif /* HAVE_LIBCTRACE */ 63 #else /* !ISC_PLATFORM_USEBACKTRACE */ 64 #define BACKTRACE_DISABLED 65 #endif /* ISC_PLATFORM_USEBACKTRACE */ 66 67 #ifdef BACKTRACE_LIBC 68 isc_result_t 69 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 70 int n; 71 72 /* 73 * Validate the arguments: intentionally avoid using REQUIRE(). 74 * See notes in backtrace.h. 75 */ 76 if (addrs == NULL || nframes == NULL) 77 return (ISC_R_FAILURE); 78 79 /* 80 * backtrace(3) includes this function itself in the address array, 81 * which should be eliminated from the returned sequence. 82 */ 83 n = backtrace(addrs, maxaddrs); 84 if (n < 2) 85 return (ISC_R_NOTFOUND); 86 n--; 87 memmove(addrs, &addrs[1], sizeof(void *) * n); 88 *nframes = n; 89 return (ISC_R_SUCCESS); 90 } 91 #elif defined(BACKTRACE_GCC) 92 extern int _Unwind_Backtrace(void* fn, void* a); 93 extern void* _Unwind_GetIP(void* ctx); 94 95 typedef struct { 96 void **result; 97 int max_depth; 98 int skip_count; 99 int count; 100 } trace_arg_t; 101 102 static int 103 btcallback(void *uc, void *opq) { 104 trace_arg_t *arg = (trace_arg_t *)opq; 105 106 if (arg->skip_count > 0) 107 arg->skip_count--; 108 else 109 arg->result[arg->count++] = (void *)_Unwind_GetIP(uc); 110 if (arg->count == arg->max_depth) 111 return (5); /* _URC_END_OF_STACK */ 112 113 return (0); /* _URC_NO_REASON */ 114 } 115 116 isc_result_t 117 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 118 trace_arg_t arg; 119 120 /* Argument validation: see above. */ 121 if (addrs == NULL || nframes == NULL) 122 return (ISC_R_FAILURE); 123 124 arg.skip_count = 1; 125 arg.result = addrs; 126 arg.max_depth = maxaddrs; 127 arg.count = 0; 128 _Unwind_Backtrace(btcallback, &arg); 129 130 *nframes = arg.count; 131 132 return (ISC_R_SUCCESS); 133 } 134 #elif defined(BACKTRACE_WIN32) 135 isc_result_t 136 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 137 unsigned long ftc = (unsigned long)maxaddrs; 138 139 *nframes = (int)CaptureStackBackTrace(1, ftc, addrs, NULL); 140 return ISC_R_SUCCESS; 141 } 142 #elif defined(BACKTRACE_X86STACK) 143 #ifdef __x86_64__ 144 static unsigned long 145 getrbp(void) { 146 __asm("movq %rbp, %rax\n"); 147 } 148 #endif 149 150 static void ** 151 getnextframeptr(void **sp) { 152 void **newsp = (void **)*sp; 153 154 /* 155 * Perform sanity check for the new frame pointer, derived from 156 * google glog. This can actually be bogus depending on compiler. 157 */ 158 159 /* prohibit the stack frames from growing downwards */ 160 if (newsp <= sp) 161 return (NULL); 162 163 /* A heuristics to reject "too large" frame: this actually happened. */ 164 if ((char *)newsp - (char *)sp > 100000) 165 return (NULL); 166 167 /* 168 * Not sure if other checks used in glog are needed at this moment. 169 * For our purposes we don't have to consider non-contiguous frames, 170 * for example. 171 */ 172 173 return (newsp); 174 } 175 176 isc_result_t 177 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 178 int i = 0; 179 void **sp; 180 181 /* Argument validation: see above. */ 182 if (addrs == NULL || nframes == NULL) 183 return (ISC_R_FAILURE); 184 185 #ifdef __x86_64__ 186 sp = (void **)getrbp(); 187 if (sp == NULL) 188 return (ISC_R_NOTFOUND); 189 /* 190 * sp is the frame ptr of this function itself due to the call to 191 * getrbp(), so need to unwind one frame for consistency. 192 */ 193 sp = getnextframeptr(sp); 194 #else 195 /* 196 * i386: the frame pointer is stored 2 words below the address for the 197 * first argument. Note that the body of this function cannot be 198 * inlined since it depends on the address of the function argument. 199 */ 200 sp = (void **)(void *)&addrs - 2; 201 #endif 202 203 while (sp != NULL && i < maxaddrs) { 204 addrs[i++] = *(sp + 1); 205 sp = getnextframeptr(sp); 206 } 207 208 *nframes = i; 209 210 return (ISC_R_SUCCESS); 211 } 212 #elif defined(BACKTRACE_DISABLED) 213 isc_result_t 214 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 215 /* Argument validation: see above. */ 216 if (addrs == NULL || nframes == NULL) 217 return (ISC_R_FAILURE); 218 219 UNUSED(maxaddrs); 220 221 return (ISC_R_NOTIMPLEMENTED); 222 } 223 #endif 224 225 isc_result_t 226 isc_backtrace_getsymbolfromindex(int index, const void **addrp, 227 const char **symbolp) 228 { 229 REQUIRE(addrp != NULL && *addrp == NULL); 230 REQUIRE(symbolp != NULL && *symbolp == NULL); 231 232 if (index < 0 || index >= isc__backtrace_nsymbols) 233 return (ISC_R_RANGE); 234 235 *addrp = isc__backtrace_symtable[index].addr; 236 *symbolp = isc__backtrace_symtable[index].symbol; 237 return (ISC_R_SUCCESS); 238 } 239 240 static int 241 symtbl_compare(const void *addr, const void *entryarg) { 242 const isc_backtrace_symmap_t *entry = entryarg; 243 const isc_backtrace_symmap_t *end = 244 &isc__backtrace_symtable[isc__backtrace_nsymbols - 1]; 245 246 if (isc__backtrace_nsymbols == 1 || entry == end) { 247 if (addr >= entry->addr) { 248 /* 249 * If addr is equal to or larger than that of the last 250 * entry of the table, we cannot be sure if this is 251 * within a valid range so we consider it valid. 252 */ 253 return (0); 254 } 255 return (-1); 256 } 257 258 /* entry + 1 is a valid entry from now on. */ 259 if (addr < entry->addr) 260 return (-1); 261 else if (addr >= (entry + 1)->addr) 262 return (1); 263 return (0); 264 } 265 266 isc_result_t 267 isc_backtrace_getsymbol(const void *addr, const char **symbolp, 268 unsigned long *offsetp) 269 { 270 isc_result_t result = ISC_R_SUCCESS; 271 isc_backtrace_symmap_t *found; 272 273 /* 274 * Validate the arguments: intentionally avoid using REQUIRE(). 275 * See notes in backtrace.h. 276 */ 277 if (symbolp == NULL || *symbolp != NULL || offsetp == NULL) 278 return (ISC_R_FAILURE); 279 280 if (isc__backtrace_nsymbols < 1) 281 return (ISC_R_NOTFOUND); 282 283 /* 284 * Search the table for the entry that meets: 285 * entry.addr <= addr < next_entry.addr. 286 */ 287 found = bsearch(addr, isc__backtrace_symtable, isc__backtrace_nsymbols, 288 sizeof(isc__backtrace_symtable[0]), symtbl_compare); 289 if (found == NULL) 290 result = ISC_R_NOTFOUND; 291 else { 292 *symbolp = found->symbol; 293 *offsetp = (unsigned long) ((const char *)addr - 294 (char *)found->addr); 295 } 296 297 return (result); 298 } 299