1 /* 2 * This file is part of ltrace. 3 * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc. 4 * Copyright (C) 2010 Arnaud Patard, Mandriva SA 5 * Copyright (C) 1998,2001,2002,2003,2004,2007,2008,2009 Juan Cespedes 6 * Copyright (C) 2008 Luis Machado, IBM Corporation 7 * Copyright (C) 2006 Ian Wienand 8 * Copyright (C) 2006 Paul Gilliam, IBM Corporation 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License as 12 * published by the Free Software Foundation; either version 2 of the 13 * License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 23 * 02110-1301 USA 24 */ 25 26 #include "config.h" 27 28 #define _GNU_SOURCE 29 #include <assert.h> 30 #include <errno.h> 31 #include <signal.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <stdbool.h> 36 37 #include "backend.h" 38 #include "breakpoint.h" 39 #include "common.h" 40 #include "fetch.h" 41 #include "library.h" 42 #include "proc.h" 43 #include "prototype.h" 44 #include "summary.h" 45 #include "value_dict.h" 46 47 static void handle_signal(Event *event); 48 static void handle_exit(Event *event); 49 static void handle_exit_signal(Event *event); 50 static void handle_syscall(Event *event); 51 static void handle_arch_syscall(Event *event); 52 static void handle_sysret(Event *event); 53 static void handle_arch_sysret(Event *event); 54 static void handle_clone(Event *event); 55 static void handle_exec(Event *event); 56 static void handle_breakpoint(Event *event); 57 static void handle_new(Event *event); 58 59 static void callstack_push_syscall(struct process *proc, int sysnum); 60 static void callstack_push_symfunc(struct process *proc, struct breakpoint *bp); 61 /* XXX Stack maintenance should be moved to a dedicated module, or to 62 * proc.c, and push/pop should be visible outside this module. For 63 * now, because we need this in proc.c, this is non-static. */ 64 void callstack_pop(struct process *proc); 65 66 static char *shortsignal(struct process *proc, int signum); 67 static char *sysname(struct process *proc, int sysnum); 68 static char *arch_sysname(struct process *proc, int sysnum); 69 70 static Event * 71 call_handler(struct process *proc, Event *event) 72 { 73 assert(proc != NULL); 74 75 struct event_handler *handler = proc->event_handler; 76 if (handler == NULL) 77 return event; 78 79 return (*handler->on_event) (handler, event); 80 } 81 82 void 83 handle_event(Event *event) 84 { 85 if (exiting == 1) { 86 debug(1, "ltrace about to exit"); 87 os_ltrace_exiting(); 88 exiting = 2; 89 } 90 debug(DEBUG_FUNCTION, "handle_event(pid=%d, type=%d)", 91 event->proc ? event->proc->pid : -1, event->type); 92 93 /* If the thread group or an individual task define an 94 overriding event handler, give them a chance to kick in. 95 We will end up calling both handlers, if the first one 96 doesn't sink the event. */ 97 if (event->proc != NULL) { 98 event = call_handler(event->proc, event); 99 if (event == NULL) 100 /* It was handled. */ 101 return; 102 103 /* Note: the previous handler has a chance to alter 104 * the event. */ 105 if (event->proc != NULL 106 && event->proc->leader != NULL 107 && event->proc != event->proc->leader) { 108 event = call_handler(event->proc->leader, event); 109 if (event == NULL) 110 return; 111 } 112 } 113 114 switch (event->type) { 115 case EVENT_NONE: 116 debug(1, "event: none"); 117 return; 118 119 case EVENT_SIGNAL: 120 assert(event->proc != NULL); 121 debug(1, "[%d] event: signal (%s [%d])", 122 event->proc->pid, 123 shortsignal(event->proc, event->e_un.signum), 124 event->e_un.signum); 125 handle_signal(event); 126 return; 127 128 case EVENT_EXIT: 129 assert(event->proc != NULL); 130 debug(1, "[%d] event: exit (%d)", 131 event->proc->pid, 132 event->e_un.ret_val); 133 handle_exit(event); 134 return; 135 136 case EVENT_EXIT_SIGNAL: 137 assert(event->proc != NULL); 138 debug(1, "[%d] event: exit signal (%s [%d])", 139 event->proc->pid, 140 shortsignal(event->proc, event->e_un.signum), 141 event->e_un.signum); 142 handle_exit_signal(event); 143 return; 144 145 case EVENT_SYSCALL: 146 assert(event->proc != NULL); 147 debug(1, "[%d] event: syscall (%s [%d])", 148 event->proc->pid, 149 sysname(event->proc, event->e_un.sysnum), 150 event->e_un.sysnum); 151 handle_syscall(event); 152 return; 153 154 case EVENT_SYSRET: 155 assert(event->proc != NULL); 156 debug(1, "[%d] event: sysret (%s [%d])", 157 event->proc->pid, 158 sysname(event->proc, event->e_un.sysnum), 159 event->e_un.sysnum); 160 handle_sysret(event); 161 return; 162 163 case EVENT_ARCH_SYSCALL: 164 assert(event->proc != NULL); 165 debug(1, "[%d] event: arch_syscall (%s [%d])", 166 event->proc->pid, 167 arch_sysname(event->proc, event->e_un.sysnum), 168 event->e_un.sysnum); 169 handle_arch_syscall(event); 170 return; 171 172 case EVENT_ARCH_SYSRET: 173 assert(event->proc != NULL); 174 debug(1, "[%d] event: arch_sysret (%s [%d])", 175 event->proc->pid, 176 arch_sysname(event->proc, event->e_un.sysnum), 177 event->e_un.sysnum); 178 handle_arch_sysret(event); 179 return; 180 181 case EVENT_CLONE: 182 case EVENT_VFORK: 183 assert(event->proc != NULL); 184 debug(1, "[%d] event: clone (%u)", 185 event->proc->pid, event->e_un.newpid); 186 handle_clone(event); 187 return; 188 189 case EVENT_EXEC: 190 assert(event->proc != NULL); 191 debug(1, "[%d] event: exec()", 192 event->proc->pid); 193 handle_exec(event); 194 return; 195 196 case EVENT_BREAKPOINT: 197 assert(event->proc != NULL); 198 debug(1, "[%d] event: breakpoint %p", 199 event->proc->pid, event->e_un.brk_addr); 200 handle_breakpoint(event); 201 return; 202 203 case EVENT_NEW: 204 debug(1, "[%d] event: new process", 205 event->e_un.newpid); 206 handle_new(event); 207 return; 208 default: 209 fprintf(stderr, "Error! unknown event?\n"); 210 exit(1); 211 } 212 } 213 214 typedef struct Pending_New Pending_New; 215 struct Pending_New { 216 pid_t pid; 217 Pending_New * next; 218 }; 219 static Pending_New * pending_news = NULL; 220 221 static int 222 pending_new(pid_t pid) { 223 Pending_New * p; 224 225 debug(DEBUG_FUNCTION, "pending_new(%d)", pid); 226 227 p = pending_news; 228 while (p) { 229 if (p->pid == pid) { 230 return 1; 231 } 232 p = p->next; 233 } 234 return 0; 235 } 236 237 static void 238 pending_new_insert(pid_t pid) { 239 Pending_New * p; 240 241 debug(DEBUG_FUNCTION, "pending_new_insert(%d)", pid); 242 243 p = malloc(sizeof(Pending_New)); 244 if (!p) { 245 perror("malloc()"); 246 exit(1); 247 } 248 p->pid = pid; 249 p->next = pending_news; 250 pending_news = p; 251 } 252 253 static void 254 pending_new_remove(pid_t pid) 255 { 256 debug(DEBUG_FUNCTION, "pending_new_remove(%d)", pid); 257 258 Pending_New **pp; 259 for (pp = &pending_news; *pp != NULL; pp = &(*pp)->next) 260 if ((*pp)->pid == pid) { 261 Pending_New *p = *pp; 262 *pp = p->next; 263 free(p); 264 return; 265 } 266 } 267 268 static void 269 handle_clone(Event *event) 270 { 271 debug(DEBUG_FUNCTION, "handle_clone(pid=%d)", event->proc->pid); 272 273 struct process *proc = malloc(sizeof(*proc)); 274 pid_t newpid = event->e_un.newpid; 275 if (proc == NULL 276 || process_clone(proc, event->proc, newpid) < 0) { 277 free(proc); 278 proc = NULL; 279 fprintf(stderr, 280 "Couldn't initialize tracing of process %d.\n", 281 newpid); 282 283 } else { 284 proc->parent = event->proc; 285 /* We save register values to the arch pointer, and 286 * these need to be per-thread. XXX arch_ptr should 287 * be retired in favor of fetch interface anyway. */ 288 proc->arch_ptr = NULL; 289 } 290 291 if (pending_new(newpid)) { 292 pending_new_remove(newpid); 293 294 if (proc != NULL) { 295 proc->event_handler = NULL; 296 if (event->proc->state == STATE_ATTACHED 297 && options.follow) 298 proc->state = STATE_ATTACHED; 299 else 300 proc->state = STATE_IGNORED; 301 } 302 303 continue_process(newpid); 304 305 } else if (proc != NULL) { 306 proc->state = STATE_BEING_CREATED; 307 } 308 309 if (event->type != EVENT_VFORK) 310 continue_process(event->proc->pid); 311 else if (proc != NULL) 312 continue_after_vfork(proc); 313 else 314 continue_process(newpid); 315 } 316 317 static void 318 handle_new(Event *event) 319 { 320 debug(DEBUG_FUNCTION, "handle_new(pid=%d)", event->e_un.newpid); 321 322 struct process *proc = pid2proc(event->e_un.newpid); 323 if (!proc) { 324 pending_new_insert(event->e_un.newpid); 325 } else { 326 assert(proc->state == STATE_BEING_CREATED); 327 if (options.follow) { 328 proc->state = STATE_ATTACHED; 329 } else { 330 proc->state = STATE_IGNORED; 331 } 332 continue_process(proc->pid); 333 } 334 } 335 336 static char * 337 shortsignal(struct process *proc, int signum) 338 { 339 static char *signalent0[] = { 340 #include "signalent.h" 341 }; 342 static char *signalent1[] = { 343 #include "signalent1.h" 344 }; 345 static char **signalents[] = { signalent0, signalent1 }; 346 int nsignals[] = { sizeof signalent0 / sizeof signalent0[0], 347 sizeof signalent1 / sizeof signalent1[0] 348 }; 349 350 debug(DEBUG_FUNCTION, "shortsignal(pid=%d, signum=%d)", proc->pid, signum); 351 352 assert(proc->personality < sizeof signalents / sizeof signalents[0]); 353 if (signum < 0 || signum >= nsignals[proc->personality]) { 354 return "UNKNOWN_SIGNAL"; 355 } else { 356 return signalents[proc->personality][signum]; 357 } 358 } 359 360 static char * 361 sysname(struct process *proc, int sysnum) 362 { 363 static char result[128]; 364 static char *syscallent0[] = { 365 #include "syscallent.h" 366 }; 367 static char *syscallent1[] = { 368 #include "syscallent1.h" 369 }; 370 static char **syscallents[] = { syscallent0, syscallent1 }; 371 int nsyscalls[] = { 372 sizeof syscallent0 / sizeof syscallent0[0], 373 sizeof syscallent1 / sizeof syscallent1[0], 374 }; 375 376 debug(DEBUG_FUNCTION, "sysname(pid=%d, sysnum=%d)", proc->pid, sysnum); 377 378 assert(proc->personality < sizeof syscallents / sizeof syscallents[0]); 379 if (sysnum < 0 || sysnum >= nsyscalls[proc->personality]) { 380 sprintf(result, "SYS_%d", sysnum); 381 return result; 382 } else { 383 return syscallents[proc->personality][sysnum]; 384 } 385 } 386 387 static char * 388 arch_sysname(struct process *proc, int sysnum) 389 { 390 static char result[128]; 391 static char *arch_syscallent[] = { 392 #include "arch_syscallent.h" 393 }; 394 int nsyscalls = sizeof arch_syscallent / sizeof arch_syscallent[0]; 395 396 debug(DEBUG_FUNCTION, "arch_sysname(pid=%d, sysnum=%d)", proc->pid, sysnum); 397 398 if (sysnum < 0 || sysnum >= nsyscalls) { 399 sprintf(result, "ARCH_%d", sysnum); 400 return result; 401 } else { 402 sprintf(result, "ARCH_%s", arch_syscallent[sysnum]); 403 return result; 404 } 405 } 406 407 #ifndef HAVE_STRSIGNAL 408 # define strsignal(SIGNUM) "???" 409 #endif 410 411 static void 412 handle_signal(Event *event) { 413 debug(DEBUG_FUNCTION, "handle_signal(pid=%d, signum=%d)", event->proc->pid, event->e_un.signum); 414 if (event->proc->state != STATE_IGNORED && !options.no_signals) { 415 output_line(event->proc, "--- %s (%s) ---", 416 shortsignal(event->proc, event->e_un.signum), 417 strsignal(event->e_un.signum)); 418 } 419 continue_after_signal(event->proc->pid, event->e_un.signum); 420 } 421 422 static int 423 init_syscall_symbol(struct library_symbol *libsym, const char *name) 424 { 425 static struct library syscall_lib; 426 427 if (syscall_lib.protolib == NULL) { 428 struct protolib *protolib 429 = protolib_cache_load(&g_protocache, "syscalls", 0, 1); 430 if (protolib == NULL) { 431 fprintf(stderr, "Couldn't load system call prototypes:" 432 " %s.\n", strerror(errno)); 433 434 /* Instead, get a fake one just so we can 435 * carry on, limping. */ 436 protolib = malloc(sizeof *protolib); 437 if (protolib == NULL) { 438 fprintf(stderr, "Couldn't even allocate a fake " 439 "prototype library: %s.\n", 440 strerror(errno)); 441 abort(); 442 } 443 protolib_init(protolib); 444 } 445 446 assert(protolib != NULL); 447 if (library_init(&syscall_lib, LT_LIBTYPE_SYSCALL) < 0) { 448 fprintf(stderr, "Couldn't initialize system call " 449 "library: %s.\n", strerror(errno)); 450 abort(); 451 } 452 453 library_set_soname(&syscall_lib, "SYS", 0); 454 syscall_lib.protolib = protolib; 455 } 456 457 if (library_symbol_init(libsym, 0, name, 0, LS_TOPLT_NONE) < 0) 458 return -1; 459 460 libsym->lib = &syscall_lib; 461 return 0; 462 } 463 464 /* Account the unfinished functions on the call stack. */ 465 static void 466 account_current_callstack(struct process *proc) 467 { 468 if (! options.summary) 469 return; 470 471 struct timedelta spent[proc->callstack_depth]; 472 473 size_t i; 474 for (i = 0; i < proc->callstack_depth; ++i) { 475 struct callstack_element *elem = &proc->callstack[i]; 476 spent[i] = calc_time_spent(elem->enter_time); 477 } 478 479 for (i = 0; i < proc->callstack_depth; ++i) { 480 struct callstack_element *elem = &proc->callstack[i]; 481 struct library_symbol syscall, *libsym = NULL; 482 if (elem->is_syscall) { 483 const char *name = sysname(proc, elem->c_un.syscall); 484 if (init_syscall_symbol(&syscall, name) >= 0) 485 libsym = &syscall; 486 487 } else { 488 libsym = elem->c_un.libfunc; 489 } 490 491 if (libsym != NULL) { 492 summary_account_call(libsym, spent[i]); 493 494 if (elem->is_syscall) 495 library_symbol_destroy(&syscall); 496 } 497 } 498 } 499 500 static void 501 handle_exit(Event *event) { 502 debug(DEBUG_FUNCTION, "handle_exit(pid=%d, status=%d)", event->proc->pid, event->e_un.ret_val); 503 if (event->proc->state != STATE_IGNORED) { 504 output_line(event->proc, "+++ exited (status %d) +++", 505 event->e_un.ret_val); 506 } 507 508 account_current_callstack(event->proc); 509 remove_process(event->proc); 510 } 511 512 static void 513 handle_exit_signal(Event *event) { 514 debug(DEBUG_FUNCTION, "handle_exit_signal(pid=%d, signum=%d)", event->proc->pid, event->e_un.signum); 515 if (event->proc->state != STATE_IGNORED) { 516 output_line(event->proc, "+++ killed by %s +++", 517 shortsignal(event->proc, event->e_un.signum)); 518 } 519 520 account_current_callstack(event->proc); 521 remove_process(event->proc); 522 } 523 524 static void 525 output_syscall(struct process *proc, const char *name, enum tof tof, 526 bool left, struct timedelta *spent) 527 { 528 if (left) 529 assert(spent == NULL); 530 531 struct library_symbol syscall; 532 if (init_syscall_symbol(&syscall, name) >= 0) { 533 if (left) { 534 if (! options.summary) 535 output_left(tof, proc, &syscall); 536 } else if (options.summary) { 537 summary_account_call(&syscall, *spent); 538 } else { 539 output_right(tof, proc, &syscall, spent); 540 } 541 542 library_symbol_destroy(&syscall); 543 } 544 } 545 546 static void 547 output_syscall_left(struct process *proc, const char *name) 548 { 549 output_syscall(proc, name, LT_TOF_SYSCALL, true, NULL); 550 } 551 552 static void 553 output_syscall_right(struct process *proc, const char *name, 554 struct timedelta *spent) 555 { 556 output_syscall(proc, name, LT_TOF_SYSCALLR, false, spent); 557 } 558 559 static void 560 handle_syscall(Event *event) 561 { 562 debug(DEBUG_FUNCTION, "handle_syscall(pid=%d, sysnum=%d)", event->proc->pid, event->e_un.sysnum); 563 if (event->proc->state != STATE_IGNORED) { 564 callstack_push_syscall(event->proc, event->e_un.sysnum); 565 if (options.syscalls) 566 output_syscall_left(event->proc, 567 sysname(event->proc, 568 event->e_un.sysnum)); 569 } 570 continue_after_syscall(event->proc, event->e_un.sysnum, 0); 571 } 572 573 static void 574 handle_exec(Event *event) 575 { 576 struct process *proc = event->proc; 577 578 /* Save the PID so that we can use it after unsuccessful 579 * process_exec. */ 580 pid_t pid = proc->pid; 581 582 debug(DEBUG_FUNCTION, "handle_exec(pid=%d)", proc->pid); 583 if (proc->state == STATE_IGNORED) { 584 untrace: 585 untrace_pid(pid); 586 remove_process(proc); 587 return; 588 } 589 output_line(proc, "--- Called exec() ---"); 590 591 account_current_callstack(proc); 592 593 if (process_exec(proc) < 0) { 594 fprintf(stderr, 595 "couldn't reinitialize process %d after exec\n", pid); 596 goto untrace; 597 } 598 599 continue_after_exec(proc); 600 } 601 602 static void 603 handle_arch_syscall(Event *event) { 604 debug(DEBUG_FUNCTION, "handle_arch_syscall(pid=%d, sysnum=%d)", event->proc->pid, event->e_un.sysnum); 605 if (event->proc->state != STATE_IGNORED) { 606 callstack_push_syscall(event->proc, 0xf0000 + event->e_un.sysnum); 607 if (options.syscalls) { 608 output_syscall_left(event->proc, 609 arch_sysname(event->proc, 610 event->e_un.sysnum)); 611 } 612 } 613 continue_process(event->proc->pid); 614 } 615 616 static void 617 handle_x_sysret(Event *event, char *(*name_cb)(struct process *, int)) 618 { 619 debug(DEBUG_FUNCTION, "handle_x_sysret(pid=%d, sysnum=%d)", 620 event->proc->pid, event->e_un.sysnum); 621 622 unsigned d = event->proc->callstack_depth; 623 assert(d > 0); 624 struct callstack_element *elem = &event->proc->callstack[d - 1]; 625 assert(elem->is_syscall); 626 627 if (event->proc->state != STATE_IGNORED) { 628 struct timedelta spent = calc_time_spent(elem->enter_time); 629 if (options.syscalls) 630 output_syscall_right(event->proc, 631 name_cb(event->proc, 632 event->e_un.sysnum), 633 &spent); 634 635 callstack_pop(event->proc); 636 } 637 continue_after_syscall(event->proc, event->e_un.sysnum, 1); 638 } 639 640 static void 641 handle_sysret(Event *event) 642 { 643 handle_x_sysret(event, &sysname); 644 } 645 646 static void 647 handle_arch_sysret(Event *event) 648 { 649 handle_x_sysret(event, &arch_sysname); 650 } 651 652 static void 653 output_right_tos(struct process *proc) 654 { 655 size_t d = proc->callstack_depth; 656 assert(d > 0); 657 struct callstack_element *elem = &proc->callstack[d - 1]; 658 assert(! elem->is_syscall); 659 660 if (proc->state != STATE_IGNORED) { 661 struct timedelta spent = calc_time_spent(elem->enter_time); 662 if (options.summary) 663 summary_account_call(elem->c_un.libfunc, spent); 664 else 665 output_right(LT_TOF_FUNCTIONR, proc, elem->c_un.libfunc, 666 &spent); 667 } 668 } 669 670 #ifndef ARCH_HAVE_SYMBOL_RET 671 void arch_symbol_ret(struct process *proc, struct library_symbol *libsym) 672 { 673 } 674 #endif 675 676 static void 677 handle_breakpoint(Event *event) 678 { 679 int i, j; 680 struct breakpoint *sbp; 681 struct process *leader = event->proc->leader; 682 void *brk_addr = event->e_un.brk_addr; 683 684 /* The leader has terminated. */ 685 if (leader == NULL) { 686 continue_process(event->proc->pid); 687 return; 688 } 689 690 debug(DEBUG_FUNCTION, "handle_breakpoint(pid=%d, addr=%p)", 691 event->proc->pid, brk_addr); 692 debug(2, "event: breakpoint (%p)", brk_addr); 693 694 for (i = event->proc->callstack_depth - 1; i >= 0; i--) { 695 if (brk_addr == event->proc->callstack[i].return_addr) { 696 for (j = event->proc->callstack_depth - 1; j > i; j--) 697 callstack_pop(event->proc); 698 699 struct library_symbol *libsym = 700 event->proc->callstack[i].c_un.libfunc; 701 702 arch_symbol_ret(event->proc, libsym); 703 output_right_tos(event->proc); 704 callstack_pop(event->proc); 705 706 /* Pop also any other entries that seem like 707 * they are linked to the current one: they 708 * have the same return address, but were made 709 * for different symbols. This should only 710 * happen for entry point tracing, i.e. for -x 711 * everywhere, or -x and -e on MIPS. */ 712 while (event->proc->callstack_depth > 0) { 713 struct callstack_element *prev; 714 size_t d = event->proc->callstack_depth; 715 prev = &event->proc->callstack[d - 1]; 716 717 if (prev->c_un.libfunc == libsym 718 || prev->return_addr != brk_addr) 719 break; 720 721 arch_symbol_ret(event->proc, 722 prev->c_un.libfunc); 723 output_right_tos(event->proc); 724 callstack_pop(event->proc); 725 } 726 727 /* Maybe the previous callstack_pop's got rid 728 * of the breakpoint, but if we are in a 729 * recursive call, it's still enabled. In 730 * that case we need to skip it properly. */ 731 if ((sbp = address2bpstruct(leader, brk_addr)) != NULL) { 732 continue_after_breakpoint(event->proc, sbp); 733 } else { 734 set_instruction_pointer(event->proc, brk_addr); 735 continue_process(event->proc->pid); 736 } 737 return; 738 } 739 } 740 741 if ((sbp = address2bpstruct(leader, brk_addr)) != NULL) 742 breakpoint_on_hit(sbp, event->proc); 743 else if (event->proc->state != STATE_IGNORED) 744 output_line(event->proc, 745 "unexpected breakpoint at %p", brk_addr); 746 747 /* breakpoint_on_hit may delete its own breakpoint, so we have 748 * to look it up again. */ 749 if ((sbp = address2bpstruct(leader, brk_addr)) != NULL) { 750 751 if (event->proc->state != STATE_IGNORED 752 && sbp->libsym != NULL) { 753 event->proc->stack_pointer = get_stack_pointer(event->proc); 754 callstack_push_symfunc(event->proc, sbp); 755 if (! options.summary) 756 output_left(LT_TOF_FUNCTION, event->proc, 757 sbp->libsym); 758 } 759 760 breakpoint_on_continue(sbp, event->proc); 761 return; 762 } else { 763 set_instruction_pointer(event->proc, brk_addr); 764 } 765 766 continue_process(event->proc->pid); 767 } 768 769 static void 770 callstack_push_syscall(struct process *proc, int sysnum) 771 { 772 struct callstack_element *elem; 773 774 debug(DEBUG_FUNCTION, "callstack_push_syscall(pid=%d, sysnum=%d)", proc->pid, sysnum); 775 /* FIXME: not good -- should use dynamic allocation. 19990703 mortene. */ 776 if (proc->callstack_depth == MAX_CALLDEPTH - 1) { 777 fprintf(stderr, "%s: Error: call nesting too deep!\n", __func__); 778 abort(); 779 return; 780 } 781 782 elem = &proc->callstack[proc->callstack_depth]; 783 *elem = (struct callstack_element){}; 784 elem->is_syscall = 1; 785 elem->c_un.syscall = sysnum; 786 elem->return_addr = NULL; 787 788 proc->callstack_depth++; 789 if (opt_T || options.summary) { 790 struct timezone tz; 791 gettimeofday(&elem->enter_time, &tz); 792 } 793 } 794 795 static void 796 callstack_push_symfunc(struct process *proc, struct breakpoint *bp) 797 { 798 struct callstack_element *elem; 799 800 debug(DEBUG_FUNCTION, "callstack_push_symfunc(pid=%d, symbol=%s)", 801 proc->pid, bp->libsym->name); 802 /* FIXME: not good -- should use dynamic allocation. 19990703 mortene. */ 803 if (proc->callstack_depth == MAX_CALLDEPTH - 1) { 804 fprintf(stderr, "%s: Error: call nesting too deep!\n", __func__); 805 abort(); 806 return; 807 } 808 809 elem = &proc->callstack[proc->callstack_depth++]; 810 *elem = (struct callstack_element){}; 811 elem->is_syscall = 0; 812 elem->c_un.libfunc = bp->libsym; 813 814 struct breakpoint *rbp = NULL; 815 if (breakpoint_get_return_bp(&rbp, bp, proc) == 0 816 && rbp != NULL) { 817 struct breakpoint *ext_rbp = insert_breakpoint(proc, rbp); 818 if (ext_rbp != rbp) { 819 breakpoint_destroy(rbp); 820 free(rbp); 821 rbp = ext_rbp; 822 } 823 } 824 825 elem->return_addr = rbp != NULL ? rbp->addr : 0; 826 827 if (opt_T || options.summary) { 828 struct timezone tz; 829 gettimeofday(&elem->enter_time, &tz); 830 } 831 } 832 833 void 834 callstack_pop(struct process *proc) 835 { 836 struct callstack_element *elem; 837 assert(proc->callstack_depth > 0); 838 839 debug(DEBUG_FUNCTION, "callstack_pop(pid=%d)", proc->pid); 840 elem = &proc->callstack[proc->callstack_depth - 1]; 841 if (!elem->is_syscall && elem->return_addr) { 842 struct breakpoint *bp 843 = address2bpstruct(proc->leader, elem->return_addr); 844 if (bp != NULL) { 845 breakpoint_on_hit(bp, proc); 846 delete_breakpoint(proc, bp); 847 } 848 } 849 850 if (elem->fetch_context != NULL) 851 fetch_arg_done(elem->fetch_context); 852 853 if (elem->arguments != NULL) { 854 val_dict_destroy(elem->arguments); 855 free(elem->arguments); 856 } 857 858 proc->callstack_depth--; 859 } 860
