/* GNU/Linux native-dependent code common to multiple platforms.
- Copyright (C) 2001-2015 Free Software Foundation, Inc.
+ Copyright (C) 2001-2016 Free Software Foundation, Inc.
This file is part of GDB.
#include "nat/linux-nat.h"
#include "nat/linux-waitpid.h"
#include "gdb_wait.h"
-#ifdef HAVE_TKILL_SYSCALL
#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 "target-descriptions.h"
#include "filestuff.h"
#include "objfiles.h"
+#include "nat/linux-namespaces.h"
+#include "fileio.h"
#ifndef SPUFS_MAGIC
#define SPUFS_MAGIC 0x23c9b64e
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. */
+blocked.
+
+Exec events
+===========
+
+The case of a thread group (process) with 3 or more threads, and a
+thread other than the leader execs is worth detailing:
+
+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. */
#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif
+/* Does the current host support PTRACE_GETREGSET? */
+enum tribool have_ptrace_getregset = TRIBOOL_UNKNOWN;
+
/* 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;
};
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
static int lwp_status_pending_p (struct lwp_info *lp);
-static int check_stopped_by_breakpoint (struct lwp_info *lp);
static int sigtrap_is_event (int status);
static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
+static void save_stop_reason (struct lwp_info *lp);
+
\f
/* LWP accessors. */
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;
}
+/* 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 warnings and check for supported ptrace
features given PID.
static void
linux_init_ptrace (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 ();
}
static void
delete_lwp_cleanup (void *lp_voidp)
{
- struct lwp_info *lp = lp_voidp;
+ struct lwp_info *lp = (struct lwp_info *) lp_voidp;
delete_lwp (lp->ptid);
}
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 = ptid_get_lwp (lp->ptid);
+
+ 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 ptid_get_lwp (entry->ptid) == ptid_get_lwp (element->ptid);
+}
+
+/* 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;
+
+/* 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
/* Original signal mask. */
/* 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 resume_stopped_resumed_lwps (struct lwp_info *lp, void *data);
+static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
\f
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;
-
- lpprev = NULL;
+ struct lwp_info *lp = (struct lwp_info *) *slot;
+ int pid = *(int *) info;
- for (lp = lwp_list; lp; lp = lpnext)
+ if (ptid_get_pid (lp->ptid) == 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
gdb_assert (ptid_lwp_p (ptid));
- 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;
}
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);
else
lwp = ptid_get_pid (ptid);
- for (lp = lwp_list; lp; lp = lp->next)
- if (lwp == ptid_get_lwp (lp->ptid))
- return lp;
-
- return NULL;
+ dummy.ptid = ptid_build (0, lwp, 0);
+ lp = (struct lwp_info *) htab_find (lwp_lwpid_htab, &dummy);
+ return lp;
}
/* See nat/linux-nat.h. */
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 first, int *signalled)
{
pid_t new_pid, pid = ptid_get_lwp (ptid);
int status;
/* 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 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 (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. */
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLAL: attach failed, but already seen "
- "this thread %s stop\n",
- target_pid_to_str (ptid));
- return 1;
- }
- else
- {
- int new_pid;
- int status;
-
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLAL: attach failed, and haven't seen "
- "this thread %s stop yet\n",
- target_pid_to_str (ptid));
-
- /* We may or may not be attached to the LWP already.
- Try waitpid on it. If that errors, we're not
- attached to the LWP yet. Otherwise, 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 (new_pid == 0)
- {
- /* The child hasn't stopped for its initial
- SIGSTOP stop yet. */
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLAL: child hasn't "
- "stopped yet\n");
- }
- else if (WIFSTOPPED (status))
- {
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLAL: adding to stopped_pids\n");
- 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->last_resume_kind = resume_stop;
- 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));
- }
- }
-
- return 0;
-}
-
static void
linux_nat_create_inferior (struct target_ops *ops,
char *exec_file, char *allargs, char **env,
target_pid_to_str (ptid));
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;
/* 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, 1, &lp->signalled);
if (!WIFSTOPPED (status))
{
if (WIFEXITED (status))
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 if (target_is_non_stop_p () && !is_executing (lp->ptid))
{
struct thread_info *tp = find_thread_ptid (lp->ptid);
- signo = tp->suspend.stop_signal;
+ if (tp->suspend.waitstatus_pending_p)
+ signo = tp->suspend.waitstatus.value.sig;
+ else
+ signo = tp->suspend.stop_signal;
}
- else if (!non_stop)
+ else if (!target_is_non_stop_p ())
{
struct target_waitstatus last;
ptid_t last_ptid;
}
}
- *status = 0;
-
if (signo == GDB_SIGNAL_0)
{
if (debug_linux_nat)
}
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),
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 = ptid_get_lwp (lp->ptid);
+ int signo;
+
gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
if (debug_linux_nat && lp->status)
"DC: Sending SIGCONT to %s\n",
target_pid_to_str (lp->ptid));
- 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;
+ /* 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
+ {
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));
+ }
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ if (!check_ptrace_stopped_lwp_gone (lp))
+ throw_exception (ex);
+ }
+ END_CATCH
- 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, 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),
+ 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),
+ strsignal (signo));
}
+ delete_lwp (lp->ptid);
+}
+
+static int
+detach_callback (struct lwp_info *lp, void *data)
+{
+ /* 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 (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
+ detach_one_lwp (lp, NULL);
return 0;
}
linux_nat_detach (struct target_ops *ops, const char *args, int from_tty)
{
int pid;
- int status;
struct lwp_info *main_lwp;
pid = ptid_get_pid (inferior_ptid);
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));
- }
-
- if (linux_nat_prepare_to_resume != NULL)
- linux_nat_prepare_to_resume (main_lwp);
- delete_lwp (main_lwp->ptid);
-
if (forks_exist_p ())
{
/* Multi-fork case. The current inferior_ptid is being detached
linux_fork_detach (args, from_tty);
}
else
- linux_ops->to_detach (ops, args, from_tty);
+ {
+ int signo;
+
+ target_announce_detach (from_tty);
+
+ /* Pass on any pending signal for the last LWP, unless the user
+ requested detaching with a different signal (most likely 0,
+ meaning, discard the signal). */
+ if (args != NULL)
+ signo = atoi (args);
+ else
+ signo = get_detach_signal (main_lwp);
+
+ detach_one_lwp (main_lwp, &signo);
+
+ inf_ptrace_detach_success (ops);
+ }
+ delete_lwp (main_lwp->ptid);
}
/* Resume execution of the inferior process. If STEP is nonzero,
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);
}
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
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. */
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);
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)
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;
pid, new_pid);
new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
- new_lp->cloned = 1;
new_lp->stopped = 1;
-
- if (WSTOPSIG (status) != SIGSTOP)
- {
- /* This can happen if someone starts sending signals to
- the new thread before it gets a chance to run, which
- 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. */
-
- 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;
- }
+ 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
}
/* Even if we're stopping the thread for some reason
- internal to this module, from the user/frontend's
- perspective, this new thread is running. */
+ 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);
- if (!stopping)
- {
- set_executing (new_lp->ptid, 1);
- /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
- resume_stop. */
- new_lp->last_resume_kind = resume_continue;
- }
+ set_executing (new_lp->ptid, 1);
- if (status != 0)
+ if (WSTOPSIG (status) != SIGSTOP)
{
+ /* This can happen if someone starts sending signals to
+ the new thread before it gets a chance to run, which
+ 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. */
+
+ new_lp->signalled = 1;
+
/* We created NEW_LP so it cannot yet contain STATUS. */
gdb_assert (new_lp->status == 0);
status_to_str (status));
new_lp->status = status;
}
+ else if (report_thread_events)
+ {
+ new_lp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
+ new_lp->status = status;
+ }
- new_lp->resumed = !stopping;
return 1;
}
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 (ptid_get_lwp (lp->ptid), &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",
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.
/* Check if the thread has exited. */
if (WIFEXITED (status) || WIFSIGNALED (status))
{
+ if (report_thread_events
+ || ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
+ {
+ if (debug_linux_nat)
+ fprintf_unfiltered (gdb_stdlog, "WL: LWP %d exited.\n",
+ ptid_get_pid (lp->ptid));
+
+ /* 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",
if (lp->must_set_ptrace_flags)
{
struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
+ 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 (ptid_get_lwp (lp->ptid), 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);
- linux_handle_extended_wait (lp, status, 1);
+ linux_handle_extended_wait (lp, status);
return 0;
}
return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
-/* Called when the LWP stopped for a trap that could be explained by a
- watchpoint or a breakpoint. */
-
-static void
-save_sigtrap (struct lwp_info *lp)
-{
- gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
- gdb_assert (lp->status != 0);
-
- /* Check first if this was a SW/HW breakpoint before checking
- watchpoints, because at least s390 can't tell the data address of
- hardware watchpoint hits, and the kernel returns
- stopped-by-watchpoint as long as there's a watchpoint set. */
- if (linux_nat_status_is_event (lp->status))
- check_stopped_by_breakpoint (lp);
-
- /* Note that TRAP_HWBKPT can indicate either a hardware breakpoint
- or hardware watchpoint. Check which is which if we got
- TARGET_STOPPED_BY_HW_BREAKPOINT. */
- if (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON
- || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
- check_stopped_by_watchpoint (lp);
-}
-
/* Returns true if the LWP had stopped for a watchpoint. */
static int
/* Save the sigtrap event. */
lp->status = status;
gdb_assert (lp->signalled);
- save_sigtrap (lp);
+ save_stop_reason (lp);
}
else
{
|| lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
{
struct regcache *regcache = get_thread_regcache (lp->ptid);
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
CORE_ADDR pc;
int discard = 0;
return 1;
}
-/* Return non-zero if LP isn't stopped. */
-
-static int
-running_callback (struct lwp_info *lp, void *data)
-{
- return (!lp->stopped
- || (lwp_status_pending_p (lp) && lp->resumed));
-}
-
/* Count the LWP's that have had events. */
static int
count_events_callback (struct lwp_info *lp, void *data)
{
- int *count = data;
+ int *count = (int *) data;
gdb_assert (count != NULL);
static int
select_event_lwp_callback (struct lwp_info *lp, void *data)
{
- int *selector = data;
+ int *selector = (int *) data;
gdb_assert (selector != NULL);
return 0;
}
-/* Called when the LWP got a signal/trap that could be explained by a
- software or hardware breakpoint. */
+/* 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 int
-check_stopped_by_breakpoint (struct lwp_info *lp)
+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.
-
- 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. */
-
- struct regcache *regcache = get_thread_regcache (lp->ptid);
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct regcache *regcache;
+ struct gdbarch *gdbarch;
CORE_ADDR pc;
CORE_ADDR sw_bp_pc;
#if USE_SIGTRAP_SIGINFO
siginfo_t siginfo;
#endif
+ gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
+ gdb_assert (lp->status != 0);
+
+ if (!linux_nat_status_is_event (lp->status))
+ return;
+
+ regcache = get_thread_regcache (lp->ptid);
+ gdbarch = get_regcache_arch (regcache);
+
pc = regcache_read_pc (regcache);
sw_bp_pc = pc - gdbarch_decr_pc_after_break (gdbarch);
{
if (siginfo.si_signo == SIGTRAP)
{
- if (siginfo.si_code == GDB_ARCH_TRAP_BRKPT)
+ if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
+ && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
{
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "CSBB: %s stopped by software "
- "breakpoint\n",
- target_pid_to_str (lp->ptid));
-
- /* Back up the PC if necessary. */
- if (pc != sw_bp_pc)
- regcache_write_pc (regcache, sw_bp_pc);
-
- lp->stop_pc = sw_bp_pc;
+ /* 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;
- return 1;
}
- else if (siginfo.si_code == TRAP_HWBKPT)
+ else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
{
- if (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "CSBB: %s stopped by hardware "
- "breakpoint/watchpoint\n",
- target_pid_to_str (lp->ptid));
-
- lp->stop_pc = pc;
- lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
- return 1;
+ /* 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)
{
fprintf_unfiltered (gdb_stdlog,
"CSBB: %s stopped by trace\n",
target_pid_to_str (lp->ptid));
+
+ /* 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);
}
}
}
{
/* 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 (get_regcache_aspace (regcache), 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,
"CSBB: %s stopped by software breakpoint\n",
if (pc != sw_bp_pc)
regcache_write_pc (regcache, sw_bp_pc);
- lp->stop_pc = sw_bp_pc;
- lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
- return 1;
+ /* Update this so we record the correct stop PC below. */
+ pc = sw_bp_pc;
}
-
- if (hardware_breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
+ else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
{
if (debug_linux_nat)
fprintf_unfiltered (gdb_stdlog,
- "CSBB: stopped by hardware breakpoint %s\n",
+ "CSBB: %s stopped by hardware breakpoint\n",
+ target_pid_to_str (lp->ptid));
+ }
+ 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));
-
- lp->stop_pc = pc;
- lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
- return 1;
}
-#endif
- return 0;
+ lp->stop_pc = pc;
}
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 (!non_stop)
+ if (!target_is_non_stop_p ())
{
event_lp = iterate_over_lwps (filter,
select_singlestep_lwp_callback, NULL);
/* Flush the wait status for the event LWP. */
(*orig_lp)->status = 0;
-}
-
-/* Return non-zero if LP has been resumed. */
-
-static int
-resumed_callback (struct lwp_info *lp, void *data)
-{
- 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)
-{
- 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);
- }
+/* Return non-zero if LP has been resumed. */
- 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));
- }
- }
- }
- return 0;
+static int
+resumed_callback (struct lwp_info *lp, void *data)
+{
+ return lp->resumed;
}
/* Check if we should go on and pass this event to common code.
if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
{
struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
+ 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 (ptid_get_lwp (lp->ptid), 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;
}
/* Check if the thread has exited. */
if (WIFEXITED (status) || WIFSIGNALED (status))
{
- if (num_lwps (ptid_get_pid (lp->ptid)) > 1)
+ if (!report_thread_events
+ && num_lwps (ptid_get_pid (lp->ptid)) > 1)
{
- /* 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))
- {
- iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
- stop_and_resume_callback, NULL);
- }
-
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 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;
}
- gdb_assert (lp->resumed);
-
+ /* 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,
- "Process %ld exited\n",
- ptid_get_lwp (lp->ptid));
-
- /* This was the last lwp in the process. Since events are
- serialized to GDB core, we may not be able 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. */
+ "LWP %ld exited (resumed=%d)\n",
+ ptid_get_lwp (lp->ptid), lp->resumed);
/* Dead LWP's aren't expected to reported a pending sigstop. */
lp->signalled = 0;
return lp;
}
- /* 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 (debug_linux_nat)
- fprintf_unfiltered (gdb_stdlog,
- "LLW: %s exited.\n",
- target_pid_to_str (lp->ptid));
-
- exit_lwp (lp);
-
- /* Make sure there is at least one thread running. */
- gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
-
- /* Discard the event. */
- return NULL;
- }
-
/* Make sure we don't report a SIGSTOP that we sent ourselves in
an attempt to stop an LWP. */
if (lp->signalled
{
enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
- if (!non_stop)
+ 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
/* An interesting event. */
gdb_assert (lp);
lp->status = status;
- save_sigtrap (lp);
+ save_stop_reason (lp);
return lp;
}
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
+filter_exit_event (struct lwp_info *event_child,
+ struct target_waitstatus *ourstatus)
+{
+ ptid_t ptid = event_child->ptid;
+
+ if (num_lwps (ptid_get_pid (ptid)) > 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 (struct target_ops *ops,
ptid_t ptid, struct target_waitstatus *ourstatus,
target_pid_to_str (lp->ptid));
}
- if (!target_is_async_p ())
- {
- /* Causes SIGINT to be passed on to the attached process. */
- set_sigint_trap ();
- }
-
/* 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. */
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,
ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
- if (!target_is_async_p ())
- clear_sigint_trap ();
-
restore_child_signals_mask (&prev_mask);
return minus_one_ptid;
}
sigsuspend (&suspend_mask);
}
- if (!target_is_async_p ())
- clear_sigint_trap ();
-
gdb_assert (lp);
status = lp->status;
lp->status = 0;
- if (!non_stop)
+ if (!target_is_non_stop_p ())
{
/* Now stop all other LWP's ... */
iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
clears it. */
last_resume_kind = lp->last_resume_kind;
- if (!non_stop)
+ if (!target_is_non_stop_p ())
{
/* In all-stop, from the core's perspective, all LWPs are now
stopped until a new resume action is sent over. */
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;
}
static int
resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
{
- ptid_t *wait_ptid_p = data;
+ ptid_t *wait_ptid_p = (ptid_t *) 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));
+ }
+ 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));
+ }
+ 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));
+ }
+ else
{
struct regcache *regcache = get_thread_regcache (lp->ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
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)
+ if (target_is_non_stop_p ())
iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
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);
+ gdb_assert (res == -1 && errno == ECHILD);
+}
+
+/* Callback for iterate_over_lwps. */
+
+static int
+kill_callback (struct lwp_info *lp, void *data)
+{
+ kill_one_lwp (ptid_get_lwp (lp->ptid));
+ return 0;
+}
+
+/* Callback for iterate_over_lwps. */
+
+static int
+kill_wait_callback (struct lwp_info *lp, void *data)
+{
+ kill_wait_one_lwp (ptid_get_lwp (lp->ptid));
return 0;
}
+/* Kill the fork children of any threads of inferior INF that are
+ stopped at a fork event. */
+
static void
-linux_nat_kill (struct target_ops *ops)
+kill_unfollowed_fork_children (struct inferior *inf)
{
- struct target_waitstatus last;
- ptid_t last_ptid;
- int status;
+ struct thread_info *thread;
+ ALL_NON_EXITED_THREADS (thread)
+ if (thread->inf == inf)
+ {
+ 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 = ptid_get_pid (child_ptid);
+ int child_lwp = ptid_get_lwp (child_ptid);
+
+ kill_one_lwp (child_lwp);
+ kill_wait_one_lwp (child_lwp);
+
+ /* Let the arch-specific native code know this process is
+ gone. */
+ linux_nat_forget_process (child_pid);
+ }
+ }
+}
+
+static void
+linux_nat_kill (struct target_ops *ops)
+{
/* If we're stopped while forking and we haven't followed yet,
kill the other task. We need to do this first because the
parent will be sleeping if this is a vfork. */
-
- get_last_target_status (&last_ptid, &last);
-
- if (last.kind == TARGET_WAITKIND_FORKED
- || last.kind == TARGET_WAITKIND_VFORKED)
- {
- ptrace (PT_KILL, ptid_get_pid (last.value.related_pid), 0, 0);
- wait (&status);
-
- /* Let the arch-specific native code know this process is
- gone. */
- linux_nat_forget_process (ptid_get_pid (last.value.related_pid));
- }
+ kill_unfollowed_fork_children (current_inferior ());
if (forks_exist_p ())
linux_fork_killall ();
}
static int
-linux_thread_alive (ptid_t ptid)
+linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
{
- int err, tmp_errno;
-
- gdb_assert (ptid_lwp_p (ptid));
+ /* As long as a PTID is in lwp list, consider it alive. */
+ return find_lwp_pid (ptid) != NULL;
+}
- /* 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");
+/* Implement the to_update_thread_list target method for this
+ target. */
- if (err != 0)
- return 0;
+static void
+linux_nat_update_thread_list (struct target_ops *ops)
+{
+ struct lwp_info *lwp;
- return 1;
-}
+ /* 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 ();
-static int
-linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
-{
- return linux_thread_alive (ptid);
+ /* Update the processor core that each lwp/thread was last seen
+ running on. */
+ ALL_LWPS (lwp)
+ {
+ /* 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);
+ }
}
static char *
return normal_pid_to_str (ptid);
}
-static char *
+static const char *
linux_nat_thread_name (struct target_ops *self, struct thread_info *thr)
{
- 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;
-
- 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 result;
+ return linux_proc_tid_get_name (thr->ptid);
}
/* Accepts an integer PID; Returns a string representing a file that
static char *
linux_child_pid_to_exec_file (struct target_ops *self, 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
char filename[64];
if (object != TARGET_OBJECT_MEMORY || !readbuf)
- return 0;
+ return TARGET_XFER_EOF;
/* Don't bother for one word. */
if (len < 3 * sizeof (long))
return 1;
}
+/* to_always_non_stop_p implementation. */
+
+static int
+linux_nat_always_non_stop_p (struct target_ops *self)
+{
+ return 1;
+}
+
/* True if we want to support multi-process. To be removed when GDB
supports multi-exec. */
static void
linux_nat_terminal_inferior (struct target_ops *self)
{
- /* Like target_terminal_inferior, use target_can_async_p, not
- target_is_async_p, since at this point the target is not async
- yet. If it can async, then we know it will become async prior to
- resume. */
- if (!target_can_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 ();
}
return;
clear_sigint_trap ();
- add_file_handler (input_fd, stdin_event_handler, 0);
async_terminal_is_ours = 1;
}
static void
linux_nat_stop (struct target_ops *self, 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, NULL);
}
static void
return -1;
}
+/* Implementation of to_filesystem_is_local. */
+
+static int
+linux_nat_filesystem_is_local (struct target_ops *ops)
+{
+ struct inferior *inf = current_inferior ();
+
+ if (inf->fake_pid_p || inf->pid == 0)
+ return 1;
+
+ return linux_ns_same (inf->pid, LINUX_NS_MNT);
+}
+
+/* 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)
+{
+ if (inf == NULL || inf->fake_pid_p || inf->pid == 0)
+ return getpid ();
+ else
+ return inf->pid;
+}
+
+/* Implementation of to_fileio_open. */
+
+static int
+linux_nat_fileio_open (struct target_ops *self,
+ struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *target_errno)
+{
+ 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;
+}
+
+/* Implementation of to_fileio_readlink. */
+
+static char *
+linux_nat_fileio_readlink (struct target_ops *self,
+ struct inferior *inf, const char *filename,
+ int *target_errno)
+{
+ char buf[PATH_MAX];
+ int len;
+ char *ret;
+
+ 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 NULL;
+ }
+
+ ret = (char *) xmalloc (len + 1);
+ memcpy (ret, buf, len);
+ ret[len] = '\0';
+ return ret;
+}
+
+/* Implementation of to_fileio_unlink. */
+
+static int
+linux_nat_fileio_unlink (struct target_ops *self,
+ struct inferior *inf, const char *filename,
+ int *target_errno)
+{
+ 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;
+}
+
+/* Implementation of the to_thread_events method. */
+
+static void
+linux_nat_thread_events (struct target_ops *ops, int enable)
+{
+ report_thread_events = enable;
+}
+
void
linux_nat_add_target (struct target_ops *t)
{
t->to_kill = linux_nat_kill;
t->to_mourn_inferior = linux_nat_mourn_inferior;
t->to_thread_alive = linux_nat_thread_alive;
+ t->to_update_thread_list = linux_nat_update_thread_list;
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_supports_stopped_by_sw_breakpoint = linux_nat_supports_stopped_by_sw_breakpoint;
t->to_stopped_by_hw_breakpoint = linux_nat_stopped_by_hw_breakpoint;
t->to_supports_stopped_by_hw_breakpoint = linux_nat_supports_stopped_by_hw_breakpoint;
+ t->to_thread_events = linux_nat_thread_events;
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_always_non_stop_p = linux_nat_always_non_stop_p;
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_core_of_thread = linux_nat_core_of_thread;
+ t->to_filesystem_is_local = linux_nat_filesystem_is_local;
+ t->to_fileio_open = linux_nat_fileio_open;
+ t->to_fileio_readlink = linux_nat_fileio_readlink;
+ t->to_fileio_unlink = linux_nat_fileio_unlink;
+
/* 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
show_debug_linux_nat,
&setdebuglist, &showdebuglist);
+ 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);
+
/* Save this mask as the default. */
sigprocmask (SIG_SETMASK, NULL, &normal_mask);
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 / thirdparty / binutils-gdb.git / blobdiff