/* Low-level child interface to ttrace.
- Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2004-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcore.h"
#include "gdbthread.h"
#include "inferior.h"
+#include "terminal.h"
#include "target.h"
#include "gdb_assert.h"
-#include "gdb_string.h"
+#include <string.h>
#include <sys/mman.h>
#include <sys/ttrace.h>
#include <signal.h>
#include "inf-child.h"
#include "inf-ttrace.h"
+#include "common/filestuff.h"
-/* HACK: Save the ttrace ops returned by inf_ttrace_target. */
-static struct target_ops *ttrace_ops_hack;
\f
/* HP-UX uses a threading model where each user-space thread
addr, 0, (uintptr_t)&prot) == -1)
perror_with_name (("ttrace"));
- page = XMALLOC (struct inf_ttrace_page);
+ page = XNEW (struct inf_ttrace_page);
page->addr = addr;
page->prot = prot;
page->refcount = 0;
type TYPE. */
static int
-inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type)
+inf_ttrace_insert_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len, int type,
+ struct expression *cond)
{
const int pagesize = inf_ttrace_page_dict.pagesize;
pid_t pid = ptid_get_pid (inferior_ptid);
type TYPE. */
static int
-inf_ttrace_remove_watchpoint (CORE_ADDR addr, int len, int type)
+inf_ttrace_remove_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len, int type,
+ struct expression *cond)
{
const int pagesize = inf_ttrace_page_dict.pagesize;
pid_t pid = ptid_get_pid (inferior_ptid);
}
static int
-inf_ttrace_can_use_hw_breakpoint (int type, int len, int ot)
+inf_ttrace_can_use_hw_breakpoint (struct target_ops *self,
+ int type, int len, int ot)
{
return (type == bp_hardware_watchpoint);
}
static int
-inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+inf_ttrace_region_ok_for_hw_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len)
{
return 1;
}
by hitting a "hardware" watchpoint. */
static int
-inf_ttrace_stopped_by_watchpoint (void)
+inf_ttrace_stopped_by_watchpoint (struct target_ops *ops)
{
pid_t pid = ptid_get_pid (inferior_ptid);
lwpid_t lwpid = ptid_get_lwp (inferior_ptid);
static pid_t inf_ttrace_vfork_ppid = -1;
static int
-inf_ttrace_follow_fork (struct target_ops *ops, int follow_child)
+inf_ttrace_follow_fork (struct target_ops *ops, int follow_child,
+ int detach_fork)
{
pid_t pid, fpid;
lwpid_t lwpid, flwpid;
ttstate_t tts;
+ struct thread_info *tp = inferior_thread ();
- /* FIXME: kettenis/20050720: This stuff should really be passed as
- an argument by our caller. */
- {
- ptid_t ptid;
- struct target_waitstatus status;
+ gdb_assert (tp->pending_follow.kind == TARGET_WAITKIND_FORKED
+ || tp->pending_follow.kind == TARGET_WAITKIND_VFORKED);
- get_last_target_status (&ptid, &status);
- gdb_assert (status.kind == TARGET_WAITKIND_FORKED
- || status.kind == TARGET_WAITKIND_VFORKED);
-
- pid = ptid_get_pid (ptid);
- lwpid = ptid_get_lwp (ptid);
- }
+ pid = ptid_get_pid (inferior_ptid);
+ lwpid = ptid_get_lwp (inferior_ptid);
/* Get all important details that core GDB doesn't (and shouldn't)
know about. */
if (follow_child)
{
+ struct inferior *inf;
+ struct inferior *parent_inf;
+
+ parent_inf = find_inferior_pid (pid);
+
inferior_ptid = ptid_build (fpid, flwpid, 0);
- detach_breakpoints (pid);
+ inf = add_inferior (fpid);
+ inf->attach_flag = parent_inf->attach_flag;
+ inf->pspace = parent_inf->pspace;
+ inf->aspace = parent_inf->aspace;
+ copy_terminal_info (inf, parent_inf);
+ detach_breakpoints (ptid_build (pid, lwpid, 0));
target_terminal_ours ();
- fprintf_unfiltered (gdb_stdlog, _("\
-Attaching after fork to child process %ld.\n"), (long)fpid);
+ fprintf_unfiltered (gdb_stdlog,
+ _("Attaching after fork to child process %ld.\n"),
+ (long)fpid);
}
else
{
inferior_ptid = ptid_build (pid, lwpid, 0);
- detach_breakpoints (fpid);
+ /* Detach any remaining breakpoints in the child. In the case
+ of fork events, we do not need to do this, because breakpoints
+ should have already been removed earlier. */
+ if (tts.tts_event == TTEVT_VFORK)
+ detach_breakpoints (ptid_build (fpid, flwpid, 0));
target_terminal_ours ();
- fprintf_unfiltered (gdb_stdlog, _("\
-Detaching after fork from child process %ld.\n"), (long)fpid);
+ fprintf_unfiltered (gdb_stdlog,
+ _("Detaching after fork from child process %ld.\n"),
+ (long)fpid);
}
if (tts.tts_event == TTEVT_VFORK)
/* Delete parent. */
delete_thread_silent (ptid_build (pid, lwpid, 0));
+ detach_inferior (pid);
- /* Add child. inferior_ptid was already set above. */
+ /* 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));
-
- /* Reset breakpoints in the child as appropriate. */
- follow_inferior_reset_breakpoints ();
}
return 0;
close (inf_ttrace_pfd1[1]);
close (inf_ttrace_pfd2[0]);
close (inf_ttrace_pfd2[1]);
+
+ unmark_fd_no_cloexec (inf_ttrace_pfd1[0]);
+ unmark_fd_no_cloexec (inf_ttrace_pfd1[1]);
+ unmark_fd_no_cloexec (inf_ttrace_pfd2[0]);
+ unmark_fd_no_cloexec (inf_ttrace_pfd2[1]);
}
static void
close (inf_ttrace_pfd2[0]);
perror_with_name (("pipe"));
}
+
+ mark_fd_no_cloexec (inf_ttrace_pfd1[0]);
+ mark_fd_no_cloexec (inf_ttrace_pfd1[1]);
+ mark_fd_no_cloexec (inf_ttrace_pfd2[0]);
+ mark_fd_no_cloexec (inf_ttrace_pfd2[1]);
}
/* Prepare to be traced. */
/* Start tracing PID. */
static void
-inf_ttrace_him (int pid)
+inf_ttrace_him (struct target_ops *ops, int pid)
{
struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
ttevent_t tte;
do_cleanups (old_chain);
- push_target (ttrace_ops_hack);
+ push_target (ops);
- /* On some targets, there must be some explicit synchronization
- between the parent and child processes after the debugger forks,
- and before the child execs the debuggee program. This call
- basically gives permission for the child to exec. */
-
- target_acknowledge_created_inferior (pid);
-
- /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
- be 1 or 2 depending on whether we're starting without or with a
- shell. */
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
/* On some targets, there must be some explicit actions taken after
}
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)
{
+ int pid;
+
gdb_assert (inf_ttrace_num_lwps == 0);
gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
gdb_assert (inf_ttrace_page_dict.count == 0);
gdb_assert (inf_ttrace_reenable_page_protections == 0);
gdb_assert (inf_ttrace_vfork_ppid == -1);
- fork_inferior (exec_file, allargs, env, inf_ttrace_me, inf_ttrace_him,
- inf_ttrace_prepare, NULL);
+ pid = fork_inferior (exec_file, allargs, env, inf_ttrace_me, NULL,
+ inf_ttrace_prepare, NULL, NULL);
+
+ inf_ttrace_him (ops, pid);
}
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;
}
inf_ttrace_page_dict.count = 0;
- unpush_target (ttrace_ops_hack);
+ unpush_target (ops);
generic_mourn_inferior ();
}
+/* Assuming we just attached the debugger to a new inferior, create
+ a new thread_info structure for each thread, and add it to our
+ list of threads. */
+
+static void
+inf_ttrace_create_threads_after_attach (int pid)
+{
+ int status;
+ ptid_t ptid;
+ ttstate_t tts;
+ struct thread_info *ti;
+
+ status = ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
+ (uintptr_t) &tts, sizeof (ttstate_t), 0);
+ if (status < 0)
+ perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
+ gdb_assert (tts.tts_pid == pid);
+
+ /* Add the stopped thread. */
+ ptid = ptid_build (pid, tts.tts_lwpid, 0);
+ ti = add_thread (ptid);
+ ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
+ inf_ttrace_num_lwps++;
+
+ /* We use the "first stopped thread" as the currently active thread. */
+ inferior_ptid = ptid;
+
+ /* Iterative over all the remaining threads. */
+
+ for (;;)
+ {
+ ptid_t ptid;
+
+ status = ttrace (TT_PROC_GET_NEXT_LWP_STATE, pid, 0,
+ (uintptr_t) &tts, sizeof (ttstate_t), 0);
+ if (status < 0)
+ perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
+ if (status == 0)
+ break; /* End of list. */
+
+ ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
+ ti = add_thread (ptid);
+ ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
+ inf_ttrace_num_lwps++;
+ }
+}
+
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"));
-
- dummy = args;
- pid = strtol (args, &dummy, 0);
- if (pid == 0 && args == dummy)
- error (_("Illegal process-id: %s."), args);
+ pid = parse_pid_to_attach (args);
if (pid == getpid ()) /* Trying to masturbate? */
error (_("I refuse to debug myself!"));
if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
perror_with_name (("ttrace"));
- attach_flag = 1;
+
+ inf = current_inferior ();
+ inferior_appeared (inf, 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"));
- push_target (ttrace_ops_hack);
+ push_target (ops);
- /* 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);
+ inf_ttrace_create_threads_after_attach (pid);
}
static void
-inf_ttrace_detach (char *args, int from_tty)
+inf_ttrace_detach (struct target_ops *ops, const 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 (ops);
}
static void
-inf_ttrace_kill (void)
+inf_ttrace_kill (struct target_ops *ops)
{
pid_t pid = ptid_get_pid (inferior_ptid);
}
static void
-inf_ttrace_resume (ptid_t ptid, int step, enum target_signal signal)
+inf_ttrace_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum gdb_signal signal)
{
int resume_all;
ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
- int sig = target_signal_to_host (signal);
+ int sig = gdb_signal_to_host (signal);
struct thread_info *info;
/* A specific PTID means `step only this process id'. */
if (resume_all)
ptid = inferior_ptid;
- info = thread_find_pid (ptid);
+ info = find_thread_ptid (ptid);
inf_ttrace_resume_lwp (info, request, sig);
if (resume_all)
}
static ptid_t
-inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+inf_ttrace_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus, int options)
{
pid_t pid = ptid_get_pid (ptid);
lwpid_t lwpid = ptid_get_lwp (ptid);
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);
/* We haven't set the private member on the main thread yet. Do
it now. */
- ti = find_thread_pid (inferior_ptid);
+ ti = find_thread_ptid (inferior_ptid);
gdb_assert (ti != NULL && ti->private == NULL);
ti->private =
xmalloc (sizeof (struct inf_ttrace_private_thread_info));
case TTEVT_BPT_SSTEP:
/* Make it look like a breakpoint. */
ourstatus->kind = TARGET_WAITKIND_STOPPED;
- ourstatus->value.sig = TARGET_SIGNAL_TRAP;
+ ourstatus->value.sig = GDB_SIGNAL_TRAP;
break;
#endif
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)
printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid));
- ti = find_thread_pid (ptid);
+ ti = find_thread_ptid (ptid);
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));
- ti = find_thread_pid (ptid);
+ if (print_thread_events)
+ printf_unfiltered(_("[%s has been terminated]\n"),
+ target_pid_to_str (ptid));
+ ti = find_thread_ptid (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;
ourstatus->value.sig =
- target_signal_from_host (tts.tts_u.tts_signal.tts_signo);
+ gdb_signal_from_host (tts.tts_u.tts_signal.tts_signo);
break;
case TTEVT_SYSCALL_ENTRY:
inf_ttrace_disable_page_protections (tts.tts_pid);
}
ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
- ourstatus->value.syscall_id = tts.tts_scno;
+ ourstatus->value.syscall_number = tts.tts_scno;
break;
case TTEVT_SYSCALL_RETURN:
inf_ttrace_num_lwps_in_syscall--;
}
ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
- ourstatus->value.syscall_id = tts.tts_scno;
+ ourstatus->value.syscall_number = tts.tts_scno;
break;
default:
return len;
}
-static LONGEST
+static enum target_xfer_status
inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,
const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
switch (object)
{
case TARGET_OBJECT_MEMORY:
- return inf_ttrace_xfer_memory (offset, len, readbuf, writebuf);
+ {
+ LONGEST val = inf_ttrace_xfer_memory (offset, len, readbuf, writebuf);
+
+ if (val == 0)
+ return TARGET_XFER_EOF;
+ else
+ {
+ *xfered_len = (ULONGEST) val;
+ return TARGET_XFER_OK;
+ }
+ }
case TARGET_OBJECT_UNWIND_TABLE:
- return -1;
+ return TARGET_XFER_E_IO;
case TARGET_OBJECT_AUXV:
- return -1;
+ return TARGET_XFER_E_IO;
case TARGET_OBJECT_WCOOKIE:
- return -1;
+ return TARGET_XFER_E_IO;
default:
- return -1;
+ return TARGET_XFER_E_IO;
}
}
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)
+inf_ttrace_thread_alive (struct target_ops *ops, ptid_t ptid)
{
return 1;
}
INFO. */
static char *
-inf_ttrace_extra_thread_info (struct thread_info *info)
+inf_ttrace_extra_thread_info (struct target_ops *self,
+ struct thread_info *info)
{
struct inf_ttrace_private_thread_info* private =
(struct inf_ttrace_private_thread_info *) info->private;
}
static char *
-inf_ttrace_pid_to_str (ptid_t ptid)
+inf_ttrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
pid_t pid = ptid_get_pid (ptid);
lwpid_t lwpid = ptid_get_lwp (ptid);
}
\f
+/* Implement the get_ada_task_ptid target_ops method. */
+
+static ptid_t
+inf_ttrace_get_ada_task_ptid (long lwp, long thread)
+{
+ return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
+}
+
+\f
struct target_ops *
inf_ttrace_target (void)
{
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;
+ t->to_get_ada_task_ptid = inf_ttrace_get_ada_task_ptid;
- ttrace_ops_hack = t;
return t;
}
#endif
\f
/* Prevent warning from -Wmissing-prototypes. */
-void _initialize_hppa_hpux_nat (void);
+void _initialize_inf_ttrace (void);
void
_initialize_inf_ttrace (void)
projects / binutils-gdb.git / blobdiff