/* Low-level child interface to ttrace.
- Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
+ Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_string.h"
#include <sys/mman.h>
#include <sys/ttrace.h>
+#include <signal.h>
#include "inf-child.h"
#include "inf-ttrace.h"
pid_t pid, fpid;
lwpid_t lwpid, flwpid;
ttstate_t tts;
+ struct thread_info *last_tp = NULL;
+ struct breakpoint *step_resume_breakpoint = NULL;
+ CORE_ADDR step_range_start = 0, step_range_end = 0;
+ struct frame_id step_frame_id = null_frame_id;
/* FIXME: kettenis/20050720: This stuff should really be passed as
an argument by our caller. */
pid = ptid_get_pid (ptid);
lwpid = ptid_get_lwp (ptid);
+ last_tp = find_thread_pid (ptid);
}
/* Get all important details that core GDB doesn't (and shouldn't)
if (follow_child)
{
+ /* Copy user stepping state to the new inferior thread. */
+ step_resume_breakpoint = last_tp->step_resume_breakpoint;
+ step_range_start = last_tp->step_range_start;
+ step_range_end = last_tp->step_range_end;
+ step_frame_id = last_tp->step_frame_id;
+
+ /* Otherwise, deleting the parent would get rid of this
+ breakpoint. */
+ last_tp->step_resume_breakpoint = NULL;
+
inferior_ptid = ptid_build (fpid, flwpid, 0);
+ add_inferior (fpid);
detach_breakpoints (pid);
target_terminal_ours ();
if (follow_child)
{
+ struct thread_info *ti;
+
/* The child will start out single-threaded. */
- inf_ttrace_num_lwps = 0;
+ inf_ttrace_num_lwps = 1;
inf_ttrace_num_lwps_in_syscall = 0;
+ /* Delete parent. */
+ delete_thread_silent (ptid_build (pid, lwpid, 0));
+ detach_inferior (pid);
+
+ /* Add child thread. inferior_ptid was already set above. */
+ ti = add_thread_silent (inferior_ptid);
+ ti->private =
+ xmalloc (sizeof (struct inf_ttrace_private_thread_info));
+ memset (ti->private, 0,
+ sizeof (struct inf_ttrace_private_thread_info));
+
+ ti->step_resume_breakpoint = step_resume_breakpoint;
+ ti->step_range_start = step_range_start;
+ ti->step_range_end = step_range_end;
+ ti->step_frame_id = step_frame_id;
+
/* Reset breakpoints in the child as appropriate. */
follow_inferior_reset_breakpoints ();
}
}
static void
-inf_ttrace_create_inferior (char *exec_file, char *allargs, char **env,
- int from_tty)
+inf_ttrace_create_inferior (struct target_ops *ops, char *exec_file,
+ char *allargs, char **env, int from_tty)
{
gdb_assert (inf_ttrace_num_lwps == 0);
gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
}
static void
-inf_ttrace_mourn_inferior (void)
+inf_ttrace_mourn_inferior (struct target_ops *ops)
{
const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
int bucket;
}
static void
-inf_ttrace_attach (char *args, int from_tty)
+inf_ttrace_attach (struct target_ops *ops, char *args, int from_tty)
{
char *exec_file;
pid_t pid;
char *dummy;
ttevent_t tte;
+ struct inferior *inf;
if (!args)
error_no_arg (_("process-id to attach"));
if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
perror_with_name (("ttrace"));
- attach_flag = 1;
+
+ inf = add_inferior (pid);
+ inf->attach_flag = 1;
/* Set the initial event mask. */
memset (&tte, 0, sizeof (tte));
(uintptr_t)&tte, sizeof tte, 0) == -1)
perror_with_name (("ttrace"));
- inferior_ptid = pid_to_ptid (pid);
push_target (ttrace_ops_hack);
+
+ /* We'll bump inf_ttrace_num_lwps up and add the private data to the
+ thread as soon as we get to inf_ttrace_wait. At this point, we
+ don't have lwpid info yet. */
+ inferior_ptid = pid_to_ptid (pid);
+ add_thread_silent (inferior_ptid);
}
static void
-inf_ttrace_detach (char *args, int from_tty)
+inf_ttrace_detach (struct target_ops *ops, char *args, int from_tty)
{
pid_t pid = ptid_get_pid (inferior_ptid);
int sig = 0;
inf_ttrace_num_lwps = 0;
inf_ttrace_num_lwps_in_syscall = 0;
- unpush_target (ttrace_ops_hack);
inferior_ptid = null_ptid;
+ detach_inferior (pid);
+
+ unpush_target (ttrace_ops_hack);
}
static void
target_mourn_inferior ();
}
+/* Check is a dying thread is dead by now, and delete it from GDBs
+ thread list if so. */
static int
-inf_ttrace_resume_callback (struct thread_info *info, void *arg)
+inf_ttrace_delete_dead_threads_callback (struct thread_info *info, void *arg)
{
- if (!ptid_equal (info->ptid, inferior_ptid))
- {
- pid_t pid = ptid_get_pid (info->ptid);
- lwpid_t lwpid = ptid_get_lwp (info->ptid);
+ lwpid_t lwpid;
+ struct inf_ttrace_private_thread_info *p;
- if (ttrace (TT_LWP_CONTINUE, pid, lwpid, TT_NOPC, 0, 0) == -1)
- perror_with_name (("ttrace"));
- }
+ if (is_exited (info->ptid))
+ return 0;
+
+ lwpid = ptid_get_lwp (info->ptid);
+ p = (struct inf_ttrace_private_thread_info *) info->private;
+
+ /* Check if an lwp that was dying is still there or not. */
+ if (p->dying && (kill (lwpid, 0) == -1))
+ /* It's gone now. */
+ delete_thread (info->ptid);
return 0;
}
+/* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
+ SIG. */
+
+static void
+inf_ttrace_resume_lwp (struct thread_info *info, ttreq_t request, int sig)
+{
+ pid_t pid = ptid_get_pid (info->ptid);
+ lwpid_t lwpid = ptid_get_lwp (info->ptid);
+
+ if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
+ {
+ struct inf_ttrace_private_thread_info *p
+ = (struct inf_ttrace_private_thread_info *) info->private;
+ if (p->dying && errno == EPROTO)
+ /* This is expected, it means the dying lwp is really gone
+ by now. If ttrace had an event to inform the debugger
+ the lwp is really gone, this wouldn't be needed. */
+ delete_thread (info->ptid);
+ else
+ /* This was really unexpected. */
+ perror_with_name (("ttrace"));
+ }
+}
+
+/* Callback for iterate_over_threads. */
+
static int
-inf_ttrace_delete_dying_threads_callback (struct thread_info *info, void *arg)
+inf_ttrace_resume_callback (struct thread_info *info, void *arg)
{
- if (((struct inf_ttrace_private_thread_info *)info->private)->dying == 1)
- delete_thread (info->ptid);
+ if (!ptid_equal (info->ptid, inferior_ptid) && !is_exited (info->ptid))
+ inf_ttrace_resume_lwp (info, TT_LWP_CONTINUE, 0);
+
return 0;
}
static void
inf_ttrace_resume (ptid_t ptid, int step, enum target_signal signal)
{
- pid_t pid = ptid_get_pid (ptid);
- lwpid_t lwpid = ptid_get_lwp (ptid);
+ int resume_all;
ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
int sig = target_signal_to_host (signal);
+ struct thread_info *info;
- if (pid == -1)
- {
- pid = ptid_get_pid (inferior_ptid);
- lwpid = ptid_get_lwp (inferior_ptid);
- }
+ /* A specific PTID means `step only this process id'. */
+ resume_all = (ptid_equal (ptid, minus_one_ptid));
- if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
- perror_with_name (("ttrace"));
+ /* If resuming all threads, it's the current thread that should be
+ handled specially. */
+ if (resume_all)
+ ptid = inferior_ptid;
- if (ptid_equal (ptid, minus_one_ptid) && inf_ttrace_num_lwps > 0)
- {
- /* Let all the other threads run too. */
- iterate_over_threads (inf_ttrace_resume_callback, NULL);
- iterate_over_threads (inf_ttrace_delete_dying_threads_callback, NULL);
- }
+ info = find_thread_pid (ptid);
+ inf_ttrace_resume_lwp (info, request, sig);
+
+ if (resume_all)
+ /* Let all the other threads run too. */
+ iterate_over_threads (inf_ttrace_resume_callback, NULL);
}
static ptid_t
do
{
set_sigint_trap ();
- set_sigio_trap ();
if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
perror_with_name (("ttrace_wait"));
tts.tts_event = TTEVT_NONE;
}
- clear_sigio_trap ();
clear_sigint_trap ();
}
while (tts.tts_event == TTEVT_NONE);
ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
+ if (inf_ttrace_num_lwps == 0)
+ {
+ struct thread_info *ti;
+
+ inf_ttrace_num_lwps = 1;
+
+ /* This is the earliest we hear about the lwp member of
+ INFERIOR_PTID, after an attach or fork_inferior. */
+ gdb_assert (ptid_get_lwp (inferior_ptid) == 0);
+
+ /* We haven't set the private member on the main thread yet. Do
+ it now. */
+ ti = find_thread_pid (inferior_ptid);
+ gdb_assert (ti != NULL && ti->private == NULL);
+ ti->private =
+ xmalloc (sizeof (struct inf_ttrace_private_thread_info));
+ memset (ti->private, 0,
+ sizeof (struct inf_ttrace_private_thread_info));
+
+ /* Notify the core that this ptid changed. This changes
+ inferior_ptid as well. */
+ thread_change_ptid (inferior_ptid, ptid);
+ }
+
switch (tts.tts_event)
{
#ifdef TTEVT_BPT_SSTEP
case TTEVT_LWP_CREATE:
lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
ptid = ptid_build (tts.tts_pid, lwpid, 0);
- if (inf_ttrace_num_lwps == 0)
- {
- /* Now that we're going to be multi-threaded, add the
- original thread to the list first. */
- ti = add_thread (ptid_build (tts.tts_pid, tts.tts_lwpid, 0));
- ti->private =
- xmalloc (sizeof (struct inf_ttrace_private_thread_info));
- memset (ti->private, 0,
- sizeof (struct inf_ttrace_private_thread_info));
- inf_ttrace_num_lwps++;
- }
ti = add_thread (ptid);
ti->private =
xmalloc (sizeof (struct inf_ttrace_private_thread_info));
sizeof (struct inf_ttrace_private_thread_info));
inf_ttrace_num_lwps++;
ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
- break;
+ /* Let the lwp_create-caller thread continue. */
+ ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
+ ptid_get_lwp (ptid), TT_NOPC, 0, 0);
+ /* Return without stopping the whole process. */
+ ourstatus->kind = TARGET_WAITKIND_IGNORE;
+ return ptid;
case TTEVT_LWP_EXIT:
if (print_thread_events)
gdb_assert (ti != NULL);
((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
inf_ttrace_num_lwps--;
+ /* Let the thread really exit. */
ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
ptid_get_lwp (ptid), TT_NOPC, 0, 0);
- /* If we don't return -1 here, core GDB will re-add the thread. */
- ptid = minus_one_ptid;
- break;
+ /* Return without stopping the whole process. */
+ ourstatus->kind = TARGET_WAITKIND_IGNORE;
+ return ptid;
case TTEVT_LWP_TERMINATE:
lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
ptid = ptid_build (tts.tts_pid, lwpid, 0);
- printf_filtered(_("[%s has been terminated]\n"), target_pid_to_str (ptid));
+ if (print_thread_events)
+ printf_unfiltered(_("[%s has been terminated]\n"),
+ target_pid_to_str (ptid));
ti = find_thread_pid (ptid);
gdb_assert (ti != NULL);
((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;
inf_ttrace_num_lwps--;
+
+ /* Resume the lwp_terminate-caller thread. */
ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
- break;
+ ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
+ ptid_get_lwp (ptid), TT_NOPC, 0, 0);
+ /* Return without stopping the whole process. */
+ ourstatus->kind = TARGET_WAITKIND_IGNORE;
+ return ptid;
case TTEVT_SIGNAL:
ourstatus->kind = TARGET_WAITKIND_STOPPED;
if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
perror_with_name (("ttrace"));
- /* HACK: Twiddle INFERIOR_PTID such that the initial thread of a
- process isn't recognized as a new thread. */
- if (ptid_get_lwp (inferior_ptid) == 0)
- inferior_ptid = ptid;
+ /* Now that the whole process is stopped, check if any dying thread
+ is really dead by now. If a dying thread is still alive, it will
+ be stopped too, and will still show up in `info threads', tagged
+ with "(Exiting)". We could make `info threads' prune dead
+ threads instead via inf_ttrace_thread_alive, but doing this here
+ has the advantage that a frontend is notificed sooner of thread
+ exits. Note that a dying lwp is still alive, it still has to be
+ resumed, like any other lwp. */
+ iterate_over_threads (inf_ttrace_delete_dead_threads_callback, NULL);
return ptid;
}
static void
inf_ttrace_files_info (struct target_ops *ignore)
{
+ struct inferior *inf = current_inferior ();
printf_filtered (_("\tUsing the running image of %s %s.\n"),
- attach_flag ? "attached" : "child",
+ inf->attach_flag ? "attached" : "child",
target_pid_to_str (inferior_ptid));
}
static int
inf_ttrace_thread_alive (ptid_t ptid)
{
- struct thread_info *ti;
- ti = find_thread_pid (ptid);
- return !(((struct inf_ttrace_private_thread_info *)ti->private)->dying);
+ return 1;
}
+/* Return a string describing the state of the thread specified by
+ INFO. */
+
static char *
-inf_ttrace_pid_to_str (ptid_t ptid)
+inf_ttrace_extra_thread_info (struct thread_info *info)
{
- if (inf_ttrace_num_lwps > 0)
- {
- pid_t pid = ptid_get_pid (ptid);
- lwpid_t lwpid = ptid_get_lwp (ptid);
- static char buf[128];
+ struct inf_ttrace_private_thread_info* private =
+ (struct inf_ttrace_private_thread_info *) info->private;
- xsnprintf (buf, sizeof buf, "process %ld, lwp %ld",
- (long)pid, (long)lwpid);
- return buf;
- }
+ if (private != NULL && private->dying)
+ return "Exiting";
+
+ return NULL;
+}
- return normal_pid_to_str (ptid);
+static char *
+inf_ttrace_pid_to_str (ptid_t ptid)
+{
+ pid_t pid = ptid_get_pid (ptid);
+ lwpid_t lwpid = ptid_get_lwp (ptid);
+ static char buf[128];
+
+ if (lwpid == 0)
+ xsnprintf (buf, sizeof buf, "process %ld",
+ (long) pid);
+ else
+ xsnprintf (buf, sizeof buf, "process %ld, lwp %ld",
+ (long) pid, (long) lwpid);
+ return buf;
}
\f
t->to_follow_fork = inf_ttrace_follow_fork;
t->to_mourn_inferior = inf_ttrace_mourn_inferior;
t->to_thread_alive = inf_ttrace_thread_alive;
+ t->to_extra_thread_info = inf_ttrace_extra_thread_info;
t->to_pid_to_str = inf_ttrace_pid_to_str;
t->to_xfer_partial = inf_ttrace_xfer_partial;