1 /* $NetBSD: backtrace.c,v 1.2 2024/08/18 20:47:14 christos Exp $ */ 2 3 /* 4 * Copyright (C) 2009 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(__x86_64__) || defined(__i386__) 57 #define BACKTRACE_X86STACK 58 #else 59 #define BACKTRACE_DISABLED 60 #endif /* HAVE_LIBCTRACE */ 61 #else /* !ISC_PLATFORM_USEBACKTRACE */ 62 #define BACKTRACE_DISABLED 63 #endif /* ISC_PLATFORM_USEBACKTRACE */ 64 65 #ifdef BACKTRACE_LIBC 66 isc_result_t 67 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 68 int n; 69 70 /* 71 * Validate the arguments: intentionally avoid using REQUIRE(). 72 * See notes in backtrace.h. 73 */ 74 if (addrs == NULL || nframes == NULL) 75 return (ISC_R_FAILURE); 76 77 /* 78 * backtrace(3) includes this function itself in the address array, 79 * which should be eliminated from the returned sequence. 80 */ 81 n = backtrace(addrs, maxaddrs); 82 if (n < 2) 83 return (ISC_R_NOTFOUND); 84 n--; 85 memmove(addrs, &addrs[1], sizeof(void *) * n); 86 *nframes = n; 87 return (ISC_R_SUCCESS); 88 } 89 #elif defined(BACKTRACE_GCC) 90 extern int _Unwind_Backtrace(void* fn, void* a); 91 extern void* _Unwind_GetIP(void* ctx); 92 93 typedef struct { 94 void **result; 95 int max_depth; 96 int skip_count; 97 int count; 98 } trace_arg_t; 99 100 static int 101 btcallback(void *uc, void *opq) { 102 trace_arg_t *arg = (trace_arg_t *)opq; 103 104 if (arg->skip_count > 0) 105 arg->skip_count--; 106 else 107 arg->result[arg->count++] = (void *)_Unwind_GetIP(uc); 108 if (arg->count == arg->max_depth) 109 return (5); /* _URC_END_OF_STACK */ 110 111 return (0); /* _URC_NO_REASON */ 112 } 113 114 isc_result_t 115 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 116 trace_arg_t arg; 117 118 /* Argument validation: see above. */ 119 if (addrs == NULL || nframes == NULL) 120 return (ISC_R_FAILURE); 121 122 arg.skip_count = 1; 123 arg.result = addrs; 124 arg.max_depth = maxaddrs; 125 arg.count = 0; 126 _Unwind_Backtrace(btcallback, &arg); 127 128 *nframes = arg.count; 129 130 return (ISC_R_SUCCESS); 131 } 132 #elif defined(BACKTRACE_X86STACK) 133 #ifdef __x86_64__ 134 static unsigned long 135 getrbp() { 136 __asm("movq %rbp, %rax\n"); 137 } 138 #endif 139 140 static void ** 141 getnextframeptr(void **sp) { 142 void **newsp = (void **)*sp; 143 144 /* 145 * Perform sanity check for the new frame pointer, derived from 146 * google glog. This can actually be bogus depending on compiler. 147 */ 148 149 /* prohibit the stack frames from growing downwards */ 150 if (newsp <= sp) 151 return (NULL); 152 153 /* A heuristics to reject "too large" frame: this actually happened. */ 154 if ((char *)newsp - (char *)sp > 100000) 155 return (NULL); 156 157 /* 158 * Not sure if other checks used in glog are needed at this moment. 159 * For our purposes we don't have to consider non-contiguous frames, 160 * for example. 161 */ 162 163 return (newsp); 164 } 165 166 isc_result_t 167 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 168 int i = 0; 169 void **sp; 170 171 /* Argument validation: see above. */ 172 if (addrs == NULL || nframes == NULL) 173 return (ISC_R_FAILURE); 174 175 #ifdef __x86_64__ 176 sp = (void **)getrbp(); 177 if (sp == NULL) 178 return (ISC_R_NOTFOUND); 179 /* 180 * sp is the frame ptr of this function itself due to the call to 181 * getrbp(), so need to unwind one frame for consistency. 182 */ 183 sp = getnextframeptr(sp); 184 #else 185 /* 186 * i386: the frame pointer is stored 2 words below the address for the 187 * first argument. Note that the body of this function cannot be 188 * inlined since it depends on the address of the function argument. 189 */ 190 sp = (void **)&addrs - 2; 191 #endif 192 193 while (sp != NULL && i < maxaddrs) { 194 addrs[i++] = *(sp + 1); 195 sp = getnextframeptr(sp); 196 } 197 198 *nframes = i; 199 200 return (ISC_R_SUCCESS); 201 } 202 #elif defined(BACKTRACE_DISABLED) 203 isc_result_t 204 isc_backtrace_gettrace(void **addrs, int maxaddrs, int *nframes) { 205 /* Argument validation: see above. */ 206 if (addrs == NULL || nframes == NULL) 207 return (ISC_R_FAILURE); 208 209 UNUSED(maxaddrs); 210 211 return (ISC_R_NOTIMPLEMENTED); 212 } 213 #endif 214 215 isc_result_t 216 isc_backtrace_getsymbolfromindex(int idx, const void **addrp, 217 const char **symbolp) 218 { 219 REQUIRE(addrp != NULL && *addrp == NULL); 220 REQUIRE(symbolp != NULL && *symbolp == NULL); 221 222 if (idx < 0 || idx >= isc__backtrace_nsymbols) 223 return (ISC_R_RANGE); 224 225 *addrp = isc__backtrace_symtable[idx].addr; 226 *symbolp = isc__backtrace_symtable[idx].symbol; 227 return (ISC_R_SUCCESS); 228 } 229 230 static int 231 symtbl_compare(const void *addr, const void *entryarg) { 232 const isc_backtrace_symmap_t *entry = entryarg; 233 const isc_backtrace_symmap_t *end = 234 &isc__backtrace_symtable[isc__backtrace_nsymbols - 1]; 235 236 if (isc__backtrace_nsymbols == 1 || entry == end) { 237 if (addr >= entry->addr) { 238 /* 239 * If addr is equal to or larger than that of the last 240 * entry of the table, we cannot be sure if this is 241 * within a valid range so we consider it valid. 242 */ 243 return (0); 244 } 245 return (-1); 246 } 247 248 /* entry + 1 is a valid entry from now on. */ 249 if (addr < entry->addr) 250 return (-1); 251 else if (addr >= (entry + 1)->addr) 252 return (1); 253 return (0); 254 } 255 256 isc_result_t 257 isc_backtrace_getsymbol(const void *addr, const char **symbolp, 258 unsigned long *offsetp) 259 { 260 isc_result_t result = ISC_R_SUCCESS; 261 isc_backtrace_symmap_t *found; 262 263 /* 264 * Validate the arguments: intentionally avoid using REQUIRE(). 265 * See notes in backtrace.h. 266 */ 267 if (symbolp == NULL || *symbolp != NULL || offsetp == NULL) 268 return (ISC_R_FAILURE); 269 270 if (isc__backtrace_nsymbols < 1) 271 return (ISC_R_NOTFOUND); 272 273 /* 274 * Search the table for the entry that meets: 275 * entry.addr <= addr < next_entry.addr. 276 */ 277 found = bsearch(addr, isc__backtrace_symtable, isc__backtrace_nsymbols, 278 sizeof(isc__backtrace_symtable[0]), symtbl_compare); 279 if (found == NULL) 280 result = ISC_R_NOTFOUND; 281 else { 282 *symbolp = found->symbol; 283 *offsetp = (u_long)((const char *)addr - (char *)found->addr); 284 } 285 286 return (result); 287 } 288