1 /* 2 * Copyright (c) 2013 Luca Clementi <luca.clementi (at) gmail.com> 3 * Copyright (c) 2013-2017 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 <limits.h> 30 #include <libunwind-ptrace.h> 31 32 #ifdef _LARGEFILE64_SOURCE 33 # ifdef HAVE_FOPEN64 34 # define fopen_for_input fopen64 35 # else 36 # define fopen_for_input fopen 37 # endif 38 #else 39 # define fopen_for_input fopen 40 #endif 41 42 #define DPRINTF(F, A, ...) \ 43 do { \ 44 if (debug_flag) \ 45 error_msg("[unwind(" A ")] " F, __VA_ARGS__); \ 46 } while (0) 47 48 /* 49 * Keep a sorted array of cache entries, 50 * so that we can binary search through it. 51 */ 52 struct mmap_cache_t { 53 /** 54 * example entry: 55 * 7fabbb09b000-7fabbb09f000 r-xp 00179000 fc:00 1180246 /lib/libc-2.11.1.so 56 * 57 * start_addr is 0x7fabbb09b000 58 * end_addr is 0x7fabbb09f000 59 * mmap_offset is 0x179000 60 * binary_filename is "/lib/libc-2.11.1.so" 61 */ 62 unsigned long start_addr; 63 unsigned long end_addr; 64 unsigned long mmap_offset; 65 char *binary_filename; 66 }; 67 68 /* 69 * Type used in stacktrace walker 70 */ 71 typedef void (*call_action_fn)(void *data, 72 const char *binary_filename, 73 const char *symbol_name, 74 unw_word_t function_offset, 75 unsigned long true_offset); 76 typedef void (*error_action_fn)(void *data, 77 const char *error, 78 unsigned long true_offset); 79 80 /* 81 * Type used in stacktrace capturing 82 */ 83 struct call_t { 84 struct call_t *next; 85 char *output_line; 86 }; 87 88 struct queue_t { 89 struct call_t *tail; 90 struct call_t *head; 91 }; 92 93 static void queue_print(struct queue_t *queue); 94 static void delete_mmap_cache(struct tcb *tcp, const char *caller); 95 96 static unw_addr_space_t libunwind_as; 97 static unsigned int mmap_cache_generation; 98 99 void 100 unwind_init(void) 101 { 102 libunwind_as = unw_create_addr_space(&_UPT_accessors, 0); 103 if (!libunwind_as) 104 error_msg_and_die("failed to create address space for stack tracing"); 105 unw_set_caching_policy(libunwind_as, UNW_CACHE_GLOBAL); 106 } 107 108 void 109 unwind_tcb_init(struct tcb *tcp) 110 { 111 if (tcp->libunwind_ui) 112 return; 113 114 tcp->libunwind_ui = _UPT_create(tcp->pid); 115 if (!tcp->libunwind_ui) 116 perror_msg_and_die("_UPT_create"); 117 118 tcp->queue = xmalloc(sizeof(*tcp->queue)); 119 tcp->queue->head = NULL; 120 tcp->queue->tail = NULL; 121 } 122 123 void 124 unwind_tcb_fin(struct tcb *tcp) 125 { 126 queue_print(tcp->queue); 127 free(tcp->queue); 128 tcp->queue = NULL; 129 130 delete_mmap_cache(tcp, __func__); 131 132 _UPT_destroy(tcp->libunwind_ui); 133 tcp->libunwind_ui = NULL; 134 } 135 136 /* 137 * caching of /proc/ID/maps for each process to speed up stack tracing 138 * 139 * The cache must be refreshed after syscalls that affect memory mappings, 140 * e.g. mmap, mprotect, munmap, execve. 141 */ 142 static void 143 build_mmap_cache(struct tcb *tcp) 144 { 145 FILE *fp; 146 struct mmap_cache_t *cache_head; 147 /* start with a small dynamically-allocated array and then expand it */ 148 size_t cur_array_size = 10; 149 char filename[sizeof("/proc/4294967296/maps")]; 150 char buffer[PATH_MAX + 80]; 151 152 unw_flush_cache(libunwind_as, 0, 0); 153 154 sprintf(filename, "/proc/%u/maps", tcp->pid); 155 fp = fopen_for_input(filename, "r"); 156 if (!fp) { 157 perror_msg("fopen: %s", filename); 158 return; 159 } 160 161 cache_head = xcalloc(cur_array_size, sizeof(*cache_head)); 162 163 while (fgets(buffer, sizeof(buffer), fp) != NULL) { 164 struct mmap_cache_t *entry; 165 unsigned long start_addr, end_addr, mmap_offset; 166 char exec_bit; 167 char binary_path[sizeof(buffer)]; 168 169 if (sscanf(buffer, "%lx-%lx %*c%*c%c%*c %lx %*x:%*x %*d %[^\n]", 170 &start_addr, &end_addr, &exec_bit, 171 &mmap_offset, binary_path) != 5) 172 continue; 173 174 /* ignore mappings that have no PROT_EXEC bit set */ 175 if (exec_bit != 'x') 176 continue; 177 178 if (end_addr < start_addr) { 179 error_msg("%s: unrecognized file format", filename); 180 break; 181 } 182 183 /* 184 * sanity check to make sure that we're storing 185 * non-overlapping regions in ascending order 186 */ 187 if (tcp->mmap_cache_size > 0) { 188 entry = &cache_head[tcp->mmap_cache_size - 1]; 189 if (entry->start_addr == start_addr && 190 entry->end_addr == end_addr) { 191 /* duplicate entry, e.g. [vsyscall] */ 192 continue; 193 } 194 if (start_addr <= entry->start_addr || 195 start_addr < entry->end_addr) { 196 error_msg("%s: overlapping memory region", 197 filename); 198 continue; 199 } 200 } 201 202 if (tcp->mmap_cache_size >= cur_array_size) { 203 cur_array_size *= 2; 204 cache_head = xreallocarray(cache_head, cur_array_size, 205 sizeof(*cache_head)); 206 } 207 208 entry = &cache_head[tcp->mmap_cache_size]; 209 entry->start_addr = start_addr; 210 entry->end_addr = end_addr; 211 entry->mmap_offset = mmap_offset; 212 entry->binary_filename = xstrdup(binary_path); 213 tcp->mmap_cache_size++; 214 } 215 fclose(fp); 216 tcp->mmap_cache = cache_head; 217 tcp->mmap_cache_generation = mmap_cache_generation; 218 219 DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p", 220 "cache-build", 221 tcp->mmap_cache_generation, 222 mmap_cache_generation, 223 tcp, tcp->mmap_cache); 224 } 225 226 /* deleting the cache */ 227 static void 228 delete_mmap_cache(struct tcb *tcp, const char *caller) 229 { 230 unsigned int i; 231 232 DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p, caller=%s", 233 "cache-delete", 234 tcp->mmap_cache_generation, 235 mmap_cache_generation, 236 tcp, tcp->mmap_cache, caller); 237 238 for (i = 0; i < tcp->mmap_cache_size; i++) { 239 free(tcp->mmap_cache[i].binary_filename); 240 tcp->mmap_cache[i].binary_filename = NULL; 241 } 242 free(tcp->mmap_cache); 243 tcp->mmap_cache = NULL; 244 tcp->mmap_cache_size = 0; 245 } 246 247 static bool 248 rebuild_cache_if_invalid(struct tcb *tcp, const char *caller) 249 { 250 if ((tcp->mmap_cache_generation != mmap_cache_generation) 251 && tcp->mmap_cache) 252 delete_mmap_cache(tcp, caller); 253 254 if (!tcp->mmap_cache) 255 build_mmap_cache(tcp); 256 257 if (!tcp->mmap_cache || !tcp->mmap_cache_size) 258 return false; 259 else 260 return true; 261 } 262 263 void 264 unwind_cache_invalidate(struct tcb *tcp) 265 { 266 #if SUPPORTED_PERSONALITIES > 1 267 if (tcp->currpers != DEFAULT_PERSONALITY) { 268 /* disable strack trace */ 269 return; 270 } 271 #endif 272 mmap_cache_generation++; 273 DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p", "increment", 274 tcp->mmap_cache_generation, 275 mmap_cache_generation, 276 tcp, 277 tcp->mmap_cache); 278 } 279 280 static void 281 get_symbol_name(unw_cursor_t *cursor, char **name, 282 size_t *size, unw_word_t *offset) 283 { 284 for (;;) { 285 int rc = unw_get_proc_name(cursor, *name, *size, offset); 286 if (rc == 0) 287 break; 288 if (rc != -UNW_ENOMEM) { 289 **name = '\0'; 290 *offset = 0; 291 break; 292 } 293 *name = xreallocarray(*name, 2, *size); 294 *size *= 2; 295 } 296 } 297 298 static int 299 print_stack_frame(struct tcb *tcp, 300 call_action_fn call_action, 301 error_action_fn error_action, 302 void *data, 303 unw_cursor_t *cursor, 304 char **symbol_name, 305 size_t *symbol_name_size) 306 { 307 unw_word_t ip; 308 int lower = 0; 309 int upper = (int) tcp->mmap_cache_size - 1; 310 311 if (unw_get_reg(cursor, UNW_REG_IP, &ip) < 0) { 312 perror_msg("Can't walk the stack of process %d", tcp->pid); 313 return -1; 314 } 315 316 while (lower <= upper) { 317 struct mmap_cache_t *cur_mmap_cache; 318 int mid = (upper + lower) / 2; 319 320 cur_mmap_cache = &tcp->mmap_cache[mid]; 321 322 if (ip >= cur_mmap_cache->start_addr && 323 ip < cur_mmap_cache->end_addr) { 324 unsigned long true_offset; 325 unw_word_t function_offset; 326 327 get_symbol_name(cursor, symbol_name, symbol_name_size, 328 &function_offset); 329 true_offset = ip - cur_mmap_cache->start_addr + 330 cur_mmap_cache->mmap_offset; 331 call_action(data, 332 cur_mmap_cache->binary_filename, 333 *symbol_name, 334 function_offset, 335 true_offset); 336 return 0; 337 } else if (ip < cur_mmap_cache->start_addr) 338 upper = mid - 1; 339 else 340 lower = mid + 1; 341 } 342 343 /* 344 * there is a bug in libunwind >= 1.0 345 * after a set_tid_address syscall 346 * unw_get_reg returns IP == 0 347 */ 348 if (ip) 349 error_action(data, "unexpected_backtracing_error", ip); 350 return -1; 351 } 352 353 /* 354 * walking the stack 355 */ 356 static void 357 stacktrace_walk(struct tcb *tcp, 358 call_action_fn call_action, 359 error_action_fn error_action, 360 void *data) 361 { 362 char *symbol_name; 363 size_t symbol_name_size = 40; 364 unw_cursor_t cursor; 365 int stack_depth; 366 367 if (!tcp->mmap_cache) 368 error_msg_and_die("bug: mmap_cache is NULL"); 369 if (tcp->mmap_cache_size == 0) 370 error_msg_and_die("bug: mmap_cache is empty"); 371 372 symbol_name = xmalloc(symbol_name_size); 373 374 if (unw_init_remote(&cursor, libunwind_as, tcp->libunwind_ui) < 0) 375 perror_msg_and_die("Can't initiate libunwind"); 376 377 for (stack_depth = 0; stack_depth < 256; ++stack_depth) { 378 if (print_stack_frame(tcp, call_action, error_action, data, 379 &cursor, &symbol_name, &symbol_name_size) < 0) 380 break; 381 if (unw_step(&cursor) <= 0) 382 break; 383 } 384 if (stack_depth >= 256) 385 error_action(data, "too many stack frames", 0); 386 387 free(symbol_name); 388 } 389 390 /* 391 * printing an entry in stack to stream or buffer 392 */ 393 /* 394 * we want to keep the format used by backtrace_symbols from the glibc 395 * 396 * ./a.out() [0x40063d] 397 * ./a.out() [0x4006bb] 398 * ./a.out() [0x4006c6] 399 * /lib64/libc.so.6(__libc_start_main+0xed) [0x7fa2f8a5976d] 400 * ./a.out() [0x400569] 401 */ 402 #define STACK_ENTRY_SYMBOL_FMT \ 403 " > %s(%s+0x%lx) [0x%lx]\n", \ 404 binary_filename, \ 405 symbol_name, \ 406 (unsigned long) function_offset, \ 407 true_offset 408 #define STACK_ENTRY_NOSYMBOL_FMT \ 409 " > %s() [0x%lx]\n", \ 410 binary_filename, true_offset 411 #define STACK_ENTRY_BUG_FMT \ 412 " > BUG IN %s\n" 413 #define STACK_ENTRY_ERROR_WITH_OFFSET_FMT \ 414 " > %s [0x%lx]\n", error, true_offset 415 #define STACK_ENTRY_ERROR_FMT \ 416 " > %s\n", error 417 418 static void 419 print_call_cb(void *dummy, 420 const char *binary_filename, 421 const char *symbol_name, 422 unw_word_t function_offset, 423 unsigned long true_offset) 424 { 425 if (symbol_name && (symbol_name[0] != '\0')) 426 tprintf(STACK_ENTRY_SYMBOL_FMT); 427 else if (binary_filename) 428 tprintf(STACK_ENTRY_NOSYMBOL_FMT); 429 else 430 tprintf(STACK_ENTRY_BUG_FMT, __func__); 431 432 line_ended(); 433 } 434 435 static void 436 print_error_cb(void *dummy, 437 const char *error, 438 unsigned long true_offset) 439 { 440 if (true_offset) 441 tprintf(STACK_ENTRY_ERROR_WITH_OFFSET_FMT); 442 else 443 tprintf(STACK_ENTRY_ERROR_FMT); 444 445 line_ended(); 446 } 447 448 static char * 449 sprint_call_or_error(const char *binary_filename, 450 const char *symbol_name, 451 unw_word_t function_offset, 452 unsigned long true_offset, 453 const char *error) 454 { 455 char *output_line = NULL; 456 int n; 457 458 if (symbol_name) 459 n = asprintf(&output_line, STACK_ENTRY_SYMBOL_FMT); 460 else if (binary_filename) 461 n = asprintf(&output_line, STACK_ENTRY_NOSYMBOL_FMT); 462 else if (error) 463 n = true_offset 464 ? asprintf(&output_line, STACK_ENTRY_ERROR_WITH_OFFSET_FMT) 465 : asprintf(&output_line, STACK_ENTRY_ERROR_FMT); 466 else 467 n = asprintf(&output_line, STACK_ENTRY_BUG_FMT, __func__); 468 469 if (n < 0) 470 error_msg_and_die("error in asprintf"); 471 472 return output_line; 473 } 474 475 /* 476 * queue manipulators 477 */ 478 static void 479 queue_put(struct queue_t *queue, 480 const char *binary_filename, 481 const char *symbol_name, 482 unw_word_t function_offset, 483 unsigned long true_offset, 484 const char *error) 485 { 486 struct call_t *call; 487 488 call = xmalloc(sizeof(*call)); 489 call->output_line = sprint_call_or_error(binary_filename, 490 symbol_name, 491 function_offset, 492 true_offset, 493 error); 494 call->next = NULL; 495 496 if (!queue->head) { 497 queue->head = call; 498 queue->tail = call; 499 } else { 500 queue->tail->next = call; 501 queue->tail = call; 502 } 503 } 504 505 static void 506 queue_put_call(void *queue, 507 const char *binary_filename, 508 const char *symbol_name, 509 unw_word_t function_offset, 510 unsigned long true_offset) 511 { 512 queue_put(queue, 513 binary_filename, 514 symbol_name, 515 function_offset, 516 true_offset, 517 NULL); 518 } 519 520 static void 521 queue_put_error(void *queue, 522 const char *error, 523 unsigned long ip) 524 { 525 queue_put(queue, NULL, NULL, 0, ip, error); 526 } 527 528 static void 529 queue_print(struct queue_t *queue) 530 { 531 struct call_t *call, *tmp; 532 533 queue->tail = NULL; 534 call = queue->head; 535 queue->head = NULL; 536 while (call) { 537 tmp = call; 538 call = call->next; 539 540 tprints(tmp->output_line); 541 line_ended(); 542 543 free(tmp->output_line); 544 tmp->output_line = NULL; 545 tmp->next = NULL; 546 free(tmp); 547 } 548 } 549 550 /* 551 * printing stack 552 */ 553 void 554 unwind_print_stacktrace(struct tcb *tcp) 555 { 556 #if SUPPORTED_PERSONALITIES > 1 557 if (tcp->currpers != DEFAULT_PERSONALITY) { 558 /* disable strack trace */ 559 return; 560 } 561 #endif 562 if (tcp->queue->head) { 563 DPRINTF("tcp=%p, queue=%p", "queueprint", tcp, tcp->queue->head); 564 queue_print(tcp->queue); 565 } else if (rebuild_cache_if_invalid(tcp, __func__)) { 566 DPRINTF("tcp=%p, queue=%p", "stackprint", tcp, tcp->queue->head); 567 stacktrace_walk(tcp, print_call_cb, print_error_cb, NULL); 568 } 569 } 570 571 /* 572 * capturing stack 573 */ 574 void 575 unwind_capture_stacktrace(struct tcb *tcp) 576 { 577 #if SUPPORTED_PERSONALITIES > 1 578 if (tcp->currpers != DEFAULT_PERSONALITY) { 579 /* disable strack trace */ 580 return; 581 } 582 #endif 583 if (tcp->queue->head) 584 error_msg_and_die("bug: unprinted entries in queue"); 585 586 if (rebuild_cache_if_invalid(tcp, __func__)) { 587 stacktrace_walk(tcp, queue_put_call, queue_put_error, 588 tcp->queue); 589 DPRINTF("tcp=%p, queue=%p", "captured", tcp, tcp->queue->head); 590 } 591 } 592
