granicus.if.org Git - strace/blob - unwind.c

   1 /*
   2  * Copyright (c) 2013 Luca Clementi <luca.clementi@gmail.com>
   3  * Copyright (c) 2013-2018 The strace developers.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "defs.h"
  29 #include "unwind.h"
  30
  31 #ifdef USE_DEMANGLE
  32 # if defined HAVE_DEMANGLE_H
  33 #  include <demangle.h>
  34 # elif defined HAVE_LIBIBERTY_DEMANGLE_H
  35 #  include <libiberty/demangle.h>
  36 # endif
  37 #endif
  38
  39 /*
  40  * Type used in stacktrace capturing
  41  */
  42 struct call_t {
  43         struct call_t *next;
  44         char *output_line;
  45 };
  46
  47 struct unwind_queue_t {
  48         struct call_t *tail;
  49         struct call_t *head;
  50 };
  51
  52 static void queue_print(struct unwind_queue_t *queue);
  53
  54 static const char asprintf_error_str[] = "???";
  55
  56 void
  57 unwind_init(void)
  58 {
  59         if (unwinder.init)
  60                 unwinder.init();
  61 }
  62
  63 void
  64 unwind_tcb_init(struct tcb *tcp)
  65 {
  66         if (tcp->unwind_queue)
  67                 return;
  68
  69         tcp->unwind_queue = xmalloc(sizeof(*tcp->unwind_queue));
  70         tcp->unwind_queue->head = NULL;
  71         tcp->unwind_queue->tail = NULL;
  72
  73         tcp->unwind_ctx = unwinder.tcb_init(tcp);
  74 }
  75
  76 void
  77 unwind_tcb_fin(struct tcb *tcp)
  78 {
  79         if (!tcp->unwind_queue)
  80                 return;
  81
  82         queue_print(tcp->unwind_queue);
  83         free(tcp->unwind_queue);
  84         tcp->unwind_queue = NULL;
  85
  86         unwinder.tcb_fin(tcp);
  87         tcp->unwind_ctx = NULL;
  88 }
  89
  90 /*
  91  * printing an entry in stack to stream or buffer
  92  */
  93 /*
  94  * we want to keep the format used by backtrace_symbols from the glibc
  95  *
  96  * ./a.out() [0x40063d]
  97  * ./a.out() [0x4006bb]
  98  * ./a.out() [0x4006c6]
  99  * /lib64/libc.so.6(__libc_start_main+0xed) [0x7fa2f8a5976d]
 100  * ./a.out() [0x400569]
 101  */
 102 #define STACK_ENTRY_SYMBOL_FMT(SYM)             \
 103         " > %s(%s+0x%lx) [0x%lx]\n",            \
 104         binary_filename,                        \
 105         (SYM),                                  \
 106         (unsigned long) function_offset,        \
 107         true_offset
 108 #define STACK_ENTRY_NOSYMBOL_FMT                \
 109         " > %s() [0x%lx]\n",                    \
 110         binary_filename, true_offset
 111 #define STACK_ENTRY_BUG_FMT                     \
 112         " > BUG IN %s\n"
 113 #define STACK_ENTRY_ERROR_WITH_OFFSET_FMT       \
 114         " > %s [0x%lx]\n", error, true_offset
 115 #define STACK_ENTRY_ERROR_FMT                   \
 116         " > %s\n", error
 117
 118 static void
 119 print_call_cb(void *dummy,
 120               const char *binary_filename,
 121               const char *symbol_name,
 122               unwind_function_offset_t function_offset,
 123               unsigned long true_offset)
 124 {
 125         if (symbol_name && (symbol_name[0] != '\0')) {
 126 #ifdef USE_DEMANGLE
 127                 char *demangled_name =
 128                         cplus_demangle(symbol_name,
 129                                        DMGL_AUTO | DMGL_PARAMS);
 130 #endif
 131                 tprintf(STACK_ENTRY_SYMBOL_FMT(
 132 #ifdef USE_DEMANGLE
 133                                                demangled_name ? demangled_name :
 134 #endif
 135                                                symbol_name));
 136 #ifdef USE_DEMANGLE
 137                 free(demangled_name);
 138 #endif
 139         }
 140         else if (binary_filename)
 141                 tprintf(STACK_ENTRY_NOSYMBOL_FMT);
 142         else
 143                 tprintf(STACK_ENTRY_BUG_FMT, __func__);
 144
 145         line_ended();
 146 }
 147
 148 static void
 149 print_error_cb(void *dummy,
 150                const char *error,
 151                unsigned long true_offset)
 152 {
 153         if (true_offset)
 154                 tprintf(STACK_ENTRY_ERROR_WITH_OFFSET_FMT);
 155         else
 156                 tprintf(STACK_ENTRY_ERROR_FMT);
 157
 158         line_ended();
 159 }
 160
 161 static char *
 162 sprint_call_or_error(const char *binary_filename,
 163                      const char *symbol_name,
 164                      unwind_function_offset_t function_offset,
 165                      unsigned long true_offset,
 166                      const char *error)
 167 {
 168         char *output_line = NULL;
 169         int n;
 170
 171         if (symbol_name) {
 172 #ifdef USE_DEMANGLE
 173                 char *demangled_name =
 174                         cplus_demangle(symbol_name,
 175                                        DMGL_AUTO | DMGL_PARAMS);
 176 #endif
 177                 n = asprintf(&output_line,
 178                              STACK_ENTRY_SYMBOL_FMT(
 179 #ifdef USE_DEMANGLE
 180                                                     demangled_name ? demangled_name :
 181 #endif
 182                                                     symbol_name));
 183 #ifdef USE_DEMANGLE
 184                 free(demangled_name);
 185 #endif
 186         }
 187         else if (binary_filename)
 188                 n = asprintf(&output_line, STACK_ENTRY_NOSYMBOL_FMT);
 189         else if (error)
 190                 n = true_offset
 191                         ? asprintf(&output_line, STACK_ENTRY_ERROR_WITH_OFFSET_FMT)
 192                         : asprintf(&output_line, STACK_ENTRY_ERROR_FMT);
 193         else
 194                 n = asprintf(&output_line, STACK_ENTRY_BUG_FMT, __func__);
 195
 196         if (n < 0) {
 197                 perror_func_msg("asprintf");
 198                 output_line = (char *) asprintf_error_str;
 199         }
 200
 201         return output_line;
 202 }
 203
 204 /*
 205  * queue manipulators
 206  */
 207 static void
 208 queue_put(struct unwind_queue_t *queue,
 209           const char *binary_filename,
 210           const char *symbol_name,
 211           unwind_function_offset_t function_offset,
 212           unsigned long true_offset,
 213           const char *error)
 214 {
 215         struct call_t *call;
 216
 217         call = xmalloc(sizeof(*call));
 218         call->output_line = sprint_call_or_error(binary_filename,
 219                                                  symbol_name,
 220                                                  function_offset,
 221                                                  true_offset,
 222                                                  error);
 223         call->next = NULL;
 224
 225         if (!queue->head) {
 226                 queue->head = call;
 227                 queue->tail = call;
 228         } else {
 229                 queue->tail->next = call;
 230                 queue->tail = call;
 231         }
 232 }
 233
 234 static void
 235 queue_put_call(void *queue,
 236                const char *binary_filename,
 237                const char *symbol_name,
 238                unwind_function_offset_t function_offset,
 239                unsigned long true_offset)
 240 {
 241         queue_put(queue,
 242                   binary_filename,
 243                   symbol_name,
 244                   function_offset,
 245                   true_offset,
 246                   NULL);
 247 }
 248
 249 static void
 250 queue_put_error(void *queue,
 251                 const char *error,
 252                 unsigned long ip)
 253 {
 254         queue_put(queue, NULL, NULL, 0, ip, error);
 255 }
 256
 257 static void
 258 queue_print(struct unwind_queue_t *queue)
 259 {
 260         struct call_t *call, *tmp;
 261
 262         queue->tail = NULL;
 263         call = queue->head;
 264         queue->head = NULL;
 265         while (call) {
 266                 tmp = call;
 267                 call = call->next;
 268
 269                 tprints(tmp->output_line);
 270                 line_ended();
 271
 272                 if (tmp->output_line != asprintf_error_str)
 273                         free(tmp->output_line);
 274
 275                 tmp->output_line = NULL;
 276                 tmp->next = NULL;
 277                 free(tmp);
 278         }
 279 }
 280
 281 /*
 282  * printing stack
 283  */
 284 void
 285 unwind_tcb_print(struct tcb *tcp)
 286 {
 287 #if SUPPORTED_PERSONALITIES > 1
 288         if (tcp->currpers != DEFAULT_PERSONALITY) {
 289                 /* disable stack trace */
 290                 return;
 291         }
 292 #endif
 293         if (tcp->unwind_queue->head) {
 294                 debug_func_msg("head: tcp=%p, queue=%p",
 295                                tcp, tcp->unwind_queue->head);
 296                 queue_print(tcp->unwind_queue);
 297         } else
 298                 unwinder.tcb_walk(tcp, print_call_cb, print_error_cb, NULL);
 299 }
 300
 301 /*
 302  * capturing stack
 303  */
 304 void
 305 unwind_tcb_capture(struct tcb *tcp)
 306 {
 307 #if SUPPORTED_PERSONALITIES > 1
 308         if (tcp->currpers != DEFAULT_PERSONALITY) {
 309                 /* disable stack trace */
 310                 return;
 311         }
 312 #endif
 313         if (tcp->unwind_queue->head)
 314                 error_msg_and_die("bug: unprinted entries in queue");
 315         else {
 316                 debug_func_msg("walk: tcp=%p, queue=%p",
 317                                tcp, tcp->unwind_queue->head);
 318                 unwinder.tcb_walk(tcp, queue_put_call, queue_put_error,
 319                                   tcp->unwind_queue);
 320         }
 321 }