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 *
call_handler(struct process * proc,Event * 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
handle_event(Event * event)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
pending_new(pid_t pid)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
pending_new_insert(pid_t pid)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
pending_new_remove(pid_t pid)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
handle_clone(Event * event)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
handle_new(Event * event)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 *
shortsignal(struct process * proc,int signum)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 *
sysname(struct process * proc,int sysnum)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 *
arch_sysname(struct process * proc,int sysnum)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
handle_signal(Event * event)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
init_syscall_symbol(struct library_symbol * libsym,const char * name)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
account_current_callstack(struct process * proc)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
handle_exit(Event * event)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
handle_exit_signal(Event * event)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
output_syscall(struct process * proc,const char * name,enum tof tof,bool left,struct timedelta * spent)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
output_syscall_left(struct process * proc,const char * name)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
output_syscall_right(struct process * proc,const char * name,struct timedelta * spent)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
handle_syscall(Event * event)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
handle_exec(Event * event)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
handle_arch_syscall(Event * event)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
handle_x_sysret(Event * event,char * (* name_cb)(struct process *,int))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
handle_sysret(Event * event)641 handle_sysret(Event *event)
642 {
643 handle_x_sysret(event, &sysname);
644 }
645
646 static void
handle_arch_sysret(Event * event)647 handle_arch_sysret(Event *event)
648 {
649 handle_x_sysret(event, &arch_sysname);
650 }
651
652 static void
output_right_tos(struct process * proc)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
arch_symbol_ret(struct process * proc,struct library_symbol * libsym)671 void arch_symbol_ret(struct process *proc, struct library_symbol *libsym)
672 {
673 }
674 #endif
675
676 static void
handle_breakpoint(Event * event)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
callstack_push_syscall(struct process * proc,int sysnum)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
callstack_push_symfunc(struct process * proc,struct breakpoint * bp)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
callstack_pop(struct process * proc)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