{
/* The process id of the LWP. This is a combination of the LWP id
and overall process id. */
- int pid;
+ ptid_t ptid;
/* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
it back yet). */
/* Non-zero if this LWP is stopped. */
int stopped;
+ /* Non-zero if this LWP will be/has been resumed. Note that an LWP
+ can be marked both as stopped and resumed at the same time. This
+ happens if we try to resume an LWP that has a wait status
+ pending. We shouldn't let the LWP run until that wait status has
+ been processed, but we should not report that wait status if GDB
+ didn't try to let the LWP run. */
+ int resumed;
+
/* If non-zero, a pending wait status. */
int status;
static int threaded;
\f
-#ifndef TIDGET
-#define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
-#define PIDGET(PID) (((PID) & 0xffff))
-#define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
-#endif
-
-#define THREAD_FLAG 0x80000000
-#define is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
-#define GET_LWP(pid) TIDGET (pid)
-#define GET_PID(pid) PIDGET (pid)
-#define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
+#define GET_LWP(ptid) ptid_get_lwp (ptid)
+#define GET_PID(ptid) ptid_get_pid (ptid)
+#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. */
-int trap_pid;
+ptid_t trap_ptid;
\f
/* This module's target-specific operations. */
\f
/* Prototypes for local functions. */
-static void lin_lwp_mourn_inferior (void);
+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));
-/* Initialize the list of LWPs. */
+ 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
+ doesn't involve mourning) the inferior. */
static void
init_lwp_list (void)
Return a pointer to the structure describing the new LWP. */
static struct lwp_info *
-add_lwp (int pid)
+add_lwp (ptid_t ptid)
{
struct lwp_info *lp;
- gdb_assert (is_lwp (pid));
+ gdb_assert (is_lwp (ptid));
lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
memset (lp, 0, sizeof (struct lwp_info));
- lp->pid = pid;
+ lp->ptid = ptid;
lp->next = lwp_list;
lwp_list = lp;
/* Remove the LWP specified by PID from the list. */
static void
-delete_lwp (int pid)
+delete_lwp (ptid_t ptid)
{
struct lwp_info *lp, *lpprev;
lpprev = NULL;
for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
- if (lp->pid == pid)
+ if (ptid_equal (lp->ptid, ptid))
break;
if (!lp)
to PID. If no corresponding LWP could be found, return NULL. */
static struct lwp_info *
-find_lwp_pid (int pid)
+find_lwp_pid (ptid_t ptid)
{
struct lwp_info *lp;
+ int lwp;
- if (is_lwp (pid))
- pid = GET_LWP (pid);
+ if (is_lwp (ptid))
+ lwp = GET_LWP (ptid);
+ else
+ lwp = GET_PID (ptid);
for (lp = lwp_list; lp; lp = lp->next)
- if (pid == GET_LWP (lp->pid))
+ if (lwp == GET_LWP (lp->ptid))
return lp;
return NULL;
struct lwp_info *
iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
{
- struct lwp_info *lp;
+ struct lwp_info *lp, *lpnext;
- for (lp = lwp_list; lp; lp = lp->next)
- if ((*callback) (lp, data))
- return lp;
+ for (lp = lwp_list; lp; lp = lpnext)
+ {
+ lpnext = lp->next;
+ if ((*callback) (lp, data))
+ return lp;
+ }
return NULL;
}
\f
-/* Helper functions. */
-
-static void
-restore_inferior_pid (void *arg)
-{
- int *saved_pid_ptr = arg;
- inferior_pid = *saved_pid_ptr;
- xfree (arg);
-}
-
-static struct cleanup *
-save_inferior_pid (void)
-{
- int *saved_pid_ptr;
-
- saved_pid_ptr = xmalloc (sizeof (int));
- *saved_pid_ptr = inferior_pid;
- return make_cleanup (restore_inferior_pid, saved_pid_ptr);
-}
-\f
-
/* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP
layer.
Note that this implementation is potentially redundant now that
- default_prepare_to_proceed() has been added. */
+ default_prepare_to_proceed() has been added.
+
+ FIXME This may not support switching threads after Ctrl-C
+ correctly. The default implementation does support this. */
int
lin_lwp_prepare_to_proceed (void)
{
- if (trap_pid && inferior_pid != trap_pid)
+ if (! ptid_equal (trap_ptid, null_ptid)
+ && ! ptid_equal (inferior_ptid, trap_ptid))
{
/* Switched over from TRAP_PID. */
CORE_ADDR stop_pc = read_pc ();
/* Avoid switching where it wouldn't do any good, i.e. if both
threads are at the same breakpoint. */
- trap_pc = read_pc_pid (trap_pid);
+ trap_pc = read_pc_pid (trap_ptid);
if (trap_pc != stop_pc && breakpoint_here_p (trap_pc))
{
/* User hasn't deleted the breakpoint. Return non-zero, and
switch back to TRAP_PID. */
- inferior_pid = trap_pid;
+ inferior_ptid = trap_ptid;
/* FIXME: Is this stuff really necessary? */
flush_cached_frames ();
process. */
void
-lin_lwp_attach_lwp (int pid, int verbose)
+lin_lwp_attach_lwp (ptid_t ptid, int verbose)
{
struct lwp_info *lp;
- gdb_assert (is_lwp (pid));
+ gdb_assert (is_lwp (ptid));
if (verbose)
- printf_filtered ("[New %s]\n", target_pid_to_str (pid));
+ printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
- if (ptrace (PTRACE_ATTACH, GET_LWP (pid), 0, 0) < 0)
- error ("Can't attach %s: %s", target_pid_to_str (pid), strerror (errno));
+ /* 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 = add_lwp (pid);
- lp->signalled = 1;
+ lp = find_lwp_pid (ptid);
+ if (lp == NULL)
+ lp = add_lwp (ptid);
+
+ if (is_cloned (ptid))
+ {
+ lp->signalled = 1;
+ stop_wait_callback (lp, NULL);
+ }
}
static void
lin_lwp_attach (char *args, int from_tty)
{
+ struct lwp_info *lp;
+
/* FIXME: We should probably accept a list of process id's, and
attach all of them. */
- error("Not implemented yet");
+ 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)));
+
+ /* 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);
+
+ /* Fake the SIGSTOP that core GDB expects. */
+ lp->status = W_STOPCODE (SIGSTOP);
+ lp->resumed = 1;
+}
+
+static int
+detach_callback (struct lwp_info *lp, void *data)
+{
+ gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
+
+ if (debug_lin_lwp && lp->status)
+ fprintf_unfiltered (gdb_stdlog, "Pending %s for LWP %ld on detach.\n",
+ strsignal (WSTOPSIG (lp->status)), GET_LWP (lp->ptid));
+
+ while (lp->signalled && lp->stopped)
+ {
+ if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0,
+ WSTOPSIG (lp->status)) < 0)
+ error ("Can't continue %s: %s", target_pid_to_str (lp->ptid),
+ strerror (errno));
+
+ lp->stopped = 0;
+ lp->signalled = 0;
+ lp->status = 0;
+ stop_wait_callback (lp, NULL);
+
+ gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
+ }
+
+ if (is_cloned (lp->ptid))
+ {
+ if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
+ WSTOPSIG (lp->status)) < 0)
+ error ("Can't detach %s: %s", target_pid_to_str (lp->ptid),
+ strerror (errno));
+
+ delete_lwp (lp->ptid);
+ }
+
+ return 0;
}
static void
lin_lwp_detach (char *args, int from_tty)
{
- /* FIXME: Provide implementation when we implement lin_lwp_attach. */
- error ("Not implemented yet");
+ iterate_over_lwps (detach_callback, NULL);
+
+ /* Only the initial (uncloned) process should be left right now. */
+ gdb_assert (num_lwps == 1);
+
+ trap_ptid = null_ptid;
+
+ /* Destroy LWP info; it's no longer valid. */
+ init_lwp_list ();
+
+ /* Restore the original signal mask. */
+ sigprocmask (SIG_SETMASK, &normal_mask, NULL);
+ sigemptyset (&blocked_mask);
+
+ inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
+ child_ops.to_detach (args, from_tty);
}
\f
{
struct lwp_info *lp = data;
- if (tp->private->lwpid == GET_LWP (lp->pid))
+ if (tp->private->lwpid == GET_LWP (lp->ptid))
return 1;
return 0;
{
struct thread_info *tp;
-#if 1
+#if 0
/* FIXME: kettenis/2000-08-26: This should really be handled
properly by core GDB. */
- tp = find_thread_pid (lp->pid);
+ tp = find_thread_pid (lp->ptid);
if (tp == NULL)
tp = iterate_over_threads (find_lwp_callback, lp);
gdb_assert (tp);
}
#endif
- child_resume (GET_LWP (lp->pid), 0, TARGET_SIGNAL_0);
+ child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0);
lp->stopped = 0;
lp->step = 0;
}
return 0;
}
+static int
+resume_clear_callback (struct lwp_info *lp, void *data)
+{
+ lp->resumed = 0;
+ return 0;
+}
+
+static int
+resume_set_callback (struct lwp_info *lp, void *data)
+{
+ lp->resumed = 1;
+ return 0;
+}
+
static void
-lin_lwp_resume (int pid, int step, enum target_signal signo)
+lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo)
{
struct lwp_info *lp;
int resume_all;
STEP is non-zero, a specific PID means `step only this process
id'. But if STEP is zero, then PID means `continue *all*
processes, but give the signal only to this one'. */
- resume_all = (pid == -1) || !step;
+ resume_all = (PIDGET (ptid) == -1) || !step;
+
+ if (resume_all)
+ iterate_over_lwps (resume_set_callback, NULL);
+ else
+ iterate_over_lwps (resume_clear_callback, NULL);
/* If PID is -1, it's the current inferior that should be
- handled special. */
- if (pid == -1)
- pid = inferior_pid;
+ handled specially. */
+ if (PIDGET (ptid) == -1)
+ ptid = inferior_ptid;
- lp = find_lwp_pid (pid);
+ lp = find_lwp_pid (ptid);
if (lp)
{
- pid = GET_LWP (lp->pid);
+ ptid = pid_to_ptid (GET_LWP (lp->ptid));
/* Remember if we're stepping. */
lp->step = step;
+ /* Mark this LWP as resumed. */
+ lp->resumed = 1;
+
/* If we have a pending wait status for this thread, there is no
point in resuming the process. */
if (lp->status)
if (resume_all)
iterate_over_lwps (resume_callback, NULL);
- child_resume (pid, step, signo);
+ child_resume (ptid, step, signo);
}
\f
{
int ret;
- ret = kill (GET_LWP (lp->pid), SIGSTOP);
+ ret = kill (GET_LWP (lp->ptid), SIGSTOP);
gdb_assert (ret == 0);
lp->signalled = 1;
gdb_assert (lp->status == 0);
- pid = waitpid (GET_LWP (lp->pid), &status,
- is_cloned (lp->pid) ? __WCLONE : 0);
+ pid = waitpid (GET_LWP (lp->ptid), &status,
+ is_cloned (lp->ptid) ? __WCLONE : 0);
if (pid == -1 && errno == ECHILD)
/* OK, the proccess has disappeared. We'll catch the actual
exit event in lin_lwp_wait. */
return 0;
- gdb_assert (pid == GET_LWP (lp->pid));
+ gdb_assert (pid == GET_LWP (lp->ptid));
if (WIFEXITED (status) || WIFSIGNALED (status))
{
gdb_assert (num_lwps > 1);
- if (in_thread_list (lp->pid))
+ if (in_thread_list (lp->ptid))
{
/* Core GDB cannot deal with us deleting the current
thread. */
- if (lp->pid != inferior_pid)
- delete_thread (lp->pid);
+ if (!ptid_equal (lp->ptid, inferior_ptid))
+ delete_thread (lp->ptid);
printf_unfiltered ("[%s exited]\n",
- target_pid_to_str (lp->pid));
+ target_pid_to_str (lp->ptid));
}
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
- "%s exited.\n", target_pid_to_str (lp->pid));
+ "%s exited.\n", target_pid_to_str (lp->ptid));
- delete_lwp (lp->pid);
+ delete_lwp (lp->ptid);
return 0;
}
gdb_assert (WIFSTOPPED (status));
- lp->stopped = 1;
if (WSTOPSIG (status) != SIGSTOP)
{
- if (WSTOPSIG (status) == SIGTRAP
- && breakpoint_inserted_here_p (read_pc_pid (pid)
- - DECR_PC_AFTER_BREAK))
+ if (WSTOPSIG (status) == SIGTRAP)
{
/* If a LWP other than the LWP that we're reporting an
event for has hit a GDB breakpoint (as opposed to
user will delete or disable the breakpoint, but the
thread will have already tripped on it. */
+ /* Now resume this LWP and get the SIGSTOP event. */
+ ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
if (debug_lin_lwp)
- fprintf_unfiltered (gdb_stdlog,
- "Tripped breakpoint at %lx in LWP %d"
- " while waiting for SIGSTOP.\n",
- (long) read_pc_pid (lp->pid), pid);
-
- /* Set the PC to before the trap. */
- if (DECR_PC_AFTER_BREAK)
- write_pc_pid (read_pc_pid (pid) - DECR_PC_AFTER_BREAK, pid);
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "SWC: Candidate SIGTRAP event in %ld\n",
+ GET_LWP (lp->ptid));
+ }
+ /* Hold the SIGTRAP for handling by lin_lwp_wait. */
+ stop_wait_callback (lp, data);
+ /* If there's another event, throw it back into the queue. */
+ if (lp->status)
+ kill (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
+ /* Save the sigtrap event. */
+ 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
{
- if (debug_lin_lwp)
- fprintf_unfiltered (gdb_stdlog,
- "Received %s in LWP %d while waiting for SIGSTOP.\n",
- strsignal (WSTOPSIG (status)), pid);
-
/* The thread was stopped with a signal other than
- SIGSTOP, and didn't accidentiliy trip a breakpoint.
- Record the wait status. */
- lp->status = status;
+ SIGSTOP, and didn't accidentally trip a breakpoint. */
+
+ if (debug_lin_lwp)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "SWC: Pending event %d in %ld\n",
+ WSTOPSIG (status), GET_LWP (lp->ptid));
+ }
+ /* Now resume this LWP and get the SIGSTOP event. */
+ ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
+
+ /* Hold this event/waitstatus while we check to see if
+ there are any more (we still want to get that SIGSTOP). */
+ stop_wait_callback (lp, data);
+ /* If the lp->status field is still empty, use it to hold
+ this event. If not, then this event must be returned
+ to the event queue of the LWP. */
+ if (lp->status == 0)
+ lp->status = status;
+ else
+ kill (GET_LWP (lp->ptid), WSTOPSIG (status));
+ return 0;
}
}
else
{
/* We caught the SIGSTOP that we intended to catch, so
there's no SIGSTOP pending. */
+ lp->stopped = 1;
lp->signalled = 0;
}
}
static int
status_callback (struct lwp_info *lp, void *data)
{
- return (lp->status != 0);
+ /* Only report a pending wait status if we pretend that this has
+ indeed been resumed. */
+ return (lp->status != 0 && lp->resumed);
}
/* Return non-zero if LP isn't stopped. */
return (lp->stopped == 0);
}
+/* Count the LWP's that have had events. */
+
+static int
+count_events_callback (struct lwp_info *lp, void *data)
+{
+ int *count = data;
+
+ gdb_assert (count != NULL);
+
+ /* Count only LWPs that have a SIGTRAP event pending. */
+ if (lp->status != 0
+ && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
+ (*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)
+{
+ if (lp->step && lp->status != 0)
+ return 1;
+ else
+ return 0;
+}
+
+/* Select the Nth LWP that has had a SIGTRAP event. */
+
+static int
+select_event_lwp_callback (struct lwp_info *lp, void *data)
+{
+ int *selector = data;
+
+ gdb_assert (selector != NULL);
+
+ /* Select only LWPs that have a SIGTRAP event pending. */
+ if (lp->status != 0
+ && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
+ if ((*selector)-- == 0)
+ return 1;
+
+ return 0;
+}
+
static int
-lin_lwp_wait (int pid, struct target_waitstatus *ourstatus)
+cancel_breakpoints_callback (struct lwp_info *lp, void *data)
+{
+ struct lwp_info *event_lp = data;
+
+ /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
+ if (lp == event_lp)
+ return 0;
+
+ /* 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.
+
+ 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. */
+
+ if (lp->status != 0
+ && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
+ && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
+ DECR_PC_AFTER_BREAK))
+ {
+ if (debug_lin_lwp)
+ fprintf_unfiltered (gdb_stdlog,
+ "Push back breakpoint for LWP %ld\n",
+ GET_LWP (lp->ptid));
+
+ /* Back up the PC if necessary. */
+ if (DECR_PC_AFTER_BREAK)
+ write_pc_pid (read_pc_pid (lp->ptid) - DECR_PC_AFTER_BREAK, lp->ptid);
+
+ /* Throw away the SIGTRAP. */
+ lp->status = 0;
+ }
+
+ return 0;
+}
+
+/* Select one LWP out of those that have events pending. */
+
+static void
+select_event_lwp (struct lwp_info **orig_lp, int *status)
+{
+ int num_events = 0;
+ int random_selector;
+ struct lwp_info *event_lp;
+
+ /* Record the wait status for the origional LWP. */
+ (*orig_lp)->status = *status;
+
+ /* Give preference to any LWP that is being single-stepped. */
+ event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL);
+ if (event_lp != NULL)
+ {
+ if (debug_lin_lwp)
+ fprintf_unfiltered (gdb_stdlog,
+ "Select single-step LWP %ld\n",
+ GET_LWP (event_lp->ptid));
+ }
+ 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 (count_events_callback, &num_events);
+
+ /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
+ random_selector = (int)
+ ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
+
+ if (debug_lin_lwp && num_events > 1)
+ fprintf_unfiltered (gdb_stdlog,
+ "Found %d SIGTRAP events, selecting #%d\n",
+ num_events, random_selector);
+
+ event_lp = iterate_over_lwps (select_event_lwp_callback,
+ &random_selector);
+ }
+
+ if (event_lp != NULL)
+ {
+ /* Switch the event LWP. */
+ *orig_lp = event_lp;
+ *status = event_lp->status;
+ }
+
+ /* 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;
+}
+
+static ptid_t
+lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
struct lwp_info *lp = NULL;
int options = 0;
int status = 0;
+ pid_t pid = PIDGET (ptid);
/* 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));
+
/* First check if there is a LWP with a wait status pending. */
if (pid == -1)
{
- /* Any LWP will do. */
+ /* Any LWP that's been resumed will do. */
lp = iterate_over_lwps (status_callback, NULL);
if (lp)
{
- if (debug_lin_lwp)
- fprintf_unfiltered (gdb_stdlog,
- "Using pending wait status for LWP %d.\n",
- GET_LWP (lp->pid));
-
status = lp->status;
lp->status = 0;
+
+ if (debug_lin_lwp && status)
+ 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
processes. */
options = __WCLONE | WNOHANG;
}
- else if (is_lwp (pid))
+ else if (is_lwp (ptid))
{
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
- "Waiting for specific LWP %d.\n", GET_LWP (pid));
+ "Waiting for specific LWP %ld.\n",
+ GET_LWP (ptid));
/* We have a specific LWP to check. */
- lp = find_lwp_pid (GET_LWP (pid));
+ lp = find_lwp_pid (ptid);
gdb_assert (lp);
status = lp->status;
lp->status = 0;
- if (debug_lin_lwp)
- if (status)
- fprintf_unfiltered (gdb_stdlog,
- "Using pending wait status for LWP %d.\n",
- GET_LWP (lp->pid));
+ if (debug_lin_lwp && status)
+ 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->pid) ? __WCLONE : 0;
- pid = GET_LWP (pid);
+ options = is_cloned (lp->ptid) ? __WCLONE : 0;
+ pid = GET_LWP (ptid);
}
if (status && lp->signalled)
/* Resume the thread. It should halt immediately returning the
pending SIGSTOP. */
- child_resume (GET_LWP (lp->pid), lp->step, TARGET_SIGNAL_0);
+ child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
+ TARGET_SIGNAL_0);
lp->stopped = 0;
+ gdb_assert (lp->resumed);
/* This should catch the pending SIGSTOP. */
stop_wait_callback (lp, NULL);
{
gdb_assert (pid == -1 || lwpid == pid);
- lp = find_lwp_pid (lwpid);
+ lp = find_lwp_pid (pid_to_ptid (lwpid));
if (! lp)
{
- lp = add_lwp (BUILD_LWP (lwpid, inferior_pid));
+ lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
if (threaded)
{
gdb_assert (WIFSTOPPED (status)
&& WSTOPSIG (status) == SIGSTOP);
lp->signalled = 1;
- if (! in_thread_list (inferior_pid))
+ if (! in_thread_list (inferior_ptid))
{
- inferior_pid = BUILD_LWP (inferior_pid, inferior_pid);
- add_thread (inferior_pid);
+ inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
+ GET_PID (inferior_ptid));
+ add_thread (inferior_ptid);
}
- add_thread (lp->pid);
+ add_thread (lp->ptid);
printf_unfiltered ("[New %s]\n",
- target_pid_to_str (lp->pid));
+ target_pid_to_str (lp->ptid));
}
}
left in the process. */
if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
{
- if (in_thread_list (lp->pid))
+ if (in_thread_list (lp->ptid))
{
/* Core GDB cannot deal with us deleting the current
thread. */
- if (lp->pid != inferior_pid)
- delete_thread (lp->pid);
+ if (! ptid_equal (lp->ptid, inferior_ptid))
+ delete_thread (lp->ptid);
printf_unfiltered ("[%s exited]\n",
- target_pid_to_str (lp->pid));
+ target_pid_to_str (lp->ptid));
}
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"%s exited.\n",
- target_pid_to_str (lp->pid));
+ target_pid_to_str (lp->ptid));
- delete_lwp (lp->pid);
+ delete_lwp (lp->ptid);
/* Make sure there is at least one thread running. */
gdb_assert (iterate_over_lwps (running_callback, NULL));
if (debug_lin_lwp)
fprintf_unfiltered (gdb_stdlog,
"Delayed SIGSTOP caught for %s.\n",
- target_pid_to_str (lp->pid));
+ target_pid_to_str (lp->ptid));
/* This is a delayed SIGSTOP. */
lp->signalled = 0;
- child_resume (GET_LWP (lp->pid), lp->step, TARGET_SIGNAL_0);
+ child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
+ TARGET_SIGNAL_0);
lp->stopped = 0;
+ gdb_assert (lp->resumed);
/* Discard the event. */
status = 0;
&& signal_print_state (signo) == 0
&& signal_pass_state (signo) == 1)
{
- child_resume (GET_LWP (lp->pid), lp->step, signo);
+ /* 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. */
+ child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, signo);
lp->stopped = 0;
status = 0;
goto retry;
/* This LWP is stopped now. */
lp->stopped = 1;
+ if (debug_lin_lwp)
+ 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);
longer running. */
iterate_over_lwps (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 (pid == -1)
+ select_event_lwp (&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 (cancel_breakpoints_callback, lp);
+
/* If we're not running in "threaded" mode, we'll report the bare
process id. */
if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
- trap_pid = (threaded ? lp->pid : GET_LWP (lp->pid));
+ {
+ trap_ptid = (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
+ if (debug_lin_lwp)
+ fprintf_unfiltered (gdb_stdlog,
+ "LLW: trap_ptid is %ld\n",
+ GET_LWP (trap_ptid));
+ }
else
- trap_pid = 0;
+ trap_ptid = null_ptid;
store_waitstatus (ourstatus, status);
- return (threaded ? lp->pid : GET_LWP (lp->pid));
+ return (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
}
static int
kill_callback (struct lwp_info *lp, void *data)
{
- ptrace (PTRACE_KILL, GET_LWP (lp->pid), 0, 0);
+ ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
return 0;
}
/* 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->pid))
+ if (is_cloned (lp->ptid))
{
do
{
- pid = waitpid (GET_LWP (lp->pid), NULL, __WCLONE);
+ pid = waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
}
- while (pid == GET_LWP (lp->pid));
+ while (pid == GET_LWP (lp->ptid));
gdb_assert (pid == -1 && errno == ECHILD);
}
do
{
- pid = waitpid (GET_LWP (lp->pid), NULL, 0);
+ pid = waitpid (GET_LWP (lp->ptid), NULL, 0);
}
- while (pid == GET_LWP (lp->pid));
+ while (pid == GET_LWP (lp->ptid));
gdb_assert (pid == -1 && errno == ECHILD);
return 0;
static void
lin_lwp_create_inferior (char *exec_file, char *allargs, char **env)
{
- struct target_ops *target_beneath;
-
- init_lwp_list ();
-
-#if 0
- target_beneath = find_target_beneath (&lin_lwp_ops);
-#else
- target_beneath = &child_ops;
-#endif
- target_beneath->to_create_inferior (exec_file, allargs, env);
+ child_ops.to_create_inferior (exec_file, allargs, env);
}
static void
lin_lwp_mourn_inferior (void)
{
- struct target_ops *target_beneath;
+ trap_ptid = null_ptid;
+ /* Destroy LWP info; it's no longer valid. */
init_lwp_list ();
- trap_pid = 0;
-
/* Restore the original signal mask. */
sigprocmask (SIG_SETMASK, &normal_mask, NULL);
sigemptyset (&blocked_mask);
-#if 0
- target_beneath = find_target_beneath (&lin_lwp_ops);
-#else
- target_beneath = &child_ops;
-#endif
- target_beneath->to_mourn_inferior ();
+ child_ops.to_mourn_inferior ();
}
static void
lin_lwp_fetch_registers (int regno)
{
- struct cleanup *old_chain = save_inferior_pid ();
+ struct cleanup *old_chain = save_inferior_ptid ();
- if (is_lwp (inferior_pid))
- inferior_pid = GET_LWP (inferior_pid);
+ if (is_lwp (inferior_ptid))
+ inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
fetch_inferior_registers (regno);
static void
lin_lwp_store_registers (int regno)
{
- struct cleanup *old_chain = save_inferior_pid ();
+ struct cleanup *old_chain = save_inferior_ptid ();
- if (is_lwp (inferior_pid))
- inferior_pid = GET_LWP (inferior_pid);
+ if (is_lwp (inferior_ptid))
+ inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
store_inferior_registers (regno);
struct mem_attrib *attrib,
struct target_ops *target)
{
- struct cleanup *old_chain = save_inferior_pid ();
+ struct cleanup *old_chain = save_inferior_ptid ();
int xfer;
- if (is_lwp (inferior_pid))
- inferior_pid = GET_LWP (inferior_pid);
+ if (is_lwp (inferior_ptid))
+ inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
xfer = child_xfer_memory (memaddr, myaddr, len, write, attrib, target);
}
static int
-lin_lwp_thread_alive (int pid)
+lin_lwp_thread_alive (ptid_t ptid)
{
- gdb_assert (is_lwp (pid));
+ gdb_assert (is_lwp (ptid));
errno = 0;
- ptrace (PTRACE_PEEKUSER, GET_LWP (pid), 0, 0);
+ ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0);
if (errno)
return 0;
}
static char *
-lin_lwp_pid_to_str (int pid)
+lin_lwp_pid_to_str (ptid_t ptid)
{
static char buf[64];
- if (is_lwp (pid))
+ if (is_lwp (ptid))
{
- snprintf (buf, sizeof (buf), "LWP %d", GET_LWP (pid));
+ snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
return buf;
}
- return normal_pid_to_str (pid);
+ return normal_pid_to_str (ptid);
}
static void