contrib/bind9/lib/isc/backtrace.c

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