ltrace/ltrace-0.6.0-process-start.patch

diff --git a/breakpoint.h b/breakpoint.h
new file mode 100644
index 0000000..ce6f501
--- /dev/null
+++ b/breakpoint.h
@@ -0,0 +1,106 @@
+/*
+ * This file is part of ltrace.
+ * Copyright (C) 2012 Petr Machata, Red Hat Inc.
+ * Copyright (C) 2009 Juan Cespedes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef BREAKPOINT_H
+#define BREAKPOINT_H
+
+/* XXX This is currently a very weak abstraction.  We would like to
+ * much expand this to allow things like breakpoints on SDT probes and
+ * such.
+ *
+ * In particular, we would like to add a tracepoint abstraction.
+ * Tracepoint is a traceable feature--e.g. an exact address, a DWARF
+ * symbol, an ELF symbol, a PLT entry, or an SDT probe.  Tracepoints
+ * are named and the user can configure which of them he wants to
+ * enable.  Realized tracepoints enable breakpoints, which are a
+ * low-level realization of high-level tracepoint.
+ *
+ * Tracepoints are provided by the main binary as well as by any
+ * opened libraries: every time an ELF file is mapped into the address
+ * space, a new set of tracepoints is extracted, and filtered
+ * according to user settings.  Those tracepoints that are left are
+ * then realized, and the tracing starts.
+ *
+ * A scheme like this would take care of gradually introducing
+ * breakpoints when the library is mapped, and therefore ready, and
+ * would avoid certain hacks.  For example on PPC64, we don't actually
+ * add breakpoints to PLT.  Instead, we read the PLT (which contains
+ * addresses, not code), to figure out where to put the breakpoints.
+ * In prelinked code, that address is non-zero, and points to an
+ * address that's not yet mapped.  ptrace then fails when we try to
+ * add the breakpoint.
+ *
+ * Ideally, return breakpoints would be just a special kind of
+ * tracepoint that has attached some magic.  Or a feature of a
+ * tracepoint.  Service breakpoints like the handling of dlopen would
+ * be a low-level breakpoint, likely without tracepoint attached.
+ *
+ * So that's for sometimes.
+ */
+
+#include "arch.h"
+
+struct Process;
+struct breakpoint;
+
+struct bp_callbacks {
+	void (*on_hit) (struct breakpoint *bp, struct Process *proc);
+	void (*on_destroy) (struct breakpoint *bp);
+};
+
+struct breakpoint {
+	struct bp_callbacks *cbs;
+	void *addr;
+	unsigned char orig_value[BREAKPOINT_LENGTH];
+	int enabled;
+	struct library_symbol *libsym;
+#ifdef __arm__
+	int thumb_mode;
+#endif
+};
+
+/* Call on-hit handler of BP, if any is set.  */
+void breakpoint_on_hit(struct breakpoint *bp, struct Process *proc);
+
+/* Call on-destroy handler of BP, if any is set.  */
+void breakpoint_on_destroy(struct breakpoint *bp);
+
+/* This is actually three functions rolled in one:
+ *  - breakpoint_init
+ *  - proc_insert_breakpoint
+ *  - breakpoint_enable
+ * XXX I think it should be broken up somehow.  */
+struct breakpoint *insert_breakpoint(struct Process *proc, void *addr,
+				     struct library_symbol *libsym, int enable);
+
+/* */
+void delete_breakpoint(struct Process *proc, void *addr);
+
+/* XXX some of the following belongs to proc.h/proc.c.  */
+struct breakpoint *address2bpstruct(struct Process *proc, void *addr);
+void enable_all_breakpoints(struct Process *proc);
+void disable_all_breakpoints(struct Process *proc);
+int breakpoints_init(struct Process *proc, int enable);
+
+void reinitialize_breakpoints(struct Process *proc);
+
+
+#endif /* BREAKPOINT_H */
diff --git a/breakpoints.c b/breakpoints.c
index 387b2a5..5713fe4 100644
--- a/breakpoints.c
+++ b/breakpoints.c
@@ -8,12 +8,30 @@
 #include <sys/ptrace.h>
 #endif
 
+#include "breakpoint.h"
 #include "common.h"
 
+void
+breakpoint_on_hit(struct breakpoint *bp, struct Process *proc)
+{
+	assert(bp != NULL);
+	if (bp->cbs != NULL && bp->cbs->on_hit != NULL)
+		(bp->cbs->on_hit) (bp, proc);
+}
+
+void
+breakpoint_on_destroy(struct breakpoint *bp)
+{
+	assert(bp != NULL);
+	if (bp->cbs != NULL && bp->cbs->on_destroy != NULL)
+		(bp->cbs->on_destroy) (bp);
+}
+
 /*****************************************************************************/
 
-Breakpoint *
-address2bpstruct(Process *proc, void *addr) {
+struct breakpoint *
+address2bpstruct(Process *proc, void *addr)
+{
 	assert(proc != NULL);
 	assert(proc->breakpoints != NULL);
 	assert(proc->leader == proc);
@@ -21,10 +39,11 @@ address2bpstruct(Process *proc, void *addr) {
 	return dict_find_entry(proc->breakpoints, addr);
 }
 
-void
+struct breakpoint *
 insert_breakpoint(Process *proc, void *addr,
-		  struct library_symbol *libsym, int enable) {
-	Breakpoint *sbp;
+		  struct library_symbol *libsym, int enable)
+{
+	struct breakpoint *sbp;
 
 	Process * leader = proc->leader;
 
@@ -43,16 +62,16 @@ insert_breakpoint(Process *proc, void *addr,
 	debug(1, "symbol=%s, addr=%p", libsym?libsym->name:"(nil)", addr);
 
 	if (!addr)
-		return;
+		return NULL;
 
 	if (libsym)
 		libsym->needs_init = 0;
 
 	sbp = dict_find_entry(leader->breakpoints, addr);
-	if (!sbp) {
-		sbp = calloc(1, sizeof(Breakpoint));
-		if (!sbp) {
-			return;	/* TODO FIXME XXX: error_mem */
+	if (sbp == NULL) {
+		sbp = calloc(1, sizeof(*sbp));
+		if (sbp == NULL) {
+			return NULL;	/* TODO FIXME XXX: error_mem */
 		}
 		dict_enter(leader->breakpoints, addr, sbp);
 		sbp->addr = addr;
@@ -67,11 +86,14 @@ insert_breakpoint(Process *proc, void *addr,
 		assert(proc->pid != 0);
 		enable_breakpoint(proc, sbp);
 	}
+
+	return sbp;
 }
 
 void
-delete_breakpoint(Process *proc, void *addr) {
-	Breakpoint *sbp;
+delete_breakpoint(Process *proc, void *addr)
+{
+	struct breakpoint *sbp;
 
 	debug(DEBUG_FUNCTION, "delete_breakpoint(pid=%d, addr=%p)", proc->pid, addr);
 
@@ -91,89 +113,67 @@ delete_breakpoint(Process *proc, void *addr) {
 }
 
 static void
-enable_bp_cb(void *addr, void *sbp, void *proc) {
+enable_bp_cb(void *addr, void *sbp, void *proc)
+{
 	debug(DEBUG_FUNCTION, "enable_bp_cb(pid=%d)", ((Process *)proc)->pid);
-	if (((Breakpoint *)sbp)->enabled) {
+	if (((struct breakpoint *)sbp)->enabled)
 		enable_breakpoint(proc, sbp);
-	}
 }
 
 void
-enable_all_breakpoints(Process *proc) {
+enable_all_breakpoints(Process *proc)
+{
 	debug(DEBUG_FUNCTION, "enable_all_breakpoints(pid=%d)", proc->pid);
-	if (proc->breakpoints_enabled <= 0) {
-#ifdef __powerpc__
-		unsigned long a;
 
+	debug(1, "Enabling breakpoints for pid %u...", proc->pid);
+	if (proc->breakpoints) {
+		dict_apply_to_all(proc->breakpoints, enable_bp_cb,
+				  proc);
+	}
+#ifdef __mips__
+	{
 		/*
-		 * PPC HACK! (XXX FIXME TODO)
-		 * If the dynamic linker hasn't populated the PLT then
-		 * dont enable the breakpoints
+		 * I'm sure there is a nicer way to do this. We need to
+		 * insert breakpoints _after_ the child has been started.
 		 */
-		if (options.libcalls) {
-			a = ptrace(PTRACE_PEEKTEXT, proc->pid,
-				   sym2addr(proc, proc->list_of_symbols),
-				   0);
-			if (a == 0x0)
-				return;
-		}
-#endif
-
-		debug(1, "Enabling breakpoints for pid %u...", proc->pid);
-		if (proc->breakpoints) {
-			dict_apply_to_all(proc->breakpoints, enable_bp_cb,
-					  proc);
-		}
-#ifdef __mips__
-		{
-			/*
-			 * I'm sure there is a nicer way to do this. We need to
-			 * insert breakpoints _after_ the child has been started.
-			 */
-			struct library_symbol *sym;
-			struct library_symbol *new_sym;
-			sym=proc->list_of_symbols;
-			while(sym){
-				void *addr= sym2addr(proc,sym);
-				if(!addr){
-					sym=sym->next;
-					continue;
-				}
-				if(dict_find_entry(proc->breakpoints,addr)){
-					sym=sym->next;
-					continue;
-				}
-				debug(2,"inserting bp %p %s",addr,sym->name);
-				new_sym=malloc(sizeof(*new_sym) + strlen(sym->name) + 1);
-				memcpy(new_sym,sym,sizeof(*new_sym) + strlen(sym->name) + 1);
-				new_sym->next=proc->list_of_symbols;
-				proc->list_of_symbols=new_sym;
-				insert_breakpoint(proc, addr, new_sym);
+		struct library_symbol *sym;
+		struct library_symbol *new_sym;
+		sym=proc->list_of_symbols;
+		while(sym){
+			void *addr= sym2addr(proc,sym);
+			if(!addr){
 				sym=sym->next;
+				continue;
 			}
+			if(dict_find_entry(proc->breakpoints,addr)){
+				sym=sym->next;
+				continue;
+			}
+			debug(2,"inserting bp %p %s",addr,sym->name);
+			new_sym=malloc(sizeof(*new_sym) + strlen(sym->name) + 1);
+			memcpy(new_sym,sym,sizeof(*new_sym) + strlen(sym->name) + 1);
+			new_sym->next=proc->list_of_symbols;
+			proc->list_of_symbols=new_sym;
+			insert_breakpoint(proc, addr, new_sym);
+			sym=sym->next;
 		}
-#endif
 	}
-	proc->breakpoints_enabled = 1;
+#endif
 }
 
 static void
-disable_bp_cb(void *addr, void *sbp, void *proc) {
+disable_bp_cb(void *addr, void *sbp, void *proc)
+{
 	debug(DEBUG_FUNCTION, "disable_bp_cb(pid=%d)", ((Process *)proc)->pid);
-	if (((Breakpoint *)sbp)->enabled) {
+	if (((struct breakpoint *)sbp)->enabled)
 		disable_breakpoint(proc, sbp);
-	}
 }
 
 void
 disable_all_breakpoints(Process *proc) {
 	debug(DEBUG_FUNCTION, "disable_all_breakpoints(pid=%d)", proc->pid);
 	assert(proc->leader == proc);
-	if (proc->breakpoints_enabled) {
-		debug(1, "Disabling breakpoints for pid %u...", proc->pid);
-		dict_apply_to_all(proc->breakpoints, disable_bp_cb, proc);
-	}
-	proc->breakpoints_enabled = 0;
+	dict_apply_to_all(proc->breakpoints, disable_bp_cb, proc);
 }
 
 static void
@@ -183,11 +183,18 @@ free_bp_cb(void *addr, void *sbp, void *data) {
 	free(sbp);
 }
 
+static void
+entry_callback_hit(struct breakpoint *bp, struct Process *proc)
+{
+	if (proc == NULL || proc->leader == NULL)
+		return;
+	delete_breakpoint(proc, bp->addr); // xxx
+	reinitialize_breakpoints(proc->leader);
+}
+
 int
 breakpoints_init(Process *proc, int enable)
 {
-	struct library_symbol *sym;
-
 	debug(DEBUG_FUNCTION, "breakpoints_init(pid=%d)", proc->pid);
 	if (proc->breakpoints) {	/* let's remove that struct */
 		dict_apply_to_all(proc->breakpoints, free_bp_cb, NULL);
@@ -206,9 +213,11 @@ breakpoints_init(Process *proc, int enable)
 	destroy_library_symbol_chain(proc->list_of_symbols);
 	proc->list_of_symbols = NULL;
 
+	GElf_Addr entry;
 	if (options.libcalls && proc->filename) {
-		proc->list_of_symbols = read_elf(proc);
+		proc->list_of_symbols = read_elf(proc, &entry);
 		if (proc->list_of_symbols == NULL) {
+		fail:
 			/* XXX leak breakpoints */
 			return -1;
 		}
@@ -235,11 +244,19 @@ breakpoints_init(Process *proc, int enable)
 		}
 	}
 
-	for (sym = proc->list_of_symbols; sym; sym = sym->next)
-		insert_breakpoint(proc, sym2addr(proc, sym), sym, enable);
+	struct breakpoint *entry_bp
+		= insert_breakpoint(proc, (void *)(uintptr_t)entry, NULL, 1);
+	if (entry_bp == NULL) {
+		fprintf(stderr, "fail!\n");
+		goto fail;
+	}
+
+	static struct bp_callbacks entry_callbacks = {
+		.on_hit = entry_callback_hit,
+	};
+	entry_bp->cbs = &entry_callbacks;
 
 	proc->callstack_depth = 0;
-	proc->breakpoints_enabled = -1;
 	return 0;
 }
 
diff --git a/common.h b/common.h
index 715898d..a47cd89 100644
--- a/common.h
+++ b/common.h
@@ -26,17 +26,6 @@ extern char * command;
 
 extern int exiting;  /* =1 if we have to exit ASAP */
 
-typedef struct Breakpoint Breakpoint;
-struct Breakpoint {
-	void * addr;
-	unsigned char orig_value[BREAKPOINT_LENGTH];
-	int enabled;
-	struct library_symbol * libsym;
-#ifdef __arm__
-	int thumb_mode;
-#endif
-};
-
 enum arg_type {
 	ARGTYPE_UNKNOWN = -1,
 	ARGTYPE_VOID,
@@ -187,11 +176,10 @@ struct Process {
 	pid_t pid;
 
 	/* Dictionary of breakpoints (which is a mapping
-	 * address->Breakpoint).  This is NULL for non-leader
+	 * address->breakpoint).  This is NULL for non-leader
 	 * processes.  */
 	Dict * breakpoints;
 
-	int breakpoints_enabled;  /* -1:not enabled yet, 0:disabled, 1:enabled */
 	int mask_32bit;           /* 1 if 64-bit ltrace is tracing 32-bit process */
 	unsigned int personality;
 	int tracesysgood;         /* signal indicating a PTRACE_SYSCALL trap */
@@ -296,14 +284,7 @@ extern void destroy_event_handler(Process * proc);
 
 extern pid_t execute_program(const char * command, char ** argv);
 extern int display_arg(enum tof type, Process * proc, int arg_num, arg_type_info * info);
-extern Breakpoint * address2bpstruct(Process * proc, void * addr);
-extern int breakpoints_init(Process * proc, int enable);
-extern void insert_breakpoint(Process * proc, void * addr,
-			      struct library_symbol * libsym, int enable);
-extern void delete_breakpoint(Process * proc, void * addr);
-extern void enable_all_breakpoints(Process * proc);
 extern void disable_all_breakpoints(Process * proc);
-extern void reinitialize_breakpoints(Process *);
 
 extern Process * open_program(char * filename, pid_t pid, int init_breakpoints);
 extern void open_pid(pid_t pid);
@@ -322,6 +303,8 @@ extern struct library_symbol * clone_library_symbol(struct library_symbol * s);
 extern void destroy_library_symbol(struct library_symbol * s);
 extern void destroy_library_symbol_chain(struct library_symbol * chain);
 
+struct breakpoint;
+
 /* Arch-dependent stuff: */
 extern char * pid2name(pid_t pid);
 extern pid_t process_leader(pid_t pid);
@@ -329,6 +312,7 @@ extern int process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n);
 extern int process_stopped(pid_t pid);
 extern enum process_status process_status(pid_t pid);
 extern void trace_set_options(Process * proc, pid_t pid);
+extern void wait_for_proc(pid_t pid);
 extern void trace_me(void);
 extern int trace_pid(pid_t pid);
 extern void untrace_pid(pid_t pid);
@@ -338,13 +322,13 @@ extern void set_instruction_pointer(Process * proc, void * addr);
 extern void * get_stack_pointer(Process * proc);
 extern void * get_return_addr(Process * proc, void * stack_pointer);
 extern void set_return_addr(Process * proc, void * addr);
-extern void enable_breakpoint(Process * proc, Breakpoint * sbp);
-extern void disable_breakpoint(Process * proc, Breakpoint * sbp);
+extern void enable_breakpoint(Process * proc, struct breakpoint *sbp);
+extern void disable_breakpoint(Process * proc, struct breakpoint *sbp);
 extern int syscall_p(Process * proc, int status, int * sysnum);
 extern void continue_process(pid_t pid);
 extern void continue_after_signal(pid_t pid, int signum);
 extern void continue_after_syscall(Process *proc, int sysnum, int ret_p);
-extern void continue_after_breakpoint(Process * proc, Breakpoint * sbp);
+extern void continue_after_breakpoint(Process * proc, struct breakpoint *sbp);
 extern void continue_after_vfork(Process * proc);
 extern void ltrace_exiting(void);
 extern long gimme_arg(enum tof type, Process * proc, int arg_num, arg_type_info * info);
diff --git a/execute_program.c b/execute_program.c
index 47f514d..859f32c 100644
--- a/execute_program.c
+++ b/execute_program.c
@@ -89,6 +89,8 @@ execute_program(const char * command, char **argv)
 		_exit(1);
 	}
 
+	wait_for_proc(pid);
+
 	debug(1, "PID=%d", pid);
 
 	return pid;
diff --git a/handle_event.c b/handle_event.c
index 203459c..c146eb9 100644
--- a/handle_event.c
+++ b/handle_event.c
@@ -1,6 +1,6 @@
+#define _GNU_SOURCE
 #include "config.h"
 
-#define _GNU_SOURCE
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -9,12 +9,13 @@
 #include <sys/time.h>
 #include <errno.h>
 
-#include "common.h"
-
 #ifdef __powerpc__
 #include <sys/ptrace.h>
 #endif
 
+#include "common.h"
+#include "breakpoint.h"
+
 static void handle_signal(Event *event);
 static void handle_exit(Event *event);
 static void handle_exit_signal(Event *event);
@@ -155,19 +156,18 @@ address_clone(void * addr, void * data)
 }
 
 static void *
-breakpoint_clone(void * bp, void * data)
+breakpoint_clone(void *bp, void *data)
 {
-	Breakpoint * b;
-	Dict * map = data;
+	Dict *map = data;
 	debug(DEBUG_FUNCTION, "breakpoint_clone(%p)", bp);
-	b = malloc(sizeof(Breakpoint));
+	struct breakpoint *b = malloc(sizeof(*b));
 	if (!b) {
 		perror("malloc()");
 		exit(1);
 	}
-	memcpy(b, bp, sizeof(Breakpoint));
+	memcpy(b, bp, sizeof(*b));
 	if (b->libsym != NULL) {
-		struct library_symbol * sym = dict_find_entry(map, b->libsym);
+		struct library_symbol *sym = dict_find_entry(map, b->libsym);
 		if (b->libsym == NULL) {
 			fprintf(stderr, "Can't find cloned symbol %s.\n",
 				b->libsym->name);
@@ -452,9 +452,6 @@ handle_syscall(Event *event) {
 			output_left(LT_TOF_SYSCALL, event->proc,
 				    sysname(event->proc, event->e_un.sysnum));
 		}
-		if (event->proc->breakpoints_enabled == 0) {
-			enable_all_breakpoints(event->proc);
-		}
 	}
 	continue_after_syscall(event->proc, event->e_un.sysnum, 0);
 }
@@ -462,7 +459,6 @@ handle_syscall(Event *event) {
 static void
 handle_exec(Event * event) {
 	Process * proc = event->proc;
-	pid_t saved_pid;
 
 	debug(DEBUG_FUNCTION, "handle_exec(pid=%d)", proc->pid);
 	if (proc->state == STATE_IGNORED) {
@@ -476,10 +472,7 @@ handle_exec(Event * event) {
 	proc->arch_ptr = NULL;
 	free(proc->filename);
 	proc->filename = pid2name(proc->pid);
-	saved_pid = proc->pid;
-	proc->pid = 0;
 	breakpoints_init(proc, 0);
-	proc->pid = saved_pid;
 	proc->callstack_depth = 0;
 	continue_process(proc->pid);
 }
@@ -493,9 +486,6 @@ handle_arch_syscall(Event *event) {
 			output_left(LT_TOF_SYSCALL, event->proc,
 					arch_sysname(event->proc, event->e_un.sysnum));
 		}
-		if (event->proc->breakpoints_enabled == 0) {
-			enable_all_breakpoints(event->proc);
-		}
 	}
 	continue_process(event->proc->pid);
 }
@@ -559,14 +549,11 @@ handle_arch_sysret(Event *event) {
 	continue_process(event->proc->pid);
 }
 
-#ifdef __powerpc__
-void *get_count_register (Process *proc);
-#endif
-
 static void
-handle_breakpoint(Event *event) {
+handle_breakpoint(Event *event)
+{
 	int i, j;
-	Breakpoint *sbp;
+	struct breakpoint *sbp;
 	Process *leader = event->proc->leader;
 
 	/* The leader has terminated.  */
@@ -578,28 +565,6 @@ handle_breakpoint(Event *event) {
 	debug(DEBUG_FUNCTION, "handle_breakpoint(pid=%d, addr=%p)", event->proc->pid, event->e_un.brk_addr);
 	debug(2, "event: breakpoint (%p)", event->e_un.brk_addr);
 
-#ifdef __powerpc__
-	/* Need to skip following NOP's to prevent a fake function from being stacked.  */
-	long stub_addr = (long) get_count_register(event->proc);
-	Breakpoint *stub_bp = NULL;
-	char nop_instruction[] = PPC_NOP;
-
-	stub_bp = address2bpstruct(leader, event->e_un.brk_addr);
-
-	if (stub_bp) {
-		unsigned char *bp_instruction = stub_bp->orig_value;
-
-		if (memcmp(bp_instruction, nop_instruction,
-			    PPC_NOP_LENGTH) == 0) {
-			if (stub_addr != (long) event->e_un.brk_addr) {
-				set_instruction_pointer (event->proc, event->e_un.brk_addr + 4);
-				continue_process(event->proc->pid);
-				return;
-			}
-		}
-	}
-#endif
-
 	for (i = event->proc->callstack_depth - 1; i >= 0; i--) {
 		if (event->e_un.brk_addr ==
 		    event->proc->callstack[i].return_addr) {
@@ -679,6 +644,8 @@ handle_breakpoint(Event *event) {
 	}
 
 	if ((sbp = address2bpstruct(leader, event->e_un.brk_addr))) {
+		breakpoint_on_hit(sbp, event->proc);
+
 		if (sbp->libsym == NULL) {
 			continue_after_breakpoint(event->proc, sbp);
 			return;
@@ -696,12 +663,6 @@ handle_breakpoint(Event *event) {
 			callstack_push_symfunc(event->proc, sbp->libsym);
 			output_left(LT_TOF_FUNCTION, event->proc, sbp->libsym->name);
 		}
-#ifdef PLT_REINITALISATION_BP
-		if (event->proc->need_to_reinitialize_breakpoints
-		    && (strcmp(sbp->libsym->name, PLTs_initialized_by_here) ==
-			0))
-			reinitialize_breakpoints(leader);
-#endif
 
 		continue_after_breakpoint(event->proc, sbp);
 		return;
diff --git a/ltrace-elf.c b/ltrace-elf.c
index 8dbc298..f7fc239 100644
--- a/ltrace-elf.c
+++ b/ltrace-elf.c
@@ -662,7 +662,8 @@ opd2addr(struct ltelf *lte, GElf_Addr addr) {
 }
 
 struct library_symbol *
-read_elf(Process *proc) {
+read_elf(Process *proc, GElf_Addr *entryp)
+{
 	struct ltelf lte[MAX_LIBRARIES + 1];
 	size_t i;
 	struct opt_x_t *xptr;
@@ -700,7 +701,6 @@ read_elf(Process *proc) {
 #ifdef __mips__
 		// MIPS doesn't use the PLT and the GOT entries get changed
 		// on startup.
-		proc->need_to_reinitialize_breakpoints = 1;
 		for(i=lte->mips_gotsym; i<lte->dynsym_count;i++){
 			GElf_Sym sym;
 			const char *name;
@@ -745,11 +745,6 @@ read_elf(Process *proc) {
 						"Couldn't get relocation from \"%s\"",
 						proc->filename);
 
-#ifdef PLT_REINITALISATION_BP
-			if (!sym.st_value && PLTs_initialized_by_here)
-				proc->need_to_reinitialize_breakpoints = 1;
-#endif
-
 			name = lte->dynstr + sym.st_name;
 			count = library_num ? library_num+1 : 0;
 
@@ -772,30 +767,6 @@ read_elf(Process *proc) {
 			}
 		}
 #endif // !__mips__
-#ifdef PLT_REINITALISATION_BP
-		struct opt_x_t *main_cheat;
-
-		if (proc->need_to_reinitialize_breakpoints) {
-			/* Add "PLTs_initialized_by_here" to opt_x list, if not
-				 already there. */
-			main_cheat = (struct opt_x_t *)malloc(sizeof(struct opt_x_t));
-			if (main_cheat == NULL)
-				error(EXIT_FAILURE, 0, "Couldn't allocate memory");
-			main_cheat->next = opt_x_loc;
-			main_cheat->found = 0;
-			main_cheat->name = PLTs_initialized_by_here;
-
-			for (xptr = opt_x_loc; xptr; xptr = xptr->next)
-				if (strcmp(xptr->name, PLTs_initialized_by_here) == 0
-						&& main_cheat) {
-					free(main_cheat);
-					main_cheat = NULL;
-					break;
-				}
-			if (main_cheat)
-				opt_x_loc = main_cheat;
-		}
-#endif
 	} else {
 		lib_tail = &library_symbols;
 	}
@@ -850,16 +821,17 @@ read_elf(Process *proc) {
 		}
 	}
 
+	if (lte->ehdr.e_entry != 0) {
+		*entryp = opd2addr(lte, lte->ehdr.e_entry);
+	} else {
+	}
+
 	for (xptr = opt_x_loc; xptr; xptr = xptr->next)
 		if ( ! xptr->found) {
 			char *badthing = "WARNING";
 #ifdef PLT_REINITALISATION_BP
 			if (strcmp(xptr->name, PLTs_initialized_by_here) == 0) {
 				if (lte->ehdr.e_entry) {
-					add_library_symbol (
-						opd2addr (lte, lte->ehdr.e_entry),
-						PLTs_initialized_by_here,
-						lib_tail, 1, 0);
 					fprintf (stderr, "WARNING: Using e_ent"
 						 "ry from elf header (%p) for "
 						 "address of \"%s\"\n", (void*)
diff --git a/ltrace-elf.h b/ltrace-elf.h
index 3b675c5..4da8a0a 100644
--- a/ltrace-elf.h
+++ b/ltrace-elf.h
@@ -45,7 +45,7 @@ extern size_t library_num;
 extern char *library[MAX_LIBRARIES];
 
 extern int open_elf(struct ltelf *lte, const char *filename);
-extern struct library_symbol *read_elf(Process *);
+extern struct library_symbol *read_elf(Process *proc, GElf_Addr *entryp);
 
 extern GElf_Addr arch_plt_sym_val(struct ltelf *, size_t, GElf_Rela *);
 
diff --git a/proc.c b/proc.c
index f4d3396..5febc3f 100644
--- a/proc.c
+++ b/proc.c
@@ -14,6 +14,7 @@
 #include <error.h>
 
 #include "common.h"
+#include "breakpoint.h"
 
 Process *
 open_program(char *filename, pid_t pid, int enable) {
@@ -26,7 +27,6 @@ open_program(char *filename, pid_t pid, int enable) {
 	}
 
 	proc->filename = strdup(filename);
-	proc->breakpoints_enabled = -1;
 	proc->pid = pid;
 #if defined(HAVE_LIBUNWIND)
 	proc->unwind_priv = _UPT_create(pid);
@@ -39,13 +39,15 @@ open_program(char *filename, pid_t pid, int enable) {
 		return NULL;
 	}
 
-	if (proc->leader == proc)
+	if (proc->leader == proc) {
+		trace_set_options(proc, proc->pid);
 		if (breakpoints_init(proc, enable)) {
 			fprintf(stderr, "failed to init breakpoints %d\n",
 				proc->pid);
 			remove_process(proc);
 			return NULL;
 		}
+	}
 
 	return proc;
 }
@@ -73,11 +75,10 @@ open_one_pid(pid_t pid)
 	return 0;
 }
 
-enum pcb_status
+static enum pcb_status
 start_one_pid(Process * proc, void * data)
 {
 	continue_process(proc->pid);
-	proc->breakpoints_enabled = 1;
 	return pcb_cont;
 }
 
@@ -116,7 +117,7 @@ open_pid(pid_t pid)
 		if (process_tasks(pid, &tasks, &ntasks) < 0) {
 			fprintf(stderr, "Cannot obtain tasks of pid %u: %s\n",
 				pid, strerror(errno));
-			goto start;
+			break;
 		}
 
 		have_all = 1;
@@ -135,7 +136,6 @@ open_pid(pid_t pid)
 	/* Done.  Now initialize breakpoints and then continue
 	 * everyone.  */
 	Process * leader;
-start:
 	leader = pid2proc(pid)->leader;
 	enable_all_breakpoints(leader);
 
diff --git a/sysdeps/linux-gnu/arm/breakpoint.c b/sysdeps/linux-gnu/arm/breakpoint.c
index 4e17940..493f973 100644
--- a/sysdeps/linux-gnu/arm/breakpoint.c
+++ b/sysdeps/linux-gnu/arm/breakpoint.c
@@ -27,7 +27,8 @@
 #include "common.h"
 
 void
-arch_enable_breakpoint(pid_t pid, Breakpoint *sbp) {
+arch_enable_breakpoint(pid_t pid, struct breakpoint *sbp)
+{
 	unsigned int i, j;
 	const unsigned char break_insn[] = BREAKPOINT_VALUE;
 	const unsigned char thumb_break_insn[] = THUMB_BREAKPOINT_VALUE;
@@ -59,7 +60,8 @@ arch_enable_breakpoint(pid_t pid, Breakpoint *sbp) {
 }
 
 void
-arch_disable_breakpoint(pid_t pid, const Breakpoint *sbp) {
+arch_disable_breakpoint(pid_t pid, const struct breakpoint *sbp)
+{
 	unsigned int i, j;
 
 	debug(1, "arch_disable_breakpoint(%d,%p)", pid, sbp->addr);
diff --git a/sysdeps/linux-gnu/breakpoint.c b/sysdeps/linux-gnu/breakpoint.c
index 5a49e9d..b98374b 100644
--- a/sysdeps/linux-gnu/breakpoint.c
+++ b/sysdeps/linux-gnu/breakpoint.c
@@ -5,12 +5,13 @@
 
 #include "common.h"
 #include "arch.h"
+#include "breakpoint.h"
 
 #ifdef ARCH_HAVE_ENABLE_BREAKPOINT
-extern void arch_enable_breakpoint(pid_t, Breakpoint *);
+extern void arch_enable_breakpoint(pid_t, struct breakpoint *);
 #else				/* ARCH_HAVE_ENABLE_BREAKPOINT */
 void
-arch_enable_breakpoint(pid_t pid, Breakpoint *sbp)
+arch_enable_breakpoint(pid_t pid, struct breakpoint *sbp)
 {
 	static unsigned char break_insn[] = BREAKPOINT_VALUE;
 	unsigned int i, j;
@@ -38,7 +39,8 @@ arch_enable_breakpoint(pid_t pid, Breakpoint *sbp)
 #endif				/* ARCH_HAVE_ENABLE_BREAKPOINT */
 
 void
-enable_breakpoint(Process * proc, Breakpoint *sbp) {
+enable_breakpoint(Process *proc, struct breakpoint *sbp)
+{
 	if (sbp->libsym) {
 		debug(DEBUG_PROCESS, "enable_breakpoint: pid=%d, addr=%p, symbol=%s", proc->pid, sbp->addr, sbp->libsym->name);
 	} else {
@@ -48,10 +50,10 @@ enable_breakpoint(Process * proc, Breakpoint *sbp) {
 }
 
 #ifdef ARCH_HAVE_DISABLE_BREAKPOINT
-extern void arch_disable_breakpoint(pid_t, const Breakpoint *sbp);
+extern void arch_disable_breakpoint(pid_t, const struct breakpoint *sbp);
 #else				/* ARCH_HAVE_DISABLE_BREAKPOINT */
 void
-arch_disable_breakpoint(pid_t pid, const Breakpoint *sbp)
+arch_disable_breakpoint(pid_t pid, const struct breakpoint *sbp)
 {
 	unsigned int i, j;
 
@@ -78,7 +80,8 @@ arch_disable_breakpoint(pid_t pid, const Breakpoint *sbp)
 #endif				/* ARCH_HAVE_DISABLE_BREAKPOINT */
 
 void
-disable_breakpoint(Process * proc, Breakpoint *sbp) {
+disable_breakpoint(Process *proc, struct breakpoint *sbp)
+{
 	if (sbp->libsym) {
 		debug(DEBUG_PROCESS, "disable_breakpoint: pid=%d, addr=%p, symbol=%s", proc->pid, sbp->addr, sbp->libsym->name);
 	} else {
diff --git a/sysdeps/linux-gnu/events.c b/sysdeps/linux-gnu/events.c
index 021192f..3174c1a 100644
--- a/sysdeps/linux-gnu/events.c
+++ b/sysdeps/linux-gnu/events.c
@@ -12,6 +12,7 @@
 #include <unistd.h>
 
 #include "common.h"
+#include "breakpoint.h"
 
 static Event event;
 
@@ -166,19 +167,9 @@ next_event(void)
 	}
 	get_arch_dep(event.proc);
 	debug(3, "event from pid %u", pid);
-	if (event.proc->breakpoints_enabled == -1)
-		trace_set_options(event.proc, event.proc->pid);
 	Process *leader = event.proc->leader;
 	if (leader == event.proc) {
-		if (event.proc->breakpoints_enabled == -1) {
-			event.type = EVENT_NONE;
-			enable_all_breakpoints(event.proc);
-			continue_process(event.proc->pid);
-			debug(DEBUG_EVENT,
-			      "event: NONE: pid=%d (enabling breakpoints)",
-			      pid);
-			return &event;
-		} else if (!event.proc->libdl_hooked) {
+		if (!event.proc->libdl_hooked) {
 			/* debug struct may not have been written yet.. */
 			if (linkmap_init(event.proc, &main_lte) == 0) {
 				event.proc->libdl_hooked = 1;
diff --git a/sysdeps/linux-gnu/ia64/breakpoint.c b/sysdeps/linux-gnu/ia64/breakpoint.c
index 45ee11e..a0bfaf9 100644
--- a/sysdeps/linux-gnu/ia64/breakpoint.c
+++ b/sysdeps/linux-gnu/ia64/breakpoint.c
@@ -150,7 +150,8 @@ union bundle_t {
 };
 
 void
-arch_enable_breakpoint(pid_t pid, Breakpoint *sbp) {
+arch_enable_breakpoint(pid_t pid, struct breakpoint *sbp)
+{
 
 	unsigned long addr = (unsigned long)sbp->addr;
 	union bundle_t bundle;
@@ -187,7 +188,8 @@ arch_enable_breakpoint(pid_t pid, Breakpoint *sbp) {
 }
 
 void
-arch_disable_breakpoint(pid_t pid, const Breakpoint *sbp) {
+arch_disable_breakpoint(pid_t pid, const struct breakpoint *sbp)
+{
 
 	unsigned long addr = (unsigned long)sbp->addr;
 	int slotnum = (int)(addr & 0x0f) & 0x3;
diff --git a/sysdeps/linux-gnu/proc.c b/sysdeps/linux-gnu/proc.c
index a99593c..3350117 100644
--- a/sysdeps/linux-gnu/proc.c
+++ b/sysdeps/linux-gnu/proc.c
@@ -1,6 +1,5 @@
 #define _GNU_SOURCE /* For getline.  */
 #include "config.h"
-#include "common.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -17,6 +16,8 @@
 #include <sys/syscall.h>
 #include <error.h>
 
+#include "common.h"
+#include "breakpoint.h"
 
 /* /proc/pid doesn't exist just after the fork, and sometimes `ltrace'
  * couldn't open it to find the executable.  So it may be necessary to
diff --git a/sysdeps/linux-gnu/trace.c b/sysdeps/linux-gnu/trace.c
index db18df0..b4d8fd1 100644
--- a/sysdeps/linux-gnu/trace.c
+++ b/sysdeps/linux-gnu/trace.c
@@ -11,6 +11,7 @@
 
 #include "common.h"
 #include "config.h"
+#include "breakpoint.h"
 
 /* If the system headers did not provide the constants, hard-code the normal
    values.  */
@@ -77,6 +78,29 @@ trace_me(void) {
 	}
 }
 
+/* There's a (hopefully) brief period of time after the child process
+ * exec's when we can't trace it yet.  Here we wait for kernel to
+ * prepare the process.  */
+void
+wait_for_proc(pid_t pid)
+{
+	size_t i;
+	for (i = 0; i < 100; ++i) {
+		/* We read from memory address 0, but that shouldn't
+		 * be a problem: the reading will just fail.  We are
+		 * looking for a particular reason of failure.  */
+		if (ptrace(PTRACE_PEEKTEXT, pid, 0, 0) != -1
+		    || errno != ESRCH)
+			return;
+
+		usleep(1000);
+	}
+
+	fprintf(stderr, "\
+I consistently fail to read a word from the freshly launched process.\n\
+I'll now try to proceed with tracing, but this shouldn't be happening.\n");
+}
+
 int
 trace_pid(pid_t pid) {
 	debug(DEBUG_PROCESS, "trace_pid: pid=%d", pid);
@@ -193,7 +217,7 @@ struct process_stopping_handler
 	Process * task_enabling_breakpoint;
 
 	/* The pointer being re-enabled.  */
-	Breakpoint * breakpoint_being_enabled;
+	struct breakpoint *breakpoint_being_enabled;
 
 	enum {
 		/* We are waiting for everyone to land in t/T.  */
@@ -364,7 +388,7 @@ static void
 ugly_workaround(Process * proc)
 {
 	void * ip = get_instruction_pointer(proc);
-	Breakpoint * sbp = dict_find_entry(proc->leader->breakpoints, ip);
+	struct breakpoint *sbp = dict_find_entry(proc->leader->breakpoints, ip);
 	if (sbp != NULL)
 		enable_breakpoint(proc, sbp);
 	else
@@ -578,7 +602,7 @@ process_stopping_on_event(Event_Handler * super, Event * event)
 	struct process_stopping_handler * self = (void *)super;
 	Process * task = event->proc;
 	Process * leader = task->leader;
-	Breakpoint * sbp = self->breakpoint_being_enabled;
+	struct breakpoint *sbp = self->breakpoint_being_enabled;
 	Process * teb = self->task_enabling_breakpoint;
 
 	debug(DEBUG_PROCESS,
@@ -687,7 +711,7 @@ process_stopping_destroy(Event_Handler * super)
 }
 
 void
-continue_after_breakpoint(Process *proc, Breakpoint *sbp)
+continue_after_breakpoint(Process *proc, struct breakpoint *sbp)
 {
 	set_instruction_pointer(proc, sbp->addr);
 	if (sbp->enabled == 0) {
@@ -851,7 +875,7 @@ static Event *
 process_vfork_on_event(Event_Handler * super, Event * event)
 {
 	struct process_vfork_handler * self = (void *)super;
-	Breakpoint * sbp;
+	struct breakpoint *sbp;
 	assert(self != NULL);
 
 	switch (event->type) {