/* Low-level child interface to ptrace.
|
/* Low-level child interface to ptrace.
|
|
|
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
|
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
|
1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "command.h"
|
#include "command.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "inflow.h"
|
#include "inflow.h"
|
#include "terminal.h"
|
#include "terminal.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "regcache.h"
|
#include "regcache.h"
|
|
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include "gdb_ptrace.h"
|
#include "gdb_ptrace.h"
|
#include "gdb_wait.h"
|
#include "gdb_wait.h"
|
#include <signal.h>
|
#include <signal.h>
|
|
|
#include "inf-ptrace.h"
|
#include "inf-ptrace.h"
|
#include "inf-child.h"
|
#include "inf-child.h"
|
#include "gdbthread.h"
|
#include "gdbthread.h"
|
|
|
|
|
|
|
#ifdef PT_GET_PROCESS_STATE
|
#ifdef PT_GET_PROCESS_STATE
|
|
|
static int
|
static int
|
inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
|
inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
|
{
|
{
|
pid_t pid, fpid;
|
pid_t pid, fpid;
|
ptrace_state_t pe;
|
ptrace_state_t pe;
|
|
|
pid = ptid_get_pid (inferior_ptid);
|
pid = ptid_get_pid (inferior_ptid);
|
|
|
if (ptrace (PT_GET_PROCESS_STATE, pid,
|
if (ptrace (PT_GET_PROCESS_STATE, pid,
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
|
|
gdb_assert (pe.pe_report_event == PTRACE_FORK);
|
gdb_assert (pe.pe_report_event == PTRACE_FORK);
|
fpid = pe.pe_other_pid;
|
fpid = pe.pe_other_pid;
|
|
|
if (follow_child)
|
if (follow_child)
|
{
|
{
|
struct inferior *parent_inf, *child_inf;
|
struct inferior *parent_inf, *child_inf;
|
struct thread_info *tp;
|
struct thread_info *tp;
|
|
|
parent_inf = find_inferior_pid (pid);
|
parent_inf = find_inferior_pid (pid);
|
|
|
/* Add the child. */
|
/* Add the child. */
|
child_inf = add_inferior (fpid);
|
child_inf = add_inferior (fpid);
|
child_inf->attach_flag = parent_inf->attach_flag;
|
child_inf->attach_flag = parent_inf->attach_flag;
|
copy_terminal_info (child_inf, parent_inf);
|
copy_terminal_info (child_inf, parent_inf);
|
child_inf->pspace = parent_inf->pspace;
|
child_inf->pspace = parent_inf->pspace;
|
child_inf->aspace = parent_inf->aspace;
|
child_inf->aspace = parent_inf->aspace;
|
|
|
/* Before detaching from the parent, remove all breakpoints from
|
/* Before detaching from the parent, remove all breakpoints from
|
it. */
|
it. */
|
remove_breakpoints ();
|
remove_breakpoints ();
|
|
|
if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
|
if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
|
|
/* Switch inferior_ptid out of the parent's way. */
|
/* Switch inferior_ptid out of the parent's way. */
|
inferior_ptid = pid_to_ptid (fpid);
|
inferior_ptid = pid_to_ptid (fpid);
|
|
|
/* Delete the parent. */
|
/* Delete the parent. */
|
detach_inferior (pid);
|
detach_inferior (pid);
|
|
|
add_thread_silent (inferior_ptid);
|
add_thread_silent (inferior_ptid);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Breakpoints have already been detached from the child by
|
/* Breakpoints have already been detached from the child by
|
infrun.c. */
|
infrun.c. */
|
|
|
if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
|
if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#endif /* PT_GET_PROCESS_STATE */
|
#endif /* PT_GET_PROCESS_STATE */
|
|
|
|
|
/* Prepare to be traced. */
|
/* Prepare to be traced. */
|
|
|
static void
|
static void
|
inf_ptrace_me (void)
|
inf_ptrace_me (void)
|
{
|
{
|
/* "Trace me, Dr. Memory!" */
|
/* "Trace me, Dr. Memory!" */
|
ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
|
ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
|
}
|
}
|
|
|
/* Start a new inferior Unix child process. EXEC_FILE is the file to
|
/* Start a new inferior Unix child process. EXEC_FILE is the file to
|
run, ALLARGS is a string containing the arguments to the program.
|
run, ALLARGS is a string containing the arguments to the program.
|
ENV is the environment vector to pass. If FROM_TTY is non-zero, be
|
ENV is the environment vector to pass. If FROM_TTY is non-zero, be
|
chatty about it. */
|
chatty about it. */
|
|
|
static void
|
static void
|
inf_ptrace_create_inferior (struct target_ops *ops,
|
inf_ptrace_create_inferior (struct target_ops *ops,
|
char *exec_file, char *allargs, char **env,
|
char *exec_file, char *allargs, char **env,
|
int from_tty)
|
int from_tty)
|
{
|
{
|
int pid;
|
int pid;
|
|
|
pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
|
pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
|
NULL, NULL);
|
NULL, NULL);
|
|
|
push_target (ops);
|
push_target (ops);
|
|
|
/* On some targets, there must be some explicit synchronization
|
/* On some targets, there must be some explicit synchronization
|
between the parent and child processes after the debugger
|
between the parent and child processes after the debugger
|
forks, and before the child execs the debuggee program. This
|
forks, and before the child execs the debuggee program. This
|
call basically gives permission for the child to exec. */
|
call basically gives permission for the child to exec. */
|
|
|
target_acknowledge_created_inferior (pid);
|
target_acknowledge_created_inferior (pid);
|
|
|
/* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
|
/* 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
|
be 1 or 2 depending on whether we're starting without or with a
|
shell. */
|
shell. */
|
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
|
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
|
|
|
/* On some targets, there must be some explicit actions taken after
|
/* On some targets, there must be some explicit actions taken after
|
the inferior has been started up. */
|
the inferior has been started up. */
|
target_post_startup_inferior (pid_to_ptid (pid));
|
target_post_startup_inferior (pid_to_ptid (pid));
|
}
|
}
|
|
|
#ifdef PT_GET_PROCESS_STATE
|
#ifdef PT_GET_PROCESS_STATE
|
|
|
static void
|
static void
|
inf_ptrace_post_startup_inferior (ptid_t pid)
|
inf_ptrace_post_startup_inferior (ptid_t pid)
|
{
|
{
|
ptrace_event_t pe;
|
ptrace_event_t pe;
|
|
|
/* Set the initial event mask. */
|
/* Set the initial event mask. */
|
memset (&pe, 0, sizeof pe);
|
memset (&pe, 0, sizeof pe);
|
pe.pe_set_event |= PTRACE_FORK;
|
pe.pe_set_event |= PTRACE_FORK;
|
if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
|
if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
}
|
}
|
|
|
#endif
|
#endif
|
|
|
/* Clean up a rotting corpse of an inferior after it died. */
|
/* Clean up a rotting corpse of an inferior after it died. */
|
|
|
static void
|
static void
|
inf_ptrace_mourn_inferior (struct target_ops *ops)
|
inf_ptrace_mourn_inferior (struct target_ops *ops)
|
{
|
{
|
int status;
|
int status;
|
|
|
/* Wait just one more time to collect the inferior's exit status.
|
/* Wait just one more time to collect the inferior's exit status.
|
Do not check whether this succeeds though, since we may be
|
Do not check whether this succeeds though, since we may be
|
dealing with a process that we attached to. Such a process will
|
dealing with a process that we attached to. Such a process will
|
only report its exit status to its original parent. */
|
only report its exit status to its original parent. */
|
waitpid (ptid_get_pid (inferior_ptid), &status, 0);
|
waitpid (ptid_get_pid (inferior_ptid), &status, 0);
|
|
|
generic_mourn_inferior ();
|
generic_mourn_inferior ();
|
|
|
if (!have_inferiors ())
|
if (!have_inferiors ())
|
unpush_target (ops);
|
unpush_target (ops);
|
}
|
}
|
|
|
/* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
|
/* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
|
be chatty about it. */
|
be chatty about it. */
|
|
|
static void
|
static void
|
inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
|
inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
|
{
|
{
|
char *exec_file;
|
char *exec_file;
|
pid_t pid;
|
pid_t pid;
|
struct inferior *inf;
|
struct inferior *inf;
|
|
|
pid = parse_pid_to_attach (args);
|
pid = parse_pid_to_attach (args);
|
|
|
if (pid == getpid ()) /* Trying to masturbate? */
|
if (pid == getpid ()) /* Trying to masturbate? */
|
error (_("I refuse to debug myself!"));
|
error (_("I refuse to debug myself!"));
|
|
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
exec_file = get_exec_file (0);
|
exec_file = get_exec_file (0);
|
|
|
if (exec_file)
|
if (exec_file)
|
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
|
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
|
target_pid_to_str (pid_to_ptid (pid)));
|
target_pid_to_str (pid_to_ptid (pid)));
|
else
|
else
|
printf_unfiltered (_("Attaching to %s\n"),
|
printf_unfiltered (_("Attaching to %s\n"),
|
target_pid_to_str (pid_to_ptid (pid)));
|
target_pid_to_str (pid_to_ptid (pid)));
|
|
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
|
|
#ifdef PT_ATTACH
|
#ifdef PT_ATTACH
|
errno = 0;
|
errno = 0;
|
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
|
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
|
if (errno != 0)
|
if (errno != 0)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
#else
|
#else
|
error (_("This system does not support attaching to a process"));
|
error (_("This system does not support attaching to a process"));
|
#endif
|
#endif
|
|
|
inf = current_inferior ();
|
inf = current_inferior ();
|
inferior_appeared (inf, pid);
|
inferior_appeared (inf, pid);
|
inf->attach_flag = 1;
|
inf->attach_flag = 1;
|
inferior_ptid = pid_to_ptid (pid);
|
inferior_ptid = pid_to_ptid (pid);
|
|
|
/* Always add a main thread. If some target extends the ptrace
|
/* Always add a main thread. If some target extends the ptrace
|
target, it should decorate the ptid later with more info. */
|
target, it should decorate the ptid later with more info. */
|
add_thread_silent (inferior_ptid);
|
add_thread_silent (inferior_ptid);
|
|
|
push_target(ops);
|
push_target(ops);
|
}
|
}
|
|
|
#ifdef PT_GET_PROCESS_STATE
|
#ifdef PT_GET_PROCESS_STATE
|
|
|
void
|
void
|
inf_ptrace_post_attach (int pid)
|
inf_ptrace_post_attach (int pid)
|
{
|
{
|
ptrace_event_t pe;
|
ptrace_event_t pe;
|
|
|
/* Set the initial event mask. */
|
/* Set the initial event mask. */
|
memset (&pe, 0, sizeof pe);
|
memset (&pe, 0, sizeof pe);
|
pe.pe_set_event |= PTRACE_FORK;
|
pe.pe_set_event |= PTRACE_FORK;
|
if (ptrace (PT_SET_EVENT_MASK, pid,
|
if (ptrace (PT_SET_EVENT_MASK, pid,
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
}
|
}
|
|
|
#endif
|
#endif
|
|
|
/* Detach from the inferior, optionally passing it the signal
|
/* Detach from the inferior, optionally passing it the signal
|
specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
|
specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
|
|
|
static void
|
static void
|
inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty)
|
inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty)
|
{
|
{
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
int sig = 0;
|
int sig = 0;
|
|
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
char *exec_file = get_exec_file (0);
|
char *exec_file = get_exec_file (0);
|
if (exec_file == 0)
|
if (exec_file == 0)
|
exec_file = "";
|
exec_file = "";
|
printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
|
printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
|
target_pid_to_str (pid_to_ptid (pid)));
|
target_pid_to_str (pid_to_ptid (pid)));
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
if (args)
|
if (args)
|
sig = atoi (args);
|
sig = atoi (args);
|
|
|
#ifdef PT_DETACH
|
#ifdef PT_DETACH
|
/* We'd better not have left any breakpoints in the program or it'll
|
/* We'd better not have left any breakpoints in the program or it'll
|
die when it hits one. Also note that this may only work if we
|
die when it hits one. Also note that this may only work if we
|
previously attached to the inferior. It *might* work if we
|
previously attached to the inferior. It *might* work if we
|
started the process ourselves. */
|
started the process ourselves. */
|
errno = 0;
|
errno = 0;
|
ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
|
ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
|
if (errno != 0)
|
if (errno != 0)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
#else
|
#else
|
error (_("This system does not support detaching from a process"));
|
error (_("This system does not support detaching from a process"));
|
#endif
|
#endif
|
|
|
inferior_ptid = null_ptid;
|
inferior_ptid = null_ptid;
|
detach_inferior (pid);
|
detach_inferior (pid);
|
|
|
if (!have_inferiors ())
|
if (!have_inferiors ())
|
unpush_target (ops);
|
unpush_target (ops);
|
}
|
}
|
|
|
/* Kill the inferior. */
|
/* Kill the inferior. */
|
|
|
static void
|
static void
|
inf_ptrace_kill (struct target_ops *ops)
|
inf_ptrace_kill (struct target_ops *ops)
|
{
|
{
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
int status;
|
int status;
|
|
|
if (pid == 0)
|
if (pid == 0)
|
return;
|
return;
|
|
|
ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
|
ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
|
waitpid (pid, &status, 0);
|
waitpid (pid, &status, 0);
|
|
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
}
|
}
|
|
|
/* Stop the inferior. */
|
/* Stop the inferior. */
|
|
|
static void
|
static void
|
inf_ptrace_stop (ptid_t ptid)
|
inf_ptrace_stop (ptid_t ptid)
|
{
|
{
|
/* Send a SIGINT to the process group. This acts just like the user
|
/* Send a SIGINT to the process group. This acts just like the user
|
typed a ^C on the controlling terminal. Note that using a
|
typed a ^C on the controlling terminal. Note that using a
|
negative process number in kill() is a System V-ism. The proper
|
negative process number in kill() is a System V-ism. The proper
|
BSD interface is killpg(). However, all modern BSDs support the
|
BSD interface is killpg(). However, all modern BSDs support the
|
System V interface too. */
|
System V interface too. */
|
kill (-inferior_process_group (), SIGINT);
|
kill (-inferior_process_group (), SIGINT);
|
}
|
}
|
|
|
/* Resume execution of thread PTID, or all threads if PTID is -1. If
|
/* Resume execution of thread PTID, or all threads if PTID is -1. If
|
STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
|
STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
|
that signal. */
|
that signal. */
|
|
|
static void
|
static void
|
inf_ptrace_resume (struct target_ops *ops,
|
inf_ptrace_resume (struct target_ops *ops,
|
ptid_t ptid, int step, enum target_signal signal)
|
ptid_t ptid, int step, enum target_signal signal)
|
{
|
{
|
pid_t pid = ptid_get_pid (ptid);
|
pid_t pid = ptid_get_pid (ptid);
|
int request;
|
int request;
|
|
|
if (pid == -1)
|
if (pid == -1)
|
/* Resume all threads. Traditionally ptrace() only supports
|
/* Resume all threads. Traditionally ptrace() only supports
|
single-threaded processes, so simply resume the inferior. */
|
single-threaded processes, so simply resume the inferior. */
|
pid = ptid_get_pid (inferior_ptid);
|
pid = ptid_get_pid (inferior_ptid);
|
|
|
if (catch_syscall_enabled () > 0)
|
if (catch_syscall_enabled () > 0)
|
request = PT_SYSCALL;
|
request = PT_SYSCALL;
|
else
|
else
|
request = PT_CONTINUE;
|
request = PT_CONTINUE;
|
|
|
if (step)
|
if (step)
|
{
|
{
|
/* If this system does not support PT_STEP, a higher level
|
/* If this system does not support PT_STEP, a higher level
|
function will have called single_step() to transmute the step
|
function will have called single_step() to transmute the step
|
request into a continue request (by setting breakpoints on
|
request into a continue request (by setting breakpoints on
|
all possible successor instructions), so we don't have to
|
all possible successor instructions), so we don't have to
|
worry about that here. */
|
worry about that here. */
|
request = PT_STEP;
|
request = PT_STEP;
|
}
|
}
|
|
|
/* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
|
/* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
|
where it was. If GDB wanted it to start some other way, we have
|
where it was. If GDB wanted it to start some other way, we have
|
already written a new program counter value to the child. */
|
already written a new program counter value to the child. */
|
errno = 0;
|
errno = 0;
|
ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
|
ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
|
if (errno != 0)
|
if (errno != 0)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
}
|
}
|
|
|
/* Wait for the child specified by PTID to do something. Return the
|
/* Wait for the child specified by PTID to do something. Return the
|
process ID of the child, or MINUS_ONE_PTID in case of error; store
|
process ID of the child, or MINUS_ONE_PTID in case of error; store
|
the status in *OURSTATUS. */
|
the status in *OURSTATUS. */
|
|
|
static ptid_t
|
static ptid_t
|
inf_ptrace_wait (struct target_ops *ops,
|
inf_ptrace_wait (struct target_ops *ops,
|
ptid_t ptid, struct target_waitstatus *ourstatus, int options)
|
ptid_t ptid, struct target_waitstatus *ourstatus, int options)
|
{
|
{
|
pid_t pid;
|
pid_t pid;
|
int status, save_errno;
|
int status, save_errno;
|
|
|
do
|
do
|
{
|
{
|
set_sigint_trap ();
|
set_sigint_trap ();
|
|
|
do
|
do
|
{
|
{
|
pid = waitpid (ptid_get_pid (ptid), &status, 0);
|
pid = waitpid (ptid_get_pid (ptid), &status, 0);
|
save_errno = errno;
|
save_errno = errno;
|
}
|
}
|
while (pid == -1 && errno == EINTR);
|
while (pid == -1 && errno == EINTR);
|
|
|
clear_sigint_trap ();
|
clear_sigint_trap ();
|
|
|
if (pid == -1)
|
if (pid == -1)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
_("Child process unexpectedly missing: %s.\n"),
|
_("Child process unexpectedly missing: %s.\n"),
|
safe_strerror (save_errno));
|
safe_strerror (save_errno));
|
|
|
/* Claim it exited with unknown signal. */
|
/* Claim it exited with unknown signal. */
|
ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
|
ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
|
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
|
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
|
return inferior_ptid;
|
return inferior_ptid;
|
}
|
}
|
|
|
/* Ignore terminated detached child processes. */
|
/* Ignore terminated detached child processes. */
|
if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
|
if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
|
pid = -1;
|
pid = -1;
|
}
|
}
|
while (pid == -1);
|
while (pid == -1);
|
|
|
#ifdef PT_GET_PROCESS_STATE
|
#ifdef PT_GET_PROCESS_STATE
|
if (WIFSTOPPED (status))
|
if (WIFSTOPPED (status))
|
{
|
{
|
ptrace_state_t pe;
|
ptrace_state_t pe;
|
pid_t fpid;
|
pid_t fpid;
|
|
|
if (ptrace (PT_GET_PROCESS_STATE, pid,
|
if (ptrace (PT_GET_PROCESS_STATE, pid,
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
|
|
switch (pe.pe_report_event)
|
switch (pe.pe_report_event)
|
{
|
{
|
case PTRACE_FORK:
|
case PTRACE_FORK:
|
ourstatus->kind = TARGET_WAITKIND_FORKED;
|
ourstatus->kind = TARGET_WAITKIND_FORKED;
|
ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
|
ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
|
|
|
/* Make sure the other end of the fork is stopped too. */
|
/* Make sure the other end of the fork is stopped too. */
|
fpid = waitpid (pe.pe_other_pid, &status, 0);
|
fpid = waitpid (pe.pe_other_pid, &status, 0);
|
if (fpid == -1)
|
if (fpid == -1)
|
perror_with_name (("waitpid"));
|
perror_with_name (("waitpid"));
|
|
|
if (ptrace (PT_GET_PROCESS_STATE, fpid,
|
if (ptrace (PT_GET_PROCESS_STATE, fpid,
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
(PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
|
perror_with_name (("ptrace"));
|
perror_with_name (("ptrace"));
|
|
|
gdb_assert (pe.pe_report_event == PTRACE_FORK);
|
gdb_assert (pe.pe_report_event == PTRACE_FORK);
|
gdb_assert (pe.pe_other_pid == pid);
|
gdb_assert (pe.pe_other_pid == pid);
|
if (fpid == ptid_get_pid (inferior_ptid))
|
if (fpid == ptid_get_pid (inferior_ptid))
|
{
|
{
|
ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
|
ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
|
return pid_to_ptid (fpid);
|
return pid_to_ptid (fpid);
|
}
|
}
|
|
|
return pid_to_ptid (pid);
|
return pid_to_ptid (pid);
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
|
|
store_waitstatus (ourstatus, status);
|
store_waitstatus (ourstatus, status);
|
return pid_to_ptid (pid);
|
return pid_to_ptid (pid);
|
}
|
}
|
|
|
/* Attempt a transfer all LEN bytes starting at OFFSET between the
|
/* Attempt a transfer all LEN bytes starting at OFFSET between the
|
inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
|
inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
|
Return the number of bytes actually transferred. */
|
Return the number of bytes actually transferred. */
|
|
|
static LONGEST
|
static LONGEST
|
inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
|
inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
|
const char *annex, gdb_byte *readbuf,
|
const char *annex, gdb_byte *readbuf,
|
const gdb_byte *writebuf,
|
const gdb_byte *writebuf,
|
ULONGEST offset, LONGEST len)
|
ULONGEST offset, LONGEST len)
|
{
|
{
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
|
|
switch (object)
|
switch (object)
|
{
|
{
|
case TARGET_OBJECT_MEMORY:
|
case TARGET_OBJECT_MEMORY:
|
#ifdef PT_IO
|
#ifdef PT_IO
|
/* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
|
/* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
|
request that promises to be much more efficient in reading
|
request that promises to be much more efficient in reading
|
and writing data in the traced process's address space. */
|
and writing data in the traced process's address space. */
|
{
|
{
|
struct ptrace_io_desc piod;
|
struct ptrace_io_desc piod;
|
|
|
/* NOTE: We assume that there are no distinct address spaces
|
/* NOTE: We assume that there are no distinct address spaces
|
for instruction and data. However, on OpenBSD 3.9 and
|
for instruction and data. However, on OpenBSD 3.9 and
|
later, PIOD_WRITE_D doesn't allow changing memory that's
|
later, PIOD_WRITE_D doesn't allow changing memory that's
|
mapped read-only. Since most code segments will be
|
mapped read-only. Since most code segments will be
|
read-only, using PIOD_WRITE_D will prevent us from
|
read-only, using PIOD_WRITE_D will prevent us from
|
inserting breakpoints, so we use PIOD_WRITE_I instead. */
|
inserting breakpoints, so we use PIOD_WRITE_I instead. */
|
piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
|
piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
|
piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
|
piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
|
piod.piod_offs = (void *) (long) offset;
|
piod.piod_offs = (void *) (long) offset;
|
piod.piod_len = len;
|
piod.piod_len = len;
|
|
|
errno = 0;
|
errno = 0;
|
if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
|
if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
|
/* Return the actual number of bytes read or written. */
|
/* Return the actual number of bytes read or written. */
|
return piod.piod_len;
|
return piod.piod_len;
|
/* If the PT_IO request is somehow not supported, fallback on
|
/* If the PT_IO request is somehow not supported, fallback on
|
using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
|
using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
|
to indicate failure. */
|
to indicate failure. */
|
if (errno != EINVAL)
|
if (errno != EINVAL)
|
return 0;
|
return 0;
|
}
|
}
|
#endif
|
#endif
|
{
|
{
|
union
|
union
|
{
|
{
|
PTRACE_TYPE_RET word;
|
PTRACE_TYPE_RET word;
|
gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
|
gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
|
} buffer;
|
} buffer;
|
ULONGEST rounded_offset;
|
ULONGEST rounded_offset;
|
LONGEST partial_len;
|
LONGEST partial_len;
|
|
|
/* Round the start offset down to the next long word
|
/* Round the start offset down to the next long word
|
boundary. */
|
boundary. */
|
rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
|
rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
|
|
|
/* Since ptrace will transfer a single word starting at that
|
/* Since ptrace will transfer a single word starting at that
|
rounded_offset the partial_len needs to be adjusted down to
|
rounded_offset the partial_len needs to be adjusted down to
|
that (remember this function only does a single transfer).
|
that (remember this function only does a single transfer).
|
Should the required length be even less, adjust it down
|
Should the required length be even less, adjust it down
|
again. */
|
again. */
|
partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
|
partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
|
if (partial_len > len)
|
if (partial_len > len)
|
partial_len = len;
|
partial_len = len;
|
|
|
if (writebuf)
|
if (writebuf)
|
{
|
{
|
/* If OFFSET:PARTIAL_LEN is smaller than
|
/* If OFFSET:PARTIAL_LEN is smaller than
|
ROUNDED_OFFSET:WORDSIZE then a read/modify write will
|
ROUNDED_OFFSET:WORDSIZE then a read/modify write will
|
be needed. Read in the entire word. */
|
be needed. Read in the entire word. */
|
if (rounded_offset < offset
|
if (rounded_offset < offset
|
|| (offset + partial_len
|
|| (offset + partial_len
|
< rounded_offset + sizeof (PTRACE_TYPE_RET)))
|
< rounded_offset + sizeof (PTRACE_TYPE_RET)))
|
/* Need part of initial word -- fetch it. */
|
/* Need part of initial word -- fetch it. */
|
buffer.word = ptrace (PT_READ_I, pid,
|
buffer.word = ptrace (PT_READ_I, pid,
|
(PTRACE_TYPE_ARG3)(uintptr_t)
|
(PTRACE_TYPE_ARG3)(uintptr_t)
|
rounded_offset, 0);
|
rounded_offset, 0);
|
|
|
/* Copy data to be written over corresponding part of
|
/* Copy data to be written over corresponding part of
|
buffer. */
|
buffer. */
|
memcpy (buffer.byte + (offset - rounded_offset),
|
memcpy (buffer.byte + (offset - rounded_offset),
|
writebuf, partial_len);
|
writebuf, partial_len);
|
|
|
errno = 0;
|
errno = 0;
|
ptrace (PT_WRITE_D, pid,
|
ptrace (PT_WRITE_D, pid,
|
(PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
|
(PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
|
buffer.word);
|
buffer.word);
|
if (errno)
|
if (errno)
|
{
|
{
|
/* Using the appropriate one (I or D) is necessary for
|
/* Using the appropriate one (I or D) is necessary for
|
Gould NP1, at least. */
|
Gould NP1, at least. */
|
errno = 0;
|
errno = 0;
|
ptrace (PT_WRITE_I, pid,
|
ptrace (PT_WRITE_I, pid,
|
(PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
|
(PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
|
buffer.word);
|
buffer.word);
|
if (errno)
|
if (errno)
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
if (readbuf)
|
if (readbuf)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
buffer.word = ptrace (PT_READ_I, pid,
|
buffer.word = ptrace (PT_READ_I, pid,
|
(PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
|
(PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
|
0);
|
0);
|
if (errno)
|
if (errno)
|
return 0;
|
return 0;
|
/* Copy appropriate bytes out of the buffer. */
|
/* Copy appropriate bytes out of the buffer. */
|
memcpy (readbuf, buffer.byte + (offset - rounded_offset),
|
memcpy (readbuf, buffer.byte + (offset - rounded_offset),
|
partial_len);
|
partial_len);
|
}
|
}
|
|
|
return partial_len;
|
return partial_len;
|
}
|
}
|
|
|
case TARGET_OBJECT_UNWIND_TABLE:
|
case TARGET_OBJECT_UNWIND_TABLE:
|
return -1;
|
return -1;
|
|
|
case TARGET_OBJECT_AUXV:
|
case TARGET_OBJECT_AUXV:
|
return -1;
|
return -1;
|
|
|
case TARGET_OBJECT_WCOOKIE:
|
case TARGET_OBJECT_WCOOKIE:
|
return -1;
|
return -1;
|
|
|
default:
|
default:
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
|
|
/* Return non-zero if the thread specified by PTID is alive. */
|
/* Return non-zero if the thread specified by PTID is alive. */
|
|
|
static int
|
static int
|
inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
|
inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
|
{
|
{
|
/* ??? Is kill the right way to do this? */
|
/* ??? Is kill the right way to do this? */
|
return (kill (ptid_get_pid (ptid), 0) != -1);
|
return (kill (ptid_get_pid (ptid), 0) != -1);
|
}
|
}
|
|
|
/* Print status information about what we're accessing. */
|
/* Print status information about what we're accessing. */
|
|
|
static void
|
static void
|
inf_ptrace_files_info (struct target_ops *ignore)
|
inf_ptrace_files_info (struct target_ops *ignore)
|
{
|
{
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
|
|
printf_filtered (_("\tUsing the running image of %s %s.\n"),
|
printf_filtered (_("\tUsing the running image of %s %s.\n"),
|
inf->attach_flag ? "attached" : "child",
|
inf->attach_flag ? "attached" : "child",
|
target_pid_to_str (inferior_ptid));
|
target_pid_to_str (inferior_ptid));
|
}
|
}
|
|
|
static char *
|
static char *
|
inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
|
inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
|
{
|
{
|
return normal_pid_to_str (ptid);
|
return normal_pid_to_str (ptid);
|
}
|
}
|
|
|
/* Create a prototype ptrace target. The client can override it with
|
/* Create a prototype ptrace target. The client can override it with
|
local methods. */
|
local methods. */
|
|
|
struct target_ops *
|
struct target_ops *
|
inf_ptrace_target (void)
|
inf_ptrace_target (void)
|
{
|
{
|
struct target_ops *t = inf_child_target ();
|
struct target_ops *t = inf_child_target ();
|
|
|
t->to_attach = inf_ptrace_attach;
|
t->to_attach = inf_ptrace_attach;
|
t->to_detach = inf_ptrace_detach;
|
t->to_detach = inf_ptrace_detach;
|
t->to_resume = inf_ptrace_resume;
|
t->to_resume = inf_ptrace_resume;
|
t->to_wait = inf_ptrace_wait;
|
t->to_wait = inf_ptrace_wait;
|
t->to_files_info = inf_ptrace_files_info;
|
t->to_files_info = inf_ptrace_files_info;
|
t->to_kill = inf_ptrace_kill;
|
t->to_kill = inf_ptrace_kill;
|
t->to_create_inferior = inf_ptrace_create_inferior;
|
t->to_create_inferior = inf_ptrace_create_inferior;
|
#ifdef PT_GET_PROCESS_STATE
|
#ifdef PT_GET_PROCESS_STATE
|
t->to_follow_fork = inf_ptrace_follow_fork;
|
t->to_follow_fork = inf_ptrace_follow_fork;
|
t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
|
t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
|
t->to_post_attach = inf_ptrace_post_attach;
|
t->to_post_attach = inf_ptrace_post_attach;
|
#endif
|
#endif
|
t->to_mourn_inferior = inf_ptrace_mourn_inferior;
|
t->to_mourn_inferior = inf_ptrace_mourn_inferior;
|
t->to_thread_alive = inf_ptrace_thread_alive;
|
t->to_thread_alive = inf_ptrace_thread_alive;
|
t->to_pid_to_str = inf_ptrace_pid_to_str;
|
t->to_pid_to_str = inf_ptrace_pid_to_str;
|
t->to_stop = inf_ptrace_stop;
|
t->to_stop = inf_ptrace_stop;
|
t->to_xfer_partial = inf_ptrace_xfer_partial;
|
t->to_xfer_partial = inf_ptrace_xfer_partial;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
/* Pointer to a function that returns the offset within the user area
|
/* Pointer to a function that returns the offset within the user area
|
where a particular register is stored. */
|
where a particular register is stored. */
|
static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
|
static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
|
|
|
/* Fetch register REGNUM from the inferior. */
|
/* Fetch register REGNUM from the inferior. */
|
|
|
static void
|
static void
|
inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
|
inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
|
{
|
{
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
size_t size;
|
size_t size;
|
PTRACE_TYPE_RET *buf;
|
PTRACE_TYPE_RET *buf;
|
int pid, i;
|
int pid, i;
|
|
|
/* This isn't really an address, but ptrace thinks of it as one. */
|
/* This isn't really an address, but ptrace thinks of it as one. */
|
addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
|
addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
|
if (addr == (CORE_ADDR)-1
|
if (addr == (CORE_ADDR)-1
|
|| gdbarch_cannot_fetch_register (gdbarch, regnum))
|
|| gdbarch_cannot_fetch_register (gdbarch, regnum))
|
{
|
{
|
regcache_raw_supply (regcache, regnum, NULL);
|
regcache_raw_supply (regcache, regnum, NULL);
|
return;
|
return;
|
}
|
}
|
|
|
/* Cater for systems like GNU/Linux, that implement threads as
|
/* Cater for systems like GNU/Linux, that implement threads as
|
separate processes. */
|
separate processes. */
|
pid = ptid_get_lwp (inferior_ptid);
|
pid = ptid_get_lwp (inferior_ptid);
|
if (pid == 0)
|
if (pid == 0)
|
pid = ptid_get_pid (inferior_ptid);
|
pid = ptid_get_pid (inferior_ptid);
|
|
|
size = register_size (gdbarch, regnum);
|
size = register_size (gdbarch, regnum);
|
gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
|
gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
|
buf = alloca (size);
|
buf = alloca (size);
|
|
|
/* Read the register contents from the inferior a chunk at a time. */
|
/* Read the register contents from the inferior a chunk at a time. */
|
for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
|
for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
|
buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
|
if (errno != 0)
|
if (errno != 0)
|
error (_("Couldn't read register %s (#%d): %s."),
|
error (_("Couldn't read register %s (#%d): %s."),
|
gdbarch_register_name (gdbarch, regnum),
|
gdbarch_register_name (gdbarch, regnum),
|
regnum, safe_strerror (errno));
|
regnum, safe_strerror (errno));
|
|
|
addr += sizeof (PTRACE_TYPE_RET);
|
addr += sizeof (PTRACE_TYPE_RET);
|
}
|
}
|
regcache_raw_supply (regcache, regnum, buf);
|
regcache_raw_supply (regcache, regnum, buf);
|
}
|
}
|
|
|
/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
|
/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
|
for all registers. */
|
for all registers. */
|
|
|
static void
|
static void
|
inf_ptrace_fetch_registers (struct target_ops *ops,
|
inf_ptrace_fetch_registers (struct target_ops *ops,
|
struct regcache *regcache, int regnum)
|
struct regcache *regcache, int regnum)
|
{
|
{
|
if (regnum == -1)
|
if (regnum == -1)
|
for (regnum = 0;
|
for (regnum = 0;
|
regnum < gdbarch_num_regs (get_regcache_arch (regcache));
|
regnum < gdbarch_num_regs (get_regcache_arch (regcache));
|
regnum++)
|
regnum++)
|
inf_ptrace_fetch_register (regcache, regnum);
|
inf_ptrace_fetch_register (regcache, regnum);
|
else
|
else
|
inf_ptrace_fetch_register (regcache, regnum);
|
inf_ptrace_fetch_register (regcache, regnum);
|
}
|
}
|
|
|
/* Store register REGNUM into the inferior. */
|
/* Store register REGNUM into the inferior. */
|
|
|
static void
|
static void
|
inf_ptrace_store_register (const struct regcache *regcache, int regnum)
|
inf_ptrace_store_register (const struct regcache *regcache, int regnum)
|
{
|
{
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
size_t size;
|
size_t size;
|
PTRACE_TYPE_RET *buf;
|
PTRACE_TYPE_RET *buf;
|
int pid, i;
|
int pid, i;
|
|
|
/* This isn't really an address, but ptrace thinks of it as one. */
|
/* This isn't really an address, but ptrace thinks of it as one. */
|
addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
|
addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
|
if (addr == (CORE_ADDR)-1
|
if (addr == (CORE_ADDR)-1
|
|| gdbarch_cannot_store_register (gdbarch, regnum))
|
|| gdbarch_cannot_store_register (gdbarch, regnum))
|
return;
|
return;
|
|
|
/* Cater for systems like GNU/Linux, that implement threads as
|
/* Cater for systems like GNU/Linux, that implement threads as
|
separate processes. */
|
separate processes. */
|
pid = ptid_get_lwp (inferior_ptid);
|
pid = ptid_get_lwp (inferior_ptid);
|
if (pid == 0)
|
if (pid == 0)
|
pid = ptid_get_pid (inferior_ptid);
|
pid = ptid_get_pid (inferior_ptid);
|
|
|
size = register_size (gdbarch, regnum);
|
size = register_size (gdbarch, regnum);
|
gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
|
gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
|
buf = alloca (size);
|
buf = alloca (size);
|
|
|
/* Write the register contents into the inferior a chunk at a time. */
|
/* Write the register contents into the inferior a chunk at a time. */
|
regcache_raw_collect (regcache, regnum, buf);
|
regcache_raw_collect (regcache, regnum, buf);
|
for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
|
for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
|
ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
|
if (errno != 0)
|
if (errno != 0)
|
error (_("Couldn't write register %s (#%d): %s."),
|
error (_("Couldn't write register %s (#%d): %s."),
|
gdbarch_register_name (gdbarch, regnum),
|
gdbarch_register_name (gdbarch, regnum),
|
regnum, safe_strerror (errno));
|
regnum, safe_strerror (errno));
|
|
|
addr += sizeof (PTRACE_TYPE_RET);
|
addr += sizeof (PTRACE_TYPE_RET);
|
}
|
}
|
}
|
}
|
|
|
/* Store register REGNUM back into the inferior. If REGNUM is -1, do
|
/* Store register REGNUM back into the inferior. If REGNUM is -1, do
|
this for all registers. */
|
this for all registers. */
|
|
|
static void
|
static void
|
inf_ptrace_store_registers (struct target_ops *ops,
|
inf_ptrace_store_registers (struct target_ops *ops,
|
struct regcache *regcache, int regnum)
|
struct regcache *regcache, int regnum)
|
{
|
{
|
if (regnum == -1)
|
if (regnum == -1)
|
for (regnum = 0;
|
for (regnum = 0;
|
regnum < gdbarch_num_regs (get_regcache_arch (regcache));
|
regnum < gdbarch_num_regs (get_regcache_arch (regcache));
|
regnum++)
|
regnum++)
|
inf_ptrace_store_register (regcache, regnum);
|
inf_ptrace_store_register (regcache, regnum);
|
else
|
else
|
inf_ptrace_store_register (regcache, regnum);
|
inf_ptrace_store_register (regcache, regnum);
|
}
|
}
|
|
|
/* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
|
/* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
|
a function returning the offset within the user area where a
|
a function returning the offset within the user area where a
|
particular register is stored. */
|
particular register is stored. */
|
|
|
struct target_ops *
|
struct target_ops *
|
inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
|
inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
|
(struct gdbarch *, int, int))
|
(struct gdbarch *, int, int))
|
{
|
{
|
struct target_ops *t = inf_ptrace_target();
|
struct target_ops *t = inf_ptrace_target();
|
|
|
gdb_assert (register_u_offset);
|
gdb_assert (register_u_offset);
|
inf_ptrace_register_u_offset = register_u_offset;
|
inf_ptrace_register_u_offset = register_u_offset;
|
t->to_fetch_registers = inf_ptrace_fetch_registers;
|
t->to_fetch_registers = inf_ptrace_fetch_registers;
|
t->to_store_registers = inf_ptrace_store_registers;
|
t->to_store_registers = inf_ptrace_store_registers;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
