/* GNU/Linux native-dependent code common to multiple platforms.
- Copyright (C) 2001-2015 Free Software Foundation, Inc.
+ Copyright (C) 2001-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "target.h"
#include "nat/linux-nat.h"
#include "nat/linux-waitpid.h"
-#include "gdb_wait.h"
-#ifdef HAVE_TKILL_SYSCALL
+#include "gdbsupport/gdb_wait.h"
#include <unistd.h>
#include <sys/syscall.h>
-#endif
-#include <sys/ptrace.h>
+#include "nat/gdb_ptrace.h"
#include "linux-nat.h"
#include "nat/linux-ptrace.h"
#include "nat/linux-procfs.h"
+#include "nat/linux-personality.h"
#include "linux-fork.h"
#include "gdbthread.h"
#include "gdbcmd.h"
#include "nat/linux-osdata.h"
#include "linux-tdep.h"
#include "symfile.h"
-#include "agent.h"
+#include "gdbsupport/agent.h"
#include "tracepoint.h"
-#include "buffer.h"
+#include "gdbsupport/buffer.h"
#include "target-descriptions.h"
-#include "filestuff.h"
+#include "gdbsupport/filestuff.h"
#include "objfiles.h"
-
-#ifndef SPUFS_MAGIC
-#define SPUFS_MAGIC 0x23c9b64e
-#endif
-
-#ifdef HAVE_PERSONALITY
-# include <sys/personality.h>
-# if !HAVE_DECL_ADDR_NO_RANDOMIZE
-# define ADDR_NO_RANDOMIZE 0x0040000
-# endif
-#endif /* HAVE_PERSONALITY */
+#include "nat/linux-namespaces.h"
+#include "gdbsupport/fileio.h"
+#include "gdbsupport/scope-exit.h"
+#include "gdbsupport/gdb-sigmask.h"
/* This comment documents high-level logic of this file.
Waiting for events in sync mode
===============================
-When waiting for an event in a specific thread, we just use waitpid, passing
-the specific pid, and not passing WNOHANG.
-
-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
-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
-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
-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
-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
-an event, we get back to calling nonblocking waitpid with and without
-__WCLONED.
-
-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
-blocked, the signal becomes pending and sigsuspend immediately
-notices it and returns.
-
-Waiting for events in async mode
-================================
+When waiting for an event in a specific thread, we just use waitpid,
+passing the specific pid, and not passing WNOHANG.
+
+When waiting for an event in all threads, waitpid is not quite good:
+
+- If the thread group leader exits while other threads in the thread
+ group still exist, waitpid(TGID, ...) hangs. That waitpid won't
+ return an exit status until the other threads in the group are
+ reaped.
+
+- When a non-leader thread execs, that thread just vanishes without
+ reporting an exit (so we'd hang if we waited for it explicitly in
+ that case). The exec event is instead reported to the TGID pid.
+
+The solution is to always use -1 and WNOHANG, together with
+sigsuspend.
+
+First, we use non-blocking waitpid to check for events. If nothing is
+found, we use sigsuspend to wait for SIGCHLD. When SIGCHLD arrives,
+it means something happened to a child process. As soon as we know
+there's an event, we get back to calling nonblocking waitpid.
+
+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 blocked, the signal becomes pending and sigsuspend
+immediately notices it and returns.
+
+Waiting for events in async mode (TARGET_WNOHANG)
+=================================================
In async mode, GDB should always be ready to handle both user input
and target events, so neither blocking waitpid nor sigsuspend are
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
generates it, and there are races with trying to find a signal that is not
-blocked. */
-
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0
-#endif
-
-/* The single-threaded native GNU/Linux target_ops. We save a pointer for
- the use of the multi-threaded target. */
-static struct target_ops *linux_ops;
-static struct target_ops linux_ops_saved;
+blocked.
-/* The method to call, if any, when a new thread is attached. */
-static void (*linux_nat_new_thread) (struct lwp_info *);
+Exec events
+===========
-/* The method to call, if any, when a new fork is attached. */
-static linux_nat_new_fork_ftype *linux_nat_new_fork;
+The case of a thread group (process) with 3 or more threads, and a
+thread other than the leader execs is worth detailing:
-/* The method to call, if any, when a process is no longer
- attached. */
-static linux_nat_forget_process_ftype *linux_nat_forget_process_hook;
+On an exec, the Linux kernel destroys all threads except the execing
+one in the thread group, and resets the execing thread's tid to the
+tgid. No exit notification is sent for the execing thread -- from the
+ptracer's perspective, it appears as though the execing thread just
+vanishes. Until we reap all other threads except the leader and the
+execing thread, the leader will be zombie, and the execing thread will
+be in `D (disc sleep)' state. As soon as all other threads are
+reaped, the execing thread changes its tid to the tgid, and the
+previous (zombie) leader vanishes, giving place to the "new"
+leader. */
-/* Hook to call prior to resuming a thread. */
-static void (*linux_nat_prepare_to_resume) (struct lwp_info *);
-
-/* The method to call, if any, when the siginfo object needs to be
- converted between the layout returned by ptrace, and the layout in
- the architecture of the inferior. */
-static int (*linux_nat_siginfo_fixup) (siginfo_t *,
- gdb_byte *,
- int);
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
-/* The saved to_xfer_partial method, inherited from inf-ptrace.c.
- Called by our to_xfer_partial. */
-static target_xfer_partial_ftype *super_xfer_partial;
+struct linux_nat_target *linux_target;
-/* The saved to_close method, inherited from inf-ptrace.c.
- Called by our to_close. */
-static void (*super_close) (struct target_ops *);
+/* Does the current host support PTRACE_GETREGSET? */
+enum tribool have_ptrace_getregset = TRIBOOL_UNKNOWN;
static unsigned int debug_linux_nat;
static void
};
struct simple_pid_list *stopped_pids;
+/* Whether target_thread_events is in effect. */
+static int report_thread_events;
+
/* Async mode support. */
/* The read/write ends of the pipe registered as waitable file in the
event loop. */
static int linux_nat_event_pipe[2] = { -1, -1 };
+/* True if we're currently in async mode. */
+#define linux_is_async_p() (linux_nat_event_pipe[0] != -1)
+
/* Flush the event pipe. */
static void
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);
static void block_child_signals (sigset_t *prev_mask);
static void restore_child_signals_mask (sigset_t *prev_mask);
static int lwp_status_pending_p (struct lwp_info *lp);
+static void save_stop_reason (struct lwp_info *lp);
+
+\f
+/* LWP accessors. */
+
+/* See nat/linux-nat.h. */
+
+ptid_t
+ptid_of_lwp (struct lwp_info *lwp)
+{
+ return lwp->ptid;
+}
+
+/* See nat/linux-nat.h. */
+
+void
+lwp_set_arch_private_info (struct lwp_info *lwp,
+ struct arch_lwp_info *info)
+{
+ lwp->arch_private = info;
+}
+
+/* See nat/linux-nat.h. */
+
+struct arch_lwp_info *
+lwp_arch_private_info (struct lwp_info *lwp)
+{
+ return lwp->arch_private;
+}
+
+/* See nat/linux-nat.h. */
+
+int
+lwp_is_stopped (struct lwp_info *lwp)
+{
+ return lwp->stopped;
+}
+
+/* See nat/linux-nat.h. */
+
+enum target_stop_reason
+lwp_stop_reason (struct lwp_info *lwp)
+{
+ return lwp->stop_reason;
+}
+
+/* See nat/linux-nat.h. */
+
+int
+lwp_is_stepping (struct lwp_info *lwp)
+{
+ return lwp->step;
+}
+
\f
/* Trivial list manipulation functions to keep track of a list of
new stopped processes. */
static void
add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
{
- struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
+ struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
new_pid->pid = pid;
new_pid->status = status;
*listp = new_pid;
}
-static int
-in_pid_list_p (struct simple_pid_list *list, int pid)
-{
- struct simple_pid_list *p;
-
- for (p = list; p != NULL; p = p->next)
- if (p->pid == pid)
- return 1;
- return 0;
-}
-
static int
pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
{
return 0;
}
-/* Initialize ptrace warnings and check for supported ptrace
- features given PID.
+/* Return the ptrace options that we want to try to enable. */
+
+static int
+linux_nat_ptrace_options (int attached)
+{
+ int options = 0;
+
+ if (!attached)
+ options |= PTRACE_O_EXITKILL;
+
+ options |= (PTRACE_O_TRACESYSGOOD
+ | PTRACE_O_TRACEVFORKDONE
+ | PTRACE_O_TRACEVFORK
+ | PTRACE_O_TRACEFORK
+ | PTRACE_O_TRACEEXEC);
+
+ return options;
+}
+
+/* Initialize ptrace and procfs warnings and check for supported
+ ptrace features given PID.
ATTACHED should be nonzero iff we attached to the inferior. */
static void
-linux_init_ptrace (pid_t pid, int attached)
+linux_init_ptrace_procfs (pid_t pid, int attached)
{
- linux_enable_event_reporting (pid, attached);
+ int options = linux_nat_ptrace_options (attached);
+
+ linux_enable_event_reporting (pid, options);
linux_ptrace_init_warnings ();
+ linux_proc_init_warnings ();
}
-static void
-linux_child_post_attach (struct target_ops *self, int pid)
+linux_nat_target::~linux_nat_target ()
+{}
+
+void
+linux_nat_target::post_attach (int pid)
{
- linux_init_ptrace (pid, 1);
+ linux_init_ptrace_procfs (pid, 1);
}
-static void
-linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
+void
+linux_nat_target::post_startup_inferior (ptid_t ptid)
{
- linux_init_ptrace (ptid_get_pid (ptid), 0);
+ linux_init_ptrace_procfs (ptid.pid (), 0);
}
/* Return the number of known LWPs in the tgid given by PID. */
struct lwp_info *lp;
for (lp = lwp_list; lp; lp = lp->next)
- if (ptid_get_pid (lp->ptid) == pid)
+ if (lp->ptid.pid () == pid)
count++;
return count;
}
-/* Call delete_lwp with prototype compatible for make_cleanup. */
+/* Deleter for lwp_info unique_ptr specialisation. */
-static void
-delete_lwp_cleanup (void *lp_voidp)
+struct lwp_deleter
{
- struct lwp_info *lp = lp_voidp;
+ void operator() (struct lwp_info *lwp) const
+ {
+ delete_lwp (lwp->ptid);
+ }
+};
- delete_lwp (lp->ptid);
-}
+/* A unique_ptr specialisation for lwp_info. */
+
+typedef std::unique_ptr<struct lwp_info, lwp_deleter> lwp_info_up;
/* Target hook for follow_fork. On entry inferior_ptid must be the
ptid of the followed inferior. At return, inferior_ptid will be
unchanged. */
-static int
-linux_child_follow_fork (struct target_ops *ops, int follow_child,
- int detach_fork)
+int
+linux_nat_target::follow_fork (int follow_child, int detach_fork)
{
if (!follow_child)
{
struct lwp_info *child_lp = NULL;
- int status = W_STOPCODE (0);
- struct cleanup *old_chain;
int has_vforked;
+ ptid_t parent_ptid, child_ptid;
int parent_pid, child_pid;
has_vforked = (inferior_thread ()->pending_follow.kind
== TARGET_WAITKIND_VFORKED);
- parent_pid = ptid_get_lwp (inferior_ptid);
- if (parent_pid == 0)
- parent_pid = ptid_get_pid (inferior_ptid);
- child_pid
- = ptid_get_pid (inferior_thread ()->pending_follow.value.related_pid);
-
+ parent_ptid = inferior_ptid;
+ child_ptid = inferior_thread ()->pending_follow.value.related_pid;
+ parent_pid = parent_ptid.lwp ();
+ child_pid = child_ptid.lwp ();
/* We're already attached to the parent, by default. */
- old_chain = save_inferior_ptid ();
- inferior_ptid = ptid_build (child_pid, child_pid, 0);
- child_lp = add_lwp (inferior_ptid);
+ child_lp = add_lwp (child_ptid);
child_lp->stopped = 1;
child_lp->last_resume_kind = resume_stop;
/* Detach new forked process? */
if (detach_fork)
{
- make_cleanup (delete_lwp_cleanup, child_lp);
+ int child_stop_signal = 0;
+ bool detach_child = true;
- if (linux_nat_prepare_to_resume != NULL)
- linux_nat_prepare_to_resume (child_lp);
+ /* Move CHILD_LP into a unique_ptr and clear the source pointer
+ to prevent us doing anything stupid with it. */
+ lwp_info_up child_lp_ptr (child_lp);
+ child_lp = nullptr;
+
+ linux_target->low_prepare_to_resume (child_lp_ptr.get ());
/* When debugging an inferior in an architecture that supports
hardware single stepping on a kernel without commit
To work around this, single step the child process
once before detaching to clear the flags. */
+ /* Note that we consult the parent's architecture instead of
+ the child's because there's no inferior for the child at
+ this point. */
if (!gdbarch_software_single_step_p (target_thread_architecture
- (child_lp->ptid)))
+ (parent_ptid)))
{
+ int status;
+
linux_disable_event_reporting (child_pid);
if (ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
perror_with_name (_("Couldn't do single step"));
if (my_waitpid (child_pid, &status, 0) < 0)
perror_with_name (_("Couldn't wait vfork process"));
+ else
+ {
+ detach_child = WIFSTOPPED (status);
+ child_stop_signal = WSTOPSIG (status);
+ }
}
- if (WIFSTOPPED (status))
+ if (detach_child)
{
- int signo;
+ int signo = child_stop_signal;
- signo = WSTOPSIG (status);
if (signo != 0
&& !signal_pass_state (gdb_signal_from_host (signo)))
signo = 0;
ptrace (PTRACE_DETACH, child_pid, 0, signo);
}
-
- /* Resets value of inferior_ptid to parent ptid. */
- do_cleanups (old_chain);
}
else
{
+ scoped_restore save_inferior_ptid
+ = make_scoped_restore (&inferior_ptid);
+ inferior_ptid = child_ptid;
+
/* Let the thread_db layer learn about this new process. */
check_for_thread_db ();
}
- do_cleanups (old_chain);
-
if (has_vforked)
{
struct lwp_info *parent_lp;
- parent_lp = find_lwp_pid (pid_to_ptid (parent_pid));
+ parent_lp = find_lwp_pid (parent_ptid);
gdb_assert (linux_supports_tracefork () >= 0);
if (linux_supports_tracevforkdone ())
/* If we're in async mode, need to tell the event loop
there's something here to process. */
- if (target_can_async_p ())
+ if (target_is_async_p ())
async_file_mark ();
}
}
}
\f
-static int
-linux_child_insert_fork_catchpoint (struct target_ops *self, int pid)
+int
+linux_nat_target::insert_fork_catchpoint (int pid)
{
return !linux_supports_tracefork ();
}
-static int
-linux_child_remove_fork_catchpoint (struct target_ops *self, int pid)
+int
+linux_nat_target::remove_fork_catchpoint (int pid)
{
return 0;
}
-static int
-linux_child_insert_vfork_catchpoint (struct target_ops *self, int pid)
+int
+linux_nat_target::insert_vfork_catchpoint (int pid)
{
return !linux_supports_tracefork ();
}
-static int
-linux_child_remove_vfork_catchpoint (struct target_ops *self, int pid)
+int
+linux_nat_target::remove_vfork_catchpoint (int pid)
{
return 0;
}
-static int
-linux_child_insert_exec_catchpoint (struct target_ops *self, int pid)
+int
+linux_nat_target::insert_exec_catchpoint (int pid)
{
return !linux_supports_tracefork ();
}
-static int
-linux_child_remove_exec_catchpoint (struct target_ops *self, int pid)
+int
+linux_nat_target::remove_exec_catchpoint (int pid)
{
return 0;
}
-static int
-linux_child_set_syscall_catchpoint (struct target_ops *self,
- int pid, int needed, int any_count,
- int table_size, int *table)
+int
+linux_nat_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
+ gdb::array_view<const int> syscall_counts)
{
if (!linux_supports_tracesysgood ())
return 1;
/* On GNU/Linux, we ignore the arguments. It means that we only
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 `syscall_counts' information because we do not
filter system calls here. We let GDB do the logic for us. */
return 0;
}
-/* 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
- is basically a group of such processes. However, such a grouping
- is almost entirely a user-space issue; the kernel doesn't enforce
- 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
- Threads library) to provide such a grouping.
-
- It is perfectly well possible to write a multi-threaded application
- without the assistance of a threads library, by using the clone
- system call directly. This module should be able to give some
- rudimentary support for debugging such applications if developers
- specify the CLONE_PTRACE flag in the clone system call, and are
- using the Linux kernel 2.4 or above.
-
- Note that there are some peculiarities in GNU/Linux that affect
- this code:
-
- - In general one should specify the __WCLONE flag to waitpid in
- order to make it report events for any of the cloned processes
- (and leave it out for the initial process). However, if a cloned
- process has exited the exit status is only reported if the
- __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.
-
- - When a traced, cloned process exits and is waited for by the
- debugger, the kernel reassigns it to the original parent and
- keeps it around as a "zombie". Somehow, the GNU/Linux Threads
- library doesn't notice this, which leads to the "zombie problem":
- When debugged a multi-threaded process that spawns a lot of
- threads will run out of processes, even if the threads exit,
- because the "zombies" stay around. */
-
-/* List of known LWPs. */
+/* List of known LWPs, keyed by LWP PID. This speeds up the common
+ case of mapping a PID returned from the kernel to our corresponding
+ lwp_info data structure. */
+static htab_t lwp_lwpid_htab;
+
+/* Calculate a hash from a lwp_info's LWP PID. */
+
+static hashval_t
+lwp_info_hash (const void *ap)
+{
+ const struct lwp_info *lp = (struct lwp_info *) ap;
+ pid_t pid = lp->ptid.lwp ();
+
+ return iterative_hash_object (pid, 0);
+}
+
+/* Equality function for the lwp_info hash table. Compares the LWP's
+ PID. */
+
+static int
+lwp_lwpid_htab_eq (const void *a, const void *b)
+{
+ const struct lwp_info *entry = (const struct lwp_info *) a;
+ const struct lwp_info *element = (const struct lwp_info *) b;
+
+ return entry->ptid.lwp () == element->ptid.lwp ();
+}
+
+/* Create the lwp_lwpid_htab hash table. */
+
+static void
+lwp_lwpid_htab_create (void)
+{
+ lwp_lwpid_htab = htab_create (100, lwp_info_hash, lwp_lwpid_htab_eq, NULL);
+}
+
+/* Add LP to the hash table. */
+
+static void
+lwp_lwpid_htab_add_lwp (struct lwp_info *lp)
+{
+ void **slot;
+
+ slot = htab_find_slot (lwp_lwpid_htab, lp, INSERT);
+ gdb_assert (slot != NULL && *slot == NULL);
+ *slot = lp;
+}
+
+/* Head of doubly-linked list of known LWPs. Sorted by reverse
+ creation order. This order is assumed in some cases. E.g.,
+ reaping status after killing alls lwps of a process: the leader LWP
+ must be reaped last. */
struct lwp_info *lwp_list;
-\f
-/* Original signal mask. */
-static sigset_t normal_mask;
+/* Add LP to sorted-by-reverse-creation-order doubly-linked list. */
+
+static void
+lwp_list_add (struct lwp_info *lp)
+{
+ lp->next = lwp_list;
+ if (lwp_list != NULL)
+ lwp_list->prev = lp;
+ lwp_list = lp;
+}
+
+/* Remove LP from sorted-by-reverse-creation-order doubly-linked
+ list. */
+
+static void
+lwp_list_remove (struct lwp_info *lp)
+{
+ /* Remove from sorted-by-creation-order list. */
+ if (lp->next != NULL)
+ lp->next->prev = lp->prev;
+ if (lp->prev != NULL)
+ lp->prev->next = lp->next;
+ if (lp == lwp_list)
+ lwp_list = lp->next;
+}
+
+\f
/* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
_initialize_linux_nat. */
if (!sigismember (&blocked_mask, SIGCHLD))
sigaddset (&blocked_mask, SIGCHLD);
- sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
+ gdb_sigmask (SIG_BLOCK, &blocked_mask, prev_mask);
}
/* Restore child signals mask, previously returned by
static void
restore_child_signals_mask (sigset_t *prev_mask)
{
- sigprocmask (SIG_SETMASK, prev_mask, NULL);
+ gdb_sigmask (SIG_SETMASK, prev_mask, NULL);
}
/* Mask of signals to pass directly to the inferior. */
static sigset_t pass_mask;
/* Update signals to pass to the inferior. */
-static void
-linux_nat_pass_signals (struct target_ops *self,
- int numsigs, unsigned char *pass_signals)
+void
+linux_nat_target::pass_signals
+ (gdb::array_view<const unsigned char> pass_signals)
{
int signo;
for (signo = 1; signo < NSIG; signo++)
{
int target_signo = gdb_signal_from_host (signo);
- if (target_signo < numsigs && pass_signals[target_signo])
+ if (target_signo < pass_signals.size () && pass_signals[target_signo])
sigaddset (&pass_mask, signo);
}
}
\f
/* Prototypes for local functions. */
-static int stop_wait_callback (struct lwp_info *lp, void *data);
-static int linux_thread_alive (ptid_t ptid);
-static char *linux_child_pid_to_exec_file (struct target_ops *self, int pid);
+static int stop_wait_callback (struct lwp_info *lp);
+static int resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid);
+static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
\f
static void
lwp_free (struct lwp_info *lp)
{
- xfree (lp->arch_private);
+ /* Let the arch specific bits release arch_lwp_info. */
+ linux_target->low_delete_thread (lp->arch_private);
+
xfree (lp);
}
-/* Remove all LWPs belong to PID from the lwp list. */
+/* Traversal function for purge_lwp_list. */
-static void
-purge_lwp_list (int pid)
+static int
+lwp_lwpid_htab_remove_pid (void **slot, void *info)
{
- struct lwp_info *lp, *lpprev, *lpnext;
+ struct lwp_info *lp = (struct lwp_info *) *slot;
+ int pid = *(int *) info;
- lpprev = NULL;
-
- for (lp = lwp_list; lp; lp = lpnext)
+ if (lp->ptid.pid () == pid)
{
- lpnext = lp->next;
+ htab_clear_slot (lwp_lwpid_htab, slot);
+ lwp_list_remove (lp);
+ lwp_free (lp);
+ }
- if (ptid_get_pid (lp->ptid) == pid)
- {
- if (lp == lwp_list)
- lwp_list = lp->next;
- else
- lpprev->next = lp->next;
+ return 1;
+}
- lwp_free (lp);
- }
- else
- lpprev = lp;
- }
+/* Remove all LWPs belong to PID from the lwp list. */
+
+static void
+purge_lwp_list (int pid)
+{
+ htab_traverse_noresize (lwp_lwpid_htab, lwp_lwpid_htab_remove_pid, &pid);
}
/* Add the LWP specified by PTID to the list. PTID is the first LWP
{
struct lwp_info *lp;
- gdb_assert (ptid_lwp_p (ptid));
+ gdb_assert (ptid.lwp_p ());
- lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
+ lp = XNEW (struct lwp_info);
memset (lp, 0, sizeof (struct lwp_info));
lp->ptid = ptid;
lp->core = -1;
- lp->next = lwp_list;
- lwp_list = lp;
+ /* Add to sorted-by-reverse-creation-order list. */
+ lwp_list_add (lp);
+
+ /* Add to keyed-by-pid htab. */
+ lwp_lwpid_htab_add_lwp (lp);
return lp;
}
clients of this callback take the opportunity to install
watchpoints in the new thread. We don't do this for the first
thread though. See add_initial_lwp. */
- if (linux_nat_new_thread != NULL)
- linux_nat_new_thread (lp);
+ linux_target->low_new_thread (lp);
return lp;
}
static void
delete_lwp (ptid_t ptid)
{
- struct lwp_info *lp, *lpprev;
+ struct lwp_info *lp;
+ void **slot;
+ struct lwp_info dummy;
- lpprev = NULL;
+ dummy.ptid = ptid;
+ slot = htab_find_slot (lwp_lwpid_htab, &dummy, NO_INSERT);
+ if (slot == NULL)
+ return;
- for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
- if (ptid_equal (lp->ptid, ptid))
- break;
+ lp = *(struct lwp_info **) slot;
+ gdb_assert (lp != NULL);
- if (!lp)
- return;
+ htab_clear_slot (lwp_lwpid_htab, slot);
- if (lpprev)
- lpprev->next = lp->next;
- else
- lwp_list = lp->next;
+ /* Remove from sorted-by-creation-order list. */
+ lwp_list_remove (lp);
+ /* Release. */
lwp_free (lp);
}
{
struct lwp_info *lp;
int lwp;
+ struct lwp_info dummy;
- if (ptid_lwp_p (ptid))
- lwp = ptid_get_lwp (ptid);
+ if (ptid.lwp_p ())
+ lwp = ptid.lwp ();
else
- lwp = ptid_get_pid (ptid);
-
- for (lp = lwp_list; lp; lp = lp->next)
- if (lwp == ptid_get_lwp (lp->ptid))
- return lp;
+ lwp = ptid.pid ();
- return NULL;
+ dummy.ptid = ptid_t (0, lwp, 0);
+ lp = (struct lwp_info *) htab_find (lwp_lwpid_htab, &dummy);
+ return lp;
}
-/* 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
- pointer to the structure describing that LWP immediately.
- Otherwise return NULL. */
+/* See nat/linux-nat.h. */
struct lwp_info *
iterate_over_lwps (ptid_t filter,
- int (*callback) (struct lwp_info *, void *),
- void *data)
+ gdb::function_view<iterate_over_lwps_ftype> callback)
{
struct lwp_info *lp, *lpnext;
{
lpnext = lp->next;
- if (ptid_match (lp->ptid, filter))
+ if (lp->ptid.matches (filter))
{
- if ((*callback) (lp, data))
+ if (callback (lp) != 0)
return lp;
}
}
{
struct lwp_info *lp;
- purge_lwp_list (ptid_get_pid (inferior_ptid));
+ purge_lwp_list (inferior_ptid.pid ());
lp = add_lwp (new_ptid);
lp->stopped = 1;
if (th)
{
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).c_str ());
- delete_thread (lp->ptid);
+ delete_thread (th);
}
delete_lwp (lp->ptid);
Returns a wait status for that LWP, to cache. */
static int
-linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
- int *signalled)
+linux_nat_post_attach_wait (ptid_t ptid, int *signalled)
{
- pid_t new_pid, pid = ptid_get_lwp (ptid);
+ pid_t new_pid, pid = ptid.lwp ();
int status;
if (linux_proc_pid_is_stopped (pid))
/* Make sure the initial process is stopped. The user-level threads
layer might want to poke around in the inferior, and that won't
work if things haven't stabilized yet. */
- new_pid = my_waitpid (pid, &status, 0);
- if (new_pid == -1 && errno == ECHILD)
- {
- if (first)
- warning (_("%s is a cloned process"), target_pid_to_str (ptid));
-
- /* Try again with __WCLONE to check cloned processes. */
- new_pid = my_waitpid (pid, &status, __WCLONE);
- *cloned = 1;
- }
-
+ new_pid = my_waitpid (pid, &status, __WALL);
gdb_assert (pid == new_pid);
if (!WIFSTOPPED (status))
return status;
}
-/* Attach to the LWP specified by PID. Return 0 if successful, -1 if
- the new LWP could not be attached, or 1 if we're already auto
- attached to this thread, but haven't processed the
- PTRACE_EVENT_CLONE event of its parent thread, so we just ignore
- its existance, without considering it an error. */
-
-int
-lin_lwp_attach_lwp (ptid_t ptid)
-{
- struct lwp_info *lp;
- int lwpid;
-
- gdb_assert (ptid_lwp_p (ptid));
-
- lp = find_lwp_pid (ptid);
- lwpid = ptid_get_lwp (ptid);
-
- /* 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
- 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,
- this assumption might be wrong; fortunately, this is very unlikely
- to happen. */
- if (lwpid != ptid_get_pid (ptid) && lp == NULL)
- {
- int status, cloned = 0, signalled = 0;
-
- if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
- {
- if (linux_supports_tracefork ())
- {
- /* If we haven't stopped all threads when we get here,
- we may have seen a thread listed in thread_db's list,
- but not processed the PTRACE_EVENT_CLONE yet. If
- that's the case, ignore this new thread, and let
- normal event handling discover it later. */
- if (in_pid_list_p (stopped_pids, lwpid))
- {
- /* We've already seen this thread stop, but we
- haven't seen the PTRACE_EVENT_CLONE extended
- event yet. */
- return 0;
- }
- else
- {
- int new_pid;
- int status;
-
- /* See if we've got a stop for this new child
- pending. If so, we're already attached. */
- gdb_assert (lwpid > 0);
- new_pid = my_waitpid (lwpid, &status, WNOHANG);
- if (new_pid == -1 && errno == ECHILD)
- new_pid = my_waitpid (lwpid, &status, __WCLONE | WNOHANG);
- if (new_pid != -1)
- {
- if (WIFSTOPPED (status))
- add_to_pid_list (&stopped_pids, lwpid, status);
- return 1;
- }
- }
- }
-
- /* If we fail to attach to the thread, issue a warning,
- but continue. One way this can happen is if thread
- creation is interrupted; as of Linux kernel 2.6.19, a
- bug may place threads in the thread list and then fail
- to create them. */
- warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
- safe_strerror (errno));
- return -1;
- }
-
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
- target_pid_to_str (ptid));
-
- status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
- if (!WIFSTOPPED (status))
- return 1;
-
- lp = add_lwp (ptid);
- lp->stopped = 1;
- lp->cloned = cloned;
- lp->signalled = signalled;
- if (WSTOPSIG (status) != SIGSTOP)
- {
- lp->resumed = 1;
- lp->status = status;
- }
-
- target_post_attach (ptid_get_lwp (lp->ptid));
-
- if (debug_linux_nat)
- {
- fprintf_unfiltered (gdb_stdlog,
- "LLAL: waitpid %s received %s\n",
- target_pid_to_str (ptid),
- status_to_str (status));
- }
- }
- else
- {
- /* We assume that the LWP representing the original process is
- already stopped. Mark it as stopped in the data structure
- that the GNU/linux ptrace layer uses to keep track of
- threads. Note that this won't have already been done since
- the main thread will have, we assume, been stopped by an
- attach from a different layer. */
- if (lp == NULL)
- lp = add_lwp (ptid);
- lp->stopped = 1;
- }
-
- lp->last_resume_kind = resume_stop;
- return 0;
-}
-
-static void
-linux_nat_create_inferior (struct target_ops *ops,
- char *exec_file, char *allargs, char **env,
- int from_tty)
+void
+linux_nat_target::create_inferior (const char *exec_file,
+ const std::string &allargs,
+ char **env, int from_tty)
{
-#ifdef HAVE_PERSONALITY
- int personality_orig = 0, personality_set = 0;
-#endif /* HAVE_PERSONALITY */
+ maybe_disable_address_space_randomization restore_personality
+ (disable_randomization);
/* The fork_child mechanism is synchronous and calls target_wait, so
we have to mask the async mode. */
-#ifdef HAVE_PERSONALITY
- if (disable_randomization)
- {
- errno = 0;
- personality_orig = personality (0xffffffff);
- if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
- {
- personality_set = 1;
- personality (personality_orig | ADDR_NO_RANDOMIZE);
- }
- if (errno != 0 || (personality_set
- && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
- warning (_("Error disabling address space randomization: %s"),
- safe_strerror (errno));
- }
-#endif /* HAVE_PERSONALITY */
-
/* Make sure we report all signals during startup. */
- linux_nat_pass_signals (ops, 0, NULL);
-
- linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
+ pass_signals ({});
-#ifdef HAVE_PERSONALITY
- if (personality_set)
- {
- errno = 0;
- personality (personality_orig);
- if (errno != 0)
- warning (_("Error restoring address space randomization: %s"),
- safe_strerror (errno));
- }
-#endif /* HAVE_PERSONALITY */
+ inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty);
}
/* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
lp = find_lwp_pid (ptid);
if (lp == NULL)
{
- int lwpid = ptid_get_lwp (ptid);
+ int lwpid = ptid.lwp ();
if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
{
}
else
{
- warning (_("Cannot attach to lwp %d: %s\n"),
- lwpid,
- linux_ptrace_attach_fail_reason_string (ptid,
- err));
+ std::string reason
+ = linux_ptrace_attach_fail_reason_string (ptid, err);
+
+ warning (_("Cannot attach to lwp %d: %s"),
+ lwpid, reason.c_str ());
}
}
else
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"PTRACE_ATTACH %s, 0, 0 (OK)\n",
- target_pid_to_str (ptid));
+ target_pid_to_str (ptid).c_str ());
lp = add_lwp (ptid);
- lp->cloned = 1;
/* The next time we wait for this LWP we'll see a SIGSTOP as
PTRACE_ATTACH brings it to a halt. */
/* We need to wait for a stop before being able to make the
next ptrace call on this LWP. */
lp->must_set_ptrace_flags = 1;
+
+ /* So that wait collects the SIGSTOP. */
+ lp->resumed = 1;
+
+ /* Also add the LWP to gdb's thread list, in case a
+ matching libthread_db is not found (or the process uses
+ raw clone). */
+ add_thread (lp->ptid);
+ set_running (lp->ptid, 1);
+ set_executing (lp->ptid, 1);
}
return 1;
return 0;
}
-static void
-linux_nat_attach (struct target_ops *ops, const char *args, int from_tty)
+void
+linux_nat_target::attach (const char *args, int from_tty)
{
struct lwp_info *lp;
int status;
ptid_t ptid;
- volatile struct gdb_exception ex;
/* Make sure we report all signals during attach. */
- linux_nat_pass_signals (ops, 0, NULL);
+ pass_signals ({});
- TRY_CATCH (ex, RETURN_MASK_ERROR)
+ try
{
- linux_ops->to_attach (ops, args, from_tty);
+ inf_ptrace_target::attach (args, from_tty);
}
- if (ex.reason < 0)
+ catch (const gdb_exception_error &ex)
{
pid_t pid = parse_pid_to_attach (args);
- struct buffer buffer;
- char *message, *buffer_s;
-
- message = xstrdup (ex.message);
- make_cleanup (xfree, message);
-
- buffer_init (&buffer);
- linux_ptrace_attach_fail_reason (pid, &buffer);
-
- buffer_grow_str0 (&buffer, "");
- buffer_s = buffer_finish (&buffer);
- make_cleanup (xfree, buffer_s);
+ std::string reason = linux_ptrace_attach_fail_reason (pid);
- if (*buffer_s != '\0')
- throw_error (ex.error, "warning: %s\n%s", buffer_s, message);
+ if (!reason.empty ())
+ throw_error (ex.error, "warning: %s\n%s", reason.c_str (),
+ ex.what ());
else
- throw_error (ex.error, "%s", message);
+ throw_error (ex.error, "%s", ex.what ());
}
/* The ptrace base target adds the main thread with (pid,0,0)
format. Decorate it with lwp info. */
- ptid = ptid_build (ptid_get_pid (inferior_ptid),
- ptid_get_pid (inferior_ptid),
- 0);
+ ptid = ptid_t (inferior_ptid.pid (),
+ inferior_ptid.pid (),
+ 0);
thread_change_ptid (inferior_ptid, ptid);
/* Add the initial process as the first LWP to the list. */
lp = add_initial_lwp (ptid);
- status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
- &lp->signalled);
+ status = linux_nat_post_attach_wait (lp->ptid, &lp->signalled);
if (!WIFSTOPPED (status))
{
if (WIFEXITED (status))
{
int exit_code = WEXITSTATUS (status);
- target_terminal_ours ();
- target_mourn_inferior ();
+ target_terminal::ours ();
+ target_mourn_inferior (inferior_ptid);
if (exit_code == 0)
error (_("Unable to attach: program exited normally."));
else
{
enum gdb_signal signo;
- target_terminal_ours ();
- target_mourn_inferior ();
+ target_terminal::ours ();
+ target_mourn_inferior (inferior_ptid);
signo = gdb_signal_from_host (WTERMSIG (status));
error (_("Unable to attach: program terminated with signal "
internal_error (__FILE__, __LINE__,
_("unexpected status %d for PID %ld"),
- status, (long) ptid_get_lwp (ptid));
+ status, (long) ptid.lwp ());
}
lp->stopped = 1;
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LNA: waitpid %ld, saving status %s\n",
- (long) ptid_get_pid (lp->ptid), status_to_str (status));
+ (long) lp->ptid.pid (), status_to_str (status));
lp->status = status;
of threads/LWPs, and those structures may well be corrupted.
Note that once thread_db is loaded, we'll still use it to list
threads and associate pthread info with each LWP. */
- linux_proc_attach_tgid_threads (ptid_get_pid (lp->ptid),
+ linux_proc_attach_tgid_threads (lp->ptid.pid (),
attach_proc_task_lwp_callback);
if (target_can_async_p ())
- target_async (inferior_event_handler, 0);
+ target_async (1);
}
-/* Get pending status of LP. */
+/* Get pending signal of THREAD as a host signal number, for detaching
+ purposes. This is the signal the thread last stopped for, which we
+ need to deliver to the thread when detaching, otherwise, it'd be
+ suppressed/lost. */
+
static int
-get_pending_status (struct lwp_info *lp, int *status)
+get_detach_signal (struct lwp_info *lp)
{
enum gdb_signal signo = GDB_SIGNAL_0;
signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal. */
else if (lp->status)
signo = gdb_signal_from_host (WSTOPSIG (lp->status));
- else if (non_stop && !is_executing (lp->ptid))
+ else
{
struct thread_info *tp = find_thread_ptid (lp->ptid);
- signo = tp->suspend.stop_signal;
- }
- else if (!non_stop)
- {
- struct target_waitstatus last;
- ptid_t last_ptid;
-
- get_last_target_status (&last_ptid, &last);
-
- if (ptid_get_lwp (lp->ptid) == ptid_get_lwp (last_ptid))
+ if (target_is_non_stop_p () && !tp->executing)
+ {
+ if (tp->suspend.waitstatus_pending_p)
+ signo = tp->suspend.waitstatus.value.sig;
+ else
+ signo = tp->suspend.stop_signal;
+ }
+ else if (!target_is_non_stop_p ())
{
- struct thread_info *tp = find_thread_ptid (lp->ptid);
+ struct target_waitstatus last;
+ ptid_t last_ptid;
+
+ get_last_target_status (&last_ptid, &last);
- signo = tp->suspend.stop_signal;
+ if (lp->ptid.lwp () == last_ptid.lwp ())
+ signo = tp->suspend.stop_signal;
}
}
- *status = 0;
-
if (signo == GDB_SIGNAL_0)
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"GPT: lwp %s has no pending signal\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
else if (!signal_pass_state (signo))
{
fprintf_unfiltered (gdb_stdlog,
"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).c_str (),
gdb_signal_to_string (signo));
}
else
{
- *status = W_STOPCODE (gdb_signal_to_host (signo));
-
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"GPT: lwp %s has pending signal %s\n",
- target_pid_to_str (lp->ptid),
+ target_pid_to_str (lp->ptid).c_str (),
gdb_signal_to_string (signo));
+
+ return gdb_signal_to_host (signo);
}
return 0;
}
-static int
-detach_callback (struct lwp_info *lp, void *data)
+/* Detach from LP. If SIGNO_P is non-NULL, then it points to the
+ signal number that should be passed to the LWP when detaching.
+ Otherwise pass any pending signal the LWP may have, if any. */
+
+static void
+detach_one_lwp (struct lwp_info *lp, int *signo_p)
{
+ int lwpid = lp->ptid.lwp ();
+ int signo;
+
gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
if (debug_linux_nat && lp->status)
fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
strsignal (WSTOPSIG (lp->status)),
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
/* If there is a pending SIGSTOP, get rid of it. */
if (lp->signalled)
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"DC: Sending SIGCONT to %s\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
- kill_lwp (ptid_get_lwp (lp->ptid), SIGCONT);
+ kill_lwp (lwpid, SIGCONT);
lp->signalled = 0;
}
- /* We don't actually detach from the LWP that has an id equal to the
- overall process id just yet. */
- if (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
+ if (signo_p == NULL)
{
- int status = 0;
-
/* Pass on any pending signal for this LWP. */
- get_pending_status (lp, &status);
+ signo = get_detach_signal (lp);
+ }
+ else
+ signo = *signo_p;
- if (linux_nat_prepare_to_resume != NULL)
- linux_nat_prepare_to_resume (lp);
- errno = 0;
- if (ptrace (PTRACE_DETACH, ptid_get_lwp (lp->ptid), 0,
- WSTOPSIG (status)) < 0)
- error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
- safe_strerror (errno));
+ /* Preparing to resume may try to write registers, and fail if the
+ lwp is zombie. If that happens, ignore the error. We'll handle
+ it below, when detach fails with ESRCH. */
+ try
+ {
+ linux_target->low_prepare_to_resume (lp);
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ if (!check_ptrace_stopped_lwp_gone (lp))
+ throw;
+ }
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "PTRACE_DETACH (%s, %s, 0) (OK)\n",
- target_pid_to_str (lp->ptid),
- strsignal (WSTOPSIG (status)));
+ if (ptrace (PTRACE_DETACH, lwpid, 0, signo) < 0)
+ {
+ int save_errno = errno;
+
+ /* We know the thread exists, so ESRCH must mean the lwp is
+ zombie. This can happen if one of the already-detached
+ threads exits the whole thread group. In that case we're
+ still attached, and must reap the lwp. */
+ if (save_errno == ESRCH)
+ {
+ int ret, status;
- delete_lwp (lp->ptid);
+ ret = my_waitpid (lwpid, &status, __WALL);
+ if (ret == -1)
+ {
+ warning (_("Couldn't reap LWP %d while detaching: %s"),
+ lwpid, safe_strerror (errno));
+ }
+ else if (!WIFEXITED (status) && !WIFSIGNALED (status))
+ {
+ warning (_("Reaping LWP %d while detaching "
+ "returned unexpected status 0x%x"),
+ lwpid, status);
+ }
+ }
+ else
+ {
+ error (_("Can't detach %s: %s"),
+ target_pid_to_str (lp->ptid).c_str (),
+ safe_strerror (save_errno));
+ }
+ }
+ else if (debug_linux_nat)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "PTRACE_DETACH (%s, %s, 0) (OK)\n",
+ target_pid_to_str (lp->ptid).c_str (),
+ strsignal (signo));
}
+ delete_lwp (lp->ptid);
+}
+
+static int
+detach_callback (struct lwp_info *lp)
+{
+ /* We don't actually detach from the thread group leader just yet.
+ If the thread group exits, we must reap the zombie clone lwps
+ before we're able to reap the leader. */
+ if (lp->ptid.lwp () != lp->ptid.pid ())
+ detach_one_lwp (lp, NULL);
return 0;
}
-static void
-linux_nat_detach (struct target_ops *ops, const char *args, int from_tty)
+void
+linux_nat_target::detach (inferior *inf, int from_tty)
{
- int pid;
- int status;
struct lwp_info *main_lwp;
-
- pid = ptid_get_pid (inferior_ptid);
+ int pid = inf->pid;
/* Don't unregister from the event loop, as there may be other
inferiors running. */
/* Stop all threads before detaching. ptrace requires that the
- thread is stopped to sucessfully detach. */
- iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
+ thread is stopped to successfully detach. */
+ iterate_over_lwps (ptid_t (pid), stop_callback);
/* ... and wait until all of them have reported back that
they're no longer running. */
- iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
+ iterate_over_lwps (ptid_t (pid), stop_wait_callback);
- iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
+ iterate_over_lwps (ptid_t (pid), detach_callback);
/* Only the initial process should be left right now. */
- gdb_assert (num_lwps (ptid_get_pid (inferior_ptid)) == 1);
-
- main_lwp = find_lwp_pid (pid_to_ptid (pid));
-
- /* Pass on any pending signal for the last LWP. */
- if ((args == NULL || *args == '\0')
- && get_pending_status (main_lwp, &status) != -1
- && WIFSTOPPED (status))
- {
- char *tem;
-
- /* Put the signal number in ARGS so that inf_ptrace_detach will
- pass it along with PTRACE_DETACH. */
- tem = alloca (8);
- xsnprintf (tem, 8, "%d", (int) WSTOPSIG (status));
- args = tem;
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LND: Sending signal %s to %s\n",
- args,
- target_pid_to_str (main_lwp->ptid));
- }
+ gdb_assert (num_lwps (pid) == 1);
- if (linux_nat_prepare_to_resume != NULL)
- linux_nat_prepare_to_resume (main_lwp);
- delete_lwp (main_lwp->ptid);
+ main_lwp = find_lwp_pid (ptid_t (pid));
if (forks_exist_p ())
{
from, but there are other viable forks to debug. Detach from
the current fork, and context-switch to the first
available. */
- linux_fork_detach (args, from_tty);
+ linux_fork_detach (from_tty);
}
else
- linux_ops->to_detach (ops, args, from_tty);
+ {
+ target_announce_detach (from_tty);
+
+ /* Pass on any pending signal for the last LWP. */
+ int signo = get_detach_signal (main_lwp);
+
+ detach_one_lwp (main_lwp, &signo);
+
+ detach_success (inf);
+ }
}
/* Resume execution of the inferior process. If STEP is nonzero,
single-step it. If SIGNAL is nonzero, give it that signal. */
static void
-linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
+linux_resume_one_lwp_throw (struct lwp_info *lp, int step,
+ enum gdb_signal signo)
{
- ptid_t ptid;
-
lp->step = step;
- if (linux_nat_prepare_to_resume != NULL)
- linux_nat_prepare_to_resume (lp);
- /* Convert to something the lower layer understands. */
- ptid = pid_to_ptid (ptid_get_lwp (lp->ptid));
- linux_ops->to_resume (linux_ops, ptid, step, signo);
- lp->stopped_by_watchpoint = 0;
+
+ /* stop_pc doubles as the PC the LWP had when it was last resumed.
+ We only presently need that if the LWP is stepped though (to
+ handle the case of stepping a breakpoint instruction). */
+ if (step)
+ {
+ struct regcache *regcache = get_thread_regcache (lp->ptid);
+
+ lp->stop_pc = regcache_read_pc (regcache);
+ }
+ else
+ lp->stop_pc = 0;
+
+ linux_target->low_prepare_to_resume (lp);
+ linux_target->low_resume (lp->ptid, step, signo);
+
+ /* Successfully resumed. Clear state that no longer makes sense,
+ and mark the LWP as running. Must not do this before resuming
+ otherwise if that fails other code will be confused. E.g., we'd
+ later try to stop the LWP and hang forever waiting for a stop
+ status. Note that we must not throw after this is cleared,
+ otherwise handle_zombie_lwp_error would get confused. */
lp->stopped = 0;
+ lp->core = -1;
+ lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
registers_changed_ptid (lp->ptid);
}
+/* Called when we try to resume a stopped LWP and that errors out. If
+ the LWP is no longer in ptrace-stopped state (meaning it's zombie,
+ or about to become), discard the error, clear any pending status
+ the LWP may have, and return true (we'll collect the exit status
+ soon enough). Otherwise, return false. */
+
+static int
+check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
+{
+ /* If we get an error after resuming the LWP successfully, we'd
+ confuse !T state for the LWP being gone. */
+ gdb_assert (lp->stopped);
+
+ /* We can't just check whether the LWP is in 'Z (Zombie)' state,
+ because even if ptrace failed with ESRCH, the tracee may be "not
+ yet fully dead", but already refusing ptrace requests. In that
+ case the tracee has 'R (Running)' state for a little bit
+ (observed in Linux 3.18). See also the note on ESRCH in the
+ ptrace(2) man page. Instead, check whether the LWP has any state
+ other than ptrace-stopped. */
+
+ /* Don't assume anything if /proc/PID/status can't be read. */
+ if (linux_proc_pid_is_trace_stopped_nowarn (lp->ptid.lwp ()) == 0)
+ {
+ lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
+ lp->status = 0;
+ lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
+ return 1;
+ }
+ return 0;
+}
+
+/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
+ disappears while we try to resume it. */
+
+static void
+linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
+{
+ try
+ {
+ linux_resume_one_lwp_throw (lp, step, signo);
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ if (!check_ptrace_stopped_lwp_gone (lp))
+ throw;
+ }
+}
+
/* Resume LP. */
static void
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"RC: Not resuming %s (vfork parent)\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
else if (!lwp_status_pending_p (lp))
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"RC: Resuming sibling %s, %s, %s\n",
- target_pid_to_str (lp->ptid),
+ target_pid_to_str (lp->ptid).c_str (),
(signo != GDB_SIGNAL_0
? strsignal (gdb_signal_to_host (signo))
: "0"),
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"RC: Not resuming sibling %s (has pending)\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
}
else
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"RC: Not resuming sibling %s (not stopped)\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
}
Resume LWP with the last stop signal, if it is in pass state. */
static int
-linux_nat_resume_callback (struct lwp_info *lp, void *except)
+linux_nat_resume_callback (struct lwp_info *lp, struct lwp_info *except)
{
enum gdb_signal signo = GDB_SIGNAL_0;
}
static int
-resume_clear_callback (struct lwp_info *lp, void *data)
+resume_clear_callback (struct lwp_info *lp)
{
lp->resumed = 0;
lp->last_resume_kind = resume_stop;
}
static int
-resume_set_callback (struct lwp_info *lp, void *data)
+resume_set_callback (struct lwp_info *lp)
{
lp->resumed = 1;
lp->last_resume_kind = resume_continue;
return 0;
}
-static void
-linux_nat_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal signo)
+void
+linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
{
struct lwp_info *lp;
int resume_many;
fprintf_unfiltered (gdb_stdlog,
"LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
step ? "step" : "resume",
- target_pid_to_str (ptid),
+ target_pid_to_str (ptid).c_str (),
(signo != GDB_SIGNAL_0
? strsignal (gdb_signal_to_host (signo)) : "0"),
- target_pid_to_str (inferior_ptid));
+ target_pid_to_str (inferior_ptid).c_str ());
/* A specific PTID means `step only this process id'. */
- resume_many = (ptid_equal (minus_one_ptid, ptid)
- || ptid_is_pid (ptid));
+ resume_many = (minus_one_ptid == ptid
+ || ptid.is_pid ());
/* Mark the lwps we're resuming as resumed. */
- iterate_over_lwps (ptid, resume_set_callback, NULL);
+ iterate_over_lwps (ptid, resume_set_callback);
/* See if it's the current inferior that should be handled
specially. */
if (target_can_async_p ())
{
- target_async (inferior_event_handler, 0);
+ target_async (1);
/* Tell the event loop we have something to process. */
async_file_mark ();
}
}
if (resume_many)
- iterate_over_lwps (ptid, linux_nat_resume_callback, lp);
-
- linux_resume_one_lwp (lp, step, signo);
+ iterate_over_lwps (ptid, [=] (struct lwp_info *info)
+ {
+ return linux_nat_resume_callback (info, lp);
+ });
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LLR: %s %s, %s (resume event thread)\n",
step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
- target_pid_to_str (ptid),
+ target_pid_to_str (lp->ptid).c_str (),
(signo != GDB_SIGNAL_0
? strsignal (gdb_signal_to_host (signo)) : "0"));
+ linux_resume_one_lwp (lp, step, signo);
+
if (target_can_async_p ())
- target_async (inferior_event_handler, 0);
+ target_async (1);
}
/* Send a signal to an LWP. */
static int
kill_lwp (int lwpid, int signo)
{
- /* 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. */
-
-#ifdef HAVE_TKILL_SYSCALL
- {
- static int tkill_failed;
-
- if (!tkill_failed)
- {
- int ret;
-
- errno = 0;
- ret = syscall (__NR_tkill, lwpid, signo);
- if (errno != ENOSYS)
- return ret;
- tkill_failed = 1;
- }
- }
-#endif
+ int ret;
- return kill (lwpid, signo);
+ errno = 0;
+ ret = syscall (__NR_tkill, lwpid, signo);
+ if (errno == ENOSYS)
+ {
+ /* If tkill fails, then we are not using nptl threads, a
+ configuration we no longer support. */
+ perror_with_name (("tkill"));
+ }
+ return ret;
}
/* Handle a GNU/Linux syscall trap wait response. If we see a syscall
{
struct target_waitstatus *ourstatus = &lp->waitstatus;
struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
- int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
+ thread_info *thread = find_thread_ptid (lp->ptid);
+ int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, thread);
if (stopping)
{
"for LWP %ld (stopping threads), "
"resuming with PTRACE_CONT for SIGSTOP\n",
syscall_number,
- ptid_get_lwp (lp->ptid));
+ lp->ptid.lwp ());
lp->syscall_state = TARGET_WAITKIND_IGNORE;
- ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
+ ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0);
lp->stopped = 0;
return 1;
}
+ /* Always update the entry/return state, even if this particular
+ syscall isn't interesting to the core now. In async mode,
+ the user could install a new catchpoint for this syscall
+ between syscall enter/return, and we'll need to know to
+ report a syscall return if that happens. */
+ lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
+ ? TARGET_WAITKIND_SYSCALL_RETURN
+ : TARGET_WAITKIND_SYSCALL_ENTRY);
+
if (catch_syscall_enabled ())
{
- /* Always update the entry/return state, even if this particular
- syscall isn't interesting to the core now. In async mode,
- the user could install a new catchpoint for this syscall
- between syscall enter/return, and we'll need to know to
- report a syscall return if that happens. */
- lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
- ? TARGET_WAITKIND_SYSCALL_RETURN
- : TARGET_WAITKIND_SYSCALL_ENTRY);
-
if (catching_syscall_number (syscall_number))
{
/* Alright, an event to report. */
== TARGET_WAITKIND_SYSCALL_ENTRY
? "entry" : "return",
syscall_number,
- ptid_get_lwp (lp->ptid));
+ lp->ptid.lwp ());
return 0;
}
lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
? "entry" : "return",
syscall_number,
- ptid_get_lwp (lp->ptid));
+ lp->ptid.lwp ());
}
else
{
"with no syscall catchpoints."
" %d for LWP %ld, ignoring\n",
syscall_number,
- ptid_get_lwp (lp->ptid));
+ lp->ptid.lwp ());
lp->syscall_state = TARGET_WAITKIND_IGNORE;
}
true, the new LWP remains stopped, otherwise it is continued. */
static int
-linux_handle_extended_wait (struct lwp_info *lp, int status,
- int stopping)
+linux_handle_extended_wait (struct lwp_info *lp, int status)
{
- int pid = ptid_get_lwp (lp->ptid);
+ int pid = lp->ptid.lwp ();
struct target_waitstatus *ourstatus = &lp->waitstatus;
int event = linux_ptrace_get_extended_event (status);
+ /* All extended events we currently use are mid-syscall. Only
+ PTRACE_EVENT_STOP is delivered more like a signal-stop, but
+ you have to be using PTRACE_SEIZE to get that. */
+ lp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
+
if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
|| event == PTRACE_EVENT_CLONE)
{
{
/* The new child has a pending SIGSTOP. We can't affect it until it
hits the SIGSTOP, but we're already attached. */
- ret = my_waitpid (new_pid, &status,
- (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
+ ret = my_waitpid (new_pid, &status, __WALL);
if (ret == -1)
perror_with_name (_("waiting for new child"));
else if (ret != new_pid)
_("wait returned unexpected status 0x%x"), status);
}
- ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
+ ourstatus->value.related_pid = ptid_t (new_pid, new_pid, 0);
if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
{
/* The arch-specific native code may need to know about new
forks even if those end up never mapped to an
inferior. */
- if (linux_nat_new_fork != NULL)
- linux_nat_new_fork (lp, new_pid);
+ linux_target->low_new_fork (lp, new_pid);
}
if (event == PTRACE_EVENT_FORK
- && linux_fork_checkpointing_p (ptid_get_pid (lp->ptid)))
+ && linux_fork_checkpointing_p (lp->ptid.pid ()))
{
/* Handle checkpointing by linux-fork.c here as a special
case. We don't want the follow-fork-mode or 'catch fork'
/* This won't actually modify the breakpoint list, but will
physically remove the breakpoints from the child. */
- detach_breakpoints (ptid_build (new_pid, new_pid, 0));
+ detach_breakpoints (ptid_t (new_pid, new_pid, 0));
/* Retain child fork in ptrace (stopped) state. */
if (!find_fork_pid (new_pid))
ourstatus->kind = TARGET_WAITKIND_FORKED;
else if (event == PTRACE_EVENT_VFORK)
ourstatus->kind = TARGET_WAITKIND_VFORKED;
- else
+ else if (event == PTRACE_EVENT_CLONE)
{
struct lwp_info *new_lp;
"from LWP %d, new child is LWP %ld\n",
pid, new_pid);
- new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
- new_lp->cloned = 1;
+ new_lp = add_lwp (ptid_t (lp->ptid.pid (), new_pid, 0));
new_lp->stopped = 1;
+ new_lp->resumed = 1;
+
+ /* If the thread_db layer is active, let it record the user
+ level thread id and status, and add the thread to GDB's
+ list. */
+ if (!thread_db_notice_clone (lp->ptid, new_lp->ptid))
+ {
+ /* The process is not using thread_db. Add the LWP to
+ GDB's list. */
+ target_post_attach (new_lp->ptid.lwp ());
+ add_thread (new_lp->ptid);
+ }
+
+ /* Even if we're stopping the thread for some reason
+ internal to this module, from the perspective of infrun
+ and the user/frontend, this new thread is running until
+ it next reports a stop. */
+ set_running (new_lp->ptid, 1);
+ set_executing (new_lp->ptid, 1);
if (WSTOPSIG (status) != SIGSTOP)
{
have a lower number than SIGSTOP (e.g. SIGUSR1).
This is an unlikely case, and harder to handle for
fork / vfork than for clone, so we do not try - but
- we handle it for clone events here. We'll send
- the other signal on to the thread below. */
+ we handle it for clone events here. */
new_lp->signalled = 1;
- }
- else
- {
- struct thread_info *tp;
-
- /* When we stop for an event in some other thread, and
- pull the thread list just as this thread has cloned,
- we'll have seen the new thread in the thread_db list
- before handling the CLONE event (glibc's
- pthread_create adds the new thread to the thread list
- before clone'ing, and has the kernel fill in the
- thread's tid on the clone call with
- CLONE_PARENT_SETTID). If that happened, and the core
- had requested the new thread to stop, we'll have
- killed it with SIGSTOP. But since SIGSTOP is not an
- RT signal, it can only be queued once. We need to be
- careful to not resume the LWP if we wanted it to
- stop. In that case, we'll leave the SIGSTOP pending.
- It will later be reported as GDB_SIGNAL_0. */
- tp = find_thread_ptid (new_lp->ptid);
- if (tp != NULL && tp->stop_requested)
- new_lp->last_resume_kind = resume_stop;
- else
- status = 0;
- }
-
- if (non_stop)
- {
- /* Add the new thread to GDB's lists as soon as possible
- so that:
-
- 1) the frontend doesn't have to wait for a stop to
- display them, and,
-
- 2) we tag it with the correct running state. */
- /* If the thread_db layer is active, let it know about
- this new thread, and add it to GDB's list. */
- if (!thread_db_attach_lwp (new_lp->ptid))
- {
- /* We're not using thread_db. Add it to GDB's
- list. */
- target_post_attach (ptid_get_lwp (new_lp->ptid));
- add_thread (new_lp->ptid);
- }
-
- if (!stopping)
- {
- set_running (new_lp->ptid, 1);
- set_executing (new_lp->ptid, 1);
- /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
- resume_stop. */
- new_lp->last_resume_kind = resume_continue;
- }
- }
-
- if (status != 0)
- {
/* We created NEW_LP so it cannot yet contain STATUS. */
gdb_assert (new_lp->status == 0);
fprintf_unfiltered (gdb_stdlog,
"LHEW: waitpid of new LWP %ld, "
"saving status %s\n",
- (long) ptid_get_lwp (new_lp->ptid),
+ (long) new_lp->ptid.lwp (),
status_to_str (status));
new_lp->status = status;
}
-
- /* Note the need to use the low target ops to resume, to
- handle resuming with PT_SYSCALL if we have syscall
- catchpoints. */
- if (!stopping)
+ else if (report_thread_events)
{
- new_lp->resumed = 1;
-
- if (status == 0)
- {
- gdb_assert (new_lp->last_resume_kind == resume_continue);
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LHEW: resuming new LWP %ld\n",
- ptid_get_lwp (new_lp->ptid));
- linux_resume_one_lwp (new_lp, 0, GDB_SIGNAL_0);
- }
+ new_lp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
+ new_lp->status = status;
}
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LHEW: resuming parent LWP %d\n", pid);
- linux_resume_one_lwp (lp, 0, GDB_SIGNAL_0);
return 1;
}
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LHEW: Got exec event from LWP %ld\n",
- ptid_get_lwp (lp->ptid));
+ lp->ptid.lwp ());
ourstatus->kind = TARGET_WAITKIND_EXECD;
ourstatus->value.execd_pathname
- = xstrdup (linux_child_pid_to_exec_file (NULL, pid));
+ = xstrdup (linux_proc_pid_to_exec_file (pid));
/* The thread that execed must have been resumed, but, when a
thread execs, it changes its tid to the tgid, and the old
fprintf_unfiltered (gdb_stdlog,
"LHEW: Got expected PTRACE_EVENT_"
"VFORK_DONE from LWP %ld: stopping\n",
- ptid_get_lwp (lp->ptid));
+ lp->ptid.lwp ());
ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
return 0;
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LHEW: Got PTRACE_EVENT_VFORK_DONE "
- "from LWP %ld: resuming\n",
- ptid_get_lwp (lp->ptid));
- ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
+ "from LWP %ld: ignoring\n",
+ lp->ptid.lwp ());
return 1;
}
_("unknown ptrace event %d"), event);
}
+/* Suspend waiting for a signal. We're mostly interested in
+ SIGCHLD/SIGINT. */
+
+static void
+wait_for_signal ()
+{
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog, "linux-nat: about to sigsuspend\n");
+ sigsuspend (&suspend_mask);
+
+ /* If the quit flag is set, it means that the user pressed Ctrl-C
+ and we're debugging a process that is running on a separate
+ terminal, so we must forward the Ctrl-C to the inferior. (If the
+ inferior is sharing GDB's terminal, then the Ctrl-C reaches the
+ inferior directly.) We must do this here because functions that
+ need to block waiting for a signal loop forever until there's an
+ event to report before returning back to the event loop. */
+ if (!target_terminal::is_ours ())
+ {
+ if (check_quit_flag ())
+ target_pass_ctrlc ();
+ }
+}
+
/* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
exited. */
for (;;)
{
- /* If my_waitpid returns 0 it means the __WCLONE vs. non-__WCLONE kind
- was right and we should just call sigsuspend. */
-
- pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, WNOHANG);
- if (pid == -1 && errno == ECHILD)
- pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, __WCLONE | WNOHANG);
+ pid = my_waitpid (lp->ptid.lwp (), &status, __WALL | WNOHANG);
if (pid == -1 && errno == ECHILD)
{
/* The thread has previously exited. We need to delete it
- now because, for some vendor 2.4 kernels with NPTL
- support backported, there won't be an exit event unless
- it is the main thread. 2.6 kernels will report an exit
- event for each thread that exits, as expected. */
+ now because if this was a non-leader thread execing, we
+ won't get an exit event. See comments on exec events at
+ the top of the file. */
thread_dead = 1;
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
if (pid != 0)
break;
Thread group leader may have exited in which case we'll lock up in
waitpid if there are other threads, even if they are all zombies too.
Basically, we're not supposed to use waitpid this way.
- __WCLONE is not applicable for the leader so we can't use that.
- LINUX_NAT_THREAD_ALIVE cannot be used here as it requires a STOPPED
- process; it gets ESRCH both for the zombie and for running processes.
+ tkill(pid,0) cannot be used here as it gets ESRCH for both
+ for zombie and running processes.
As a workaround, check if we're waiting for the thread group leader and
if it's a zombie, and avoid calling waitpid if it is.
Therefore always use WNOHANG with sigsuspend - it is equivalent to
waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
- if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid)
- && linux_proc_pid_is_zombie (ptid_get_lwp (lp->ptid)))
+ if (lp->ptid.pid () == lp->ptid.lwp ()
+ && linux_proc_pid_is_zombie (lp->ptid.lwp ()))
{
thread_dead = 1;
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"WL: Thread group leader %s vanished.\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
break;
}
linux_nat_wait_1 and there if we get called my_waitpid gets called
again before it gets to sigsuspend so we can safely let the handlers
get executed here. */
-
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog, "WL: about to sigsuspend\n");
- sigsuspend (&suspend_mask);
+ wait_for_signal ();
}
restore_child_signals_mask (&prev_mask);
if (!thread_dead)
{
- gdb_assert (pid == ptid_get_lwp (lp->ptid));
+ gdb_assert (pid == lp->ptid.lwp ());
if (debug_linux_nat)
{
fprintf_unfiltered (gdb_stdlog,
"WL: waitpid %s received %s\n",
- target_pid_to_str (lp->ptid),
+ target_pid_to_str (lp->ptid).c_str (),
status_to_str (status));
}
/* Check if the thread has exited. */
if (WIFEXITED (status) || WIFSIGNALED (status))
{
+ if (report_thread_events
+ || lp->ptid.pid () == lp->ptid.lwp ())
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog, "WL: LWP %d exited.\n",
+ lp->ptid.pid ());
+
+ /* If this is the leader exiting, it means the whole
+ process is gone. Store the status to report to the
+ core. Store it in lp->waitstatus, because lp->status
+ would be ambiguous (W_EXITCODE(0,0) == 0). */
+ store_waitstatus (&lp->waitstatus, status);
+ return 0;
+ }
+
thread_dead = 1;
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
}
if (lp->must_set_ptrace_flags)
{
- struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
+ struct inferior *inf = find_inferior_pid (lp->ptid.pid ());
+ int options = linux_nat_ptrace_options (inf->attach_flag);
- linux_enable_event_reporting (ptid_get_lwp (lp->ptid), inf->attach_flag);
+ linux_enable_event_reporting (lp->ptid.lwp (), options);
lp->must_set_ptrace_flags = 0;
}
if (linux_handle_syscall_trap (lp, 1))
return wait_lwp (lp);
}
+ else
+ {
+ /* Almost all other ptrace-stops are known to be outside of system
+ calls, with further exceptions in linux_handle_extended_wait. */
+ lp->syscall_state = TARGET_WAITKIND_IGNORE;
+ }
/* Handle GNU/Linux's extended waitstatus for trace events. */
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
fprintf_unfiltered (gdb_stdlog,
"WL: Handling extended status 0x%06x\n",
status);
- if (linux_handle_extended_wait (lp, status, 1))
- return wait_lwp (lp);
+ linux_handle_extended_wait (lp, status);
+ return 0;
}
return status;
/* Send a SIGSTOP to LP. */
static int
-stop_callback (struct lwp_info *lp, void *data)
+stop_callback (struct lwp_info *lp)
{
if (!lp->stopped && !lp->signalled)
{
{
fprintf_unfiltered (gdb_stdlog,
"SC: kill %s **<SIGSTOP>**\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
errno = 0;
- ret = kill_lwp (ptid_get_lwp (lp->ptid), SIGSTOP);
+ ret = kill_lwp (lp->ptid.lwp (), SIGSTOP);
if (debug_linux_nat)
{
fprintf_unfiltered (gdb_stdlog,
void
linux_stop_lwp (struct lwp_info *lwp)
{
- stop_callback (lwp, NULL);
+ stop_callback (lwp);
+}
+
+/* See linux-nat.h */
+
+void
+linux_stop_and_wait_all_lwps (void)
+{
+ /* Stop all LWP's ... */
+ iterate_over_lwps (minus_one_ptid, stop_callback);
+
+ /* ... and wait until all of them have reported back that
+ they're no longer running. */
+ iterate_over_lwps (minus_one_ptid, stop_wait_callback);
+}
+
+/* See linux-nat.h */
+
+void
+linux_unstop_all_lwps (void)
+{
+ iterate_over_lwps (minus_one_ptid,
+ [] (struct lwp_info *info)
+ {
+ return resume_stopped_resumed_lwps (info, minus_one_ptid);
+ });
}
/* Return non-zero if LWP PID has a pending SIGINT. */
/* Set a flag in LP indicating that we should ignore its next SIGINT. */
static int
-set_ignore_sigint (struct lwp_info *lp, void *data)
+set_ignore_sigint (struct lwp_info *lp)
{
/* If a thread has a pending SIGINT, consume it; otherwise, set a
flag to consume the next one. */
if (!lp->ignore_sigint)
return;
- if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp->ptid)))
+ if (!linux_nat_has_pending_sigint (lp->ptid.lwp ()))
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"MCIS: Clearing bogus flag for %s\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
lp->ignore_sigint = 0;
}
}
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. */
-static void
-save_sigtrap (struct lwp_info *lp)
+static int
+check_stopped_by_watchpoint (struct lwp_info *lp)
{
- struct cleanup *old_chain;
-
- if (linux_ops->to_stopped_by_watchpoint == NULL)
- {
- lp->stopped_by_watchpoint = 0;
- return;
- }
-
- old_chain = save_inferior_ptid ();
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
inferior_ptid = lp->ptid;
- lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint (linux_ops);
-
- if (lp->stopped_by_watchpoint)
+ if (linux_target->low_stopped_by_watchpoint ())
{
- if (linux_ops->to_stopped_data_address != NULL)
- lp->stopped_data_address_p =
- linux_ops->to_stopped_data_address (¤t_target,
- &lp->stopped_data_address);
- else
- lp->stopped_data_address_p = 0;
+ lp->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
+ lp->stopped_data_address_p
+ = linux_target->low_stopped_data_address (&lp->stopped_data_address);
}
- do_cleanups (old_chain);
+ return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
-/* See save_sigtrap. */
+/* Returns true if the LWP had stopped for a watchpoint. */
-static int
-linux_nat_stopped_by_watchpoint (struct target_ops *ops)
+bool
+linux_nat_target::stopped_by_watchpoint ()
{
struct lwp_info *lp = find_lwp_pid (inferior_ptid);
gdb_assert (lp != NULL);
- return lp->stopped_by_watchpoint;
+ return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
-static int
-linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
+bool
+linux_nat_target::stopped_data_address (CORE_ADDR *addr_p)
{
struct lwp_info *lp = find_lwp_pid (inferior_ptid);
/* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
-static int
-sigtrap_is_event (int status)
+bool
+linux_nat_target::low_status_is_event (int status)
{
return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
}
-/* SIGTRAP-like events recognizer. */
-
-static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
-
-/* Check for SIGTRAP-like events in LP. */
-
-static int
-linux_nat_lp_status_is_event (struct lwp_info *lp)
-{
- /* We check for lp->waitstatus in addition to lp->status, because we can
- have pending process exits recorded in lp->status
- and W_EXITCODE(0,0) == 0. We should probably have an additional
- lp->status_p flag. */
-
- return (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
- && linux_nat_status_is_event (lp->status));
-}
-
-/* Set alternative SIGTRAP-like events recognizer. If
- breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
- applied. */
-
-void
-linux_nat_set_status_is_event (struct target_ops *t,
- int (*status_is_event) (int status))
-{
- linux_nat_status_is_event = status_is_event;
-}
-
/* Wait until LP is stopped. */
static int
-stop_wait_callback (struct lwp_info *lp, void *data)
+stop_wait_callback (struct lwp_info *lp)
{
struct inferior *inf = find_inferior_ptid (lp->ptid);
lp->ignore_sigint = 0;
errno = 0;
- ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
+ ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0);
lp->stopped = 0;
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"PTRACE_CONT %s, 0, 0 (%s) "
"(discarding SIGINT)\n",
- target_pid_to_str (lp->ptid),
+ target_pid_to_str (lp->ptid).c_str (),
errno ? safe_strerror (errno) : "OK");
- return stop_wait_callback (lp, NULL);
+ return stop_wait_callback (lp);
}
maybe_clear_ignore_sigint (lp);
{
/* The thread was stopped with a signal other than SIGSTOP. */
- save_sigtrap (lp);
-
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"SWC: Pending event %s in %s\n",
status_to_str ((int) status),
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
/* Save the sigtrap event. */
lp->status = status;
gdb_assert (lp->signalled);
+ save_stop_reason (lp);
}
else
{
- /* We caught the SIGSTOP that we intended to catch, so
- there's no SIGSTOP pending. */
+ /* We caught the SIGSTOP that we intended to catch. */
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
- "SWC: Delayed SIGSTOP caught for %s.\n",
- target_pid_to_str (lp->ptid));
+ "SWC: Expected SIGSTOP caught for %s.\n",
+ target_pid_to_str (lp->ptid).c_str ());
- /* Reset SIGNALLED only after the stop_wait_callback call
- above as it does gdb_assert on SIGNALLED. */
lp->signalled = 0;
+
+ /* If we are waiting for this stop so we can report the thread
+ stopped then we need to record this status. Otherwise, we can
+ now discard this stop event. */
+ if (lp->last_resume_kind == resume_stop)
+ {
+ lp->status = status;
+ save_stop_reason (lp);
+ }
}
}
return 0;
}
-/* Return non-zero if LP has a wait status pending. */
+/* Return non-zero if LP has a wait status pending. Discard the
+ pending event and resume the LWP if the event that originally
+ caused the stop became uninteresting. */
static int
-status_callback (struct lwp_info *lp, void *data)
+status_callback (struct lwp_info *lp)
{
/* Only report a pending wait status if we pretend that this has
indeed been resumed. */
if (!lp->resumed)
return 0;
- return lwp_status_pending_p (lp);
-}
+ if (!lwp_status_pending_p (lp))
+ return 0;
-/* Return non-zero if LP isn't stopped. */
+ if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
+ || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
+ {
+ struct regcache *regcache = get_thread_regcache (lp->ptid);
+ CORE_ADDR pc;
+ int discard = 0;
-static int
-running_callback (struct lwp_info *lp, void *data)
-{
- return (!lp->stopped
- || (lwp_status_pending_p (lp) && lp->resumed));
+ pc = regcache_read_pc (regcache);
+
+ if (pc != lp->stop_pc)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "SC: PC of %s changed. was=%s, now=%s\n",
+ target_pid_to_str (lp->ptid).c_str (),
+ paddress (target_gdbarch (), lp->stop_pc),
+ paddress (target_gdbarch (), pc));
+ discard = 1;
+ }
+
+#if !USE_SIGTRAP_SIGINFO
+ else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "SC: previous breakpoint of %s, at %s gone\n",
+ target_pid_to_str (lp->ptid).c_str (),
+ paddress (target_gdbarch (), lp->stop_pc));
+
+ discard = 1;
+ }
+#endif
+
+ if (discard)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "SC: pending event of %s cancelled.\n",
+ target_pid_to_str (lp->ptid).c_str ());
+
+ lp->status = 0;
+ linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
+ return 0;
+ }
+ }
+
+ return 1;
}
/* Count the LWP's that have had events. */
static int
-count_events_callback (struct lwp_info *lp, void *data)
+count_events_callback (struct lwp_info *lp, int *count)
{
- int *count = data;
-
gdb_assert (count != NULL);
- /* Count only resumed LWPs that have a SIGTRAP event pending. */
- if (lp->resumed && linux_nat_lp_status_is_event (lp))
+ /* Select only resumed LWPs that have an event pending. */
+ if (lp->resumed && lwp_status_pending_p (lp))
(*count)++;
return 0;
/* Select the LWP (if any) that is currently being single-stepped. */
static int
-select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
+select_singlestep_lwp_callback (struct lwp_info *lp)
{
if (lp->last_resume_kind == resume_step
&& lp->status != 0)
return lp->status != 0 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE;
}
-/* Select the Nth LWP that has had a SIGTRAP event. */
+/* Select the Nth LWP that has had an event. */
static int
-select_event_lwp_callback (struct lwp_info *lp, void *data)
+select_event_lwp_callback (struct lwp_info *lp, int *selector)
{
- int *selector = data;
-
gdb_assert (selector != NULL);
- /* Select only resumed LWPs that have a SIGTRAP event pending. */
- if (lp->resumed && linux_nat_lp_status_is_event (lp))
+ /* Select only resumed LWPs that have an event pending. */
+ if (lp->resumed && lwp_status_pending_p (lp))
if ((*selector)-- == 0)
return 1;
return 0;
}
-static int
-cancel_breakpoint (struct lwp_info *lp)
+/* Called when the LWP stopped for a signal/trap. If it stopped for a
+ trap check what caused it (breakpoint, watchpoint, trace, etc.),
+ and save the result in the LWP's stop_reason field. If it stopped
+ for a breakpoint, decrement the PC if necessary on the lwp's
+ architecture. */
+
+static void
+save_stop_reason (struct lwp_info *lp)
{
- /* 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
- LWP. We will handle the current event, eventually we will resume
- this LWP, and this breakpoint will trap again.
+ struct regcache *regcache;
+ struct gdbarch *gdbarch;
+ CORE_ADDR pc;
+ CORE_ADDR sw_bp_pc;
+#if USE_SIGTRAP_SIGINFO
+ siginfo_t siginfo;
+#endif
- 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
- tripped on it. */
+ gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
+ gdb_assert (lp->status != 0);
- struct regcache *regcache = get_thread_regcache (lp->ptid);
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
- CORE_ADDR pc;
+ if (!linux_target->low_status_is_event (lp->status))
+ return;
- pc = regcache_read_pc (regcache) - target_decr_pc_after_break (gdbarch);
- if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
- {
+ regcache = get_thread_regcache (lp->ptid);
+ gdbarch = regcache->arch ();
+
+ pc = regcache_read_pc (regcache);
+ sw_bp_pc = pc - gdbarch_decr_pc_after_break (gdbarch);
+
+#if USE_SIGTRAP_SIGINFO
+ if (linux_nat_get_siginfo (lp->ptid, &siginfo))
+ {
+ if (siginfo.si_signo == SIGTRAP)
+ {
+ if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
+ && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
+ {
+ /* The si_code is ambiguous on this arch -- check debug
+ registers. */
+ if (!check_stopped_by_watchpoint (lp))
+ lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
+ }
+ else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
+ {
+ /* If we determine the LWP stopped for a SW breakpoint,
+ trust it. Particularly don't check watchpoint
+ registers, because at least on s390, we'd find
+ stopped-by-watchpoint as long as there's a watchpoint
+ set. */
+ lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
+ }
+ else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
+ {
+ /* This can indicate either a hardware breakpoint or
+ hardware watchpoint. Check debug registers. */
+ if (!check_stopped_by_watchpoint (lp))
+ lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
+ }
+ else if (siginfo.si_code == TRAP_TRACE)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "CSBB: %s stopped by trace\n",
+ target_pid_to_str (lp->ptid).c_str ());
+
+ /* We may have single stepped an instruction that
+ triggered a watchpoint. In that case, on some
+ architectures (such as x86), instead of TRAP_HWBKPT,
+ si_code indicates TRAP_TRACE, and we need to check
+ the debug registers separately. */
+ check_stopped_by_watchpoint (lp);
+ }
+ }
+ }
+#else
+ if ((!lp->step || lp->stop_pc == sw_bp_pc)
+ && software_breakpoint_inserted_here_p (regcache->aspace (),
+ sw_bp_pc))
+ {
+ /* The LWP was either continued, or stepped a software
+ breakpoint instruction. */
+ lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
+ }
+
+ if (hardware_breakpoint_inserted_here_p (regcache->aspace (), pc))
+ lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
+
+ if (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON)
+ check_stopped_by_watchpoint (lp);
+#endif
+
+ if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
+ {
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
- "CB: Push back breakpoint for %s\n",
- target_pid_to_str (lp->ptid));
+ "CSBB: %s stopped by software breakpoint\n",
+ target_pid_to_str (lp->ptid).c_str ());
/* Back up the PC if necessary. */
- if (target_decr_pc_after_break (gdbarch))
- regcache_write_pc (regcache, pc);
+ if (pc != sw_bp_pc)
+ regcache_write_pc (regcache, sw_bp_pc);
- return 1;
+ /* Update this so we record the correct stop PC below. */
+ pc = sw_bp_pc;
}
- return 0;
+ else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "CSBB: %s stopped by hardware breakpoint\n",
+ target_pid_to_str (lp->ptid).c_str ());
+ }
+ else if (lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "CSBB: %s stopped by hardware watchpoint\n",
+ target_pid_to_str (lp->ptid).c_str ());
+ }
+
+ lp->stop_pc = pc;
}
-static int
-cancel_breakpoints_callback (struct lwp_info *lp, void *data)
+
+/* Returns true if the LWP had stopped for a software breakpoint. */
+
+bool
+linux_nat_target::stopped_by_sw_breakpoint ()
{
- struct lwp_info *event_lp = data;
+ struct lwp_info *lp = find_lwp_pid (inferior_ptid);
- /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
- if (lp == event_lp)
- return 0;
+ gdb_assert (lp != NULL);
+
+ return lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
+}
- /* 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),
- 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
- LWP. We will handle the current event, eventually we will resume
- all LWPs, and this one will get its breakpoint trap again.
+/* Implement the supports_stopped_by_sw_breakpoint method. */
- 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
- tripped on it. */
+bool
+linux_nat_target::supports_stopped_by_sw_breakpoint ()
+{
+ return USE_SIGTRAP_SIGINFO;
+}
- if (linux_nat_lp_status_is_event (lp)
- && cancel_breakpoint (lp))
- /* Throw away the SIGTRAP. */
- lp->status = 0;
+/* Returns true if the LWP had stopped for a hardware
+ breakpoint/watchpoint. */
- return 0;
+bool
+linux_nat_target::stopped_by_hw_breakpoint ()
+{
+ struct lwp_info *lp = find_lwp_pid (inferior_ptid);
+
+ gdb_assert (lp != NULL);
+
+ return lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
+}
+
+/* Implement the supports_stopped_by_hw_breakpoint method. */
+
+bool
+linux_nat_target::supports_stopped_by_hw_breakpoint ()
+{
+ return USE_SIGTRAP_SIGINFO;
}
/* Select one LWP out of those that have events pending. */
{
int num_events = 0;
int random_selector;
- struct lwp_info *event_lp;
+ struct lwp_info *event_lp = NULL;
/* Record the wait status for the original LWP. */
(*orig_lp)->status = *status;
- /* Give preference to any LWP that is being single-stepped. */
- event_lp = iterate_over_lwps (filter,
- select_singlestep_lwp_callback, NULL);
- if (event_lp != NULL)
+ /* In all-stop, give preference to the LWP that is being
+ single-stepped. There will be at most one, and it will be the
+ LWP that the core is most interested in. If we didn't do this,
+ then we'd have to handle pending step SIGTRAPs somehow in case
+ the core later continues the previously-stepped thread, as
+ otherwise we'd report the pending SIGTRAP then, and the core, not
+ having stepped the thread, wouldn't understand what the trap was
+ for, and therefore would report it to the user as a random
+ signal. */
+ if (!target_is_non_stop_p ())
{
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "SEL: Select single-step %s\n",
- target_pid_to_str (event_lp->ptid));
+ event_lp = iterate_over_lwps (filter, select_singlestep_lwp_callback);
+ if (event_lp != NULL)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "SEL: Select single-step %s\n",
+ target_pid_to_str (event_lp->ptid).c_str ());
+ }
}
- else
- {
- /* No single-stepping LWP. Select one at random, out of those
- which have had SIGTRAP events. */
-
- /* First see how many SIGTRAP events we have. */
- iterate_over_lwps (filter, count_events_callback, &num_events);
- /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
+ if (event_lp == NULL)
+ {
+ /* Pick one at random, out of those which have had events. */
+
+ /* First see how many events we have. */
+ iterate_over_lwps (filter,
+ [&] (struct lwp_info *info)
+ {
+ return count_events_callback (info, &num_events);
+ });
+ gdb_assert (num_events > 0);
+
+ /* Now randomly pick a LWP out of those that have had
+ events. */
random_selector = (int)
((num_events * (double) rand ()) / (RAND_MAX + 1.0));
if (debug_linux_nat && num_events > 1)
fprintf_unfiltered (gdb_stdlog,
- "SEL: Found %d SIGTRAP events, selecting #%d\n",
+ "SEL: Found %d events, selecting #%d\n",
num_events, random_selector);
- event_lp = iterate_over_lwps (filter,
- select_event_lwp_callback,
- &random_selector);
+ event_lp
+ = (iterate_over_lwps
+ (filter,
+ [&] (struct lwp_info *info)
+ {
+ return select_event_lwp_callback (info,
+ &random_selector);
+ }));
}
if (event_lp != NULL)
/* Return non-zero if LP has been resumed. */
static int
-resumed_callback (struct lwp_info *lp, void *data)
+resumed_callback (struct lwp_info *lp)
{
return lp->resumed;
}
-/* Stop an active thread, verify it still exists, then resume it. If
- the thread ends up with a pending status, then it is not resumed,
- and *DATA (really a pointer to int), is set. */
-
-static int
-stop_and_resume_callback (struct lwp_info *lp, void *data)
-{
- int *new_pending_p = data;
-
- if (!lp->stopped)
- {
- ptid_t ptid = lp->ptid;
-
- stop_callback (lp, NULL);
- stop_wait_callback (lp, NULL);
-
- /* Resume if the lwp still exists, and the core wanted it
- running. */
- lp = find_lwp_pid (ptid);
- if (lp != NULL)
- {
- if (lp->last_resume_kind == resume_stop
- && !lwp_status_pending_p (lp))
- {
- /* The core wanted the LWP to stop. Even if it stopped
- cleanly (with SIGSTOP), leave the event pending. */
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "SARC: core wanted LWP %ld stopped "
- "(leaving SIGSTOP pending)\n",
- ptid_get_lwp (lp->ptid));
- lp->status = W_STOPCODE (SIGSTOP);
- }
-
- if (!lwp_status_pending_p (lp))
- {
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "SARC: re-resuming LWP %ld\n",
- ptid_get_lwp (lp->ptid));
- resume_lwp (lp, lp->step, GDB_SIGNAL_0);
- }
- else
- {
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "SARC: not re-resuming LWP %ld "
- "(has pending)\n",
- ptid_get_lwp (lp->ptid));
- if (new_pending_p)
- *new_pending_p = 1;
- }
- }
- }
- return 0;
-}
-
/* Check if we should go on and pass this event to common code.
- Return the affected lwp if we are, or NULL otherwise. If we stop
- all lwps temporarily, we may end up with new pending events in some
- other lwp. In that case set *NEW_PENDING_P to true. */
+ Return the affected lwp if we are, or NULL otherwise. */
static struct lwp_info *
-linux_nat_filter_event (int lwpid, int status, int *new_pending_p)
+linux_nat_filter_event (int lwpid, int status)
{
struct lwp_info *lp;
int event = linux_ptrace_get_extended_event (status);
- *new_pending_p = 0;
-
- lp = find_lwp_pid (pid_to_ptid (lwpid));
+ lp = find_lwp_pid (ptid_t (lwpid));
/* Check for stop events reported by a process we didn't already
know about - anything not already in our LWP list.
"LLW: Re-adding thread group leader LWP %d.\n",
lwpid);
- lp = add_lwp (ptid_build (lwpid, lwpid, 0));
+ lp = add_lwp (ptid_t (lwpid, lwpid, 0));
lp->stopped = 1;
lp->resumed = 1;
add_thread (lp->ptid);
if (WIFSTOPPED (status) && !lp)
{
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "LHEW: saving LWP %ld status %s in stopped_pids list\n",
+ (long) lwpid, status_to_str (status));
add_to_pid_list (&stopped_pids, lwpid, status);
return NULL;
}
if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
{
- struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
+ struct inferior *inf = find_inferior_pid (lp->ptid.pid ());
+ int options = linux_nat_ptrace_options (inf->attach_flag);
- linux_enable_event_reporting (ptid_get_lwp (lp->ptid), inf->attach_flag);
+ linux_enable_event_reporting (lp->ptid.lwp (), options);
lp->must_set_ptrace_flags = 0;
}
if (linux_handle_syscall_trap (lp, 0))
return NULL;
}
+ else
+ {
+ /* Almost all other ptrace-stops are known to be outside of system
+ calls, with further exceptions in linux_handle_extended_wait. */
+ lp->syscall_state = TARGET_WAITKIND_IGNORE;
+ }
/* Handle GNU/Linux's extended waitstatus for trace events. */
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
fprintf_unfiltered (gdb_stdlog,
"LLW: Handling extended status 0x%06x\n",
status);
- if (linux_handle_extended_wait (lp, status, 0))
+ if (linux_handle_extended_wait (lp, status))
return NULL;
}
- if (linux_nat_status_is_event (status))
- save_sigtrap (lp);
-
/* Check if the thread has exited. */
- if ((WIFEXITED (status) || WIFSIGNALED (status))
- && num_lwps (ptid_get_pid (lp->ptid)) > 1)
+ if (WIFEXITED (status) || WIFSIGNALED (status))
{
- /* 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
- on Linux 2.4, there is no signal issued for exiting LWPs
- other than the main thread. We only get the main thread exit
- signal once all child threads have already exited. If we
- stop all the threads and use the stop_wait_callback to check
- if they have exited we can determine whether this signal
- should be ignored or whether it means the end of the debugged
- application, regardless of which threading model is being
- used. */
- if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
+ if (!report_thread_events
+ && num_lwps (lp->ptid.pid ()) > 1)
{
- iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
- stop_and_resume_callback, new_pending_p);
- }
-
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLW: %s exited.\n",
- target_pid_to_str (lp->ptid));
-
- if (num_lwps (ptid_get_pid (lp->ptid)) > 1)
- {
- /* If there is at least one more LWP, then the exit signal
- was not the end of the debugged application and should be
- ignored. */
- exit_lwp (lp);
- return NULL;
- }
- }
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "LLW: %s exited.\n",
+ target_pid_to_str (lp->ptid).c_str ());
- /* Check if the current LWP has previously exited. In the nptl
- thread model, LWPs other than the main thread do not issue
- signals when they exit so we must check whenever the thread has
- stopped. A similar check is made in stop_wait_callback(). */
- if (num_lwps (ptid_get_pid (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
- {
- ptid_t ptid = pid_to_ptid (ptid_get_pid (lp->ptid));
+ /* If there is at least one more LWP, then the exit signal
+ was not the end of the debugged application and should be
+ ignored. */
+ exit_lwp (lp);
+ return NULL;
+ }
+ /* Note that even if the leader was ptrace-stopped, it can still
+ exit, if e.g., some other thread brings down the whole
+ process (calls `exit'). So don't assert that the lwp is
+ resumed. */
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
- "LLW: %s exited.\n",
- target_pid_to_str (lp->ptid));
-
- exit_lwp (lp);
+ "LWP %ld exited (resumed=%d)\n",
+ lp->ptid.lwp (), lp->resumed);
- /* Make sure there is at least one thread running. */
- gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
+ /* Dead LWP's aren't expected to reported a pending sigstop. */
+ lp->signalled = 0;
- /* Discard the event. */
- return NULL;
+ /* Store the pending event in the waitstatus, because
+ W_EXITCODE(0,0) == 0. */
+ store_waitstatus (&lp->waitstatus, status);
+ return lp;
}
/* Make sure we don't report a SIGSTOP that we sent ourselves in
if (lp->signalled
&& WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
{
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLW: Delayed SIGSTOP caught for %s.\n",
- target_pid_to_str (lp->ptid));
-
lp->signalled = 0;
- if (lp->last_resume_kind != resume_stop)
+ if (lp->last_resume_kind == resume_stop)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "LLW: resume_stop SIGSTOP caught for %s.\n",
+ target_pid_to_str (lp->ptid).c_str ());
+ }
+ else
{
- /* This is a delayed SIGSTOP. */
+ /* This is a delayed SIGSTOP. Filter out the event. */
- linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
- "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
+ "LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
lp->step ?
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
+ linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
gdb_assert (lp->resumed);
-
- /* Discard the event. */
return NULL;
}
}
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LLW: Delayed SIGINT caught for %s.\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
/* This is a delayed SIGINT. */
lp->ignore_sigint = 0;
"LLW: %s %s, 0, 0 (discard SIGINT)\n",
lp->step ?
"PTRACE_SINGLESTEP" : "PTRACE_CONT",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
gdb_assert (lp->resumed);
/* Discard the event. */
return NULL;
}
+ /* Don't report signals that GDB isn't interested in, such as
+ signals that are neither printed nor stopped upon. Stopping all
+ threads can be a bit time-consuming so if we want decent
+ performance with heavily multi-threaded programs, especially when
+ they're using a high frequency timer, we'd better avoid it if we
+ can. */
+ if (WIFSTOPPED (status))
+ {
+ enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
+
+ if (!target_is_non_stop_p ())
+ {
+ /* Only do the below in all-stop, as we currently use SIGSTOP
+ to implement target_stop (see linux_nat_stop) in
+ non-stop. */
+ if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
+ {
+ /* If ^C/BREAK is typed at the tty/console, SIGINT gets
+ forwarded to the entire process group, that is, all LWPs
+ will receive it - unless they're using CLONE_THREAD to
+ share signals. Since we only want to report it once, we
+ mark it as ignored for all LWPs except this one. */
+ iterate_over_lwps (ptid_t (lp->ptid.pid ()), set_ignore_sigint);
+ lp->ignore_sigint = 0;
+ }
+ else
+ maybe_clear_ignore_sigint (lp);
+ }
+
+ /* When using hardware single-step, we need to report every signal.
+ Otherwise, signals in pass_mask may be short-circuited
+ except signals that might be caused by a breakpoint, or SIGSTOP
+ if we sent the SIGSTOP and are waiting for it to arrive. */
+ if (!lp->step
+ && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status))
+ && (WSTOPSIG (status) != SIGSTOP
+ || !find_thread_ptid (lp->ptid)->stop_requested)
+ && !linux_wstatus_maybe_breakpoint (status))
+ {
+ linux_resume_one_lwp (lp, lp->step, signo);
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "LLW: %s %s, %s (preempt 'handle')\n",
+ lp->step ?
+ "PTRACE_SINGLESTEP" : "PTRACE_CONT",
+ target_pid_to_str (lp->ptid).c_str (),
+ (signo != GDB_SIGNAL_0
+ ? strsignal (gdb_signal_to_host (signo))
+ : "0"));
+ return NULL;
+ }
+ }
+
/* An interesting event. */
gdb_assert (lp);
lp->status = status;
+ save_stop_reason (lp);
return lp;
}
static void
check_zombie_leaders (void)
{
- struct inferior *inf;
-
- ALL_INFERIORS (inf)
+ for (inferior *inf : all_inferiors ())
{
struct lwp_info *leader_lp;
if (inf->pid == 0)
continue;
- leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
+ leader_lp = find_lwp_pid (ptid_t (inf->pid));
if (leader_lp != NULL
/* Check if there are other threads in the group, as we may
have raced with the inferior simply exiting. */
leader's exit status until all other threads are gone.
- There are 3 or more threads in the group, and a thread
- other than the leader exec'd. On an exec, the Linux
- kernel destroys all other threads (except the execing
- one) in the thread group, and resets the execing thread's
- tid to the tgid. No exit notification is sent for the
- execing thread -- from the ptracer's perspective, it
- appears as though the execing thread just vanishes.
- Until we reap all other threads except the leader and the
- execing thread, the leader will be zombie, and the
- execing thread will be in `D (disc sleep)'. As soon as
- all other threads are reaped, the execing thread changes
- it's tid to the tgid, and the previous (zombie) leader
- vanishes, giving place to the "new" leader. We could try
+ other than the leader exec'd. See comments on exec
+ events at the top of the file. We could try
distinguishing the exit and exec cases, by waiting once
more, and seeing if something comes out, but it doesn't
sound useful. The previous leader _does_ go away, and
}
}
+/* Convenience function that is called when the kernel reports an exit
+ event. This decides whether to report the event to GDB as a
+ process exit event, a thread exit event, or to suppress the
+ event. */
+
static ptid_t
-linux_nat_wait_1 (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *ourstatus,
+filter_exit_event (struct lwp_info *event_child,
+ struct target_waitstatus *ourstatus)
+{
+ ptid_t ptid = event_child->ptid;
+
+ if (num_lwps (ptid.pid ()) > 1)
+ {
+ if (report_thread_events)
+ ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED;
+ else
+ ourstatus->kind = TARGET_WAITKIND_IGNORE;
+
+ exit_lwp (event_child);
+ }
+
+ return ptid;
+}
+
+static ptid_t
+linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus,
int target_options)
{
sigset_t prev_mask;
/* 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
moment at which we know its PID. */
- if (ptid_is_pid (inferior_ptid))
+ if (inferior_ptid.is_pid ())
{
/* Upgrade the main thread's ptid. */
thread_change_ptid (inferior_ptid,
- ptid_build (ptid_get_pid (inferior_ptid),
- ptid_get_pid (inferior_ptid), 0));
+ ptid_t (inferior_ptid.pid (),
+ inferior_ptid.pid (), 0));
lp = add_initial_lwp (inferior_ptid);
lp->resumed = 1;
/* Make sure SIGCHLD is blocked until the sigsuspend below. */
block_child_signals (&prev_mask);
-retry:
- status = 0;
-
/* First check if there is a LWP with a wait status pending. */
- lp = iterate_over_lwps (ptid, status_callback, NULL);
+ lp = iterate_over_lwps (ptid, status_callback);
if (lp != NULL)
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LLW: Using pending wait status %s for %s.\n",
status_to_str (lp->status),
- target_pid_to_str (lp->ptid));
- }
-
- if (!target_can_async_p ())
- {
- /* Causes SIGINT to be passed on to the attached process. */
- set_sigint_trap ();
+ target_pid_to_str (lp->ptid).c_str ());
}
- /* But if we don't find a pending event, we'll have to wait. */
+ /* But if we don't find a pending event, we'll have to wait. Always
+ pull all events out of the kernel. We'll randomly select an
+ event LWP out of all that have events, to prevent starvation. */
while (lp == NULL)
{
- If the thread group leader exits while other threads in the
thread group still exist, waitpid(TGID, ...) hangs. That
waitpid won't return an exit status until the other threads
- in the group are reapped.
+ in the group are reaped.
- When a non-leader thread execs, that thread just vanishes
without reporting an exit (so we'd hang if we waited for it
the TGID pid. */
errno = 0;
- lwpid = my_waitpid (-1, &status, __WCLONE | WNOHANG);
- if (lwpid == 0 || (lwpid == -1 && errno == ECHILD))
- lwpid = my_waitpid (-1, &status, WNOHANG);
+ lwpid = my_waitpid (-1, &status, __WALL | WNOHANG);
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
if (lwpid > 0)
{
- /* If this is true, then we paused LWPs momentarily, and may
- now have pending events to handle. */
- int new_pending;
-
if (debug_linux_nat)
{
fprintf_unfiltered (gdb_stdlog,
(long) lwpid, status_to_str (status));
}
- lp = linux_nat_filter_event (lwpid, status, &new_pending);
-
- /* STATUS is now no longer valid, use LP->STATUS instead. */
- status = 0;
-
- if (lp && !ptid_match (lp->ptid, ptid))
- {
- gdb_assert (lp->resumed);
-
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LWP %ld got an event %06x, "
- "leaving pending.\n",
- ptid_get_lwp (lp->ptid), lp->status);
-
- if (WIFSTOPPED (lp->status))
- {
- if (WSTOPSIG (lp->status) != SIGSTOP)
- {
- /* Cancel breakpoint hits. The breakpoint may
- be removed before we fetch events from this
- process to report to the core. It is best
- not to assume the moribund breakpoints
- heuristic always handles these cases --- it
- could be too many events go through to the
- core before this one is handled. All-stop
- always cancels breakpoint hits in all
- threads. */
- if (non_stop
- && linux_nat_lp_status_is_event (lp)
- && cancel_breakpoint (lp))
- {
- /* Throw away the SIGTRAP. */
- lp->status = 0;
-
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLW: LWP %ld hit a "
- "breakpoint while "
- "waiting for another "
- "process; "
- "cancelled it\n",
- ptid_get_lwp (lp->ptid));
- }
- }
- else
- lp->signalled = 0;
- }
- else if (WIFEXITED (lp->status) || WIFSIGNALED (lp->status))
- {
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "Process %ld exited while stopping "
- "LWPs\n",
- ptid_get_lwp (lp->ptid));
-
- /* This was the last lwp in the process. Since
- events are serialized to GDB core, and we can't
- report this one right now, but GDB core and the
- other target layers will want to be notified
- about the exit code/signal, leave the status
- pending for the next time we're able to report
- it. */
-
- /* Dead LWP's aren't expected to reported a pending
- sigstop. */
- lp->signalled = 0;
-
- /* Store the pending event in the waitstatus as
- well, because W_EXITCODE(0,0) == 0. */
- store_waitstatus (&lp->waitstatus, lp->status);
- }
-
- /* Keep looking. */
- lp = NULL;
- }
-
- if (new_pending)
- {
- /* Some LWP now has a pending event. Go all the way
- back to check it. */
- goto retry;
- }
-
- if (lp)
- {
- /* We got an event to report to the core. */
- break;
- }
-
+ linux_nat_filter_event (lwpid, status);
/* Retry until nothing comes out of waitpid. A single
SIGCHLD can indicate more than one child stopped. */
continue;
}
+ /* Now that we've pulled all events out of the kernel, resume
+ LWPs that don't have an interesting event to report. */
+ iterate_over_lwps (minus_one_ptid,
+ [] (struct lwp_info *info)
+ {
+ return resume_stopped_resumed_lwps (info, minus_one_ptid);
+ });
+
+ /* ... and find an LWP with a status to report to the core, if
+ any. */
+ lp = iterate_over_lwps (ptid, status_callback);
+ if (lp != NULL)
+ break;
+
/* Check for zombie thread group leaders. Those can't be reaped
until all other threads in the thread group are. */
check_zombie_leaders ();
/* If there are no resumed children left, bail. We'd be stuck
forever in the sigsuspend call below otherwise. */
- if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
+ if (iterate_over_lwps (ptid, resumed_callback) == NULL)
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
- if (!target_can_async_p ())
- clear_sigint_trap ();
-
restore_child_signals_mask (&prev_mask);
return minus_one_ptid;
}
gdb_assert (lp == NULL);
/* Block until we get an event reported with SIGCHLD. */
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog, "LNW: about to sigsuspend\n");
- sigsuspend (&suspend_mask);
+ wait_for_signal ();
}
- if (!target_can_async_p ())
- clear_sigint_trap ();
-
gdb_assert (lp);
status = lp->status;
lp->status = 0;
- /* Don't report signals that GDB isn't interested in, such as
- signals that are neither printed nor stopped upon. Stopping all
- threads can be a bit time-consuming so if we want decent
- performance with heavily multi-threaded programs, especially when
- they're using a high frequency timer, we'd better avoid it if we
- can. */
+ if (!target_is_non_stop_p ())
+ {
+ /* Now stop all other LWP's ... */
+ iterate_over_lwps (minus_one_ptid, stop_callback);
- if (WIFSTOPPED (status))
+ /* ... and wait until all of them have reported back that
+ they're no longer running. */
+ iterate_over_lwps (minus_one_ptid, stop_wait_callback);
+ }
+
+ /* If we're not waiting for a specific LWP, choose an event LWP from
+ among those that have had events. Giving equal priority to all
+ LWPs that have had events helps prevent starvation. */
+ if (ptid == minus_one_ptid || ptid.is_pid ())
+ select_event_lwp (ptid, &lp, &status);
+
+ gdb_assert (lp != NULL);
+
+ /* Now that we've selected our final event LWP, un-adjust its PC if
+ it was a software breakpoint, and we can't reliably support the
+ "stopped by software breakpoint" stop reason. */
+ if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
+ && !USE_SIGTRAP_SIGINFO)
{
- enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
+ struct regcache *regcache = get_thread_regcache (lp->ptid);
+ struct gdbarch *gdbarch = regcache->arch ();
+ int decr_pc = gdbarch_decr_pc_after_break (gdbarch);
- /* When using hardware single-step, we need to report every signal.
- Otherwise, signals in pass_mask may be short-circuited. */
- if (!lp->step
- && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
+ if (decr_pc != 0)
{
- /* FIMXE: kettenis/2001-06-06: Should we resume all threads
- here? It is not clear we should. GDB may not expect
- other threads to run. On the other hand, not resuming
- newly attached threads may cause an unwanted delay in
- getting them running. */
- linux_resume_one_lwp (lp, lp->step, signo);
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLW: %s %s, %s (preempt 'handle')\n",
- lp->step ?
- "PTRACE_SINGLESTEP" : "PTRACE_CONT",
- target_pid_to_str (lp->ptid),
- (signo != GDB_SIGNAL_0
- ? strsignal (gdb_signal_to_host (signo))
- : "0"));
- goto retry;
- }
+ CORE_ADDR pc;
- if (!non_stop)
- {
- /* Only do the below in all-stop, as we currently use SIGINT
- to implement target_stop (see linux_nat_stop) in
- non-stop. */
- if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
- {
- /* If ^C/BREAK is typed at the tty/console, SIGINT gets
- forwarded to the entire process group, that is, all LWPs
- will receive it - unless they're using CLONE_THREAD to
- share signals. Since we only want to report it once, we
- mark it as ignored for all LWPs except this one. */
- iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
- set_ignore_sigint, NULL);
- lp->ignore_sigint = 0;
- }
- else
- maybe_clear_ignore_sigint (lp);
+ pc = regcache_read_pc (regcache);
+ regcache_write_pc (regcache, pc + decr_pc);
}
}
- /* This LWP is stopped now. */
- lp->stopped = 1;
-
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
- status_to_str (status), target_pid_to_str (lp->ptid));
+ /* We'll need this to determine whether to report a SIGSTOP as
+ GDB_SIGNAL_0. Need to take a copy because resume_clear_callback
+ clears it. */
+ last_resume_kind = lp->last_resume_kind;
- if (!non_stop)
+ if (!target_is_non_stop_p ())
{
- /* Now stop all other LWP's ... */
- iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
-
- /* ... and wait until all of them have reported back that
- they're no longer running. */
- iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
-
- /* If we're not waiting for a specific LWP, choose an event LWP
- from among those that have had events. Giving equal priority
- to all LWPs that have had events helps prevent
- starvation. */
- if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
- select_event_lwp (ptid, &lp, &status);
-
- /* Now that we've selected our final event LWP, cancel any
- breakpoints in other LWPs that have hit a GDB breakpoint.
- See the comment in cancel_breakpoints_callback to find out
- why. */
- iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
-
- /* We'll need this to determine whether to report a SIGSTOP as
- TARGET_WAITKIND_0. Need to take a copy because
- resume_clear_callback clears it. */
- last_resume_kind = lp->last_resume_kind;
-
/* In all-stop, from the core's perspective, all LWPs are now
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);
}
else
{
- /* See above. */
- last_resume_kind = lp->last_resume_kind;
- resume_clear_callback (lp, NULL);
+ resume_clear_callback (lp);
}
- if (linux_nat_status_is_event (status))
+ if (linux_target->low_status_is_event (status))
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LLW: trap ptid is %s.\n",
- target_pid_to_str (lp->ptid));
+ target_pid_to_str (lp->ptid).c_str ());
}
if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
else
lp->core = linux_common_core_of_thread (lp->ptid);
+ if (ourstatus->kind == TARGET_WAITKIND_EXITED)
+ return filter_exit_event (lp, ourstatus);
+
return lp->ptid;
}
to report, but are resumed from the core's perspective. */
static int
-resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
+resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid)
{
- ptid_t *wait_ptid_p = data;
-
- if (lp->stopped
- && lp->resumed
- && !lwp_status_pending_p (lp))
+ if (!lp->stopped)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "RSRL: NOT resuming LWP %s, not stopped\n",
+ target_pid_to_str (lp->ptid).c_str ());
+ }
+ else if (!lp->resumed)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "RSRL: NOT resuming LWP %s, not resumed\n",
+ target_pid_to_str (lp->ptid).c_str ());
+ }
+ else if (lwp_status_pending_p (lp))
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "RSRL: NOT resuming LWP %s, has pending status\n",
+ target_pid_to_str (lp->ptid).c_str ());
+ }
+ else
{
struct regcache *regcache = get_thread_regcache (lp->ptid);
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
- CORE_ADDR pc = regcache_read_pc (regcache);
-
- gdb_assert (is_executing (lp->ptid));
+ struct gdbarch *gdbarch = regcache->arch ();
- /* Don't bother if there's a breakpoint at PC that we'd hit
- immediately, and we're not waiting for this LWP. */
- if (!ptid_match (lp->ptid, *wait_ptid_p))
+ try
{
- if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
- return 0;
- }
+ CORE_ADDR pc = regcache_read_pc (regcache);
+ int leave_stopped = 0;
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
- target_pid_to_str (lp->ptid),
- paddress (gdbarch, pc),
- lp->step);
+ /* Don't bother if there's a breakpoint at PC that we'd hit
+ immediately, and we're not waiting for this LWP. */
+ if (!lp->ptid.matches (wait_ptid))
+ {
+ if (breakpoint_inserted_here_p (regcache->aspace (), pc))
+ leave_stopped = 1;
+ }
- linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
+ if (!leave_stopped)
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog,
+ "RSRL: resuming stopped-resumed LWP %s at "
+ "%s: step=%d\n",
+ target_pid_to_str (lp->ptid).c_str (),
+ paddress (gdbarch, pc),
+ lp->step);
+
+ linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0);
+ }
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ if (!check_ptrace_stopped_lwp_gone (lp))
+ throw;
+ }
}
return 0;
}
-static ptid_t
-linux_nat_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *ourstatus,
- int target_options)
+ptid_t
+linux_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ int target_options)
{
ptid_t event_ptid;
if (debug_linux_nat)
{
- char *options_string;
-
- options_string = target_options_to_string (target_options);
+ std::string options_string = target_options_to_string (target_options);
fprintf_unfiltered (gdb_stdlog,
"linux_nat_wait: [%s], [%s]\n",
- target_pid_to_str (ptid),
- options_string);
- xfree (options_string);
+ target_pid_to_str (ptid).c_str (),
+ options_string.c_str ());
}
/* Flush the async file first. */
- if (target_can_async_p ())
+ if (target_is_async_p ())
async_file_flush ();
/* Resume LWPs that are currently stopped without any pending status
specific_process, for example, see linux_nat_wait_1), and
meanwhile the event became uninteresting. Don't bother resuming
LWPs we're not going to wait for if they'd stop immediately. */
- if (non_stop)
- iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
+ if (target_is_non_stop_p ())
+ iterate_over_lwps (minus_one_ptid,
+ [=] (struct lwp_info *info)
+ {
+ return resume_stopped_resumed_lwps (info, ptid);
+ });
- event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
+ event_ptid = linux_nat_wait_1 (ptid, ourstatus, target_options);
/* If we requested any event, and something came out, assume there
may be more. If we requested a specific lwp or process, also
assume there may be more. */
- if (target_can_async_p ()
+ if (target_is_async_p ()
&& ((ourstatus->kind != TARGET_WAITKIND_IGNORE
&& ourstatus->kind != TARGET_WAITKIND_NO_RESUMED)
- || !ptid_equal (ptid, minus_one_ptid)))
+ || ptid != minus_one_ptid))
async_file_mark ();
- /* Get ready for the next event. */
- if (target_can_async_p ())
- target_async (inferior_event_handler, 0);
-
return event_ptid;
}
-static int
-kill_callback (struct lwp_info *lp, void *data)
+/* Kill one LWP. */
+
+static void
+kill_one_lwp (pid_t pid)
{
/* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
errno = 0;
- kill_lwp (ptid_get_lwp (lp->ptid), SIGKILL);
+ kill_lwp (pid, SIGKILL);
if (debug_linux_nat)
{
int save_errno = errno;
fprintf_unfiltered (gdb_stdlog,
- "KC: kill (SIGKILL) %s, 0, 0 (%s)\n",
- target_pid_to_str (lp->ptid),
+ "KC: kill (SIGKILL) %ld, 0, 0 (%s)\n", (long) pid,
save_errno ? safe_strerror (save_errno) : "OK");
}
/* Some kernels ignore even SIGKILL for processes under ptrace. */
errno = 0;
- ptrace (PTRACE_KILL, ptid_get_lwp (lp->ptid), 0, 0);
+ ptrace (PTRACE_KILL, pid, 0, 0);
if (debug_linux_nat)
{
int save_errno = errno;
fprintf_unfiltered (gdb_stdlog,
- "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
- target_pid_to_str (lp->ptid),
+ "KC: PTRACE_KILL %ld, 0, 0 (%s)\n", (long) pid,
save_errno ? safe_strerror (save_errno) : "OK");
}
-
- return 0;
}
-static int
-kill_wait_callback (struct lwp_info *lp, void *data)
+/* Wait for an LWP to die. */
+
+static void
+kill_wait_one_lwp (pid_t pid)
{
- pid_t pid;
+ pid_t res;
/* We must make sure that there are no pending events (delayed
SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
program doesn't interfere with any following debugging session. */
- /* For cloned processes we must check both with __WCLONE and
- without, since the exit status of a cloned process isn't reported
- with __WCLONE. */
- if (lp->cloned)
- {
- do
- {
- pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, __WCLONE);
- if (pid != (pid_t) -1)
- {
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "KWC: wait %s received unknown.\n",
- target_pid_to_str (lp->ptid));
- /* The Linux kernel sometimes fails to kill a thread
- completely after PTRACE_KILL; that goes from the stop
- point in do_fork out to the one in
- get_signal_to_deliever and waits again. So kill it
- again. */
- kill_callback (lp, NULL);
- }
- }
- while (pid == ptid_get_lwp (lp->ptid));
-
- gdb_assert (pid == -1 && errno == ECHILD);
- }
-
do
{
- pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, 0);
- if (pid != (pid_t) -1)
+ res = my_waitpid (pid, NULL, __WALL);
+ if (res != (pid_t) -1)
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
- "KWC: wait %s received unk.\n",
- target_pid_to_str (lp->ptid));
- /* See the call to kill_callback above. */
- kill_callback (lp, NULL);
+ "KWC: wait %ld received unknown.\n",
+ (long) pid);
+ /* The Linux kernel sometimes fails to kill a thread
+ completely after PTRACE_KILL; that goes from the stop
+ point in do_fork out to the one in get_signal_to_deliver
+ and waits again. So kill it again. */
+ kill_one_lwp (pid);
}
}
- while (pid == ptid_get_lwp (lp->ptid));
+ while (res == pid);
- gdb_assert (pid == -1 && errno == ECHILD);
- return 0;
+ gdb_assert (res == -1 && errno == ECHILD);
}
-static void
-linux_nat_kill (struct target_ops *ops)
+/* Callback for iterate_over_lwps. */
+
+static int
+kill_callback (struct lwp_info *lp)
{
- struct target_waitstatus last;
- ptid_t last_ptid;
- int status;
+ kill_one_lwp (lp->ptid.lwp ());
+ return 0;
+}
- /* If we're stopped while forking and we haven't followed yet,
- kill the other task. We need to do this first because the
- parent will be sleeping if this is a vfork. */
+/* Callback for iterate_over_lwps. */
+
+static int
+kill_wait_callback (struct lwp_info *lp)
+{
+ kill_wait_one_lwp (lp->ptid.lwp ());
+ return 0;
+}
- get_last_target_status (&last_ptid, &last);
+/* Kill the fork children of any threads of inferior INF that are
+ stopped at a fork event. */
- if (last.kind == TARGET_WAITKIND_FORKED
- || last.kind == TARGET_WAITKIND_VFORKED)
+static void
+kill_unfollowed_fork_children (struct inferior *inf)
+{
+ for (thread_info *thread : inf->non_exited_threads ())
{
- ptrace (PT_KILL, ptid_get_pid (last.value.related_pid), 0, 0);
- wait (&status);
+ struct target_waitstatus *ws = &thread->pending_follow;
+
+ if (ws->kind == TARGET_WAITKIND_FORKED
+ || ws->kind == TARGET_WAITKIND_VFORKED)
+ {
+ ptid_t child_ptid = ws->value.related_pid;
+ int child_pid = child_ptid.pid ();
+ int child_lwp = child_ptid.lwp ();
- /* Let the arch-specific native code know this process is
- gone. */
- linux_nat_forget_process (ptid_get_pid (last.value.related_pid));
+ kill_one_lwp (child_lwp);
+ kill_wait_one_lwp (child_lwp);
+
+ /* Let the arch-specific native code know this process is
+ gone. */
+ linux_target->low_forget_process (child_pid);
+ }
}
+}
+
+void
+linux_nat_target::kill ()
+{
+ /* If we're stopped while forking and we haven't followed yet,
+ kill the other task. We need to do this first because the
+ parent will be sleeping if this is a vfork. */
+ kill_unfollowed_fork_children (current_inferior ());
if (forks_exist_p ())
linux_fork_killall ();
else
{
- ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
+ ptid_t ptid = ptid_t (inferior_ptid.pid ());
/* Stop all threads before killing them, since ptrace requires
- that the thread is stopped to sucessfully PTRACE_KILL. */
- iterate_over_lwps (ptid, stop_callback, NULL);
+ that the thread is stopped to successfully PTRACE_KILL. */
+ iterate_over_lwps (ptid, stop_callback);
/* ... and wait until all of them have reported back that
they're no longer running. */
- iterate_over_lwps (ptid, stop_wait_callback, NULL);
+ iterate_over_lwps (ptid, stop_wait_callback);
/* Kill all LWP's ... */
- iterate_over_lwps (ptid, kill_callback, NULL);
+ iterate_over_lwps (ptid, kill_callback);
/* ... and wait until we've flushed all events. */
- iterate_over_lwps (ptid, kill_wait_callback, NULL);
+ iterate_over_lwps (ptid, kill_wait_callback);
}
- target_mourn_inferior ();
+ target_mourn_inferior (inferior_ptid);
}
-static void
-linux_nat_mourn_inferior (struct target_ops *ops)
+void
+linux_nat_target::mourn_inferior ()
{
- int pid = ptid_get_pid (inferior_ptid);
+ int pid = inferior_ptid.pid ();
purge_lwp_list (pid);
if (! forks_exist_p ())
/* Normal case, no other forks available. */
- linux_ops->to_mourn_inferior (ops);
+ inf_ptrace_target::mourn_inferior ();
else
/* Multi-fork case. The current inferior_ptid has exited, but
there are other viable forks to debug. Delete the exiting
linux_fork_mourn_inferior ();
/* Let the arch-specific native code know this process is gone. */
- linux_nat_forget_process (pid);
+ linux_target->low_forget_process (pid);
}
/* Convert a native/host siginfo object, into/from the siginfo in the
static void
siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
{
- int done = 0;
-
- if (linux_nat_siginfo_fixup != NULL)
- done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
-
- /* If there was no callback, or the callback didn't do anything,
- then just do a straight memcpy. */
- if (!done)
+ /* If the low target didn't do anything, then just do a straight
+ memcpy. */
+ if (!linux_target->low_siginfo_fixup (siginfo, inf_siginfo, direction))
{
if (direction == 1)
memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
}
static enum target_xfer_status
-linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
+linux_xfer_siginfo (enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len)
gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
gdb_assert (readbuf || writebuf);
- pid = ptid_get_lwp (inferior_ptid);
+ pid = inferior_ptid.lwp ();
if (pid == 0)
- pid = ptid_get_pid (inferior_ptid);
+ pid = inferior_ptid.pid ();
if (offset > sizeof (siginfo))
return TARGET_XFER_E_IO;
}
static enum target_xfer_status
-linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf,
- ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+linux_nat_xfer_osdata (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len);
+
+static enum target_xfer_status
+linux_proc_xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len, ULONGEST *xfered_len);
+
+enum target_xfer_status
+linux_nat_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
- struct cleanup *old_chain;
enum target_xfer_status xfer;
if (object == TARGET_OBJECT_SIGNAL_INFO)
- return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
+ return linux_xfer_siginfo (object, annex, readbuf, writebuf,
offset, len, xfered_len);
/* The target is connected but no live inferior is selected. Pass
this request down to a lower stratum (e.g., the executable
file). */
- if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
+ if (object == TARGET_OBJECT_MEMORY && inferior_ptid == null_ptid)
return TARGET_XFER_EOF;
- old_chain = save_inferior_ptid ();
-
- if (ptid_lwp_p (inferior_ptid))
- inferior_ptid = pid_to_ptid (ptid_get_lwp (inferior_ptid));
-
- xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
- offset, len, xfered_len);
+ if (object == TARGET_OBJECT_AUXV)
+ return memory_xfer_auxv (this, object, annex, readbuf, writebuf,
+ offset, len, xfered_len);
- do_cleanups (old_chain);
- return xfer;
-}
+ if (object == TARGET_OBJECT_OSDATA)
+ return linux_nat_xfer_osdata (object, annex, readbuf, writebuf,
+ offset, len, xfered_len);
-static int
-linux_thread_alive (ptid_t ptid)
-{
- int err, tmp_errno;
+ /* GDB calculates all addresses in the largest possible address
+ width.
+ The address width must be masked before its final use - either by
+ linux_proc_xfer_partial or inf_ptrace_target::xfer_partial.
- gdb_assert (ptid_lwp_p (ptid));
+ Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
- /* Send signal 0 instead of anything ptrace, because ptracing a
- running thread errors out claiming that the thread doesn't
- exist. */
- err = kill_lwp (ptid_get_lwp (ptid), 0);
- tmp_errno = errno;
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLTA: KILL(SIG0) %s (%s)\n",
- target_pid_to_str (ptid),
- err ? safe_strerror (tmp_errno) : "OK");
+ if (object == TARGET_OBJECT_MEMORY)
+ {
+ int addr_bit = gdbarch_addr_bit (target_gdbarch ());
- if (err != 0)
- return 0;
+ if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
+ offset &= ((ULONGEST) 1 << addr_bit) - 1;
+ }
- return 1;
+ xfer = linux_proc_xfer_partial (object, annex, readbuf, writebuf,
+ offset, len, xfered_len);
+ if (xfer != TARGET_XFER_EOF)
+ return xfer;
+
+ return inf_ptrace_target::xfer_partial (object, annex, readbuf, writebuf,
+ offset, len, xfered_len);
}
-static int
-linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+linux_nat_target::thread_alive (ptid_t ptid)
{
- return linux_thread_alive (ptid);
+ /* As long as a PTID is in lwp list, consider it alive. */
+ return find_lwp_pid (ptid) != NULL;
}
-static char *
-linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
+/* Implement the to_update_thread_list target method for this
+ target. */
+
+void
+linux_nat_target::update_thread_list ()
{
- static char buf[64];
+ struct lwp_info *lwp;
+
+ /* We add/delete threads from the list as clone/exit events are
+ processed, so just try deleting exited threads still in the
+ thread list. */
+ delete_exited_threads ();
- if (ptid_lwp_p (ptid)
- && (ptid_get_pid (ptid) != ptid_get_lwp (ptid)
- || num_lwps (ptid_get_pid (ptid)) > 1))
+ /* Update the processor core that each lwp/thread was last seen
+ running on. */
+ ALL_LWPS (lwp)
{
- snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
- return buf;
+ /* Avoid accessing /proc if the thread hasn't run since we last
+ time we fetched the thread's core. Accessing /proc becomes
+ noticeably expensive when we have thousands of LWPs. */
+ if (lwp->core == -1)
+ lwp->core = linux_common_core_of_thread (lwp->ptid);
}
-
- return normal_pid_to_str (ptid);
}
-static char *
-linux_nat_thread_name (struct target_ops *self, struct thread_info *thr)
+std::string
+linux_nat_target::pid_to_str (ptid_t ptid)
{
- int pid = ptid_get_pid (thr->ptid);
- long lwp = ptid_get_lwp (thr->ptid);
-#define FORMAT "/proc/%d/task/%ld/comm"
- char buf[sizeof (FORMAT) + 30];
- FILE *comm_file;
- char *result = NULL;
+ if (ptid.lwp_p ()
+ && (ptid.pid () != ptid.lwp ()
+ || num_lwps (ptid.pid ()) > 1))
+ return string_printf ("LWP %ld", ptid.lwp ());
- snprintf (buf, sizeof (buf), FORMAT, pid, lwp);
- comm_file = gdb_fopen_cloexec (buf, "r");
- if (comm_file)
- {
- /* Not exported by the kernel, so we define it here. */
-#define COMM_LEN 16
- static char line[COMM_LEN + 1];
-
- if (fgets (line, sizeof (line), comm_file))
- {
- char *nl = strchr (line, '\n');
-
- if (nl)
- *nl = '\0';
- if (*line != '\0')
- result = line;
- }
-
- fclose (comm_file);
- }
-
-#undef COMM_LEN
-#undef FORMAT
+ return normal_pid_to_str (ptid);
+}
- return result;
+const char *
+linux_nat_target::thread_name (struct thread_info *thr)
+{
+ return linux_proc_tid_get_name (thr->ptid);
}
/* Accepts an integer PID; Returns a string representing a file that
can be opened to get the symbols for the child process. */
-static char *
-linux_child_pid_to_exec_file (struct target_ops *self, int pid)
+char *
+linux_nat_target::pid_to_exec_file (int pid)
{
- static char buf[PATH_MAX];
- char name[PATH_MAX];
-
- xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
- memset (buf, 0, PATH_MAX);
- if (readlink (name, buf, PATH_MAX - 1) <= 0)
- strcpy (buf, name);
-
- return buf;
+ return linux_proc_pid_to_exec_file (pid);
}
-/* Implement the to_xfer_partial interface for memory reads using the /proc
- filesystem. Because we can use a single read() call for /proc, this
- can be much more efficient than banging away at PTRACE_PEEKTEXT,
- but it doesn't support writes. */
+/* Implement the to_xfer_partial target method using /proc/<pid>/mem.
+ Because we can use a single read/write call, this can be much more
+ efficient than banging away at PTRACE_PEEKTEXT. */
static enum target_xfer_status
-linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
+linux_proc_xfer_partial (enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf,
ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
int fd;
char filename[64];
- if (object != TARGET_OBJECT_MEMORY || !readbuf)
- return 0;
+ if (object != TARGET_OBJECT_MEMORY)
+ return TARGET_XFER_EOF;
/* Don't bother for one word. */
if (len < 3 * sizeof (long))
/* We could keep this file open and cache it - possibly one per
thread. That requires some juggling, but is even faster. */
- xsnprintf (filename, sizeof filename, "/proc/%d/mem",
- ptid_get_pid (inferior_ptid));
- fd = gdb_open_cloexec (filename, O_RDONLY | O_LARGEFILE, 0);
+ xsnprintf (filename, sizeof filename, "/proc/%ld/mem",
+ inferior_ptid.lwp ());
+ fd = gdb_open_cloexec (filename, ((readbuf ? O_RDONLY : O_WRONLY)
+ | O_LARGEFILE), 0);
if (fd == -1)
return TARGET_XFER_EOF;
- /* 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
- 32-bit platforms (for instance, SPARC debugging a SPARC64
- application). */
+ /* Use pread64/pwrite64 if available, since they save a syscall and can
+ handle 64-bit offsets even on 32-bit platforms (for instance, SPARC
+ debugging a SPARC64 application). */
#ifdef HAVE_PREAD64
- if (pread64 (fd, readbuf, len, offset) != len)
+ ret = (readbuf ? pread64 (fd, readbuf, len, offset)
+ : pwrite64 (fd, writebuf, len, offset));
#else
- if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
+ ret = lseek (fd, offset, SEEK_SET);
+ if (ret != -1)
+ ret = (readbuf ? read (fd, readbuf, len)
+ : write (fd, writebuf, len));
#endif
- ret = 0;
- else
- ret = len;
close (fd);
- if (ret == 0)
+ if (ret == -1 || ret == 0)
return TARGET_XFER_EOF;
else
{
}
-/* Enumerate spufs IDs for process PID. */
-static LONGEST
-spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len)
-{
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
- LONGEST pos = 0;
- LONGEST written = 0;
- char path[128];
- DIR *dir;
- struct dirent *entry;
-
- xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
- dir = opendir (path);
- if (!dir)
- return -1;
-
- rewinddir (dir);
- while ((entry = readdir (dir)) != NULL)
- {
- struct stat st;
- struct statfs stfs;
- int fd;
-
- fd = atoi (entry->d_name);
- if (!fd)
- continue;
-
- xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
- if (stat (path, &st) != 0)
- continue;
- if (!S_ISDIR (st.st_mode))
- continue;
-
- if (statfs (path, &stfs) != 0)
- continue;
- if (stfs.f_type != SPUFS_MAGIC)
- continue;
-
- if (pos >= offset && pos + 4 <= offset + len)
- {
- store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
- written += 4;
- }
- pos += 4;
- }
-
- closedir (dir);
- return written;
-}
-
-/* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
- object type, using the /proc file system. */
-
-static enum target_xfer_status
-linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf,
- ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
-{
- char buf[128];
- int fd = 0;
- int ret = -1;
- int pid = ptid_get_pid (inferior_ptid);
-
- if (!annex)
- {
- if (!readbuf)
- return TARGET_XFER_E_IO;
- else
- {
- LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len);
-
- if (l < 0)
- return TARGET_XFER_E_IO;
- else if (l == 0)
- return TARGET_XFER_EOF;
- else
- {
- *xfered_len = (ULONGEST) l;
- return TARGET_XFER_OK;
- }
- }
- }
-
- xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
- fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0);
- if (fd <= 0)
- return TARGET_XFER_E_IO;
-
- if (offset != 0
- && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
- {
- close (fd);
- return TARGET_XFER_EOF;
- }
-
- if (writebuf)
- ret = write (fd, writebuf, (size_t) len);
- else if (readbuf)
- ret = read (fd, readbuf, (size_t) len);
-
- close (fd);
-
- if (ret < 0)
- return TARGET_XFER_E_IO;
- else if (ret == 0)
- return TARGET_XFER_EOF;
- else
- {
- *xfered_len = (ULONGEST) ret;
- return TARGET_XFER_OK;
- }
-}
-
-
/* Parse LINE as a signal set and add its set bits to SIGS. */
static void
linux_proc_pending_signals (int pid, sigset_t *pending,
sigset_t *blocked, sigset_t *ignored)
{
- FILE *procfile;
char buffer[PATH_MAX], fname[PATH_MAX];
- struct cleanup *cleanup;
sigemptyset (pending);
sigemptyset (blocked);
sigemptyset (ignored);
xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
- procfile = gdb_fopen_cloexec (fname, "r");
+ gdb_file_up procfile = gdb_fopen_cloexec (fname, "r");
if (procfile == NULL)
error (_("Could not open %s"), fname);
- cleanup = make_cleanup_fclose (procfile);
- while (fgets (buffer, PATH_MAX, procfile) != NULL)
+ while (fgets (buffer, PATH_MAX, procfile.get ()) != NULL)
{
/* Normal queued signals are on the SigPnd line in the status
file. However, 2.6 kernels also have a "shared" pending
Unfortunately some Red Hat kernels include the shared pending
queue but not the ShdPnd status field. */
- if (strncmp (buffer, "SigPnd:\t", 8) == 0)
+ if (startswith (buffer, "SigPnd:\t"))
add_line_to_sigset (buffer + 8, pending);
- else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
+ else if (startswith (buffer, "ShdPnd:\t"))
add_line_to_sigset (buffer + 8, pending);
- else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
+ else if (startswith (buffer, "SigBlk:\t"))
add_line_to_sigset (buffer + 8, blocked);
- else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
+ else if (startswith (buffer, "SigIgn:\t"))
add_line_to_sigset (buffer + 8, ignored);
}
-
- do_cleanups (cleanup);
}
static enum target_xfer_status
-linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
+linux_nat_xfer_osdata (enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len)
return TARGET_XFER_OK;
}
-static enum target_xfer_status
-linux_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
- ULONGEST *xfered_len)
-{
- enum target_xfer_status xfer;
-
- if (object == TARGET_OBJECT_AUXV)
- return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
- offset, len, xfered_len);
-
- if (object == TARGET_OBJECT_OSDATA)
- return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
- offset, len, xfered_len);
-
- if (object == TARGET_OBJECT_SPU)
- return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
- offset, len, xfered_len);
-
- /* GDB calculates all the addresses in possibly larget width of the address.
- Address width needs to be masked before its final use - either by
- linux_proc_xfer_partial or inf_ptrace_xfer_partial.
-
- Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
-
- if (object == TARGET_OBJECT_MEMORY)
- {
- int addr_bit = gdbarch_addr_bit (target_gdbarch ());
-
- if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
- offset &= ((ULONGEST) 1 << addr_bit) - 1;
- }
-
- xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
- offset, len, xfered_len);
- if (xfer != TARGET_XFER_EOF)
- return xfer;
-
- return super_xfer_partial (ops, object, annex, readbuf, writebuf,
- offset, len, xfered_len);
-}
-
-static void
-cleanup_target_stop (void *arg)
-{
- ptid_t *ptid = (ptid_t *) arg;
-
- gdb_assert (arg != NULL);
-
- /* Unpause all */
- target_resume (*ptid, 0, GDB_SIGNAL_0);
-}
-
-static VEC(static_tracepoint_marker_p) *
-linux_child_static_tracepoint_markers_by_strid (struct target_ops *self,
- const char *strid)
+std::vector<static_tracepoint_marker>
+linux_nat_target::static_tracepoint_markers_by_strid (const char *strid)
{
char s[IPA_CMD_BUF_SIZE];
- struct cleanup *old_chain;
- int pid = ptid_get_pid (inferior_ptid);
- VEC(static_tracepoint_marker_p) *markers = NULL;
- struct static_tracepoint_marker *marker = NULL;
- char *p = s;
- ptid_t ptid = ptid_build (pid, 0, 0);
+ int pid = inferior_ptid.pid ();
+ std::vector<static_tracepoint_marker> markers;
+ const char *p = s;
+ ptid_t ptid = ptid_t (pid, 0, 0);
+ static_tracepoint_marker marker;
/* Pause all */
target_stop (ptid);
agent_run_command (pid, s, strlen (s) + 1);
- old_chain = make_cleanup (free_current_marker, &marker);
- make_cleanup (cleanup_target_stop, &ptid);
+ /* Unpause all. */
+ SCOPE_EXIT { target_continue_no_signal (ptid); };
while (*p++ == 'm')
{
- if (marker == NULL)
- marker = XCNEW (struct static_tracepoint_marker);
-
do
{
- parse_static_tracepoint_marker_definition (p, &p, marker);
+ parse_static_tracepoint_marker_definition (p, &p, &marker);
- if (strid == NULL || strcmp (strid, marker->str_id) == 0)
- {
- VEC_safe_push (static_tracepoint_marker_p,
- markers, marker);
- marker = NULL;
- }
- else
- {
- release_static_tracepoint_marker (marker);
- memset (marker, 0, sizeof (*marker));
- }
+ if (strid == NULL || marker.str_id == strid)
+ markers.push_back (std::move (marker));
}
while (*p++ == ','); /* comma-separated list */
p = s;
}
- do_cleanups (old_chain);
-
return markers;
}
-/* Create a prototype generic GNU/Linux target. The client can override
- it with local methods. */
-
-static void
-linux_target_install_ops (struct target_ops *t)
-{
- t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
- t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
- t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
- t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
- t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
- t->to_remove_exec_catchpoint = linux_child_remove_exec_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_post_startup_inferior = linux_child_post_startup_inferior;
- t->to_post_attach = linux_child_post_attach;
- t->to_follow_fork = linux_child_follow_fork;
-
- super_xfer_partial = t->to_xfer_partial;
- t->to_xfer_partial = linux_xfer_partial;
-
- t->to_static_tracepoint_markers_by_strid
- = linux_child_static_tracepoint_markers_by_strid;
-}
-
-struct target_ops *
-linux_target (void)
-{
- struct target_ops *t;
-
- t = inf_ptrace_target ();
- linux_target_install_ops (t);
-
- return t;
-}
+/* target_is_async_p implementation. */
-struct target_ops *
-linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
+bool
+linux_nat_target::is_async_p ()
{
- struct target_ops *t;
-
- t = inf_ptrace_trad_target (register_u_offset);
- linux_target_install_ops (t);
-
- return t;
+ return linux_is_async_p ();
}
-/* target_is_async_p implementation. */
+/* target_can_async_p implementation. */
-static int
-linux_nat_is_async_p (struct target_ops *ops)
+bool
+linux_nat_target::can_async_p ()
{
- /* NOTE: palves 2008-03-21: We're only async when the user requests
- it explicitly with the "set target-async" command.
- Someday, linux will always be async. */
+ /* We're always async, unless the user explicitly prevented it with the
+ "maint set target-async" command. */
return target_async_permitted;
}
-/* target_can_async_p implementation. */
-
-static int
-linux_nat_can_async_p (struct target_ops *ops)
+bool
+linux_nat_target::supports_non_stop ()
{
- /* NOTE: palves 2008-03-21: We're only async when the user requests
- it explicitly with the "set target-async" command.
- Someday, linux will always be async. */
- return target_async_permitted;
+ return 1;
}
-static int
-linux_nat_supports_non_stop (struct target_ops *self)
+/* to_always_non_stop_p implementation. */
+
+bool
+linux_nat_target::always_non_stop_p ()
{
return 1;
}
int linux_multi_process = 1;
-static int
-linux_nat_supports_multi_process (struct target_ops *self)
+bool
+linux_nat_target::supports_multi_process ()
{
return linux_multi_process;
}
-static int
-linux_nat_supports_disable_randomization (struct target_ops *self)
+bool
+linux_nat_target::supports_disable_randomization ()
{
#ifdef HAVE_PERSONALITY
return 1;
#endif
}
-static int async_terminal_is_ours = 1;
-
-/* target_terminal_inferior implementation.
-
- This is a wrapper around child_terminal_inferior to add async support. */
-
-static void
-linux_nat_terminal_inferior (struct target_ops *self)
-{
- if (!target_is_async_p ())
- {
- /* Async mode is disabled. */
- child_terminal_inferior (self);
- return;
- }
-
- child_terminal_inferior (self);
-
- /* Calls to target_terminal_*() are meant to be idempotent. */
- if (!async_terminal_is_ours)
- return;
-
- delete_file_handler (input_fd);
- async_terminal_is_ours = 0;
- set_sigint_trap ();
-}
-
-/* target_terminal_ours implementation.
-
- This is a wrapper around child_terminal_ours to add async support (and
- implement the target_terminal_ours vs target_terminal_ours_for_output
- distinction). child_terminal_ours is currently no different than
- child_terminal_ours_for_output.
- We leave target_terminal_ours_for_output alone, leaving it to
- child_terminal_ours_for_output. */
-
-static void
-linux_nat_terminal_ours (struct target_ops *self)
-{
- if (!target_is_async_p ())
- {
- /* Async mode is disabled. */
- child_terminal_ours (self);
- return;
- }
-
- /* GDB should never give the terminal to the inferior if the
- inferior is running in the background (run&, continue&, etc.),
- but claiming it sure should. */
- child_terminal_ours (self);
-
- if (async_terminal_is_ours)
- return;
-
- clear_sigint_trap ();
- add_file_handler (input_fd, stdin_event_handler, 0);
- async_terminal_is_ours = 1;
-}
-
-static void (*async_client_callback) (enum inferior_event_type event_type,
- void *context);
-static void *async_client_context;
-
/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
so we notice when any child changes state, and notify the
event-loop; it allows us to use sigsuspend in linux_nat_wait_1
static void
handle_target_event (int error, gdb_client_data client_data)
{
- (*async_client_callback) (INF_REG_EVENT, async_client_context);
+ inferior_event_handler (INF_REG_EVENT, NULL);
}
/* Create/destroy the target events pipe. Returns previous state. */
static int
linux_async_pipe (int enable)
{
- int previous = (linux_nat_event_pipe[0] != -1);
+ int previous = linux_is_async_p ();
if (previous != enable)
{
/* target_async implementation. */
-static void
-linux_nat_async (struct target_ops *ops,
- void (*callback) (enum inferior_event_type event_type,
- void *context),
- void *context)
+void
+linux_nat_target::async (int enable)
{
- if (callback != NULL)
+ if (enable)
{
- async_client_callback = callback;
- async_client_context = context;
if (!linux_async_pipe (1))
{
add_file_handler (linux_nat_event_pipe[0],
}
else
{
- async_client_callback = callback;
- async_client_context = context;
delete_file_handler (linux_nat_event_pipe[0]);
linux_async_pipe (0);
}
event came out. */
static int
-linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
+linux_nat_stop_lwp (struct lwp_info *lwp)
{
if (!lwp->stopped)
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
"LNSL: running -> suspending %s\n",
- target_pid_to_str (lwp->ptid));
+ target_pid_to_str (lwp->ptid).c_str ());
if (lwp->last_resume_kind == resume_stop)
fprintf_unfiltered (gdb_stdlog,
"linux-nat: already stopping LWP %ld at "
"GDB's request\n",
- ptid_get_lwp (lwp->ptid));
+ lwp->ptid.lwp ());
return 0;
}
- stop_callback (lwp, NULL);
+ stop_callback (lwp);
lwp->last_resume_kind = resume_stop;
}
else
if (find_thread_ptid (lwp->ptid)->stop_requested)
fprintf_unfiltered (gdb_stdlog,
"LNSL: already stopped/stop_requested %s\n",
- target_pid_to_str (lwp->ptid));
+ target_pid_to_str (lwp->ptid).c_str ());
else
fprintf_unfiltered (gdb_stdlog,
"LNSL: already stopped/no "
"stop_requested yet %s\n",
- target_pid_to_str (lwp->ptid));
+ target_pid_to_str (lwp->ptid).c_str ());
}
}
return 0;
}
-static void
-linux_nat_stop (struct target_ops *self, ptid_t ptid)
+void
+linux_nat_target::stop (ptid_t ptid)
{
- if (non_stop)
- iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
- else
- linux_ops->to_stop (linux_ops, ptid);
+ iterate_over_lwps (ptid, linux_nat_stop_lwp);
}
-static void
-linux_nat_close (struct target_ops *self)
+void
+linux_nat_target::close ()
{
/* Unregister from the event loop. */
- if (linux_nat_is_async_p (self))
- linux_nat_async (self, NULL, NULL);
+ if (is_async_p ())
+ async (0);
- if (linux_ops->to_close)
- linux_ops->to_close (linux_ops);
-
- super_close (self);
+ inf_ptrace_target::close ();
}
/* When requests are passed down from the linux-nat layer to the
lwpid is a "main" process id or not (it assumes so). We reverse
look up the "main" process id from the lwp here. */
-static struct address_space *
-linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
+struct address_space *
+linux_nat_target::thread_address_space (ptid_t ptid)
{
struct lwp_info *lwp;
struct inferior *inf;
int pid;
- if (ptid_get_lwp (ptid) == 0)
+ if (ptid.lwp () == 0)
{
/* An (lwpid,0,0) ptid. Look up the lwp object to get at the
tgid. */
lwp = find_lwp_pid (ptid);
- pid = ptid_get_pid (lwp->ptid);
+ pid = lwp->ptid.pid ();
}
else
{
/* A (pid,lwpid,0) ptid. */
- pid = ptid_get_pid (ptid);
+ pid = ptid.pid ();
}
inf = find_inferior_pid (pid);
/* Return the cached value of the processor core for thread PTID. */
-static int
-linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
+int
+linux_nat_target::core_of_thread (ptid_t ptid)
{
struct lwp_info *info = find_lwp_pid (ptid);
return -1;
}
-void
-linux_nat_add_target (struct target_ops *t)
-{
- /* Save the provided single-threaded target. We save this in a separate
- 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
- process stratum target. */
- linux_ops_saved = *t;
- linux_ops = &linux_ops_saved;
-
- /* Override some methods for multithreading. */
- t->to_create_inferior = linux_nat_create_inferior;
- t->to_attach = linux_nat_attach;
- t->to_detach = linux_nat_detach;
- t->to_resume = linux_nat_resume;
- t->to_wait = linux_nat_wait;
- t->to_pass_signals = linux_nat_pass_signals;
- t->to_xfer_partial = linux_nat_xfer_partial;
- t->to_kill = linux_nat_kill;
- t->to_mourn_inferior = linux_nat_mourn_inferior;
- t->to_thread_alive = linux_nat_thread_alive;
- t->to_pid_to_str = linux_nat_pid_to_str;
- t->to_thread_name = linux_nat_thread_name;
- t->to_has_thread_control = tc_schedlock;
- t->to_thread_address_space = linux_nat_thread_address_space;
- t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
- t->to_stopped_data_address = linux_nat_stopped_data_address;
-
- t->to_can_async_p = linux_nat_can_async_p;
- t->to_is_async_p = linux_nat_is_async_p;
- t->to_supports_non_stop = linux_nat_supports_non_stop;
- t->to_async = linux_nat_async;
- t->to_terminal_inferior = linux_nat_terminal_inferior;
- t->to_terminal_ours = linux_nat_terminal_ours;
-
- super_close = t->to_close;
- t->to_close = linux_nat_close;
-
- /* Methods for non-stop support. */
- t->to_stop = linux_nat_stop;
-
- t->to_supports_multi_process = linux_nat_supports_multi_process;
-
- t->to_supports_disable_randomization
- = linux_nat_supports_disable_randomization;
-
- t->to_core_of_thread = linux_nat_core_of_thread;
+/* Implementation of to_filesystem_is_local. */
- /* We don't change the stratum; this target will sit at
- process_stratum and thread_db will set at thread_stratum. This
- 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
- also want to be used for single-threaded processes. */
+bool
+linux_nat_target::filesystem_is_local ()
+{
+ struct inferior *inf = current_inferior ();
- add_target (t);
+ if (inf->fake_pid_p || inf->pid == 0)
+ return true;
+
+ return linux_ns_same (inf->pid, LINUX_NS_MNT);
}
-/* Register a method to call whenever a new thread is attached. */
-void
-linux_nat_set_new_thread (struct target_ops *t,
- void (*new_thread) (struct lwp_info *))
+/* Convert the INF argument passed to a to_fileio_* method
+ to a process ID suitable for passing to its corresponding
+ linux_mntns_* function. If INF is non-NULL then the
+ caller is requesting the filesystem seen by INF. If INF
+ is NULL then the caller is requesting the filesystem seen
+ by the GDB. We fall back to GDB's filesystem in the case
+ that INF is non-NULL but its PID is unknown. */
+
+static pid_t
+linux_nat_fileio_pid_of (struct inferior *inf)
{
- /* 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
- T. */
- linux_nat_new_thread = new_thread;
+ if (inf == NULL || inf->fake_pid_p || inf->pid == 0)
+ return getpid ();
+ else
+ return inf->pid;
}
-/* See declaration in linux-nat.h. */
+/* Implementation of to_fileio_open. */
-void
-linux_nat_set_new_fork (struct target_ops *t,
- linux_nat_new_fork_ftype *new_fork)
+int
+linux_nat_target::fileio_open (struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *target_errno)
{
- /* Save the pointer. */
- linux_nat_new_fork = new_fork;
+ int nat_flags;
+ mode_t nat_mode;
+ int fd;
+
+ if (fileio_to_host_openflags (flags, &nat_flags) == -1
+ || fileio_to_host_mode (mode, &nat_mode) == -1)
+ {
+ *target_errno = FILEIO_EINVAL;
+ return -1;
+ }
+
+ fd = linux_mntns_open_cloexec (linux_nat_fileio_pid_of (inf),
+ filename, nat_flags, nat_mode);
+ if (fd == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return fd;
}
-/* See declaration in linux-nat.h. */
+/* Implementation of to_fileio_readlink. */
-void
-linux_nat_set_forget_process (struct target_ops *t,
- linux_nat_forget_process_ftype *fn)
+gdb::optional<std::string>
+linux_nat_target::fileio_readlink (struct inferior *inf, const char *filename,
+ int *target_errno)
{
- /* Save the pointer. */
- linux_nat_forget_process_hook = fn;
+ char buf[PATH_MAX];
+ int len;
+
+ len = linux_mntns_readlink (linux_nat_fileio_pid_of (inf),
+ filename, buf, sizeof (buf));
+ if (len < 0)
+ {
+ *target_errno = host_to_fileio_error (errno);
+ return {};
+ }
+
+ return std::string (buf, len);
}
-/* See declaration in linux-nat.h. */
+/* Implementation of to_fileio_unlink. */
-void
-linux_nat_forget_process (pid_t pid)
+int
+linux_nat_target::fileio_unlink (struct inferior *inf, const char *filename,
+ int *target_errno)
{
- if (linux_nat_forget_process_hook != NULL)
- linux_nat_forget_process_hook (pid);
+ int ret;
+
+ ret = linux_mntns_unlink (linux_nat_fileio_pid_of (inf),
+ filename);
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
}
-/* Register a method that converts a siginfo object between the layout
- that ptrace returns, and the layout in the architecture of the
- inferior. */
+/* Implementation of the to_thread_events method. */
+
void
-linux_nat_set_siginfo_fixup (struct target_ops *t,
- int (*siginfo_fixup) (siginfo_t *,
- gdb_byte *,
- int))
+linux_nat_target::thread_events (int enable)
{
- /* Save the pointer. */
- linux_nat_siginfo_fixup = siginfo_fixup;
+ report_thread_events = enable;
}
-/* Register a method to call prior to resuming a thread. */
-
-void
-linux_nat_set_prepare_to_resume (struct target_ops *t,
- void (*prepare_to_resume) (struct lwp_info *))
+linux_nat_target::linux_nat_target ()
{
- /* Save the pointer. */
- linux_nat_prepare_to_resume = prepare_to_resume;
+ /* We don't change the stratum; this target will sit at
+ process_stratum and thread_db will set at thread_stratum. This
+ 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
+ also want to be used for single-threaded processes. */
}
/* See linux-nat.h. */
{
int pid;
- pid = ptid_get_lwp (ptid);
+ pid = ptid.lwp ();
if (pid == 0)
- pid = ptid_get_pid (ptid);
+ pid = ptid.pid ();
errno = 0;
ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
return 1;
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_linux_nat;
+/* See nat/linux-nat.h. */
+
+ptid_t
+current_lwp_ptid (void)
+{
+ gdb_assert (inferior_ptid.lwp_p ());
+ return inferior_ptid;
+}
void
_initialize_linux_nat (void)
show_debug_linux_nat,
&setdebuglist, &showdebuglist);
- /* Save this mask as the default. */
- sigprocmask (SIG_SETMASK, NULL, &normal_mask);
+ add_setshow_boolean_cmd ("linux-namespaces", class_maintenance,
+ &debug_linux_namespaces, _("\
+Set debugging of GNU/Linux namespaces module."), _("\
+Show debugging of GNU/Linux namespaces module."), _("\
+Enables printf debugging output."),
+ NULL,
+ NULL,
+ &setdebuglist, &showdebuglist);
/* Install a SIGCHLD handler. */
sigchld_action.sa_handler = sigchld_handler;
sigaction (SIGCHLD, &sigchld_action, NULL);
/* Make sure we don't block SIGCHLD during a sigsuspend. */
- sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
+ gdb_sigmask (SIG_SETMASK, NULL, &suspend_mask);
sigdelset (&suspend_mask, SIGCHLD);
sigemptyset (&blocked_mask);
- /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to
- support read-only process state. */
- linux_ptrace_set_additional_flags (PTRACE_O_TRACESYSGOOD
- | PTRACE_O_TRACEVFORKDONE
- | PTRACE_O_TRACEVFORK
- | PTRACE_O_TRACEFORK
- | PTRACE_O_TRACEEXEC);
+ lwp_lwpid_htab_create ();
}
\f
the GNU/Linux Threads library and therefore doesn't really belong
here. */
-/* Read variable NAME in the target and return its value if found.
- Otherwise return zero. It is assumed that the type of the variable
- is `int'. */
-
-static int
-get_signo (const char *name)
-{
- struct bound_minimal_symbol ms;
- int signo;
-
- ms = lookup_minimal_symbol (name, NULL, NULL);
- if (ms.minsym == NULL)
- return 0;
-
- if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
- sizeof (signo)) != 0)
- return 0;
-
- return signo;
-}
-
/* Return the set of signals used by the threads library in *SET. */
void
lin_thread_get_thread_signals (sigset_t *set)
{
- struct sigaction action;
- int restart, cancel;
-
- sigemptyset (&blocked_mask);
sigemptyset (set);
- restart = get_signo ("__pthread_sig_restart");
- cancel = get_signo ("__pthread_sig_cancel");
-
- /* LinuxThreads normally uses the first two RT signals, but in some legacy
- cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
- not provide any way for the debugger to query the signal numbers -
- fortunately they don't change! */
-
- if (restart == 0)
- restart = __SIGRTMIN;
-
- if (cancel == 0)
- cancel = __SIGRTMIN + 1;
-
- sigaddset (set, restart);
- sigaddset (set, cancel);
-
- /* The GNU/Linux Threads library makes terminating threads send a
- special "cancel" signal instead of SIGCHLD. Make sure we catch
- those (to prevent them from terminating GDB itself, which is
- likely to be their default action) and treat them the same way as
- SIGCHLD. */
-
- action.sa_handler = sigchld_handler;
- sigemptyset (&action.sa_mask);
- action.sa_flags = SA_RESTART;
- sigaction (cancel, &action, NULL);
-
- /* We block the "cancel" signal throughout this code ... */
- sigaddset (&blocked_mask, cancel);
- sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
-
- /* ... except during a sigsuspend. */
- sigdelset (&suspend_mask, cancel);
+ /* NPTL reserves the first two RT signals, but does not provide any
+ way for the debugger to query the signal numbers - fortunately
+ they don't change. */
+ sigaddset (set, __SIGRTMIN);
+ sigaddset (set, __SIGRTMIN + 1);
}
projects / deliverable / binutils-gdb.git / blobdiff