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