/* GNU/Linux native-dependent code common to multiple platforms.
|
/* GNU/Linux native-dependent code common to multiple platforms.
|
|
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Copyright (C) 2001, 2002, 2003, 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 "inferior.h"
|
#include "inferior.h"
|
#include "target.h"
|
#include "target.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include "gdb_wait.h"
|
#include "gdb_wait.h"
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#ifdef HAVE_TKILL_SYSCALL
|
#ifdef HAVE_TKILL_SYSCALL
|
#include <unistd.h>
|
#include <unistd.h>
|
#include <sys/syscall.h>
|
#include <sys/syscall.h>
|
#endif
|
#endif
|
#include <sys/ptrace.h>
|
#include <sys/ptrace.h>
|
#include "linux-nat.h"
|
#include "linux-nat.h"
|
#include "linux-fork.h"
|
#include "linux-fork.h"
|
#include "gdbthread.h"
|
#include "gdbthread.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "regcache.h"
|
#include "regcache.h"
|
#include "regset.h"
|
#include "regset.h"
|
#include "inf-ptrace.h"
|
#include "inf-ptrace.h"
|
#include "auxv.h"
|
#include "auxv.h"
|
#include <sys/param.h> /* for MAXPATHLEN */
|
#include <sys/param.h> /* for MAXPATHLEN */
|
#include <sys/procfs.h> /* for elf_gregset etc. */
|
#include <sys/procfs.h> /* for elf_gregset etc. */
|
#include "elf-bfd.h" /* for elfcore_write_* */
|
#include "elf-bfd.h" /* for elfcore_write_* */
|
#include "gregset.h" /* for gregset */
|
#include "gregset.h" /* for gregset */
|
#include "gdbcore.h" /* for get_exec_file */
|
#include "gdbcore.h" /* for get_exec_file */
|
#include <ctype.h> /* for isdigit */
|
#include <ctype.h> /* for isdigit */
|
#include "gdbthread.h" /* for struct thread_info etc. */
|
#include "gdbthread.h" /* for struct thread_info etc. */
|
#include "gdb_stat.h" /* for struct stat */
|
#include "gdb_stat.h" /* for struct stat */
|
#include <fcntl.h> /* for O_RDONLY */
|
#include <fcntl.h> /* for O_RDONLY */
|
#include "inf-loop.h"
|
#include "inf-loop.h"
|
#include "event-loop.h"
|
#include "event-loop.h"
|
#include "event-top.h"
|
#include "event-top.h"
|
#include <pwd.h>
|
#include <pwd.h>
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include "gdb_dirent.h"
|
#include "gdb_dirent.h"
|
#include "xml-support.h"
|
#include "xml-support.h"
|
#include "terminal.h"
|
#include "terminal.h"
|
#include <sys/vfs.h>
|
#include <sys/vfs.h>
|
#include "solib.h"
|
#include "solib.h"
|
|
|
#ifndef SPUFS_MAGIC
|
#ifndef SPUFS_MAGIC
|
#define SPUFS_MAGIC 0x23c9b64e
|
#define SPUFS_MAGIC 0x23c9b64e
|
#endif
|
#endif
|
|
|
#ifdef HAVE_PERSONALITY
|
#ifdef HAVE_PERSONALITY
|
# include <sys/personality.h>
|
# include <sys/personality.h>
|
# if !HAVE_DECL_ADDR_NO_RANDOMIZE
|
# if !HAVE_DECL_ADDR_NO_RANDOMIZE
|
# define ADDR_NO_RANDOMIZE 0x0040000
|
# define ADDR_NO_RANDOMIZE 0x0040000
|
# endif
|
# endif
|
#endif /* HAVE_PERSONALITY */
|
#endif /* HAVE_PERSONALITY */
|
|
|
/* This comment documents high-level logic of this file.
|
/* This comment documents high-level logic of this file.
|
|
|
Waiting for events in sync mode
|
Waiting for events in sync mode
|
===============================
|
===============================
|
|
|
When waiting for an event in a specific thread, we just use waitpid, passing
|
When waiting for an event in a specific thread, we just use waitpid, passing
|
the specific pid, and not passing WNOHANG.
|
the specific pid, and not passing WNOHANG.
|
|
|
When waiting for an event in all threads, waitpid is not quite good. Prior to
|
When waiting for an event in all threads, waitpid is not quite good. Prior to
|
version 2.4, Linux can either wait for event in main thread, or in secondary
|
version 2.4, Linux can either wait for event in main thread, or in secondary
|
threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
|
threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
|
miss an event. The solution is to use non-blocking waitpid, together with
|
miss an event. The solution is to use non-blocking waitpid, together with
|
sigsuspend. First, we use non-blocking waitpid to get an event in the main
|
sigsuspend. First, we use non-blocking waitpid to get an event in the main
|
process, if any. Second, we use non-blocking waitpid with the __WCLONED
|
process, if any. Second, we use non-blocking waitpid with the __WCLONED
|
flag to check for events in cloned processes. If nothing is found, we use
|
flag to check for events in cloned processes. If nothing is found, we use
|
sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
|
sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
|
happened to a child process -- and SIGCHLD will be delivered both for events
|
happened to a child process -- and SIGCHLD will be delivered both for events
|
in main debugged process and in cloned processes. As soon as we know there's
|
in main debugged process and in cloned processes. As soon as we know there's
|
an event, we get back to calling nonblocking waitpid with and without __WCLONED.
|
an event, we get back to calling nonblocking waitpid with and without __WCLONED.
|
|
|
Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
|
Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
|
so that we don't miss a signal. If SIGCHLD arrives in between, when it's
|
so that we don't miss a signal. If SIGCHLD arrives in between, when it's
|
blocked, the signal becomes pending and sigsuspend immediately
|
blocked, the signal becomes pending and sigsuspend immediately
|
notices it and returns.
|
notices it and returns.
|
|
|
Waiting for events in async mode
|
Waiting for events in async mode
|
================================
|
================================
|
|
|
In async mode, GDB should always be ready to handle both user input
|
In async mode, GDB should always be ready to handle both user input
|
and target events, so neither blocking waitpid nor sigsuspend are
|
and target events, so neither blocking waitpid nor sigsuspend are
|
viable options. Instead, we should asynchronously notify the GDB main
|
viable options. Instead, we should asynchronously notify the GDB main
|
event loop whenever there's an unprocessed event from the target. We
|
event loop whenever there's an unprocessed event from the target. We
|
detect asynchronous target events by handling SIGCHLD signals. To
|
detect asynchronous target events by handling SIGCHLD signals. To
|
notify the event loop about target events, the self-pipe trick is used
|
notify the event loop about target events, the self-pipe trick is used
|
--- a pipe is registered as waitable event source in the event loop,
|
--- a pipe is registered as waitable event source in the event loop,
|
the event loop select/poll's on the read end of this pipe (as well on
|
the event loop select/poll's on the read end of this pipe (as well on
|
other event sources, e.g., stdin), and the SIGCHLD handler writes a
|
other event sources, e.g., stdin), and the SIGCHLD handler writes a
|
byte to this pipe. This is more portable than relying on
|
byte to this pipe. This is more portable than relying on
|
pselect/ppoll, since on kernels that lack those syscalls, libc
|
pselect/ppoll, since on kernels that lack those syscalls, libc
|
emulates them with select/poll+sigprocmask, and that is racy
|
emulates them with select/poll+sigprocmask, and that is racy
|
(a.k.a. plain broken).
|
(a.k.a. plain broken).
|
|
|
Obviously, if we fail to notify the event loop if there's a target
|
Obviously, if we fail to notify the event loop if there's a target
|
event, it's bad. OTOH, if we notify the event loop when there's no
|
event, it's bad. OTOH, if we notify the event loop when there's no
|
event from the target, linux_nat_wait will detect that there's no real
|
event from the target, linux_nat_wait will detect that there's no real
|
event to report, and return event of type TARGET_WAITKIND_IGNORE.
|
event to report, and return event of type TARGET_WAITKIND_IGNORE.
|
This is mostly harmless, but it will waste time and is better avoided.
|
This is mostly harmless, but it will waste time and is better avoided.
|
|
|
The main design point is that every time GDB is outside linux-nat.c,
|
The main design point is that every time GDB is outside linux-nat.c,
|
we have a SIGCHLD handler installed that is called when something
|
we have a SIGCHLD handler installed that is called when something
|
happens to the target and notifies the GDB event loop. Whenever GDB
|
happens to the target and notifies the GDB event loop. Whenever GDB
|
core decides to handle the event, and calls into linux-nat.c, we
|
core decides to handle the event, and calls into linux-nat.c, we
|
process things as in sync mode, except that the we never block in
|
process things as in sync mode, except that the we never block in
|
sigsuspend.
|
sigsuspend.
|
|
|
While processing an event, we may end up momentarily blocked in
|
While processing an event, we may end up momentarily blocked in
|
waitpid calls. Those waitpid calls, while blocking, are guarantied to
|
waitpid calls. Those waitpid calls, while blocking, are guarantied to
|
return quickly. E.g., in all-stop mode, before reporting to the core
|
return quickly. E.g., in all-stop mode, before reporting to the core
|
that an LWP hit a breakpoint, all LWPs are stopped by sending them
|
that an LWP hit a breakpoint, all LWPs are stopped by sending them
|
SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
|
SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
|
Note that this is different from blocking indefinitely waiting for the
|
Note that this is different from blocking indefinitely waiting for the
|
next event --- here, we're already handling an event.
|
next event --- here, we're already handling an event.
|
|
|
Use of signals
|
Use of signals
|
==============
|
==============
|
|
|
We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
|
We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
|
signal is not entirely significant; we just need for a signal to be delivered,
|
signal is not entirely significant; we just need for a signal to be delivered,
|
so that we can intercept it. SIGSTOP's advantage is that it can not be
|
so that we can intercept it. SIGSTOP's advantage is that it can not be
|
blocked. A disadvantage is that it is not a real-time signal, so it can only
|
blocked. A disadvantage is that it is not a real-time signal, so it can only
|
be queued once; we do not keep track of other sources of SIGSTOP.
|
be queued once; we do not keep track of other sources of SIGSTOP.
|
|
|
Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
|
Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
|
use them, because they have special behavior when the signal is generated -
|
use them, because they have special behavior when the signal is generated -
|
not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
|
not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
|
kills the entire thread group.
|
kills the entire thread group.
|
|
|
A delivered SIGSTOP would stop the entire thread group, not just the thread we
|
A delivered SIGSTOP would stop the entire thread group, not just the thread we
|
tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
|
tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
|
cancel it (by PTRACE_CONT without passing SIGSTOP).
|
cancel it (by PTRACE_CONT without passing SIGSTOP).
|
|
|
We could use a real-time signal instead. This would solve those problems; we
|
We could use a real-time signal instead. This would solve those problems; we
|
could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
|
could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
|
But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
|
But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
|
generates it, and there are races with trying to find a signal that is not
|
generates it, and there are races with trying to find a signal that is not
|
blocked. */
|
blocked. */
|
|
|
#ifndef O_LARGEFILE
|
#ifndef O_LARGEFILE
|
#define O_LARGEFILE 0
|
#define O_LARGEFILE 0
|
#endif
|
#endif
|
|
|
/* If the system headers did not provide the constants, hard-code the normal
|
/* If the system headers did not provide the constants, hard-code the normal
|
values. */
|
values. */
|
#ifndef PTRACE_EVENT_FORK
|
#ifndef PTRACE_EVENT_FORK
|
|
|
#define PTRACE_SETOPTIONS 0x4200
|
#define PTRACE_SETOPTIONS 0x4200
|
#define PTRACE_GETEVENTMSG 0x4201
|
#define PTRACE_GETEVENTMSG 0x4201
|
|
|
/* options set using PTRACE_SETOPTIONS */
|
/* options set using PTRACE_SETOPTIONS */
|
#define PTRACE_O_TRACESYSGOOD 0x00000001
|
#define PTRACE_O_TRACESYSGOOD 0x00000001
|
#define PTRACE_O_TRACEFORK 0x00000002
|
#define PTRACE_O_TRACEFORK 0x00000002
|
#define PTRACE_O_TRACEVFORK 0x00000004
|
#define PTRACE_O_TRACEVFORK 0x00000004
|
#define PTRACE_O_TRACECLONE 0x00000008
|
#define PTRACE_O_TRACECLONE 0x00000008
|
#define PTRACE_O_TRACEEXEC 0x00000010
|
#define PTRACE_O_TRACEEXEC 0x00000010
|
#define PTRACE_O_TRACEVFORKDONE 0x00000020
|
#define PTRACE_O_TRACEVFORKDONE 0x00000020
|
#define PTRACE_O_TRACEEXIT 0x00000040
|
#define PTRACE_O_TRACEEXIT 0x00000040
|
|
|
/* Wait extended result codes for the above trace options. */
|
/* Wait extended result codes for the above trace options. */
|
#define PTRACE_EVENT_FORK 1
|
#define PTRACE_EVENT_FORK 1
|
#define PTRACE_EVENT_VFORK 2
|
#define PTRACE_EVENT_VFORK 2
|
#define PTRACE_EVENT_CLONE 3
|
#define PTRACE_EVENT_CLONE 3
|
#define PTRACE_EVENT_EXEC 4
|
#define PTRACE_EVENT_EXEC 4
|
#define PTRACE_EVENT_VFORK_DONE 5
|
#define PTRACE_EVENT_VFORK_DONE 5
|
#define PTRACE_EVENT_EXIT 6
|
#define PTRACE_EVENT_EXIT 6
|
|
|
#endif /* PTRACE_EVENT_FORK */
|
#endif /* PTRACE_EVENT_FORK */
|
|
|
/* Unlike other extended result codes, WSTOPSIG (status) on
|
/* Unlike other extended result codes, WSTOPSIG (status) on
|
PTRACE_O_TRACESYSGOOD syscall events doesn't return SIGTRAP, but
|
PTRACE_O_TRACESYSGOOD syscall events doesn't return SIGTRAP, but
|
instead SIGTRAP with bit 7 set. */
|
instead SIGTRAP with bit 7 set. */
|
#define SYSCALL_SIGTRAP (SIGTRAP | 0x80)
|
#define SYSCALL_SIGTRAP (SIGTRAP | 0x80)
|
|
|
/* We can't always assume that this flag is available, but all systems
|
/* 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
|
with the ptrace event handlers also have __WALL, so it's safe to use
|
here. */
|
here. */
|
#ifndef __WALL
|
#ifndef __WALL
|
#define __WALL 0x40000000 /* Wait for any child. */
|
#define __WALL 0x40000000 /* Wait for any child. */
|
#endif
|
#endif
|
|
|
#ifndef PTRACE_GETSIGINFO
|
#ifndef PTRACE_GETSIGINFO
|
# define PTRACE_GETSIGINFO 0x4202
|
# define PTRACE_GETSIGINFO 0x4202
|
# define PTRACE_SETSIGINFO 0x4203
|
# define PTRACE_SETSIGINFO 0x4203
|
#endif
|
#endif
|
|
|
/* The single-threaded native GNU/Linux target_ops. We save a pointer for
|
/* The single-threaded native GNU/Linux target_ops. We save a pointer for
|
the use of the multi-threaded target. */
|
the use of the multi-threaded target. */
|
static struct target_ops *linux_ops;
|
static struct target_ops *linux_ops;
|
static struct target_ops linux_ops_saved;
|
static struct target_ops linux_ops_saved;
|
|
|
/* The method to call, if any, when a new thread is attached. */
|
/* The method to call, if any, when a new thread is attached. */
|
static void (*linux_nat_new_thread) (ptid_t);
|
static void (*linux_nat_new_thread) (ptid_t);
|
|
|
/* The method to call, if any, when the siginfo object needs to be
|
/* The method to call, if any, when the siginfo object needs to be
|
converted between the layout returned by ptrace, and the layout in
|
converted between the layout returned by ptrace, and the layout in
|
the architecture of the inferior. */
|
the architecture of the inferior. */
|
static int (*linux_nat_siginfo_fixup) (struct siginfo *,
|
static int (*linux_nat_siginfo_fixup) (struct siginfo *,
|
gdb_byte *,
|
gdb_byte *,
|
int);
|
int);
|
|
|
/* The saved to_xfer_partial method, inherited from inf-ptrace.c.
|
/* The saved to_xfer_partial method, inherited from inf-ptrace.c.
|
Called by our to_xfer_partial. */
|
Called by our to_xfer_partial. */
|
static LONGEST (*super_xfer_partial) (struct target_ops *,
|
static LONGEST (*super_xfer_partial) (struct target_ops *,
|
enum target_object,
|
enum target_object,
|
const char *, gdb_byte *,
|
const char *, gdb_byte *,
|
const gdb_byte *,
|
const gdb_byte *,
|
ULONGEST, LONGEST);
|
ULONGEST, LONGEST);
|
|
|
static int debug_linux_nat;
|
static int debug_linux_nat;
|
static void
|
static void
|
show_debug_linux_nat (struct ui_file *file, int from_tty,
|
show_debug_linux_nat (struct ui_file *file, int from_tty,
|
struct cmd_list_element *c, const char *value)
|
struct cmd_list_element *c, const char *value)
|
{
|
{
|
fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
|
fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
|
value);
|
value);
|
}
|
}
|
|
|
static int debug_linux_nat_async = 0;
|
static int debug_linux_nat_async = 0;
|
static void
|
static void
|
show_debug_linux_nat_async (struct ui_file *file, int from_tty,
|
show_debug_linux_nat_async (struct ui_file *file, int from_tty,
|
struct cmd_list_element *c, const char *value)
|
struct cmd_list_element *c, const char *value)
|
{
|
{
|
fprintf_filtered (file, _("Debugging of GNU/Linux async lwp module is %s.\n"),
|
fprintf_filtered (file, _("Debugging of GNU/Linux async lwp module is %s.\n"),
|
value);
|
value);
|
}
|
}
|
|
|
static int disable_randomization = 1;
|
static int disable_randomization = 1;
|
|
|
static void
|
static void
|
show_disable_randomization (struct ui_file *file, int from_tty,
|
show_disable_randomization (struct ui_file *file, int from_tty,
|
struct cmd_list_element *c, const char *value)
|
struct cmd_list_element *c, const char *value)
|
{
|
{
|
#ifdef HAVE_PERSONALITY
|
#ifdef HAVE_PERSONALITY
|
fprintf_filtered (file, _("\
|
fprintf_filtered (file, _("\
|
Disabling randomization of debuggee's virtual address space is %s.\n"),
|
Disabling randomization of debuggee's virtual address space is %s.\n"),
|
value);
|
value);
|
#else /* !HAVE_PERSONALITY */
|
#else /* !HAVE_PERSONALITY */
|
fputs_filtered (_("\
|
fputs_filtered (_("\
|
Disabling randomization of debuggee's virtual address space is unsupported on\n\
|
Disabling randomization of debuggee's virtual address space is unsupported on\n\
|
this platform.\n"), file);
|
this platform.\n"), file);
|
#endif /* !HAVE_PERSONALITY */
|
#endif /* !HAVE_PERSONALITY */
|
}
|
}
|
|
|
static void
|
static void
|
set_disable_randomization (char *args, int from_tty, struct cmd_list_element *c)
|
set_disable_randomization (char *args, int from_tty, struct cmd_list_element *c)
|
{
|
{
|
#ifndef HAVE_PERSONALITY
|
#ifndef HAVE_PERSONALITY
|
error (_("\
|
error (_("\
|
Disabling randomization of debuggee's virtual address space is unsupported on\n\
|
Disabling randomization of debuggee's virtual address space is unsupported on\n\
|
this platform."));
|
this platform."));
|
#endif /* !HAVE_PERSONALITY */
|
#endif /* !HAVE_PERSONALITY */
|
}
|
}
|
|
|
static int linux_parent_pid;
|
static int linux_parent_pid;
|
|
|
struct simple_pid_list
|
struct simple_pid_list
|
{
|
{
|
int pid;
|
int pid;
|
int status;
|
int status;
|
struct simple_pid_list *next;
|
struct simple_pid_list *next;
|
};
|
};
|
struct simple_pid_list *stopped_pids;
|
struct simple_pid_list *stopped_pids;
|
|
|
/* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
|
/* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
|
can not be used, 1 if it can. */
|
can not be used, 1 if it can. */
|
|
|
static int linux_supports_tracefork_flag = -1;
|
static int linux_supports_tracefork_flag = -1;
|
|
|
/* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACESYSGOOD
|
/* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACESYSGOOD
|
can not be used, 1 if it can. */
|
can not be used, 1 if it can. */
|
|
|
static int linux_supports_tracesysgood_flag = -1;
|
static int linux_supports_tracesysgood_flag = -1;
|
|
|
/* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
|
/* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
|
PTRACE_O_TRACEVFORKDONE. */
|
PTRACE_O_TRACEVFORKDONE. */
|
|
|
static int linux_supports_tracevforkdone_flag = -1;
|
static int linux_supports_tracevforkdone_flag = -1;
|
|
|
/* Async mode support */
|
/* Async mode support */
|
|
|
/* Zero if the async mode, although enabled, is masked, which means
|
/* Zero if the async mode, although enabled, is masked, which means
|
linux_nat_wait should behave as if async mode was off. */
|
linux_nat_wait should behave as if async mode was off. */
|
static int linux_nat_async_mask_value = 1;
|
static int linux_nat_async_mask_value = 1;
|
|
|
/* Stores the current used ptrace() options. */
|
/* Stores the current used ptrace() options. */
|
static int current_ptrace_options = 0;
|
static int current_ptrace_options = 0;
|
|
|
/* The read/write ends of the pipe registered as waitable file in the
|
/* The read/write ends of the pipe registered as waitable file in the
|
event loop. */
|
event loop. */
|
static int linux_nat_event_pipe[2] = { -1, -1 };
|
static int linux_nat_event_pipe[2] = { -1, -1 };
|
|
|
/* Flush the event pipe. */
|
/* Flush the event pipe. */
|
|
|
static void
|
static void
|
async_file_flush (void)
|
async_file_flush (void)
|
{
|
{
|
int ret;
|
int ret;
|
char buf;
|
char buf;
|
|
|
do
|
do
|
{
|
{
|
ret = read (linux_nat_event_pipe[0], &buf, 1);
|
ret = read (linux_nat_event_pipe[0], &buf, 1);
|
}
|
}
|
while (ret >= 0 || (ret == -1 && errno == EINTR));
|
while (ret >= 0 || (ret == -1 && errno == EINTR));
|
}
|
}
|
|
|
/* Put something (anything, doesn't matter what, or how much) in event
|
/* Put something (anything, doesn't matter what, or how much) in event
|
pipe, so that the select/poll in the event-loop realizes we have
|
pipe, so that the select/poll in the event-loop realizes we have
|
something to process. */
|
something to process. */
|
|
|
static void
|
static void
|
async_file_mark (void)
|
async_file_mark (void)
|
{
|
{
|
int ret;
|
int ret;
|
|
|
/* It doesn't really matter what the pipe contains, as long we end
|
/* It doesn't really matter what the pipe contains, as long we end
|
up with something in it. Might as well flush the previous
|
up with something in it. Might as well flush the previous
|
left-overs. */
|
left-overs. */
|
async_file_flush ();
|
async_file_flush ();
|
|
|
do
|
do
|
{
|
{
|
ret = write (linux_nat_event_pipe[1], "+", 1);
|
ret = write (linux_nat_event_pipe[1], "+", 1);
|
}
|
}
|
while (ret == -1 && errno == EINTR);
|
while (ret == -1 && errno == EINTR);
|
|
|
/* Ignore EAGAIN. If the pipe is full, the event loop will already
|
/* Ignore EAGAIN. If the pipe is full, the event loop will already
|
be awakened anyway. */
|
be awakened anyway. */
|
}
|
}
|
|
|
static void linux_nat_async (void (*callback)
|
static void linux_nat_async (void (*callback)
|
(enum inferior_event_type event_type, void *context),
|
(enum inferior_event_type event_type, void *context),
|
void *context);
|
void *context);
|
static int linux_nat_async_mask (int mask);
|
static int linux_nat_async_mask (int mask);
|
static int kill_lwp (int lwpid, int signo);
|
static int kill_lwp (int lwpid, int signo);
|
|
|
static int stop_callback (struct lwp_info *lp, void *data);
|
static int stop_callback (struct lwp_info *lp, void *data);
|
|
|
static void block_child_signals (sigset_t *prev_mask);
|
static void block_child_signals (sigset_t *prev_mask);
|
static void restore_child_signals_mask (sigset_t *prev_mask);
|
static void restore_child_signals_mask (sigset_t *prev_mask);
|
|
|
struct lwp_info;
|
struct lwp_info;
|
static struct lwp_info *add_lwp (ptid_t ptid);
|
static struct lwp_info *add_lwp (ptid_t ptid);
|
static void purge_lwp_list (int pid);
|
static void purge_lwp_list (int pid);
|
static struct lwp_info *find_lwp_pid (ptid_t ptid);
|
static struct lwp_info *find_lwp_pid (ptid_t ptid);
|
|
|
|
|
/* Trivial list manipulation functions to keep track of a list of
|
/* Trivial list manipulation functions to keep track of a list of
|
new stopped processes. */
|
new stopped processes. */
|
static void
|
static void
|
add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
|
add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
|
{
|
{
|
struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
|
struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
|
new_pid->pid = pid;
|
new_pid->pid = pid;
|
new_pid->status = status;
|
new_pid->status = status;
|
new_pid->next = *listp;
|
new_pid->next = *listp;
|
*listp = new_pid;
|
*listp = new_pid;
|
}
|
}
|
|
|
static int
|
static int
|
pull_pid_from_list (struct simple_pid_list **listp, int pid, int *status)
|
pull_pid_from_list (struct simple_pid_list **listp, int pid, int *status)
|
{
|
{
|
struct simple_pid_list **p;
|
struct simple_pid_list **p;
|
|
|
for (p = listp; *p != NULL; p = &(*p)->next)
|
for (p = listp; *p != NULL; p = &(*p)->next)
|
if ((*p)->pid == pid)
|
if ((*p)->pid == pid)
|
{
|
{
|
struct simple_pid_list *next = (*p)->next;
|
struct simple_pid_list *next = (*p)->next;
|
*status = (*p)->status;
|
*status = (*p)->status;
|
xfree (*p);
|
xfree (*p);
|
*p = next;
|
*p = next;
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
linux_record_stopped_pid (int pid, int status)
|
linux_record_stopped_pid (int pid, int status)
|
{
|
{
|
add_to_pid_list (&stopped_pids, pid, status);
|
add_to_pid_list (&stopped_pids, pid, status);
|
}
|
}
|
|
|
|
|
/* A helper function for linux_test_for_tracefork, called after fork (). */
|
/* A helper function for linux_test_for_tracefork, called after fork (). */
|
|
|
static void
|
static void
|
linux_tracefork_child (void)
|
linux_tracefork_child (void)
|
{
|
{
|
int ret;
|
int ret;
|
|
|
ptrace (PTRACE_TRACEME, 0, 0, 0);
|
ptrace (PTRACE_TRACEME, 0, 0, 0);
|
kill (getpid (), SIGSTOP);
|
kill (getpid (), SIGSTOP);
|
fork ();
|
fork ();
|
_exit (0);
|
_exit (0);
|
}
|
}
|
|
|
/* Wrapper function for waitpid which handles EINTR. */
|
/* Wrapper function for waitpid which handles EINTR. */
|
|
|
static int
|
static int
|
my_waitpid (int pid, int *status, int flags)
|
my_waitpid (int pid, int *status, int flags)
|
{
|
{
|
int ret;
|
int ret;
|
|
|
do
|
do
|
{
|
{
|
ret = waitpid (pid, status, flags);
|
ret = waitpid (pid, status, flags);
|
}
|
}
|
while (ret == -1 && errno == EINTR);
|
while (ret == -1 && errno == EINTR);
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
|
/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
|
|
|
First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
|
First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
|
we know that the feature is not available. This may change the tracing
|
we know that the feature is not available. This may change the tracing
|
options for ORIGINAL_PID, but we'll be setting them shortly anyway.
|
options for ORIGINAL_PID, but we'll be setting them shortly anyway.
|
|
|
However, if it succeeds, we don't know for sure that the feature is
|
However, if it succeeds, we don't know for sure that the feature is
|
available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
|
available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
|
create a child process, attach to it, use PTRACE_SETOPTIONS to enable
|
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
|
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
|
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. */
|
the new child's PID, then we assume that we can. */
|
|
|
static void
|
static void
|
linux_test_for_tracefork (int original_pid)
|
linux_test_for_tracefork (int original_pid)
|
{
|
{
|
int child_pid, ret, status;
|
int child_pid, ret, status;
|
long second_pid;
|
long second_pid;
|
sigset_t prev_mask;
|
sigset_t prev_mask;
|
|
|
/* We don't want those ptrace calls to be interrupted. */
|
/* We don't want those ptrace calls to be interrupted. */
|
block_child_signals (&prev_mask);
|
block_child_signals (&prev_mask);
|
|
|
linux_supports_tracefork_flag = 0;
|
linux_supports_tracefork_flag = 0;
|
linux_supports_tracevforkdone_flag = 0;
|
linux_supports_tracevforkdone_flag = 0;
|
|
|
ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
|
ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
|
if (ret != 0)
|
if (ret != 0)
|
{
|
{
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return;
|
return;
|
}
|
}
|
|
|
child_pid = fork ();
|
child_pid = fork ();
|
if (child_pid == -1)
|
if (child_pid == -1)
|
perror_with_name (("fork"));
|
perror_with_name (("fork"));
|
|
|
if (child_pid == 0)
|
if (child_pid == 0)
|
linux_tracefork_child ();
|
linux_tracefork_child ();
|
|
|
ret = my_waitpid (child_pid, &status, 0);
|
ret = my_waitpid (child_pid, &status, 0);
|
if (ret == -1)
|
if (ret == -1)
|
perror_with_name (("waitpid"));
|
perror_with_name (("waitpid"));
|
else if (ret != child_pid)
|
else if (ret != child_pid)
|
error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
|
error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
|
if (! WIFSTOPPED (status))
|
if (! WIFSTOPPED (status))
|
error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status);
|
error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status);
|
|
|
ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
|
ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
|
if (ret != 0)
|
if (ret != 0)
|
{
|
{
|
ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
|
ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
|
if (ret != 0)
|
if (ret != 0)
|
{
|
{
|
warning (_("linux_test_for_tracefork: failed to kill child"));
|
warning (_("linux_test_for_tracefork: failed to kill child"));
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return;
|
return;
|
}
|
}
|
|
|
ret = my_waitpid (child_pid, &status, 0);
|
ret = my_waitpid (child_pid, &status, 0);
|
if (ret != child_pid)
|
if (ret != child_pid)
|
warning (_("linux_test_for_tracefork: failed to wait for killed child"));
|
warning (_("linux_test_for_tracefork: failed to wait for killed child"));
|
else if (!WIFSIGNALED (status))
|
else if (!WIFSIGNALED (status))
|
warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
|
warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
|
"killed child"), status);
|
"killed child"), status);
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return;
|
return;
|
}
|
}
|
|
|
/* Check whether PTRACE_O_TRACEVFORKDONE is available. */
|
/* Check whether PTRACE_O_TRACEVFORKDONE is available. */
|
ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
|
ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
|
PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
|
PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
|
linux_supports_tracevforkdone_flag = (ret == 0);
|
linux_supports_tracevforkdone_flag = (ret == 0);
|
|
|
ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
|
ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
|
if (ret != 0)
|
if (ret != 0)
|
warning (_("linux_test_for_tracefork: failed to resume child"));
|
warning (_("linux_test_for_tracefork: failed to resume child"));
|
|
|
ret = my_waitpid (child_pid, &status, 0);
|
ret = my_waitpid (child_pid, &status, 0);
|
|
|
if (ret == child_pid && WIFSTOPPED (status)
|
if (ret == child_pid && WIFSTOPPED (status)
|
&& status >> 16 == PTRACE_EVENT_FORK)
|
&& status >> 16 == PTRACE_EVENT_FORK)
|
{
|
{
|
second_pid = 0;
|
second_pid = 0;
|
ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
|
ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
|
if (ret == 0 && second_pid != 0)
|
if (ret == 0 && second_pid != 0)
|
{
|
{
|
int second_status;
|
int second_status;
|
|
|
linux_supports_tracefork_flag = 1;
|
linux_supports_tracefork_flag = 1;
|
my_waitpid (second_pid, &second_status, 0);
|
my_waitpid (second_pid, &second_status, 0);
|
ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
|
ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
|
if (ret != 0)
|
if (ret != 0)
|
warning (_("linux_test_for_tracefork: failed to kill second child"));
|
warning (_("linux_test_for_tracefork: failed to kill second child"));
|
my_waitpid (second_pid, &status, 0);
|
my_waitpid (second_pid, &status, 0);
|
}
|
}
|
}
|
}
|
else
|
else
|
warning (_("linux_test_for_tracefork: unexpected result from waitpid "
|
warning (_("linux_test_for_tracefork: unexpected result from waitpid "
|
"(%d, status 0x%x)"), ret, status);
|
"(%d, status 0x%x)"), ret, status);
|
|
|
ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
|
ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
|
if (ret != 0)
|
if (ret != 0)
|
warning (_("linux_test_for_tracefork: failed to kill child"));
|
warning (_("linux_test_for_tracefork: failed to kill child"));
|
my_waitpid (child_pid, &status, 0);
|
my_waitpid (child_pid, &status, 0);
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
}
|
}
|
|
|
/* Determine if PTRACE_O_TRACESYSGOOD can be used to follow syscalls.
|
/* Determine if PTRACE_O_TRACESYSGOOD can be used to follow syscalls.
|
|
|
We try to enable syscall tracing on ORIGINAL_PID. If this fails,
|
We try to enable syscall tracing on ORIGINAL_PID. If this fails,
|
we know that the feature is not available. This may change the tracing
|
we know that the feature is not available. This may change the tracing
|
options for ORIGINAL_PID, but we'll be setting them shortly anyway. */
|
options for ORIGINAL_PID, but we'll be setting them shortly anyway. */
|
|
|
static void
|
static void
|
linux_test_for_tracesysgood (int original_pid)
|
linux_test_for_tracesysgood (int original_pid)
|
{
|
{
|
int ret;
|
int ret;
|
sigset_t prev_mask;
|
sigset_t prev_mask;
|
|
|
/* We don't want those ptrace calls to be interrupted. */
|
/* We don't want those ptrace calls to be interrupted. */
|
block_child_signals (&prev_mask);
|
block_child_signals (&prev_mask);
|
|
|
linux_supports_tracesysgood_flag = 0;
|
linux_supports_tracesysgood_flag = 0;
|
|
|
ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACESYSGOOD);
|
ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACESYSGOOD);
|
if (ret != 0)
|
if (ret != 0)
|
goto out;
|
goto out;
|
|
|
linux_supports_tracesysgood_flag = 1;
|
linux_supports_tracesysgood_flag = 1;
|
out:
|
out:
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
}
|
}
|
|
|
/* Determine wether we support PTRACE_O_TRACESYSGOOD option available.
|
/* Determine wether we support PTRACE_O_TRACESYSGOOD option available.
|
This function also sets linux_supports_tracesysgood_flag. */
|
This function also sets linux_supports_tracesysgood_flag. */
|
|
|
static int
|
static int
|
linux_supports_tracesysgood (int pid)
|
linux_supports_tracesysgood (int pid)
|
{
|
{
|
if (linux_supports_tracesysgood_flag == -1)
|
if (linux_supports_tracesysgood_flag == -1)
|
linux_test_for_tracesysgood (pid);
|
linux_test_for_tracesysgood (pid);
|
return linux_supports_tracesysgood_flag;
|
return linux_supports_tracesysgood_flag;
|
}
|
}
|
|
|
/* Return non-zero iff we have tracefork functionality available.
|
/* Return non-zero iff we have tracefork functionality available.
|
This function also sets linux_supports_tracefork_flag. */
|
This function also sets linux_supports_tracefork_flag. */
|
|
|
static int
|
static int
|
linux_supports_tracefork (int pid)
|
linux_supports_tracefork (int pid)
|
{
|
{
|
if (linux_supports_tracefork_flag == -1)
|
if (linux_supports_tracefork_flag == -1)
|
linux_test_for_tracefork (pid);
|
linux_test_for_tracefork (pid);
|
return linux_supports_tracefork_flag;
|
return linux_supports_tracefork_flag;
|
}
|
}
|
|
|
static int
|
static int
|
linux_supports_tracevforkdone (int pid)
|
linux_supports_tracevforkdone (int pid)
|
{
|
{
|
if (linux_supports_tracefork_flag == -1)
|
if (linux_supports_tracefork_flag == -1)
|
linux_test_for_tracefork (pid);
|
linux_test_for_tracefork (pid);
|
return linux_supports_tracevforkdone_flag;
|
return linux_supports_tracevforkdone_flag;
|
}
|
}
|
|
|
static void
|
static void
|
linux_enable_tracesysgood (ptid_t ptid)
|
linux_enable_tracesysgood (ptid_t ptid)
|
{
|
{
|
int pid = ptid_get_lwp (ptid);
|
int pid = ptid_get_lwp (ptid);
|
|
|
if (pid == 0)
|
if (pid == 0)
|
pid = ptid_get_pid (ptid);
|
pid = ptid_get_pid (ptid);
|
|
|
if (linux_supports_tracesysgood (pid) == 0)
|
if (linux_supports_tracesysgood (pid) == 0)
|
return;
|
return;
|
|
|
current_ptrace_options |= PTRACE_O_TRACESYSGOOD;
|
current_ptrace_options |= PTRACE_O_TRACESYSGOOD;
|
|
|
ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
|
ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
|
}
|
}
|
|
|
|
|
void
|
void
|
linux_enable_event_reporting (ptid_t ptid)
|
linux_enable_event_reporting (ptid_t ptid)
|
{
|
{
|
int pid = ptid_get_lwp (ptid);
|
int pid = ptid_get_lwp (ptid);
|
|
|
if (pid == 0)
|
if (pid == 0)
|
pid = ptid_get_pid (ptid);
|
pid = ptid_get_pid (ptid);
|
|
|
if (! linux_supports_tracefork (pid))
|
if (! linux_supports_tracefork (pid))
|
return;
|
return;
|
|
|
current_ptrace_options |= PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK
|
current_ptrace_options |= PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK
|
| PTRACE_O_TRACEEXEC | PTRACE_O_TRACECLONE;
|
| PTRACE_O_TRACEEXEC | PTRACE_O_TRACECLONE;
|
|
|
if (linux_supports_tracevforkdone (pid))
|
if (linux_supports_tracevforkdone (pid))
|
current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
|
current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
|
|
|
/* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
|
/* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
|
read-only process state. */
|
read-only process state. */
|
|
|
ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
|
ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
|
}
|
}
|
|
|
static void
|
static void
|
linux_child_post_attach (int pid)
|
linux_child_post_attach (int pid)
|
{
|
{
|
linux_enable_event_reporting (pid_to_ptid (pid));
|
linux_enable_event_reporting (pid_to_ptid (pid));
|
check_for_thread_db ();
|
check_for_thread_db ();
|
linux_enable_tracesysgood (pid_to_ptid (pid));
|
linux_enable_tracesysgood (pid_to_ptid (pid));
|
}
|
}
|
|
|
static void
|
static void
|
linux_child_post_startup_inferior (ptid_t ptid)
|
linux_child_post_startup_inferior (ptid_t ptid)
|
{
|
{
|
linux_enable_event_reporting (ptid);
|
linux_enable_event_reporting (ptid);
|
check_for_thread_db ();
|
check_for_thread_db ();
|
linux_enable_tracesysgood (ptid);
|
linux_enable_tracesysgood (ptid);
|
}
|
}
|
|
|
static int
|
static int
|
linux_child_follow_fork (struct target_ops *ops, int follow_child)
|
linux_child_follow_fork (struct target_ops *ops, int follow_child)
|
{
|
{
|
sigset_t prev_mask;
|
sigset_t prev_mask;
|
int has_vforked;
|
int has_vforked;
|
int parent_pid, child_pid;
|
int parent_pid, child_pid;
|
|
|
block_child_signals (&prev_mask);
|
block_child_signals (&prev_mask);
|
|
|
has_vforked = (inferior_thread ()->pending_follow.kind
|
has_vforked = (inferior_thread ()->pending_follow.kind
|
== TARGET_WAITKIND_VFORKED);
|
== TARGET_WAITKIND_VFORKED);
|
parent_pid = ptid_get_lwp (inferior_ptid);
|
parent_pid = ptid_get_lwp (inferior_ptid);
|
if (parent_pid == 0)
|
if (parent_pid == 0)
|
parent_pid = ptid_get_pid (inferior_ptid);
|
parent_pid = ptid_get_pid (inferior_ptid);
|
child_pid = PIDGET (inferior_thread ()->pending_follow.value.related_pid);
|
child_pid = PIDGET (inferior_thread ()->pending_follow.value.related_pid);
|
|
|
if (!detach_fork)
|
if (!detach_fork)
|
linux_enable_event_reporting (pid_to_ptid (child_pid));
|
linux_enable_event_reporting (pid_to_ptid (child_pid));
|
|
|
if (has_vforked
|
if (has_vforked
|
&& !non_stop /* Non-stop always resumes both branches. */
|
&& !non_stop /* Non-stop always resumes both branches. */
|
&& (!target_is_async_p () || sync_execution)
|
&& (!target_is_async_p () || sync_execution)
|
&& !(follow_child || detach_fork || sched_multi))
|
&& !(follow_child || detach_fork || sched_multi))
|
{
|
{
|
/* The parent stays blocked inside the vfork syscall until the
|
/* The parent stays blocked inside the vfork syscall until the
|
child execs or exits. If we don't let the child run, then
|
child execs or exits. If we don't let the child run, then
|
the parent stays blocked. If we're telling the parent to run
|
the parent stays blocked. If we're telling the parent to run
|
in the foreground, the user will not be able to ctrl-c to get
|
in the foreground, the user will not be able to ctrl-c to get
|
back the terminal, effectively hanging the debug session. */
|
back the terminal, effectively hanging the debug session. */
|
fprintf_filtered (gdb_stderr, _("\
|
fprintf_filtered (gdb_stderr, _("\
|
Can not resume the parent process over vfork in the foreground while \n\
|
Can not resume the parent process over vfork in the foreground while \n\
|
holding the child stopped. Try \"set detach-on-fork\" or \
|
holding the child stopped. Try \"set detach-on-fork\" or \
|
\"set schedule-multiple\".\n"));
|
\"set schedule-multiple\".\n"));
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (! follow_child)
|
if (! follow_child)
|
{
|
{
|
struct lwp_info *child_lp = NULL;
|
struct lwp_info *child_lp = NULL;
|
|
|
/* We're already attached to the parent, by default. */
|
/* We're already attached to the parent, by default. */
|
|
|
/* Detach new forked process? */
|
/* Detach new forked process? */
|
if (detach_fork)
|
if (detach_fork)
|
{
|
{
|
/* Before detaching from the child, remove all breakpoints
|
/* Before detaching from the child, remove all breakpoints
|
from it. If we forked, then this has already been taken
|
from it. If we forked, then this has already been taken
|
care of by infrun.c. If we vforked however, any
|
care of by infrun.c. If we vforked however, any
|
breakpoint inserted in the parent is visible in the
|
breakpoint inserted in the parent is visible in the
|
child, even those added while stopped in a vfork
|
child, even those added while stopped in a vfork
|
catchpoint. This will remove the breakpoints from the
|
catchpoint. This will remove the breakpoints from the
|
parent also, but they'll be reinserted below. */
|
parent also, but they'll be reinserted below. */
|
if (has_vforked)
|
if (has_vforked)
|
{
|
{
|
/* keep breakpoints list in sync. */
|
/* keep breakpoints list in sync. */
|
remove_breakpoints_pid (GET_PID (inferior_ptid));
|
remove_breakpoints_pid (GET_PID (inferior_ptid));
|
}
|
}
|
|
|
if (info_verbose || debug_linux_nat)
|
if (info_verbose || debug_linux_nat)
|
{
|
{
|
target_terminal_ours ();
|
target_terminal_ours ();
|
fprintf_filtered (gdb_stdlog,
|
fprintf_filtered (gdb_stdlog,
|
"Detaching after fork from child process %d.\n",
|
"Detaching after fork from child process %d.\n",
|
child_pid);
|
child_pid);
|
}
|
}
|
|
|
ptrace (PTRACE_DETACH, child_pid, 0, 0);
|
ptrace (PTRACE_DETACH, child_pid, 0, 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
struct inferior *parent_inf, *child_inf;
|
struct inferior *parent_inf, *child_inf;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
|
|
/* Add process to GDB's tables. */
|
/* Add process to GDB's tables. */
|
child_inf = add_inferior (child_pid);
|
child_inf = add_inferior (child_pid);
|
|
|
parent_inf = current_inferior ();
|
parent_inf = current_inferior ();
|
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);
|
|
|
old_chain = save_inferior_ptid ();
|
old_chain = save_inferior_ptid ();
|
save_current_program_space ();
|
save_current_program_space ();
|
|
|
inferior_ptid = ptid_build (child_pid, child_pid, 0);
|
inferior_ptid = ptid_build (child_pid, child_pid, 0);
|
add_thread (inferior_ptid);
|
add_thread (inferior_ptid);
|
child_lp = add_lwp (inferior_ptid);
|
child_lp = add_lwp (inferior_ptid);
|
child_lp->stopped = 1;
|
child_lp->stopped = 1;
|
child_lp->resumed = 1;
|
child_lp->resumed = 1;
|
|
|
/* If this is a vfork child, then the address-space is
|
/* If this is a vfork child, then the address-space is
|
shared with the parent. */
|
shared with the parent. */
|
if (has_vforked)
|
if (has_vforked)
|
{
|
{
|
child_inf->pspace = parent_inf->pspace;
|
child_inf->pspace = parent_inf->pspace;
|
child_inf->aspace = parent_inf->aspace;
|
child_inf->aspace = parent_inf->aspace;
|
|
|
/* The parent will be frozen until the child is done
|
/* The parent will be frozen until the child is done
|
with the shared region. Keep track of the
|
with the shared region. Keep track of the
|
parent. */
|
parent. */
|
child_inf->vfork_parent = parent_inf;
|
child_inf->vfork_parent = parent_inf;
|
child_inf->pending_detach = 0;
|
child_inf->pending_detach = 0;
|
parent_inf->vfork_child = child_inf;
|
parent_inf->vfork_child = child_inf;
|
parent_inf->pending_detach = 0;
|
parent_inf->pending_detach = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
child_inf->aspace = new_address_space ();
|
child_inf->aspace = new_address_space ();
|
child_inf->pspace = add_program_space (child_inf->aspace);
|
child_inf->pspace = add_program_space (child_inf->aspace);
|
child_inf->removable = 1;
|
child_inf->removable = 1;
|
set_current_program_space (child_inf->pspace);
|
set_current_program_space (child_inf->pspace);
|
clone_program_space (child_inf->pspace, parent_inf->pspace);
|
clone_program_space (child_inf->pspace, parent_inf->pspace);
|
|
|
/* Let the shared library layer (solib-svr4) learn about
|
/* Let the shared library layer (solib-svr4) learn about
|
this new process, relocate the cloned exec, pull in
|
this new process, relocate the cloned exec, pull in
|
shared libraries, and install the solib event
|
shared libraries, and install the solib event
|
breakpoint. If a "cloned-VM" event was propagated
|
breakpoint. If a "cloned-VM" event was propagated
|
better throughout the core, this wouldn't be
|
better throughout the core, this wouldn't be
|
required. */
|
required. */
|
solib_create_inferior_hook (0);
|
solib_create_inferior_hook (0);
|
}
|
}
|
|
|
/* Let the thread_db layer learn about this new process. */
|
/* Let the thread_db layer learn about this new process. */
|
check_for_thread_db ();
|
check_for_thread_db ();
|
|
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
if (has_vforked)
|
if (has_vforked)
|
{
|
{
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
struct inferior *parent_inf;
|
struct inferior *parent_inf;
|
|
|
parent_inf = current_inferior ();
|
parent_inf = current_inferior ();
|
|
|
/* If we detached from the child, then we have to be careful
|
/* If we detached from the child, then we have to be careful
|
to not insert breakpoints in the parent until the child
|
to not insert breakpoints in the parent until the child
|
is done with the shared memory region. However, if we're
|
is done with the shared memory region. However, if we're
|
staying attached to the child, then we can and should
|
staying attached to the child, then we can and should
|
insert breakpoints, so that we can debug it. A
|
insert breakpoints, so that we can debug it. A
|
subsequent child exec or exit is enough to know when does
|
subsequent child exec or exit is enough to know when does
|
the child stops using the parent's address space. */
|
the child stops using the parent's address space. */
|
parent_inf->waiting_for_vfork_done = detach_fork;
|
parent_inf->waiting_for_vfork_done = detach_fork;
|
parent_inf->pspace->breakpoints_not_allowed = detach_fork;
|
parent_inf->pspace->breakpoints_not_allowed = detach_fork;
|
|
|
lp = find_lwp_pid (pid_to_ptid (parent_pid));
|
lp = find_lwp_pid (pid_to_ptid (parent_pid));
|
gdb_assert (linux_supports_tracefork_flag >= 0);
|
gdb_assert (linux_supports_tracefork_flag >= 0);
|
if (linux_supports_tracevforkdone (0))
|
if (linux_supports_tracevforkdone (0))
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LCFF: waiting for VFORK_DONE on %d\n",
|
"LCFF: waiting for VFORK_DONE on %d\n",
|
parent_pid);
|
parent_pid);
|
|
|
lp->stopped = 1;
|
lp->stopped = 1;
|
lp->resumed = 1;
|
lp->resumed = 1;
|
|
|
/* We'll handle the VFORK_DONE event like any other
|
/* We'll handle the VFORK_DONE event like any other
|
event, in target_wait. */
|
event, in target_wait. */
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We can't insert breakpoints until the child has
|
/* We can't insert breakpoints until the child has
|
finished with the shared memory region. We need to
|
finished with the shared memory region. We need to
|
wait until that happens. Ideal would be to just
|
wait until that happens. Ideal would be to just
|
call:
|
call:
|
- ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
|
- ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
|
- waitpid (parent_pid, &status, __WALL);
|
- waitpid (parent_pid, &status, __WALL);
|
However, most architectures can't handle a syscall
|
However, most architectures can't handle a syscall
|
being traced on the way out if it wasn't traced on
|
being traced on the way out if it wasn't traced on
|
the way in.
|
the way in.
|
|
|
We might also think to loop, continuing the child
|
We might also think to loop, continuing the child
|
until it exits or gets a SIGTRAP. One problem is
|
until it exits or gets a SIGTRAP. One problem is
|
that the child might call ptrace with PTRACE_TRACEME.
|
that the child might call ptrace with PTRACE_TRACEME.
|
|
|
There's no simple and reliable way to figure out when
|
There's no simple and reliable way to figure out when
|
the vforked child will be done with its copy of the
|
the vforked child will be done with its copy of the
|
shared memory. We could step it out of the syscall,
|
shared memory. We could step it out of the syscall,
|
two instructions, let it go, and then single-step the
|
two instructions, let it go, and then single-step the
|
parent once. When we have hardware single-step, this
|
parent once. When we have hardware single-step, this
|
would work; with software single-step it could still
|
would work; with software single-step it could still
|
be made to work but we'd have to be able to insert
|
be made to work but we'd have to be able to insert
|
single-step breakpoints in the child, and we'd have
|
single-step breakpoints in the child, and we'd have
|
to insert -just- the single-step breakpoint in the
|
to insert -just- the single-step breakpoint in the
|
parent. Very awkward.
|
parent. Very awkward.
|
|
|
In the end, the best we can do is to make sure it
|
In the end, the best we can do is to make sure it
|
runs for a little while. Hopefully it will be out of
|
runs for a little while. Hopefully it will be out of
|
range of any breakpoints we reinsert. Usually this
|
range of any breakpoints we reinsert. Usually this
|
is only the single-step breakpoint at vfork's return
|
is only the single-step breakpoint at vfork's return
|
point. */
|
point. */
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LCFF: no VFORK_DONE support, sleeping a bit\n");
|
"LCFF: no VFORK_DONE support, sleeping a bit\n");
|
|
|
usleep (10000);
|
usleep (10000);
|
|
|
/* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
|
/* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
|
and leave it pending. The next linux_nat_resume call
|
and leave it pending. The next linux_nat_resume call
|
will notice a pending event, and bypasses actually
|
will notice a pending event, and bypasses actually
|
resuming the inferior. */
|
resuming the inferior. */
|
lp->status = 0;
|
lp->status = 0;
|
lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
|
lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
|
lp->stopped = 0;
|
lp->stopped = 0;
|
lp->resumed = 1;
|
lp->resumed = 1;
|
|
|
/* If we're in async mode, need to tell the event loop
|
/* If we're in async mode, need to tell the event loop
|
there's something here to process. */
|
there's something here to process. */
|
if (target_can_async_p ())
|
if (target_can_async_p ())
|
async_file_mark ();
|
async_file_mark ();
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
struct thread_info *tp;
|
struct thread_info *tp;
|
struct inferior *parent_inf, *child_inf;
|
struct inferior *parent_inf, *child_inf;
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
struct program_space *parent_pspace;
|
struct program_space *parent_pspace;
|
|
|
if (info_verbose || debug_linux_nat)
|
if (info_verbose || debug_linux_nat)
|
{
|
{
|
target_terminal_ours ();
|
target_terminal_ours ();
|
if (has_vforked)
|
if (has_vforked)
|
fprintf_filtered (gdb_stdlog, _("\
|
fprintf_filtered (gdb_stdlog, _("\
|
Attaching after process %d vfork to child process %d.\n"),
|
Attaching after process %d vfork to child process %d.\n"),
|
parent_pid, child_pid);
|
parent_pid, child_pid);
|
else
|
else
|
fprintf_filtered (gdb_stdlog, _("\
|
fprintf_filtered (gdb_stdlog, _("\
|
Attaching after process %d fork to child process %d.\n"),
|
Attaching after process %d fork to child process %d.\n"),
|
parent_pid, child_pid);
|
parent_pid, child_pid);
|
}
|
}
|
|
|
/* Add the new inferior first, so that the target_detach below
|
/* Add the new inferior first, so that the target_detach below
|
doesn't unpush the target. */
|
doesn't unpush the target. */
|
|
|
child_inf = add_inferior (child_pid);
|
child_inf = add_inferior (child_pid);
|
|
|
parent_inf = current_inferior ();
|
parent_inf = current_inferior ();
|
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);
|
|
|
parent_pspace = parent_inf->pspace;
|
parent_pspace = parent_inf->pspace;
|
|
|
/* If we're vforking, we want to hold on to the parent until the
|
/* If we're vforking, we want to hold on to the parent until the
|
child exits or execs. At child exec or exit time we can
|
child exits or execs. At child exec or exit time we can
|
remove the old breakpoints from the parent and detach or
|
remove the old breakpoints from the parent and detach or
|
resume debugging it. Otherwise, detach the parent now; we'll
|
resume debugging it. Otherwise, detach the parent now; we'll
|
want to reuse it's program/address spaces, but we can't set
|
want to reuse it's program/address spaces, but we can't set
|
them to the child before removing breakpoints from the
|
them to the child before removing breakpoints from the
|
parent, otherwise, the breakpoints module could decide to
|
parent, otherwise, the breakpoints module could decide to
|
remove breakpoints from the wrong process (since they'd be
|
remove breakpoints from the wrong process (since they'd be
|
assigned to the same address space). */
|
assigned to the same address space). */
|
|
|
if (has_vforked)
|
if (has_vforked)
|
{
|
{
|
gdb_assert (child_inf->vfork_parent == NULL);
|
gdb_assert (child_inf->vfork_parent == NULL);
|
gdb_assert (parent_inf->vfork_child == NULL);
|
gdb_assert (parent_inf->vfork_child == NULL);
|
child_inf->vfork_parent = parent_inf;
|
child_inf->vfork_parent = parent_inf;
|
child_inf->pending_detach = 0;
|
child_inf->pending_detach = 0;
|
parent_inf->vfork_child = child_inf;
|
parent_inf->vfork_child = child_inf;
|
parent_inf->pending_detach = detach_fork;
|
parent_inf->pending_detach = detach_fork;
|
parent_inf->waiting_for_vfork_done = 0;
|
parent_inf->waiting_for_vfork_done = 0;
|
}
|
}
|
else if (detach_fork)
|
else if (detach_fork)
|
target_detach (NULL, 0);
|
target_detach (NULL, 0);
|
|
|
/* Note that the detach above makes PARENT_INF dangling. */
|
/* Note that the detach above makes PARENT_INF dangling. */
|
|
|
/* Add the child thread to the appropriate lists, and switch to
|
/* Add the child thread to the appropriate lists, and switch to
|
this new thread, before cloning the program space, and
|
this new thread, before cloning the program space, and
|
informing the solib layer about this new process. */
|
informing the solib layer about this new process. */
|
|
|
inferior_ptid = ptid_build (child_pid, child_pid, 0);
|
inferior_ptid = ptid_build (child_pid, child_pid, 0);
|
add_thread (inferior_ptid);
|
add_thread (inferior_ptid);
|
lp = add_lwp (inferior_ptid);
|
lp = add_lwp (inferior_ptid);
|
lp->stopped = 1;
|
lp->stopped = 1;
|
lp->resumed = 1;
|
lp->resumed = 1;
|
|
|
/* If this is a vfork child, then the address-space is shared
|
/* If this is a vfork child, then the address-space is shared
|
with the parent. If we detached from the parent, then we can
|
with the parent. If we detached from the parent, then we can
|
reuse the parent's program/address spaces. */
|
reuse the parent's program/address spaces. */
|
if (has_vforked || detach_fork)
|
if (has_vforked || detach_fork)
|
{
|
{
|
child_inf->pspace = parent_pspace;
|
child_inf->pspace = parent_pspace;
|
child_inf->aspace = child_inf->pspace->aspace;
|
child_inf->aspace = child_inf->pspace->aspace;
|
}
|
}
|
else
|
else
|
{
|
{
|
child_inf->aspace = new_address_space ();
|
child_inf->aspace = new_address_space ();
|
child_inf->pspace = add_program_space (child_inf->aspace);
|
child_inf->pspace = add_program_space (child_inf->aspace);
|
child_inf->removable = 1;
|
child_inf->removable = 1;
|
set_current_program_space (child_inf->pspace);
|
set_current_program_space (child_inf->pspace);
|
clone_program_space (child_inf->pspace, parent_pspace);
|
clone_program_space (child_inf->pspace, parent_pspace);
|
|
|
/* Let the shared library layer (solib-svr4) learn about
|
/* Let the shared library layer (solib-svr4) learn about
|
this new process, relocate the cloned exec, pull in
|
this new process, relocate the cloned exec, pull in
|
shared libraries, and install the solib event breakpoint.
|
shared libraries, and install the solib event breakpoint.
|
If a "cloned-VM" event was propagated better throughout
|
If a "cloned-VM" event was propagated better throughout
|
the core, this wouldn't be required. */
|
the core, this wouldn't be required. */
|
solib_create_inferior_hook (0);
|
solib_create_inferior_hook (0);
|
}
|
}
|
|
|
/* Let the thread_db layer learn about this new process. */
|
/* Let the thread_db layer learn about this new process. */
|
check_for_thread_db ();
|
check_for_thread_db ();
|
}
|
}
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
linux_child_insert_fork_catchpoint (int pid)
|
linux_child_insert_fork_catchpoint (int pid)
|
{
|
{
|
if (! linux_supports_tracefork (pid))
|
if (! linux_supports_tracefork (pid))
|
error (_("Your system does not support fork catchpoints."));
|
error (_("Your system does not support fork catchpoints."));
|
}
|
}
|
|
|
static void
|
static void
|
linux_child_insert_vfork_catchpoint (int pid)
|
linux_child_insert_vfork_catchpoint (int pid)
|
{
|
{
|
if (!linux_supports_tracefork (pid))
|
if (!linux_supports_tracefork (pid))
|
error (_("Your system does not support vfork catchpoints."));
|
error (_("Your system does not support vfork catchpoints."));
|
}
|
}
|
|
|
static void
|
static void
|
linux_child_insert_exec_catchpoint (int pid)
|
linux_child_insert_exec_catchpoint (int pid)
|
{
|
{
|
if (!linux_supports_tracefork (pid))
|
if (!linux_supports_tracefork (pid))
|
error (_("Your system does not support exec catchpoints."));
|
error (_("Your system does not support exec catchpoints."));
|
}
|
}
|
|
|
static int
|
static int
|
linux_child_set_syscall_catchpoint (int pid, int needed, int any_count,
|
linux_child_set_syscall_catchpoint (int pid, int needed, int any_count,
|
int table_size, int *table)
|
int table_size, int *table)
|
{
|
{
|
if (! linux_supports_tracesysgood (pid))
|
if (! linux_supports_tracesysgood (pid))
|
error (_("Your system does not support syscall catchpoints."));
|
error (_("Your system does not support syscall catchpoints."));
|
/* On GNU/Linux, we ignore the arguments. It means that we only
|
/* On GNU/Linux, we ignore the arguments. It means that we only
|
enable the syscall catchpoints, but do not disable them.
|
enable the syscall catchpoints, but do not disable them.
|
|
|
Also, we do not use the `table' information because we do not
|
Also, we do not use the `table' information because we do not
|
filter system calls here. We let GDB do the logic for us. */
|
filter system calls here. We let GDB do the logic for us. */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* On GNU/Linux there are no real LWP's. The closest thing to LWP's
|
/* On GNU/Linux there are no real LWP's. The closest thing to LWP's
|
are processes sharing the same VM space. A multi-threaded process
|
are processes sharing the same VM space. A multi-threaded process
|
is basically a group of such processes. However, such a grouping
|
is basically a group of such processes. However, such a grouping
|
is almost entirely a user-space issue; the kernel doesn't enforce
|
is almost entirely a user-space issue; the kernel doesn't enforce
|
such a grouping at all (this might change in the future). In
|
such a grouping at all (this might change in the future). In
|
general, we'll rely on the threads library (i.e. the GNU/Linux
|
general, we'll rely on the threads library (i.e. the GNU/Linux
|
Threads library) to provide such a grouping.
|
Threads library) to provide such a grouping.
|
|
|
It is perfectly well possible to write a multi-threaded application
|
It is perfectly well possible to write a multi-threaded application
|
without the assistance of a threads library, by using the clone
|
without the assistance of a threads library, by using the clone
|
system call directly. This module should be able to give some
|
system call directly. This module should be able to give some
|
rudimentary support for debugging such applications if developers
|
rudimentary support for debugging such applications if developers
|
specify the CLONE_PTRACE flag in the clone system call, and are
|
specify the CLONE_PTRACE flag in the clone system call, and are
|
using the Linux kernel 2.4 or above.
|
using the Linux kernel 2.4 or above.
|
|
|
Note that there are some peculiarities in GNU/Linux that affect
|
Note that there are some peculiarities in GNU/Linux that affect
|
this code:
|
this code:
|
|
|
- In general one should specify the __WCLONE flag to waitpid in
|
- In general one should specify the __WCLONE flag to waitpid in
|
order to make it report events for any of the cloned processes
|
order to make it report events for any of the cloned processes
|
(and leave it out for the initial process). However, if a cloned
|
(and leave it out for the initial process). However, if a cloned
|
process has exited the exit status is only reported if the
|
process has exited the exit status is only reported if the
|
__WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
|
__WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
|
we cannot use it since GDB must work on older systems too.
|
we cannot use it since GDB must work on older systems too.
|
|
|
- When a traced, cloned process exits and is waited for by the
|
- When a traced, cloned process exits and is waited for by the
|
debugger, the kernel reassigns it to the original parent and
|
debugger, the kernel reassigns it to the original parent and
|
keeps it around as a "zombie". Somehow, the GNU/Linux Threads
|
keeps it around as a "zombie". Somehow, the GNU/Linux Threads
|
library doesn't notice this, which leads to the "zombie problem":
|
library doesn't notice this, which leads to the "zombie problem":
|
When debugged a multi-threaded process that spawns a lot of
|
When debugged a multi-threaded process that spawns a lot of
|
threads will run out of processes, even if the threads exit,
|
threads will run out of processes, even if the threads exit,
|
because the "zombies" stay around. */
|
because the "zombies" stay around. */
|
|
|
/* List of known LWPs. */
|
/* List of known LWPs. */
|
struct lwp_info *lwp_list;
|
struct lwp_info *lwp_list;
|
|
|
|
|
/* Original signal mask. */
|
/* Original signal mask. */
|
static sigset_t normal_mask;
|
static sigset_t normal_mask;
|
|
|
/* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
|
/* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
|
_initialize_linux_nat. */
|
_initialize_linux_nat. */
|
static sigset_t suspend_mask;
|
static sigset_t suspend_mask;
|
|
|
/* Signals to block to make that sigsuspend work. */
|
/* Signals to block to make that sigsuspend work. */
|
static sigset_t blocked_mask;
|
static sigset_t blocked_mask;
|
|
|
/* SIGCHLD action. */
|
/* SIGCHLD action. */
|
struct sigaction sigchld_action;
|
struct sigaction sigchld_action;
|
|
|
/* Block child signals (SIGCHLD and linux threads signals), and store
|
/* Block child signals (SIGCHLD and linux threads signals), and store
|
the previous mask in PREV_MASK. */
|
the previous mask in PREV_MASK. */
|
|
|
static void
|
static void
|
block_child_signals (sigset_t *prev_mask)
|
block_child_signals (sigset_t *prev_mask)
|
{
|
{
|
/* Make sure SIGCHLD is blocked. */
|
/* Make sure SIGCHLD is blocked. */
|
if (!sigismember (&blocked_mask, SIGCHLD))
|
if (!sigismember (&blocked_mask, SIGCHLD))
|
sigaddset (&blocked_mask, SIGCHLD);
|
sigaddset (&blocked_mask, SIGCHLD);
|
|
|
sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
|
sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
|
}
|
}
|
|
|
/* Restore child signals mask, previously returned by
|
/* Restore child signals mask, previously returned by
|
block_child_signals. */
|
block_child_signals. */
|
|
|
static void
|
static void
|
restore_child_signals_mask (sigset_t *prev_mask)
|
restore_child_signals_mask (sigset_t *prev_mask)
|
{
|
{
|
sigprocmask (SIG_SETMASK, prev_mask, NULL);
|
sigprocmask (SIG_SETMASK, prev_mask, NULL);
|
}
|
}
|
|
|
|
|
/* Prototypes for local functions. */
|
/* Prototypes for local functions. */
|
static int stop_wait_callback (struct lwp_info *lp, void *data);
|
static int stop_wait_callback (struct lwp_info *lp, void *data);
|
static int linux_thread_alive (ptid_t ptid);
|
static int linux_thread_alive (ptid_t ptid);
|
static char *linux_child_pid_to_exec_file (int pid);
|
static char *linux_child_pid_to_exec_file (int pid);
|
static int cancel_breakpoint (struct lwp_info *lp);
|
static int cancel_breakpoint (struct lwp_info *lp);
|
|
|
|
|
/* Convert wait status STATUS to a string. Used for printing debug
|
/* Convert wait status STATUS to a string. Used for printing debug
|
messages only. */
|
messages only. */
|
|
|
static char *
|
static char *
|
status_to_str (int status)
|
status_to_str (int status)
|
{
|
{
|
static char buf[64];
|
static char buf[64];
|
|
|
if (WIFSTOPPED (status))
|
if (WIFSTOPPED (status))
|
{
|
{
|
if (WSTOPSIG (status) == SYSCALL_SIGTRAP)
|
if (WSTOPSIG (status) == SYSCALL_SIGTRAP)
|
snprintf (buf, sizeof (buf), "%s (stopped at syscall)",
|
snprintf (buf, sizeof (buf), "%s (stopped at syscall)",
|
strsignal (SIGTRAP));
|
strsignal (SIGTRAP));
|
else
|
else
|
snprintf (buf, sizeof (buf), "%s (stopped)",
|
snprintf (buf, sizeof (buf), "%s (stopped)",
|
strsignal (WSTOPSIG (status)));
|
strsignal (WSTOPSIG (status)));
|
}
|
}
|
else if (WIFSIGNALED (status))
|
else if (WIFSIGNALED (status))
|
snprintf (buf, sizeof (buf), "%s (terminated)",
|
snprintf (buf, sizeof (buf), "%s (terminated)",
|
strsignal (WSTOPSIG (status)));
|
strsignal (WSTOPSIG (status)));
|
else
|
else
|
snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
|
snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
|
|
|
return buf;
|
return buf;
|
}
|
}
|
|
|
/* Remove all LWPs belong to PID from the lwp list. */
|
/* Remove all LWPs belong to PID from the lwp list. */
|
|
|
static void
|
static void
|
purge_lwp_list (int pid)
|
purge_lwp_list (int pid)
|
{
|
{
|
struct lwp_info *lp, *lpprev, *lpnext;
|
struct lwp_info *lp, *lpprev, *lpnext;
|
|
|
lpprev = NULL;
|
lpprev = NULL;
|
|
|
for (lp = lwp_list; lp; lp = lpnext)
|
for (lp = lwp_list; lp; lp = lpnext)
|
{
|
{
|
lpnext = lp->next;
|
lpnext = lp->next;
|
|
|
if (ptid_get_pid (lp->ptid) == pid)
|
if (ptid_get_pid (lp->ptid) == pid)
|
{
|
{
|
if (lp == lwp_list)
|
if (lp == lwp_list)
|
lwp_list = lp->next;
|
lwp_list = lp->next;
|
else
|
else
|
lpprev->next = lp->next;
|
lpprev->next = lp->next;
|
|
|
xfree (lp);
|
xfree (lp);
|
}
|
}
|
else
|
else
|
lpprev = lp;
|
lpprev = lp;
|
}
|
}
|
}
|
}
|
|
|
/* Return the number of known LWPs in the tgid given by PID. */
|
/* Return the number of known LWPs in the tgid given by PID. */
|
|
|
static int
|
static int
|
num_lwps (int pid)
|
num_lwps (int pid)
|
{
|
{
|
int count = 0;
|
int count = 0;
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
|
|
for (lp = lwp_list; lp; lp = lp->next)
|
for (lp = lwp_list; lp; lp = lp->next)
|
if (ptid_get_pid (lp->ptid) == pid)
|
if (ptid_get_pid (lp->ptid) == pid)
|
count++;
|
count++;
|
|
|
return count;
|
return count;
|
}
|
}
|
|
|
/* Add the LWP specified by PID to the list. Return a pointer to the
|
/* Add the LWP specified by PID to the list. Return a pointer to the
|
structure describing the new LWP. The LWP should already be stopped
|
structure describing the new LWP. The LWP should already be stopped
|
(with an exception for the very first LWP). */
|
(with an exception for the very first LWP). */
|
|
|
static struct lwp_info *
|
static struct lwp_info *
|
add_lwp (ptid_t ptid)
|
add_lwp (ptid_t ptid)
|
{
|
{
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
|
|
gdb_assert (is_lwp (ptid));
|
gdb_assert (is_lwp (ptid));
|
|
|
lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
|
lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
|
|
|
memset (lp, 0, sizeof (struct lwp_info));
|
memset (lp, 0, sizeof (struct lwp_info));
|
|
|
lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
|
lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
|
|
|
lp->ptid = ptid;
|
lp->ptid = ptid;
|
lp->core = -1;
|
lp->core = -1;
|
|
|
lp->next = lwp_list;
|
lp->next = lwp_list;
|
lwp_list = lp;
|
lwp_list = lp;
|
|
|
if (num_lwps (GET_PID (ptid)) > 1 && linux_nat_new_thread != NULL)
|
if (num_lwps (GET_PID (ptid)) > 1 && linux_nat_new_thread != NULL)
|
linux_nat_new_thread (ptid);
|
linux_nat_new_thread (ptid);
|
|
|
return lp;
|
return lp;
|
}
|
}
|
|
|
/* Remove the LWP specified by PID from the list. */
|
/* Remove the LWP specified by PID from the list. */
|
|
|
static void
|
static void
|
delete_lwp (ptid_t ptid)
|
delete_lwp (ptid_t ptid)
|
{
|
{
|
struct lwp_info *lp, *lpprev;
|
struct lwp_info *lp, *lpprev;
|
|
|
lpprev = NULL;
|
lpprev = NULL;
|
|
|
for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
|
for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
|
if (ptid_equal (lp->ptid, ptid))
|
if (ptid_equal (lp->ptid, ptid))
|
break;
|
break;
|
|
|
if (!lp)
|
if (!lp)
|
return;
|
return;
|
|
|
if (lpprev)
|
if (lpprev)
|
lpprev->next = lp->next;
|
lpprev->next = lp->next;
|
else
|
else
|
lwp_list = lp->next;
|
lwp_list = lp->next;
|
|
|
xfree (lp);
|
xfree (lp);
|
}
|
}
|
|
|
/* Return a pointer to the structure describing the LWP corresponding
|
/* Return a pointer to the structure describing the LWP corresponding
|
to PID. If no corresponding LWP could be found, return NULL. */
|
to PID. If no corresponding LWP could be found, return NULL. */
|
|
|
static struct lwp_info *
|
static struct lwp_info *
|
find_lwp_pid (ptid_t ptid)
|
find_lwp_pid (ptid_t ptid)
|
{
|
{
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
int lwp;
|
int lwp;
|
|
|
if (is_lwp (ptid))
|
if (is_lwp (ptid))
|
lwp = GET_LWP (ptid);
|
lwp = GET_LWP (ptid);
|
else
|
else
|
lwp = GET_PID (ptid);
|
lwp = GET_PID (ptid);
|
|
|
for (lp = lwp_list; lp; lp = lp->next)
|
for (lp = lwp_list; lp; lp = lp->next)
|
if (lwp == GET_LWP (lp->ptid))
|
if (lwp == GET_LWP (lp->ptid))
|
return lp;
|
return lp;
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Returns true if PTID matches filter FILTER. FILTER can be the wild
|
/* Returns true if PTID matches filter FILTER. FILTER can be the wild
|
card MINUS_ONE_PTID (all ptid match it); can be a ptid representing
|
card MINUS_ONE_PTID (all ptid match it); can be a ptid representing
|
a process (ptid_is_pid returns true), in which case, all lwps of
|
a process (ptid_is_pid returns true), in which case, all lwps of
|
that give process match, lwps of other process do not; or, it can
|
that give process match, lwps of other process do not; or, it can
|
represent a specific thread, in which case, only that thread will
|
represent a specific thread, in which case, only that thread will
|
match true. PTID must represent an LWP, it can never be a wild
|
match true. PTID must represent an LWP, it can never be a wild
|
card. */
|
card. */
|
|
|
static int
|
static int
|
ptid_match (ptid_t ptid, ptid_t filter)
|
ptid_match (ptid_t ptid, ptid_t filter)
|
{
|
{
|
/* Since both parameters have the same type, prevent easy mistakes
|
/* Since both parameters have the same type, prevent easy mistakes
|
from happening. */
|
from happening. */
|
gdb_assert (!ptid_equal (ptid, minus_one_ptid)
|
gdb_assert (!ptid_equal (ptid, minus_one_ptid)
|
&& !ptid_equal (ptid, null_ptid));
|
&& !ptid_equal (ptid, null_ptid));
|
|
|
if (ptid_equal (filter, minus_one_ptid))
|
if (ptid_equal (filter, minus_one_ptid))
|
return 1;
|
return 1;
|
if (ptid_is_pid (filter)
|
if (ptid_is_pid (filter)
|
&& ptid_get_pid (ptid) == ptid_get_pid (filter))
|
&& ptid_get_pid (ptid) == ptid_get_pid (filter))
|
return 1;
|
return 1;
|
else if (ptid_equal (ptid, filter))
|
else if (ptid_equal (ptid, filter))
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Call CALLBACK with its second argument set to DATA for every LWP in
|
/* Call CALLBACK with its second argument set to DATA for every LWP in
|
the list. If CALLBACK returns 1 for a particular LWP, return a
|
the list. If CALLBACK returns 1 for a particular LWP, return a
|
pointer to the structure describing that LWP immediately.
|
pointer to the structure describing that LWP immediately.
|
Otherwise return NULL. */
|
Otherwise return NULL. */
|
|
|
struct lwp_info *
|
struct lwp_info *
|
iterate_over_lwps (ptid_t filter,
|
iterate_over_lwps (ptid_t filter,
|
int (*callback) (struct lwp_info *, void *),
|
int (*callback) (struct lwp_info *, void *),
|
void *data)
|
void *data)
|
{
|
{
|
struct lwp_info *lp, *lpnext;
|
struct lwp_info *lp, *lpnext;
|
|
|
for (lp = lwp_list; lp; lp = lpnext)
|
for (lp = lwp_list; lp; lp = lpnext)
|
{
|
{
|
lpnext = lp->next;
|
lpnext = lp->next;
|
|
|
if (ptid_match (lp->ptid, filter))
|
if (ptid_match (lp->ptid, filter))
|
{
|
{
|
if ((*callback) (lp, data))
|
if ((*callback) (lp, data))
|
return lp;
|
return lp;
|
}
|
}
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Update our internal state when changing from one checkpoint to
|
/* Update our internal state when changing from one checkpoint to
|
another indicated by NEW_PTID. We can only switch single-threaded
|
another indicated by NEW_PTID. We can only switch single-threaded
|
applications, so we only create one new LWP, and the previous list
|
applications, so we only create one new LWP, and the previous list
|
is discarded. */
|
is discarded. */
|
|
|
void
|
void
|
linux_nat_switch_fork (ptid_t new_ptid)
|
linux_nat_switch_fork (ptid_t new_ptid)
|
{
|
{
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
|
|
purge_lwp_list (GET_PID (inferior_ptid));
|
purge_lwp_list (GET_PID (inferior_ptid));
|
|
|
lp = add_lwp (new_ptid);
|
lp = add_lwp (new_ptid);
|
lp->stopped = 1;
|
lp->stopped = 1;
|
|
|
/* This changes the thread's ptid while preserving the gdb thread
|
/* This changes the thread's ptid while preserving the gdb thread
|
num. Also changes the inferior pid, while preserving the
|
num. Also changes the inferior pid, while preserving the
|
inferior num. */
|
inferior num. */
|
thread_change_ptid (inferior_ptid, new_ptid);
|
thread_change_ptid (inferior_ptid, new_ptid);
|
|
|
/* We've just told GDB core that the thread changed target id, but,
|
/* We've just told GDB core that the thread changed target id, but,
|
in fact, it really is a different thread, with different register
|
in fact, it really is a different thread, with different register
|
contents. */
|
contents. */
|
registers_changed ();
|
registers_changed ();
|
}
|
}
|
|
|
/* Handle the exit of a single thread LP. */
|
/* Handle the exit of a single thread LP. */
|
|
|
static void
|
static void
|
exit_lwp (struct lwp_info *lp)
|
exit_lwp (struct lwp_info *lp)
|
{
|
{
|
struct thread_info *th = find_thread_ptid (lp->ptid);
|
struct thread_info *th = find_thread_ptid (lp->ptid);
|
|
|
if (th)
|
if (th)
|
{
|
{
|
if (print_thread_events)
|
if (print_thread_events)
|
printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
|
printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
|
|
|
delete_thread (lp->ptid);
|
delete_thread (lp->ptid);
|
}
|
}
|
|
|
delete_lwp (lp->ptid);
|
delete_lwp (lp->ptid);
|
}
|
}
|
|
|
/* Return an lwp's tgid, found in `/proc/PID/status'. */
|
/* Return an lwp's tgid, found in `/proc/PID/status'. */
|
|
|
int
|
int
|
linux_proc_get_tgid (int lwpid)
|
linux_proc_get_tgid (int lwpid)
|
{
|
{
|
FILE *status_file;
|
FILE *status_file;
|
char buf[100];
|
char buf[100];
|
int tgid = -1;
|
int tgid = -1;
|
|
|
snprintf (buf, sizeof (buf), "/proc/%d/status", (int) lwpid);
|
snprintf (buf, sizeof (buf), "/proc/%d/status", (int) lwpid);
|
status_file = fopen (buf, "r");
|
status_file = fopen (buf, "r");
|
if (status_file != NULL)
|
if (status_file != NULL)
|
{
|
{
|
while (fgets (buf, sizeof (buf), status_file))
|
while (fgets (buf, sizeof (buf), status_file))
|
{
|
{
|
if (strncmp (buf, "Tgid:", 5) == 0)
|
if (strncmp (buf, "Tgid:", 5) == 0)
|
{
|
{
|
tgid = strtoul (buf + strlen ("Tgid:"), NULL, 10);
|
tgid = strtoul (buf + strlen ("Tgid:"), NULL, 10);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
fclose (status_file);
|
fclose (status_file);
|
}
|
}
|
|
|
return tgid;
|
return tgid;
|
}
|
}
|
|
|
/* Detect `T (stopped)' in `/proc/PID/status'.
|
/* Detect `T (stopped)' in `/proc/PID/status'.
|
Other states including `T (tracing stop)' are reported as false. */
|
Other states including `T (tracing stop)' are reported as false. */
|
|
|
static int
|
static int
|
pid_is_stopped (pid_t pid)
|
pid_is_stopped (pid_t pid)
|
{
|
{
|
FILE *status_file;
|
FILE *status_file;
|
char buf[100];
|
char buf[100];
|
int retval = 0;
|
int retval = 0;
|
|
|
snprintf (buf, sizeof (buf), "/proc/%d/status", (int) pid);
|
snprintf (buf, sizeof (buf), "/proc/%d/status", (int) pid);
|
status_file = fopen (buf, "r");
|
status_file = fopen (buf, "r");
|
if (status_file != NULL)
|
if (status_file != NULL)
|
{
|
{
|
int have_state = 0;
|
int have_state = 0;
|
|
|
while (fgets (buf, sizeof (buf), status_file))
|
while (fgets (buf, sizeof (buf), status_file))
|
{
|
{
|
if (strncmp (buf, "State:", 6) == 0)
|
if (strncmp (buf, "State:", 6) == 0)
|
{
|
{
|
have_state = 1;
|
have_state = 1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (have_state && strstr (buf, "T (stopped)") != NULL)
|
if (have_state && strstr (buf, "T (stopped)") != NULL)
|
retval = 1;
|
retval = 1;
|
fclose (status_file);
|
fclose (status_file);
|
}
|
}
|
return retval;
|
return retval;
|
}
|
}
|
|
|
/* Wait for the LWP specified by LP, which we have just attached to.
|
/* Wait for the LWP specified by LP, which we have just attached to.
|
Returns a wait status for that LWP, to cache. */
|
Returns a wait status for that LWP, to cache. */
|
|
|
static int
|
static int
|
linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
|
linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
|
int *signalled)
|
int *signalled)
|
{
|
{
|
pid_t new_pid, pid = GET_LWP (ptid);
|
pid_t new_pid, pid = GET_LWP (ptid);
|
int status;
|
int status;
|
|
|
if (pid_is_stopped (pid))
|
if (pid_is_stopped (pid))
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LNPAW: Attaching to a stopped process\n");
|
"LNPAW: Attaching to a stopped process\n");
|
|
|
/* The process is definitely stopped. It is in a job control
|
/* The process is definitely stopped. It is in a job control
|
stop, unless the kernel predates the TASK_STOPPED /
|
stop, unless the kernel predates the TASK_STOPPED /
|
TASK_TRACED distinction, in which case it might be in a
|
TASK_TRACED distinction, in which case it might be in a
|
ptrace stop. Make sure it is in a ptrace stop; from there we
|
ptrace stop. Make sure it is in a ptrace stop; from there we
|
can kill it, signal it, et cetera.
|
can kill it, signal it, et cetera.
|
|
|
First make sure there is a pending SIGSTOP. Since we are
|
First make sure there is a pending SIGSTOP. Since we are
|
already attached, the process can not transition from stopped
|
already attached, the process can not transition from stopped
|
to running without a PTRACE_CONT; so we know this signal will
|
to running without a PTRACE_CONT; so we know this signal will
|
go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
|
go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
|
probably already in the queue (unless this kernel is old
|
probably already in the queue (unless this kernel is old
|
enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
|
enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
|
is not an RT signal, it can only be queued once. */
|
is not an RT signal, it can only be queued once. */
|
kill_lwp (pid, SIGSTOP);
|
kill_lwp (pid, SIGSTOP);
|
|
|
/* Finally, resume the stopped process. This will deliver the SIGSTOP
|
/* Finally, resume the stopped process. This will deliver the SIGSTOP
|
(or a higher priority signal, just like normal PTRACE_ATTACH). */
|
(or a higher priority signal, just like normal PTRACE_ATTACH). */
|
ptrace (PTRACE_CONT, pid, 0, 0);
|
ptrace (PTRACE_CONT, pid, 0, 0);
|
}
|
}
|
|
|
/* Make sure the initial process is stopped. The user-level threads
|
/* Make sure the initial process is stopped. The user-level threads
|
layer might want to poke around in the inferior, and that won't
|
layer might want to poke around in the inferior, and that won't
|
work if things haven't stabilized yet. */
|
work if things haven't stabilized yet. */
|
new_pid = my_waitpid (pid, &status, 0);
|
new_pid = my_waitpid (pid, &status, 0);
|
if (new_pid == -1 && errno == ECHILD)
|
if (new_pid == -1 && errno == ECHILD)
|
{
|
{
|
if (first)
|
if (first)
|
warning (_("%s is a cloned process"), target_pid_to_str (ptid));
|
warning (_("%s is a cloned process"), target_pid_to_str (ptid));
|
|
|
/* Try again with __WCLONE to check cloned processes. */
|
/* Try again with __WCLONE to check cloned processes. */
|
new_pid = my_waitpid (pid, &status, __WCLONE);
|
new_pid = my_waitpid (pid, &status, __WCLONE);
|
*cloned = 1;
|
*cloned = 1;
|
}
|
}
|
|
|
gdb_assert (pid == new_pid);
|
gdb_assert (pid == new_pid);
|
|
|
if (!WIFSTOPPED (status))
|
if (!WIFSTOPPED (status))
|
{
|
{
|
/* The pid we tried to attach has apparently just exited. */
|
/* The pid we tried to attach has apparently just exited. */
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
|
fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
|
pid, status_to_str (status));
|
pid, status_to_str (status));
|
return status;
|
return status;
|
}
|
}
|
|
|
if (WSTOPSIG (status) != SIGSTOP)
|
if (WSTOPSIG (status) != SIGSTOP)
|
{
|
{
|
*signalled = 1;
|
*signalled = 1;
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LNPAW: Received %s after attaching\n",
|
"LNPAW: Received %s after attaching\n",
|
status_to_str (status));
|
status_to_str (status));
|
}
|
}
|
|
|
return status;
|
return status;
|
}
|
}
|
|
|
/* Attach to the LWP specified by PID. Return 0 if successful or -1
|
/* Attach to the LWP specified by PID. Return 0 if successful or -1
|
if the new LWP could not be attached. */
|
if the new LWP could not be attached. */
|
|
|
int
|
int
|
lin_lwp_attach_lwp (ptid_t ptid)
|
lin_lwp_attach_lwp (ptid_t ptid)
|
{
|
{
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
sigset_t prev_mask;
|
sigset_t prev_mask;
|
|
|
gdb_assert (is_lwp (ptid));
|
gdb_assert (is_lwp (ptid));
|
|
|
block_child_signals (&prev_mask);
|
block_child_signals (&prev_mask);
|
|
|
lp = find_lwp_pid (ptid);
|
lp = find_lwp_pid (ptid);
|
|
|
/* We assume that we're already attached to any LWP that has an id
|
/* We assume that we're already attached to any LWP that has an id
|
equal to the overall process id, and to any LWP that is already
|
equal to the overall process id, and to any LWP that is already
|
in our list of LWPs. If we're not seeing exit events from threads
|
in our list of LWPs. If we're not seeing exit events from threads
|
and we've had PID wraparound since we last tried to stop all threads,
|
and we've had PID wraparound since we last tried to stop all threads,
|
this assumption might be wrong; fortunately, this is very unlikely
|
this assumption might be wrong; fortunately, this is very unlikely
|
to happen. */
|
to happen. */
|
if (GET_LWP (ptid) != GET_PID (ptid) && lp == NULL)
|
if (GET_LWP (ptid) != GET_PID (ptid) && lp == NULL)
|
{
|
{
|
int status, cloned = 0, signalled = 0;
|
int status, cloned = 0, signalled = 0;
|
|
|
if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
|
if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
|
{
|
{
|
/* If we fail to attach to the thread, issue a warning,
|
/* If we fail to attach to the thread, issue a warning,
|
but continue. One way this can happen is if thread
|
but continue. One way this can happen is if thread
|
creation is interrupted; as of Linux kernel 2.6.19, a
|
creation is interrupted; as of Linux kernel 2.6.19, a
|
bug may place threads in the thread list and then fail
|
bug may place threads in the thread list and then fail
|
to create them. */
|
to create them. */
|
warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
|
warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
|
safe_strerror (errno));
|
safe_strerror (errno));
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
|
"LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
|
target_pid_to_str (ptid));
|
target_pid_to_str (ptid));
|
|
|
status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
|
status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
|
if (!WIFSTOPPED (status))
|
if (!WIFSTOPPED (status))
|
return -1;
|
return -1;
|
|
|
lp = add_lwp (ptid);
|
lp = add_lwp (ptid);
|
lp->stopped = 1;
|
lp->stopped = 1;
|
lp->cloned = cloned;
|
lp->cloned = cloned;
|
lp->signalled = signalled;
|
lp->signalled = signalled;
|
if (WSTOPSIG (status) != SIGSTOP)
|
if (WSTOPSIG (status) != SIGSTOP)
|
{
|
{
|
lp->resumed = 1;
|
lp->resumed = 1;
|
lp->status = status;
|
lp->status = status;
|
}
|
}
|
|
|
target_post_attach (GET_LWP (lp->ptid));
|
target_post_attach (GET_LWP (lp->ptid));
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLAL: waitpid %s received %s\n",
|
"LLAL: waitpid %s received %s\n",
|
target_pid_to_str (ptid),
|
target_pid_to_str (ptid),
|
status_to_str (status));
|
status_to_str (status));
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We assume that the LWP representing the original process is
|
/* We assume that the LWP representing the original process is
|
already stopped. Mark it as stopped in the data structure
|
already stopped. Mark it as stopped in the data structure
|
that the GNU/linux ptrace layer uses to keep track of
|
that the GNU/linux ptrace layer uses to keep track of
|
threads. Note that this won't have already been done since
|
threads. Note that this won't have already been done since
|
the main thread will have, we assume, been stopped by an
|
the main thread will have, we assume, been stopped by an
|
attach from a different layer. */
|
attach from a different layer. */
|
if (lp == NULL)
|
if (lp == NULL)
|
lp = add_lwp (ptid);
|
lp = add_lwp (ptid);
|
lp->stopped = 1;
|
lp->stopped = 1;
|
}
|
}
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_create_inferior (struct target_ops *ops,
|
linux_nat_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)
|
{
|
{
|
#ifdef HAVE_PERSONALITY
|
#ifdef HAVE_PERSONALITY
|
int personality_orig = 0, personality_set = 0;
|
int personality_orig = 0, personality_set = 0;
|
#endif /* HAVE_PERSONALITY */
|
#endif /* HAVE_PERSONALITY */
|
|
|
/* The fork_child mechanism is synchronous and calls target_wait, so
|
/* The fork_child mechanism is synchronous and calls target_wait, so
|
we have to mask the async mode. */
|
we have to mask the async mode. */
|
|
|
#ifdef HAVE_PERSONALITY
|
#ifdef HAVE_PERSONALITY
|
if (disable_randomization)
|
if (disable_randomization)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
personality_orig = personality (0xffffffff);
|
personality_orig = personality (0xffffffff);
|
if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
|
if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
|
{
|
{
|
personality_set = 1;
|
personality_set = 1;
|
personality (personality_orig | ADDR_NO_RANDOMIZE);
|
personality (personality_orig | ADDR_NO_RANDOMIZE);
|
}
|
}
|
if (errno != 0 || (personality_set
|
if (errno != 0 || (personality_set
|
&& !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
|
&& !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
|
warning (_("Error disabling address space randomization: %s"),
|
warning (_("Error disabling address space randomization: %s"),
|
safe_strerror (errno));
|
safe_strerror (errno));
|
}
|
}
|
#endif /* HAVE_PERSONALITY */
|
#endif /* HAVE_PERSONALITY */
|
|
|
linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
|
linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
|
|
|
#ifdef HAVE_PERSONALITY
|
#ifdef HAVE_PERSONALITY
|
if (personality_set)
|
if (personality_set)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
personality (personality_orig);
|
personality (personality_orig);
|
if (errno != 0)
|
if (errno != 0)
|
warning (_("Error restoring address space randomization: %s"),
|
warning (_("Error restoring address space randomization: %s"),
|
safe_strerror (errno));
|
safe_strerror (errno));
|
}
|
}
|
#endif /* HAVE_PERSONALITY */
|
#endif /* HAVE_PERSONALITY */
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_attach (struct target_ops *ops, char *args, int from_tty)
|
linux_nat_attach (struct target_ops *ops, char *args, int from_tty)
|
{
|
{
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
int status;
|
int status;
|
ptid_t ptid;
|
ptid_t ptid;
|
|
|
linux_ops->to_attach (ops, args, from_tty);
|
linux_ops->to_attach (ops, args, from_tty);
|
|
|
/* The ptrace base target adds the main thread with (pid,0,0)
|
/* The ptrace base target adds the main thread with (pid,0,0)
|
format. Decorate it with lwp info. */
|
format. Decorate it with lwp info. */
|
ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
|
ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
|
thread_change_ptid (inferior_ptid, ptid);
|
thread_change_ptid (inferior_ptid, ptid);
|
|
|
/* Add the initial process as the first LWP to the list. */
|
/* Add the initial process as the first LWP to the list. */
|
lp = add_lwp (ptid);
|
lp = add_lwp (ptid);
|
|
|
status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
|
status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
|
&lp->signalled);
|
&lp->signalled);
|
if (!WIFSTOPPED (status))
|
if (!WIFSTOPPED (status))
|
{
|
{
|
if (WIFEXITED (status))
|
if (WIFEXITED (status))
|
{
|
{
|
int exit_code = WEXITSTATUS (status);
|
int exit_code = WEXITSTATUS (status);
|
|
|
target_terminal_ours ();
|
target_terminal_ours ();
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
if (exit_code == 0)
|
if (exit_code == 0)
|
error (_("Unable to attach: program exited normally."));
|
error (_("Unable to attach: program exited normally."));
|
else
|
else
|
error (_("Unable to attach: program exited with code %d."),
|
error (_("Unable to attach: program exited with code %d."),
|
exit_code);
|
exit_code);
|
}
|
}
|
else if (WIFSIGNALED (status))
|
else if (WIFSIGNALED (status))
|
{
|
{
|
enum target_signal signo;
|
enum target_signal signo;
|
|
|
target_terminal_ours ();
|
target_terminal_ours ();
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
|
|
signo = target_signal_from_host (WTERMSIG (status));
|
signo = target_signal_from_host (WTERMSIG (status));
|
error (_("Unable to attach: program terminated with signal "
|
error (_("Unable to attach: program terminated with signal "
|
"%s, %s."),
|
"%s, %s."),
|
target_signal_to_name (signo),
|
target_signal_to_name (signo),
|
target_signal_to_string (signo));
|
target_signal_to_string (signo));
|
}
|
}
|
|
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("unexpected status %d for PID %ld"),
|
_("unexpected status %d for PID %ld"),
|
status, (long) GET_LWP (ptid));
|
status, (long) GET_LWP (ptid));
|
}
|
}
|
|
|
lp->stopped = 1;
|
lp->stopped = 1;
|
|
|
/* Save the wait status to report later. */
|
/* Save the wait status to report later. */
|
lp->resumed = 1;
|
lp->resumed = 1;
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LNA: waitpid %ld, saving status %s\n",
|
"LNA: waitpid %ld, saving status %s\n",
|
(long) GET_PID (lp->ptid), status_to_str (status));
|
(long) GET_PID (lp->ptid), status_to_str (status));
|
|
|
lp->status = status;
|
lp->status = status;
|
|
|
if (target_can_async_p ())
|
if (target_can_async_p ())
|
target_async (inferior_event_handler, 0);
|
target_async (inferior_event_handler, 0);
|
}
|
}
|
|
|
/* Get pending status of LP. */
|
/* Get pending status of LP. */
|
static int
|
static int
|
get_pending_status (struct lwp_info *lp, int *status)
|
get_pending_status (struct lwp_info *lp, int *status)
|
{
|
{
|
enum target_signal signo = TARGET_SIGNAL_0;
|
enum target_signal signo = TARGET_SIGNAL_0;
|
|
|
/* If we paused threads momentarily, we may have stored pending
|
/* If we paused threads momentarily, we may have stored pending
|
events in lp->status or lp->waitstatus (see stop_wait_callback),
|
events in lp->status or lp->waitstatus (see stop_wait_callback),
|
and GDB core hasn't seen any signal for those threads.
|
and GDB core hasn't seen any signal for those threads.
|
Otherwise, the last signal reported to the core is found in the
|
Otherwise, the last signal reported to the core is found in the
|
thread object's stop_signal.
|
thread object's stop_signal.
|
|
|
There's a corner case that isn't handled here at present. Only
|
There's a corner case that isn't handled here at present. Only
|
if the thread stopped with a TARGET_WAITKIND_STOPPED does
|
if the thread stopped with a TARGET_WAITKIND_STOPPED does
|
stop_signal make sense as a real signal to pass to the inferior.
|
stop_signal make sense as a real signal to pass to the inferior.
|
Some catchpoint related events, like
|
Some catchpoint related events, like
|
TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
|
TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
|
to TARGET_SIGNAL_SIGTRAP when the catchpoint triggers. But,
|
to TARGET_SIGNAL_SIGTRAP when the catchpoint triggers. But,
|
those traps are debug API (ptrace in our case) related and
|
those traps are debug API (ptrace in our case) related and
|
induced; the inferior wouldn't see them if it wasn't being
|
induced; the inferior wouldn't see them if it wasn't being
|
traced. Hence, we should never pass them to the inferior, even
|
traced. Hence, we should never pass them to the inferior, even
|
when set to pass state. Since this corner case isn't handled by
|
when set to pass state. Since this corner case isn't handled by
|
infrun.c when proceeding with a signal, for consistency, neither
|
infrun.c when proceeding with a signal, for consistency, neither
|
do we handle it here (or elsewhere in the file we check for
|
do we handle it here (or elsewhere in the file we check for
|
signal pass state). Normally SIGTRAP isn't set to pass state, so
|
signal pass state). Normally SIGTRAP isn't set to pass state, so
|
this is really a corner case. */
|
this is really a corner case. */
|
|
|
if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
signo = TARGET_SIGNAL_0; /* a pending ptrace event, not a real signal. */
|
signo = TARGET_SIGNAL_0; /* a pending ptrace event, not a real signal. */
|
else if (lp->status)
|
else if (lp->status)
|
signo = target_signal_from_host (WSTOPSIG (lp->status));
|
signo = target_signal_from_host (WSTOPSIG (lp->status));
|
else if (non_stop && !is_executing (lp->ptid))
|
else if (non_stop && !is_executing (lp->ptid))
|
{
|
{
|
struct thread_info *tp = find_thread_ptid (lp->ptid);
|
struct thread_info *tp = find_thread_ptid (lp->ptid);
|
signo = tp->stop_signal;
|
signo = tp->stop_signal;
|
}
|
}
|
else if (!non_stop)
|
else if (!non_stop)
|
{
|
{
|
struct target_waitstatus last;
|
struct target_waitstatus last;
|
ptid_t last_ptid;
|
ptid_t last_ptid;
|
|
|
get_last_target_status (&last_ptid, &last);
|
get_last_target_status (&last_ptid, &last);
|
|
|
if (GET_LWP (lp->ptid) == GET_LWP (last_ptid))
|
if (GET_LWP (lp->ptid) == GET_LWP (last_ptid))
|
{
|
{
|
struct thread_info *tp = find_thread_ptid (lp->ptid);
|
struct thread_info *tp = find_thread_ptid (lp->ptid);
|
signo = tp->stop_signal;
|
signo = tp->stop_signal;
|
}
|
}
|
}
|
}
|
|
|
*status = 0;
|
*status = 0;
|
|
|
if (signo == TARGET_SIGNAL_0)
|
if (signo == TARGET_SIGNAL_0)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"GPT: lwp %s has no pending signal\n",
|
"GPT: lwp %s has no pending signal\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
else if (!signal_pass_state (signo))
|
else if (!signal_pass_state (signo))
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "\
|
fprintf_unfiltered (gdb_stdlog, "\
|
GPT: lwp %s had signal %s, but it is in no pass state\n",
|
GPT: lwp %s had signal %s, but it is in no pass state\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
target_signal_to_string (signo));
|
target_signal_to_string (signo));
|
}
|
}
|
else
|
else
|
{
|
{
|
*status = W_STOPCODE (target_signal_to_host (signo));
|
*status = W_STOPCODE (target_signal_to_host (signo));
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"GPT: lwp %s has pending signal %s\n",
|
"GPT: lwp %s has pending signal %s\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
target_signal_to_string (signo));
|
target_signal_to_string (signo));
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
detach_callback (struct lwp_info *lp, void *data)
|
detach_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
|
gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
|
|
|
if (debug_linux_nat && lp->status)
|
if (debug_linux_nat && lp->status)
|
fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
|
fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
|
strsignal (WSTOPSIG (lp->status)),
|
strsignal (WSTOPSIG (lp->status)),
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
/* If there is a pending SIGSTOP, get rid of it. */
|
/* If there is a pending SIGSTOP, get rid of it. */
|
if (lp->signalled)
|
if (lp->signalled)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"DC: Sending SIGCONT to %s\n",
|
"DC: Sending SIGCONT to %s\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
kill_lwp (GET_LWP (lp->ptid), SIGCONT);
|
kill_lwp (GET_LWP (lp->ptid), SIGCONT);
|
lp->signalled = 0;
|
lp->signalled = 0;
|
}
|
}
|
|
|
/* We don't actually detach from the LWP that has an id equal to the
|
/* We don't actually detach from the LWP that has an id equal to the
|
overall process id just yet. */
|
overall process id just yet. */
|
if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
|
if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
|
{
|
{
|
int status = 0;
|
int status = 0;
|
|
|
/* Pass on any pending signal for this LWP. */
|
/* Pass on any pending signal for this LWP. */
|
get_pending_status (lp, &status);
|
get_pending_status (lp, &status);
|
|
|
errno = 0;
|
errno = 0;
|
if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
|
if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
|
WSTOPSIG (status)) < 0)
|
WSTOPSIG (status)) < 0)
|
error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
|
error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
|
safe_strerror (errno));
|
safe_strerror (errno));
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"PTRACE_DETACH (%s, %s, 0) (OK)\n",
|
"PTRACE_DETACH (%s, %s, 0) (OK)\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
strsignal (WSTOPSIG (status)));
|
strsignal (WSTOPSIG (status)));
|
|
|
delete_lwp (lp->ptid);
|
delete_lwp (lp->ptid);
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_detach (struct target_ops *ops, char *args, int from_tty)
|
linux_nat_detach (struct target_ops *ops, char *args, int from_tty)
|
{
|
{
|
int pid;
|
int pid;
|
int status;
|
int status;
|
enum target_signal sig;
|
enum target_signal sig;
|
struct lwp_info *main_lwp;
|
struct lwp_info *main_lwp;
|
|
|
pid = GET_PID (inferior_ptid);
|
pid = GET_PID (inferior_ptid);
|
|
|
if (target_can_async_p ())
|
if (target_can_async_p ())
|
linux_nat_async (NULL, 0);
|
linux_nat_async (NULL, 0);
|
|
|
/* Stop all threads before detaching. ptrace requires that the
|
/* Stop all threads before detaching. ptrace requires that the
|
thread is stopped to sucessfully detach. */
|
thread is stopped to sucessfully detach. */
|
iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
|
iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
|
/* ... and wait until all of them have reported back that
|
/* ... and wait until all of them have reported back that
|
they're no longer running. */
|
they're no longer running. */
|
iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
|
iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
|
|
|
iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
|
iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
|
|
|
/* Only the initial process should be left right now. */
|
/* Only the initial process should be left right now. */
|
gdb_assert (num_lwps (GET_PID (inferior_ptid)) == 1);
|
gdb_assert (num_lwps (GET_PID (inferior_ptid)) == 1);
|
|
|
main_lwp = find_lwp_pid (pid_to_ptid (pid));
|
main_lwp = find_lwp_pid (pid_to_ptid (pid));
|
|
|
/* Pass on any pending signal for the last LWP. */
|
/* Pass on any pending signal for the last LWP. */
|
if ((args == NULL || *args == '\0')
|
if ((args == NULL || *args == '\0')
|
&& get_pending_status (main_lwp, &status) != -1
|
&& get_pending_status (main_lwp, &status) != -1
|
&& WIFSTOPPED (status))
|
&& WIFSTOPPED (status))
|
{
|
{
|
/* Put the signal number in ARGS so that inf_ptrace_detach will
|
/* Put the signal number in ARGS so that inf_ptrace_detach will
|
pass it along with PTRACE_DETACH. */
|
pass it along with PTRACE_DETACH. */
|
args = alloca (8);
|
args = alloca (8);
|
sprintf (args, "%d", (int) WSTOPSIG (status));
|
sprintf (args, "%d", (int) WSTOPSIG (status));
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LND: Sending signal %s to %s\n",
|
"LND: Sending signal %s to %s\n",
|
args,
|
args,
|
target_pid_to_str (main_lwp->ptid));
|
target_pid_to_str (main_lwp->ptid));
|
}
|
}
|
|
|
delete_lwp (main_lwp->ptid);
|
delete_lwp (main_lwp->ptid);
|
|
|
if (forks_exist_p ())
|
if (forks_exist_p ())
|
{
|
{
|
/* Multi-fork case. The current inferior_ptid is being detached
|
/* Multi-fork case. The current inferior_ptid is being detached
|
from, but there are other viable forks to debug. Detach from
|
from, but there are other viable forks to debug. Detach from
|
the current fork, and context-switch to the first
|
the current fork, and context-switch to the first
|
available. */
|
available. */
|
linux_fork_detach (args, from_tty);
|
linux_fork_detach (args, from_tty);
|
|
|
if (non_stop && target_can_async_p ())
|
if (non_stop && target_can_async_p ())
|
target_async (inferior_event_handler, 0);
|
target_async (inferior_event_handler, 0);
|
}
|
}
|
else
|
else
|
linux_ops->to_detach (ops, args, from_tty);
|
linux_ops->to_detach (ops, args, from_tty);
|
}
|
}
|
|
|
/* Resume LP. */
|
/* Resume LP. */
|
|
|
static int
|
static int
|
resume_callback (struct lwp_info *lp, void *data)
|
resume_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
|
struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
|
|
|
if (lp->stopped && inf->vfork_child != NULL)
|
if (lp->stopped && inf->vfork_child != NULL)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"RC: Not resuming %s (vfork parent)\n",
|
"RC: Not resuming %s (vfork parent)\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
else if (lp->stopped && lp->status == 0)
|
else if (lp->stopped && lp->status == 0)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"RC: PTRACE_CONT %s, 0, 0 (resuming sibling)\n",
|
"RC: PTRACE_CONT %s, 0, 0 (resuming sibling)\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
linux_ops->to_resume (linux_ops,
|
linux_ops->to_resume (linux_ops,
|
pid_to_ptid (GET_LWP (lp->ptid)),
|
pid_to_ptid (GET_LWP (lp->ptid)),
|
0, TARGET_SIGNAL_0);
|
0, TARGET_SIGNAL_0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
|
"RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
lp->stopped = 0;
|
lp->stopped = 0;
|
lp->step = 0;
|
lp->step = 0;
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
lp->stopped_by_watchpoint = 0;
|
lp->stopped_by_watchpoint = 0;
|
}
|
}
|
else if (lp->stopped && debug_linux_nat)
|
else if (lp->stopped && debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "RC: Not resuming sibling %s (has pending)\n",
|
fprintf_unfiltered (gdb_stdlog, "RC: Not resuming sibling %s (has pending)\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
else if (debug_linux_nat)
|
else if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "RC: Not resuming sibling %s (not stopped)\n",
|
fprintf_unfiltered (gdb_stdlog, "RC: Not resuming sibling %s (not stopped)\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
resume_clear_callback (struct lwp_info *lp, void *data)
|
resume_clear_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
lp->resumed = 0;
|
lp->resumed = 0;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
resume_set_callback (struct lwp_info *lp, void *data)
|
resume_set_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
lp->resumed = 1;
|
lp->resumed = 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_resume (struct target_ops *ops,
|
linux_nat_resume (struct target_ops *ops,
|
ptid_t ptid, int step, enum target_signal signo)
|
ptid_t ptid, int step, enum target_signal signo)
|
{
|
{
|
sigset_t prev_mask;
|
sigset_t prev_mask;
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
int resume_many;
|
int resume_many;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
|
"LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
|
step ? "step" : "resume",
|
step ? "step" : "resume",
|
target_pid_to_str (ptid),
|
target_pid_to_str (ptid),
|
signo ? strsignal (signo) : "0",
|
signo ? strsignal (signo) : "0",
|
target_pid_to_str (inferior_ptid));
|
target_pid_to_str (inferior_ptid));
|
|
|
block_child_signals (&prev_mask);
|
block_child_signals (&prev_mask);
|
|
|
/* A specific PTID means `step only this process id'. */
|
/* A specific PTID means `step only this process id'. */
|
resume_many = (ptid_equal (minus_one_ptid, ptid)
|
resume_many = (ptid_equal (minus_one_ptid, ptid)
|
|| ptid_is_pid (ptid));
|
|| ptid_is_pid (ptid));
|
|
|
/* Mark the lwps we're resuming as resumed. */
|
/* Mark the lwps we're resuming as resumed. */
|
iterate_over_lwps (ptid, resume_set_callback, NULL);
|
iterate_over_lwps (ptid, resume_set_callback, NULL);
|
|
|
/* See if it's the current inferior that should be handled
|
/* See if it's the current inferior that should be handled
|
specially. */
|
specially. */
|
if (resume_many)
|
if (resume_many)
|
lp = find_lwp_pid (inferior_ptid);
|
lp = find_lwp_pid (inferior_ptid);
|
else
|
else
|
lp = find_lwp_pid (ptid);
|
lp = find_lwp_pid (ptid);
|
gdb_assert (lp != NULL);
|
gdb_assert (lp != NULL);
|
|
|
/* Remember if we're stepping. */
|
/* Remember if we're stepping. */
|
lp->step = step;
|
lp->step = step;
|
|
|
/* If we have a pending wait status for this thread, there is no
|
/* If we have a pending wait status for this thread, there is no
|
point in resuming the process. But first make sure that
|
point in resuming the process. But first make sure that
|
linux_nat_wait won't preemptively handle the event - we
|
linux_nat_wait won't preemptively handle the event - we
|
should never take this short-circuit if we are going to
|
should never take this short-circuit if we are going to
|
leave LP running, since we have skipped resuming all the
|
leave LP running, since we have skipped resuming all the
|
other threads. This bit of code needs to be synchronized
|
other threads. This bit of code needs to be synchronized
|
with linux_nat_wait. */
|
with linux_nat_wait. */
|
|
|
if (lp->status && WIFSTOPPED (lp->status))
|
if (lp->status && WIFSTOPPED (lp->status))
|
{
|
{
|
int saved_signo;
|
int saved_signo;
|
struct inferior *inf;
|
struct inferior *inf;
|
|
|
inf = find_inferior_pid (ptid_get_pid (lp->ptid));
|
inf = find_inferior_pid (ptid_get_pid (lp->ptid));
|
gdb_assert (inf);
|
gdb_assert (inf);
|
saved_signo = target_signal_from_host (WSTOPSIG (lp->status));
|
saved_signo = target_signal_from_host (WSTOPSIG (lp->status));
|
|
|
/* Defer to common code if we're gaining control of the
|
/* Defer to common code if we're gaining control of the
|
inferior. */
|
inferior. */
|
if (inf->stop_soon == NO_STOP_QUIETLY
|
if (inf->stop_soon == NO_STOP_QUIETLY
|
&& signal_stop_state (saved_signo) == 0
|
&& signal_stop_state (saved_signo) == 0
|
&& signal_print_state (saved_signo) == 0
|
&& signal_print_state (saved_signo) == 0
|
&& signal_pass_state (saved_signo) == 1)
|
&& signal_pass_state (saved_signo) == 1)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLR: Not short circuiting for ignored "
|
"LLR: Not short circuiting for ignored "
|
"status 0x%x\n", lp->status);
|
"status 0x%x\n", lp->status);
|
|
|
/* FIXME: What should we do if we are supposed to continue
|
/* FIXME: What should we do if we are supposed to continue
|
this thread with a signal? */
|
this thread with a signal? */
|
gdb_assert (signo == TARGET_SIGNAL_0);
|
gdb_assert (signo == TARGET_SIGNAL_0);
|
signo = saved_signo;
|
signo = saved_signo;
|
lp->status = 0;
|
lp->status = 0;
|
}
|
}
|
}
|
}
|
|
|
if (lp->status || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
if (lp->status || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
{
|
{
|
/* FIXME: What should we do if we are supposed to continue
|
/* FIXME: What should we do if we are supposed to continue
|
this thread with a signal? */
|
this thread with a signal? */
|
gdb_assert (signo == TARGET_SIGNAL_0);
|
gdb_assert (signo == TARGET_SIGNAL_0);
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLR: Short circuiting for status 0x%x\n",
|
"LLR: Short circuiting for status 0x%x\n",
|
lp->status);
|
lp->status);
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
if (target_can_async_p ())
|
if (target_can_async_p ())
|
{
|
{
|
target_async (inferior_event_handler, 0);
|
target_async (inferior_event_handler, 0);
|
/* Tell the event loop we have something to process. */
|
/* Tell the event loop we have something to process. */
|
async_file_mark ();
|
async_file_mark ();
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* Mark LWP as not stopped to prevent it from being continued by
|
/* Mark LWP as not stopped to prevent it from being continued by
|
resume_callback. */
|
resume_callback. */
|
lp->stopped = 0;
|
lp->stopped = 0;
|
|
|
if (resume_many)
|
if (resume_many)
|
iterate_over_lwps (ptid, resume_callback, NULL);
|
iterate_over_lwps (ptid, resume_callback, NULL);
|
|
|
/* Convert to something the lower layer understands. */
|
/* Convert to something the lower layer understands. */
|
ptid = pid_to_ptid (GET_LWP (lp->ptid));
|
ptid = pid_to_ptid (GET_LWP (lp->ptid));
|
|
|
linux_ops->to_resume (linux_ops, ptid, step, signo);
|
linux_ops->to_resume (linux_ops, ptid, step, signo);
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
lp->stopped_by_watchpoint = 0;
|
lp->stopped_by_watchpoint = 0;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLR: %s %s, %s (resume event thread)\n",
|
"LLR: %s %s, %s (resume event thread)\n",
|
step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
target_pid_to_str (ptid),
|
target_pid_to_str (ptid),
|
signo ? strsignal (signo) : "0");
|
signo ? strsignal (signo) : "0");
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
if (target_can_async_p ())
|
if (target_can_async_p ())
|
target_async (inferior_event_handler, 0);
|
target_async (inferior_event_handler, 0);
|
}
|
}
|
|
|
/* Send a signal to an LWP. */
|
/* Send a signal to an LWP. */
|
|
|
static int
|
static int
|
kill_lwp (int lwpid, int signo)
|
kill_lwp (int lwpid, int signo)
|
{
|
{
|
/* Use tkill, if possible, in case we are using nptl threads. If tkill
|
/* Use tkill, if possible, in case we are using nptl threads. If tkill
|
fails, then we are not using nptl threads and we should be using kill. */
|
fails, then we are not using nptl threads and we should be using kill. */
|
|
|
#ifdef HAVE_TKILL_SYSCALL
|
#ifdef HAVE_TKILL_SYSCALL
|
{
|
{
|
static int tkill_failed;
|
static int tkill_failed;
|
|
|
if (!tkill_failed)
|
if (!tkill_failed)
|
{
|
{
|
int ret;
|
int ret;
|
|
|
errno = 0;
|
errno = 0;
|
ret = syscall (__NR_tkill, lwpid, signo);
|
ret = syscall (__NR_tkill, lwpid, signo);
|
if (errno != ENOSYS)
|
if (errno != ENOSYS)
|
return ret;
|
return ret;
|
tkill_failed = 1;
|
tkill_failed = 1;
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
|
|
return kill (lwpid, signo);
|
return kill (lwpid, signo);
|
}
|
}
|
|
|
/* Handle a GNU/Linux syscall trap wait response. If we see a syscall
|
/* Handle a GNU/Linux syscall trap wait response. If we see a syscall
|
event, check if the core is interested in it: if not, ignore the
|
event, check if the core is interested in it: if not, ignore the
|
event, and keep waiting; otherwise, we need to toggle the LWP's
|
event, and keep waiting; otherwise, we need to toggle the LWP's
|
syscall entry/exit status, since the ptrace event itself doesn't
|
syscall entry/exit status, since the ptrace event itself doesn't
|
indicate it, and report the trap to higher layers. */
|
indicate it, and report the trap to higher layers. */
|
|
|
static int
|
static int
|
linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
|
linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
|
{
|
{
|
struct target_waitstatus *ourstatus = &lp->waitstatus;
|
struct target_waitstatus *ourstatus = &lp->waitstatus;
|
struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
|
struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
|
int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
|
int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
|
|
|
if (stopping)
|
if (stopping)
|
{
|
{
|
/* If we're stopping threads, there's a SIGSTOP pending, which
|
/* If we're stopping threads, there's a SIGSTOP pending, which
|
makes it so that the LWP reports an immediate syscall return,
|
makes it so that the LWP reports an immediate syscall return,
|
followed by the SIGSTOP. Skip seeing that "return" using
|
followed by the SIGSTOP. Skip seeing that "return" using
|
PTRACE_CONT directly, and let stop_wait_callback collect the
|
PTRACE_CONT directly, and let stop_wait_callback collect the
|
SIGSTOP. Later when the thread is resumed, a new syscall
|
SIGSTOP. Later when the thread is resumed, a new syscall
|
entry event. If we didn't do this (and returned 0), we'd
|
entry event. If we didn't do this (and returned 0), we'd
|
leave a syscall entry pending, and our caller, by using
|
leave a syscall entry pending, and our caller, by using
|
PTRACE_CONT to collect the SIGSTOP, skips the syscall return
|
PTRACE_CONT to collect the SIGSTOP, skips the syscall return
|
itself. Later, when the user re-resumes this LWP, we'd see
|
itself. Later, when the user re-resumes this LWP, we'd see
|
another syscall entry event and we'd mistake it for a return.
|
another syscall entry event and we'd mistake it for a return.
|
|
|
If stop_wait_callback didn't force the SIGSTOP out of the LWP
|
If stop_wait_callback didn't force the SIGSTOP out of the LWP
|
(leaving immediately with LWP->signalled set, without issuing
|
(leaving immediately with LWP->signalled set, without issuing
|
a PTRACE_CONT), it would still be problematic to leave this
|
a PTRACE_CONT), it would still be problematic to leave this
|
syscall enter pending, as later when the thread is resumed,
|
syscall enter pending, as later when the thread is resumed,
|
it would then see the same syscall exit mentioned above,
|
it would then see the same syscall exit mentioned above,
|
followed by the delayed SIGSTOP, while the syscall didn't
|
followed by the delayed SIGSTOP, while the syscall didn't
|
actually get to execute. It seems it would be even more
|
actually get to execute. It seems it would be even more
|
confusing to the user. */
|
confusing to the user. */
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LHST: ignoring syscall %d "
|
"LHST: ignoring syscall %d "
|
"for LWP %ld (stopping threads), "
|
"for LWP %ld (stopping threads), "
|
"resuming with PTRACE_CONT for SIGSTOP\n",
|
"resuming with PTRACE_CONT for SIGSTOP\n",
|
syscall_number,
|
syscall_number,
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
|
|
lp->syscall_state = TARGET_WAITKIND_IGNORE;
|
lp->syscall_state = TARGET_WAITKIND_IGNORE;
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (catch_syscall_enabled ())
|
if (catch_syscall_enabled ())
|
{
|
{
|
/* Always update the entry/return state, even if this particular
|
/* Always update the entry/return state, even if this particular
|
syscall isn't interesting to the core now. In async mode,
|
syscall isn't interesting to the core now. In async mode,
|
the user could install a new catchpoint for this syscall
|
the user could install a new catchpoint for this syscall
|
between syscall enter/return, and we'll need to know to
|
between syscall enter/return, and we'll need to know to
|
report a syscall return if that happens. */
|
report a syscall return if that happens. */
|
lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
|
lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
|
? TARGET_WAITKIND_SYSCALL_RETURN
|
? TARGET_WAITKIND_SYSCALL_RETURN
|
: TARGET_WAITKIND_SYSCALL_ENTRY);
|
: TARGET_WAITKIND_SYSCALL_ENTRY);
|
|
|
if (catching_syscall_number (syscall_number))
|
if (catching_syscall_number (syscall_number))
|
{
|
{
|
/* Alright, an event to report. */
|
/* Alright, an event to report. */
|
ourstatus->kind = lp->syscall_state;
|
ourstatus->kind = lp->syscall_state;
|
ourstatus->value.syscall_number = syscall_number;
|
ourstatus->value.syscall_number = syscall_number;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LHST: stopping for %s of syscall %d"
|
"LHST: stopping for %s of syscall %d"
|
" for LWP %ld\n",
|
" for LWP %ld\n",
|
lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
|
lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
|
? "entry" : "return",
|
? "entry" : "return",
|
syscall_number,
|
syscall_number,
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LHST: ignoring %s of syscall %d "
|
"LHST: ignoring %s of syscall %d "
|
"for LWP %ld\n",
|
"for LWP %ld\n",
|
lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
|
lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
|
? "entry" : "return",
|
? "entry" : "return",
|
syscall_number,
|
syscall_number,
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
}
|
}
|
else
|
else
|
{
|
{
|
/* If we had been syscall tracing, and hence used PT_SYSCALL
|
/* If we had been syscall tracing, and hence used PT_SYSCALL
|
before on this LWP, it could happen that the user removes all
|
before on this LWP, it could happen that the user removes all
|
syscall catchpoints before we get to process this event.
|
syscall catchpoints before we get to process this event.
|
There are two noteworthy issues here:
|
There are two noteworthy issues here:
|
|
|
- When stopped at a syscall entry event, resuming with
|
- When stopped at a syscall entry event, resuming with
|
PT_STEP still resumes executing the syscall and reports a
|
PT_STEP still resumes executing the syscall and reports a
|
syscall return.
|
syscall return.
|
|
|
- Only PT_SYSCALL catches syscall enters. If we last
|
- Only PT_SYSCALL catches syscall enters. If we last
|
single-stepped this thread, then this event can't be a
|
single-stepped this thread, then this event can't be a
|
syscall enter. If we last single-stepped this thread, this
|
syscall enter. If we last single-stepped this thread, this
|
has to be a syscall exit.
|
has to be a syscall exit.
|
|
|
The points above mean that the next resume, be it PT_STEP or
|
The points above mean that the next resume, be it PT_STEP or
|
PT_CONTINUE, can not trigger a syscall trace event. */
|
PT_CONTINUE, can not trigger a syscall trace event. */
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LHST: caught syscall event with no syscall catchpoints."
|
"LHST: caught syscall event with no syscall catchpoints."
|
" %d for LWP %ld, ignoring\n",
|
" %d for LWP %ld, ignoring\n",
|
syscall_number,
|
syscall_number,
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
lp->syscall_state = TARGET_WAITKIND_IGNORE;
|
lp->syscall_state = TARGET_WAITKIND_IGNORE;
|
}
|
}
|
|
|
/* The core isn't interested in this event. For efficiency, avoid
|
/* The core isn't interested in this event. For efficiency, avoid
|
stopping all threads only to have the core resume them all again.
|
stopping all threads only to have the core resume them all again.
|
Since we're not stopping threads, if we're still syscall tracing
|
Since we're not stopping threads, if we're still syscall tracing
|
and not stepping, we can't use PTRACE_CONT here, as we'd miss any
|
and not stepping, we can't use PTRACE_CONT here, as we'd miss any
|
subsequent syscall. Simply resume using the inf-ptrace layer,
|
subsequent syscall. Simply resume using the inf-ptrace layer,
|
which knows when to use PT_SYSCALL or PT_CONTINUE. */
|
which knows when to use PT_SYSCALL or PT_CONTINUE. */
|
|
|
/* Note that gdbarch_get_syscall_number may access registers, hence
|
/* Note that gdbarch_get_syscall_number may access registers, hence
|
fill a regcache. */
|
fill a regcache. */
|
registers_changed ();
|
registers_changed ();
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
lp->step, TARGET_SIGNAL_0);
|
lp->step, TARGET_SIGNAL_0);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Handle a GNU/Linux extended wait response. If we see a clone
|
/* Handle a GNU/Linux extended wait response. If we see a clone
|
event, we need to add the new LWP to our list (and not report the
|
event, we need to add the new LWP to our list (and not report the
|
trap to higher layers). This function returns non-zero if the
|
trap to higher layers). This function returns non-zero if the
|
event should be ignored and we should wait again. If STOPPING is
|
event should be ignored and we should wait again. If STOPPING is
|
true, the new LWP remains stopped, otherwise it is continued. */
|
true, the new LWP remains stopped, otherwise it is continued. */
|
|
|
static int
|
static int
|
linux_handle_extended_wait (struct lwp_info *lp, int status,
|
linux_handle_extended_wait (struct lwp_info *lp, int status,
|
int stopping)
|
int stopping)
|
{
|
{
|
int pid = GET_LWP (lp->ptid);
|
int pid = GET_LWP (lp->ptid);
|
struct target_waitstatus *ourstatus = &lp->waitstatus;
|
struct target_waitstatus *ourstatus = &lp->waitstatus;
|
struct lwp_info *new_lp = NULL;
|
struct lwp_info *new_lp = NULL;
|
int event = status >> 16;
|
int event = status >> 16;
|
|
|
if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
|
if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
|
|| event == PTRACE_EVENT_CLONE)
|
|| event == PTRACE_EVENT_CLONE)
|
{
|
{
|
unsigned long new_pid;
|
unsigned long new_pid;
|
int ret;
|
int ret;
|
|
|
ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
|
ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
|
|
|
/* If we haven't already seen the new PID stop, wait for it now. */
|
/* If we haven't already seen the new PID stop, wait for it now. */
|
if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
|
if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
|
{
|
{
|
/* The new child has a pending SIGSTOP. We can't affect it until it
|
/* The new child has a pending SIGSTOP. We can't affect it until it
|
hits the SIGSTOP, but we're already attached. */
|
hits the SIGSTOP, but we're already attached. */
|
ret = my_waitpid (new_pid, &status,
|
ret = my_waitpid (new_pid, &status,
|
(event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
|
(event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
|
if (ret == -1)
|
if (ret == -1)
|
perror_with_name (_("waiting for new child"));
|
perror_with_name (_("waiting for new child"));
|
else if (ret != new_pid)
|
else if (ret != new_pid)
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("wait returned unexpected PID %d"), ret);
|
_("wait returned unexpected PID %d"), ret);
|
else if (!WIFSTOPPED (status))
|
else if (!WIFSTOPPED (status))
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("wait returned unexpected status 0x%x"), status);
|
_("wait returned unexpected status 0x%x"), status);
|
}
|
}
|
|
|
ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
|
ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
|
|
|
if (event == PTRACE_EVENT_FORK
|
if (event == PTRACE_EVENT_FORK
|
&& linux_fork_checkpointing_p (GET_PID (lp->ptid)))
|
&& linux_fork_checkpointing_p (GET_PID (lp->ptid)))
|
{
|
{
|
struct fork_info *fp;
|
struct fork_info *fp;
|
|
|
/* Handle checkpointing by linux-fork.c here as a special
|
/* Handle checkpointing by linux-fork.c here as a special
|
case. We don't want the follow-fork-mode or 'catch fork'
|
case. We don't want the follow-fork-mode or 'catch fork'
|
to interfere with this. */
|
to interfere with this. */
|
|
|
/* This won't actually modify the breakpoint list, but will
|
/* This won't actually modify the breakpoint list, but will
|
physically remove the breakpoints from the child. */
|
physically remove the breakpoints from the child. */
|
detach_breakpoints (new_pid);
|
detach_breakpoints (new_pid);
|
|
|
/* Retain child fork in ptrace (stopped) state. */
|
/* Retain child fork in ptrace (stopped) state. */
|
fp = find_fork_pid (new_pid);
|
fp = find_fork_pid (new_pid);
|
if (!fp)
|
if (!fp)
|
fp = add_fork (new_pid);
|
fp = add_fork (new_pid);
|
|
|
/* Report as spurious, so that infrun doesn't want to follow
|
/* Report as spurious, so that infrun doesn't want to follow
|
this fork. We're actually doing an infcall in
|
this fork. We're actually doing an infcall in
|
linux-fork.c. */
|
linux-fork.c. */
|
ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
|
ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
|
linux_enable_event_reporting (pid_to_ptid (new_pid));
|
linux_enable_event_reporting (pid_to_ptid (new_pid));
|
|
|
/* Report the stop to the core. */
|
/* Report the stop to the core. */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (event == PTRACE_EVENT_FORK)
|
if (event == PTRACE_EVENT_FORK)
|
ourstatus->kind = TARGET_WAITKIND_FORKED;
|
ourstatus->kind = TARGET_WAITKIND_FORKED;
|
else if (event == PTRACE_EVENT_VFORK)
|
else if (event == PTRACE_EVENT_VFORK)
|
ourstatus->kind = TARGET_WAITKIND_VFORKED;
|
ourstatus->kind = TARGET_WAITKIND_VFORKED;
|
else
|
else
|
{
|
{
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
|
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
new_lp = add_lwp (BUILD_LWP (new_pid, GET_PID (lp->ptid)));
|
new_lp = add_lwp (BUILD_LWP (new_pid, GET_PID (lp->ptid)));
|
new_lp->cloned = 1;
|
new_lp->cloned = 1;
|
new_lp->stopped = 1;
|
new_lp->stopped = 1;
|
|
|
if (WSTOPSIG (status) != SIGSTOP)
|
if (WSTOPSIG (status) != SIGSTOP)
|
{
|
{
|
/* This can happen if someone starts sending signals to
|
/* This can happen if someone starts sending signals to
|
the new thread before it gets a chance to run, which
|
the new thread before it gets a chance to run, which
|
have a lower number than SIGSTOP (e.g. SIGUSR1).
|
have a lower number than SIGSTOP (e.g. SIGUSR1).
|
This is an unlikely case, and harder to handle for
|
This is an unlikely case, and harder to handle for
|
fork / vfork than for clone, so we do not try - but
|
fork / vfork than for clone, so we do not try - but
|
we handle it for clone events here. We'll send
|
we handle it for clone events here. We'll send
|
the other signal on to the thread below. */
|
the other signal on to the thread below. */
|
|
|
new_lp->signalled = 1;
|
new_lp->signalled = 1;
|
}
|
}
|
else
|
else
|
status = 0;
|
status = 0;
|
|
|
if (non_stop)
|
if (non_stop)
|
{
|
{
|
/* Add the new thread to GDB's lists as soon as possible
|
/* Add the new thread to GDB's lists as soon as possible
|
so that:
|
so that:
|
|
|
1) the frontend doesn't have to wait for a stop to
|
1) the frontend doesn't have to wait for a stop to
|
display them, and,
|
display them, and,
|
|
|
2) we tag it with the correct running state. */
|
2) we tag it with the correct running state. */
|
|
|
/* If the thread_db layer is active, let it know about
|
/* If the thread_db layer is active, let it know about
|
this new thread, and add it to GDB's list. */
|
this new thread, and add it to GDB's list. */
|
if (!thread_db_attach_lwp (new_lp->ptid))
|
if (!thread_db_attach_lwp (new_lp->ptid))
|
{
|
{
|
/* We're not using thread_db. Add it to GDB's
|
/* We're not using thread_db. Add it to GDB's
|
list. */
|
list. */
|
target_post_attach (GET_LWP (new_lp->ptid));
|
target_post_attach (GET_LWP (new_lp->ptid));
|
add_thread (new_lp->ptid);
|
add_thread (new_lp->ptid);
|
}
|
}
|
|
|
if (!stopping)
|
if (!stopping)
|
{
|
{
|
set_running (new_lp->ptid, 1);
|
set_running (new_lp->ptid, 1);
|
set_executing (new_lp->ptid, 1);
|
set_executing (new_lp->ptid, 1);
|
}
|
}
|
}
|
}
|
|
|
/* Note the need to use the low target ops to resume, to
|
/* Note the need to use the low target ops to resume, to
|
handle resuming with PT_SYSCALL if we have syscall
|
handle resuming with PT_SYSCALL if we have syscall
|
catchpoints. */
|
catchpoints. */
|
if (!stopping)
|
if (!stopping)
|
{
|
{
|
int signo;
|
int signo;
|
|
|
new_lp->stopped = 0;
|
new_lp->stopped = 0;
|
new_lp->resumed = 1;
|
new_lp->resumed = 1;
|
|
|
signo = (status
|
signo = (status
|
? target_signal_from_host (WSTOPSIG (status))
|
? target_signal_from_host (WSTOPSIG (status))
|
: TARGET_SIGNAL_0);
|
: TARGET_SIGNAL_0);
|
|
|
linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
|
0, signo);
|
0, signo);
|
}
|
}
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LHEW: Got clone event from LWP %ld, resuming\n",
|
"LHEW: Got clone event from LWP %ld, resuming\n",
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
0, TARGET_SIGNAL_0);
|
0, TARGET_SIGNAL_0);
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (event == PTRACE_EVENT_EXEC)
|
if (event == PTRACE_EVENT_EXEC)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LHEW: Got exec event from LWP %ld\n",
|
"LHEW: Got exec event from LWP %ld\n",
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
|
|
ourstatus->kind = TARGET_WAITKIND_EXECD;
|
ourstatus->kind = TARGET_WAITKIND_EXECD;
|
ourstatus->value.execd_pathname
|
ourstatus->value.execd_pathname
|
= xstrdup (linux_child_pid_to_exec_file (pid));
|
= xstrdup (linux_child_pid_to_exec_file (pid));
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (event == PTRACE_EVENT_VFORK_DONE)
|
if (event == PTRACE_EVENT_VFORK_DONE)
|
{
|
{
|
if (current_inferior ()->waiting_for_vfork_done)
|
if (current_inferior ()->waiting_for_vfork_done)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "\
|
fprintf_unfiltered (gdb_stdlog, "\
|
LHEW: Got expected PTRACE_EVENT_VFORK_DONE from LWP %ld: stopping\n",
|
LHEW: Got expected PTRACE_EVENT_VFORK_DONE from LWP %ld: stopping\n",
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
|
|
ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
|
ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "\
|
fprintf_unfiltered (gdb_stdlog, "\
|
LHEW: Got PTRACE_EVENT_VFORK_DONE from LWP %ld: resuming\n",
|
LHEW: Got PTRACE_EVENT_VFORK_DONE from LWP %ld: resuming\n",
|
GET_LWP (lp->ptid));
|
GET_LWP (lp->ptid));
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("unknown ptrace event %d"), event);
|
_("unknown ptrace event %d"), event);
|
}
|
}
|
|
|
/* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
|
/* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
|
exited. */
|
exited. */
|
|
|
static int
|
static int
|
wait_lwp (struct lwp_info *lp)
|
wait_lwp (struct lwp_info *lp)
|
{
|
{
|
pid_t pid;
|
pid_t pid;
|
int status;
|
int status;
|
int thread_dead = 0;
|
int thread_dead = 0;
|
|
|
gdb_assert (!lp->stopped);
|
gdb_assert (!lp->stopped);
|
gdb_assert (lp->status == 0);
|
gdb_assert (lp->status == 0);
|
|
|
pid = my_waitpid (GET_LWP (lp->ptid), &status, 0);
|
pid = my_waitpid (GET_LWP (lp->ptid), &status, 0);
|
if (pid == -1 && errno == ECHILD)
|
if (pid == -1 && errno == ECHILD)
|
{
|
{
|
pid = my_waitpid (GET_LWP (lp->ptid), &status, __WCLONE);
|
pid = my_waitpid (GET_LWP (lp->ptid), &status, __WCLONE);
|
if (pid == -1 && errno == ECHILD)
|
if (pid == -1 && errno == ECHILD)
|
{
|
{
|
/* The thread has previously exited. We need to delete it
|
/* The thread has previously exited. We need to delete it
|
now because, for some vendor 2.4 kernels with NPTL
|
now because, for some vendor 2.4 kernels with NPTL
|
support backported, there won't be an exit event unless
|
support backported, there won't be an exit event unless
|
it is the main thread. 2.6 kernels will report an exit
|
it is the main thread. 2.6 kernels will report an exit
|
event for each thread that exits, as expected. */
|
event for each thread that exits, as expected. */
|
thread_dead = 1;
|
thread_dead = 1;
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
|
fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
}
|
}
|
|
|
if (!thread_dead)
|
if (!thread_dead)
|
{
|
{
|
gdb_assert (pid == GET_LWP (lp->ptid));
|
gdb_assert (pid == GET_LWP (lp->ptid));
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"WL: waitpid %s received %s\n",
|
"WL: waitpid %s received %s\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
status_to_str (status));
|
status_to_str (status));
|
}
|
}
|
}
|
}
|
|
|
/* Check if the thread has exited. */
|
/* Check if the thread has exited. */
|
if (WIFEXITED (status) || WIFSIGNALED (status))
|
if (WIFEXITED (status) || WIFSIGNALED (status))
|
{
|
{
|
thread_dead = 1;
|
thread_dead = 1;
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
|
fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
|
|
if (thread_dead)
|
if (thread_dead)
|
{
|
{
|
exit_lwp (lp);
|
exit_lwp (lp);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
gdb_assert (WIFSTOPPED (status));
|
gdb_assert (WIFSTOPPED (status));
|
|
|
/* Handle GNU/Linux's syscall SIGTRAPs. */
|
/* Handle GNU/Linux's syscall SIGTRAPs. */
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
|
{
|
{
|
/* No longer need the sysgood bit. The ptrace event ends up
|
/* No longer need the sysgood bit. The ptrace event ends up
|
recorded in lp->waitstatus if we care for it. We can carry
|
recorded in lp->waitstatus if we care for it. We can carry
|
on handling the event like a regular SIGTRAP from here
|
on handling the event like a regular SIGTRAP from here
|
on. */
|
on. */
|
status = W_STOPCODE (SIGTRAP);
|
status = W_STOPCODE (SIGTRAP);
|
if (linux_handle_syscall_trap (lp, 1))
|
if (linux_handle_syscall_trap (lp, 1))
|
return wait_lwp (lp);
|
return wait_lwp (lp);
|
}
|
}
|
|
|
/* Handle GNU/Linux's extended waitstatus for trace events. */
|
/* Handle GNU/Linux's extended waitstatus for trace events. */
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"WL: Handling extended status 0x%06x\n",
|
"WL: Handling extended status 0x%06x\n",
|
status);
|
status);
|
if (linux_handle_extended_wait (lp, status, 1))
|
if (linux_handle_extended_wait (lp, status, 1))
|
return wait_lwp (lp);
|
return wait_lwp (lp);
|
}
|
}
|
|
|
return status;
|
return status;
|
}
|
}
|
|
|
/* Save the most recent siginfo for LP. This is currently only called
|
/* Save the most recent siginfo for LP. This is currently only called
|
for SIGTRAP; some ports use the si_addr field for
|
for SIGTRAP; some ports use the si_addr field for
|
target_stopped_data_address. In the future, it may also be used to
|
target_stopped_data_address. In the future, it may also be used to
|
restore the siginfo of requeued signals. */
|
restore the siginfo of requeued signals. */
|
|
|
static void
|
static void
|
save_siginfo (struct lwp_info *lp)
|
save_siginfo (struct lwp_info *lp)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
ptrace (PTRACE_GETSIGINFO, GET_LWP (lp->ptid),
|
ptrace (PTRACE_GETSIGINFO, GET_LWP (lp->ptid),
|
(PTRACE_TYPE_ARG3) 0, &lp->siginfo);
|
(PTRACE_TYPE_ARG3) 0, &lp->siginfo);
|
|
|
if (errno != 0)
|
if (errno != 0)
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
}
|
}
|
|
|
/* Send a SIGSTOP to LP. */
|
/* Send a SIGSTOP to LP. */
|
|
|
static int
|
static int
|
stop_callback (struct lwp_info *lp, void *data)
|
stop_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
if (!lp->stopped && !lp->signalled)
|
if (!lp->stopped && !lp->signalled)
|
{
|
{
|
int ret;
|
int ret;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SC: kill %s **<SIGSTOP>**\n",
|
"SC: kill %s **<SIGSTOP>**\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
errno = 0;
|
errno = 0;
|
ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
|
ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SC: lwp kill %d %s\n",
|
"SC: lwp kill %d %s\n",
|
ret,
|
ret,
|
errno ? safe_strerror (errno) : "ERRNO-OK");
|
errno ? safe_strerror (errno) : "ERRNO-OK");
|
}
|
}
|
|
|
lp->signalled = 1;
|
lp->signalled = 1;
|
gdb_assert (lp->status == 0);
|
gdb_assert (lp->status == 0);
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return non-zero if LWP PID has a pending SIGINT. */
|
/* Return non-zero if LWP PID has a pending SIGINT. */
|
|
|
static int
|
static int
|
linux_nat_has_pending_sigint (int pid)
|
linux_nat_has_pending_sigint (int pid)
|
{
|
{
|
sigset_t pending, blocked, ignored;
|
sigset_t pending, blocked, ignored;
|
int i;
|
int i;
|
|
|
linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
|
linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
|
|
|
if (sigismember (&pending, SIGINT)
|
if (sigismember (&pending, SIGINT)
|
&& !sigismember (&ignored, SIGINT))
|
&& !sigismember (&ignored, SIGINT))
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Set a flag in LP indicating that we should ignore its next SIGINT. */
|
/* Set a flag in LP indicating that we should ignore its next SIGINT. */
|
|
|
static int
|
static int
|
set_ignore_sigint (struct lwp_info *lp, void *data)
|
set_ignore_sigint (struct lwp_info *lp, void *data)
|
{
|
{
|
/* If a thread has a pending SIGINT, consume it; otherwise, set a
|
/* If a thread has a pending SIGINT, consume it; otherwise, set a
|
flag to consume the next one. */
|
flag to consume the next one. */
|
if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
|
if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
|
&& WSTOPSIG (lp->status) == SIGINT)
|
&& WSTOPSIG (lp->status) == SIGINT)
|
lp->status = 0;
|
lp->status = 0;
|
else
|
else
|
lp->ignore_sigint = 1;
|
lp->ignore_sigint = 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
|
/* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
|
This function is called after we know the LWP has stopped; if the LWP
|
This function is called after we know the LWP has stopped; if the LWP
|
stopped before the expected SIGINT was delivered, then it will never have
|
stopped before the expected SIGINT was delivered, then it will never have
|
arrived. Also, if the signal was delivered to a shared queue and consumed
|
arrived. Also, if the signal was delivered to a shared queue and consumed
|
by a different thread, it will never be delivered to this LWP. */
|
by a different thread, it will never be delivered to this LWP. */
|
|
|
static void
|
static void
|
maybe_clear_ignore_sigint (struct lwp_info *lp)
|
maybe_clear_ignore_sigint (struct lwp_info *lp)
|
{
|
{
|
if (!lp->ignore_sigint)
|
if (!lp->ignore_sigint)
|
return;
|
return;
|
|
|
if (!linux_nat_has_pending_sigint (GET_LWP (lp->ptid)))
|
if (!linux_nat_has_pending_sigint (GET_LWP (lp->ptid)))
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"MCIS: Clearing bogus flag for %s\n",
|
"MCIS: Clearing bogus flag for %s\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
lp->ignore_sigint = 0;
|
lp->ignore_sigint = 0;
|
}
|
}
|
}
|
}
|
|
|
/* Fetch the possible triggered data watchpoint info and store it in
|
/* Fetch the possible triggered data watchpoint info and store it in
|
LP.
|
LP.
|
|
|
On some archs, like x86, that use debug registers to set
|
On some archs, like x86, that use debug registers to set
|
watchpoints, it's possible that the way to know which watched
|
watchpoints, it's possible that the way to know which watched
|
address trapped, is to check the register that is used to select
|
address trapped, is to check the register that is used to select
|
which address to watch. Problem is, between setting the watchpoint
|
which address to watch. Problem is, between setting the watchpoint
|
and reading back which data address trapped, the user may change
|
and reading back which data address trapped, the user may change
|
the set of watchpoints, and, as a consequence, GDB changes the
|
the set of watchpoints, and, as a consequence, GDB changes the
|
debug registers in the inferior. To avoid reading back a stale
|
debug registers in the inferior. To avoid reading back a stale
|
stopped-data-address when that happens, we cache in LP the fact
|
stopped-data-address when that happens, we cache in LP the fact
|
that a watchpoint trapped, and the corresponding data address, as
|
that a watchpoint trapped, and the corresponding data address, as
|
soon as we see LP stop with a SIGTRAP. If GDB changes the debug
|
soon as we see LP stop with a SIGTRAP. If GDB changes the debug
|
registers meanwhile, we have the cached data we can rely on. */
|
registers meanwhile, we have the cached data we can rely on. */
|
|
|
static void
|
static void
|
save_sigtrap (struct lwp_info *lp)
|
save_sigtrap (struct lwp_info *lp)
|
{
|
{
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
|
|
if (linux_ops->to_stopped_by_watchpoint == NULL)
|
if (linux_ops->to_stopped_by_watchpoint == NULL)
|
{
|
{
|
lp->stopped_by_watchpoint = 0;
|
lp->stopped_by_watchpoint = 0;
|
return;
|
return;
|
}
|
}
|
|
|
old_chain = save_inferior_ptid ();
|
old_chain = save_inferior_ptid ();
|
inferior_ptid = lp->ptid;
|
inferior_ptid = lp->ptid;
|
|
|
lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint ();
|
lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint ();
|
|
|
if (lp->stopped_by_watchpoint)
|
if (lp->stopped_by_watchpoint)
|
{
|
{
|
if (linux_ops->to_stopped_data_address != NULL)
|
if (linux_ops->to_stopped_data_address != NULL)
|
lp->stopped_data_address_p =
|
lp->stopped_data_address_p =
|
linux_ops->to_stopped_data_address (¤t_target,
|
linux_ops->to_stopped_data_address (¤t_target,
|
&lp->stopped_data_address);
|
&lp->stopped_data_address);
|
else
|
else
|
lp->stopped_data_address_p = 0;
|
lp->stopped_data_address_p = 0;
|
}
|
}
|
|
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
/* See save_sigtrap. */
|
/* See save_sigtrap. */
|
|
|
static int
|
static int
|
linux_nat_stopped_by_watchpoint (void)
|
linux_nat_stopped_by_watchpoint (void)
|
{
|
{
|
struct lwp_info *lp = find_lwp_pid (inferior_ptid);
|
struct lwp_info *lp = find_lwp_pid (inferior_ptid);
|
|
|
gdb_assert (lp != NULL);
|
gdb_assert (lp != NULL);
|
|
|
return lp->stopped_by_watchpoint;
|
return lp->stopped_by_watchpoint;
|
}
|
}
|
|
|
static int
|
static int
|
linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
|
linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
|
{
|
{
|
struct lwp_info *lp = find_lwp_pid (inferior_ptid);
|
struct lwp_info *lp = find_lwp_pid (inferior_ptid);
|
|
|
gdb_assert (lp != NULL);
|
gdb_assert (lp != NULL);
|
|
|
*addr_p = lp->stopped_data_address;
|
*addr_p = lp->stopped_data_address;
|
|
|
return lp->stopped_data_address_p;
|
return lp->stopped_data_address_p;
|
}
|
}
|
|
|
/* Wait until LP is stopped. */
|
/* Wait until LP is stopped. */
|
|
|
static int
|
static int
|
stop_wait_callback (struct lwp_info *lp, void *data)
|
stop_wait_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
|
struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
|
|
|
/* If this is a vfork parent, bail out, it is not going to report
|
/* If this is a vfork parent, bail out, it is not going to report
|
any SIGSTOP until the vfork is done with. */
|
any SIGSTOP until the vfork is done with. */
|
if (inf->vfork_child != NULL)
|
if (inf->vfork_child != NULL)
|
return 0;
|
return 0;
|
|
|
if (!lp->stopped)
|
if (!lp->stopped)
|
{
|
{
|
int status;
|
int status;
|
|
|
status = wait_lwp (lp);
|
status = wait_lwp (lp);
|
if (status == 0)
|
if (status == 0)
|
return 0;
|
return 0;
|
|
|
if (lp->ignore_sigint && WIFSTOPPED (status)
|
if (lp->ignore_sigint && WIFSTOPPED (status)
|
&& WSTOPSIG (status) == SIGINT)
|
&& WSTOPSIG (status) == SIGINT)
|
{
|
{
|
lp->ignore_sigint = 0;
|
lp->ignore_sigint = 0;
|
|
|
errno = 0;
|
errno = 0;
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)\n",
|
"PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
errno ? safe_strerror (errno) : "OK");
|
errno ? safe_strerror (errno) : "OK");
|
|
|
return stop_wait_callback (lp, NULL);
|
return stop_wait_callback (lp, NULL);
|
}
|
}
|
|
|
maybe_clear_ignore_sigint (lp);
|
maybe_clear_ignore_sigint (lp);
|
|
|
if (WSTOPSIG (status) != SIGSTOP)
|
if (WSTOPSIG (status) != SIGSTOP)
|
{
|
{
|
if (WSTOPSIG (status) == SIGTRAP)
|
if (WSTOPSIG (status) == SIGTRAP)
|
{
|
{
|
/* If a LWP other than the LWP that we're reporting an
|
/* If a LWP other than the LWP that we're reporting an
|
event for has hit a GDB breakpoint (as opposed to
|
event for has hit a GDB breakpoint (as opposed to
|
some random trap signal), then just arrange for it to
|
some random trap signal), then just arrange for it to
|
hit it again later. We don't keep the SIGTRAP status
|
hit it again later. We don't keep the SIGTRAP status
|
and don't forward the SIGTRAP signal to the LWP. We
|
and don't forward the SIGTRAP signal to the LWP. We
|
will handle the current event, eventually we will
|
will handle the current event, eventually we will
|
resume all LWPs, and this one will get its breakpoint
|
resume all LWPs, and this one will get its breakpoint
|
trap again.
|
trap again.
|
|
|
If we do not do this, then we run the risk that the
|
If we do not do this, then we run the risk that the
|
user will delete or disable the breakpoint, but the
|
user will delete or disable the breakpoint, but the
|
thread will have already tripped on it. */
|
thread will have already tripped on it. */
|
|
|
/* Save the trap's siginfo in case we need it later. */
|
/* Save the trap's siginfo in case we need it later. */
|
save_siginfo (lp);
|
save_siginfo (lp);
|
|
|
save_sigtrap (lp);
|
save_sigtrap (lp);
|
|
|
/* Now resume this LWP and get the SIGSTOP event. */
|
/* Now resume this LWP and get the SIGSTOP event. */
|
errno = 0;
|
errno = 0;
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"PTRACE_CONT %s, 0, 0 (%s)\n",
|
"PTRACE_CONT %s, 0, 0 (%s)\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
errno ? safe_strerror (errno) : "OK");
|
errno ? safe_strerror (errno) : "OK");
|
|
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SWC: Candidate SIGTRAP event in %s\n",
|
"SWC: Candidate SIGTRAP event in %s\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
/* Hold this event/waitstatus while we check to see if
|
/* Hold this event/waitstatus while we check to see if
|
there are any more (we still want to get that SIGSTOP). */
|
there are any more (we still want to get that SIGSTOP). */
|
stop_wait_callback (lp, NULL);
|
stop_wait_callback (lp, NULL);
|
|
|
/* Hold the SIGTRAP for handling by linux_nat_wait. If
|
/* Hold the SIGTRAP for handling by linux_nat_wait. If
|
there's another event, throw it back into the
|
there's another event, throw it back into the
|
queue. */
|
queue. */
|
if (lp->status)
|
if (lp->status)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SWC: kill %s, %s\n",
|
"SWC: kill %s, %s\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
status_to_str ((int) status));
|
status_to_str ((int) status));
|
kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
|
kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
|
}
|
}
|
|
|
/* Save the sigtrap event. */
|
/* Save the sigtrap event. */
|
lp->status = status;
|
lp->status = status;
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* The thread was stopped with a signal other than
|
/* The thread was stopped with a signal other than
|
SIGSTOP, and didn't accidentally trip a breakpoint. */
|
SIGSTOP, and didn't accidentally trip a breakpoint. */
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SWC: Pending event %s in %s\n",
|
"SWC: Pending event %s in %s\n",
|
status_to_str ((int) status),
|
status_to_str ((int) status),
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
/* Now resume this LWP and get the SIGSTOP event. */
|
/* Now resume this LWP and get the SIGSTOP event. */
|
errno = 0;
|
errno = 0;
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
|
"SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
errno ? safe_strerror (errno) : "OK");
|
errno ? safe_strerror (errno) : "OK");
|
|
|
/* Hold this event/waitstatus while we check to see if
|
/* Hold this event/waitstatus while we check to see if
|
there are any more (we still want to get that SIGSTOP). */
|
there are any more (we still want to get that SIGSTOP). */
|
stop_wait_callback (lp, NULL);
|
stop_wait_callback (lp, NULL);
|
|
|
/* If the lp->status field is still empty, use it to
|
/* If the lp->status field is still empty, use it to
|
hold this event. If not, then this event must be
|
hold this event. If not, then this event must be
|
returned to the event queue of the LWP. */
|
returned to the event queue of the LWP. */
|
if (lp->status)
|
if (lp->status)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SWC: kill %s, %s\n",
|
"SWC: kill %s, %s\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
status_to_str ((int) status));
|
status_to_str ((int) status));
|
}
|
}
|
kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
|
kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
|
}
|
}
|
else
|
else
|
lp->status = status;
|
lp->status = status;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We caught the SIGSTOP that we intended to catch, so
|
/* We caught the SIGSTOP that we intended to catch, so
|
there's no SIGSTOP pending. */
|
there's no SIGSTOP pending. */
|
lp->stopped = 1;
|
lp->stopped = 1;
|
lp->signalled = 0;
|
lp->signalled = 0;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return non-zero if LP has a wait status pending. */
|
/* Return non-zero if LP has a wait status pending. */
|
|
|
static int
|
static int
|
status_callback (struct lwp_info *lp, void *data)
|
status_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
/* Only report a pending wait status if we pretend that this has
|
/* Only report a pending wait status if we pretend that this has
|
indeed been resumed. */
|
indeed been resumed. */
|
if (!lp->resumed)
|
if (!lp->resumed)
|
return 0;
|
return 0;
|
|
|
if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
{
|
{
|
/* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
|
/* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
|
or a a pending process exit. Note that `W_EXITCODE(0,0) ==
|
or a a pending process exit. Note that `W_EXITCODE(0,0) ==
|
0', so a clean process exit can not be stored pending in
|
0', so a clean process exit can not be stored pending in
|
lp->status, it is indistinguishable from
|
lp->status, it is indistinguishable from
|
no-pending-status. */
|
no-pending-status. */
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (lp->status != 0)
|
if (lp->status != 0)
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return non-zero if LP isn't stopped. */
|
/* Return non-zero if LP isn't stopped. */
|
|
|
static int
|
static int
|
running_callback (struct lwp_info *lp, void *data)
|
running_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
return (lp->stopped == 0 || (lp->status != 0 && lp->resumed));
|
return (lp->stopped == 0 || (lp->status != 0 && lp->resumed));
|
}
|
}
|
|
|
/* Count the LWP's that have had events. */
|
/* Count the LWP's that have had events. */
|
|
|
static int
|
static int
|
count_events_callback (struct lwp_info *lp, void *data)
|
count_events_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
int *count = data;
|
int *count = data;
|
|
|
gdb_assert (count != NULL);
|
gdb_assert (count != NULL);
|
|
|
/* Count only resumed LWPs that have a SIGTRAP event pending. */
|
/* Count only resumed LWPs that have a SIGTRAP event pending. */
|
if (lp->status != 0 && lp->resumed
|
if (lp->status != 0 && lp->resumed
|
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
|
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
|
(*count)++;
|
(*count)++;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Select the LWP (if any) that is currently being single-stepped. */
|
/* Select the LWP (if any) that is currently being single-stepped. */
|
|
|
static int
|
static int
|
select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
|
select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
if (lp->step && lp->status != 0)
|
if (lp->step && lp->status != 0)
|
return 1;
|
return 1;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Select the Nth LWP that has had a SIGTRAP event. */
|
/* Select the Nth LWP that has had a SIGTRAP event. */
|
|
|
static int
|
static int
|
select_event_lwp_callback (struct lwp_info *lp, void *data)
|
select_event_lwp_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
int *selector = data;
|
int *selector = data;
|
|
|
gdb_assert (selector != NULL);
|
gdb_assert (selector != NULL);
|
|
|
/* Select only resumed LWPs that have a SIGTRAP event pending. */
|
/* Select only resumed LWPs that have a SIGTRAP event pending. */
|
if (lp->status != 0 && lp->resumed
|
if (lp->status != 0 && lp->resumed
|
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
|
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
|
if ((*selector)-- == 0)
|
if ((*selector)-- == 0)
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
cancel_breakpoint (struct lwp_info *lp)
|
cancel_breakpoint (struct lwp_info *lp)
|
{
|
{
|
/* Arrange for a breakpoint to be hit again later. We don't keep
|
/* Arrange for a breakpoint to be hit again later. We don't keep
|
the SIGTRAP status and don't forward the SIGTRAP signal to the
|
the SIGTRAP status and don't forward the SIGTRAP signal to the
|
LWP. We will handle the current event, eventually we will resume
|
LWP. We will handle the current event, eventually we will resume
|
this LWP, and this breakpoint will trap again.
|
this LWP, and this breakpoint will trap again.
|
|
|
If we do not do this, then we run the risk that the user will
|
If we do not do this, then we run the risk that the user will
|
delete or disable the breakpoint, but the LWP will have already
|
delete or disable the breakpoint, but the LWP will have already
|
tripped on it. */
|
tripped on it. */
|
|
|
struct regcache *regcache = get_thread_regcache (lp->ptid);
|
struct regcache *regcache = get_thread_regcache (lp->ptid);
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
CORE_ADDR pc;
|
CORE_ADDR pc;
|
|
|
pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
|
pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
|
if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
|
if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"CB: Push back breakpoint for %s\n",
|
"CB: Push back breakpoint for %s\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
/* Back up the PC if necessary. */
|
/* Back up the PC if necessary. */
|
if (gdbarch_decr_pc_after_break (gdbarch))
|
if (gdbarch_decr_pc_after_break (gdbarch))
|
regcache_write_pc (regcache, pc);
|
regcache_write_pc (regcache, pc);
|
|
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
cancel_breakpoints_callback (struct lwp_info *lp, void *data)
|
cancel_breakpoints_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
struct lwp_info *event_lp = data;
|
struct lwp_info *event_lp = data;
|
|
|
/* Leave the LWP that has been elected to receive a SIGTRAP alone. */
|
/* Leave the LWP that has been elected to receive a SIGTRAP alone. */
|
if (lp == event_lp)
|
if (lp == event_lp)
|
return 0;
|
return 0;
|
|
|
/* If a LWP other than the LWP that we're reporting an event for has
|
/* If a LWP other than the LWP that we're reporting an event for has
|
hit a GDB breakpoint (as opposed to some random trap signal),
|
hit a GDB breakpoint (as opposed to some random trap signal),
|
then just arrange for it to hit it again later. We don't keep
|
then just arrange for it to hit it again later. We don't keep
|
the SIGTRAP status and don't forward the SIGTRAP signal to the
|
the SIGTRAP status and don't forward the SIGTRAP signal to the
|
LWP. We will handle the current event, eventually we will resume
|
LWP. We will handle the current event, eventually we will resume
|
all LWPs, and this one will get its breakpoint trap again.
|
all LWPs, and this one will get its breakpoint trap again.
|
|
|
If we do not do this, then we run the risk that the user will
|
If we do not do this, then we run the risk that the user will
|
delete or disable the breakpoint, but the LWP will have already
|
delete or disable the breakpoint, but the LWP will have already
|
tripped on it. */
|
tripped on it. */
|
|
|
if (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
|
if (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
|
&& lp->status != 0
|
&& lp->status != 0
|
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
|
&& WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
|
&& cancel_breakpoint (lp))
|
&& cancel_breakpoint (lp))
|
/* Throw away the SIGTRAP. */
|
/* Throw away the SIGTRAP. */
|
lp->status = 0;
|
lp->status = 0;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Select one LWP out of those that have events pending. */
|
/* Select one LWP out of those that have events pending. */
|
|
|
static void
|
static void
|
select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
|
select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
|
{
|
{
|
int num_events = 0;
|
int num_events = 0;
|
int random_selector;
|
int random_selector;
|
struct lwp_info *event_lp;
|
struct lwp_info *event_lp;
|
|
|
/* Record the wait status for the original LWP. */
|
/* Record the wait status for the original LWP. */
|
(*orig_lp)->status = *status;
|
(*orig_lp)->status = *status;
|
|
|
/* Give preference to any LWP that is being single-stepped. */
|
/* Give preference to any LWP that is being single-stepped. */
|
event_lp = iterate_over_lwps (filter,
|
event_lp = iterate_over_lwps (filter,
|
select_singlestep_lwp_callback, NULL);
|
select_singlestep_lwp_callback, NULL);
|
if (event_lp != NULL)
|
if (event_lp != NULL)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SEL: Select single-step %s\n",
|
"SEL: Select single-step %s\n",
|
target_pid_to_str (event_lp->ptid));
|
target_pid_to_str (event_lp->ptid));
|
}
|
}
|
else
|
else
|
{
|
{
|
/* No single-stepping LWP. Select one at random, out of those
|
/* No single-stepping LWP. Select one at random, out of those
|
which have had SIGTRAP events. */
|
which have had SIGTRAP events. */
|
|
|
/* First see how many SIGTRAP events we have. */
|
/* First see how many SIGTRAP events we have. */
|
iterate_over_lwps (filter, count_events_callback, &num_events);
|
iterate_over_lwps (filter, count_events_callback, &num_events);
|
|
|
/* Now randomly pick a LWP out of those that have had a SIGTRAP. */
|
/* Now randomly pick a LWP out of those that have had a SIGTRAP. */
|
random_selector = (int)
|
random_selector = (int)
|
((num_events * (double) rand ()) / (RAND_MAX + 1.0));
|
((num_events * (double) rand ()) / (RAND_MAX + 1.0));
|
|
|
if (debug_linux_nat && num_events > 1)
|
if (debug_linux_nat && num_events > 1)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"SEL: Found %d SIGTRAP events, selecting #%d\n",
|
"SEL: Found %d SIGTRAP events, selecting #%d\n",
|
num_events, random_selector);
|
num_events, random_selector);
|
|
|
event_lp = iterate_over_lwps (filter,
|
event_lp = iterate_over_lwps (filter,
|
select_event_lwp_callback,
|
select_event_lwp_callback,
|
&random_selector);
|
&random_selector);
|
}
|
}
|
|
|
if (event_lp != NULL)
|
if (event_lp != NULL)
|
{
|
{
|
/* Switch the event LWP. */
|
/* Switch the event LWP. */
|
*orig_lp = event_lp;
|
*orig_lp = event_lp;
|
*status = event_lp->status;
|
*status = event_lp->status;
|
}
|
}
|
|
|
/* Flush the wait status for the event LWP. */
|
/* Flush the wait status for the event LWP. */
|
(*orig_lp)->status = 0;
|
(*orig_lp)->status = 0;
|
}
|
}
|
|
|
/* Return non-zero if LP has been resumed. */
|
/* Return non-zero if LP has been resumed. */
|
|
|
static int
|
static int
|
resumed_callback (struct lwp_info *lp, void *data)
|
resumed_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
return lp->resumed;
|
return lp->resumed;
|
}
|
}
|
|
|
/* Stop an active thread, verify it still exists, then resume it. */
|
/* Stop an active thread, verify it still exists, then resume it. */
|
|
|
static int
|
static int
|
stop_and_resume_callback (struct lwp_info *lp, void *data)
|
stop_and_resume_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
struct lwp_info *ptr;
|
struct lwp_info *ptr;
|
|
|
if (!lp->stopped && !lp->signalled)
|
if (!lp->stopped && !lp->signalled)
|
{
|
{
|
stop_callback (lp, NULL);
|
stop_callback (lp, NULL);
|
stop_wait_callback (lp, NULL);
|
stop_wait_callback (lp, NULL);
|
/* Resume if the lwp still exists. */
|
/* Resume if the lwp still exists. */
|
for (ptr = lwp_list; ptr; ptr = ptr->next)
|
for (ptr = lwp_list; ptr; ptr = ptr->next)
|
if (lp == ptr)
|
if (lp == ptr)
|
{
|
{
|
resume_callback (lp, NULL);
|
resume_callback (lp, NULL);
|
resume_set_callback (lp, NULL);
|
resume_set_callback (lp, NULL);
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Check if we should go on and pass this event to common code.
|
/* Check if we should go on and pass this event to common code.
|
Return the affected lwp if we are, or NULL otherwise. */
|
Return the affected lwp if we are, or NULL otherwise. */
|
static struct lwp_info *
|
static struct lwp_info *
|
linux_nat_filter_event (int lwpid, int status, int options)
|
linux_nat_filter_event (int lwpid, int status, int options)
|
{
|
{
|
struct lwp_info *lp;
|
struct lwp_info *lp;
|
|
|
lp = find_lwp_pid (pid_to_ptid (lwpid));
|
lp = find_lwp_pid (pid_to_ptid (lwpid));
|
|
|
/* Check for stop events reported by a process we didn't already
|
/* Check for stop events reported by a process we didn't already
|
know about - anything not already in our LWP list.
|
know about - anything not already in our LWP list.
|
|
|
If we're expecting to receive stopped processes after
|
If we're expecting to receive stopped processes after
|
fork, vfork, and clone events, then we'll just add the
|
fork, vfork, and clone events, then we'll just add the
|
new one to our list and go back to waiting for the event
|
new one to our list and go back to waiting for the event
|
to be reported - the stopped process might be returned
|
to be reported - the stopped process might be returned
|
from waitpid before or after the event is. */
|
from waitpid before or after the event is. */
|
if (WIFSTOPPED (status) && !lp)
|
if (WIFSTOPPED (status) && !lp)
|
{
|
{
|
linux_record_stopped_pid (lwpid, status);
|
linux_record_stopped_pid (lwpid, status);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Make sure we don't report an event for the exit of an LWP not in
|
/* Make sure we don't report an event for the exit of an LWP not in
|
our list, i.e. not part of the current process. This can happen
|
our list, i.e. not part of the current process. This can happen
|
if we detach from a program we original forked and then it
|
if we detach from a program we original forked and then it
|
exits. */
|
exits. */
|
if (!WIFSTOPPED (status) && !lp)
|
if (!WIFSTOPPED (status) && !lp)
|
return NULL;
|
return NULL;
|
|
|
/* NOTE drow/2003-06-17: This code seems to be meant for debugging
|
/* NOTE drow/2003-06-17: This code seems to be meant for debugging
|
CLONE_PTRACE processes which do not use the thread library -
|
CLONE_PTRACE processes which do not use the thread library -
|
otherwise we wouldn't find the new LWP this way. That doesn't
|
otherwise we wouldn't find the new LWP this way. That doesn't
|
currently work, and the following code is currently unreachable
|
currently work, and the following code is currently unreachable
|
due to the two blocks above. If it's fixed some day, this code
|
due to the two blocks above. If it's fixed some day, this code
|
should be broken out into a function so that we can also pick up
|
should be broken out into a function so that we can also pick up
|
LWPs from the new interface. */
|
LWPs from the new interface. */
|
if (!lp)
|
if (!lp)
|
{
|
{
|
lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
|
lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
|
if (options & __WCLONE)
|
if (options & __WCLONE)
|
lp->cloned = 1;
|
lp->cloned = 1;
|
|
|
gdb_assert (WIFSTOPPED (status)
|
gdb_assert (WIFSTOPPED (status)
|
&& WSTOPSIG (status) == SIGSTOP);
|
&& WSTOPSIG (status) == SIGSTOP);
|
lp->signalled = 1;
|
lp->signalled = 1;
|
|
|
if (!in_thread_list (inferior_ptid))
|
if (!in_thread_list (inferior_ptid))
|
{
|
{
|
inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
|
inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
|
GET_PID (inferior_ptid));
|
GET_PID (inferior_ptid));
|
add_thread (inferior_ptid);
|
add_thread (inferior_ptid);
|
}
|
}
|
|
|
add_thread (lp->ptid);
|
add_thread (lp->ptid);
|
}
|
}
|
|
|
/* Handle GNU/Linux's syscall SIGTRAPs. */
|
/* Handle GNU/Linux's syscall SIGTRAPs. */
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
|
{
|
{
|
/* No longer need the sysgood bit. The ptrace event ends up
|
/* No longer need the sysgood bit. The ptrace event ends up
|
recorded in lp->waitstatus if we care for it. We can carry
|
recorded in lp->waitstatus if we care for it. We can carry
|
on handling the event like a regular SIGTRAP from here
|
on handling the event like a regular SIGTRAP from here
|
on. */
|
on. */
|
status = W_STOPCODE (SIGTRAP);
|
status = W_STOPCODE (SIGTRAP);
|
if (linux_handle_syscall_trap (lp, 0))
|
if (linux_handle_syscall_trap (lp, 0))
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Handle GNU/Linux's extended waitstatus for trace events. */
|
/* Handle GNU/Linux's extended waitstatus for trace events. */
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: Handling extended status 0x%06x\n",
|
"LLW: Handling extended status 0x%06x\n",
|
status);
|
status);
|
if (linux_handle_extended_wait (lp, status, 0))
|
if (linux_handle_extended_wait (lp, status, 0))
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
|
{
|
{
|
/* Save the trap's siginfo in case we need it later. */
|
/* Save the trap's siginfo in case we need it later. */
|
save_siginfo (lp);
|
save_siginfo (lp);
|
|
|
save_sigtrap (lp);
|
save_sigtrap (lp);
|
}
|
}
|
|
|
/* Check if the thread has exited. */
|
/* Check if the thread has exited. */
|
if ((WIFEXITED (status) || WIFSIGNALED (status))
|
if ((WIFEXITED (status) || WIFSIGNALED (status))
|
&& num_lwps (GET_PID (lp->ptid)) > 1)
|
&& num_lwps (GET_PID (lp->ptid)) > 1)
|
{
|
{
|
/* If this is the main thread, we must stop all threads and verify
|
/* If this is the main thread, we must stop all threads and verify
|
if they are still alive. This is because in the nptl thread model
|
if they are still alive. This is because in the nptl thread model
|
on Linux 2.4, there is no signal issued for exiting LWPs
|
on Linux 2.4, there is no signal issued for exiting LWPs
|
other than the main thread. We only get the main thread exit
|
other than the main thread. We only get the main thread exit
|
signal once all child threads have already exited. If we
|
signal once all child threads have already exited. If we
|
stop all the threads and use the stop_wait_callback to check
|
stop all the threads and use the stop_wait_callback to check
|
if they have exited we can determine whether this signal
|
if they have exited we can determine whether this signal
|
should be ignored or whether it means the end of the debugged
|
should be ignored or whether it means the end of the debugged
|
application, regardless of which threading model is being
|
application, regardless of which threading model is being
|
used. */
|
used. */
|
if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
|
if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
|
{
|
{
|
lp->stopped = 1;
|
lp->stopped = 1;
|
iterate_over_lwps (pid_to_ptid (GET_PID (lp->ptid)),
|
iterate_over_lwps (pid_to_ptid (GET_PID (lp->ptid)),
|
stop_and_resume_callback, NULL);
|
stop_and_resume_callback, NULL);
|
}
|
}
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: %s exited.\n",
|
"LLW: %s exited.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
if (num_lwps (GET_PID (lp->ptid)) > 1)
|
if (num_lwps (GET_PID (lp->ptid)) > 1)
|
{
|
{
|
/* If there is at least one more LWP, then the exit signal
|
/* If there is at least one more LWP, then the exit signal
|
was not the end of the debugged application and should be
|
was not the end of the debugged application and should be
|
ignored. */
|
ignored. */
|
exit_lwp (lp);
|
exit_lwp (lp);
|
return NULL;
|
return NULL;
|
}
|
}
|
}
|
}
|
|
|
/* Check if the current LWP has previously exited. In the nptl
|
/* Check if the current LWP has previously exited. In the nptl
|
thread model, LWPs other than the main thread do not issue
|
thread model, LWPs other than the main thread do not issue
|
signals when they exit so we must check whenever the thread has
|
signals when they exit so we must check whenever the thread has
|
stopped. A similar check is made in stop_wait_callback(). */
|
stopped. A similar check is made in stop_wait_callback(). */
|
if (num_lwps (GET_PID (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
|
if (num_lwps (GET_PID (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
|
{
|
{
|
ptid_t ptid = pid_to_ptid (GET_PID (lp->ptid));
|
ptid_t ptid = pid_to_ptid (GET_PID (lp->ptid));
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: %s exited.\n",
|
"LLW: %s exited.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
exit_lwp (lp);
|
exit_lwp (lp);
|
|
|
/* Make sure there is at least one thread running. */
|
/* Make sure there is at least one thread running. */
|
gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
|
gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
|
|
|
/* Discard the event. */
|
/* Discard the event. */
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Make sure we don't report a SIGSTOP that we sent ourselves in
|
/* Make sure we don't report a SIGSTOP that we sent ourselves in
|
an attempt to stop an LWP. */
|
an attempt to stop an LWP. */
|
if (lp->signalled
|
if (lp->signalled
|
&& WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
|
&& WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: Delayed SIGSTOP caught for %s.\n",
|
"LLW: Delayed SIGSTOP caught for %s.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
/* This is a delayed SIGSTOP. */
|
/* This is a delayed SIGSTOP. */
|
lp->signalled = 0;
|
lp->signalled = 0;
|
|
|
registers_changed ();
|
registers_changed ();
|
|
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
lp->step, TARGET_SIGNAL_0);
|
lp->step, TARGET_SIGNAL_0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
|
"LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
|
lp->step ?
|
lp->step ?
|
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
lp->stopped = 0;
|
lp->stopped = 0;
|
gdb_assert (lp->resumed);
|
gdb_assert (lp->resumed);
|
|
|
/* Discard the event. */
|
/* Discard the event. */
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Make sure we don't report a SIGINT that we have already displayed
|
/* Make sure we don't report a SIGINT that we have already displayed
|
for another thread. */
|
for another thread. */
|
if (lp->ignore_sigint
|
if (lp->ignore_sigint
|
&& WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
|
&& WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: Delayed SIGINT caught for %s.\n",
|
"LLW: Delayed SIGINT caught for %s.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
/* This is a delayed SIGINT. */
|
/* This is a delayed SIGINT. */
|
lp->ignore_sigint = 0;
|
lp->ignore_sigint = 0;
|
|
|
registers_changed ();
|
registers_changed ();
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
lp->step, TARGET_SIGNAL_0);
|
lp->step, TARGET_SIGNAL_0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: %s %s, 0, 0 (discard SIGINT)\n",
|
"LLW: %s %s, 0, 0 (discard SIGINT)\n",
|
lp->step ?
|
lp->step ?
|
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
lp->stopped = 0;
|
lp->stopped = 0;
|
gdb_assert (lp->resumed);
|
gdb_assert (lp->resumed);
|
|
|
/* Discard the event. */
|
/* Discard the event. */
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* An interesting event. */
|
/* An interesting event. */
|
gdb_assert (lp);
|
gdb_assert (lp);
|
lp->status = status;
|
lp->status = status;
|
return lp;
|
return lp;
|
}
|
}
|
|
|
static ptid_t
|
static ptid_t
|
linux_nat_wait_1 (struct target_ops *ops,
|
linux_nat_wait_1 (struct target_ops *ops,
|
ptid_t ptid, struct target_waitstatus *ourstatus,
|
ptid_t ptid, struct target_waitstatus *ourstatus,
|
int target_options)
|
int target_options)
|
{
|
{
|
static sigset_t prev_mask;
|
static sigset_t prev_mask;
|
struct lwp_info *lp = NULL;
|
struct lwp_info *lp = NULL;
|
int options = 0;
|
int options = 0;
|
int status = 0;
|
int status = 0;
|
pid_t pid;
|
pid_t pid;
|
|
|
if (debug_linux_nat_async)
|
if (debug_linux_nat_async)
|
fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
|
fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
|
|
|
/* The first time we get here after starting a new inferior, we may
|
/* The first time we get here after starting a new inferior, we may
|
not have added it to the LWP list yet - this is the earliest
|
not have added it to the LWP list yet - this is the earliest
|
moment at which we know its PID. */
|
moment at which we know its PID. */
|
if (ptid_is_pid (inferior_ptid))
|
if (ptid_is_pid (inferior_ptid))
|
{
|
{
|
/* Upgrade the main thread's ptid. */
|
/* Upgrade the main thread's ptid. */
|
thread_change_ptid (inferior_ptid,
|
thread_change_ptid (inferior_ptid,
|
BUILD_LWP (GET_PID (inferior_ptid),
|
BUILD_LWP (GET_PID (inferior_ptid),
|
GET_PID (inferior_ptid)));
|
GET_PID (inferior_ptid)));
|
|
|
lp = add_lwp (inferior_ptid);
|
lp = add_lwp (inferior_ptid);
|
lp->resumed = 1;
|
lp->resumed = 1;
|
}
|
}
|
|
|
/* Make sure SIGCHLD is blocked. */
|
/* Make sure SIGCHLD is blocked. */
|
block_child_signals (&prev_mask);
|
block_child_signals (&prev_mask);
|
|
|
if (ptid_equal (ptid, minus_one_ptid))
|
if (ptid_equal (ptid, minus_one_ptid))
|
pid = -1;
|
pid = -1;
|
else if (ptid_is_pid (ptid))
|
else if (ptid_is_pid (ptid))
|
/* A request to wait for a specific tgid. This is not possible
|
/* A request to wait for a specific tgid. This is not possible
|
with waitpid, so instead, we wait for any child, and leave
|
with waitpid, so instead, we wait for any child, and leave
|
children we're not interested in right now with a pending
|
children we're not interested in right now with a pending
|
status to report later. */
|
status to report later. */
|
pid = -1;
|
pid = -1;
|
else
|
else
|
pid = GET_LWP (ptid);
|
pid = GET_LWP (ptid);
|
|
|
retry:
|
retry:
|
lp = NULL;
|
lp = NULL;
|
status = 0;
|
status = 0;
|
|
|
/* Make sure that of those LWPs we want to get an event from, there
|
/* Make sure that of those LWPs we want to get an event from, there
|
is at least one LWP that has been resumed. If there's none, just
|
is at least one LWP that has been resumed. If there's none, just
|
bail out. The core may just be flushing asynchronously all
|
bail out. The core may just be flushing asynchronously all
|
events. */
|
events. */
|
if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
|
if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
|
{
|
{
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
|
|
if (debug_linux_nat_async)
|
if (debug_linux_nat_async)
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
|
|
/* First check if there is a LWP with a wait status pending. */
|
/* First check if there is a LWP with a wait status pending. */
|
if (pid == -1)
|
if (pid == -1)
|
{
|
{
|
/* Any LWP that's been resumed will do. */
|
/* Any LWP that's been resumed will do. */
|
lp = iterate_over_lwps (ptid, status_callback, NULL);
|
lp = iterate_over_lwps (ptid, status_callback, NULL);
|
if (lp)
|
if (lp)
|
{
|
{
|
if (debug_linux_nat && lp->status)
|
if (debug_linux_nat && lp->status)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: Using pending wait status %s for %s.\n",
|
"LLW: Using pending wait status %s for %s.\n",
|
status_to_str (lp->status),
|
status_to_str (lp->status),
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
|
|
/* But if we don't find one, we'll have to wait, and check both
|
/* But if we don't find one, we'll have to wait, and check both
|
cloned and uncloned processes. We start with the cloned
|
cloned and uncloned processes. We start with the cloned
|
processes. */
|
processes. */
|
options = __WCLONE | WNOHANG;
|
options = __WCLONE | WNOHANG;
|
}
|
}
|
else if (is_lwp (ptid))
|
else if (is_lwp (ptid))
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: Waiting for specific LWP %s.\n",
|
"LLW: Waiting for specific LWP %s.\n",
|
target_pid_to_str (ptid));
|
target_pid_to_str (ptid));
|
|
|
/* We have a specific LWP to check. */
|
/* We have a specific LWP to check. */
|
lp = find_lwp_pid (ptid);
|
lp = find_lwp_pid (ptid);
|
gdb_assert (lp);
|
gdb_assert (lp);
|
|
|
if (debug_linux_nat && lp->status)
|
if (debug_linux_nat && lp->status)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: Using pending wait status %s for %s.\n",
|
"LLW: Using pending wait status %s for %s.\n",
|
status_to_str (lp->status),
|
status_to_str (lp->status),
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
/* If we have to wait, take into account whether PID is a cloned
|
/* If we have to wait, take into account whether PID is a cloned
|
process or not. And we have to convert it to something that
|
process or not. And we have to convert it to something that
|
the layer beneath us can understand. */
|
the layer beneath us can understand. */
|
options = lp->cloned ? __WCLONE : 0;
|
options = lp->cloned ? __WCLONE : 0;
|
pid = GET_LWP (ptid);
|
pid = GET_LWP (ptid);
|
|
|
/* We check for lp->waitstatus in addition to lp->status,
|
/* We check for lp->waitstatus in addition to lp->status,
|
because we can have pending process exits recorded in
|
because we can have pending process exits recorded in
|
lp->status and W_EXITCODE(0,0) == 0. We should probably have
|
lp->status and W_EXITCODE(0,0) == 0. We should probably have
|
an additional lp->status_p flag. */
|
an additional lp->status_p flag. */
|
if (lp->status == 0 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
|
if (lp->status == 0 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
|
lp = NULL;
|
lp = NULL;
|
}
|
}
|
|
|
if (lp && lp->signalled)
|
if (lp && lp->signalled)
|
{
|
{
|
/* A pending SIGSTOP may interfere with the normal stream of
|
/* A pending SIGSTOP may interfere with the normal stream of
|
events. In a typical case where interference is a problem,
|
events. In a typical case where interference is a problem,
|
we have a SIGSTOP signal pending for LWP A while
|
we have a SIGSTOP signal pending for LWP A while
|
single-stepping it, encounter an event in LWP B, and take the
|
single-stepping it, encounter an event in LWP B, and take the
|
pending SIGSTOP while trying to stop LWP A. After processing
|
pending SIGSTOP while trying to stop LWP A. After processing
|
the event in LWP B, LWP A is continued, and we'll never see
|
the event in LWP B, LWP A is continued, and we'll never see
|
the SIGTRAP associated with the last time we were
|
the SIGTRAP associated with the last time we were
|
single-stepping LWP A. */
|
single-stepping LWP A. */
|
|
|
/* Resume the thread. It should halt immediately returning the
|
/* Resume the thread. It should halt immediately returning the
|
pending SIGSTOP. */
|
pending SIGSTOP. */
|
registers_changed ();
|
registers_changed ();
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
lp->step, TARGET_SIGNAL_0);
|
lp->step, TARGET_SIGNAL_0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
|
"LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
|
lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
lp->stopped = 0;
|
lp->stopped = 0;
|
gdb_assert (lp->resumed);
|
gdb_assert (lp->resumed);
|
|
|
/* Catch the pending SIGSTOP. */
|
/* Catch the pending SIGSTOP. */
|
status = lp->status;
|
status = lp->status;
|
lp->status = 0;
|
lp->status = 0;
|
|
|
stop_wait_callback (lp, NULL);
|
stop_wait_callback (lp, NULL);
|
|
|
/* If the lp->status field isn't empty, we caught another signal
|
/* If the lp->status field isn't empty, we caught another signal
|
while flushing the SIGSTOP. Return it back to the event
|
while flushing the SIGSTOP. Return it back to the event
|
queue of the LWP, as we already have an event to handle. */
|
queue of the LWP, as we already have an event to handle. */
|
if (lp->status)
|
if (lp->status)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: kill %s, %s\n",
|
"LLW: kill %s, %s\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
status_to_str (lp->status));
|
status_to_str (lp->status));
|
kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
|
kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
|
}
|
}
|
|
|
lp->status = status;
|
lp->status = status;
|
}
|
}
|
|
|
if (!target_can_async_p ())
|
if (!target_can_async_p ())
|
{
|
{
|
/* Causes SIGINT to be passed on to the attached process. */
|
/* Causes SIGINT to be passed on to the attached process. */
|
set_sigint_trap ();
|
set_sigint_trap ();
|
}
|
}
|
|
|
/* Translate generic target_wait options into waitpid options. */
|
/* Translate generic target_wait options into waitpid options. */
|
if (target_options & TARGET_WNOHANG)
|
if (target_options & TARGET_WNOHANG)
|
options |= WNOHANG;
|
options |= WNOHANG;
|
|
|
while (lp == NULL)
|
while (lp == NULL)
|
{
|
{
|
pid_t lwpid;
|
pid_t lwpid;
|
|
|
lwpid = my_waitpid (pid, &status, options);
|
lwpid = my_waitpid (pid, &status, options);
|
|
|
if (lwpid > 0)
|
if (lwpid > 0)
|
{
|
{
|
gdb_assert (pid == -1 || lwpid == pid);
|
gdb_assert (pid == -1 || lwpid == pid);
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: waitpid %ld received %s\n",
|
"LLW: waitpid %ld received %s\n",
|
(long) lwpid, status_to_str (status));
|
(long) lwpid, status_to_str (status));
|
}
|
}
|
|
|
lp = linux_nat_filter_event (lwpid, status, options);
|
lp = linux_nat_filter_event (lwpid, status, options);
|
|
|
if (lp
|
if (lp
|
&& ptid_is_pid (ptid)
|
&& ptid_is_pid (ptid)
|
&& ptid_get_pid (lp->ptid) != ptid_get_pid (ptid))
|
&& ptid_get_pid (lp->ptid) != ptid_get_pid (ptid))
|
{
|
{
|
gdb_assert (lp->resumed);
|
gdb_assert (lp->resumed);
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf (stderr, "LWP %ld got an event %06x, leaving pending.\n",
|
fprintf (stderr, "LWP %ld got an event %06x, leaving pending.\n",
|
ptid_get_lwp (lp->ptid), status);
|
ptid_get_lwp (lp->ptid), status);
|
|
|
if (WIFSTOPPED (lp->status))
|
if (WIFSTOPPED (lp->status))
|
{
|
{
|
if (WSTOPSIG (lp->status) != SIGSTOP)
|
if (WSTOPSIG (lp->status) != SIGSTOP)
|
{
|
{
|
/* Cancel breakpoint hits. The breakpoint may
|
/* Cancel breakpoint hits. The breakpoint may
|
be removed before we fetch events from this
|
be removed before we fetch events from this
|
process to report to the core. It is best
|
process to report to the core. It is best
|
not to assume the moribund breakpoints
|
not to assume the moribund breakpoints
|
heuristic always handles these cases --- it
|
heuristic always handles these cases --- it
|
could be too many events go through to the
|
could be too many events go through to the
|
core before this one is handled. All-stop
|
core before this one is handled. All-stop
|
always cancels breakpoint hits in all
|
always cancels breakpoint hits in all
|
threads. */
|
threads. */
|
if (non_stop
|
if (non_stop
|
&& lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
|
&& lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
|
&& WSTOPSIG (lp->status) == SIGTRAP
|
&& WSTOPSIG (lp->status) == SIGTRAP
|
&& cancel_breakpoint (lp))
|
&& cancel_breakpoint (lp))
|
{
|
{
|
/* Throw away the SIGTRAP. */
|
/* Throw away the SIGTRAP. */
|
lp->status = 0;
|
lp->status = 0;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf (stderr,
|
fprintf (stderr,
|
"LLW: LWP %ld hit a breakpoint while waiting "
|
"LLW: LWP %ld hit a breakpoint while waiting "
|
"for another process; cancelled it\n",
|
"for another process; cancelled it\n",
|
ptid_get_lwp (lp->ptid));
|
ptid_get_lwp (lp->ptid));
|
}
|
}
|
lp->stopped = 1;
|
lp->stopped = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
lp->stopped = 1;
|
lp->stopped = 1;
|
lp->signalled = 0;
|
lp->signalled = 0;
|
}
|
}
|
}
|
}
|
else if (WIFEXITED (status) || WIFSIGNALED (status))
|
else if (WIFEXITED (status) || WIFSIGNALED (status))
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf (stderr, "Process %ld exited while stopping LWPs\n",
|
fprintf (stderr, "Process %ld exited while stopping LWPs\n",
|
ptid_get_lwp (lp->ptid));
|
ptid_get_lwp (lp->ptid));
|
|
|
/* This was the last lwp in the process. Since
|
/* This was the last lwp in the process. Since
|
events are serialized to GDB core, and we can't
|
events are serialized to GDB core, and we can't
|
report this one right now, but GDB core and the
|
report this one right now, but GDB core and the
|
other target layers will want to be notified
|
other target layers will want to be notified
|
about the exit code/signal, leave the status
|
about the exit code/signal, leave the status
|
pending for the next time we're able to report
|
pending for the next time we're able to report
|
it. */
|
it. */
|
|
|
/* Prevent trying to stop this thread again. We'll
|
/* Prevent trying to stop this thread again. We'll
|
never try to resume it because it has a pending
|
never try to resume it because it has a pending
|
status. */
|
status. */
|
lp->stopped = 1;
|
lp->stopped = 1;
|
|
|
/* Dead LWP's aren't expected to reported a pending
|
/* Dead LWP's aren't expected to reported a pending
|
sigstop. */
|
sigstop. */
|
lp->signalled = 0;
|
lp->signalled = 0;
|
|
|
/* Store the pending event in the waitstatus as
|
/* Store the pending event in the waitstatus as
|
well, because W_EXITCODE(0,0) == 0. */
|
well, because W_EXITCODE(0,0) == 0. */
|
store_waitstatus (&lp->waitstatus, lp->status);
|
store_waitstatus (&lp->waitstatus, lp->status);
|
}
|
}
|
|
|
/* Keep looking. */
|
/* Keep looking. */
|
lp = NULL;
|
lp = NULL;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (lp)
|
if (lp)
|
break;
|
break;
|
else
|
else
|
{
|
{
|
if (pid == -1)
|
if (pid == -1)
|
{
|
{
|
/* waitpid did return something. Restart over. */
|
/* waitpid did return something. Restart over. */
|
options |= __WCLONE;
|
options |= __WCLONE;
|
}
|
}
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
|
|
if (pid == -1)
|
if (pid == -1)
|
{
|
{
|
/* Alternate between checking cloned and uncloned processes. */
|
/* Alternate between checking cloned and uncloned processes. */
|
options ^= __WCLONE;
|
options ^= __WCLONE;
|
|
|
/* And every time we have checked both:
|
/* And every time we have checked both:
|
In async mode, return to event loop;
|
In async mode, return to event loop;
|
In sync mode, suspend waiting for a SIGCHLD signal. */
|
In sync mode, suspend waiting for a SIGCHLD signal. */
|
if (options & __WCLONE)
|
if (options & __WCLONE)
|
{
|
{
|
if (target_options & TARGET_WNOHANG)
|
if (target_options & TARGET_WNOHANG)
|
{
|
{
|
/* No interesting event. */
|
/* No interesting event. */
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
|
|
if (debug_linux_nat_async)
|
if (debug_linux_nat_async)
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
|
|
sigsuspend (&suspend_mask);
|
sigsuspend (&suspend_mask);
|
}
|
}
|
}
|
}
|
else if (target_options & TARGET_WNOHANG)
|
else if (target_options & TARGET_WNOHANG)
|
{
|
{
|
/* No interesting event for PID yet. */
|
/* No interesting event for PID yet. */
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
ourstatus->kind = TARGET_WAITKIND_IGNORE;
|
|
|
if (debug_linux_nat_async)
|
if (debug_linux_nat_async)
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
|
|
/* We shouldn't end up here unless we want to try again. */
|
/* We shouldn't end up here unless we want to try again. */
|
gdb_assert (lp == NULL);
|
gdb_assert (lp == NULL);
|
}
|
}
|
|
|
if (!target_can_async_p ())
|
if (!target_can_async_p ())
|
clear_sigint_trap ();
|
clear_sigint_trap ();
|
|
|
gdb_assert (lp);
|
gdb_assert (lp);
|
|
|
status = lp->status;
|
status = lp->status;
|
lp->status = 0;
|
lp->status = 0;
|
|
|
/* Don't report signals that GDB isn't interested in, such as
|
/* Don't report signals that GDB isn't interested in, such as
|
signals that are neither printed nor stopped upon. Stopping all
|
signals that are neither printed nor stopped upon. Stopping all
|
threads can be a bit time-consuming so if we want decent
|
threads can be a bit time-consuming so if we want decent
|
performance with heavily multi-threaded programs, especially when
|
performance with heavily multi-threaded programs, especially when
|
they're using a high frequency timer, we'd better avoid it if we
|
they're using a high frequency timer, we'd better avoid it if we
|
can. */
|
can. */
|
|
|
if (WIFSTOPPED (status))
|
if (WIFSTOPPED (status))
|
{
|
{
|
int signo = target_signal_from_host (WSTOPSIG (status));
|
int signo = target_signal_from_host (WSTOPSIG (status));
|
struct inferior *inf;
|
struct inferior *inf;
|
|
|
inf = find_inferior_pid (ptid_get_pid (lp->ptid));
|
inf = find_inferior_pid (ptid_get_pid (lp->ptid));
|
gdb_assert (inf);
|
gdb_assert (inf);
|
|
|
/* Defer to common code if we get a signal while
|
/* Defer to common code if we get a signal while
|
single-stepping, since that may need special care, e.g. to
|
single-stepping, since that may need special care, e.g. to
|
skip the signal handler, or, if we're gaining control of the
|
skip the signal handler, or, if we're gaining control of the
|
inferior. */
|
inferior. */
|
if (!lp->step
|
if (!lp->step
|
&& inf->stop_soon == NO_STOP_QUIETLY
|
&& inf->stop_soon == NO_STOP_QUIETLY
|
&& signal_stop_state (signo) == 0
|
&& signal_stop_state (signo) == 0
|
&& signal_print_state (signo) == 0
|
&& signal_print_state (signo) == 0
|
&& signal_pass_state (signo) == 1)
|
&& signal_pass_state (signo) == 1)
|
{
|
{
|
/* FIMXE: kettenis/2001-06-06: Should we resume all threads
|
/* FIMXE: kettenis/2001-06-06: Should we resume all threads
|
here? It is not clear we should. GDB may not expect
|
here? It is not clear we should. GDB may not expect
|
other threads to run. On the other hand, not resuming
|
other threads to run. On the other hand, not resuming
|
newly attached threads may cause an unwanted delay in
|
newly attached threads may cause an unwanted delay in
|
getting them running. */
|
getting them running. */
|
registers_changed ();
|
registers_changed ();
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
lp->step, signo);
|
lp->step, signo);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: %s %s, %s (preempt 'handle')\n",
|
"LLW: %s %s, %s (preempt 'handle')\n",
|
lp->step ?
|
lp->step ?
|
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
signo ? strsignal (signo) : "0");
|
signo ? strsignal (signo) : "0");
|
lp->stopped = 0;
|
lp->stopped = 0;
|
goto retry;
|
goto retry;
|
}
|
}
|
|
|
if (!non_stop)
|
if (!non_stop)
|
{
|
{
|
/* Only do the below in all-stop, as we currently use SIGINT
|
/* Only do the below in all-stop, as we currently use SIGINT
|
to implement target_stop (see linux_nat_stop) in
|
to implement target_stop (see linux_nat_stop) in
|
non-stop. */
|
non-stop. */
|
if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
|
if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
|
{
|
{
|
/* If ^C/BREAK is typed at the tty/console, SIGINT gets
|
/* If ^C/BREAK is typed at the tty/console, SIGINT gets
|
forwarded to the entire process group, that is, all LWPs
|
forwarded to the entire process group, that is, all LWPs
|
will receive it - unless they're using CLONE_THREAD to
|
will receive it - unless they're using CLONE_THREAD to
|
share signals. Since we only want to report it once, we
|
share signals. Since we only want to report it once, we
|
mark it as ignored for all LWPs except this one. */
|
mark it as ignored for all LWPs except this one. */
|
iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
|
iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
|
set_ignore_sigint, NULL);
|
set_ignore_sigint, NULL);
|
lp->ignore_sigint = 0;
|
lp->ignore_sigint = 0;
|
}
|
}
|
else
|
else
|
maybe_clear_ignore_sigint (lp);
|
maybe_clear_ignore_sigint (lp);
|
}
|
}
|
}
|
}
|
|
|
/* This LWP is stopped now. */
|
/* This LWP is stopped now. */
|
lp->stopped = 1;
|
lp->stopped = 1;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
|
fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
|
status_to_str (status), target_pid_to_str (lp->ptid));
|
status_to_str (status), target_pid_to_str (lp->ptid));
|
|
|
if (!non_stop)
|
if (!non_stop)
|
{
|
{
|
/* Now stop all other LWP's ... */
|
/* Now stop all other LWP's ... */
|
iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
|
iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
|
|
|
/* ... and wait until all of them have reported back that
|
/* ... and wait until all of them have reported back that
|
they're no longer running. */
|
they're no longer running. */
|
iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
|
iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
|
|
|
/* If we're not waiting for a specific LWP, choose an event LWP
|
/* If we're not waiting for a specific LWP, choose an event LWP
|
from among those that have had events. Giving equal priority
|
from among those that have had events. Giving equal priority
|
to all LWPs that have had events helps prevent
|
to all LWPs that have had events helps prevent
|
starvation. */
|
starvation. */
|
if (pid == -1)
|
if (pid == -1)
|
select_event_lwp (ptid, &lp, &status);
|
select_event_lwp (ptid, &lp, &status);
|
|
|
/* Now that we've selected our final event LWP, cancel any
|
/* Now that we've selected our final event LWP, cancel any
|
breakpoints in other LWPs that have hit a GDB breakpoint.
|
breakpoints in other LWPs that have hit a GDB breakpoint.
|
See the comment in cancel_breakpoints_callback to find out
|
See the comment in cancel_breakpoints_callback to find out
|
why. */
|
why. */
|
iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
|
iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
|
|
|
/* In all-stop, from the core's perspective, all LWPs are now
|
/* In all-stop, from the core's perspective, all LWPs are now
|
stopped until a new resume action is sent over. */
|
stopped until a new resume action is sent over. */
|
iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
|
iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
|
}
|
}
|
else
|
else
|
lp->resumed = 0;
|
lp->resumed = 0;
|
|
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
|
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLW: trap ptid is %s.\n",
|
"LLW: trap ptid is %s.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
}
|
}
|
|
|
if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
|
{
|
{
|
*ourstatus = lp->waitstatus;
|
*ourstatus = lp->waitstatus;
|
lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
|
lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
|
}
|
}
|
else
|
else
|
store_waitstatus (ourstatus, status);
|
store_waitstatus (ourstatus, status);
|
|
|
if (debug_linux_nat_async)
|
if (debug_linux_nat_async)
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
|
fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
lp->core = linux_nat_core_of_thread_1 (lp->ptid);
|
lp->core = linux_nat_core_of_thread_1 (lp->ptid);
|
return lp->ptid;
|
return lp->ptid;
|
}
|
}
|
|
|
/* Resume LWPs that are currently stopped without any pending status
|
/* Resume LWPs that are currently stopped without any pending status
|
to report, but are resumed from the core's perspective. */
|
to report, but are resumed from the core's perspective. */
|
|
|
static int
|
static int
|
resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
|
resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
|
{
|
{
|
ptid_t *wait_ptid_p = data;
|
ptid_t *wait_ptid_p = data;
|
|
|
if (lp->stopped
|
if (lp->stopped
|
&& lp->resumed
|
&& lp->resumed
|
&& lp->status == 0
|
&& lp->status == 0
|
&& lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
|
&& lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
|
{
|
{
|
gdb_assert (is_executing (lp->ptid));
|
gdb_assert (is_executing (lp->ptid));
|
|
|
/* Don't bother if there's a breakpoint at PC that we'd hit
|
/* Don't bother if there's a breakpoint at PC that we'd hit
|
immediately, and we're not waiting for this LWP. */
|
immediately, and we're not waiting for this LWP. */
|
if (!ptid_match (lp->ptid, *wait_ptid_p))
|
if (!ptid_match (lp->ptid, *wait_ptid_p))
|
{
|
{
|
struct regcache *regcache = get_thread_regcache (lp->ptid);
|
struct regcache *regcache = get_thread_regcache (lp->ptid);
|
CORE_ADDR pc = regcache_read_pc (regcache);
|
CORE_ADDR pc = regcache_read_pc (regcache);
|
|
|
if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
|
if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"RSRL: resuming stopped-resumed LWP %s\n",
|
"RSRL: resuming stopped-resumed LWP %s\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
|
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
|
lp->step, TARGET_SIGNAL_0);
|
lp->step, TARGET_SIGNAL_0);
|
lp->stopped = 0;
|
lp->stopped = 0;
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
memset (&lp->siginfo, 0, sizeof (lp->siginfo));
|
lp->stopped_by_watchpoint = 0;
|
lp->stopped_by_watchpoint = 0;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static ptid_t
|
static ptid_t
|
linux_nat_wait (struct target_ops *ops,
|
linux_nat_wait (struct target_ops *ops,
|
ptid_t ptid, struct target_waitstatus *ourstatus,
|
ptid_t ptid, struct target_waitstatus *ourstatus,
|
int target_options)
|
int target_options)
|
{
|
{
|
ptid_t event_ptid;
|
ptid_t event_ptid;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog, "linux_nat_wait: [%s]\n", target_pid_to_str (ptid));
|
fprintf_unfiltered (gdb_stdlog, "linux_nat_wait: [%s]\n", target_pid_to_str (ptid));
|
|
|
/* Flush the async file first. */
|
/* Flush the async file first. */
|
if (target_can_async_p ())
|
if (target_can_async_p ())
|
async_file_flush ();
|
async_file_flush ();
|
|
|
/* Resume LWPs that are currently stopped without any pending status
|
/* Resume LWPs that are currently stopped without any pending status
|
to report, but are resumed from the core's perspective. LWPs get
|
to report, but are resumed from the core's perspective. LWPs get
|
in this state if we find them stopping at a time we're not
|
in this state if we find them stopping at a time we're not
|
interested in reporting the event (target_wait on a
|
interested in reporting the event (target_wait on a
|
specific_process, for example, see linux_nat_wait_1), and
|
specific_process, for example, see linux_nat_wait_1), and
|
meanwhile the event became uninteresting. Don't bother resuming
|
meanwhile the event became uninteresting. Don't bother resuming
|
LWPs we're not going to wait for if they'd stop immediately. */
|
LWPs we're not going to wait for if they'd stop immediately. */
|
if (non_stop)
|
if (non_stop)
|
iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
|
iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
|
|
|
event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
|
event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
|
|
|
/* If we requested any event, and something came out, assume there
|
/* If we requested any event, and something came out, assume there
|
may be more. If we requested a specific lwp or process, also
|
may be more. If we requested a specific lwp or process, also
|
assume there may be more. */
|
assume there may be more. */
|
if (target_can_async_p ()
|
if (target_can_async_p ()
|
&& (ourstatus->kind != TARGET_WAITKIND_IGNORE
|
&& (ourstatus->kind != TARGET_WAITKIND_IGNORE
|
|| !ptid_equal (ptid, minus_one_ptid)))
|
|| !ptid_equal (ptid, minus_one_ptid)))
|
async_file_mark ();
|
async_file_mark ();
|
|
|
/* Get ready for the next event. */
|
/* Get ready for the next event. */
|
if (target_can_async_p ())
|
if (target_can_async_p ())
|
target_async (inferior_event_handler, 0);
|
target_async (inferior_event_handler, 0);
|
|
|
return event_ptid;
|
return event_ptid;
|
}
|
}
|
|
|
static int
|
static int
|
kill_callback (struct lwp_info *lp, void *data)
|
kill_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
|
ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"KC: PTRACE_KILL %s, 0, 0 (%s)\n",
|
"KC: PTRACE_KILL %s, 0, 0 (%s)\n",
|
target_pid_to_str (lp->ptid),
|
target_pid_to_str (lp->ptid),
|
errno ? safe_strerror (errno) : "OK");
|
errno ? safe_strerror (errno) : "OK");
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
kill_wait_callback (struct lwp_info *lp, void *data)
|
kill_wait_callback (struct lwp_info *lp, void *data)
|
{
|
{
|
pid_t pid;
|
pid_t pid;
|
|
|
/* We must make sure that there are no pending events (delayed
|
/* We must make sure that there are no pending events (delayed
|
SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
|
SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
|
program doesn't interfere with any following debugging session. */
|
program doesn't interfere with any following debugging session. */
|
|
|
/* For cloned processes we must check both with __WCLONE and
|
/* For cloned processes we must check both with __WCLONE and
|
without, since the exit status of a cloned process isn't reported
|
without, since the exit status of a cloned process isn't reported
|
with __WCLONE. */
|
with __WCLONE. */
|
if (lp->cloned)
|
if (lp->cloned)
|
{
|
{
|
do
|
do
|
{
|
{
|
pid = my_waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
|
pid = my_waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
|
if (pid != (pid_t) -1)
|
if (pid != (pid_t) -1)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"KWC: wait %s received unknown.\n",
|
"KWC: wait %s received unknown.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
/* The Linux kernel sometimes fails to kill a thread
|
/* The Linux kernel sometimes fails to kill a thread
|
completely after PTRACE_KILL; that goes from the stop
|
completely after PTRACE_KILL; that goes from the stop
|
point in do_fork out to the one in
|
point in do_fork out to the one in
|
get_signal_to_deliever and waits again. So kill it
|
get_signal_to_deliever and waits again. So kill it
|
again. */
|
again. */
|
kill_callback (lp, NULL);
|
kill_callback (lp, NULL);
|
}
|
}
|
}
|
}
|
while (pid == GET_LWP (lp->ptid));
|
while (pid == GET_LWP (lp->ptid));
|
|
|
gdb_assert (pid == -1 && errno == ECHILD);
|
gdb_assert (pid == -1 && errno == ECHILD);
|
}
|
}
|
|
|
do
|
do
|
{
|
{
|
pid = my_waitpid (GET_LWP (lp->ptid), NULL, 0);
|
pid = my_waitpid (GET_LWP (lp->ptid), NULL, 0);
|
if (pid != (pid_t) -1)
|
if (pid != (pid_t) -1)
|
{
|
{
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"KWC: wait %s received unk.\n",
|
"KWC: wait %s received unk.\n",
|
target_pid_to_str (lp->ptid));
|
target_pid_to_str (lp->ptid));
|
/* See the call to kill_callback above. */
|
/* See the call to kill_callback above. */
|
kill_callback (lp, NULL);
|
kill_callback (lp, NULL);
|
}
|
}
|
}
|
}
|
while (pid == GET_LWP (lp->ptid));
|
while (pid == GET_LWP (lp->ptid));
|
|
|
gdb_assert (pid == -1 && errno == ECHILD);
|
gdb_assert (pid == -1 && errno == ECHILD);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_kill (struct target_ops *ops)
|
linux_nat_kill (struct target_ops *ops)
|
{
|
{
|
struct target_waitstatus last;
|
struct target_waitstatus last;
|
ptid_t last_ptid;
|
ptid_t last_ptid;
|
int status;
|
int status;
|
|
|
/* If we're stopped while forking and we haven't followed yet,
|
/* If we're stopped while forking and we haven't followed yet,
|
kill the other task. We need to do this first because the
|
kill the other task. We need to do this first because the
|
parent will be sleeping if this is a vfork. */
|
parent will be sleeping if this is a vfork. */
|
|
|
get_last_target_status (&last_ptid, &last);
|
get_last_target_status (&last_ptid, &last);
|
|
|
if (last.kind == TARGET_WAITKIND_FORKED
|
if (last.kind == TARGET_WAITKIND_FORKED
|
|| last.kind == TARGET_WAITKIND_VFORKED)
|
|| last.kind == TARGET_WAITKIND_VFORKED)
|
{
|
{
|
ptrace (PT_KILL, PIDGET (last.value.related_pid), 0, 0);
|
ptrace (PT_KILL, PIDGET (last.value.related_pid), 0, 0);
|
wait (&status);
|
wait (&status);
|
}
|
}
|
|
|
if (forks_exist_p ())
|
if (forks_exist_p ())
|
linux_fork_killall ();
|
linux_fork_killall ();
|
else
|
else
|
{
|
{
|
ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
|
ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
|
/* Stop all threads before killing them, since ptrace requires
|
/* Stop all threads before killing them, since ptrace requires
|
that the thread is stopped to sucessfully PTRACE_KILL. */
|
that the thread is stopped to sucessfully PTRACE_KILL. */
|
iterate_over_lwps (ptid, stop_callback, NULL);
|
iterate_over_lwps (ptid, stop_callback, NULL);
|
/* ... and wait until all of them have reported back that
|
/* ... and wait until all of them have reported back that
|
they're no longer running. */
|
they're no longer running. */
|
iterate_over_lwps (ptid, stop_wait_callback, NULL);
|
iterate_over_lwps (ptid, stop_wait_callback, NULL);
|
|
|
/* Kill all LWP's ... */
|
/* Kill all LWP's ... */
|
iterate_over_lwps (ptid, kill_callback, NULL);
|
iterate_over_lwps (ptid, kill_callback, NULL);
|
|
|
/* ... and wait until we've flushed all events. */
|
/* ... and wait until we've flushed all events. */
|
iterate_over_lwps (ptid, kill_wait_callback, NULL);
|
iterate_over_lwps (ptid, kill_wait_callback, NULL);
|
}
|
}
|
|
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_mourn_inferior (struct target_ops *ops)
|
linux_nat_mourn_inferior (struct target_ops *ops)
|
{
|
{
|
purge_lwp_list (ptid_get_pid (inferior_ptid));
|
purge_lwp_list (ptid_get_pid (inferior_ptid));
|
|
|
if (! forks_exist_p ())
|
if (! forks_exist_p ())
|
/* Normal case, no other forks available. */
|
/* Normal case, no other forks available. */
|
linux_ops->to_mourn_inferior (ops);
|
linux_ops->to_mourn_inferior (ops);
|
else
|
else
|
/* Multi-fork case. The current inferior_ptid has exited, but
|
/* Multi-fork case. The current inferior_ptid has exited, but
|
there are other viable forks to debug. Delete the exiting
|
there are other viable forks to debug. Delete the exiting
|
one and context-switch to the first available. */
|
one and context-switch to the first available. */
|
linux_fork_mourn_inferior ();
|
linux_fork_mourn_inferior ();
|
}
|
}
|
|
|
/* Convert a native/host siginfo object, into/from the siginfo in the
|
/* Convert a native/host siginfo object, into/from the siginfo in the
|
layout of the inferiors' architecture. */
|
layout of the inferiors' architecture. */
|
|
|
static void
|
static void
|
siginfo_fixup (struct siginfo *siginfo, gdb_byte *inf_siginfo, int direction)
|
siginfo_fixup (struct siginfo *siginfo, gdb_byte *inf_siginfo, int direction)
|
{
|
{
|
int done = 0;
|
int done = 0;
|
|
|
if (linux_nat_siginfo_fixup != NULL)
|
if (linux_nat_siginfo_fixup != NULL)
|
done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
|
done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
|
|
|
/* If there was no callback, or the callback didn't do anything,
|
/* If there was no callback, or the callback didn't do anything,
|
then just do a straight memcpy. */
|
then just do a straight memcpy. */
|
if (!done)
|
if (!done)
|
{
|
{
|
if (direction == 1)
|
if (direction == 1)
|
memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
|
memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
|
else
|
else
|
memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
|
memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
|
}
|
}
|
}
|
}
|
|
|
static LONGEST
|
static LONGEST
|
linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
|
linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
|
const char *annex, gdb_byte *readbuf,
|
const char *annex, gdb_byte *readbuf,
|
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
|
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
|
{
|
{
|
int pid;
|
int pid;
|
struct siginfo siginfo;
|
struct siginfo siginfo;
|
gdb_byte inf_siginfo[sizeof (struct siginfo)];
|
gdb_byte inf_siginfo[sizeof (struct siginfo)];
|
|
|
gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
|
gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
|
gdb_assert (readbuf || writebuf);
|
gdb_assert (readbuf || writebuf);
|
|
|
pid = GET_LWP (inferior_ptid);
|
pid = GET_LWP (inferior_ptid);
|
if (pid == 0)
|
if (pid == 0)
|
pid = GET_PID (inferior_ptid);
|
pid = GET_PID (inferior_ptid);
|
|
|
if (offset > sizeof (siginfo))
|
if (offset > sizeof (siginfo))
|
return -1;
|
return -1;
|
|
|
errno = 0;
|
errno = 0;
|
ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
|
ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
|
if (errno != 0)
|
if (errno != 0)
|
return -1;
|
return -1;
|
|
|
/* When GDB is built as a 64-bit application, ptrace writes into
|
/* When GDB is built as a 64-bit application, ptrace writes into
|
SIGINFO an object with 64-bit layout. Since debugging a 32-bit
|
SIGINFO an object with 64-bit layout. Since debugging a 32-bit
|
inferior with a 64-bit GDB should look the same as debugging it
|
inferior with a 64-bit GDB should look the same as debugging it
|
with a 32-bit GDB, we need to convert it. GDB core always sees
|
with a 32-bit GDB, we need to convert it. GDB core always sees
|
the converted layout, so any read/write will have to be done
|
the converted layout, so any read/write will have to be done
|
post-conversion. */
|
post-conversion. */
|
siginfo_fixup (&siginfo, inf_siginfo, 0);
|
siginfo_fixup (&siginfo, inf_siginfo, 0);
|
|
|
if (offset + len > sizeof (siginfo))
|
if (offset + len > sizeof (siginfo))
|
len = sizeof (siginfo) - offset;
|
len = sizeof (siginfo) - offset;
|
|
|
if (readbuf != NULL)
|
if (readbuf != NULL)
|
memcpy (readbuf, inf_siginfo + offset, len);
|
memcpy (readbuf, inf_siginfo + offset, len);
|
else
|
else
|
{
|
{
|
memcpy (inf_siginfo + offset, writebuf, len);
|
memcpy (inf_siginfo + offset, writebuf, len);
|
|
|
/* Convert back to ptrace layout before flushing it out. */
|
/* Convert back to ptrace layout before flushing it out. */
|
siginfo_fixup (&siginfo, inf_siginfo, 1);
|
siginfo_fixup (&siginfo, inf_siginfo, 1);
|
|
|
errno = 0;
|
errno = 0;
|
ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
|
ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
|
if (errno != 0)
|
if (errno != 0)
|
return -1;
|
return -1;
|
}
|
}
|
|
|
return len;
|
return len;
|
}
|
}
|
|
|
static LONGEST
|
static LONGEST
|
linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
|
linux_nat_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)
|
{
|
{
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
LONGEST xfer;
|
LONGEST xfer;
|
|
|
if (object == TARGET_OBJECT_SIGNAL_INFO)
|
if (object == TARGET_OBJECT_SIGNAL_INFO)
|
return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
|
return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
|
offset, len);
|
offset, len);
|
|
|
/* The target is connected but no live inferior is selected. Pass
|
/* The target is connected but no live inferior is selected. Pass
|
this request down to a lower stratum (e.g., the executable
|
this request down to a lower stratum (e.g., the executable
|
file). */
|
file). */
|
if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
|
if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
|
return 0;
|
return 0;
|
|
|
old_chain = save_inferior_ptid ();
|
old_chain = save_inferior_ptid ();
|
|
|
if (is_lwp (inferior_ptid))
|
if (is_lwp (inferior_ptid))
|
inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
|
inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
|
|
|
xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
|
xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
|
offset, len);
|
offset, len);
|
|
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
return xfer;
|
return xfer;
|
}
|
}
|
|
|
static int
|
static int
|
linux_thread_alive (ptid_t ptid)
|
linux_thread_alive (ptid_t ptid)
|
{
|
{
|
int err;
|
int err;
|
|
|
gdb_assert (is_lwp (ptid));
|
gdb_assert (is_lwp (ptid));
|
|
|
/* Send signal 0 instead of anything ptrace, because ptracing a
|
/* Send signal 0 instead of anything ptrace, because ptracing a
|
running thread errors out claiming that the thread doesn't
|
running thread errors out claiming that the thread doesn't
|
exist. */
|
exist. */
|
err = kill_lwp (GET_LWP (ptid), 0);
|
err = kill_lwp (GET_LWP (ptid), 0);
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LLTA: KILL(SIG0) %s (%s)\n",
|
"LLTA: KILL(SIG0) %s (%s)\n",
|
target_pid_to_str (ptid),
|
target_pid_to_str (ptid),
|
err ? safe_strerror (err) : "OK");
|
err ? safe_strerror (err) : "OK");
|
|
|
if (err != 0)
|
if (err != 0)
|
return 0;
|
return 0;
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
static int
|
static int
|
linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
|
linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
|
{
|
{
|
return linux_thread_alive (ptid);
|
return linux_thread_alive (ptid);
|
}
|
}
|
|
|
static char *
|
static char *
|
linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
|
linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
|
{
|
{
|
static char buf[64];
|
static char buf[64];
|
|
|
if (is_lwp (ptid)
|
if (is_lwp (ptid)
|
&& (GET_PID (ptid) != GET_LWP (ptid)
|
&& (GET_PID (ptid) != GET_LWP (ptid)
|
|| num_lwps (GET_PID (ptid)) > 1))
|
|| num_lwps (GET_PID (ptid)) > 1))
|
{
|
{
|
snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
|
snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
|
return buf;
|
return buf;
|
}
|
}
|
|
|
return normal_pid_to_str (ptid);
|
return normal_pid_to_str (ptid);
|
}
|
}
|
|
|
/* Accepts an integer PID; Returns a string representing a file that
|
/* Accepts an integer PID; Returns a string representing a file that
|
can be opened to get the symbols for the child process. */
|
can be opened to get the symbols for the child process. */
|
|
|
static char *
|
static char *
|
linux_child_pid_to_exec_file (int pid)
|
linux_child_pid_to_exec_file (int pid)
|
{
|
{
|
char *name1, *name2;
|
char *name1, *name2;
|
|
|
name1 = xmalloc (MAXPATHLEN);
|
name1 = xmalloc (MAXPATHLEN);
|
name2 = xmalloc (MAXPATHLEN);
|
name2 = xmalloc (MAXPATHLEN);
|
make_cleanup (xfree, name1);
|
make_cleanup (xfree, name1);
|
make_cleanup (xfree, name2);
|
make_cleanup (xfree, name2);
|
memset (name2, 0, MAXPATHLEN);
|
memset (name2, 0, MAXPATHLEN);
|
|
|
sprintf (name1, "/proc/%d/exe", pid);
|
sprintf (name1, "/proc/%d/exe", pid);
|
if (readlink (name1, name2, MAXPATHLEN) > 0)
|
if (readlink (name1, name2, MAXPATHLEN) > 0)
|
return name2;
|
return name2;
|
else
|
else
|
return name1;
|
return name1;
|
}
|
}
|
|
|
/* Service function for corefiles and info proc. */
|
/* Service function for corefiles and info proc. */
|
|
|
static int
|
static int
|
read_mapping (FILE *mapfile,
|
read_mapping (FILE *mapfile,
|
long long *addr,
|
long long *addr,
|
long long *endaddr,
|
long long *endaddr,
|
char *permissions,
|
char *permissions,
|
long long *offset,
|
long long *offset,
|
char *device, long long *inode, char *filename)
|
char *device, long long *inode, char *filename)
|
{
|
{
|
int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
|
int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
|
addr, endaddr, permissions, offset, device, inode);
|
addr, endaddr, permissions, offset, device, inode);
|
|
|
filename[0] = '\0';
|
filename[0] = '\0';
|
if (ret > 0 && ret != EOF)
|
if (ret > 0 && ret != EOF)
|
{
|
{
|
/* Eat everything up to EOL for the filename. This will prevent
|
/* Eat everything up to EOL for the filename. This will prevent
|
weird filenames (such as one with embedded whitespace) from
|
weird filenames (such as one with embedded whitespace) from
|
confusing this code. It also makes this code more robust in
|
confusing this code. It also makes this code more robust in
|
respect to annotations the kernel may add after the filename.
|
respect to annotations the kernel may add after the filename.
|
|
|
Note the filename is used for informational purposes
|
Note the filename is used for informational purposes
|
only. */
|
only. */
|
ret += fscanf (mapfile, "%[^\n]\n", filename);
|
ret += fscanf (mapfile, "%[^\n]\n", filename);
|
}
|
}
|
|
|
return (ret != 0 && ret != EOF);
|
return (ret != 0 && ret != EOF);
|
}
|
}
|
|
|
/* Fills the "to_find_memory_regions" target vector. Lists the memory
|
/* Fills the "to_find_memory_regions" target vector. Lists the memory
|
regions in the inferior for a corefile. */
|
regions in the inferior for a corefile. */
|
|
|
static int
|
static int
|
linux_nat_find_memory_regions (int (*func) (CORE_ADDR,
|
linux_nat_find_memory_regions (int (*func) (CORE_ADDR,
|
unsigned long,
|
unsigned long,
|
int, int, int, void *), void *obfd)
|
int, int, int, void *), void *obfd)
|
{
|
{
|
int pid = PIDGET (inferior_ptid);
|
int pid = PIDGET (inferior_ptid);
|
char mapsfilename[MAXPATHLEN];
|
char mapsfilename[MAXPATHLEN];
|
FILE *mapsfile;
|
FILE *mapsfile;
|
long long addr, endaddr, size, offset, inode;
|
long long addr, endaddr, size, offset, inode;
|
char permissions[8], device[8], filename[MAXPATHLEN];
|
char permissions[8], device[8], filename[MAXPATHLEN];
|
int read, write, exec;
|
int read, write, exec;
|
int ret;
|
int ret;
|
struct cleanup *cleanup;
|
struct cleanup *cleanup;
|
|
|
/* Compose the filename for the /proc memory map, and open it. */
|
/* Compose the filename for the /proc memory map, and open it. */
|
sprintf (mapsfilename, "/proc/%d/maps", pid);
|
sprintf (mapsfilename, "/proc/%d/maps", pid);
|
if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
|
if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
|
error (_("Could not open %s."), mapsfilename);
|
error (_("Could not open %s."), mapsfilename);
|
cleanup = make_cleanup_fclose (mapsfile);
|
cleanup = make_cleanup_fclose (mapsfile);
|
|
|
if (info_verbose)
|
if (info_verbose)
|
fprintf_filtered (gdb_stdout,
|
fprintf_filtered (gdb_stdout,
|
"Reading memory regions from %s\n", mapsfilename);
|
"Reading memory regions from %s\n", mapsfilename);
|
|
|
/* Now iterate until end-of-file. */
|
/* Now iterate until end-of-file. */
|
while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
|
while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
|
&offset, &device[0], &inode, &filename[0]))
|
&offset, &device[0], &inode, &filename[0]))
|
{
|
{
|
size = endaddr - addr;
|
size = endaddr - addr;
|
|
|
/* Get the segment's permissions. */
|
/* Get the segment's permissions. */
|
read = (strchr (permissions, 'r') != 0);
|
read = (strchr (permissions, 'r') != 0);
|
write = (strchr (permissions, 'w') != 0);
|
write = (strchr (permissions, 'w') != 0);
|
exec = (strchr (permissions, 'x') != 0);
|
exec = (strchr (permissions, 'x') != 0);
|
|
|
if (info_verbose)
|
if (info_verbose)
|
{
|
{
|
fprintf_filtered (gdb_stdout,
|
fprintf_filtered (gdb_stdout,
|
"Save segment, %lld bytes at %s (%c%c%c)",
|
"Save segment, %lld bytes at %s (%c%c%c)",
|
size, paddress (target_gdbarch, addr),
|
size, paddress (target_gdbarch, addr),
|
read ? 'r' : ' ',
|
read ? 'r' : ' ',
|
write ? 'w' : ' ', exec ? 'x' : ' ');
|
write ? 'w' : ' ', exec ? 'x' : ' ');
|
if (filename[0])
|
if (filename[0])
|
fprintf_filtered (gdb_stdout, " for %s", filename);
|
fprintf_filtered (gdb_stdout, " for %s", filename);
|
fprintf_filtered (gdb_stdout, "\n");
|
fprintf_filtered (gdb_stdout, "\n");
|
}
|
}
|
|
|
/* Invoke the callback function to create the corefile
|
/* Invoke the callback function to create the corefile
|
segment. */
|
segment. */
|
func (addr, size, read, write, exec, obfd);
|
func (addr, size, read, write, exec, obfd);
|
}
|
}
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
find_signalled_thread (struct thread_info *info, void *data)
|
find_signalled_thread (struct thread_info *info, void *data)
|
{
|
{
|
if (info->stop_signal != TARGET_SIGNAL_0
|
if (info->stop_signal != TARGET_SIGNAL_0
|
&& ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
|
&& ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static enum target_signal
|
static enum target_signal
|
find_stop_signal (void)
|
find_stop_signal (void)
|
{
|
{
|
struct thread_info *info =
|
struct thread_info *info =
|
iterate_over_threads (find_signalled_thread, NULL);
|
iterate_over_threads (find_signalled_thread, NULL);
|
|
|
if (info)
|
if (info)
|
return info->stop_signal;
|
return info->stop_signal;
|
else
|
else
|
return TARGET_SIGNAL_0;
|
return TARGET_SIGNAL_0;
|
}
|
}
|
|
|
/* Records the thread's register state for the corefile note
|
/* Records the thread's register state for the corefile note
|
section. */
|
section. */
|
|
|
static char *
|
static char *
|
linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
|
linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
|
char *note_data, int *note_size,
|
char *note_data, int *note_size,
|
enum target_signal stop_signal)
|
enum target_signal stop_signal)
|
{
|
{
|
gdb_gregset_t gregs;
|
gdb_gregset_t gregs;
|
gdb_fpregset_t fpregs;
|
gdb_fpregset_t fpregs;
|
unsigned long lwp = ptid_get_lwp (ptid);
|
unsigned long lwp = ptid_get_lwp (ptid);
|
struct gdbarch *gdbarch = target_gdbarch;
|
struct gdbarch *gdbarch = target_gdbarch;
|
struct regcache *regcache = get_thread_arch_regcache (ptid, gdbarch);
|
struct regcache *regcache = get_thread_arch_regcache (ptid, gdbarch);
|
const struct regset *regset;
|
const struct regset *regset;
|
int core_regset_p;
|
int core_regset_p;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
struct core_regset_section *sect_list;
|
struct core_regset_section *sect_list;
|
char *gdb_regset;
|
char *gdb_regset;
|
|
|
old_chain = save_inferior_ptid ();
|
old_chain = save_inferior_ptid ();
|
inferior_ptid = ptid;
|
inferior_ptid = ptid;
|
target_fetch_registers (regcache, -1);
|
target_fetch_registers (regcache, -1);
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
|
|
core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
|
core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
|
sect_list = gdbarch_core_regset_sections (gdbarch);
|
sect_list = gdbarch_core_regset_sections (gdbarch);
|
|
|
if (core_regset_p
|
if (core_regset_p
|
&& (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
|
&& (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
|
sizeof (gregs))) != NULL
|
sizeof (gregs))) != NULL
|
&& regset->collect_regset != NULL)
|
&& regset->collect_regset != NULL)
|
regset->collect_regset (regset, regcache, -1,
|
regset->collect_regset (regset, regcache, -1,
|
&gregs, sizeof (gregs));
|
&gregs, sizeof (gregs));
|
else
|
else
|
fill_gregset (regcache, &gregs, -1);
|
fill_gregset (regcache, &gregs, -1);
|
|
|
note_data = (char *) elfcore_write_prstatus (obfd,
|
note_data = (char *) elfcore_write_prstatus (obfd,
|
note_data,
|
note_data,
|
note_size,
|
note_size,
|
lwp,
|
lwp,
|
stop_signal, &gregs);
|
stop_signal, &gregs);
|
|
|
/* The loop below uses the new struct core_regset_section, which stores
|
/* The loop below uses the new struct core_regset_section, which stores
|
the supported section names and sizes for the core file. Note that
|
the supported section names and sizes for the core file. Note that
|
note PRSTATUS needs to be treated specially. But the other notes are
|
note PRSTATUS needs to be treated specially. But the other notes are
|
structurally the same, so they can benefit from the new struct. */
|
structurally the same, so they can benefit from the new struct. */
|
if (core_regset_p && sect_list != NULL)
|
if (core_regset_p && sect_list != NULL)
|
while (sect_list->sect_name != NULL)
|
while (sect_list->sect_name != NULL)
|
{
|
{
|
/* .reg was already handled above. */
|
/* .reg was already handled above. */
|
if (strcmp (sect_list->sect_name, ".reg") == 0)
|
if (strcmp (sect_list->sect_name, ".reg") == 0)
|
{
|
{
|
sect_list++;
|
sect_list++;
|
continue;
|
continue;
|
}
|
}
|
regset = gdbarch_regset_from_core_section (gdbarch,
|
regset = gdbarch_regset_from_core_section (gdbarch,
|
sect_list->sect_name,
|
sect_list->sect_name,
|
sect_list->size);
|
sect_list->size);
|
gdb_assert (regset && regset->collect_regset);
|
gdb_assert (regset && regset->collect_regset);
|
gdb_regset = xmalloc (sect_list->size);
|
gdb_regset = xmalloc (sect_list->size);
|
regset->collect_regset (regset, regcache, -1,
|
regset->collect_regset (regset, regcache, -1,
|
gdb_regset, sect_list->size);
|
gdb_regset, sect_list->size);
|
note_data = (char *) elfcore_write_register_note (obfd,
|
note_data = (char *) elfcore_write_register_note (obfd,
|
note_data,
|
note_data,
|
note_size,
|
note_size,
|
sect_list->sect_name,
|
sect_list->sect_name,
|
gdb_regset,
|
gdb_regset,
|
sect_list->size);
|
sect_list->size);
|
xfree (gdb_regset);
|
xfree (gdb_regset);
|
sect_list++;
|
sect_list++;
|
}
|
}
|
|
|
/* For architectures that does not have the struct core_regset_section
|
/* For architectures that does not have the struct core_regset_section
|
implemented, we use the old method. When all the architectures have
|
implemented, we use the old method. When all the architectures have
|
the new support, the code below should be deleted. */
|
the new support, the code below should be deleted. */
|
else
|
else
|
{
|
{
|
if (core_regset_p
|
if (core_regset_p
|
&& (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
|
&& (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
|
sizeof (fpregs))) != NULL
|
sizeof (fpregs))) != NULL
|
&& regset->collect_regset != NULL)
|
&& regset->collect_regset != NULL)
|
regset->collect_regset (regset, regcache, -1,
|
regset->collect_regset (regset, regcache, -1,
|
&fpregs, sizeof (fpregs));
|
&fpregs, sizeof (fpregs));
|
else
|
else
|
fill_fpregset (regcache, &fpregs, -1);
|
fill_fpregset (regcache, &fpregs, -1);
|
|
|
note_data = (char *) elfcore_write_prfpreg (obfd,
|
note_data = (char *) elfcore_write_prfpreg (obfd,
|
note_data,
|
note_data,
|
note_size,
|
note_size,
|
&fpregs, sizeof (fpregs));
|
&fpregs, sizeof (fpregs));
|
}
|
}
|
|
|
return note_data;
|
return note_data;
|
}
|
}
|
|
|
struct linux_nat_corefile_thread_data
|
struct linux_nat_corefile_thread_data
|
{
|
{
|
bfd *obfd;
|
bfd *obfd;
|
char *note_data;
|
char *note_data;
|
int *note_size;
|
int *note_size;
|
int num_notes;
|
int num_notes;
|
enum target_signal stop_signal;
|
enum target_signal stop_signal;
|
};
|
};
|
|
|
/* Called by gdbthread.c once per thread. Records the thread's
|
/* Called by gdbthread.c once per thread. Records the thread's
|
register state for the corefile note section. */
|
register state for the corefile note section. */
|
|
|
static int
|
static int
|
linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
|
linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
|
{
|
{
|
struct linux_nat_corefile_thread_data *args = data;
|
struct linux_nat_corefile_thread_data *args = data;
|
|
|
args->note_data = linux_nat_do_thread_registers (args->obfd,
|
args->note_data = linux_nat_do_thread_registers (args->obfd,
|
ti->ptid,
|
ti->ptid,
|
args->note_data,
|
args->note_data,
|
args->note_size,
|
args->note_size,
|
args->stop_signal);
|
args->stop_signal);
|
args->num_notes++;
|
args->num_notes++;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Enumerate spufs IDs for process PID. */
|
/* Enumerate spufs IDs for process PID. */
|
|
|
static void
|
static void
|
iterate_over_spus (int pid, void (*callback) (void *, int), void *data)
|
iterate_over_spus (int pid, void (*callback) (void *, int), void *data)
|
{
|
{
|
char path[128];
|
char path[128];
|
DIR *dir;
|
DIR *dir;
|
struct dirent *entry;
|
struct dirent *entry;
|
|
|
xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
|
xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
|
dir = opendir (path);
|
dir = opendir (path);
|
if (!dir)
|
if (!dir)
|
return;
|
return;
|
|
|
rewinddir (dir);
|
rewinddir (dir);
|
while ((entry = readdir (dir)) != NULL)
|
while ((entry = readdir (dir)) != NULL)
|
{
|
{
|
struct stat st;
|
struct stat st;
|
struct statfs stfs;
|
struct statfs stfs;
|
int fd;
|
int fd;
|
|
|
fd = atoi (entry->d_name);
|
fd = atoi (entry->d_name);
|
if (!fd)
|
if (!fd)
|
continue;
|
continue;
|
|
|
xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
|
xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
|
if (stat (path, &st) != 0)
|
if (stat (path, &st) != 0)
|
continue;
|
continue;
|
if (!S_ISDIR (st.st_mode))
|
if (!S_ISDIR (st.st_mode))
|
continue;
|
continue;
|
|
|
if (statfs (path, &stfs) != 0)
|
if (statfs (path, &stfs) != 0)
|
continue;
|
continue;
|
if (stfs.f_type != SPUFS_MAGIC)
|
if (stfs.f_type != SPUFS_MAGIC)
|
continue;
|
continue;
|
|
|
callback (data, fd);
|
callback (data, fd);
|
}
|
}
|
|
|
closedir (dir);
|
closedir (dir);
|
}
|
}
|
|
|
/* Generate corefile notes for SPU contexts. */
|
/* Generate corefile notes for SPU contexts. */
|
|
|
struct linux_spu_corefile_data
|
struct linux_spu_corefile_data
|
{
|
{
|
bfd *obfd;
|
bfd *obfd;
|
char *note_data;
|
char *note_data;
|
int *note_size;
|
int *note_size;
|
};
|
};
|
|
|
static void
|
static void
|
linux_spu_corefile_callback (void *data, int fd)
|
linux_spu_corefile_callback (void *data, int fd)
|
{
|
{
|
struct linux_spu_corefile_data *args = data;
|
struct linux_spu_corefile_data *args = data;
|
int i;
|
int i;
|
|
|
static const char *spu_files[] =
|
static const char *spu_files[] =
|
{
|
{
|
"object-id",
|
"object-id",
|
"mem",
|
"mem",
|
"regs",
|
"regs",
|
"fpcr",
|
"fpcr",
|
"lslr",
|
"lslr",
|
"decr",
|
"decr",
|
"decr_status",
|
"decr_status",
|
"signal1",
|
"signal1",
|
"signal1_type",
|
"signal1_type",
|
"signal2",
|
"signal2",
|
"signal2_type",
|
"signal2_type",
|
"event_mask",
|
"event_mask",
|
"event_status",
|
"event_status",
|
"mbox_info",
|
"mbox_info",
|
"ibox_info",
|
"ibox_info",
|
"wbox_info",
|
"wbox_info",
|
"dma_info",
|
"dma_info",
|
"proxydma_info",
|
"proxydma_info",
|
};
|
};
|
|
|
for (i = 0; i < sizeof (spu_files) / sizeof (spu_files[0]); i++)
|
for (i = 0; i < sizeof (spu_files) / sizeof (spu_files[0]); i++)
|
{
|
{
|
char annex[32], note_name[32];
|
char annex[32], note_name[32];
|
gdb_byte *spu_data;
|
gdb_byte *spu_data;
|
LONGEST spu_len;
|
LONGEST spu_len;
|
|
|
xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[i]);
|
xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[i]);
|
spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
|
spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
|
annex, &spu_data);
|
annex, &spu_data);
|
if (spu_len > 0)
|
if (spu_len > 0)
|
{
|
{
|
xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
|
xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
|
args->note_data = elfcore_write_note (args->obfd, args->note_data,
|
args->note_data = elfcore_write_note (args->obfd, args->note_data,
|
args->note_size, note_name,
|
args->note_size, note_name,
|
NT_SPU, spu_data, spu_len);
|
NT_SPU, spu_data, spu_len);
|
xfree (spu_data);
|
xfree (spu_data);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static char *
|
static char *
|
linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
|
linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
|
{
|
{
|
struct linux_spu_corefile_data args;
|
struct linux_spu_corefile_data args;
|
args.obfd = obfd;
|
args.obfd = obfd;
|
args.note_data = note_data;
|
args.note_data = note_data;
|
args.note_size = note_size;
|
args.note_size = note_size;
|
|
|
iterate_over_spus (PIDGET (inferior_ptid),
|
iterate_over_spus (PIDGET (inferior_ptid),
|
linux_spu_corefile_callback, &args);
|
linux_spu_corefile_callback, &args);
|
|
|
return args.note_data;
|
return args.note_data;
|
}
|
}
|
|
|
/* Fills the "to_make_corefile_note" target vector. Builds the note
|
/* Fills the "to_make_corefile_note" target vector. Builds the note
|
section for a corefile, and returns it in a malloc buffer. */
|
section for a corefile, and returns it in a malloc buffer. */
|
|
|
static char *
|
static char *
|
linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
|
linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
|
{
|
{
|
struct linux_nat_corefile_thread_data thread_args;
|
struct linux_nat_corefile_thread_data thread_args;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
/* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
|
/* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
|
char fname[16] = { '\0' };
|
char fname[16] = { '\0' };
|
/* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
|
/* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
|
char psargs[80] = { '\0' };
|
char psargs[80] = { '\0' };
|
char *note_data = NULL;
|
char *note_data = NULL;
|
ptid_t current_ptid = inferior_ptid;
|
ptid_t current_ptid = inferior_ptid;
|
ptid_t filter = pid_to_ptid (ptid_get_pid (inferior_ptid));
|
ptid_t filter = pid_to_ptid (ptid_get_pid (inferior_ptid));
|
gdb_byte *auxv;
|
gdb_byte *auxv;
|
int auxv_len;
|
int auxv_len;
|
|
|
if (get_exec_file (0))
|
if (get_exec_file (0))
|
{
|
{
|
strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
|
strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
|
strncpy (psargs, get_exec_file (0), sizeof (psargs));
|
strncpy (psargs, get_exec_file (0), sizeof (psargs));
|
if (get_inferior_args ())
|
if (get_inferior_args ())
|
{
|
{
|
char *string_end;
|
char *string_end;
|
char *psargs_end = psargs + sizeof (psargs);
|
char *psargs_end = psargs + sizeof (psargs);
|
|
|
/* linux_elfcore_write_prpsinfo () handles zero unterminated
|
/* linux_elfcore_write_prpsinfo () handles zero unterminated
|
strings fine. */
|
strings fine. */
|
string_end = memchr (psargs, 0, sizeof (psargs));
|
string_end = memchr (psargs, 0, sizeof (psargs));
|
if (string_end != NULL)
|
if (string_end != NULL)
|
{
|
{
|
*string_end++ = ' ';
|
*string_end++ = ' ';
|
strncpy (string_end, get_inferior_args (),
|
strncpy (string_end, get_inferior_args (),
|
psargs_end - string_end);
|
psargs_end - string_end);
|
}
|
}
|
}
|
}
|
note_data = (char *) elfcore_write_prpsinfo (obfd,
|
note_data = (char *) elfcore_write_prpsinfo (obfd,
|
note_data,
|
note_data,
|
note_size, fname, psargs);
|
note_size, fname, psargs);
|
}
|
}
|
|
|
/* Dump information for threads. */
|
/* Dump information for threads. */
|
thread_args.obfd = obfd;
|
thread_args.obfd = obfd;
|
thread_args.note_data = note_data;
|
thread_args.note_data = note_data;
|
thread_args.note_size = note_size;
|
thread_args.note_size = note_size;
|
thread_args.num_notes = 0;
|
thread_args.num_notes = 0;
|
thread_args.stop_signal = find_stop_signal ();
|
thread_args.stop_signal = find_stop_signal ();
|
iterate_over_lwps (filter, linux_nat_corefile_thread_callback, &thread_args);
|
iterate_over_lwps (filter, linux_nat_corefile_thread_callback, &thread_args);
|
gdb_assert (thread_args.num_notes != 0);
|
gdb_assert (thread_args.num_notes != 0);
|
note_data = thread_args.note_data;
|
note_data = thread_args.note_data;
|
|
|
auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
|
auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
|
NULL, &auxv);
|
NULL, &auxv);
|
if (auxv_len > 0)
|
if (auxv_len > 0)
|
{
|
{
|
note_data = elfcore_write_note (obfd, note_data, note_size,
|
note_data = elfcore_write_note (obfd, note_data, note_size,
|
"CORE", NT_AUXV, auxv, auxv_len);
|
"CORE", NT_AUXV, auxv, auxv_len);
|
xfree (auxv);
|
xfree (auxv);
|
}
|
}
|
|
|
note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
|
note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
|
|
|
make_cleanup (xfree, note_data);
|
make_cleanup (xfree, note_data);
|
return note_data;
|
return note_data;
|
}
|
}
|
|
|
/* Implement the "info proc" command. */
|
/* Implement the "info proc" command. */
|
|
|
static void
|
static void
|
linux_nat_info_proc_cmd (char *args, int from_tty)
|
linux_nat_info_proc_cmd (char *args, int from_tty)
|
{
|
{
|
/* A long is used for pid instead of an int to avoid a loss of precision
|
/* A long is used for pid instead of an int to avoid a loss of precision
|
compiler warning from the output of strtoul. */
|
compiler warning from the output of strtoul. */
|
long pid = PIDGET (inferior_ptid);
|
long pid = PIDGET (inferior_ptid);
|
FILE *procfile;
|
FILE *procfile;
|
char **argv = NULL;
|
char **argv = NULL;
|
char buffer[MAXPATHLEN];
|
char buffer[MAXPATHLEN];
|
char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
|
char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
|
int cmdline_f = 1;
|
int cmdline_f = 1;
|
int cwd_f = 1;
|
int cwd_f = 1;
|
int exe_f = 1;
|
int exe_f = 1;
|
int mappings_f = 0;
|
int mappings_f = 0;
|
int environ_f = 0;
|
int environ_f = 0;
|
int status_f = 0;
|
int status_f = 0;
|
int stat_f = 0;
|
int stat_f = 0;
|
int all = 0;
|
int all = 0;
|
struct stat dummy;
|
struct stat dummy;
|
|
|
if (args)
|
if (args)
|
{
|
{
|
/* Break up 'args' into an argv array. */
|
/* Break up 'args' into an argv array. */
|
argv = gdb_buildargv (args);
|
argv = gdb_buildargv (args);
|
make_cleanup_freeargv (argv);
|
make_cleanup_freeargv (argv);
|
}
|
}
|
while (argv != NULL && *argv != NULL)
|
while (argv != NULL && *argv != NULL)
|
{
|
{
|
if (isdigit (argv[0][0]))
|
if (isdigit (argv[0][0]))
|
{
|
{
|
pid = strtoul (argv[0], NULL, 10);
|
pid = strtoul (argv[0], NULL, 10);
|
}
|
}
|
else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
|
else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
|
{
|
{
|
mappings_f = 1;
|
mappings_f = 1;
|
}
|
}
|
else if (strcmp (argv[0], "status") == 0)
|
else if (strcmp (argv[0], "status") == 0)
|
{
|
{
|
status_f = 1;
|
status_f = 1;
|
}
|
}
|
else if (strcmp (argv[0], "stat") == 0)
|
else if (strcmp (argv[0], "stat") == 0)
|
{
|
{
|
stat_f = 1;
|
stat_f = 1;
|
}
|
}
|
else if (strcmp (argv[0], "cmd") == 0)
|
else if (strcmp (argv[0], "cmd") == 0)
|
{
|
{
|
cmdline_f = 1;
|
cmdline_f = 1;
|
}
|
}
|
else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
|
else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
|
{
|
{
|
exe_f = 1;
|
exe_f = 1;
|
}
|
}
|
else if (strcmp (argv[0], "cwd") == 0)
|
else if (strcmp (argv[0], "cwd") == 0)
|
{
|
{
|
cwd_f = 1;
|
cwd_f = 1;
|
}
|
}
|
else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
|
else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
|
{
|
{
|
all = 1;
|
all = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* [...] (future options here) */
|
/* [...] (future options here) */
|
}
|
}
|
argv++;
|
argv++;
|
}
|
}
|
if (pid == 0)
|
if (pid == 0)
|
error (_("No current process: you must name one."));
|
error (_("No current process: you must name one."));
|
|
|
sprintf (fname1, "/proc/%ld", pid);
|
sprintf (fname1, "/proc/%ld", pid);
|
if (stat (fname1, &dummy) != 0)
|
if (stat (fname1, &dummy) != 0)
|
error (_("No /proc directory: '%s'"), fname1);
|
error (_("No /proc directory: '%s'"), fname1);
|
|
|
printf_filtered (_("process %ld\n"), pid);
|
printf_filtered (_("process %ld\n"), pid);
|
if (cmdline_f || all)
|
if (cmdline_f || all)
|
{
|
{
|
sprintf (fname1, "/proc/%ld/cmdline", pid);
|
sprintf (fname1, "/proc/%ld/cmdline", pid);
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
{
|
{
|
struct cleanup *cleanup = make_cleanup_fclose (procfile);
|
struct cleanup *cleanup = make_cleanup_fclose (procfile);
|
if (fgets (buffer, sizeof (buffer), procfile))
|
if (fgets (buffer, sizeof (buffer), procfile))
|
printf_filtered ("cmdline = '%s'\n", buffer);
|
printf_filtered ("cmdline = '%s'\n", buffer);
|
else
|
else
|
warning (_("unable to read '%s'"), fname1);
|
warning (_("unable to read '%s'"), fname1);
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
}
|
}
|
else
|
else
|
warning (_("unable to open /proc file '%s'"), fname1);
|
warning (_("unable to open /proc file '%s'"), fname1);
|
}
|
}
|
if (cwd_f || all)
|
if (cwd_f || all)
|
{
|
{
|
sprintf (fname1, "/proc/%ld/cwd", pid);
|
sprintf (fname1, "/proc/%ld/cwd", pid);
|
memset (fname2, 0, sizeof (fname2));
|
memset (fname2, 0, sizeof (fname2));
|
if (readlink (fname1, fname2, sizeof (fname2)) > 0)
|
if (readlink (fname1, fname2, sizeof (fname2)) > 0)
|
printf_filtered ("cwd = '%s'\n", fname2);
|
printf_filtered ("cwd = '%s'\n", fname2);
|
else
|
else
|
warning (_("unable to read link '%s'"), fname1);
|
warning (_("unable to read link '%s'"), fname1);
|
}
|
}
|
if (exe_f || all)
|
if (exe_f || all)
|
{
|
{
|
sprintf (fname1, "/proc/%ld/exe", pid);
|
sprintf (fname1, "/proc/%ld/exe", pid);
|
memset (fname2, 0, sizeof (fname2));
|
memset (fname2, 0, sizeof (fname2));
|
if (readlink (fname1, fname2, sizeof (fname2)) > 0)
|
if (readlink (fname1, fname2, sizeof (fname2)) > 0)
|
printf_filtered ("exe = '%s'\n", fname2);
|
printf_filtered ("exe = '%s'\n", fname2);
|
else
|
else
|
warning (_("unable to read link '%s'"), fname1);
|
warning (_("unable to read link '%s'"), fname1);
|
}
|
}
|
if (mappings_f || all)
|
if (mappings_f || all)
|
{
|
{
|
sprintf (fname1, "/proc/%ld/maps", pid);
|
sprintf (fname1, "/proc/%ld/maps", pid);
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
{
|
{
|
long long addr, endaddr, size, offset, inode;
|
long long addr, endaddr, size, offset, inode;
|
char permissions[8], device[8], filename[MAXPATHLEN];
|
char permissions[8], device[8], filename[MAXPATHLEN];
|
struct cleanup *cleanup;
|
struct cleanup *cleanup;
|
|
|
cleanup = make_cleanup_fclose (procfile);
|
cleanup = make_cleanup_fclose (procfile);
|
printf_filtered (_("Mapped address spaces:\n\n"));
|
printf_filtered (_("Mapped address spaces:\n\n"));
|
if (gdbarch_addr_bit (target_gdbarch) == 32)
|
if (gdbarch_addr_bit (target_gdbarch) == 32)
|
{
|
{
|
printf_filtered ("\t%10s %10s %10s %10s %7s\n",
|
printf_filtered ("\t%10s %10s %10s %10s %7s\n",
|
"Start Addr",
|
"Start Addr",
|
" End Addr",
|
" End Addr",
|
" Size", " Offset", "objfile");
|
" Size", " Offset", "objfile");
|
}
|
}
|
else
|
else
|
{
|
{
|
printf_filtered (" %18s %18s %10s %10s %7s\n",
|
printf_filtered (" %18s %18s %10s %10s %7s\n",
|
"Start Addr",
|
"Start Addr",
|
" End Addr",
|
" End Addr",
|
" Size", " Offset", "objfile");
|
" Size", " Offset", "objfile");
|
}
|
}
|
|
|
while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
|
while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
|
&offset, &device[0], &inode, &filename[0]))
|
&offset, &device[0], &inode, &filename[0]))
|
{
|
{
|
size = endaddr - addr;
|
size = endaddr - addr;
|
|
|
/* FIXME: carlton/2003-08-27: Maybe the printf_filtered
|
/* FIXME: carlton/2003-08-27: Maybe the printf_filtered
|
calls here (and possibly above) should be abstracted
|
calls here (and possibly above) should be abstracted
|
out into their own functions? Andrew suggests using
|
out into their own functions? Andrew suggests using
|
a generic local_address_string instead to print out
|
a generic local_address_string instead to print out
|
the addresses; that makes sense to me, too. */
|
the addresses; that makes sense to me, too. */
|
|
|
if (gdbarch_addr_bit (target_gdbarch) == 32)
|
if (gdbarch_addr_bit (target_gdbarch) == 32)
|
{
|
{
|
printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
|
printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
|
(unsigned long) addr, /* FIXME: pr_addr */
|
(unsigned long) addr, /* FIXME: pr_addr */
|
(unsigned long) endaddr,
|
(unsigned long) endaddr,
|
(int) size,
|
(int) size,
|
(unsigned int) offset,
|
(unsigned int) offset,
|
filename[0] ? filename : "");
|
filename[0] ? filename : "");
|
}
|
}
|
else
|
else
|
{
|
{
|
printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
|
printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
|
(unsigned long) addr, /* FIXME: pr_addr */
|
(unsigned long) addr, /* FIXME: pr_addr */
|
(unsigned long) endaddr,
|
(unsigned long) endaddr,
|
(int) size,
|
(int) size,
|
(unsigned int) offset,
|
(unsigned int) offset,
|
filename[0] ? filename : "");
|
filename[0] ? filename : "");
|
}
|
}
|
}
|
}
|
|
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
}
|
}
|
else
|
else
|
warning (_("unable to open /proc file '%s'"), fname1);
|
warning (_("unable to open /proc file '%s'"), fname1);
|
}
|
}
|
if (status_f || all)
|
if (status_f || all)
|
{
|
{
|
sprintf (fname1, "/proc/%ld/status", pid);
|
sprintf (fname1, "/proc/%ld/status", pid);
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
{
|
{
|
struct cleanup *cleanup = make_cleanup_fclose (procfile);
|
struct cleanup *cleanup = make_cleanup_fclose (procfile);
|
while (fgets (buffer, sizeof (buffer), procfile) != NULL)
|
while (fgets (buffer, sizeof (buffer), procfile) != NULL)
|
puts_filtered (buffer);
|
puts_filtered (buffer);
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
}
|
}
|
else
|
else
|
warning (_("unable to open /proc file '%s'"), fname1);
|
warning (_("unable to open /proc file '%s'"), fname1);
|
}
|
}
|
if (stat_f || all)
|
if (stat_f || all)
|
{
|
{
|
sprintf (fname1, "/proc/%ld/stat", pid);
|
sprintf (fname1, "/proc/%ld/stat", pid);
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
if ((procfile = fopen (fname1, "r")) != NULL)
|
{
|
{
|
int itmp;
|
int itmp;
|
char ctmp;
|
char ctmp;
|
long ltmp;
|
long ltmp;
|
struct cleanup *cleanup = make_cleanup_fclose (procfile);
|
struct cleanup *cleanup = make_cleanup_fclose (procfile);
|
|
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
printf_filtered (_("Process: %d\n"), itmp);
|
printf_filtered (_("Process: %d\n"), itmp);
|
if (fscanf (procfile, "(%[^)]) ", &buffer[0]) > 0)
|
if (fscanf (procfile, "(%[^)]) ", &buffer[0]) > 0)
|
printf_filtered (_("Exec file: %s\n"), buffer);
|
printf_filtered (_("Exec file: %s\n"), buffer);
|
if (fscanf (procfile, "%c ", &ctmp) > 0)
|
if (fscanf (procfile, "%c ", &ctmp) > 0)
|
printf_filtered (_("State: %c\n"), ctmp);
|
printf_filtered (_("State: %c\n"), ctmp);
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
printf_filtered (_("Parent process: %d\n"), itmp);
|
printf_filtered (_("Parent process: %d\n"), itmp);
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
printf_filtered (_("Process group: %d\n"), itmp);
|
printf_filtered (_("Process group: %d\n"), itmp);
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
printf_filtered (_("Session id: %d\n"), itmp);
|
printf_filtered (_("Session id: %d\n"), itmp);
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
printf_filtered (_("TTY: %d\n"), itmp);
|
printf_filtered (_("TTY: %d\n"), itmp);
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
if (fscanf (procfile, "%d ", &itmp) > 0)
|
printf_filtered (_("TTY owner process group: %d\n"), itmp);
|
printf_filtered (_("TTY owner process group: %d\n"), itmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Flags: 0x%lx\n"), ltmp);
|
printf_filtered (_("Flags: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Minor faults (no memory page): %lu\n"),
|
printf_filtered (_("Minor faults (no memory page): %lu\n"),
|
(unsigned long) ltmp);
|
(unsigned long) ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Minor faults, children: %lu\n"),
|
printf_filtered (_("Minor faults, children: %lu\n"),
|
(unsigned long) ltmp);
|
(unsigned long) ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Major faults (memory page faults): %lu\n"),
|
printf_filtered (_("Major faults (memory page faults): %lu\n"),
|
(unsigned long) ltmp);
|
(unsigned long) ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Major faults, children: %lu\n"),
|
printf_filtered (_("Major faults, children: %lu\n"),
|
(unsigned long) ltmp);
|
(unsigned long) ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("utime: %ld\n"), ltmp);
|
printf_filtered (_("utime: %ld\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("stime: %ld\n"), ltmp);
|
printf_filtered (_("stime: %ld\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("utime, children: %ld\n"), ltmp);
|
printf_filtered (_("utime, children: %ld\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("stime, children: %ld\n"), ltmp);
|
printf_filtered (_("stime, children: %ld\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
|
printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
|
ltmp);
|
ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("'nice' value: %ld\n"), ltmp);
|
printf_filtered (_("'nice' value: %ld\n"), ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("jiffies until next timeout: %lu\n"),
|
printf_filtered (_("jiffies until next timeout: %lu\n"),
|
(unsigned long) ltmp);
|
(unsigned long) ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
|
printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
|
(unsigned long) ltmp);
|
(unsigned long) ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("start time (jiffies since system boot): %ld\n"),
|
printf_filtered (_("start time (jiffies since system boot): %ld\n"),
|
ltmp);
|
ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Virtual memory size: %lu\n"),
|
printf_filtered (_("Virtual memory size: %lu\n"),
|
(unsigned long) ltmp);
|
(unsigned long) ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp);
|
printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp);
|
printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Start of text: 0x%lx\n"), ltmp);
|
printf_filtered (_("Start of text: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("End of text: 0x%lx\n"), ltmp);
|
printf_filtered (_("End of text: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
if (fscanf (procfile, "%lu ", <mp) > 0)
|
printf_filtered (_("Start of stack: 0x%lx\n"), ltmp);
|
printf_filtered (_("Start of stack: 0x%lx\n"), ltmp);
|
#if 0 /* Don't know how architecture-dependent the rest is...
|
#if 0 /* Don't know how architecture-dependent the rest is...
|
Anyway the signal bitmap info is available from "status". */
|
Anyway the signal bitmap info is available from "status". */
|
if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
|
if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
|
printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp);
|
printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
|
if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
|
printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp);
|
printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp);
|
printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp);
|
printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp);
|
printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
if (fscanf (procfile, "%ld ", <mp) > 0)
|
printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp);
|
printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp);
|
if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
|
if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
|
printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp);
|
printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp);
|
#endif
|
#endif
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
}
|
}
|
else
|
else
|
warning (_("unable to open /proc file '%s'"), fname1);
|
warning (_("unable to open /proc file '%s'"), fname1);
|
}
|
}
|
}
|
}
|
|
|
/* Implement the to_xfer_partial interface for memory reads using the /proc
|
/* Implement the to_xfer_partial interface for memory reads using the /proc
|
filesystem. Because we can use a single read() call for /proc, this
|
filesystem. Because we can use a single read() call for /proc, this
|
can be much more efficient than banging away at PTRACE_PEEKTEXT,
|
can be much more efficient than banging away at PTRACE_PEEKTEXT,
|
but it doesn't support writes. */
|
but it doesn't support writes. */
|
|
|
static LONGEST
|
static LONGEST
|
linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
|
linux_proc_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)
|
{
|
{
|
LONGEST ret;
|
LONGEST ret;
|
int fd;
|
int fd;
|
char filename[64];
|
char filename[64];
|
|
|
if (object != TARGET_OBJECT_MEMORY || !readbuf)
|
if (object != TARGET_OBJECT_MEMORY || !readbuf)
|
return 0;
|
return 0;
|
|
|
/* Don't bother for one word. */
|
/* Don't bother for one word. */
|
if (len < 3 * sizeof (long))
|
if (len < 3 * sizeof (long))
|
return 0;
|
return 0;
|
|
|
/* We could keep this file open and cache it - possibly one per
|
/* We could keep this file open and cache it - possibly one per
|
thread. That requires some juggling, but is even faster. */
|
thread. That requires some juggling, but is even faster. */
|
sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
|
sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
|
fd = open (filename, O_RDONLY | O_LARGEFILE);
|
fd = open (filename, O_RDONLY | O_LARGEFILE);
|
if (fd == -1)
|
if (fd == -1)
|
return 0;
|
return 0;
|
|
|
/* If pread64 is available, use it. It's faster if the kernel
|
/* If pread64 is available, use it. It's faster if the kernel
|
supports it (only one syscall), and it's 64-bit safe even on
|
supports it (only one syscall), and it's 64-bit safe even on
|
32-bit platforms (for instance, SPARC debugging a SPARC64
|
32-bit platforms (for instance, SPARC debugging a SPARC64
|
application). */
|
application). */
|
#ifdef HAVE_PREAD64
|
#ifdef HAVE_PREAD64
|
if (pread64 (fd, readbuf, len, offset) != len)
|
if (pread64 (fd, readbuf, len, offset) != len)
|
#else
|
#else
|
if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
|
if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
|
#endif
|
#endif
|
ret = 0;
|
ret = 0;
|
else
|
else
|
ret = len;
|
ret = len;
|
|
|
close (fd);
|
close (fd);
|
return ret;
|
return ret;
|
}
|
}
|
|
|
|
|
/* Enumerate spufs IDs for process PID. */
|
/* Enumerate spufs IDs for process PID. */
|
static LONGEST
|
static LONGEST
|
spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, LONGEST len)
|
spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, LONGEST len)
|
{
|
{
|
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
|
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
|
LONGEST pos = 0;
|
LONGEST pos = 0;
|
LONGEST written = 0;
|
LONGEST written = 0;
|
char path[128];
|
char path[128];
|
DIR *dir;
|
DIR *dir;
|
struct dirent *entry;
|
struct dirent *entry;
|
|
|
xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
|
xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
|
dir = opendir (path);
|
dir = opendir (path);
|
if (!dir)
|
if (!dir)
|
return -1;
|
return -1;
|
|
|
rewinddir (dir);
|
rewinddir (dir);
|
while ((entry = readdir (dir)) != NULL)
|
while ((entry = readdir (dir)) != NULL)
|
{
|
{
|
struct stat st;
|
struct stat st;
|
struct statfs stfs;
|
struct statfs stfs;
|
int fd;
|
int fd;
|
|
|
fd = atoi (entry->d_name);
|
fd = atoi (entry->d_name);
|
if (!fd)
|
if (!fd)
|
continue;
|
continue;
|
|
|
xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
|
xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
|
if (stat (path, &st) != 0)
|
if (stat (path, &st) != 0)
|
continue;
|
continue;
|
if (!S_ISDIR (st.st_mode))
|
if (!S_ISDIR (st.st_mode))
|
continue;
|
continue;
|
|
|
if (statfs (path, &stfs) != 0)
|
if (statfs (path, &stfs) != 0)
|
continue;
|
continue;
|
if (stfs.f_type != SPUFS_MAGIC)
|
if (stfs.f_type != SPUFS_MAGIC)
|
continue;
|
continue;
|
|
|
if (pos >= offset && pos + 4 <= offset + len)
|
if (pos >= offset && pos + 4 <= offset + len)
|
{
|
{
|
store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
|
store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
|
written += 4;
|
written += 4;
|
}
|
}
|
pos += 4;
|
pos += 4;
|
}
|
}
|
|
|
closedir (dir);
|
closedir (dir);
|
return written;
|
return written;
|
}
|
}
|
|
|
/* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
|
/* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
|
object type, using the /proc file system. */
|
object type, using the /proc file system. */
|
static LONGEST
|
static LONGEST
|
linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
|
linux_proc_xfer_spu (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)
|
{
|
{
|
char buf[128];
|
char buf[128];
|
int fd = 0;
|
int fd = 0;
|
int ret = -1;
|
int ret = -1;
|
int pid = PIDGET (inferior_ptid);
|
int pid = PIDGET (inferior_ptid);
|
|
|
if (!annex)
|
if (!annex)
|
{
|
{
|
if (!readbuf)
|
if (!readbuf)
|
return -1;
|
return -1;
|
else
|
else
|
return spu_enumerate_spu_ids (pid, readbuf, offset, len);
|
return spu_enumerate_spu_ids (pid, readbuf, offset, len);
|
}
|
}
|
|
|
xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
|
xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
|
fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
|
fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
|
if (fd <= 0)
|
if (fd <= 0)
|
return -1;
|
return -1;
|
|
|
if (offset != 0
|
if (offset != 0
|
&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
|
&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
|
{
|
{
|
close (fd);
|
close (fd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (writebuf)
|
if (writebuf)
|
ret = write (fd, writebuf, (size_t) len);
|
ret = write (fd, writebuf, (size_t) len);
|
else if (readbuf)
|
else if (readbuf)
|
ret = read (fd, readbuf, (size_t) len);
|
ret = read (fd, readbuf, (size_t) len);
|
|
|
close (fd);
|
close (fd);
|
return ret;
|
return ret;
|
}
|
}
|
|
|
|
|
/* Parse LINE as a signal set and add its set bits to SIGS. */
|
/* Parse LINE as a signal set and add its set bits to SIGS. */
|
|
|
static void
|
static void
|
add_line_to_sigset (const char *line, sigset_t *sigs)
|
add_line_to_sigset (const char *line, sigset_t *sigs)
|
{
|
{
|
int len = strlen (line) - 1;
|
int len = strlen (line) - 1;
|
const char *p;
|
const char *p;
|
int signum;
|
int signum;
|
|
|
if (line[len] != '\n')
|
if (line[len] != '\n')
|
error (_("Could not parse signal set: %s"), line);
|
error (_("Could not parse signal set: %s"), line);
|
|
|
p = line;
|
p = line;
|
signum = len * 4;
|
signum = len * 4;
|
while (len-- > 0)
|
while (len-- > 0)
|
{
|
{
|
int digit;
|
int digit;
|
|
|
if (*p >= '0' && *p <= '9')
|
if (*p >= '0' && *p <= '9')
|
digit = *p - '0';
|
digit = *p - '0';
|
else if (*p >= 'a' && *p <= 'f')
|
else if (*p >= 'a' && *p <= 'f')
|
digit = *p - 'a' + 10;
|
digit = *p - 'a' + 10;
|
else
|
else
|
error (_("Could not parse signal set: %s"), line);
|
error (_("Could not parse signal set: %s"), line);
|
|
|
signum -= 4;
|
signum -= 4;
|
|
|
if (digit & 1)
|
if (digit & 1)
|
sigaddset (sigs, signum + 1);
|
sigaddset (sigs, signum + 1);
|
if (digit & 2)
|
if (digit & 2)
|
sigaddset (sigs, signum + 2);
|
sigaddset (sigs, signum + 2);
|
if (digit & 4)
|
if (digit & 4)
|
sigaddset (sigs, signum + 3);
|
sigaddset (sigs, signum + 3);
|
if (digit & 8)
|
if (digit & 8)
|
sigaddset (sigs, signum + 4);
|
sigaddset (sigs, signum + 4);
|
|
|
p++;
|
p++;
|
}
|
}
|
}
|
}
|
|
|
/* Find process PID's pending signals from /proc/pid/status and set
|
/* Find process PID's pending signals from /proc/pid/status and set
|
SIGS to match. */
|
SIGS to match. */
|
|
|
void
|
void
|
linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
|
linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
|
{
|
{
|
FILE *procfile;
|
FILE *procfile;
|
char buffer[MAXPATHLEN], fname[MAXPATHLEN];
|
char buffer[MAXPATHLEN], fname[MAXPATHLEN];
|
int signum;
|
int signum;
|
struct cleanup *cleanup;
|
struct cleanup *cleanup;
|
|
|
sigemptyset (pending);
|
sigemptyset (pending);
|
sigemptyset (blocked);
|
sigemptyset (blocked);
|
sigemptyset (ignored);
|
sigemptyset (ignored);
|
sprintf (fname, "/proc/%d/status", pid);
|
sprintf (fname, "/proc/%d/status", pid);
|
procfile = fopen (fname, "r");
|
procfile = fopen (fname, "r");
|
if (procfile == NULL)
|
if (procfile == NULL)
|
error (_("Could not open %s"), fname);
|
error (_("Could not open %s"), fname);
|
cleanup = make_cleanup_fclose (procfile);
|
cleanup = make_cleanup_fclose (procfile);
|
|
|
while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
|
while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
|
{
|
{
|
/* Normal queued signals are on the SigPnd line in the status
|
/* Normal queued signals are on the SigPnd line in the status
|
file. However, 2.6 kernels also have a "shared" pending
|
file. However, 2.6 kernels also have a "shared" pending
|
queue for delivering signals to a thread group, so check for
|
queue for delivering signals to a thread group, so check for
|
a ShdPnd line also.
|
a ShdPnd line also.
|
|
|
Unfortunately some Red Hat kernels include the shared pending
|
Unfortunately some Red Hat kernels include the shared pending
|
queue but not the ShdPnd status field. */
|
queue but not the ShdPnd status field. */
|
|
|
if (strncmp (buffer, "SigPnd:\t", 8) == 0)
|
if (strncmp (buffer, "SigPnd:\t", 8) == 0)
|
add_line_to_sigset (buffer + 8, pending);
|
add_line_to_sigset (buffer + 8, pending);
|
else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
|
else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
|
add_line_to_sigset (buffer + 8, pending);
|
add_line_to_sigset (buffer + 8, pending);
|
else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
|
else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
|
add_line_to_sigset (buffer + 8, blocked);
|
add_line_to_sigset (buffer + 8, blocked);
|
else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
|
else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
|
add_line_to_sigset (buffer + 8, ignored);
|
add_line_to_sigset (buffer + 8, ignored);
|
}
|
}
|
|
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
}
|
}
|
|
|
static LONGEST
|
static LONGEST
|
linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
|
linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
|
const char *annex, gdb_byte *readbuf,
|
const char *annex, gdb_byte *readbuf,
|
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
|
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
|
{
|
{
|
/* We make the process list snapshot when the object starts to be
|
/* We make the process list snapshot when the object starts to be
|
read. */
|
read. */
|
static const char *buf;
|
static const char *buf;
|
static LONGEST len_avail = -1;
|
static LONGEST len_avail = -1;
|
static struct obstack obstack;
|
static struct obstack obstack;
|
|
|
DIR *dirp;
|
DIR *dirp;
|
|
|
gdb_assert (object == TARGET_OBJECT_OSDATA);
|
gdb_assert (object == TARGET_OBJECT_OSDATA);
|
|
|
if (strcmp (annex, "processes") != 0)
|
if (strcmp (annex, "processes") != 0)
|
return 0;
|
return 0;
|
|
|
gdb_assert (readbuf && !writebuf);
|
gdb_assert (readbuf && !writebuf);
|
|
|
if (offset == 0)
|
if (offset == 0)
|
{
|
{
|
if (len_avail != -1 && len_avail != 0)
|
if (len_avail != -1 && len_avail != 0)
|
obstack_free (&obstack, NULL);
|
obstack_free (&obstack, NULL);
|
len_avail = 0;
|
len_avail = 0;
|
buf = NULL;
|
buf = NULL;
|
obstack_init (&obstack);
|
obstack_init (&obstack);
|
obstack_grow_str (&obstack, "<osdata type=\"processes\">\n");
|
obstack_grow_str (&obstack, "<osdata type=\"processes\">\n");
|
|
|
dirp = opendir ("/proc");
|
dirp = opendir ("/proc");
|
if (dirp)
|
if (dirp)
|
{
|
{
|
struct dirent *dp;
|
struct dirent *dp;
|
while ((dp = readdir (dirp)) != NULL)
|
while ((dp = readdir (dirp)) != NULL)
|
{
|
{
|
struct stat statbuf;
|
struct stat statbuf;
|
char procentry[sizeof ("/proc/4294967295")];
|
char procentry[sizeof ("/proc/4294967295")];
|
|
|
if (!isdigit (dp->d_name[0])
|
if (!isdigit (dp->d_name[0])
|
|| NAMELEN (dp) > sizeof ("4294967295") - 1)
|
|| NAMELEN (dp) > sizeof ("4294967295") - 1)
|
continue;
|
continue;
|
|
|
sprintf (procentry, "/proc/%s", dp->d_name);
|
sprintf (procentry, "/proc/%s", dp->d_name);
|
if (stat (procentry, &statbuf) == 0
|
if (stat (procentry, &statbuf) == 0
|
&& S_ISDIR (statbuf.st_mode))
|
&& S_ISDIR (statbuf.st_mode))
|
{
|
{
|
char *pathname;
|
char *pathname;
|
FILE *f;
|
FILE *f;
|
char cmd[MAXPATHLEN + 1];
|
char cmd[MAXPATHLEN + 1];
|
struct passwd *entry;
|
struct passwd *entry;
|
|
|
pathname = xstrprintf ("/proc/%s/cmdline", dp->d_name);
|
pathname = xstrprintf ("/proc/%s/cmdline", dp->d_name);
|
entry = getpwuid (statbuf.st_uid);
|
entry = getpwuid (statbuf.st_uid);
|
|
|
if ((f = fopen (pathname, "r")) != NULL)
|
if ((f = fopen (pathname, "r")) != NULL)
|
{
|
{
|
size_t len = fread (cmd, 1, sizeof (cmd) - 1, f);
|
size_t len = fread (cmd, 1, sizeof (cmd) - 1, f);
|
if (len > 0)
|
if (len > 0)
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
if (cmd[i] == '\0')
|
if (cmd[i] == '\0')
|
cmd[i] = ' ';
|
cmd[i] = ' ';
|
cmd[len] = '\0';
|
cmd[len] = '\0';
|
|
|
obstack_xml_printf (
|
obstack_xml_printf (
|
&obstack,
|
&obstack,
|
"<item>"
|
"<item>"
|
"<column name=\"pid\">%s</column>"
|
"<column name=\"pid\">%s</column>"
|
"<column name=\"user\">%s</column>"
|
"<column name=\"user\">%s</column>"
|
"<column name=\"command\">%s</column>"
|
"<column name=\"command\">%s</column>"
|
"</item>",
|
"</item>",
|
dp->d_name,
|
dp->d_name,
|
entry ? entry->pw_name : "?",
|
entry ? entry->pw_name : "?",
|
cmd);
|
cmd);
|
}
|
}
|
fclose (f);
|
fclose (f);
|
}
|
}
|
|
|
xfree (pathname);
|
xfree (pathname);
|
}
|
}
|
}
|
}
|
|
|
closedir (dirp);
|
closedir (dirp);
|
}
|
}
|
|
|
obstack_grow_str0 (&obstack, "</osdata>\n");
|
obstack_grow_str0 (&obstack, "</osdata>\n");
|
buf = obstack_finish (&obstack);
|
buf = obstack_finish (&obstack);
|
len_avail = strlen (buf);
|
len_avail = strlen (buf);
|
}
|
}
|
|
|
if (offset >= len_avail)
|
if (offset >= len_avail)
|
{
|
{
|
/* Done. Get rid of the obstack. */
|
/* Done. Get rid of the obstack. */
|
obstack_free (&obstack, NULL);
|
obstack_free (&obstack, NULL);
|
buf = NULL;
|
buf = NULL;
|
len_avail = 0;
|
len_avail = 0;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (len > len_avail - offset)
|
if (len > len_avail - offset)
|
len = len_avail - offset;
|
len = len_avail - offset;
|
memcpy (readbuf, buf + offset, len);
|
memcpy (readbuf, buf + offset, len);
|
|
|
return len;
|
return len;
|
}
|
}
|
|
|
static LONGEST
|
static LONGEST
|
linux_xfer_partial (struct target_ops *ops, enum target_object object,
|
linux_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, ULONGEST offset, LONGEST len)
|
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
|
{
|
{
|
LONGEST xfer;
|
LONGEST xfer;
|
|
|
if (object == TARGET_OBJECT_AUXV)
|
if (object == TARGET_OBJECT_AUXV)
|
return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
|
return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
|
offset, len);
|
offset, len);
|
|
|
if (object == TARGET_OBJECT_OSDATA)
|
if (object == TARGET_OBJECT_OSDATA)
|
return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
|
return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
|
offset, len);
|
offset, len);
|
|
|
if (object == TARGET_OBJECT_SPU)
|
if (object == TARGET_OBJECT_SPU)
|
return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
|
return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
|
offset, len);
|
offset, len);
|
|
|
/* GDB calculates all the addresses in possibly larget width of the address.
|
/* GDB calculates all the addresses in possibly larget width of the address.
|
Address width needs to be masked before its final use - either by
|
Address width needs to be masked before its final use - either by
|
linux_proc_xfer_partial or inf_ptrace_xfer_partial.
|
linux_proc_xfer_partial or inf_ptrace_xfer_partial.
|
|
|
Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
|
Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
|
|
|
if (object == TARGET_OBJECT_MEMORY)
|
if (object == TARGET_OBJECT_MEMORY)
|
{
|
{
|
int addr_bit = gdbarch_addr_bit (target_gdbarch);
|
int addr_bit = gdbarch_addr_bit (target_gdbarch);
|
|
|
if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
|
if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
|
offset &= ((ULONGEST) 1 << addr_bit) - 1;
|
offset &= ((ULONGEST) 1 << addr_bit) - 1;
|
}
|
}
|
|
|
xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
|
xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
|
offset, len);
|
offset, len);
|
if (xfer != 0)
|
if (xfer != 0)
|
return xfer;
|
return xfer;
|
|
|
return super_xfer_partial (ops, object, annex, readbuf, writebuf,
|
return super_xfer_partial (ops, object, annex, readbuf, writebuf,
|
offset, len);
|
offset, len);
|
}
|
}
|
|
|
/* Create a prototype generic GNU/Linux target. The client can override
|
/* Create a prototype generic GNU/Linux target. The client can override
|
it with local methods. */
|
it with local methods. */
|
|
|
static void
|
static void
|
linux_target_install_ops (struct target_ops *t)
|
linux_target_install_ops (struct target_ops *t)
|
{
|
{
|
t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
|
t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
|
t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
|
t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
|
t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
|
t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
|
t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
|
t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
|
t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
|
t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
|
t->to_post_startup_inferior = linux_child_post_startup_inferior;
|
t->to_post_startup_inferior = linux_child_post_startup_inferior;
|
t->to_post_attach = linux_child_post_attach;
|
t->to_post_attach = linux_child_post_attach;
|
t->to_follow_fork = linux_child_follow_fork;
|
t->to_follow_fork = linux_child_follow_fork;
|
t->to_find_memory_regions = linux_nat_find_memory_regions;
|
t->to_find_memory_regions = linux_nat_find_memory_regions;
|
t->to_make_corefile_notes = linux_nat_make_corefile_notes;
|
t->to_make_corefile_notes = linux_nat_make_corefile_notes;
|
|
|
super_xfer_partial = t->to_xfer_partial;
|
super_xfer_partial = t->to_xfer_partial;
|
t->to_xfer_partial = linux_xfer_partial;
|
t->to_xfer_partial = linux_xfer_partial;
|
}
|
}
|
|
|
struct target_ops *
|
struct target_ops *
|
linux_target (void)
|
linux_target (void)
|
{
|
{
|
struct target_ops *t;
|
struct target_ops *t;
|
|
|
t = inf_ptrace_target ();
|
t = inf_ptrace_target ();
|
linux_target_install_ops (t);
|
linux_target_install_ops (t);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
struct target_ops *
|
struct target_ops *
|
linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
|
linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
|
{
|
{
|
struct target_ops *t;
|
struct target_ops *t;
|
|
|
t = inf_ptrace_trad_target (register_u_offset);
|
t = inf_ptrace_trad_target (register_u_offset);
|
linux_target_install_ops (t);
|
linux_target_install_ops (t);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* target_is_async_p implementation. */
|
/* target_is_async_p implementation. */
|
|
|
static int
|
static int
|
linux_nat_is_async_p (void)
|
linux_nat_is_async_p (void)
|
{
|
{
|
/* NOTE: palves 2008-03-21: We're only async when the user requests
|
/* NOTE: palves 2008-03-21: We're only async when the user requests
|
it explicitly with the "set target-async" command.
|
it explicitly with the "set target-async" command.
|
Someday, linux will always be async. */
|
Someday, linux will always be async. */
|
if (!target_async_permitted)
|
if (!target_async_permitted)
|
return 0;
|
return 0;
|
|
|
/* See target.h/target_async_mask. */
|
/* See target.h/target_async_mask. */
|
return linux_nat_async_mask_value;
|
return linux_nat_async_mask_value;
|
}
|
}
|
|
|
/* target_can_async_p implementation. */
|
/* target_can_async_p implementation. */
|
|
|
static int
|
static int
|
linux_nat_can_async_p (void)
|
linux_nat_can_async_p (void)
|
{
|
{
|
/* NOTE: palves 2008-03-21: We're only async when the user requests
|
/* NOTE: palves 2008-03-21: We're only async when the user requests
|
it explicitly with the "set target-async" command.
|
it explicitly with the "set target-async" command.
|
Someday, linux will always be async. */
|
Someday, linux will always be async. */
|
if (!target_async_permitted)
|
if (!target_async_permitted)
|
return 0;
|
return 0;
|
|
|
/* See target.h/target_async_mask. */
|
/* See target.h/target_async_mask. */
|
return linux_nat_async_mask_value;
|
return linux_nat_async_mask_value;
|
}
|
}
|
|
|
static int
|
static int
|
linux_nat_supports_non_stop (void)
|
linux_nat_supports_non_stop (void)
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* True if we want to support multi-process. To be removed when GDB
|
/* True if we want to support multi-process. To be removed when GDB
|
supports multi-exec. */
|
supports multi-exec. */
|
|
|
int linux_multi_process = 1;
|
int linux_multi_process = 1;
|
|
|
static int
|
static int
|
linux_nat_supports_multi_process (void)
|
linux_nat_supports_multi_process (void)
|
{
|
{
|
return linux_multi_process;
|
return linux_multi_process;
|
}
|
}
|
|
|
/* target_async_mask implementation. */
|
/* target_async_mask implementation. */
|
|
|
static int
|
static int
|
linux_nat_async_mask (int new_mask)
|
linux_nat_async_mask (int new_mask)
|
{
|
{
|
int curr_mask = linux_nat_async_mask_value;
|
int curr_mask = linux_nat_async_mask_value;
|
|
|
if (curr_mask != new_mask)
|
if (curr_mask != new_mask)
|
{
|
{
|
if (new_mask == 0)
|
if (new_mask == 0)
|
{
|
{
|
linux_nat_async (NULL, 0);
|
linux_nat_async (NULL, 0);
|
linux_nat_async_mask_value = new_mask;
|
linux_nat_async_mask_value = new_mask;
|
}
|
}
|
else
|
else
|
{
|
{
|
linux_nat_async_mask_value = new_mask;
|
linux_nat_async_mask_value = new_mask;
|
|
|
/* If we're going out of async-mask in all-stop, then the
|
/* If we're going out of async-mask in all-stop, then the
|
inferior is stopped. The next resume will call
|
inferior is stopped. The next resume will call
|
target_async. In non-stop, the target event source
|
target_async. In non-stop, the target event source
|
should be always registered in the event loop. Do so
|
should be always registered in the event loop. Do so
|
now. */
|
now. */
|
if (non_stop)
|
if (non_stop)
|
linux_nat_async (inferior_event_handler, 0);
|
linux_nat_async (inferior_event_handler, 0);
|
}
|
}
|
}
|
}
|
|
|
return curr_mask;
|
return curr_mask;
|
}
|
}
|
|
|
static int async_terminal_is_ours = 1;
|
static int async_terminal_is_ours = 1;
|
|
|
/* target_terminal_inferior implementation. */
|
/* target_terminal_inferior implementation. */
|
|
|
static void
|
static void
|
linux_nat_terminal_inferior (void)
|
linux_nat_terminal_inferior (void)
|
{
|
{
|
if (!target_is_async_p ())
|
if (!target_is_async_p ())
|
{
|
{
|
/* Async mode is disabled. */
|
/* Async mode is disabled. */
|
terminal_inferior ();
|
terminal_inferior ();
|
return;
|
return;
|
}
|
}
|
|
|
terminal_inferior ();
|
terminal_inferior ();
|
|
|
/* Calls to target_terminal_*() are meant to be idempotent. */
|
/* Calls to target_terminal_*() are meant to be idempotent. */
|
if (!async_terminal_is_ours)
|
if (!async_terminal_is_ours)
|
return;
|
return;
|
|
|
delete_file_handler (input_fd);
|
delete_file_handler (input_fd);
|
async_terminal_is_ours = 0;
|
async_terminal_is_ours = 0;
|
set_sigint_trap ();
|
set_sigint_trap ();
|
}
|
}
|
|
|
/* target_terminal_ours implementation. */
|
/* target_terminal_ours implementation. */
|
|
|
static void
|
static void
|
linux_nat_terminal_ours (void)
|
linux_nat_terminal_ours (void)
|
{
|
{
|
if (!target_is_async_p ())
|
if (!target_is_async_p ())
|
{
|
{
|
/* Async mode is disabled. */
|
/* Async mode is disabled. */
|
terminal_ours ();
|
terminal_ours ();
|
return;
|
return;
|
}
|
}
|
|
|
/* GDB should never give the terminal to the inferior if the
|
/* GDB should never give the terminal to the inferior if the
|
inferior is running in the background (run&, continue&, etc.),
|
inferior is running in the background (run&, continue&, etc.),
|
but claiming it sure should. */
|
but claiming it sure should. */
|
terminal_ours ();
|
terminal_ours ();
|
|
|
if (async_terminal_is_ours)
|
if (async_terminal_is_ours)
|
return;
|
return;
|
|
|
clear_sigint_trap ();
|
clear_sigint_trap ();
|
add_file_handler (input_fd, stdin_event_handler, 0);
|
add_file_handler (input_fd, stdin_event_handler, 0);
|
async_terminal_is_ours = 1;
|
async_terminal_is_ours = 1;
|
}
|
}
|
|
|
static void (*async_client_callback) (enum inferior_event_type event_type,
|
static void (*async_client_callback) (enum inferior_event_type event_type,
|
void *context);
|
void *context);
|
static void *async_client_context;
|
static void *async_client_context;
|
|
|
/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
|
/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
|
so we notice when any child changes state, and notify the
|
so we notice when any child changes state, and notify the
|
event-loop; it allows us to use sigsuspend in linux_nat_wait_1
|
event-loop; it allows us to use sigsuspend in linux_nat_wait_1
|
above to wait for the arrival of a SIGCHLD. */
|
above to wait for the arrival of a SIGCHLD. */
|
|
|
static void
|
static void
|
sigchld_handler (int signo)
|
sigchld_handler (int signo)
|
{
|
{
|
int old_errno = errno;
|
int old_errno = errno;
|
|
|
if (debug_linux_nat_async)
|
if (debug_linux_nat_async)
|
fprintf_unfiltered (gdb_stdlog, "sigchld\n");
|
fprintf_unfiltered (gdb_stdlog, "sigchld\n");
|
|
|
if (signo == SIGCHLD
|
if (signo == SIGCHLD
|
&& linux_nat_event_pipe[0] != -1)
|
&& linux_nat_event_pipe[0] != -1)
|
async_file_mark (); /* Let the event loop know that there are
|
async_file_mark (); /* Let the event loop know that there are
|
events to handle. */
|
events to handle. */
|
|
|
errno = old_errno;
|
errno = old_errno;
|
}
|
}
|
|
|
/* Callback registered with the target events file descriptor. */
|
/* Callback registered with the target events file descriptor. */
|
|
|
static void
|
static void
|
handle_target_event (int error, gdb_client_data client_data)
|
handle_target_event (int error, gdb_client_data client_data)
|
{
|
{
|
(*async_client_callback) (INF_REG_EVENT, async_client_context);
|
(*async_client_callback) (INF_REG_EVENT, async_client_context);
|
}
|
}
|
|
|
/* Create/destroy the target events pipe. Returns previous state. */
|
/* Create/destroy the target events pipe. Returns previous state. */
|
|
|
static int
|
static int
|
linux_async_pipe (int enable)
|
linux_async_pipe (int enable)
|
{
|
{
|
int previous = (linux_nat_event_pipe[0] != -1);
|
int previous = (linux_nat_event_pipe[0] != -1);
|
|
|
if (previous != enable)
|
if (previous != enable)
|
{
|
{
|
sigset_t prev_mask;
|
sigset_t prev_mask;
|
|
|
block_child_signals (&prev_mask);
|
block_child_signals (&prev_mask);
|
|
|
if (enable)
|
if (enable)
|
{
|
{
|
if (pipe (linux_nat_event_pipe) == -1)
|
if (pipe (linux_nat_event_pipe) == -1)
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
"creating event pipe failed.");
|
"creating event pipe failed.");
|
|
|
fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
|
fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
|
fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
|
fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
|
}
|
}
|
else
|
else
|
{
|
{
|
close (linux_nat_event_pipe[0]);
|
close (linux_nat_event_pipe[0]);
|
close (linux_nat_event_pipe[1]);
|
close (linux_nat_event_pipe[1]);
|
linux_nat_event_pipe[0] = -1;
|
linux_nat_event_pipe[0] = -1;
|
linux_nat_event_pipe[1] = -1;
|
linux_nat_event_pipe[1] = -1;
|
}
|
}
|
|
|
restore_child_signals_mask (&prev_mask);
|
restore_child_signals_mask (&prev_mask);
|
}
|
}
|
|
|
return previous;
|
return previous;
|
}
|
}
|
|
|
/* target_async implementation. */
|
/* target_async implementation. */
|
|
|
static void
|
static void
|
linux_nat_async (void (*callback) (enum inferior_event_type event_type,
|
linux_nat_async (void (*callback) (enum inferior_event_type event_type,
|
void *context), void *context)
|
void *context), void *context)
|
{
|
{
|
if (linux_nat_async_mask_value == 0 || !target_async_permitted)
|
if (linux_nat_async_mask_value == 0 || !target_async_permitted)
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
"Calling target_async when async is masked");
|
"Calling target_async when async is masked");
|
|
|
if (callback != NULL)
|
if (callback != NULL)
|
{
|
{
|
async_client_callback = callback;
|
async_client_callback = callback;
|
async_client_context = context;
|
async_client_context = context;
|
if (!linux_async_pipe (1))
|
if (!linux_async_pipe (1))
|
{
|
{
|
add_file_handler (linux_nat_event_pipe[0],
|
add_file_handler (linux_nat_event_pipe[0],
|
handle_target_event, NULL);
|
handle_target_event, NULL);
|
/* There may be pending events to handle. Tell the event loop
|
/* There may be pending events to handle. Tell the event loop
|
to poll them. */
|
to poll them. */
|
async_file_mark ();
|
async_file_mark ();
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
async_client_callback = callback;
|
async_client_callback = callback;
|
async_client_context = context;
|
async_client_context = context;
|
delete_file_handler (linux_nat_event_pipe[0]);
|
delete_file_handler (linux_nat_event_pipe[0]);
|
linux_async_pipe (0);
|
linux_async_pipe (0);
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* Stop an LWP, and push a TARGET_SIGNAL_0 stop status if no other
|
/* Stop an LWP, and push a TARGET_SIGNAL_0 stop status if no other
|
event came out. */
|
event came out. */
|
|
|
static int
|
static int
|
linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
|
linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
|
{
|
{
|
if (!lwp->stopped)
|
if (!lwp->stopped)
|
{
|
{
|
int pid, status;
|
int pid, status;
|
ptid_t ptid = lwp->ptid;
|
ptid_t ptid = lwp->ptid;
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"LNSL: running -> suspending %s\n",
|
"LNSL: running -> suspending %s\n",
|
target_pid_to_str (lwp->ptid));
|
target_pid_to_str (lwp->ptid));
|
|
|
|
|
stop_callback (lwp, NULL);
|
stop_callback (lwp, NULL);
|
stop_wait_callback (lwp, NULL);
|
stop_wait_callback (lwp, NULL);
|
|
|
/* If the lwp exits while we try to stop it, there's nothing
|
/* If the lwp exits while we try to stop it, there's nothing
|
else to do. */
|
else to do. */
|
lwp = find_lwp_pid (ptid);
|
lwp = find_lwp_pid (ptid);
|
if (lwp == NULL)
|
if (lwp == NULL)
|
return 0;
|
return 0;
|
|
|
/* If we didn't collect any signal other than SIGSTOP while
|
/* If we didn't collect any signal other than SIGSTOP while
|
stopping the LWP, push a SIGNAL_0 event. In either case, the
|
stopping the LWP, push a SIGNAL_0 event. In either case, the
|
event-loop will end up calling target_wait which will collect
|
event-loop will end up calling target_wait which will collect
|
these. */
|
these. */
|
if (lwp->status == 0)
|
if (lwp->status == 0)
|
lwp->status = W_STOPCODE (0);
|
lwp->status = W_STOPCODE (0);
|
async_file_mark ();
|
async_file_mark ();
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Already known to be stopped; do nothing. */
|
/* Already known to be stopped; do nothing. */
|
|
|
if (debug_linux_nat)
|
if (debug_linux_nat)
|
{
|
{
|
if (find_thread_ptid (lwp->ptid)->stop_requested)
|
if (find_thread_ptid (lwp->ptid)->stop_requested)
|
fprintf_unfiltered (gdb_stdlog, "\
|
fprintf_unfiltered (gdb_stdlog, "\
|
LNSL: already stopped/stop_requested %s\n",
|
LNSL: already stopped/stop_requested %s\n",
|
target_pid_to_str (lwp->ptid));
|
target_pid_to_str (lwp->ptid));
|
else
|
else
|
fprintf_unfiltered (gdb_stdlog, "\
|
fprintf_unfiltered (gdb_stdlog, "\
|
LNSL: already stopped/no stop_requested yet %s\n",
|
LNSL: already stopped/no stop_requested yet %s\n",
|
target_pid_to_str (lwp->ptid));
|
target_pid_to_str (lwp->ptid));
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_stop (ptid_t ptid)
|
linux_nat_stop (ptid_t ptid)
|
{
|
{
|
if (non_stop)
|
if (non_stop)
|
iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
|
iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
|
else
|
else
|
linux_ops->to_stop (ptid);
|
linux_ops->to_stop (ptid);
|
}
|
}
|
|
|
static void
|
static void
|
linux_nat_close (int quitting)
|
linux_nat_close (int quitting)
|
{
|
{
|
/* Unregister from the event loop. */
|
/* Unregister from the event loop. */
|
if (target_is_async_p ())
|
if (target_is_async_p ())
|
target_async (NULL, 0);
|
target_async (NULL, 0);
|
|
|
/* Reset the async_masking. */
|
/* Reset the async_masking. */
|
linux_nat_async_mask_value = 1;
|
linux_nat_async_mask_value = 1;
|
|
|
if (linux_ops->to_close)
|
if (linux_ops->to_close)
|
linux_ops->to_close (quitting);
|
linux_ops->to_close (quitting);
|
}
|
}
|
|
|
/* When requests are passed down from the linux-nat layer to the
|
/* When requests are passed down from the linux-nat layer to the
|
single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
|
single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
|
used. The address space pointer is stored in the inferior object,
|
used. The address space pointer is stored in the inferior object,
|
but the common code that is passed such ptid can't tell whether
|
but the common code that is passed such ptid can't tell whether
|
lwpid is a "main" process id or not (it assumes so). We reverse
|
lwpid is a "main" process id or not (it assumes so). We reverse
|
look up the "main" process id from the lwp here. */
|
look up the "main" process id from the lwp here. */
|
|
|
struct address_space *
|
struct address_space *
|
linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
|
linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
|
{
|
{
|
struct lwp_info *lwp;
|
struct lwp_info *lwp;
|
struct inferior *inf;
|
struct inferior *inf;
|
int pid;
|
int pid;
|
|
|
pid = GET_LWP (ptid);
|
pid = GET_LWP (ptid);
|
if (GET_LWP (ptid) == 0)
|
if (GET_LWP (ptid) == 0)
|
{
|
{
|
/* An (lwpid,0,0) ptid. Look up the lwp object to get at the
|
/* An (lwpid,0,0) ptid. Look up the lwp object to get at the
|
tgid. */
|
tgid. */
|
lwp = find_lwp_pid (ptid);
|
lwp = find_lwp_pid (ptid);
|
pid = GET_PID (lwp->ptid);
|
pid = GET_PID (lwp->ptid);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* A (pid,lwpid,0) ptid. */
|
/* A (pid,lwpid,0) ptid. */
|
pid = GET_PID (ptid);
|
pid = GET_PID (ptid);
|
}
|
}
|
|
|
inf = find_inferior_pid (pid);
|
inf = find_inferior_pid (pid);
|
gdb_assert (inf != NULL);
|
gdb_assert (inf != NULL);
|
return inf->aspace;
|
return inf->aspace;
|
}
|
}
|
|
|
int
|
int
|
linux_nat_core_of_thread_1 (ptid_t ptid)
|
linux_nat_core_of_thread_1 (ptid_t ptid)
|
{
|
{
|
struct cleanup *back_to;
|
struct cleanup *back_to;
|
char *filename;
|
char *filename;
|
FILE *f;
|
FILE *f;
|
char *content = NULL;
|
char *content = NULL;
|
char *p;
|
char *p;
|
char *ts = 0;
|
char *ts = 0;
|
int content_read = 0;
|
int content_read = 0;
|
int i;
|
int i;
|
int core;
|
int core;
|
|
|
filename = xstrprintf ("/proc/%d/task/%ld/stat",
|
filename = xstrprintf ("/proc/%d/task/%ld/stat",
|
GET_PID (ptid), GET_LWP (ptid));
|
GET_PID (ptid), GET_LWP (ptid));
|
back_to = make_cleanup (xfree, filename);
|
back_to = make_cleanup (xfree, filename);
|
|
|
f = fopen (filename, "r");
|
f = fopen (filename, "r");
|
if (!f)
|
if (!f)
|
{
|
{
|
do_cleanups (back_to);
|
do_cleanups (back_to);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
make_cleanup_fclose (f);
|
make_cleanup_fclose (f);
|
|
|
for (;;)
|
for (;;)
|
{
|
{
|
int n;
|
int n;
|
content = xrealloc (content, content_read + 1024);
|
content = xrealloc (content, content_read + 1024);
|
n = fread (content + content_read, 1, 1024, f);
|
n = fread (content + content_read, 1, 1024, f);
|
content_read += n;
|
content_read += n;
|
if (n < 1024)
|
if (n < 1024)
|
{
|
{
|
content[content_read] = '\0';
|
content[content_read] = '\0';
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
make_cleanup (xfree, content);
|
make_cleanup (xfree, content);
|
|
|
p = strchr (content, '(');
|
p = strchr (content, '(');
|
p = strchr (p, ')') + 2; /* skip ")" and a whitespace. */
|
p = strchr (p, ')') + 2; /* skip ")" and a whitespace. */
|
|
|
/* If the first field after program name has index 0, then core number is
|
/* If the first field after program name has index 0, then core number is
|
the field with index 36. There's no constant for that anywhere. */
|
the field with index 36. There's no constant for that anywhere. */
|
p = strtok_r (p, " ", &ts);
|
p = strtok_r (p, " ", &ts);
|
for (i = 0; i != 36; ++i)
|
for (i = 0; i != 36; ++i)
|
p = strtok_r (NULL, " ", &ts);
|
p = strtok_r (NULL, " ", &ts);
|
|
|
if (sscanf (p, "%d", &core) == 0)
|
if (sscanf (p, "%d", &core) == 0)
|
core = -1;
|
core = -1;
|
|
|
do_cleanups (back_to);
|
do_cleanups (back_to);
|
|
|
return core;
|
return core;
|
}
|
}
|
|
|
/* Return the cached value of the processor core for thread PTID. */
|
/* Return the cached value of the processor core for thread PTID. */
|
|
|
int
|
int
|
linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
|
linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
|
{
|
{
|
struct lwp_info *info = find_lwp_pid (ptid);
|
struct lwp_info *info = find_lwp_pid (ptid);
|
if (info)
|
if (info)
|
return info->core;
|
return info->core;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
void
|
void
|
linux_nat_add_target (struct target_ops *t)
|
linux_nat_add_target (struct target_ops *t)
|
{
|
{
|
/* Save the provided single-threaded target. We save this in a separate
|
/* Save the provided single-threaded target. We save this in a separate
|
variable because another target we've inherited from (e.g. inf-ptrace)
|
variable because another target we've inherited from (e.g. inf-ptrace)
|
may have saved a pointer to T; we want to use it for the final
|
may have saved a pointer to T; we want to use it for the final
|
process stratum target. */
|
process stratum target. */
|
linux_ops_saved = *t;
|
linux_ops_saved = *t;
|
linux_ops = &linux_ops_saved;
|
linux_ops = &linux_ops_saved;
|
|
|
/* Override some methods for multithreading. */
|
/* Override some methods for multithreading. */
|
t->to_create_inferior = linux_nat_create_inferior;
|
t->to_create_inferior = linux_nat_create_inferior;
|
t->to_attach = linux_nat_attach;
|
t->to_attach = linux_nat_attach;
|
t->to_detach = linux_nat_detach;
|
t->to_detach = linux_nat_detach;
|
t->to_resume = linux_nat_resume;
|
t->to_resume = linux_nat_resume;
|
t->to_wait = linux_nat_wait;
|
t->to_wait = linux_nat_wait;
|
t->to_xfer_partial = linux_nat_xfer_partial;
|
t->to_xfer_partial = linux_nat_xfer_partial;
|
t->to_kill = linux_nat_kill;
|
t->to_kill = linux_nat_kill;
|
t->to_mourn_inferior = linux_nat_mourn_inferior;
|
t->to_mourn_inferior = linux_nat_mourn_inferior;
|
t->to_thread_alive = linux_nat_thread_alive;
|
t->to_thread_alive = linux_nat_thread_alive;
|
t->to_pid_to_str = linux_nat_pid_to_str;
|
t->to_pid_to_str = linux_nat_pid_to_str;
|
t->to_has_thread_control = tc_schedlock;
|
t->to_has_thread_control = tc_schedlock;
|
t->to_thread_address_space = linux_nat_thread_address_space;
|
t->to_thread_address_space = linux_nat_thread_address_space;
|
t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
|
t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
|
t->to_stopped_data_address = linux_nat_stopped_data_address;
|
t->to_stopped_data_address = linux_nat_stopped_data_address;
|
|
|
t->to_can_async_p = linux_nat_can_async_p;
|
t->to_can_async_p = linux_nat_can_async_p;
|
t->to_is_async_p = linux_nat_is_async_p;
|
t->to_is_async_p = linux_nat_is_async_p;
|
t->to_supports_non_stop = linux_nat_supports_non_stop;
|
t->to_supports_non_stop = linux_nat_supports_non_stop;
|
t->to_async = linux_nat_async;
|
t->to_async = linux_nat_async;
|
t->to_async_mask = linux_nat_async_mask;
|
t->to_async_mask = linux_nat_async_mask;
|
t->to_terminal_inferior = linux_nat_terminal_inferior;
|
t->to_terminal_inferior = linux_nat_terminal_inferior;
|
t->to_terminal_ours = linux_nat_terminal_ours;
|
t->to_terminal_ours = linux_nat_terminal_ours;
|
t->to_close = linux_nat_close;
|
t->to_close = linux_nat_close;
|
|
|
/* Methods for non-stop support. */
|
/* Methods for non-stop support. */
|
t->to_stop = linux_nat_stop;
|
t->to_stop = linux_nat_stop;
|
|
|
t->to_supports_multi_process = linux_nat_supports_multi_process;
|
t->to_supports_multi_process = linux_nat_supports_multi_process;
|
|
|
t->to_core_of_thread = linux_nat_core_of_thread;
|
t->to_core_of_thread = linux_nat_core_of_thread;
|
|
|
/* We don't change the stratum; this target will sit at
|
/* We don't change the stratum; this target will sit at
|
process_stratum and thread_db will set at thread_stratum. This
|
process_stratum and thread_db will set at thread_stratum. This
|
is a little strange, since this is a multi-threaded-capable
|
is a little strange, since this is a multi-threaded-capable
|
target, but we want to be on the stack below thread_db, and we
|
target, but we want to be on the stack below thread_db, and we
|
also want to be used for single-threaded processes. */
|
also want to be used for single-threaded processes. */
|
|
|
add_target (t);
|
add_target (t);
|
}
|
}
|
|
|
/* Register a method to call whenever a new thread is attached. */
|
/* Register a method to call whenever a new thread is attached. */
|
void
|
void
|
linux_nat_set_new_thread (struct target_ops *t, void (*new_thread) (ptid_t))
|
linux_nat_set_new_thread (struct target_ops *t, void (*new_thread) (ptid_t))
|
{
|
{
|
/* Save the pointer. We only support a single registered instance
|
/* Save the pointer. We only support a single registered instance
|
of the GNU/Linux native target, so we do not need to map this to
|
of the GNU/Linux native target, so we do not need to map this to
|
T. */
|
T. */
|
linux_nat_new_thread = new_thread;
|
linux_nat_new_thread = new_thread;
|
}
|
}
|
|
|
/* Register a method that converts a siginfo object between the layout
|
/* Register a method that converts a siginfo object between the layout
|
that ptrace returns, and the layout in the architecture of the
|
that ptrace returns, and the layout in the architecture of the
|
inferior. */
|
inferior. */
|
void
|
void
|
linux_nat_set_siginfo_fixup (struct target_ops *t,
|
linux_nat_set_siginfo_fixup (struct target_ops *t,
|
int (*siginfo_fixup) (struct siginfo *,
|
int (*siginfo_fixup) (struct siginfo *,
|
gdb_byte *,
|
gdb_byte *,
|
int))
|
int))
|
{
|
{
|
/* Save the pointer. */
|
/* Save the pointer. */
|
linux_nat_siginfo_fixup = siginfo_fixup;
|
linux_nat_siginfo_fixup = siginfo_fixup;
|
}
|
}
|
|
|
/* Return the saved siginfo associated with PTID. */
|
/* Return the saved siginfo associated with PTID. */
|
struct siginfo *
|
struct siginfo *
|
linux_nat_get_siginfo (ptid_t ptid)
|
linux_nat_get_siginfo (ptid_t ptid)
|
{
|
{
|
struct lwp_info *lp = find_lwp_pid (ptid);
|
struct lwp_info *lp = find_lwp_pid (ptid);
|
|
|
gdb_assert (lp != NULL);
|
gdb_assert (lp != NULL);
|
|
|
return &lp->siginfo;
|
return &lp->siginfo;
|
}
|
}
|
|
|
/* Provide a prototype to silence -Wmissing-prototypes. */
|
/* Provide a prototype to silence -Wmissing-prototypes. */
|
extern initialize_file_ftype _initialize_linux_nat;
|
extern initialize_file_ftype _initialize_linux_nat;
|
|
|
void
|
void
|
_initialize_linux_nat (void)
|
_initialize_linux_nat (void)
|
{
|
{
|
sigset_t mask;
|
sigset_t mask;
|
|
|
add_info ("proc", linux_nat_info_proc_cmd, _("\
|
add_info ("proc", linux_nat_info_proc_cmd, _("\
|
Show /proc process information about any running process.\n\
|
Show /proc process information about any running process.\n\
|
Specify any process id, or use the program being debugged by default.\n\
|
Specify any process id, or use the program being debugged by default.\n\
|
Specify any of the following keywords for detailed info:\n\
|
Specify any of the following keywords for detailed info:\n\
|
mappings -- list of mapped memory regions.\n\
|
mappings -- list of mapped memory regions.\n\
|
stat -- list a bunch of random process info.\n\
|
stat -- list a bunch of random process info.\n\
|
status -- list a different bunch of random process info.\n\
|
status -- list a different bunch of random process info.\n\
|
all -- list all available /proc info."));
|
all -- list all available /proc info."));
|
|
|
add_setshow_zinteger_cmd ("lin-lwp", class_maintenance,
|
add_setshow_zinteger_cmd ("lin-lwp", class_maintenance,
|
&debug_linux_nat, _("\
|
&debug_linux_nat, _("\
|
Set debugging of GNU/Linux lwp module."), _("\
|
Set debugging of GNU/Linux lwp module."), _("\
|
Show debugging of GNU/Linux lwp module."), _("\
|
Show debugging of GNU/Linux lwp module."), _("\
|
Enables printf debugging output."),
|
Enables printf debugging output."),
|
NULL,
|
NULL,
|
show_debug_linux_nat,
|
show_debug_linux_nat,
|
&setdebuglist, &showdebuglist);
|
&setdebuglist, &showdebuglist);
|
|
|
add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance,
|
add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance,
|
&debug_linux_nat_async, _("\
|
&debug_linux_nat_async, _("\
|
Set debugging of GNU/Linux async lwp module."), _("\
|
Set debugging of GNU/Linux async lwp module."), _("\
|
Show debugging of GNU/Linux async lwp module."), _("\
|
Show debugging of GNU/Linux async lwp module."), _("\
|
Enables printf debugging output."),
|
Enables printf debugging output."),
|
NULL,
|
NULL,
|
show_debug_linux_nat_async,
|
show_debug_linux_nat_async,
|
&setdebuglist, &showdebuglist);
|
&setdebuglist, &showdebuglist);
|
|
|
/* Save this mask as the default. */
|
/* Save this mask as the default. */
|
sigprocmask (SIG_SETMASK, NULL, &normal_mask);
|
sigprocmask (SIG_SETMASK, NULL, &normal_mask);
|
|
|
/* Install a SIGCHLD handler. */
|
/* Install a SIGCHLD handler. */
|
sigchld_action.sa_handler = sigchld_handler;
|
sigchld_action.sa_handler = sigchld_handler;
|
sigemptyset (&sigchld_action.sa_mask);
|
sigemptyset (&sigchld_action.sa_mask);
|
sigchld_action.sa_flags = SA_RESTART;
|
sigchld_action.sa_flags = SA_RESTART;
|
|
|
/* Make it the default. */
|
/* Make it the default. */
|
sigaction (SIGCHLD, &sigchld_action, NULL);
|
sigaction (SIGCHLD, &sigchld_action, NULL);
|
|
|
/* Make sure we don't block SIGCHLD during a sigsuspend. */
|
/* Make sure we don't block SIGCHLD during a sigsuspend. */
|
sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
|
sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
|
sigdelset (&suspend_mask, SIGCHLD);
|
sigdelset (&suspend_mask, SIGCHLD);
|
|
|
sigemptyset (&blocked_mask);
|
sigemptyset (&blocked_mask);
|
|
|
add_setshow_boolean_cmd ("disable-randomization", class_support,
|
add_setshow_boolean_cmd ("disable-randomization", class_support,
|
&disable_randomization, _("\
|
&disable_randomization, _("\
|
Set disabling of debuggee's virtual address space randomization."), _("\
|
Set disabling of debuggee's virtual address space randomization."), _("\
|
Show disabling of debuggee's virtual address space randomization."), _("\
|
Show disabling of debuggee's virtual address space randomization."), _("\
|
When this mode is on (which is the default), randomization of the virtual\n\
|
When this mode is on (which is the default), randomization of the virtual\n\
|
address space is disabled. Standalone programs run with the randomization\n\
|
address space is disabled. Standalone programs run with the randomization\n\
|
enabled by default on some platforms."),
|
enabled by default on some platforms."),
|
&set_disable_randomization,
|
&set_disable_randomization,
|
&show_disable_randomization,
|
&show_disable_randomization,
|
&setlist, &showlist);
|
&setlist, &showlist);
|
}
|
}
|
|
|
|
|
/* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
|
/* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
|
the GNU/Linux Threads library and therefore doesn't really belong
|
the GNU/Linux Threads library and therefore doesn't really belong
|
here. */
|
here. */
|
|
|
/* Read variable NAME in the target and return its value if found.
|
/* Read variable NAME in the target and return its value if found.
|
Otherwise return zero. It is assumed that the type of the variable
|
Otherwise return zero. It is assumed that the type of the variable
|
is `int'. */
|
is `int'. */
|
|
|
static int
|
static int
|
get_signo (const char *name)
|
get_signo (const char *name)
|
{
|
{
|
struct minimal_symbol *ms;
|
struct minimal_symbol *ms;
|
int signo;
|
int signo;
|
|
|
ms = lookup_minimal_symbol (name, NULL, NULL);
|
ms = lookup_minimal_symbol (name, NULL, NULL);
|
if (ms == NULL)
|
if (ms == NULL)
|
return 0;
|
return 0;
|
|
|
if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
|
if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
|
sizeof (signo)) != 0)
|
sizeof (signo)) != 0)
|
return 0;
|
return 0;
|
|
|
return signo;
|
return signo;
|
}
|
}
|
|
|
/* Return the set of signals used by the threads library in *SET. */
|
/* Return the set of signals used by the threads library in *SET. */
|
|
|
void
|
void
|
lin_thread_get_thread_signals (sigset_t *set)
|
lin_thread_get_thread_signals (sigset_t *set)
|
{
|
{
|
struct sigaction action;
|
struct sigaction action;
|
int restart, cancel;
|
int restart, cancel;
|
|
|
sigemptyset (&blocked_mask);
|
sigemptyset (&blocked_mask);
|
sigemptyset (set);
|
sigemptyset (set);
|
|
|
restart = get_signo ("__pthread_sig_restart");
|
restart = get_signo ("__pthread_sig_restart");
|
cancel = get_signo ("__pthread_sig_cancel");
|
cancel = get_signo ("__pthread_sig_cancel");
|
|
|
/* LinuxThreads normally uses the first two RT signals, but in some legacy
|
/* LinuxThreads normally uses the first two RT signals, but in some legacy
|
cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
|
cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
|
not provide any way for the debugger to query the signal numbers -
|
not provide any way for the debugger to query the signal numbers -
|
fortunately they don't change! */
|
fortunately they don't change! */
|
|
|
if (restart == 0)
|
if (restart == 0)
|
restart = __SIGRTMIN;
|
restart = __SIGRTMIN;
|
|
|
if (cancel == 0)
|
if (cancel == 0)
|
cancel = __SIGRTMIN + 1;
|
cancel = __SIGRTMIN + 1;
|
|
|
sigaddset (set, restart);
|
sigaddset (set, restart);
|
sigaddset (set, cancel);
|
sigaddset (set, cancel);
|
|
|
/* The GNU/Linux Threads library makes terminating threads send a
|
/* The GNU/Linux Threads library makes terminating threads send a
|
special "cancel" signal instead of SIGCHLD. Make sure we catch
|
special "cancel" signal instead of SIGCHLD. Make sure we catch
|
those (to prevent them from terminating GDB itself, which is
|
those (to prevent them from terminating GDB itself, which is
|
likely to be their default action) and treat them the same way as
|
likely to be their default action) and treat them the same way as
|
SIGCHLD. */
|
SIGCHLD. */
|
|
|
action.sa_handler = sigchld_handler;
|
action.sa_handler = sigchld_handler;
|
sigemptyset (&action.sa_mask);
|
sigemptyset (&action.sa_mask);
|
action.sa_flags = SA_RESTART;
|
action.sa_flags = SA_RESTART;
|
sigaction (cancel, &action, NULL);
|
sigaction (cancel, &action, NULL);
|
|
|
/* We block the "cancel" signal throughout this code ... */
|
/* We block the "cancel" signal throughout this code ... */
|
sigaddset (&blocked_mask, cancel);
|
sigaddset (&blocked_mask, cancel);
|
sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
|
sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
|
|
|
/* ... except during a sigsuspend. */
|
/* ... except during a sigsuspend. */
|
sigdelset (&suspend_mask, cancel);
|
sigdelset (&suspend_mask, cancel);
|
}
|
}
|
|
|
