Home | History | Annotate | Download | only in ltrace 
      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