6fa7e98da6de4bbd35a2cfe1a379370a8d50d972
[platform/upstream/ltrace.git] / handle_event.c
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 }