rpms/ltrace
7
0
Fork 0
Code Issues Pull Requests Releases Activity
66bd20ff53
ltrace/ltrace-0.6.0-threads.patch
Petr Machata 1e29979d39 Add several upstream patches
2011-09-03 00:41:59 +02:00

2798 lines
78 KiB
Diff
Raw Blame History

diff --git a/breakpoints.c b/breakpoints.c
index 1ea406a..1eff8b0 100644
--- a/breakpoints.c
+++ b/breakpoints.c
@@ -14,15 +14,25 @@
Breakpoint *
address2bpstruct(Process *proc, void *addr) {
+ assert(proc != NULL);
+ assert(proc->breakpoints != NULL);
+ assert(proc->leader == proc);
debug(DEBUG_FUNCTION, "address2bpstruct(pid=%d, addr=%p)", proc->pid, addr);
return dict_find_entry(proc->breakpoints, addr);
}
void
insert_breakpoint(Process *proc, void *addr,
- struct library_symbol *libsym) {
+ struct library_symbol *libsym, int enable) {
Breakpoint *sbp;
+ Process * leader = proc->leader;
+
+ /* Only the group leader should be getting the breakpoints and
+ * thus have ->breakpoint initialized. */
+ assert(leader != NULL);
+ assert(leader->breakpoints != NULL);
+
#ifdef __arm__
int thumb_mode = (int)addr & 1;
if (thumb_mode)
@@ -38,13 +48,13 @@ insert_breakpoint(Process *proc, void *addr,
if (libsym)
libsym->needs_init = 0;
- sbp = dict_find_entry(proc->breakpoints, addr);
+ sbp = dict_find_entry(leader->breakpoints, addr);
if (!sbp) {
sbp = calloc(1, sizeof(Breakpoint));
if (!sbp) {
return; /* TODO FIXME XXX: error_mem */
}
- dict_enter(proc->breakpoints, addr, sbp);
+ dict_enter(leader->breakpoints, addr, sbp);
sbp->addr = addr;
sbp->libsym = libsym;
}
@@ -53,8 +63,10 @@ insert_breakpoint(Process *proc, void *addr,
proc->thumb_mode = 0;
#endif
sbp->enabled++;
- if (sbp->enabled == 1 && proc->pid)
- enable_breakpoint(proc->pid, sbp);
+ if (sbp->enabled == 1 && enable) {
+ assert(proc->pid != 0);
+ enable_breakpoint(proc, sbp);
+ }
}
void
@@ -63,7 +75,10 @@ delete_breakpoint(Process *proc, void *addr) {
debug(DEBUG_FUNCTION, "delete_breakpoint(pid=%d, addr=%p)", proc->pid, addr);
- sbp = dict_find_entry(proc->breakpoints, addr);
+ Process * leader = proc->leader;
+ assert(leader != NULL);
+
+ sbp = dict_find_entry(leader->breakpoints, addr);
assert(sbp); /* FIXME: remove after debugging has been done. */
/* This should only happen on out-of-memory conditions. */
if (sbp == NULL)
@@ -71,7 +86,7 @@ delete_breakpoint(Process *proc, void *addr) {
sbp->enabled--;
if (sbp->enabled == 0)
- disable_breakpoint(proc->pid, sbp);
+ disable_breakpoint(proc, sbp);
assert(sbp->enabled >= 0);
}
@@ -79,7 +94,7 @@ static void
enable_bp_cb(void *addr, void *sbp, void *proc) {
debug(DEBUG_FUNCTION, "enable_bp_cb(pid=%d)", ((Process *)proc)->pid);
if (((Breakpoint *)sbp)->enabled) {
- enable_breakpoint(((Process *)proc)->pid, sbp);
+ enable_breakpoint(proc, sbp);
}
}
@@ -146,13 +161,14 @@ static void
disable_bp_cb(void *addr, void *sbp, void *proc) {
debug(DEBUG_FUNCTION, "disable_bp_cb(pid=%d)", ((Process *)proc)->pid);
if (((Breakpoint *)sbp)->enabled) {
- disable_breakpoint(((Process *)proc)->pid, sbp);
+ 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);
@@ -167,8 +183,9 @@ free_bp_cb(void *addr, void *sbp, void *data) {
free(sbp);
}
-void
-breakpoints_init(Process *proc) {
+int
+breakpoints_init(Process *proc, int enable)
+{
struct library_symbol *sym;
debug(DEBUG_FUNCTION, "breakpoints_init(pid=%d)", proc->pid);
@@ -177,19 +194,41 @@ breakpoints_init(Process *proc) {
dict_clear(proc->breakpoints);
proc->breakpoints = NULL;
}
- proc->breakpoints = dict_init(dict_key2hash_int, dict_key_cmp_int);
+
+ /* Only the thread group leader should hold the breakpoints.
+ * (N.B. PID may be set to 0 temporarily when called by
+ * handle_exec). */
+ assert(proc->leader == proc);
+
+ proc->breakpoints = dict_init(dict_key2hash_int,
+ dict_key_cmp_int);
+
+ if (proc->list_of_symbols != NULL) {
+ struct library_symbol * sym = proc->list_of_symbols;
+ while (sym != NULL) {
+ struct library_symbol * next = sym->next;
+ free(sym);
+ sym = next;
+ }
+ }
+ proc->list_of_symbols = NULL;
if (options.libcalls && proc->filename) {
- /* FIXME: memory leak when called by exec(): */
proc->list_of_symbols = read_elf(proc);
+ if (proc->list_of_symbols == NULL) {
+ /* XXX leak breakpoints */
+ return -1;
+ }
+
if (opt_e) {
- struct library_symbol **tmp1 = &(proc->list_of_symbols);
+ struct library_symbol **tmp1 = &proc->list_of_symbols;
while (*tmp1) {
struct opt_e_t *tmp2 = opt_e;
int keep = !opt_e_enable;
while (tmp2) {
- if (!strcmp((*tmp1)->name, tmp2->name)) {
+ if (!strcmp((*tmp1)->name,
+ tmp2->name)) {
keep = opt_e_enable;
}
tmp2 = tmp2->next;
@@ -201,15 +240,14 @@ breakpoints_init(Process *proc) {
}
}
}
- } else {
- proc->list_of_symbols = NULL;
- }
- for (sym = proc->list_of_symbols; sym; sym = sym->next) {
- /* proc->pid==0 delays enabling. */
- insert_breakpoint(proc, sym2addr(proc, sym), sym);
}
+
+ for (sym = proc->list_of_symbols; sym; sym = sym->next)
+ insert_breakpoint(proc, sym2addr(proc, sym), sym, enable);
+
proc->callstack_depth = 0;
proc->breakpoints_enabled = -1;
+ return 0;
}
void
@@ -222,8 +260,7 @@ reinitialize_breakpoints(Process *proc) {
while (sym) {
if (sym->needs_init) {
- insert_breakpoint(proc, sym2addr(proc, sym),
- sym);
+ insert_breakpoint(proc, sym2addr(proc, sym), sym, 1);
if (sym->needs_init && !sym->is_weak) {
fprintf(stderr,
"could not re-initialize breakpoint for \"%s\" in file \"%s\"\n",
diff --git a/common.h b/common.h
index 70e4a5a..49861cf 100644
--- a/common.h
+++ b/common.h
@@ -1,3 +1,4 @@
+#include <config.h>
#if defined(HAVE_LIBUNWIND)
#include <libunwind.h>
#endif /* defined(HAVE_LIBUNWIND) */
@@ -161,12 +162,32 @@ enum Process_State {
STATE_IGNORED /* ignore this process (it's a fork and no -f was used) */
};
+typedef struct Event_Handler Event_Handler;
+struct Event_Handler {
+ /* Event handler that overrides the default one. Should
+ * return NULL if the event was handled, otherwise the
+ * returned event is passed to the default handler. */
+ Event * (* on_event)(Event_Handler * self, Event * event);
+
+ /* Called when the event handler removal is requested. */
+ void (* destroy)(Event_Handler * self);
+};
+
+/* XXX We would rather have this all organized a little differently,
+ * have Process for the whole group and Task for what's there for
+ * per-thread stuff. But for now this is the less invasive way of
+ * structuring it. */
struct Process {
Process_State state;
Process * parent; /* needed by STATE_BEING_CREATED */
char * filename;
pid_t pid;
+
+ /* Dictionary of breakpoints (which is a mapping
+ * 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;
@@ -183,7 +204,6 @@ struct Process {
void * instruction_pointer;
void * stack_pointer; /* To get return addr, args... */
void * return_addr;
- Breakpoint * breakpoint_being_enabled;
void * arch_ptr;
short e_machine;
short need_to_reinitialize_breakpoints;
@@ -191,16 +211,28 @@ struct Process {
int thumb_mode; /* ARM execution mode: 0: ARM, 1: Thumb */
#endif
- /* output: */
- enum tof type_being_displayed;
-
#if defined(HAVE_LIBUNWIND)
/* libunwind address space */
unw_addr_space_t unwind_as;
void *unwind_priv;
#endif /* defined(HAVE_LIBUNWIND) */
+ /* Set in leader. */
+ Event_Handler * event_handler;
+
+
+ /**
+ * Process chaining.
+ **/
Process * next;
+
+ /* LEADER points to the leader thread of the POSIX.1 process.
+ If X->LEADER == X, then X is the leader thread and the
+ Process structures chained by NEXT represent other threads,
+ up until, but not including, the next leader thread.
+ LEADER may be NULL after the leader has already exited. In
+ that case this process is waiting to be collected. */
+ Process * leader;
};
struct opt_c_struct {
@@ -216,27 +248,64 @@ struct opt_c_struct {
extern Dict * dict_opt_c;
-extern Process * list_of_processes;
+enum process_status {
+ ps_invalid, /* Failure. */
+ ps_stop, /* Job-control stop. */
+ ps_tracing_stop,
+ ps_zombie,
+ ps_other, /* Necessary other states can be added as needed. */
+};
-extern Event * next_event(void);
+enum pcb_status {
+ pcb_stop, /* The iteration should stop. */
+ pcb_cont, /* The iteration should continue. */
+};
+
+/* Process list */
extern Process * pid2proc(pid_t pid);
+extern void add_process(Process * proc);
+extern void remove_process(Process * proc);
+extern Process *each_process(Process * start,
+ enum pcb_status (* cb)(Process * proc, void * data),
+ void * data);
+extern Process *each_task(Process * start,
+ enum pcb_status (* cb)(Process * proc, void * data),
+ void * data);
+
+/* Events */
+enum ecb_status {
+ ecb_cont, /* The iteration should continue. */
+ ecb_yield, /* The iteration should stop, yielding this
+ * event. */
+ ecb_deque, /* Like ecb_stop, but the event should be removed
+ * from the queue. */
+};
+extern Event * next_event(void);
+extern Event * each_qd_event(enum ecb_status (* cb)(Event * event, void * data),
+ void * data);
+extern void enque_event(Event * event);
extern void handle_event(Event * event);
-extern void execute_program(Process *, char **);
+
+extern void install_event_handler(Process * proc, Event_Handler * handler);
+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 void breakpoints_init(Process * proc);
-extern void insert_breakpoint(Process * proc, void * addr, struct library_symbol * libsym);
+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);
+extern Process * open_program(char * filename, pid_t pid, int init_breakpoints);
extern void open_pid(pid_t pid);
extern void show_summary(void);
extern arg_type_info * lookup_prototype(enum arg_type at);
-extern void do_init_elf(struct ltelf *lte, const char *filename);
+extern int do_init_elf(struct ltelf *lte, const char *filename);
extern void do_close_elf(struct ltelf *lte);
extern int in_load_libraries(const char *name, struct ltelf *lte, size_t count, GElf_Sym *sym);
extern struct library_symbol *library_symbols;
@@ -246,6 +315,10 @@ extern void add_library_symbol(GElf_Addr addr, const char *name,
/* Arch-dependent stuff: */
extern char * pid2name(pid_t pid);
+extern pid_t process_leader(pid_t pid);
+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 trace_me(void);
extern int trace_pid(pid_t pid);
@@ -256,13 +329,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(pid_t pid, Breakpoint * sbp);
-extern void disable_breakpoint(pid_t pid, const Breakpoint * sbp);
+extern void enable_breakpoint(Process * proc, Breakpoint * sbp);
+extern void disable_breakpoint(Process * proc, 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_breakpoint(Process * proc, Breakpoint * sbp);
-extern void continue_enabling_breakpoint(pid_t pid, Breakpoint * sbp);
+extern void ltrace_exiting(void);
extern long gimme_arg(enum tof type, Process * proc, int arg_num, arg_type_info * info);
extern void save_register_args(enum tof type, Process * proc);
extern int umovestr(Process * proc, void * addr, int len, void * laddr);
@@ -272,5 +345,7 @@ extern int ffcheck(void * maddr);
extern void * sym2addr(Process *, struct library_symbol *);
extern int linkmap_init(Process *, struct ltelf *);
extern void arch_check_dbg(Process *proc);
+extern int task_kill (pid_t pid, int sig);
+
extern struct ltelf main_lte;
diff --git a/execute_program.c b/execute_program.c
index 3651b66..47f514d 100644
--- a/execute_program.c
+++ b/execute_program.c
@@ -17,7 +17,8 @@
#include "common.h"
static void
-change_uid(Process *proc) {
+change_uid(const char * command)
+{
uid_t run_uid, run_euid;
gid_t run_gid, run_egid;
@@ -49,7 +50,7 @@ change_uid(Process *proc) {
run_euid = run_uid;
run_egid = run_gid;
- if (!stat(proc->filename, &statbuf)) {
+ if (!stat(command, &statbuf)) {
if (statbuf.st_mode & S_ISUID) {
run_euid = statbuf.st_uid;
}
@@ -68,32 +69,27 @@ change_uid(Process *proc) {
}
}
-void
-execute_program(Process *sp, char **argv) {
+pid_t
+execute_program(const char * command, char **argv)
+{
pid_t pid;
- debug(1, "Executing `%s'...", sp->filename);
+ debug(1, "Executing `%s'...", command);
pid = fork();
if (pid < 0) {
perror("ltrace: fork");
exit(1);
} else if (!pid) { /* child */
- change_uid(sp);
+ change_uid(command);
trace_me();
- execvp(sp->filename, argv);
- fprintf(stderr, "Can't execute `%s': %s\n", sp->filename,
+ execvp(command, argv);
+ fprintf(stderr, "Can't execute `%s': %s\n", command,
strerror(errno));
_exit(1);
}
debug(1, "PID=%d", pid);
- sp->pid = pid;
-
-#if defined(HAVE_LIBUNWIND)
- sp->unwind_priv = _UPT_create(pid);
-#endif /* defined(HAVE_LIBUNWIND) */
-
- return;
+ return pid;
}
diff --git a/handle_event.c b/handle_event.c
index 01309ff..0aa40f7 100644
--- a/handle_event.c
+++ b/handle_event.c
@@ -25,7 +25,6 @@ static void handle_clone(Event *event);
static void handle_exec(Event *event);
static void handle_breakpoint(Event *event);
static void handle_new(Event *event);
-static void remove_proc(Process *proc);
static void callstack_push_syscall(Process *proc, int sysnum);
static void callstack_push_symfunc(Process *proc,
@@ -38,7 +37,26 @@ static char * arch_sysname(Process *proc, int sysnum);
void
handle_event(Event *event) {
- debug(DEBUG_FUNCTION, "handle_event(pid=%d, type=%d)", event->proc ? event->proc->pid : -1, event->type);
+ if (exiting == 1) {
+ exiting = 2;
+ debug(1, "ltrace about to exit");
+ ltrace_exiting();
+ }
+ debug(DEBUG_FUNCTION, "handle_event(pid=%d, type=%d)",
+ event->proc ? event->proc->pid : -1, event->type);
+ /* If the thread group defines an overriding event handler,
+ give it a chance to kick in. */
+ if (event->proc != NULL
+ && event->proc->leader != NULL) {
+ Event_Handler * handler = event->proc->leader->event_handler;
+ if (handler != NULL) {
+ event = (*handler->on_event) (handler, event);
+ if (event == NULL)
+ /* It was handled. */
+ return;
+ }
+ }
+
switch (event->type) {
case EVENT_NONE:
debug(1, "event: none");
@@ -202,24 +220,24 @@ handle_clone(Event * event) {
p->pid = event->e_un.newpid;
p->parent = event->proc;
+ /* We save register values to the arch pointer, and these need
+ to be per-thread. */
+ p->arch_ptr = NULL;
+
if (pending_new(p->pid)) {
pending_new_remove(p->pid);
- if (p->breakpoint_being_enabled) {
- enable_breakpoint(p->pid, p->breakpoint_being_enabled);
- p->breakpoint_being_enabled = NULL;
- }
+ if (p->event_handler != NULL)
+ destroy_event_handler(p);
if (event->proc->state == STATE_ATTACHED && options.follow) {
p->state = STATE_ATTACHED;
} else {
p->state = STATE_IGNORED;
}
continue_process(p->pid);
- p->next = list_of_processes;
- list_of_processes = p;
+ add_process(p);
} else {
p->state = STATE_BEING_CREATED;
- p->next = list_of_processes;
- list_of_processes = p;
+ add_process(p);
}
continue_process(event->proc->pid);
}
@@ -235,10 +253,8 @@ handle_new(Event * event) {
pending_new_insert(event->e_un.newpid);
} else {
assert(proc->state == STATE_BEING_CREATED);
- if (proc->breakpoint_being_enabled) {
- enable_breakpoint(proc->pid, proc->breakpoint_being_enabled);
- proc->breakpoint_being_enabled = NULL;
- }
+ if (proc->event_handler != NULL)
+ destroy_event_handler(proc);
if (options.follow) {
proc->state = STATE_ATTACHED;
} else {
@@ -323,13 +339,6 @@ arch_sysname(Process *proc, int sysnum) {
static void
handle_signal(Event *event) {
debug(DEBUG_FUNCTION, "handle_signal(pid=%d, signum=%d)", event->proc->pid, event->e_un.signum);
- if (exiting && event->e_un.signum == SIGSTOP) {
- pid_t pid = event->proc->pid;
- disable_all_breakpoints(event->proc);
- untrace_pid(pid);
- remove_proc(event->proc);
- return;
- }
if (event->proc->state != STATE_IGNORED && !options.no_signals) {
output_line(event->proc, "--- %s (%s) ---",
shortsignal(event->proc, event->e_un.signum),
@@ -345,7 +354,7 @@ handle_exit(Event *event) {
output_line(event->proc, "+++ exited (status %d) +++",
event->e_un.ret_val);
}
- remove_proc(event->proc);
+ remove_process(event->proc);
}
static void
@@ -355,31 +364,7 @@ handle_exit_signal(Event *event) {
output_line(event->proc, "+++ killed by %s +++",
shortsignal(event->proc, event->e_un.signum));
}
- remove_proc(event->proc);
-}
-
-static void
-remove_proc(Process *proc) {
- Process *tmp, *tmp2;
-
- debug(DEBUG_FUNCTION, "remove_proc(pid=%d)", proc->pid);
-
- if (list_of_processes == proc) {
- tmp = list_of_processes;
- list_of_processes = list_of_processes->next;
- free(tmp);
- return;
- }
- tmp = list_of_processes;
- while (tmp->next) {
- if (tmp->next == proc) {
- tmp2 = tmp->next;
- tmp->next = tmp->next->next;
- free(tmp2);
- continue;
- }
- tmp = tmp->next;
- }
+ remove_process(event->proc);
}
static void
@@ -389,7 +374,7 @@ handle_syscall(Event *event) {
callstack_push_syscall(event->proc, event->e_un.sysnum);
if (options.syscalls) {
output_left(LT_TOF_SYSCALL, event->proc,
- sysname(event->proc, event->e_un.sysnum));
+ sysname(event->proc, event->e_un.sysnum));
}
if (event->proc->breakpoints_enabled == 0) {
enable_all_breakpoints(event->proc);
@@ -406,7 +391,7 @@ handle_exec(Event * event) {
debug(DEBUG_FUNCTION, "handle_exec(pid=%d)", proc->pid);
if (proc->state == STATE_IGNORED) {
untrace_pid(proc->pid);
- remove_proc(proc);
+ remove_process(proc);
return;
}
output_line(proc, "--- Called exec() ---");
@@ -417,7 +402,7 @@ handle_exec(Event * event) {
proc->filename = pid2name(proc->pid);
saved_pid = proc->pid;
proc->pid = 0;
- breakpoints_init(proc);
+ breakpoints_init(proc, 0);
proc->pid = saved_pid;
proc->callstack_depth = 0;
continue_process(proc->pid);
@@ -503,6 +488,13 @@ static void
handle_breakpoint(Event *event) {
int i, j;
Breakpoint *sbp;
+ Process *leader = event->proc->leader;
+
+ /* The leader has terminated. */
+ if (leader == NULL) {
+ continue_process(event->proc->pid);
+ return;
+ }
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);
@@ -513,7 +505,7 @@ handle_breakpoint(Event *event) {
Breakpoint *stub_bp = NULL;
char nop_instruction[] = PPC_NOP;
- stub_bp = address2bpstruct (event->proc, event->e_un.brk_addr);
+ stub_bp = address2bpstruct(leader, event->e_un.brk_addr);
if (stub_bp) {
unsigned char *bp_instruction = stub_bp->orig_value;
@@ -528,14 +520,6 @@ handle_breakpoint(Event *event) {
}
}
#endif
- if ((sbp = event->proc->breakpoint_being_enabled) != 0) {
- /* Reinsert breakpoint */
- continue_enabling_breakpoint(event->proc->pid,
- event->proc->
- breakpoint_being_enabled);
- event->proc->breakpoint_being_enabled = NULL;
- return;
- }
for (i = event->proc->callstack_depth - 1; i >= 0; i--) {
if (event->e_un.brk_addr ==
@@ -554,7 +538,7 @@ handle_breakpoint(Event *event) {
if (libsym->plt_type != LS_TOPLT_POINT) {
unsigned char break_insn[] = BREAKPOINT_VALUE;
- sbp = address2bpstruct(event->proc, addr);
+ sbp = address2bpstruct(leader, addr);
assert(sbp);
a = ptrace(PTRACE_PEEKTEXT, event->proc->pid,
addr);
@@ -562,10 +546,10 @@ handle_breakpoint(Event *event) {
if (memcmp(&a, break_insn, BREAKPOINT_LENGTH)) {
sbp->enabled--;
insert_breakpoint(event->proc, addr,
- libsym);
+ libsym, 1);
}
} else {
- sbp = dict_find_entry(event->proc->breakpoints, addr);
+ sbp = dict_find_entry(leader->breakpoints, addr);
/* On powerpc, the breakpoint address
may end up being actual entry point
of the library symbol, not the PLT
@@ -573,7 +557,7 @@ handle_breakpoint(Event *event) {
sbp is NULL. */
if (sbp == NULL || addr != sbp->addr) {
insert_breakpoint(event->proc, addr,
- libsym);
+ libsym, 1);
}
}
#elif defined(__mips__)
@@ -581,18 +565,18 @@ handle_breakpoint(Event *event) {
struct library_symbol *sym= event->proc->callstack[i].c_un.libfunc;
struct library_symbol *new_sym;
assert(sym);
- addr=sym2addr(event->proc,sym);
- sbp = dict_find_entry(event->proc->breakpoints, addr);
+ addr = sym2addr(leader, sym);
+ sbp = dict_find_entry(leader->breakpoints, addr);
if (sbp) {
if (addr != sbp->addr) {
- insert_breakpoint(event->proc, addr, sym);
+ insert_breakpoint(event->proc, addr, sym, 1);
}
} else {
new_sym=malloc(sizeof(*new_sym) + strlen(sym->name) + 1);
memcpy(new_sym,sym,sizeof(*new_sym) + strlen(sym->name) + 1);
- new_sym->next=event->proc->list_of_symbols;
- event->proc->list_of_symbols=new_sym;
- insert_breakpoint(event->proc, addr, new_sym);
+ new_sym->next = leader->list_of_symbols;
+ leader->list_of_symbols = new_sym;
+ insert_breakpoint(event->proc, addr, new_sym, 1);
}
#endif
for (j = event->proc->callstack_depth - 1; j > i; j--) {
@@ -609,18 +593,23 @@ handle_breakpoint(Event *event) {
event->proc->callstack[i].c_un.libfunc->name);
}
callstack_pop(event->proc);
- continue_after_breakpoint(event->proc,
- address2bpstruct(event->proc,
- event->e_un.brk_addr));
+ sbp = address2bpstruct(leader, event->e_un.brk_addr);
+ continue_after_breakpoint(event->proc, sbp);
return;
}
}
- if ((sbp = address2bpstruct(event->proc, event->e_un.brk_addr))) {
+ if ((sbp = address2bpstruct(leader, event->e_un.brk_addr))) {
+ if (sbp->libsym == NULL) {
+ continue_after_breakpoint(event->proc, sbp);
+ return;
+ }
+
if (strcmp(sbp->libsym->name, "") == 0) {
- debug(2, "Hit _dl_debug_state breakpoint!\n");
- arch_check_dbg(event->proc);
+ debug(DEBUG_PROCESS, "Hit _dl_debug_state breakpoint!\n");
+ arch_check_dbg(leader);
}
+
if (event->proc->state != STATE_IGNORED) {
event->proc->stack_pointer = get_stack_pointer(event->proc);
event->proc->return_addr =
@@ -632,7 +621,7 @@ handle_breakpoint(Event *event) {
if (event->proc->need_to_reinitialize_breakpoints
&& (strcmp(sbp->libsym->name, PLTs_initialized_by_here) ==
0))
- reinitialize_breakpoints(event->proc);
+ reinitialize_breakpoints(leader);
#endif
continue_after_breakpoint(event->proc, sbp);
@@ -689,7 +678,7 @@ callstack_push_symfunc(Process *proc, struct library_symbol *sym) {
elem->return_addr = proc->return_addr;
if (elem->return_addr) {
- insert_breakpoint(proc, elem->return_addr, 0);
+ insert_breakpoint(proc, elem->return_addr, NULL, 1);
}
/* handle functions like atexit() on mips which have no return */
@@ -709,6 +698,7 @@ callstack_pop(Process *proc) {
debug(DEBUG_FUNCTION, "callstack_pop(pid=%d)", proc->pid);
elem = &proc->callstack[proc->callstack_depth - 1];
if (!elem->is_syscall && elem->return_addr) {
+ assert(proc->leader != NULL);
delete_breakpoint(proc, elem->return_addr);
}
if (elem->arch_ptr != NULL) {
diff --git a/libltrace.c b/libltrace.c
index 0f48d11..e731fe1 100644
--- a/libltrace.c
+++ b/libltrace.c
@@ -12,32 +12,39 @@
#include "common.h"
char *command = NULL;
-Process *list_of_processes = NULL;
int exiting = 0; /* =1 if a SIGINT or SIGTERM has been received */
-static void
-signal_alarm(int sig) {
- Process *tmp = list_of_processes;
+static enum pcb_status
+stop_non_p_processes (Process * proc, void * data)
+{
+ int stop = 1;
- signal(SIGALRM, SIG_DFL);
- while (tmp) {
- struct opt_p_t *tmp2 = opt_p;
- while (tmp2) {
- if (tmp->pid == tmp2->pid) {
- tmp = tmp->next;
- if (!tmp) {
- return;
- }
- tmp2 = opt_p;
- continue;
- }
- tmp2 = tmp2->next;
+ struct opt_p_t *it;
+ for (it = opt_p; it != NULL; it = it->next) {
+ Process * p_proc = pid2proc(it->pid);
+ if (p_proc == NULL) {
+ printf("stop_non_p_processes: %d terminated?\n", it->pid);
+ continue;
+ }
+ if (p_proc == proc || p_proc->leader == proc->leader) {
+ stop = 0;
+ break;
}
- debug(2, "Sending SIGSTOP to process %u\n", tmp->pid);
- kill(tmp->pid, SIGSTOP);
- tmp = tmp->next;
}
+
+ if (stop) {
+ debug(2, "Sending SIGSTOP to process %u", proc->pid);
+ kill(proc->pid, SIGSTOP);
+ }
+
+ return pcb_cont;
+}
+
+static void
+signal_alarm(int sig) {
+ signal(SIGALRM, SIG_DFL);
+ each_process(NULL, &stop_non_p_processes, NULL);
}
static void
@@ -47,15 +54,7 @@ signal_exit(int sig) {
signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
signal(SIGALRM, signal_alarm);
- if (opt_p) {
- struct opt_p_t *tmp = opt_p;
- while (tmp) {
- debug(2, "Sending SIGSTOP to process %u\n", tmp->pid);
- kill(tmp->pid, SIGSTOP);
- tmp = tmp->next;
- }
- }
- alarm(1);
+ //alarm(1);
}
static void
@@ -108,7 +107,7 @@ ltrace_init(int argc, char **argv) {
}
}
if (command) {
- execute_program(open_program(command, 0), argv);
+ open_program(command, execute_program(command, argv), 0);
}
opt_p_tmp = opt_p;
while (opt_p_tmp) {
diff --git a/ltrace-elf.c b/ltrace-elf.c
index 1a33ec3..d88d5a6 100644
--- a/ltrace-elf.c
+++ b/ltrace-elf.c
@@ -14,7 +14,6 @@
#include "common.h"
-void do_init_elf(struct ltelf *lte, const char *filename);
void do_close_elf(struct ltelf *lte);
void add_library_symbol(GElf_Addr addr, const char *name,
struct library_symbol **library_symbolspp,
@@ -136,7 +135,7 @@ static GElf_Addr get_glink_vma(struct ltelf *lte, GElf_Addr ppcgot,
return 0;
}
-void
+int
do_init_elf(struct ltelf *lte, const char *filename) {
int i;
GElf_Addr relplt_addr = 0;
@@ -147,7 +146,7 @@ do_init_elf(struct ltelf *lte, const char *filename) {
lte->fd = open(filename, O_RDONLY);
if (lte->fd == -1)
- error(EXIT_FAILURE, errno, "Can't open \"%s\"", filename);
+ return 1;
#ifdef HAVE_ELF_C_READ_MMAP
lte->elf = elf_begin(lte->fd, ELF_C_READ_MMAP, NULL);
@@ -454,6 +453,7 @@ do_init_elf(struct ltelf *lte, const char *filename) {
debug(1, "%s %zd PLT relocations", filename, lte->relplt_count);
}
+ return 0;
}
void
@@ -622,7 +622,8 @@ read_elf(Process *proc) {
elf_version(EV_CURRENT);
- do_init_elf(lte, proc->filename);
+ if (do_init_elf(lte, proc->filename))
+ return NULL;
memcpy(&main_lte, lte, sizeof(struct ltelf));
@@ -634,7 +635,9 @@ read_elf(Process *proc) {
proc->e_machine = lte->ehdr.e_machine;
for (i = 0; i < library_num; ++i) {
- do_init_elf(&lte[i + 1], library[i]);
+ if (do_init_elf(&lte[i + 1], library[i]))
+ error(EXIT_FAILURE, errno, "Can't open \"%s\"",
+ proc->filename);
}
if (!options.no_plt) {
diff --git a/ltrace.h b/ltrace.h
index 5e43ba5..0ff4572 100644
--- a/ltrace.h
+++ b/ltrace.h
@@ -20,6 +20,7 @@ enum Event_type {
typedef struct Process Process;
typedef struct Event Event;
struct Event {
+ struct Event * next;
Process * proc;
Event_type type;
union {
diff --git a/output.c b/output.c
index de2a836..945dd52 100644
--- a/output.c
+++ b/output.c
@@ -96,7 +96,7 @@ begin_of_line(enum tof type, Process *proc) {
}
static Function *
-name2func(char *name) {
+name2func(char const *name) {
Function *tmp;
const char *str1, *str2;
@@ -153,7 +153,7 @@ tabto(int col) {
}
void
-output_left(enum tof type, Process *proc, char *function_name) {
+output_left(enum tof type, Process *proc, char const *function_name) {
Function *func;
static arg_type_info *arg_unknown = NULL;
if (arg_unknown == NULL)
@@ -168,7 +168,6 @@ output_left(enum tof type, Process *proc, char *function_name) {
}
current_proc = proc;
current_depth = proc->callstack_depth;
- proc->type_being_displayed = type;
begin_of_line(type, proc);
#ifdef USE_DEMANGLE
current_column +=
diff --git a/output.h b/output.h
index c58577a..fa840c7 100644
--- a/output.h
+++ b/output.h
@@ -1,3 +1,3 @@
void output_line(Process *proc, char *fmt, ...);
-void output_left(enum tof type, Process *proc, char *function_name);
+void output_left(enum tof type, Process *proc, char const *function_name);
void output_right(enum tof type, Process *proc, char *function_name);
diff --git a/proc.c b/proc.c
index 1c57532..0425e09 100644
--- a/proc.c
+++ b/proc.c
@@ -10,73 +10,280 @@
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
+#include <assert.h>
+#include <error.h>
#include "common.h"
Process *
-open_program(char *filename, pid_t pid) {
+open_program(char *filename, pid_t pid, int enable) {
Process *proc;
+ assert(pid != 0);
proc = calloc(sizeof(Process), 1);
if (!proc) {
perror("malloc");
exit(1);
}
+
proc->filename = strdup(filename);
proc->breakpoints_enabled = -1;
- if (pid) {
- proc->pid = pid;
+ proc->pid = pid;
#if defined(HAVE_LIBUNWIND)
- proc->unwind_priv = _UPT_create(pid);
- } else {
- proc->unwind_priv = NULL;
+ proc->unwind_priv = _UPT_create(pid);
+ proc->unwind_as = unw_create_addr_space(&_UPT_accessors, 0);
#endif /* defined(HAVE_LIBUNWIND) */
- }
- breakpoints_init(proc);
+ add_process(proc);
+ if (proc->leader == NULL) {
+ free(proc);
+ return NULL;
+ }
- proc->next = list_of_processes;
- list_of_processes = proc;
+ if (proc->leader == proc)
+ if (breakpoints_init(proc, enable)) {
+ fprintf(stderr, "failed to init breakpoints %d\n",
+ proc->pid);
+ remove_process(proc);
+ return NULL;
+ }
-#if defined(HAVE_LIBUNWIND)
- proc->unwind_as = unw_create_addr_space(&_UPT_accessors, 0);
-#endif /* defined(HAVE_LIBUNWIND) */
return proc;
}
-void
-open_pid(pid_t pid) {
+static int
+open_one_pid(pid_t pid)
+{
Process *proc;
char *filename;
+ debug(DEBUG_PROCESS, "open_one_pid(pid=%d)", pid);
- if (trace_pid(pid) < 0) {
- fprintf(stderr, "Cannot attach to pid %u: %s\n", pid,
- strerror(errno));
- return;
+ /* Get the filename first. Should the trace_pid fail, we can
+ * easily free it, untracing is more work. */
+ if ((filename = pid2name(pid)) == NULL
+ || trace_pid(pid) < 0) {
+ free(filename);
+ return -1;
}
- filename = pid2name(pid);
+ proc = open_program(filename, pid, 0);
+ if (proc == NULL)
+ return -1;
+ trace_set_options(proc, pid);
+
+ return 0;
+}
+
+enum pcb_status
+start_one_pid(Process * proc, void * data)
+{
+ continue_process(proc->pid);
+ proc->breakpoints_enabled = 1;
+ return pcb_cont;
+}
+
+void
+open_pid(pid_t pid)
+{
+ debug(DEBUG_PROCESS, "open_pid(pid=%d)", pid);
+ /* If we are already tracing this guy, we should be seeing all
+ * his children via normal tracing route. */
+ if (pid2proc(pid) != NULL)
+ return;
- if (!filename) {
- fprintf(stderr, "Cannot trace pid %u: %s\n", pid,
- strerror(errno));
+ /* First, see if we can attach the requested PID itself. */
+ if (open_one_pid(pid)) {
+ fprintf(stderr, "Cannot attach to pid %u: %s\n",
+ pid, strerror(errno));
return;
}
- proc = open_program(filename, pid);
- continue_process(pid);
- proc->breakpoints_enabled = 1;
+ /* Now attach to all tasks that belong to that PID. There's a
+ * race between process_tasks and open_one_pid. So when we
+ * fail in open_one_pid below, we just do another round.
+ * Chances are that by then that PID will have gone away, and
+ * that's why we have seen the failure. The processes that we
+ * manage to open_one_pid are stopped, so we should eventually
+ * reach a point where process_tasks doesn't give any new
+ * processes (because there's nobody left to produce
+ * them). */
+ size_t old_ntasks = 0;
+ int have_all;
+ while (1) {
+ pid_t *tasks;
+ size_t ntasks;
+ size_t i;
+
+ if (process_tasks(pid, &tasks, &ntasks) < 0) {
+ fprintf(stderr, "Cannot obtain tasks of pid %u: %s\n",
+ pid, strerror(errno));
+ goto start;
+ }
+
+ have_all = 1;
+ for (i = 0; i < ntasks; ++i)
+ if (pid2proc(tasks[i]) == NULL
+ && open_one_pid(tasks[i]))
+ have_all = 0;
+
+ free(tasks);
+
+ if (have_all && old_ntasks == ntasks)
+ break;
+ old_ntasks = ntasks;
+ }
+
+ /* Done. Now initialize breakpoints and then continue
+ * everyone. */
+ Process * leader;
+start:
+ leader = pid2proc(pid)->leader;
+ enable_all_breakpoints(leader);
+
+ each_task(pid2proc(pid)->leader, start_one_pid, NULL);
+}
+
+static enum pcb_status
+find_proc(Process * proc, void * data)
+{
+ pid_t pid = (pid_t)(uintptr_t)data;
+ return proc->pid == pid ? pcb_stop : pcb_cont;
}
Process *
pid2proc(pid_t pid) {
- Process *tmp;
+ return each_process(NULL, &find_proc, (void *)(uintptr_t)pid);
+}
+
+static Process * list_of_processes = NULL;
+
+Process *
+each_process(Process * proc,
+ enum pcb_status (* cb)(Process * proc, void * data),
+ void * data)
+{
+ Process * it = proc ?: list_of_processes;
+ for (; it != NULL; ) {
+ /* Callback might call remove_process. */
+ Process * next = it->next;
+ if ((*cb) (it, data) == pcb_stop)
+ return it;
+ it = next;
+ }
+ return NULL;
+}
+
+Process *
+each_task(Process * it, enum pcb_status (* cb)(Process * proc, void * data),
+ void * data)
+{
+ if (it != NULL) {
+ Process * leader = it->leader;
+ for (; it != NULL && it->leader == leader; ) {
+ /* Callback might call remove_process. */
+ Process * next = it->next;
+ if ((*cb) (it, data) == pcb_stop)
+ return it;
+ it = next;
+ }
+ }
+ return NULL;
+}
+
+void
+add_process(Process * proc)
+{
+ Process ** leaderp = &list_of_processes;
+ if (proc->pid) {
+ pid_t tgid = process_leader(proc->pid);
+ if (tgid == 0)
+ /* Must have been terminated before we managed
+ * to fully attach. */
+ return;
+ if (tgid == proc->pid)
+ proc->leader = proc;
+ else {
+ Process * leader = pid2proc(tgid);
+ proc->leader = leader;
+ if (leader != NULL)
+ leaderp = &leader->next;
+ }
+ }
+ proc->next = *leaderp;
+ *leaderp = proc;
+}
+
+static enum pcb_status
+clear_leader(Process * proc, void * data)
+{
+ debug(DEBUG_FUNCTION, "detach_task %d from leader %d",
+ proc->pid, proc->leader->pid);
+ proc->leader = NULL;
+ return pcb_cont;
+}
+
+static enum ecb_status
+event_for_proc(Event * event, void * data)
+{
+ if (event->proc == data)
+ return ecb_deque;
+ else
+ return ecb_cont;
+}
+
+static void
+delete_events_for(Process * proc)
+{
+ Event * event;
+ while ((event = each_qd_event(&event_for_proc, proc)) != NULL)
+ free(event);
+}
+
+void
+remove_process(Process *proc)
+{
+ Process *tmp, *tmp2;
+
+ debug(DEBUG_FUNCTION, "remove_proc(pid=%d)", proc->pid);
+
+ if (proc->leader == proc)
+ each_task(proc, &clear_leader, NULL);
+
+ if (list_of_processes == proc) {
+ tmp = list_of_processes;
+ list_of_processes = list_of_processes->next;
+ delete_events_for(tmp);
+ free(tmp);
+ return;
+ }
tmp = list_of_processes;
- while (tmp) {
- if (pid == tmp->pid) {
- return tmp;
+ while (tmp->next) {
+ if (tmp->next == proc) {
+ tmp2 = tmp->next;
+ tmp->next = tmp->next->next;
+ delete_events_for(tmp2);
+ free(tmp2);
+ return;
}
tmp = tmp->next;
}
- return NULL;
+}
+
+void
+install_event_handler(Process * proc, Event_Handler * handler)
+{
+ debug(DEBUG_FUNCTION, "install_event_handler(pid=%d, %p)", proc->pid, handler);
+ assert(proc->event_handler == NULL);
+ proc->event_handler = handler;
+}
+
+void
+destroy_event_handler(Process * proc)
+{
+ Event_Handler * handler = proc->event_handler;
+ debug(DEBUG_FUNCTION, "destroy_event_handler(pid=%d, %p)", proc->pid, handler);
+ assert(handler != NULL);
+ handler->destroy(handler);
+ free(handler);
+ proc->event_handler = NULL;
}
diff --git a/sysdeps/linux-gnu/breakpoint.c b/sysdeps/linux-gnu/breakpoint.c
index 9104189..5a49e9d 100644
--- a/sysdeps/linux-gnu/breakpoint.c
+++ b/sysdeps/linux-gnu/breakpoint.c
@@ -8,21 +8,11 @@
#ifdef ARCH_HAVE_ENABLE_BREAKPOINT
extern void arch_enable_breakpoint(pid_t, Breakpoint *);
+#else /* ARCH_HAVE_ENABLE_BREAKPOINT */
void
-enable_breakpoint(pid_t pid, Breakpoint *sbp) {
- if (sbp->libsym) {
- debug(DEBUG_PROCESS, "enable_breakpoint: pid=%d, addr=%p, symbol=%s", pid, sbp->addr, sbp->libsym->name);
- } else {
- debug(DEBUG_PROCESS, "enable_breakpoint: pid=%d, addr=%p", pid, sbp->addr);
- }
- arch_enable_breakpoint(pid, sbp);
-}
-#else
-
-static unsigned char break_insn[] = BREAKPOINT_VALUE;
-
-void
-enable_breakpoint(pid_t pid, Breakpoint *sbp) {
+arch_enable_breakpoint(pid_t pid, Breakpoint *sbp)
+{
+ static unsigned char break_insn[] = BREAKPOINT_VALUE;
unsigned int i, j;
if (sbp->libsym) {
@@ -32,9 +22,8 @@ enable_breakpoint(pid_t pid, Breakpoint *sbp) {
}
for (i = 0; i < 1 + ((BREAKPOINT_LENGTH - 1) / sizeof(long)); i++) {
- long a =
- ptrace(PTRACE_PEEKTEXT, pid, sbp->addr + i * sizeof(long),
- 0);
+ long a = ptrace(PTRACE_PEEKTEXT, pid,
+ sbp->addr + i * sizeof(long), 0);
for (j = 0;
j < sizeof(long)
&& i * sizeof(long) + j < BREAKPOINT_LENGTH; j++) {
@@ -48,20 +37,22 @@ enable_breakpoint(pid_t pid, Breakpoint *sbp) {
}
#endif /* ARCH_HAVE_ENABLE_BREAKPOINT */
-#ifdef ARCH_HAVE_DISABLE_BREAKPOINT
-extern void arch_disable_breakpoint(pid_t, const Breakpoint *sbp);
void
-disable_breakpoint(pid_t pid, const Breakpoint *sbp) {
+enable_breakpoint(Process * proc, Breakpoint *sbp) {
if (sbp->libsym) {
- debug(DEBUG_PROCESS, "disable_breakpoint: pid=%d, addr=%p, symbol=%s", pid, sbp->addr, sbp->libsym->name);
+ debug(DEBUG_PROCESS, "enable_breakpoint: pid=%d, addr=%p, symbol=%s", proc->pid, sbp->addr, sbp->libsym->name);
} else {
- debug(DEBUG_PROCESS, "disable_breakpoint: pid=%d, addr=%p", pid, sbp->addr);
+ debug(DEBUG_PROCESS, "enable_breakpoint: pid=%d, addr=%p", proc->pid, sbp->addr);
}
- arch_disable_breakpoint(pid, sbp);
+ arch_enable_breakpoint(proc->pid, sbp);
}
-#else
+
+#ifdef ARCH_HAVE_DISABLE_BREAKPOINT
+extern void arch_disable_breakpoint(pid_t, const Breakpoint *sbp);
+#else /* ARCH_HAVE_DISABLE_BREAKPOINT */
void
-disable_breakpoint(pid_t pid, const Breakpoint *sbp) {
+arch_disable_breakpoint(pid_t pid, const Breakpoint *sbp)
+{
unsigned int i, j;
if (sbp->libsym) {
@@ -85,3 +76,13 @@ disable_breakpoint(pid_t pid, const Breakpoint *sbp) {
}
}
#endif /* ARCH_HAVE_DISABLE_BREAKPOINT */
+
+void
+disable_breakpoint(Process * proc, Breakpoint *sbp) {
+ if (sbp->libsym) {
+ debug(DEBUG_PROCESS, "disable_breakpoint: pid=%d, addr=%p, symbol=%s", proc->pid, sbp->addr, sbp->libsym->name);
+ } else {
+ debug(DEBUG_PROCESS, "disable_breakpoint: pid=%d, addr=%p", proc->pid, sbp->addr);
+ }
+ arch_disable_breakpoint(proc->pid, sbp);
+}
diff --git a/sysdeps/linux-gnu/events.c b/sysdeps/linux-gnu/events.c
index fd19e71..8a79583 100644
--- a/sysdeps/linux-gnu/events.c
+++ b/sysdeps/linux-gnu/events.c
@@ -8,20 +8,118 @@
#include <signal.h>
#include <string.h>
#include <sys/ptrace.h>
+#include <assert.h>
#include "common.h"
static Event event;
+/* A queue of events that we missed while enabling the
+ * breakpoint in one of tasks. */
+static Event * delayed_events = NULL;
+static Event * end_delayed_events = NULL;
+
+static enum pcb_status
+first (Process * proc, void * data)
+{
+ return pcb_stop;
+}
+
+void
+enque_event(Event * event)
+{
+ debug(DEBUG_FUNCTION, "%d: queuing event %d for later",
+ event->proc->pid, event->type);
+ Event * ne = malloc(sizeof(*ne));
+ if (ne == NULL) {
+ perror("event will be missed: malloc");
+ return;
+ }
+
+ *ne = *event;
+ ne->next = NULL;
+ if (end_delayed_events == NULL) {
+ assert(delayed_events == NULL);
+ end_delayed_events = delayed_events = ne;
+ }
+ else {
+ assert(delayed_events != NULL);
+ end_delayed_events = end_delayed_events->next = ne;
+ }
+}
+
+Event *
+each_qd_event(enum ecb_status (*pred)(Event *, void *), void * data)
+{
+ Event * prev = delayed_events;
+ Event * event;
+ for (event = prev; event != NULL; ) {
+ switch ((*pred)(event, data)) {
+ case ecb_cont:
+ prev = event;
+ event = event->next;
+ continue;
+
+ case ecb_deque:
+ debug(DEBUG_FUNCTION, "dequeuing event %d for %d",
+ event->type,
+ event->proc != NULL ? event->proc->pid : -1);
+ /*
+ printf("dequeuing event %d for %d\n", event->type,
+ event->proc != NULL ? event->proc->pid : -1) ;
+ */
+ if (end_delayed_events == event)
+ end_delayed_events = prev;
+ if (delayed_events == event)
+ delayed_events = event->next;
+ else
+ prev->next = event->next;
+ if (delayed_events == NULL)
+ end_delayed_events = NULL;
+ /* fall-through */
+
+ case ecb_yield:
+ return event;
+ }
+ }
+
+ return NULL;
+}
+
+static enum ecb_status
+event_process_not_reenabling(Event * event, void * data)
+{
+ if (event->proc == NULL
+ || event->proc->leader == NULL
+ || event->proc->leader->event_handler == NULL)
+ return ecb_deque;
+ else
+ return ecb_cont;
+}
+
+static Event *
+next_qd_event(void)
+{
+ return each_qd_event(&event_process_not_reenabling, NULL);
+}
+
Event *
-next_event(void) {
+next_event(void)
+{
pid_t pid;
int status;
int tmp;
int stop_signal;
debug(DEBUG_FUNCTION, "next_event()");
- if (!list_of_processes) {
+ Event * ev;
+ if ((ev = next_qd_event()) != NULL) {
+ event = *ev;
+ free(ev);
+ return &event;
+ }
+
+ if (!each_process(NULL, &first, NULL)) {
debug(DEBUG_EVENT, "event: No more traced programs: exiting");
exit(0);
}
@@ -46,26 +144,76 @@ next_event(void) {
return &event;
}
get_arch_dep(event.proc);
- event.proc->instruction_pointer = NULL;
debug(3, "event from pid %u", pid);
- if (event.proc->breakpoints_enabled == -1) {
- event.type = EVENT_NONE;
+ if (event.proc->breakpoints_enabled == -1)
trace_set_options(event.proc, event.proc->pid);
- 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) {
- /* debug struct may not have been written yet.. */
- if (linkmap_init(event.proc, &main_lte) == 0) {
- event.proc->libdl_hooked = 1;
+ 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) {
+ /* debug struct may not have been written yet.. */
+ if (linkmap_init(event.proc, &main_lte) == 0) {
+ event.proc->libdl_hooked = 1;
+ }
}
}
- if (opt_i) {
- event.proc->instruction_pointer =
- get_instruction_pointer(event.proc);
+ /* The process should be stopped after the waitpid call. But
+ * when the whole thread group is terminated, we see
+ * individual tasks spontaneously transitioning from 't' to
+ * 'R' and 'Z'. Calls to ptrace fail and /proc/pid/status may
+ * not even be available anymore, so we can't check in
+ * advance. So we just drop the error checking around ptrace
+ * calls. We check for termination ex post when it fails,
+ * suppress the event, and let the event loop collect the
+ * termination in the next iteration. */
+#define CHECK_PROCESS_TERMINATED \
+ do { \
+ int errno_save = errno; \
+ switch (process_stopped(pid)) \
+ case 0: \
+ case -1: { \
+ debug(DEBUG_EVENT, \
+ "process not stopped, is it terminating?"); \
+ event.type = EVENT_NONE; \
+ continue_process(event.proc->pid); \
+ return &event; \
+ } \
+ errno = errno_save; \
+ } while (0)
+
+ event.proc->instruction_pointer = (void *)(uintptr_t)-1;
+
+ /* Check for task termination now, before we have a need to
+ * call CHECK_PROCESS_TERMINATED later. That would suppress
+ * the event that we are processing. */
+ if (WIFSIGNALED(status)) {
+ event.type = EVENT_EXIT_SIGNAL;
+ event.e_un.signum = WTERMSIG(status);
+ debug(DEBUG_EVENT, "event: EXIT_SIGNAL: pid=%d, signum=%d", pid, event.e_un.signum);
+ return &event;
+ }
+ if (WIFEXITED(status)) {
+ event.type = EVENT_EXIT;
+ event.e_un.ret_val = WEXITSTATUS(status);
+ debug(DEBUG_EVENT, "event: EXIT: pid=%d, status=%d", pid, event.e_un.ret_val);
+ return &event;
+ }
+
+ event.proc->instruction_pointer = get_instruction_pointer(event.proc);
+ if (event.proc->instruction_pointer == (void *)(uintptr_t)-1) {
+ CHECK_PROCESS_TERMINATED;
+ if (errno != 0)
+ perror("get_instruction_pointer");
}
+
switch (syscall_p(event.proc, status, &tmp)) {
case 1:
event.type = EVENT_SYSCALL;
@@ -88,10 +236,9 @@ next_event(void) {
debug(DEBUG_EVENT, "event: ARCH_SYSRET: pid=%d, sysnum=%d", pid, tmp);
return &event;
case -1:
- event.type = EVENT_NONE;
- continue_process(event.proc->pid);
- debug(DEBUG_EVENT, "event: NONE: pid=%d (syscall_p returned -1)", pid);
- return &event;
+ CHECK_PROCESS_TERMINATED;
+ if (errno != 0)
+ perror("syscall_p");
}
if (WIFSTOPPED(status) && ((status>>16 == PTRACE_EVENT_FORK) || (status>>16 == PTRACE_EVENT_VFORK) || (status>>16 == PTRACE_EVENT_CLONE))) {
unsigned long data;
@@ -106,18 +253,6 @@ next_event(void) {
debug(DEBUG_EVENT, "event: EXEC: pid=%d", pid);
return &event;
}
- if (WIFEXITED(status)) {
- event.type = EVENT_EXIT;
- event.e_un.ret_val = WEXITSTATUS(status);
- debug(DEBUG_EVENT, "event: EXIT: pid=%d, status=%d", pid, event.e_un.ret_val);
- return &event;
- }
- if (WIFSIGNALED(status)) {
- event.type = EVENT_EXIT_SIGNAL;
- event.e_un.signum = WTERMSIG(status);
- debug(DEBUG_EVENT, "event: EXIT_SIGNAL: pid=%d, signum=%d", pid, event.e_un.signum);
- return &event;
- }
if (!WIFSTOPPED(status)) {
/* should never happen */
event.type = EVENT_NONE;
@@ -128,22 +263,19 @@ next_event(void) {
stop_signal = WSTOPSIG(status);
/* On some targets, breakpoints are signalled not using
- SIGTRAP, but also with SIGILL, SIGSEGV or SIGEMT. Check
- for these. (TODO: is this true?) */
- if (stop_signal == SIGSEGV
- || stop_signal == SIGILL
-#ifdef SIGEMT
- || stop_signal == SIGEMT
-#endif
- ) {
- if (!event.proc->instruction_pointer) {
- event.proc->instruction_pointer =
- get_instruction_pointer(event.proc);
- }
+ SIGTRAP, but also with SIGILL, SIGSEGV or SIGEMT. SIGEMT
+ is not defined on Linux, but check for the others.
- if (address2bpstruct(event.proc, event.proc->instruction_pointer))
+ N.B. see comments in GDB's infrun.c for details. I've
+ actually seen this on an Itanium machine on RHEL 5, I don't
+ remember the exact kernel version anymore. ia64-sigill.s
+ in the test suite tests this. Petr Machata 2011-06-08. */
+ void * break_address
+ = event.proc->instruction_pointer - DECR_PC_AFTER_BREAK;
+ if ((stop_signal == SIGSEGV || stop_signal == SIGILL)
+ && leader != NULL
+ && address2bpstruct(leader, break_address))
stop_signal = SIGTRAP;
- }
if (stop_signal != (SIGTRAP | event.proc->tracesysgood)
&& stop_signal != SIGTRAP) {
@@ -156,12 +288,8 @@ next_event(void) {
/* last case [by exhaustion] */
event.type = EVENT_BREAKPOINT;
- if (!event.proc->instruction_pointer) {
- event.proc->instruction_pointer =
- get_instruction_pointer(event.proc);
- }
- event.e_un.brk_addr =
- event.proc->instruction_pointer - DECR_PC_AFTER_BREAK;
+ event.e_un.brk_addr = break_address;
debug(DEBUG_EVENT, "event: BREAKPOINT: pid=%d, addr=%p", pid, event.e_un.brk_addr);
+
return &event;
}
diff --git a/sysdeps/linux-gnu/proc.c b/sysdeps/linux-gnu/proc.c
index e1cadf7..e3b71e5 100644
--- a/sysdeps/linux-gnu/proc.c
+++ b/sysdeps/linux-gnu/proc.c
@@ -1,13 +1,22 @@
+#define _GNU_SOURCE /* For getline. */
#include "config.h"
#include "common.h"
#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
#include <inttypes.h>
#include <link.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
+#include <dirent.h>
+#include <ctype.h>
+#include <errno.h>
+#include <sys/syscall.h>
+#include <error.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
@@ -16,17 +25,19 @@
#define MAX_DELAY 100000 /* 100000 microseconds = 0.1 seconds */
+#define PROC_PID_FILE(VAR, FORMAT, PID) \
+ char VAR[strlen(FORMAT) + 6]; \
+ sprintf(VAR, FORMAT, PID)
+
/*
* Returns a (malloc'd) file name corresponding to a running pid
*/
char *
pid2name(pid_t pid) {
- char proc_exe[1024];
-
if (!kill(pid, 0)) {
int delay = 0;
- sprintf(proc_exe, "/proc/%d/exe", pid);
+ PROC_PID_FILE(proc_exe, "/proc/%d/exe", pid);
while (delay < MAX_DELAY) {
if (!access(proc_exe, F_OK)) {
@@ -38,6 +49,197 @@ pid2name(pid_t pid) {
return NULL;
}
+static FILE *
+open_status_file(pid_t pid)
+{
+ PROC_PID_FILE(fn, "/proc/%d/status", pid);
+ /* Don't complain if we fail. This would typically happen
+ when the process is about to terminate, and these files are
+ not available anymore. This function is called from the
+ event loop, and we don't want to clutter the output just
+ because the process terminates. */
+ return fopen(fn, "r");
+}
+
+static char *
+find_line_starting(FILE * file, const char * prefix, size_t len)
+{
+ char * line = NULL;
+ size_t line_len = 0;
+ while (!feof(file)) {
+ if (getline(&line, &line_len, file) < 0)
+ return NULL;
+ if (strncmp(line, prefix, len) == 0)
+ return line;
+ }
+ return NULL;
+}
+
+static void
+each_line_starting(FILE * file, const char *prefix,
+ enum pcb_status (*cb)(const char * line, const char * prefix,
+ void * data),
+ void * data)
+{
+ size_t len = strlen(prefix);
+ char * line;
+ while ((line = find_line_starting(file, prefix, len)) != NULL) {
+ enum pcb_status st = (*cb)(line, prefix, data);
+ free (line);
+ if (st == pcb_stop)
+ return;
+ }
+}
+
+static enum pcb_status
+process_leader_cb(const char * line, const char * prefix, void * data)
+{
+ pid_t * pidp = data;
+ *pidp = atoi(line + strlen(prefix));
+ return pcb_stop;
+}
+
+pid_t
+process_leader(pid_t pid)
+{
+ pid_t tgid = 0;
+ FILE * file = open_status_file(pid);
+ if (file != NULL) {
+ each_line_starting(file, "Tgid:\t", &process_leader_cb, &tgid);
+ fclose(file);
+ }
+
+ return tgid;
+}
+
+static enum pcb_status
+process_stopped_cb(const char * line, const char * prefix, void * data)
+{
+ char c = line[strlen(prefix)];
+ // t:tracing stop, T:job control stop
+ *(int *)data = (c == 't' || c == 'T');
+ return pcb_stop;
+}
+
+int
+process_stopped(pid_t pid)
+{
+ int is_stopped = -1;
+ FILE * file = open_status_file(pid);
+ if (file != NULL) {
+ each_line_starting(file, "State:\t", &process_stopped_cb,
+ &is_stopped);
+ fclose(file);
+ }
+ return is_stopped;
+}
+
+static enum pcb_status
+process_status_cb(const char * line, const char * prefix, void * data)
+{
+ const char * status = line + strlen(prefix);
+ const char c = *status;
+
+#define RETURN(C) do { \
+ *(enum process_status *)data = C; \
+ return pcb_stop; \
+ } while (0)
+
+ switch (c) {
+ case 'Z': RETURN(ps_zombie);
+ case 't': RETURN(ps_tracing_stop);
+ case 'T': {
+ /* This can be either "T (stopped)" or, for older
+ * kernels, "T (tracing stop)". */
+ if (!strcmp(status, "T (stopped)\n"))
+ RETURN(ps_stop);
+ else if (!strcmp(status, "T (tracing stop)\n"))
+ RETURN(ps_tracing_stop);
+ else {
+ fprintf(stderr, "Unknown process status: %s",
+ status);
+ RETURN(ps_stop); /* Some sort of stop
+ * anyway. */
+ }
+ }
+ }
+
+ RETURN(ps_other);
+#undef RETURN
+}
+
+enum process_status
+process_status(pid_t pid)
+{
+ enum process_status ret = ps_invalid;
+ FILE * file = open_status_file(pid);
+ if (file != NULL) {
+ each_line_starting(file, "State:\t", &process_status_cb, &ret);
+ fclose(file);
+ if (ret == ps_invalid)
+ error(0, errno, "process_status %d", pid);
+ } else
+ /* If the file is not present, the process presumably
+ * exited already. */
+ ret = ps_zombie;
+
+ return ret;
+}
+
+static int
+all_digits(const char *str)
+{
+ while (isdigit(*str))
+ str++;
+ return !*str;
+}
+
+int
+process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n)
+{
+ PROC_PID_FILE(fn, "/proc/%d/task", pid);
+ DIR * d = opendir(fn);
+ if (d == NULL)
+ return -1;
+
+ pid_t *tasks = NULL;
+ size_t n = 0;
+ size_t alloc = 0;
+
+ while (1) {
+ struct dirent entry;
+ struct dirent *result;
+ if (readdir_r(d, &entry, &result) != 0) {
+ free(tasks);
+ return -1;
+ }
+ if (result == NULL)
+ break;
+ if (result->d_type == DT_DIR && all_digits(result->d_name)) {
+ pid_t npid = atoi(result->d_name);
+ if (n >= alloc) {
+ alloc = alloc > 0 ? (2 * alloc) : 8;
+ pid_t *ntasks = realloc(tasks,
+ sizeof(*tasks) * alloc);
+ if (ntasks == NULL) {
+ free(tasks);
+ return -1;
+ }
+ tasks = ntasks;
+ }
+ if (n >= alloc)
+ abort();
+ tasks[n++] = npid;
+ }
+ }
+
+ closedir(d);
+
+ *ret_tasks = tasks;
+ *ret_n = n;
+ return 0;
+}
+
static int
find_dynamic_entry_addr(Process *proc, void *pvAddr, int d_tag, void **addr) {
int i = 0, done = 0;
@@ -187,7 +389,10 @@ linkmap_add_cb(void *data) { //const char *lib_name, ElfW(Addr) addr) {
addr = sym.st_value;
add_library_symbol(addr, xptr->name, &library_symbols, LS_TOPLT_NONE, 0);
xptr->found = 1;
- insert_breakpoint(lm_add->proc, sym2addr(lm_add->proc, library_symbols), library_symbols);
+ insert_breakpoint(lm_add->proc,
+ sym2addr(lm_add->proc,
+ library_symbols),
+ library_symbols, 1);
}
}
do_close_elf(&lte);
@@ -275,10 +480,22 @@ linkmap_init(Process *proc, struct ltelf *lte) {
data.lte = lte;
add_library_symbol(rdbg->r_brk, "", &library_symbols, LS_TOPLT_NONE, 0);
- insert_breakpoint(proc, sym2addr(proc, library_symbols), library_symbols);
+ insert_breakpoint(proc, sym2addr(proc, library_symbols),
+ library_symbols, 1);
crawl_linkmap(proc, rdbg, hook_libdl_cb, &data);
free(rdbg);
return 0;
}
+
+int
+task_kill (pid_t pid, int sig)
+{
+ // Taken from GDB
+ int ret;
+
+ errno = 0;
+ ret = syscall (__NR_tkill, pid, sig);
+ return ret;
+}
diff --git a/sysdeps/linux-gnu/trace.c b/sysdeps/linux-gnu/trace.c
index e4be465..3800fad 100644
--- a/sysdeps/linux-gnu/trace.c
+++ b/sysdeps/linux-gnu/trace.c
@@ -7,6 +7,7 @@
#include <sys/wait.h>
#include "ptrace.h"
#include <asm/unistd.h>
+#include <assert.h>
#include "common.h"
@@ -69,7 +70,7 @@ umovelong (Process *proc, void *addr, long *result, arg_type_info *info) {
void
trace_me(void) {
- debug(DEBUG_PROCESS, "trace_me: pid=%d\n", getpid());
+ debug(DEBUG_PROCESS, "trace_me: pid=%d", getpid());
if (ptrace(PTRACE_TRACEME, 0, 1, 0) < 0) {
perror("PTRACE_TRACEME");
exit(1);
@@ -78,7 +79,7 @@ trace_me(void) {
int
trace_pid(pid_t pid) {
- debug(DEBUG_PROCESS, "trace_pid: pid=%d\n", pid);
+ debug(DEBUG_PROCESS, "trace_pid: pid=%d", pid);
if (ptrace(PTRACE_ATTACH, pid, 1, 0) < 0) {
return -1;
}
@@ -87,9 +88,9 @@ trace_pid(pid_t pid) {
in pid. The child is sent a SIGSTOP, but will not
necessarily have stopped by the completion of this call;
use wait() to wait for the child to stop. */
- if (waitpid (pid, NULL, 0) != pid) {
+ if (waitpid (pid, NULL, __WALL) != pid) {
perror ("trace_pid: waitpid");
- exit (1);
+ return -1;
}
return 0;
@@ -100,7 +101,7 @@ trace_set_options(Process *proc, pid_t pid) {
if (proc->tracesysgood & 0x80)
return;
- debug(DEBUG_PROCESS, "trace_set_options: pid=%d\n", pid);
+ debug(DEBUG_PROCESS, "trace_set_options: pid=%d", pid);
long options = PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACEFORK |
PTRACE_O_TRACEVFORK | PTRACE_O_TRACECLONE |
@@ -115,7 +116,7 @@ trace_set_options(Process *proc, pid_t pid) {
void
untrace_pid(pid_t pid) {
- debug(DEBUG_PROCESS, "untrace_pid: pid=%d\n", pid);
+ debug(DEBUG_PROCESS, "untrace_pid: pid=%d", pid);
ptrace(PTRACE_DETACH, pid, 1, 0);
}
@@ -126,56 +127,652 @@ continue_after_signal(pid_t pid, int signum) {
void
continue_after_signal(pid_t pid, int signum) {
- Process *proc;
-
debug(DEBUG_PROCESS, "continue_after_signal: pid=%d, signum=%d", pid, signum);
-
- proc = pid2proc(pid);
- if (proc && proc->breakpoint_being_enabled) {
-#if defined __sparc__ || defined __ia64___ || defined __mips__
- ptrace(PTRACE_SYSCALL, pid, 0, signum);
-#else
- ptrace(PTRACE_SINGLESTEP, pid, 0, signum);
-#endif
+ ptrace(PTRACE_SYSCALL, pid, 0, signum);
+}
+
+static enum ecb_status
+event_for_pid(Event * event, void * data)
+{
+ if (event->proc != NULL && event->proc->pid == (pid_t)(uintptr_t)data)
+ return ecb_yield;
+ return ecb_cont;
+}
+
+static int
+have_events_for(pid_t pid)
+{
+ return each_qd_event(event_for_pid, (void *)(uintptr_t)pid) != NULL;
+}
+
+void
+continue_process(pid_t pid)
+{
+ debug(DEBUG_PROCESS, "continue_process: pid=%d", pid);
+
+ /* Only really continue the process if there are no events in
+ the queue for this process. Otherwise just for the other
+ events to arrive. */
+ if (!have_events_for(pid))
+ /* We always trace syscalls to control fork(),
+ * clone(), execve()... */
+ ptrace(PTRACE_SYSCALL, pid, 0, 0);
+ else
+ debug(DEBUG_PROCESS,
+ "putting off the continue, events in que.");
+}
+
+/**
+ * This is used for bookkeeping related to PIDs that the event
+ * handlers work with.
+ */
+struct pid_task {
+ pid_t pid; /* This may be 0 for tasks that exited
+ * mid-handling. */
+ int sigstopped;
+ int got_event;
+ int delivered;
+} * pids;
+
+struct pid_set {
+ struct pid_task * tasks;
+ size_t count;
+ size_t alloc;
+};
+
+/**
+ * Breakpoint re-enablement. When we hit a breakpoint, we must
+ * disable it, single-step, and re-enable it. That single-step can be
+ * done only by one task in a task group, while others are stopped,
+ * otherwise the processes would race for who sees the breakpoint
+ * disabled and who doesn't. The following is to keep track of it
+ * all.
+ */
+struct process_stopping_handler
+{
+ Event_Handler super;
+
+ /* The task that is doing the re-enablement. */
+ Process * task_enabling_breakpoint;
+
+ /* The pointer being re-enabled. */
+ Breakpoint * breakpoint_being_enabled;
+
+ enum {
+ /* We are waiting for everyone to land in t/T. */
+ psh_stopping = 0,
+
+ /* We are doing the PTRACE_SINGLESTEP. */
+ psh_singlestep,
+
+ /* We are waiting for all the SIGSTOPs to arrive so
+ * that we can sink them. */
+ psh_sinking,
+
+ /* This is for tracking the ugly workaround. */
+ psh_ugly_workaround,
+ } state;
+
+ int exiting;
+
+ struct pid_set pids;
+};
+
+static enum pcb_status
+task_stopped(Process * task, void * data)
+{
+ /* If the task is already stopped, don't worry about it.
+ * Likewise if it managed to become a zombie or terminate in
+ * the meantime. This can happen when the whole thread group
+ * is terminating. */
+ switch (process_status(task->pid)) {
+ case ps_invalid:
+ case ps_tracing_stop:
+ case ps_zombie:
+ return pcb_cont;
+ default:
+ return pcb_stop;
+ }
+}
+
+static struct pid_task *
+get_task_info(struct pid_set * pids, pid_t pid)
+{
+ assert(pid != 0);
+ size_t i;
+ for (i = 0; i < pids->count; ++i)
+ if (pids->tasks[i].pid == pid)
+ return &pids->tasks[i];
+
+ return NULL;
+}
+
+static struct pid_task *
+add_task_info(struct pid_set * pids, pid_t pid)
+{
+ if (pids->count == pids->alloc) {
+ size_t ns = (2 * pids->alloc) ?: 4;
+ struct pid_task * n = realloc(pids->tasks,
+ sizeof(*pids->tasks) * ns);
+ if (n == NULL)
+ return NULL;
+ pids->tasks = n;
+ pids->alloc = ns;
+ }
+ struct pid_task * task_info = &pids->tasks[pids->count++];
+ memset(task_info, 0, sizeof(*task_info));
+ task_info->pid = pid;
+ return task_info;
+}
+
+static enum pcb_status
+send_sigstop(Process * task, void * data)
+{
+ Process * leader = task->leader;
+ struct pid_set * pids = data;
+
+ /* Look for pre-existing task record, or add new. */
+ struct pid_task * task_info = get_task_info(pids, task->pid);
+ if (task_info == NULL)
+ task_info = add_task_info(pids, task->pid);
+ if (task_info == NULL) {
+ perror("send_sigstop: add_task_info");
+ destroy_event_handler(leader);
+ /* Signal failure upwards. */
+ return pcb_stop;
+ }
+
+ /* This task still has not been attached to. It should be
+ stopped by the kernel. */
+ if (task->state == STATE_BEING_CREATED)
+ return pcb_cont;
+
+ /* Don't bother sending SIGSTOP if we are already stopped, or
+ * if we sent the SIGSTOP already, which happens when we
+ * inherit the handler from breakpoint re-enablement. */
+ if (task_stopped(task, NULL) == pcb_cont)
+ return pcb_cont;
+ if (task_info->sigstopped) {
+ if (!task_info->delivered)
+ return pcb_cont;
+ task_info->delivered = 0;
+ }
+
+ if (task_kill(task->pid, SIGSTOP) >= 0) {
+ debug(DEBUG_PROCESS, "send SIGSTOP to %d", task->pid);
+ task_info->sigstopped = 1;
+ } else
+ fprintf(stderr,
+ "Warning: couldn't send SIGSTOP to %d\n", task->pid);
+
+ return pcb_cont;
+}
+
+/* On certain kernels, detaching right after a singlestep causes the
+ tracee to be killed with a SIGTRAP (that even though the singlestep
+ was properly caught by waitpid. The ugly workaround is to put a
+ breakpoint where IP points and let the process continue. After
+ this the breakpoint can be retracted and the process detached. */
+static void
+ugly_workaround(Process * proc)
+{
+ void * ip = get_instruction_pointer(proc);
+ Breakpoint * sbp = dict_find_entry(proc->leader->breakpoints, ip);
+ if (sbp != NULL)
+ enable_breakpoint(proc, sbp);
+ else
+ insert_breakpoint(proc, ip, NULL, 1);
+ ptrace(PTRACE_CONT, proc->pid, 0, 0);
+}
+
+static void
+process_stopping_done(struct process_stopping_handler * self, Process * leader)
+{
+ debug(DEBUG_PROCESS, "process stopping done %d",
+ self->task_enabling_breakpoint->pid);
+ size_t i;
+ if (!self->exiting) {
+ for (i = 0; i < self->pids.count; ++i)
+ if (self->pids.tasks[i].pid != 0
+ && self->pids.tasks[i].delivered)
+ continue_process(self->pids.tasks[i].pid);
+ continue_process(self->task_enabling_breakpoint->pid);
+ destroy_event_handler(leader);
} else {
- ptrace(PTRACE_SYSCALL, pid, 0, signum);
+ self->state = psh_ugly_workaround;
+ ugly_workaround(self->task_enabling_breakpoint);
}
}
-void
-continue_process(pid_t pid) {
- /* We always trace syscalls to control fork(), clone(), execve()... */
+/* Before we detach, we need to make sure that task's IP is on the
+ * edge of an instruction. So for tasks that have a breakpoint event
+ * in the queue, we adjust the instruction pointer, just like
+ * continue_after_breakpoint does. */
+static enum ecb_status
+undo_breakpoint(Event * event, void * data)
+{
+ if (event != NULL
+ && event->proc->leader == data
+ && event->type == EVENT_BREAKPOINT)
+ set_instruction_pointer(event->proc, event->e_un.brk_addr);
+ return ecb_cont;
+}
- debug(DEBUG_PROCESS, "continue_process: pid=%d", pid);
+static enum pcb_status
+untrace_task(Process * task, void * data)
+{
+ if (task != data)
+ untrace_pid(task->pid);
+ return pcb_cont;
+}
- ptrace(PTRACE_SYSCALL, pid, 0, 0);
+static enum pcb_status
+remove_task(Process * task, void * data)
+{
+ /* Don't untrace leader just yet. */
+ if (task != data)
+ remove_process(task);
+ return pcb_cont;
}
-void
-continue_enabling_breakpoint(pid_t pid, Breakpoint *sbp) {
- enable_breakpoint(pid, sbp);
- continue_process(pid);
+static void
+detach_process(Process * leader)
+{
+ each_qd_event(&undo_breakpoint, leader);
+ disable_all_breakpoints(leader);
+
+ /* Now untrace the process, if it was attached to by -p. */
+ struct opt_p_t * it;
+ for (it = opt_p; it != NULL; it = it->next) {
+ Process * proc = pid2proc(it->pid);
+ if (proc == NULL)
+ continue;
+ if (proc->leader == leader) {
+ each_task(leader, &untrace_task, NULL);
+ break;
+ }
+ }
+ each_task(leader, &remove_task, leader);
+ destroy_event_handler(leader);
+ remove_task(leader, NULL);
+}
+
+static void
+handle_stopping_event(struct pid_task * task_info, Event ** eventp)
+{
+ /* Mark all events, so that we know whom to SIGCONT later. */
+ if (task_info != NULL)
+ task_info->got_event = 1;
+
+ Event * event = *eventp;
+
+ /* In every state, sink SIGSTOP events for tasks that it was
+ * sent to. */
+ if (task_info != NULL
+ && event->type == EVENT_SIGNAL
+ && event->e_un.signum == SIGSTOP) {
+ debug(DEBUG_PROCESS, "SIGSTOP delivered to %d", task_info->pid);
+ if (task_info->sigstopped
+ && !task_info->delivered) {
+ task_info->delivered = 1;
+ *eventp = NULL; // sink the event
+ } else
+ fprintf(stderr, "suspicious: %d got SIGSTOP, but "
+ "sigstopped=%d and delivered=%d\n",
+ task_info->pid, task_info->sigstopped,
+ task_info->delivered);
+ }
+}
+
+/* Some SIGSTOPs may have not been delivered to their respective tasks
+ * yet. They are still in the queue. If we have seen an event for
+ * that process, continue it, so that the SIGSTOP can be delivered and
+ * caught by ltrace. */
+static void
+continue_for_sigstop_delivery(struct pid_set * pids)
+{
+ size_t i;
+ for (i = 0; i < pids->count; ++i) {
+ if (pids->tasks[i].pid != 0
+ && pids->tasks[i].sigstopped
+ && !pids->tasks[i].delivered
+ && pids->tasks[i].got_event) {
+ debug(DEBUG_PROCESS, "continue %d for SIGSTOP delivery",
+ pids->tasks[i].pid);
+ ptrace(PTRACE_SYSCALL, pids->tasks[i].pid, 0, 0);
+ }
+ }
+}
+
+static int
+event_exit_p(Event * event)
+{
+ return event != NULL && (event->type == EVENT_EXIT
+ || event->type == EVENT_EXIT_SIGNAL);
+}
+
+static int
+event_exit_or_none_p(Event * event)
+{
+ return event == NULL || event_exit_p(event)
+ || event->type == EVENT_NONE;
+}
+
+static int
+await_sigstop_delivery(struct pid_set * pids, struct pid_task * task_info,
+ Event * event)
+{
+ /* If we still didn't get our SIGSTOP, continue the process
+ * and carry on. */
+ if (event != NULL && !event_exit_or_none_p(event)
+ && task_info != NULL && task_info->sigstopped) {
+ debug(DEBUG_PROCESS, "continue %d for SIGSTOP delivery",
+ task_info->pid);
+ /* We should get the signal the first thing
+ * after this, so it should be OK to continue
+ * even if we are over a breakpoint. */
+ ptrace(PTRACE_SYSCALL, task_info->pid, 0, 0);
+
+ } else {
+ /* If all SIGSTOPs were delivered, uninstall the
+ * handler and continue everyone. */
+ /* XXX I suspect that we should check tasks that are
+ * still around. Is things are now, there should be a
+ * race between waiting for everyone to stop and one
+ * of the tasks exiting. */
+ int all_clear = 1;
+ size_t i;
+ for (i = 0; i < pids->count; ++i)
+ if (pids->tasks[i].pid != 0
+ && pids->tasks[i].sigstopped
+ && !pids->tasks[i].delivered) {
+ all_clear = 0;
+ break;
+ }
+ return all_clear;
+ }
+
+ return 0;
+}
+
+static int
+all_stops_accountable(struct pid_set * pids)
+{
+ size_t i;
+ for (i = 0; i < pids->count; ++i)
+ if (pids->tasks[i].pid != 0
+ && !pids->tasks[i].got_event
+ && !have_events_for(pids->tasks[i].pid))
+ return 0;
+ return 1;
+}
+
+/* This event handler is installed when we are in the process of
+ * stopping the whole thread group to do the pointer re-enablement for
+ * one of the threads. We pump all events to the queue for later
+ * processing while we wait for all the threads to stop. When this
+ * happens, we let the re-enablement thread to PTRACE_SINGLESTEP,
+ * re-enable, and continue everyone. */
+static Event *
+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;
+ Process * teb = self->task_enabling_breakpoint;
+
+ debug(DEBUG_PROCESS,
+ "pid %d; event type %d; state %d",
+ task->pid, event->type, self->state);
+
+ struct pid_task * task_info = get_task_info(&self->pids, task->pid);
+ if (task_info == NULL)
+ fprintf(stderr, "new task??? %d\n", task->pid);
+ handle_stopping_event(task_info, &event);
+
+ int state = self->state;
+ int event_to_queue = !event_exit_or_none_p(event);
+
+ /* Deactivate the entry if the task exits. */
+ if (event_exit_p(event) && task_info != NULL)
+ task_info->pid = 0;
+
+ switch (state) {
+ case psh_stopping:
+ /* If everyone is stopped, singlestep. */
+ if (each_task(leader, &task_stopped, NULL) == NULL) {
+ debug(DEBUG_PROCESS, "all stopped, now SINGLESTEP %d",
+ teb->pid);
+ if (sbp->enabled)
+ disable_breakpoint(teb, sbp);
+ if (ptrace(PTRACE_SINGLESTEP, teb->pid, 0, 0))
+ perror("PTRACE_SINGLESTEP");
+ self->state = state = psh_singlestep;
+ }
+ break;
+
+ case psh_singlestep: {
+ /* In singlestep state, breakpoint signifies that we
+ * have now stepped, and can re-enable the breakpoint. */
+ if (event != NULL && task == teb) {
+ /* Essentially we don't care what event caused
+ * the thread to stop. We can do the
+ * re-enablement now. */
+ if (sbp->enabled)
+ enable_breakpoint(teb, sbp);
+
+ continue_for_sigstop_delivery(&self->pids);
+
+ self->breakpoint_being_enabled = NULL;
+ self->state = state = psh_sinking;
+
+ if (event->type == EVENT_BREAKPOINT)
+ event = NULL; // handled
+ } else
+ break;
+ }
+
+ /* fall-through */
+
+ case psh_sinking:
+ if (await_sigstop_delivery(&self->pids, task_info, event))
+ process_stopping_done(self, leader);
+ break;
+
+ case psh_ugly_workaround:
+ if (event == NULL)
+ break;
+ if (event->type == EVENT_BREAKPOINT) {
+ undo_breakpoint(event, leader);
+ if (task == teb)
+ self->task_enabling_breakpoint = NULL;
+ }
+ if (self->task_enabling_breakpoint == NULL
+ && all_stops_accountable(&self->pids)) {
+ undo_breakpoint(event, leader);
+ detach_process(leader);
+ event = NULL; // handled
+ }
+ }
+
+ if (event != NULL && event_to_queue) {
+ enque_event(event);
+ event = NULL; // sink the event
+ }
+
+ return event;
+}
+
+static void
+process_stopping_destroy(Event_Handler * super)
+{
+ struct process_stopping_handler * self = (void *)super;
+ free(self->pids.tasks);
}
void
-continue_after_breakpoint(Process *proc, Breakpoint *sbp) {
- if (sbp->enabled)
- disable_breakpoint(proc->pid, sbp);
+continue_after_breakpoint(Process *proc, Breakpoint *sbp)
+{
set_instruction_pointer(proc, sbp->addr);
if (sbp->enabled == 0) {
continue_process(proc->pid);
} else {
- debug(DEBUG_PROCESS, "continue_after_breakpoint: pid=%d, addr=%p", proc->pid, sbp->addr);
- proc->breakpoint_being_enabled = sbp;
+ debug(DEBUG_PROCESS,
+ "continue_after_breakpoint: pid=%d, addr=%p",
+ proc->pid, sbp->addr);
#if defined __sparc__ || defined __ia64___ || defined __mips__
/* we don't want to singlestep here */
continue_process(proc->pid);
#else
- ptrace(PTRACE_SINGLESTEP, proc->pid, 0, 0);
+ struct process_stopping_handler * handler
+ = calloc(sizeof(*handler), 1);
+ if (handler == NULL) {
+ perror("malloc breakpoint disable handler");
+ fatal:
+ /* Carry on not bothering to re-enable. */
+ continue_process(proc->pid);
+ return;
+ }
+
+ handler->super.on_event = process_stopping_on_event;
+ handler->super.destroy = process_stopping_destroy;
+ handler->task_enabling_breakpoint = proc;
+ handler->breakpoint_being_enabled = sbp;
+ install_event_handler(proc->leader, &handler->super);
+
+ if (each_task(proc->leader, &send_sigstop,
+ &handler->pids) != NULL)
+ goto fatal;
+
+ /* And deliver the first fake event, in case all the
+ * conditions are already fulfilled. */
+ Event ev;
+ ev.type = EVENT_NONE;
+ ev.proc = proc;
+ process_stopping_on_event(&handler->super, &ev);
#endif
}
}
+/**
+ * Ltrace exit. When we are about to exit, we have to go through all
+ * the processes, stop them all, remove all the breakpoints, and then
+ * detach the processes that we attached to using -p. If we left the
+ * other tasks running, they might hit stray return breakpoints and
+ * produce artifacts, so we better stop everyone, even if it's a bit
+ * of extra work.
+ */
+struct ltrace_exiting_handler
+{
+ Event_Handler super;
+ struct pid_set pids;
+};
+
+static Event *
+ltrace_exiting_on_event(Event_Handler * super, Event * event)
+{
+ struct ltrace_exiting_handler * self = (void *)super;
+ Process * task = event->proc;
+ Process * leader = task->leader;
+
+ debug(DEBUG_PROCESS, "pid %d; event type %d", task->pid, event->type);
+
+ struct pid_task * task_info = get_task_info(&self->pids, task->pid);
+ handle_stopping_event(task_info, &event);
+
+ if (event != NULL && event->type == EVENT_BREAKPOINT)
+ undo_breakpoint(event, leader);
+
+ if (await_sigstop_delivery(&self->pids, task_info, event)
+ && all_stops_accountable(&self->pids))
+ detach_process(leader);
+
+ /* Sink all non-exit events. We are about to exit, so we
+ * don't bother with queuing them. */
+ if (event_exit_or_none_p(event))
+ return event;
+
+ return NULL;
+}
+
+static void
+ltrace_exiting_destroy(Event_Handler * super)
+{
+ struct ltrace_exiting_handler * self = (void *)super;
+ free(self->pids.tasks);
+}
+
+static int
+ltrace_exiting_install_handler(Process * proc)
+{
+ /* Only install to leader. */
+ if (proc->leader != proc)
+ return 0;
+
+ /* Perhaps we are already installed, if the user passed
+ * several -p options that are tasks of one process. */
+ if (proc->event_handler != NULL
+ && proc->event_handler->on_event == &ltrace_exiting_on_event)
+ return 0;
+
+ /* If stopping handler is already present, let it do the
+ * work. */
+ if (proc->event_handler != NULL) {
+ assert(proc->event_handler->on_event
+ == &process_stopping_on_event);
+ struct process_stopping_handler * other
+ = (void *)proc->event_handler;
+ other->exiting = 1;
+ return 0;
+ }
+
+ struct ltrace_exiting_handler * handler
+ = calloc(sizeof(*handler), 1);
+ if (handler == NULL) {
+ perror("malloc exiting handler");
+ fatal:
+ /* XXXXXXXXXXXXXXXXXXX fixme */
+ return -1;
+ }
+
+ handler->super.on_event = ltrace_exiting_on_event;
+ handler->super.destroy = ltrace_exiting_destroy;
+ install_event_handler(proc->leader, &handler->super);
+
+ if (each_task(proc->leader, &send_sigstop,
+ &handler->pids) != NULL)
+ goto fatal;
+
+ return 0;
+}
+
+/* If ltrace gets SIGINT, the processes directly or indirectly run by
+ * ltrace get it too. We just have to wait long enough for the signal
+ * to be delivered and the process terminated, which we notice and
+ * exit ltrace, too. So there's not much we need to do there. We
+ * want to keep tracing those processes as usual, in case they just
+ * SIG_IGN the SIGINT to do their shutdown etc.
+ *
+ * For processes ran on the background, we want to install an exit
+ * handler that stops all the threads, removes all breakpoints, and
+ * detaches.
+ */
+void
+ltrace_exiting(void)
+{
+ struct opt_p_t * it;
+ for (it = opt_p; it != NULL; it = it->next) {
+ Process * proc = pid2proc(it->pid);
+ if (proc == NULL || proc->leader == NULL)
+ continue;
+ if (ltrace_exiting_install_handler(proc->leader) < 0)
+ fprintf(stderr,
+ "Couldn't install exiting handler for %d.\n",
+ proc->pid);
+ }
+}
+
size_t
umovebytes(Process *proc, void *addr, void *laddr, size_t len) {
diff --git a/sysdeps/linux-gnu/x86_64/trace.c b/sysdeps/linux-gnu/x86_64/trace.c
index e8581af..d0299d9 100644
--- a/sysdeps/linux-gnu/x86_64/trace.c
+++ b/sysdeps/linux-gnu/x86_64/trace.c
@@ -8,6 +8,7 @@
#include <sys/reg.h>
#include <string.h>
#include <assert.h>
+#include <errno.h>
#include "common.h"
#include "ptrace.h"
@@ -44,8 +45,11 @@ int
syscall_p(Process *proc, int status, int *sysnum) {
if (WIFSTOPPED(status)
&& WSTOPSIG(status) == (SIGTRAP | proc->tracesysgood)) {
- *sysnum = ptrace(PTRACE_PEEKUSER, proc->pid, 8 * ORIG_RAX, 0);
+ long int ret = ptrace(PTRACE_PEEKUSER, proc->pid, 8 * ORIG_RAX, 0);
+ if (ret == -1 && errno)
+ return -1;
+ *sysnum = ret;
if (proc->callstack_depth > 0 &&
proc->callstack[proc->callstack_depth - 1].is_syscall &&
proc->callstack[proc->callstack_depth - 1].c_un.syscall == *sysnum) {
diff --git a/testsuite/ltrace.main/main-threaded.c b/testsuite/ltrace.main/main-threaded.c
new file mode 100644
index 0000000..a183966
--- /dev/null
+++ b/testsuite/ltrace.main/main-threaded.c
@@ -0,0 +1,29 @@
+#include <pthread.h>
+
+extern void print (char *);
+
+#define PRINT_LOOP 10
+
+void *
+th_main (void *arg)
+{
+ int i;
+ for (i=0; i<PRINT_LOOP; i++)
+ print (arg);
+}
+
+int
+main ()
+{
+ pthread_t thread1;
+ pthread_t thread2;
+ pthread_t thread3;
+ pthread_create (&thread1, NULL, th_main, "aaa");
+ pthread_create (&thread2, NULL, th_main, "bbb");
+ pthread_create (&thread3, NULL, th_main, "ccc");
+ pthread_join (thread1, NULL);
+ pthread_join (thread2, NULL);
+ pthread_join (thread3, NULL);
+ return 0;
+}
+
diff --git a/testsuite/ltrace.main/main-threaded.exp b/testsuite/ltrace.main/main-threaded.exp
new file mode 100644
index 0000000..0157797
--- /dev/null
+++ b/testsuite/ltrace.main/main-threaded.exp
@@ -0,0 +1,39 @@
+# This file was written by Yao Qi <qiyao@cn.ibm.com>.
+
+set testfile "main-threaded"
+set srcfile ${testfile}.c
+set binfile ${testfile}
+set libfile "main-lib"
+set libsrc $srcdir/$subdir/$libfile.c
+set lib_sl $objdir/$subdir/lib$testfile.so
+
+
+if [get_compiler_info $binfile] {
+ return -1
+}
+
+verbose "compiling source file now....."
+if { [ltrace_compile_shlib $libsrc $lib_sl debug ] != ""
+ || [ltrace_compile $srcdir/$subdir/$srcfile $objdir/$subdir/$binfile executable [list debug shlib=$lib_sl ldflags=-pthread] ] != ""} {
+ send_user "Testcase compile failed, so all tests in this file will automatically fail.\n"
+}
+
+# set options for ltrace.
+ltrace_options "-l" "$objdir/$subdir/libmain.so" "-f"
+
+# Run PUT for ltarce.
+set exec_output [ltrace_runtest $objdir/$subdir $objdir/$subdir/$binfile]
+
+# Check the output of this program.
+verbose "ltrace runtest output: $exec_output\n"
+if [regexp {ELF from incompatible architecture} $exec_output] {
+ fail "32-bit ltrace can not perform on 64-bit PUTs and rebuild ltrace in 64 bit mode!"
+ return
+} elseif [ regexp {Couldn't get .hash data} $exec_output ] {
+ fail "Couldn't get .hash data!"
+ return
+}
+
+# Verify the output by checking numbers of print in main-threaded.ltrace.
+set pattern "print("
+ltrace_verify_output ${objdir}/${subdir}/${testfile}.ltrace $pattern 30
Reference in New Issue View Git Blame Copy Permalink