binutils-gdb/gdb/linux-nat.c

521 lines
14 KiB
C
Raw Normal View History

/* GNU/Linux native-dependent code common to multiple platforms.
Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "inferior.h"
#include "target.h"
#include "gdb_wait.h"
#include <sys/ptrace.h>
#include "linux-nat.h"
/* If the system headers did not provide the constants, hard-code the normal
values. */
#ifndef PTRACE_EVENT_FORK
#define PTRACE_SETOPTIONS 0x4200
#define PTRACE_GETEVENTMSG 0x4201
/* options set using PTRACE_SETOPTIONS */
#define PTRACE_O_TRACESYSGOOD 0x00000001
#define PTRACE_O_TRACEFORK 0x00000002
#define PTRACE_O_TRACEVFORK 0x00000004
#define PTRACE_O_TRACECLONE 0x00000008
#define PTRACE_O_TRACEEXEC 0x00000010
#define PTRACE_O_TRACEVFORKDONE 0x00000020
#define PTRACE_O_TRACEEXIT 0x00000040
/* Wait extended result codes for the above trace options. */
#define PTRACE_EVENT_FORK 1
#define PTRACE_EVENT_VFORK 2
#define PTRACE_EVENT_CLONE 3
#define PTRACE_EVENT_EXEC 4
#define PTRACE_EVENT_VFORKDONE 5
#define PTRACE_EVENT_EXIT 6
#endif /* PTRACE_EVENT_FORK */
/* We can't always assume that this flag is available, but all systems
with the ptrace event handlers also have __WALL, so it's safe to use
here. */
#ifndef __WALL
#define __WALL 0x40000000 /* Wait for any child. */
#endif
extern struct target_ops child_ops;
static int linux_parent_pid;
struct simple_pid_list
{
int pid;
struct simple_pid_list *next;
};
struct simple_pid_list *stopped_pids;
/* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
can not be used, 1 if it can. */
static int linux_supports_tracefork_flag = -1;
/* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
PTRACE_O_TRACEVFORKDONE. */
static int linux_supports_tracevforkdone_flag = -1;
/* Trivial list manipulation functions to keep track of a list of
new stopped processes. */
static void
add_to_pid_list (struct simple_pid_list **listp, int pid)
{
struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
new_pid->pid = pid;
new_pid->next = *listp;
*listp = new_pid;
}
static int
pull_pid_from_list (struct simple_pid_list **listp, int pid)
{
struct simple_pid_list **p;
for (p = listp; *p != NULL; p = &(*p)->next)
if ((*p)->pid == pid)
{
struct simple_pid_list *next = (*p)->next;
xfree (*p);
*p = next;
return 1;
}
return 0;
}
void
linux_record_stopped_pid (int pid)
{
add_to_pid_list (&stopped_pids, pid);
}
/* A helper function for linux_test_for_tracefork, called after fork (). */
static void
linux_tracefork_child (void)
{
int ret;
ptrace (PTRACE_TRACEME, 0, 0, 0);
kill (getpid (), SIGSTOP);
fork ();
exit (0);
}
/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. We
create a child process, attach to it, use PTRACE_SETOPTIONS to enable
fork tracing, and let it fork. If the process exits, we assume that
we can't use TRACEFORK; if we get the fork notification, and we can
extract the new child's PID, then we assume that we can. */
static void
linux_test_for_tracefork (void)
{
int child_pid, ret, status;
long second_pid;
child_pid = fork ();
if (child_pid == -1)
perror_with_name ("linux_test_for_tracefork: fork");
if (child_pid == 0)
linux_tracefork_child ();
ret = waitpid (child_pid, &status, 0);
if (ret == -1)
perror_with_name ("linux_test_for_tracefork: waitpid");
else if (ret != child_pid)
error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
if (! WIFSTOPPED (status))
error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
linux_supports_tracefork_flag = 0;
ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
if (ret != 0)
{
ptrace (PTRACE_KILL, child_pid, 0, 0);
waitpid (child_pid, &status, 0);
return;
}
/* Check whether PTRACE_O_TRACEVFORKDONE is available. */
ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
linux_supports_tracevforkdone_flag = (ret == 0);
ptrace (PTRACE_CONT, child_pid, 0, 0);
ret = waitpid (child_pid, &status, 0);
if (ret == child_pid && WIFSTOPPED (status)
&& status >> 16 == PTRACE_EVENT_FORK)
{
second_pid = 0;
ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
if (ret == 0 && second_pid != 0)
{
int second_status;
linux_supports_tracefork_flag = 1;
waitpid (second_pid, &second_status, 0);
ptrace (PTRACE_DETACH, second_pid, 0, 0);
}
}
if (WIFSTOPPED (status))
{
ptrace (PTRACE_DETACH, child_pid, 0, 0);
waitpid (child_pid, &status, 0);
}
}
/* Return non-zero iff we have tracefork functionality available.
This function also sets linux_supports_tracefork_flag. */
static int
linux_supports_tracefork (void)
{
if (linux_supports_tracefork_flag == -1)
linux_test_for_tracefork ();
return linux_supports_tracefork_flag;
}
static int
linux_supports_tracevforkdone (void)
{
if (linux_supports_tracefork_flag == -1)
linux_test_for_tracefork ();
return linux_supports_tracevforkdone_flag;
}
void
linux_enable_event_reporting (ptid_t ptid)
{
int pid = ptid_get_pid (ptid);
int options;
if (! linux_supports_tracefork ())
return;
options = PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK | PTRACE_O_TRACEEXEC;
if (linux_supports_tracevforkdone ())
options |= PTRACE_O_TRACEVFORKDONE;
/* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
read-only process state. */
ptrace (PTRACE_SETOPTIONS, pid, 0, options);
}
void
child_post_attach (int pid)
{
linux_enable_event_reporting (pid_to_ptid (pid));
}
void
linux_child_post_startup_inferior (ptid_t ptid)
{
linux_enable_event_reporting (ptid);
}
#ifndef LINUX_CHILD_POST_STARTUP_INFERIOR
void
child_post_startup_inferior (ptid_t ptid)
{
linux_child_post_startup_inferior (ptid);
}
#endif
int
child_follow_fork (int follow_child)
{
ptid_t last_ptid;
struct target_waitstatus last_status;
int has_vforked;
int parent_pid, child_pid;
get_last_target_status (&last_ptid, &last_status);
has_vforked = (last_status.kind == TARGET_WAITKIND_VFORKED);
parent_pid = ptid_get_pid (last_ptid);
child_pid = last_status.value.related_pid;
if (! follow_child)
{
/* We're already attached to the parent, by default. */
/* Before detaching from the child, remove all breakpoints from
it. (This won't actually modify the breakpoint list, but will
physically remove the breakpoints from the child.) */
/* If we vforked this will remove the breakpoints from the parent
also, but they'll be reinserted below. */
detach_breakpoints (child_pid);
fprintf_filtered (gdb_stdout,
"Detaching after fork from child process %d.\n",
child_pid);
ptrace (PTRACE_DETACH, child_pid, 0, 0);
if (has_vforked)
{
if (linux_supports_tracevforkdone ())
{
int status;
ptrace (PTRACE_CONT, parent_pid, 0, 0);
waitpid (parent_pid, &status, __WALL);
if ((status >> 16) != PTRACE_EVENT_VFORKDONE)
warning ("Unexpected waitpid result %06x when waiting for "
"vfork-done", status);
}
else
{
/* We can't insert breakpoints until the child has
finished with the shared memory region. We need to
wait until that happens. Ideal would be to just
call:
- ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
- waitpid (parent_pid, &status, __WALL);
However, most architectures can't handle a syscall
being traced on the way out if it wasn't traced on
the way in.
We might also think to loop, continuing the child
until it exits or gets a SIGTRAP. One problem is
that the child might call ptrace with PTRACE_TRACEME.
There's no simple and reliable way to figure out when
the vforked child will be done with its copy of the
shared memory. We could step it out of the syscall,
two instructions, let it go, and then single-step the
parent once. When we have hardware single-step, this
would work; with software single-step it could still
be made to work but we'd have to be able to insert
single-step breakpoints in the child, and we'd have
to insert -just- the single-step breakpoint in the
parent. Very awkward.
In the end, the best we can do is to make sure it
runs for a little while. Hopefully it will be out of
range of any breakpoints we reinsert. Usually this
is only the single-step breakpoint at vfork's return
point. */
usleep (10000);
}
/* Since we vforked, breakpoints were removed in the parent
too. Put them back. */
reattach_breakpoints (parent_pid);
}
}
else
{
char child_pid_spelling[40];
/* Needed to keep the breakpoint lists in sync. */
if (! has_vforked)
detach_breakpoints (child_pid);
/* Before detaching from the parent, remove all breakpoints from it. */
remove_breakpoints ();
fprintf_filtered (gdb_stdout,
"Attaching after fork to child process %d.\n",
child_pid);
/* If we're vforking, we may want to hold on to the parent until
the child exits or execs. At exec time we can remove the old
breakpoints from the parent and detach it; at exit time we
could do the same (or even, sneakily, resume debugging it - the
child's exec has failed, or something similar).
This doesn't clean up "properly", because we can't call
target_detach, but that's OK; if the current target is "child",
then it doesn't need any further cleanups, and lin_lwp will
generally not encounter vfork (vfork is defined to fork
in libpthread.so).
The holding part is very easy if we have VFORKDONE events;
but keeping track of both processes is beyond GDB at the
moment. So we don't expose the parent to the rest of GDB.
Instead we quietly hold onto it until such time as we can
safely resume it. */
if (has_vforked)
linux_parent_pid = parent_pid;
else
target_detach (NULL, 0);
inferior_ptid = pid_to_ptid (child_pid);
push_target (&child_ops);
/* Reset breakpoints in the child as appropriate. */
follow_inferior_reset_breakpoints ();
}
return 0;
}
ptid_t
linux_handle_extended_wait (int pid, int status,
struct target_waitstatus *ourstatus)
{
int event = status >> 16;
if (event == PTRACE_EVENT_CLONE)
internal_error (__FILE__, __LINE__,
"unexpected clone event");
if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
{
unsigned long new_pid;
int ret;
ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
/* If we haven't already seen the new PID stop, wait for it now. */
if (! pull_pid_from_list (&stopped_pids, new_pid))
{
/* The new child has a pending SIGSTOP. We can't affect it until it
hits the SIGSTOP, but we're already attached.
It won't be a clone (we didn't ask for clones in the event mask)
so we can just call waitpid and wait for the SIGSTOP. */
do {
ret = waitpid (new_pid, &status, 0);
} while (ret == -1 && errno == EINTR);
if (ret == -1)
perror_with_name ("waiting for new child");
else if (ret != new_pid)
internal_error (__FILE__, __LINE__,
"wait returned unexpected PID %d", ret);
else if (!WIFSTOPPED (status) || WSTOPSIG (status) != SIGSTOP)
internal_error (__FILE__, __LINE__,
"wait returned unexpected status 0x%x", status);
}
ourstatus->kind = (event == PTRACE_EVENT_FORK)
? TARGET_WAITKIND_FORKED : TARGET_WAITKIND_VFORKED;
ourstatus->value.related_pid = new_pid;
return inferior_ptid;
}
if (event == PTRACE_EVENT_EXEC)
{
ourstatus->kind = TARGET_WAITKIND_EXECD;
ourstatus->value.execd_pathname
= xstrdup (child_pid_to_exec_file (pid));
if (linux_parent_pid)
{
detach_breakpoints (linux_parent_pid);
ptrace (PTRACE_DETACH, linux_parent_pid, 0, 0);
linux_parent_pid = 0;
}
return inferior_ptid;
}
internal_error (__FILE__, __LINE__,
"unknown ptrace event %d", event);
}
int
child_insert_fork_catchpoint (int pid)
{
if (! linux_supports_tracefork ())
error ("Your system does not support fork catchpoints.");
return 0;
}
int
child_insert_vfork_catchpoint (int pid)
{
if (!linux_supports_tracefork ())
error ("Your system does not support vfork catchpoints.");
return 0;
}
int
child_insert_exec_catchpoint (int pid)
{
if (!linux_supports_tracefork ())
error ("Your system does not support exec catchpoints.");
return 0;
}
void
kill_inferior (void)
{
int status;
int pid = PIDGET (inferior_ptid);
struct target_waitstatus last;
ptid_t last_ptid;
int ret;
if (pid == 0)
return;
/* If we're stopped while forking and we haven't followed yet, kill the
other task. We need to do this first because the parent will be
sleeping if this is a vfork. */
get_last_target_status (&last_ptid, &last);
if (last.kind == TARGET_WAITKIND_FORKED
|| last.kind == TARGET_WAITKIND_VFORKED)
{
ptrace (PT_KILL, last.value.related_pid);
ptrace_wait (null_ptid, &status);
}
/* Kill the current process. */
ptrace (PT_KILL, pid, (PTRACE_ARG3_TYPE) 0, 0);
ret = ptrace_wait (null_ptid, &status);
/* We might get a SIGCHLD instead of an exit status. This is
aggravated by the first kill above - a child has just died. */
while (ret == pid && WIFSTOPPED (status))
{
ptrace (PT_KILL, pid, (PTRACE_ARG3_TYPE) 0, 0);
ret = ptrace_wait (null_ptid, &status);
}
target_mourn_inferior ();
}