1 /* 2 * Copyright (c) 2013 Luca Clementi <luca.clementi (at) gmail.com> 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. The name of the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include "defs.h" 28 #include <limits.h> 29 #include <libunwind-ptrace.h> 30 31 #ifdef _LARGEFILE64_SOURCE 32 # ifdef HAVE_FOPEN64 33 # define fopen_for_input fopen64 34 # else 35 # define fopen_for_input fopen 36 # endif 37 #else 38 # define fopen_for_input fopen 39 #endif 40 41 #define DPRINTF(F, A, ...) if (debug_flag) fprintf(stderr, " [unwind(" A ")] " F "\n", __VA_ARGS__) 42 43 /* 44 * eep a sorted array of cache entries, 45 * so that we can binary search through it. 46 */ 47 struct mmap_cache_t { 48 /** 49 * example entry: 50 * 7fabbb09b000-7fabbb09f000 r-xp 00179000 fc:00 1180246 /lib/libc-2.11.1.so 51 * 52 * start_addr is 0x7fabbb09b000 53 * end_addr is 0x7fabbb09f000 54 * mmap_offset is 0x179000 55 * binary_filename is "/lib/libc-2.11.1.so" 56 */ 57 unsigned long start_addr; 58 unsigned long end_addr; 59 unsigned long mmap_offset; 60 char *binary_filename; 61 }; 62 63 /* 64 * Type used in stacktrace walker 65 */ 66 typedef void (*call_action_fn)(void *data, 67 const char *binary_filename, 68 const char *symbol_name, 69 unw_word_t function_offset, 70 unsigned long true_offset); 71 typedef void (*error_action_fn)(void *data, 72 const char *error, 73 unsigned long true_offset); 74 75 /* 76 * Type used in stacktrace capturing 77 */ 78 struct call_t { 79 struct call_t* next; 80 char *output_line; 81 }; 82 83 struct queue_t { 84 struct call_t *tail; 85 struct call_t *head; 86 }; 87 88 static void queue_print(struct queue_t *queue); 89 static void delete_mmap_cache(struct tcb *tcp, const char *caller); 90 91 static unw_addr_space_t libunwind_as; 92 static unsigned int mmap_cache_generation; 93 94 void 95 unwind_init(void) 96 { 97 libunwind_as = unw_create_addr_space(&_UPT_accessors, 0); 98 if (!libunwind_as) 99 error_msg_and_die("failed to create address space for stack tracing"); 100 unw_set_caching_policy(libunwind_as, UNW_CACHE_GLOBAL); 101 } 102 103 void 104 unwind_tcb_init(struct tcb *tcp) 105 { 106 tcp->libunwind_ui = _UPT_create(tcp->pid); 107 if (!tcp->libunwind_ui) 108 die_out_of_memory(); 109 110 tcp->queue = malloc(sizeof(*tcp->queue)); 111 if (!tcp->queue) 112 die_out_of_memory(); 113 tcp->queue->head = NULL; 114 tcp->queue->tail = NULL; 115 } 116 117 void 118 unwind_tcb_fin(struct tcb *tcp) 119 { 120 queue_print(tcp->queue); 121 free(tcp->queue); 122 tcp->queue = NULL; 123 124 delete_mmap_cache(tcp, __FUNCTION__); 125 126 _UPT_destroy(tcp->libunwind_ui); 127 tcp->libunwind_ui = NULL; 128 } 129 130 /* 131 * caching of /proc/ID/maps for each process to speed up stack tracing 132 * 133 * The cache must be refreshed after syscalls that affect memory mappings, 134 * e.g. mmap, mprotect, munmap, execve. 135 */ 136 static void 137 build_mmap_cache(struct tcb* tcp) 138 { 139 FILE *fp; 140 struct mmap_cache_t *cache_head; 141 /* start with a small dynamically-allocated array and then expand it */ 142 size_t cur_array_size = 10; 143 char filename[sizeof("/proc/4294967296/maps")]; 144 char buffer[PATH_MAX + 80]; 145 146 unw_flush_cache(libunwind_as, 0, 0); 147 148 sprintf(filename, "/proc/%u/maps", tcp->pid); 149 fp = fopen_for_input(filename, "r"); 150 if (!fp) { 151 perror_msg("fopen: %s", filename); 152 return; 153 } 154 155 cache_head = calloc(cur_array_size, sizeof(*cache_head)); 156 if (!cache_head) 157 die_out_of_memory(); 158 159 while (fgets(buffer, sizeof(buffer), fp) != NULL) { 160 struct mmap_cache_t *entry; 161 unsigned long start_addr, end_addr, mmap_offset; 162 char exec_bit; 163 char binary_path[PATH_MAX]; 164 165 if (sscanf(buffer, "%lx-%lx %*c%*c%c%*c %lx %*x:%*x %*d %[^\n]", 166 &start_addr, &end_addr, &exec_bit, 167 &mmap_offset, binary_path) != 5) 168 continue; 169 170 /* ignore mappings that have no PROT_EXEC bit set */ 171 if (exec_bit != 'x') 172 continue; 173 174 if (end_addr < start_addr) { 175 error_msg("%s: unrecognized file format", filename); 176 break; 177 } 178 179 /* 180 * sanity check to make sure that we're storing 181 * non-overlapping regions in ascending order 182 */ 183 if (tcp->mmap_cache_size > 0) { 184 entry = &cache_head[tcp->mmap_cache_size - 1]; 185 if (entry->start_addr == start_addr && 186 entry->end_addr == end_addr) { 187 /* duplicate entry, e.g. [vsyscall] */ 188 continue; 189 } 190 if (start_addr <= entry->start_addr || 191 start_addr < entry->end_addr) { 192 error_msg("%s: overlapping memory region", 193 filename); 194 continue; 195 } 196 } 197 198 if (tcp->mmap_cache_size >= cur_array_size) { 199 cur_array_size *= 2; 200 cache_head = realloc(cache_head, 201 cur_array_size * sizeof(*cache_head)); 202 if (!cache_head) 203 die_out_of_memory(); 204 } 205 206 entry = &cache_head[tcp->mmap_cache_size]; 207 entry->start_addr = start_addr; 208 entry->end_addr = end_addr; 209 entry->mmap_offset = mmap_offset; 210 entry->binary_filename = strdup(binary_path); 211 if (!entry->binary_filename) 212 die_out_of_memory(); 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 *size *= 2; 294 *name = realloc(*name, *size); 295 if (!*name) 296 die_out_of_memory(); 297 } 298 } 299 300 static int 301 print_stack_frame(struct tcb *tcp, 302 call_action_fn call_action, 303 error_action_fn error_action, 304 void *data, 305 unw_cursor_t *cursor, 306 char **symbol_name, 307 size_t *symbol_name_size) 308 { 309 unw_word_t ip; 310 int lower = 0; 311 int upper = (int) tcp->mmap_cache_size - 1; 312 313 if (unw_get_reg(cursor, UNW_REG_IP, &ip) < 0) { 314 perror_msg("Can't walk the stack of process %d", tcp->pid); 315 return -1; 316 } 317 318 while (lower <= upper) { 319 struct mmap_cache_t *cur_mmap_cache; 320 int mid = (upper + lower) / 2; 321 322 cur_mmap_cache = &tcp->mmap_cache[mid]; 323 324 if (ip >= cur_mmap_cache->start_addr && 325 ip < cur_mmap_cache->end_addr) { 326 unsigned long true_offset; 327 unw_word_t function_offset; 328 329 get_symbol_name(cursor, symbol_name, symbol_name_size, 330 &function_offset); 331 true_offset = ip - cur_mmap_cache->start_addr + 332 cur_mmap_cache->mmap_offset; 333 call_action(data, 334 cur_mmap_cache->binary_filename, 335 *symbol_name, 336 function_offset, 337 true_offset); 338 return 0; 339 } 340 else if (ip < cur_mmap_cache->start_addr) 341 upper = mid - 1; 342 else 343 lower = mid + 1; 344 } 345 346 /* 347 * there is a bug in libunwind >= 1.0 348 * after a set_tid_address syscall 349 * unw_get_reg returns IP == 0 350 */ 351 if(ip) 352 error_action(data, "unexpected_backtracing_error", ip); 353 return -1; 354 } 355 356 /* 357 * walking the stack 358 */ 359 static void 360 stacktrace_walk(struct tcb *tcp, 361 call_action_fn call_action, 362 error_action_fn error_action, 363 void *data) 364 { 365 char *symbol_name; 366 size_t symbol_name_size = 40; 367 unw_cursor_t cursor; 368 int stack_depth; 369 370 if (!tcp->mmap_cache) 371 error_msg_and_die("bug: mmap_cache is NULL"); 372 if (tcp->mmap_cache_size == 0) 373 error_msg_and_die("bug: mmap_cache is empty"); 374 375 symbol_name = malloc(symbol_name_size); 376 if (!symbol_name) 377 die_out_of_memory(); 378 379 if (unw_init_remote(&cursor, libunwind_as, tcp->libunwind_ui) < 0) 380 perror_msg_and_die("Can't initiate libunwind"); 381 382 for (stack_depth = 0; stack_depth < 256; ++stack_depth) { 383 if (print_stack_frame(tcp, call_action, error_action, data, 384 &cursor, &symbol_name, &symbol_name_size) < 0) 385 break; 386 if (unw_step(&cursor) <= 0) 387 break; 388 } 389 if (stack_depth >= 256) 390 error_action(data, "too many stack frames", 0); 391 392 free(symbol_name); 393 } 394 395 /* 396 * printing an entry in stack to stream or buffer 397 */ 398 /* 399 * we want to keep the format used by backtrace_symbols from the glibc 400 * 401 * ./a.out() [0x40063d] 402 * ./a.out() [0x4006bb] 403 * ./a.out() [0x4006c6] 404 * /lib64/libc.so.6(__libc_start_main+0xed) [0x7fa2f8a5976d] 405 * ./a.out() [0x400569] 406 */ 407 #define STACK_ENTRY_SYMBOL_FMT \ 408 " > %s(%s+0x%lx) [0x%lx]\n", \ 409 binary_filename, \ 410 symbol_name, \ 411 (unsigned long) function_offset, \ 412 true_offset 413 #define STACK_ENTRY_NOSYMBOL_FMT \ 414 " > %s() [0x%lx]\n", \ 415 binary_filename, true_offset 416 #define STACK_ENTRY_BUG_FMT \ 417 " > BUG IN %s\n" 418 #define STACK_ENTRY_ERROR_WITH_OFFSET_FMT \ 419 " > %s [0x%lx]\n", error, true_offset 420 #define STACK_ENTRY_ERROR_FMT \ 421 " > %s\n", error 422 423 static void 424 print_call_cb(void *dummy, 425 const char *binary_filename, 426 const char *symbol_name, 427 unw_word_t function_offset, 428 unsigned long true_offset) 429 { 430 if (symbol_name) 431 tprintf(STACK_ENTRY_SYMBOL_FMT); 432 else if (binary_filename) 433 tprintf(STACK_ENTRY_NOSYMBOL_FMT); 434 else 435 tprintf(STACK_ENTRY_BUG_FMT, __FUNCTION__); 436 437 line_ended(); 438 } 439 440 static void 441 print_error_cb(void *dummy, 442 const char *error, 443 unsigned long true_offset) 444 { 445 if (true_offset) 446 tprintf(STACK_ENTRY_ERROR_WITH_OFFSET_FMT); 447 else 448 tprintf(STACK_ENTRY_ERROR_FMT); 449 450 line_ended(); 451 } 452 453 static char * 454 sprint_call_or_error(const char *binary_filename, 455 const char *symbol_name, 456 unw_word_t function_offset, 457 unsigned long true_offset, 458 const char *error) 459 { 460 char *output_line = NULL; 461 int n; 462 463 if (symbol_name) 464 n = asprintf(&output_line, STACK_ENTRY_SYMBOL_FMT); 465 else if (binary_filename) 466 n = asprintf(&output_line, STACK_ENTRY_NOSYMBOL_FMT); 467 else if (error) 468 n = true_offset 469 ? asprintf(&output_line, STACK_ENTRY_ERROR_WITH_OFFSET_FMT) 470 : asprintf(&output_line, STACK_ENTRY_ERROR_FMT); 471 else 472 n = asprintf(&output_line, STACK_ENTRY_BUG_FMT, __FUNCTION__); 473 474 if (n < 0) 475 error_msg_and_die("error in asprintf"); 476 477 return output_line; 478 } 479 480 /* 481 * queue manipulators 482 */ 483 static void 484 queue_put(struct queue_t *queue, 485 const char *binary_filename, 486 const char *symbol_name, 487 unw_word_t function_offset, 488 unsigned long true_offset, 489 const char *error) 490 { 491 struct call_t *call; 492 493 call = malloc(sizeof(*call)); 494 if (!call) 495 die_out_of_memory(); 496 497 call->output_line = sprint_call_or_error(binary_filename, 498 symbol_name, 499 function_offset, 500 true_offset, 501 error); 502 call->next = NULL; 503 504 if (!queue->head) { 505 queue->head = call; 506 queue->tail = call; 507 } else { 508 queue->tail->next = call; 509 queue->tail = call; 510 } 511 } 512 513 static void 514 queue_put_call(void *queue, 515 const char *binary_filename, 516 const char *symbol_name, 517 unw_word_t function_offset, 518 unsigned long true_offset) 519 { 520 queue_put(queue, 521 binary_filename, 522 symbol_name, 523 function_offset, 524 true_offset, 525 NULL); 526 } 527 528 static void 529 queue_put_error(void *queue, 530 const char *error, 531 unsigned long ip) 532 { 533 queue_put(queue, NULL, NULL, 0, ip, error); 534 } 535 536 static void 537 queue_print(struct queue_t *queue) 538 { 539 struct call_t *call, *tmp; 540 541 queue->tail = NULL; 542 call = queue->head; 543 queue->head = NULL; 544 while (call) { 545 tmp = call; 546 call = call->next; 547 548 tprints(tmp->output_line); 549 line_ended(); 550 551 free(tmp->output_line); 552 tmp->output_line = NULL; 553 tmp->next = NULL; 554 free(tmp); 555 } 556 } 557 558 /* 559 * printing stack 560 */ 561 void 562 unwind_print_stacktrace(struct tcb* tcp) 563 { 564 #if SUPPORTED_PERSONALITIES > 1 565 if (tcp->currpers != DEFAULT_PERSONALITY) { 566 /* disable strack trace */ 567 return; 568 } 569 #endif 570 if (tcp->queue->head) { 571 DPRINTF("tcp=%p, queue=%p", "queueprint", tcp, tcp->queue->head); 572 queue_print(tcp->queue); 573 } 574 else if (rebuild_cache_if_invalid(tcp, __FUNCTION__)) { 575 DPRINTF("tcp=%p, queue=%p", "stackprint", tcp, tcp->queue->head); 576 stacktrace_walk(tcp, print_call_cb, print_error_cb, NULL); 577 } 578 } 579 580 /* 581 * capturing stack 582 */ 583 void 584 unwind_capture_stacktrace(struct tcb *tcp) 585 { 586 #if SUPPORTED_PERSONALITIES > 1 587 if (tcp->currpers != DEFAULT_PERSONALITY) { 588 /* disable strack trace */ 589 return; 590 } 591 #endif 592 if (tcp->queue->head) 593 error_msg_and_die("bug: unprinted entries in queue"); 594 595 if (rebuild_cache_if_invalid(tcp, __FUNCTION__)) { 596 stacktrace_walk(tcp, queue_put_call, queue_put_error, 597 tcp->queue); 598 DPRINTF("tcp=%p, queue=%p", "captured", tcp, tcp->queue->head); 599 } 600 } 601
