and overall process id. */
ptid_t ptid;
+ /* Non-zero if this LWP is cloned. In this context "cloned" means
+ that the LWP is reporting to its parent using a signal other than
+ SIGCHLD. */
+ int cloned;
+
/* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
it back yet). */
int signalled;
#define is_lwp(ptid) (GET_LWP (ptid) != 0)
#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
-#define is_cloned(pid) (GET_LWP (pid) != GET_PID (pid))
-
/* If the last reported event was a SIGTRAP, this variable is set to
the process id of the LWP/thread that got it. */
ptid_t trap_ptid;
/* Prototypes for local functions. */
static int stop_wait_callback (struct lwp_info *lp, void *data);
\f
+/* Convert wait status STATUS to a string. Used for printing debug
+ messages only. */
+
+static char *
+status_to_str (int status)
+{
+ static char buf[64];
+ if (WIFSTOPPED (status))
+ snprintf (buf, sizeof (buf), "%s (stopped)",
+ strsignal (WSTOPSIG (status)));
+ else if (WIFSIGNALED (status))
+ snprintf (buf, sizeof (buf), "%s (terminated)",
+ strsignal (WSTOPSIG (status)));
+ else
+ snprintf (buf, sizeof (buf), "%d (exited)",
+ WEXITSTATUS (status));
+
+ return buf;
+}
+\f
/* Initialize the list of LWPs. Note that this module, contrary to
what GDB's generic threads layer does for its thread list,
re-initializes the LWP lists whenever we mourn or detach (which
gdb_assert (is_lwp (ptid));
+ /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
+ to interrupt either the ptrace() or waitpid() calls below. */
+ if (! sigismember (&blocked_mask, SIGCHLD))
+ {
+ sigaddset (&blocked_mask, SIGCHLD);
+ sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
+ }
+
if (verbose)
printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
- /* We assume that we're already tracing the initial process. */
- if (is_cloned (ptid) && ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
- error ("Can't attach %s: %s", target_pid_to_str (ptid), strerror (errno));
-
lp = find_lwp_pid (ptid);
if (lp == NULL)
lp = add_lwp (ptid);
- if (is_cloned (ptid))
+ /* We assume that we're already attached to any LWP that has an
+ id equal to the overall process id. */
+ if (GET_LWP (ptid) != GET_PID (ptid))
{
- lp->signalled = 1;
- stop_wait_callback (lp, NULL);
+ pid_t pid;
+ int status;
+
+ if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
+ error ("Can't attach %s: %s", target_pid_to_str (ptid),
+ strerror (errno));
+
+ pid = waitpid (GET_LWP (ptid), &status, 0);
+ if (pid == -1 && errno == ECHILD)
+ {
+ /* Try again with __WCLONE to check cloned processes. */
+ pid = waitpid (GET_LWP (ptid), &status, __WCLONE);
+ lp->cloned = 1;
+ }
+
+ gdb_assert (pid == GET_LWP (ptid)
+ && WIFSTOPPED (status) && WSTOPSIG (status));
+
+ lp->stopped = 1;
+ }
+ else
+ {
+ /* We assume that the LWP representing the original process
+ is already stopped. Mark it as stopped in the data structure
+ that the lin-lwp 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. */
+ lp->stopped = 1;
}
}
lin_lwp_attach (char *args, int from_tty)
{
struct lwp_info *lp;
+ pid_t pid;
+ int status;
/* FIXME: We should probably accept a list of process id's, and
attach all of them. */
child_ops.to_attach (args, from_tty);
/* Add the initial process as the first LWP to the list. */
- lp = add_lwp (BUILD_LWP (PIDGET (inferior_ptid), PIDGET (inferior_ptid)));
+ lp = add_lwp (BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid)));
/* 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. */
- lp->signalled = 1;
- stop_wait_callback (lp, NULL);
- gdb_assert (lp->status == 0);
+ pid = waitpid (GET_PID (inferior_ptid), &status, 0);
+ if (pid == -1 && errno == ECHILD)
+ {
+ warning ("%s is a cloned process", target_pid_to_str (inferior_ptid));
+
+ /* Try again with __WCLONE to check cloned processes. */
+ pid = waitpid (GET_PID (inferior_ptid), &status, __WCLONE);
+ lp->cloned = 1;
+ }
+
+ gdb_assert (pid == GET_PID (inferior_ptid)
+ && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP);
+
+ lp->stopped = 1;
/* Fake the SIGSTOP that core GDB expects. */
lp->status = W_STOPCODE (SIGSTOP);
gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
}
- if (is_cloned (lp->ptid))
+ /* We don't actually detach from the LWP that has an id equal to the
+ overall process id just yet. */
+ if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
{
if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
WSTOPSIG (lp->status)) < 0)
{
iterate_over_lwps (detach_callback, NULL);
- /* Only the initial (uncloned) process should be left right now. */
+ /* Only the initial process should be left right now. */
gdb_assert (num_lwps == 1);
trap_ptid = null_ptid;
return 0;
}
-/* Wait until LP is stopped. */
+/* Wait until LP is stopped. If DATA is non-null it is interpreted as
+ a pointer to a set of signals to be flushed immediately. */
static int
stop_wait_callback (struct lwp_info *lp, void *data)
{
+ sigset_t *flush_mask = data;
+
if (! lp->stopped && lp->signalled)
{
pid_t pid;
gdb_assert (lp->status == 0);
- pid = waitpid (GET_LWP (lp->ptid), &status,
- is_cloned (lp->ptid) ? __WCLONE : 0);
+ pid = waitpid (GET_LWP (lp->ptid), &status, lp->cloned ? __WCLONE : 0);
if (pid == -1 && errno == ECHILD)
/* OK, the proccess has disappeared. We'll catch the actual
exit event in lin_lwp_wait. */
gdb_assert (WIFSTOPPED (status));
+ /* Ignore any signals in FLUSH_MASK. */
+ if (flush_mask && sigismember (flush_mask, WSTOPSIG (status)))
+ {
+ ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
+ return stop_wait_callback (lp, flush_mask);
+ }
+
if (WSTOPSIG (status) != SIGSTOP)
{
if (WSTOPSIG (status) == SIGTRAP)
lp->status = status;
return 0;
}
- else if (WSTOPSIG (status) == SIGINT &&
- signal_pass_state (SIGINT) == 0)
- {
- /* Since SIGINT gets forwarded to the entire process group
- (in the case where ^C/BREAK is typed at the tty/console),
- just ignore all SIGINT events from all lwp's except for
- the one that was caught by lin_lwp_wait. */
-
- /* Now resume this LWP and get the SIGSTOP event. */
- ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
- return stop_wait_callback (lp, data);
- }
else
{
/* The thread was stopped with a signal other than
return lp->resumed;
}
+#ifdef CHILD_WAIT
+
+/* We need to override child_wait to support attaching to cloned
+ processes, since a normal wait (as done by the default version)
+ ignores those processes. */
+
+/* Wait for child PTID to do something. Return id of the child,
+ minus_one_ptid in case of error; store status into *OURSTATUS. */
+
+ptid_t
+child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+{
+ int save_errno;
+ int status;
+ pid_t pid;
+
+ do
+ {
+ set_sigint_trap (); /* Causes SIGINT to be passed on to the
+ attached process. */
+ set_sigio_trap ();
+
+ pid = waitpid (GET_PID (ptid), &status, 0);
+ if (pid == -1 && errno == ECHILD)
+ /* Try again with __WCLONE to check cloned processes. */
+ pid = waitpid (GET_PID (ptid), &status, __WCLONE);
+ save_errno = errno;
+
+ clear_sigio_trap ();
+ clear_sigint_trap ();
+ }
+ while (pid == -1 && errno == EINTR);
+
+ if (pid == -1)
+ {
+ warning ("Child process unexpectedly missing: %s", strerror (errno));
+
+ /* Claim it exited with unknown signal. */
+ ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+ ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
+ return minus_one_ptid;
+ }
+
+ store_waitstatus (ourstatus, status);
+ return pid_to_ptid (pid);
+}
+
+#endif
+
static ptid_t
lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
int options = 0;
int status = 0;
pid_t pid = PIDGET (ptid);
+ sigset_t flush_mask;
+
+ sigemptyset (&flush_mask);
/* Make sure SIGCHLD is blocked. */
if (! sigismember (&blocked_mask, SIGCHLD))
retry:
- /* Make sure there is at least one thread that has been resumed. */
- gdb_assert (iterate_over_lwps (resumed_callback, NULL));
+ /* Make sure there is at least one LWP that has been resumed, at
+ least if there are any LWPs at all. */
+ gdb_assert (num_lwps == 0 || iterate_over_lwps (resumed_callback, NULL));
/* First check if there is a LWP with a wait status pending. */
if (pid == -1)
lp->status = 0;
if (debug_lin_lwp && status)
- fprintf_unfiltered (gdb_stdlog,
- "Using pending wait status %d for LWP %ld.\n",
- WIFSTOPPED (status) ? WSTOPSIG (status) :
- WIFSIGNALED (status) ? WTERMSIG (status) :
- WEXITSTATUS (status), GET_LWP (lp->ptid));
+ fprintf_unfiltered (gdb_stdlog,
+ "Using pending wait status %s for LWP %ld.\n",
+ status_to_str (status), GET_LWP (lp->ptid));
}
/* But if we don't fine one, we'll have to wait, and check both
lp->status = 0;
if (debug_lin_lwp && status)
- fprintf_unfiltered (gdb_stdlog,
- "Using pending wait status %d for LWP %ld.\n",
- WIFSTOPPED (status) ? WSTOPSIG (status) :
- WIFSIGNALED (status) ? WTERMSIG (status) :
- WEXITSTATUS (status), GET_LWP (lp->ptid));
+ fprintf_unfiltered (gdb_stdlog,
+ "Using pending wait status %s for LWP %ld.\n",
+ status_to_str (status), GET_LWP (lp->ptid));
/* If we have to wait, take into account whether PID is a cloned
process or not. And we have to convert it to something that
the layer beneath us can understand. */
- options = is_cloned (lp->ptid) ? __WCLONE : 0;
+ options = lp->cloned ? __WCLONE : 0;
pid = GET_LWP (ptid);
}
if (! lp)
{
lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
+ if (options & __WCLONE)
+ lp->cloned = 1;
+
if (threaded)
{
gdb_assert (WIFSTOPPED (status)
status = 0;
goto retry;
}
+
+ if (signo == TARGET_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 LWP's
+ will receive it. Since we only want to report it once,
+ we try to flush it from all LWPs except this one. */
+ sigaddset (&flush_mask, SIGINT);
+ }
}
/* This LWP is stopped now. */
lp->stopped = 1;
if (debug_lin_lwp)
- fprintf_unfiltered (gdb_stdlog,
- "LLW: Candidate event %d in %ld\n",
- WSTOPSIG (status), GET_LWP (lp->ptid));
+ fprintf_unfiltered (gdb_stdlog, "Candidate event %s in LWP %ld.\n",
+ status_to_str (status), GET_LWP (lp->ptid));
/* Now stop all other LWP's ... */
iterate_over_lwps (stop_callback, NULL);
/* ... and wait until all of them have reported back that they're no
longer running. */
- iterate_over_lwps (stop_wait_callback, NULL);
+ iterate_over_lwps (stop_wait_callback, &flush_mask);
/* 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
/* 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 (is_cloned (lp->ptid))
+ if (lp->cloned)
{
do
{
projects / deliverable / binutils-gdb.git / blobdiff